agent-relay-server 0.114.0 → 0.116.0

package/runner/plugins/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-relay-runner",
   "description": "Thin Agent Relay runner bridge for Claude Code",
-  "version": "0.114.0",
+  "version": "0.116.0",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/scripts/orchestrator-spawn-smoke.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env bun
+import { spawnSync } from "node:child_process";
 import { hostname } from "node:os";
 import { RELAY_TOKEN_HEADER } from "agent-relay-sdk";
 
@@ -16,7 +17,7 @@ type Agent = {
   status: string;
   ready: boolean;
   tags?: string[];
-  meta?: { cwd?: string; provider?: string };
+  meta?: { cwd?: string; provider?: string; workspace?: { repoRoot?: string; sourceCwd?: string } };
   createdAt?: number;
 };
 
@@ -25,10 +26,9 @@ type ApprovalMode = "open" | "guarded" | "read-only";
 const args = process.argv.slice(2);
 let relayUrl = process.env.AGENT_RELAY_URL || "http://127.0.0.1:4850";
 let orchestratorId = process.env.AGENT_RELAY_SMOKE_ORCHESTRATOR || "";
-// Default cwd is resolved from the selected orchestrator's baseDir below, not
-// the local process.cwd() — the chosen orchestrator may be on a different host
-// (e.g. macOS macmini with /Users/admin/projects) where a local Linux path
-// fails cwd containment.
+// Default cwd is resolved to the local git repo root below. For remote
+// orchestrators, pass --cwd or AGENT_RELAY_SMOKE_CWD with a repo path on that
+// host so isolated workspace creation has a valid source repository.
 let cwd = process.env.AGENT_RELAY_SMOKE_CWD || "";
 let timeoutMs = Number(process.env.AGENT_RELAY_SMOKE_TIMEOUT_MS || 90_000);
 let providers = (process.env.AGENT_RELAY_SMOKE_PROVIDERS || "codex,claude").split(",").filter(Boolean);
@@ -83,11 +83,24 @@ async function waitFor<T>(label: string, fn: () => Promise<T | null>): Promise<T
   throw new Error(`${label} timed out after ${timeoutMs}ms`);
 }
 
+function localRepoRoot(): string | null {
+  const result = spawnSync("git", ["rev-parse", "--show-toplevel"], {
+    cwd: process.cwd(),
+    encoding: "utf8",
+  });
+  if (result.status !== 0) return null;
+  return result.stdout.trim() || null;
+}
+
 function findSpawnedAgent(agents: Agent[], provider: string, label: string, startedAt: number): Agent | null {
   return agents
     .filter((agent) => agent.ready && agent.status !== "offline")
     .filter((agent) => agent.label === label)
-    .filter((agent) => agent.meta?.cwd === cwd)
+    .filter((agent) =>
+      agent.meta?.cwd === cwd ||
+      agent.meta?.workspace?.sourceCwd === cwd ||
+      agent.meta?.workspace?.repoRoot === cwd
+    )
     .filter((agent) => (agent.tags || []).includes(provider))
     .filter((agent) => (agent.tags || []).includes("dashboard-spawned"))
     .filter((agent) => !agent.createdAt || agent.createdAt >= startedAt - 5_000)
@@ -118,8 +131,8 @@ const orchestrators = await api<Orchestrator[]>("GET", "/orchestrators");
 // Default selection prefers the orchestrator on the same host as the relay (the
 // gate runs there): a local spawn is faster and avoids cross-host teardown
 // flakiness. Fall back to any online orchestrator. An explicit --orchestrator
-// always wins — pair it with --cwd (or rely on the baseDir default below) to
-// target a remote host such as a macOS macmini.
+// always wins — pair it with --cwd to target a remote host such as a macOS
+// macmini.
 const onlineOrchestrators = orchestrators.filter((orch) => orch.status === "online");
 const localOrchestrator = onlineOrchestrators.find((orch) => orch.id === hostname());
 const orchestrator = orchestratorId
@@ -129,13 +142,17 @@ if (!orchestrator) throw new Error(orchestratorId ? `orchestrator not found: ${o
 if (orchestrator.status !== "online") throw new Error(`orchestrator ${orchestrator.id} is ${orchestrator.status}`);
 
 // Resolve the spawn cwd against the chosen orchestrator's own base directory so
-// the smoke works regardless of which host runs it. An explicit --cwd / env
-// override still wins (and is subject to the orchestrator's containment check).
+// the smoke exercises isolated workspace creation from a real git repository.
+// An explicit --cwd / env override still wins (and is subject to the
+// orchestrator's containment check).
 if (!cwd) {
-  if (!orchestrator.baseDir) {
-    throw new Error(`orchestrator ${orchestrator.id} did not report a baseDir; pass --cwd or set AGENT_RELAY_SMOKE_CWD`);
+  if (orchestrator.id !== hostname()) {
+    throw new Error(`orchestrator ${orchestrator.id} is remote; pass --cwd or set AGENT_RELAY_SMOKE_CWD to a git repo on that host`);
+  }
+  cwd = localRepoRoot() || "";
+  if (!cwd) {
+    throw new Error("could not resolve the local git repo root; pass --cwd or set AGENT_RELAY_SMOKE_CWD");
   }
-  cwd = orchestrator.baseDir;
 }
 console.log(`using cwd ${cwd} on ${orchestrator.id} (base ${orchestrator.baseDir})`);
 

package/src/branch-landed.ts

@@ -2,7 +2,7 @@ import { errMessage, type BaseWorktreeSyncResult } from "agent-relay-sdk";
 import { emitRelayEvent } from "./events";
 import { routeNotification, INFORMATIONAL_TTL_MS } from "./notification-router";
 import { registerDefaultAudienceRules, audiencePredicates } from "./notification-rules";
-import { createActivityEvent, getAgent, updateWorkspaceStatus } from "./db";
+import { createActivityEvent, deliverableTaskIdsByBranch, deliverableTaskIdsByOwnerAgent, getAgent, getTaskDetail, updateWorkspaceStatus } from "./db";
 import { renderTemplate } from "./prompt-resolver";
 import { resolveCoordinatorAgentId } from "./steward-identity";
 import { stewardFallbackTarget } from "./config";
@@ -85,6 +85,15 @@ function landedCommitSubjects(input: BranchLandedInput, log: BranchLandedLogFn):
   }
 }
 
+function resolveLandedTask(workspace: Pick<WorkspaceRecord, "branch" | "ownerAgentId">): { taskId: number; taskLabel: string } | undefined {
+  const branchTaskId = workspace.branch ? deliverableTaskIdsByBranch(workspace.branch)[0] : undefined;
+  const ownerTaskIds = !branchTaskId && workspace.ownerAgentId ? deliverableTaskIdsByOwnerAgent(workspace.ownerAgentId) : [];
+  const taskId = branchTaskId ?? (ownerTaskIds.length === 1 ? ownerTaskIds[0] : undefined);
+  if (!taskId) return undefined;
+  const task = getTaskDetail(taskId);
+  return task ? { taskId: task.id, taskLabel: task.title } : undefined;
+}
+
 /**
  * #239 — turn an authoritative land completion into a relay-driven push so the author
  * stops polling to learn it merged. Always emits the durable `branch.landed` event (the
@@ -100,6 +109,7 @@ export function notifyBranchLanded(input: BranchLandedInput): void {
   const shortSha = input.mergedSha ? input.mergedSha.slice(0, 12) : undefined;
   const lifecycleLog = (message: string) => console.warn(message);
   const commitSubjects = landedCommitSubjects(input, lifecycleLog);
+  const landedTask = resolveLandedTask(workspace);
 
   emitRelayEvent({
     type: "branch.landed",
@@ -115,6 +125,7 @@ export function notifyBranchLanded(input: BranchLandedInput): void {
       author: workspace.ownerAgentId,
       newBranch: input.newBranch,
       pushed: input.pushed,
+      ...landedTask,
     },
   });
   emitRelayEvent({
@@ -132,6 +143,7 @@ export function notifyBranchLanded(input: BranchLandedInput): void {
       newBranch: input.newBranch,
       pushed: input.pushed,
       notification: "landed-success",
+      ...landedTask,
     },
   });
   // #482/#833 issue close FIRST, then the #831 Task drive: the Task's close PROJECTION
@@ -164,6 +176,7 @@ export function notifyBranchLanded(input: BranchLandedInput): void {
     author,
     newBranch: input.newBranch,
     pushed: input.pushed,
+    ...landedTask,
   };
 
   // A local-only land (push disabled, or base has no upstream) has NOT reached the

package/src/config-store.ts

@@ -67,14 +67,14 @@ const WORKER_TOOL_GROUPS = ["core", "workspace", "memory", "artifacts", "blackbo
 
 function builtInAgentProfiles(): AgentProfile[] {
   return [
-    agentProfileDefaults({ name: DEFAULT_SPAWN_PROFILE_NAME, icon: "🤖", description: "Relay-aware spawned agent with bundled Relay context, skills, plugins, and status integration.", base: "host", mcp: { mode: "none" }, relay: { tools: { groups: WORKER_TOOL_GROUPS } } }),
+    agentProfileDefaults({ name: DEFAULT_SPAWN_PROFILE_NAME, icon: "🤖", description: "Relay-aware spawned agent with bundled Relay context, skills, plugins, and status integration.", base: "minimal", instructions: { append: [], repoInstructions: "allow", globalInstructions: "allow" }, sharedMcp: { policy: "all" }, hostAssets: { skills: true, plugins: true }, relay: { context: true, skills: true, plugins: true, statusLine: true, mcp: true, tools: { groups: WORKER_TOOL_GROUPS } }, permissions: { filesystem: "host" } }),
     agentProfileDefaults({ name: "minimal", icon: "▫️", description: "Repo-focused spawned agent with Relay affordances disabled and host/global extras avoided where supported.", base: "minimal" }),
     agentProfileDefaults({ name: "isolated-research", icon: "🔬", description: "Strict profile for autonomous research runs: repo context only, no Relay prompt surface, no global extras where supported.", base: "isolated" }),
     agentProfileDefaults({ name: "vanilla", icon: "🫥", description: "Zero host bleed (#552): isolated provider home with host plugins, skills, hooks, MCP, and the CLAUDE.md/AGENTS.md cascade (repo + global) all suppressed at launch. Relay provisions any surface explicitly per profile.", base: "vanilla" }),
     agentProfileDefaults({ name: "lean-worker", icon: "🪶", description: "Lean worker profile (#570): vanilla host-dependency drop with only Relay context/MCP restored and Project knowledge injected from the spawn cwd.", base: "vanilla", relay: { context: true, skills: false, plugins: false, statusLine: false, mcp: true, tools: { groups: WORKER_TOOL_GROUPS } }, projectInstructions: { policy: "all" } }),
-    agentProfileDefaults({ name: "coordinator", icon: "🧭", description: "Relay-aware coordination lead for spawning worker teams, maintaining shared state, and driving review and release.", base: "host", instructions: { append: [renderTemplate("profile.coordinator.charter")], repoInstructions: "allow", globalInstructions: "allow" }, maxSpawnedAgents: 8 }),
+    agentProfileDefaults({ name: "coordinator", icon: "🧭", description: "Relay-aware coordination lead for spawning worker teams, maintaining shared state, and driving review and release.", base: "minimal", instructions: { append: [renderTemplate("profile.coordinator.charter")], repoInstructions: "allow", globalInstructions: "allow" }, sharedMcp: { policy: "all" }, hostAssets: { skills: true, plugins: true }, relay: { context: true, skills: true, plugins: true, statusLine: true, mcp: true }, permissions: { filesystem: "host" }, maxSpawnedAgents: 8 }),
     agentProfileDefaults({ name: "ops-assistant", icon: "🛠️", description: "Relay-aware ops lieutenant for a coordinator: runs tests, releases, smoke probes, gates, and host checks, then reports crisp outcomes back up.", provider: "codex", base: "host", instructions: { append: [renderTemplate("profile.ops-assistant.brief")], repoInstructions: "allow", globalInstructions: "allow" }, notifications: { responseMode: "results-only" }, permissions: { mode: "open", filesystem: "host" } }),
-    agentProfileDefaults({ name: "worker", icon: "🔨", description: "Relay-aware focused implementer with open approval posture and no delegated spawn capability.", base: "host", instructions: { system: renderTemplate("profile.worker.system"), append: [], repoInstructions: "allow", globalInstructions: "allow" }, mcp: { mode: "none" }, permissions: { mode: "open", filesystem: "host" }, relay: { tools: { groups: WORKER_TOOL_GROUPS } } }),
+    agentProfileDefaults({ name: "worker", icon: "🔨", description: "Relay-aware focused implementer with open approval posture and no delegated spawn capability.", base: "minimal", instructions: { system: renderTemplate("profile.worker.system"), append: [], repoInstructions: "allow", globalInstructions: "allow" }, sharedMcp: { policy: "all" }, hostAssets: { skills: true, plugins: true }, relay: { context: true, skills: true, plugins: true, statusLine: true, mcp: true, tools: { groups: WORKER_TOOL_GROUPS } }, permissions: { mode: "open", filesystem: "host" } }),
     agentProfileDefaults({ name: "reviewer", icon: "🔍", description: "Relay-aware read-only reviewer for audit and review passes without file writes.", base: "host", mcp: { mode: "none" }, permissions: { mode: "read-only", filesystem: "host" }, relay: { tools: { groups: WORKER_TOOL_GROUPS } } }),
   ].map((profile) => ({ ...profile, builtIn: true }));
 }
@@ -272,6 +272,16 @@ function cleanAgentProfileSharedMcp(value: unknown): AgentProfile["sharedMcp"] {
   return { policy: cleanEnum(policy, "sharedMcp.policy", SHARED_MCP_POLICY_NAMES) as NonNullable<AgentProfile["sharedMcp"]>["policy"] };
 }
 
+function cleanAgentProfileHostAssets(value: unknown): AgentProfile["hostAssets"] {
+  if (value === undefined || value === null || value === false) return undefined;
+  if (!isRecord(value)) throw new ValidationError("hostAssets must be an object");
+  const hostAssets = {
+    ...(value.skills === undefined ? {} : { skills: cleanBoolean(value.skills, "hostAssets.skills") }),
+    ...(value.plugins === undefined ? {} : { plugins: cleanBoolean(value.plugins, "hostAssets.plugins") }),
+  };
+  return Object.keys(hostAssets).length ? hostAssets : undefined;
+}
+
 function cleanAgentProfileNotifications(value: unknown): AgentProfile["notifications"] {
   if (value === undefined || value === null) return undefined;
   if (!isRecord(value)) throw new ValidationError("notifications must be an object");
@@ -306,6 +316,7 @@ function agentProfileDefaults(input: Pick<AgentProfile, "name" | "base"> & Omit<
     ...(input.projectSkills ? { projectSkills: input.projectSkills } : {}),
     ...(input.projectSettings ? { projectSettings: input.projectSettings } : {}),
     ...(input.sharedMcp ? { sharedMcp: input.sharedMcp } : {}),
+    ...(input.hostAssets ? { hostAssets: input.hostAssets } : {}),
     ...(input.notifications ? { notifications: input.notifications } : {}),
     relay: {
       context: input.relay?.context ?? !isolated,
@@ -389,6 +400,7 @@ function validateAgentProfile(key: string, value: unknown, opts: { allowBuiltIn?
     projectSkills: cleanAgentProfileProjectSkills(value.projectSkills),
     projectSettings: cleanAgentProfileProjectSettings(value.projectSettings),
     sharedMcp: cleanAgentProfileSharedMcp(value.sharedMcp),
+    hostAssets: cleanAgentProfileHostAssets(value.hostAssets),
     notifications: cleanAgentProfileNotifications(value.notifications),
     relay: {
       context: relay.context === undefined ? defaults.relay.context : cleanBoolean(relay.context, "relay.context"),

package/src/db/mappers.ts

@@ -277,6 +277,7 @@ export function rowToTask(row: any): Task {
   return {
     id: row.id,
     source: row.source,
+    label: row.title,
     title: row.title,
     body: row.body,
     severity: row.severity as TaskSeverity,
@@ -310,6 +311,8 @@ export function rowToTask(row: any): Task {
     ...(row.commits != null ? { commits: parseJson(row.commits, []) } : {}),
     ...(row.done_when != null ? { doneWhen: row.done_when } : {}),
     ...(row.team_id != null ? { teamId: row.team_id } : {}),
+    ...(row.project_id != null ? { projectId: row.project_id } : {}),
+    ...(row.repo != null ? { repo: row.repo } : {}),
     ...(row.created_by != null ? { createdBy: row.created_by } : {}),
     ...(row.owner_agent_id != null ? { ownerAgentId: row.owner_agent_id } : {}),
     ...(row.dispatch != null ? { dispatch: parseJson(row.dispatch, {}) } : {}),

package/src/db/migrations.ts

@@ -444,11 +444,11 @@ export function applyMigrations(): void {
       created_by TEXT NOT NULL, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
     )
   `);
-  const planCols = getDb().query("PRAGMA table_info(plans)").all() as any[];
-  const planColNames = planCols.map((c: any) => c.name);
+  const planColNames = (getDb().query("PRAGMA table_info(plans)").all() as any[]).map((c: any) => c.name);
   if (!planColNames.includes("team_id")) {
     getDb().run("ALTER TABLE plans ADD COLUMN team_id TEXT");
   }
+  if (!planColNames.includes("archived")) getDb().run("ALTER TABLE plans ADD COLUMN archived INTEGER NOT NULL DEFAULT 0");
   getDb().run("CREATE UNIQUE INDEX IF NOT EXISTS idx_plans_thread_channel ON plans(thread_id, coalesce(channel, ''))");
   getDb().run("CREATE INDEX IF NOT EXISTS idx_plans_updated ON plans(updated_at)");
   getDb().run("CREATE INDEX IF NOT EXISTS idx_plans_team ON plans(team_id)");
@@ -1049,6 +1049,8 @@ export function applyMigrations(): void {
   addTaskCol("commits", "commits TEXT");
   addTaskCol("done_when", "done_when TEXT");
   addTaskCol("team_id", "team_id TEXT");
+  addTaskCol("project_id", "project_id TEXT");
+  addTaskCol("repo", "repo TEXT");
   addTaskCol("created_by", "created_by TEXT");
   addTaskCol("owner_agent_id", "owner_agent_id TEXT");
   addTaskCol("dispatch", "dispatch TEXT");
@@ -1056,6 +1058,43 @@ export function applyMigrations(): void {
   getDb().run("CREATE INDEX IF NOT EXISTS idx_tasks_kind ON tasks(kind, status, updated_at)");
   getDb().run("CREATE INDEX IF NOT EXISTS idx_tasks_branch ON tasks(branch) WHERE branch IS NOT NULL");
   getDb().run("CREATE INDEX IF NOT EXISTS idx_tasks_team ON tasks(team_id) WHERE team_id IS NOT NULL");
+  getDb().run("CREATE INDEX IF NOT EXISTS idx_tasks_project ON tasks(project_id, status, updated_at) WHERE project_id IS NOT NULL");
+  getDb().run("CREATE INDEX IF NOT EXISTS idx_tasks_repo ON tasks(repo, status, updated_at) WHERE repo IS NOT NULL");
+  getDb().run(`
+    UPDATE tasks
+    SET repo = (
+      SELECT ir.repo
+      FROM issue_associations ia
+      JOIN issue_refs ir ON ir.id = ia.issue_ref_id
+      WHERE ia.entity_type = 'task' AND ia.entity_id = CAST(tasks.id AS TEXT)
+      ORDER BY ia.created_at ASC, ir.id ASC
+      LIMIT 1
+    )
+    WHERE kind = 'deliverable'
+      AND (repo IS NULL OR trim(repo) = '')
+      AND EXISTS (
+        SELECT 1 FROM issue_associations ia
+        JOIN issue_refs ir ON ir.id = ia.issue_ref_id
+        WHERE ia.entity_type = 'task' AND ia.entity_id = CAST(tasks.id AS TEXT)
+      )
+  `);
+  getDb().run(`
+    UPDATE tasks
+    SET project_id = (
+      SELECT p.id
+      FROM projects p
+      WHERE p.scope = 'project' AND p.issue_repo = tasks.repo
+      ORDER BY p.created_at ASC, p.id ASC
+      LIMIT 1
+    )
+    WHERE kind = 'deliverable'
+      AND (project_id IS NULL OR trim(project_id) = '')
+      AND repo IS NOT NULL AND trim(repo) <> ''
+      AND EXISTS (
+        SELECT 1 FROM projects p
+        WHERE p.scope = 'project' AND p.issue_repo = tasks.repo
+      )
+  `);
 
   getDb().run(`
     CREATE TABLE IF NOT EXISTS task_dependencies (

package/src/db/plans.ts

@@ -8,6 +8,7 @@ interface PlanRow {
   thread_id: number;
   team_id: string | null;
   channel: string | null;
+  archived: number;
   version: number;
   title: string | null;
   objective: string | null;
@@ -52,6 +53,7 @@ function rowToPlan(row: PlanRow): Plan {
     threadId: String(row.thread_id),
     ...(row.team_id ? { teamId: row.team_id } : {}),
     ...(row.channel ? { channel: row.channel } : {}),
+    archived: Boolean(row.archived),
     version: row.version,
     ...(row.title ? { title: row.title } : {}),
     ...(row.objective ? { objective: row.objective } : {}),
@@ -189,6 +191,15 @@ export function replacePlan(input: Plan, changedBy?: string): Plan {
   return getPlan(input.id)!;
 }
 
+export function setPlanArchived(id: string, archived: boolean): Plan {
+  const existing = getPlan(id);
+  if (!existing) throw new ValidationError(`plan ${id} not found`);
+  if (existing.archived === archived) return existing;
+  const now = Date.now();
+  getDb().query("UPDATE plans SET archived = ?, updated_at = ? WHERE id = ?").run(archived ? 1 : 0, now, id);
+  return getPlan(id)!;
+}
+
 export function deletePlan(id: string, changedBy?: string): boolean {
   const existing = getPlan(id);
   if (!existing) return false;

package/src/db/schema.ts

@@ -304,7 +304,7 @@ export function initDb(path: string = "agent-relay.db"): Database {
     CREATE INDEX IF NOT EXISTS idx_project_edges_to ON project_edges(to_project, kind);
     CREATE TABLE IF NOT EXISTS plans (
       id TEXT PRIMARY KEY, thread_id INTEGER NOT NULL, team_id TEXT, channel TEXT, version INTEGER NOT NULL DEFAULT 1,
-      title TEXT, objective TEXT, nodes TEXT NOT NULL DEFAULT '[]', edges TEXT NOT NULL DEFAULT '[]',
+      archived INTEGER NOT NULL DEFAULT 0, title TEXT, objective TEXT, nodes TEXT NOT NULL DEFAULT '[]', edges TEXT NOT NULL DEFAULT '[]',
       created_by TEXT NOT NULL, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
     );
     CREATE UNIQUE INDEX IF NOT EXISTS idx_plans_thread_channel ON plans(thread_id, coalesce(channel, ''));
@@ -657,6 +657,8 @@ export function initDb(path: string = "agent-relay.db"): Database {
       commits TEXT,
       done_when TEXT,
       team_id TEXT,
+      project_id TEXT,
+      repo TEXT,
       created_by TEXT,
       owner_agent_id TEXT,
       dispatch TEXT,

package/src/db/task-entity.ts

@@ -28,6 +28,7 @@ import {
   type TaskGateState,
   type TaskGateStatus,
   type TaskIssueLink,
+  type TaskListItem,
   type TaskStatus,
 } from "../types";
 import { parseJson } from "../utils";
@@ -38,6 +39,7 @@ import { latestTaskDispatchDecision, taskBoundWorkerModel, taskDispatchWorkShape
 import { TASK_SELECT, insertTaskEvent, DELIVERABLE_TASK_KIND } from "./task-core.ts";
 import { associateIssue, listIssuesForEntity, removeAssociation } from "./issue-associations.ts";
 import { resolveIssueRefFromString } from "./issue-refs.ts";
+import { getProject } from "./projects.ts";
 
 // Execution-status axis (#834): the existing claim FSM vocabulary, reused so there is no
 // enum break. not-started=open, working=in_progress, plus claimed/blocked/done/failed/canceled.
@@ -100,6 +102,38 @@ function cleanDispatch(value: unknown): TaskDispatch | undefined {
   return out;
 }
 
+function projectForRepo(repo: string | undefined): string | undefined {
+  const cleaned = repo?.trim();
+  if (!cleaned) return undefined;
+  const row = getDb()
+    .query("SELECT id FROM projects WHERE scope = 'project' AND issue_repo = ? ORDER BY created_at ASC, id ASC LIMIT 1")
+    .get(cleaned) as { id: string } | undefined;
+  return row?.id;
+}
+
+function cleanTaskProject(input: { projectId?: unknown; repo?: unknown }): { projectId?: string; repo?: string } {
+  const projectId = optionalText(input.projectId, "projectId", 120);
+  const project = projectId ? getProject(projectId) : null;
+  const repo = optionalText(input.repo, "repo", 500) ?? project?.issueRepo;
+  return {
+    ...(projectId ? { projectId } : repo ? { projectId: projectForRepo(repo) } : {}),
+    ...(repo ? { repo } : {}),
+  };
+}
+
+function fillTaskProjectFromRepo(id: number, repo: string, now = Date.now()): void {
+  const cleaned = optionalText(repo, "repo", 500);
+  if (!cleaned) return;
+  const projectId = projectForRepo(cleaned);
+  getDb().query(`
+    UPDATE tasks
+    SET repo = COALESCE(NULLIF(trim(repo), ''), ?),
+        project_id = COALESCE(NULLIF(trim(project_id), ''), ?),
+        updated_at = ?
+    WHERE id = ?
+  `).run(cleaned, projectId ?? null, now, id);
+}
+
 function getRawTask(id: number): Task | null {
   const row = getDb().query(`${TASK_SELECT} WHERE id = ?`).get(id) as any;
   return row ? rowToTask(row) : null;
@@ -119,6 +153,8 @@ export interface CreateDeliverableTaskInput {
   context?: string;
   doneWhen?: string;
   teamId?: string;
+  projectId?: string;
+  repo?: string;
   createdBy: string;
   source?: string;
   target?: string;
@@ -134,13 +170,14 @@ export function createDeliverableTask(input: CreateDeliverableTaskInput): TaskDe
   const dispatch = cleanDispatch(input.dispatch);
   const complexity = cleanTaskComplexity(input.complexity ?? dispatch?.complexity, "complexity") ?? DEFAULT_TASK_COMPLEXITY;
   const context = optionalText(input.context, "context", 1_000_000);
+  const taskProject = cleanTaskProject(input);
   // Legacy NOT-NULL columns have no DB defaults (#834 finding 6) — set them explicitly.
   const result = getDb().query(`
     INSERT INTO tasks (
       source, title, body, severity, status, target, occurrence_count, metadata,
       created_at, updated_at, last_seen_at,
-      kind, intent, complexity, context, latest_steer, deliverable_stage, done_when, team_id, created_by, dispatch
-    ) VALUES (?, ?, ?, 'info', 'open', ?, 1, '{}', ?, ?, ?, '${DELIVERABLE_TASK_KIND}', ?, ?, ?, ?, 'none', ?, ?, ?, ?)
+      kind, intent, complexity, context, latest_steer, deliverable_stage, done_when, team_id, project_id, repo, created_by, dispatch
+    ) VALUES (?, ?, ?, 'info', 'open', ?, 1, '{}', ?, ?, ?, '${DELIVERABLE_TASK_KIND}', ?, ?, ?, ?, 'none', ?, ?, ?, ?, ?, ?)
   `).run(
     optionalText(input.source, "source", 200) ?? "coordinator",
     title,
@@ -153,6 +190,8 @@ export function createDeliverableTask(input: CreateDeliverableTaskInput): TaskDe
     optionalText(input.latestSteer, "latestSteer", 1_000_000) ?? null,
     optionalText(input.doneWhen, "doneWhen", 1_000_000) ?? null,
     optionalText(input.teamId, "teamId", 200) ?? null,
+    taskProject.projectId ?? null,
+    taskProject.repo ?? null,
     createdBy,
     dispatch ? JSON.stringify(dispatch) : null,
   );
@@ -163,7 +202,7 @@ export function createDeliverableTask(input: CreateDeliverableTaskInput): TaskDe
     severity: "info",
     title: `Task created: ${title}`,
     body: intent,
-    metadata: { createdBy, complexity, ...(context ? { context } : {}), ...(dispatch ? { dispatch } : {}) },
+    metadata: { createdBy, complexity, ...(context ? { context } : {}), ...(taskProject.projectId ? { projectId: taskProject.projectId } : {}), ...(taskProject.repo ? { repo: taskProject.repo } : {}), ...(dispatch ? { dispatch } : {}) },
   }, now);
   return getTaskDetail(id)!;
 }
@@ -177,6 +216,8 @@ export interface UpdateDeliverableTaskInput {
   doneWhen?: string;
   dispatch?: TaskDispatch;
   teamId?: string;
+  projectId?: string;
+  repo?: string;
   actor?: string;
 }
 
@@ -192,6 +233,11 @@ export function updateDeliverableTask(id: number, input: UpdateDeliverableTaskIn
   if (input.latestSteer !== undefined) push("latest_steer", optionalText(input.latestSteer, "latestSteer", 1_000_000) ?? null);
   if (input.doneWhen !== undefined) push("done_when", optionalText(input.doneWhen, "doneWhen", 1_000_000) ?? null);
   if (input.teamId !== undefined) push("team_id", optionalText(input.teamId, "teamId", 200) ?? null);
+  if (input.projectId !== undefined || input.repo !== undefined) {
+    const taskProject = cleanTaskProject(input);
+    if (input.projectId !== undefined) push("project_id", taskProject.projectId ?? null);
+    if (input.repo !== undefined) push("repo", taskProject.repo ?? null);
+  }
   if (input.dispatch !== undefined) { const d = cleanDispatch(input.dispatch); push("dispatch", d ? JSON.stringify(d) : null); }
   const now = Date.now();
   if (sets.length > 0) {
@@ -424,6 +470,7 @@ export function addTaskRef(id: number, input: AddTaskRefInput): TaskDetail {
   if (input.issue) {
     const ref = resolveIssueRefFromString({ ref: input.issue, defaultRepo: optionalText(input.defaultRepo, "defaultRepo", 500) });
     associateIssue(ref.id, "task", taskEntityId(String(id)));
+    fillTaskProjectFromRepo(id, ref.repo, now);
     insertTaskEvent(id, {
       source: input.actor ?? "agent-relay",
       type: "ref.issue.added",
@@ -619,6 +666,8 @@ export interface ListDeliverableTasksFilter {
   teamId?: string;
   createdBy?: string;
   ownerAgentId?: string;
+  projectId?: string;
+  repo?: string;
   limit?: number;
 }
 
@@ -630,11 +679,37 @@ export function listDeliverableTasks(filter: ListDeliverableTasksFilter = {}): T
   if (filter.teamId) { conditions.push("team_id = ?"); params.push(filter.teamId); }
   if (filter.createdBy) { conditions.push("created_by = ?"); params.push(filter.createdBy); }
   if (filter.ownerAgentId) { conditions.push("owner_agent_id = ?"); params.push(filter.ownerAgentId); }
+  if (filter.projectId) { conditions.push("project_id = ?"); params.push(filter.projectId); }
+  if (filter.repo) { conditions.push("repo = ?"); params.push(filter.repo); }
   const limit = Math.min(Math.max(filter.limit ?? 100, 1), 500);
   params.push(limit);
   return (getDb().query(`${TASK_SELECT} WHERE ${conditions.join(" AND ")} ORDER BY updated_at DESC LIMIT ?`).all(...params as any[]) as any[]).map(rowToTask);
 }
 
+function taskListItem(task: Task): TaskListItem {
+  return {
+    id: task.id,
+    label: task.title,
+    title: task.title,
+    status: task.status,
+    kind: task.kind,
+    ...(task.deliverableStage ? { deliverableStage: task.deliverableStage } : {}),
+    ...(task.teamId ? { teamId: task.teamId } : {}),
+    ...(task.projectId ? { projectId: task.projectId } : {}),
+    ...(task.repo ? { repo: task.repo } : {}),
+    ...(task.createdBy ? { createdBy: task.createdBy } : {}),
+    ...(task.ownerAgentId ? { ownerAgentId: task.ownerAgentId } : {}),
+    ...(task.branch ? { branch: task.branch } : {}),
+    createdAt: task.createdAt,
+    updatedAt: task.updatedAt,
+    ...(task.reapedAt ? { reapedAt: task.reapedAt } : {}),
+  };
+}
+
+export function listDeliverableTaskSummaries(filter: ListDeliverableTasksFilter = {}): TaskListItem[] {
+  return listDeliverableTasks(filter).map(taskListItem);
+}
+
 // Task-aware issue resolution for the land→close bridge (#833/#834 finding 4). Deliverable
 // Tasks own `branch`, so a landed branch resolves to its Task(s). The land WIRING is #831;
 // this is the resolution path + entity-type the bridge needs to be ABLE to fire. The issue

package/src/mcp/index.ts

@@ -54,7 +54,7 @@ export const RELAY_TOOL_GROUPS: Record<string, readonly string[]> = {
   artifacts: ["relay_upload_artifact", "relay_attach_artifact"],
   workspace: ["relay_workspace_status", "relay_workspace_ready", "relay_workspace_deps", "relay_workspace_list", "relay_workspace_claim", "relay_workspace_release", "relay_workspace_land", "relay_merge_pause", "relay_merge_pauses", "relay_merge_renew", "relay_merge_resume"],
   "spawn-lifecycle": ["relay_spawn_agent", "relay_spawn_targets", "relay_my_agents", "relay_shutdown_agent", "relay_agent_action", "relay_agent_status", "relay_agent_crash_report", "relay_schedule_timer", "relay_list_timers", "relay_cancel_timer"],
-  plans: ["relay_plan_create", "relay_plan_add_node", "relay_plan_update_node", "relay_plan_add_edge", "relay_plan_remove_node", "relay_plan_remove_edge", "relay_plan_delete", "relay_plan_get"],
+  plans: ["relay_plan_create", "relay_plan_add_node", "relay_plan_update_node", "relay_plan_add_edge", "relay_plan_remove_node", "relay_plan_remove_edge", "relay_plan_archive", "relay_plan_delete", "relay_plan_get"],
   tasks: ["relay_task_create", "relay_task_get", "relay_task_list", "relay_task_update", "relay_task_set_status", "relay_task_set_stage", "relay_task_record_gate", "relay_task_add_dependency", "relay_task_remove_dependency", "relay_task_add_ref", "relay_task_remove_ref", "relay_task_assign_agent", "relay_task_history", "relay_task_memory_read", "relay_task_memory_replace_working_state", "relay_task_memory_append_ruled_out", "relay_task_memory_append_decision", "relay_task_dispatch", "relay_task_comment", "relay_task_close_bridge", "relay_release_readiness"],
   teams: ["relay_team_get", "relay_team_set_brief", "relay_team_claim", "relay_team_dissolve"],
   blackboard: ["relay_blackboard_write", "relay_blackboard_get", "relay_blackboard_read", "relay_blackboard_search", "relay_blackboard_retract"],

package/src/mcp-plan-tools.ts

@@ -4,6 +4,7 @@ import { authContextFromMcp } from "./services/auth-context";
 import {
   addPlanEdge,
   addPlanNode,
+  archivePlanGraph,
   bindPlanNodeToTask,
   createPlan,
   deletePlanGraph,
@@ -98,6 +99,7 @@ export const PLAN_TOOLS = [
   { name: "relay_plan_add_edge", description: "Add a dependency edge to a plan DAG; rejects cycles.", requiredScopes: ["plans:write"], inputSchema: { type: "object", properties: { planId: { type: "string" }, from: { type: "string" }, to: { type: "string" } }, required: ["planId", "from", "to"], additionalProperties: false } },
   { name: "relay_plan_remove_node", description: "Remove a node and its connected edges from a plan DAG.", requiredScopes: ["plans:write"], inputSchema: { type: "object", properties: { planId: { type: "string" }, nodeId: { type: "string" } }, required: ["planId", "nodeId"], additionalProperties: false } },
   { name: "relay_plan_remove_edge", description: "Remove a dependency edge from a plan DAG.", requiredScopes: ["plans:write"], inputSchema: { type: "object", properties: { planId: { type: "string" }, from: { type: "string" }, to: { type: "string" } }, required: ["planId", "from", "to"], additionalProperties: false } },
+  { name: "relay_plan_archive", description: "Soft-archive or unarchive a persisted plan DAG without deleting its history.", requiredScopes: ["plans:write"], inputSchema: { type: "object", properties: { planId: { type: "string" }, archived: { type: "boolean", default: true } }, required: ["planId"], additionalProperties: false } },
   { name: "relay_plan_delete", description: "Delete a persisted plan DAG and archive its latest version.", requiredScopes: ["plans:write"], inputSchema: { type: "object", properties: { planId: { type: "string" } }, required: ["planId"], additionalProperties: false } },
   {
     name: "relay_plan_bind_node",
@@ -135,6 +137,7 @@ export function relayPlanTool(auth: McpAuthLike, name: string, args: Record<stri
   if (name === "relay_plan_add_edge") return addPlanEdge(stringArg(args.planId, "planId"), { from: args.from, to: args.to }, ctx) as unknown as Record<string, unknown>;
   if (name === "relay_plan_remove_node") return removePlanNode(stringArg(args.planId, "planId"), stringArg(args.nodeId, "nodeId"), ctx) as unknown as Record<string, unknown>;
   if (name === "relay_plan_remove_edge") return removePlanEdge(stringArg(args.planId, "planId"), { from: args.from, to: args.to }, ctx) as unknown as Record<string, unknown>;
+  if (name === "relay_plan_archive") return archivePlanGraph(stringArg(args.planId, "planId"), args.archived !== false, ctx) as unknown as Record<string, unknown>;
   if (name === "relay_plan_delete") return deletePlanGraph(stringArg(args.planId, "planId"), ctx);
   if (name === "relay_plan_bind_node") {
     return bindPlanNodeToTask(