agent-relay-server 0.39.0 → 0.41.0

package/src/db/continuation-archives.ts

@@ -0,0 +1,179 @@
+import { MAX_BODY_BYTES } from "../config";
+import { getContinuationEnvelope } from "./continuations.ts";
+import { getDb, ValidationError } from "./connection.ts";
+
+export interface ContinuationArchive {
+  id: number;
+  ref: string;
+  agentId: string;
+  generation: number;
+  segment: string;
+  createdAt: number;
+}
+
+export interface ContinuationArchiveSearchResult extends ContinuationArchive {
+  score: number | null;
+  searchMode: "fts5" | "like";
+}
+
+interface ContinuationArchiveRow {
+  id: number;
+  agent_id: string;
+  generation: number;
+  segment: string;
+  created_at: number;
+  score?: number | null;
+}
+
+const MAX_RECALL_LIMIT = 20;
+
+export function ensureContinuationArchiveSearchSchema(): void {
+  if (process.env.AGENT_RELAY_DISABLE_CONTINUATION_ARCHIVE_FTS === "1") return;
+  try {
+    getDb().query(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS continuation_archive_segments
+      USING fts5(segment, content='continuation_archives', content_rowid='id')
+    `).run();
+    getDb().query(`
+      CREATE TRIGGER IF NOT EXISTS continuation_archives_ai AFTER INSERT ON continuation_archives BEGIN
+        INSERT INTO continuation_archive_segments(rowid, segment) VALUES (new.id, new.segment);
+      END
+    `).run();
+    getDb().query(`
+      CREATE TRIGGER IF NOT EXISTS continuation_archives_ad AFTER DELETE ON continuation_archives BEGIN
+        INSERT INTO continuation_archive_segments(continuation_archive_segments, rowid, segment)
+        VALUES('delete', old.id, old.segment);
+      END
+    `).run();
+    getDb().query(`
+      CREATE TRIGGER IF NOT EXISTS continuation_archives_au AFTER UPDATE ON continuation_archives BEGIN
+        INSERT INTO continuation_archive_segments(continuation_archive_segments, rowid, segment)
+        VALUES('delete', old.id, old.segment);
+        INSERT INTO continuation_archive_segments(rowid, segment) VALUES (new.id, new.segment);
+      END
+    `).run();
+    getDb().query("INSERT INTO continuation_archive_segments(continuation_archive_segments) VALUES('rebuild')").run();
+  } catch {
+    // FTS5 is expected in bun:sqlite, but recall stays available through LIKE when
+    // a custom SQLite build omits it.
+  }
+}
+
+export function archiveContinuationSegment(input: {
+  agentId: string;
+  segment: string;
+  generation?: number;
+  now?: number;
+}): ContinuationArchive {
+  const agentId = input.agentId.trim();
+  if (!agentId) throw new ValidationError("agentId required");
+  const segment = input.segment.trim();
+  if (!segment) throw new ValidationError("segment required");
+  if (new TextEncoder().encode(segment).byteLength > MAX_BODY_BYTES) throw new ValidationError(`segment exceeds ${MAX_BODY_BYTES} bytes`);
+  const generation = input.generation ?? nextContinuationArchiveGeneration(agentId);
+  if (!Number.isSafeInteger(generation) || generation < 0) throw new ValidationError("generation must be a non-negative integer");
+  const createdAt = input.now ?? Date.now();
+  const info = getDb().query(`
+    INSERT INTO continuation_archives (agent_id, generation, segment, created_at)
+    VALUES (?, ?, ?, ?)
+  `).run(agentId, generation, segment, createdAt);
+  return getContinuationArchive(Number(info.lastInsertRowid))!;
+}
+
+export function getContinuationArchive(id: number): ContinuationArchive | null {
+  const row = getDb().query("SELECT * FROM continuation_archives WHERE id = ?").get(id) as ContinuationArchiveRow | undefined;
+  return row ? rowToArchive(row) : null;
+}
+
+export function searchContinuationArchives(input: {
+  agentId: string;
+  query: string;
+  limit?: number;
+}): ContinuationArchiveSearchResult[] {
+  const agentId = input.agentId.trim();
+  if (!agentId) throw new ValidationError("agentId required");
+  const query = input.query.trim();
+  if (!query) throw new ValidationError("query required");
+  const limit = clampLimit(input.limit);
+  const fts = ftsQuery(query);
+  if (continuationArchiveSearchMode() === "fts5" && fts) {
+    try {
+      const rows = getDb().query(`
+        SELECT a.*, bm25(continuation_archive_segments) AS score
+        FROM continuation_archive_segments
+        JOIN continuation_archives a ON a.id = continuation_archive_segments.rowid
+        WHERE continuation_archive_segments MATCH ? AND a.agent_id = ?
+        ORDER BY score ASC, a.created_at DESC, a.id DESC
+        LIMIT ?
+      `).all(fts, agentId, limit) as ContinuationArchiveRow[];
+      return rows.map((row) => ({ ...rowToArchive(row), score: row.score ?? null, searchMode: "fts5" as const }));
+    } catch {
+      // Bad MATCH syntax should not make recall fail; the LIKE fallback is less
+      // precise but deterministic.
+    }
+  }
+  return searchContinuationArchivesLike(agentId, query, limit);
+}
+
+export function continuationArchiveSearchMode(): "fts5" | "like" {
+  if (process.env.AGENT_RELAY_DISABLE_CONTINUATION_ARCHIVE_FTS === "1") return "like";
+  const row = getDb().query(`
+    SELECT 1 FROM sqlite_master
+    WHERE type = 'table' AND name = 'continuation_archive_segments'
+  `).get();
+  return row ? "fts5" : "like";
+}
+
+function nextContinuationArchiveGeneration(agentId: string): number {
+  const row = getDb().query(`
+    SELECT max(generation) AS generation FROM continuation_archives WHERE agent_id = ?
+  `).get(agentId) as { generation: number | null } | undefined;
+  const archiveGeneration = typeof row?.generation === "number" ? row.generation : 0;
+  const envelopeGeneration = getContinuationEnvelope(agentId)?.generation ?? 0;
+  return Math.max(archiveGeneration, envelopeGeneration) + 1;
+}
+
+function searchContinuationArchivesLike(agentId: string, query: string, limit: number): ContinuationArchiveSearchResult[] {
+  const terms = likeTerms(query);
+  if (terms.length === 0) return [];
+  const clauses = terms.map(() => "lower(segment) LIKE ? ESCAPE '\\'").join(" AND ");
+  const rows = getDb().query(`
+    SELECT *, NULL AS score FROM continuation_archives
+    WHERE agent_id = ? AND ${clauses}
+    ORDER BY created_at DESC, id DESC
+    LIMIT ?
+  `).all(agentId, ...terms.map((term) => `%${escapeLike(term)}%`), limit) as ContinuationArchiveRow[];
+  return rows.map((row) => ({ ...rowToArchive(row), score: null, searchMode: "like" as const }));
+}
+
+function clampLimit(value: number | undefined): number {
+  if (value === undefined) return 5;
+  if (!Number.isSafeInteger(value) || value <= 0) throw new ValidationError("limit must be a positive integer");
+  return Math.min(value, MAX_RECALL_LIMIT);
+}
+
+function ftsQuery(query: string): string {
+  return likeTerms(query)
+    .slice(0, 16)
+    .map((term) => `"${term.replace(/"/g, '""')}"`)
+    .join(" ");
+}
+
+function likeTerms(query: string): string[] {
+  return [...new Set((query.toLowerCase().match(/[\p{L}\p{N}_-]+/gu) ?? []).filter(Boolean))];
+}
+
+function escapeLike(value: string): string {
+  return value.replace(/[\\%_]/g, (match) => `\\${match}`);
+}
+
+function rowToArchive(row: ContinuationArchiveRow): ContinuationArchive {
+  return {
+    id: row.id,
+    ref: String(row.id),
+    agentId: row.agent_id,
+    generation: row.generation,
+    segment: row.segment,
+    createdAt: row.created_at,
+  };
+}

package/src/db/continuations.ts

@@ -0,0 +1,151 @@
+import { isRecord } from "agent-relay-sdk";
+import { parseJson } from "../utils";
+import { getDb, ValidationError } from "./connection.ts";
+import type { ContinuationBudget, ContinuationEnvelope, ContinuationLedgerEntry, SelfResumeConfig } from "../types";
+
+interface ContinuationRow {
+  agent_id: string;
+  objective: string;
+  generation: number;
+  ledger: string;
+  working_state: string;
+  archive_refs: string;
+  budget: string;
+  created_at: number;
+  updated_at: number;
+}
+
+export function getContinuationEnvelope(agentId: string): ContinuationEnvelope | null {
+  const row = getDb().query("SELECT * FROM agent_continuations WHERE agent_id = ?").get(agentId) as ContinuationRow | undefined;
+  return row ? rowToEnvelope(row) : null;
+}
+
+export function ensureContinuationEnvelope(input: {
+  agentId: string;
+  objective?: string;
+  config: SelfResumeConfig;
+  now?: number;
+}): ContinuationEnvelope {
+  const existing = getContinuationEnvelope(input.agentId);
+  if (existing) return existing;
+  const objective = input.objective;
+  if (!objective?.trim()) throw new ValidationError("objective required for first self-resume when no spawn prompt was recorded");
+  const now = input.now ?? Date.now();
+  const budget: ContinuationBudget = {
+    ...input.config.budget,
+    spent: { generations: 0, wallClockMs: 0, tokens: 0 },
+  };
+  getDb().query(`
+    INSERT INTO agent_continuations (agent_id, objective, generation, ledger, working_state, archive_refs, budget, created_at, updated_at)
+    VALUES (?, ?, 0, '[]', '', '[]', ?, ?, ?)
+  `).run(input.agentId, objective, JSON.stringify(budget), now, now);
+  return getContinuationEnvelope(input.agentId)!;
+}
+
+export function seedContinuationObjectiveFromSpawnPrompt(agentId: string, spawnRequestId: string | undefined, config: SelfResumeConfig, now = Date.now()): ContinuationEnvelope | null {
+  if (!spawnRequestId || getContinuationEnvelope(agentId)) return getContinuationEnvelope(agentId);
+  const row = getDb().query(`
+    SELECT params FROM commands
+    WHERE type = 'agent.spawn' AND correlation_id = ?
+    ORDER BY created_at DESC
+    LIMIT 1
+  `).get(spawnRequestId) as { params: string } | undefined;
+  const params = row ? parseJson<unknown>(row.params, {}) : {};
+  if (!isRecord(params) || typeof params.prompt !== "string" || !params.prompt.trim()) return null;
+  return ensureContinuationEnvelope({ agentId, objective: params.prompt, config, now });
+}
+
+export function updateContinuationAfterCompact(input: {
+  agentId: string;
+  generation: number;
+  ledgerEntries: ContinuationLedgerEntry[];
+  workingState: string;
+  archiveRefs?: string[];
+  spentTokens: number;
+  now?: number;
+}): ContinuationEnvelope {
+  const existing = getContinuationEnvelope(input.agentId);
+  if (!existing) throw new ValidationError("continuation envelope not found");
+  const now = input.now ?? Date.now();
+  const nextBudget: ContinuationBudget = {
+    ...existing.budget,
+    spent: {
+      generations: input.generation,
+      wallClockMs: Math.max(0, now - existing.createdAt),
+      tokens: existing.budget.spent.tokens + Math.max(0, input.spentTokens),
+    },
+  };
+  getDb().query(`
+    UPDATE agent_continuations
+    SET generation = ?, ledger = ?, working_state = ?, archive_refs = ?, budget = ?, updated_at = ?
+    WHERE agent_id = ?
+  `).run(
+    input.generation,
+    JSON.stringify([...existing.ledger, ...input.ledgerEntries]),
+    input.workingState,
+    JSON.stringify([...existing.archiveRefs, ...(input.archiveRefs ?? [])]),
+    JSON.stringify(nextBudget),
+    now,
+    input.agentId,
+  );
+  return getContinuationEnvelope(input.agentId)!;
+}
+
+export function appendContinuationArchiveRefs(agentId: string, archiveRefs: string[]): ContinuationEnvelope | null {
+  if (archiveRefs.length === 0) return getContinuationEnvelope(agentId);
+  const existing = getContinuationEnvelope(agentId);
+  if (!existing) return null;
+  const refs = [...existing.archiveRefs];
+  for (const ref of archiveRefs) {
+    if (!refs.includes(ref)) refs.push(ref);
+  }
+  getDb().query(`
+    UPDATE agent_continuations
+    SET archive_refs = ?, updated_at = ?
+    WHERE agent_id = ?
+  `).run(JSON.stringify(refs), Date.now(), agentId);
+  return getContinuationEnvelope(agentId);
+}
+
+function rowToEnvelope(row: ContinuationRow): ContinuationEnvelope {
+  return {
+    agentId: row.agent_id,
+    objective: row.objective,
+    generation: row.generation,
+    ledger: parseJson<ContinuationLedgerEntry[]>(row.ledger, []).filter(isLedgerEntry),
+    workingState: row.working_state,
+    archiveRefs: parseJson<string[]>(row.archive_refs, []).filter((value): value is string => typeof value === "string"),
+    budget: parseBudget(row.budget),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+function parseBudget(raw: string): ContinuationBudget {
+  const parsed = parseJson<unknown>(raw, null);
+  if (!isRecord(parsed) || !isRecord(parsed.spent)) {
+    return { maxGenerations: 1, maxWallClockMs: 1, maxTokens: 1, spent: { generations: 0, wallClockMs: 0, tokens: 0 } };
+  }
+  return {
+    maxGenerations: numberValue(parsed.maxGenerations),
+    maxWallClockMs: numberValue(parsed.maxWallClockMs),
+    maxTokens: numberValue(parsed.maxTokens),
+    spent: {
+      generations: numberValue(parsed.spent.generations),
+      wallClockMs: numberValue(parsed.spent.wallClockMs),
+      tokens: numberValue(parsed.spent.tokens),
+    },
+  };
+}
+
+function isLedgerEntry(value: unknown): value is ContinuationLedgerEntry {
+  return isRecord(value)
+    && typeof value.gen === "number"
+    && typeof value.ruledOut === "string"
+    && typeof value.why === "string"
+    && typeof value.at === "number";
+}
+
+function numberValue(value: unknown): number {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}

package/src/db/index.ts

@@ -21,3 +21,5 @@ export * from "./stats.ts";
 export * from "./orchestrators.ts";
 export * from "./workspaces.ts";
 export * from "./merge-lease.ts";
+export * from "./continuations.ts";
+export * from "./continuation-archives.ts";

package/src/db/messages.ts

@@ -90,6 +90,34 @@ export function findMessageByIdempotencyKey(from: string, key: string): Message
   return row ? rowToMessage(row) : null;
 }
 
+function sessionStepId(payload: Record<string, unknown> | undefined): string | undefined {
+  const session = isRecord(payload?.session) ? payload.session : undefined;
+  return stringValue(session?.stepId);
+}
+
+/**
+ * Codex session-mirror upsert (#parity): a provider step that emits more than once — a
+ * tool's running→completed lifecycle, a reasoning/response row that streams — carries a
+ * stable `payload.session.stepId`. Instead of appending a second row (which renders as a
+ * duplicate on dashboard reload), update the EXISTING row in place: same DB id, so the
+ * dashboard's id-keyed merge replaces it. Gated on stepId presence + matching step, so the
+ * Claude transcript path (no stepId) is byte-identical. Newer-event-wins via occurredAt so a
+ * late retry of an earlier lifecycle phase can't clobber a later one.
+ */
+function upsertSessionStepInPlace(existing: Message, input: SendMessageInput, now: number): Message | null {
+  const incomingStep = sessionStepId(input.payload);
+  if (!incomingStep) return null;
+  if (existing.kind !== "session") return null;
+  if (sessionStepId(existing.payload) !== incomingStep) return null;
+  const incomingAt = sanitizeOccurredAt(input.occurredAt, now) ?? now;
+  const existingAt = existing.occurredAt ?? existing.createdAt;
+  if (incomingAt < existingAt) return null; // stale lifecycle phase — keep the newer row, no re-emit
+  getDb()
+    .query("UPDATE messages SET body = ?, payload = ?, occurred_at = ? WHERE id = ?")
+    .run(input.body, JSON.stringify(input.payload ?? {}), incomingAt, existing.id);
+  return getMessage(existing.id);
+}
+
 export function policyNameFromTarget(target: string): string | null {
   if (!target.startsWith("policy:")) return null;
   const name = target.slice("policy:".length).trim();
@@ -169,7 +197,7 @@ export function sanitizeOccurredAt(occurredAt: number | undefined, receivedAt: n
   return Math.floor(occurredAt);
 }
 
-export function sendMessageWithResult(input: SendMessageInput): { message: Message; created: boolean } {
+export function sendMessageWithResult(input: SendMessageInput): { message: Message; created: boolean; updated?: boolean } {
   const now = Date.now();
   const payload = input.payload ?? {};
   const attachmentRefs = cleanAttachmentRefs(payload);
@@ -181,7 +209,13 @@ export function sendMessageWithResult(input: SendMessageInput): { message: Messa
 
   if (input.idempotencyKey) {
     const existing = findMessageByIdempotencyKey(input.from, input.idempotencyKey);
-    if (existing) return { message: existing, created: false };
+    if (existing) {
+      // Session-step upsert: a re-emitted provider step (tool running→completed, streamed
+      // reasoning/response) updates its row in place instead of being dropped as a dup retry.
+      const upserted = upsertSessionStepInPlace(existing, input, now);
+      if (upserted) return { message: upserted, created: false, updated: true };
+      return { message: existing, created: false };
+    }
   }
 
   // Resolve thread: if replying, inherit from parent; reject unknown replyTo

package/src/db/migrations.ts

@@ -15,6 +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 { getDb } from "./connection.ts";
+import { ensureContinuationArchiveSearchSchema } from "./continuation-archives.ts";
 import { normalizeReactionEmoji } from "./mappers.ts";
 import type {
   AgentCard,
@@ -176,6 +177,34 @@ export function applyMigrations(): void {
   getDb().run("CREATE INDEX IF NOT EXISTS idx_msg_delivery_status ON messages(delivery_status)");
   getDb().run("CREATE INDEX IF NOT EXISTS idx_msg_resolved_to_agent ON messages(resolved_to_agent)");
 
+  getDb().run(`
+    CREATE TABLE IF NOT EXISTS agent_continuations (
+      agent_id TEXT PRIMARY KEY REFERENCES agents(id) ON DELETE CASCADE,
+      objective TEXT NOT NULL,
+      generation INTEGER NOT NULL DEFAULT 0,
+      ledger TEXT NOT NULL DEFAULT '[]',
+      working_state TEXT NOT NULL DEFAULT '',
+      archive_refs TEXT NOT NULL DEFAULT '[]',
+      budget TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  getDb().run(`
+    CREATE TABLE IF NOT EXISTS continuation_archives (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+      generation INTEGER NOT NULL,
+      segment TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    )
+  `);
+  getDb().run(`
+    CREATE INDEX IF NOT EXISTS idx_continuation_archives_agent_generation
+    ON continuation_archives(agent_id, generation, created_at DESC)
+  `);
+  ensureContinuationArchiveSearchSchema();
+
   const tokenCols = getDb().query("PRAGMA table_info(tokens)").all() as any[];
   const tokenColNames = tokenCols.map((c: any) => c.name);
   if (!tokenColNames.includes("constraints")) {
@@ -245,6 +274,11 @@ export function applyMigrations(): void {
   }
   getDb().run("CREATE INDEX IF NOT EXISTS idx_msg_kind ON messages(kind)");
   getDb().run("CREATE INDEX IF NOT EXISTS idx_msg_from_kind_id ON messages(from_agent, kind, id)");
+  // (from_agent, idempotency_key) powers findMessageByIdempotencyKey — the retry-dedup lookup
+  // AND the session-step in-place upsert (Codex tool running→completed / streamed reasoning),
+  // which runs per persisted session step. Added here (not the base schema) because the column
+  // is migration-added for pre-hardening DBs. Without it that lookup full-scans messages.
+  getDb().run("CREATE INDEX IF NOT EXISTS idx_msg_idempotency ON messages(from_agent, idempotency_key)");
 
   // Backfill thread_id for pre-migration rows (self-threaded).
   getDb().run("UPDATE messages SET thread_id = id WHERE thread_id IS NULL");

package/src/db/schema.ts

@@ -15,6 +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 { applyConnectionPragmas, getDb, setDb } from "./connection.ts";
+import { ensureContinuationArchiveSearchSchema } from "./continuation-archives.ts";
 import { applyMigrations } from "./migrations.ts";
 import type {
   AgentCard,
@@ -174,6 +175,28 @@ export function initDb(path: string = "agent-relay.db"): Database {
     );
     CREATE INDEX IF NOT EXISTS idx_context_snapshots_agent_time ON context_snapshots(agent_id, captured_at DESC);
 
+    CREATE TABLE IF NOT EXISTS agent_continuations (
+      agent_id TEXT PRIMARY KEY REFERENCES agents(id) ON DELETE CASCADE,
+      objective TEXT NOT NULL,
+      generation INTEGER NOT NULL DEFAULT 0,
+      ledger TEXT NOT NULL DEFAULT '[]',
+      working_state TEXT NOT NULL DEFAULT '',
+      archive_refs TEXT NOT NULL DEFAULT '[]',
+      budget TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS continuation_archives (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+      generation INTEGER NOT NULL,
+      segment TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_continuation_archives_agent_generation
+      ON continuation_archives(agent_id, generation, created_at DESC);
+
     CREATE TABLE IF NOT EXISTS memories (
       id TEXT PRIMARY KEY,
       type TEXT NOT NULL,
@@ -743,6 +766,7 @@ export function initDb(path: string = "agent-relay.db"): Database {
     CREATE INDEX IF NOT EXISTS idx_insights_obs_session ON insights_observations(session_id);
   `);
 
+  ensureContinuationArchiveSearchSchema();
   applyMigrations();
 
   // Bootstrap planner statistics on first run (sqlite_stat1 absent means ANALYZE

package/src/lifecycle-manager.ts

@@ -9,6 +9,7 @@ import {
   upsertManagedAgentState,
 } from "./config-store";
 import { emitRelayEvent } from "./events";
+import { handleContextPressure } from "./context-advisory";
 import { markManagedAgentRunning, emitManagedState } from "./services/managed-running";
 import { authContextFromSystem } from "./services/auth-context";
 import { emitCommandEvent } from "./command-events";
@@ -25,7 +26,6 @@ const STOP_TIMEOUT_MS = 60_000;
 const FAST_FAIL_RUNTIME_MS = 30_000;
 const MAX_FAST_FAILURES = 3;
 const DAY_MS = 24 * 60 * 60 * 1000;
-const DEFAULT_COMPACT_THRESHOLD = 0.75;
 const DEFAULT_COMPACT_TARGET = 0.3;
 const DEFAULT_MAX_TASKS_BEFORE_COMPACT = 10;
 const DEFAULT_COMPACT_COOLDOWN_MS = 60_000;
@@ -354,6 +354,7 @@ export class LifecycleManager {
         this.stopAgent(policy, true, "idle-timeout");
         return;
       }
+      if (handleContextPressure({ agent, now: this.now, hasActiveCommand: (target, type) => this.hasActiveCommand(target, type), compact: (reason) => this.compactAgent(policy, agent.id, reason, alwaysReloadTags(agent.tags)) })) return;
       if (this.shouldCompact(agent)) {
         this.compactAgent(policy, agent.id, "context-threshold", alwaysReloadTags(agent.tags));
         return;
@@ -524,7 +525,6 @@ export class LifecycleManager {
     if (agent.providerCapabilities?.context?.compact !== true) return false;
     if (this.hasActiveCommand(agent.id, "agent.compact")) return false;
 
-    if (context.utilization > DEFAULT_COMPACT_THRESHOLD) return true;
     if (context.tasksSinceCompact > DEFAULT_MAX_TASKS_BEFORE_COMPACT) return true;
     return context.lifecycleState === "cooling" &&
       this.now() - context.lastUpdatedAt >= DEFAULT_COMPACT_COOLDOWN_MS &&

package/src/maintenance.ts

@@ -34,7 +34,8 @@ import {
 import type { WorkspaceMergePreview, WorkspaceRecord, WorkspaceStatus } from "./types";
 import { requestWorkspaceMerge } from "./workspace-merge";
 import { reconcileLandedWorkspace } from "./branch-landed";
-import { handleReviewerPipelineScan, isAwaitingReviewerApproval } from "./reviewer-pipeline";
+import { isAwaitingReviewerApproval } from "./reviewer-pipeline";
+import { preparePrCompletionScan } from "./workspace-pr-completion";
 import { notifyAgentOffline } from "./agent-lifecycle-events";
 import { workspaceActiveClaim } from "./workspace-claim";
 import { reapOrphanedWorktrees } from "./workspace-orphans";
@@ -578,12 +579,8 @@ async function scanWorkspaceConflicts(): Promise<Record<string, unknown>> {
   const candidates = listWorkspaces().filter(
     (ws) => ws.mode === "isolated" && Boolean(ws.worktreePath) && CONFLICT_SCAN_STATUSES.has(ws.status),
   );
-  const flagged: string[] = [];
-  const cleared: string[] = [];
-  const merged: string[] = [];
-  const notifiedStewards: string[] = [];
-  const reviewerArmed: string[] = [];
-  const reviewerChangesRequested: string[] = [];
+  const flagged: string[] = [], cleared: string[] = [], merged: string[] = [], notifiedStewards: string[] = [];
+  const reviewerArmed: string[] = [], reviewerChangesRequested: string[] = [], relayPrMerged: string[] = [], relayPrWaiting: string[] = [];
 
   for (const ws of candidates) {
     const orch = orchestrators.find((candidate) => workspacePathWithinBase(ws.sourceCwd, candidate.baseDir));
@@ -621,15 +618,12 @@ async function scanWorkspaceConflicts(): Promise<Record<string, unknown>> {
       continue;
     }
 
-    if (isAwaitingReviewerApproval(ws)) {
-      const action = handleReviewerPipelineScan(ws, p, orch.agentId);
-      if (action.armCommand) {
-        emitCommand(action.armCommand);
-        reviewerArmed.push(ws.id);
-      }
-      if (action.notifiedOwner) reviewerChangesRequested.push(ws.id);
-      continue;
-    }
+    const prAction = preparePrCompletionScan(ws, p, orch.agentId);
+    if (prAction.armCommand) { emitCommand(prAction.armCommand); reviewerArmed.push(ws.id); continue; }
+    if (prAction.notifiedOwner) { reviewerChangesRequested.push(ws.id); continue; }
+    if (prAction.mergeCommand) { emitCommand(prAction.mergeCommand); relayPrMerged.push(ws.id); continue; }
+    if (prAction.waitReason) relayPrWaiting.push(`${ws.id}:${prAction.waitReason}`);
+    if (prAction.stop) continue;
 
     // Past here we act on the conflict signal — skip when the host couldn't assess it
     // (undefined): never flag/clear a conflict on incomplete data.
@@ -684,7 +678,7 @@ async function scanWorkspaceConflicts(): Promise<Record<string, unknown>> {
     }
   }
 
-  return { scanned: candidates.length, flagged, cleared, merged, notifiedStewards, reviewerArmed, reviewerChangesRequested };
+  return { scanned: candidates.length, flagged, cleared, merged, notifiedStewards, reviewerArmed, reviewerChangesRequested, relayPrMerged, relayPrWaiting };
 }
 
 // Deterministic auto-land (Layer 0, #167/#207/#242): land conflict-free ready