agent-relay-server 0.107.0 → 0.109.0

package/src/services/plan-graph.ts

@@ -1,10 +1,12 @@
 import { isRecord } from "agent-relay-sdk";
-import { createPlanRow, deletePlan, getAgent, getEntry, getPlan, getPlanByTeam, getPlanByThread, listPlansWithBoundOwner, planThreadExists, replacePlan, ValidationError } from "../db";
+import { addTaskDependency, createPlanRow, deletePlan, getAgent, getEntry, getPlan, getPlanByTeam, getPlanByThread, getTaskDetail, listPlansWithBoundOwner, planThreadExists, removeTaskDependency, replacePlan, ValidationError } from "../db";
 import { associateIssue, planNodeIssueEntityId, removeAssociation } from "../db/issue-associations";
 import { resolveIssueRefFromString } from "../db/issue-refs";
 import { emitRelayEvent } from "../events";
 import { cleanString, cleanStringArray, optionalEnum } from "../validation";
 import { defaultIssueRepo } from "../config";
+import { buildTaskGraphView, parseTaskId, planStatusToTaskStatus, projectPlanOverTasks } from "./task-plan-view";
+import { createTaskEntity, setTaskEntityStatus } from "./task-entity";
 import type { AuthContext } from "./auth-context";
 import type { AgentCard, Plan, PlanEdge, PlanNode, PlanOwnerRef, PlanStatus } from "../types";
 
@@ -82,8 +84,20 @@ function cleanRefs(value: unknown): PlanNode["refs"] | undefined {
   if (issueId) {
     out.issueId = resolveIssueRefFromString({ ref: issueId, defaultRepo: defaultIssueRepo() }).id;
   }
-  const unsupported = ["agentId", "taskId", "landingRef"].filter((key) => cleanString(ref[key], `refs.${key}`, { max: 240 }));
-  if (unsupported.length > 0) throw new ValidationError("agentId/taskId/landingRef refs are populated by live binding in slice c");
+  // #836: refs.taskId is the live binding seam to a durable Task. Validate it resolves to a
+  // deliverable Task; store the canonical numeric id as a string. Once bound, the node's
+  // label/scopeBlurb/status PROJECT from the Task (see projectPlanOverTasks) — no double-keeping.
+  const taskIdRaw = ref.taskId;
+  const taskIdStr = typeof taskIdRaw === "number" ? String(taskIdRaw) : cleanString(taskIdRaw, "refs.taskId", { max: 240 });
+  if (taskIdStr) {
+    const taskId = parseTaskId(taskIdStr);
+    if (taskId === undefined) throw new ValidationError("refs.taskId must be a positive task id");
+    if (!getTaskDetail(taskId)) throw new ValidationError(`refs.taskId ${taskId} is not a deliverable task`);
+    out.taskId = String(taskId);
+  }
+  // agentId/landingRef remain populated by live binding in later slices (#838); reject here.
+  const unsupported = ["agentId", "landingRef"].filter((key) => cleanString(ref[key], `refs.${key}`, { max: 240 }));
+  if (unsupported.length > 0) throw new ValidationError("agentId/landingRef refs are populated by live binding in a later slice");
   return Object.keys(out).length ? out : undefined;
 }
 
@@ -300,11 +314,39 @@ function optionalProp<K extends keyof PlanNode>(key: K, value: PlanNode[K] | und
   return value === undefined ? { [key]: undefined } as Partial<PlanNode> : { [key]: value } as Partial<PlanNode>;
 }
 
+// The Task this node is bound to (#836), or undefined for an unbound node / missing node.
+function boundTaskId(plan: Plan, nodeId: string): number | undefined {
+  const node = plan.nodes.find((item) => item.id === nodeId);
+  return node ? parseTaskId(node.refs?.taskId) : undefined;
+}
+
+// Cycle safety across BOTH edge stores (#836 review). Edges live in two places — the JSON
+// `plan.edges` (legacy/mixed) and task_dependencies (bound pairs) — and each store's own
+// checker sees only half the graph, so a cycle that SPANS the two (e.g. task edge A→B plus
+// JSON edges B→C, C→A) would slip through. Validate the COMBINED projected graph (task deps ∪
+// JSON edges) with the prospective edge before mutating either store. projectPlanOverTasks
+// already unions both stores into `edges`, so this is the single source of truth for the graph.
+function assertEdgeKeepsAcyclic(plan: Plan, edge: PlanEdge): void {
+  const projected = projectPlanOverTasks(plan);
+  validateEdges(projected.nodes, dedupeEdges([...projected.edges, edge]));
+}
+
 export function addPlanEdge(planId: string, edgeInput: unknown, ctx: AuthContext): Plan {
   const plan = existingPlan(planId);
   const edge = cleanEdge(edgeInput);
+  assertEdgeKeepsAcyclic(plan, edge);
+  // #836: when BOTH endpoints are Task-bound, the canonical edge store is task_dependencies,
+  // not the plan JSON. Plan edge {from,to} means `to` depends on `from`. The combined-graph
+  // pre-check above already rejected cross-store cycles; the edge surfaces back via projection.
+  const fromTask = boundTaskId(plan, edge.from);
+  const toTask = boundTaskId(plan, edge.to);
+  if (fromTask !== undefined && toTask !== undefined) {
+    addTaskDependency(toTask, fromTask, actorId(ctx));
+    const projected = projectPlanOverTasks(existingPlan(planId));
+    emitPlan("plan.changed", projected, actorId(ctx));
+    return projected;
+  }
   const edges = dedupeEdges([...plan.edges, edge]);
-  validateEdges(plan.nodes, edges);
   const updated = replacePlan({ ...plan, edges }, actorId(ctx));
   emitPlan("plan.changed", updated, actorId(ctx));
   return updated;
@@ -327,6 +369,15 @@ export function removePlanNode(planId: string, nodeId: string, ctx: AuthContext)
 export function removePlanEdge(planId: string, edgeInput: unknown, ctx: AuthContext): Plan {
   const plan = existingPlan(planId);
   const edge = cleanEdge(edgeInput);
+  // #836: a bound-pair edge lives in task_dependencies. Try that store first; fall through to
+  // the JSON path so a legacy edge stored before the nodes were bound is still removable.
+  const fromTask = boundTaskId(plan, edge.from);
+  const toTask = boundTaskId(plan, edge.to);
+  if (fromTask !== undefined && toTask !== undefined && removeTaskDependency(toTask, fromTask, actorId(ctx))) {
+    const projected = projectPlanOverTasks(existingPlan(planId));
+    emitPlan("plan.changed", projected, actorId(ctx));
+    return projected;
+  }
   const edges = plan.edges.filter((item) => item.from !== edge.from || item.to !== edge.to);
   if (edges.length === plan.edges.length) throw new ValidationError(`edge ${edge.from}->${edge.to} not found`);
   const updated = replacePlan({ ...plan, edges }, actorId(ctx));
@@ -367,11 +418,58 @@ export function updateBoundPlanNodesFromAgent(agentId: string, actor = "server")
   return status ? updateBoundPlanNodesForAgent(agentId, status, actor) : [];
 }
 
-export function getPlanGraph(input: { planId?: unknown; threadId?: unknown; teamId?: unknown; channel?: unknown }): Plan | null {
-  const planId = cleanString(input.planId, "planId", { max: 120 });
-  if (planId) return getPlan(planId);
+// #836: `view: "tasks"` returns the pure task-backed DAG synthesized from a team's deliverable
+// Tasks (no plan row needed) — the endgame view. Otherwise a stored plan is fetched and overlaid
+// with its Task bindings via projectPlanOverTasks (coexistence: unbound plans pass through).
+export function getPlanGraph(input: { planId?: unknown; threadId?: unknown; teamId?: unknown; channel?: unknown; view?: unknown }): Plan | null {
+  const view = cleanString(input.view, "view", { max: 40 });
   const teamId = cleanString(input.teamId, "teamId", { max: 120 });
-  if (teamId) return getPlanByTeam(teamId, cleanString(input.channel, "channel", { max: 120 }));
+  if (view === "tasks") {
+    if (!teamId) throw new ValidationError("view 'tasks' requires teamId");
+    return buildTaskGraphView({ teamId });
+  }
+  const planId = cleanString(input.planId, "planId", { max: 120 });
+  if (planId) { const plan = getPlan(planId); return plan ? projectPlanOverTasks(plan) : null; }
+  if (teamId) { const plan = getPlanByTeam(teamId, cleanString(input.channel, "channel", { max: 120 })); return plan ? projectPlanOverTasks(plan) : null; }
   const threadId = cleanThreadId(input.threadId);
-  return getPlanByThread(threadId, cleanString(input.channel, "channel", { max: 120 }));
+  const plan = getPlanByThread(threadId, cleanString(input.channel, "channel", { max: 120 }));
+  return plan ? projectPlanOverTasks(plan) : null;
+}
+
+// --- #836 migration: plan node → Task. The "no double-bookkeeping" path. Either links an
+// existing deliverable Task, or mints one from the node's label/scopeBlurb/status and binds it.
+// After binding, the node's display fields project from the Task (projectPlanOverTasks).
+export interface BindPlanNodeInput {
+  taskId?: number;
+}
+
+export function bindPlanNodeToTask(planId: string, nodeId: string, input: BindPlanNodeInput, ctx: AuthContext): { plan: Plan; taskId: number } {
+  const plan = existingPlan(planId);
+  const node = plan.nodes.find((item) => item.id === nodeId);
+  if (!node) throw new ValidationError(`node ${nodeId} not found`);
+  if (node.refs?.taskId) throw new ValidationError(`node ${nodeId} is already bound to task ${node.refs.taskId}`);
+  const actor = actorId(ctx);
+  let taskId = input.taskId;
+  if (taskId === undefined) {
+    const created = createTaskEntity({
+      title: node.label,
+      ...(node.scopeBlurb ? { intent: node.scopeBlurb } : {}),
+      ...(plan.teamId ? { teamId: plan.teamId } : {}),
+      createdBy: actor,
+    });
+    taskId = created.id;
+    // Carry the plan node's coarse status onto the new Task so the migrated board reads true.
+    const status = planStatusToTaskStatus(node.status);
+    if (status !== "open") {
+      setTaskEntityStatus(taskId, {
+        status,
+        ...(status === "blocked" ? { blockedBy: [{ type: "external", note: "migrated from plan node" }] } : {}),
+        actor,
+      });
+    }
+  } else if (!getTaskDetail(taskId)) {
+    throw new ValidationError(`task ${taskId} not found or not a deliverable task`);
+  }
+  const updated = updatePlanNode(planId, nodeId, { refs: { ...(node.refs ?? {}), taskId: String(taskId) } }, ctx);
+  return { plan: projectPlanOverTasks(updated), taskId };
 }

package/src/services/release-readiness.ts

@@ -0,0 +1,142 @@
+import { getTaskDetail, listDeliverableTasks } from "../db/task-entity";
+import type { TaskCommitRef, TaskDetail, TaskIssueLink } from "../types";
+
+export type ReleaseBump = "none" | "patch" | "minor" | "major";
+
+export interface ReleaseReadinessEvidence {
+  source: "task-title" | "issue-title" | "commit-subject" | "label" | "fallback";
+  value: string;
+  bump: ReleaseBump;
+  reason: string;
+}
+
+export interface ReleaseReadinessTask {
+  taskId: number;
+  title: string;
+  status: string;
+  deliverableStage: string;
+  issues: TaskIssueLink[];
+  commits: TaskCommitRef[];
+  commitRange?: string;
+  suggestedBump: ReleaseBump;
+  evidence: ReleaseReadinessEvidence[];
+}
+
+export interface ReleaseReadinessReport {
+  generatedAt: number;
+  unreleasedCount: number;
+  suggestedBump: ReleaseBump;
+  commitRange?: string;
+  tasks: ReleaseReadinessTask[];
+}
+
+export interface ReleaseReadinessOptions {
+  teamId?: string;
+  limit?: number;
+}
+
+const PATCH_TYPES = new Set(["fix", "chore", "docs", "refactor", "perf", "test", "build", "ci"]);
+
+function bumpRank(bump: ReleaseBump): number {
+  if (bump === "major") return 3;
+  if (bump === "minor") return 2;
+  if (bump === "patch") return 1;
+  return 0;
+}
+
+function maxBump(values: ReleaseBump[]): ReleaseBump {
+  return values.reduce((best, bump) => bumpRank(bump) > bumpRank(best) ? bump : best, "none" as ReleaseBump);
+}
+
+function commitRange(commits: TaskCommitRef[]): string | undefined {
+  const shas = commits.map((commit) => commit.sha).filter(Boolean);
+  if (shas.length === 0) return undefined;
+  if (shas.length === 1) return shas[0];
+  return `${shas[0]}..${shas[shas.length - 1]}`;
+}
+
+function evidenceFromConventionalPrefix(source: ReleaseReadinessEvidence["source"], value: string): ReleaseReadinessEvidence | undefined {
+  const normalized = value.trim();
+  const match = normalized.match(/^([a-z][a-z0-9-]*)(?:\([^)]+\))?(!)?:/i);
+  if (!match) return undefined;
+  const type = match[1]!.toLowerCase();
+  const breaking = match[2] === "!";
+  if (breaking) return { source, value: normalized, bump: "major", reason: "conventional commit breaking marker" };
+  if (type === "feat") return { source, value: normalized, bump: "minor", reason: "conventional feat prefix" };
+  if (PATCH_TYPES.has(type)) return { source, value: normalized, bump: "patch", reason: `conventional ${type} prefix` };
+  return undefined;
+}
+
+function evidenceFromLabel(label: string): ReleaseReadinessEvidence | undefined {
+  const value = label.trim();
+  const normalized = value.toLowerCase();
+  if (!normalized) return undefined;
+  if (["breaking", "breaking-change", "major"].includes(normalized)) {
+    return { source: "label", value, bump: "major", reason: "release label" };
+  }
+  if (["feat", "feature", "minor"].includes(normalized)) {
+    return { source: "label", value, bump: "minor", reason: "release label" };
+  }
+  if (["fix", "bug", "bugfix", "chore", "patch"].includes(normalized)) {
+    return { source: "label", value, bump: "patch", reason: "release label" };
+  }
+  return undefined;
+}
+
+function labelsFromTask(task: TaskDetail): string[] {
+  const raw = task.metadata.labels ?? task.metadata.issueLabels ?? task.metadata.releaseLabels;
+  if (!Array.isArray(raw)) return [];
+  return raw.filter((item): item is string => typeof item === "string");
+}
+
+function classifyTask(task: TaskDetail): { bump: ReleaseBump; evidence: ReleaseReadinessEvidence[] } {
+  const evidence = [
+    evidenceFromConventionalPrefix("task-title", task.title),
+    ...task.issues.map((issue) => issue.title ? evidenceFromConventionalPrefix("issue-title", issue.title) : undefined),
+    ...task.commits?.map((commit) => commit.subject ? evidenceFromConventionalPrefix("commit-subject", commit.subject) : undefined) ?? [],
+    ...labelsFromTask(task).map(evidenceFromLabel),
+  ].filter((item): item is ReleaseReadinessEvidence => item !== undefined);
+
+  const bump = maxBump(evidence.map((item) => item.bump));
+  if (bump !== "none") return { bump, evidence };
+  return {
+    bump: "patch",
+    evidence: [{ source: "fallback", value: task.title, bump: "patch", reason: "landed deliverable without feat/fix/chore evidence" }],
+  };
+}
+
+export function releaseReadinessReport(options: ReleaseReadinessOptions = {}): ReleaseReadinessReport {
+  const landed = listDeliverableTasks({
+    deliverableStage: "landed-on-main",
+    teamId: options.teamId,
+    limit: options.limit ?? 500,
+  })
+    .map((task) => getTaskDetail(task.id))
+    .filter((task): task is TaskDetail => Boolean(task))
+    .filter((task) => task.deliverableStage === "landed-on-main");
+
+  const tasks = landed.map((task): ReleaseReadinessTask => {
+    const classification = classifyTask(task);
+    const commits = task.commits ?? [];
+    return {
+      taskId: task.id,
+      title: task.title,
+      status: task.status,
+      deliverableStage: task.deliverableStage ?? "landed-on-main",
+      issues: task.issues,
+      commits,
+      ...(commitRange(commits) ? { commitRange: commitRange(commits) } : {}),
+      suggestedBump: classification.bump,
+      evidence: classification.evidence,
+    };
+  });
+
+  const allCommits = tasks.flatMap((task) => task.commits);
+  return {
+    generatedAt: Date.now(),
+    unreleasedCount: tasks.length,
+    suggestedBump: tasks.length === 0 ? "none" : maxBump(tasks.map((task) => task.suggestedBump)),
+    ...(commitRange(allCommits) ? { commitRange: commitRange(allCommits) } : {}),
+    tasks,
+  };
+}

package/src/services/send-message.ts

@@ -24,6 +24,7 @@
 import { canonicalHumanAgentId, isHumanAgentId, isMechanicalMessageKind, isRecord, isReservedAgentId } from "agent-relay-sdk";
 import {
   ValidationError,
+  getAgent,
   getMessage,
   listAgents,
   promoteLineageCapturedResponse,
@@ -185,6 +186,8 @@ export function sendMessageService(
       ?? spawnObligationAnsweredBy(input.from, input.to);
     if (answered !== null) input.replyTo = answered;
   }
+  const suppressedParent = suppressResultsOnlyAck(input);
+  if (suppressedParent) return { message: suppressedParent, created: false, receipt };
   const result = sendMessageWithResult(input);
   if (result.created) {
     if (result.message.deliveryStatus === "queued") {
@@ -207,3 +210,31 @@ export function sendMessageService(
   }
   return { message: result.message, created: result.created, receipt };
 }
+
+function suppressResultsOnlyAck(input: SendMessageInput): Message | null {
+  if (input.kind && input.kind !== "chat" && input.kind !== "session") return null;
+  const sender = getAgent(input.from);
+  const profile = isRecord(sender?.meta?.agentProfile) ? sender.meta.agentProfile : undefined;
+  const notifications = isRecord(profile?.notifications) ? profile.notifications : undefined;
+  if (notifications?.responseMode !== "results-only") return null;
+  if (!isPassiveAck(input.body)) return null;
+  if (isRecord(input.payload?.responseCapture)) return null;
+  const session = isRecord(input.payload?.session) ? input.payload.session : undefined;
+  if (session?.final === true) return null;
+  return input.replyTo ? getMessage(input.replyTo) : null;
+}
+
+function isPassiveAck(body: string): boolean {
+  const text = body.toLowerCase().replace(/[.!]+/g, "").replace(/\s+/g, " ").trim();
+  return [
+    "noted",
+    "noted standing by",
+    "acknowledged",
+    "acknowledged standing by",
+    "standing by",
+    "ok standing by",
+    "okay standing by",
+    "understood",
+    "understood standing by",
+  ].includes(text);
+}

package/src/services/spawn-agent.ts

@@ -25,7 +25,7 @@
 // deliberately out of scope here — this slice converges the two external TRANSPORTS.
 import type { SpawnProvider } from "agent-relay-sdk";
 import { DEFAULT_USER_ID, errMessage, isRecord, stringValue } from "agent-relay-sdk";
-import { countLiveSpawnedAgents, createActivityEvent, ensureTeam, getAgent, listAgents, listWorkspaces, resolveAgentOwnership, resolveProjectForCwd, resolveScopedAnchor, setAgentTeam, ValidationError, withResolvedProvisioning } from "../db";
+import { assignTaskAgent, countLiveSpawnedAgents, createActivityEvent, ensureTeam, getAgent, listAgents, listWorkspaces, recordTaskSpawnRequested, resolveAgentOwnership, resolveProjectForCwd, resolveScopedAnchor, setAgentTeam, ValidationError, withResolvedProvisioning } from "../db";
 import { createCommand } from "../commands-db";
 import { emitCommandEvent } from "../command-events";
 import { buildSpawnCommand, generateSpawnRequestId, resolveSpawnModelParams } from "../spawn-command";
@@ -38,6 +38,8 @@ import type { ProjectSettingsPolicy } from "../project-settings";
 import type { ProjectSkillsPolicy } from "../project-skills";
 import { applyDefaultSharedMcp, type SharedMcpSpawnOverride } from "../shared-mcp";
 import { autoSeedProjectForCwd } from "./project";
+import { hydrateTaskContext, projectTaskHydration } from "./task-context-hydration";
+import { dispatchTask } from "../task-dispatcher";
 import { hasComponentScope, isComponentAuthorizedFor } from "../security";
 import { isPathWithinBase } from "../utils";
 import { McpAuthError, McpNotFoundError } from "../mcp-errors";
@@ -70,6 +72,16 @@ export interface SpawnAgentInput {
   profile?: string;
   prompt?: string;
   systemPromptAppend?: string;
+  /**
+   * #838 — spawn-with-task. When set, relay hydrates the worker's FIRST-TURN context FROM the
+   * durable Task #834 (intent + linked-issue spec/acceptance + recorded decisions + history +
+   * attribution) instead of the caller hand-writing a brief, records the spawn on the Task for
+   * attribution, and (when model/effort are omitted) MAY resolve them from the Task's dispatch
+   * work-shape (#839). Absent = today's behavior, byte-identical.
+   */
+  taskId?: number;
+  /** #838 — the latest one-line steer; the actionable instruction layered over the hydrated Task context. */
+  steer?: string;
   /**
    * #409 — project instruction projection. When set, relay composes an instruction
    * preamble from the spawn's resolved project (own entries + inherited `contains`-
@@ -194,7 +206,45 @@ export async function spawnAgent(input: SpawnAgentInput, ctx: AuthContext): Prom
   const inheritedCwd = callerCwd && isPathWithinBase(callerCwd, orchestrator.baseDir) ? callerCwd : undefined;
   const resolvedCwd = input.cwd || inheritedCwd || orchestrator.baseDir;
 
-  const modelParams = resolveSpawnModelParams(input.provider, input.model, input.effort);
+  // #838 — spawn-with-task hydration. When a taskId is given, relay assembles the worker's
+  // first-turn context FROM the durable Task (intent + linked-issue spec/acceptance + recorded
+  // decisions + history + latest steer), resolved server-side ONCE, and projects it onto the
+  // provider-appropriate channel (Claude → systemPromptAppend; Codex/other → first message). The
+  // caller-supplied systemPromptAppend/prompt are preserved. Absent (no taskId) = byte-identical
+  // to today: `resolvedSystemPromptAppend`/`resolvedPrompt` stay the raw inputs.
+  let resolvedSystemPromptAppend = input.systemPromptAppend;
+  let resolvedPrompt = input.prompt;
+  let hydratedTask: Awaited<ReturnType<typeof hydrateTaskContext>> | undefined;
+  if (input.taskId !== undefined) {
+    hydratedTask = await hydrateTaskContext({ taskId: input.taskId, steer: input.steer });
+    const projection = projectTaskHydration(
+      input.provider,
+      hydratedTask.context,
+      hydratedTask.steer,
+      input.systemPromptAppend,
+      input.prompt,
+    );
+    resolvedSystemPromptAppend = projection.systemPromptAppend;
+    resolvedPrompt = projection.prompt;
+  }
+
+  // #838/#839 — OPTIONAL dispatch composition: when a Task is given and the caller pinned NEITHER
+  // model NOR effort, resolve them from the Task's dispatch work-shape (provider stays the explicit
+  // pin). Best-effort: a dispatch failure never blocks the spawn. Explicit model/effort always win,
+  // and a no-taskId spawn is untouched — the coupling is opt-in, not hard-wired.
+  let dispatchModel = input.model;
+  let dispatchEffort = input.effort;
+  if (hydratedTask && !input.model && !input.effort && hydratedTask.task.dispatch) {
+    try {
+      const decision = dispatchTask(hydratedTask.task.dispatch, { provider: input.provider });
+      dispatchModel = decision.target.model ?? dispatchModel;
+      dispatchEffort = decision.target.effort ?? dispatchEffort;
+    } catch (err) {
+      console.warn(`task ${input.taskId} dispatch resolution skipped: ${errMessage(err)}`);
+    }
+  }
+
+  const modelParams = resolveSpawnModelParams(input.provider, dispatchModel, dispatchEffort);
 
   // #331 — default the child's approval mode to the CALLER's, not a hardcoded `guarded` (a
   // headless `guarded` child wedges on its first tool-call approval prompt). Explicit always
@@ -333,7 +383,7 @@ export async function spawnAgent(input: SpawnAgentInput, ctx: AuthContext): Prom
     ...(userAnchor ? { userAnchor } : {}),
     ...(agentProfile ? { profile: agentProfile } : {}),
     ...(callerId ? { spawnedBy: callerId } : {}),
-    ...(input.systemPromptAppend ? { callerSystemPromptAppend: input.systemPromptAppend } : {}),
+    ...(resolvedSystemPromptAppend ? { callerSystemPromptAppend: resolvedSystemPromptAppend } : {}),
   });
   const systemPromptAppend = composedInstructions.systemPromptAppend;
   // TODO(#569): comms:delivered emitter — deferred, lives on the #575 delivery path.
@@ -384,7 +434,7 @@ export async function spawnAgent(input: SpawnAgentInput, ctx: AuthContext): Prom
       approvalMode,
       permissionMode: approvalMode,
       providerArgs: input.providerArgs ?? [],
-      prompt: input.prompt,
+      prompt: resolvedPrompt,
       systemPromptAppend,
       relayInjectionEvents: composedInstructions.relayInjectionEvents,
       landStrategy: input.landStrategy,
@@ -431,10 +481,37 @@ export async function spawnAgent(input: SpawnAgentInput, ctx: AuthContext): Prom
     },
   });
 
+  // #838 — record the spawn on the Task FOR attribution, keyed on spawnRequestId. Done now (not
+  // after registration) so even a fire-and-forget spawn leaves the durable hook #831 reads to
+  // drive one-shot reap. Best-effort: an attribution write never fails the spawn.
+  if (input.taskId !== undefined) {
+    try {
+      recordTaskSpawnRequested(input.taskId, {
+        spawnRequestId,
+        provider: input.provider,
+        requestedBy,
+        ...(hydratedTask?.steer ? { steer: hydratedTask.steer } : {}),
+      });
+    } catch (err) {
+      console.warn(`task ${input.taskId} spawn attribution skipped: ${errMessage(err)}`);
+    }
+  }
+
   // #255 — resolve the spawned child's id once it registers back to THIS relay (same DB) with
   // meta.spawnRequestId set. Bounded poll; 0 opts out (pure fire-and-forget, e.g. the HTTP 202).
   const waitMs = Math.min(input.waitForRegistrationMs ?? 0, 30_000);
   const agentId = waitMs > 0 ? await waitForSpawnedAgent(spawnRequestId, waitMs) : null;
+
+  // #838 — once the child's id is known (waitForRegistrationMs > 0), stamp it as the Task owner
+  // via the #834 attribution API. Fire-and-forget spawns resolve the id later; #831 closes that
+  // gap by reading the spawn_requested event above. Best-effort, never fails the spawn.
+  if (input.taskId !== undefined && agentId) {
+    try {
+      assignTaskAgent(input.taskId, agentId, "worker", requestedBy);
+    } catch (err) {
+      console.warn(`task ${input.taskId} owner attribution skipped: ${errMessage(err)}`);
+    }
+  }
   return {
     ok: true,
     spawnRequestId,