@humwick/server 0.130.2 → 0.130.3

package/src/db/plans-write-ops.ts

@@ -1,7 +1,9 @@
 import { createPlanRow, deletePlan, replacePlanIfVersion, setPlanArchived } from "./plans.ts";
+import { PLAN_READY_NOTICE_WRITE_OPS } from "./plan-ready-notices.ts";
 import type { WriterOpContext, WriterOpSpec } from "./write-ops.ts";
 
 export const PLANS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
+  ...PLAN_READY_NOTICE_WRITE_OPS,
   "plans.create": { offLoop: true, idempotent: false, fn: (args: { input: Parameters<typeof createPlanRow>[0] }, ctx: WriterOpContext) => createPlanRow(args.input, ctx.now) },
   "plans.replace": { offLoop: true, idempotent: false, fn: (args: { input: Parameters<typeof replacePlanIfVersion>[0]; changedBy?: string }, ctx: WriterOpContext) => replacePlanIfVersion(args.input, args.changedBy, ctx.now, false) },
   "plans.setArchived": { offLoop: true, idempotent: true, fn: (args: { id: string; archived: boolean }, ctx: WriterOpContext) => setPlanArchived(args.id, args.archived, ctx.now) },

package/src/db/presence-buffer.ts

@@ -104,6 +104,11 @@ export function snapshotBufferedPresence(): PresenceSnapshot {
  *  current, and the caller's surrounding status/ready predicates constrain the match. */
 export function bufferedLiveAgentIds(cutoff: number): string[] {
   const ids: string[] = [];
+  const snapshot = writerPresenceSnapshot();
+  if (snapshot) {
+    for (const beat of snapshot) if (beat.lastSeen > cutoff) ids.push(beat.id);
+    return ids;
+  }
   for (const [id, pending] of pendingPresence) {
     if (pending.lastSeen > cutoff) ids.push(id);
   }

package/src/db/presence-loop.ts

@@ -1,3 +1,4 @@
+import { framed } from "../hub-metrics";
 import { assertMainThreadState } from "./main-thread-state";
 // Lifecycle glue for the coalesced presence buffer. Kept outside agents.ts so its writer-op body
 // never depends on the gateway-facing facade (ADR 0001 §3.1).
@@ -6,53 +7,47 @@ import { errMessage } from "@humwick/sdk";
 import { PRESENCE_FLUSH_MS } from "../config";
 import { drainPendingLandSettleSideEffects } from "../land-settle-dispatch";
 import { onShutdown } from "../shutdown";
-import { flushPresence } from "./agents.ts";
+import { flushPresenceAsync } from "./presence-write.ts";
 import { pendingPresence } from "./presence-buffer.ts";
 
 let presenceFlushTimer: ReturnType<typeof setInterval> | undefined;
-let asyncPresenceFlusher: (() => Promise<{ flushed: number }>) | undefined;
 let removeShutdownHook: (() => void) | undefined;
 
-/** Attach the gateway-backed normal-tick flusher without importing the gateway into agents.ts. */
-export function setAsyncPresenceFlusher(flusher: () => Promise<{ flushed: number }>): void {
-  assertMainThreadState("presence-loop.ts");
-  asyncPresenceFlusher = flusher;
-}
-
 /** Start the periodic presence-buffer flush loop (server boot). */
 export function startPresenceFlushLoop(intervalMs: number = PRESENCE_FLUSH_MS): void {
   assertMainThreadState("presence-loop.ts");
   if (presenceFlushTimer) return;
-  presenceFlushTimer = setInterval(() => {
-    const flush = asyncPresenceFlusher;
-    if (!flush) return flushPresenceQuietly(); // Bootstrap/isolated compatibility fallback.
-    void flush().catch((err) => console.warn(`[presence] flush failed: ${errMessage(err)}`));
-  }, intervalMs);
+  presenceFlushTimer = setInterval(framed("timer presence-flush", () =>
+    flushPresenceAsync().catch((err) => console.warn(`[presence] flush failed: ${errMessage(err)}`))), intervalMs);
   presenceFlushTimer.unref?.();
-  process.once("beforeExit", flushPresenceQuietly);
-  removeShutdownHook = onShutdown("presence", () => {
-    drainPendingLandSettleSideEffects();
-    stopPresenceFlushLoop();
+  process.once("beforeExit", flushPresenceBeforeExit);
+  removeShutdownHook = onShutdown("presence", async () => {
+    await drainPendingLandSettleSideEffects();
+    await stopPresenceFlushLoop();
   });
 }
 
 /** Stop the loop and persist whatever is buffered (graceful shutdown / test teardown). */
-export function stopPresenceFlushLoop(): void {
+function detachPresenceLoop(): void {
   assertMainThreadState("presence-loop.ts");
   removeShutdownHook?.();
   removeShutdownHook = undefined;
-  process.removeListener("beforeExit", flushPresenceQuietly);
+  process.removeListener("beforeExit", flushPresenceBeforeExit);
   if (presenceFlushTimer) clearInterval(presenceFlushTimer);
   presenceFlushTimer = undefined;
-  flushPresenceQuietly();
 }
 
-function flushPresenceQuietly(): void {
-  try { flushPresence(); } catch (err) { console.warn(`[presence] flush failed: ${errMessage(err)}`); }
+export async function stopPresenceFlushLoop(): Promise<void> {
+  detachPresenceLoop();
+  await flushPresenceAsync();
+}
+
+function flushPresenceBeforeExit(): void {
+  void flushPresenceAsync().catch(err => console.warn(`[presence] flush failed: ${errMessage(err)}`));
 }
 
 /** Test-only: drop the buffered presence and stop the flush loop. */
 export function resetPresenceBufferForTests(): void {
   pendingPresence.clear();
-  stopPresenceFlushLoop();
+  detachPresenceLoop();
 }

package/src/db/presence-write.ts

@@ -3,7 +3,6 @@ import { assertMainThreadState } from "./main-thread-state";
 // Kept outside agents.ts because the writer registry imports the op body from that module; importing
 // the gateway there would make the writer-stack cycle gateway → write-ops → agents → gateway.
 
-import { setAsyncPresenceFlusher } from "./presence-loop.ts";
 import { settlePendingPresenceFlush, snapshotPendingPresenceFlush, type PresenceFlushPayload } from "./presence-buffer.ts";
 import { getGateway } from "./gateway.ts";
 
@@ -31,8 +30,3 @@ export function flushPresenceAsync(now: number = Date.now()): Promise<{ flushed:
     .finally(() => { activeFlush = undefined; });
   return activeFlush;
 }
-
-// The timer remains owned by presence-loop.ts for its synchronous shutdown guarantee, while normal ticks
-// arrive here through an injected callback. This direction deliberately avoids a writer-op → gateway
-// dependency cycle; the callback carries no DB closure across the worker seam.
-setAsyncPresenceFlusher(flushPresenceAsync);

package/src/db/project-entries-async.ts

@@ -1,3 +1,5 @@
+import { randomUUID } from "node:crypto";
+import type { writeProjectEntry, promoteBlackboardEntry } from "./project-entries";
 // Async project-entries facades (T4060 hub on-loop). Kept outside
 // project-entries.ts to avoid a gateway cycle.
 import { getGateway } from "./gateway.ts";
@@ -16,3 +18,15 @@ export const searchProjectEntriesAsync = (
   query: string,
   opts: ProjectEntrySearchOptions = {},
 ): Promise<ProjectEntrySearchResult[]> => read("projectEntries.search", { projectId, query, ...opts });
+
+export const getProjectEntryAsync = (id: string): Promise<ProjectEntry | null> => read("projectEntries.get", { id });
+export const getProjectEntryChainAsync = (id: string): Promise<ProjectEntry[]> => read("projectEntries.chain", { id });
+export const listActiveEntriesInAreaAsync = (projectId: string, area: string): Promise<ProjectEntry[]> => read("projectEntries.inArea", { projectId, area });
+export const countActivePinnedEntriesInAreaAsync = (projectId: string, area: string): Promise<number> => read("projectEntries.countPinnedInArea", { projectId, area });
+
+export const writeProjectEntryAsync = (input: Parameters<typeof writeProjectEntry>[0], requestId: string = randomUUID()): Promise<ProjectEntry> =>
+  getGateway().write("projectEntries.write", input, { idempotencyKey: requestId }) as unknown as Promise<ProjectEntry>;
+export const retractProjectEntryAsync = (id: string): Promise<ProjectEntry | null> =>
+  getGateway().write("projectEntries.retract", { id }) as unknown as Promise<ProjectEntry | null>;
+export const promoteBlackboardEntryAsync = (input: Parameters<typeof promoteBlackboardEntry>[0], requestId: string = randomUUID()): Promise<ProjectEntry> =>
+  getGateway().write("projectEntries.promoteBlackboard", input, { idempotencyKey: requestId }) as unknown as Promise<ProjectEntry>;

package/src/db/project-entries-read-ops.ts

@@ -1,10 +1,14 @@
 // Project-entries reader operations (T4060 hub on-loop). The MCP memory/project
 // read tools ran these scans synchronously on the event loop — including the
 // temp-B-TREE display ORDER BY over cells whose rows are ~95% retracted.
-import { listProjectEntries, searchProjectEntries } from "./project-entries.ts";
+import { countActivePinnedEntriesInArea, getProjectEntry, getProjectEntryChain, listActiveEntriesInArea, listProjectEntries, searchProjectEntries } from "./project-entries.ts";
 import type { ProjectEntryKind, ProjectEntryStatus, ProjectEntrySearchOptions } from "../types";
 
 export const PROJECT_ENTRIES_READ_OPS = {
+  "projectEntries.get": (args: { id: string }) => getProjectEntry(args.id),
+  "projectEntries.chain": (args: { id: string }) => getProjectEntryChain(args.id),
+  "projectEntries.inArea": (args: { projectId: string; area: string }) => listActiveEntriesInArea(args.projectId, args.area),
+  "projectEntries.countPinnedInArea": (args: { projectId: string; area: string }) => countActivePinnedEntriesInArea(args.projectId, args.area),
   "projectEntries.list": (args: {
     projectId: string;
     kind?: ProjectEntryKind;

package/src/db/project-entries-write-ops.ts

@@ -0,0 +1,8 @@
+import { promoteBlackboardEntry, retractProjectEntry, writeProjectEntry } from "./project-entries";
+import type { WriterOpSpec } from "./write-ops";
+
+export const PROJECT_ENTRIES_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = {
+  "projectEntries.write": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof writeProjectEntry>[0], ctx) => writeProjectEntry(args, ctx.now) },
+  "projectEntries.retract": { offLoop: true, idempotent: true, fn: (args: { id: string }, ctx) => retractProjectEntry(args.id, ctx.now) },
+  "projectEntries.promoteBlackboard": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof promoteBlackboardEntry>[0], ctx) => promoteBlackboardEntry(args, ctx.now) },
+};

package/src/db/project-entries.ts

@@ -1,7 +1,7 @@
 import { isolateMemoryEntry } from "../memory-entry-safety";
 import { validateProjectEntryText } from "../validation";
 import { randomUUID } from "node:crypto";
-import { getDb, writeTransaction, ValidationError } from "./connection.ts";
+import { getDb, inWriteTransaction, ValidationError } from "./connection.ts";
 import { getEntry as getBlackboardEntry, listEntries as listBlackboardEntries } from "./blackboard.ts";
 import { parseJson } from "../utils";
 import {
@@ -211,7 +211,7 @@ function assertProjectKnowledge(projectId: string): void {
   }
 }
 
-export function writeProjectEntry(input: WriteProjectEntryInput): ProjectEntry {
+export function writeProjectEntry(input: WriteProjectEntryInput, now: number = Date.now()): ProjectEntry {
   validateProjectEntryText(input);
   assertProjectKnowledge(input.projectId);
   assertKind(input.kind);
@@ -234,8 +234,7 @@ export function writeProjectEntry(input: WriteProjectEntryInput): ProjectEntry {
     supersedes = latestEntryByTitle(input.projectId, input.kind, input.title)?.id;
   }
   const id = projectEntryId();
-  const now = Date.now();
-  writeTransaction(() => {
+  inWriteTransaction(() => {
     let inheritedAreas: string[] | null = null;
     if (supersedes) {
       const previous = getProjectEntry(supersedes);
@@ -404,21 +403,25 @@ export function countActivePinnedEntriesInArea(projectId: string, area: string):
 }
 
 /** #3410 — active entries of one cell that name `area`, newest first. Same index as the count above. */
-export function listActiveEntriesInArea(projectId: string, area: string): ProjectEntry[] {
-  const rows = getDb().query(`
+export function buildActiveEntriesInAreaQuery(projectId: string, area: string): { sql: string; params: string[] } {
+  return { sql: `
     SELECT * FROM project_entries
     WHERE project_id = ? AND status = 'active' AND areas LIKE ? ESCAPE '\\'
     ORDER BY updated_at DESC, created_at DESC, id DESC
-  `).all(projectId, `%${escapeLike(JSON.stringify(area))}%`) as ProjectEntryRow[];
-  return rows.map(rowToEntry);
+  `, params: [projectId, `%${escapeLike(JSON.stringify(area))}%`] };
 }
 
-export function retractProjectEntry(id: string): ProjectEntry | null {
+export function listActiveEntriesInArea(projectId: string, area: string): ProjectEntry[] {
+  const { sql, params } = buildActiveEntriesInAreaQuery(projectId, area);
+  return (getDb().query(sql).all(...params) as ProjectEntryRow[]).map(rowToEntry);
+}
+
+export function retractProjectEntry(id: string, now: number = Date.now()): ProjectEntry | null {
   const existing = getProjectEntry(id);
   if (!existing) return null;
   assertStatus("retracted");
   getDb().query("UPDATE project_entries SET status = 'retracted', updated_at = ? WHERE id = ?")
-    .run(Date.now(), id);
+    .run(now, id);
   return getProjectEntry(id);
 }
 
@@ -472,7 +475,7 @@ function activePromotedEntry(projectId: string, originRef: string): ProjectEntry
  * project supersedes the prior promoted copy rather than duplicating it, so the durable
  * ledger holds at most one active entry per promoted finding while keeping the full
  * supersede chain for audit. */
-export function promoteBlackboardEntry(input: PromoteBlackboardEntryInput): ProjectEntry {
+export function promoteBlackboardEntry(input: PromoteBlackboardEntryInput, now: number = Date.now()): ProjectEntry {
   const source = getBlackboardEntry(input.blackboardEntryId);
   if (!source) throw new ValidationError(`blackboard entry ${input.blackboardEntryId} not found`);
   if (source.status !== "active") {
@@ -489,7 +492,7 @@ export function promoteBlackboardEntry(input: PromoteBlackboardEntryInput): Proj
     source: "promoted",
     originRef: source.id,
     ...(existing ? { supersedes: existing.id } : {}),
-  });
+  }, now);
 }
 
 export interface UnpromotedBlackboardSummary {

package/src/db/project-journal.ts

@@ -203,7 +203,7 @@ export function setProjectJournalFields(input: {
   fields: Record<string, string | null>;
   changedBy: string;
   now?: number;
-}): ProjectJournalFieldChange[] {
+}, submittedAt: number = Date.now()): ProjectJournalFieldChange[] {
   const entries = Object.entries(input.fields);
   if (!entries.length) throw new ValidationError("fields must name at least one journal field");
   const plan: Array<{ field: ProjectJournalField; value: string | null; previous: string | null }> = [];
@@ -222,7 +222,7 @@ export function setProjectJournalFields(input: {
     plan.push({ field, value: value === "" ? null : value, previous });
   }
 
-  const now = input.now ?? Date.now();
+  const now = input.now ?? submittedAt;
   const changes: ProjectJournalFieldChange[] = [];
   writeTransaction(() => {
     for (const { field, value, previous } of plan) {

package/src/db/project-trust-approvals.ts

@@ -68,9 +68,9 @@ export interface UpsertProjectTrustApprovalInput {
 /** Records `approvedValue` as the trusted content for this (profile, repo, capability), replacing
  * any prior approval — used both by the operator-triggered dashboard approve action and by the
  * gate's own grandfather-on-first-encounter path (decision #4). */
-export function upsertProjectTrustApproval(input: UpsertProjectTrustApprovalInput): ProjectTrustApproval {
+export function upsertProjectTrustApproval(input: UpsertProjectTrustApprovalInput, submittedAt: number = Date.now()): ProjectTrustApproval {
   return writeTransaction(() => {
-    const now = Date.now();
+    const now = submittedAt;
     const existing = getDb().query(`
       SELECT id FROM project_trust_approvals WHERE profile_name = ? AND repo_key = ? AND capability = ?
     `).get(input.profileName, input.repoKey, input.capability) as { id: string } | null;

package/src/db/prompt-templates.ts

@@ -74,8 +74,8 @@ export function listTemplates(category?: string): PromptTemplateRecord[] {
   return templates;
 }
 
-export function upsertTemplate(slug: string, template: string): void {
-  const now = Date.now();
+export function upsertTemplate(slug: string, template: string, submittedAt: number = Date.now()): void {
+  const now = submittedAt;
   if (versionedPromptSlot(slug)) {
     throw new ValidationError("Use the versioned prompt writer with expectedVersion and actor");
   }
@@ -83,11 +83,11 @@ export function upsertTemplate(slug: string, template: string): void {
   if ((result.changes ?? 0) === 0) throw new ValidationError(`prompt template ${slug} not found`);
 }
 
-export function resetTemplate(slug: string): void {
+export function resetTemplate(slug: string, submittedAt: number = Date.now()): void {
   if (versionedPromptSlot(slug)) {
     throw new ValidationError("Use the versioned prompt writer with expectedVersion and actor");
   }
-  const now = Date.now();
+  const now = submittedAt;
   const result = getDb().query("UPDATE prompt_templates SET template = default_template, updated_at = ? WHERE slug = ?").run(now, slug);
   if ((result.changes ?? 0) === 0) throw new ValidationError(`prompt template ${slug} not found`);
 }

package/src/db/read-op-marshaling-fixtures.ts

@@ -191,6 +191,16 @@ export const READ_OP_MARSHALING_FIXTURES: ReadOpFixtures = {
   "projects.resolveEntries": { args: { projectId: SEED.projectId } },
   "projects.readMemoryEntriesByIds": { args: { identity: { projectId: SEED.projectId }, ids: ["pe_t9_alpha"] } },
   "projects.memoryPreamble": { args: { identity: { projectId: SEED.projectId }, options: {} } },
+  "issueRefs.list": { args: { limit: 10 } },
+  "automations.listRuns": { args: { limit: 10 } },
+  "automations.pendingPrecheckRuns": { args: undefined },
+  "automations.reconcilableRuns": { args: undefined },
+  "automations.dispatchableQueuedRuns": { args: undefined },
+  "automations.dueAutomations": { args: { now: 1_700_000_000_000 } },
+  "projectEntries.get": { args: { id: "pe_t9_alpha" } },
+  "projectEntries.chain": { args: { id: "pe_t9_alpha" } },
+  "projectEntries.inArea": { args: { projectId: SEED.projectId, area: "db" } },
+  "projectEntries.countPinnedInArea": { args: { projectId: SEED.projectId, area: "db" } },
   "projectEntries.list": { args: { projectId: SEED.projectId } },
   "projectEntries.search": { args: { projectId: SEED.projectId, query: "t9" } },
   "teams.spawnDelegation.get": { args: { teamId: SEED.teamId } },
@@ -242,6 +252,7 @@ export const READ_OP_MARSHALING_FIXTURES: ReadOpFixtures = {
   // --- commands / codex reset / inbox / insights --------------------------------------------------
   "commands.spawnOutcome": { args: { spawnRequestId: "spawn-t9" } },
   "commands.get": { args: { id: SEED.commandId } },
+  "commands.latestAttempt": { args: { baseId: SEED.commandId } },
   "commands.listLegacyLandingBackfillCandidates": { args: { afterId: "", limit: 10 } },
   // `observedAt` is the dispatcher's own `ctx.now`, so the in-process and worker runs legitimately
   // stamp different clock readings for the same DB state — normalize it out or the #1960 worker-seam
@@ -714,6 +725,12 @@ export function seedReadOpMarshalingData(): void {
      VALUES ('t9', 't9 claimed task', 't9', 'info', 'in_progress', 't9', 'claim', ?, ?, ?, ?, ?)`,
   ).run(SEED.agentId, t - 1, t, t, t);
 
+  // An open task-bound run so the automation scan ops marshal a NON-trivial run (meta/result JSON parsed worker-side).
+  db.query(
+    `INSERT INTO automation_runs (id, automation_id, status, scheduled_for, orchestrator_id, task_id, meta, created_at, updated_at)
+     VALUES ('run-t9', 'automation-t9', 'running', ?, 'orch-t9', 1, '{"k":"v"}', ?, ?)`,
+  ).run(t, t, t);
+
   // Project-entries rows so `projectEntries.list`/`search` marshal NON-trivial results:
   // two active rows the query term hits, plus a retracted row proving mixed-status parity.
   for (const [id, title, body, status, updatedAt] of [
@@ -725,5 +742,6 @@ export function seedReadOpMarshalingData(): void {
       `INSERT INTO project_entries (id, project_id, kind, title, body, status, tags, author_id, source, audience, inject, sensitivity, created_at, updated_at)
        VALUES (?, ?, 'rule', ?, ?, ?, '["t9"]', ?, 'manual', 'all', 'indexed', 'normal', ?, ?)`,
     ).run(id, SEED.projectId, title, body, status, SEED.agentId, updatedAt, updatedAt);
+    db.query("UPDATE project_entries SET areas = ?, inject = ? WHERE id = ?").run('["db"]', "pinned", id);
   }
 }

package/src/db/read-ops.ts

@@ -63,6 +63,8 @@ import { ARTIFACTS_READ_OPS } from "./artifacts-read-ops.ts";
 import { PLANS_READ_OPS } from "./plans-read-ops.ts";
 import { CONTINUATION_ARCHIVES_READ_OPS } from "./continuation-archives-read-ops.ts";
 import { WORKFLOW_JOURNAL_READ_OPS } from "./workflow-journal-read-ops.ts";
+import { AUTOMATION_READ_OPS } from "./automation-read-ops.ts";
+import { ISSUE_REFS_READ_OPS } from "./issue-refs-read-ops.ts";
 import { PROJECTS_READ_OPS } from "./projects-read-ops.ts";
 import { PROJECT_ENTRIES_READ_OPS } from "./project-entries-read-ops.ts";
 import { CHANNELS_READ_OPS } from "./channels-read-ops.ts";
@@ -256,6 +258,8 @@ export const readOps = {
   ...WORKFLOW_JOURNAL_READ_OPS,
   ...PROJECTS_READ_OPS,
   ...PROJECT_ENTRIES_READ_OPS,
+  ...AUTOMATION_READ_OPS,
+  ...ISSUE_REFS_READ_OPS,
   ...CHANNELS_READ_OPS,
   ...INTEGRATIONS_READ_OPS,
 } satisfies Record<string, ReadOpFn>;

package/src/db/retention.ts

@@ -1,5 +1,6 @@
 import { getDb, getDbPath, runDbMaintenanceWorker } from "./connection.ts";
 import { spawnProcessGoneSql } from "./spawn-process-evidence";
+import { slimSpawnProfileChunk } from "./command-agent-profile-backfill";
 
 export interface RetentionPruneInput {
   messageCutoff: number;
@@ -13,6 +14,8 @@ export interface RetentionPruneResult {
   prunedMessages: number;
   prunedActivityEvents: number;
   prunedSpawnCommands: number;
+  /** #3610 — legacy spawn rows whose inline agentProfile moved to the content-hash store. */
+  slimmedSpawnProfiles: number;
   // #1758 — true when this run stopped on its batch-size cap or its wall-time budget with candidate
   // rows still available in at least one table, i.e. it made bounded progress but did NOT drain the
   // backlog. The scheduler uses it to record the run `succeeded` (not `failed`) and to reschedule the
@@ -325,11 +328,13 @@ export function pruneRetentionBatchOnDb(db: RetentionDb, input: RetentionPruneIn
   const messages = pruneChunks(batchSize, deadlineAt, (limit) => messageChunk(db, input.messageCutoff, limit));
   const activity = pruneChunks(batchSize, deadlineAt, (limit) => activityChunk(db, input.activityCutoff, activityHotSetBoundary, limit));
   const spawnCommands = pruneChunks(batchSize, deadlineAt, (limit) => spawnCommandChunk(db, input.spawnCommandCutoff, limit));
+  const profiles = pruneChunks(batchSize, deadlineAt, (limit) => slimSpawnProfileChunk(db, limit));
   return {
     prunedMessages: messages.pruned,
     prunedActivityEvents: activity.pruned,
     prunedSpawnCommands: spawnCommands.pruned,
-    moreWork: messages.moreWork || activity.moreWork || spawnCommands.moreWork,
+    slimmedSpawnProfiles: profiles.pruned,
+    moreWork: messages.moreWork || activity.moreWork || spawnCommands.moreWork || profiles.moreWork,
   };
 }
 
@@ -362,10 +367,13 @@ export async function pruneRetentionBatchOnDbAsync(
   const runMessages = (deadlineAt: number) => pruneChunksAsync(batchCap, deadlineAt, (limit) => messageChunk(db, input.messageCutoff, limit));
   const runActivity = (deadlineAt: number) => pruneChunksAsync(batchCap, deadlineAt, (limit) => activityChunk(db, input.activityCutoff, activityHotSetBoundary, limit));
   const runSpawn = (deadlineAt: number) => pruneChunksAsync(batchCap, deadlineAt, (limit) => spawnCommandChunk(db, input.spawnCommandCutoff, limit));
+  // After the deletes, so rows about to age out are never rewritten first.
+  const runProfiles = (deadlineAt: number) => pruneChunksAsync(batchCap, deadlineAt, (limit) => slimSpawnProfileChunk(db, limit));
 
   let messages: { pruned: number; moreWork: boolean };
   let activity: { pruned: number; moreWork: boolean };
   let spawnCommands: { pruned: number; moreWork: boolean };
+  let profiles: { pruned: number; moreWork: boolean };
   if (options.catchUp) {
     // Cumulative per-table deadline checkpoints against one shared clock. With the batch cap unreachable,
     // a single shared deadline would let a large `messages` backlog consume the whole budget before
@@ -377,6 +385,7 @@ export async function pruneRetentionBatchOnDbAsync(
     const third = totalBudget / 3;
     activity = await runActivity(start + third);
     spawnCommands = await runSpawn(start + 2 * third);
+    profiles = await runProfiles(start + 2 * third);
     messages = await runMessages(start + totalBudget);
   } else {
     // Inline-async fallback (:memory:): one shared deadline + the operator batch cap, unchanged.
@@ -384,12 +393,14 @@ export async function pruneRetentionBatchOnDbAsync(
     messages = await runMessages(deadlineAt);
     activity = await runActivity(deadlineAt);
     spawnCommands = await runSpawn(deadlineAt);
+    profiles = await runProfiles(deadlineAt);
   }
   return {
     prunedMessages: messages.pruned,
     prunedActivityEvents: activity.pruned,
     prunedSpawnCommands: spawnCommands.pruned,
-    moreWork: messages.moreWork || activity.moreWork || spawnCommands.moreWork,
+    slimmedSpawnProfiles: profiles.pruned,
+    moreWork: messages.moreWork || activity.moreWork || spawnCommands.moreWork || profiles.moreWork,
   };
 }
 

package/src/db/review-publish-write.ts

@@ -0,0 +1,8 @@
+import { createCommandInternal, type CreateCommandWriteArgs } from "../commands-db";
+import { upsertReviewRefCleanup } from "./review-ref-cleanups";
+export type ReviewCleanupInput = Omit<Parameters<typeof upsertReviewRefCleanup>[0], "id">;
+export function createReviewPublishBody(args: { command: CreateCommandWriteArgs; cleanup: ReviewCleanupInput }, now: number) {
+  const command = createCommandInternal(args.command, now);
+  upsertReviewRefCleanup({ ...args.cleanup, id: command.id });
+  return command;
+}

package/src/db/runtime-admin-async.ts

@@ -0,0 +1,19 @@
+import { randomUUID } from "node:crypto";
+import { getGateway } from "./gateway";
+import { emitWorkspaceChange, emitWorkspaceCreate, type RecoveredWorkspaceInput } from "./workspaces";
+import type { upsertWorkspaceRow } from "./workspaces";
+import type { recoverWorkspaceBody, expireRuntimeCommands } from "./runtime-admin-write-ops";
+
+export async function upsertWorkspaceAsync(input: Parameters<typeof upsertWorkspaceRow>[0]) {
+  const result = await getGateway().write("workspaces.upsertRow", input, { idempotencyKey: randomUUID() }) as unknown as ReturnType<typeof upsertWorkspaceRow>;
+  if (result.changed) emitWorkspaceChange(result.workspace);
+  return result.workspace;
+}
+export async function insertRecoveredWorkspaceAsync(input: RecoveredWorkspaceInput): Promise<ReturnType<typeof recoverWorkspaceBody>> {
+  const result = await getGateway().write("workspaces.recover", input, { idempotencyKey: randomUUID() }) as unknown as ReturnType<typeof recoverWorkspaceBody>;
+  if (result.created) { emitWorkspaceChange(result.workspace); emitWorkspaceCreate(result.workspace); }
+  return result;
+}
+export function expireCommandsAsync(now = Date.now()): Promise<ReturnType<typeof expireRuntimeCommands>> {
+  return getGateway().write("commands.expireRuntime", { now }, { idempotencyKey: randomUUID(), critical: true }) as unknown as Promise<ReturnType<typeof expireRuntimeCommands>>;
+}

package/src/db/runtime-admin-write-ops.ts

@@ -0,0 +1,36 @@
+import { createUserInvite, acceptUserInvite } from "./user-invites";
+import { getAgent } from "./agents";
+import { getWorkspace, upsertWorkspaceRow, type RecoveredWorkspaceInput } from "./workspaces";
+import { expireCommands, updateCommandInternal, applyCommandUpdatePostCommit } from "../commands-db";
+import { redactCommandSecrets } from "../command-secrets";
+import type { Command } from "../types";
+import type { WriterOpSpec } from "./write-ops";
+
+export function recoverWorkspaceBody(input: RecoveredWorkspaceInput, now: number) {
+  const existing = getWorkspace(input.id);
+  if (existing) return { workspace: existing, created: false };
+  const result = upsertWorkspaceRow({ id: input.id, repoRoot: input.repoRoot, sourceCwd: input.sourceCwd, worktreePath: input.worktreePath,
+    branch: input.branch, baseRef: input.baseRef, baseSha: input.baseSha, mode: "isolated", status: "active", orchestratorId: input.orchestratorId,
+    ownerAgentId: input.ownerAgentId, metadata: { reregistered: true, ...input.landMetadata } }, now);
+  return { workspace: result.workspace, created: result.created };
+}
+export function expireRuntimeCommands(now: number) {
+  return expireCommands(now, {
+    isTargetGone: command => Boolean(command.target && command.target !== "system" && (!getAgent(command.target) || getAgent(command.target)!.status === "offline")),
+    update: (id, input, options) => {
+      const result = updateCommandInternal(id, input, options, now);
+      return applyCommandUpdatePostCommit(result.previousStatus, result.command);
+    },
+  });
+}
+export const RUNTIME_ADMIN_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
+  "userInvites.create": { offLoop: true, idempotent: false,
+    fn: (input: Parameters<typeof createUserInvite>[0], ctx) => createUserInvite({ ...input, now: input.now ?? ctx.now }),
+    // The invite code is a bearer credential returned once, like a token mint (#1870).
+    serializeIdempotencyResult: value => ({ invite: (value as ReturnType<typeof createUserInvite>).invite }) },
+  "userInvites.accept": { offLoop: true, idempotent: false, fn: (input: Parameters<typeof acceptUserInvite>[0], ctx) => acceptUserInvite({ ...input, now: input.now ?? ctx.now }) },
+  "workspaces.upsertRow": { offLoop: true, idempotent: false, fn: (input: Parameters<typeof upsertWorkspaceRow>[0], ctx) => upsertWorkspaceRow(input, ctx.now) },
+  "workspaces.recover": { offLoop: true, idempotent: false, fn: (input: RecoveredWorkspaceInput, ctx) => recoverWorkspaceBody(input, ctx.now) },
+  "commands.expireRuntime": { offLoop: true, idempotent: false, fn: (args: { now?: number }, ctx) => expireRuntimeCommands(args.now ?? ctx.now),
+    serializeIdempotencyResult: value => (value as Command[]).map(command => redactCommandSecrets(command)) },
+});