@humwick/server 0.130.1 → 0.130.3

package/src/db/hosts.ts

@@ -9,6 +9,7 @@ import type { Host, HostDaemonSample, HostHardware, HostMachineSample, HostPolic
 import { normalizeHostToken, parseJson } from "../utils";
 import { getDb } from "./connection.ts";
 import { primeHostAliases, type HostAliasRecord } from "../host/identity.ts";
+import { settleDiskWatch, type DiskAlert } from "../host/disk-alert.ts";
 import { settleGateArming, type GateCapacityAlert } from "../host/gate-capacity-alert.ts";
 
 function rowToHost(row: any): Host {
@@ -99,18 +100,20 @@ function storedSample<T extends { at: number }>(table: "hosts" | "orchestrators"
  */
 export function recordHostUtilizationInternal(
   input: { hostId: string; orchestratorId: string; machine: HostMachineSample; daemon: HostDaemonSample },
-): { hostUpdated: boolean; generationUpdated: boolean; gateAlert?: GateCapacityAlert; hostLabel?: string } {
+): { hostUpdated: boolean; generationUpdated: boolean; gateAlert?: GateCapacityAlert; diskAlert?: DiskAlert; hostLabel?: string } {
   // `last_seen_at` is deliberately NOT touched here: it is the Host's freshness clock and the §3.5
   // seam already bumps it on every beat with the RELAY's clock. `machine.at` is the PRODUCER's wall
   // clock, so writing it here would let a skewed daemon move a Host's liveness backwards.
   const prevHost = storedSample<HostMachineSample>("hosts", input.hostId);
   let hostUpdated = false;
   let gateAlert: GateCapacityAlert | undefined;
+  let diskAlert: DiskAlert | undefined;
   if (!prevHost || input.machine.at > prevHost.at) {
-    // #2822 — settled inside this single-writer read-modify-write, so each transition alerts once.
-    const settled = settleGateArming(prevHost ?? undefined, input.machine);
+    // #2822 / #3762 — settled inside this single-writer read-modify-write, so each transition alerts once.
+    const gate = settleGateArming(prevHost ?? undefined, input.machine);
+    const settled = settleDiskWatch(prevHost ?? undefined, gate.machine);
     hostUpdated = getDb().query("UPDATE hosts SET utilization = ? WHERE id = ?").run(JSON.stringify(settled.machine), input.hostId).changes > 0;
-    if (hostUpdated) gateAlert = settled.alert;
+    if (hostUpdated) { gateAlert = gate.alert; diskAlert = settled.alert; }
   }
 
   const generationAt = storedSample<HostDaemonSample>("orchestrators", input.orchestratorId)?.at ?? null;
@@ -118,9 +121,9 @@ export function recordHostUtilizationInternal(
     ? false
     : getDb().query("UPDATE orchestrators SET utilization = ? WHERE id = ?").run(JSON.stringify(input.daemon), input.orchestratorId).changes > 0;
 
-  if (!gateAlert) return { hostUpdated, generationUpdated };
+  if (!gateAlert && !diskAlert) return { hostUpdated, generationUpdated };
   const label = (getDb().query("SELECT label FROM hosts WHERE id = ?").get(input.hostId) as { label: string } | null)?.label;
-  return { hostUpdated, generationUpdated, gateAlert, hostLabel: label ?? input.hostId };
+  return { hostUpdated, generationUpdated, ...(gateAlert ? { gateAlert } : {}), ...(diskAlert ? { diskAlert } : {}), hostLabel: label ?? input.hostId };
 }
 
 export function setHostLabelInternal(id: string, label: string): Host | null {

package/src/db/inbox-async.ts

@@ -9,8 +9,8 @@ import type {
   setInboxThreadState,
 } from "./inbox.ts";
 
-export function getInboxStateAsync(operatorId: string): Promise<ReturnType<typeof getInboxState>> {
-  return getGateway().read("inbox.state", { operatorId }) as unknown as Promise<ReturnType<typeof getInboxState>>;
+export function getInboxStateAsync(operatorId: string, options: { excludeOffline?: boolean } = {}): Promise<ReturnType<typeof getInboxState>> {
+  return getGateway().read("inbox.state", { operatorId, ...(options.excludeOffline ? { excludeOffline: true } : {}) }) as unknown as Promise<ReturnType<typeof getInboxState>>;
 }
 export function listChatHistoryImportsAsync(input: Parameters<typeof listChatHistoryImports>[0] = {}): Promise<ReturnType<typeof listChatHistoryImports>> {
   return getGateway().read("inbox.historyImports", input) as unknown as Promise<ReturnType<typeof listChatHistoryImports>>;

package/src/db/inbox-read-ops.ts

@@ -3,6 +3,6 @@
 import { getInboxState, listChatHistoryImports } from "./inbox.ts";
 
 export const INBOX_READ_OPS = {
-  "inbox.state": (args: { operatorId: string }) => getInboxState(args.operatorId),
+  "inbox.state": (args: { operatorId: string; excludeOffline?: boolean }) => getInboxState(args.operatorId, { excludeOffline: args.excludeOffline }),
   "inbox.historyImports": (args: Parameters<typeof listChatHistoryImports>[0]) => listChatHistoryImports(args),
 };

package/src/db/inbox.ts

@@ -1,18 +1,4 @@
 import { randomUUID } from "node:crypto";
-import { isRecord, stringValue, isMechanicalMessageKind } from "@humwick/sdk";
-import { ORCHESTRATOR_PROTOCOL_VERSION, VERSION } from "../config.ts";
-import { parseJson } from "../utils";
-import { isLiveIsolatedWorkspace } from "../workspace-phase";
-import {
-  CONTRACT_REQUIREMENTS,
-  contractCompatibility,
-  parseRuntimeCapabilities,
-  parseRuntimeContracts,
-  parseRuntimePackage,
-  type RuntimeContracts,
-} from "../contracts";
-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 { ValidationError, getDb, writeTransaction } from "./connection.ts";
 import { rowToChatHistoryImport, rowToChatHistoryImportEntry, rowToInboxDraft, rowToInboxThreadState } from "./mappers.ts";
 import { getMessage } from "./messages.ts";
@@ -24,12 +10,18 @@ import type {
   InboxThreadState,
 } from "../types";
 
-export function getInboxState(operatorId: string): InboxState {
+/**
+ * #2410 — `excludeOffline` (opt-in, the #2396 contract) keeps only peers whose agent is registered
+ * and not offline: the dashboard's "Show offline" switch hides every other thread, and the table
+ * accrues a row per agent id ever chatted with, so the full read is mostly long-dead peers.
+ */
+export function getInboxState(operatorId: string, options: { excludeOffline?: boolean } = {}): InboxState {
+  const live = options.excludeOffline ? " AND peer_id IN (SELECT id FROM agents WHERE status <> 'offline')" : "";
   const threads = (getDb().query(
-    "SELECT * FROM inbox_thread_state WHERE operator_id = ? ORDER BY updated_at DESC",
+    `SELECT * FROM inbox_thread_state WHERE operator_id = ?${live} ORDER BY updated_at DESC`,
   ).all(operatorId) as any[]).map(rowToInboxThreadState);
   const drafts = (getDb().query(
-    "SELECT * FROM inbox_drafts WHERE operator_id = ? ORDER BY updated_at DESC",
+    `SELECT * FROM inbox_drafts WHERE operator_id = ?${live} ORDER BY updated_at DESC`,
   ).all(operatorId) as any[]).map(rowToInboxDraft);
   return { operatorId, threads, drafts };
 }

package/src/db/index.ts

@@ -44,6 +44,7 @@ export * from "./task-comment-through-async.ts";
 export * from "./deploy-events.ts";
 export * from "./deploy-events-async.ts";
 export * from "./integrations.ts";
+export * from "./integrations-async.ts";
 export * from "./pairs.ts";
 export * from "./artifacts.ts";
 export * from "./artifact-browse.ts";
@@ -75,6 +76,7 @@ export * from "./orchestrators-async.ts";
 export * from "./hosts.ts";
 export * from "./hosts-async.ts";
 export type { HostRegistrationEvent, HostRegistrationInput, HostRegistrationResult } from "./hosts-registration.ts";
+export { conflictingHardwareFields } from "./hosts-registration.ts";
 export * from "./workspaces.ts";
 export * from "./workspace-writes.ts";
 export * from "./workspace-writes-async.ts";

package/src/db/integrations-async.ts

@@ -0,0 +1,8 @@
+import { getGateway } from "./gateway.ts";
+import type { IntegrationRegistryInput, reconcileIntegrationRegistry } from "./integrations.ts";
+
+export const listIntegrationTaskStatsAsync = () => getGateway().read("integrations.taskStats", undefined);
+
+export async function reconcileIntegrationRegistryAsync(configured: IntegrationRegistryInput[], observedSources: string[]): Promise<ReturnType<typeof reconcileIntegrationRegistry>> {
+  return await getGateway().write("integrations.reconcileRegistry", { configured, observedSources }) as unknown as ReturnType<typeof reconcileIntegrationRegistry>;
+}

package/src/db/integrations-ops.ts

@@ -0,0 +1,15 @@
+import { listIntegrationTaskStats, reconcileIntegrationRegistry, type IntegrationRegistryInput } from "./integrations.ts";
+import type { WriterOpSpec } from "./write-ops.ts";
+
+export const INTEGRATIONS_READ_OPS = {
+  "integrations.taskStats": () => listIntegrationTaskStats(),
+};
+
+export const INTEGRATIONS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = {
+  "integrations.reconcileRegistry": {
+    offLoop: true,
+    idempotent: true,
+    fn: (args: { configured: IntegrationRegistryInput[]; observedSources: string[] }, ctx) =>
+      reconcileIntegrationRegistry(args.configured, args.observedSources, ctx.now),
+  },
+};

package/src/db/integrations.ts

@@ -1,18 +1,5 @@
-import { randomUUID } from "node:crypto";
-import { isRecord, stringValue, isMechanicalMessageKind } from "@humwick/sdk";
-import { ORCHESTRATOR_PROTOCOL_VERSION, VERSION } from "../config.ts";
+import { stringValue } from "@humwick/sdk";
 import { parseJson } from "../utils";
-import { isLiveIsolatedWorkspace } from "../workspace-phase";
-import {
-  CONTRACT_REQUIREMENTS,
-  contractCompatibility,
-  parseRuntimeCapabilities,
-  parseRuntimeContracts,
-  parseRuntimePackage,
-  type RuntimeContracts,
-} from "../contracts";
-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 { normalizeTags, parseStringArray } from "./agents.ts";
 import { linkAttachmentRefs, validateAttachmentRefs } from "./artifacts.ts";
 import { ValidationError, getDb, writeTransaction } from "./connection.ts";
@@ -143,9 +130,7 @@ function integrationTaskMetadata(
   };
 }
 
-
-export function listIntegrationTaskStats(): IntegrationTaskStats[] {
-  const rows = getDb().query(`
+export const INTEGRATION_TASK_STATS_SQL = `
     SELECT
       coalesce(json_extract(metadata, '$.relayIntegrationName'), source) AS source,
       COUNT(*) AS tasks,
@@ -157,7 +142,10 @@ export function listIntegrationTaskStats(): IntegrationTaskStats[] {
     FROM tasks
     GROUP BY coalesce(json_extract(metadata, '$.relayIntegrationName'), source)
     ORDER BY last_seen_at DESC, source ASC
-  `).all() as any[];
+  `;
+
+export function listIntegrationTaskStats(): IntegrationTaskStats[] {
+  const rows = getDb().query(INTEGRATION_TASK_STATS_SQL).all() as any[];
 
   return rows.map((row) => ({
     source: row.source,
@@ -170,7 +158,7 @@ export function listIntegrationTaskStats(): IntegrationTaskStats[] {
   }));
 }
 
-type IntegrationRegistryInput = {
+export type IntegrationRegistryInput = {
   name: string;
   displayName?: string;
   description?: string;
@@ -220,10 +208,9 @@ function rowToIntegrationRegistry(row: any): Omit<IntegrationSummary, "configure
   };
 }
 
-export function upsertIntegrationRegistry(input: IntegrationRegistryInput): ReturnType<typeof rowToIntegrationRegistry> {
+export function upsertIntegrationRegistry(input: IntegrationRegistryInput, now = Date.now()): ReturnType<typeof rowToIntegrationRegistry> {
   const name = stringValue(input.name);
   if (!name) throw new ValidationError("integration name required");
-  const now = Date.now();
   getDb().query(`
     INSERT INTO integration_registry (
       name, display_name, description, enabled, scopes, targets, channels, type, icon, accent_color,
@@ -295,3 +282,10 @@ export function isIntegrationRegistryEnabled(name: string): boolean {
   const registry = getIntegrationRegistry(name);
   return registry?.enabled !== false;
 }
+
+// GET reconciliation preserves registry precedence, but runs entirely on the writer (#3740).
+export function reconcileIntegrationRegistry(configured: IntegrationRegistryInput[], observedSources: string[], now: number): ReturnType<typeof listIntegrationRegistry> {
+  for (const input of configured) upsertIntegrationRegistry({ ...input, source: "env" }, now);
+  for (const name of observedSources) upsertIntegrationRegistry({ name, enabled: true, source: "observed" }, now);
+  return listIntegrationRegistry();
+}

package/src/db/issue-associations.ts

@@ -40,13 +40,13 @@ function cleanText(value: string | undefined, field: string, max: number): strin
   return cleaned;
 }
 
-export function associateIssue(issueRefId: string, entityType: IssueAssociationEntityType, entityId: string, relation?: IssueRefRelation): IssueAssociation {
+export function associateIssue(issueRefId: string, entityType: IssueAssociationEntityType, entityId: string, relation?: IssueRefRelation, submittedAt: number = Date.now()): IssueAssociation {
   const cleanedIssueRefId = cleanText(issueRefId, "issueRefId", 120);
   if (!getIssueRef(cleanedIssueRefId)) throw new ValidationError(`issue ref ${cleanedIssueRefId} not found`);
   const cleanedEntityType = cleanEntityType(entityType);
   const cleanedEntityId = cleanText(entityId, "entityId", 240);
   const cleanedRelation = optionalEnum(relation, "relation", ISSUE_REF_RELATIONS);
-  const now = Date.now();
+  const now = submittedAt;
   getDb().query(`
     INSERT INTO issue_associations (issue_ref_id, entity_type, entity_id, created_at, relation)
     VALUES (?, ?, ?, ?, ?)

package/src/db/issue-lifecycle.ts

@@ -5,7 +5,7 @@ const ISSUE_LIFECYCLE_STATUSES = ["succeeded", "failed"] as const;
 type IssueLifecycleAction = (typeof ISSUE_LIFECYCLE_ACTIONS)[number];
 type IssueLifecycleStatus = (typeof ISSUE_LIFECYCLE_STATUSES)[number];
 
-interface IssueLifecycleActionRecord {
+export interface IssueLifecycleActionRecord {
   id: number;
   issueRefId: string;
   action: IssueLifecycleAction;
@@ -24,7 +24,7 @@ interface IssueLifecycleActionRecord {
   updatedAt: number;
 }
 
-interface UpsertIssueLifecycleActionInput {
+export interface UpsertIssueLifecycleActionInput {
   issueRefId: string;
   action: IssueLifecycleAction;
   landKey: string;
@@ -150,8 +150,7 @@ export function listSuccessfulCloseActionsForCommit(input: { commitSha?: string;
   return rows.map(rowToIssueLifecycleAction);
 }
 
-export function upsertIssueLifecycleAction(input: UpsertIssueLifecycleActionInput): IssueLifecycleActionRecord {
-  const now = Date.now();
+export function upsertIssueLifecycleAction(input: UpsertIssueLifecycleActionInput, now: number = Date.now()): IssueLifecycleActionRecord {
   const issueRefId = cleanRequiredText(input.issueRefId, "issueRefId", 120);
   const action = cleanAction(input.action);
   const landKey = cleanRequiredText(input.landKey, "landKey", 240);

package/src/db/issue-refs-async.ts

@@ -0,0 +1,23 @@
+// #1870 S7 — async facades for the issue-ref writer ops (`issue-refs-write-ops.ts`).
+import { randomUUID } from "node:crypto";
+import { getGateway } from "./gateway.ts";
+import type { IssueRef } from "../types";
+import type { IssueTrackerIssueSummary } from "../issue-tracker/adapter";
+import type { ListIssueRefsOptions, ResolveIssueRefByExternalKeyInput, ResolveIssueRefFromStringInput, UpdateIssueRefInput, UpsertIssueRefInput } from "./issue-refs.ts";
+import type { IssueLifecycleActionRecord, UpsertIssueLifecycleActionInput } from "./issue-lifecycle.ts";
+
+const write = <T>(op: string, args: unknown, opts?: { idempotencyKey?: string }) => getGateway().write(op, args as never, opts) as unknown as Promise<T>;
+
+const read = <T>(op: string, args: unknown = {}) => getGateway().read(op as never, args as never) as unknown as Promise<T>;
+
+export const listIssueRefsAsync = (opts: ListIssueRefsOptions = {}) => read<IssueRef[]>("issueRefs.list", opts);
+export const upsertIssueRefAsync = (input: UpsertIssueRefInput) => write<IssueRef>("issueRefs.upsert", input);
+export const resolveIssueRefByExternalKeyAsync = (input: ResolveIssueRefByExternalKeyInput) => write<IssueRef>("issueRefs.resolveExternalKey", input);
+export const resolveIssueRefFromStringAsync = (input: ResolveIssueRefFromStringInput) => write<IssueRef>("issueRefs.resolveFromString", input);
+export const updateIssueRefAsync = (id: string, input: UpdateIssueRefInput) => write<IssueRef | null>("issueRefs.update", { id, input });
+export const deleteIssueRefAsync = (id: string) => write<boolean>("issueRefs.delete", { id });
+/** The tracker answered: clear the not-found streak and cache its status, in one write. */
+export const recordIssueRefLiveStatusAsync = (id: string, input: UpdateIssueRefInput) => write<IssueRef | null>("issueRefs.recordLiveStatus", { id, input });
+export const putIssueHierarchyAsync = (id: string, children: IssueTrackerIssueSummary[]) => write<void>("issueRefs.putHierarchy", { id, children });
+export const recordIssueTrackerNotFoundAsync = (id: string) => write<number>("issueRefs.recordNotFound", { id }, { idempotencyKey: randomUUID() });
+export const upsertIssueLifecycleActionAsync = (input: UpsertIssueLifecycleActionInput) => write<IssueLifecycleActionRecord>("issueLifecycle.upsertAction", input);

package/src/db/issue-refs-read-ops.ts

@@ -0,0 +1,6 @@
+// #3799 — the issue-ref listing on the reader pool (it ran as a cold main-thread scan, 10 s on swap-bound I/O).
+import { listIssueRefs, type ListIssueRefsOptions } from "./issue-refs.ts";
+
+export const ISSUE_REFS_READ_OPS = {
+  "issueRefs.list": (args: ListIssueRefsOptions) => listIssueRefs(args),
+};

package/src/db/issue-refs-write-ops.ts

@@ -0,0 +1,29 @@
+// #1870 S7 — issue-ref cache, tracker refresh state and lifecycle ledger writes run on the writer thread.
+// Every body is plain SQL against its own tables. All but `recordNotFound` converge on replay: upserts are
+// keyed by (provider, repo, externalKey) or (issue, action, landKey), updates re-set the same columns.
+import { resolveIssueRefByExternalKey, resolveIssueRefFromString, updateIssueRef, upsertIssueRef, deleteIssueRef, type ResolveIssueRefByExternalKeyInput, type ResolveIssueRefFromStringInput, type UpdateIssueRefInput, type UpsertIssueRefInput } from "./issue-refs.ts";
+import { clearIssueTrackerNotFound, putIssueHierarchy, recordIssueTrackerNotFound } from "./long-running-work.ts";
+import { upsertIssueLifecycleAction, type UpsertIssueLifecycleActionInput } from "./issue-lifecycle.ts";
+import type { IssueTrackerIssueSummary } from "../issue-tracker/adapter";
+import type { WriterOpContext, WriterOpSpec } from "./write-ops.ts";
+
+export const ISSUE_REFS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
+  "issueRefs.upsert": { offLoop: true, idempotent: true, fn: (args: UpsertIssueRefInput, ctx: WriterOpContext) => upsertIssueRef(args, ctx.now) },
+  "issueRefs.resolveExternalKey": { offLoop: true, idempotent: true, fn: (args: ResolveIssueRefByExternalKeyInput, ctx: WriterOpContext) => resolveIssueRefByExternalKey(args, ctx.now) },
+  "issueRefs.resolveFromString": { offLoop: true, idempotent: true, fn: (args: ResolveIssueRefFromStringInput, ctx: WriterOpContext) => resolveIssueRefFromString(args, ctx.now) },
+  "issueRefs.update": { offLoop: true, idempotent: true, fn: (args: { id: string; input: UpdateIssueRefInput }, ctx: WriterOpContext) => updateIssueRef(args.id, args.input, ctx.now) },
+  "issueRefs.delete": { offLoop: true, idempotent: true, fn: (args: { id: string }) => deleteIssueRef(args.id) },
+  // A tracker answered for this ref: the not-found streak ends and the cached status follows the tracker.
+  "issueRefs.recordLiveStatus": {
+    offLoop: true,
+    idempotent: true,
+    fn: (args: { id: string; input: UpdateIssueRefInput }, ctx: WriterOpContext) => {
+      clearIssueTrackerNotFound(args.id);
+      return updateIssueRef(args.id, args.input, ctx.now);
+    },
+  },
+  "issueRefs.putHierarchy": { offLoop: true, idempotent: true, fn: (args: { id: string; children: IssueTrackerIssueSummary[] }, ctx: WriterOpContext) => putIssueHierarchy(args.id, args.children, ctx.now) },
+  // Increments a counter, so a replay would double-count: keyed.
+  "issueRefs.recordNotFound": { offLoop: true, idempotent: false, fn: (args: { id: string }) => recordIssueTrackerNotFound(args.id) },
+  "issueLifecycle.upsertAction": { offLoop: true, idempotent: true, fn: (args: UpsertIssueLifecycleActionInput, ctx: WriterOpContext) => upsertIssueLifecycleAction(args, ctx.now) },
+});

package/src/db/issue-refs.ts

@@ -151,7 +151,7 @@ export function getIssueRefByExternalKey(provider: IssueProvider, repo: string,
   return row ? rowToIssueRef(row) : null;
 }
 
-export function upsertIssueRef(input: UpsertIssueRefInput): IssueRef {
+export function upsertIssueRef(input: UpsertIssueRefInput, now: number = Date.now()): IssueRef {
   const provider = cleanProvider(input.provider);
   const repo = requiredText(input.repo, "repo", 500);
   const externalKey = requiredText(input.externalKey, "externalKey", 240);
@@ -162,7 +162,6 @@ export function upsertIssueRef(input: UpsertIssueRefInput): IssueRef {
   // An open/unknown upsert clears a stale closeReason; an explicit closeReason requires closed.
   const closeReason = input.closeReason === undefined && status !== "closed" ? undefined : cleanCloseReason(input.closeReason, status) ?? (status === "closed" ? existing?.closeReason : undefined);
   const statusSyncedAt = cleanSyncedAt(input.statusSyncedAt);
-  const now = Date.now();
   if (existing) {
     getDb().query(`
       UPDATE issue_refs
@@ -179,7 +178,7 @@ export function upsertIssueRef(input: UpsertIssueRefInput): IssueRef {
   return getIssueRef(id)!;
 }
 
-export function resolveIssueRefByExternalKey(input: ResolveIssueRefByExternalKeyInput): IssueRef {
+export function resolveIssueRefByExternalKey(input: ResolveIssueRefByExternalKeyInput, now: number = Date.now()): IssueRef {
   const provider = cleanProvider(input.provider);
   const repo = requiredText(input.repo, "repo", 500);
   const externalKey = requiredText(input.externalKey, "externalKey", 240);
@@ -196,7 +195,7 @@ export function resolveIssueRefByExternalKey(input: ResolveIssueRefByExternalKey
     status: input.status ?? existing?.status,
     closeReason: input.closeReason ?? (input.status !== undefined ? undefined : existing?.closeReason),
     statusSyncedAt: input.statusSyncedAt ?? existing?.statusSyncedAt,
-  });
+  }, now);
 }
 
 // A BARE `#123` ref carries no repo, so it only resolves when the caller supplies a
@@ -231,7 +230,7 @@ export function issueRefForRefString(ref: string, defaultRepo?: string): IssueRe
   return getIssueRefByExternalKey("github", parsed.repo, parsed.externalKey);
 }
 
-export function resolveIssueRefFromString(input: ResolveIssueRefFromStringInput): IssueRef {
+export function resolveIssueRefFromString(input: ResolveIssueRefFromStringInput, now: number = Date.now()): IssueRef {
   const ref = requiredText(input.ref, "ref", 1000);
   if (ref.startsWith("issue_")) {
     const existing = getIssueRef(ref);
@@ -250,10 +249,11 @@ export function resolveIssueRefFromString(input: ResolveIssueRefFromStringInput)
     status: input.status,
     closeReason: input.closeReason,
     statusSyncedAt: input.statusSyncedAt,
-  });
+  }, now);
 }
 
-export function listIssueRefs(opts: ListIssueRefsOptions = {}): IssueRef[] {
+/** Listing SQL, exported so the query-plan gate pins the production statement (#3799). */
+export function buildListIssueRefsQuery(opts: ListIssueRefsOptions = {}): { sql: string; params: Array<string | number> } {
   const conditions: string[] = [];
   const params: Array<string | number> = [];
   if (opts.provider) {
@@ -272,16 +272,15 @@ export function listIssueRefs(opts: ListIssueRefsOptions = {}): IssueRef[] {
   if (!Number.isSafeInteger(limit) || limit <= 0 || limit > 500) throw new ValidationError("limit must be between 1 and 500");
   params.push(limit);
   const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
-  const rows = getDb().query(`
-    SELECT * FROM issue_refs
-    ${where}
-    ORDER BY updated_at DESC, created_at DESC, id DESC
-    LIMIT ?
-  `).all(...params) as IssueRefRow[];
-  return rows.map(rowToIssueRef);
+  return { sql: `SELECT * FROM issue_refs ${where} ORDER BY updated_at DESC, created_at DESC, id DESC LIMIT ?`, params };
+}
+
+export function listIssueRefs(opts: ListIssueRefsOptions = {}): IssueRef[] {
+  const { sql, params } = buildListIssueRefsQuery(opts);
+  return (getDb().query(sql).all(...params) as IssueRefRow[]).map(rowToIssueRef);
 }
 
-export function updateIssueRef(id: string, input: UpdateIssueRefInput): IssueRef | null {
+export function updateIssueRef(id: string, input: UpdateIssueRefInput, now: number = Date.now()): IssueRef | null {
   const existing = getIssueRef(requiredText(id, "id", 120));
   if (!existing) return null;
   const url = optionalText(input.url, "url", 2000) ?? existing.url;
@@ -295,7 +294,7 @@ export function updateIssueRef(id: string, input: UpdateIssueRefInput): IssueRef
     UPDATE issue_refs
     SET url = ?, title = ?, status = ?, close_reason = ?, status_synced_at = ?, updated_at = ?
     WHERE id = ?
-  `).run(url, title ?? null, status, closeReason ?? null, statusSyncedAt ?? null, Date.now(), existing.id);
+  `).run(url, title ?? null, status, closeReason ?? null, statusSyncedAt ?? null, now, existing.id);
   return getIssueRef(existing.id);
 }
 

package/src/db/kernel-event-log-schema.ts

@@ -1,4 +1,5 @@
 import { ensureEventLogSchema } from "@humwick/kernel/event-log";
+import { ensureKernelReplayRetentionSchema } from "@humwick/kernel/sqlite-kernel-persistence";
 import { getDb } from "./connection.ts";
 
 /**
@@ -11,4 +12,5 @@ import { getDb } from "./connection.ts";
  */
 export function ensureKernelEventLogSchema(): void {
   ensureEventLogSchema(getDb());
+  ensureKernelReplayRetentionSchema(getDb(), Date.now());
 }

package/src/db/land-boundaries.ts

@@ -1,7 +1,8 @@
 // #3363 — reads of the Kernel landing boundary and incident entities (kernel/landing-incident.ts) for
 // the red-main controller. Writes go through the Kernel ops (src/services/red-main-incident.ts).
 import type { LandBoundary, RedMainIncident } from "@humwick/kernel/landing-incident";
-import type { ShippingRedMain } from "@humwick/sdk";
+import { ciRunUrl, type ShippingFailingTest, type ShippingRedMain } from "@humwick/sdk";
+import type { BaseKnownFailure } from "@humwick/sdk/base-known-failures";
 import { getDb } from "./connection.ts";
 import { LAND_INCIDENT_TABLE, OPEN_INCIDENT_STATES } from "./land-incident-eligibility.ts";
 
@@ -81,12 +82,57 @@ export function openRedMainIncidentForRemote(remote: string): RedMainIncident |
   return row ? incident(row) : null;
 }
 
-/** The Shipping page's "lane stopped" lines: each open incident with its red sha. */
-export function openRedMainLines(): ShippingRedMain[] {
+type OpenIncidentRow = Record<string, unknown> & { redRemote: string; redSha: string };
+
+/** Open incidents with their red boundary. `i.*`: the Kernel adds a newer field's column only when the
+ *  landing module starts, so a read right after deploy must not name it (#3362 §11 failingTests). */
+function openIncidentRows(remote?: string): OpenIncidentRow[] {
   if (!tablesReady()) return [];
-  return getDb().query(`SELECT i.id AS incidentId, i.laneKey, i.state, i.mainFailurePolicy, b.remote, b.landedTipSha AS sha
+  return getDb().query(`SELECT i.*, b.remote AS redRemote, b.landedTipSha AS redSha
     FROM ${LAND_INCIDENT_TABLE} i JOIN ${BOUNDARY_TABLE} b ON b.id = i.redBoundaryId
-    WHERE i.state IN ${OPEN_STATES_SQL} ORDER BY i.openedAt, i.id`).all() as ShippingRedMain[];
+    WHERE i.state IN ${OPEN_STATES_SQL} AND (? IS NULL OR b.remote = ?) ORDER BY i.openedAt, i.id`).all(remote ?? null, remote ?? null) as OpenIncidentRow[];
+}
+
+function failingTestsOf(row: Record<string, unknown>): ShippingFailingTest[] {
+  if (typeof row.failingTests !== "string") return [];
+  try {
+    const parsed: unknown = JSON.parse(row.failingTests);
+    return Array.isArray(parsed) ? parsed.filter((entry): entry is ShippingFailingTest =>
+      typeof entry?.file === "string" && typeof entry?.name === "string") : [];
+  } catch {
+    console.warn(`[red-main] incident ${String(row.id)} has unreadable failingTests; showing none`);
+    return [];
+  }
+}
+
+function culpritTaskIds(row: Record<string, unknown>): number[] {
+  const ids = JSON.parse(String(row.culpritBoundaryIds ?? "[]")) as string[];
+  if (!ids.length) return [];
+  const rows = getDb().query(`SELECT DISTINCT taskId FROM ${BOUNDARY_TABLE} WHERE taskId IS NOT NULL AND id IN (${ids.map(() => "?").join(",")}) ORDER BY taskId`)
+    .all(...ids) as { taskId: number }[];
+  return rows.map((entry) => entry.taskId);
+}
+
+/** The Shipping page's red-main lines: each open incident with its red sha, failing cases, owners and run. */
+export function openRedMainLines(): ShippingRedMain[] {
+  return openIncidentRows().map((row) => {
+    const failingTests = failingTestsOf(row);
+    const ownerTaskIds = culpritTaskIds(row);
+    return {
+      incidentId: String(row.id), laneKey: String(row.laneKey), state: String(row.state),
+      ...(row.mainFailurePolicy ? { mainFailurePolicy: row.mainFailurePolicy as "stop" | "advisory" } : {}),
+      remote: row.redRemote, sha: row.redSha,
+      runUrl: ciRunUrl(row.redRemote, Number(row.ciRunId), Number(row.ciAttempt)),
+      ...(failingTests.length ? { failingTests } : {}),
+      ...(ownerTaskIds.length ? { ownerTaskIds } : {}),
+    };
+  });
+}
+
+/** #3362 §11: failing cases already present on `remote`'s main, which delivery gates hold out of unrelated runs. */
+export function baseKnownFailures(remote: string): BaseKnownFailure[] {
+  return openIncidentRows(remote).flatMap((row) =>
+    failingTestsOf(row).map((test) => ({ ...test, incidentId: String(row.id), sha: row.redSha })));
 }
 
 /** #3381 — whether any partial land happened (for `remote`, or anywhere when omitted): a boundary or a

package/src/db/land-gate-attestations.ts

@@ -110,7 +110,7 @@ export interface InsertLandGateAttestationInput extends Omit<LandGateAttestation
  * can legitimately land twice (a revert-and-reland, a retried push), and the FIRST green attestation
  * is as true as the second — so a conflict keeps the original rather than churning the row.
  */
-export function insertLandGateAttestation(input: InsertLandGateAttestationInput): LandGateAttestationRecord {
+export function insertLandGateAttestation(input: InsertLandGateAttestationInput, submittedAt: number = Date.now()): LandGateAttestationRecord {
   const record = decodeLandGateAttestationRow({
     repo: input.repo,
     tree_sha: input.treeSha,
@@ -121,7 +121,7 @@ export function insertLandGateAttestation(input: InsertLandGateAttestationInput)
     gate_names: JSON.stringify(input.gateNames),
     gates_ran: input.gatesRan,
     workspace_id: input.workspaceId ?? null,
-    attested_at: input.attestedAt ?? Date.now(),
+    attested_at: input.attestedAt ?? submittedAt,
     suite_coverage: input.suiteCoverage ?? null,
   });
   getDb().query(`

package/src/db/landing-receipts.ts

@@ -110,7 +110,7 @@ function receiptId(input: InsertLandingReceiptInput): string {
   return `landing_${createHash("sha256").update(key).digest("hex").slice(0, 24)}`;
 }
 
-export function insertLandingReceipt(input: InsertLandingReceiptInput): LandingReceipt {
+export function insertLandingReceipt(input: InsertLandingReceiptInput, submittedAt: number = Date.now()): LandingReceipt {
   const receipt: LandingReceipt = decodeLandingReceiptRow({
     id: receiptId(input),
     project_id: input.projectId ?? null,
@@ -127,7 +127,7 @@ export function insertLandingReceipt(input: InsertLandingReceiptInput): LandingR
     team_id: input.teamId ?? null,
     orchestrator_id: input.orchestratorId ?? null,
     host: input.host ?? null,
-    landed_at: input.landedAt ?? Date.now(),
+    landed_at: input.landedAt ?? submittedAt,
   });
   getDb().query(`
     INSERT INTO landing_receipts (

package/src/db/lifecycle-context-write.ts

@@ -0,0 +1,5 @@
+import { getDb } from "./connection";
+import type { ContextState } from "../types";
+export function persistAdvisoryContext(agentId: string, context: ContextState): void {
+  getDb().query("UPDATE agents SET context_state = ? WHERE id = ?").run(JSON.stringify(context), agentId);
+}

package/src/db/lifecycle-tail-async.ts

@@ -0,0 +1,76 @@
+import { randomUUID } from "node:crypto";
+import { getGateway } from "./gateway";
+import type { clearAgentNotice, recordTerminalEvent } from "./terminal-events";
+import type { recordCrashReport } from "./crash-reports";
+import type { stampSpawnPrincipal } from "./agent-ownership";
+import type { markSpawnRegistrationConfirmed } from "../commands-db";
+import type { seedSpawnPromptMirror } from "./message-reads";
+import type { resolveQueuedPolicyMessages, resolveQueuedDirectMessages } from "./delivery";
+import type { resolveQueuedCoordinatorMessages } from "./coordinator-delivery";
+import type { updateManagedAgentState } from "../config-store";
+import type { deleteWorkspace } from "./workspaces";
+import type { addSubscription, removeSubscription, removeSubscriptionsForTask } from "./notification-subscriptions";
+
+export function clearAgentNoticeAsync(...args: Parameters<typeof clearAgentNotice>): Promise<ReturnType<typeof clearAgentNotice>> {
+  return getGateway().write("lifecycleTail.clearAgentNotice", args) as unknown as Promise<ReturnType<typeof clearAgentNotice>>;
+}
+
+export function recordTerminalEventAsync(...args: Parameters<typeof recordTerminalEvent>): Promise<ReturnType<typeof recordTerminalEvent>> {
+  return getGateway().write("lifecycleTail.recordTerminalEvent", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof recordTerminalEvent>>;
+}
+
+export function recordCrashReportAsync(...args: Parameters<typeof recordCrashReport>): Promise<ReturnType<typeof recordCrashReport>> {
+  return getGateway().write("lifecycleTail.recordCrashReport", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof recordCrashReport>>;
+}
+
+export function stampSpawnPrincipalAsync(...args: Parameters<typeof stampSpawnPrincipal>): Promise<ReturnType<typeof stampSpawnPrincipal>> {
+  return getGateway().write("lifecycleTail.stampSpawnPrincipal", args) as unknown as Promise<ReturnType<typeof stampSpawnPrincipal>>;
+}
+
+export function markSpawnRegistrationConfirmedAsync(...args: Parameters<typeof markSpawnRegistrationConfirmed>): Promise<ReturnType<typeof markSpawnRegistrationConfirmed>> {
+  return getGateway().write("lifecycleTail.markSpawnRegistrationConfirmed", args) as unknown as Promise<ReturnType<typeof markSpawnRegistrationConfirmed>>;
+}
+
+export function seedSpawnPromptMirrorAsync(...args: Parameters<typeof seedSpawnPromptMirror>): Promise<ReturnType<typeof seedSpawnPromptMirror>> {
+  return getGateway().write("lifecycleTail.seedSpawnPromptMirror", args) as unknown as Promise<ReturnType<typeof seedSpawnPromptMirror>>;
+}
+
+export function resolveQueuedPolicyMessagesAsync(...args: Parameters<typeof resolveQueuedPolicyMessages>): Promise<ReturnType<typeof resolveQueuedPolicyMessages>> {
+  return getGateway().write("lifecycleTail.resolveQueuedPolicyMessages", args) as unknown as Promise<ReturnType<typeof resolveQueuedPolicyMessages>>;
+}
+
+export function resolveQueuedDirectMessagesAsync(...args: Parameters<typeof resolveQueuedDirectMessages>): Promise<ReturnType<typeof resolveQueuedDirectMessages>> {
+  return getGateway().write("lifecycleTail.resolveQueuedDirectMessages", args) as unknown as Promise<ReturnType<typeof resolveQueuedDirectMessages>>;
+}
+
+export function resolveQueuedCoordinatorMessagesAsync(...args: Parameters<typeof resolveQueuedCoordinatorMessages>): Promise<ReturnType<typeof resolveQueuedCoordinatorMessages>> {
+  return getGateway().write("lifecycleTail.resolveQueuedCoordinatorMessages", args) as unknown as Promise<ReturnType<typeof resolveQueuedCoordinatorMessages>>;
+}
+
+export function updateManagedAgentStateAsync(...args: Parameters<typeof updateManagedAgentState>): Promise<ReturnType<typeof updateManagedAgentState>> {
+  return getGateway().write("lifecycleTail.updateManagedAgentState", args) as unknown as Promise<ReturnType<typeof updateManagedAgentState>>;
+}
+
+export function deleteWorkspaceAsync(...args: Parameters<typeof deleteWorkspace>): Promise<ReturnType<typeof deleteWorkspace>> {
+  return getGateway().write("lifecycleTail.deleteWorkspace", args) as unknown as Promise<ReturnType<typeof deleteWorkspace>>;
+}
+
+export function addSubscriptionAsync(...args: Parameters<typeof addSubscription>): Promise<ReturnType<typeof addSubscription>> {
+  return getGateway().write("lifecycleTail.addSubscription", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof addSubscription>>;
+}
+
+export function removeSubscriptionAsync(...args: Parameters<typeof removeSubscription>): Promise<ReturnType<typeof removeSubscription>> {
+  return getGateway().write("lifecycleTail.removeSubscription", args) as unknown as Promise<ReturnType<typeof removeSubscription>>;
+}
+
+export function removeSubscriptionsForTaskAsync(...args: Parameters<typeof removeSubscriptionsForTask>): Promise<ReturnType<typeof removeSubscriptionsForTask>> {
+  return getGateway().write("lifecycleTail.removeSubscriptionsForTask", args) as unknown as Promise<ReturnType<typeof removeSubscriptionsForTask>>;
+}
+
+export function addSubscriptionsAsync(inputs: Array<Parameters<typeof addSubscription>[0]>): Promise<Array<ReturnType<typeof addSubscription>>> {
+  return getGateway().write("notifications.subscriptions.addBatch", { inputs }, { idempotencyKey: randomUUID() }) as unknown as Promise<Array<ReturnType<typeof addSubscription>>>;
+}
+
+export function upsertManagedAgentStateAsync(...args: Parameters<typeof import("../config-store").upsertManagedAgentState>): Promise<ReturnType<typeof import("../config-store").upsertManagedAgentState>> {
+  return getGateway().write("lifecycleTail.upsertManagedAgentState", args) as unknown as Promise<ReturnType<typeof import("../config-store").upsertManagedAgentState>>;
+}