@staix/agent-hub 0.12.43 → 0.12.45

package/src/hub/facts.ts

@@ -1,7 +1,7 @@
 import { repoGitArgs, repoGitEnv, type Repo } from "./snapshots.ts";
 import { isHubWritePath } from "./permission-mode.ts";
 import { createHash, randomUUID } from "node:crypto";
-import { closeSync, constants, fstatSync, mkdirSync, openSync, readSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { closeSync, constants, fstatSync, mkdirSync, openSync, readSync, rmSync, statSync, writeFileSync, type Stats } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { sanitize, type PeerId } from "./envelope.ts";
 import { isDenied } from "../local/deny.ts";
@@ -24,6 +24,22 @@ import { realPath } from "./project.ts";
 const MAX_BYTES = 256 * 1024;
 /** Larger files that are not read are hashed for the HEAD comparison while all of them in one comparison total this much or less; beyond it, none is compared. */
 const HASHED_BYTES = 64 * 1024 * 1024;
+/**
+ * A large file whose last change (ctime) is this recent may still be rewritten with the same stat: Linux before 6.13
+ * stamps files from a coarse clock, so a same-size rewrite within one tick keeps size, mtime, ctime and inode (#428).
+ * Such a file is named by its bytes, as git treats a racily clean entry: at most RACY_HASH_MAX_BYTES each, hashed once
+ * per version in a public entry point, RACY_BURST_BYTES in all per store (Facts instance) per event-loop turn (the hooks
+ * run on the daemon's loop). The HEAD comparison keeps its own bound (HASHED_BYTES) and is not limited by these.
+ * ponytail: ceilings, each falling back to the stat-only stamp (no claim either way): a racy file over the per-file cap,
+ * or past the turn's budget, misses a same-size rewrite within one timestamp tick; a racy file first seen past the
+ * budget (kept stat-only) reads as changed once when a later turn hashes it with the same bytes; a file written continuously never settles and is hashed at every look, within that budget; FAT's 2 s mtime
+ * is the widest covered; a settled file made racy with the same bytes (chmod, `cp -p`, touch) reads as changed once; a
+ * version first seen racy costs an open and a stat at every later look (largeBlob's cache answers). A per-file history
+ * of racy versions if any of these matters.
+ */
+const RACY_MS = 2000;
+const RACY_HASH_MAX_BYTES = 4 * 1024 * 1024;
+const RACY_BURST_BYTES = 16 * 1024 * 1024;
 /** Changed lines shown in one fact, all files together; the rest is counted and the files named. */
 export const MAX_LINES = 60;
 /** What Claude Code's Read returns by default: the first 2000 lines, each cut at 2000 characters. */
@@ -145,6 +161,10 @@ export class Facts {
   private readonly seenDropped = new Map<PeerId, Set<string>>();
   /** Git blob ids of large files, by path, with the stat they were taken at. */
   private readonly largeBlobs = new Map<string, { stamp: string; blob: string }>();
+  /** Blob ids of racy large files hashed in the current boundary, by path and stat (#428). */
+  private racyMemo = new Map<string, string>();
+  /** Bytes of racy large files left to hash in this event-loop turn. */
+  private racyLeft?: { bytes: number };
   /** Directories each peer acknowledged being told were cut: once per session, not at every boundary. */
   private readonly cutTold = new Map<PeerId, Set<string>>();
   /**
@@ -217,7 +237,7 @@ export class Facts {
    * ponytail: a directory swapped between the containment check and the open is followed once; an fd-relative walk
    * (openat per component) closes that if it matters.
    */
-  private load(file: string): Omit<Version, "seq"> {
+  private load(file: string, statOnly = false): Omit<Version, "seq"> {
     if (this.rel(join(this.root, file)) !== file) return { hash: "missing" };
     const projected = this.o.projection?.(join(this.root, file));
     if (projected) return { hash: projected.rawHash, blob: projected.rawBlob, text: projected.text, projected: true };
@@ -226,7 +246,10 @@ export class Facts {
       fd = openSync(join(this.root, file), constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
       const st = fstatSync(fd);
       if (!st.isFile()) return { hash: "missing" }; // a directory, a device or a fifo: never read
-      if (st.size > MAX_BYTES) return { hash: `large:${st.size}:${st.mtimeMs}` };
+      if (st.size > MAX_BYTES) {
+        const blob = statOnly ? undefined : this.racyBlob(file, fd, st);
+        return blob ? { hash: `large:${st.size}:${st.mtimeMs}:${blob}`, blob } : { hash: `large:${st.size}:${st.mtimeMs}` };
+      }
       const buf = Buffer.alloc(st.size);
       let got = 0;
       while (got < buf.length) {
@@ -317,13 +340,17 @@ export class Facts {
     const seen = files.filter((f) => head.has(f)).map((f) => [f, version(f)] as const);
     const large = seen.reduce((n, [, v]) => n + (v?.hash.startsWith("large:") ? Number(v.hash.split(":")[1]) : 0), 0);
     return new Set(seen.filter(([f, v]) => {
-      const blob = v?.blob ?? (v?.hash.startsWith("large:") && large <= HASHED_BYTES ? this.largeBlob(f, v.hash) : undefined);
+      const blob = !v?.hash.startsWith("large:") ? v?.blob : large <= HASHED_BYTES ? v.blob ?? this.largeBlob(f, v.hash, true) : undefined;
       return blob !== undefined && blob === head.get(f);
     }).map(([f]) => f));
   }
 
   /** Git's blob id of a file too large to load, streamed; undefined for anything that is not a small enough regular file. */
-  private largeBlob(file: string, observed: string): string | undefined {
+  /**
+   * `head`: for the HEAD comparison, which bounds its own hashing (HASHED_BYTES): a racy file is streamed whatever the
+   * racy cap and the turn's budget, uncached. Otherwise a racy file goes through racyBlob's limits.
+   */
+  private largeBlob(file: string, observed: string, head = false): string | undefined {
     if (this.rel(join(this.root, file)) !== file) return undefined;
     let fd: number | undefined;
     try {
@@ -333,13 +360,10 @@ export class Facts {
       // A file that stays stat-dirty but equal to HEAD is looked at again at every boundary: hashed once per version.
       const stamp = `${st.ino}:${st.size}:${st.mtimeMs}:${st.ctimeMs}`, known = this.largeBlobs.get(file);
       if (known?.stamp === stamp) return known.blob;
-      const h = createHash("sha1").update(`blob ${st.size}\0`);
-      const buf = Buffer.alloc(1024 * 1024);
-      let got = 0;
-      for (let n = 0; got < st.size && (n = readSync(fd, buf, 0, buf.length, got)) > 0; got += n) h.update(buf.subarray(0, n));
-      if (got !== st.size) return undefined; // changed while read: no claim
-      const blob = h.digest("hex");
-      this.largeBlobs.set(file, { stamp, blob });
+      // A racy stamp may name other bytes later: never cached.
+      if (Date.now() - st.ctimeMs < RACY_MS) return head ? this.racyMemo.get(racyKey(file, st)) ?? streamBlob(fd, st.size) : this.racyBlob(file, fd, st);
+      const blob = streamBlob(fd, st.size);
+      if (blob) this.largeBlobs.set(file, { stamp, blob });
       return blob;
     } catch {
       return undefined;
@@ -348,6 +372,22 @@ export class Facts {
     }
   }
 
+  /** A racy large file's blob id (#428), or undefined when it is settled, over the per-file cap or past the turn's budget. */
+  private racyBlob(file: string, fd: number, st: Stats): string | undefined {
+    if (Date.now() - st.ctimeMs >= RACY_MS || st.size > RACY_HASH_MAX_BYTES) return undefined;
+    const key = racyKey(file, st), known = this.racyMemo.get(key);
+    if (known) return known;
+    if (!this.racyLeft) {
+      const turn = this.racyLeft = { bytes: RACY_BURST_BYTES };
+      setImmediate(() => { if (this.racyLeft === turn) this.racyLeft = undefined; });
+    }
+    if (st.size > this.racyLeft.bytes) return undefined;
+    this.racyLeft.bytes -= st.size;
+    const blob = streamBlob(fd, st.size);
+    if (blob) this.racyMemo.set(key, blob);
+    return blob;
+  }
+
   /** `file` is covered again: an offer still unread that named it as dropped must not spend the notice of a later drop. */
   private coveredAgain(peer: PeerId, notice: "untracked" | "unfollowed", file: string): void {
     for (const o of this.offers.get(peer) ?? []) if (o[notice]?.includes(file)) o[notice] = o[notice]!.filter((f) => f !== file);
@@ -357,6 +397,7 @@ export class Facts {
   private boundary(): void {
     this.expanded = new Map();
     this.expandedCut = new Set();
+    this.racyMemo = new Map(); // not per turn: a rewrite between two entry points of one turn is another version
   }
 
   /** `peer` worked on `file`; `seen` is the file as it was when it did, the baseline if it has no view of it yet. */
@@ -463,6 +504,12 @@ export class Facts {
     const now = this.load(file);
     const was = this.latest.get(file);
     if (was && was.hash === now.hash) return was;
+    // Seen while racy (named by its bytes), now with the same stat but no blob (settled, or past the turn's budget): the
+    // same version if the bytes are, or when they cannot be hashed now (no claim).
+    if (was?.blob && was.hash === `${now.hash}:${was.blob}`) {
+      const blob = this.largeBlob(file, now.hash);
+      if (blob === undefined || blob === was.blob) return was;
+    }
     const version = { ...now, seq: ++this.seq };
     this.latest.set(file, version);
     if (was) {
@@ -720,7 +767,9 @@ export class Facts {
     // does, nor what they wrote before or after (a member settling keeps its files in the set).
     const written = windows.flatMap((w) => [...(this.writes.get(w.peer) ?? [])].filter(([, times]) => times.some((t) => t >= w.since && (w.until === undefined || t <= w.until))).map(([file]) => file));
     const files = [...new Set([...this.expand(paths.flatMap((p) => { const r = this.rel(p); return r ? [r] : []; }), true), ...written])].sort();
-    for (const file of files) h.update(file).update("\0").update(this.load(file).hash).update("\0");
+    // ponytail: a large file counts by its stat, racy or not, so the target does not move when it settles; a same-size
+    // rewrite within one timestamp tick does not move it either (observe() sees that one).
+    for (const file of files) h.update(file).update("\0").update(this.load(file, true).hash).update("\0");
     return h.digest("hex");
   }
 
@@ -871,3 +920,17 @@ export function codexEffect(before: string | undefined, now: { hash: string; tex
   const observed = changedLines(diff(before, now.text));
   return reported.length > 0 && reported.length === observed.length && reported.every((l, i) => l === observed[i]);
 }
+
+/** Git's blob id of the `size` bytes `fd` reads, streamed; undefined when fewer were read (changed while read). */
+function streamBlob(fd: number, size: number): string | undefined {
+  const h = createHash("sha1").update(`blob ${size}\0`);
+  const buf = Buffer.alloc(1024 * 1024);
+  let got = 0;
+  for (let n = 0; got < size && (n = readSync(fd, buf, 0, buf.length, got)) > 0; got += n) h.update(buf.subarray(0, n));
+  return got === size ? h.digest("hex") : undefined;
+}
+
+/** A racy large file's version within one boundary: its path and every stat field. */
+function racyKey(file: string, st: Stats): string {
+  return `${file}\0${st.ino}:${st.size}:${st.mtimeMs}:${st.ctimeMs}`;
+}

package/src/hub/hub-tools.ts

@@ -17,10 +17,26 @@ const refs = {
   additionalProperties: false,
 } as const;
 const list = (description: string) => ({ type: "array", items: str, description }) as const;
+const reviewFindings = {
+  type: "array", maxItems: 64,
+  description: "Head-bound findings; open Important findings carry across heads until explicitly fixed, false_positive or person-accepted; omission never settles them. Nits stay on their head. accepted is person-only and requires rationale. Nit count is capped by sdlc.max_nits (default 5).",
+  items: { type: "object", properties: {
+    id: { type: "string", minLength: 1, maxLength: 96, pattern: "^[A-Za-z0-9._:-]+$" },
+    pass: { type: "string", enum: ["bugs", "security", "compliance"] },
+    severity: { type: "string", enum: ["important", "nit"] },
+    path: { type: "string", minLength: 1, maxLength: 512 },
+    disposition: { type: "string", enum: ["open", "fixed", "false_positive", "accepted"] },
+    rationale: { type: "string", minLength: 1, maxLength: 2048 },
+  }, required: ["id", "pass", "severity", "disposition"], additionalProperties: false },
+} as const;
 const costPlanProperties = {
   review: { type: "object", properties: { scope: { type: "string", enum: ["none", "delta", "full"] }, reviewers: { type: "integer", minimum: 0, maximum: 8 } }, required: ["scope", "reviewers"], additionalProperties: false },
   ci: { type: "string", enum: ["focused", "full", "reuse"] },
 } as const;
+const evidencePlanProperties = {
+  proof: { type: "array", maxItems: 32, items: { type: "string", maxLength: 512 }, description: "test paths or check names planned to prove the change" },
+  risks: { type: "array", maxItems: 32, items: { type: "string", maxLength: 512 }, description: "short risks to check during implementation and review" },
+} as const;
 const plan = {
   type: "object",
   description: "what you will change, before you start. Owners of open tasks on the same files or symbols see it, and get a notice when your task is done.",
@@ -75,7 +91,7 @@ export const TASK_TOOLS: HubTool[] = [
   tool("hub_task_done", "Mark your task finished. It goes to its reviewer with your summary and refs; no duplicate hub_send chat is needed. When the project configures a check for its class, the hub runs it first and the result comes as a task message: a failed check keeps the task with you.", { id, summary: { type: "string", description: "what changed, why, and the check you ran with its result" }, refs }, ["id", "summary"]),
   tool("hub_sdlc_record", "Record artifact ids or claimed local checks on your task. This grants no authority or external-check evidence. Only its owner/reviewer or the person may record; only its reviewer/person may name a reviewed head or phase checklist. Phase evidence refs are content hashes, not external verification.", { id, receipt: { type: "object", properties: { stage: { type: "string", enum: ["spec", "plan", "implement", "review", "verify", "merge", "release"] }, repo: str, issue: id, pr: id, localHead: str, localResult: { type: "string", enum: ["passed", "failed", "unknown"] }, reviewedHead: str, phase: { type: "object", properties: { id: str, head: str, tasks: { type: "array", maxItems: 64, items: { type: "object", properties: { id, after: { type: "array", maxItems: 16, items: id } }, required: ["id", "after"], additionalProperties: false } }, criteria: { type: "array", maxItems: 32, items: { type: "object", properties: { id: str, required: { type: "boolean" }, result: { type: "string", enum: ["verified", "failed", "unverified"] }, refs: { type: "array", maxItems: 8, items: str } }, required: ["id", "required", "result", "refs"], additionalProperties: false } } }, required: ["id", "tasks", "criteria"], additionalProperties: false } }, additionalProperties: false } }, ["id", "receipt"]),
   tool("hub_task_list", "The task board. PII tasks show as [pii].", { state: { type: "string", enum: ["proposed", "in_progress", "in_review", "approved", "changes_requested", "cancelled"] }, ready: { type: "boolean", description: "only proposed tasks with nothing left to wait for" } }),
-  tool("hub_review", "Give your verdict on a task you were asked to review: map the changed signatures and call sites to the task's plan or detail, read the check result (hub_task_show has it, with the done summary), and list what is unmet. The verdict notifies the task owner; no duplicate hub_send chat is needed. Consecutive changes_requested verdicts (three by default, `tasks.escalate_after`) move the task to another peer.", { id, head: { type: "string", description: "full SHA actually reviewed; enforce binds approval to the current PR head" }, verdict: { type: "string", enum: ["approved", "changes_requested"] }, note: str, unmet: { type: "array", items: str, description: "each requirement of the plan or detail that the change does not meet" }, coverage: { type: "object", description: "the review brief's reviewable paths you read (reviewed) and any you did not (skipped, each with a reason); in enforce an approval must account for every one", properties: { reviewed: { type: "array", items: str }, skipped: { type: "array", items: { type: "object", properties: { path: str, reason: str }, required: ["path", "reason"] } } } } }, ["id", "verdict"]),
+  tool("hub_review", "Give your verdict on a task you were asked to review: map the changed signatures and call sites to the task's plan or detail, read the check result (hub_task_show has it, with the done summary), and list what is unmet. The verdict notifies the task owner; no duplicate hub_send chat is needed. Consecutive changes_requested verdicts (three by default, `tasks.escalate_after`) move the task to another peer.", { id, head: { type: "string", description: "full SHA actually reviewed; enforce binds approval to the current PR head" }, findings: reviewFindings, verdict: { type: "string", enum: ["approved", "changes_requested"] }, note: str, unmet: { type: "array", items: str, description: "each requirement of the plan or detail that the change does not meet" }, coverage: { type: "object", description: "the review brief's reviewable paths you read (reviewed) and any you did not (skipped, each with a reason); in enforce an approval must account for every one", properties: { reviewed: { type: "array", items: str }, skipped: { type: "array", items: { type: "object", properties: { path: str, reason: str }, required: ["path", "reason"] } } } } }, ["id", "verdict"]),
   tool("hub_checkpoint", "Answer a checkpoint request from the hub (quota or context window pressure): what you were doing, what is half done, what whoever continues must know. Write the same to .agenthub/checkpoint.md first if you can.", { summary: str, request_id: { type: "string", description: "The request id supplied by a context checkpoint request; required for context checkpoints" } }, ["summary"]),
   tool("hub_memory_search", "Search daemon-scoped visible memory, fails first. Query <=200 UTF-8 bytes; default 8, max 20 lines; whole output <=4 KB. Incomplete excerpts are marked. No project argument.", { query: { type: "string", maxLength: 200, description: "At most 200 UTF-8 bytes, enforced by the daemon" }, limit: { type: "integer", minimum: 1, maximum: 20 } }, ["query"]),
   tool("hub_memory_show", "Read up to 8 visible memory ids or unique prefixes (6..64 UTF-8 bytes each). Original ids redirect; unavailable ids share one refusal. Whole output <=8 KB.", { ids: { type: "array", minItems: 1, maxItems: 8, items: { type: "string", minLength: 6, maxLength: 64, description: "6 to 64 UTF-8 bytes" } } }, ["ids"]),
@@ -105,6 +121,42 @@ export const CONDUCTOR_TOOLS: HubTool[] = [
 ];
 export const CONDUCTOR_TOOL_NAMES = new Set(CONDUCTOR_TOOLS.map((t) => t.name));
 
+/** Authenticated status metadata only; malformed values never add a tool target. */
+function projectPeerIds(value: unknown): string[] | undefined {
+  if (!Array.isArray(value) || value.length > 256 || value.some(id => typeof id !== "string" || !/^[a-z][a-z0-9-]{0,31}$/.test(id) || ["user", "hub", "digest"].includes(id)) || new Set(value).size !== value.length) return undefined;
+  return [...value] as string[];
+}
+
+/** A project-local schema projection; released builtin arrays and all other tools keep their identity. */
+export function projectConductorTools(startPeers?: unknown): HubTool[] {
+  const peers = startPeers === undefined ? undefined : projectPeerIds(startPeers);
+  if (peers === undefined) return CONDUCTOR_TOOLS;
+  return CONDUCTOR_TOOLS.map(tool => tool.name !== "hub_peer_start" ? tool : {
+    ...tool, inputSchema: { ...tool.inputSchema, properties: { ...tool.inputSchema.properties,
+      peer: { ...(tool.inputSchema.properties.peer as Record<string, unknown>), enum: [...new Set([...CONDUCTOR_START_PEERS, ...peers])] },
+    } },
+  });
+}
+
+export interface ProjectToolContext { startPeers?: string[]; readOnly?: boolean }
+/** Ordinary projects retain their exact prior publication context; configured metadata is body-free and bounded. */
+export function configuredToolContext(status: unknown, peer: string): ProjectToolContext {
+  if (!status || typeof status !== "object" || Array.isArray(status)) return {};
+  const raw = status as Record<string, unknown>, configured = projectPeerIds(raw.configuredAdapters);
+  if (!configured?.length) return {};
+  const startPeers = projectPeerIds(raw.startablePeers), readOnlyPeers = projectPeerIds(raw.readOnlyPeers);
+  // With an incomplete configured-project reading, publish only R2 reads until authenticated status is complete.
+  if (!startPeers || !readOnlyPeers) return { readOnly: true };
+  return { startPeers, readOnly: readOnlyPeers.includes(peer) };
+}
+
+const READ_ONLY_PROJECT_TOOLS = Object.freeze(["hub_send", "hub_inbox", "hub_delivery_done", "hub_review", "hub_task_show", "hub_task_list", "hub_memory_search", "hub_memory_show", "hub_memory_graph", "hub_status"]);
+/** Publication restricts exposure only; server-side authority remains mandatory for every call. */
+export function projectToolList<T extends { name: string }>(tools: T[], readOnly = false): T[] {
+  return readOnly ? tools.filter(tool => READ_ONLY_PROJECT_TOOLS.includes(tool.name)) : tools;
+}
+
+
 /** Role contracts, by role name. Shown to each peer for the roles `.agenthub/config.json` gives it. */
 export const ROLE_TEXT: Record<string, string> = {
   conductor: "conductor: plan and split work into tasks with owners, watch the team with hub_status, move stalled work, and ensure every task is reviewed (review it yourself only if you also hold reviewer). Report results and open decisions to the person. Do not implement tasks you handed out. Never ask a peer to answer an approval; ask the person for human-only actions. You may release only holds you placed, never human holds or budget pauses.",
@@ -144,19 +196,19 @@ export function profileTaskTools(profile: ProfileSelection = "dev", stages?: rea
       properties.receipt = { ...receipt, properties: fields };
     }
     if (customProfile && tool.name === "hub_task_propose") properties.class = { type: "string", enum: [...new Set([...Object.keys(data.classes), ...PROFILE_CLASS_NAMES.filter(v => projectProfile("dev").classes[v])])] };
-    if (customProfile && properties.plan && tool.name !== "hub_task_accept") properties.plan = { ...plan, properties: Object.fromEntries(data.plan_keys.map(key => [key, plan.properties[key as keyof typeof plan.properties] ?? list(key === "sections" ? "document heading anchors, such as report.md#methods" : key === "sources" ? "citation ids, DOI or source URL ids" : "short claim ids to verify")])) };
+    if (customProfile && properties.plan && tool.name !== "hub_task_accept") properties.plan = { ...plan, properties: { ...Object.fromEntries(data.plan_keys.map(key => [key, plan.properties[key as keyof typeof plan.properties] ?? list(key === "sections" ? "document heading anchors, such as report.md#methods" : key === "sources" ? "citation ids, DOI or source URL ids" : "short claim ids to verify")])) } };
     if (customProfile && tool.name === "hub_backlog_split") {
       const parts = properties.parts as { items: { properties: Record<string, unknown> } };
-      const selectedPlan = { ...plan, properties: Object.fromEntries(data.plan_keys.map(key => [key, plan.properties[key as keyof typeof plan.properties] ?? list(key === "sections" ? "document heading anchors, such as report.md#methods" : key === "sources" ? "citation ids, DOI or source URL ids" : "short claim ids to verify")])) };
+      const selectedPlan = { ...plan, properties: { ...Object.fromEntries(data.plan_keys.map(key => [key, plan.properties[key as keyof typeof plan.properties] ?? list(key === "sections" ? "document heading anchors, such as report.md#methods" : key === "sources" ? "citation ids, DOI or source URL ids" : "short claim ids to verify")])) } };
       properties.parts = { ...parts, items: { ...parts.items, properties: { ...parts.items.properties, plan: selectedPlan } } };
     }
     if (criteria && properties.plan) {
       const current = properties.plan as { properties: Record<string, unknown> };
-      properties.plan = { ...current, properties: { ...current.properties, ...costPlanProperties } };
+      properties.plan = { ...current, properties: { ...current.properties, ...costPlanProperties, ...evidencePlanProperties } };
     }
     if (criteria && tool.name === "hub_backlog_split") {
       const parts = properties.parts as { items: { properties: { plan: { properties: Record<string, unknown> } } } };
-      properties.parts = { ...parts, items: { ...parts.items, properties: { ...parts.items.properties, plan: { ...parts.items.properties.plan, properties: { ...parts.items.properties.plan.properties, ...costPlanProperties } } } } };
+      properties.parts = { ...parts, items: { ...parts.items, properties: { ...parts.items.properties, plan: { ...parts.items.properties.plan, properties: { ...parts.items.properties.plan.properties, ...costPlanProperties, ...evidencePlanProperties } } } } };
     }
     return { ...tool, ...(customProfile && tool.name === "hub_task_propose" ? { description: tool.description + ` Selected profile ${data.name}: ${Object.keys(data.classes).join(", ")}. Routing uses their existing base classes.` } : {}), inputSchema: { ...tool.inputSchema, properties } };
   });

package/src/hub/instance-config.ts

@@ -1,6 +1,9 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import { defaultPeerRoles } from "../adapters/registry.ts";
+import { createProjectAdapterCatalog, defaultPeerRoles, definitionOf, type ProjectAdapterCatalog, type AdapterDefinition } from "../adapters/registry.ts";
+import { readAdapterModuleDeclarations, type AdapterModuleDeclaration } from "../adapters/external-modules.ts";
+import { externalMetadataDefinitions } from "../adapters/external-metadata.ts";
+import { readControl, stateDirFor } from "./control-client.ts";
 import { conductorPeer } from "./conductor.ts";
 import { configRefusal } from "./config-trust.ts";
 import { validateInstances, type InstancesConfig } from "./instances.ts";
@@ -17,24 +20,42 @@ export function readInstanceConfigLayers(cwd: string): InstanceConfigLayer[] {
 }
 
 /** Declaration authority is file provenance, never a suffix or a claim made by a native child. */
-export function readInstanceConfig(cwd: string, layers: readonly InstanceConfigLayer[] = readInstanceConfigLayers(cwd)): { instances?: InstancesConfig; ignored: string[] } {
-  const ignored: string[] = [];
-  let instances: InstancesConfig | undefined;
+export interface InstanceRoleConfig {
+  adapter_modules?: readonly AdapterModuleDeclaration[];
+  adapters?: Readonly<Record<string, import("../adapters/configured-acp.ts").ConfiguredAcpAdapterConfig>>;
+  instances?: InstancesConfig;
+  catalog: ProjectAdapterCatalog;
+  ignored: string[];
+}
+export function readInstanceConfig(cwd: string, layers: readonly InstanceConfigLayer[] = readInstanceConfigLayers(cwd), externalDefinitions?: readonly AdapterDefinition[]): InstanceRoleConfig {
+  const moduleConfig = readAdapterModuleDeclarations(cwd, layers);
+  const ignored: string[] = [...moduleConfig.ignored];
+  let adapters: Readonly<Record<string, import("../adapters/configured-acp.ts").ConfiguredAcpAdapterConfig>> | undefined, rawInstances: unknown;
   for (const { name, raw } of layers) {
-    const checked = validateInstances(raw.instances);
-    if (!Object.keys(checked).length) continue;
-    if (name !== "config.local.json") { ignored.push(`instances in .agenthub/${name} ignored: instances are machine-local config.local.json declarations`); continue; }
-    const refusal = configRefusal(cwd, name);
-    if (refusal) ignored.push(`instances in .agenthub/${name} ignored: ${refusal}`);
-    else instances = checked;
+    const keys = ["adapters", "instances"].filter(key => raw[key] !== undefined);
+    if (!keys.length) continue;
+    const refusal = name !== "config.local.json" ? "declarations are machine-local config.local.json values" : configRefusal(cwd, name);
+    if (refusal) { ignored.push(`${keys.join(", ")} in .agenthub/${name} ignored: ${refusal}`); continue; }
+    if (raw.adapters !== undefined) adapters = raw.adapters as Readonly<Record<string, import("../adapters/configured-acp.ts").ConfiguredAcpAdapterConfig>>;
+    if (raw.instances !== undefined) rawInstances = raw.instances;
+  }
+  let external = externalDefinitions;
+  if (external === undefined) {
+    // Metadata discovery is optional: retained recovery receipts may name a project that no longer exists.
+    let metadata;
+    try { metadata = readControl(stateDirFor(cwd))?.externalAdapters; } catch { /* no running catalog available */ }
+    external = externalMetadataDefinitions(metadata);
   }
-  return { ...(instances ? { instances } : {}), ignored };
+  const catalog = createProjectAdapterCatalog(adapters, external);
+  const instances = validateInstances(rawInstances, catalog);
+  return { ...(moduleConfig.modules.length ? { adapter_modules: moduleConfig.modules } : {}), ...(adapters !== undefined ? { adapters } : {}), ...(Object.keys(instances).length ? { instances } : {}), catalog, ignored };
 }
 
 /** Capture ordinary role policy and trusted instance declarations together, without loading daemon configuration. */
-export function readInstanceRoleConfig(cwd: string, layers: readonly InstanceConfigLayer[] = readInstanceConfigLayers(cwd)): { instances?: InstancesConfig; roles: Record<string, string[]>; ignored: string[] } {
+export function readInstanceRoleConfig(cwd: string, layers: readonly InstanceConfigLayer[] = readInstanceConfigLayers(cwd)): InstanceRoleConfig & { roles: Record<string, string[]> } {
   const declarationConfig = readInstanceConfig(cwd, layers);
   const roles = defaultPeerRoles(false);
+  for (const definition of declarationConfig.catalog.definitions) if (!definitionOf(definition.kind)) roles[definition.kind] = [...definition.roles];
   for (const name of INSTANCE_CONFIG_FILES) {
     const raw = layers.find(layer => layer.name === name)?.raw;
     if (raw?.roles !== undefined) {

package/src/hub/instance-execution.ts

@@ -1,23 +1,35 @@
 import { lstatSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { definitionOf } from "../adapters/registry.ts";
+import type { ProjectAdapterCatalog } from "../adapters/registry.ts";
 import { hubGitSync } from "./git.ts";
 import { realPath } from "./project.ts";
 import { validateInstances, type InstancesConfig } from "./instances.ts";
 
 const refuse = (reason: string): never => { throw new Error(`instance execution workspace refused: ${reason}`); };
-const GIT_TIMEOUT_MS = 5000, GIT_OUTPUT_BYTES = 1024 * 1024;
-function git(cwd: string, args: string[]): string {
-  const result = hubGitSync(["-C", cwd, ...args], { encoding: "utf8", timeout: GIT_TIMEOUT_MS, maxBuffer: GIT_OUTPUT_BYTES });
-  if (result.error || result.status !== 0) return refuse("Git workspace evidence unavailable");
-  return result.stdout;
+// #225: this runs synchronously on the daemon's event loop (an extra-instance start, turn_revert), and a resolution makes up to four git
+// calls. One allowance covers all of them, so the loop is held for at most GIT_BUDGET_MS in git however many calls remain; a call that
+// finds the allowance spent refuses without starting git. ponytail: the calls stay synchronous because the CLI and recovery callers are
+// synchronous by contract; an async twin for the two daemon call sites is the upgrade if a typical resolution ever costs more than a few ms
+// (measured about 15 ms for four calls on a warm local repository).
+const GIT_BUDGET_MS = 5000, GIT_OUTPUT_BYTES = 1024 * 1024;
+type Gitter = (cwd: string, args: string[]) => string;
+function gitWithin(budgetMs: number, clock: () => number, run: typeof hubGitSync = hubGitSync): Gitter {
+  const deadline = clock() + budgetMs;
+  return (cwd, args) => {
+    const left = Math.floor(deadline - clock());
+    if (left <= 0) return refuse("Git workspace evidence unavailable");
+    const result = run(["-C", cwd, ...args], { encoding: "utf8", timeout: left, maxBuffer: GIT_OUTPUT_BYTES });
+    if (result.error || result.status !== 0) return refuse("Git workspace evidence unavailable");
+    return result.stdout;
+  };
 }
-const commonDirectory = (cwd: string): string => realPath(git(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"]).replace(/\n$/, ""));
+const commonDirectory = (git: Gitter, cwd: string): string => realPath(git(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"]).replace(/\n$/, ""));
 
 /** Point-in-time read only. No worktree is created, repaired or chosen implicitly. */
-export function resolveInstanceExecutionCwd(projectRoot: string, id: string, declarations: InstancesConfig | undefined, roles: readonly string[]): string {
-  if (definitionOf(id)) return projectRoot;
-  const declaration = validateInstances(declarations)[id];
+export function resolveInstanceExecutionCwd(projectRoot: string, id: string, declarations: InstancesConfig | undefined, roles: readonly string[], adapterCatalog: ProjectAdapterCatalog, budgetMs = GIT_BUDGET_MS, clock: () => number = () => performance.now(), run: typeof hubGitSync = hubGitSync): string {
+  if (adapterCatalog.definitionOf(id)) return projectRoot;
+  const git = gitWithin(budgetMs, clock, run);
+  const declaration = validateInstances(declarations, adapterCatalog)[id];
   if (!declaration) return refuse("extra instance is not declared");
   const implementer = roles.includes("implementer");
   if (!declaration.worktree) {
@@ -41,7 +53,7 @@ export function resolveInstanceExecutionCwd(projectRoot: string, id: string, dec
     try { return realPath(path) === cwd; } catch { return false; }
   });
   if (matches.length !== 1 || matches[0]!.some(field => field === "prunable" || field.startsWith("prunable "))) return refuse("directory is not an available registered project worktree");
-  if (commonDirectory(root) !== commonDirectory(cwd)) return refuse("worktree belongs to a different Git repository");
+  if (commonDirectory(git, root) !== commonDirectory(git, cwd)) return refuse("worktree belongs to a different Git repository");
   const top = git(cwd, ["rev-parse", "--show-toplevel"]).replace(/\n$/, "");
   if (realPath(top) !== cwd) return refuse("directory is not the registered worktree root");
   if (implementer && !matches[0]!.some(field => field.startsWith("branch refs/heads/") && field.length > "branch refs/heads/".length)) return refuse("an implementer worktree requires an attached branch");

package/src/hub/instances.ts

@@ -1,5 +1,5 @@
 import { types } from "node:util";
-import { ADAPTERS, defaultPeerRoles, definitionOf, type AdapterDefinition, type StartForm } from "../adapters/registry.ts";
+import { defaultPeerRoles, definitionOf, type AdapterDefinition, type StartForm, type ProjectAdapterCatalog } from "../adapters/registry.ts";
 import { isPermissionMode, type PermissionMode } from "./permission-mode.ts";
 
 export interface InstanceConfig {
@@ -9,6 +9,7 @@ export interface InstanceConfig {
   permission_mode?: PermissionMode;
   review_mode?: "fresh";
   worktree?: string;
+  readOnly?: boolean;
 }
 export type InstancesConfig = Readonly<Record<string, InstanceConfig>>;
 export interface InstanceCatalogEntry { id: string; kind: string; definition: AdapterDefinition; config?: InstanceConfig }
@@ -40,20 +41,32 @@ function roles(value: unknown, field: string): string[] {
   return out;
 }
 
-/** Pure I2 declaration validation. Physical worktree and startup authority checks belong to the bound host. */
-export function validateInstances(raw: unknown): InstancesConfig {
+/** Declaration support is explicit policy, independent of the native MCP binding mechanism. */
+export function supportsHeadlessInstances(definition: AdapterDefinition): boolean {
+  return definition.instances?.mode === "headless" && !!definition.start.create && definition.start.forms.includes("headless");
+}
+
+/** Resolve project declarations only through their captured, explicit catalog. */
+export function instanceDefinitionOf(id: string, declarations: InstancesConfig | undefined, catalog: ProjectAdapterCatalog): AdapterDefinition | undefined {
+  return catalog.definitionOf(id, declarations);
+}
+
+/** Pure I2 validation; physical worktree and startup authority stay host-bound. */
+export function validateInstances(raw: unknown, catalog: ProjectAdapterCatalog): InstancesConfig {
+  const resolve = catalog.definitionOf;
   const result: Record<string, InstanceConfig> = Object.create(null);
   if (raw === undefined) return Object.freeze(result);
   const declarations = fields(raw, "instances");
   if (Object.keys(declarations).length > MAX_INSTANCES) return fail("instances", "at most 64 extra instances are supported");
   for (const [id, descriptor] of Object.entries(declarations)) {
-    if (!PEER_ID.test(id) || RESERVED.has(id) || definitionOf(id)) return fail("instances", "ids must be nonreserved extra instance ids, not builtin ids");
+    if (!PEER_ID.test(id) || RESERVED.has(id) || resolve(id)) return fail("instances", "ids must be nonreserved extra instance ids, not builtin ids");
     const path = `instances.${id}`, entry = fields(descriptor.value, path);
-    if (Object.keys(entry).some(key => !["kind", "roles", "start_mode", "permission_mode", "worktree", "review_mode"].includes(key))) return fail(path, "unsupported field");
+    if (Object.keys(entry).some(key => !["kind", "roles", "start_mode", "permission_mode", "worktree", "review_mode", "readOnly"].includes(key))) return fail(path, "unsupported field");
     const kind: unknown = entry.kind?.value;
     if (typeof kind !== "string") return fail(`${path}.kind`, "must name a native kind");
-    const definition = definitionOf(kind), prefix = `${kind}-`;
-    if (!definition) return fail(`${path}.kind`, "unknown native kind");
+    const definition = resolve(kind), prefix = `${kind}-`;
+    if (!definition) return fail(`${path}.kind`, "unknown native kind (external adapter instances are unsupported in A4)");
+    if (catalog.externalDefinitions.some(item => item.kind === kind)) return fail(`${path}.kind`, "external adapter instances are unsupported in A4");
     if (!id.startsWith(prefix) || !/^[a-z0-9][a-z0-9-]*$/.test(id.slice(prefix.length))) return fail(path, "id must be <kind>-<name>");
     const declaredRoles = entry.roles ? roles(entry.roles.value, `${path}.roles`) : [];
     const reviewer = (definition.reviewerVariant ?? definition).reviewer;
@@ -63,11 +76,12 @@ export function validateInstances(raw: unknown): InstancesConfig {
     if (definition.routing?.reviewOnly && !freshReviewer) return fail(path, "a review-only kind requires headless roles exactly [\"reviewer\"]");
     if (freshReviewer && entry.worktree) return fail(`${path}.worktree`, "a fresh reviewer reads the project checkout: worktree is not supported");
     if (freshReviewer && entry.permission_mode) return fail(`${path}.permission_mode`, "a fresh reviewer has a fixed read-only policy");
-    // #450 I3: a channel-plugin kind (Claude) runs only in the person's terminal, so it reviews or plans and never owns writes.
-    const channel = definition.identity.mcp === "channel-plugin";
+    // An external instance runs only in the person's terminal; its definition bounds the declared roles.
+    const external = definition.instances?.mode === "external";
+    const runtime = freshReviewer ? definition.reviewerVariant ?? definition : definition;
     const unavailableReviewer = freshReviewer && !!(definition.reviewerVariant ?? definition).reviewer?.unavailable;
-    if (!channel && !unavailableReviewer && (!definition.start.create || !definition.start.forms.includes("headless") || !["env", "acp-session"].includes(definition.identity.mcp))) return fail(`${path}.kind`, "unsupported; a headless factory with env or ACP-session identity, or a channel-plugin kind, is required, not project-file identity");
-    if (channel) {
+    if (!unavailableReviewer && runtime.instances?.mode !== "external" && !supportsHeadlessInstances(runtime)) return fail(`${path}.kind`, definition.reviewerVariant ? 'unsupported; this kind only declares headless reviewer instances with roles exactly ["reviewer"]' : "unsupported; explicit external instance policy or a headless instance policy with a headless factory is required");
+    if (external) {
       const declared = entry.roles ? roles(entry.roles.value, `${path}.roles`) : [];
       // #223: a headless one is the kind's reviewer variant, one fresh hub-run session per review request.
       if (entry.start_mode && definition.reviewerVariant) {
@@ -75,10 +89,20 @@ export function validateInstances(raw: unknown): InstancesConfig {
         if (declared.length !== 1 || declared[0] !== "reviewer") return fail(`${path}.roles`, "a headless channel-kind instance is a reviewer: roles must be exactly [\"reviewer\"]");
       } else {
         if (entry.start_mode || entry.worktree) return fail(path, "a channel instance starts only from the person's terminal (ahub <kind> --as <id>): start_mode and worktree are not supported; a headless reviewer declares roles [\"reviewer\"] and start_mode \"headless\"");
-        if (!declared.length || declared.some(role => role !== "reviewer" && role !== "planner")) return fail(`${path}.roles`, "a channel instance must declare its roles: reviewer and/or planner");
+        const allowed = definition.instances?.roles ?? definition.roles;
+        if (!declared.length || declared.some(role => !allowed.includes(role))) return fail(`${path}.roles`, "a channel instance must declare its roles: reviewer and/or planner");
       }
+    } else {
+      const allowed = runtime.instances?.roles;
+      if (allowed && (declaredRoles.length ? declaredRoles : runtime.roles).some(role => !allowed.includes(role))) return fail(`${path}.roles`, "roles must fit the definition's instance policy");
+    }
+    if (entry.readOnly) {
+      if (typeof entry.readOnly.value !== "boolean") return fail(`${path}.readOnly`, "must be a boolean");
+      if (!runtime.permission.genericAcp?.readOnly) return fail(`${path}.readOnly`, "native adapter has no verified read-only mode");
+      if (entry.readOnly.value && entry.permission_mode) return fail(`${path}.permission_mode`, "read-only instances cannot select a permission mode");
     }
     const value: InstanceConfig = { kind, ...(entry.review_mode ? { review_mode: "fresh" as const } : {}) };
+    if (entry.readOnly) value.readOnly = entry.readOnly.value as boolean;
     if (entry.roles) { value.roles = roles(entry.roles.value, `${path}.roles`); Object.freeze(value.roles); }
     if (entry.start_mode) {
       if (entry.start_mode.value !== "headless") return fail(`${path}.start_mode`, "I2 extra instances require headless mode");
@@ -99,24 +123,25 @@ export function validateInstances(raw: unknown): InstancesConfig {
 }
 
 /** Each call derives a fresh project-local projection, without registration or suffix discovery. */
-export function instanceCatalog(declarations?: InstancesConfig): readonly InstanceCatalogEntry[] {
-  const instances = validateInstances(declarations);
+export function instanceCatalog(declarations: InstancesConfig | undefined, catalog: ProjectAdapterCatalog): readonly InstanceCatalogEntry[] {
+  const instances = validateInstances(declarations, catalog);
   return Object.freeze([
-    ...ADAPTERS.map(definition => Object.freeze({ id: definition.kind, kind: definition.kind, definition })),
-    ...Object.entries(instances).map(([id, config]) => Object.freeze({ id, kind: config.kind, definition: definitionOf(id, instances)!, config })),
+    ...catalog.definitions.map(definition => Object.freeze({ id: definition.kind, kind: definition.kind, definition })),
+    ...Object.entries(instances).map(([id, config]) => Object.freeze({ id, kind: config.kind, definition: catalog.definitionOf(id, instances)!, config })),
   ]);
 }
-export function instancePeerIds(declarations?: InstancesConfig): string[] { return instanceCatalog(declarations).map(entry => entry.id); }
-export function instanceDefaultRoles(declarations?: InstancesConfig, includeOptional = true): Record<string, string[]> {
+export function instancePeerIds(declarations: InstancesConfig | undefined, catalog: ProjectAdapterCatalog): string[] { return instanceCatalog(declarations, catalog).map(entry => entry.id); }
+export function instanceDefaultRoles(declarations: InstancesConfig | undefined, includeOptional: boolean, catalog: ProjectAdapterCatalog): Record<string, string[]> {
   const result = defaultPeerRoles(includeOptional);
-  const instances = validateInstances(declarations);
-  for (const [id, config] of Object.entries(instances)) result[id] = [...(config.roles ?? definitionOf(id, instances)!.roles)];
+  for (const definition of catalog.definitions) if (!definitionOf(definition.kind) && (includeOptional || !definition.optional)) result[definition.kind] = [...definition.roles];
+  const instances = validateInstances(declarations, catalog);
+  for (const [id, config] of Object.entries(instances)) result[id] = [...(config.roles ?? catalog.definitionOf(id, instances)!.roles)];
   return result;
 }
 
 /** One precedence rule for startup, native launch and recovery; ordinary roles may use the instance id or its kind. */
-export function effectiveInstanceRoles(id: string, declarations: InstancesConfig | undefined, policyRoles: Readonly<Record<string, readonly string[]>>): string[] {
-  const definition = definitionOf(id, declarations);
+export function effectiveInstanceRoles(id: string, declarations: InstancesConfig | undefined, policyRoles: Readonly<Record<string, readonly string[]>>, catalog: ProjectAdapterCatalog): string[] {
+  const definition = catalog.definitionOf(id, declarations);
   if (!definition) throw new Error(`${id}: no declared native instance`);
   const declaration = declarations && Object.hasOwn(declarations, id) ? declarations[id] : undefined;
   const ownRoles = (key: string): readonly string[] | undefined => Object.hasOwn(policyRoles, key) ? policyRoles[key] : undefined;

package/src/hub/lifecycle-schema.ts

@@ -1,18 +1,20 @@
 import { ControlClient } from "./control-client.ts";
+import { configuredToolContext, type ProjectToolContext } from "./hub-tools.ts";
 import { SDLC_STAGES } from "./sdlc.ts";
 /** The daemon owns the active definition. Unavailable reads never invent a project-file stage set. */
 /** The active stage ids and whether the lifecycle is enabled (`criteria`, #481 S8); an older daemon never says so. */
-export async function activeLifecycle(stateDir: string, peer: string, projectRoot: string, active?: ControlClient): Promise<{ stages: string[]; criteria: boolean } | undefined> {
+export async function activeLifecycle(stateDir: string, peer: string, projectRoot: string, active?: ControlClient): Promise<({ stages: string[]; criteria: boolean } & ProjectToolContext) | undefined> {
   let client: ControlClient | undefined;
   try {
     client = active ?? await ControlClient.connect(stateDir, { role: "tools", peer, projectRoot }, 1000);
     const reply = await client.request({ t: "status" }, 1000);
     if (reply.t !== "status" || !reply.status || typeof reply.status !== "object" || Array.isArray(reply.status)) return undefined;
+    const projectTools = configuredToolContext(reply.status, peer);
     // A live older daemon has the fixed seven-stage contract and no optional metadata field.
-    if (!Object.hasOwn(reply.status, "lifecycleStages")) return { stages: [...SDLC_STAGES], criteria: false };
+    if (!Object.hasOwn(reply.status, "lifecycleStages")) return { stages: [...SDLC_STAGES], criteria: false, ...projectTools };
     const stages: unknown = reply.status.lifecycleStages;
     if (!Array.isArray(stages) || !stages.length || stages.length > 32 || stages.some(s => typeof s !== "string" || !/^[a-z][a-z0-9_-]{0,47}$/.test(s)) || new Set(stages).size !== stages.length) return undefined;
-    return { stages: [...stages] as string[], criteria: reply.status.lifecycleCriteria === true };
+    return { stages: [...stages] as string[], criteria: reply.status.lifecycleCriteria === true, ...projectTools };
   } catch { return undefined; }
   finally { if (client !== active) client?.close(); }
 }

package/src/hub/memory-profile.ts

@@ -117,6 +117,14 @@ export function memoryProjectFor(cwd: string, opts: Pick<StoreOptions, "home"> =
   return resolveAlias(homeFor(opts), memoryProjectKey(cwd));
 }
 
+/**
+ * #240: the project key for a caller-injected store. Its alias log is the one in its own bound home (`profile.home`),
+ * never the ambient memory home's: a different alias log could hide that store's rows or refuse its writes.
+ */
+export function memoryProjectForStore(store: MemoryStore, cwd: string): string {
+  return resolveAlias(canonicalHome(store.profile.home), memoryProjectKey(cwd));
+}
+
 /** Inspect selection without constructing a store, index, or candidate sidecar. */
 export function selectedMemoryProfile(opts: StoreOptions = {}): MemoryProfileReceipt {
   assertLoadedAgentMem();
@@ -241,11 +249,16 @@ export function openProfileMemory(opts: ProfileMemoryOptions = {}, onUnavailable
   }
 }
 
-/** Bind a caller-owned store only when it exactly matches the current person selection. */
-export function bindProfileMemory(store: MemoryStore, onUnavailable?: (neutralReason: string) => void): {
+/**
+ * Bind a caller-owned store only when it exactly matches the current person selection. `projectKey` is the raw key
+ * the caller resolves its project from (#240): a sharded store whose home now aliases that key to another project is
+ * refused, and a later remap latches the binding unavailable, so a command never runs as B through A's shard.
+ */
+export function bindProfileMemory(store: MemoryStore, onUnavailable?: (neutralReason: string) => void, projectKey?: string): {
   store: MemoryStore; binding: MemoryProfileBinding;
 } {
-  const binding = new MemoryProfileBinding({ project: store.profile.shardKey }, onUnavailable, store.profile.home);
+  const sharded = store.profile.shardKey !== undefined;
+  const binding = new MemoryProfileBinding({ project: store.profile.shardKey, ...(sharded && projectKey !== undefined ? { projectKey } : {}) }, onUnavailable, store.profile.home);
   binding.assertCurrent();
   if (!sameProfile(store.profile, binding.profile)) throw new Error(UNAVAILABLE);
   return { store, binding };