agent-relay-server 0.120.1 → 0.120.2

package/src/automations/reconcile.ts

@@ -1,5 +1,5 @@
 import { createCommand } from "../commands-db";
-import { getAgent, getTask, listOrchestrators, sendMessage, updateTaskStatus } from "../db";
+import { getAgent, getTask, listAgents, listOrchestrators, sendMessage, updateTaskStatus } from "../db";
 import { renderTemplate } from "../prompt-resolver";
 import { CLOSED_TASK_STATUS } from "./constants";
 import {
@@ -11,7 +11,7 @@ import {
   db,
 } from "./storage";
 import type { AutomationReconcileResult } from "./types";
-import type { AutomationRun, AutomationRunStatus, AutomationRuntimeBudget, Command, Message, Task } from "../types";
+import type { AgentCard, AutomationRun, AutomationRunStatus, AutomationRuntimeBudget, Command, Message, Task } from "../types";
 
 export function reconcileAutomationRuns(now = Date.now()): AutomationReconcileResult[] {
   ensureAutomationTables();
@@ -41,6 +41,11 @@ export function reconcileAutomationRuns(now = Date.now()): AutomationReconcileRe
     if (!CLOSED_TASK_STATUS.has(task.status)) {
       const updated = getAutomationRun(run.id);
       if (!updated) continue;
+      const neverReadyOffline = maybeFailNeverReadyOfflineTarget(updated, task, now);
+      if (neverReadyOffline) {
+        results.push(neverReadyOffline);
+        continue;
+      }
       const timedOut = maybeTimeoutRuntimeBudget(updated, task, now);
       if (timedOut) {
         results.push(timedOut);
@@ -68,9 +73,8 @@ export function reconcileAutomationRuns(now = Date.now()): AutomationReconcileRe
 }
 
 function automationRunRuntimeMeta(run: AutomationRun, task: Task): Record<string, unknown> {
-  const agentId = task.claimedBy ?? run.targetAgentId ?? run.spawnedAgentId;
+  const { agentId, agent } = resolveAutomationRunAgent(run, task);
   if (!agentId) return {};
-  const agent = getAgent(agentId);
   const managed = listOrchestrators()
     .flatMap((orchestrator) => orchestrator.managedAgents.map((managedAgent) => ({ orchestrator, managedAgent })))
     .find(({ managedAgent }) => managedAgent.agentId === agentId);
@@ -103,6 +107,23 @@ function hasMetaChanges(current: Record<string, unknown>, patch: Record<string,
   return Object.entries(patch).some(([key, value]) => current[key] !== value);
 }
 
+function resolveAutomationRunAgent(run: AutomationRun, task: Task): { agentId?: string; agent?: AgentCard } {
+  const explicitAgentId = task.claimedBy ?? run.targetAgentId ?? run.spawnedAgentId ?? stringMeta(run.meta, "runtimeAgentId");
+  if (explicitAgentId) return { agentId: explicitAgentId, agent: getAgent(explicitAgentId) ?? undefined };
+
+  const onDemandLabel = stringMeta(run.meta, "onDemandLabel");
+  const agent = listAgents().find((candidate) =>
+    (onDemandLabel !== undefined && candidate.label === onDemandLabel) ||
+    stringMeta(candidate.meta, "automationRunId") === run.id
+  );
+  return agent ? { agentId: agent.id, agent } : {};
+}
+
+function isOnDemandAutomationRun(run: AutomationRun): boolean {
+  if (run.meta.targetMode === "on_demand_agent") return true;
+  return getAutomation(run.automationId)?.targetPolicy.mode === "on_demand_agent";
+}
+
 function runtimeBudgetForRun(run: AutomationRun): AutomationRuntimeBudget | undefined {
   const automation = getAutomation(run.automationId);
   if (!automation || automation.targetPolicy.mode !== "on_demand_agent") return undefined;
@@ -163,6 +184,50 @@ function maybeWarnRuntimeBudget(run: AutomationRun, task: Task, now: number): Me
   return message;
 }
 
+function maybeFailNeverReadyOfflineTarget(run: AutomationRun, task: Task, now: number): AutomationReconcileResult | undefined {
+  if (!isOnDemandAutomationRun(run) || task.claimedBy) return undefined;
+  const { agentId, agent } = resolveAutomationRunAgent(run, task);
+  if (!agentId || !agent || agent.status !== "offline" || agent.ready) return undefined;
+
+  const reason = "Automation target went offline before becoming ready";
+  const taskResult = updateTaskStatus(task.id, {
+    status: "canceled",
+    agentId,
+    result: reason,
+    body: reason,
+    metadata: {
+      automationId: run.automationId,
+      automationRunId: run.id,
+      automationTargetOffline: true,
+      automationTargetNeverReady: true,
+      agentId,
+    },
+  });
+  const updatedTask = taskResult.task ?? getTask(task.id) ?? task;
+  updateRun(run.id, {
+    status: "failed",
+    finishedAt: now,
+    error: reason,
+    result: {
+      taskStatus: updatedTask.status,
+      automationTargetOffline: true,
+      automationTargetNeverReady: true,
+      agentId,
+    },
+    targetAgentId: agentId,
+    spawnedAgentId: run.spawnedAgentId ?? agentId,
+    meta: {
+      ...run.meta,
+      runtimeAgentId: agentId,
+      runtimeAgentStatus: agent.status,
+      runtimeAgentReady: agent.ready,
+      runtimeTargetOfflineAt: now,
+      runtimeTargetNeverReady: true,
+    },
+  }, now);
+  return { run: getAutomationRun(run.id)!, task: getTask(task.id) ?? updatedTask };
+}
+
 function maybeTimeoutRuntimeBudget(run: AutomationRun, task: Task, now: number): AutomationReconcileResult | undefined {
   const budget = runtimeBudgetForRun(run);
   if (!budget) return undefined;

package/src/branch-landed.ts

@@ -46,7 +46,7 @@ export interface BranchLandedInput {
 }
 
 type BranchLandedLogFn = (message: string) => void;
-type LandedCommitSubjectResolver = (input: BranchLandedInput, log: BranchLandedLogFn) => string[] | undefined;
+type LandedCommitSubjectResolver = (input: BranchLandedInput, log: BranchLandedLogFn) => string[] | undefined | Promise<string[] | undefined>;
 
 let landedCommitSubjectResolverForTests: LandedCommitSubjectResolver | undefined;
 
@@ -59,7 +59,7 @@ function cleanRef(value: string | undefined): string | undefined {
   return cleaned || undefined;
 }
 
-function landedCommitSubjects(input: BranchLandedInput, log: BranchLandedLogFn): string[] | undefined {
+async function landedCommitSubjects(input: BranchLandedInput, log: BranchLandedLogFn): Promise<string[] | undefined> {
   if (landedCommitSubjectResolverForTests) return landedCommitSubjectResolverForTests(input, log);
   if (input.prLand) return undefined;
   const repoRoot = cleanRef(input.workspace.repoRoot);
@@ -67,17 +67,18 @@ function landedCommitSubjects(input: BranchLandedInput, log: BranchLandedLogFn):
   const tipSha = cleanRef(input.mergedSha);
   if (!repoRoot || !baseSha || !tipSha || baseSha === tipSha) return undefined;
   try {
-    const proc = Bun.spawnSync(["git", "-C", repoRoot, "log", "--format=%B%x00", `${baseSha}..${tipSha}`], {
+    const proc = Bun.spawn(["git", "-C", repoRoot, "log", "--format=%B%x00", `${baseSha}..${tipSha}`], {
       stdin: "ignore",
       stdout: "pipe",
       stderr: "pipe",
     });
-    if (proc.exitCode !== 0) {
-      const error = Buffer.from(proc.stderr).toString("utf8").trim() || `exit ${proc.exitCode}`;
+    const [stdout, stderr, exitCode] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text(), proc.exited]);
+    if (exitCode !== 0) {
+      const error = stderr.trim() || `exit ${exitCode}`;
       log(`issue lifecycle commit range scan failed for ${input.workspace.id} (${baseSha.slice(0, 12)}..${tipSha.slice(0, 12)}): ${error}; falling back to tip subject`);
       return undefined;
     }
-    const subjects = Buffer.from(proc.stdout).toString("utf8").split("\x00").map((msg) => msg.trim()).filter(Boolean);
+    const subjects = stdout.split("\x00").map((msg) => msg.trim()).filter(Boolean);
     return subjects.length > 0 ? subjects : undefined;
   } catch (error) {
     log(`issue lifecycle commit range scan failed for ${input.workspace.id} (${baseSha.slice(0, 12)}..${tipSha.slice(0, 12)}): ${errMessage(error)}; falling back to tip subject`);
@@ -94,6 +95,13 @@ function resolveLandedTask(workspace: Pick<WorkspaceRecord, "branch" | "ownerAge
   return task ? { taskId: task.id, taskLabel: task.title } : undefined;
 }
 
+function landedNotificationIdempotencyKey(input: BranchLandedInput, landedTask: { taskId: number } | undefined, base: string): string | undefined {
+  const sha = cleanRef(input.mergedSha);
+  if (sha) return `branch-landed:${sha}`;
+  if (landedTask) return `branch-landed:task:${landedTask.taskId}:${base}`;
+  return undefined;
+}
+
 /**
  * #239 — turn an authoritative land completion into a relay-driven push so the author
  * stops polling to learn it merged. Always emits the durable `branch.landed` event (the
@@ -108,8 +116,8 @@ export function notifyBranchLanded(input: BranchLandedInput): void {
   const landedBranch = workspace.branch;
   const shortSha = input.mergedSha ? input.mergedSha.slice(0, 12) : undefined;
   const lifecycleLog = (message: string) => console.warn(message);
-  const commitSubjects = landedCommitSubjects(input, lifecycleLog);
   const landedTask = resolveLandedTask(workspace);
+  const idempotencyKey = landedNotificationIdempotencyKey(input, landedTask, base);
 
   emitRelayEvent({
     type: "branch.landed",
@@ -151,6 +159,7 @@ export function notifyBranchLanded(input: BranchLandedInput): void {
   // receipt accurate. Both are best-effort + isolated — a throw in either can never fail the merge
   // (it already landed before notifyBranchLanded runs). A non-task branch makes the Task drive a no-op.
   void (async () => {
+    const commitSubjects = await landedCommitSubjects(input, lifecycleLog);
     try {
       await handleLandedIssueLifecycle({ ...input, commitSubjects }, { log: lifecycleLog });
     } catch (error) {
@@ -208,6 +217,7 @@ export function notifyBranchLanded(input: BranchLandedInput): void {
           continueLabel,
         }),
         payload: { ...payload, notification: "landed-success" },
+        idempotencyKey,
         replyExpected: false,
       },
     });
@@ -231,6 +241,7 @@ export function notifyBranchLanded(input: BranchLandedInput): void {
       subject: `Merged to ${base}`,
       body: `🔀 ${branchLabel}${authorLabel} merged to \`${base}\`${shaLabel}${subjectLabel}.${publishLabel}`,
       payload: { ...payload, notification: "landed-success" },
+      idempotencyKey,
       replyExpected: false,
     },
   });

package/src/bus.ts

@@ -31,7 +31,7 @@ import {
 } from "agent-relay-sdk/protocol";
 import { errMessage, isRecord } from "agent-relay-sdk";
 import { getComponentAuth, isComponentAuthorizedFor, isAuthorized, isOriginAllowed, unauthorized } from "./security";
-import type { Command, ComponentToken, ContextState, Message, ProviderCapabilities, QuotaState, RegisterAgentInput, Task } from "./types";
+import type { AgentCard, Command, ComponentToken, ContextState, Message, ProviderCapabilities, QuotaState, RegisterAgentInput, Task } from "./types";
 
 interface BusSocketData {
   kind: "bus";
@@ -503,30 +503,37 @@ function withRegistered(
 }
 
 function broadcastRelayEvent(event: RelayEvent): void {
+  const frame = JSON.stringify({
+    type: "event",
+    payload: {
+      seq: event.seq,
+      eventType: event.type,
+      source: event.source,
+      subject: event.subject,
+      data: event.data,
+      timestamp: event.timestamp,
+    },
+  });
+  const agentCache = new Map<string, AgentCard | null>();
   for (const conn of busConnections.values()) {
-    if (!connectionWantsEvent(conn, event)) continue;
-    send(conn.ws, {
-      type: "event",
-      payload: {
-        seq: event.seq,
-        eventType: event.type,
-        source: event.source,
-        subject: event.subject,
-        data: event.data,
-        timestamp: event.timestamp,
-      },
-    });
+    if (!connectionWantsEvent(conn, event, agentCache)) continue;
+    conn.ws.send(frame);
   }
 }
 
-function connectionWantsEvent(conn: BusConnection, event: RelayEvent): boolean {
+function fanoutAgent(agentId: string, cache: Map<string, AgentCard | null>): AgentCard | null {
+  if (!cache.has(agentId)) cache.set(agentId, getAgent(agentId));
+  return cache.get(agentId) ?? null;
+}
+
+function connectionWantsEvent(conn: BusConnection, event: RelayEvent, agentCache: Map<string, AgentCard | null>): boolean {
   if (!matchesSubscription(conn.subscriptions, event.type)) return false;
   if (event.type === "message.new" && conn.agentId) {
-    return messageMatchesAgent(event.data as unknown as Message, conn.agentId, getAgent(conn.agentId));
+    return messageMatchesAgent(event.data as unknown as Message, conn.agentId, fanoutAgent(conn.agentId, agentCache));
   }
   if (event.type.startsWith("task.") && conn.agentId) {
     const target = typeof event.data.target === "string" ? event.data.target : "";
-    return targetMatchesAgent(target, conn.agentId, getAgent(conn.agentId));
+    return targetMatchesAgent(target, conn.agentId, fanoutAgent(conn.agentId, agentCache));
   }
   if (event.type.startsWith("command.")) {
     const command = isRecord(event.data.command) ? event.data.command : undefined;

package/src/db/connection.ts

@@ -1,12 +1,15 @@
 import { Database } from "bun:sqlite";
+import { join } from "node:path";
 import { DB_SLOW_QUERY_MS } from "../config";
 
 // The shared SQLite handle. Set once by initDb() (schema.ts) and read everywhere
 // else through getDb(). Kept module-private so the only mutation path is setDb().
 let db: Database;
+let dbPath: string | undefined;
 
-export function setDb(conn: Database): void {
+export function setDb(conn: Database, path?: string): void {
   db = conn;
+  dbPath = path;
 }
 
 export function getDb(): Database {
@@ -14,6 +17,10 @@ export function getDb(): Database {
   return db;
 }
 
+export function getDbPath(): string | undefined {
+  return dbPath;
+}
+
 // Connection-scoped pragmas. journal_mode and auto_vacuum persist in the file;
 // the rest reset per connection, so they must be re-applied on every open.
 export function applyConnectionPragmas(conn: Database): void {
@@ -67,6 +74,27 @@ export function runDbMaintenance(options: { vacuum?: boolean } = {}): {
   return { analyzed: true, checkpointed: true, vacuumed };
 }
 
+export async function runDbMaintenanceAsync(options: { vacuum?: boolean } = {}): Promise<{
+  analyzed: boolean;
+  checkpointed: boolean;
+  vacuumed: boolean;
+  offThread: boolean;
+}> {
+  if (!dbPath || dbPath === ":memory:") return { ...runDbMaintenance(options), offThread: false };
+  const proc = Bun.spawn([process.execPath, join(import.meta.dir, "maintenance-worker.ts"), dbPath, options.vacuum ? "vacuum" : "no-vacuum"], {
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text(), proc.exited]);
+  if (exitCode !== 0) {
+    const detail = stderr.trim() || stdout.trim() || `exit ${exitCode}`;
+    throw new Error(`db maintenance worker failed: ${detail}`);
+  }
+  const result = JSON.parse(stdout) as { analyzed: boolean; checkpointed: boolean; vacuumed: boolean };
+  return { ...result, offThread: true };
+}
+
 // Shared error types thrown across query domains and unwrapped at call sites.
 // `ValidationError` now lives in the SDK (agent-relay-sdk) as the single canonical
 // home shared with the orchestrator package; re-exported here so the ~120 server

package/src/db/maintenance-worker.ts

@@ -0,0 +1,25 @@
+import { Database } from "bun:sqlite";
+import { applyConnectionPragmas } from "./connection";
+
+const [, , dbPath, mode] = Bun.argv;
+
+if (!dbPath) {
+  console.error("db path is required");
+  process.exit(2);
+}
+
+const db = new Database(dbPath, { create: true });
+try {
+  applyConnectionPragmas(db);
+  db.run("ANALYZE");
+  db.run("PRAGMA optimize");
+  db.run("PRAGMA wal_checkpoint(TRUNCATE)");
+  let vacuumed = false;
+  if (mode === "vacuum") {
+    db.run("VACUUM");
+    vacuumed = true;
+  }
+  console.log(JSON.stringify({ analyzed: true, checkpointed: true, vacuumed }));
+} finally {
+  db.close();
+}

package/src/db/message-reads.ts

@@ -15,7 +15,7 @@ import {
 import { STALE_TTL_MS, DAY_MS, CLAIM_LEASE_MS, POOL_CLAIM_LEASE_MS, WORKSPACE_MERGE_LEASE_MS } from "../config";
 import { matchAgents } from "../agent-ref";
 import { getAgent } from "./agents.ts";
-import { getMessage, sendMessageWithResult } from "./messages.ts";
+import { sendMessageWithResult } from "./messages.ts";
 import { deleteArtifactLinksForEntity } from "./artifacts.ts";
 import { getDb, timedQuery } from "./connection.ts";
 import { legacyChannelTargets, isChannelAgentId } from "./delivery.ts";
@@ -393,25 +393,58 @@ function relayConversationId(message: Message): string | undefined {
   return stringField(replyContext?.conversationId) ?? stringField(conversation?.id);
 }
 
-function isCoveredByLaterAgentResponse(message: Message, agentId: string): boolean {
+function messagesCoveredByLaterAgentResponses(messages: Message[], agentId: string): Set<number> {
+  if (messages.length === 0) return new Set();
   // Order by id, not created_at: ids are monotonic insertion order, so this is
   // robust when a reply lands in the same millisecond as the message it covers
   // (created_at > … strictly would miss it, leaving the message wrongly pending).
-  const replies = (getDb().query(`
-    ${MSG_SELECT}
-    WHERE m.from_agent = ?
-      AND m.id > ?
-    ORDER BY m.id ASC
-    LIMIT 200
-  `).all(agentId, message.id) as any[]).map(rowToMessage);
-
-  const conversationId = relayConversationId(message);
-  return replies.some((reply) => {
-    if (reply.replyTo === message.id) return true;
-    if (message.threadId !== undefined && reply.threadId === message.threadId) return true;
-    if (!message.channel || reply.channel !== message.channel || !conversationId) return false;
-    return relayConversationId(reply) === conversationId;
-  });
+  const minMessageId = Math.min(...messages.map((message) => message.id));
+  const replies = getDb().query(`
+    SELECT id, thread_id, channel, reply_to, payload
+    FROM messages INDEXED BY idx_msg_from_id
+    WHERE from_agent = ?
+      AND id > ?
+    ORDER BY id ASC
+  `).all(agentId, minMessageId) as Array<{ id: number; thread_id: number | null; channel: string | null; reply_to: number | null; payload: string }>;
+  if (replies.length === 0) return new Set();
+
+  const covered = new Set<number>();
+  const conversationsById = new Map<number, string | undefined>();
+  for (const message of messages) conversationsById.set(message.id, relayConversationId(message));
+
+  for (const message of messages) {
+    const conversationId = conversationsById.get(message.id);
+    for (const reply of replies) {
+      if (reply.id <= message.id) continue;
+      if (reply.reply_to === message.id) {
+        covered.add(message.id);
+        break;
+      }
+      if (message.threadId !== undefined && reply.thread_id === message.threadId) {
+        covered.add(message.id);
+        break;
+      }
+      if (!message.channel || reply.channel !== message.channel || !conversationId) continue;
+      if (relayConversationId({
+        id: reply.id,
+        from: agentId,
+        to: "",
+        body: "",
+        kind: "chat",
+        channel: reply.channel ?? undefined,
+        replyTo: reply.reply_to ?? undefined,
+        threadId: reply.thread_id ?? undefined,
+        payload: parseJson(reply.payload ?? "{}", {}),
+        meta: {},
+        readBy: [],
+        createdAt: 0,
+      }) === conversationId) {
+        covered.add(message.id);
+        break;
+      }
+    }
+  }
+  return covered;
 }
 
 function replyObligationFromMessage(message: Message, agentId: string): ReplyObligation {
@@ -433,11 +466,20 @@ function replyObligationFromMessage(message: Message, agentId: string): ReplyObl
 export function listPendingReplyObligations(agentId: string, limit = 20): ReplyObligation[] {
   const scanLimit = Math.max(limit * 5, 50);
   const rows = timedQuery("listPendingReplyObligations", () => getDb().query(`
-    ${MSG_SELECT}
-    WHERE EXISTS (
-      SELECT 1 FROM message_reads mr
-      WHERE mr.message_id = m.id AND mr.agent_id = ?
-    )
+    SELECT m.*, (
+      SELECT json_group_array(agent_id) FROM message_reads WHERE message_id = m.id
+    ) AS read_by_agents, (
+      SELECT json_group_array(json_object(
+        'messageId', message_id,
+        'actorId', actor_id,
+        'emoji', emoji,
+        'createdAt', created_at,
+        'updatedAt', updated_at
+      )) FROM message_reactions WHERE message_id = m.id
+    ) AS reactions_json
+    FROM message_reads mr INDEXED BY idx_mr_agent
+    JOIN messages m ON m.id = mr.message_id
+    WHERE mr.agent_id = ?
       AND m.from_agent != ?
       AND NOT EXISTS (
         SELECT 1 FROM messages reply
@@ -447,10 +489,12 @@ export function listPendingReplyObligations(agentId: string, limit = 20): ReplyO
     ORDER BY m.created_at ASC
     LIMIT ?
   `).all(agentId, agentId, agentId, scanLimit) as any[]);
-  return rows
+  const candidates = rows
     .map(rowToMessage)
-    .filter(messageRequiresReply)
-    .filter((message) => !isCoveredByLaterAgentResponse(message, agentId))
+    .filter(messageRequiresReply);
+  const covered = messagesCoveredByLaterAgentResponses(candidates, agentId);
+  return candidates
+    .filter((message) => !covered.has(message.id))
     .slice(0, limit)
     .map((message) => replyObligationFromMessage(message, agentId));
 }
@@ -484,25 +528,6 @@ export function channelObligationAnsweredBy(
   return open.length === 1 ? open[0]!.messageId : null;
 }
 
-/**
- * Spawn report-back linking (#492): a spawned worker's actual task is delivered as the provider
- * prompt, while `seedSpawnReplyObligation` creates a short Stop-hook contract message so the worker
- * cannot go idle without reporting back. Workers commonly send their natural completion report
- * directly to the spawning coordinator; when there is exactly one open spawn obligation from that
- * coordinator, that send is the answer. Link it to the obligation at send time so the Stop hook does
- * not nag the worker into re-sending the same verdict through `/reply`.
- */
-export function spawnObligationAnsweredBy(
-  agentId: string,
-  spawnerAgentId: string,
-): number | null {
-  const open = listPendingReplyObligations(agentId, 50).filter((obligation) => {
-    if (obligation.from !== spawnerAgentId) return false;
-    return getMessage(obligation.messageId)?.payload?.source === "spawn-obligation";
-  });
-  return open.length === 1 ? open[0]!.messageId : null;
-}
-
 /**
  * #573 — spawned children no longer get a report-back reply obligation. Their turn-final
  * response is promoted server-side to the spawn-parent by lineage, so creating a separate

package/src/db/migrations.ts

@@ -411,6 +411,7 @@ export function applyMigrations(): void {
     getDb().run("ALTER TABLE messages ADD COLUMN payload TEXT NOT NULL DEFAULT '{}'");
   }
   getDb().run("CREATE INDEX IF NOT EXISTS idx_msg_kind ON messages(kind)");
+  getDb().run("CREATE INDEX IF NOT EXISTS idx_msg_from_id ON messages(from_agent, id)");
   getDb().run("CREATE INDEX IF NOT EXISTS idx_msg_from_kind_id ON messages(from_agent, kind, id)"); getDb().run("CREATE INDEX IF NOT EXISTS idx_msg_analytics_created ON messages(created_at, kind, from_agent, claimable, reply_to)"); getDb().run("CREATE INDEX IF NOT EXISTS idx_msg_session_analytics ON messages(kind, created_at, json_extract(payload, '$.session.type'), json_extract(payload, '$.session.label'), json_extract(payload, '$.session.turnId'))");
   // (from_agent, idempotency_key) powers findMessageByIdempotencyKey — the retry-dedup lookup
   // AND the session-step in-place upsert (Codex tool running→completed / streamed reasoning),

package/src/db/provider-quotas.ts

@@ -125,10 +125,15 @@ function supersededAccountKeys(provider: string, accountKey: string, rawAccountK
   return [...candidates];
 }
 
+// Source priority for quota precedence: "ingest" (WHAM/API) beats "probe" (agent self-report).
+const QUOTA_SOURCE_PRIORITY: Record<string, number> = { ingest: 3, header: 2, probe: 1, statusline: 0, emulated: -1 };
+function quotaSourcePriority(source: string): number { return QUOTA_SOURCE_PRIORITY[source] ?? 1; }
+
 function newestQuotaState(rows: ProviderQuotaRow[]): string | null {
+  const priority = (candidate: ProviderQuotaRow) => { const source = parseJson<Partial<QuotaState>>(candidate.quota_state, { source: "probe" }).source; return quotaSourcePriority(typeof source === "string" ? source : "probe"); };
   const row = rows
     .filter((candidate) => candidate.quota_state)
-    .sort((a, b) => (b.last_updated_at ?? 0) - (a.last_updated_at ?? 0))[0];
+    .sort((a, b) => priority(b) - priority(a) || (b.last_updated_at ?? 0) - (a.last_updated_at ?? 0))[0];
   return row?.quota_state ?? null;
 }
 
@@ -285,12 +290,6 @@ function storedQuotaWindowSampleTimes(quota: StoredQuotaState): Map<string, numb
   return times;
 }
 
-// Source priority for per-window precedence: "ingest" (WHAM/API) beats "probe" (agent self-report).
-const QUOTA_SOURCE_PRIORITY: Record<string, number> = { ingest: 3, header: 2, probe: 1, statusline: 0, emulated: -1 };
-function quotaSourcePriority(source: string): number {
-  return QUOTA_SOURCE_PRIORITY[source] ?? 1;
-}
-
 function storedQuotaWindowSources(quota: StoredQuotaState): Map<string, string> {
   const sources = new Map<string, string>();
   const rawSources = quota._windowSource && typeof quota._windowSource === "object" ? quota._windowSource : {};

package/src/db/schema.ts

@@ -91,7 +91,7 @@ import type {
 export function initDb(path: string = "agent-relay.db"): Database {
   const conn = new Database(path, { create: true });
   applyConnectionPragmas(conn);
-  setDb(conn);
+  setDb(conn, path);
 
   getDb().run(`
     CREATE TABLE IF NOT EXISTS agents (
@@ -165,6 +165,7 @@ export function initDb(path: string = "agent-relay.db"): Database {
     -- resolved_to_agent ALTER — never inline here (same hazard as #483/#559).
     -- idx_msg_reply_to is also migration-owned because reply_to was added by ALTER.
     CREATE INDEX IF NOT EXISTS idx_msg_to_id ON messages(to_target, id);
+    CREATE INDEX IF NOT EXISTS idx_msg_from_id ON messages(from_agent, id);
     CREATE INDEX IF NOT EXISTS idx_msg_created ON messages(created_at);
     CREATE INDEX IF NOT EXISTS idx_msg_channel ON messages(channel);
     CREATE TABLE IF NOT EXISTS scheduled_timers (

package/src/maintenance/jobs.ts

@@ -20,7 +20,7 @@ import {
   releaseExpiredClaims,
   releaseExpiredDriveLeases,
   releaseOrphanedTasks,
-  runDbMaintenance,
+  runDbMaintenanceAsync,
   sweepArtifacts,
 } from "../db";
 import { isAgentUnavailable } from "../db/agent-predicates";
@@ -385,10 +385,10 @@ export const definitions: MaintenanceJobDefinition[] = [
     intervalMs: DB_MAINTENANCE_INTERVAL_MS,
     runOnStart: false,
     timeoutMs: 5 * 60 * 1000,
-    handler() {
+    async handler() {
       dbMaintenanceRuns += 1;
       const vacuum = DB_VACUUM_EVERY > 0 && dbMaintenanceRuns % DB_VACUUM_EVERY === 0;
-      return runDbMaintenance({ vacuum });
+      return runDbMaintenanceAsync({ vacuum });
     },
   },
   {

package/src/mcp/index.ts

@@ -167,11 +167,11 @@ async function callTool(auth: McpAuthContext, params: unknown): Promise<Record<s
     else if (name === "relay_agent_action") result = relayAgentAction(auth, args);
     else if (name === "relay_workspace_status") result = await relayWorkspaceStatus(auth, args);
     else if (name === "relay_workspace_list") result = relayWorkspaceList(auth, args);
-    else if (name === "relay_workspace_ready") result = relayWorkspaceMutation(auth, "ready", args);
-    else if (name === "relay_workspace_deps") result = relayWorkspaceMutation(auth, "deps-refresh", args);
-    else if (name === "relay_workspace_claim") result = relayWorkspaceMutation(auth, "claim", args);
-    else if (name === "relay_workspace_release") result = relayWorkspaceMutation(auth, "release-claim", args);
-    else if (name === "relay_workspace_land") result = relayWorkspaceMutation(auth, "merge", args);
+    else if (name === "relay_workspace_ready") result = await relayWorkspaceMutation(auth, "ready", args);
+    else if (name === "relay_workspace_deps") result = await relayWorkspaceMutation(auth, "deps-refresh", args);
+    else if (name === "relay_workspace_claim") result = await relayWorkspaceMutation(auth, "claim", args);
+    else if (name === "relay_workspace_release") result = await relayWorkspaceMutation(auth, "release-claim", args);
+    else if (name === "relay_workspace_land") result = await relayWorkspaceMutation(auth, "merge", args);
     else if (name.startsWith("relay_merge_")) result = relayMergeTool(auth, name, args); else if (name.startsWith("relay_team_")) result = await relayTeamTool(auth, name, args);
     else if (name.startsWith("relay_plan_")) result = relayPlanTool(auth, name, args);
     else if (name.startsWith("relay_task_memory_")) result = relayTaskMemoryTool(auth, name, args);

package/src/mcp/tools-workspace.ts

@@ -4,6 +4,7 @@ import { McpAuthError, McpNotFoundError } from "../mcp-errors";
 import { AUTO_MERGE_POLICIES } from "../workspace-merge";
 import { describeWorkspacePhase, landReceipt, readyContract } from "../workspace-phase";
 import { LAND_STRATEGIES, applyWorkspaceAction, waitForWorkspaceStatus, type WorkspaceAction } from "../workspace-actions";
+import { refreshWorkspaceGitState } from "../workspace-probe";
 import { optionalEnum } from "../validation";
 import type { Command, WorkspaceAutoMergePolicy, WorkspaceMergeStrategy, WorkspaceRecord } from "../types";
 import type { McpAuthContext, ToolDefinition } from "./types";
@@ -185,9 +186,13 @@ export function relayWorkspaceList(auth: McpAuthContext, args: Record<string, un
   return { workspaces, count: workspaces.length };
 }
 
-export function relayWorkspaceMutation(auth: McpAuthContext, action: WorkspaceAction, args: Record<string, unknown>): Record<string, unknown> {
-  const ws = resolveWorkspaceForCaller(auth, args);
-  const result = applyWorkspaceAction(ws, {
+export async function relayWorkspaceMutation(auth: McpAuthContext, action: WorkspaceAction, args: Record<string, unknown>): Promise<Record<string, unknown>> {
+  let ws = resolveWorkspaceForCaller(auth, args);
+  if (action === "ready" || action === "request-review") {
+    await refreshWorkspaceGitState(ws);
+    ws = getWorkspace(ws.id) ?? ws;
+  }
+  const result = await applyWorkspaceAction(ws, {
     action,
     agentId: callerAgentId(auth) ?? auth.actor,
     detail: optionalString(args.detail, "detail", 4000),

package/src/routes/orchestrator-proxy.ts

@@ -6,6 +6,7 @@ import { cleanStringArray } from "../validation";
 import { emitOrchestratorStatus } from "../sse";
 import { type OrchestratorRuntimeInput, type SpawnProvider } from "../types";
 import { relayToken } from "../config";
+import { isTerminalSessionRequestAuthorized } from "../terminal-authz";
 
 export const getOrchestratorDirectories: Handler = async (req, params) => {
   const orch = getOrchestrator(params.id!);
@@ -146,16 +147,16 @@ export const getOrchestratorLogs: Handler = (req, params) => {
 };
 
 export const getOrchestratorTerminal: Handler = (req, params) => {
-  const denied = authorizeRoute(req, { scope: "terminal:attach", resource: { orchestratorId: params.id!, terminalAttach: true } });
-  return denied ?? proxyOrchestratorGet(req, params.id!, `/api/terminal/${encodeURIComponent(params.session!)}`);
+  if (!isTerminalSessionRequestAuthorized(req, params.id!, params.session!, "read")) return error("forbidden", 403);
+  return proxyOrchestratorGet(req, params.id!, `/api/terminal/${encodeURIComponent(params.session!)}`);
 };
 
 export const postOrchestratorTerminalInput: Handler = (req, params) => {
-  const denied = authorizeRoute(req, { scope: "terminal:attach", resource: { orchestratorId: params.id!, terminalAttach: true } });
-  return denied ?? proxyOrchestratorPost(req, params.id!, `/api/terminal/${encodeURIComponent(params.session!)}/input`);
+  if (!isTerminalSessionRequestAuthorized(req, params.id!, params.session!, "write")) return error("forbidden", 403);
+  return proxyOrchestratorPost(req, params.id!, `/api/terminal/${encodeURIComponent(params.session!)}/input`);
 };
 
 export const postOrchestratorTerminalResize: Handler = (req, params) => {
-  const denied = authorizeRoute(req, { scope: "terminal:attach", resource: { orchestratorId: params.id!, terminalAttach: true } });
-  return denied ?? proxyOrchestratorPost(req, params.id!, `/api/terminal/${encodeURIComponent(params.session!)}/resize`);
+  if (!isTerminalSessionRequestAuthorized(req, params.id!, params.session!, "read")) return error("forbidden", 403);
+  return proxyOrchestratorPost(req, params.id!, `/api/terminal/${encodeURIComponent(params.session!)}/resize`);
 };