agent-relay-server 0.125.0 → 0.127.0

package/src/routes/orchestrator.ts

@@ -4,7 +4,7 @@ import { CONTRACT_VERSIONS, parseRuntimeCapabilities, parseRuntimeContracts, par
 import { notifyAgentOffline } from "../agent-lifecycle-events";
 import { diagnoseAgentDeath } from "../agent-death-diagnosis";
 import { VERSION } from "../config";
-import { ValidationError, deleteOrchestrator, getOrchestrator, listOrchestrators, orchestratorHeartbeat, recordAgentExitDiagnostics, setOrchestratorUpgradeState, updateManagedAgents, upsertOrchestrator } from "../db";
+import { ValidationError, deleteOrchestrator, getAgent, getOrchestrator, listOrchestrators, orchestratorHeartbeat, recordAgentExitDiagnostics, setOrchestratorUpgradeState, updateManagedAgents, upsertOrchestrator } from "../db";
 import { auditEvent, authAuditMetadata, authorizeRoute, cleanJsonArray, cleanSafeNumber, dashboardAttribution, emitCommand, error, isRootCredentialRequest, json, parseBody, spawnRequestId, type Handler } from "./_shared";
 import { cleanMeta, cleanString, cleanStringArray, cleanWorkspaceMetadata, optionalEnum } from "../validation";
 import { createCommand, updateCommand } from "../commands-db";
@@ -13,6 +13,7 @@ import { getLifecycleManager } from "../lifecycle-manager";
 import { issueOrchestratorRuntimeToken } from "../runtime-tokens";
 import { isOrchestratorRegistrationAuthorized } from "../security";
 import { type ManagedAgent, type ManagedSessionExitDiagnostics, type OrchestratorRuntimeInput, type RegisterOrchestratorInput, type SpawnApprovalMode, type SpawnProvider } from "../types";
+import { restartSpawnParamsForAgent } from "./agent-sessions";
 
 function cleanProtocolVersion(value: unknown): number | undefined {
   if (value === undefined) return undefined;
@@ -533,13 +534,15 @@ export const postOrchestratorAction: Handler = async (req, params) => {
       resource: { orchestratorId: orch.id, agentId, policyName, spawnRequestId },
     });
     if (denied) return denied;
+    const agent = action === "restart" && agentId ? getAgent(agentId) : undefined;
+    const restartSpawn = agent ? restartSpawnParamsForAgent(agent, orch, policyName, spawnRequestId) : undefined;
 
     const command = createCommand({
       type: action === "restart" ? "agent.restart" : "agent.shutdown",
       source: "system",
       target: orch.agentId,
       correlationId: spawnRequestId,
-      params: { action, agentId, policyName, spawnRequestId, sessionName, tmuxSession, reason, requestedBy: "dashboard", requestedAt: Date.now(), orchestratorId: orch.id },
+      params: { action, agentId, policyName, spawnRequestId, sessionName, tmuxSession, reason, ...(restartSpawn ? { restartSpawn } : {}), requestedBy: "dashboard", requestedAt: Date.now(), orchestratorId: orch.id },
     });
     emitCommand(command);
     auditEvent({

package/src/routes/settings.ts

@@ -10,7 +10,7 @@ import { isRequestAuthorizedFor } from "../security";
 import { cleanString } from "../validation";
 import { emitConfigChanged } from "../sse";
 import { error, json, normalizeConfigPathParam, parseBody, requestUserId, type Handler } from "./_shared";
-import { DEFAULT_USER_ID, isRecord, type ConfigEntry, type SettingDescriptor, type SettingEntry } from "agent-relay-sdk";
+import { DEFAULT_USER_ID, isRecord, type ConfigEntry, type JSONSchema, type SettingDescriptor, type SettingEntry } from "agent-relay-sdk";
 
 type SettingEnvelope = SettingEntry;
 
@@ -91,7 +91,10 @@ async function putSetting(req: Request, namespaceRaw: string | undefined, keyRaw
     if (!validation.valid) return json({ error: "invalid setting value", details: validation.errors }, 400);
     if (descriptor.tier === "user") {
       const userId = requestUserId(req);
-      const userEntry = setUserSetting(userId, namespace, key, parsed.body.value, updatedBy);
+      const valueToStore = descriptor.mergeMapKeys && isRecord(parsed.body.value)
+        ? mergeMapKeysIntoExisting(getUserSetting(userId, namespace, key)?.value, parsed.body.value, descriptor.schema)
+        : parsed.body.value;
+      const userEntry = setUserSetting(userId, namespace, key, valueToStore, updatedBy);
       emitConfigChanged(userEntry.namespace, userEntry.key, userEntry.version);
       return json(settingEnvelope(req, descriptor, userEntry), userEntry.version === 1 ? 201 : 200);
     }
@@ -156,3 +159,29 @@ function mergeSettingDefaults(defaults: unknown, value: unknown): unknown {
   }
   return merged;
 }
+
+// A `mergeMapKeys` descriptor (#1124) is a dictionary keyed by caller-chosen ids (e.g. one row
+// per conversation). A PUT only ever knows its own device's changed keys, never every other
+// device's, so overwriting the whole stored value like a normal setting would erase them — this
+// merges just the incoming keys on top of whatever is already stored instead. The merged result
+// is then capped at the schema's `maxProperties` (when set) so per-key merges from unboundedly
+// many devices can't grow the row forever; the entry with the OLDEST `updatedAt` is evicted first
+// (missing/non-numeric `updatedAt`, e.g. a pre-#1124 row, sorts as oldest: 0).
+function mergeMapKeysIntoExisting(existing: unknown, incoming: Record<string, unknown>, schema: JSONSchema): Record<string, unknown> {
+  const merged: Record<string, unknown> = isRecord(existing) ? { ...existing } : {};
+  for (const [key, item] of Object.entries(incoming)) merged[key] = item;
+
+  const cap = typeof schema.maxProperties === "number" ? schema.maxProperties : undefined;
+  const entries = Object.entries(merged);
+  if (cap !== undefined && entries.length > cap) {
+    entries.sort((a, b) => entryUpdatedAt(a[1]) - entryUpdatedAt(b[1]));
+    const overflow = entries.length - cap;
+    for (let i = 0; i < overflow; i += 1) delete merged[entries[i]![0]];
+  }
+  return merged;
+}
+
+function entryUpdatedAt(value: unknown): number {
+  if (isRecord(value) && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt)) return value.updatedAt;
+  return 0;
+}

package/src/services/restart-instructions.ts

@@ -0,0 +1,36 @@
+import { isSpawnProvider } from "agent-relay-sdk";
+import { getAgentProfile } from "../config-store";
+import { readSpawnCallerSystemPromptAppend, resolveAgentOwnership, withResolvedProvisioning } from "../db";
+import { composeProfileSpawnInstructions } from "../project-instructions";
+import { applyDefaultSharedMcp } from "../shared-mcp";
+import type { AgentCard } from "../types";
+
+function metaString(meta: Record<string, unknown> | undefined, key: string): string | undefined {
+  const value = meta?.[key];
+  return typeof value === "string" ? value : undefined;
+}
+
+export function restartInstructionParamsForAgent(
+  agent: AgentCard,
+  opts: { spawnRequestId?: string; cwd?: string } = {},
+): Record<string, unknown> | undefined {
+  const provider = metaString(agent.meta, "provider");
+  if (!isSpawnProvider(provider)) return undefined;
+  const cwd = opts.cwd ?? metaString(agent.meta, "cwd");
+  const profileName = metaString(agent.meta, "profile");
+  const resolvedProfile = withResolvedProvisioning(profileName ? getAgentProfile(profileName)?.value : undefined, provider);
+  const agentProfile = resolvedProfile ? applyDefaultSharedMcp(resolvedProfile) : undefined;
+  const callerAppend = readSpawnCallerSystemPromptAppend(opts.spawnRequestId);
+  const composed = composeProfileSpawnInstructions({
+    ...(cwd ? { cwd } : {}),
+    operatorId: resolveAgentOwnership(agent.id).ownerUserId,
+    ...(profileName ? { profileName } : {}),
+    ...(agentProfile ? { profile: agentProfile } : {}),
+    ...(callerAppend ? { callerSystemPromptAppend: callerAppend } : {}),
+  });
+  return {
+    ...(composed.systemPromptAppend ? { systemPromptAppend: composed.systemPromptAppend } : {}),
+    ...(callerAppend ? { callerSystemPromptAppend: callerAppend } : {}),
+    ...(composed.relayInjectionEvents.length ? { relayInjectionEvents: composed.relayInjectionEvents } : {}),
+  };
+}

package/src/services/task-delivery.ts

@@ -0,0 +1,275 @@
+import {
+  getTaskDetail,
+  getWorkspace,
+  insertTaskEvent,
+  listTaskEvents,
+  ownedIsolatedWorkspace,
+  recordGate,
+  recordTaskDeliverable,
+  setTaskStatus,
+  ValidationError,
+} from "../db";
+import { emitRelayEvent } from "../events";
+import { routeNotification } from "../notification-router";
+import { emitTaskChanged, emitNewMessages } from "../sse";
+import { agentBoundTaskIds, hasTaskReadAdminScope } from "../task-authz";
+import { applyWorkspaceAction } from "../workspace-actions";
+import { emitTaskSemanticNotification } from "./task-semantic-events";
+import { ServiceAuthError } from "./errors";
+import { resolveCoordinatorAgentId } from "../steward-identity";
+import { markAgentWorkFinal } from "./work-finality";
+import type { AuthContext } from "./auth-context";
+import type { Command, TaskBlocker, TaskDeliverableEventMetadata, TaskDeliveryGateReports, TaskDeliveryResult, TaskGateStatus, TaskDetail, WorkspaceRecord } from "../types";
+
+const REQUIRED_COMPLETE_GATES = ["typecheck", "test"] as const;
+
+export interface DeliverTaskInput extends TaskDeliveryResult {
+  taskId?: number;
+  workspaceId?: string;
+  idempotencyKey?: string;
+}
+
+interface GateWrite {
+  gate: string;
+  status: TaskGateStatus;
+  detail?: string;
+  count?: number;
+  runId?: string;
+}
+
+function callerLabel(ctx: AuthContext): string {
+  return ctx.callerAgentId ?? ctx.actor.id;
+}
+
+function taskIdFrom(value: unknown): number | undefined {
+  if (value === undefined || value === null) return undefined;
+  const n = typeof value === "string" ? Number(value) : value;
+  if (typeof n !== "number" || !Number.isSafeInteger(n) || n < 1) throw new ValidationError("taskId must be a positive integer");
+  return n;
+}
+
+function resolveTaskId(ctx: AuthContext, explicit: unknown): number {
+  const taskId = taskIdFrom(explicit);
+  const caller = ctx.callerAgentId;
+  const bound = caller ? agentBoundTaskIds(caller) : new Set<number>();
+  const admin = hasTaskReadAdminScope(ctx.scopes);
+  if (taskId !== undefined) {
+    if (admin || bound.has(taskId)) return taskId;
+    throw new ServiceAuthError("taskId is not bound to the caller");
+  }
+  if (bound.size === 1) return [...bound][0]!;
+  if (bound.size === 0) throw new ServiceAuthError("caller is not bound to a Task");
+  throw new ValidationError("caller is bound to multiple Tasks; pass taskId explicitly");
+}
+
+function resolveWorkspace(ctx: AuthContext, input: { workspaceId?: string }, taskId: number): WorkspaceRecord | undefined {
+  const caller = ctx.callerAgentId;
+  const explicit = input.workspaceId?.trim();
+  const ws = explicit ? getWorkspace(explicit) : caller ? ownedIsolatedWorkspace(caller) : undefined;
+  if (!ws) return undefined;
+  if (!hasTaskReadAdminScope(ctx.scopes) && (!caller || ws.ownerAgentId !== caller)) {
+    throw new ServiceAuthError(`workspace ${ws.id} is not owned by the caller`);
+  }
+  const task = getTaskDetail(taskId);
+  if (!task) throw new ValidationError("task not found");
+  if (task.branch && ws.branch && task.branch !== ws.branch) {
+    throw new ValidationError(`task ${taskId} is bound to branch ${task.branch}, not workspace branch ${ws.branch}`);
+  }
+  return ws;
+}
+
+function gateWrites(gates: TaskDeliveryGateReports | undefined, deliveryKey: string): GateWrite[] {
+  const writes: GateWrite[] = [];
+  if (gates?.typecheck) writes.push({ gate: "typecheck", ...gatePayload(gates.typecheck, `${deliveryKey}:typecheck`) });
+  if (gates?.test) writes.push({ gate: "test", ...gatePayload(gates.test, `${deliveryKey}:test`) });
+  for (const gate of gates?.other ?? []) {
+    writes.push({ gate: gate.name, ...gatePayload(gate, `${deliveryKey}:other:${gate.name}`) });
+  }
+  return writes;
+}
+
+function gatePayload(input: { status: TaskGateStatus; detail?: string; count?: number; runId?: string }, fallbackRunId: string): Omit<GateWrite, "gate"> {
+  return {
+    status: input.status,
+    ...(input.detail ? { detail: input.detail } : {}),
+    ...(typeof input.count === "number" ? { count: input.count } : {}),
+    runId: input.runId ?? fallbackRunId,
+  };
+}
+
+function normalizedDoneWhen(task: TaskDetail): string {
+  return (task.doneWhen ?? "").toLowerCase();
+}
+
+function completeDeliveryLands(task: TaskDetail): boolean {
+  const dispatchType = task.dispatch?.type;
+  if (dispatchType === "review" || dispatchType === "research" || dispatchType === "ops") return false;
+  const acceptance = normalizedDoneWhen(task);
+  if (/\b(no[-\s]?branch|review(?:ed)?|verdict|report[-\s]?only|none)\b/.test(acceptance)) return false;
+  if (/\b(merged?|landed(?:-on-main)?|live[-\s]?verified|deployed|agent[-\s]?exit|reaped)\b/.test(acceptance)) return true;
+  return true;
+}
+
+function cleanReason(value: unknown, disposition: "blocked" | "failed"): string {
+  if (typeof value !== "string" || !value.trim()) throw new ValidationError(`${disposition} delivery requires reason`);
+  const cleaned = value.trim();
+  if (cleaned.length > 64_000) throw new ValidationError("reason must be 64000 characters or fewer");
+  return cleaned;
+}
+
+function cleanBlockedBy(value: unknown): TaskBlocker[] {
+  if (!Array.isArray(value) || value.length === 0) throw new ValidationError("blocked delivery requires blockedBy");
+  return value as TaskBlocker[];
+}
+
+function completeGateProblem(gates: TaskDeliveryGateReports | undefined): string | undefined {
+  if (!gates) return "missing-gate-block";
+  const writes = gateWrites(gates, "check");
+  const byName = new Map(writes.map((gate) => [gate.gate, gate.status]));
+  const missing = REQUIRED_COMPLETE_GATES.filter((gate) => !byName.has(gate));
+  if (missing.length > 0) return `missing-gates:${missing.join("+")}`;
+  const failed = writes.filter((gate) => gate.status !== "pass").map((gate) => gate.gate);
+  if (failed.length > 0) return `failed-gates:${failed.join("+")}`;
+  return undefined;
+}
+
+function deliveryEvent(taskId: number, idempotencyKey: string | undefined): { id: number; metadata: TaskDeliverableEventMetadata } | undefined {
+  const events = listTaskEvents(taskId).filter((event) => event.type === "deliverable").reverse();
+  const event = idempotencyKey
+    ? events.find((item) => item.metadata.idempotencyKey === idempotencyKey)
+    : events[0];
+  if (!event) return undefined;
+  return { id: event.id, metadata: event.metadata as unknown as TaskDeliverableEventMetadata };
+}
+
+function notifyDelivery(taskId: number, eventId: number, metadata: TaskDeliverableEventMetadata): void {
+  const task = getTaskDetail(taskId);
+  if (!task) return;
+  emitRelayEvent({
+    type: "task.deliverable",
+    source: metadata.actor,
+    subject: String(taskId),
+    data: { taskId, eventId, disposition: metadata.disposition, summary: metadata.summary, workspaceId: metadata.workspaceId },
+  });
+  const coordinator = resolveCoordinatorAgentId(task.ownerAgentId ?? metadata.actor);
+  const recipients = [...new Set([coordinator, task.createdBy].filter((item): item is string => Boolean(item && item.trim())))];
+  const delivered = routeNotification({
+    type: "task.deliverable",
+    scope: {
+      taskId: String(taskId),
+      transition: "deliverable",
+      ...(task.ownerAgentId ? { agentId: task.ownerAgentId, author: task.ownerAgentId } : {}),
+      ...(task.createdBy ? { parent: task.createdBy } : {}),
+      ...(task.teamId ? { teamId: task.teamId } : {}),
+      ...(metadata.workspaceId ? { workspaceId: metadata.workspaceId } : {}),
+    },
+    recipients,
+    ttlMs: null,
+    message: {
+      subject: `Task T${taskId} delivery: ${metadata.disposition}`,
+      body: `Task T${taskId} delivery (${metadata.disposition}): ${metadata.summary}`,
+      payload: {
+        kind: "task.deliverable",
+        notification: "task-deliverable",
+        taskId,
+        eventId,
+        disposition: metadata.disposition,
+        summary: metadata.summary,
+        gates: metadata.gates,
+        risks: metadata.risks,
+        workspaceId: metadata.workspaceId,
+      },
+      idempotencyKey: metadata.idempotencyKey ? `task:${taskId}:deliverable:${metadata.idempotencyKey}` : `task:${taskId}:deliverable:event:${eventId}`,
+      replyExpected: false,
+    },
+  });
+  if (delivered.length > 0) emitNewMessages(delivered);
+}
+
+function emitCommand(command: Command): void {
+  emitRelayEvent({
+    type: command.status === "pending" ? "command.requested" : `command.${command.status}`,
+    source: command.source,
+    subject: command.id,
+    data: { command },
+  });
+}
+
+export async function deliverTask(input: DeliverTaskInput, ctx: AuthContext): Promise<Record<string, unknown>> {
+  const actor = callerLabel(ctx);
+  const taskId = resolveTaskId(ctx, input.taskId);
+  const before = getTaskDetail(taskId);
+  if (!before) throw new ValidationError("task not found");
+  if (before.kind !== "deliverable") throw new ValidationError("task not found");
+  const wantsLand = input.disposition === "complete" && completeDeliveryLands(before);
+  const isVerdictOnlyComplete = input.disposition === "complete" && !wantsLand;
+  const gateProblem = input.disposition === "complete" ? completeGateProblem(input.gates) : undefined;
+  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;
+  if (wantsLand && (!workspace || workspace.mode !== "isolated" || !workspace.worktreePath)) {
+    throw new ValidationError("complete delivery requires a live isolated workspace");
+  }
+  const landMeta: TaskDeliverableEventMetadata["land"] | undefined = wantsLand && workspace
+    ? { requested: true, triggered: false, reason: "pending", workspaceId: workspace.id, workspaceStatus: workspace.status }
+    : undefined;
+  const delivery = recordTaskDeliverable(taskId, {
+    ...input,
+    actor,
+    ...(reason ? { reason } : {}),
+    ...(blockedBy ? { blockedBy } : {}),
+    ...(workspace ? { workspaceId: workspace.id } : {}),
+    ...(input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : {}),
+    ...(landMeta ? { land: landMeta } : {}),
+  });
+  const eventMeta = deliveryEvent(taskId, input.idempotencyKey)?.metadata;
+  if (delivery.created) {
+    const deliveryKey = input.idempotencyKey ?? `event:${delivery.event.id}`;
+    for (const gate of gateWrites(input.gates, deliveryKey)) {
+      recordGate(taskId, { ...gate, actor });
+    }
+    if (input.disposition === "blocked") {
+      setTaskStatus(taskId, { status: "blocked", blockedBy: blockedBy as TaskBlocker[], note: reason, actor });
+    } else if (input.disposition === "failed") {
+      setTaskStatus(taskId, { status: "failed", note: reason, actor });
+    } else if (isVerdictOnlyComplete) {
+      setTaskStatus(taskId, { status: "done", note: "complete delivery recorded without land", actor });
+    }
+    const detail = getTaskDetail(taskId);
+    if (detail) {
+      emitTaskChanged(detail, "task.deliverable");
+      notifyDelivery(taskId, delivery.event.id, eventMeta ?? (delivery.event.metadata as unknown as TaskDeliverableEventMetadata));
+      if (input.disposition === "failed") {
+        emitTaskSemanticNotification({ task: detail, transition: "gate-failed", actor, occurrenceKey: `event:${delivery.event.id}`, outcome: { disposition: "failed" } });
+      }
+    }
+  }
+
+  let land: Record<string, unknown> | undefined;
+  if (wantsLand && delivery.created && workspace) {
+    markAgentWorkFinal(actor, "task-deliver");
+    const result = await applyWorkspaceAction(workspace, {
+      action: "ready",
+      agentId: actor,
+      detail: `Task T${taskId} delivered complete`,
+      auditMetadata: { via: "task_deliver", actor, taskId, deliveryEventId: delivery.event.id },
+    });
+    if (!result.ok) {
+      land = { requested: true, triggered: false, error: result.error, workspaceId: workspace.id };
+    } else {
+      if (result.command) emitCommand(result.command);
+      land = { requested: true, triggered: true, workspace: result.workspace, command: result.command };
+    }
+  } else if (wantsLand && !delivery.created) {
+    land = { requested: true, triggered: false, reason: "duplicate-delivery" };
+  }
+
+  return {
+    taskId,
+    event: delivery.event,
+    created: delivery.created,
+    delivery: eventMeta ?? delivery.event.metadata,
+    ...(land ? { land } : {}),
+  };
+}

package/src/settings/registry.ts

@@ -99,6 +99,7 @@ export function registerSetting<T>(reg: SettingRegistration<T>): SettingDescript
     scope: resolveScope(reg.scope),
     tier: reg.tier,
     display: reg.display,
+    mergeMapKeys: reg.mergeMapKeys,
   };
   registry.set(id, { descriptor: descriptor as SettingDescriptor, validate });
   return descriptor;
@@ -235,14 +236,19 @@ const DISPLAY_PREFS_SCHEMA: JSONSchema = {
   },
 };
 
-// Per-conversation chat scroll memory (#759), tier:"user" so a human's reading position +
+// Per-conversation chat scroll memory (#759/#1124), tier:"user" so a human's reading position +
 // sticky-bottom intent follow them across devices instead of dying in per-browser module state.
 // The value is a MAP keyed by conversation/agent id — one user-settings row holds every
 // conversation's anchor, so this is ONE descriptor (not a per-agent descriptor explosion).
   // Each entry is a LOGICAL anchor, never a pixel scrollTop: `anchorMessageId` is the durable
   // message-id anchor, `topKey` is the compatibility timeline entry key, `offset` the within-row
-  // pixel offset, `stick` the follow-the-bottom intent. `maxProperties` bounds unbounded
-  // conversation growth; the dashboard store evicts oldest-touched before it can be hit.
+  // pixel offset, `stick` the follow-the-bottom intent. `updatedAt` (epoch ms, #1124) is the
+  // per-entry write timestamp the client stamps on every write; it drives both the server's
+  // over-cap eviction (oldest-`updatedAt`-first, not oldest-key-first) and the client's
+  // newer-wins re-hydration merge, so it is intentionally NOT `required` — older rows written
+  // before #1124 lack it and must still validate (they just sort as oldest). `maxProperties`
+  // bounds unbounded conversation growth across every device that merges into this row (#1124
+  // `mergeMapKeys`); the dashboard store also evicts oldest-touched locally well under it.
 const CHAT_SCROLL_SCHEMA: JSONSchema = {
   type: "object",
   maxProperties: 200,
@@ -256,6 +262,7 @@ const CHAT_SCROLL_SCHEMA: JSONSchema = {
       anchorMessageId: { type: "number", minimum: 0, maximum: 10_000_000_000 },
       anchorEndMessageId: { type: "number", minimum: 0, maximum: 10_000_000_000 },
       offset: { type: "number", minimum: 0, maximum: 10_000_000 },
+      updatedAt: { type: "number", minimum: 0 },
     },
   },
 };
@@ -443,6 +450,9 @@ function seedBuiltInSettings(): void {
   });
 
   // Per-conversation chat scroll memory (#759) — one row per user, keyed internally by agent id.
+  // `mergeMapKeys` (#1124): a PUT merges only the conversation keys it carries into the stored
+  // map instead of replacing it, so one device's write can't clobber another device's write to a
+  // different conversation (the "desktop tab resurrects every conversation" bug in #1130 chain A2).
   registerSetting({
     namespace: "chat",
     key: "scroll",
@@ -450,6 +460,7 @@ function seedBuiltInSettings(): void {
     defaults: {},
     scope: { read: "settings:read:chat", write: "settings:write:chat" },
     tier: "user",
+    mergeMapKeys: true,
     display: { group: "Preferences", label: "Chat scroll", description: "Per-conversation scroll position and sticky-bottom flag (follows you across devices).", order: 72 },
   });
 

package/src/workspace-phase.ts

@@ -84,7 +84,7 @@ export const LAND_PENDING_STALL_MS = 15 * 60 * 1000;
 export const DIRTY_WORKTREE_LAND_SKIP_REASON = "worktree has uncommitted changes";
 
 type WorkspacePhase =
-  | "working" // active — your turn: commit, then mark ready
+  | "working" // active — your turn: commit, then deliver
   | "land-pending" // ready | review_requested — handed off; auto-merge will land it
   | "landing" // merge_planned — merge dispatched, in progress
   | "steward" // conflict — auto-merge couldn't; a steward is reconciling (not your job)
@@ -122,13 +122,13 @@ const WAIT_ACTION: WorkspaceNextAction = {
 const CHECK_STATUS_ACTION: WorkspaceNextAction = {
   tool: "relay_workspace_status",
   cli: "agent-relay workspace status",
-  when: "only if you are explicitly checking state later; do not poll or wait after marking ready",
+  when: "only if you are explicitly checking state later; do not poll or wait after delivering",
 };
 
 const READY_ACTION: WorkspaceNextAction = {
-  tool: "relay_workspace_ready",
-  cli: "agent-relay workspace ready",
-  when: "after you commit your work in this worktree",
+  tool: "relay_task_deliver",
+  cli: "MCP relay_task_deliver",
+  when: "after you commit your work and have passing delivery gates",
 };
 
 // Map every WorkspaceStatus to the branch agent's mental model. Statuses that