agent-relay-server 0.121.0 → 0.121.1

package/src/self-resume.ts

@@ -1,6 +1,7 @@
 import { isRecord } from "agent-relay-sdk";
 import { createCommand, listCommands } from "./commands-db";
 import { emitCommandEvent } from "./command-events";
+import { MAX_BODY_BYTES, REAP_INTERVAL_MS } from "./config";
 import { getSelfResumeConfig } from "./config-store";
 import {
   archiveContinuationSegment,
@@ -14,7 +15,7 @@ import {
 import { emitRelayEvent } from "./events";
 import { routeNotification } from "./notification-router";
 import { renderTemplate } from "./prompt-resolver";
-import type { AgentCard, Command, ContinuationDecisionEntry, ContinuationEnvelope, ContinuationLedgerEntry, SelfResumeMode } from "./types";
+import type { AgentCard, Command, CommandStatus, ContinuationDecisionEntry, ContinuationEnvelope, ContinuationLedgerEntry, SelfResumeMode } from "./types";
 
 interface CompactAndResumeInput {
   agentId: string;
@@ -89,7 +90,8 @@ export function compactAndResume(input: CompactAndResumeInput): CompactAndResume
     spentTokens: typeof agent.context?.tokensUsed === "number" ? agent.context.tokensUsed : 0,
     now,
   });
-  const continuation = renderContinuation(updated);
+  if (updated.droppedLedgerEntries.length) archiveDroppedLedgerEntries(agent.id, generation, updated.droppedLedgerEntries, now);
+  const continuation = renderContinuation(updated.envelope);
   const command = mode === "native"
     ? createNativeCompact(agent.id, generation, continuation)
     : createClearThenInject(agent.id, generation, continuation);
@@ -100,18 +102,55 @@ export function compactAndResume(input: CompactAndResumeInput): CompactAndResume
     generation,
     commandId: command.id,
     continuationChars: continuation.length,
-    ledgerEntries: updated.ledger.length,
+    ledgerEntries: updated.envelope.ledger.length,
   };
 }
 
-export function enqueueContinuationInjectionAfterSelfResume(command: Command): Command | null {
-  if (command.status !== "succeeded") return null;
+// #1023 — the ruledOut ledger bound (see updateContinuationAfterCompact) drops the
+// oldest entries once the persisted ledger grows past its cap instead of letting a
+// long-running agent render a multi-megabyte continuation. Dropped entries are not
+// destroyed: they're archived alongside the workingState segments so relay_recall
+// still finds them. Chunked well under archiveContinuationSegment's MAX_BODY_BYTES
+// limit since a large drop batch could otherwise exceed a single segment's cap.
+const DROPPED_LEDGER_ARCHIVE_CHUNK_BYTES = MAX_BODY_BYTES / 2;
+
+function archiveDroppedLedgerEntries(agentId: string, generation: number, dropped: ContinuationLedgerEntry[], now: number): void {
+  let chunk: string[] = [];
+  let chunkBytes = 0;
+  const flush = () => {
+    if (!chunk.length) return;
+    archiveContinuationSegment({
+      agentId,
+      generation,
+      segment: `Ruled-out ledger entries dropped for size (search via relay_recall):\n${chunk.join("\n")}`,
+      now,
+    });
+    chunk = [];
+    chunkBytes = 0;
+  };
+  for (const entry of dropped) {
+    const line = renderLedgerLine(entry);
+    const lineBytes = new TextEncoder().encode(line).byteLength;
+    if (chunk.length && chunkBytes + lineBytes > DROPPED_LEDGER_ARCHIVE_CHUNK_BYTES) flush();
+    chunk.push(line);
+    chunkBytes += lineBytes;
+  }
+  flush();
+}
+
+interface PendingInjection {
+  continuation: string;
+  mode: string;
+  generation?: number;
+}
+
+function extractPendingInjection(command: Command): PendingInjection | null {
   const resume = isRecord(command.params.selfResume) ? command.params.selfResume : undefined;
   const mode = typeof resume?.mode === "string" ? resume.mode : undefined;
   const shouldInject =
     command.type === "agent.clearContext" && mode === "clear-inject"
     || command.type === "agent.compact" && mode === "native";
-  if (!shouldInject) return null;
+  if (!shouldInject || !mode) return null;
   const continuation = typeof resume?.continuation === "string"
     ? resume.continuation
     : typeof command.params.instructions === "string"
@@ -119,6 +158,26 @@ export function enqueueContinuationInjectionAfterSelfResume(command: Command): C
       : undefined;
   if (!continuation) return null;
   const generation = typeof resume?.generation === "number" ? resume.generation : undefined;
+  return { continuation, mode, generation };
+}
+
+function buildInjectionParams(command: Command, injection: PendingInjection): Record<string, unknown> {
+  return {
+    reason: "self-resume-continuation",
+    content: injection.continuation,
+    selfResume: {
+      generation: injection.generation,
+      mode: injection.mode,
+      ...(command.type === "agent.clearContext" ? { afterClearCommandId: command.id } : {}),
+      ...(command.type === "agent.compact" ? { afterCompactCommandId: command.id } : {}),
+    },
+  };
+}
+
+export function enqueueContinuationInjectionAfterSelfResume(command: Command): Command | null {
+  if (command.status !== "succeeded") return null;
+  const injection = extractPendingInjection(command);
+  if (!injection) return null;
   const existing = listCommands({ target: command.target, type: "agent.injectContext", limit: 500 })
     .find((item) => item.correlationId === command.id);
   if (existing) return null;
@@ -127,16 +186,7 @@ export function enqueueContinuationInjectionAfterSelfResume(command: Command): C
     source: "system",
     target: command.target,
     correlationId: command.id,
-    params: {
-      reason: "self-resume-continuation",
-      content: continuation,
-      selfResume: {
-        generation,
-        mode,
-        ...(command.type === "agent.clearContext" ? { afterClearCommandId: command.id } : {}),
-        ...(command.type === "agent.compact" ? { afterCompactCommandId: command.id } : {}),
-      },
-    },
+    params: buildInjectionParams(command, injection),
   });
   emitCommandEvent(inject, "command.requested");
   return inject;
@@ -146,19 +196,101 @@ export function enqueueContinuationInjectionAfterClear(command: Command): Comman
   return enqueueContinuationInjectionAfterSelfResume(command);
 }
 
+const CLEAR_OR_COMPACT_TYPES = ["agent.clearContext", "agent.compact"] as const;
+const INJECTION_SWEEP_TERMINAL_STATUSES: CommandStatus[] = ["succeeded", "timed_out"];
+const INJECTION_SWEEP_LOOKBACK_MS = 24 * 60 * 60 * 1000;
+const MAX_INJECTION_ATTEMPTS = 3;
+const IN_FLIGHT_OR_DONE_STATUSES: CommandStatus[] = ["succeeded", "pending", "accepted", "running"];
+
+// #1023 — periodic backstop for the three silent mind-wipe windows found in the
+// self-resume audit (relay message #176981):
+//   1. runner->relay `command.update` lost in transit, so the clear/compact command
+//      never reaches "succeeded" and just times out — the reactive inject in
+//      enqueueContinuationInjectionAfterSelfResume never fires.
+//   2. relay crash between persisting "succeeded" and creating the inject command.
+//   3. the inject command itself fails once (e.g. provider momentarily unavailable)
+//      with no retry.
+// This re-derives the missing inject directly from the durably persisted command
+// params — the same idempotency key (correlationId = the clear/compact command id)
+// used by the reactive path, so running this concurrently with it is safe. A
+// timed-out clear/compact is treated the same as succeeded: we cannot always tell
+// whether the runner's destructive step actually completed before the update was
+// lost, and a redundant-but-harmless re-injection is preferable to a permanent
+// silent mind-wipe. Retries are capped at MAX_INJECTION_ATTEMPTS; once exhausted the
+// parent is notified once instead of retrying forever against an unreachable agent.
+export function sweepMissedContinuationInjections(now: number = Date.now()): { enqueuedCommandIds: string[] } {
+  const enqueuedCommandIds: string[] = [];
+  const since = now - INJECTION_SWEEP_LOOKBACK_MS;
+  for (const type of CLEAR_OR_COMPACT_TYPES) {
+    for (const command of listCommands({ type, since, limit: 500 })) {
+      if (!INJECTION_SWEEP_TERMINAL_STATUSES.includes(command.status)) continue;
+      const injection = extractPendingInjection(command);
+      if (!injection) continue;
+      if (!getAgent(command.target)) continue;
+      const attempts = listCommands({ target: command.target, type: "agent.injectContext", limit: 500 })
+        .filter((item) => item.correlationId === command.id);
+      if (attempts.some((item) => IN_FLIGHT_OR_DONE_STATUSES.includes(item.status))) continue;
+      if (attempts.length >= MAX_INJECTION_ATTEMPTS) {
+        notifyContinuationInjectionExhausted(command, attempts.length);
+        continue;
+      }
+      const inject = createCommand({
+        type: "agent.injectContext",
+        source: "system",
+        target: command.target,
+        correlationId: command.id,
+        params: buildInjectionParams(command, injection),
+      });
+      emitCommandEvent(inject, "command.requested");
+      enqueuedCommandIds.push(inject.id);
+    }
+  }
+  return { enqueuedCommandIds };
+}
+
+export const SELF_RESUME_INJECTION_SWEEP_JOB = {
+  id: "self-resume-injection-sweep",
+  title: "Self-resume injection sweep",
+  description: "Re-deliver self-resume continuations whose inject was lost to a transport blip, a relay crash between persisting the clear/compact and enqueuing the inject, or a failed inject attempt (#1023).",
+  intervalMs: REAP_INTERVAL_MS,
+  runOnStart: true,
+  handler() {
+    return sweepMissedContinuationInjections();
+  },
+};
+
+function notifyContinuationInjectionExhausted(command: Command, attempts: number): void {
+  const idempotencyKey = `self-resume-injection-exhausted:${command.target}:${command.id}`;
+  if (findMessageByIdempotencyKey(command.target, idempotencyKey)) return;
+  const agent = getAgent(command.target);
+  const payload = { kind: "agent.resume_injection_failed", agentId: command.target, commandId: command.id, attempts };
+  emitRelayEvent({ type: "agent.resume_injection_failed", source: "server", subject: command.target, data: payload });
+  const recipient = agent?.spawnedBy ?? "user";
+  routeNotification({
+    type: "agent.resume_injection_failed",
+    scope: { agentId: command.target, parent: agent?.spawnedBy },
+    recipients: [recipient],
+    message: {
+      subject: "Self-resume continuation failed to inject",
+      body: `Agent \`${command.target}\` completed a self-resume ${command.type === "agent.compact" ? "compact" : "clear"} but its continuation could not be delivered after ${attempts} attempt(s). The agent may be running with an empty or stale context — check it and consider a manual relay_compact_and_resume or restart.`,
+      payload,
+      idempotencyKey,
+      from: command.target,
+      replyExpected: false,
+    },
+  });
+}
+
 export function renderContinuation(
   envelope: ContinuationEnvelope,
   input: { intro?: string } = {},
 ): string {
-  const ledger = envelope.ledger.length
-    ? envelope.ledger.map((entry) => `- gen ${entry.gen} @ ${new Date(entry.at).toISOString()}: ${entry.ruledOut}${entry.why ? `; why: ${entry.why}` : ""}`).join("\n")
-    : "- none";
   const decisions = envelope.decisions.length ? envelope.decisions.map(renderDecisionEntry).join("\n") : "- none";
   return renderTemplate("continuation.envelope", {
     intro: input.intro ?? `You have been resumed by Agent Relay — generation ${envelope.generation}.`,
     generation: String(envelope.generation),
     objective: envelope.objective,
-    ruledOut: ledger,
+    ruledOut: renderLedger(envelope.ledger),
     decisions,
     workingState: envelope.workingState,
     archiveRefs: envelope.archiveRefs.length ? envelope.archiveRefs.join("\n") : "- none",
@@ -170,6 +302,31 @@ function renderDecisionEntry(entry: ContinuationDecisionEntry): string {
   return `- gen ${entry.gen} @ ${new Date(entry.at).toISOString()}${by}: ${entry.decision}${entry.rationale ? `; rationale: ${entry.rationale}` : ""}`;
 }
 
+function renderLedgerLine(entry: ContinuationLedgerEntry): string {
+  return `- gen ${entry.gen} @ ${new Date(entry.at).toISOString()}: ${entry.ruledOut}${entry.why ? `; why: ${entry.why}` : ""}`;
+}
+
+// #1023 — render-time backstop on top of the persisted bound in
+// updateContinuationAfterCompact. Even if that bound is ever bypassed by a future
+// bug, this guarantees the ledger section injected into a fresh context can't blow
+// past a fixed size; it keeps the newest entries and notes what was omitted rather
+// than truncating mid-entry.
+const MAX_RENDERED_LEDGER_CHARS = 300_000;
+
+function renderLedger(entries: ContinuationLedgerEntry[]): string {
+  if (!entries.length) return "- none";
+  const lines = entries.map(renderLedgerLine);
+  let start = 0;
+  let totalChars = lines.reduce((sum, line) => sum + line.length + 1, 0);
+  while (totalChars > MAX_RENDERED_LEDGER_CHARS && start < lines.length - 1) {
+    totalChars -= lines[start]!.length + 1;
+    start += 1;
+  }
+  if (start === 0) return lines.join("\n");
+  const omitted = start;
+  return `- (${omitted} older ruled-out ${omitted === 1 ? "entry" : "entries"} omitted for size — see relay_recall for the archived history)\n${lines.slice(start).join("\n")}`;
+}
+
 function assertResumeSupported(agent: AgentCard, mode: SelfResumeMode): void {
   const context = agent.providerCapabilities?.context;
   const resume = context?.resume ?? (context?.clear && context?.inject ? "clear-inject" : "none");
@@ -320,7 +477,7 @@ function notifySelfResumeBudgetWarning(agent: AgentCard, envelope: ContinuationE
 function parseRuledOut(value: unknown, generation: number, now: number): ContinuationLedgerEntry[] {
   if (value === undefined || value === null) return [];
   if (!Array.isArray(value)) throw new ValidationError("ruledOut must be an array");
-  return value.map((item, index) => {
+  const entries = value.map((item, index) => {
     if (typeof item === "string") return ledgerEntry(item, "", generation, now);
     if (!isRecord(item)) throw new ValidationError(`ruledOut[${index}] must be a string or object`);
     const ruledOut = typeof item.ruledOut === "string" ? item.ruledOut.trim() : "";
@@ -328,6 +485,13 @@ function parseRuledOut(value: unknown, generation: number, now: number): Continu
     if (!ruledOut) throw new ValidationError(`ruledOut[${index}].ruledOut required`);
     return ledgerEntry(ruledOut, why, generation, now);
   });
+  // #1023 — ruledOut had no size limit at all (unlike the sibling workingState/objective
+  // fields, both capped at/near MAX_BODY_BYTES): a single legal call could inject a
+  // multi-megabyte continuation straight into the fresh context it was meant to fit
+  // inside. Bound total new content per call to the same ceiling as workingState.
+  const totalBytes = entries.reduce((sum, entry) => sum + new TextEncoder().encode(entry.ruledOut).byteLength + new TextEncoder().encode(entry.why).byteLength, 0);
+  if (totalBytes > MAX_BODY_BYTES) throw new ValidationError(`ruledOut exceeds ${MAX_BODY_BYTES} bytes for a single call — split it across multiple relay_compact_and_resume calls`);
+  return entries;
 }
 
 function ledgerEntry(ruledOut: string, why: string, generation: number, now: number): ContinuationLedgerEntry {

package/src/server.ts

@@ -16,6 +16,7 @@ import { startRelayScheduler } from "./services/scheduler";
 import { startEventLoopLagSampler } from "./event-loop-lag";
 import { recordWorkspaceIssueActivity } from "./services/spawn-issue-activity";
 import { onWorkspaceCreate } from "./db";
+import { warnIfNoHumanReachableEscalationTarget } from "./workspace-human-escalation";
 import { isTerminalSessionRequestAuthorized } from "./terminal-authz";
 import { resolve, sep } from "path";
 import { gzipSync, brotliCompressSync, constants as zlibConstants } from "node:zlib";
@@ -81,6 +82,7 @@ export function startServer(): void {
   getCompactionWatch().start();
   reconcileRelayVersion();
   startConnectorStatusPoller();
+  warnIfNoHumanReachableEscalationTarget();
   startEventLoopLagSampler();
   startMaintenanceScheduler();
   startRelayScheduler();

package/src/services/plan-graph.ts

@@ -1,10 +1,11 @@
 import { isRecord } from "agent-relay-sdk";
-import { addTaskDependency, createPlanRow, deletePlan, getAgent, getEntry, getPlan, getPlanByTeam, getPlanByThread, getTaskDetail, listPlansWithBoundOwner, planThreadExists, removeTaskDependency, replacePlan, setPlanArchived, ValidationError } from "../db";
+import { addTaskDependency, createPlanRow, deletePlan, getAgent, getEntry, getPlan, getPlanByTeam, getPlanByThread, getTaskDetail, listPlansWithBoundOwner, planThreadExists, removeTaskDependency, replacePlan, sendMessage, setPlanArchived, 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 { issueRepoForAgent } from "../agent-issue-repo";
 import { buildTaskGraphView, parseTaskId, planStatusToTaskStatus, projectPlanOverTasks } from "./task-plan-view";
 import { createTaskEntity, setTaskEntityStatus } from "./task-entity";
 import type { AuthContext } from "./auth-context";
@@ -75,14 +76,25 @@ function cleanOwnerRef(value: unknown): PlanOwnerRef | undefined {
   return Object.keys(out).length ? out : undefined;
 }
 
-function cleanRefs(value: unknown): PlanNode["refs"] | undefined {
+// #220: a bare `#NNN` issueId ref needs a default repo to resolve against — issue-refs.ts
+// throws without one, contrary to its own error text advertising the bare form as accepted.
+// Resolve it the same way #533 resolves chat `#NNN` linkify: the CALLING agent's own project
+// (cwd → project → issueRepo), falling back to the single global env default. This scopes the
+// default to the actor's actual repo rather than guessing from teamId — agents have no
+// team→project FK; cwd is the only durable link (see agent-issue-repo.ts).
+function resolveDefaultIssueRepo(actor: string): string | undefined {
+  const agent = getAgent(actor);
+  return (agent ? issueRepoForAgent(agent) : undefined) ?? defaultIssueRepo();
+}
+
+function cleanRefs(value: unknown, actor: string): PlanNode["refs"] | undefined {
   if (value === undefined || value === null) return undefined;
   const ref = cleanRecordRef(value, "refs");
   if (!ref) return undefined;
   const out: PlanNode["refs"] = {};
   const issueId = cleanString(ref.issueId, "refs.issueId", { max: 1000 });
   if (issueId) {
-    out.issueId = resolveIssueRefFromString({ ref: issueId, defaultRepo: defaultIssueRepo() }).id;
+    out.issueId = resolveIssueRefFromString({ ref: issueId, defaultRepo: resolveDefaultIssueRepo(actor) }).id;
   }
   // #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
@@ -147,12 +159,12 @@ function applyBoundStatus(node: PlanNode): PlanNode {
   return { ...node, status: boundStatusForAgent(getAgent(agentId)) ?? "pending" };
 }
 
-function cleanNode(input: PlanNodeInput, planTeamId?: string): PlanNode {
+function cleanNode(input: PlanNodeInput, actor: string, planTeamId?: string): PlanNode {
   if (!isRecord(input)) throw new ValidationError("node must be an object");
   const scopeBlurb = cleanString(input.scopeBlurb, "node.scopeBlurb", { max: 2000 });
   const ownerRef = cleanOwnerRef(input.ownerRef);
   const lane = cleanString(input.lane, "node.lane", { max: 120 });
-  const refs = cleanRefs(input.refs);
+  const refs = cleanRefs(input.refs, actor);
   const blackboardRefs = cleanBlackboardRefs(input.blackboardRefs, planTeamId);
   const statusSource = cleanStatusSource(input.statusSource);
   return applyBoundStatus({
@@ -168,10 +180,10 @@ function cleanNode(input: PlanNodeInput, planTeamId?: string): PlanNode {
   });
 }
 
-function cleanNodes(value: unknown, planTeamId?: string): PlanNode[] {
+function cleanNodes(value: unknown, actor: string, planTeamId?: string): PlanNode[] {
   if (value === undefined || value === null) return [];
   if (!Array.isArray(value)) throw new ValidationError("nodes must be an array");
-  const nodes = value.map((item) => cleanNode(item as PlanNodeInput, planTeamId));
+  const nodes = value.map((item) => cleanNode(item as PlanNodeInput, actor, planTeamId));
   assertUnique(nodes.map((node) => node.id), "node id");
   return nodes;
 }
@@ -252,14 +264,32 @@ function emitPlan(type: "plan.created" | "plan.changed" | "plan.deleted", plan:
   emitRelayEvent({ type, source: actor, subject: plan.id, data: { plan, actor } });
 }
 
+// #1035: a plan anchors to a messages.thread_id, but a fresh coordinator has no thread yet —
+// forcing it to send a throwaway message just to mint one. When no threadId is supplied, mint the
+// thread server-side by self-threading a lightweight system message (the same sendMessage path the
+// caller would have used). Sent AS the actor when that agent is registered, else the reserved
+// `system` sink, so the mint always passes the sender-registration gate.
+function mintPlanThread(actor: string, channel: string | undefined): number {
+  const sender = getAgent(actor) ? actor : "system";
+  const root = sendMessage({
+    from: sender,
+    to: "system",
+    body: "Plan thread root",
+    ...(channel ? { channel } : {}),
+  });
+  return root.threadId ?? root.id;
+}
+
 export function createPlan(input: PlanCreateInput, ctx: AuthContext): Plan {
-  const threadId = cleanThreadId(input.threadId);
-  if (!planThreadExists(threadId)) throw new ValidationError(`thread ${threadId} not found`);
   const channel = cleanString(input.channel, "channel", { max: 120 });
   const actor = actorId(ctx);
+  const threadId = input.threadId === undefined || input.threadId === null
+    ? mintPlanThread(actor, channel)
+    : cleanThreadId(input.threadId);
+  if (!planThreadExists(threadId)) throw new ValidationError(`thread ${threadId} not found`);
   const explicitTeamId = cleanString(input.teamId, "teamId", { max: 120 });
   const teamId = explicitTeamId ?? (input.teamId === undefined || input.teamId === null ? getAgent(actor)?.teamId : undefined);
-  const nodes = cleanNodes(input.nodes, teamId);
+  const nodes = cleanNodes(input.nodes, actor, teamId);
   const edges = cleanEdges(input.edges);
   validateEdges(nodes, edges);
   const plan = createPlanRow({
@@ -279,7 +309,7 @@ export function createPlan(input: PlanCreateInput, ctx: AuthContext): Plan {
 
 export function addPlanNode(planId: string, nodeInput: PlanNodeInput, ctx: AuthContext): Plan {
   const plan = existingPlan(planId);
-  const node = cleanNode(nodeInput, plan.teamId);
+  const node = cleanNode(nodeInput, actorId(ctx), plan.teamId);
   if (plan.nodes.some((item) => item.id === node.id)) throw new ValidationError(`node ${node.id} already exists`);
   const updated = replacePlan({ ...plan, nodes: [...plan.nodes, node] }, actorId(ctx));
   syncPlanNodeIssueAssociation(updated.id, node);
@@ -299,7 +329,7 @@ export function updatePlanNode(planId: string, nodeId: string, patch: PlanNodePa
     ...(patch.ownerRef !== undefined ? optionalProp("ownerRef", cleanOwnerRef(patch.ownerRef)) : {}),
     ...(patch.lane !== undefined ? optionalProp("lane", cleanString(patch.lane, "lane", { max: 120 })) : {}),
     ...(patch.status !== undefined ? { status: optionalEnum(patch.status, "status", PLAN_STATUSES) as PlanStatus } : {}),
-    ...(patch.refs !== undefined ? optionalProp("refs", cleanRefs(patch.refs)) : {}),
+    ...(patch.refs !== undefined ? optionalProp("refs", cleanRefs(patch.refs, actorId(ctx))) : {}),
     ...(patch.blackboardRefs !== undefined ? optionalProp("blackboardRefs", cleanBlackboardRefs(patch.blackboardRefs, plan.teamId)) : {}),
     statusSource,
   };

package/src/services/register-agent.ts

@@ -10,7 +10,7 @@
 // status broadcast, the single timeline note, the spawned-child parent-wake, and
 // the first-registration audit row.
 import { errMessage, isReservedAgentId } from "agent-relay-sdk";
-import { ValidationError, createActivityEvent, deliverableTaskIdsBySpawnRequestId, getAgent, getTaskDetail, seedSpawnPromptMirror, seedSpawnReplyObligation, upsertAgent } from "../db";
+import { ValidationError, createActivityEvent, deliverableTaskIdsBySpawnRequestId, getAgent, getTaskDetail, mergeAgentMeta, readSpawnReportVerbosity, seedSpawnPromptMirror, seedSpawnReplyObligation, upsertAgent } from "../db";
 import { emitAgentStatus, emitNewMessage } from "../sse";
 import { noteAgentTimelineEvent } from "../compaction-watch";
 import { agentProviderTimelineEvent } from "../provider-timeline-event";
@@ -128,6 +128,10 @@ export function registerAgent(input: RegisterAgentInput, ctx: AuthContext): Agen
     // spawner so it can't idle with its verdict undelivered (vent #121). First-registration only.
     const spawnRequestId = metaStr(agent.meta, "spawnRequestId");
     const provider = metaStr(agent.meta, "provider");
+    // #1037 — stamp the spawner-chosen report-up verbosity onto the child's meta from the persisted
+    // spawn command, so the lineage report-up delivery gate can read it (defaults to quiet if absent).
+    const reportVerbosity = readSpawnReportVerbosity(spawnRequestId);
+    if (reportVerbosity) mergeAgentMeta(agent.id, { reportVerbosity });
     const promptMirror = seedSpawnPromptMirror(agent.id, spawnRequestId);
     if (promptMirror?.created || promptMirror?.updated) emitNewMessage(promptMirror.message);
     seedSpawnReplyObligation(agent.id, agent.spawnedBy, spawnRequestId);

package/src/services/send-message.ts

@@ -24,9 +24,11 @@
 import { canonicalHumanAgentId, isHumanAgentId, isMechanicalMessageKind, isRecord, isReservedAgentId } from "agent-relay-sdk";
 import {
   ValidationError,
+  flushDeferredLineageReport,
   getAgent,
   getMessage,
   listAgents,
+  listRecentFinalResponseCaptures,
   promoteLineageCapturedResponse,
   sendMessagesBatchWithResult,
   sendMessageWithResult,
@@ -225,6 +227,40 @@ function prepareSendMessage(input: SendMessageInput, ctx: AuthContext, opts: Sen
   return { receipt, suppressedParent: suppressResultsOnlyAck(input) };
 }
 
+/**
+ * #1037 — the child transitioned out of busy (idle/awaiting-input). Deliver its deferred turn-final
+ * report-up (a quiet child's last turn, held back so mid-work narration never reached the spawner)
+ * and fan it out over SSE. No-op when nothing was deferred. Driven off the bus turn-end edge.
+ */
+export function flushIdleLineageReport(childId: string): void {
+  const promoted = flushDeferredLineageReport(childId);
+  if (promoted?.created) emitNewMessages([promoted.message]);
+}
+
+/** How far back the startup sweep re-scans for held-but-lost turn-final captures (#1040). A report
+ * is only ever deferred while its child is mid-turn, so any capture lost across a restart is recent;
+ * a day is a generous ceiling that still bounds the scan. */
+const LINEAGE_STARTUP_SWEEP_WINDOW_MS = 24 * 60 * 60 * 1000;
+
+/**
+ * #1040 — startup re-promotion sweep. `deferredLineageReports` is an in-memory Map, so a relay
+ * restart drops every held turn-final report-up. The captures are persisted, though, so re-run
+ * promotion for recent final response captures: an idle child whose report was lost gets it
+ * delivered now, an already-delivered one is a no-op (idempotency key), and a still-busy child
+ * re-defers (re-arming the in-memory hold so a later idle edge flushes it). Idempotent and safe to
+ * run periodically.
+ */
+export function sweepDeferredLineageReportsOnStartup(now: number = Date.now()): { promoted: number; scanned: number } {
+  const captures = listRecentFinalResponseCaptures(now - LINEAGE_STARTUP_SWEEP_WINDOW_MS);
+  const emitted: Message[] = [];
+  for (const capture of captures) {
+    const promoted = promoteLineageCapturedResponse(capture);
+    if (promoted?.created) emitted.push(promoted.message);
+  }
+  if (emitted.length > 0) emitNewMessages(emitted);
+  return { promoted: emitted.length, scanned: captures.length };
+}
+
 function emitSendResults(results: DbSendMessageResult[]): void {
   const liveMessages: Message[] = [];
   for (const result of results) {

package/src/services/spawn-agent.ts

@@ -23,7 +23,7 @@
 // shared `buildSpawnCommand`/`buildManagedSpawnParams` payload home directly. Folding
 // them through `spawnAgent(systemCtx)` is a clean belt-and-suspenders follow-up (#342),
 // deliberately out of scope here — this slice converges the two external TRANSPORTS.
-import type { SpawnProvider } from "agent-relay-sdk";
+import type { ReportVerbosity, SpawnProvider } from "agent-relay-sdk";
 import { DEFAULT_USER_ID, errMessage, isRecord, stringValue } from "agent-relay-sdk";
 import { statSync } from "node:fs";
 import { dirname, resolve } from "node:path";
@@ -211,6 +211,12 @@ export interface SpawnAgentInput {
    * Explicit true is preserved in the command payload for compatibility only.
    */
   expectReply?: boolean;
+  /**
+   * #1037 — per-spawn report-up verbosity (`quiet` default | `normal` | `verbose`). Persisted in
+   * the spawn command params and stamped onto the child's meta at registration, where the lineage
+   * report-up delivery gate reads it. Absent = `quiet`.
+   */
+  reportVerbosity?: ReportVerbosity;
   tags?: string[];
   capabilities?: string[];
   providerArgs?: string[];
@@ -249,6 +255,8 @@ export interface SpawnAgentResult {
   agentId: string | null;
   registered: boolean;
   command: Command;
+  /** #1033 — the durable Task this spawn is bound to (explicit taskId or auto-scaffolded), when any. */
+  taskId?: number;
   task?: { id: number; autoScaffolded: boolean; nudge: string };
 }
 
@@ -332,7 +340,16 @@ export async function spawnAgent(input: SpawnAgentInput, ctx: AuthContext): Prom
 
   // #255/#328 — bias the host to the caller's own machine when neither an explicit
   // orchestratorId nor a cwd pins it, so an agent spawning a helper lands on its own host.
-  const orchestrator = selectSpawnOrchestrator(input.provider, input.orchestratorId, requestedCwd, caller?.machine ?? lineageAgent?.machine);
+  // #1034 — pass the token's orchestrator allow-set so host selection can NEVER land on a host
+  // the caller isn't authorized for (which would then trip assertResourceAllowed with a
+  // misleading `-32001 component token cannot access this resource` — the concurrent-spawn flap).
+  const orchestrator = selectSpawnOrchestrator(
+    input.provider,
+    input.orchestratorId,
+    requestedCwd,
+    caller?.machine ?? lineageAgent?.machine,
+    ctx.constraints?.orchestrators,
+  );
 
   // #308 §3 — an explicit cwd must resolve within the TARGET host's base dir (a path valid on
   // your host may not exist on a different orchestrator).
@@ -638,6 +655,7 @@ export async function spawnAgent(input: SpawnAgentInput, ctx: AuthContext): Prom
       resumeWorkspace: input.resumeWorkspace,
       acquisition,
       ...(expectReply ? { expectReply } : {}),
+      ...(input.reportVerbosity ? { reportVerbosity: input.reportVerbosity } : {}),
       policyName: input.policyName,
       spawnRequestId,
       env,
@@ -727,6 +745,7 @@ export async function spawnAgent(input: SpawnAgentInput, ctx: AuthContext): Prom
     agentId,
     registered: agentId !== null,
     command,
+    ...(input.taskId !== undefined ? { taskId: input.taskId } : {}),
     ...(autoScaffoldedTask ? { task: autoScaffoldedTask } : {}),
   };
 }

package/src/services/task-semantic-events.ts

@@ -1,6 +1,7 @@
 import { getAgent } from "../db";
 import { addSubscription } from "../db/notification-subscriptions";
 import { emitRelayEvent } from "../events";
+import { hasRecentLifecycleSignal, taskSignalKey } from "../lifecycle-signal-registry";
 import { notifySystemMessage } from "../notify";
 import type { NotificationScope, NotificationType } from "../notification-types";
 import { routeNotification } from "../notification-router";
@@ -216,7 +217,18 @@ function dedupeRecipients(recipients: Array<{ agentId: string; matchedRule: stri
   return out;
 }
 
+// #1032b — a status pulse is redundant when a first-class lifecycle event (agent.ready, the lineage
+// report-up, branch.landed/merge) already conveyed this task's state to this recipient. Suppress it
+// rather than waking the spawner a second time for the same fact.
+// #1038 — keyed by the pulse's own transition: a progress signal (report-up / ready) supersedes only
+// a redundant `working` pulse, never a later DISTINCT-state transition (committed / landed / done)
+// for the same task within the TTL.
+function pulseSupersededByLifecycle(agentId: string, taskId: number, transition: TaskSemanticTransition): boolean {
+  return hasRecentLifecycleSignal(agentId, taskSignalKey(taskId, transition));
+}
+
 function enqueueStatusPulse(agentId: string, item: StatusPulseDigestItem): void {
+  if (pulseSupersededByLifecycle(agentId, item.taskId, item.transition)) return; // #1032b/#1038
   const batch = statusPulseBatches.get(agentId) ?? { items: [] };
   batch.items.push(item);
   if (!batch.timer) {
@@ -233,7 +245,11 @@ export function flushTaskStatusPulses(agentId?: string): void {
     if (batch.timer) clearTimeout(batch.timer);
     statusPulseBatches.delete(target);
     if (batch.items.length === 0) continue;
-    const items = compactStatusPulseItems(batch.items);
+    // #1032b — a lifecycle event that fired AFTER these items were queued (but within the batch
+    // window) also supersedes them; drop those before flushing so the digest carries only news.
+    const fresh = batch.items.filter((item) => !pulseSupersededByLifecycle(target, item.taskId, item.transition));
+    if (fresh.length === 0) continue;
+    const items = compactStatusPulseItems(fresh);
     notifySystemMessage(target, {
       subject: `Task status pulse (${items.length})`,
       body: taskStatusPulseBody(items),

package/src/spawn-command.ts

@@ -109,6 +109,8 @@ interface BuildSpawnCommandOptions {
    * registration from the persisted spawn command params.
    */
   expectReply?: boolean;
+  /** #1037 — per-spawn report-up verbosity, persisted so registration can stamp it onto child meta. */
+  reportVerbosity?: string;
   profile?: string;
   agentProfile?: unknown;
   headless?: boolean;
@@ -174,6 +176,7 @@ export function buildSpawnCommand(opts: BuildSpawnCommandOptions): Record<string
     ...def(opts.reviewer, "reviewer"),
     ...def(opts.taskId, "taskId"),
     ...def(opts.expectReply, "expectReply"),
+    ...def(opts.reportVerbosity, "reportVerbosity"),
     ...def(opts.headless, "headless"),
     ...def(opts.policyName, "policyName"),
     ...def(opts.automationId, "automationId"),