@xingular/harness 0.1.0 → 0.1.1

package/dist/cli.js

@@ -24,7 +24,7 @@ function log(...parts) {
 
 // src/harness.ts
 import { mkdirSync as mkdirSync14 } from "node:fs";
-import { join as join38 } from "node:path";
+import { join as join39 } from "node:path";
 
 // src/accounts/accounts.ts
 import { chmodSync as chmodSync3, rmSync as rmSync2 } from "node:fs";
@@ -133,9 +133,9 @@ function newId() {
 }
 
 // src/accounts/env.ts
-import { chmodSync, lstatSync, mkdirSync as mkdirSync2, readlinkSync, renameSync as renameSync2, symlinkSync, unlinkSync } from "node:fs";
+import { chmodSync, copyFileSync, linkSync, lstatSync, mkdirSync as mkdirSync2, readlinkSync, renameSync as renameSync2, rmdirSync, statSync, symlinkSync, unlinkSync, utimesSync } from "node:fs";
 import { homedir } from "node:os";
-import { basename as basename2, dirname as dirname2, join as join2, sep as sep2 } from "node:path";
+import { basename as basename2, dirname as dirname2, join as join2, resolve, sep as sep2 } from "node:path";
 var DIR_VARS = ["CODEX_HOME", "CLAUDE_CONFIG_DIR", "PI_CODING_AGENT_DIR"];
 function isCredentialVar(name) {
   const upper = name.toUpperCase();
@@ -197,43 +197,124 @@ var modified = (path3) => {
   }
 };
 function backUp(path3) {
-  renameSync2(path3, join2(dirname2(path3), `${basename2(path3)}.agentx-backup-${Math.floor(Date.now() / 1e3)}`));
+  const backup2 = join2(dirname2(path3), `${basename2(path3)}.agentx-backup-${Math.floor(Date.now() / 1e3)}`);
+  renameSync2(path3, backup2);
+  return backup2;
 }
-function linkShared(accountsDir, dir) {
-  const shared = ensureSharedDir(accountsDir);
-  for (const [name, isDir2] of SHARED_ENTRIES) {
-    const local = join2(dir, name);
-    const target = join2(shared, name);
-    let meta = null;
-    try {
-      meta = lstatSync(local);
-    } catch {
-      meta = null;
-    }
-    if (meta?.isSymbolicLink()) {
-      if (readlinkSync(local) === target) {
-        if (isDir2) mkdirSync2(target, { recursive: true });
-        continue;
+var nodeLinker = {
+  symlink: (target, path3, isDir2) => symlinkSync(resolve(target), path3, isDir2 ? "junction" : "file"),
+  hardLink: (target, path3) => linkSync(target, path3)
+};
+var codeOf = (error) => error.code ?? String(error);
+var PRIVILEGE_CODES = ["EPERM", "EACCES"];
+function createLink(target, path3, isDir2, linker) {
+  try {
+    linker.symlink(target, path3, isDir2);
+  } catch (error) {
+    if (isDir2 || !PRIVILEGE_CODES.includes(codeOf(error))) throw error;
+    linker.hardLink(target, path3);
+  }
+}
+var isLink = (path3) => {
+  try {
+    return lstatSync(path3).isSymbolicLink();
+  } catch {
+    return false;
+  }
+};
+var LONG_PREFIX = /^\\\\\?\\/;
+function samePath(a, b) {
+  const normal = (path3) => {
+    const full = resolve(path3.replace(LONG_PREFIX, ""));
+    return process.platform === "win32" ? full.toLowerCase() : full;
+  };
+  return normal(a) === normal(b);
+}
+function sameFile(a, b) {
+  try {
+    const left = lstatSync(a);
+    const right = lstatSync(b);
+    return left.ino !== 0 && left.dev === right.dev && left.ino === right.ino;
+  } catch {
+    return false;
+  }
+}
+function isLinkTo(path3, target, isDir2) {
+  try {
+    const meta = lstatSync(path3);
+    if (meta.isSymbolicLink()) return samePath(readlinkSync(path3), target);
+    return !isDir2 && meta.isFile() && sameFile(path3, target);
+  } catch {
+    return false;
+  }
+}
+function removeLink(path3, isDir2) {
+  try {
+    unlinkSync(path3);
+  } catch (error) {
+    if (!isDir2) throw error;
+    rmdirSync(path3);
+  }
+}
+function keepCopy(target, path3, isDir2) {
+  if (isDir2 || present(path3) || !present(target)) return;
+  try {
+    copyFileSync(target, path3);
+    const { atime, mtime } = statSync(target);
+    utimesSync(path3, atime, mtime);
+  } catch {
+  }
+}
+function linkOne(name, target, path3, isDir2, linker) {
+  if (isLinkTo(path3, target, isDir2)) {
+    if (isDir2) mkdirSync2(target, { recursive: true });
+    return { name, state: "linked" };
+  }
+  const undo2 = [];
+  try {
+    if (isLink(path3)) {
+      const previous = readlinkSync(path3);
+      removeLink(path3, isDir2);
+      undo2.push(() => nodeLinker.symlink(previous, path3, isDir2));
+    } else if (present(path3)) {
+      if (!present(target)) {
+        renameSync2(path3, target);
+        undo2.push(() => renameSync2(target, path3));
+      } else if (!isDir2 && modified(path3) > modified(target)) {
+        const backup2 = backUp(target);
+        undo2.push(() => renameSync2(backup2, target));
+        renameSync2(path3, target);
+        undo2.push(() => renameSync2(target, path3));
+      } else {
+        const backup2 = backUp(path3);
+        undo2.push(() => renameSync2(backup2, path3));
       }
-      unlinkSync(local);
-    } else if (meta) {
-      if (!present(target)) renameSync2(local, target);
-      else if (!isDir2 && modified(local) > modified(target)) {
-        backUp(target);
-        renameSync2(local, target);
-      } else backUp(local);
     }
     if (isDir2) mkdirSync2(target, { recursive: true });
-    symlinkSync(target, local);
+    createLink(target, path3, isDir2, linker);
+    return { name, state: "linked" };
+  } catch (error) {
+    for (const step of undo2.reverse()) {
+      try {
+        step();
+      } catch {
+      }
+    }
+    keepCopy(target, path3, isDir2);
+    return { name, state: "unshared", reason: codeOf(error) };
   }
 }
-function ensureHome(accountsDir, account) {
+function linkSharedEntries(accountsDir, account, linker = nodeLinker) {
   makePrivate(join2(accountsDir, account.id));
   makePrivate(homeDir(accountsDir, account.id));
   const dir = configDir(accountsDir, account);
   makePrivate(dir);
-  linkShared(accountsDir, dir);
-  return dir;
+  const shared = ensureSharedDir(accountsDir);
+  const entries2 = SHARED_ENTRIES.map(([name, isDir2]) => linkOne(name, join2(shared, name), join2(dir, name), isDir2, linker));
+  return { dir, entries: entries2 };
+}
+function ensureHome(accountsDir, account) {
+  return linkSharedEntries(accountsDir, account).dir;
 }
 var inside = (path3, parent) => path3 === parent || path3.startsWith(parent.endsWith(sep2) ? parent : `${parent}${sep2}`);
 function assertIsolated(accountsDir, dir) {
@@ -242,16 +323,21 @@ function assertIsolated(accountsDir, dir) {
     throw new HarnessError("account_required", "A session cannot start outside its isolated account folder.");
   }
 }
-function launchEnv(accountsDir, account, inherited = process.env) {
-  const dir = ensureHome(accountsDir, account);
-  assertIsolated(accountsDir, dir);
+function sessionEnv(dir, inherited) {
   const env = {};
   for (const name of inheritedCredentialVars(inherited)) env[name] = null;
   env.PI_CODING_AGENT_DIR = dir;
   return env;
 }
+function launchEnv(accountsDir, account, inherited = process.env) {
+  const dir = ensureHome(accountsDir, account);
+  assertIsolated(accountsDir, dir);
+  return sessionEnv(dir, inherited);
+}
 function accountContext(accountsDir, account) {
-  return { id: account.id, provider: "pi", label: account.label, env: launchEnv(accountsDir, account), configDir: configDir(accountsDir, account) };
+  const { dir, entries: entries2 } = linkSharedEntries(accountsDir, account);
+  assertIsolated(accountsDir, dir);
+  return { id: account.id, provider: "pi", label: account.label, env: sessionEnv(dir, process.env), configDir: dir, sharing: entries2 };
 }
 
 // src/accounts/secrets.ts
@@ -406,7 +492,7 @@ function find(dir, accountId) {
   return account;
 }
 var usable = (state2) => state2.health === "ok" || state2.health === "unknown";
-function resolve(dir, accountId, poolId) {
+function resolve2(dir, accountId, poolId) {
   const registry = loadRegistry(dir);
   if (accountId) {
     const account2 = find(dir, accountId);
@@ -432,7 +518,7 @@ function resolve(dir, accountId, poolId) {
 }
 function defaultAccount(dir) {
   try {
-    return resolve(dir);
+    return resolve2(dir);
   } catch {
     return null;
   }
@@ -545,7 +631,7 @@ var Accounts = class {
   }
   /** The account a new session uses; a session that already has one passes it and keeps it. */
   resolve(accountId, poolId) {
-    return resolve(this.dir, accountId, poolId);
+    return resolve2(this.dir, accountId, poolId);
   }
   context(account) {
     return accountContext(this.dir, account);
@@ -801,9 +887,9 @@ var Accounts = class {
     const interaction = {
       signal: controller.signal,
       notify: (notification) => event(notification),
-      prompt: (prompt2) => new Promise((resolve8, reject) => {
+      prompt: (prompt2) => new Promise((resolve9, reject) => {
         const promptId = randomUUID2();
-        login.prompts.set(promptId, { resolve: resolve8, reject });
+        login.prompts.set(promptId, { resolve: resolve9, reject });
         prompt2.signal?.addEventListener("abort", () => {
           login.prompts.delete(promptId);
           event({ type: "promptClosed", promptId });
@@ -922,7 +1008,7 @@ var Accounts = class {
 };
 
 // src/plugins/api.ts
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 
 // src/core/projects.ts
 import { existsSync } from "node:fs";
@@ -1048,13 +1134,24 @@ function forget(attachments, scope) {
   if (scope.agentId) delete attachments.agents[scope.agentId];
   if (scope.projectId) delete attachments.projects[scope.projectId];
 }
+function forgetId(attachments, id) {
+  const forgetFrom = (item) => {
+    item.on = item.on.filter((entry) => entry !== id);
+    item.off = item.off.filter((entry) => entry !== id);
+  };
+  forgetFrom(attachments.global);
+  for (const item of Object.values(attachments.agents)) forgetFrom(item);
+  for (const item of Object.values(attachments.projects)) forgetFrom(item);
+  attachments.agents = Object.fromEntries(Object.entries(attachments.agents).filter(([, item]) => item.on.length || item.off.length));
+  attachments.projects = Object.fromEntries(Object.entries(attachments.projects).filter(([, item]) => item.on.length || item.off.length));
+}
 
 // src/prompt/compile.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync11, statSync as statSync2 } from "node:fs";
+import { readdirSync as readdirSync6, readFileSync as readFileSync11, statSync as statSync3 } from "node:fs";
 import { join as join18 } from "node:path";
 
 // src/core/index.ts
-import { copyFileSync, existsSync as existsSync2, readdirSync, rmSync as rmSync3 } from "node:fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync2, readdirSync, rmSync as rmSync3 } from "node:fs";
 import { join as join7 } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 var RECALL_SCHEMA = `CREATE TABLE recall_runs (run_id TEXT PRIMARY KEY, passages INTEGER NOT NULL, status TEXT NOT NULL);
@@ -1141,14 +1238,14 @@ function migrate(path3, migrations) {
     throw sqlError(error);
   }
   if (current >= migrations.length) return database;
-  const backup = `${path3.replace(/\.sqlite$/, "")}.sqlite.bak-v${current}`;
+  const backup2 = `${path3.replace(/\.sqlite$/, "")}.sqlite.bak-v${current}`;
   const hadFile = existsSync2(path3) && current > 0;
   if (hadFile) {
     try {
       database.exec("PRAGMA wal_checkpoint(TRUNCATE);");
     } catch {
     }
-    copyFileSync(path3, backup);
+    copyFileSync2(path3, backup2);
   }
   for (let index = current; index < migrations.length; index += 1) {
     try {
@@ -1158,7 +1255,7 @@ function migrate(path3, migrations) {
       });
     } catch (error) {
       database.close();
-      if (hadFile) copyFileSync(backup, path3);
+      if (hadFile) copyFileSync2(backup2, path3);
       else rmSync3(path3, { force: true });
       throw new HarnessError("migration_failed", `Index migration ${index + 1} failed and the previous index was restored: ${error instanceof Error ? error.message : String(error)}`);
     }
@@ -1280,7 +1377,7 @@ import { join as join9 } from "node:path";
 
 // src/memory/store.ts
 import { createHash } from "node:crypto";
-import { existsSync as existsSync3, mkdirSync as mkdirSync5, readdirSync as readdirSync2, readFileSync as readFileSync3, statSync } from "node:fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync5, readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
 import { join as join8, relative } from "node:path";
 import { stringify as stringify2 } from "yaml";
 
@@ -1453,7 +1550,7 @@ function markdownFiles(directory, into) {
     const path3 = join8(directory, name);
     let directoryEntry = false;
     try {
-      directoryEntry = statSync(path3).isDirectory();
+      directoryEntry = statSync2(path3).isDirectory();
     } catch {
       continue;
     }
@@ -1463,14 +1560,14 @@ function markdownFiles(directory, into) {
 }
 function isFile(path3) {
   try {
-    return statSync(path3).isFile();
+    return statSync2(path3).isFile();
   } catch {
     return false;
   }
 }
 function isDir(path3) {
   try {
-    return statSync(path3).isDirectory();
+    return statSync2(path3).isDirectory();
   } catch {
     return false;
   }
@@ -1802,7 +1899,7 @@ function editRefusal(caller, block2) {
   if (block2.scope === "project") return block2.owner === caller.projectSlug ? null : "A session may edit only its own project's brief.";
   return `A Harness session can read the ${label} block but cannot edit it. Report what you learned in your result instead.`;
 }
-function resolve2(root, caller, rawLabel) {
+function resolve3(root, caller, rawLabel) {
   const wiki = wikiDir(root);
   const label = rawLabel.trim().replace(/^\/+/, "");
   const unknown = () => invalid(`There is no memory block called ${label}. Use one of the labels shown in your memory blocks.`);
@@ -1887,7 +1984,7 @@ function write(wiki, block2, front, body2, actor, reason) {
 }
 function edit(root, caller, label, change) {
   const wiki = wikiDir(root);
-  const block2 = resolve2(root, caller, label);
+  const block2 = resolve3(root, caller, label);
   const refusal = editRefusal(caller, block2);
   if (refusal) throw invalid(refusal);
   const body2 = applyEdit(block2.body, change);
@@ -2181,6 +2278,14 @@ import { join as join14 } from "node:path";
 import { lstatSync as lstatSync2, mkdirSync as mkdirSync7, mkdtempSync, readdirSync as readdirSync4, readFileSync as readFileSync7, renameSync as renameSync4, rmSync as rmSync4, unlinkSync as unlinkSync2, writeFileSync } from "node:fs";
 import { basename as basename3, dirname as dirname4, join as join12 } from "node:path";
 var KINDS = ["skills", "prompts", "rules"];
+function contributionId(item) {
+  return `${item.builtin ? "included" : "yours"}/${item.id}`;
+}
+function limitToContributions(items, contributions2) {
+  if (contributions2 === void 0) return [...items];
+  const allowed2 = new Set(contributions2);
+  return items.filter((item) => allowed2.has(contributionId(item)));
+}
 var MAX_SKILL_BUNDLES = 20;
 var MAX_SKILL_FILES = 100;
 var MAX_SKILL_IMPORT_BYTES = 10 * 1024 * 1024;
@@ -2254,7 +2359,8 @@ function enablementIds(map, key) {
 }
 var BUILTIN_OFF_KEY = "builtinOff";
 var isItemId = (id) => KINDS.some((kind) => id.startsWith(`${kind}/`));
-function enabledFor(root, projectId, agentId = null) {
+function enabledFor(root, projectId, agentId = null, contributions2) {
+  if (contributions2 !== void 0) return limitToContributions(list(root), contributions2);
   const choices = load2(root);
   return list(root).filter((item) => attached(choices, [item.id], { agentId, projectId }, !!item.builtin));
 }
@@ -2266,8 +2372,8 @@ function itemBody(item) {
     return "";
   }
 }
-function resources(root, projectId, agentId = null) {
-  const items = enabledFor(root, projectId, agentId);
+function resources(root, projectId, agentId = null, contributions2) {
+  const items = enabledFor(root, projectId, agentId, contributions2);
   return {
     ids: items.map((item) => item.id),
     skillPaths: items.filter((item) => item.kind === "skills").map((item) => item.path),
@@ -3238,7 +3344,7 @@ function cite(wiki, id) {
 }
 
 // src/sessions/runStore.ts
-import { appendFileSync, copyFileSync as copyFileSync2, existsSync as existsSync7, mkdirSync as mkdirSync8, readFileSync as readFileSync10 } from "node:fs";
+import { appendFileSync, copyFileSync as copyFileSync3, existsSync as existsSync7, mkdirSync as mkdirSync8, readFileSync as readFileSync10 } from "node:fs";
 import { join as join17 } from "node:path";
 function runDir(root, runId) {
   return join17(root, "runs", safeId(runId));
@@ -3384,8 +3490,8 @@ function markInterruptedRuns(root, reason = STOPPED) {
       const status = terminalStatus(settled2);
       const settledReason = reasonOf(settled2);
       if (record3.status !== status || record3.endedAt !== settled2.timestamp || record3.terminalReason !== settledReason) {
-        const backup = `${path3}.before-outcome-repair`;
-        if (!existsSync7(backup)) copyFileSync2(path3, backup);
+        const backup2 = `${path3}.before-outcome-repair`;
+        if (!existsSync7(backup2)) copyFileSync3(path3, backup2);
         Object.assign(record3, { status, endedAt: settled2.timestamp, terminalReason: settledReason });
         write2(root, record3);
       }
@@ -3716,10 +3822,10 @@ function hostSection(host, kept) {
   return section(host.id, host.title, own ? `${host.pinned.text}
 ${own.body}` : host.pinned.text, host.budget, host.pinned.pointer ?? host.pointer ?? "", []);
 }
-function compile(env, context, launch = {}) {
+function compile(env, context, launch = {}, contributions2) {
   const { root } = env;
   const wiki = wikiDir(root);
-  const active = enabledFor(root, context.projectId ?? null, context.agentId ?? null);
+  const active = enabledFor(root, context.projectId ?? null, context.agentId ?? null, contributions2);
   const groups = toolGroups(context, launch);
   const contextProfile = profileFor(root, context);
   const keep = (id) => id === "references" || keeps(contextProfile, id);
@@ -3832,7 +3938,7 @@ function sessionFile(sessionDir, resume) {
   const files = names.filter((name) => name.endsWith(".jsonl") && name.length > ".jsonl".length).flatMap((name) => {
     const path3 = join18(sessionDir, name);
     try {
-      return [{ path: path3, modified: statSync2(path3).mtimeMs }];
+      return [{ path: path3, modified: statSync3(path3).mtimeMs }];
     } catch {
       return [];
     }
@@ -3844,8 +3950,8 @@ function sameSection(left, right) {
   if (!left || !right) return !left && !right;
   return left.id === right.id && left.title === right.title && left.body === right.body && left.budget === right.budget && left.size === right.size && left.cut === right.cut && left.sources.length === right.sources.length && left.sources.every((source2, index) => source2.id === right.sources[index].id && source2.kind === right.sources[index].kind && (source2.revision ?? null) === (right.sources[index].revision ?? null));
 }
-function sessionLaunch(env, context, launch, historyFile) {
-  const pack = compile(env, context, launch);
+function sessionLaunch(env, context, launch, historyFile, contributions2) {
+  const pack = compile(env, context, launch, contributions2);
   const dynamic = [...BUILT_IN_DYNAMIC, ...(launch.sections ?? []).filter((host) => host.dynamic).map((host) => ({ id: host.id, order: host.order }))].map((slot, index) => ({ ...slot, index })).sort((left, right) => left.order - right.order || left.index - right.index).map((slot) => slot.id);
   const previous = historyFile ? deliveredSnapshot(historyFile) : null;
   const snapshot3 = pack.sections.filter((entry) => dynamic.includes(entry.id));
@@ -4443,6 +4549,30 @@ import { join as join21, sep as sep3 } from "node:path";
 
 // src/plugins/manifest.ts
 import { basename as basename4, join as join20 } from "node:path";
+import { z as z3 } from "zod";
+var connectorTemplateSchema = z3.object({
+  id: z3.string().regex(/^[a-z0-9-]+$/),
+  name: z3.string().min(1).max(120),
+  description: z3.string().max(500),
+  url: z3.string().url().startsWith("https://"),
+  auth: z3.enum(["none", "headers", "oauth"]),
+  oauthClient: z3.enum(["dynamic", "user"]).nullable(),
+  oauthScopes: z3.array(z3.string().max(500)).max(30),
+  docsUrl: z3.string().url().startsWith("https://").nullable(),
+  fields: z3.array(z3.object({
+    header: z3.string().regex(/^[A-Za-z0-9_-]+$/),
+    label: z3.string().min(1).max(120),
+    prefix: z3.string().max(100),
+    help: z3.string().max(500)
+  }).strict()).max(12),
+  setup: z3.array(z3.string().max(1e3)).max(20),
+  notice: z3.string().max(1e3).nullable()
+}).strict().superRefine((template, context) => {
+  const oauth = template.auth === "oauth";
+  const headers = template.auth === "headers";
+  if (oauth !== (template.oauthClient !== null)) context.addIssue({ code: "custom", message: "OAuth templates must state a client type and other templates must not.", path: ["oauthClient"] });
+  if (headers !== template.fields.length > 0) context.addIssue({ code: "custom", message: "Header templates must declare input fields and other templates must not.", path: ["fields"] });
+});
 function inside2(path3) {
   if (typeof path3 !== "string" || !path3.trim()) return null;
   try {
@@ -4459,7 +4589,11 @@ function packageManifest(packageRoot) {
     description: typeof manifest.description === "string" ? manifest.description : "",
     version: typeof manifest.version === "string" ? manifest.version : null,
     extends: (Array.isArray(own.extends) ? own.extends : typeof own.extends === "string" ? [own.extends] : []).filter((id) => typeof id === "string" && !!id),
-    hooks: inside2(own.hooks)
+    hooks: inside2(own.hooks),
+    connectorTemplates: (Array.isArray(own.connectors) ? own.connectors : []).flatMap((value) => {
+      const parsed2 = connectorTemplateSchema.safeParse(value);
+      return parsed2.success ? [parsed2.data] : [];
+    })
   };
 }
 
@@ -4488,14 +4622,14 @@ var piResolver = async ({ cwd, agentDir, install: install3, packages }) => {
   const settings = pi.SettingsManager.create(cwd, agentDir);
   const shared = new Set((settings.getGlobalSettings().packages ?? []).map((entry) => typeof entry === "string" ? entry : entry.source));
   const manager2 = () => new pi.DefaultPackageManager({ cwd, agentDir, settingsManager: settings, builtinExtensions: [...PI_BUILTINS] });
-  const resolve8 = (installing) => manager2().resolve(async (source2) => installing && shared.has(source2) ? "install" : "skip");
+  const resolve9 = (installing) => manager2().resolve(async (source2) => installing && shared.has(source2) ? "install" : "skip");
   let resolved2;
   try {
-    resolved2 = install3 ? await withoutInstallScripts(() => resolve8(true)) : await resolve8(false);
+    resolved2 = install3 ? await withoutInstallScripts(() => resolve9(true)) : await resolve9(false);
   } catch (error) {
     if (!install3) throw error;
     log("a plugin package could not be installed", error instanceof Error ? error.message : String(error));
-    resolved2 = await resolve8(false);
+    resolved2 = await resolve9(false);
   }
   const found = [];
   const add = (paths) => {
@@ -4547,8 +4681,8 @@ var piResolver = async ({ cwd, agentDir, install: install3, packages }) => {
 
 // src/plugins/runtime.ts
 import { createHash as createHash2 } from "node:crypto";
-import { readFileSync as readFileSync12, readdirSync as readdirSync7, statSync as statSync3 } from "node:fs";
-import { dirname as dirname7, resolve as resolve3 } from "node:path";
+import { readFileSync as readFileSync12, readdirSync as readdirSync7, statSync as statSync4 } from "node:fs";
+import { dirname as dirname7, resolve as resolve4 } from "node:path";
 
 // src/plugins/identity.ts
 import { basename as basename5, dirname as dirname6 } from "node:path";
@@ -4566,10 +4700,10 @@ function describeFound(item) {
   const described = describeFile(item.path);
   return { name: described?.name ?? file, description: described?.description ?? "" };
 }
-var contributionId = (pluginId, kind, name) => `${pluginId}/${kind}/${name}`;
+var contributionId2 = (pluginId, kind, name) => `${pluginId}/${kind}/${name}`;
 function foundIds(item) {
   const pluginId = pluginIdOf(item);
-  return [contributionId(pluginId, FOUND_KINDS[item.kind], describeFound(item).name), pluginId];
+  return [contributionId2(pluginId, FOUND_KINDS[item.kind], describeFound(item).name), pluginId];
 }
 
 // src/plugins/runtime.ts
@@ -4620,21 +4754,21 @@ function observeResources(pi, loader, loading, records, publish) {
         collected.push(resource);
         return loading.resourceAllowed?.({ ...owner, kind, path: resourcePath }) !== false;
       };
-      const absolute = (entry) => resolve3(dirname7(path3), entry);
+      const absolute = (entry) => resolve4(dirname7(path3), entry);
       const skills2 = pi.loadSkills({ cwd: dirname7(path3), agentDir: dirname7(path3), includeDefaults: false, skillPaths: (result.skillPaths ?? []).map(absolute) }).skills;
       const scanner = new pi.DefaultResourceLoader({ cwd: dirname7(path3), agentDir: dirname7(path3), settingsManager: pi.SettingsManager.inMemory({}), noExtensions: true, noSkills: true, noThemes: true, noContextFiles: true, noPromptTemplates: true, additionalPromptTemplatePaths: (result.promptPaths ?? []).map(absolute) });
       await scanner.reload();
       const prompts = scanner.getPrompts().prompts;
       const themes = (result.themePaths ?? []).map(absolute).flatMap((theme) => {
         try {
-          if (statSync3(theme).isDirectory()) return readdirSync7(theme).filter((name) => {
+          if (statSync4(theme).isDirectory()) return readdirSync7(theme).filter((name) => {
             if (!name.endsWith(".json")) return false;
             try {
-              return statSync3(resolve3(theme, name)).isFile();
+              return statSync4(resolve4(theme, name)).isFile();
             } catch {
               return false;
             }
-          }).map((name) => resolve3(theme, name));
+          }).map((name) => resolve4(theme, name));
         } catch {
         }
         return [theme];
@@ -4800,8 +4934,9 @@ var Plugins = class {
       if (item.kind === "hook") return !attached(choices, [pluginIdOf(item)], {}, true);
       return !attached(choices, foundIds(item), input.caller ?? {}, true);
     };
-    const detached = found.filter(off).map((item) => item.path);
-    const chosen = found.filter((item) => loads(item, trusted) && !detached.includes(item.path));
+    const allowed2 = (item) => input.contributions === void 0 ? !off(item) : input.contributions.includes(foundIds(item)[0]);
+    const detached = found.filter((item) => !allowed2(item)).map((item) => item.path);
+    const chosen = found.filter((item) => loads(item, trusted) && allowed2(item));
     const paths = (kind, builtin) => chosen.filter((item) => item.kind === kind && item.origin === "builtin" === builtin).map((item) => item.path);
     return {
       extensionPaths: paths("extension", false),
@@ -4812,7 +4947,7 @@ var Plugins = class {
       hooks: chosen.filter((item) => item.kind === "hook" && item.packageRoot).map((item) => ({ path: item.path, packageRoot: item.packageRoot, hash: packageCodeState[item.packageRoot]?.hash ?? "" })),
       found,
       detached,
-      resourceAllowed: (item) => !off(item),
+      resourceAllowed: allowed2,
       projectCode: projectCodeState,
       packageCode: packageCodeState
     };
@@ -4842,7 +4977,7 @@ var Plugins = class {
 // src/plugins/catalogue.ts
 var REGISTRY_KINDS = { rules: "instruction", skills: "skill", prompts: "command" };
 var contribution = (plugin, kind, name, rest = {}) => ({
-  id: contributionId(plugin, kind, name),
+  id: contributionId2(plugin, kind, name),
   kind,
   name,
   description: "",
@@ -4873,6 +5008,7 @@ function fromDescriptor(descriptor, source2, attachments = null, caller = {}) {
     required: descriptor.required ?? null,
     manage: descriptor.manage ?? (descriptor.tools?.length ? "tools" : null),
     settings: (descriptor.settings ?? []).map((setting) => ({ ...setting, value: settingValue(setting, attachments?.settings[descriptor.id]) })),
+    connectorTemplates: descriptor.connectorTemplates ?? [],
     attachment: switchable2 ? describe(attachments, descriptor.id, switchable2.on) : null,
     contributions: [
       ...(descriptor.code ?? []).map((code) => contribution(descriptor.id, "code", code.name, { description: code.description, state: on ? "on" : "off" })),
@@ -4934,7 +5070,7 @@ function registeredLine(entry) {
 function foundContribution(plugin, item, trusted, input, projects) {
   const kind = FOUND_KINDS[item.kind];
   const { name, description } = describeFound(item);
-  const id = contributionId(plugin, kind, name);
+  const id = contributionId2(plugin, kind, name);
   const attachment = switchable(item) && item.kind !== "hook" ? describe(input.attachments, id, attached(input.attachments, [plugin], {}, true)) : null;
   const on = item.kind === "hook" ? attached(input.attachments, [plugin], {}, true) : !attachment || attached(input.attachments, [id, plugin], input.caller, true);
   const state2 = !item.enabled || !on ? "off" : loads(item, trusted) ? "on" : "untrusted";
@@ -4955,7 +5091,7 @@ function foundContribution(plugin, item, trusted, input, projects) {
   if (item.kind === "context") return contribution(plugin, kind, name, { ...rest, description: CONTEXT_NOTES[basename7(item.path)] ?? "Read by Pi at the start of every session in this folder.", path: item.path });
   return contribution(plugin, kind, name, { ...rest, description: description ?? "", path: item.path });
 }
-var empty = (id, title, description, source2, path3) => ({ id, title, description, version: null, source: source2, path: path3, runsCode: false, trust: "none", code: null, install: null, extends: [], required: null, manage: "files", settings: [], attachment: null, contributions: [] });
+var empty = (id, title, description, source2, path3) => ({ id, title, description, version: null, source: source2, path: path3, runsCode: false, trust: "none", code: null, install: null, extends: [], required: null, manage: "files", settings: [], connectorTemplates: [], attachment: null, contributions: [] });
 function catalogue(input) {
   const plugins = /* @__PURE__ */ new Map();
   for (const descriptor of input.descriptors) plugins.set(descriptor.id, fromDescriptor(descriptor, descriptor.id === "pi" ? "pi" : descriptor.id === YOURS_PLUGIN.id ? "yours" : input.application.has(descriptor.id) ? "application" : "builtin", input.attachments, input.caller));
@@ -4986,7 +5122,7 @@ function catalogue(input) {
         const manifest = packageManifest(item.packageRoot);
         const install3 = item.project ? null : item.packageRoot.startsWith(`${input.packagesDir}/`) ? { kind: "folder", source: item.packageRoot } : item.source ? { kind: "settings", source: item.source } : null;
         const extended = manifest.extends.filter((part) => input.descriptors.some((descriptor) => descriptor.id === part));
-        plugin = { ...empty(id, manifest.name, manifest.description, item.project ? "project" : "package", item.packageRoot), version: manifest.version, install: install3, extends: extended };
+        plugin = { ...empty(id, manifest.name, manifest.description, item.project ? "project" : "package", item.packageRoot), version: manifest.version, install: install3, extends: extended, connectorTemplates: manifest.connectorTemplates };
       } else if (item.origin === "home") plugin = empty(id, "Home folder skills", "Skills in the .agents folder of your home folder. Pi reads them for every account.", "home", dirname9(dirname9(item.path)));
       else if (item.origin === "project") plugin = empty(id, "Project folder", "Found in the working folder: its .pi and .agents folders, and the instruction files Pi reads on the way up from it.", "project", input.cwd);
       else plugin = empty(id, "Shared Pi folder", "Extensions, skills, prompts and instruction files in the folder every account shares.", "shared", input.sharedDir);
@@ -4999,13 +5135,13 @@ function catalogue(input) {
     if (item.kind === "extension" && added.registered) {
       const registered = added.registered;
       const append = (kind, name, rest = {}) => {
-        const id2 = contributionId(plugin.id, kind, name);
+        const id2 = contributionId2(plugin.id, kind, name);
         if (!plugin.contributions.some((existing) => existing.id === id2)) plugin.contributions.push(contribution(plugin.id, kind, name, { state: added.state, description: `Registered by ${added.name}. Observed ${registered.seenAt ?? "in a session"}.`, ...rest }));
       };
       for (const name of registered.tools) append("tool", name);
       for (const name of registered.commands) append("command", name);
       for (const resource of registered.resources ?? []) {
-        const id2 = contributionId(plugin.id, resource.kind, resource.name);
+        const id2 = contributionId2(plugin.id, resource.kind, resource.name);
         const on = attached(input.attachments, [id2, plugin.id], input.caller, true);
         append(resource.kind, resource.name, { path: resource.path, state: on ? added.state : "off", attachment: describe(input.attachments, id2, attached(input.attachments, [plugin.id], {}, true)) });
       }
@@ -5024,15 +5160,15 @@ function catalogue(input) {
 }
 
 // src/plugins/inventory.ts
-import { readFileSync as readFileSync14 } from "node:fs";
+import { readFileSync as readFileSync15 } from "node:fs";
 
 // src/mcp/connections.ts
-import { chmodSync as chmodSync6 } from "node:fs";
-import { isAbsolute as isAbsolute3, join as join26 } from "node:path";
+import { chmodSync as chmodSync7 } from "node:fs";
+import { isAbsolute as isAbsolute3, join as join27 } from "node:path";
 
 // src/core/path.ts
 import { execFileSync } from "node:child_process";
-import { accessSync, constants, statSync as statSync4 } from "node:fs";
+import { accessSync, constants, statSync as statSync5 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { delimiter, isAbsolute as isAbsolute2, join as join25 } from "node:path";
 var resolved = null;
@@ -5054,7 +5190,7 @@ function searchPath() {
 function isExecutable(path3) {
   try {
     accessSync(path3, constants.X_OK);
-    return statSync4(path3).isFile();
+    return statSync5(path3).isFile();
   } catch {
     return false;
   }
@@ -5068,51 +5204,212 @@ function findBinary(name) {
   return null;
 }
 
+// src/mcp/scopeMigration.ts
+import { chmodSync as chmodSync6, existsSync as existsSync10, readFileSync as readFileSync14, unlinkSync as unlinkSync3 } from "node:fs";
+import { join as join26 } from "node:path";
+
 // src/mcp/types.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var MCP_OAUTH_PORT = 47823;
 var MCP_OAUTH_REDIRECT_URL = `http://127.0.0.1:${MCP_OAUTH_PORT}/oauth/callback`;
-var connectionSchema = z3.object({
-  id: z3.string().default(""),
-  name: z3.string().default(""),
+var connectionCapabilityId = (id) => `connected-apps/connection/${id}`;
+var connectionSchema = z4.object({
+  id: z4.string().default(""),
+  name: z4.string().default(""),
   /** `workspace` (the first-party Xingular Workspace server), `local` (a command), or `remote` (Streamable HTTP). */
-  kind: z3.string().default(""),
-  command: z3.string().default(""),
-  args: z3.array(z3.string()).default([]),
-  cwd: z3.string().nullable().default(null),
-  envKeys: z3.array(z3.string()).default([]),
-  enabled: z3.boolean().default(false),
+  kind: z4.string().default(""),
+  command: z4.string().default(""),
+  args: z4.array(z4.string()).default([]),
+  cwd: z4.string().nullable().default(null),
+  envKeys: z4.array(z4.string()).default([]),
+  enabled: z4.boolean().default(false),
   /** Available to every agent and project, except those excluded. */
-  global: z3.boolean().default(false),
-  agentIds: z3.array(z3.string()).default([]),
-  projectIds: z3.array(z3.string()).default([]),
-  excludedAgentIds: z3.array(z3.string()).default([]),
-  excludedProjectIds: z3.array(z3.string()).default([]),
+  global: z4.boolean().default(false),
+  agentIds: z4.array(z4.string()).default([]),
+  projectIds: z4.array(z4.string()).default([]),
+  excludedAgentIds: z4.array(z4.string()).default([]),
+  excludedProjectIds: z4.array(z4.string()).default([]),
   /** Tools that run without asking. */
-  readTools: z3.array(z3.string()).default([]),
-  expectedVaultId: z3.string().nullable().default(null),
-  checkedAt: z3.string().nullable().default(null),
-  serverName: z3.string().nullable().default(null),
-  tools: z3.array(z3.unknown()).default([]),
-  error: z3.string().nullable().default(null),
-  url: z3.string().nullable().default(null),
+  readTools: z4.array(z4.string()).default([]),
+  expectedVaultId: z4.string().nullable().default(null),
+  checkedAt: z4.string().nullable().default(null),
+  serverName: z4.string().nullable().default(null),
+  tools: z4.array(z4.unknown()).default([]),
+  error: z4.string().nullable().default(null),
+  url: z4.string().nullable().default(null),
   /** `none`, `headers`, or `oauth`. */
-  auth: z3.string().default(""),
-  headerKeys: z3.array(z3.string()).default([]),
-  oauthClient: z3.string().nullable().default(null),
-  oauthScopes: z3.array(z3.string()).default([]),
-  authState: z3.string().nullable().default(null),
-  catalogId: z3.string().nullable().default(null)
+  auth: z4.string().default(""),
+  headerKeys: z4.array(z4.string()).default([]),
+  oauthClient: z4.string().nullable().default(null),
+  oauthScopes: z4.array(z4.string()).default([]),
+  authState: z4.string().nullable().default(null),
+  catalogId: z4.string().nullable().default(null)
 });
 var connectionInputSchema = connectionSchema.extend({
-  env: z3.record(z3.string(), z3.string()).nullish(),
-  removeEnv: z3.array(z3.string()).nullish(),
-  headers: z3.record(z3.string(), z3.string()).nullish(),
-  removeHeaders: z3.array(z3.string()).nullish(),
+  env: z4.record(z4.string(), z4.string()).nullish(),
+  removeEnv: z4.array(z4.string()).nullish(),
+  headers: z4.record(z4.string(), z4.string()).nullish(),
+  removeHeaders: z4.array(z4.string()).nullish(),
   /** A client registered by the user with the provider; replaces any saved sign-in. */
-  oauthCredentials: z3.object({ clientId: z3.string(), clientSecret: z3.string() }).nullish()
+  oauthCredentials: z4.object({ clientId: z4.string(), clientSecret: z4.string() }).nullish()
 });
 
+// src/mcp/scopeMigration.ts
+var recordPath2 = (root) => join26(root, "config/capability-scope-migration.json");
+var attachmentsPath = (root) => join26(root, "config/plugin-attachments.json");
+var connectionPath = (stateDir) => join26(stateDir, "connections.json");
+var connectionsBackupPath = (stateDir) => join26(stateDir, "connections.pre-capability-scope.json");
+var attachmentsBackupPath = (root) => join26(root, "config/plugin-attachments.pre-capability-scope.json");
+function connectionScopeMigrationComplete(root) {
+  try {
+    const marker = readJson(recordPath2(root));
+    return marker?.version === 1 && marker.status === "complete";
+  } catch {
+    return false;
+  }
+}
+function unique(values2) {
+  return [...new Set(values2)];
+}
+function scopeRows(connection) {
+  const agents = /* @__PURE__ */ new Map();
+  const projects = /* @__PURE__ */ new Map();
+  for (const id of unique([...connection.agentIds, ...connection.excludedAgentIds])) {
+    agents.set(id, !connection.excludedAgentIds.includes(id));
+  }
+  for (const id of unique([...connection.projectIds, ...connection.excludedProjectIds])) {
+    projects.set(id, !connection.excludedProjectIds.includes(id));
+  }
+  return { global: connection.global, agents, projects };
+}
+function assignmentCount(rows) {
+  return 1 + rows.agents.size + rows.projects.size;
+}
+function removeId(choices, id) {
+  forgetId(choices, id);
+}
+function put(map, id, value) {
+  map.on = map.on.filter((item) => item !== id);
+  map.off = map.off.filter((item) => item !== id);
+  map[value ? "on" : "off"].push(id);
+}
+function writeRows(choices, id, rows) {
+  removeId(choices, id);
+  put(choices.global, id, rows.global);
+  for (const [scopeId, on] of rows.agents) {
+    const target = choices.agents[scopeId] ??= { on: [], off: [] };
+    put(target, id, on);
+  }
+  for (const [scopeId, on] of rows.projects) {
+    const target = choices.projects[scopeId] ??= { on: [], off: [] };
+    put(target, id, on);
+  }
+}
+function readValue(item, id) {
+  if (item?.off.includes(id)) return false;
+  if (item?.on.includes(id)) return true;
+  return null;
+}
+function verifyRows(choices, id, expected) {
+  if (readValue(choices.global, id) !== expected.global) return false;
+  for (const [scopeId, on] of expected.agents) {
+    if (readValue(choices.agents[scopeId], id) !== on) return false;
+  }
+  for (const [scopeId, on] of expected.projects) {
+    if (readValue(choices.projects[scopeId], id) !== on) return false;
+  }
+  return true;
+}
+function backup(source2, target) {
+  if (!existsSync10(source2)) return false;
+  if (!existsSync10(target)) atomicWrite(target, readFileSync14(source2));
+  chmodSync6(target, 384);
+  return true;
+}
+function setPrivate(path3) {
+  try {
+    chmodSync6(path3, 384);
+  } catch {
+  }
+}
+function stripScopes(stateDir) {
+  const path3 = connectionPath(stateDir);
+  if (!existsSync10(path3)) return;
+  const stored = readJson(path3);
+  if (!Array.isArray(stored)) throw new Error("Stored connector data must be a list before its scopes can be migrated.");
+  const records = stored.map((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) throw new Error("A stored connector record is invalid; no scope data was removed.");
+    const { global: _global, agentIds: _agentIds, projectIds: _projectIds, excludedAgentIds: _excludedAgentIds, excludedProjectIds: _excludedProjectIds, ...connection } = item;
+    return connection;
+  });
+  writeJson(path3, records);
+  setPrivate(path3);
+}
+function migrateConnectionScopes(root, stateDir) {
+  const marker = readJson(recordPath2(root));
+  if (marker?.version === 1 && marker.status === "complete") return marker;
+  if (marker?.version === 1 && marker.status === "attachments-written") {
+    stripScopes(stateDir);
+    const complete = { ...marker, status: "complete" };
+    writeJson(recordPath2(root), complete);
+    return complete;
+  }
+  const connectionsFile = connectionPath(stateDir);
+  const hadConnections = existsSync10(connectionsFile);
+  const raw = hadConnections ? readJson(connectionsFile) : [];
+  if (!Array.isArray(raw)) throw new Error("Stored connector data must be a list before its scopes can be migrated.");
+  const parsed2 = raw.map((item) => {
+    const result = connectionSchema.safeParse(item);
+    if (!result.success) throw new Error("A stored connector record is invalid; no scope data was removed.");
+    return result.data;
+  });
+  const connectionBackup = hadConnections ? connectionsBackupPath(stateDir) : null;
+  const hadAttachments = existsSync10(attachmentsPath(root));
+  const attachmentBackup = hadAttachments ? attachmentsBackupPath(root) : null;
+  const migration = {
+    version: 1,
+    status: "attachments-written",
+    connectionCount: parsed2.length,
+    scopeAssignmentCount: parsed2.reduce((count, connection) => count + assignmentCount(scopeRows(connection)), 0),
+    connectionsBackup: connectionBackup,
+    attachmentsBackup: attachmentBackup,
+    hadAttachments
+  };
+  backup(connectionsFile, connectionBackup ?? "");
+  backup(attachmentsPath(root), attachmentBackup ?? "");
+  try {
+    const choices = load2(root);
+    const expected = /* @__PURE__ */ new Map();
+    for (const connection of parsed2) {
+      const id = connectionCapabilityId(connection.id);
+      const rows = scopeRows(connection);
+      expected.set(id, rows);
+      writeRows(choices, id, rows);
+    }
+    const migratedAssignments = [...expected.values()].reduce((count, rows) => count + assignmentCount(rows), 0);
+    if (migratedAssignments !== migration.scopeAssignmentCount || [...expected].some(([id, rows]) => !verifyRows(choices, id, rows))) {
+      throw new Error("Connector scope count check failed; the original files were restored.");
+    }
+    save(root, choices);
+    const saved = load2(root);
+    if ([...expected].some(([id, rows]) => !verifyRows(saved, id, rows))) throw new Error("Connector scope count check failed after saving; the original files were restored.");
+    writeJson(recordPath2(root), migration);
+    stripScopes(stateDir);
+    const complete = { ...migration, status: "complete" };
+    writeJson(recordPath2(root), complete);
+    return complete;
+  } catch (error) {
+    if (attachmentBackup && existsSync10(attachmentBackup)) atomicWrite(attachmentsPath(root), readFileSync14(attachmentBackup));
+    else if (!hadAttachments && existsSync10(attachmentsPath(root))) unlinkSync3(attachmentsPath(root));
+    if (connectionBackup && existsSync10(connectionBackup)) atomicWrite(connectionsFile, readFileSync14(connectionBackup));
+    try {
+      unlinkSync3(recordPath2(root));
+    } catch {
+    }
+    throw error;
+  }
+}
+
 // src/mcp/connections.ts
 var OAUTH_STATE = "oauth";
 var OAUTH_CLIENT_ID = "oauth_client_id";
@@ -5133,6 +5430,17 @@ function allowed(connection, scope) {
   if (scope.projectId && connection.excludedProjectIds.includes(scope.projectId)) return false;
   return connection.global || Boolean(scope.agentId && connection.agentIds.includes(scope.agentId)) || Boolean(scope.projectId && connection.projectIds.includes(scope.projectId));
 }
+function setAgentScope(all2, agentId, ids) {
+  for (const connection of all2) {
+    connection.agentIds = connection.agentIds.filter((id) => id !== agentId);
+    connection.excludedAgentIds = connection.excludedAgentIds.filter((id) => id !== agentId);
+    if (ids.includes(connection.id)) {
+      if (!connection.global) connection.agentIds.push(agentId);
+    } else if (connection.global) {
+      connection.excludedAgentIds.push(agentId);
+    }
+  }
+}
 function setScope(connection, scope, on) {
   const without = (ids, id) => ids.filter((item) => item !== id);
   if (scope.agentId) {
@@ -5203,23 +5511,48 @@ function scrubWith(value, secrets) {
 function revisionOf(all2) {
   return all2.map((item) => ({ id: item.id, enabled: item.enabled, global: item.global, agents: item.agentIds, projects: item.projectIds, excludedAgents: item.excludedAgentIds, excludedProjects: item.excludedProjectIds, checkedAt: item.checkedAt, error: item.error }));
 }
+function sameScope(left, right) {
+  const ids = (values2) => [...values2].sort();
+  return left.global === right.global && JSON.stringify(ids(left.agentIds)) === JSON.stringify(ids(right.agentIds)) && JSON.stringify(ids(left.projectIds)) === JSON.stringify(ids(right.projectIds)) && JSON.stringify(ids(left.excludedAgentIds)) === JSON.stringify(ids(right.excludedAgentIds)) && JSON.stringify(ids(left.excludedProjectIds)) === JSON.stringify(ids(right.excludedProjectIds));
+}
+function hasScope(connection) {
+  return connection.global || connection.agentIds.length > 0 || connection.projectIds.length > 0 || connection.excludedAgentIds.length > 0 || connection.excludedProjectIds.length > 0;
+}
+function scopeMigrationError() {
+  return new HarnessError("connection_scope_migration_pending", "Connector access settings cannot be changed until their scope migration succeeds. Reopen the data root to retry it.");
+}
 var Connections = class {
-  constructor(stateDir, secrets, bus) {
+  constructor(stateDir, secrets, bus, attachmentRoot = () => null) {
     this.secrets = secrets;
     this.bus = bus;
-    this.path = join26(stateDir, "connections.json");
+    this.attachmentRoot = attachmentRoot;
+    this.path = join27(stateDir, "connections.json");
   }
   path;
   /** Every secret value a connection holds, so results can be redacted without waiting on the store. */
   known = /* @__PURE__ */ new Map();
   list() {
     const stored = readJson(this.path) ?? [];
+    const root = this.attachmentRoot();
+    const choices = root ? load2(root) : null;
     return stored.flatMap((item) => {
       const parsed2 = connectionSchema.safeParse(item);
       if (!parsed2.success) return [];
       const connection = parsed2.data;
       if (!connection.auth) connection.auth = "none";
       if (connection.kind === "workspace" && connection.name === "X Workspace") connection.name = "Xingular Workspace";
+      if (choices) {
+        const id = connectionCapabilityId(connection.id);
+        const hasChoice = choices.global.on.includes(id) || choices.global.off.includes(id) || Object.values(choices.agents).some((entry) => entry.on.includes(id) || entry.off.includes(id)) || Object.values(choices.projects).some((entry) => entry.on.includes(id) || entry.off.includes(id));
+        if (hasChoice || !(connection.global || connection.agentIds.length || connection.projectIds.length || connection.excludedAgentIds.length || connection.excludedProjectIds.length)) {
+          const attachment = describe(choices, id, connection.global);
+          connection.global = attachment.global;
+          connection.agentIds = attachment.on.agentIds;
+          connection.projectIds = attachment.on.projectIds;
+          connection.excludedAgentIds = attachment.off.agentIds;
+          connection.excludedProjectIds = attachment.off.projectIds;
+        }
+      }
       return [connection];
     });
   }
@@ -5235,12 +5568,49 @@ var Connections = class {
     return revisionOf(this.list());
   }
   write(all2) {
-    writeJson(this.path, all2);
+    const root = this.attachmentRoot();
+    let stored = all2;
+    if (root && connectionScopeMigrationComplete(root)) {
+      stored = all2.map(({ global: _global, agentIds: _agentIds, projectIds: _projectIds, excludedAgentIds: _excludedAgentIds, excludedProjectIds: _excludedProjectIds, ...connection }) => connection);
+    } else if (root) {
+      const previous = /* @__PURE__ */ new Map();
+      for (const item of readJson(this.path) ?? []) {
+        const parsed2 = connectionSchema.safeParse(item);
+        if (parsed2.success) previous.set(parsed2.data.id, parsed2.data);
+      }
+      stored = all2.map((connection) => {
+        const legacy = previous.get(connection.id);
+        return legacy ? {
+          ...connection,
+          global: legacy.global,
+          agentIds: legacy.agentIds,
+          projectIds: legacy.projectIds,
+          excludedAgentIds: legacy.excludedAgentIds,
+          excludedProjectIds: legacy.excludedProjectIds
+        } : connection;
+      });
+    }
+    writeJson(this.path, stored);
     try {
-      chmodSync6(this.path, 384);
+      chmodSync7(this.path, 384);
     } catch {
     }
   }
+  writeScope(root, connection) {
+    const choices = load2(root);
+    const id = connectionCapabilityId(connection.id);
+    forgetId(choices, id);
+    set(choices, [id], {}, connection.global, false);
+    for (const agentId of /* @__PURE__ */ new Set([...connection.agentIds, ...connection.excludedAgentIds])) {
+      const on = connection.agentIds.includes(agentId) && !connection.excludedAgentIds.includes(agentId);
+      set(choices, [id], { agentId }, on, connection.global);
+    }
+    for (const projectId of /* @__PURE__ */ new Set([...connection.projectIds, ...connection.excludedProjectIds])) {
+      const on = connection.projectIds.includes(projectId) && !connection.excludedProjectIds.includes(projectId);
+      set(choices, [id], { projectId }, on, connection.global);
+    }
+    save(root, choices);
+  }
   changed() {
     this.bus.emit({ type: "connections.changed" });
   }
@@ -5249,17 +5619,95 @@ var Connections = class {
     const all2 = this.list();
     const connection = all2.find((item) => item.id === id);
     if (!connection) throw notFound("Connection");
+    const before = { ...connection, agentIds: [...connection.agentIds], projectIds: [...connection.projectIds], excludedAgentIds: [...connection.excludedAgentIds], excludedProjectIds: [...connection.excludedProjectIds] };
     change(connection);
+    const root = this.attachmentRoot();
+    if (root && !connectionScopeMigrationComplete(root) && !sameScope(before, connection)) throw scopeMigrationError();
     this.write(all2);
     return connection;
   }
   /** Read-modify-write of every connection. */
   updateAll(change) {
     const all2 = this.list();
+    const before = new Map(all2.map((connection) => [connection.id, {
+      ...connection,
+      agentIds: [...connection.agentIds],
+      projectIds: [...connection.projectIds],
+      excludedAgentIds: [...connection.excludedAgentIds],
+      excludedProjectIds: [...connection.excludedProjectIds]
+    }]));
     change(all2);
+    const root = this.attachmentRoot();
+    if (root && !connectionScopeMigrationComplete(root)) {
+      const remainingIds = new Set(all2.map((connection) => connection.id));
+      const scopeChanged = all2.some((connection) => {
+        const previous = before.get(connection.id);
+        return previous ? !sameScope(previous, connection) : hasScope(connection);
+      }) || [...before].some(([id, connection]) => !remainingIds.has(id) && hasScope(connection));
+      if (scopeChanged) throw scopeMigrationError();
+    }
     this.write(all2);
     this.changed();
   }
+  /** Switches one connector in the shared attachment store, preserving all other scopes. */
+  setScope(connectionId, scope, on) {
+    const connection = this.find(connectionId);
+    const root = this.attachmentRoot();
+    if (root && !connectionScopeMigrationComplete(root)) throw scopeMigrationError();
+    if (!root) {
+      this.update(connectionId, (item) => setScope(item, scope, on));
+      this.changed();
+      return this.forScope(scope);
+    }
+    const choices = load2(root);
+    const fallback = connection.global;
+    set(choices, [connectionCapabilityId(connectionId)], scope, on, fallback);
+    save(root, choices);
+    this.changed();
+    return this.forScope(scope);
+  }
+  /** Gives one agent an exact connector set without changing project or global choices. */
+  setAgentScope(agentId, ids) {
+    const all2 = this.list();
+    const root = this.attachmentRoot();
+    if (root && !connectionScopeMigrationComplete(root)) throw scopeMigrationError();
+    if (!root) {
+      setAgentScope(all2, agentId, ids);
+      this.write(all2);
+      this.changed();
+      return this.forScope({ agentId });
+    }
+    const choices = load2(root);
+    for (const connection of all2) {
+      set(choices, [connectionCapabilityId(connection.id)], { agentId }, ids.includes(connection.id), connection.global);
+    }
+    save(root, choices);
+    this.changed();
+    return this.forScope({ agentId });
+  }
+  /** Removes only connector choices when an agent is deleted; other capability choices are separate. */
+  removeAgentScope(agentId) {
+    const root = this.attachmentRoot();
+    if (root && !connectionScopeMigrationComplete(root)) return;
+    if (!root) {
+      this.updateAll((all2) => {
+        for (const connection of all2) {
+          connection.agentIds = connection.agentIds.filter((id) => id !== agentId);
+          connection.excludedAgentIds = connection.excludedAgentIds.filter((id) => id !== agentId);
+        }
+      });
+      return;
+    }
+    const choices = load2(root);
+    const entry = choices.agents[agentId];
+    if (!entry) return;
+    const isConnector = (id) => id.startsWith("connected-apps/connection/");
+    entry.on = entry.on.filter((id) => !isConnector(id));
+    entry.off = entry.off.filter((id) => !isConnector(id));
+    if (!entry.on.length && !entry.off.length) delete choices.agents[agentId];
+    save(root, choices);
+    this.changed();
+  }
   secret(connectionId, name) {
     return this.secrets.get(secretKey(`mcp--${connectionId}`, name));
   }
@@ -5387,6 +5835,10 @@ var Connections = class {
     if (connection.cwd && (!isAbsolute3(connection.cwd) || !isDir(connection.cwd))) throw invalid("Working directory must be an existing absolute directory.");
     const all2 = this.list();
     const existing = all2.find((item) => item.id === connection.id);
+    const root = this.attachmentRoot();
+    if (root && !connectionScopeMigrationComplete(root) && (existing ? !sameScope(existing, connection) : hasScope(connection))) {
+      throw scopeMigrationError();
+    }
     connection.envKeys = [...existing?.envKeys ?? []];
     connection.headerKeys = [...existing?.headerKeys ?? []];
     const sameServer = (existing?.url ?? null) === connection.url && (existing?.auth ?? "") === connection.auth && !oauthCredentials;
@@ -5417,6 +5869,7 @@ var Connections = class {
       connection.envKeys = connection.envKeys.filter((value) => value !== key);
     }
     Object.assign(connection, { checkedAt: null, tools: [], serverName: null, error: null });
+    if (root && connectionScopeMigrationComplete(root)) this.writeScope(root, connection);
     this.write([...all2.filter((item) => item.id !== connection.id), connection]);
     await this.refreshSecrets();
     this.changed();
@@ -5444,6 +5897,12 @@ var Connections = class {
       for (const name of [OAUTH_STATE, OAUTH_CLIENT_ID, OAUTH_CLIENT_SECRET]) await this.deleteSecret(connection.id, name);
     }
     this.write(all2.filter((item) => item.id !== connectionId));
+    const root = this.attachmentRoot();
+    if (root) {
+      const choices = load2(root);
+      forgetId(choices, connectionCapabilityId(connectionId));
+      save(root, choices);
+    }
     this.known.delete(connectionId);
     this.changed();
   }
@@ -5463,7 +5922,7 @@ var Connections = class {
 var size = (path3) => {
   if (!path3) return null;
   try {
-    return charCount(readFileSync14(path3, "utf8"));
+    return charCount(readFileSync15(path3, "utf8"));
   } catch {
     return null;
   }
@@ -5563,7 +6022,7 @@ async function list2(harness, scope = {}) {
     loading: await loadingFor(harness, scope),
     cwd: scope.cwd || null,
     sharedDir: sharedDir(harness.accounts.dir),
-    packagesDir: join27(harness.env.root, "plugins"),
+    packagesDir: join28(harness.env.root, "plugins"),
     registered: harness.plugins.registered(),
     hooks: harness.hooks.status(),
     attachments: load2(harness.env.root),
@@ -5650,7 +6109,7 @@ function forgetAgent(harness, agentId) {
 }
 
 // src/capabilities/api.ts
-var unique = (values2) => [...new Set(values2.filter((value) => value.length > 0))];
+var unique2 = (values2) => [...new Set(values2.filter((value) => value.length > 0))];
 function contributions(plugins) {
   return plugins.flatMap((plugin) => plugin.contributions.map((item) => ({
     id: item.id,
@@ -5667,17 +6126,26 @@ async function list3(harness, params = {}) {
   const plugins = await list2(harness, params);
   return { plugins, capabilities: contributions(plugins) };
 }
-async function resolve4(harness, params) {
+async function resolve5(harness, params) {
   const caller = { agentId: params.agentId ?? null, projectId: params.projectId ?? null };
   const catalogue2 = await list3(harness, params);
   const connectors = harness.apps.connections.forScope(caller).map((connection) => connection.id);
   return {
     version: 1,
-    tools: unique(params.tools ?? []),
-    connectors: unique(connectors),
+    tools: unique2(params.tools ?? []),
+    connectors: unique2(connectors),
     contributions: catalogue2.capabilities.filter((item) => item.state === "on").map((item) => item.id)
   };
 }
+function toolIntersection(parent, assignee, taskTools) {
+  const permitted = taskTools === void 0 ? null : new Set(taskTools);
+  return {
+    version: 1,
+    tools: parent.tools.filter((tool) => assignee.tools.includes(tool) && (!permitted || permitted.has(tool))),
+    connectors: parent.connectors.filter((id) => assignee.connectors.includes(id)),
+    contributions: parent.contributions.filter((id) => assignee.contributions.includes(id))
+  };
+}
 function inventory2(harness, params = {}) {
   return inventoryFor(harness, params);
 }
@@ -5692,7 +6160,7 @@ async function switchCapability(harness, params, on) {
 
 // src/mcp/service.ts
 import { createHash as createHash4, randomUUID as randomUUID5 } from "node:crypto";
-import { join as join28 } from "node:path";
+import { join as join29 } from "node:path";
 
 // src/mcp/manager.ts
 import { Client, SSEClientTransport, StreamableHTTPClientTransport, UnauthorizedError as UnauthorizedError2 } from "@modelcontextprotocol/client";
@@ -5781,8 +6249,8 @@ var cancelActive = null;
 function listenForCallback(expectedState, clientName) {
   return new Promise((ready, failed) => {
     let settle;
-    const result = new Promise((resolve8, reject) => {
-      settle = { resolve: resolve8, reject };
+    const result = new Promise((resolve9, reject) => {
+      settle = { resolve: resolve9, reject };
     });
     result.catch(() => void 0);
     const server = createServer((request2, response3) => {
@@ -5806,7 +6274,7 @@ function listenForCallback(expectedState, clientName) {
       clearTimeout(timer);
       failed(new HarnessError("invalid_request", error.code === "EADDRINUSE" ? `Port ${MCP_OAUTH_PORT} is in use. Finish or cancel the other sign-in, or quit the program using that port, then try again.` : "The sign-in listener could not start."));
     });
-    const closed = new Promise((resolve8) => server.once("close", resolve8));
+    const closed = new Promise((resolve9) => server.once("close", resolve9));
     const close = () => {
       clearTimeout(timer);
       if (cancelActive === cancel) cancelActive = null;
@@ -5991,7 +6459,7 @@ var UNATTENDED_SCOPE = "plugin-hooks";
 var ConnectedApps = class {
   constructor(options2) {
     this.options = options2;
-    this.connections = new Connections(options2.stateDir, options2.secrets, options2.bus);
+    this.connections = new Connections(options2.stateDir, options2.secrets, options2.bus, () => options2.env.dataRoot);
     this.oauth = {
       clientName: options2.env.productName,
       load: (id) => this.connections.oauthLoad(id),
@@ -6086,7 +6554,7 @@ var ConnectedApps = class {
           return { tools: tools3, errors: [] };
         } catch (error) {
           const unauthorized = isSignInRequired(error);
-          const message = unauthorized ? signInRequired(connection).message : `${connection.name} could not load its tools. Check the connection in Settings \u2192 Connections.`;
+          const message = unauthorized ? signInRequired(connection).message : `${connection.name} could not load its tools. Check its scope in Capability \u2192 Connectors.`;
           if (unauthorized) await this.manager.close(connection.id, session.sessionId);
           this.connectionFailed(connection.id, unauthorized);
           return { tools: [], errors: [{ connection: connection.name, message }] };
@@ -6206,7 +6674,7 @@ ${action}`, standing: "switch", timeoutMs: 3e5 });
     }).slice(0, 100);
     const trace = { id: toolCallId, connectionId: connection.id, connectionName: connection.name, tool, at: now(), ok, summary: tool, result: takeChars(raw, 24e3), sources, truncated: charCount(raw) > 24e3 || structured?.truncated === true };
     try {
-      const file = join28(runDir(this.options.env.root, runId), "mcp-context.json");
+      const file = join29(runDir(this.options.env.root, runId), "mcp-context.json");
       writeJson(file, [...readJson(file) ?? [], trace]);
     } catch {
     }
@@ -6214,7 +6682,7 @@ ${action}`, standing: "switch", timeoutMs: 3e5 });
   }
   /** What a run retrieved from connected apps, in order. */
   runContext(runId) {
-    return readJson(join28(runDir(this.options.env.root, runId), "mcp-context.json")) ?? [];
+    return readJson(join29(runDir(this.options.env.root, runId), "mcp-context.json")) ?? [];
   }
   /** Changes whenever what a session can discover may have changed. */
   async revision(session) {
@@ -6230,8 +6698,8 @@ ${action}`, standing: "switch", timeoutMs: 3e5 });
     return [
       {
         name: "mcp_list_tools",
-        label: "App and connected tools",
-        description: `Discover enabled ${this.options.env.productName} app operations and connected-app tools by name. Pass tool to get one tool with its input schema.${this.brokered?.discoveryNote ? ` ${this.brokered.discoveryNote}` : ""}`,
+        label: "App and connector tools",
+        description: `Discover enabled ${this.options.env.productName} app operations and connector tools by name. Pass tool to get one tool with its input schema.${this.brokered?.discoveryNote ? ` ${this.brokered.discoveryNote}` : ""}`,
         parameters: (Type) => Type.Object({
           tool: Type.Optional(Type.String({ description: "One tool name, to get its input schema." })),
           query: Type.Optional(Type.String({ description: "Only tools whose name or description contains this text." })),
@@ -6247,8 +6715,8 @@ ${action}`, standing: "switch", timeoutMs: 3e5 });
       },
       {
         name: "mcp_call_tool",
-        label: "Use connected app",
-        description: "Invoke an enabled app or connected-app tool returned by mcp_list_tools. Current settings are checked on every call. Changes require approval.",
+        label: "Use connector",
+        description: "Invoke an enabled app or connector tool returned by mcp_list_tools. Current settings are checked on every call. Changes require approval.",
         parameters: (Type) => Type.Object({ name: Type.String(), arguments: Type.Record(Type.String(), Type.Unknown()) }),
         execute: async (input) => JSON.stringify(await this.invoke(session, String(input.name), input.arguments ?? {}))
       }
@@ -6325,23 +6793,13 @@ ${action}`, standing: "switch", timeoutMs: 3e5 });
   }
   /** Gives one agent exactly these connections, if its creator may reach each of them. */
   setAgentScope(creator, agentId, ids) {
-    this.connections.updateAll((all2) => {
-      for (const id of ids) {
-        const connection = all2.find((item) => item.id === id);
-        if (!connection) throw notFound("Connection");
-        if (!allowed(connection, creator)) throw new HarnessError("required_connections_unavailable", `${connection.name} is disabled or outside your connection scope.`);
-      }
-      for (const connection of all2) {
-        connection.agentIds = connection.agentIds.filter((id) => id !== agentId);
-        connection.excludedAgentIds = connection.excludedAgentIds.filter((id) => id !== agentId);
-        if (ids.includes(connection.id)) {
-          if (!connection.global) connection.agentIds.push(agentId);
-        } else if (connection.global) {
-          connection.excludedAgentIds.push(agentId);
-        }
-      }
-    });
-    return this.connections.forScope({ agentId });
+    const all2 = this.connections.list();
+    for (const id of ids) {
+      const connection = all2.find((item) => item.id === id);
+      if (!connection) throw notFound("Connection");
+      if (!allowed(connection, creator)) throw new HarnessError("required_connections_unavailable", `${connection.name} is disabled or outside your connection scope.`);
+    }
+    return this.connections.setAgentScope(agentId, ids);
   }
   /**
    * A call with no session and nobody to ask, made by a plugin's hook. It reaches a connection
@@ -6358,21 +6816,13 @@ ${action}`, standing: "switch", timeoutMs: 3e5 });
   }
   /** Switches one saved connection on or off for everyone, one agent, or one project. */
   attach(connectionId, scope, on) {
-    this.connections.updateAll((all2) => {
-      const connection = all2.find((item) => item.id === connectionId);
-      if (!connection) throw notFound("Connection");
-      if (!connection.enabled) throw invalid(`${connection.name} is switched off. Switch it on in its own settings first.`);
-      setScope(connection, scope, on);
-    });
+    const connection = this.connections.find(connectionId);
+    if (!connection.enabled) throw invalid(`${connection.name} is switched off. Switch it on in its own settings first.`);
+    this.connections.setScope(connectionId, scope, on);
   }
   /** Forgets an agent that no longer exists. */
   removeAgentScope(agentId) {
-    this.connections.updateAll((all2) => {
-      for (const connection of all2) {
-        connection.agentIds = connection.agentIds.filter((id) => id !== agentId);
-        connection.excludedAgentIds = connection.excludedAgentIds.filter((id) => id !== agentId);
-      }
-    });
+    this.connections.removeAgentScope(agentId);
   }
   async close() {
     await this.manager.close(void 0, UNATTENDED_SCOPE).catch(() => void 0);
@@ -6381,56 +6831,56 @@ ${action}`, standing: "switch", timeoutMs: 3e5 });
 };
 
 // src/memory/maintenance.ts
-import { readFileSync as readFileSync16 } from "node:fs";
-import { join as join30 } from "node:path";
+import { readFileSync as readFileSync17 } from "node:fs";
+import { join as join31 } from "node:path";
 
 // src/memory/api.ts
 import { dirname as dirname11 } from "node:path";
 
 // src/memory/proposals.ts
 import { createHash as createHash5 } from "node:crypto";
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync15, renameSync as renameSync6, rmSync as rmSync6 } from "node:fs";
-import { dirname as dirname10, join as join29, relative as relative4 } from "node:path";
-import { z as z4 } from "zod";
-var optionalText2 = z4.string().nullish().transform((value) => value ?? null);
-var sourceRefSchema = z4.object({
-  kind: z4.string(),
-  ref: z4.string(),
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync16, renameSync as renameSync6, rmSync as rmSync6 } from "node:fs";
+import { dirname as dirname10, join as join30, relative as relative4 } from "node:path";
+import { z as z5 } from "zod";
+var optionalText2 = z5.string().nullish().transform((value) => value ?? null);
+var sourceRefSchema = z5.object({
+  kind: z5.string(),
+  ref: z5.string(),
   /** A passage quoted from the evidence. A run or source reference counts only when this passage is found in it. */
-  excerpt: z4.string().nullish().transform((value) => value ?? void 0)
+  excerpt: z5.string().nullish().transform((value) => value ?? void 0)
 });
-var linkProposalSchema = z4.object({ toId: z4.string(), type: z4.string() });
-var pageProposalSchema = z4.object({
+var linkProposalSchema = z5.object({ toId: z5.string(), type: z5.string() });
+var pageProposalSchema = z5.object({
   id: optionalText2,
-  title: z4.string(),
-  type: z4.string(),
-  body: z4.string(),
+  title: z5.string(),
+  type: z5.string(),
+  body: z5.string(),
   /** Where a new page is filed (`/library`, `/projects/<slug>`); the job's namespace by default. */
   namespace: optionalText2,
   confidence: optionalText2,
-  sourceRefs: z4.array(sourceRefSchema).default([]),
-  links: z4.array(linkProposalSchema).default([])
+  sourceRefs: z5.array(sourceRefSchema).default([]),
+  links: z5.array(linkProposalSchema).default([])
 });
-var memoryProposalSchema = z4.object({
+var memoryProposalSchema = z5.object({
   id: optionalText2,
-  title: z4.string(),
-  kind: z4.string(),
-  body: z4.string(),
+  title: z5.string(),
+  kind: z5.string(),
+  body: z5.string(),
   /** `/` for everything, or a project namespace. The job's project namespace by default. */
   namespace: optionalText2,
   confidence: optionalText2,
   supersedes: optionalText2,
-  volatile: z4.boolean().nullish().transform((value) => value ?? null),
-  sourceRefs: z4.array(sourceRefSchema).default([]),
-  links: z4.array(linkProposalSchema).default([])
+  volatile: z5.boolean().nullish().transform((value) => value ?? null),
+  sourceRefs: z5.array(sourceRefSchema).default([]),
+  links: z5.array(linkProposalSchema).default([])
 });
-var blockProposalSchema = z4.object({ block: z4.string(), body: z4.string(), sourceRefs: z4.array(sourceRefSchema).default([]) });
-var claimFlagSchema = z4.object({ claim: z4.string(), kind: z4.string(), reason: z4.string() });
-var proposalSetSchema = z4.object({
-  pages: z4.array(pageProposalSchema).default([]),
-  memories: z4.array(memoryProposalSchema).default([]),
-  blocks: z4.array(blockProposalSchema).default([]),
-  flags: z4.array(claimFlagSchema).default([])
+var blockProposalSchema = z5.object({ block: z5.string(), body: z5.string(), sourceRefs: z5.array(sourceRefSchema).default([]) });
+var claimFlagSchema = z5.object({ claim: z5.string(), kind: z5.string(), reason: z5.string() });
+var proposalSetSchema = z5.object({
+  pages: z5.array(pageProposalSchema).default([]),
+  memories: z5.array(memoryProposalSchema).default([]),
+  blocks: z5.array(blockProposalSchema).default([]),
+  flags: z5.array(claimFlagSchema).default([])
 });
 function parseProposalSet(value) {
   const parsed2 = proposalSetSchema.safeParse(value ?? {});
@@ -6468,14 +6918,14 @@ function triggerRunId(trigger) {
 }
 function fileHash(path3) {
   try {
-    return createHash5("sha256").update(readFileSync15(path3)).digest("hex");
+    return createHash5("sha256").update(readFileSync16(path3)).digest("hex");
   } catch {
     return null;
   }
 }
 function readOrNull(path3) {
   try {
-    return readFileSync15(path3, "utf8");
+    return readFileSync16(path3, "utf8");
   } catch {
     return null;
   }
@@ -6506,11 +6956,11 @@ function writeIndex(wiki) {
 
 `;
     for (const page2 of own) {
-      const inside4 = relative4(join29(wiki, folder), page2.path);
+      const inside4 = relative4(join30(wiki, folder), page2.path);
       text6 += `- [${page2.frontmatter.title}](${inside4.startsWith("..") ? page2.path : inside4}) (${page2.frontmatter.type}, \`${page2.frontmatter.id}\`) \u2014 ${firstParagraph(page2.body)}
 `;
     }
-    atomicWrite(join29(wiki, folder, "index.md"), text6);
+    atomicWrite(join30(wiki, folder, "index.md"), text6);
   }
   const active = memories2.filter((memory) => memory.front.status === "active");
   if (active.length) {
@@ -6518,7 +6968,7 @@ function writeIndex(wiki) {
     for (const memory of active) root += `- [${memory.front.title}](facts/${memory.front.id}.md) (${memory.front.kind}, ${memory.front.namespace}${memory.front.volatile ? ", volatile" : ""})
 `;
   }
-  atomicWrite(join29(wiki, "index.md"), root);
+  atomicWrite(join30(wiki, "index.md"), root);
 }
 function apply(wiki, defaultNamespace, trigger, proposals, captured, evidence) {
   const existing = loadPages(wiki);
@@ -6618,7 +7068,7 @@ ${takeChars(body2, 600)}`, [entryId2], null, payload);
     const sourceList = current ? [...current.frontmatter.sourceIds] : [];
     for (const id of found) if (!sourceList.includes(id)) sourceList.push(id);
     const front = { id: pageId, title: proposal.title.trim(), type: proposal.type, updatedAt: now(), sourceIds: sourceList, links: links2 };
-    const path3 = current?.path ?? join29(targetDir, `${pageId}.md`);
+    const path3 = current?.path ?? join30(targetDir, `${pageId}.md`);
     outcome.notes.push(`Page "${proposal.title}" (${pageId}) ${current ? "updated" : "created"} in ${namespace}.`);
     writes.push({ entryId: pageId, oldText: current ? readOrNull(current.path) : null, newText: serializePage(front, proposal.body), path: path3 });
   }
@@ -6747,7 +7197,7 @@ ${takeChars(proposal.body, 600)}`, [proposal.block]);
     afterRevisionId: snapshot(wiki, write3.entryId, write3.newText, actor, `Update ${short} (${described})`).id
   }));
   const operation = { id: operationId, createdAt: now(), trigger: described, pages, undone: false };
-  writeJson(join29(operationsDir(wiki), `${operationId}.json`), operation);
+  writeJson(join30(operationsDir(wiki), `${operationId}.json`), operation);
   for (const write3 of writes) noteChange({ wiki, id: write3.entryId, path: write3.path, text: write3.newText, actor, reason: described });
   writeIndex(wiki);
   log2(
@@ -6765,13 +7215,13 @@ ${takeChars(proposal.body, 600)}`, [proposal.block]);
   outcome.operation = operation;
   return outcome;
 }
-var registryProposalSchema = z4.object({
+var registryProposalSchema = z5.object({
   /** `skill`, `prompt`, or `rule`. */
-  kind: z4.string(),
-  name: z4.string(),
-  description: z4.string().default(""),
-  body: z4.string(),
-  reason: z4.string().default("")
+  kind: z5.string(),
+  name: z5.string(),
+  description: z5.string().default(""),
+  body: z5.string(),
+  reason: z5.string().default("")
 });
 function parkRegistryProposal(wiki, trigger, proposal) {
   if (!["skill", "prompt", "rule"].includes(proposal.kind) || !proposal.name.trim() || !proposal.body.trim()) {
@@ -6800,7 +7250,7 @@ function parsed(schema, value) {
 }
 function accept(root, itemId) {
   const wiki = wikiDir(root);
-  const path3 = join29(wiki, "inbox", `${safeId(itemId)}.json`);
+  const path3 = join30(wiki, "inbox", `${safeId(itemId)}.json`);
   const item = readJson(path3);
   if (!item) throw notFound("Inbox item");
   const payload = item.payload;
@@ -6830,9 +7280,9 @@ function accept(root, itemId) {
   } else {
     throw invalid("Unknown proposal kind.");
   }
-  const target = join29(wiki, "inbox", "dismissed");
+  const target = join30(wiki, "inbox", "dismissed");
   mkdirSync10(target, { recursive: true });
-  renameSync6(path3, join29(target, `${item.id}.json`));
+  renameSync6(path3, join30(target, `${item.id}.json`));
   return message;
 }
 
@@ -6991,13 +7441,13 @@ function list4(env, params) {
   const pages = loadPages(wiki).filter((page2) => !namespace || page2.location.namespace === namespace || page2.location.path.startsWith(prefix)).slice(0, 200).map((page2) => `- ${page2.location.path} \u2014 ${page2.frontmatter.title} (${page2.frontmatter.type}) [${page2.frontmatter.id}]`);
   return text6 + (pages.length ? pages.join("\n") : "No pages here.");
 }
-function skill(env, context, params) {
+function skill(env, context, params, contributions2) {
   const { root } = env;
   const name = textParam(params, "name").toLowerCase();
-  const items = list(root).filter((item) => item.kind === "skills");
+  const items = limitToContributions(list(root).filter((item) => item.kind === "skills"), contributions2);
   if (!name) {
     if (!items.length) return "No skills yet.";
-    const active = enabledFor(root, context.projectId ?? null, context.agentId ?? null).map((item) => item.id);
+    const active = (contributions2 === void 0 ? enabledFor(root, context.projectId ?? null, context.agentId ?? null) : items).map((item) => item.id);
     return items.map((item) => `- ${item.name} (${item.id})${active.includes(item.id) ? " \xB7 active" : ""} \u2014 ${item.description}`).join("\n");
   }
   const found = items.find((item) => item.id.toLowerCase() === name || item.id.replace(/^skills\//, "").toLowerCase() === name || item.name.toLowerCase() === name);
@@ -7299,7 +7749,7 @@ function chatUpdatesPaused(settings) {
 function runEvidence(root, runId) {
   const run3 = findRun(root, runId);
   if (!run3) throw new Error("Run was not found.");
-  const settings = readJsonOr(join30(root, "config/settings.json"), null);
+  const settings = readJsonOr(join31(root, "config/settings.json"), null);
   if (Array.isArray(settings?.excludedSourceIds) && settings.excludedSourceIds.includes(runId)) throw new Error("run excluded in settings");
   const projectId = run3.mode === "chat" || run3.mode === "code" ? run3.projectId : null;
   let namespace;
@@ -7322,7 +7772,7 @@ function runBlocks(env, runId) {
   const run3 = findRun(env.root, runId);
   if (!run3) return [];
   const chat = run3.mode === "chat";
-  const recorded = readJsonOr(join30(env.root, "runs", run3.id, "caller.json"), null);
+  const recorded = readJsonOr(join31(env.root, "runs", run3.id, "caller.json"), null);
   const context = recorded ?? {
     runId: run3.id,
     sessionId: run3.sessionId,
@@ -7421,12 +7871,12 @@ var Maintenance = class {
     let request2;
     let shown2 = "";
     if (job.kind === "ingest") {
-      const directory = join30(wiki, "raw", job.sourceId);
-      const name = readJsonOr(join30(directory, "meta.json"), null)?.name;
+      const directory = join31(wiki, "raw", job.sourceId);
+      const name = readJsonOr(join31(directory, "meta.json"), null)?.name;
       const sourceName = typeof name === "string" ? name : "source";
       let text6 = null;
       try {
-        text6 = new TextDecoder("utf-8", { fatal: true }).decode(readFileSync16(join30(directory, sourceName)));
+        text6 = new TextDecoder("utf-8", { fatal: true }).decode(readFileSync17(join31(directory, sourceName)));
       } catch {
         text6 = null;
       }
@@ -7473,7 +7923,7 @@ var Maintenance = class {
     const context = trigger.kind === "consolidate" ? { pages: [], memories: [] } : maintainerContext(root, namespace, shown2);
     let index = "";
     try {
-      index = takeChars(readFileSync16(join30(wiki, "index.md"), "utf8"), 8e3);
+      index = takeChars(readFileSync17(join31(wiki, "index.md"), "utf8"), 8e3);
     } catch {
       index = "";
     }
@@ -7534,28 +7984,28 @@ var Maintenance = class {
 };
 
 // src/memory/migrate.ts
-import { existsSync as existsSync10, renameSync as renameSync7, rmSync as rmSync7 } from "node:fs";
-import { join as join31 } from "node:path";
+import { existsSync as existsSync11, renameSync as renameSync7, rmSync as rmSync7 } from "node:fs";
+import { join as join32 } from "node:path";
 var WIKI_VERSION = 3;
-var storagePath = (root) => join31(root, "config/storage.json");
+var storagePath = (root) => join32(root, "config/storage.json");
 function version(root) {
   const stored = readJsonOr(storagePath(root), null)?.wikiVersion;
   if (typeof stored === "number" && Number.isInteger(stored) && stored >= 0) return stored;
   const wiki = wikiDir(root);
-  if (isDir(join31(root, "knowledge"))) return 1;
-  if (!existsSync10(join31(wiki, "blocks")) && (isDir(join31(wiki, "docs")) || isDir(join31(wiki, "memory")))) return 2;
+  if (isDir(join32(root, "knowledge"))) return 1;
+  if (!existsSync11(join32(wiki, "blocks")) && (isDir(join32(wiki, "docs")) || isDir(join32(wiki, "memory")))) return 2;
   return WIKI_VERSION;
 }
 var stamp = () => now().replace(/[:.]/g, "-");
 function backUp2(root, from, name) {
-  if (!existsSync10(from)) return;
-  renameSync7(from, existsSync10(join31(root, name)) ? join31(root, `${name}-${stamp()}`) : join31(root, name));
+  if (!existsSync11(from)) return;
+  renameSync7(from, existsSync11(join32(root, name)) ? join32(root, `${name}-${stamp()}`) : join32(root, name));
 }
 function run2(env, agentIds = []) {
   const { root } = env;
   if (version(root) >= WIKI_VERSION) return false;
   const failed = (detail) => new HarnessError("migration_failed", `The Wiki was not migrated to version 3; your Wiki is unchanged. ${detail}`);
-  const staging = join31(root, "wiki.migrating");
+  const staging = join32(root, "wiki.migrating");
   rmSync7(staging, { recursive: true, force: true });
   try {
     ensureLayoutAt(staging, env.productName);
@@ -7569,7 +8019,7 @@ function run2(env, agentIds = []) {
     throw failed(error instanceof Error ? error.message : String(error));
   }
   renameSync7(staging, wikiDir(root));
-  backUp2(root, join31(root, "knowledge"), "knowledge.pre-v2");
+  backUp2(root, join32(root, "knowledge"), "knowledge.pre-v2");
   ensureLayout(root, env.productName);
   for (const project of listProjects(root)) ensureProjectNamespace(root, project.slug, project.name);
   const enablement2 = enablement(root);
@@ -7578,7 +8028,7 @@ function run2(env, agentIds = []) {
     for (const id of enablementIds(enablement2, "personal")) if (!ids.includes(id)) ids.push(id);
     delete enablement2.personal;
     enablement2[GLOBAL_KEY] = ids;
-    writeJson(join31(root, "config/registry-enabled.json"), enablement2);
+    writeJson(join32(root, "config/registry-enabled.json"), enablement2);
   }
   writeIndex(wikiDir(root));
   writeJson(storagePath(root), { wikiVersion: WIKI_VERSION, migratedAt: now() });
@@ -7754,8 +8204,8 @@ function searchAll(env, query, filter = {}) {
 }
 
 // src/plugins/hooks.ts
-import { chmodSync as chmodSync7 } from "node:fs";
-import { join as join32, sep as sep5 } from "node:path";
+import { chmodSync as chmodSync8 } from "node:fs";
+import { join as join33, sep as sep5 } from "node:path";
 import { pathToFileURL } from "node:url";
 var HOOK_EVENTS = ["memory.saved", "memory.block.changed", "wiki.page.saved", "history.run.ended"];
 var importFile = new Function("address", "return import(address)");
@@ -7770,7 +8220,7 @@ function entryEvent(change) {
 var Hooks = class {
   constructor(options2) {
     this.options = options2;
-    this.statusPath = join32(options2.stateDir, "plugin-hooks.json");
+    this.statusPath = join33(options2.stateDir, "plugin-hooks.json");
     this.stop = onChange((change) => {
       if (change.wiki === this.wiki) this.emit(entryEvent(change));
     });
@@ -7797,7 +8247,7 @@ var Hooks = class {
     if (JSON.stringify(before) === JSON.stringify(next) && all2[path3]) return;
     all2[path3] = next;
     writeJson(this.statusPath, all2);
-    chmodSync7(this.statusPath, 384);
+    chmodSync8(this.statusPath, 384);
     if (before.lastError !== next.lastError || before.events.join() !== next.events.join()) this.options.bus.emit({ type: "plugins.changed" });
   }
   /** Loads the hooks files that should run and drops the ones that should not. Safe to call often. */
@@ -7882,8 +8332,8 @@ var Hooks = class {
 };
 
 // src/sessions/approvals.ts
-import { chmodSync as chmodSync8 } from "node:fs";
-import { join as join33 } from "node:path";
+import { chmodSync as chmodSync9 } from "node:fs";
+import { join as join34 } from "node:path";
 var APPROVAL_KEYS = ["chat", "pi"];
 function decide(policy, key, sessionId, target) {
   if (policy.auto[key]) return "always";
@@ -7897,7 +8347,7 @@ var approvalKey = (run3) => run3.mode === "chat" ? "chat" : run3.harness;
 var Approvals = class {
   constructor(stateDir, bus) {
     this.bus = bus;
-    this.path = join33(stateDir, "approvals.json");
+    this.path = join34(stateDir, "approvals.json");
   }
   path;
   read() {
@@ -7909,7 +8359,7 @@ var Approvals = class {
     update2(policy);
     writeJson(this.path, policy);
     try {
-      chmodSync8(this.path, 384);
+      chmodSync9(this.path, 384);
     } catch {
     }
     this.bus.emit({ type: "approvals.changed" });
@@ -8029,7 +8479,7 @@ var RunRegistry = class {
         }
         emit("approval.requested", { approvalId, ...payload });
         emit("status.changed", { status: "waiting_for_approval" });
-        return new Promise((resolve8) => {
+        return new Promise((resolve9) => {
           const timer = timeoutMs ? setTimeout(() => this.approvals.get(approvalId)?.resolve("denied"), timeoutMs) : null;
           this.approvals.set(approvalId, {
             runId,
@@ -8038,7 +8488,7 @@ var RunRegistry = class {
               this.approvals.delete(approvalId);
               emit("approval.resolved", { approvalId, decision });
               emit("status.changed", { status: waitingStatus() });
-              resolve8(decision);
+              resolve9(decision);
             }
           });
         });
@@ -8049,7 +8499,7 @@ var RunRegistry = class {
         if (finished || this.nativeCleared.delete(questionId)) return Promise.resolve({ selected: [] });
         emit("question.requested", { questionId, ...payload });
         emit("status.changed", { status: "waiting_for_input" });
-        return new Promise((resolve8) => {
+        return new Promise((resolve9) => {
           this.questions.set(questionId, {
             runId,
             input,
@@ -8057,7 +8507,7 @@ var RunRegistry = class {
               this.questions.delete(questionId);
               emit("question.answered", { questionId, ...answer });
               emit("status.changed", { status: waitingStatus() });
-              resolve8(answer);
+              resolve9(answer);
             }
           });
         });
@@ -8136,7 +8586,7 @@ var RunRegistry = class {
   }
   /** Interrupts every live run, giving each a moment to stop cleanly. */
   async interruptAll(timeoutMs = 3e3) {
-    await Promise.race([Promise.allSettled(this.activeRunIds().map((id) => this.interrupt(id))), new Promise((resolve8) => setTimeout(resolve8, timeoutMs))]);
+    await Promise.race([Promise.allSettled(this.activeRunIds().map((id) => this.interrupt(id))), new Promise((resolve9) => setTimeout(resolve9, timeoutMs))]);
   }
   resolveApproval(runId, approvalId, decision) {
     if (decision !== "approved" && decision !== "denied" && decision !== "native") throw new HarnessError("invalid_request", "Unknown decision.");
@@ -8167,13 +8617,13 @@ var RunRegistry = class {
 };
 
 // src/sessions/sessions.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync11 } from "node:fs";
-import { join as join35 } from "node:path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync11 } from "node:fs";
+import { join as join36 } from "node:path";
 
 // src/capabilities/runSnapshot.ts
-import { existsSync as existsSync11 } from "node:fs";
-import { join as join34 } from "node:path";
-var path2 = (root, runId) => join34(root, "runs", safeId(runId), "capabilities.json");
+import { existsSync as existsSync12 } from "node:fs";
+import { join as join35 } from "node:path";
+var path2 = (root, runId) => join35(root, "runs", safeId(runId), "capabilities.json");
 function strings2(value) {
   return Array.isArray(value) ? [...new Set(value.filter((item) => typeof item === "string" && item.length > 0))] : [];
 }
@@ -8191,7 +8641,7 @@ function freezeRun(root, runId, caller, set2) {
     connectors: strings2(set2.connectors),
     contributions: strings2(set2.contributions)
   };
-  const existing = existsSync11(target) ? readJson(target) : null;
+  const existing = existsSync12(target) ? readJson(target) : null;
   if (existing) {
     if (JSON.stringify(existing) !== JSON.stringify(snapshot3)) throw new HarnessError("capabilities_frozen", "This run already has a different frozen capability set.");
     return existing;
@@ -8214,7 +8664,7 @@ function loadRun2(root, runId) {
 }
 
 // src/memory/dispatch.ts
-function dispatch(env, context, call, params) {
+function dispatch(env, context, call, params, contributions2) {
   switch (call) {
     case "wiki.entrypoint": {
       const recorded = context.runId ? safely(() => load3(env.root, context.runId)) : null;
@@ -8238,7 +8688,7 @@ function dispatch(env, context, call, params) {
     case "wiki.list":
       return list4(env, params);
     case "wiki.skill":
-      return skill(env, context, params);
+      return skill(env, context, params, contributions2);
     case "wiki.memory":
       return memories(env, context, params);
     case "wiki.propose": {
@@ -8260,7 +8710,7 @@ function safely(read3) {
 }
 
 // src/tools/memoryTools.ts
-function memoryTools(env, context) {
+function memoryTools(env, context, contributions2) {
   return WIKI_AGENT_TOOLS.map((tool) => ({
     name: tool.name,
     label: tool.label,
@@ -8268,7 +8718,7 @@ function memoryTools(env, context) {
     parameters: (Type) => Type.Unsafe(tool.parameters),
     execute: async (input) => {
       try {
-        return dispatch(env, context, tool.call, input) || "Nothing found.";
+        return dispatch(env, context, tool.call, input, contributions2) || "Nothing found.";
       } catch (error) {
         return `The Wiki could not do that: ${error instanceof Error ? error.message : String(error)}`;
       }
@@ -8277,14 +8727,14 @@ function memoryTools(env, context) {
 }
 
 // src/sessions/history.ts
-import { readFileSync as readFileSync17, realpathSync } from "node:fs";
+import { readFileSync as readFileSync18, realpathSync } from "node:fs";
 import { isAbsolute as isAbsolute4, relative as relative5 } from "node:path";
 var unavailable = () => new HarnessError("native_resume_unavailable", "The saved conversation is unavailable; this reply cannot be continued.");
 function nativeId(sessionDir, path3) {
   const file = realpathSync(path3);
   const within = relative5(realpathSync(sessionDir), file);
   if (within.startsWith("..") || isAbsolute4(within) || !file.endsWith(".jsonl")) throw new Error("Outside history");
-  const header = JSON.parse(readFileSync17(file, "utf8").split("\n", 1)[0]);
+  const header = JSON.parse(readFileSync18(file, "utf8").split("\n", 1)[0]);
   if (header.type !== "session" || !header.id) throw new Error("Missing session identity");
   return header.id;
 }
@@ -8336,7 +8786,7 @@ ${text6}`);
 async function waitForChildren(root, runId, signal) {
   while (!signal?.aborted) {
     if (settled(root, runId)) return true;
-    await new Promise((resolve8) => setTimeout(resolve8, 250));
+    await new Promise((resolve9) => setTimeout(resolve9, 250));
   }
   return false;
 }
@@ -8417,11 +8867,11 @@ var MAX_TEXT = 4e3;
 var clip2 = (text6) => text6.length > MAX_TEXT ? `${text6.slice(0, MAX_TEXT)}\u2026` : text6;
 function dismissable(answer, fallback, options2) {
   if (!options2?.signal && !options2?.timeout) return answer;
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     let timer;
     const done = (value) => {
       if (timer) clearTimeout(timer);
-      resolve8(value);
+      resolve9(value);
     };
     if (options2.signal?.aborted) return done(fallback);
     options2.signal?.addEventListener("abort", () => done(fallback), { once: true });
@@ -8903,10 +9353,10 @@ var piSessionFactory = async ({ params, allow, gate, tools: tools3, runtime: loa
 };
 
 // src/sessions/sessions.ts
-function firstPartyFor(root, caller) {
+function firstPartyFor(root, contributions2) {
   const choices = load2(root);
-  const scope = { agentId: caller.agentId ?? null, projectId: caller.projectId ?? null };
-  return firstPartyExtensions((id) => attached(choices, [id], scope, FIRST_PARTY_PLUGINS.find((plugin) => plugin.id === id)?.switchable?.on ?? false), choices.settings);
+  const allowed2 = new Set(contributions2);
+  return firstPartyExtensions((id) => FIRST_PARTY_PLUGINS.find((plugin) => plugin.id === id)?.code?.some((code) => allowed2.has(`${id}/code/${code.name}`)) ?? false, choices.settings);
 }
 var Sessions = class {
   constructor(options2) {
@@ -8969,7 +9419,7 @@ var Sessions = class {
       ...WIKI_TOOL_NAMES,
       ...broker?.toolNames ?? []
     ])];
-    const available = this.options.resolveCapabilities ? await this.options.resolveCapabilities(caller, requestedTools) : { version: 1, tools: requestedTools, connectors: [], contributions: [] };
+    const available = this.options.resolveCapabilities ? await this.options.resolveCapabilities(caller, requestedTools, input.cwd) : { version: 1, tools: requestedTools, connectors: [], contributions: [] };
     const requested = input.capabilities ? capabilitySet(input.capabilities) : available;
     const capabilities = {
       version: 1,
@@ -9004,7 +9454,7 @@ var Sessions = class {
       trigger: input.run.trigger ?? null
     });
     try {
-      writeJson(join35(runDir(root, runId), "caller.json"), caller);
+      writeJson(join36(runDir(root, runId), "caller.json"), caller);
     } catch {
     }
     const fail = (error, code = "provider_unavailable") => {
@@ -9015,7 +9465,7 @@ var Sessions = class {
     let system;
     let update2;
     try {
-      if (!existsSync12(input.sessionDir)) mkdirSync11(input.sessionDir, { recursive: true });
+      if (!existsSync13(input.sessionDir)) mkdirSync11(input.sessionDir, { recursive: true });
       const launch = input.launch ?? {};
       const effectiveLaunch = {
         ...launch,
@@ -9023,7 +9473,7 @@ var Sessions = class {
         connectionTools: (launch.connectionTools ?? []).filter((name) => capabilities.tools.includes(name)),
         toolGroups: launch.toolGroups?.map((group) => ({ ...group, tools: group.tools.filter((name) => capabilities.tools.includes(name)) })).filter((group) => group.tools.length > 0)
       };
-      ({ system, update: update2 } = sessionLaunch(this.env, caller, effectiveLaunch, historyFile));
+      ({ system, update: update2 } = sessionLaunch(this.env, caller, effectiveLaunch, historyFile, capabilities.contributions));
     } catch (error) {
       fail(error);
       throw error;
@@ -9037,7 +9487,7 @@ var Sessions = class {
     try {
       const tools3 = [
         ...broker ? broker.tools(session, { readOnly: typeof input.connections === "object" && input.connections.readOnly === true }) : [],
-        ...memoryTools(this.options.env, caller),
+        ...memoryTools(this.options.env, caller, capabilities.contributions),
         askUserTool(run3),
         pluginProposeTool(this.options.env, caller)
       ];
@@ -9055,9 +9505,9 @@ var Sessions = class {
         preamble: input.preamble ?? null,
         automatic: input.automatic,
         account: context,
-        resources: resources(root, caller.projectId ?? null, caller.agentId ?? null),
-        inline: [...firstPartyFor(root, caller), runLineageJoin(root, runId)],
-        ...plugins ? { plugins: { loading: () => plugins.loading({ cwd: input.cwd, agentDir: context.configDir, install: true, caller: { agentId: caller.agentId ?? null, projectId: caller.projectId ?? null } }), loaded: (extensions) => plugins.loaded(extensions) } } : {},
+        resources: resources(root, caller.projectId ?? null, caller.agentId ?? null, capabilities.contributions),
+        inline: [...firstPartyFor(root, capabilities.contributions), runLineageJoin(root, runId)],
+        ...plugins ? { plugins: { loading: () => plugins.loading({ cwd: input.cwd, agentDir: context.configDir, install: true, caller: { agentId: caller.agentId ?? null, projectId: caller.projectId ?? null }, contributions: capabilities.contributions }), loaded: (extensions) => plugins.loaded(extensions) } } : {},
         system,
         update: update2
       };
@@ -9093,8 +9543,8 @@ var Sessions = class {
 };
 
 // src/terminal/terminals.ts
-import { chmodSync as chmodSync10, existsSync as existsSync13, mkdirSync as mkdirSync13, readFileSync as readFileSync18, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname13, join as join37 } from "node:path";
+import { chmodSync as chmodSync11, existsSync as existsSync14, mkdirSync as mkdirSync13, readFileSync as readFileSync19, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname13, join as join38 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/terminal/client.ts
@@ -9114,7 +9564,7 @@ function connectionFromEnv(env = process.env) {
   return { socket, token };
 }
 function request(connection, body2, what, timeoutMs) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const stream = createConnection(connection.socket);
     let buffer = "";
     let settled2 = false;
@@ -9140,7 +9590,7 @@ function request(connection, body2, what, timeoutMs) {
         if (reply.error) {
           const error = typeof reply.error === "string" ? { message: reply.error } : reply.error;
           finish(() => reject(new SocketError(error.code ?? "error", error.message ?? `${what} failed.`)));
-        } else finish(() => resolve8(reply.result));
+        } else finish(() => resolve9(reply.result));
       } catch {
         finish(() => reject(new SocketError("invalid_reply", "The harness sent an unreadable reply.")));
       }
@@ -9344,15 +9794,15 @@ var TerminalController = class {
     if (this.disposed) throw new HarnessError("terminal_not_ready", "Reopen the terminal before sending instructions.");
     if (this.activeRun || this.delivery) throw new HarnessError("session_busy", "This terminal has an active task or delivery.");
     const deadline = Date.now() + READY_TIMEOUT_MS;
-    while (!this.ready && !this.startupError && !this.disposed && Date.now() < deadline) await new Promise((resolve8) => setTimeout(resolve8, 50));
+    while (!this.ready && !this.startupError && !this.disposed && Date.now() < deadline) await new Promise((resolve9) => setTimeout(resolve9, 50));
     if (this.disposed) throw new HarnessError("terminal_not_ready", "The terminal stopped during initialization.");
     if (this.startupError) throw new HarnessError("terminal_not_ready", this.startupError);
     if (!this.ready) throw new HarnessError("terminal_not_ready", `The native telemetry handshake is missing (${this.startupPhase}). Inspect the terminal sign-in or trust screen.`);
     if (this.dirty) throw new HarnessError("terminal_has_draft", "The terminal contains user input. Submit or clear it before handing back control.");
     let timer;
-    const ack = new Promise((resolve8, reject) => {
+    const ack = new Promise((resolve9, reject) => {
       timer = setTimeout(() => reject(new HarnessError("delivery_uncertain", "The native prompt acknowledgement was not received. Inspect the terminal; this instruction will not be resent.")), ACK_TIMEOUT_MS);
-      this.delivery = { runId, text: text6, resolve: resolve8, reject };
+      this.delivery = { runId, text: text6, resolve: resolve9, reject };
     });
     void ack.catch(() => {
     });
@@ -9469,16 +9919,16 @@ var TerminalController = class {
 
 // src/terminal/socket.ts
 import { createHash as createHash7 } from "node:crypto";
-import { chmodSync as chmodSync9, mkdirSync as mkdirSync12, rmSync as rmSync8 } from "node:fs";
+import { chmodSync as chmodSync10, mkdirSync as mkdirSync12, rmSync as rmSync8 } from "node:fs";
 import { createServer as createServer2 } from "node:net";
 import { tmpdir } from "node:os";
-import { dirname as dirname12, join as join36 } from "node:path";
+import { dirname as dirname12, join as join37 } from "node:path";
 var MAX_REQUEST_BYTES = 1024 * 1024;
 var MAX_SOCKET_PATH = 100;
 function socketPath(stateDir) {
-  const path3 = join36(stateDir, "run", "harness.sock");
+  const path3 = join37(stateDir, "run", "harness.sock");
   if (Buffer.byteLength(path3) <= MAX_SOCKET_PATH) return path3;
-  return join36(tmpdir(), `xh-${createHash7("sha256").update(path3).digest("hex").slice(0, 16)}.sock`);
+  return join37(tmpdir(), `xh-${createHash7("sha256").update(path3).digest("hex").slice(0, 16)}.sock`);
 }
 var SessionSocket = class {
   constructor(path3, handlers) {
@@ -9575,7 +10025,7 @@ var SessionSocket = class {
   }
   /** Binds the socket once; later calls wait for the same bind. */
   listen() {
-    this.listening ??= new Promise((resolve8, reject) => {
+    this.listening ??= new Promise((resolve9, reject) => {
       mkdirSync12(dirname12(this.path), { recursive: true, mode: 448 });
       rmSync8(this.path, { force: true });
       const server = createServer2((client) => this.serve(client));
@@ -9585,12 +10035,12 @@ var SessionSocket = class {
       });
       server.listen(this.path, () => {
         try {
-          chmodSync9(this.path, 384);
+          chmodSync10(this.path, 384);
         } catch (error) {
           log("session socket permissions", error instanceof Error ? error.message : String(error));
         }
         this.server = server;
-        resolve8();
+        resolve9();
       });
     });
     return this.listening;
@@ -9601,7 +10051,7 @@ var SessionSocket = class {
     this.server = null;
     this.listening = null;
     for (const client of this.clients) client.destroy();
-    if (server) await new Promise((resolve8) => server.close(() => resolve8()));
+    if (server) await new Promise((resolve9) => server.close(() => resolve9()));
     rmSync8(this.path, { force: true });
   }
 };
@@ -9609,8 +10059,8 @@ var SessionSocket = class {
 // src/terminal/terminals.ts
 function defaultAssets() {
   const here = dirname13(fileURLToPath(import.meta.url));
-  const dist = [here, join37(here, "..", "..", "dist"), join37(here, "..", "dist")].find((folder) => existsSync13(join37(folder, "terminal-pi.js"))) ?? here;
-  return { node: process.execPath, cli: join37(dist, "cli.js"), piExtension: join37(dist, "terminal-pi.js") };
+  const dist = [here, join38(here, "..", "..", "dist"), join38(here, "..", "dist")].find((folder) => existsSync14(join38(folder, "terminal-pi.js"))) ?? here;
+  return { node: process.execPath, cli: join38(dist, "cli.js"), piExtension: join38(dist, "terminal-pi.js") };
 }
 var READ_ONLY_TOOLS = /* @__PURE__ */ new Set(["read", "grep", "find", "ls"]);
 var Terminals = class {
@@ -9628,23 +10078,23 @@ var Terminals = class {
   assets;
   /** The commands a terminal session finds on PATH. Rewritten only when they change. */
   ensureCommands() {
-    const bin = join37(this.options.stateDir, "run", "bin");
+    const bin = join38(this.options.stateDir, "run", "bin");
     mkdirSync13(bin, { recursive: true });
     const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
     for (const [name, mode] of [[WIKI_COMMAND, "wiki"], [APPS_COMMAND, "mcp"]]) {
-      const wrapper = join37(bin, name);
+      const wrapper = join38(bin, name);
       const text6 = `#!/bin/sh
 exec ${quote(this.assets.node)} ${quote(this.assets.cli)} ${mode} "$@"
 `;
       let current = null;
       try {
-        current = readFileSync18(wrapper, "utf8");
+        current = readFileSync19(wrapper, "utf8");
       } catch {
         current = null;
       }
       if (current !== text6) {
         writeFileSync3(wrapper, text6);
-        chmodSync10(wrapper, 493);
+        chmodSync11(wrapper, 493);
       }
     }
     return bin;
@@ -9711,7 +10161,7 @@ exec ${quote(this.assets.node)} ${quote(this.assets.cli)} ${mode} "$@"
     return live;
   }
   historyDir(input) {
-    return join37(input.sessionFolder, "pi");
+    return join38(input.sessionFolder, "pi");
   }
   runRecord(live, runId, text6) {
     const { input } = live;
@@ -9943,12 +10393,12 @@ var Harness = class {
   constructor(options2) {
     this.stateDir = options2.stateDir;
     mkdirSync14(this.stateDir, { recursive: true });
-    isolateProcess(join38(this.stateDir, "accounts"));
+    isolateProcess(join39(this.stateDir, "accounts"));
     this.env = new Env(options2.dataRoot || null, options2.directory ?? EMPTY_DIRECTORY, options2.productName ?? DEFAULT_PRODUCT_NAME, this.bus);
     this.policy = options2.policy ?? {};
     configureBuiltins(options2.builtins ?? []);
-    const secrets = options2.secrets ?? fileSecretStore(join38(this.stateDir, "secrets.json"));
-    this.accounts = new Accounts({ dir: join38(this.stateDir, "accounts"), secrets, bus: this.bus });
+    const secrets = options2.secrets ?? fileSecretStore(join39(this.stateDir, "secrets.json"));
+    this.accounts = new Accounts({ dir: join39(this.stateDir, "accounts"), secrets, bus: this.bus });
     this.approvals = new Approvals(this.stateDir, this.bus);
     this.runs = new RunRegistry({
       root: () => this.env.root,
@@ -9960,7 +10410,7 @@ var Harness = class {
       ended: (runId, sessionId) => this.apps.revokeRun(runId, sessionId)
     });
     this.apps = new ConnectedApps({ env: this.env, stateDir: this.stateDir, secrets, bus: this.bus, runs: this.runs, policy: this.policy });
-    this.plugins = new Plugins({ stateDir: this.stateDir, bus: this.bus, resolver: options2.resolver, attachments: () => this.env.dataRoot ? load2(this.env.dataRoot) : null, packagesDir: () => this.env.dataRoot ? join38(this.env.dataRoot, "plugins") : null });
+    this.plugins = new Plugins({ stateDir: this.stateDir, bus: this.bus, resolver: options2.resolver, attachments: () => this.env.dataRoot ? load2(this.env.dataRoot) : null, packagesDir: () => this.env.dataRoot ? join39(this.env.dataRoot, "plugins") : null });
     this.hooks = new Hooks({
       stateDir: this.stateDir,
       bus: this.bus,
@@ -9968,9 +10418,9 @@ var Harness = class {
       // The shared folder stands in for an account: packages are the same for all of them.
       wanted: async () => {
         if (!this.env.dataRoot) return [];
-        const shared = ensureSharedDir(join38(this.stateDir, "accounts"));
-        const named2 = readJsonOr(join38(shared, "settings.json"), {}).packages;
-        if (!packageFolders(join38(this.env.dataRoot, "plugins")).length && !(Array.isArray(named2) && named2.length)) return [];
+        const shared = ensureSharedDir(join39(this.stateDir, "accounts"));
+        const named2 = readJsonOr(join39(shared, "settings.json"), {}).packages;
+        if (!packageFolders(join39(this.env.dataRoot, "plugins")).length && !(Array.isArray(named2) && named2.length)) return [];
         return (await this.plugins.loading({ cwd: this.stateDir, agentDir: shared, caller: {} })).hooks;
       },
       call: (connection, tool, args) => this.apps.callUnattended(connection, tool, args ?? {}),
@@ -9993,7 +10443,7 @@ var Harness = class {
       policy: this.policy,
       broker: this.apps,
       plugins: this.plugins,
-      resolveCapabilities: (caller, tools3) => resolve4(this, { agentId: caller.agentId ?? null, projectId: caller.projectId ?? null, tools: tools3 }),
+      resolveCapabilities: (caller, tools3, cwd) => resolve5(this, { agentId: caller.agentId ?? null, projectId: caller.projectId ?? null, cwd, tools: tools3 }),
       factory: options2.sessionFactory
     });
     this.maintenance = new Maintenance({ env: this.env, bus: this.bus, accounts: this.accounts, factory: options2.maintainerFactory, idleMs: options2.idleMs });
@@ -10029,15 +10479,24 @@ var Harness = class {
     const root = dataRoot;
     this.hooks.watch(wikiDir(root));
     void this.hooks.reload();
-    for (const folder of ["registry/skills", "registry/prompts", "registry/rules", "config", "runs"]) mkdirSync14(join38(root, folder), { recursive: true });
+    for (const folder of ["registry/skills", "registry/prompts", "registry/rules", "config", "runs"]) mkdirSync14(join39(root, folder), { recursive: true });
     let migrationError = null;
+    let wikiMigrationError = null;
     try {
       if (run2(this.env, agentIds)) log(`started Wiki storage version ${WIKI_VERSION}; the earlier Wiki is kept as a backup in the data root`);
     } catch (error) {
       migrationError = error instanceof Error ? error.message : String(error);
+      wikiMigrationError = migrationError;
       log("Wiki migration failed", migrationError);
     }
-    if (!migrationError) {
+    try {
+      migrateConnectionScopes(root, this.stateDir);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      migrationError = migrationError ? `${migrationError}; connector scope migration: ${detail}` : detail;
+      log("connector scope migration failed", detail);
+    }
+    if (!wikiMigrationError) {
       try {
         ensureLayout(root, this.env.productName);
         for (const project of projectsOrNone(root)) ensureProjectNamespace(root, project.slug, project.name);
@@ -10095,18 +10554,18 @@ function createHarness(options2) {
 
 // src/plugins/cli.ts
 import { homedir as homedir5 } from "node:os";
-import { join as join40, resolve as resolve6 } from "node:path";
+import { join as join41, resolve as resolve7 } from "node:path";
 import { createInterface } from "node:readline/promises";
 
 // src/plugins/install.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync15, renameSync as renameSync8, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync15, renameSync as renameSync8, statSync as statSync6 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { basename as basename8, isAbsolute as isAbsolute5, join as join39, resolve as resolve5 } from "node:path";
+import { basename as basename8, isAbsolute as isAbsolute5, join as join40, resolve as resolve6 } from "node:path";
 function normalizeSource(input) {
   const source2 = input.trim();
   if (!source2) throw invalid("Name a package: a folder, an npm name, or a git address.");
-  if (source2.startsWith("~/")) return join39(process.env.HOME || homedir4(), source2.slice(2));
-  if (isAbsolute5(source2)) return resolve5(source2);
+  if (source2.startsWith("~/")) return join40(process.env.HOME || homedir4(), source2.slice(2));
+  if (isAbsolute5(source2)) return resolve6(source2);
   if (source2.startsWith("./") || source2.startsWith("../")) throw invalid("Give the whole path of the folder.");
   return /^(npm:|git:|https?:\/\/|ssh:\/\/|git@)/.test(source2) ? source2 : `npm:${source2}`;
 }
@@ -10119,7 +10578,7 @@ async function manager(harness) {
 var changed = (harness) => harness.bus.emit({ type: "plugins.changed" });
 async function install2(harness, params) {
   const source2 = normalizeSource(params.source);
-  if (isAbsolute5(source2) && !(existsSync14(source2) && statSync5(source2).isDirectory())) throw invalid("That folder does not exist.");
+  if (isAbsolute5(source2) && !(existsSync15(source2) && statSync6(source2).isDirectory())) throw invalid("That folder does not exist.");
   await ensureAdopted(harness);
   const before = new Set((await list2(harness, params)).map((plugin) => plugin.id));
   const { settings, packages } = await manager(harness);
@@ -10149,9 +10608,9 @@ function installed(plugins, pluginId) {
 async function remove(harness, params) {
   const plugin = installed(await list2(harness, params), params.pluginId);
   if (plugin.install.kind === "folder") {
-    const trash = join39(harness.env.root, "trash", "plugins");
+    const trash = join40(harness.env.root, "trash", "plugins");
     mkdirSync15(trash, { recursive: true });
-    renameSync8(plugin.install.source, join39(trash, `${basename8(plugin.install.source)}-${now().replace(/[:.]/g, "-")}`));
+    renameSync8(plugin.install.source, join40(trash, `${basename8(plugin.install.source)}-${now().replace(/[:.]/g, "-")}`));
   } else {
     await (await manager(harness)).packages.removeAndPersist(plugin.install.source);
   }
@@ -10240,10 +10699,10 @@ async function runPluginsCli(argv, dependencies = {}) {
     return command ? 0 : 2;
   }
   const base = dependencies.cwd ?? process.cwd();
-  const root = join40(dependencies.home ?? homedir5(), ".xingular-harness");
-  const options2 = { dataRoot: parsed2.values.data ? resolve6(base, parsed2.values.data) : join40(root, "data"), stateDir: parsed2.values.state ? resolve6(base, parsed2.values.state) : join40(root, "state"), productName: "Xingular Harness" };
+  const root = join41(dependencies.home ?? homedir5(), ".xingular-harness");
+  const options2 = { dataRoot: parsed2.values.data ? resolve7(base, parsed2.values.data) : join41(root, "data"), stateDir: parsed2.values.state ? resolve7(base, parsed2.values.state) : join41(root, "state"), productName: "Xingular Harness" };
   const harness = dependencies.createHarness ? dependencies.createHarness(options2) : new Harness(options2);
-  const scope = { cwd: parsed2.values.cwd ? resolve6(base, parsed2.values.cwd) : null };
+  const scope = { cwd: parsed2.values.cwd ? resolve7(base, parsed2.values.cwd) : null };
   const need = (what) => {
     if (!target) throw new Error(`${command} needs ${what}.`);
     return target;
@@ -10429,7 +10888,7 @@ var RpcPeer = class {
   /** Asks the host to perform a named operation. */
   callHost(call, params, timeoutMs = 3e4) {
     const id = `s${++this.nextCallId}`;
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       const timer = setTimeout(() => {
         this.pendingCalls.delete(id);
         reject(new HarnessError("host_timeout", `The host did not answer ${call}.`));
@@ -10437,7 +10896,7 @@ var RpcPeer = class {
       this.pendingCalls.set(id, {
         resolve: (value) => {
           clearTimeout(timer);
-          resolve8(value);
+          resolve9(value);
         },
         reject: (error) => {
           clearTimeout(timer);
@@ -10488,7 +10947,7 @@ var RpcPeer = class {
 };
 
 // src/server/methods.ts
-import { readFileSync as readFileSync19, statSync as statSync6 } from "node:fs";
+import { readFileSync as readFileSync20, statSync as statSync7 } from "node:fs";
 import { basename as basename9 } from "node:path";
 
 // src/memory/graph.ts
@@ -10702,8 +11161,8 @@ function methods(harness) {
     "wiki.sources": () => listSources(wikiDir2()),
     "wiki.ingest": (params) => {
       const path3 = text5(params, "path");
-      if (statSync6(path3).size > MAX_SOURCE_BYTES) throw invalid("Sources larger than 50 MB are not imported.");
-      const source2 = maintenance.ingest(optional2(params, "name") ?? basename9(path3), readFileSync19(path3), optional2(params, "namespace") ?? LIBRARY_NAMESPACE);
+      if (statSync7(path3).size > MAX_SOURCE_BYTES) throw invalid("Sources larger than 50 MB are not imported.");
+      const source2 = maintenance.ingest(optional2(params, "name") ?? basename9(path3), readFileSync20(path3), optional2(params, "namespace") ?? LIBRARY_NAMESPACE);
       harness.bus.emit({ type: "wiki.changed" });
       return source2;
     },
@@ -10800,8 +11259,13 @@ function methods(harness) {
     "capabilities.inventory": (params) => inventory2(harness, { ...pluginScope(params), context: params.context ?? {}, launch: params.launch ?? {}, tools: Array.isArray(params.tools) ? params.tools : [], connections: params.connections }),
     "capabilities.attach": (params) => switchCapability(harness, { ...pluginScope(params), id: text5(params, "id"), scope: params.scope ?? null }, true),
     "capabilities.detach": (params) => switchCapability(harness, { ...pluginScope(params), id: text5(params, "id"), scope: params.scope ?? null }, false),
-    "capabilities.resolve": (params) => resolve4(harness, { ...pluginScope(params), tools: Array.isArray(params.tools) ? params.tools.filter((item) => typeof item === "string") : [] }),
+    "capabilities.resolve": (params) => resolve5(harness, { ...pluginScope(params), tools: Array.isArray(params.tools) ? params.tools.filter((item) => typeof item === "string") : [] }),
     "capabilities.run": (params) => loadRun2(root(), text5(params, "runId")),
+    "capabilities.intersect": (params) => toolIntersection(
+      capabilitySet(params.parent),
+      capabilitySet(params.assignee),
+      params.tools === void 0 ? void 0 : Array.isArray(params.tools) ? params.tools.filter((item) => typeof item === "string") : []
+    ),
     // ---- Runs --------------------------------------------------------------------------------------
     "runs.load": (params) => snapshot2(root(), text5(params, "runId")),
     "runs.family": (params) => runFamily(root(), text5(params, "runId")),
@@ -10863,24 +11327,24 @@ function attach3(harness, peer) {
 import { spawn as nodeSpawn } from "node:child_process";
 import { createHash as createHash8, randomUUID as randomUUID8 } from "node:crypto";
 import { homedir as homedir6 } from "node:os";
-import { join as join41, resolve as resolve7 } from "node:path";
+import { join as join42, resolve as resolve8 } from "node:path";
 function standaloneArguments(argv) {
   const command = argv[0];
   if (!command || command.startsWith("--") || command === "-h") return argv;
   return command === "terminal" ? argv.slice(1) : null;
 }
 function parseStandaloneOptions(argv, home = homedir6(), cwd = process.cwd()) {
-  const root = join41(home, ".xingular-harness");
+  const root = join42(home, ".xingular-harness");
   const paths = {
-    dataRoot: join41(root, "data"),
-    stateDir: join41(root, "state")
+    dataRoot: join42(root, "data"),
+    stateDir: join42(root, "state")
   };
   for (let index = 0; index < argv.length; index += 1) {
     const argument = argv[index];
     if (argument !== "--data" && argument !== "--state") throw new Error(`Unknown standalone option: ${argument}`);
     const value = argv[index + 1];
     if (!value || value.startsWith("--")) throw new Error(`${argument} needs a directory path.`);
-    paths[argument === "--data" ? "dataRoot" : "stateDir"] = resolve7(cwd, value);
+    paths[argument === "--data" ? "dataRoot" : "stateDir"] = resolve8(cwd, value);
     index += 1;
   }
   return paths;
@@ -10935,7 +11399,7 @@ async function runStandaloneTerminal(argv, dependencies = {}) {
   if (!(dependencies.stdinIsTTY ?? process.stdin.isTTY) || !(dependencies.stdoutIsTTY ?? process.stdout.isTTY)) {
     throw new Error("The interactive Harness terminal needs a TTY. Run it from a terminal, or use `xingular-harness serve` for a host process.");
   }
-  const cwd = resolve7(dependencies.cwd ?? process.cwd());
+  const cwd = resolve8(dependencies.cwd ?? process.cwd());
   const paths = parseStandaloneOptions(argv, dependencies.home, cwd);
   const makeHarness = dependencies.createHarness ?? createHarness;
   const harness = makeHarness({ dataRoot: paths.dataRoot, stateDir: paths.stateDir, productName: "Xingular Harness" });
@@ -10944,7 +11408,7 @@ async function runStandaloneTerminal(argv, dependencies = {}) {
     await harness.ready;
     if (harness.accounts.overview().accounts.length === 0) harness.accounts.create("Default", "subscription");
     const cwdHash = createHash8("sha256").update(cwd).digest("hex");
-    const sessionFolder = join41(paths.dataRoot, "sessions", "terminal", cwdHash);
+    const sessionFolder = join42(paths.dataRoot, "sessions", "terminal", cwdHash);
     const launch = await harness.terminals.prepare({ sessionId, cwd, sessionFolder });
     return await spawnPi(launch, cwd, dependencies.spawn);
   } finally {
@@ -11005,12 +11469,12 @@ function serveCommand(argv) {
   const harness = createHarness(options2);
   if (switches.has("host-tools")) harness.sessions.provide(remoteTools(peer));
   attach3(harness, peer);
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     let closing = false;
     const shutdown = () => {
       if (closing) return;
       closing = true;
-      void Promise.race([harness.close(), new Promise((done) => setTimeout(done, 5e3))]).then(() => resolve8(0));
+      void Promise.race([harness.close(), new Promise((done) => setTimeout(done, 5e3))]).then(() => resolve9(0));
     };
     peer.handle("harness.shutdown", () => void setImmediate(shutdown));
     process.stdin.on("end", shutdown);