paseo-follow-up 0.3.0 → 0.3.2

package/OVERVIEW.md

@@ -10,6 +10,6 @@ Every main view links to the overview, project settings and display settings. Yo
 
 Repair batches go to the original main agent after a click, or after explicit per-workspace Auto consent and fresh delivery checks. Recovery is a separate manual action. Done requires the main agent's declaration and settled requirements; merging and archiving remain your actions. Tasks are manual unless you explicitly schedule Now, After merge or After deploy, optionally with a delay. Deployment gates require serving-revision evidence; merges alone never prove deployment.
 
-This trusted unsandboxed plugin reads selected workspace metadata, saved agent history/configuration, GitHub status and existing CLI authentication. State and private recovery evidence remain in plugin-data/follow-through. Scoped MCP registration and reversible provider hooks support tracked main agents; Codex's trust review remains in force. Prompts and repair context are sent to your configured agent/provider. Site-specific reviewer and Cloud Run adapters only apply to the configured repository; unsupported deployments remain unknown.
+This trusted unsandboxed plugin reads selected workspace metadata, saved agent history/configuration, GitHub status and existing CLI authentication. State and private recovery evidence remain in plugin-data/follow-through. Scoped MCP registration and reversible provider hooks support tracked root sessions; contributors can register PRs from any worktree without taking main-agent authority. Successful submission receipts are discovered automatically within the workspace repository, while mentions remain unowned; Codex's trust review remains in force. Prompts and repair context are sent to your configured agent/provider. Site-specific reviewer and Cloud Run adapters only apply to the configured repository; unsupported deployments remain unknown.
 
 Merge, Merge when ready and reviewer requests require explicit developer controls. Optional direct browser grants trust that machine to change the PR toggle for the allowed repository, including later pushes; read-only grants require confirmation in Chrome. Auto and agent tools cannot authorize them. Follow-up has no Slack posting identity or background channel scanner. Stakeholder replies require the developer's authorization, original destination and a verified sent-message receipt from the agent.

package/README.md

@@ -60,7 +60,7 @@ See the [integration and security contract](https://github.com/tomgrin10/send-to
 
 This is a trusted, unsandboxed plugin. It reads selected workspace metadata, agent history/configuration and GitHub PR status using your existing host credentials. Local state and private recovery evidence live under `$PASEO_HOME/plugin-data/follow-through`; credentials and provider configuration are not published or transferred.
 
-It registers scoped Claude/Codex MCP tools and reversible provider hooks for tracked main agents. Codex keeps its normal hook trust review. Repair and recovery prompts reach your configured agent provider. Follow-up itself has no Slack posting identity and never scans channels or authorizes replies from historical mentions.
+It registers scoped Claude/Codex MCP tools and reversible provider hooks for tracked root sessions. Contributor sessions receive PR registration, status and sync tools; goal, task and completion authority stays with the designated main agent. Codex keeps its normal hook trust review. Repair and recovery prompts reach your configured agent provider. Follow-up itself has no Slack posting identity and never scans channels or authorizes replies from historical mentions.
 
 Human-operated Merge and reviewer controls perform GitHub/Graphite writes only after an explicit click and fresh eligibility checks. Unknown or uncertain results require checking before retrying. Site-specific reviewer and Cloud Run deployment adapters remain limited to their configured repository; other deployment status remains unknown rather than being inferred from a merge.
 
@@ -81,7 +81,7 @@ Release tags (`vX.Y.Z`) run `.github/workflows/publish-npm.yml`. GitHub Actions
 
 ## Paseo 0.14 agent integration
 
-The Follow-up MCP attaches when a tracked main or active recovery agent opens a Claude or Codex session. Normal startup no longer writes global Claude/Codex MCP settings. Existing global entries are preserved. Turn-ended discovery now fetches recent history through the SDK because Paseo 0.13+ sends an empty timeline in lifecycle events.
+The Follow-up MCP attaches when a root agent in a tracked workspace or an active recovery agent opens a Claude or Codex session. Other root sessions get `workspace_status`, `register_pr` and `sync_workspace`, even when the originally recorded main agent is unavailable. Normal startup no longer writes global Claude/Codex MCP settings. Existing global entries are preserved. Turn-ended discovery now fetches recent history through the SDK because Paseo 0.13+ sends an empty timeline in lifecycle events.
 
 Requires Paseo **0.14.0 or newer**. Agent tools are scoped to interactive Claude
 and Codex sessions; history-only opens receive none. They become available on
@@ -101,3 +101,21 @@ Also available from [Tom Gringauz](https://github.com/tomgrin10):
 - [Session Guard](https://github.com/tomgrin10/paseo-session-guard) — Pause at usage limits and resume after reset.
 - [Transfer](https://github.com/tomgrin10/paseo-transfer) — Copy or move workspaces and agent conversations between hosts.
 - [Transcript Search](https://github.com/tomgrin10/paseo-transcript-search) — Search active and archived conversations across hosts.
+
+
+Successful `gt submit` and `gh pr create` receipts in root-session history also discover submitted
+PRs automatically, including from secondary git worktrees. Discovery checks the workspace's GitHub
+repository identity; merely mentioned PRs and read-only commands do not establish ownership.
+Explicit registrations, exclusions and another tracked workspace's ownership take precedence.
+Observed GitHub base/head branches supply inferred stack relationships; explicit edits override them.
+Tracking continues after the checkout branch's PR merges, and the submitting session remains the
+recipient for Send to Paseo. Existing sessions can use the hook-provided CLI fallback before their
+next MCP session refresh. Automatic discovery does not transfer main-agent authority or enable Auto.
+
+
+Agents launched by another agent into a separate workspace can be that new workspace’s main agent.
+The creator’s parent-agent label records launch provenance; it excludes an agent from local main
+selection only when the parent belongs to the same workspace. Parent membership is checked from
+the daemon, including direct lookup when the creator is no longer in the live directory. Unknown
+membership does not grant new scope. Workspace-first creation is supported: tracking waits for an
+available local main, then applies the project default. Explicit Track also supports these launches.

package/index.server.ts

@@ -6,6 +6,7 @@ import { randomUUID } from "node:crypto";
 import * as rpc from "./shared/contracts";
 import { prOwner } from "./server/pr-owner";
 import { type Workspace } from "./shared/model";
+import { isWorkspaceRoot } from "./server/workspace-agent";
 import { Store } from "./server/store";
 import { Engine, agentWorkspace, findWorkspace, interruptionHold } from "./server/engine";
 import { Github } from "./server/github";
@@ -63,6 +64,8 @@ export default function contribute(server: PluginServerContext) {
   const callerWorkspaceId = async (agentId: string, paseo: PluginHandlerContext["paseo"], allowHandoff = true) => {
     const agent = (await paseo.agents.ref(agentId).refresh())?.agent;
     if (!agent?.workspaceId) throw new Error(`Cannot locate the caller's workspace: expected agent in a recorded workspace, received agent ${agentId}.`);
+    const record = (await store.snapshot()).workspaces.find(w => w.id === agent.workspaceId);
+    if (record?.contributorAgentIds?.includes(agentId) && !record.batches.some(b => b.recipientAgentId === agentId && !b.settledAt && b.tasks.every(t => t.kind === "inventory")) && (!await isWorkspaceRoot(agent, async id => (await paseo.agents.ref(id).refresh())?.agent) || agent.labels["follow-through.recovery"])) throw new Error("PR registration requires an available root agent in this tracked workspace.");
     if (allowHandoff) {
       const w = (await store.snapshot()).workspaces.find(w => w.id === agent.workspaceId);
       if (w && w.mainAgentId !== agentId && !w.batches.some(b => b.recipientAgentId === agentId)) {
@@ -75,6 +78,7 @@ export default function contribute(server: PluginServerContext) {
             const at = new Date().toISOString();
             b.recoveryHandoffs.push({ fromAgentId: handoff.fromAgentId, toAgentId: agentId, at });
             b.recipientAgentId = agentId; b.activityAt = at;
+            record.contributorAgentIds = record.contributorAgentIds?.filter(id => id !== agentId);
             if (b.state === "blocked") { b.state = "sent"; b.result = "Recovery continued in the replacement agent; prior inventory and evidence are preserved."; }
             if (record.hold === "Recovery stopped or failed. Check the recovery agent before retrying." || record.hold === "Recovery acknowledgment was refused. Check the identity error on this batch.") record.hold = null;
           });
@@ -107,19 +111,19 @@ export default function contribute(server: PluginServerContext) {
   server.handle(rpc.syncWorkspaceRpc, async ({ agentId, summary }, { paseo }) => {
     await requireReady();
     const workspaceId = await callerWorkspaceId(agentId, paseo, false);
-    const w = agentWorkspace(await store.snapshot(), agentId, "write", workspaceId);
-    if (w.mainAgentId !== agentId || w.archived) throw new Error(`Only the active workspace main agent can confirm sidebar sync: expected ${w.mainAgentId}, received ${agentId}.`);
+    const w = agentWorkspace(await store.snapshot(), agentId, "write", workspaceId, "pr");
+    if (w.archived) throw new Error(`Only an active workspace root agent can confirm sidebar sync: expected ${w.mainAgentId}, received ${agentId}.`);
     await agentHooks.confirm(w.id, agentId, summary);
     return { workspaceId: w.id, synced: true as const };
   });
-  server.handle(rpc.agentStatusRpc, async ({ agentId }, { paseo }) => { await requireReady(); const workspaceId = await callerWorkspaceId(agentId, paseo); return agentWorkspace(await store.snapshot(), agentId, "read", workspaceId); });
+  server.handle(rpc.agentStatusRpc, async ({ agentId }, { paseo }) => { await requireReady(); const workspaceId = await callerWorkspaceId(agentId, paseo); return agentWorkspace(await store.snapshot(), agentId, "read", workspaceId, "pr"); });
   server.handle(rpc.activateRpc, async ({ workspaceId }) => { await requireReady(); return engine.activate(workspaceId); });
   server.handle(rpc.sendRpc, async ({ workspaceId, batchId }) => { await requireReady(); return engine.sendPending(workspaceId, batchId); });
   server.handle(rpc.recoverRpc, async ({ workspaceId }) => { await requireReady(); return engine.startRecovery(workspaceId); });
   server.handle(rpc.enrollRpc, async ({ agentId, workspaceId, goal }, { paseo }) => {
     await requireReady();
     const agent = (await paseo.agents.ref(agentId).refresh())?.agent;
-    if (!agent?.workspaceId || agent.archivedAt || agent.labels["paseo.parent-agent-id"]) throw new Error("Choose an available main agent in this workspace.");
+    if (!agent?.workspaceId || !await isWorkspaceRoot(agent, async id => (await paseo.agents.ref(id).refresh())?.agent)) throw new Error("Choose an available main agent in this workspace.");
     if (workspaceId && workspaceId !== agent.workspaceId) throw new Error("The chosen agent belongs to another workspace.");
     await callerWorkspaceId(agentId, paseo);
     const workspace = await paseo.workspaces.ref(agent.workspaceId).refresh();
@@ -139,7 +143,7 @@ export default function contribute(server: PluginServerContext) {
     await requireReady();
     const workspaceId = await callerWorkspaceId(agentId, paseo);
     const result = await store.mutate(state => {
-      const w = agentWorkspace(state, agentId, "write", workspaceId);
+      const w = agentWorkspace(state, agentId, "write", workspaceId, "pr");
       const key = `${repo}#${number}`;
       const excluded = w.excludedStacks.find(s => s.name === stack || s.prs.some(p => p.key === key));
       if (excluded) throw new Error(`This PR or stack was excluded from workspace scope: ${excluded.reason}. Read workspace_status and preserve the exclusion.`);
@@ -154,7 +158,7 @@ export default function contribute(server: PluginServerContext) {
         seen.add(ancestor); ancestor = w.prs.find(p => p.key === ancestor)?.parent ?? null;
       }
       const altered = !existing || existing.stack !== stack || existing.parent !== parent || disposition !== undefined && existing.disposition !== disposition;
-      if (existing) { existing.registeredAgentId = agentId; existing.stack = stack; existing.parent = parent; if (disposition !== undefined) existing.disposition = disposition; }
+      if (existing) { existing.registeredAgentId = agentId; existing.discoveredFromSubmission = false; existing.stack = stack; existing.parent = parent; if (disposition !== undefined) existing.disposition = disposition; }
       else w.prs.push({ registeredAgentId: agentId, key, repo, number, stack, parent, disposition: disposition ?? null, snapshot: null, error: null });
       if (altered) changed(w); return w;
     });
@@ -254,9 +258,9 @@ export default function contribute(server: PluginServerContext) {
   const removers = [
     server.on("agent.turn_started", async event => {
       await ready;
-      if (!stopped && !loadError) await store.mutate(state => { const w = state.workspaces.find(w => w.enable_tracking && w.mainAgentId === event.agent.id); if (w) w.completion = null; });
+      if (!stopped && !loadError) await store.mutate(state => { const w = state.workspaces.find(w => w.enable_tracking && (w.mainAgentId === event.agent.id || w.contributorAgentIds?.includes(event.agent.id))); if (w) w.completion = null; });
     }),
-    server.before("agent.session_open", async ({ request }) => {
+    server.before("agent.session_open", async ({ request }, { paseo }) => {
       await ready;
       if (loadError || stopped || request.purpose !== "interactive") return request;
       const saved = await store.snapshot();
@@ -272,8 +276,15 @@ export default function contribute(server: PluginServerContext) {
             return { ...request, env: { ...request.env, FOLLOW_THROUGH_CLI: bridge, FOLLOW_THROUGH_CLIENT_ENTRY: clientEntry() } };
         }
       }
+      if (!w && request.workspaceId && !request.labels["follow-through.recovery"] && await isWorkspaceRoot({ id: request.agentId, workspaceId: request.workspaceId, labels: request.labels }, async id => (await paseo.agents.ref(id).refresh())?.agent)) {
+        w = await store.mutate(state => {
+          const workspace = state.workspaces.find(w => w.id === request.workspaceId && w.enable_tracking && !w.archived);
+          if (workspace) workspace.contributorAgentIds = [...new Set([...(workspace.contributorAgentIds ?? []), request.agentId])];
+          return workspace;
+        });
+      }
       if (!w) return request;
-      const recovery = w.mainAgentId !== request.agentId;
+      const recovery = w.mainAgentId !== request.agentId && !w.contributorAgentIds?.includes(request.agentId);
       return withSessionMcp({ ...request, env: { ...request.env, FOLLOW_THROUGH_CLI: bridge, FOLLOW_THROUGH_CLIENT_ENTRY: clientEntry(), ...(recovery ? { FOLLOW_THROUGH_RECOVERY: "1" } : {}) } }, directory, clientEntry(), paseoHome, recovery);
     }),
     server.on("agent.turn_ended", async (event, { paseo, signal }) => {
@@ -286,20 +297,20 @@ export default function contribute(server: PluginServerContext) {
         if (["canceled", "failed"].includes(event.outcome.kind) && !guarded) await store.mutate(state => { const w = findWorkspace(state, assigned.id); const b = w.batches.find(b => b.recipientAgentId === event.agent.id && ["sending", "sent", "uncertain"].includes(b.state)); if (b) { b.state = "blocked"; b.result = b.acknowledgmentError ? `Recovery acknowledgment was refused: ${b.acknowledgmentError.error}` : "Recovery stopped or failed. Check its agent before retrying."; } });
         void engine.tick(); return;
       }
-      if (!(await store.snapshot()).workspaces.some(w => w.enable_tracking && w.mainAgentId === event.agent.id)) return;
+      if (!(await store.snapshot()).workspaces.some(w => w.enable_tracking && (w.mainAgentId === event.agent.id || w.contributorAgentIds?.includes(event.agent.id)))) return;
       gateway.markDirty(event.agent.id);
       // Since Paseo 0.13 the lifecycle payload deliberately contains no history.
       // Read a bounded tail through the plugin-owned API, outside the state lock.
       const history = await paseo.agents.ref(event.agent.id).timeline.refetch({ direction: "tail", limit: 100, projection: "canonical" }).catch(() => null);
       if (signal.aborted || stopped) return;
       if (history) await store.mutate(state => {
-        const w = state.workspaces.find(w => w.enable_tracking && w.mainAgentId === event.agent.id);
+        const w = state.workspaces.find(w => w.enable_tracking && (w.mainAgentId === event.agent.id || w.contributorAgentIds?.includes(event.agent.id)));
         if (w) applyHistory(w, extractHistory(history.entries.map(entry => entry.item), w.inventory?.historyComplete ?? false, w.inventory?.historyError ?? null), null);
       });
       const guarded = interruption && await sessionGuardOwnsInterruption(event.agent.id, interruption).catch(() => false);
       if (["canceled", "failed"].includes(event.outcome.kind) && !guarded) await store.mutate(state => {
-        const w = state.workspaces.find(w => w.enable_tracking && w.mainAgentId === event.agent.id);
-        if (w && interruption) { w.hold = interruptionHold(interruption.kind); w.interruption = interruption; w.completion = null; }
+        const w = state.workspaces.find(w => w.enable_tracking && (w.mainAgentId === event.agent.id || w.contributorAgentIds?.includes(event.agent.id)));
+        if (w && w.mainAgentId === event.agent.id && interruption) { w.hold = interruptionHold(interruption.kind); w.interruption = interruption; w.completion = null; }
       });
       void engine.tick();
     }),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "paseo-follow-up",
   "private": false,
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Track workspace pull requests, queue follow-up work, and verify completion in Paseo.",
   "type": "module",
   "files": [

package/server/agent-hook.mjs

@@ -16,7 +16,12 @@ async function save(path, value) {
   await writeFile(temporary, JSON.stringify(value), { mode: 0o600 });
   await rename(temporary, path);
 }
-function instructions(lease) {
+function instructions(lease, contributor = false) {
+  if (contributor) return [
+    "Maintain PR tracking for this session in its tracked workspace. Read workspace_status now and after compaction. Register every PR you submit, including from secondary git worktrees, with register_pr; register parents before children. References and external dependencies are not owned PRs. Call sync_workspace before finishing. The designated main agent retains goal, task, scope and completion authority.",
+    quietInstruction,
+    `Prefer native Follow-through tools. CLI fallback: FOLLOW_THROUGH_CLIENT_ENTRY=${quote(lease.clientEntry)} node ${quote(join(directory, "mcp.mjs"))} call <tool> '<json>' --compact. Do not ask the developer to maintain the sidebar.`,
+  ].join("\n\n");
   return [
     "Maintain this tracked workspace's Follow-through sidebar as part of your normal work; do not wait for a developer reminder.",
     quietInstruction,
@@ -39,19 +44,21 @@ async function main() {
   const lease = await json(join(directory, "hooks-enabled.json"));
   if (lease.expiresAt < Date.now() || !lease.clientEntry) return;
   const state = await json(join(directory, "state.json"));
-  const workspace = state.workspaces.find(w => w.mainAgentId === agentId && w.enable_tracking && !w.archived);
+  const workspace = state.workspaces.find(w => (w.mainAgentId === agentId || w.contributorAgentIds?.includes(agentId)) && w.enable_tracking && !w.archived);
   if (!workspace) return;
+  const contributor = workspace.mainAgentId !== agentId;
+  const context = () => instructions(lease, contributor);
   const name = event.hook_event_name;
   if (!["SessionStart", "UserPromptSubmit", "PostToolUse", "Stop"].includes(name)) return;
   const session = createHash("sha256").update(String(event.session_id ?? agentId)).digest("hex").slice(0, 24);
   const path = join(directory, "hook-state", `${agentId}-${session}.json`);
   const turn = await json(path).catch(() => null);
   const emit = text => process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: name, additionalContext: text } }) + "\n");
-  if (name === "SessionStart") { emit(instructions(lease)); return; }
+  if (name === "SessionStart") { emit(context()); return; }
   if (name === "UserPromptSubmit") {
     if (turn?.stopped && String(event.prompt ?? "").startsWith(stopReason)) return;
     await save(path, { startedAt: Date.now(), dirtyAt: null, stopped: false, quietRevision });
-    emit(instructions(lease)); return;
+    emit(context()); return;
   }
   if (name === "PostToolUse") {
     const tool = String(event.tool_name ?? "");
@@ -67,6 +74,6 @@ async function main() {
   const sync = await json(join(directory, "hook-state", `sync-${agentId}.json`)).catch(() => null);
   if (turn && sync?.workspaceId === workspace.id && sync.at >= Math.max(turn.startedAt, turn.dirtyAt ?? 0)) return;
   await save(path, { ...turn, startedAt: turn?.startedAt ?? Date.now(), stopped: true });
-  process.stdout.write(JSON.stringify({ decision: "block", reason: stopReason + " This is metadata bookkeeping only; do not start queued repairs or recovery.\n\n" + instructions(lease) }) + "\n");
+  process.stdout.write(JSON.stringify({ decision: "block", reason: stopReason + " This is metadata bookkeeping only; do not start queued repairs or recovery.\n\n" + context() }) + "\n");
 }
 main().catch(() => {});

package/server/daemon.ts

@@ -8,8 +8,10 @@ import type { State } from "../shared/model";
 import { defaultTracking, projectSetting, type Project } from "../shared/settings";
 import { recoveryHandoff } from "./recovery-handoff";
 import { recoveryConfig } from "./recovery-config";
-import { extractHistory, type DiscoveredWorkspace } from "./discovery";
+import { submittedPrs, type Submission } from "./submissions";
+import { extractHistory, type History, type DiscoveredWorkspace } from "./discovery";
 import type { PluginBeforeRequests } from "@getpaseo/plugin/server";
+import { isWorkspaceRoot, type WorkspaceAgent } from "./workspace-agent";
 import { SessionGuard } from "./session-guard";
 import { DeliveryDeferred } from "./delivery";
 type RecoveryAgentOptions = Partial<PluginBeforeRequests["agent.create"]["config"]> & { workspaceId: string; labels: Record<string, string>; idempotencyKey: string; env: Record<string, string> };
@@ -88,6 +90,7 @@ export class PaseoGateway implements Gateway {
   private directory: { agents: { agent: Agent }[]; workspaces: WorkspaceRow[] } | null = null;
   private dirty = new Set<string>();
   markDirty(agentId: string): void { this.dirty.add(agentId); }
+  private histories = new Map<string, { messageAt: string | null; at: number; history: History; submissions: Submission[] }>();
   async discover(state: State, workspaceId?: string): Promise<DiscoveredWorkspace[]> {
     return this.connect(async client => {
       const [agents, workspaces, catalog] = await Promise.all([
@@ -96,40 +99,66 @@ export class PaseoGateway implements Gateway {
         client.listProjects(),
       ]);
       this.directory = { agents, workspaces };
+      const parents = new Map<string, WorkspaceAgent | null>(agents.map(({ agent }) => [agent.id, agent]));
+      const findParent = async (id: string) => {
+        if (!parents.has(id)) parents.set(id, (await client.fetchAgent(id).catch(() => null))?.agent ?? null);
+        return parents.get(id);
+      };
       const discovered: DiscoveredWorkspace[] = [];
-      let scans = 0;
+      const scans: { row: DiscoveredWorkspace; agent: Agent; repo: string | null }[] = [];
       const defaults = new Set(catalog.projects.filter(p => defaultTracking(p, state.projectDefaults)).map(p => p.projectId));
       for (const workspace of workspaces.filter(w => !w.archivingAt && (workspaceId ? w.id === workspaceId : defaults.has(w.projectId ?? "") || state.workspaces.some(saved => saved.id === w.id && saved.enable_tracking && !saved.archived)))) {
         const existing = state.workspaces.find(w => w.id === workspace.id);
         if (existing?.archived) continue;
-        const roots = agents.map(row => row.agent).filter(a => a.workspaceId === workspace.id && !a.archivedAt && !a.labels["paseo.parent-agent-id"] && !a.labels["follow-through.recovery"]);
+        const candidates = agents.map(row => row.agent).filter(a => a.workspaceId === workspace.id && !a.archivedAt && !a.labels["follow-through.recovery"]);
+        const roots: Agent[] = [];
+        for (const agent of candidates) if (await isWorkspaceRoot(agent, findParent)) roots.push(agent);
         const main = chooseMainAgent(roots, existing?.mainAgentId);
-        if (!main) continue;
-        const row: DiscoveredWorkspace = { id: workspace.id, title: workspace.name || main.title || "Untitled workspace", mainAgentId: main.id, projectId: workspace.projectId, messageAt: main.lastUserMessageAt, enable_default_tracking: defaults.has(workspace.projectId ?? "") };
-        const inventory = existing?.inventory;
-        const needsHistory = !inventory || (!inventory.historyComplete && !inventory.historyError) || inventory.scannedMessageAt !== main.lastUserMessageAt || this.dirty.has(main.id);
-        if (needsHistory && scans < 4 && !["running", "initializing"].includes(main.status)) {
-          scans++;
-          try {
-            const entries: { item: unknown; seqStart: number }[] = [];
-            let cursor: { epoch: string; seq: number } | null = null;
-            let complete = false;
-            for (let pageIndex = 0; pageIndex < 100; pageIndex++) {
-              const page = await client.fetchAgentTimeline(main.id, { direction: cursor ? "before" : "tail", ...(cursor ? { cursor } : {}), limit: 500, projection: "canonical", timeout: 15_000 });
-              if (page.error || page.gap || page.staleCursor) throw new Error("Conversation history was unavailable or changed during recovery");
-              entries.push(...page.entries);
-              if (!page.hasOlder) { complete = true; break; }
-              if (!page.startCursor || (cursor && page.startCursor.epoch === cursor.epoch && page.startCursor.seq >= cursor.seq)) throw new Error("Conversation history pagination was incomplete");
-              cursor = page.startCursor;
-            }
-            row.history = extractHistory(entries.sort((a, b) => a.seqStart - b.seqStart).map(e => e.item), complete, complete ? null : "History exceeds the recovery window; inspect older transcripts during inventory");
-          } catch {
-            row.history = extractHistory([], false, "History could not be read; the recovery agent must inspect the main conversation and local transcripts during inventory");
-          }
-          this.dirty.delete(main.id);
+        if (!main && !existing) continue;
+        const row: DiscoveredWorkspace = { id: workspace.id, title: workspace.name || main?.title || existing!.title, mainAgentId: existing?.mainAgentId ?? main!.id, projectId: workspace.projectId, messageAt: main?.lastUserMessageAt ?? null, enable_default_tracking: defaults.has(workspace.projectId ?? ""), contributorAgentIds: roots.filter(a => a.id !== existing?.mainAgentId && a.id !== main?.id).map(a => a.id) };
+        // Preserve the designated owner even when it is no longer indexed. Other root
+        // sessions can still contribute their PRs without acquiring completion authority.
+        const project = catalog.projects.find(p => p.projectId === workspace.projectId);
+        const repo = project?.projectKind === "git" ? /^remote:github\.com\/([\w.-]+\/[\w.-]+?)(?:\.git)?$/.exec(project.projectKey)?.[1] ?? null : null;
+        for (const agent of roots) {
+          const cached = this.histories.get(agent.id);
+          if (!cached || cached.messageAt !== agent.lastUserMessageAt || this.dirty.has(agent.id) || (cached.history.error && Date.now() - cached.at >= 15_000) || (["running", "initializing"].includes(agent.status) && Date.now() - cached.at >= 15_000)) scans.push({ row, agent, repo });
         }
         discovered.push(row);
       }
+      // Oldest scan first prevents busy workspaces from starving later sessions.
+      scans.sort((a, b) => (this.histories.get(a.agent.id)?.at ?? 0) - (this.histories.get(b.agent.id)?.at ?? 0) || (b.agent.lastUserMessageAt ?? "").localeCompare(a.agent.lastUserMessageAt ?? ""));
+      for (const { agent, repo } of scans.slice(0, 4)) {
+        let history: History; let submissions: Submission[] = [];
+        try {
+          const entries: { item: unknown; seqStart: number }[] = [];
+          let cursor: { epoch: string; seq: number } | null = null;
+          let complete = false;
+          for (let pageIndex = 0; pageIndex < 100; pageIndex++) {
+            const page = await client.fetchAgentTimeline(agent.id, { direction: cursor ? "before" : "tail", ...(cursor ? { cursor } : {}), limit: 500, projection: "canonical", timeout: 15_000 });
+            if (page.error || page.gap || page.staleCursor) throw new Error("Conversation history was unavailable or changed during recovery");
+            entries.push(...page.entries);
+            if (!page.hasOlder) { complete = true; break; }
+            if (!page.startCursor || (cursor && page.startCursor.epoch === cursor.epoch && page.startCursor.seq >= cursor.seq)) throw new Error("Conversation history pagination was incomplete");
+            cursor = page.startCursor;
+          }
+          const items = entries.sort((a, b) => a.seqStart - b.seqStart).map(e => e.item);
+          history = extractHistory(items, complete, complete ? null : "History exceeds the recovery window; inspect older transcripts during inventory");
+          submissions = submittedPrs(items, agent.id, repo);
+        } catch { history = extractHistory([], false, "History could not be read; inspect the session or register submitted PRs explicitly"); }
+        this.histories.set(agent.id, { messageAt: agent.lastUserMessageAt, at: Date.now(), history, submissions });
+        this.dirty.delete(agent.id);
+      }
+      for (const row of discovered) {
+        const ids = [row.mainAgentId, ...(row.contributorAgentIds ?? [])];
+        const cached = ids.flatMap(id => { const h = this.histories.get(id); return h ? [h] : []; });
+        if (cached.length) {
+          row.history = { candidates: [...new Set(cached.flatMap(c => c.history.candidates))].sort(), goal: this.histories.get(row.mainAgentId)?.history.goal ?? null, complete: cached.length === ids.length && cached.every(c => c.history.complete), error: cached.find(c => c.history.error)?.history.error ?? null };
+          row.submissions = cached.flatMap(c => c.submissions);
+        }
+      }
+      const known = new Set(agents.map(a => a.agent.id));
+      for (const id of this.histories.keys()) if (!known.has(id)) this.histories.delete(id);
       return discovered;
     });
   }

package/server/discovery.ts

@@ -1,7 +1,8 @@
+import type { Submission } from "./submissions";
 import type { State, Workspace } from "../shared/model";
 
 export type History = { candidates: string[]; goal: string | null; complete: boolean; error: string | null };
-export type DiscoveredWorkspace = { id: string; title: string; mainAgentId: string; messageAt: string | null; projectId?: string | null; enable_default_tracking?: boolean; history?: History };
+export type DiscoveredWorkspace = { id: string; title: string; mainAgentId: string; messageAt: string | null; projectId?: string | null; enable_default_tracking?: boolean; history?: History; contributorAgentIds?: string[]; submissions?: Submission[] };
 
 export function extractHistory(items: readonly unknown[], complete = true, error: string | null = null): History {
   const candidates = new Set<string>();
@@ -14,7 +15,7 @@ export function extractHistory(items: readonly unknown[], complete = true, error
     if (/^(Workspace follow-through batch|Follow-through batch|Follow-through recovery) /.test(text)) continue;
     if (!goal && value.type === "user_message" && value.text && !value.text.trimStart().startsWith("<"))
       goal = value.text.trim().replace(/\s+/g, " ").slice(0, 350) || null;
-    for (const match of text.matchAll(/https:\/\/(?:github\.com|app\.graphite\.dev\/github\/pr)\/([\w.-]+)\/([\w.-]+)\/(?:pull\/)?(\d+)(?=[/?#\s)\]"'.,;:<>}]|$)/g))
+    for (const match of text.matchAll(/https:\/\/(?:github\.com|app\.graphite\.(?:com|dev)\/github\/pr)\/([\w.-]+)\/([\w.-]+)\/(?:pull\/)?(\d+)(?=[/?#\s)\]"'.,;:<>}]|$)/g))
       candidates.add(`${match[1]}/${match[2]}#${Number(match[3])}`);
   }
   return { candidates: [...candidates].sort(), goal, complete, error };
@@ -32,6 +33,7 @@ export function applyDiscovery(state: State, discovered: DiscoveredWorkspace[],
     w.title = row.title;
     // An unavailable original owner is surfaced instead of silently transferring its authority.
     if (w.mainAgentId !== row.mainAgentId || w.archived) continue;
+    if (row.contributorAgentIds) w.contributorAgentIds = row.contributorAgentIds;
     if (row.enable_default_tracking && !w.enable_tracking && (!row.projectId || state.projectDefaults?.[row.projectId] !== false)) { w.enable_tracking = true; w.enable_auto_sends = false; }
     if (!w.inventory) {
       w.inventory = { revision: 1, syncedRevision: 0, candidates: [], historyComplete: false, historyError: null, scannedMessageAt: null };
@@ -41,6 +43,15 @@ export function applyDiscovery(state: State, discovered: DiscoveredWorkspace[],
       if (w.goal === row.title && row.history.goal) w.goal = row.history.goal;
       applyHistory(w, row.history, row.messageAt);
     }
+    for (const receipt of row.submissions ?? []) {
+      const key = `${receipt.repo}#${receipt.number}`;
+      if (!w.enable_tracking || w.prs.some(p => p.key === key) ||
+        w.excludedStacks.some(stack => stack.prs.some(p => p.key === key)) ||
+        state.workspaces.some(other => other.id !== w.id && other.enable_tracking && !other.archived && other.prs.some(p => p.key === key))) continue;
+      w.prs.push({ key, repo: receipt.repo, number: receipt.number, registeredAgentId: receipt.agentId,
+        discoveredFromSubmission: true, stack: receipt.branch ?? `PR #${receipt.number}`, parent: null, disposition: null, snapshot: null, error: null });
+      w.completion = null; w.updatedAt = new Date(now).toISOString();
+    }
   }
 }
 

package/server/engine.ts

@@ -3,6 +3,7 @@ import { completionBlockers, type Workspace, type State, type Batch } from "../s
 import { Store } from "./store";
 import { Github } from "./github";
 import { batchPrompt, tasksFor, isRecovery, needsPrObservations } from "./tasks";
+import { reconcileSubmittedStacks } from "./submissions";
 import { applyDiscovery, type DiscoveredWorkspace } from "./discovery";
 import { replyRecorded } from "../shared/communication";
 import { DeliveryDeferred } from "./delivery";
@@ -80,6 +81,7 @@ export class Engine {
           p.error = observed.error;
           if (observed.snapshot) recordSnapshot(p, observed.snapshot, this.now());
         }
+        reconcileSubmittedStacks(w);
         if (w.archived) return;
         this.reconcile(w);
         const unacknowledged = w.batches.find(b => b.state === "sent" && !isRecovery(b));
@@ -309,10 +311,11 @@ export function ownedWorkspace(state: State, agentId: string, workspaceId?: stri
   requireTracking(w, agentId);
   return w;
 }
-export function agentWorkspace(state: State, agentId: string, access: "read" | "write" = "write", workspaceId?: string): Workspace {
+export function agentWorkspace(state: State, agentId: string, access: "read" | "write" = "write", workspaceId?: string, scope: "owner" | "pr" = "owner"): Workspace {
   const w = relatedWorkspace(state, agentId, workspaceId);
   const recovery = w?.batches.some(b => b.recipientAgentId === agentId && isRecovery(b) && (access === "read" || ["sending", "sent", "uncertain"].includes(b.state) || b.state === "blocked" && !b.settledAt));
-  if (!w || (w.mainAgentId !== agentId && !recovery)) throw accessError(w, agentId, access, workspaceId);
+  const contributor = scope === "pr" && w?.enable_tracking && !w.archived && w.contributorAgentIds?.includes(agentId);
+  if (!w || (w.mainAgentId !== agentId && !recovery && !contributor)) throw accessError(w, agentId, access, workspaceId);
   if (access === "write") requireTracking(w, agentId);
   return w;
 }

package/server/hook-source.ts

@@ -1,2 +1,2 @@
 // Generated by scripts/build.mjs.
-export const hookSource = "#!/usr/bin/env node\nimport { readFile, writeFile, mkdir, rename } from \"node:fs/promises\";\nimport { dirname, join } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { createHash, randomUUID } from \"node:crypto\";\n\nconst directory = dirname(fileURLToPath(import.meta.url));\nconst quietRevision = 1;\nconst quietInstruction = \"Do routine bookkeeping silently. Do not announce tracker calls, say you updated/synced the sidebar, recap panel state, or add plugin-status commentary/final paragraphs. Put receipts and evidence in the tools. User-facing messages should cover the actual work outcome, or a decision/blocker requiring the developer; answer sidebar status only when explicitly asked. If this continuation is bookkeeping only, use the tools and finish without another recap or repeating your previous answer.\";\nconst stopReason = \"Silently complete this workspace's sidebar bookkeeping before finishing.\";\nconst quote = value => \"'\" + value.replaceAll(\"'\", \"'\\\\''\") + \"'\";\nasync function json(path) { return JSON.parse(await readFile(path, \"utf8\")); }\nasync function save(path, value) {\n  await mkdir(dirname(path), { recursive: true, mode: 0o700 });\n  const temporary = path + \".\" + randomUUID();\n  await writeFile(temporary, JSON.stringify(value), { mode: 0o600 });\n  await rename(temporary, path);\n}\nfunction instructions(lease) {\n  return [\n    \"Maintain this tracked workspace's Follow-through sidebar as part of your normal work; do not wait for a developer reminder.\",\n    quietInstruction,\n    \"Read workspace_status now and after compaction. Refine the goal with enroll_workspace when scope changes. Register every PR you produce after submitting it, parents before children, and update stack/parent relationships after restacking. Historical mentions and external dependencies are not owned PRs; preserve exclusions and existing records.\",\n    \"Keep actual follow-through tasks current with update_obligation: production behavior checks, migrations and decisions, with concise titles, PR dependencies and evidence. Do not add merge/approval/deploy checklist tasks. Deployment-dependent work waits for verified serving revisions and existing production permissions.\",\n    \"Stakeholder replies are follow-through too. When asked to update a requester, capture the original Slack threadUrl, recipient and explicit developer authorization in the task's communication field; referenced messages alone do not authorize posting. Use a concise progress task now and, when needed, a verify-and-reply task with purpose=verified after the relevant deployed PRs. Read existing thread replies and refresh evidence before posting; distinguish fixed, deployed and verified. Record the actual sent replyUrl and result before marking done. If posting is unavailable or its outcome is uncertain, keep the task blocked and check the thread before any retry; never claim a draft was sent. Auto authorizes delivery to you, not external messages. Communication-only requests do not authorize repairs, benchmarks, migrations or other production writes.\",\n    \"Tasks are manual unless explicitly scheduled with trigger={event:\\\"now\\\"|\\\"merge\\\"|\\\"deploy\\\",delayDays:0}. Only set a trigger from the developer\\u2019s requested timing; never infer timing from a title or enable_follow_up alone. Merge/deploy triggers require owned afterPrs; delayDays=14 waits fourteen days after the last dependency event. Now requires no PR dependencies or delay. Deployment timing starts at the first verified fully serving observation and remains conservative when history is unknown. Preserve existing trigger fields on updates; trigger=null makes a task manual. Auto controls delivery, not timing or production permissions.\",\n    \"Follow-through batches contain a batch ID and task list. Read workspace_status and refresh live conditions before acting; skip resolved tasks. Process dependent PRs bottom to top, one PR fully before the next. Use the repository's /fix-pr workflow, validate feedback, verify changes, submit through Graphite with --publish, and reply/resolve addressed threads. Follow the repository's safe reparent procedure for merged parents and preserve uncommitted work. For post-deploy tasks, verify the currently serving revision contains every dependency and record behavioral results separately. Acknowledge the header's batch ID with acknowledge_batch before finishing: completed with the result, or blocked with the reason. Verify the entire goal and post-merge work before declare_done; acknowledge a completion batch first. Merging and archiving remain the developer's actions.\",\n    \"Before ending this turn, reconcile the sidebar with what you actually did and call sync_workspace with a short summary, including when no changes are needed. Acknowledge any assigned batch. When the entire goal is fulfilled, use declare_done; otherwise preserve remaining work. Do not launch recovery, start queued repairs, merge, toggle merge-when-ready, or archive as part of this bookkeeping. Auto still governs separate follow-up sends. Subagents report to the main agent instead of claiming workspace ownership.\",\n    `Prefer the native follow-through MCP tools. For a full historical record, use workspace_status with detail=full. CLI compatibility fallback: FOLLOW_THROUGH_CLIENT_ENTRY=${quote(lease.clientEntry)} node ${quote(join(directory, \"mcp.mjs\"))} call <tool> '<json>' --compact. Omit --compact only when an existing script needs the full response. Never ask the developer to maintain the sidebar or run this bridge.`,\n  ].join(\"\\n\\n\");\n}\nasync function main() {\n  const agentId = process.env.PASEO_AGENT_ID;\n  if (!agentId || !/^[\\w-]+$/.test(agentId) || process.env.FOLLOW_THROUGH_RECOVERY === \"1\") return;\n  let input = \"\";\n  for await (const chunk of process.stdin) { input += chunk; if (input.length > 2_000_000) return; }\n  const event = JSON.parse(input);\n  if (event.agent_id || event.hook_event_name === \"SubagentStop\") return;\n  const lease = await json(join(directory, \"hooks-enabled.json\"));\n  if (lease.expiresAt < Date.now() || !lease.clientEntry) return;\n  const state = await json(join(directory, \"state.json\"));\n  const workspace = state.workspaces.find(w => w.mainAgentId === agentId && w.enable_tracking && !w.archived);\n  if (!workspace) return;\n  const name = event.hook_event_name;\n  if (![\"SessionStart\", \"UserPromptSubmit\", \"PostToolUse\", \"Stop\"].includes(name)) return;\n  const session = createHash(\"sha256\").update(String(event.session_id ?? agentId)).digest(\"hex\").slice(0, 24);\n  const path = join(directory, \"hook-state\", `${agentId}-${session}.json`);\n  const turn = await json(path).catch(() => null);\n  const emit = text => process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: name, additionalContext: text } }) + \"\\n\");\n  if (name === \"SessionStart\") { emit(instructions(lease)); return; }\n  if (name === \"UserPromptSubmit\") {\n    if (turn?.stopped && String(event.prompt ?? \"\").startsWith(stopReason)) return;\n    await save(path, { startedAt: Date.now(), dirtyAt: null, stopped: false, quietRevision });\n    emit(instructions(lease)); return;\n  }\n  if (name === \"PostToolUse\") {\n    const tool = String(event.tool_name ?? \"\");\n    const args = JSON.stringify(event.tool_input ?? {});\n    const trackedTool = /follow[\\s_-]*through/i.test(tool) || args.includes(join(directory, \"mcp.mjs\"));\n    const dirty = !trackedTool && /(bash|shell|exec_command|write_stdin|edit|write|apply_patch|notebook)/i.test(tool);\n    const upgrade = turn?.quietRevision !== quietRevision;\n    if (dirty || upgrade) await save(path, { ...turn, startedAt: turn?.startedAt ?? (dirty ? Date.now() : 0), stopped: turn?.stopped ?? false, ...(dirty ? { dirtyAt: Date.now() } : {}), quietRevision });\n    if (upgrade) emit(quietInstruction);\n    return;\n  }\n  if (event.stop_hook_active || turn?.stopped || event.background_tasks?.length) return;\n  const sync = await json(join(directory, \"hook-state\", `sync-${agentId}.json`)).catch(() => null);\n  if (turn && sync?.workspaceId === workspace.id && sync.at >= Math.max(turn.startedAt, turn.dirtyAt ?? 0)) return;\n  await save(path, { ...turn, startedAt: turn?.startedAt ?? Date.now(), stopped: true });\n  process.stdout.write(JSON.stringify({ decision: \"block\", reason: stopReason + \" This is metadata bookkeeping only; do not start queued repairs or recovery.\\n\\n\" + instructions(lease) }) + \"\\n\");\n}\nmain().catch(() => {});\n";
+export const hookSource = "#!/usr/bin/env node\nimport { readFile, writeFile, mkdir, rename } from \"node:fs/promises\";\nimport { dirname, join } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { createHash, randomUUID } from \"node:crypto\";\n\nconst directory = dirname(fileURLToPath(import.meta.url));\nconst quietRevision = 1;\nconst quietInstruction = \"Do routine bookkeeping silently. Do not announce tracker calls, say you updated/synced the sidebar, recap panel state, or add plugin-status commentary/final paragraphs. Put receipts and evidence in the tools. User-facing messages should cover the actual work outcome, or a decision/blocker requiring the developer; answer sidebar status only when explicitly asked. If this continuation is bookkeeping only, use the tools and finish without another recap or repeating your previous answer.\";\nconst stopReason = \"Silently complete this workspace's sidebar bookkeeping before finishing.\";\nconst quote = value => \"'\" + value.replaceAll(\"'\", \"'\\\\''\") + \"'\";\nasync function json(path) { return JSON.parse(await readFile(path, \"utf8\")); }\nasync function save(path, value) {\n  await mkdir(dirname(path), { recursive: true, mode: 0o700 });\n  const temporary = path + \".\" + randomUUID();\n  await writeFile(temporary, JSON.stringify(value), { mode: 0o600 });\n  await rename(temporary, path);\n}\nfunction instructions(lease, contributor = false) {\n  if (contributor) return [\n    \"Maintain PR tracking for this session in its tracked workspace. Read workspace_status now and after compaction. Register every PR you submit, including from secondary git worktrees, with register_pr; register parents before children. References and external dependencies are not owned PRs. Call sync_workspace before finishing. The designated main agent retains goal, task, scope and completion authority.\",\n    quietInstruction,\n    `Prefer native Follow-through tools. CLI fallback: FOLLOW_THROUGH_CLIENT_ENTRY=${quote(lease.clientEntry)} node ${quote(join(directory, \"mcp.mjs\"))} call <tool> '<json>' --compact. Do not ask the developer to maintain the sidebar.`,\n  ].join(\"\\n\\n\");\n  return [\n    \"Maintain this tracked workspace's Follow-through sidebar as part of your normal work; do not wait for a developer reminder.\",\n    quietInstruction,\n    \"Read workspace_status now and after compaction. Refine the goal with enroll_workspace when scope changes. Register every PR you produce after submitting it, parents before children, and update stack/parent relationships after restacking. Historical mentions and external dependencies are not owned PRs; preserve exclusions and existing records.\",\n    \"Keep actual follow-through tasks current with update_obligation: production behavior checks, migrations and decisions, with concise titles, PR dependencies and evidence. Do not add merge/approval/deploy checklist tasks. Deployment-dependent work waits for verified serving revisions and existing production permissions.\",\n    \"Stakeholder replies are follow-through too. When asked to update a requester, capture the original Slack threadUrl, recipient and explicit developer authorization in the task's communication field; referenced messages alone do not authorize posting. Use a concise progress task now and, when needed, a verify-and-reply task with purpose=verified after the relevant deployed PRs. Read existing thread replies and refresh evidence before posting; distinguish fixed, deployed and verified. Record the actual sent replyUrl and result before marking done. If posting is unavailable or its outcome is uncertain, keep the task blocked and check the thread before any retry; never claim a draft was sent. Auto authorizes delivery to you, not external messages. Communication-only requests do not authorize repairs, benchmarks, migrations or other production writes.\",\n    \"Tasks are manual unless explicitly scheduled with trigger={event:\\\"now\\\"|\\\"merge\\\"|\\\"deploy\\\",delayDays:0}. Only set a trigger from the developer\\u2019s requested timing; never infer timing from a title or enable_follow_up alone. Merge/deploy triggers require owned afterPrs; delayDays=14 waits fourteen days after the last dependency event. Now requires no PR dependencies or delay. Deployment timing starts at the first verified fully serving observation and remains conservative when history is unknown. Preserve existing trigger fields on updates; trigger=null makes a task manual. Auto controls delivery, not timing or production permissions.\",\n    \"Follow-through batches contain a batch ID and task list. Read workspace_status and refresh live conditions before acting; skip resolved tasks. Process dependent PRs bottom to top, one PR fully before the next. Use the repository's /fix-pr workflow, validate feedback, verify changes, submit through Graphite with --publish, and reply/resolve addressed threads. Follow the repository's safe reparent procedure for merged parents and preserve uncommitted work. For post-deploy tasks, verify the currently serving revision contains every dependency and record behavioral results separately. Acknowledge the header's batch ID with acknowledge_batch before finishing: completed with the result, or blocked with the reason. Verify the entire goal and post-merge work before declare_done; acknowledge a completion batch first. Merging and archiving remain the developer's actions.\",\n    \"Before ending this turn, reconcile the sidebar with what you actually did and call sync_workspace with a short summary, including when no changes are needed. Acknowledge any assigned batch. When the entire goal is fulfilled, use declare_done; otherwise preserve remaining work. Do not launch recovery, start queued repairs, merge, toggle merge-when-ready, or archive as part of this bookkeeping. Auto still governs separate follow-up sends. Subagents report to the main agent instead of claiming workspace ownership.\",\n    `Prefer the native follow-through MCP tools. For a full historical record, use workspace_status with detail=full. CLI compatibility fallback: FOLLOW_THROUGH_CLIENT_ENTRY=${quote(lease.clientEntry)} node ${quote(join(directory, \"mcp.mjs\"))} call <tool> '<json>' --compact. Omit --compact only when an existing script needs the full response. Never ask the developer to maintain the sidebar or run this bridge.`,\n  ].join(\"\\n\\n\");\n}\nasync function main() {\n  const agentId = process.env.PASEO_AGENT_ID;\n  if (!agentId || !/^[\\w-]+$/.test(agentId) || process.env.FOLLOW_THROUGH_RECOVERY === \"1\") return;\n  let input = \"\";\n  for await (const chunk of process.stdin) { input += chunk; if (input.length > 2_000_000) return; }\n  const event = JSON.parse(input);\n  if (event.agent_id || event.hook_event_name === \"SubagentStop\") return;\n  const lease = await json(join(directory, \"hooks-enabled.json\"));\n  if (lease.expiresAt < Date.now() || !lease.clientEntry) return;\n  const state = await json(join(directory, \"state.json\"));\n  const workspace = state.workspaces.find(w => (w.mainAgentId === agentId || w.contributorAgentIds?.includes(agentId)) && w.enable_tracking && !w.archived);\n  if (!workspace) return;\n  const contributor = workspace.mainAgentId !== agentId;\n  const context = () => instructions(lease, contributor);\n  const name = event.hook_event_name;\n  if (![\"SessionStart\", \"UserPromptSubmit\", \"PostToolUse\", \"Stop\"].includes(name)) return;\n  const session = createHash(\"sha256\").update(String(event.session_id ?? agentId)).digest(\"hex\").slice(0, 24);\n  const path = join(directory, \"hook-state\", `${agentId}-${session}.json`);\n  const turn = await json(path).catch(() => null);\n  const emit = text => process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: name, additionalContext: text } }) + \"\\n\");\n  if (name === \"SessionStart\") { emit(context()); return; }\n  if (name === \"UserPromptSubmit\") {\n    if (turn?.stopped && String(event.prompt ?? \"\").startsWith(stopReason)) return;\n    await save(path, { startedAt: Date.now(), dirtyAt: null, stopped: false, quietRevision });\n    emit(context()); return;\n  }\n  if (name === \"PostToolUse\") {\n    const tool = String(event.tool_name ?? \"\");\n    const args = JSON.stringify(event.tool_input ?? {});\n    const trackedTool = /follow[\\s_-]*through/i.test(tool) || args.includes(join(directory, \"mcp.mjs\"));\n    const dirty = !trackedTool && /(bash|shell|exec_command|write_stdin|edit|write|apply_patch|notebook)/i.test(tool);\n    const upgrade = turn?.quietRevision !== quietRevision;\n    if (dirty || upgrade) await save(path, { ...turn, startedAt: turn?.startedAt ?? (dirty ? Date.now() : 0), stopped: turn?.stopped ?? false, ...(dirty ? { dirtyAt: Date.now() } : {}), quietRevision });\n    if (upgrade) emit(quietInstruction);\n    return;\n  }\n  if (event.stop_hook_active || turn?.stopped || event.background_tasks?.length) return;\n  const sync = await json(join(directory, \"hook-state\", `sync-${agentId}.json`)).catch(() => null);\n  if (turn && sync?.workspaceId === workspace.id && sync.at >= Math.max(turn.startedAt, turn.dirtyAt ?? 0)) return;\n  await save(path, { ...turn, startedAt: turn?.startedAt ?? Date.now(), stopped: true });\n  process.stdout.write(JSON.stringify({ decision: \"block\", reason: stopReason + \" This is metadata bookkeeping only; do not start queued repairs or recovery.\\n\\n\" + context() }) + \"\\n\");\n}\nmain().catch(() => {});\n";

package/server/mcp-source.ts

@@ -1,2 +1,2 @@
 // Generated by scripts/build.mjs.
-export const mcpSource = "#!/usr/bin/env node\nimport { createInterface } from \"node:readline\";\nimport { createRequire } from \"node:module\";\nimport { pathToFileURL } from \"node:url\";\nimport { readFile } from \"node:fs/promises\";\nimport { existsSync, realpathSync } from \"node:fs\";\nimport { join, delimiter } from \"node:path\";\nimport { homedir } from \"node:os\";\n\nconst string = { type: \"string\" };\nconst boolean = { type: \"boolean\" };\nconst integer = { type: \"integer\", minimum: 1 };\nconst array = { type: \"array\", items: string };\nconst communication = { type: \"object\", properties: { threadUrl: string, recipient: string, purpose: { type: \"string\", enum: [\"progress\", \"verified\"] }, authorization: string, replyUrl: { type: [\"string\", \"null\"] } }, required: [\"threadUrl\", \"recipient\"], additionalProperties: false };\nconst trigger = { type: [\"object\", \"null\"], properties: { event: { type: \"string\", enum: [\"now\", \"merge\", \"deploy\"] }, delayDays: { type: \"integer\", minimum: 0, maximum: 3650 } }, required: [\"event\"], additionalProperties: false };\nconst tools = [\n  [\"workspace_status\", \"Read the tracked workspace's durable goal, PRs, tasks, work queue and optional recovery history. Read after compaction. Returns current work by default; detail=full includes complete evidence/history. Normal follow-through does not require recovery.\", \"follow.agent-status\", { detail: { type: \"string\", enum: [\"summary\", \"full\"] } }, []],\n  [\"sync_workspace\", \"Silently confirm the sidebar matches your work before finishing, after registering owned PRs and substantive tasks. Call even when no changes are needed. Keep the summary in this tool; never announce sync or recap sidebar/plugin status to the developer. Does not declare Done, run recovery, or start repairs. Main agent only.\", \"follow.sync\", { summary: { ...string, minLength: 1, maxLength: 1000 } }, [\"summary\"]],\n  [\"enroll_workspace\", \"Refine this developer-activated workspace's goal. Ownership is initialized by Track this workspace or the project’s default-tracking setting. This tool cannot activate another workspace. Never ask the developer to enter this. Keep the goal concise; new scope reopens completion.\", \"follow.enroll\", { goal: string }, [\"goal\"]],\n  [\"register_pr\", \"Register a PR produced by this workspace. Call after every submission. Register parents first; repeat to update its stack or parent after restacking. Supply a disposition for a deliberately closed PR.\", \"follow.register-pr\", { repo: string, number: integer, stack: string, parentNumber: { type: [\"integer\", \"null\"], minimum: 1 }, disposition: string }, [\"repo\", \"number\", \"stack\"]],\n  [\"exclude_stack\", \"Correct an unrelated stack registration. Preserve its PRs and requirements in an exclusion audit; future registration is blocked. reason must cite the scope/ownership evidence. obligationIds may include related tasks without PR dependencies. Keep external dependencies separate from owned work.\", \"follow.exclude-stack\", { stack: string, reason: string, obligationIds: array }, [\"stack\", \"reason\"]],\n  [\"update_obligation\", \"Record concrete follow-through: verification, migrations, decisions or stakeholder replies. Never add approve/merge/deploy checklist tasks. afterPrs uses owner/repo#number keys. Tasks are manual unless explicitly scheduled with trigger={event:\\\"now\\\"|\\\"merge\\\"|\\\"deploy\\\",delayDays:0}. Only set a trigger from the developer’s requested timing; never infer timing from a title or enable_follow_up alone. Merge/deploy triggers require owned afterPrs; delayDays=14 waits fourteen days after the last dependency event. Now requires no PR dependencies or delay. Deployment timing starts at the first verified fully serving observation and remains conservative when history is unknown. Preserve existing trigger fields on updates; trigger=null makes a task manual. Auto controls delivery, not timing or production permissions. For Slack replies, communication records the original threadUrl, recipient, purpose (progress or verified), explicit developer authorization and sent replyUrl. Empty authorization never queues a reply; Auto does not authorize external posts. Use a verify-and-reply task after deployment for the final update. Read the thread first; mark blocked when posting is unavailable or uncertain, never treat a draft as sent. Done requires replyUrl and evidence; preserve fields when updating.\", \"follow.obligation\", { id: string, title: string, status: { type: \"string\", enum: [\"pending\", \"waiting\", \"working\", \"blocked\", \"done\", \"waived\"] }, afterPrs: array, dependencyStage: { type: \"string\", enum: [\"merged\", \"deployed\"] }, evidence: string, enable_follow_up: boolean, communication, trigger }, [\"title\", \"status\"]],\n  [\"acknowledge_batch\", \"Record a follow-up result. Complete only after verifying all tasks; blocked surfaces the reason to the developer. Always acknowledge before ending a repair turn. Keep the result within 2000 characters.\", \"follow.acknowledge\", { batchId: string, outcome: { type: \"string\", enum: [\"completed\", \"blocked\"] }, result: { ...string, maxLength: 2000 } }, [\"batchId\", \"outcome\", \"result\"]],\n  [\"declare_done\", \"Declare that the workspace goal is fulfilled. Live PR status and remaining obligations are checked; returned blockers must be resolved first. Done labels the workspace but never archives it.\", \"follow.done\", { summary: string }, [\"summary\"]],\n];\n\nfunction toolList(recovery = process.env.FOLLOW_THROUGH_RECOVERY === \"1\") { return tools.filter(t => !recovery || ![\"declare_done\", \"sync_workspace\"].includes(t[0])); }\nconst schemas = list => list.map(([name, description, , properties, required]) => ({ name, description, inputSchema: { type: \"object\", properties, required, additionalProperties: false }, annotations: { readOnlyHint: name === \"workspace_status\", destructiveHint: false } }));\nasync function scope(resolveRecovery = false) {\n  const agentId = process.env.PASEO_AGENT_ID;\n  if (!agentId) return null;\n  try {\n    const home = process.env.PASEO_HOME ?? join(homedir(), \".paseo\");\n    const directory = join(home, \"plugin-data/follow-through\");\n    const lease = JSON.parse(await readFile(join(directory, \"hooks-enabled.json\"), \"utf8\"));\n    if (!(lease.expiresAt > Date.now())) return null;\n    const state = JSON.parse(await readFile(join(directory, \"state.json\"), \"utf8\"));\n    for (const w of state.workspaces) {\n      if (!w.enable_tracking || w.archived) continue;\n      if (w.mainAgentId === agentId) return process.env.FOLLOW_THROUGH_RECOVERY === \"1\" ? \"recovery\" : \"main\";\n      if (w.batches.some(b => b.recipientAgentId === agentId && !b.settledAt && [\"sending\", \"sent\", \"blocked\", \"uncertain\"].includes(b.state) && b.tasks.every(t => t.kind === \"inventory\"))) return \"recovery\";\n    }\n    if (resolveRecovery && process.env.FOLLOW_THROUGH_RECOVERY === \"1\") {\n      const w = await call(\"follow.agent-status\", {});\n      if (w.enable_tracking && !w.archived && w.mainAgentId !== agentId && w.batches.some(b => b.recipientAgentId === agentId && !b.settledAt && [\"sending\", \"sent\", \"blocked\", \"uncertain\"].includes(b.state) && b.tasks.every(t => t.kind === \"inventory\"))) return \"recovery\";\n    }\n  } catch {}\n  return null;\n}\nfunction validate(value, schema, path = \"arguments\") {\n  const types = Array.isArray(schema.type) ? schema.type : [schema.type];\n  const type = value === null ? \"null\" : Array.isArray(value) ? \"array\" : typeof value;\n  if (!types.includes(type) && !(type === \"number\" && types.includes(\"integer\") && Number.isInteger(value))) throw new Error(`${path}: expected ${types.join(\" or \")}.`);\n  if (schema.enum && !schema.enum.includes(value)) throw new Error(`${path}: choose ${schema.enum.join(\", \")}.`);\n  if (type === \"object\") {\n    const extra = Object.keys(value).filter(k => !Object.hasOwn(schema.properties ?? {}, k));\n    if (extra.length && schema.additionalProperties === false) throw new Error(`Unknown argument ${path}.${extra.join(\", \")}. ${extra.includes(\"dependsOnPrs\") ? \"Use afterPrs with owner/repo#number keys.\" : \"Check this tool's input schema with list.\"}`);\n    for (const key of schema.required ?? []) if (!(key in value)) throw new Error(`${path}.${key} is required. Check this tool's input schema with list.`);\n    for (const [key, nested] of Object.entries(value)) if (schema.properties?.[key]) validate(nested, schema.properties[key], `${path}.${key}`);\n  }\n  if (type === \"array\") for (let i = 0; i < value.length; i++) validate(value[i], schema.items, `${path}[${i}]`);\n  if (type === \"number\" && (schema.minimum !== undefined && value < schema.minimum || schema.maximum !== undefined && value > schema.maximum)) throw new Error(`${path}: outside the allowed range.`);\n  if (type === \"string\" && (schema.minLength !== undefined && value.length < schema.minLength || schema.maxLength !== undefined && value.length > schema.maxLength)) throw new Error(`${path}: outside the allowed length.`);\n}\nfunction currentWork(w) {\n  return { id: w.id, title: w.title, goal: w.goal, mainAgentId: w.mainAgentId, enable_tracking: w.enable_tracking, enable_auto_sends: w.enable_auto_sends, hold: w.hold, archived: w.archived, runtimeBusy: w.runtimeBusy, runtimeReason: w.runtimeReason, backgroundBusy: w.backgroundBusy, completion: w.completion,\n    prs: w.prs.map(p => ({ key: p.key, stack: p.stack, parent: p.parent, disposition: p.disposition, error: p.error, ...(p.snapshot ? { title: p.snapshot.title, state: p.snapshot.state, head: p.snapshot.head, draft: p.snapshot.draft, reviewDecision: p.snapshot.reviewDecision, conflict: p.snapshot.conflict, openThreads: p.snapshot.threads.length, failedChecks: p.snapshot.failedChecks, deployment: p.snapshot.deployment } : {}) })),\n    obligations: w.obligations.filter(o => ![\"done\", \"waived\"].includes(o.status)), completedObligations: w.obligations.filter(o => [\"done\", \"waived\"].includes(o.status)).length,\n    batches: w.batches.filter(b => ![\"completed\", \"cancelled\"].includes(b.state)).map(b => ({ id: b.id, state: b.state, tasks: b.tasks, result: b.result, recipientAgentId: b.recipientAgentId, contextPath: b.contextPath })),\n    excludedStacks: w.excludedStacks.map(s => ({ name: s.name, reason: s.reason, prs: s.prs.map(p => p.key) })), detail: \"summary\" };\n}\nfunction compact(tool, input, result) {\n  if (tool === \"workspace_status\") return currentWork(result);\n  if (tool === \"declare_done\") return { workspaceId: result.workspace.id, completion: result.workspace.completion, blockers: result.blockers };\n  if (!result?.prs) return result;\n  const workspaceId = result.id;\n  if (tool === \"enroll_workspace\") return { workspaceId, goal: result.goal };\n  if (tool === \"register_pr\") { const p = result.prs.find(p => p.key === `${input.repo}#${input.number}`); return { workspaceId, pr: { key: p.key, stack: p.stack, parent: p.parent, disposition: p.disposition } }; }\n  if (tool === \"update_obligation\") return { workspaceId, obligation: result.obligations.find(o => o.id === result.updatedObligationId) };\n  if (tool === \"acknowledge_batch\") { const b = result.batches.find(b => b.id === input.batchId); return { workspaceId, batch: { id: b.id, state: b.state, result: b.result } }; }\n  if (tool === \"exclude_stack\") { const s = result.excludedStacks.find(s => s.name === input.stack); return { workspaceId, excludedStack: { name: s.name, reason: s.reason, prs: s.prs.map(p => p.key) } }; }\n  return result;\n}\nasync function loadClient() {\n  const candidates = [];\n  if (process.env.FOLLOW_THROUGH_CLIENT_ENTRY) candidates.push(() => pathToFileURL(process.env.FOLLOW_THROUGH_CLIENT_ENTRY).href);\n  const specifier = \"@getpaseo/client/internal/daemon-client\";\n  if (process.resourcesPath) candidates.push(() => pathToFileURL(createRequire(join(process.resourcesPath, \"app.asar/node_modules/@getpaseo/cli/dist/index.js\")).resolve(specifier)).href);\n  for (const directory of (process.env.PATH ?? \"\").split(delimiter)) {\n    const cli = join(directory, process.platform === \"win32\" ? \"paseo.cmd\" : \"paseo\");\n    if (existsSync(cli)) candidates.push(() => pathToFileURL(createRequire(realpathSync(cli)).resolve(specifier)).href);\n  }\n  candidates.push(() => pathToFileURL(createRequire(import.meta.url).resolve(specifier)).href);\n  for (const resolve of candidates) try { return await import(resolve()); } catch {}\n  throw new Error(\"Cannot load the installed Paseo client. Reload Follow-through to refresh its runtime connection.\");\n}\nconst batchInstructions = \"Follow-through batches contain a header with the batchId and ordered tasks. Read workspace_status and refresh live conditions; skip resolved tasks. Process PRs bottom to top, one fully before the next, using the repository's /fix-pr and safe reparent workflow. Validate feedback, verify changes, submit with Graphite --publish, reply/resolve addressed threads and preserve uncommitted work. Post-deploy tasks require verified serving revisions and existing production permissions. Stakeholder update requests are follow-through tasks: retain the original thread, recipient and developer authorization in communication. Use current evidence, distinguish fixed/deployed/verified, and read existing replies before posting. Record the sent replyUrl; a draft or uncertain send stays blocked and must be checked before retrying. Auto authorizes agent delivery only. Acknowledge the header's batchId with acknowledge_batch before finishing (completed with the result, or blocked with the reason), before declare_done for completion batches. Declare Done only after the whole goal and post-merge work are verified. Leave merging and archiving to the developer.\";\n\nasync function call(method, input) {\n  const agentId = process.env.PASEO_AGENT_ID;\n  if (!agentId) throw new Error(\"This bridge must run inside a Paseo agent (PASEO_AGENT_ID is missing).\");\n  const { DaemonClient } = await loadClient();\n  const home = process.env.PASEO_HOME ?? join(homedir(), \".paseo\");\n  const config = JSON.parse(await readFile(join(home, \"config.json\"), \"utf8\"));\n  let password = process.env.PASEO_PASSWORD;\n  if (!password && process.env.PASEO_PASSWORD_FILE) password = (await readFile(process.env.PASEO_PASSWORD_FILE, \"utf8\")).trim();\n  if (!password && home === join(homedir(), \".paseo\")) password = await readFile(join(homedir(), \"paseo-hub/secrets/daemon-password\"), \"utf8\").then(s => s.trim()).catch(() => undefined);\n  const client = new DaemonClient({ url: process.env.PASEO_DAEMON_URL ?? `ws://${config.daemon?.listen ?? \"127.0.0.1:6767\"}/ws`, clientId: \"follow-through-mcp\", clientType: \"cli\", reconnect: { enabled: false }, connectTimeoutMs: 10000, suppressSendErrors: true, ...(password ? { password } : {}) });\n  try { await client.connect(); return await client.invokePluginRpc(\"follow-through\", method, { ...input, agentId }); }\n  finally { await client.close().catch(() => undefined); }\n}\n\nconst command = process.argv[2];\nif (command === \"list\" || command === \"--help\" || command === \"help\") {\n  process.stdout.write(command === \"list\" ? JSON.stringify({ tools: schemas(toolList()) }, null, 2) + \"\\n\" : \"Usage: node mcp.mjs list | call <tool> '<json>' [--compact]\\nNative MCP returns compact receipts; workspace_status({detail:full}) requests complete history. CLI calls retain full replies unless --compact is supplied.\\n\");\n} else if (command === \"call\") {\n  try {\n    const tool = toolList().find(t => t[0] === process.argv[3]);\n    if (!tool) throw new Error(\"Unknown tool. Run list for names and input schemas.\");\n    const input = JSON.parse(process.argv[4] ?? \"{}\");\n    validate(input, schemas([tool])[0].inputSchema);\n    if (process.argv.slice(5).some(arg => arg !== \"--compact\")) throw new Error(\"Unknown CLI option. Use --compact or omit it for a full reply.\");\n    const result = await call(tool[2], input);\n    process.stdout.write(JSON.stringify(process.argv.includes(\"--compact\") && input.detail !== \"full\" ? compact(tool[0], input, result) : result, null, 2) + \"\\n\");\n  } catch (error) { console.error(error.message); process.exitCode = 1; }\n} else if (command) {\n  console.error(\"Unknown command. Use list, --help, or call <tool> '<json>'.\"); process.exitCode = 1;\n} else {\n  const lines = createInterface({ input: process.stdin });\n  let tail = Promise.resolve(), initialized = false, lastScope = null;\n  const timer = process.env.PASEO_AGENT_ID ? setInterval(() => {\n    void (async () => { const current = await scope(); if (initialized && current !== lastScope) process.stdout.write(JSON.stringify({ jsonrpc: \"2.0\", method: \"notifications/tools/list_changed\" }) + \"\\n\"); lastScope = current; })().catch(() => {});\n  }, 2000) : null;\n  timer?.unref(); lines.on(\"close\", () => { if (timer) clearInterval(timer); });\n  lines.on(\"line\", line => {\n    tail = tail.then(async () => {\n      let request;\n      try { request = JSON.parse(line); } catch { return; }\n      if (request.id === undefined) return;\n      try {\n        let result;\n        const role = await scope(request.method === \"initialize\" || request.method === \"tools/list\");\n        const available = role ? toolList(role === \"recovery\") : [];\n        if (request.method === \"initialize\") {\n          initialized = true; lastScope = role;\n          result = { protocolVersion: request.params?.protocolVersion ?? \"2024-11-05\", capabilities: { tools: { listChanged: true } }, serverInfo: { name: \"paseo-follow-through\", version: \"0.1.0\" }, instructions: role ? (role === \"recovery\" ? \"Recover tracking metadata from evidence, acknowledge your assigned batch, and leave completion to the main agent.\" : \"Keep workspace follow-through updated after PR submission and scope changes. Read workspace_status after compaction. Track all post-merge work. \" + batchInstructions) + \" Perform bookkeeping silently: no sidebar-update announcements, plugin-status commentary or final sidebar recap. Put receipts and summaries in tools. Report actual work outcomes or decisions/blockers; discuss sidebar status only when explicitly asked.\" : \"Follow-through tools are available only to a tracked workspace's main agent or active recovery agent.\" };\n        } else if (request.method === \"ping\") result = {};\n        else if (request.method === \"tools/list\") result = { tools: schemas(available) };\n        else if (request.method === \"tools/call\") {\n          const tool = available.find(t => t[0] === request.params?.name);\n          try {\n            if (!tool) throw new Error(\"This tool is unavailable for the current agent. Tracking must be active; recovery authority ends after acknowledgment.\");\n            const input = request.params.arguments ?? {}; validate(input, schemas([tool])[0].inputSchema);\n            const value = await call(tool[2], input);\n            result = { content: [{ type: \"text\", text: JSON.stringify(input.detail === \"full\" ? value : compact(tool[0], input, value)) }] };\n          } catch (error) { result = { isError: true, content: [{ type: \"text\", text: error.message }] }; }\n        } else { process.stdout.write(JSON.stringify({ jsonrpc: \"2.0\", id: request.id, error: { code: -32601, message: \"Method not found\" } }) + \"\\n\"); return; }\n        process.stdout.write(JSON.stringify({ jsonrpc: \"2.0\", id: request.id, result }) + \"\\n\");\n      } catch (error) { process.stdout.write(JSON.stringify({ jsonrpc: \"2.0\", id: request.id, error: { code: -32603, message: error.message } }) + \"\\n\"); }\n    });\n  });\n}\n";
+export const mcpSource = "#!/usr/bin/env node\nimport { createInterface } from \"node:readline\";\nimport { createRequire } from \"node:module\";\nimport { pathToFileURL } from \"node:url\";\nimport { readFile } from \"node:fs/promises\";\nimport { existsSync, realpathSync } from \"node:fs\";\nimport { join, delimiter } from \"node:path\";\nimport { homedir } from \"node:os\";\n\nconst string = { type: \"string\" };\nconst boolean = { type: \"boolean\" };\nconst integer = { type: \"integer\", minimum: 1 };\nconst array = { type: \"array\", items: string };\nconst communication = { type: \"object\", properties: { threadUrl: string, recipient: string, purpose: { type: \"string\", enum: [\"progress\", \"verified\"] }, authorization: string, replyUrl: { type: [\"string\", \"null\"] } }, required: [\"threadUrl\", \"recipient\"], additionalProperties: false };\nconst trigger = { type: [\"object\", \"null\"], properties: { event: { type: \"string\", enum: [\"now\", \"merge\", \"deploy\"] }, delayDays: { type: \"integer\", minimum: 0, maximum: 3650 } }, required: [\"event\"], additionalProperties: false };\nconst tools = [\n  [\"workspace_status\", \"Read the tracked workspace's durable goal, PRs, tasks, work queue and optional recovery history. Read after compaction. Returns current work by default; detail=full includes complete evidence/history. Normal follow-through does not require recovery.\", \"follow.agent-status\", { detail: { type: \"string\", enum: [\"summary\", \"full\"] } }, []],\n  [\"sync_workspace\", \"Silently confirm the sidebar matches your work before finishing, after registering owned PRs and substantive tasks. Call even when no changes are needed. Keep the summary in this tool; never announce sync or recap sidebar/plugin status to the developer. Does not declare Done, run recovery, or start repairs. Tracked root agents only.\", \"follow.sync\", { summary: { ...string, minLength: 1, maxLength: 1000 } }, [\"summary\"]],\n  [\"enroll_workspace\", \"Refine this developer-activated workspace's goal. Ownership is initialized by Track this workspace or the project’s default-tracking setting. This tool cannot activate another workspace. Never ask the developer to enter this. Keep the goal concise; new scope reopens completion.\", \"follow.enroll\", { goal: string }, [\"goal\"]],\n  [\"register_pr\", \"Register a PR produced by this workspace. Call after every submission. Register parents first; repeat to update its stack or parent after restacking. Supply a disposition for a deliberately closed PR.\", \"follow.register-pr\", { repo: string, number: integer, stack: string, parentNumber: { type: [\"integer\", \"null\"], minimum: 1 }, disposition: string }, [\"repo\", \"number\", \"stack\"]],\n  [\"exclude_stack\", \"Correct an unrelated stack registration. Preserve its PRs and requirements in an exclusion audit; future registration is blocked. reason must cite the scope/ownership evidence. obligationIds may include related tasks without PR dependencies. Keep external dependencies separate from owned work.\", \"follow.exclude-stack\", { stack: string, reason: string, obligationIds: array }, [\"stack\", \"reason\"]],\n  [\"update_obligation\", \"Record concrete follow-through: verification, migrations, decisions or stakeholder replies. Never add approve/merge/deploy checklist tasks. afterPrs uses owner/repo#number keys. Tasks are manual unless explicitly scheduled with trigger={event:\\\"now\\\"|\\\"merge\\\"|\\\"deploy\\\",delayDays:0}. Only set a trigger from the developer’s requested timing; never infer timing from a title or enable_follow_up alone. Merge/deploy triggers require owned afterPrs; delayDays=14 waits fourteen days after the last dependency event. Now requires no PR dependencies or delay. Deployment timing starts at the first verified fully serving observation and remains conservative when history is unknown. Preserve existing trigger fields on updates; trigger=null makes a task manual. Auto controls delivery, not timing or production permissions. For Slack replies, communication records the original threadUrl, recipient, purpose (progress or verified), explicit developer authorization and sent replyUrl. Empty authorization never queues a reply; Auto does not authorize external posts. Use a verify-and-reply task after deployment for the final update. Read the thread first; mark blocked when posting is unavailable or uncertain, never treat a draft as sent. Done requires replyUrl and evidence; preserve fields when updating.\", \"follow.obligation\", { id: string, title: string, status: { type: \"string\", enum: [\"pending\", \"waiting\", \"working\", \"blocked\", \"done\", \"waived\"] }, afterPrs: array, dependencyStage: { type: \"string\", enum: [\"merged\", \"deployed\"] }, evidence: string, enable_follow_up: boolean, communication, trigger }, [\"title\", \"status\"]],\n  [\"acknowledge_batch\", \"Record a follow-up result. Complete only after verifying all tasks; blocked surfaces the reason to the developer. Always acknowledge before ending a repair turn. Keep the result within 2000 characters.\", \"follow.acknowledge\", { batchId: string, outcome: { type: \"string\", enum: [\"completed\", \"blocked\"] }, result: { ...string, maxLength: 2000 } }, [\"batchId\", \"outcome\", \"result\"]],\n  [\"declare_done\", \"Declare that the workspace goal is fulfilled. Live PR status and remaining obligations are checked; returned blockers must be resolved first. Done labels the workspace but never archives it.\", \"follow.done\", { summary: string }, [\"summary\"]],\n];\n\nfunction toolList(recovery = process.env.FOLLOW_THROUGH_RECOVERY === \"1\", contributor = false) {\n  return tools.filter(t => contributor ? [\"workspace_status\", \"register_pr\", \"sync_workspace\"].includes(t[0]) : !recovery || ![\"declare_done\", \"sync_workspace\"].includes(t[0]));\n}\nconst schemas = list => list.map(([name, description, , properties, required]) => ({ name, description, inputSchema: { type: \"object\", properties, required, additionalProperties: false }, annotations: { readOnlyHint: name === \"workspace_status\", destructiveHint: false } }));\nasync function scope(resolveRecovery = false) {\n  const agentId = process.env.PASEO_AGENT_ID;\n  if (!agentId) return null;\n  try {\n    const home = process.env.PASEO_HOME ?? join(homedir(), \".paseo\");\n    const directory = join(home, \"plugin-data/follow-through\");\n    const lease = JSON.parse(await readFile(join(directory, \"hooks-enabled.json\"), \"utf8\"));\n    if (!(lease.expiresAt > Date.now())) return null;\n    const state = JSON.parse(await readFile(join(directory, \"state.json\"), \"utf8\"));\n    for (const w of state.workspaces) {\n      if (!w.enable_tracking || w.archived) continue;\n      if (w.mainAgentId === agentId) return process.env.FOLLOW_THROUGH_RECOVERY === \"1\" ? \"recovery\" : \"main\";\n      if (w.batches.some(b => b.recipientAgentId === agentId && !b.settledAt && [\"sending\", \"sent\", \"blocked\", \"uncertain\"].includes(b.state) && b.tasks.every(t => t.kind === \"inventory\"))) return \"recovery\";\n      if (w.contributorAgentIds?.includes(agentId)) return \"contributor\";\n    }\n    if (resolveRecovery && process.env.FOLLOW_THROUGH_RECOVERY === \"1\") {\n      const w = await call(\"follow.agent-status\", {});\n      if (w.enable_tracking && !w.archived && w.mainAgentId !== agentId && w.batches.some(b => b.recipientAgentId === agentId && !b.settledAt && [\"sending\", \"sent\", \"blocked\", \"uncertain\"].includes(b.state) && b.tasks.every(t => t.kind === \"inventory\"))) return \"recovery\";\n    }\n  } catch {}\n  return null;\n}\nfunction validate(value, schema, path = \"arguments\") {\n  const types = Array.isArray(schema.type) ? schema.type : [schema.type];\n  const type = value === null ? \"null\" : Array.isArray(value) ? \"array\" : typeof value;\n  if (!types.includes(type) && !(type === \"number\" && types.includes(\"integer\") && Number.isInteger(value))) throw new Error(`${path}: expected ${types.join(\" or \")}.`);\n  if (schema.enum && !schema.enum.includes(value)) throw new Error(`${path}: choose ${schema.enum.join(\", \")}.`);\n  if (type === \"object\") {\n    const extra = Object.keys(value).filter(k => !Object.hasOwn(schema.properties ?? {}, k));\n    if (extra.length && schema.additionalProperties === false) throw new Error(`Unknown argument ${path}.${extra.join(\", \")}. ${extra.includes(\"dependsOnPrs\") ? \"Use afterPrs with owner/repo#number keys.\" : \"Check this tool's input schema with list.\"}`);\n    for (const key of schema.required ?? []) if (!(key in value)) throw new Error(`${path}.${key} is required. Check this tool's input schema with list.`);\n    for (const [key, nested] of Object.entries(value)) if (schema.properties?.[key]) validate(nested, schema.properties[key], `${path}.${key}`);\n  }\n  if (type === \"array\") for (let i = 0; i < value.length; i++) validate(value[i], schema.items, `${path}[${i}]`);\n  if (type === \"number\" && (schema.minimum !== undefined && value < schema.minimum || schema.maximum !== undefined && value > schema.maximum)) throw new Error(`${path}: outside the allowed range.`);\n  if (type === \"string\" && (schema.minLength !== undefined && value.length < schema.minLength || schema.maxLength !== undefined && value.length > schema.maxLength)) throw new Error(`${path}: outside the allowed length.`);\n}\nfunction currentWork(w) {\n  return { id: w.id, title: w.title, goal: w.goal, mainAgentId: w.mainAgentId, enable_tracking: w.enable_tracking, enable_auto_sends: w.enable_auto_sends, hold: w.hold, archived: w.archived, runtimeBusy: w.runtimeBusy, runtimeReason: w.runtimeReason, backgroundBusy: w.backgroundBusy, completion: w.completion,\n    prs: w.prs.map(p => ({ key: p.key, stack: p.stack, parent: p.parent, disposition: p.disposition, error: p.error, ...(p.snapshot ? { title: p.snapshot.title, state: p.snapshot.state, head: p.snapshot.head, draft: p.snapshot.draft, reviewDecision: p.snapshot.reviewDecision, conflict: p.snapshot.conflict, openThreads: p.snapshot.threads.length, failedChecks: p.snapshot.failedChecks, deployment: p.snapshot.deployment } : {}) })),\n    obligations: w.obligations.filter(o => ![\"done\", \"waived\"].includes(o.status)), completedObligations: w.obligations.filter(o => [\"done\", \"waived\"].includes(o.status)).length,\n    batches: w.batches.filter(b => ![\"completed\", \"cancelled\"].includes(b.state)).map(b => ({ id: b.id, state: b.state, tasks: b.tasks, result: b.result, recipientAgentId: b.recipientAgentId, contextPath: b.contextPath })),\n    excludedStacks: w.excludedStacks.map(s => ({ name: s.name, reason: s.reason, prs: s.prs.map(p => p.key) })), detail: \"summary\" };\n}\nfunction compact(tool, input, result) {\n  if (tool === \"workspace_status\") return currentWork(result);\n  if (tool === \"declare_done\") return { workspaceId: result.workspace.id, completion: result.workspace.completion, blockers: result.blockers };\n  if (!result?.prs) return result;\n  const workspaceId = result.id;\n  if (tool === \"enroll_workspace\") return { workspaceId, goal: result.goal };\n  if (tool === \"register_pr\") { const p = result.prs.find(p => p.key === `${input.repo}#${input.number}`); return { workspaceId, pr: { key: p.key, stack: p.stack, parent: p.parent, disposition: p.disposition } }; }\n  if (tool === \"update_obligation\") return { workspaceId, obligation: result.obligations.find(o => o.id === result.updatedObligationId) };\n  if (tool === \"acknowledge_batch\") { const b = result.batches.find(b => b.id === input.batchId); return { workspaceId, batch: { id: b.id, state: b.state, result: b.result } }; }\n  if (tool === \"exclude_stack\") { const s = result.excludedStacks.find(s => s.name === input.stack); return { workspaceId, excludedStack: { name: s.name, reason: s.reason, prs: s.prs.map(p => p.key) } }; }\n  return result;\n}\nasync function loadClient() {\n  const candidates = [];\n  if (process.env.FOLLOW_THROUGH_CLIENT_ENTRY) candidates.push(() => pathToFileURL(process.env.FOLLOW_THROUGH_CLIENT_ENTRY).href);\n  const specifier = \"@getpaseo/client/internal/daemon-client\";\n  if (process.resourcesPath) candidates.push(() => pathToFileURL(createRequire(join(process.resourcesPath, \"app.asar/node_modules/@getpaseo/cli/dist/index.js\")).resolve(specifier)).href);\n  for (const directory of (process.env.PATH ?? \"\").split(delimiter)) {\n    const cli = join(directory, process.platform === \"win32\" ? \"paseo.cmd\" : \"paseo\");\n    if (existsSync(cli)) candidates.push(() => pathToFileURL(createRequire(realpathSync(cli)).resolve(specifier)).href);\n  }\n  candidates.push(() => pathToFileURL(createRequire(import.meta.url).resolve(specifier)).href);\n  for (const resolve of candidates) try { return await import(resolve()); } catch {}\n  throw new Error(\"Cannot load the installed Paseo client. Reload Follow-through to refresh its runtime connection.\");\n}\nconst batchInstructions = \"Follow-through batches contain a header with the batchId and ordered tasks. Read workspace_status and refresh live conditions; skip resolved tasks. Process PRs bottom to top, one fully before the next, using the repository's /fix-pr and safe reparent workflow. Validate feedback, verify changes, submit with Graphite --publish, reply/resolve addressed threads and preserve uncommitted work. Post-deploy tasks require verified serving revisions and existing production permissions. Stakeholder update requests are follow-through tasks: retain the original thread, recipient and developer authorization in communication. Use current evidence, distinguish fixed/deployed/verified, and read existing replies before posting. Record the sent replyUrl; a draft or uncertain send stays blocked and must be checked before retrying. Auto authorizes agent delivery only. Acknowledge the header's batchId with acknowledge_batch before finishing (completed with the result, or blocked with the reason), before declare_done for completion batches. Declare Done only after the whole goal and post-merge work are verified. Leave merging and archiving to the developer.\";\n\nasync function call(method, input) {\n  const agentId = process.env.PASEO_AGENT_ID;\n  if (!agentId) throw new Error(\"This bridge must run inside a Paseo agent (PASEO_AGENT_ID is missing).\");\n  const { DaemonClient } = await loadClient();\n  const home = process.env.PASEO_HOME ?? join(homedir(), \".paseo\");\n  const config = JSON.parse(await readFile(join(home, \"config.json\"), \"utf8\"));\n  let password = process.env.PASEO_PASSWORD;\n  if (!password && process.env.PASEO_PASSWORD_FILE) password = (await readFile(process.env.PASEO_PASSWORD_FILE, \"utf8\")).trim();\n  if (!password && home === join(homedir(), \".paseo\")) password = await readFile(join(homedir(), \"paseo-hub/secrets/daemon-password\"), \"utf8\").then(s => s.trim()).catch(() => undefined);\n  const client = new DaemonClient({ url: process.env.PASEO_DAEMON_URL ?? `ws://${config.daemon?.listen ?? \"127.0.0.1:6767\"}/ws`, clientId: \"follow-through-mcp\", clientType: \"cli\", reconnect: { enabled: false }, connectTimeoutMs: 10000, suppressSendErrors: true, ...(password ? { password } : {}) });\n  try { await client.connect(); return await client.invokePluginRpc(\"follow-through\", method, { ...input, agentId }); }\n  finally { await client.close().catch(() => undefined); }\n}\n\nconst command = process.argv[2];\nif (command === \"list\" || command === \"--help\" || command === \"help\") {\n  process.stdout.write(command === \"list\" ? JSON.stringify({ tools: schemas(toolList()) }, null, 2) + \"\\n\" : \"Usage: node mcp.mjs list | call <tool> '<json>' [--compact]\\nNative MCP returns compact receipts; workspace_status({detail:full}) requests complete history. CLI calls retain full replies unless --compact is supplied.\\n\");\n} else if (command === \"call\") {\n  try {\n    const tool = toolList().find(t => t[0] === process.argv[3]);\n    if (!tool) throw new Error(\"Unknown tool. Run list for names and input schemas.\");\n    const input = JSON.parse(process.argv[4] ?? \"{}\");\n    validate(input, schemas([tool])[0].inputSchema);\n    if (process.argv.slice(5).some(arg => arg !== \"--compact\")) throw new Error(\"Unknown CLI option. Use --compact or omit it for a full reply.\");\n    const result = await call(tool[2], input);\n    process.stdout.write(JSON.stringify(process.argv.includes(\"--compact\") && input.detail !== \"full\" ? compact(tool[0], input, result) : result, null, 2) + \"\\n\");\n  } catch (error) { console.error(error.message); process.exitCode = 1; }\n} else if (command) {\n  console.error(\"Unknown command. Use list, --help, or call <tool> '<json>'.\"); process.exitCode = 1;\n} else {\n  const lines = createInterface({ input: process.stdin });\n  let tail = Promise.resolve(), initialized = false, lastScope = null;\n  const timer = process.env.PASEO_AGENT_ID ? setInterval(() => {\n    void (async () => { const current = await scope(); if (initialized && current !== lastScope) process.stdout.write(JSON.stringify({ jsonrpc: \"2.0\", method: \"notifications/tools/list_changed\" }) + \"\\n\"); lastScope = current; })().catch(() => {});\n  }, 2000) : null;\n  timer?.unref(); lines.on(\"close\", () => { if (timer) clearInterval(timer); });\n  lines.on(\"line\", line => {\n    tail = tail.then(async () => {\n      let request;\n      try { request = JSON.parse(line); } catch { return; }\n      if (request.id === undefined) return;\n      try {\n        let result;\n        const role = await scope(request.method === \"initialize\" || request.method === \"tools/list\");\n        const available = role ? toolList(role === \"recovery\", role === \"contributor\") : [];\n        if (request.method === \"initialize\") {\n          initialized = true; lastScope = role;\n          result = { protocolVersion: request.params?.protocolVersion ?? \"2024-11-05\", capabilities: { tools: { listChanged: true } }, serverInfo: { name: \"paseo-follow-through\", version: \"0.3.2\" }, instructions: role ? (role === \"contributor\" ? \"Register PRs this session submits, including from secondary git worktrees. Read workspace_status and call sync_workspace before finishing. Goal, task, scope and completion changes remain with the designated main agent.\" : role === \"recovery\" ? \"Recover tracking metadata from evidence, acknowledge your assigned batch, and leave completion to the main agent.\" : \"Keep workspace follow-through updated after PR submission and scope changes. Read workspace_status after compaction. Track all post-merge work. \" + batchInstructions) + \" Perform bookkeeping silently: no sidebar-update announcements, plugin-status commentary or final sidebar recap. Put receipts and summaries in tools. Report actual work outcomes or decisions/blockers; discuss sidebar status only when explicitly asked.\" : \"Follow-through tools are available to tracked workspace root agents and active recovery agents; contributor sessions receive PR registration and status tools.\" };\n        } else if (request.method === \"ping\") result = {};\n        else if (request.method === \"tools/list\") result = { tools: schemas(available) };\n        else if (request.method === \"tools/call\") {\n          const tool = available.find(t => t[0] === request.params?.name);\n          try {\n            if (!tool) throw new Error(\"This tool is unavailable for the current agent. Tracking must be active; recovery authority ends after acknowledgment.\");\n            const input = request.params.arguments ?? {}; validate(input, schemas([tool])[0].inputSchema);\n            const value = await call(tool[2], input);\n            result = { content: [{ type: \"text\", text: JSON.stringify(input.detail === \"full\" ? value : compact(tool[0], input, value)) }] };\n          } catch (error) { result = { isError: true, content: [{ type: \"text\", text: error.message }] }; }\n        } else { process.stdout.write(JSON.stringify({ jsonrpc: \"2.0\", id: request.id, error: { code: -32601, message: \"Method not found\" } }) + \"\\n\"); return; }\n        process.stdout.write(JSON.stringify({ jsonrpc: \"2.0\", id: request.id, result }) + \"\\n\");\n      } catch (error) { process.stdout.write(JSON.stringify({ jsonrpc: \"2.0\", id: request.id, error: { code: -32603, message: error.message } }) + \"\\n\"); }\n    });\n  });\n}\n";

package/server/mcp.mjs

@@ -15,7 +15,7 @@ const communication = { type: "object", properties: { threadUrl: string, recipie
 const trigger = { type: ["object", "null"], properties: { event: { type: "string", enum: ["now", "merge", "deploy"] }, delayDays: { type: "integer", minimum: 0, maximum: 3650 } }, required: ["event"], additionalProperties: false };
 const tools = [
   ["workspace_status", "Read the tracked workspace's durable goal, PRs, tasks, work queue and optional recovery history. Read after compaction. Returns current work by default; detail=full includes complete evidence/history. Normal follow-through does not require recovery.", "follow.agent-status", { detail: { type: "string", enum: ["summary", "full"] } }, []],
-  ["sync_workspace", "Silently confirm the sidebar matches your work before finishing, after registering owned PRs and substantive tasks. Call even when no changes are needed. Keep the summary in this tool; never announce sync or recap sidebar/plugin status to the developer. Does not declare Done, run recovery, or start repairs. Main agent only.", "follow.sync", { summary: { ...string, minLength: 1, maxLength: 1000 } }, ["summary"]],
+  ["sync_workspace", "Silently confirm the sidebar matches your work before finishing, after registering owned PRs and substantive tasks. Call even when no changes are needed. Keep the summary in this tool; never announce sync or recap sidebar/plugin status to the developer. Does not declare Done, run recovery, or start repairs. Tracked root agents only.", "follow.sync", { summary: { ...string, minLength: 1, maxLength: 1000 } }, ["summary"]],
   ["enroll_workspace", "Refine this developer-activated workspace's goal. Ownership is initialized by Track this workspace or the project’s default-tracking setting. This tool cannot activate another workspace. Never ask the developer to enter this. Keep the goal concise; new scope reopens completion.", "follow.enroll", { goal: string }, ["goal"]],
   ["register_pr", "Register a PR produced by this workspace. Call after every submission. Register parents first; repeat to update its stack or parent after restacking. Supply a disposition for a deliberately closed PR.", "follow.register-pr", { repo: string, number: integer, stack: string, parentNumber: { type: ["integer", "null"], minimum: 1 }, disposition: string }, ["repo", "number", "stack"]],
   ["exclude_stack", "Correct an unrelated stack registration. Preserve its PRs and requirements in an exclusion audit; future registration is blocked. reason must cite the scope/ownership evidence. obligationIds may include related tasks without PR dependencies. Keep external dependencies separate from owned work.", "follow.exclude-stack", { stack: string, reason: string, obligationIds: array }, ["stack", "reason"]],
@@ -24,7 +24,9 @@ const tools = [
   ["declare_done", "Declare that the workspace goal is fulfilled. Live PR status and remaining obligations are checked; returned blockers must be resolved first. Done labels the workspace but never archives it.", "follow.done", { summary: string }, ["summary"]],
 ];
 
-function toolList(recovery = process.env.FOLLOW_THROUGH_RECOVERY === "1") { return tools.filter(t => !recovery || !["declare_done", "sync_workspace"].includes(t[0])); }
+function toolList(recovery = process.env.FOLLOW_THROUGH_RECOVERY === "1", contributor = false) {
+  return tools.filter(t => contributor ? ["workspace_status", "register_pr", "sync_workspace"].includes(t[0]) : !recovery || !["declare_done", "sync_workspace"].includes(t[0]));
+}
 const schemas = list => list.map(([name, description, , properties, required]) => ({ name, description, inputSchema: { type: "object", properties, required, additionalProperties: false }, annotations: { readOnlyHint: name === "workspace_status", destructiveHint: false } }));
 async function scope(resolveRecovery = false) {
   const agentId = process.env.PASEO_AGENT_ID;
@@ -39,6 +41,7 @@ async function scope(resolveRecovery = false) {
       if (!w.enable_tracking || w.archived) continue;
       if (w.mainAgentId === agentId) return process.env.FOLLOW_THROUGH_RECOVERY === "1" ? "recovery" : "main";
       if (w.batches.some(b => b.recipientAgentId === agentId && !b.settledAt && ["sending", "sent", "blocked", "uncertain"].includes(b.state) && b.tasks.every(t => t.kind === "inventory"))) return "recovery";
+      if (w.contributorAgentIds?.includes(agentId)) return "contributor";
     }
     if (resolveRecovery && process.env.FOLLOW_THROUGH_RECOVERY === "1") {
       const w = await call("follow.agent-status", {});
@@ -140,10 +143,10 @@ if (command === "list" || command === "--help" || command === "help") {
       try {
         let result;
         const role = await scope(request.method === "initialize" || request.method === "tools/list");
-        const available = role ? toolList(role === "recovery") : [];
+        const available = role ? toolList(role === "recovery", role === "contributor") : [];
         if (request.method === "initialize") {
           initialized = true; lastScope = role;
-          result = { protocolVersion: request.params?.protocolVersion ?? "2024-11-05", capabilities: { tools: { listChanged: true } }, serverInfo: { name: "paseo-follow-through", version: "0.1.0" }, instructions: role ? (role === "recovery" ? "Recover tracking metadata from evidence, acknowledge your assigned batch, and leave completion to the main agent." : "Keep workspace follow-through updated after PR submission and scope changes. Read workspace_status after compaction. Track all post-merge work. " + batchInstructions) + " Perform bookkeeping silently: no sidebar-update announcements, plugin-status commentary or final sidebar recap. Put receipts and summaries in tools. Report actual work outcomes or decisions/blockers; discuss sidebar status only when explicitly asked." : "Follow-through tools are available only to a tracked workspace's main agent or active recovery agent." };
+          result = { protocolVersion: request.params?.protocolVersion ?? "2024-11-05", capabilities: { tools: { listChanged: true } }, serverInfo: { name: "paseo-follow-through", version: "0.3.2" }, instructions: role ? (role === "contributor" ? "Register PRs this session submits, including from secondary git worktrees. Read workspace_status and call sync_workspace before finishing. Goal, task, scope and completion changes remain with the designated main agent." : role === "recovery" ? "Recover tracking metadata from evidence, acknowledge your assigned batch, and leave completion to the main agent." : "Keep workspace follow-through updated after PR submission and scope changes. Read workspace_status after compaction. Track all post-merge work. " + batchInstructions) + " Perform bookkeeping silently: no sidebar-update announcements, plugin-status commentary or final sidebar recap. Put receipts and summaries in tools. Report actual work outcomes or decisions/blockers; discuss sidebar status only when explicitly asked." : "Follow-through tools are available to tracked workspace root agents and active recovery agents; contributor sessions receive PR registration and status tools." };
         } else if (request.method === "ping") result = {};
         else if (request.method === "tools/list") result = { tools: schemas(available) };
         else if (request.method === "tools/call") {

package/server/recovery-handoff.ts

@@ -1,3 +1,4 @@
+import { isWorkspaceRoot } from "./workspace-agent";
 import type { Workspace } from "../shared/model";
 import type { Agent, Daemon } from "./daemon";
 
@@ -19,7 +20,7 @@ async function userMessages(client: Daemon, agentId: string): Promise<string[]>
 }
 
 export async function recoveryHandoff(client: Daemon, w: Workspace, caller: Agent): Promise<{ batchId: string; fromAgentId: string } | null> {
-  if (!w.enable_tracking || w.archived || caller.archivedAt || caller.workspaceId !== w.id || caller.id === w.mainAgentId || caller.labels["paseo.parent-agent-id"]) return null;
+  if (!w.enable_tracking || w.archived || caller.archivedAt || caller.workspaceId !== w.id || caller.id === w.mainAgentId || !await isWorkspaceRoot(caller, async id => (await client.fetchAgent(id))?.agent)) return null;
   const candidates = w.batches.filter(b => b.recipientAgentId && b.recipientAgentId !== w.mainAgentId && b.recipientAgentId !== caller.id && b.tasks.every(t => t.kind === "inventory") && ["sending", "sent", "uncertain", "blocked"].includes(b.state) && !b.settledAt);
   if (!candidates.length) return null;
   const initialTask = (await userMessages(client, caller.id))[0];

package/server/submissions.ts

@@ -0,0 +1,75 @@
+import type { Pr, Workspace } from "../shared/model";
+
+export type Submission = { repo: string; number: number; agentId: string; branch: string | null };
+const reference = /https:\/\/(?:github\.com\/([\w.-]+)\/([\w.-]+)\/pull\/(\d+)|app\.graphite\.(?:com|dev)\/github\/pr\/([\w.-]+)\/([\w.-]+)\/(\d+))(?=[/?#\s]|$)/;
+
+/** Ignore command-like text inside quoted arguments and comments; never execute shell text. */
+function unquoted(command: string): string {
+  let quote = "", result = "";
+  for (let i = 0; i < command.length; i++) {
+    const c = command[i];
+    if (c === "\\" && quote !== "'") { result += "  "; i++; continue; }
+    if (quote) { if (c === quote) quote = ""; result += " "; continue; }
+    if (["'", '\"', "`"].includes(c)) { quote = c; result += " "; continue; }
+    if (c === "#" && (i === 0 || /\s/.test(command[i - 1]))) {
+      while (i < command.length && command[i] !== "\n") { result += " "; i++; }
+      result += "\n"; continue;
+    }
+    result += c;
+  }
+  return result;
+}
+
+/** Submission receipts are ownership evidence. Links in chat, reviews or file reads are not. */
+export function submittedPrs(items: readonly unknown[], agentId: string, repository: string | null): Submission[] {
+  if (!repository) return [];
+  const found = new Map<string, Submission>();
+  for (const item of items) {
+    if (!item || typeof item !== "object") continue;
+    const v = item as { type?: string; status?: string; error?: unknown; detail?: { type?: string; command?: string; output?: unknown } };
+    const d = v.detail;
+    if (v.type !== "tool_call" || v.status !== "completed" || v.error || d?.type !== "shell" || typeof d.command !== "string" || typeof d.output !== "string") continue;
+    const command = unquoted(d.command);
+    // Do not interpret arbitrary scripts or quoted documentation as commands.
+    if (/<</.test(command) || /--(?:help|dry-run)\b/.test(command)) continue;
+    const gh = /(?:^|[;&|\n])\s*(?:timeout\s+\d+\s+)?gh\s+pr\s+create\b/.test(command);
+    const gt = /(?:^|[;&|\n])\s*(?:timeout\s+\d+\s+)?gt\s+(?:submit|ss)\b/.test(command);
+    if (!gh && !gt) continue;
+    const output = d.output.replace(/\x1b\[[0-9;]*m/g, "");
+    for (const line of output.split(/\r?\n/)) {
+      const match = reference.exec(line);
+      if (!match) continue;
+      const repo = `${match[1] ?? match[4]}/${match[2] ?? match[5]}`;
+      const number = Number(match[3] ?? match[6]);
+      if (repo.toLowerCase() !== repository.toLowerCase() || !Number.isSafeInteger(number) || number < 1) continue;
+      const branch = gt ? /^(\S+): https:\/\/\S+ \((?:created|updated)\)\s*$/.exec(line)?.[1] ?? null : null;
+      if (!(gh && line.trim() === match[0]) && !(gt && (branch || line.trim() === `View your PR at ${match[0]}`))) continue;
+      const key = `${repository}#${number}`;
+      const previous = found.get(key);
+      found.set(key, { repo: repository, number, agentId, branch: branch ?? previous?.branch ?? null });
+    }
+  }
+  return [...found.values()];
+}
+
+/** Only inferred relationships follow GitHub's observed base/head branches. Explicit edits win. */
+export function reconcileSubmittedStacks(w: Workspace): void {
+  for (const p of w.prs.filter(p => p.discoveredFromSubmission)) {
+    const s = p.snapshot;
+    if (p.error || !s?.complete || !s.headBranch || !s.base) continue;
+    const parents = w.prs.filter(row => row.key !== p.key && row.repo === p.repo && !row.error && row.snapshot?.complete && row.snapshot.headBranch && row.snapshot.headBranch !== row.snapshot.trunk && row.snapshot.headBranch === s.base);
+    const parent = parents.length === 1 ? parents[0] : null;
+    let cursor: Pr | undefined = parent ?? undefined;
+    const seen = new Set([p.key]); let cycle = false;
+    while (cursor) { if (seen.has(cursor.key)) { cycle = true; break; } seen.add(cursor.key); cursor = w.prs.find(row => row.key === cursor!.parent); }
+    if (!cycle) p.parent = parent?.key ?? null;
+  }
+  for (const p of w.prs.filter(p => p.discoveredFromSubmission && !p.parent)) {
+    if (!p.error && p.snapshot?.complete && p.snapshot.headBranch) p.stack = p.snapshot.headBranch;
+  }
+  for (const p of w.prs.filter(p => p.discoveredFromSubmission)) {
+    let root = p; const seen = new Set([p.key]);
+    while (root.parent) { const parent = w.prs.find(row => row.key === root.parent); if (!parent || seen.has(parent.key)) break; seen.add(parent.key); root = parent; }
+    p.stack = root.stack;
+  }
+}

package/server/workspace-agent.ts

@@ -0,0 +1,20 @@
+export type WorkspaceAgent = {
+  id: string;
+  workspaceId?: string | null;
+  archivedAt?: string | null;
+  labels: Record<string, string>;
+};
+
+/** Parent labels record who launched an agent, including launches into another workspace. */
+export async function isWorkspaceRoot(
+  agent: WorkspaceAgent,
+  findParent: (id: string) => Promise<WorkspaceAgent | null | undefined>,
+): Promise<boolean> {
+  if (!agent.workspaceId || agent.archivedAt) return false;
+  const parentId = agent.labels["paseo.parent-agent-id"];
+  if (!parentId) return true;
+  if (parentId === agent.id) return false;
+  const parent = await findParent(parentId).catch(() => null);
+  // Unknown parent membership does not grant a new ownership or tool scope.
+  return !!parent && parent.id === parentId && !!parent.workspaceId && parent.workspaceId !== agent.workspaceId;
+}

package/shared/model.ts

@@ -27,6 +27,7 @@ export const prSchema = z.object({
   stack: textSchema, parent: idSchema.nullable(), disposition: z.string().nullable(),
   snapshot: snapshotSchema.nullable(), error: z.string().nullable(),
   registeredAgentId: idSchema.optional(),
+  discoveredFromSubmission: z.boolean().optional(),
   deploymentAnchor: z.object({ mergeCommit: z.string(), at: z.string() }).optional(),
 });
 export const obligationSchema = z.object({
@@ -56,6 +57,7 @@ export const batchSchema = z.object({
 });
 export const workspaceSchema = z.object({
   id: idSchema, title: textSchema, goal: textSchema, mainAgentId: idSchema,
+  contributorAgentIds: z.array(idSchema).optional(),
   enable_tracking: z.boolean().default(false), enable_auto_sends: z.boolean().default(false), hold: z.string().nullable(), archived: z.boolean(),
   prs: z.array(prSchema), obligations: z.array(obligationSchema), batches: z.array(batchSchema),
   excludedStacks: z.array(z.object({ name: textSchema, reason: textSchema, excludedAt: z.string(), prs: z.array(prSchema), obligations: z.array(obligationSchema) })).default([]),