agent-relay-server 0.127.1 → 0.127.3

package/docs/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Agent Relay API",
-    "version": "0.127.1",
+    "version": "0.127.3",
     "description": "Real-time message bus for inter-agent communication. Agent-first: this spec is designed for machine consumption — agents can self-discover the full API surface via GET /api/spec.",
     "license": {
       "name": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-server",
-  "version": "0.127.1",
+  "version": "0.127.3",
   "description": "Lightweight HTTP message relay for inter-agent communication across machines",
   "module": "src/index.ts",
   "type": "module",
@@ -37,7 +37,7 @@
     "CONTRIBUTING.md"
   ],
   "dependencies": {
-    "agent-relay-channels-host": "0.127.1",
+    "agent-relay-channels-host": "0.127.3",
     "agent-relay-providers": "0.104.4",
     "agent-relay-sdk": "0.2.118",
     "ajv": "^8.20.0"
@@ -54,9 +54,11 @@
     "build:dashboard": "bun run build:dashboard:bundle && bun run deploy:dashboard",
     "build:dashboard:bundle": "bun run build:sdk && cd dashboard && bun run build",
     "deploy:dashboard": "bun run scripts/deploy-dashboard.ts",
-    "ci:land": "bun run build:dashboard:bundle && bun run build:claude-monitor:check && bun run lint:import-boundaries && bun run lint:provider-contract && bun run typecheck && bun run docs:api:check && bun run test",
+    "ci:land": "bun run build:dashboard:bundle && bun run build:claude-monitor:check && bun run lint:import-boundaries && bun run lint:provider-contract && bun run typecheck && bun run docs:api:check && bun test",
+    "ci:release": "bun run build:dashboard:bundle && bun run build:claude-monitor:check && bun run lint:import-boundaries && bun run lint:provider-contract && bun run typecheck && bun run docs:api:check && bun test --bail",
     "ci": "bun run ci:land",
-    "test": "bun test",
+    "test": "bun run test:guards && bun test --bail",
+    "test:guards": "bun test --bail=1 src/file-size-ratchet.test.ts src/duplication-ratchet.test.ts src/env-access-ratchet.test.ts src/no-raw-control-bytes.test.ts src/transport-thinness-ratchet.test.ts src/commands-db-ttl-guard.test.ts scripts/release-deploy-guard.test.ts scripts/release-tree-guard.test.ts",
     "smoke:spawn": "bun run scripts/orchestrator-spawn-smoke.ts",
     "publish:smoke": "bun run scripts/publish-smoke.ts",
     "lint:provider-contract": "bun run scripts/check-provider-contract.ts",

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.127.1",
+  "version": "0.127.3",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/runner/plugins/claude/monitors/relay-monitor.provisioned.mjs

@@ -320,6 +320,9 @@ function shouldShowReplyReminder(deliveryCount) {
 function latestReplyableMessage(messages) {
   return messages.filter((message) => isPersistedRelayMessage2(message) && !isMemoryInjection(message) && !isReactionNotification(message) && !isSpawnObligationMessage(message) && message.replyExpected !== false).at(-1);
 }
+function isSelfResumeInjection(message) {
+  return isRecord(message.payload) && message.payload.resumeInjection === true;
+}
 function formatMessage(message, relaySurface) {
   const subject = message.subject ? `Subject: ${message.subject}
 ` : "";
@@ -331,7 +334,7 @@ function formatMessage(message, relaySurface) {
 `) : undefined;
   if (isMemoryContext) {
     return [
-      `[agent-relay context from ${message.from}]`,
+      `[agent-relay ${isSelfResumeInjection(message) ? "self-resume continuation" : "context"} from ${message.from}]`,
       providerAttachmentText(message),
       `${subject}${preview.body}`,
       truncationGuidance

package/runner/src/adapter.ts

@@ -327,6 +327,10 @@ function isMemoryInjection(message: Message): boolean {
   return isRecord(message.payload) && message.payload.memoryInjection === true;
 }
 
+function isSelfResumeInjection(message: Message): boolean {
+  return isRecord(message.payload) && message.payload.resumeInjection === true;
+}
+
 function isReactionNotification(message: Message): boolean {
   const event = isRecord(message.payload?.event) ? message.payload.event : undefined;
   return message.payload?.reactionNotification === true || event?.type === "message.reaction";
@@ -434,7 +438,7 @@ export function providerMessageText(messages: Message[]): string {
         : undefined;
       if (isMemoryContext) {
         return [
-          `[agent-relay context from ${message.from}]`,
+          `[agent-relay ${isSelfResumeInjection(message) ? "self-resume continuation" : "context"} from ${message.from}]`,
           "Guide: agent-relay /guide",
           providerAttachmentText(message),
           `${subject}${preview.body}`,

package/runner/src/adapters/claude-delivery.ts

@@ -69,6 +69,10 @@ function latestReplyableMessage(messages: Message[]): Message | undefined {
     .at(-1);
 }
 
+function isSelfResumeInjection(message: Message): boolean {
+  return isRecord(message.payload) && message.payload.resumeInjection === true;
+}
+
 function formatMessage(message: Message, relaySurface: boolean): string {
   const subject = message.subject ? `Subject: ${message.subject}\n` : "";
   const isMemoryContext = isMemoryInjection(message);
@@ -81,7 +85,7 @@ function formatMessage(message: Message, relaySurface: boolean): string {
 
   if (isMemoryContext) {
     return [
-      `[agent-relay context from ${message.from}]`,
+      `[agent-relay ${isSelfResumeInjection(message) ? "self-resume continuation" : "context"} from ${message.from}]`,
       providerAttachmentText(message),
       `${subject}${preview.body}`,
       truncationGuidance,

package/runner/src/mcp-outbox.ts

@@ -67,7 +67,12 @@ export async function deliverRunnerOutboxEvent(input: RunnerOutboxDelivery): Pro
     }
     logger.warn("outbox", `dropping event with unknown kind: ${record.kind}`);
   } catch (error) {
-    if (isHttpStatusError(error, 409)) return;
+    if (isHttpStatusError(error, 409)) {
+      if (record.kind === "session-message-batch") {
+        logger.error("outbox", `relay reported duplicate session batch; acking row seq=${record.seq} batchKey=${record.idempotencyKey} itemKeys=${sessionBatchItemKeys(record).join(",")} error=${errMessage(error)}`);
+      }
+      return;
+    }
     if (isHttpAuthError(error)) input.recoverRuntimeTokenAfterAuthFailure("outbox");
     throw error;
   }
@@ -89,6 +94,13 @@ function isDeterministicValidationError(error: unknown): boolean {
   return status === 400 || status === 413 || status === 422;
 }
 
+function sessionBatchItemKeys(record: OutboxRecord): string[] {
+  const messages = Array.isArray((record.payload as { messages?: unknown }).messages)
+    ? (record.payload as { messages: SendMessageInput[] }).messages
+    : [];
+  return messages.map((message, index) => message.idempotencyKey ?? `${record.idempotencyKey}:${index}`);
+}
+
 export async function deliverBufferedMcpCall(input: {
   record: OutboxRecord;
   relayUrl: string;

package/runner/src/runner-core.ts

@@ -842,17 +842,24 @@ export class AgentRunner {
     const content = typeof params.content === "string" ? params.content.trim() : "";
     if (!content) throw new Error("content required");
     const memoryIds = Array.isArray(params.memoryIds) ? params.memoryIds.filter((id): id is string => typeof id === "string") : [];
+    const reason = typeof params.reason === "string" ? params.reason : undefined;
+    const selfResume = params.selfResume !== null && typeof params.selfResume === "object" && !Array.isArray(params.selfResume)
+      ? params.selfResume as Record<string, unknown>
+      : undefined;
+    const isSelfResumeContinuation = reason === "self-resume-continuation" || Boolean(selfResume);
     await this.options.adapter.deliver(this.process!, [{
       id: 0,
       from: "system",
       to: this.agentId,
       kind: "system",
-      subject: "Agent Relay memory context",
+      subject: isSelfResumeContinuation ? "Agent Relay self-resume continuation" : "Agent Relay memory context",
       body: content,
       payload: {
         memoryInjection: true,
-        reason: typeof params.reason === "string" ? params.reason : undefined,
+        reason,
         memoryIds,
+        ...(isSelfResumeContinuation ? { resumeInjection: true } : {}),
+        ...(selfResume ? { selfResume } : {}),
       },
       readBy: [],
       createdAt: Date.now(),
@@ -1598,7 +1605,7 @@ export class AgentRunner {
       });
       this.sessionOutbox.enqueue({
         kind: "session-message-batch",
-        idempotencyKey: `session-batch:${this.agentId}:${++this.sessionBatchSeq}:${messages.length}`,
+        idempotencyKey: `session-batch:${this.agentId}:${this.options.instanceId}:${this.options.startedAt}:${++this.sessionBatchSeq}:${messages.length}`,
         payload: { messages },
       });
     }

package/scripts/orchestrator-spawn-smoke.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env bun
 import { spawnSync } from "node:child_process";
 import { hostname } from "node:os";
+import { basename, isAbsolute, join, relative, resolve } from "node:path";
 import { RELAY_TOKEN_HEADER } from "agent-relay-sdk";
 
 type Orchestrator = {
@@ -33,14 +34,16 @@ 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);
 
-for (let i = 0; i < args.length; i++) {
-  const arg = args[i]!;
-  if (arg === "--relay-url" && args[i + 1]) relayUrl = args[++i]!;
-  else if (arg === "--orchestrator" && args[i + 1]) orchestratorId = args[++i]!;
-  else if (arg === "--cwd" && args[i + 1]) cwd = args[++i]!;
-  else if (arg === "--timeout" && args[i + 1]) timeoutMs = Number(args[++i]);
-  else if (arg === "--providers" && args[i + 1]) providers = args[++i]!.split(",").map((p) => p.trim()).filter(Boolean);
-  else throw new Error(`Unknown option: ${arg}`);
+function parseArgs(): void {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]!;
+    if (arg === "--relay-url" && args[i + 1]) relayUrl = args[++i]!;
+    else if (arg === "--orchestrator" && args[i + 1]) orchestratorId = args[++i]!;
+    else if (arg === "--cwd" && args[i + 1]) cwd = args[++i]!;
+    else if (arg === "--timeout" && args[i + 1]) timeoutMs = Number(args[++i]);
+    else if (arg === "--providers" && args[i + 1]) providers = args[++i]!.split(",").map((p) => p.trim()).filter(Boolean);
+    else throw new Error(`Unknown option: ${arg}`);
+  }
 }
 
 relayUrl = relayUrl.replace(/\/+$/, "");
@@ -92,6 +95,68 @@ function localRepoRoot(): string | null {
   return result.stdout.trim() || null;
 }
 
+function localRepoName(): string | null {
+  const result = spawnSync("git", ["config", "--get", "remote.origin.url"], {
+    cwd: process.cwd(),
+    encoding: "utf8",
+  });
+  if (result.status !== 0) return null;
+  const remote = result.stdout.trim();
+  if (!remote) return null;
+  const name = basename(remote.replace(/\.git$/, ""));
+  return name || null;
+}
+
+function pathContainedBy(path: string, parent: string): boolean {
+  const rel = relative(resolve(parent), resolve(path));
+  return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+
+function isGitRepo(path: string): boolean {
+  const result = spawnSync("git", ["rev-parse", "--show-toplevel"], {
+    cwd: path,
+    encoding: "utf8",
+  });
+  return result.status === 0;
+}
+
+export function resolveDefaultSpawnCwd(
+  orchestrator: Pick<Orchestrator, "id" | "baseDir">,
+  deps: {
+    hostname?: () => string;
+    localRepoRoot?: () => string | null;
+    localRepoName?: () => string | null;
+    isGitRepo?: (path: string) => boolean;
+  } = {},
+): string {
+  const host = deps.hostname ?? hostname;
+  if (orchestrator.id !== host()) {
+    throw new Error(`orchestrator ${orchestrator.id} is remote; pass --cwd or set AGENT_RELAY_SMOKE_CWD to a git repo on that host`);
+  }
+  if (!orchestrator.baseDir) {
+    throw new Error(`orchestrator ${orchestrator.id} did not report a baseDir; pass --cwd or set AGENT_RELAY_SMOKE_CWD`);
+  }
+
+  const gitRoot = (deps.localRepoRoot ?? localRepoRoot)();
+  if (gitRoot && pathContainedBy(gitRoot, orchestrator.baseDir)) return gitRoot;
+
+  const repoName = (deps.localRepoName ?? localRepoName)();
+  const gitCheck = deps.isGitRepo ?? isGitRepo;
+  const candidates = [
+    repoName ? join(orchestrator.baseDir, "oss", repoName) : "",
+    repoName ? join(orchestrator.baseDir, repoName) : "",
+    orchestrator.baseDir,
+  ].filter(Boolean);
+  for (const candidate of candidates) {
+    if (pathContainedBy(candidate, orchestrator.baseDir) && gitCheck(candidate)) return candidate;
+  }
+
+  throw new Error(
+    `could not resolve a git repo inside orchestrator ${orchestrator.id} base dir ${orchestrator.baseDir}; ` +
+    "pass --cwd or set AGENT_RELAY_SMOKE_CWD",
+  );
+}
+
 function findSpawnedAgent(agents: Agent[], provider: string, label: string, startedAt: number): Agent | null {
   return agents
     .filter((agent) => agent.ready && agent.status !== "offline")
@@ -127,6 +192,8 @@ function promptForCase(provider: string, approvalMode: ApprovalMode, label: stri
   };
 }
 
+async function main(): Promise<void> {
+parseArgs();
 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
@@ -146,13 +213,7 @@ if (orchestrator.status !== "online") throw new Error(`orchestrator ${orchestrat
 // An explicit --cwd / env override still wins (and is subject to the
 // orchestrator's containment check).
 if (!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 = resolveDefaultSpawnCwd(orchestrator);
 }
 console.log(`using cwd ${cwd} on ${orchestrator.id} (base ${orchestrator.baseDir})`);
 
@@ -239,3 +300,8 @@ for (const provider of providers) {
 }
 
 console.log("spawn smoke passed");
+}
+
+if (import.meta.main) {
+  await main();
+}

package/src/bus.ts

@@ -3,9 +3,7 @@ import { ValidationError, getAgent, getDb, heartbeat, markReady, mergeAgentMeta,
 import { getOutboxCursor, hasReplayGap, replayEventsSlice, type BusEvent } from "./bus-outbox";
 import { projectAgentStatusData } from "./agent-card-projection";
 import { emitRelayEvent, subscribeRelayEvents, type RelayEvent } from "./events";
-import { getCommand, updateCommand } from "./commands-db";
-import { emitCommandEvent } from "./command-events";
-import { noteAgentTimelineEvent, noteCompactionCommandCompleted } from "./compaction-watch";
+import { noteAgentTimelineEvent } from "./compaction-watch";
 import { reconcileTerminalProviderExit } from "./services/terminal-provider-exit";
 import { bindSpawnedTaskToReadyAgent, registerAgent } from "./services/register-agent";
 import { authContextFromBus } from "./services/auth-context";
@@ -15,9 +13,8 @@ import { agentProviderTimelineEvent, auditRunnerTimelineEvent } from "./provider
 import { ServiceAuthError } from "./services/errors";
 import { ShutdownAuthError, ShutdownTargetError, shutdownAgent, shutdownInputFromBusFrame } from "./services/shutdown-agent";
 import { flushQueuedDirectMessages } from "./services/managed-running";
+import { updateCommandFromBus } from "./services/bus-command-update";
 import { isAgentUnavailable } from "./db/agent-predicates";
-import { applyCommandToRecipe } from "./recipe-runner";
-import { enqueueContinuationInjectionAfterSelfResume } from "./self-resume";
 import { messageMatchesAgent, targetMatchesAgent } from "./agent-ref";
 import { probeWorkspaceOnTurnEnd } from "./workspace-probe";
 import { busStaleGraceMs } from "./config";
@@ -31,7 +28,7 @@ import {
 } from "agent-relay-sdk/protocol";
 import { errMessage, isRecord } from "agent-relay-sdk";
 import { getComponentAuth, isComponentAuthorizedFor, isAuthorized, isOriginAllowed, unauthorized } from "./security";
-import type { AgentCard, Command, ComponentToken, ContextState, Message, ProviderCapabilities, QuotaState, RegisterAgentInput, Task } from "./types";
+import type { AgentCard, ComponentToken, ContextState, Message, ProviderCapabilities, QuotaState, RegisterAgentInput, Task } from "./types";
 
 interface BusSocketData {
   kind: "bus";
@@ -238,30 +235,9 @@ function handleCommandFrame(
   params: Record<string, unknown>,
 ): void {
   if (commandType === "command.update") {
-    const command = getCommand(target);
-    if (!command) {
-      sendCommandResult(ws, frameId, "failed", undefined, "command not found");
-      return;
-    }
-    if (!busCommandAuthorized(conn, command)) {
-      sendCommandResult(ws, frameId, "rejected", undefined, "component token lacks command scope");
-      return;
-    }
-    const status = typeof params.status === "string" ? params.status : undefined;
-    const updated = updateCommand(command.id, {
-      status: status as any,
-      result: isRecord(params.result) ? params.result : undefined,
-      error: typeof params.error === "string" ? params.error : undefined,
-    });
-    if (updated) {
-      applyCommandToRecipe(updated);
-      emitCommandEvent(updated, `command.${updated.status}`);
-      // Production command completions arrive here over the bus, not the HTTP
-      // PATCH route — arm the stall watch for finished compact/clear commands.
-      noteCompactionCommandCompleted(updated.type, updated.status, updated.id, updated.target);
-      enqueueContinuationInjectionAfterSelfResume(updated);
-    }
-    sendCommandResult(ws, frameId, "succeeded", updated ? { command: updated } : undefined);
+    void updateCommandFromBus({ target, params, componentAuth: conn.componentAuth })
+      .then((result) => sendCommandResult(ws, frameId, result.status, result.result, result.error))
+      .catch((error) => sendError(ws, frameId, "FRAME_FAILED", errMessage(error)));
     return;
   }
 
@@ -303,17 +279,6 @@ function handleCommandFrame(
   }
 }
 
-function busCommandAuthorized(
-  conn: BusConnection,
-  command: Pick<Command, "target" | "params">,
-): boolean {
-  if (!conn.componentAuth) return true;
-  return isComponentAuthorizedFor(conn.componentAuth, {
-    scope: "command:write",
-    resource: commandAuthorizationResource(command),
-  });
-}
-
 function handleRegister(ws: BusWebSocket, frame: RegisterFrame): void {
   const payload = frame.payload;
   const runnerManaged = payload.meta?.runnerManaged === true || typeof payload.meta?.runnerId === "string";

package/src/prompt-resolver.ts

@@ -147,35 +147,35 @@ const DEFAULT_PROMPT_TEMPLATES = [
       "Objective (verbatim, relay-owned):",
       "{{objective}}",
       "",
-      "Ruled-out ledger (append-only):",
-      "{{ruledOut}}",
-      "",
-      "Decision log (append-only):",
-      "{{decisions}}",
-      "",
       "Working state:",
       "{{workingState}}",
       "",
       "Archive refs:",
       "{{archiveRefs}}",
-    ),
-    defaultTemplate: lines(
-      "{{intro}}",
-      "",
-      "Objective (verbatim, relay-owned):",
-      "{{objective}}",
       "",
       "Ruled-out ledger (append-only):",
       "{{ruledOut}}",
       "",
       "Decision log (append-only):",
       "{{decisions}}",
+    ),
+    defaultTemplate: lines(
+      "{{intro}}",
+      "",
+      "Objective (verbatim, relay-owned):",
+      "{{objective}}",
       "",
       "Working state:",
       "{{workingState}}",
       "",
       "Archive refs:",
       "{{archiveRefs}}",
+      "",
+      "Ruled-out ledger (append-only):",
+      "{{ruledOut}}",
+      "",
+      "Decision log (append-only):",
+      "{{decisions}}",
     ),
     variables: ["intro", "generation", "objective", "ruledOut", "decisions", "workingState", "archiveRefs"],
   },

package/src/self-resume.ts

@@ -9,6 +9,7 @@ import {
   findMessageByIdempotencyKey,
   getAgent,
   getContinuationEnvelope,
+  sendMessage,
   updateContinuationAfterCompact,
   ValidationError,
 } from "./db";
@@ -31,6 +32,7 @@ interface CompactAndResumeResult {
   generation: number;
   commandId: string;
   continuationChars?: number;
+  continuationMessageId?: number;
   ledgerEntries: number;
   exhausted?: boolean;
   reason?: string;
@@ -91,10 +93,12 @@ export function compactAndResume(input: CompactAndResumeInput): CompactAndResume
     now,
   });
   if (updated.droppedLedgerEntries.length) archiveDroppedLedgerEntries(agent.id, generation, updated.droppedLedgerEntries, now);
-  const continuation = renderContinuation(updated.envelope);
+  const fullContinuation = renderContinuation(updated.envelope);
+  const continuationMessage = createContinuationRecoveryMessage(agent.id, generation, fullContinuation, now);
+  const continuation = insertRecoveryPointerAfterIntro(fullContinuation, continuationMessage.id);
   const command = mode === "native"
-    ? createNativeCompact(agent.id, generation, continuation)
-    : createClearThenInject(agent.id, generation, continuation);
+    ? createNativeCompact(agent.id, generation, continuation, continuationMessage.id)
+    : createClearThenInject(agent.id, generation, continuation, continuationMessage.id);
   emitCommandEvent(command, "command.requested");
   return {
     ok: true,
@@ -102,10 +106,45 @@ export function compactAndResume(input: CompactAndResumeInput): CompactAndResume
     generation,
     commandId: command.id,
     continuationChars: continuation.length,
+    continuationMessageId: continuationMessage.id,
     ledgerEntries: updated.envelope.ledger.length,
   };
 }
 
+function continuationRecoveryPointer(messageId: number): string {
+  return `Recovery pointer: use relay_get_message with message id ${messageId} to read your full prior context.`;
+}
+
+function insertRecoveryPointerAfterIntro(continuation: string, messageId: number): string {
+  const pointer = continuationRecoveryPointer(messageId);
+  const firstNewline = continuation.indexOf("\n");
+  if (firstNewline === -1) return `${continuation.trimEnd()}\n\n${pointer}`;
+  return `${continuation.slice(0, firstNewline).trimEnd()}\n${pointer}${continuation.slice(firstNewline)}`;
+}
+
+function createContinuationRecoveryMessage(agentId: string, generation: number, continuation: string, now: number) {
+  const idempotencyKey = `self-resume-continuation:${agentId}:${generation}`;
+  const existing = findMessageByIdempotencyKey("system", idempotencyKey);
+  if (existing) return existing;
+  return sendMessage({
+    from: "system",
+    to: agentId,
+    kind: "system",
+    subject: `Self-resume continuation generation ${generation}`,
+    body: continuation,
+    replyExpected: false,
+    idempotencyKey,
+    maxAgeSeconds: null,
+    occurredAt: now,
+    payload: {
+      kind: "agent.self_resume_continuation",
+      agentId,
+      generation,
+      fullEnvelope: true,
+    },
+  });
+}
+
 // #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
@@ -142,6 +181,7 @@ interface PendingInjection {
   continuation: string;
   mode: string;
   generation?: number;
+  fullContextMessageId?: number;
 }
 
 function extractPendingInjection(command: Command): PendingInjection | null {
@@ -158,7 +198,8 @@ function extractPendingInjection(command: Command): PendingInjection | null {
       : undefined;
   if (!continuation) return null;
   const generation = typeof resume?.generation === "number" ? resume.generation : undefined;
-  return { continuation, mode, generation };
+  const fullContextMessageId = typeof resume?.fullContextMessageId === "number" ? resume.fullContextMessageId : undefined;
+  return { continuation, mode, generation, fullContextMessageId };
 }
 
 function buildInjectionParams(command: Command, injection: PendingInjection): Record<string, unknown> {
@@ -168,6 +209,7 @@ function buildInjectionParams(command: Command, injection: PendingInjection): Re
     selfResume: {
       generation: injection.generation,
       mode: injection.mode,
+      fullContextMessageId: injection.fullContextMessageId,
       ...(command.type === "agent.clearContext" ? { afterClearCommandId: command.id } : {}),
       ...(command.type === "agent.compact" ? { afterCompactCommandId: command.id } : {}),
     },
@@ -376,7 +418,7 @@ function hardLimit(limit: number, multiplier: number): number {
   return Math.ceil(limit * multiplier);
 }
 
-function createNativeCompact(agentId: string, generation: number, continuation: string): Command {
+function createNativeCompact(agentId: string, generation: number, continuation: string, fullContextMessageId: number): Command {
   return createCommand({
     type: "agent.compact",
     source: "system",
@@ -384,19 +426,19 @@ function createNativeCompact(agentId: string, generation: number, continuation:
     params: {
       reason: "self-resume",
       instructions: continuation,
-      selfResume: { generation, mode: "native", continuation },
+      selfResume: { generation, mode: "native", continuation, fullContextMessageId },
     },
   });
 }
 
-function createClearThenInject(agentId: string, generation: number, continuation: string): Command {
+function createClearThenInject(agentId: string, generation: number, continuation: string, fullContextMessageId: number): Command {
   return createCommand({
     type: "agent.clearContext",
     source: "system",
     target: agentId,
     params: {
       reason: "self-resume",
-      selfResume: { generation, mode: "clear-inject", continuation },
+      selfResume: { generation, mode: "clear-inject", continuation, fullContextMessageId },
     },
   });
 }

package/src/services/bus-command-update.ts

@@ -0,0 +1,59 @@
+import { isRecord } from "agent-relay-sdk";
+import { getCommand, updateCommand } from "../commands-db";
+import { emitCommandEvent } from "../command-events";
+import { noteCompactionCommandCompleted } from "../compaction-watch";
+import { applyCommandToRecipe } from "../recipe-runner";
+import { enqueueContinuationInjectionAfterSelfResume } from "../self-resume";
+import { isComponentAuthorizedFor } from "../security";
+import type { Command, ComponentToken } from "../types";
+import { commandAuthorizationResource } from "./dispatch-command";
+import { prepareScheduledCommandResultForStorage, settleScheduledCommandTimer } from "./scheduler-command";
+
+type BusCommandUpdateResult = {
+  status: "succeeded" | "failed" | "rejected";
+  result?: Record<string, unknown>;
+  error?: string;
+};
+
+export async function updateCommandFromBus(input: {
+  target: string;
+  params: Record<string, unknown>;
+  componentAuth?: ComponentToken;
+}): Promise<BusCommandUpdateResult> {
+  const command = getCommand(input.target);
+  if (!command) return { status: "failed", error: "command not found" };
+  if (!busCommandAuthorized(input.componentAuth, command)) {
+    return { status: "rejected", error: "component token lacks command scope" };
+  }
+  const status = typeof input.params.status === "string" ? input.params.status : undefined;
+  let result = isRecord(input.params.result) ? input.params.result : undefined;
+  if (result && command.type === "scheduler.command") {
+    result = await prepareScheduledCommandResultForStorage(command, result);
+  }
+  const updated = updateCommand(command.id, {
+    status: status as any,
+    result,
+    error: typeof input.params.error === "string" ? input.params.error : undefined,
+  });
+  if (updated) {
+    applyCommandToRecipe(updated);
+    if (updated.type === "scheduler.command") {
+      await settleScheduledCommandTimer(updated);
+    }
+    emitCommandEvent(updated, `command.${updated.status}`);
+    noteCompactionCommandCompleted(updated.type, updated.status, updated.id, updated.target);
+    enqueueContinuationInjectionAfterSelfResume(updated);
+  }
+  return { status: "succeeded", result: updated ? { command: updated } : undefined };
+}
+
+function busCommandAuthorized(
+  auth: ComponentToken | undefined,
+  command: Pick<Command, "target" | "params">,
+): boolean {
+  if (!auth) return true;
+  return isComponentAuthorizedFor(auth, {
+    scope: "command:write",
+    resource: commandAuthorizationResource(command),
+  });
+}

package/src/services/task-delivery.ts

@@ -6,6 +6,7 @@ import {
   ownedIsolatedWorkspace,
   recordGate,
   recordTaskDeliverable,
+  setTaskStage,
   setTaskStatus,
   ValidationError,
 } from "../db";
@@ -62,7 +63,17 @@ function resolveTaskId(ctx: AuthContext, explicit: unknown): number {
   throw new ValidationError("caller is bound to multiple Tasks; pass taskId explicitly");
 }
 
-function resolveWorkspace(ctx: AuthContext, input: { workspaceId?: string }, taskId: number): WorkspaceRecord | undefined {
+function canRebindToWorkspace(ctx: AuthContext, task: TaskDetail, ws: WorkspaceRecord): boolean {
+  const caller = ctx.callerAgentId;
+  if (!caller || ws.ownerAgentId !== caller) return false;
+  return task.ownerAgentId === caller || agentBoundTaskIds(caller).has(task.id);
+}
+
+function shouldRebindToWorkspace(task: TaskDetail, ws: WorkspaceRecord | undefined): ws is WorkspaceRecord {
+  return Boolean(task.branch && ws?.branch && task.branch !== ws.branch);
+}
+
+function resolveWorkspace(ctx: AuthContext, input: { workspaceId?: string }, taskId: number, opts: { allowRebind?: boolean } = {}): WorkspaceRecord | undefined {
   const caller = ctx.callerAgentId;
   const explicit = input.workspaceId?.trim();
   const ws = explicit ? getWorkspace(explicit) : caller ? ownedIsolatedWorkspace(caller) : undefined;
@@ -73,11 +84,26 @@ function resolveWorkspace(ctx: AuthContext, input: { workspaceId?: string }, tas
   const task = getTaskDetail(taskId);
   if (!task) throw new ValidationError("task not found");
   if (task.branch && ws.branch && task.branch !== ws.branch) {
+    if (opts.allowRebind && canRebindToWorkspace(ctx, task, ws)) return ws;
     throw new ValidationError(`task ${taskId} is bound to branch ${task.branch}, not workspace branch ${ws.branch}`);
   }
   return ws;
 }
 
+function rebindTaskToWorkspaceIfNeeded(task: TaskDetail, ws: WorkspaceRecord | undefined, actor: string): TaskDetail {
+  if (!shouldRebindToWorkspace(task, ws)) return task;
+  setTaskStatus(task.id, {
+    status: "in_progress",
+    note: `fix-forward rebind to workspace ${ws.id} (${ws.branch})`,
+    actor,
+  });
+  return setTaskStage(task.id, {
+    deliverableStage: "committed-on-branch",
+    branch: ws.branch,
+    actor,
+  });
+}
+
 function gateWrites(gates: TaskDeliveryGateReports | undefined, deliveryKey: string): GateWrite[] {
   const writes: GateWrite[] = [];
   if (gates?.typecheck) writes.push({ gate: "typecheck", ...gatePayload(gates.typecheck, `${deliveryKey}:typecheck`) });
@@ -207,10 +233,11 @@ export async function deliverTask(input: DeliverTaskInput, ctx: AuthContext): Pr
   if (gateProblem) throw new ValidationError(`complete delivery cannot land without passing gate block (${gateProblem})`);
   const reason = input.disposition === "blocked" || input.disposition === "failed" ? cleanReason(input.reason, input.disposition) : undefined;
   const blockedBy = input.disposition === "blocked" ? cleanBlockedBy(input.blockedBy) : input.blockedBy;
-  const workspace = wantsLand || input.workspaceId ? resolveWorkspace(ctx, input, taskId) : undefined;
+  const workspace = wantsLand || input.workspaceId ? resolveWorkspace(ctx, input, taskId, { allowRebind: wantsLand }) : undefined;
   if (wantsLand && (!workspace || workspace.mode !== "isolated" || !workspace.worktreePath)) {
     throw new ValidationError("complete delivery requires a live isolated workspace");
   }
+  const currentTask = wantsLand ? rebindTaskToWorkspaceIfNeeded(before, workspace, actor) : before;
   const landMeta: TaskDeliverableEventMetadata["land"] | undefined = wantsLand && workspace
     ? { requested: true, triggered: false, reason: "pending", workspaceId: workspace.id, workspaceStatus: workspace.status }
     : undefined;
@@ -236,7 +263,7 @@ export async function deliverTask(input: DeliverTaskInput, ctx: AuthContext): Pr
     } else if (isVerdictOnlyComplete) {
       setTaskStatus(taskId, { status: "done", note: "complete delivery recorded without land", actor });
     }
-    const detail = getTaskDetail(taskId);
+    const detail = getTaskDetail(taskId) ?? currentTask;
     if (detail) {
       emitTaskChanged(detail, "task.deliverable");
       notifyDelivery(taskId, delivery.event.id, eventMeta ?? (delivery.event.metadata as unknown as TaskDeliverableEventMetadata));