lael-labs/executor

apps/host-selfhost/src/apps-backings.ts+1−10

 import { join } from "node:path";
-import { Effect } from "effect";
 import {
   makeGitArtifactStore,
-  makeLibsqlScopeDb,
   makeQuickjsToolSandbox,
   makeSqliteAppsStore,
   type AppsBackings,
 const createBackings = (dataDir: string): SelfHostAppsBackings => {
   const appsDir = join(dataDir, "apps");
-  const scopeDb = makeLibsqlScopeDb({
-    root: join(appsDir, "scope-db"),
-  });
   return {
     backings: {
       artifactStore: makeGitArtifactStore({ root: join(appsDir, "artifacts") }),
-      scopeDb,
       sandbox: makeQuickjsToolSandbox(),
       store: makeSqliteAppsStore({ path: join(appsDir, "store.sqlite") }),
     },
-    close: async () => {
+    close: async () => {},
-      await Effect.runPromise(scopeDb.close().pipe(Effect.orElseSucceed(() => undefined)));
-    },
   };
 };

packages/plugins/apps/src/api.ts+1−1

 export { type AppsRuntime, type GitHubCustomToolsSourceSummary } from "./plugin/runtime";
 export { makeAppsRuntimeFromBackings, type AppsBackings } from "./plugin/backings";
 export { makeGitArtifactStore } from "./backing/git-artifact-store";
-export { makeLibsqlScopeDb } from "./backing/libsql-scope-db";
 export { makeQuickjsToolSandbox } from "./backing/quickjs-tool-sandbox";
 export { makeSqliteAppsStore } from "./backing/sqlite-apps-store";
 export {
   type RoleBindings,
 } from "./plugin/bindings";
 export { makePluginCtxAppsResolver } from "./plugin/resolver";
+export { SourceOriginError, assertSourceOrigin } from "./plugin/apps-plugin";
 export {
   fetchGitHubSource,
   parseGitHubSourceUrl,

packages/plugins/apps/src/authoring.ts+0−3

-import type { ScopeDbHandle } from "./seams/scope-db";
 import type { StandardSchemaV1 } from "./standard-schema";
 export type JsonPrimitive = string | number | boolean | null;
 export type ToolHandlerContext<
   TIntegrations extends Readonly<Record<string, IntegrationDeclaration>> | undefined,
 > = {
-  readonly db: ScopeDbHandle;
-} & {
   readonly [K in keyof NonNullable<TIntegrations>]: unknown;
 };

packages/plugins/apps/src/backing/libsql-scope-db.test.ts+0−4

@@ -1,4 +0,0 @@
1	import { scopeDbConformance } from "../seams/scope-db.conformance";
2	import { makeLibsqlScopeDb } from "./libsql-scope-db";
3
4	scopeDbConformance("libsql (in-memory)", () => makeLibsqlScopeDb({ root: ":memory:" }));

packages/plugins/apps/src/backing/libsql-scope-db.ts+0−187

@@ -1,187 +0,0 @@
1	import { mkdirSync, rmSync } from "node:fs";
2	import { join, resolve } from "node:path";
3
4	import { createClient, type Client } from "@libsql/client";
5	import { Effect } from "effect";
6
7	import { ScopeDbError, type ScopeDb, type ScopeDbHandle } from "../seams/scope-db";
8	import { scopeAddressStorageKey, type ScopeAddress } from "../seams/scope-address";
9
10	// ---------------------------------------------------------------------------
11	// libSQL-backed ScopeDb (self-hosted). One SQLite file per tenant/scope under
12	// `<root>`. A control table `__versions` holds a monotonic counter per user
13	// table; every write statement bumps the counters for the tables it touched.
14	// Scope isolation is a separate file per tenant/scope, there is no cross-scope
15	// query path.
16	// ---------------------------------------------------------------------------
17
18	const VERSION_TABLE = "__scope_versions";
19
20	// Statements that mutate data. Determines whether a `sql` call bumps versions.
21	const WRITE_RE = /^\s*(insert\|update\|delete\|replace\|create\|drop\|alter)\b/i;
22
23	// Extract the table names a write statement targets (best-effort: covers the
24	// shapes authored tools produce — INSERT INTO x, UPDATE x, DELETE FROM x,
25	// CREATE TABLE x, REPLACE INTO x).
26	const targetsOf = (sql: string): string[] => {
27	const out = new Set<string>();
28	const patterns = [
29	/\binsert\s+(?:or\s+\w+\s+)?into\s+["'`]?([a-zA-Z_][a-zA-Z0-9_]*)["'`]?/gi,
30	/\breplace\s+into\s+["'`]?([a-zA-Z_][a-zA-Z0-9_]*)["'`]?/gi,
31	/\bupdate\s+["'`]?([a-zA-Z_][a-zA-Z0-9_]*)["'`]?/gi,
32	/\bdelete\s+from\s+["'`]?([a-zA-Z_][a-zA-Z0-9_]*)["'`]?/gi,
33	/\bcreate\s+table\s+(?:if\s+not\s+exists\s+)?["'`]?([a-zA-Z_][a-zA-Z0-9_]*)["'`]?/gi,
34	/\bdrop\s+table\s+(?:if\s+exists\s+)?["'`]?([a-zA-Z_][a-zA-Z0-9_]*)["'`]?/gi,
35	/\balter\s+table\s+["'`]?([a-zA-Z_][a-zA-Z0-9_]*)["'`]?/gi,
36	];
37	for (const re of patterns) {
38	let m: RegExpExecArray \| null;
39	while ((m = re.exec(sql)) !== null) {
40	const name = m[1];
41	if (name && name !== VERSION_TABLE) out.add(name);
42	}
43	}
44	return [...out];
45	};
46
47	const toArgs = (values: readonly unknown[]): unknown[] =>
48	values.map((v) => (v === undefined ? null : v));
49
50	const makeHandle = (address: ScopeAddress, client: Client): ScopeDbHandle => {
51	const label = `${address.tenant}/${address.scope}`;
52	const ensureVersionTable = async () => {
53	await client.execute(
54	`CREATE TABLE IF NOT EXISTS ${VERSION_TABLE} (name TEXT PRIMARY KEY, version INTEGER NOT NULL DEFAULT 0)`,
55	);
56	};
57
58	const bump = async (tables: readonly string[]): Promise<{ table: string; version: number }[]> => {
59	const bumped: { table: string; version: number }[] = [];
60	for (const table of tables) {
61	await client.execute({
62	sql: `INSERT INTO ${VERSION_TABLE} (name, version) VALUES (?, 1)
63	ON CONFLICT(name) DO UPDATE SET version = version + 1`,
64	args: [table],
65	});
66	const row = await client.execute({
67	sql: `SELECT version FROM ${VERSION_TABLE} WHERE name = ?`,
68	args: [table],
69	});
70	bumped.push({ table, version: Number(row.rows[0]?.version ?? 0) });
71	}
72	return bumped;
73	};
74
75	const runStatement = <Row>(
76	sql: string,
77	args: unknown[],
78	): Effect.Effect<readonly Row[], ScopeDbError> =>
79	Effect.tryPromise({
80	try: async () => {
81	await ensureVersionTable();
82	const result = await client.execute({ sql, args: args as never });
83	if (WRITE_RE.test(sql)) {
84	const targets = targetsOf(sql);
85	if (targets.length > 0) {
86	await bump(targets);
87	}
88	}
89	return result.rows.map((row) => row as Row);
90	},
91	catch: (cause) =>
92	new ScopeDbError({ message: `scope-db statement failed for scope ${label}`, cause }),
93	});
94
95	return {
96	sql: <Row = Record<string, unknown>>(strings: TemplateStringsArray, ...values: unknown[]) => {
97	const sql = strings.reduce((acc, part, i) => acc + part + (i < values.length ? "?" : ""), "");
98	return runStatement<Row>(sql, toArgs(values));
99	},
100	exec: <Row = Record<string, unknown>>(sql: string, params: readonly unknown[] = []) =>
101	runStatement<Row>(sql, toArgs(params)),
102	tableVersion: (table: string) =>
103	Effect.tryPromise({
104	try: async () => {
105	await ensureVersionTable();
106	const row = await client.execute({
107	sql: `SELECT version FROM ${VERSION_TABLE} WHERE name = ?`,
108	args: [table],
109	});
110	return Number(row.rows[0]?.version ?? 0);
111	},
112	catch: (cause) => new ScopeDbError({ message: "tableVersion failed", cause }),
113	}),
114	versions: () =>
115	Effect.tryPromise({
116	try: async () => {
117	await ensureVersionTable();
118	const rows = await client.execute(`SELECT name, version FROM ${VERSION_TABLE}`);
119	const out = new Map<string, number>();
120	for (const r of rows.rows) out.set(String(r.name), Number(r.version));
121	return out as ReadonlyMap<string, number>;
122	},
123	catch: (cause) => new ScopeDbError({ message: "versions failed", cause }),
124	}),
125	};
126	};
127
128	export interface LibsqlScopeDbOptions {
129	/** Directory holding one SQLite file per tenant/scope, or ":memory:" for tests. */
130	readonly root: string;
131	}
132
133	const toUrl = (path: string): string => (path === ":memory:" ? path : `file:${resolve(path)}`);
134
135	export const makeLibsqlScopeDb = (options: LibsqlScopeDbOptions): ScopeDb => {
136	const clients = new Map<string, Client>();
137
138	const clientFor = (address: ScopeAddress): Client => {
139	const key = scopeAddressStorageKey(address);
140	let client = clients.get(key);
141	if (!client) {
142	if (options.root === ":memory:") {
143	client = createClient({ url: ":memory:" });
144	} else {
145	mkdirSync(options.root, { recursive: true });
146	client = createClient({ url: toUrl(join(options.root, `${key}.db`)) });
147	}
148	clients.set(key, client);
149	}
150	return client;
151	};
152
153	return {
154	forScope: (address) =>
155	Effect.try({
156	try: () => makeHandle(address, clientFor(address)),
157	catch: (cause) =>
158	new ScopeDbError({
159	message: `failed to open scope db ${address.tenant}/${address.scope}`,
160	cause,
161	}),
162	}),
163	removeScope: (address) =>
164	Effect.try({
165	try: () => {
166	const key = scopeAddressStorageKey(address);
167	clients.get(key)?.close();
168	clients.delete(key);
169	if (options.root === ":memory:") return;
170	const dbPath = join(options.root, `${key}.db`);
171	for (const path of [dbPath, `${dbPath}-shm`, `${dbPath}-wal`]) {
172	rmSync(path, { force: true });
173	}
174	},
175	catch: (cause) =>
176	new ScopeDbError({
177	message: `failed to remove scope db ${address.tenant}/${address.scope}`,
178	cause,
179	}),
180	}),
181	close: () =>
182	Effect.sync(() => {
183	for (const client of clients.values()) client.close();
184	clients.clear();
185	}),
186	};
187	};

packages/plugins/apps/src/backing/quickjs-tool-sandbox.test.ts+30−6

     expect(descriptor.inputJsonSchema.properties).toHaveProperty("since");
   });
-  it("invokes a tool, routing injected-client + db calls through the bridge", async () => {
+  it("invokes a tool, routing injected-client calls through the bridge", async () => {
     const files = new Map([["tools/issues-sync.ts", ISSUES_SYNC_TS]]);
     const { code } = await run(bundleEntry({ files, entry: "tools/issues-sync.ts" }));
               },
             ];
           }
-          // db.sql calls return empty rows
           return [];
         }),
     };
           artifact: "issues-sync",
           kind: "tool",
           input: {},
-          roots: { github: { kind: "single" }, db: { kind: "single" } },
+          roots: { github: { kind: "single" } },
         },
         bridge,
       ),
     );
-    expect(result.output).toEqual({ synced: 1, repos: 1 });
+    expect(result.output).toEqual({
-    // The db write went through the bridge (root "db").
+      synced: 1,
-    expect(calls.some((c) => c.root === "db")).toBe(true);
+      repos: 1,
+      issues: [{ repo: "acme/app", number: 1, title: "Bug" }],
+    });
     expect(calls.some((c) => c.root === "github")).toBe(true);
   });
+  it("reports storage as unavailable when an old handler calls db.sql", async () => {
+    const source = `import { defineTool } from "executor:app";
+import { z } from "zod";
+export default defineTool({
+  description: "legacy storage",
+  input: z.object({}),
+  async handler(_input, { db }) {
+    await db.sql\`SELECT 1\`;
+    return { ok: true };
+  },
+});`;
+    const files = new Map([["tools/storage.ts", source]]);
+    const { code } = await run(bundleEntry({ files, entry: "tools/storage.ts" }));
+    const bridge: HandleBridge = { call: () => Effect.succeed(null) };
+    const exit = await Effect.runPromiseExit(
+      sandbox.invoke(code, { artifact: "storage", kind: "tool", input: {}, roots: {} }, bridge),
+    );
+    expect(Exit.isFailure(exit)).toBe(true);
+    expect(JSON.stringify(exit)).toContain("storage is not available yet");
+  });
   it("surfaces Standard Schema validation issues before the handler runs", async () => {
     const source = `import { defineTool } from "executor:app";
 import { z } from "zod";

packages/plugins/apps/src/backing/quickjs-tool-sandbox.ts+27−1

 // `await __invokeTool("__handle__", { root, path, args })` — the ONE bridge the
 // QuickJS runtime already provides (`tools`/`__invokeTool`). Our
 // `SandboxToolInvoker` decodes that and forwards to the host `HandleBridge`.
+// The old `db` handle is intentionally unavailable in v1; handlers that still
+// try it get a clear error before any host storage call exists.
 // Everything crossing is JSON (the cloud version is RPC), so the interface
 // stays honest.
 //
     }
   });
 }
+function __unavailableStorage() {
+  return new Proxy({}, {
+    get: function() {
+      return function() { throw new Error('storage is not available yet'); };
+    },
+    apply: function() {
+      throw new Error('storage is not available yet');
+    }
+  });
+}
 var __executorApp = {
   integration: function(integration) { return { integration: integration }; },
   defineTool: function(def) { __defs.tool = def; return def; },
     });
   };
   var def = __defs.tool || (globalThis.__artifact && (globalThis.__artifact.default || globalThis.__artifact));
+  if (def && typeof def.handler === 'function') {
+    var handlerSource = Function.prototype.toString.call(def.handler);
+    if (/\\bdb\\b/.test(handlerSource)) {
+      fail('StorageUnavailableError', {
+        tool: artifactName,
+        field: 'handler',
+        message: 'tool "' + artifactName + '" uses storage, but storage is not available yet',
+      });
+    }
+  }
   var integrations = {};
   if (def && def.integrations) {
     for (var k in def.integrations) {
     if (spec.kind !== 'single') throw new Error('unsupported handle root kind: ' + spec.kind);
     injected[name] = __mkHandle(name, []);
   }
+  injected.db = __unavailableStorage();
   var input = await validateWithStandardSchema('input', def.input, ${inputLiteral});
   var out = await def.handler(input, injected);
   out = await validateWithStandardSchema('output', def.output, out);
       Effect.flatMap((result) => {
         if (result.error) {
           const marker = parseMarker(result.error);
-          if (isMarker(marker, "SchemaExportError")) {
+          if (
+            isMarker(marker, "SchemaExportError") ||
+            isMarker(marker, "StorageUnavailableError")
+          ) {
             return Effect.fail(
               new ToolSandboxError({
                 kind: "collect",

packages/plugins/apps/src/backing/scope-collision.test.ts+3−37

@@ -1,52 +1,18 @@
1	import { mkdtempSync, readdirSync } from "node:fs";
2	import { tmpdir } from "node:os";
3	import { join } from "node:path";
4
5	import { describe, expect, it } from "@effect/vitest";	1	import { describe, expect, it } from "@effect/vitest";
6	import { Effect } from "effect";	2	import { Effect } from "effect";
7		3
8	import { makeLibsqlScopeDb } from "./libsql-scope-db";
9	import { makeSqliteAppsStore } from "./sqlite-apps-store";	4	import { makeSqliteAppsStore } from "./sqlite-apps-store";
10	import { DESCRIPTOR_VERSION, type AppDescriptor } from "../pipeline/descriptor";	5	import { DESCRIPTOR_VERSION, type AppDescriptor } from "../pipeline/descriptor";
11	import { scopeAddress } from "../seams/scope-address";
12		6
13	const run = <A, E>(effect: Effect.Effect<A, E>): Promise<A> => Effect.runPromise(effect);	7	const run = <A, E>(effect: Effect.Effect<A, E>): Promise<A> => Effect.runPromise(effect);
14		8
15	// ---------------------------------------------------------------------------	9	// ---------------------------------------------------------------------------
16	// Finding 9 regression: scopes that differ only by a character the old naming	10	// Finding 9 regression: scopes that differ only by a character an old naming
17	// collapsed ("my-scope" vs "my_scope") must NOT share a database, and the	11	// scheme collapsed ("my-scope" vs "my_scope") must not share descriptor
18	// connection->scope mapping must route each to its own scope. Before the fix the	12	// storage.
19	// scope-db filename collapsed `[^A-Za-z0-9._-]` to `_` (colliding two scopes onto
20	// one file) and the connection name was reverse-parsed (colliding two scopes onto
21	// one normalized identifier).
22	// ---------------------------------------------------------------------------	13	// ---------------------------------------------------------------------------
23		14
24	describe("scope collision (Fix 9)", () => {	15	describe("scope collision (Fix 9)", () => {
25	it("gives my-scope and my_scope DISTINCT scope-db files with isolated data", async () => {
26	const root = mkdtempSync(join(tmpdir(), "apps-scopecol-"));
27	const db = makeLibsqlScopeDb({ root });
28
29	const a = await run(db.forScope(scopeAddress("org", "my-scope")));
30	await run(a.exec("CREATE TABLE t (v TEXT)"));
31	await run(a.exec("INSERT INTO t (v) VALUES ('a')"));
32
33	const b = await run(db.forScope(scopeAddress("org", "my_scope")));
34	await run(b.exec("CREATE TABLE t (v TEXT)"));
35	await run(b.exec("INSERT INTO t (v) VALUES ('b')"));
36
37	// Each scope sees ONLY its own row (no shared file).
38	const aRows = await run(a.exec<{ v: string }>("SELECT v FROM t"));
39	const bRows = await run(b.exec<{ v: string }>("SELECT v FROM t"));
40	expect(aRows.map((r) => r.v)).toEqual(["a"]);
41	expect(bRows.map((r) => r.v)).toEqual(["b"]);
42
43	// Two distinct .db files exist on disk.
44	const dbFiles = readdirSync(root).filter((f) => f.endsWith(".db"));
45	expect(dbFiles.length).toBe(2);
46
47	await run(db.close());
48	});
49
50	it("stores distinct descriptor scopes independently", async () => {	16	it("stores distinct descriptor scopes independently", async () => {
51	const store = makeSqliteAppsStore({ path: ":memory:" });	17	const store = makeSqliteAppsStore({ path: ":memory:" });
52	const descriptor = (scope: string): AppDescriptor => ({	18	const descriptor = (scope: string): AppDescriptor => ({

packages/plugins/apps/src/index.ts+1−1

   type BindingContext,
 } from "./plugin/bindings";
 export { makePluginCtxAppsResolver } from "./plugin/resolver";
+export { SourceOriginError, assertSourceOrigin } from "./plugin/apps-plugin";
 export {
   makeSelfHostAppsRuntime,
   type SelfHostAppsRuntime,
 // Self-host seam backings.
 export { makeGitArtifactStore } from "./backing/git-artifact-store";
-export { makeLibsqlScopeDb } from "./backing/libsql-scope-db";
 export { makeQuickjsToolSandbox } from "./backing/quickjs-tool-sandbox";
 export { makeSqliteAppsStore } from "./backing/sqlite-apps-store";

packages/plugins/apps/src/pipeline/publish.test.ts+28−0

@@ -94,6 +94,34 @@ export default defineTool({ · 93 unmodified lines
94	expect(JSON.stringify(exit)).toContain("crm");	94	expect(JSON.stringify(exit)).toContain("crm");
95	});	95	});
96		96
		97	it("rejects tools that reference storage", async () => {
		98	const deps = makeDeps();
		99	const files = new Map<string, string>([
		100	[
		101	"tools/storage.ts",
		102	`import { defineTool } from "executor:app";
		103	import { z } from "zod";
		104	export default defineTool({
		105	description: "storage",
		106	input: z.object({}),
		107	async handler(_input, { db }) {
		108	await db.sql\`SELECT 1\`;
		109	return { ok: true };
		110	},
		111	});`,
		112	],
		113	]);
		114
		115	const exit = await Effect.runPromiseExit(publish(deps, { scope: "s", files }));
		116
		117	expect(Exit.isFailure(exit)).toBe(true);
		118	expect(JSON.stringify(exit)).toContain("storage is not available yet");
		119	const latest = await run(
		120	Effect.flatMap(deps.artifactStore.forScope(scopeAddress("org", "s")), (s) => s.latest()),
		121	);
		122	expect(latest).toBeNull();
		123	});
		124
97	it("rejects a Standard Schema vendor without JSON Schema export", async () => {	125	it("rejects a Standard Schema vendor without JSON Schema export", async () => {
98	const deps = makeDeps();	126	const deps = makeDeps();
99	const files = new Map<string, string>([	127	const files = new Map<string, string>([

packages/plugins/apps/src/plugin/apps-plugin.test.ts+52−47

-import { mkdtempSync, readFileSync } from "node:fs";
+import { mkdtempSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { IntegrationSlug } from "@executor-js/sdk";
 import { makeTestExecutor } from "@executor-js/sdk/testing";
-import { appsPlugin } from "./apps-plugin";
+import { SourceOriginError, appsPlugin, assertSourceOrigin } from "./apps-plugin";
 import { makeSelfHostAppsRuntime } from "./self-host-runtime";
 import { makeInMemoryAppsStore, makeTestResolver } from "../testing";
+import { dailyBriefFileSet } from "../testing/daily-brief";
 const run = <A, E>(effect: Effect.Effect<A, E>): Promise<A> => Effect.runPromise(effect);
-const PROTOTYPE_ROOT = "/Users/rhyssullivan/agent-workspace/prototypes/custom-tools";
-const prototypeFileSet = (): Map<string, string> =>
-  new Map<string, string>([
-    ["executor.json", readFileSync(join(PROTOTYPE_ROOT, "executor.json"), "utf8")],
-    [
-      "tools/deal-pipeline-sync.ts",
-      readFileSync(join(PROTOTYPE_ROOT, "tools/deal-pipeline-sync.ts"), "utf8"),
-    ],
-    [
-      "tools/find-deal-docs.ts",
-      readFileSync(join(PROTOTYPE_ROOT, "tools/find-deal-docs.ts"), "utf8"),
-    ],
-  ]);
 describe("appsPlugin custom-tools contract", () => {
   it.effect("detects GitHub repo URLs for console auto-detect", () =>
     Effect.gen(function* () {
     }),
   );
-  it("round-trips prototype files through publish, resolveTools, and invokeTool", async () => {
+  it.effect("rejects publishing through a different source door for a GitHub-managed app", () =>
-    let dealListArgs: unknown;
+    Effect.gen(function* () {
+      const failure = yield* Effect.flip(assertSourceOrigin("github", "mcp"));
+      expect(failure).toBeInstanceOf(SourceOriginError);
+      expect(failure.message).toBe("this app is managed by its GitHub repo");
+      expect(failure.existingOrigin).toBe("github");
+      expect(failure.requestedOrigin).toBe("mcp");
+    }),
+  );
+  it("round-trips custom tool files through publish, resolveTools, and invokeTool", async () => {
+    let issueListArgs: unknown;
     const resolver = makeTestResolver(
       {
-        dealcloud: {
+        github: {
-          "deals.list": (args) => {
+          "issues.listForRepo": (args) => {
-            dealListArgs = args[0];
+            issueListArgs = args[0];
-            return [];
+            return [{ number: 7, title: "Renewal diligence" }];
           },
         },
-        "microsoft-sharepoint": {
+        gmail: {
-          "search.query": () => [],
+          "messages.search": () => ({ messages: [] }),
         },
       },
       [
         {
-          address: "tools.dealcloud.user.crm-main",
+          address: "tools.github.user.github-main",
-          integration: "dealcloud",
+          integration: "github",
-          name: "crm-main",
+          name: "github-main",
         },
         {
-          address: "tools.microsoft-sharepoint.user.sharepoint-main",
+          address: "tools.gmail.user.inbox-main",
-          integration: "microsoft-sharepoint",
+          integration: "gmail",
-          name: "sharepoint-main",
+          name: "inbox-main",
         },
       ],
     );
     const plugin = appsPlugin({ backings: host.backings });
     const appIntegration = IntegrationSlug.make("rhys-tools");
     const appConfig = {
+      origin: "github",
       kind: "github",
       repoUrl: "https://github.com/rhys/tools",
       repo: "rhys/tools",
       },
     };
-    await run(runtime.publish({ scope: "rhys", files: prototypeFileSet() }));
+    await run(runtime.publish({ scope: "rhys", files: dailyBriefFileSet() }));
     const resolved = await run(
       plugin.resolveTools!({
         connection: { name: "main" },
       } as never),
     );
-    const syncTool = resolved.tools.find((tool) => String(tool.name) === "deal-pipeline-sync");
+    const syncTool = resolved.tools.find((tool) => String(tool.name) === "issues-sync");
     expect(syncTool).toBeTruthy();
     const persistedInputSchema = syncTool!.inputSchema as {
       properties: Record<string, unknown>;
     };
-    expect(persistedInputSchema.properties.crm).toBeUndefined();
+    expect(persistedInputSchema.properties.github).toBeUndefined();
     const projected = await run(
       plugin.projectToolSchema!({
         ctx,
         toolRow: {
-          name: "deal-pipeline-sync",
+          name: "issues-sync",
           integration: appIntegration,
           connection: "main",
         },
       properties: Record<string, { enum?: string[]; default?: string; description?: string }>;
       required?: string[];
     };
-    expect(inputSchema.properties.crm.enum).toEqual(["tools.dealcloud.user.crm-main"]);
+    expect(inputSchema.properties.github.enum).toEqual(["tools.github.user.github-main"]);
-    expect(inputSchema.properties.crm.default).toBe("tools.dealcloud.user.crm-main");
+    expect(inputSchema.properties.github.default).toBe("tools.github.user.github-main");
-    expect(inputSchema.properties.crm.description).toBe("Connection to use for crm (dealcloud)");
+    expect(inputSchema.properties.github.description).toBe("Connection to use for github (github)");
-    expect(inputSchema.required ?? []).not.toContain("crm");
+    expect(inputSchema.required ?? []).not.toContain("github");
     const output = await run(
       plugin.invokeTool!({
         ctx,
         toolRow: {
-          name: "deal-pipeline-sync",
+          name: "issues-sync",
           integration: appIntegration,
           connection: "main",
         },
         args: {
-          crm: "tools.dealcloud.user.crm-main",
+          github: "tools.github.user.github-main",
-          updatedSince: "2026-01-01T00:00:00Z",
+          repos: ["acme/tools"],
+          since: "2026-01-01T00:00:00Z",
         },
       } as never),
     );
-    expect(output).toEqual({ synced: 0 });
+    expect(output).toEqual({
-    expect(dealListArgs).toEqual({
+      synced: 1,
-      status: "active",
+      repos: 1,
-      updatedSince: "2026-01-01T00:00:00Z",
+      issues: [{ repo: "acme/tools", number: 7, title: "Renewal diligence" }],
-      pageSize: 200,
+    });
+    expect(issueListArgs).toEqual({
+      owner: "acme",
+      repo: "tools",
+      state: "open",
+      since: "2026-01-01T00:00:00Z",
+      per_page: 100,
     });
     await host.close();
   });

packages/plugins/apps/src/plugin/apps-plugin.ts+38−20

-import { Effect, Result } from "effect";
+import { Data, Effect, Result } from "effect";
 import {
   AuthTemplateSlug,
 import type { IntegrationDecl, ToolDescriptor } from "../pipeline/descriptor";
 import { PublishError } from "../pipeline/discover";
 import { ArtifactStoreError } from "../seams/artifact-store";
-import { ScopeDbError } from "../seams/scope-db";
 import { ToolSandboxError } from "../seams/tool-sandbox";
 import {
   parseGitHubSourceUrl,
 const APP_CONNECTION_NAME = connectionIdentifier("main");
 interface AppsGitHubSourceConfig {
+  readonly origin: "github";
   readonly kind: "github";
   readonly repoUrl: string;
   readonly repo: string;
   readonly tool: string;
 }) => ClientResolver;
+export class SourceOriginError extends Data.TaggedError("SourceOriginError")<{
+  readonly message: string;
+  readonly existingOrigin: string;
+  readonly requestedOrigin: string;
+}> {}
+export const assertSourceOrigin = (
+  existingOrigin: string,
+  requestedOrigin: string,
+): Effect.Effect<void, SourceOriginError> =>
+  existingOrigin === requestedOrigin
+    ? Effect.void
+    : Effect.fail(
+        new SourceOriginError({
+          existingOrigin,
+          requestedOrigin,
+          message:
+            existingOrigin === "github"
+              ? "this app is managed by its GitHub repo"
+              : `this app is managed by its ${existingOrigin} source`,
+        }),
+      );
 export type AppsPluginOptions =
   | {
       readonly backings: AppsBackings;
           }),
         ),
     },
-    scopeDb: {
-      forScope: () =>
-        Effect.fail(
-          new ScopeDbError({
-            message: missingBackingsMessage,
-          }),
-        ),
-      removeScope: () =>
-        Effect.fail(
-          new ScopeDbError({
-            message: missingBackingsMessage,
-          }),
-        ),
-      close: () => Effect.void,
-    },
     sandbox: {
       collect: () =>
         Effect.fail(
     : undefined;
 const decodeSourceConfig = (config: unknown): AppsGitHubSourceConfig | null => {
-  if (!isRecord(config) || config.kind !== "github") return null;
+  if (!isRecord(config) || config.origin !== "github" || config.kind !== "github") return null;
   const repoUrl = asString(config.repoUrl);
   const repo = asString(config.repo);
   const scope = asString(config.scope);
       }
     : undefined;
   return {
+    origin: "github",
     kind: "github",
     repoUrl,
     repo,
     Effect.gen(function* () {
       const slug = IntegrationSlug.make(slugValue);
       const record = yield* ctx.core.integrations.get(slug).pipe(Effect.orElseSucceed(() => null));
-      const config = record?.kind === APPS_PLUGIN_ID ? decodeSourceConfig(record.config) : null;
+      if (!record) {
-      if (!record || !config) {
         return syncFailure(`Custom tools source "${slugValue}" does not exist.`);
       }
+      if (record.kind === APPS_PLUGIN_ID && isRecord(record.config)) {
+        const origin = asString(record.config.origin);
+        if (origin) {
+          const originCheck = yield* assertSourceOrigin(origin, "github").pipe(Effect.result);
+          if (Result.isFailure(originCheck)) return syncFailure(originCheck.failure.message);
+        }
+      }
+      const config = record.kind === APPS_PLUGIN_ID ? decodeSourceConfig(record.config) : null;
+      if (!config) return syncFailure(`Custom tools source "${slugValue}" does not exist.`);
       const github = yield* ctx.core.integrations
         .get(IntegrationSlug.make("github"))
         .pipe(Effect.orElseSucceed(() => null));
       const descriptor = yield* runtime.getDescriptor(tenant, scope);
       const source = descriptor?.source?.kind === "github" ? descriptor.source : null;
       const config: AppsGitHubSourceConfig = {
+        origin: "github",
         kind: "github",
         repoUrl: source?.url ?? input.url.trim(),
         repo: source?.repo ?? parsed.value.repo,

packages/plugins/apps/src/plugin/backings.ts+0−3

 import type { ArtifactStore } from "../seams/artifact-store";
-import type { ScopeDb } from "../seams/scope-db";
 import type { ToolSandbox } from "../seams/tool-sandbox";
 import { makeAppsRuntime, type AppsRuntime } from "./runtime";
 import type { AppsStore } from "./store";
 export interface AppsBackings {
   readonly artifactStore: ArtifactStore;
-  readonly scopeDb: ScopeDb;
   readonly sandbox: ToolSandbox;
   readonly store: AppsStore;
   readonly defaultTenant?: string;
 ): AppsRuntime =>
   makeAppsRuntime({
     artifactStore: backings.artifactStore,
-    scopeDb: backings.scopeDb,
     sandbox: backings.sandbox,
     store: backings.store,
     resolver: backings.resolver ?? fallbackResolver,

packages/plugins/apps/src/plugin/bindings.strict.test.ts+1−13

 import { buildBridge, resolveIntegrationBindings, type ClientResolver } from "./bindings";
 import type { IntegrationDecl } from "../pipeline/descriptor";
-import type { ScopeDbHandle } from "../seams/scope-db";
 // ---------------------------------------------------------------------------
 // Strict HandleBridge dispatch (Fix 4, grafted from build A). The bridge is the
 // malformed, reserved, undeclared, or out-of-range rather than resolve it.
 // ---------------------------------------------------------------------------
-const okDb: ScopeDbHandle = {
-  sql: () => Effect.succeed([]),
-  exec: () => Effect.succeed([]),
-  tableVersion: () => Effect.succeed(0),
-  versions: () => Effect.succeed(new Map()),
-};
 const okResolver: ClientResolver = {
   listConnections: ({ integration }) =>
     Effect.succeed([
   const bindings = {
     gh: "tools.github.user.main",
   };
-  const bridge = buildBridge({ declared, bindings, db: okDb, resolver: okResolver });
+  const bridge = buildBridge({ declared, bindings, resolver: okResolver });
   it("rejects an empty method path", async () => {
     expect(await fails(bridge.call({ root: "gh", path: [], args: [] }))).toBe(true);
     );
   });
-  it("rejects an unsupported db call", async () => {
-    expect(await fails(bridge.call({ root: "db", path: ["drop"], args: [] }))).toBe(true);
-  });
   it("routes a valid single-connection call through the resolver", async () => {
     const out = await Effect.runPromise(
       bridge.call({ root: "gh", path: ["repos", "list"], args: [{}] }),

packages/plugins/apps/src/plugin/bindings.ts+9−30

 import type { HandleBridge, HandleRootSpec } from "../seams/tool-sandbox";
 import { ToolSandboxError } from "../seams/tool-sandbox";
-import type { ScopeDbHandle } from "../seams/scope-db";
 import type { IntegrationDecl } from "../pipeline/descriptor";
 // ---------------------------------------------------------------------------
 // has exactly one connection for a role's integration, that connection is used
 // as the default. Missing, unknown, or wrong-integration choices are typed
 // BindingError failures. The handler receives clients under the declared role
-// names and `db`.
+// names.
 // ---------------------------------------------------------------------------
 export class BindingError extends Data.TaggedError("BindingError")<{
   readonly declared: Readonly<Record<string, IntegrationDecl>>;
   /** Resolved role -> connection address choices for this invocation. */
   readonly bindings: RoleBindings;
-  /** The invoking scope's app database (bound to the `db` root). */
-  readonly db: ScopeDbHandle;
   /** Routes a bound method call to the real integration. */
   readonly resolver: ClientResolver;
   /** Caller-supplied invoke options to preserve approval/elicitation context. */
     return { input, bindings };
   });
-/** Compute the sandbox handle roots: `db` plus one single root per declared
+/** Compute the sandbox handle roots: one single root per declared integration
- *  integration role. */
+ *  role. */
 export const rootsFor = (
   declared: Readonly<Record<string, IntegrationDecl>>,
 ): Readonly<Record<string, HandleRootSpec>> => {
-  const roots: Record<string, HandleRootSpec> = { db: { kind: "single" } };
+  const roots: Record<string, HandleRootSpec> = {};
   for (const role of Object.keys(declared)) {
     roots[role] = { kind: "single" };
   }
   new ToolSandboxError({ kind: "invoke", message });
 /**
- * Build the HandleBridge the sandbox calls out through. `db` routes to the
+ * Build the HandleBridge the sandbox calls out through. A declared role routes
- * scope database; a declared role routes to its resolved connection through the
+ * to its resolved connection through the `ClientResolver`. The dispatch is
- * `ClientResolver`. The dispatch is STRICT: an empty/malformed path, a reserved
+ * STRICT: an empty/malformed path, a reserved root, an undeclared root, or an
- * root, an undeclared root, or an indexed root is an error, never a silent
+ * indexed root is an error, never a silent success. A `.account` read on a
- * success. A `.account` read on a client returns bound-connection metadata
+ * client returns bound-connection metadata without a round-trip.
- * without a round-trip.
  */
 export const buildBridge = (context: BindingContext): HandleBridge => ({
   call: ({ root, path, args }) => {
       return Effect.fail(invokeErr(`reserved handle root is not callable: ${root}`));
     }
-    if (root === "db") {
-      if (path.length === 1 && path[0] === "sql") {
-        const [strings, ...values] = args as [TemplateStringsArray, ...unknown[]];
-        return context.db.sql(strings, ...values).pipe(
-          Effect.mapError(
-            (cause) =>
-              new ToolSandboxError({
-                kind: "invoke",
-                message: "scope database call failed",
-                cause,
-              }),
-          ),
-        );
-      }
-      return Effect.fail(invokeErr(`unsupported db call: ${path.join(".")}`));
-    }
     const { role, index } = parseRoot(root);
     if (index !== undefined) {
       return Effect.fail(

packages/plugins/apps/src/plugin/runtime.test.ts+14−8

@@ -7,7 +7,6 @@ import { Effect, Exit } from "effect"; · 6 unmodified lines
7		7
8	import { makeSelfHostAppsRuntime } from "./self-host-runtime";	8	import { makeSelfHostAppsRuntime } from "./self-host-runtime";
9	import { makeInMemoryAppsStore, makeTestResolver, dailyBriefFileSet } from "../testing";	9	import { makeInMemoryAppsStore, makeTestResolver, dailyBriefFileSet } from "../testing";
10	import { scopeAddress } from "../seams/scope-address";
11		10
12	const run = <A, E>(effect: Effect.Effect<A, E>): Promise<A> => Effect.runPromise(effect);	11	const run = <A, E>(effect: Effect.Effect<A, E>): Promise<A> => Effect.runPromise(effect);
13		12
@@ -36,7 +35,7 @@ const githubHandlers = { · 22 unmodified lines
36	};	35	};
37		36
38	describe("AppsRuntime end-to-end (publish -> invoke)", () => {	37	describe("AppsRuntime end-to-end (publish -> invoke)", () => {
39	it("publishes daily-brief and invokes the tool into the scope db", async () => {	38	it("publishes daily-brief and invokes the tool through declared integrations", async () => {
40	const store = makeInMemoryAppsStore();	39	const store = makeInMemoryAppsStore();
41	const resolver = makeTestResolver(githubHandlers, [	40	const resolver = makeTestResolver(githubHandlers, [
42	{ address: "tools.github.user.rhys-github", integration: "github", name: "rhys-github" },	41	{ address: "tools.github.user.rhys-github", integration: "github", name: "rhys-github" },
@@ -61,12 +60,19 @@ describe("AppsRuntime end-to-end (publish -> invoke)", () => { · 18 unmodified lines
61	tool: "issues-sync",	60	tool: "issues-sync",
62	args: { github: "tools.github.user.rhys-github" },	61	args: { github: "tools.github.user.rhys-github" },
63	}),	62	}),
64	)) as { synced: number; repos: number };	63	)) as {
65	expect(syncResult).toEqual({ synced: 2, repos: 1 });	64	synced: number;
66		65	repos: number;
67	const db = await run(host.scopeDb.forScope(scopeAddress("org", "rhys")));	66	issues: readonly { repo: string; number: number; title: string }[];
68	const rows = await run(db.exec<{ n: number }>("SELECT COUNT(*) AS n FROM issues"));	67	};
69	expect(Number(rows[0].n)).toBe(2);	68	expect(syncResult).toEqual({
		69	synced: 2,
		70	repos: 1,
		71	issues: [
		72	{ repo: "acme/app", number: 1, title: "Fresh bug" },
		73	{ repo: "acme/app", number: 2, title: "Old bug" },
		74	],
		75	});
70		76
71	await host.close();	77	await host.close();
72	});	78	});

packages/plugins/apps/src/plugin/runtime.ts+0−16

 import type { InvokeOptions } from "@executor-js/sdk";
 import type { ArtifactStore } from "../seams/artifact-store";
-import type { ScopeDb } from "../seams/scope-db";
 import {
   InputValidationError,
   OutputValidationError,
 export interface AppsRuntimeDeps {
   readonly artifactStore: ArtifactStore;
-  readonly scopeDb: ScopeDb;
   readonly sandbox: ToolSandbox;
   readonly store: AppsStore;
   /** Routes a bound integration method call to the real API (policy/audit). */
       );
       const roots = rootsFor(toolDesc.integrations);
       const code = yield* bundleFor(descriptor, toolDesc.sourcePath);
-      const db = yield* deps.scopeDb.forScope(scopeAddress(descriptor.tenant, scope)).pipe(
-        Effect.mapError(
-          (c) =>
-            new PublishError({
-              message: c.message,
-              stage: "project",
-              diagnostics: [],
-            }),
-        ),
-      );
       const bridge = buildBridge({
         declared: toolDesc.integrations,
         bindings: resolved.bindings,
-        db,
         resolver: activeResolver,
         invokeOptions,
       });
         yield* deps.artifactStore
           .removeScope(address)
           .pipe(Effect.mapError(toPublishError("remove artifact scope failed")));
-        yield* deps.scopeDb
-          .removeScope(address)
-          .pipe(Effect.mapError(toPublishError("remove scope db failed")));
       });
     },

packages/plugins/apps/src/plugin/self-host-runtime.ts+2−14

 import { join } from "node:path";
-import { Effect } from "effect";
 import { makeGitArtifactStore } from "../backing/git-artifact-store";
-import { makeLibsqlScopeDb } from "../backing/libsql-scope-db";
 import { makeQuickjsToolSandbox } from "../backing/quickjs-tool-sandbox";
-import type { ScopeDb } from "../seams/scope-db";
 import { type AppsRuntime } from "./runtime";
 import type { AppsStore } from "./store";
 import type { ClientResolver } from "./bindings";
 import { makeAppsRuntimeFromBackings, type AppsBackings } from "./backings";
 export interface SelfHostAppsRuntimeOptions {
-  /** Data dir root; `<root>/artifacts` and `<root>/scope-db`. */
+  /** Data dir root; `<root>/artifacts`. */
   readonly dataDir: string;
   /** Default tenant for direct runtime calls; request paths pass tenant explicitly. */
   readonly tenant?: string;
 export interface SelfHostAppsRuntime {
   readonly runtime: AppsRuntime;
   readonly backings: AppsBackings;
-  readonly scopeDb: ScopeDb;
   readonly close: () => Promise<void>;
 }
   const artifactStore = makeGitArtifactStore({
     root: inMem ? options.dataDir : join(options.dataDir, "artifacts"),
   });
-  const scopeDb = makeLibsqlScopeDb({
-    root: inMem ? ":memory:" : join(options.dataDir, "scope-db"),
-  });
   const sandbox = makeQuickjsToolSandbox();
   const backings: AppsBackings = {
     artifactStore,
-    scopeDb,
     sandbox,
     store: options.store,
     resolver: options.resolver,
   return {
     runtime,
     backings,
-    scopeDb,
+    close: async () => {},
-    close: async () => {
-      await Effect.runPromise(scopeDb.close().pipe(Effect.orElseSucceed(() => undefined)));
-    },
   };
 };

packages/plugins/apps/src/plugin/tenant-isolation.test.ts+3−22

 import { Effect } from "effect";
 import { makeSqliteAppsStore } from "../backing/sqlite-apps-store";
-import { scopeAddress } from "../seams/scope-address";
 import { syncGitHubSource } from "../source/github-source";
 import { makeTestResolver } from "../testing";
 import { makeSelfHostAppsRuntime } from "./self-host-runtime";
 export default defineTool({
   description: "${name}",
   input: z.object({}),
-  output: z.object({ ok: z.boolean() }),
+  output: z.object({ ok: z.boolean(), name: z.string() }),
-  async handler(_input, { db }) {
+  async handler() {
-    await db.sql\`CREATE TABLE IF NOT EXISTS markers (name TEXT NOT NULL)\`;
+    return { ok: true, name: ${JSON.stringify(name)} };
-    await db.sql\`INSERT INTO markers (name) VALUES (${JSON.stringify(name)})\`;
-    return { ok: true };
   },
 });`;
     expect(descriptorA?.tools.map((tool) => tool.name)).toEqual(["alpha"]);
     expect(descriptorB?.tools.map((tool) => tool.name)).toEqual(["beta"]);
-    const dbA = await run(hostA.scopeDb.forScope(scopeAddress(tenantA, scope)));
-    const dbB = await run(hostB.scopeDb.forScope(scopeAddress(tenantB, scope)));
-    await run(dbA.exec("CREATE TABLE marker (value TEXT)"));
-    await run(dbA.exec("INSERT INTO marker (value) VALUES ('a')"));
-    await run(dbB.exec("CREATE TABLE marker (value TEXT)"));
-    await run(dbB.exec("INSERT INTO marker (value) VALUES ('b')"));
-    expect(
-      (await run(dbA.exec<{ value: string }>("SELECT value FROM marker"))).map((r) => r.value),
-    ).toEqual(["a"]);
-    expect(
-      (await run(dbB.exec<{ value: string }>("SELECT value FROM marker"))).map((r) => r.value),
-    ).toEqual(["b"]);
-    expect(
-      readdirSync(join(dataDir, "scope-db")).filter((name) => name.endsWith(".db")).length,
-    ).toBe(2);
     await hostA.close();
     await hostB.close();
   });

packages/plugins/apps/src/seams/index.ts+0−1

@@ -2,5 +2,4 @@ · 1 unmodified line
2	// `src/backing/`; each seam has a conformance suite (`*.conformance.ts`) that a	2	// `src/backing/`; each seam has a conformance suite (`*.conformance.ts`) that a
3	// backing must pass, keeping a future Cloudflare backing honest.	3	// backing must pass, keeping a future Cloudflare backing honest.
4	export * from "./artifact-store";	4	export * from "./artifact-store";
5	export * from "./scope-db";
6	export * from "./tool-sandbox";	5	export * from "./tool-sandbox";

packages/plugins/apps/src/seams/scope-db.conformance.ts+0−70

@@ -1,70 +0,0 @@
1	import { describe, expect, it } from "@effect/vitest";
2	import { Effect } from "effect";
3
4	import type { ScopeDb } from "./scope-db";
5	import { scopeAddress } from "./scope-address";
6
7	// ---------------------------------------------------------------------------
8	// ScopeDb conformance suite. Runs against the interface. Covers: scope
9	// isolation (a write in scope A is invisible in scope B), per-table version
10	// bumps on write, and tagged-template parameters.
11	// ---------------------------------------------------------------------------
12
13	const run = <A, E>(effect: Effect.Effect<A, E>): Promise<A> => Effect.runPromise(effect);
14
15	export const scopeDbConformance = (
16	name: string,
17	makeDb: () => Promise<ScopeDb> \| ScopeDb,
18	): void => {
19	describe(`ScopeDb conformance: ${name}`, () => {
20	it("isolates data between scopes", async () => {
21	const db = await makeDb();
22	const a = await run(db.forScope(scopeAddress("org", "scope-a")));
23	const b = await run(db.forScope(scopeAddress("org", "scope-b")));
24	await run(a.exec("CREATE TABLE items (id INTEGER PRIMARY KEY, name TEXT)"));
25	await run(a.exec("INSERT INTO items (name) VALUES ('a-only')"));
26	await run(b.exec("CREATE TABLE items (id INTEGER PRIMARY KEY, name TEXT)"));
27
28	const aRows = await run(a.exec<{ name: string }>("SELECT name FROM items"));
29	const bRows = await run(b.exec<{ name: string }>("SELECT name FROM items"));
30	expect(aRows.map((r) => r.name)).toEqual(["a-only"]);
31	expect(bRows).toEqual([]);
32	await run(db.close());
33	});
34
35	it("bumps a table's version on each write", async () => {
36	const db = await makeDb();
37	const s = await run(db.forScope(scopeAddress("org", "ver")));
38	await run(s.exec("CREATE TABLE t (id INTEGER PRIMARY KEY)"));
39	const afterCreate = await run(s.tableVersion("t"));
40	expect(afterCreate).toBeGreaterThanOrEqual(1);
41
42	await run(s.exec("INSERT INTO t (id) VALUES (1)"));
43	const afterInsert = await run(s.tableVersion("t"));
44	expect(afterInsert).toBe(afterCreate + 1);
45
46	await run(s.exec("UPDATE t SET id = 2 WHERE id = 1"));
47	const afterUpdate = await run(s.tableVersion("t"));
48	expect(afterUpdate).toBe(afterInsert + 1);
49
50	// Reads do not bump.
51	await run(s.exec("SELECT * FROM t"));
52	expect(await run(s.tableVersion("t"))).toBe(afterUpdate);
53	await run(db.close());
54	});
55
56	it("supports the author-facing tagged-template sql with parameters", async () => {
57	const db = await makeDb();
58	const s = await run(db.forScope(scopeAddress("org", "tpl")));
59	await run(s.exec("CREATE TABLE issues (repo TEXT, title TEXT)"));
60	const repo = "acme/app";
61	const title = "Bug";
62	await run(s.sql`INSERT INTO issues (repo, title) VALUES (${repo}, ${title})`);
63	const rows = await run(
64	s.sql<{ repo: string; title: string }>`SELECT * FROM issues WHERE repo = ${repo}`,
65	);
66	expect(rows).toEqual([{ repo: "acme/app", title: "Bug" }]);
67	await run(db.close());
68	});
69	});
70	};

packages/plugins/apps/src/seams/scope-db.ts+0−44

@@ -1,44 +0,0 @@
1	import type { Effect } from "effect";
2	import { Data } from "effect";
3	import type { ScopeAddress } from "./scope-address";
4
5	// ---------------------------------------------------------------------------
6	// ScopeDb — the per-scope app database (the shared primitive).
7	//
8	// One SQL database per scope: tools read and write it. The self-hosted backing
9	// is one libSQL (SQLite) file per scope; the cloud backing (future) is a
10	// Durable Object facet. The seam carries a template-tag `sql` (the author-facing
11	// shape) plus per-table version counters.
12	//
13	// Scope isolation is structural: `forScope(a)` and `forScope(b)` are distinct
14	// databases; there is no cross-scope query path.
15	// ---------------------------------------------------------------------------
16
17	export class ScopeDbError extends Data.TaggedError("ScopeDbError")<{
18	readonly message: string;
19	readonly cause?: unknown;
20	}> {}
21
22	/** The author-facing db handle (matches `executor:app`'s `ScopeDb`): a tagged
23	* template returning rows. */
24	export interface ScopeDbHandle {
25	readonly sql: <Row = Record<string, unknown>>(
26	strings: TemplateStringsArray,
27	...values: unknown[]
28	) => Effect.Effect<readonly Row[], ScopeDbError>;
29	/** Run a raw statement (used by the runtime for probes/migrations). */
30	readonly exec: <Row = Record<string, unknown>>(
31	sql: string,
32	params?: readonly unknown[],
33	) => Effect.Effect<readonly Row[], ScopeDbError>;
34	/** Current version counter for a table (0 if never written). */
35	readonly tableVersion: (table: string) => Effect.Effect<number, ScopeDbError>;
36	/** Snapshot of every tracked table's version. */
37	readonly versions: () => Effect.Effect<ReadonlyMap<string, number>, ScopeDbError>;
38	}
39
40	export interface ScopeDb {
41	readonly forScope: (address: ScopeAddress) => Effect.Effect<ScopeDbHandle, ScopeDbError>;
42	readonly removeScope: (address: ScopeAddress) => Effect.Effect<void, ScopeDbError>;
43	readonly close: () => Effect.Effect<void, ScopeDbError>;
44	}

packages/plugins/apps/src/seams/tool-sandbox.conformance.ts+0−55

@@ -106,60 +106,5 @@ export default defineTool({ · 105 unmodified lines
106	expect(seen[0].path).toEqual(["messages", "search"]);	106	expect(seen[0].path).toEqual(["messages", "search"]);
107	expect(seen[0].args[0]).toMatchObject({ q: "invoice" });	107	expect(seen[0].args[0]).toMatchObject({ q: "invoice" });
108	});	108	});
109
110	// --- richer assertions grafted from build A ---------------------------
111
112	it("round-trips a db.sql write with its parameters intact", async () => {
113	const sandbox = makeSandbox();
114	// A tool with a github client AND a db.sql write, asserting BOTH the
115	// connection call and the parameterized db statement cross the bridge with
116	// their args intact (the db.sql param round-trip A's suite covers).
117	const src = `import { defineTool, integration } from "executor:app";
118	import { z } from "zod";
119	export default defineTool({
120	description: "bridge",
121	integrations: { gh: integration("github") },
122	input: z.object({}),
123	async handler(_i, { gh, db }) {
124	const repos = await gh.repos.listForAuthenticatedUser({ per_page: 5 });
125	await db.sql\`INSERT INTO log (n) VALUES (\${repos.length})\`;
126	return { count: repos.length };
127	},
128	});`;
129	const b = await bundle("tools/bridge.ts", src);
130	const calls: { root: string; path: readonly string[]; args: readonly unknown[] }[] = [];
131	const bridge: HandleBridge = {
132	call: ({ root, path, args }) =>
133	Effect.sync(() => {
134	calls.push({ root, path, args });
135	if (root === "gh" && path.join(".") === "repos.listForAuthenticatedUser") {
136	return [{ full_name: "a/b" }, { full_name: "c/d" }];
137	}
138	return [];
139	}),
140	};
141	const result = await run(
142	sandbox.invoke(
143	b,
144	{
145	artifact: "bridge",
146	kind: "tool",
147	input: {},
148	roots: { gh: { kind: "single" }, db: { kind: "single" } },
149	},
150	bridge,
151	),
152	);
153	expect(result.output).toEqual({ count: 2 });
154	// The github call crossed the bridge.
155	expect(calls.some((c) => c.root === "gh")).toBe(true);
156	// The db.sql write crossed as ["sql"] with the template strings + the
157	// interpolated parameter (2) intact.
158	const dbCall = calls.find((c) => c.root === "db");
159	expect(dbCall?.path).toEqual(["sql"]);
160	const [strings, ...params] = dbCall!.args as [readonly string[], ...unknown[]];
161	expect(strings.join("?")).toContain("INSERT INTO log");
162	expect(params).toEqual([2]);
163	});
164	});	109	});
165	};	110	};

packages/plugins/apps/src/seams/tool-sandbox.ts+5−5

@@ -49,7 +49,7 @@ export class OutputValidationError extends Data.TaggedError("OutputValidationErr · 48 unmodified lines
49		49
50	/**	50	/**
51	* The serializable bridge the sandbox calls out through. `root` names an	51	* The serializable bridge the sandbox calls out through. `root` names an
52	* injected handle (a connection role, `db`, or one element of a fan-out set);	52	* injected handle (a connection role or one element of a fan-out set);
53	* `path` is the method chain (`["events", "list"]`); `args` is the JSON call	53	* `path` is the method chain (`["events", "list"]`); `args` is the JSON call
54	* arguments. The return value is JSON. This is the ONE way sandboxed code	54	* arguments. The return value is JSON. This is the ONE way sandboxed code
55	* reaches the host — nothing else is wired.	55	* reaches the host — nothing else is wired.
@@ -62,9 +62,9 @@ export interface HandleBridge { · 6 unmodified lines
62	}) => Effect.Effect<unknown, ToolSandboxError>;	62	}) => Effect.Effect<unknown, ToolSandboxError>;
63	}	63	}
64		64
65	/** Which handle roots to inject. Each declared integration role and `db` are	65	/** Which handle roots to inject. Each declared integration role is a single
66	* single roots. Everything the handler can see is enumerated here —	66	* root. Everything the handler can see is enumerated here; undeclared roots
67	* undeclared roots are simply absent. */	67	* are simply absent. */
68	export interface HandleRootSpec {	68	export interface HandleRootSpec {
69	readonly kind: "single";	69	readonly kind: "single";
70	}	70	}
@@ -77,7 +77,7 @@ export interface InvokeRequest { · 6 unmodified lines
77	/** JSON input passed to the handler. */	77	/** JSON input passed to the handler. */
78	readonly input: unknown;	78	readonly input: unknown;
79	/** The handle roots to inject, keyed by the name the handler destructures	79	/** The handle roots to inject, keyed by the name the handler destructures
80	* (`github`, `db`, `inboxes`). */	80	* (`github`, `inboxes`). */
81	readonly roots: Readonly<Record<string, HandleRootSpec>>;	81	readonly roots: Readonly<Record<string, HandleRootSpec>>;
82	}	82	}
83		83

packages/plugins/apps/src/testing/daily-brief.ts+6−19

 export default defineTool({
   description:
-    "Refresh the scope \\\`issues\\\` table from GitHub. Syncs open issues across the given repos (default: every repo the connection can see).",
+    "Summarize open GitHub issues across the given repos (default: every repo the connection can see).",
   integrations: {
     github: integration("github"),
   },
     repos: z.array(z.string()).optional().describe("owner/repo entries; omit to sync all accessible repos"),
     since: z.string().optional().describe("ISO timestamp, only issues updated after this"),
   }),
-  output: z.object({ synced: z.number(), repos: z.number() }),
+  output: z.object({ synced: z.number(), repos: z.number(), issues: z.array(z.object({ repo: z.string(), number: z.number(), title: z.string() })) }),
   annotations: { readOnly: false, destructive: false },
-  async handler({ repos, since }, { github, db }) {
+  async handler({ repos, since }, { github }) {
     const targets =
       repos ??
       (await github.repos.listForAuthenticatedUser({ per_page: 100 })).map((r) => r.full_name);
-    await db.sql\`
-      CREATE TABLE IF NOT EXISTS issues (
-        repo TEXT NOT NULL, number INTEGER NOT NULL, title TEXT NOT NULL,
-        labels TEXT NOT NULL DEFAULT '[]', assignee TEXT, updated_at TEXT NOT NULL, url TEXT NOT NULL,
-        PRIMARY KEY (repo, number)
-      )\`;
     let synced = 0;
+    const collected = [];
     for (const target of targets) {
       const [owner, repo] = target.split("/");
       const issues = await github.issues.listForRepo({ owner, repo, state: "open", since, per_page: 100 });
       for (const issue of issues) {
         if (issue.pull_request) continue;
-        await db.sql\`
+        collected.push({ repo: target, number: issue.number, title: issue.title });
-          INSERT INTO issues (repo, number, title, labels, assignee, updated_at, url)
-          VALUES (\${target}, \${issue.number}, \${issue.title},
-            \${JSON.stringify(issue.labels.map((l) => l.name))},
-            \${issue.assignee?.login ?? null}, \${issue.updated_at}, \${issue.html_url})
-          ON CONFLICT (repo, number) DO UPDATE SET
-            title = excluded.title, labels = excluded.labels,
-            assignee = excluded.assignee, updated_at = excluded.updated_at\`;
         synced++;
       }
     }
-    return { synced, repos: targets.length };
+    return { synced, repos: targets.length, issues: collected };
   },
 });
 `;