@humwick/server 0.130.0 → 0.130.2

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

@@ -25,6 +25,7 @@ import {
   type PruneExpiredTokenRecordsInput,
 } from "../token-db.ts";
 import type { TokenRecord } from "../types.ts";
+import { recordLaunchFact, type LaunchFact } from "./launch-facts.ts";
 import type { TokenRevokeReason } from "../security.ts";
 import type { WriterOpContext, WriterOpSpec } from "./write-ops.ts";
 
@@ -41,6 +42,11 @@ export interface HandoffTokenOpArgs {
   readonly newJti: string;
 }
 
+/** Args for `tokens.createRunner`: a runner mint plus, for a fresh launch, its launch fact (#1870 S7). */
+export interface CreateRunnerTokenOpArgs extends CreateTokenOpArgs {
+  readonly launch?: { readonly agentId: string; readonly fact: LaunchFact };
+}
+
 export interface RevokeTokenOpArgs {
   readonly jti: string;
   readonly reason?: TokenRevokeReason;
@@ -67,12 +73,25 @@ function stripHandoffToken(result: unknown): unknown {
 export const TOKEN_DB_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
   // Non-idempotent (mints a new row each apply); the facade supplies `jti` as the ledger key.
   "tokens.create": {
+    offLoop: true,
     idempotent: false,
     fn: (args: CreateTokenOpArgs, ctx: WriterOpContext) => createTokenInternal(args.input, args.jti, ctx.now),
     serializeIdempotencyResult: stripCreateToken,
   },
+  // A runner mint and the launch fact its successors derive from, in one transaction.
+  "tokens.createRunner": {
+    offLoop: true,
+    idempotent: false,
+    fn: (args: CreateRunnerTokenOpArgs, ctx: WriterOpContext) => {
+      const issued = createTokenInternal(args.input, args.jti, ctx.now);
+      if (args.launch) recordLaunchFact(args.launch.agentId, args.launch.fact, ctx.now);
+      return issued;
+    },
+    serializeIdempotencyResult: stripCreateToken,
+  },
   // Non-idempotent (mints and links a successor); folds the eligibility read (ADR §3.4).
   "tokens.handoff": {
+    offLoop: true,
     idempotent: false,
     fn: (args: HandoffTokenOpArgs, ctx: WriterOpContext) => handoffTokenInternal(args.input, args.newJti, ctx.now),
     serializeIdempotencyResult: stripHandoffToken,
@@ -80,11 +99,13 @@ export const TOKEN_DB_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object
   // Idempotent by construction (the `revoked_at IS NULL` guard makes a re-apply a no-op). No key, no
   // secret in the boolean result.
   "tokens.revoke": {
+    offLoop: true,
     idempotent: true,
     fn: (args: RevokeTokenOpArgs, ctx: WriterOpContext) => revokeTokenInternal(args.jti, args.reason, ctx.now),
   },
   // Idempotent (deleting an already-reaped row is a no-op). Returns pruned jtis — not secret.
   "tokens.pruneExpired": {
+    offLoop: true,
     idempotent: true,
     fn: (args: PruneExpiredTokensOpArgs, ctx: WriterOpContext) =>
       pruneExpiredTokenRecordsInternal(args.input, ctx.now),

package/src/db/token-standing.ts

@@ -61,24 +61,28 @@ export function tokenRevocationReason(jti: string): string | null | undefined {
 /** A rotation retires one token for its successor, so it is never a lineage revocation. */
 export type LineageRevokeReason = Exclude<TokenRevokeReason, "rotation">;
 
-/** #1245 — a token and every token handed off from it (token-db.ts handoffTokenInternal) are one credential, so
- * revoking any of them revokes the whole lineage: unretired predecessors, pending successors and their renewals.
- * A hard reason also hardens stale members, so no auth, renewal or orchestrator recovery reaches the lineage. A
- * stale walk stops at stale members: what follows them is an orchestrator recovery. It never enters a `keep` token. */
-export function revokeTokenLineage(seeds: readonly string[], reason: LineageRevokeReason | null, nowSeconds: number, keep: readonly string[] = []): string[] {
-  if (seeds.length === 0) return [];
-  const rows = getDb().query(`
+// #3776 — each step must be a key lookup whatever sqlite_stat1 says: CROSS JOIN pins the join order and the unary
+// `+` keeps the predecessor index off the backward step, so stale stats cannot make the walk scan per member.
+export const TOKEN_LINEAGE_REVOKE_SQL = `
     WITH RECURSIVE kept(jti) AS (SELECT value FROM json_each(?1)),
     lineage(jti) AS (
       SELECT value FROM json_each(?2) WHERE value NOT IN kept
-      UNION SELECT t.jti FROM lineage l JOIN tokens p ON p.jti = l.jti JOIN tokens t ON t.predecessor_jti = p.jti
+      UNION SELECT t.jti FROM lineage l CROSS JOIN tokens p ON p.jti = l.jti CROSS JOIN tokens t ON t.predecessor_jti = p.jti
         WHERE t.jti NOT IN kept AND (?4 IS NOT 'stale' OR p.revoked_reason IS NOT 'stale')
-      UNION SELECT p.predecessor_jti FROM lineage l JOIN tokens p ON p.jti = l.jti
-        WHERE p.predecessor_jti IS NOT NULL AND p.predecessor_jti NOT IN kept AND (?4 IS NOT 'stale' OR p.revoked_reason IS NOT 'stale')
+      UNION SELECT p.predecessor_jti FROM lineage l CROSS JOIN tokens p ON p.jti = l.jti
+        WHERE +p.predecessor_jti IS NOT NULL AND +p.predecessor_jti NOT IN kept AND (?4 IS NOT 'stale' OR p.revoked_reason IS NOT 'stale')
     )
     UPDATE tokens SET revoked_at = COALESCE(revoked_at, ?3), revoked_reason = ?4
     WHERE jti IN lineage AND (revoked_at IS NULL OR (?4 IS NOT 'stale' AND revoked_reason = 'stale'))
     RETURNING jti
-  `).all(JSON.stringify(keep), JSON.stringify(seeds), nowSeconds, reason) as Array<{ jti: string }>;
+  `;
+
+/** #1245 — a token and every token handed off from it (token-db.ts handoffTokenInternal) are one credential, so
+ * revoking any of them revokes the whole lineage: unretired predecessors, pending successors and their renewals.
+ * A hard reason also hardens stale members, so no auth, renewal or orchestrator recovery reaches the lineage. A
+ * stale walk stops at stale members: what follows them is an orchestrator recovery. It never enters a `keep` token. */
+export function revokeTokenLineage(seeds: readonly string[], reason: LineageRevokeReason | null, nowSeconds: number, keep: readonly string[] = []): string[] {
+  if (seeds.length === 0) return [];
+  const rows = getDb().query(TOKEN_LINEAGE_REVOKE_SQL).all(JSON.stringify(keep), JSON.stringify(seeds), nowSeconds, reason) as Array<{ jti: string }>;
   return rows.map((row) => row.jti);
 }

package/src/db/user-settings-write-ops.ts

@@ -36,6 +36,7 @@ export const USER_SETTINGS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = O
   },
   // Idempotent by construction: deleting again finds no row (`existing` null → early false).
   "userSettings.delete": {
+    offLoop: true,
     idempotent: true,
     fn: (args: DeleteUserSettingOpArgs) => deleteUserSetting(getDb(), args.userId, args.namespace, args.key),
   },

package/src/db/vault-backup.ts

@@ -54,6 +54,6 @@ export function syncVaultBackupWarning(args: { kind: VaultBackupWarning | null;
 }
 
 export const VAULT_BACKUP_WRITE_OPS = {
-  "secretsVault.backup.record": { idempotent: true, fn: recordVaultBackup },
-  "secretsVault.backup.warn": { idempotent: true, fn: syncVaultBackupWarning },
+  "secretsVault.backup.record": { offLoop: true, idempotent: true, fn: recordVaultBackup },
+  "secretsVault.backup.warn": { offLoop: true, idempotent: true, fn: syncVaultBackupWarning },
 };

package/src/db/vault-expiry.ts

@@ -66,6 +66,6 @@ export function prepareVaultExpiryNotices(args: { now: number }) {
 }
 
 export const VAULT_EXPIRY_WRITE_OPS = {
-  "secretsVault.expiry.prepare": { idempotent: true, fn: prepareVaultExpiryNotices },
-  "secretsVault.expiry.sent": { idempotent: true, fn: (args: { id: number }) => { getDb().query("UPDATE vault_expiry_notices SET notified=1 WHERE decision_id=?").run(args.id); } },
+  "secretsVault.expiry.prepare": { offLoop: true, idempotent: true, fn: prepareVaultExpiryNotices },
+  "secretsVault.expiry.sent": { offLoop: true, idempotent: true, fn: (args: { id: number }) => { getDb().query("UPDATE vault_expiry_notices SET notified=1 WHERE decision_id=?").run(args.id); } },
 };

package/src/db/vault-health.ts

@@ -85,9 +85,9 @@ export function logPage(args: { profile?: string; before?: { at: number; id: num
 }
 
 export const VAULT_HEALTH_WRITE_OPS: Record<string, WriterOpSpec> = {
-  "vaultHealth.host": { idempotent: true, fn: (host: ServiceAccessHostHealth, ctx: WriterOpContext) => { writeState("host", host, ctx.now); return null; } },
-  "vaultHealth.collect": { idempotent: true, fn: (input: VaultLogCollect, ctx: WriterOpContext) => collectVaultLogs(input, ctx.now) },
-  "vaultHealth.prune": { idempotent: true, fn: (args: { now: number }) => pruneVaultLogs(args.now) },
+  "vaultHealth.host": { offLoop: true, idempotent: true, fn: (host: ServiceAccessHostHealth, ctx: WriterOpContext) => { writeState("host", host, ctx.now); return null; } },
+  "vaultHealth.collect": { offLoop: true, idempotent: true, fn: (input: VaultLogCollect, ctx: WriterOpContext) => collectVaultLogs(input, ctx.now) },
+  "vaultHealth.prune": { offLoop: true, idempotent: true, fn: (args: { now: number }) => pruneVaultLogs(args.now) },
 };
 
 export const VAULT_HEALTH_READ_OPS = {

package/src/db/vault-token-ops.ts

@@ -3,12 +3,12 @@ import { settleVaultToken, revokeVaultTokens, recordOrphanVaultToken, pruneVault
 import type { WriterOpContext, WriterOpSpec } from "./write-ops";
 
 export const VAULT_TOKEN_WRITE_OPS: Record<string, WriterOpSpec> = {
-  "vaultTokens.orphan": { idempotent: true, fn: (row: VaultTokenRow) => recordOrphanVaultToken(row) },
-  "vaultTokens.prune": { idempotent: true, fn: (args: { now: number }) => pruneVaultTokens(args.now) },
-  "vaultTokens.begin": { idempotent: false, fn: (row: VaultTokenRow) => beginVaultToken(row) },
-  "vaultTokens.activate": { idempotent: true, fn: (args: { id: string; sessionId: string; expiresAt: number }, ctx: WriterOpContext) => activateVaultToken(args.id, args.sessionId, args.expiresAt, ctx.now) },
-  "vaultTokens.renew": { idempotent: true, fn: (args: { id: string; sessionId: string; expiresAt: number }, ctx: WriterOpContext) => renewVaultToken(args.id, args.sessionId, args.expiresAt, ctx.now) },
-  "vaultTokens.check": { idempotent: true, fn: (args: { id: string; now: number }) => checkVaultToken(args.id, args.now) ?? null },
-  "vaultTokens.settle": { idempotent: false, fn: (args: { id: string; error?: string }, ctx: WriterOpContext) => { settleVaultToken(args.id, ctx.now, args.error); return null; } },
-  "vaultTokens.revoke": { idempotent: true, fn: (args: { agentId: string; instanceId: string; spawnRequestId: string; launchId: string }, ctx: WriterOpContext) => { revokeVaultTokens(args.agentId, ctx.now, "runner_release", args.instanceId, args.spawnRequestId, args.launchId); return null; } },
+  "vaultTokens.orphan": { offLoop: true, idempotent: true, fn: (row: VaultTokenRow) => recordOrphanVaultToken(row) },
+  "vaultTokens.prune": { offLoop: true, idempotent: true, fn: (args: { now: number }) => pruneVaultTokens(args.now) },
+  "vaultTokens.begin": { offLoop: true, idempotent: false, fn: (row: VaultTokenRow) => beginVaultToken(row) },
+  "vaultTokens.activate": { offLoop: true, idempotent: true, fn: (args: { id: string; sessionId: string; expiresAt: number }, ctx: WriterOpContext) => activateVaultToken(args.id, args.sessionId, args.expiresAt, ctx.now) },
+  "vaultTokens.renew": { offLoop: true, idempotent: true, fn: (args: { id: string; sessionId: string; expiresAt: number }, ctx: WriterOpContext) => renewVaultToken(args.id, args.sessionId, args.expiresAt, ctx.now) },
+  "vaultTokens.check": { offLoop: true, idempotent: true, fn: (args: { id: string; now: number }) => checkVaultToken(args.id, args.now) ?? null },
+  "vaultTokens.settle": { offLoop: true, idempotent: false, fn: (args: { id: string; error?: string }, ctx: WriterOpContext) => { settleVaultToken(args.id, ctx.now, args.error); return null; } },
+  "vaultTokens.revoke": { offLoop: true, idempotent: true, fn: (args: { agentId: string; instanceId: string; spawnRequestId: string; launchId: string }, ctx: WriterOpContext) => { revokeVaultTokens(args.agentId, ctx.now, "runner_release", args.instanceId, args.spawnRequestId, args.launchId); return null; } },
 };

package/src/db/web-tool-call-ops.ts

@@ -9,7 +9,7 @@ export const WEB_TOOL_CALL_READ_OPS = {
 };
 
 export const WEB_TOOL_CALL_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = {
-  "webSearch.reserveBrave": { idempotent: false, fn: (args: { month: string }) => reserveBraveSearch(args.month) },
-  "webToolCalls.record": { idempotent: true, fn: (call: WebToolCall) => { recordWebToolCall(call); return null; } },
-  "webToolCalls.prune": { idempotent: true, fn: (args: { before: number }) => pruneWebToolCalls(args.before) },
+  "webSearch.reserveBrave": { offLoop: true, idempotent: false, fn: (args: { month: string }) => reserveBraveSearch(args.month) },
+  "webToolCalls.record": { offLoop: true, idempotent: true, fn: (call: WebToolCall) => { recordWebToolCall(call); return null; } },
+  "webToolCalls.prune": { offLoop: true, idempotent: true, fn: (args: { before: number }) => pruneWebToolCalls(args.before) },
 };

package/src/db/workflow-contact.ts

@@ -20,7 +20,7 @@ export interface WorkflowHeldContact { runId: string; reason: WorkflowContactRea
 
 /** Notices that bypass the step-contact hold: the run's own coordinator notices (including GO awaiting an external
  *  hold's release), and a step agent held on a provider block, which waits until someone acts (#3647). */
-const COORDINATOR_NOTICE_KINDS = new Set(["workflow.started", "workflow.landed", "workflow.escalated", "workflow.result", "workflow.review-passed", "agent.spawn_failed", "agent.spawn_recovered", "delegation.budget_exhausted", "agent.provider_blocked", "agent.provider_still_held"]);
+const COORDINATOR_NOTICE_KINDS = new Set(["workflow.started", "workflow.landed", "workflow.escalated", "workflow.result", "workflow.review-passed", "workflow.paused", "workflow.unpaused", "agent.spawn_failed", "agent.spawn_recovered", "delegation.budget_exhausted", "agent.provider_blocked", "agent.provider_still_held"]);
 export const WORKFLOW_SCOPE = "local";
 export const WORKFLOW_RUN_TABLE = "kernel_entity__workflow__run";
 const LINK_TABLE = "kernel_entity__workflow__link";

package/src/db/workflow-task-read-ops.ts

@@ -185,3 +185,33 @@ export function openWorkflowRunHolders(): { teamIds: Set<string>; coordinatorIds
   }
   return holders;
 }
+
+/** #3757 — a running run a coordinator paused, with its input Task's team; `pause` is the stored JSON. */
+export interface PausedWorkflowRunRow {
+  runId: string; taskId: number; taskTitle: string | null; coordinator: string; callerAgentId: string | null;
+  teamId: string | null; owner: string | null; pause: string;
+}
+
+let pauseColumnOn: unknown;
+/** The column appears when the workflow module first registers after #3757; until then nothing is paused. */
+function pauseColumnReady(): boolean {
+  const db = getDb();
+  if (pauseColumnOn === db) return true;
+  const ready = (db.query(`PRAGMA table_info(${WORKFLOW_RUN_TABLE})`).all() as Array<{ name: string }>).some((column) => column.name === "pause");
+  if (ready) pauseColumnOn = db;
+  return ready;
+}
+
+export function pausedWorkflowRuns(): PausedWorkflowRunRow[] {
+  if (!workflowTablesReady() || !pauseColumnReady()) return [];
+  return getDb().query(`SELECT run.id AS runId, run.taskId AS taskId, task.title AS taskTitle, run.coordinator AS coordinator, run.callerAgentId AS callerAgentId,
+      task.team_id AS teamId, task.owner AS owner, run.pause AS pause
+    FROM ${WORKFLOW_RUN_TABLE} run LEFT JOIN tasks task ON task.id = run.taskId
+    WHERE run.scope = ? AND run.status = 'running' AND run.pause IS NOT NULL ORDER BY run.id`).all(WORKFLOW_SCOPE) as PausedWorkflowRunRow[];
+}
+
+/** #3757 — a paused run keeps its idle step agents: the idle reapers leave them alone until it is unpaused. */
+export function workflowRunPaused(runId: string): boolean {
+  if (!workflowTablesReady() || !pauseColumnReady()) return false;
+  return Boolean(getDb().query(`SELECT 1 FROM ${WORKFLOW_RUN_TABLE} WHERE scope = ? AND id = ? AND status = 'running' AND pause IS NOT NULL`).get(WORKFLOW_SCOPE, runId));
+}

package/src/db/write-ops.ts

@@ -1,3 +1,4 @@
+import { INTEGRATIONS_WRITE_OPS } from "./integrations-ops.ts";
 import { bufferedLastSeen, type PresenceSnapshot } from "./presence-buffer";
 import { ensureDurablePayloadSchema, readRetryReceipt, storeDurablePayload } from "./durable-payloads";
 import { ledgerSlotPredicate, ledgerSlots, WRITER_IDEMPOTENCY_RETENTION_MS } from "./writer-ledger";
@@ -5,6 +6,7 @@ import { workspaceChangeListeners } from "./workspaces";
 import { withWriterOpState } from "./main-thread-state";
 import { importVaultRows } from "./secrets-vault-import";
 import { PROMPT_VERSION_WRITE_OPS } from "./prompt-versions-ops";
+import { PROJECT_PROFILE_INSTRUCTION_WRITE_OPS } from "./project-profile-instructions";
 import { VAULT_WRITE_OPS } from "./secrets-vault-write";
 import { VAULT_EXPIRY_WRITE_OPS } from "./vault-expiry";
 import { VAULT_BACKUP_WRITE_OPS } from "./vault-backup";
@@ -117,6 +119,7 @@ import { RESTART_EPOCH_WRITE_OPS } from "./restart-epoch-write-ops.ts";
 import { TOKEN_USAGE_WRITE_OPS } from "./token-usage-write-ops.ts";
 // #1870 S3 — the 1 s raw writers: maintenance leases/runs, pending issue closes, workspace lifecycle.
 import { MAINTENANCE_JOB_WRITE_OPS } from "./maintenance-job-write-ops.ts";
+import { ISSUE_REFS_WRITE_OPS } from "./issue-refs-write-ops.ts";
 import { LONG_RUNNING_WORK_WRITE_OPS } from "./long-running-work-write-ops.ts";
 import { WORKSPACE_WRITE_OPS } from "./workspace-write-ops.ts";
 
@@ -260,6 +263,7 @@ export const WRITER_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze(
   // Delete all probe rows — a test reset. Deleting again reaches the same end state, so re-applying is
   // safe: idempotent, no key required.
   "seam.reset": {
+    offLoop: true,
     idempotent: true,
     fn: () => {
       const before = (getDb().query("SELECT COUNT(*) AS n FROM _writer_seam_probe").get() as { n: number }).n;
@@ -286,6 +290,7 @@ export const WRITER_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze(
   // must NOT enter the retry ledger — the retry re-evaluates fresh and can succeed once the blocker
   // clears — while an applied outcome dedups exactly-once as usual.
   "seam.claimLike": {
+    offLoop: true,
     idempotent: false,
     fn: (args: { tag: string; refuse?: boolean }, ctx) => {
       if (args.refuse) return { applied: false };
@@ -301,6 +306,7 @@ export const WRITER_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze(
   // single transaction (or savepoint), the first insert MUST roll back — the atomic-multi-statement
   // proof across the boundary (§3.4). Inserts rows — NON-idempotent, key required.
   "seam.txPair": {
+    offLoop: true,
     idempotent: false,
     fn: (args: { a: string; b: string; failSecond?: boolean }, ctx) => {
       const first = getDb()
@@ -318,6 +324,7 @@ export const WRITER_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze(
   // the main thread as a real `ValidationError` (instanceof true), not a bare `Error`. No state change,
   // so re-applying is safe: idempotent, no key required.
   "seam.throwValidation": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { message?: string }) => {
       throw new ValidationError(args.message ?? "seam.throwValidation");
@@ -327,6 +334,7 @@ export const WRITER_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze(
   // Insert-once keyed by `idem_key` in its OWN args — dedups by construction (`ON CONFLICT DO
   // NOTHING`), so it is idempotent and needs no gateway key.
   "seam.idempotent": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { key: string; value?: string }, ctx) => {
       const inserted = getDb()
@@ -347,6 +355,7 @@ export const WRITER_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze(
   // marshaling seam (H1) clones args before the op and clones the result after, so the caller's object
   // is NEVER mutated and the caller sees only the cloned result — as across a real worker boundary.
   "seam.mutateArg": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { n: number }) => {
       args.n += 1000;
@@ -358,6 +367,7 @@ export const WRITER_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze(
   // integration suite to force a writer-job deadline (H4 wedged-writer): Atomics.wait on a private
   // buffer is a true synchronous sleep the gateway deadline fires behind. No write, so idempotent.
   "seam.sleep": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { ms: number }) => {
       Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, Math.max(0, args.ms));
@@ -368,6 +378,7 @@ export const WRITER_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze(
   // A writer-side read of committed state, for tests to verify persistence without a reader gateway
   // (the writer reading its own connection trivially sees its own writes — §3.5). Read-only: idempotent.
   "seam.snapshot": {
+    offLoop: true,
     idempotent: true,
     fn: () => {
       const rows = getDb().query("SELECT id, tag, value, idem_key FROM _writer_seam_probe ORDER BY id").all();
@@ -398,6 +409,7 @@ export function allWriterOps(): Readonly<Record<string, WriterOpSpec>> {
   ...ROUTING_POLICY_WRITE_OPS,
       ...USER_SETTINGS_WRITE_OPS,
   ...PROMPT_VERSION_WRITE_OPS,
+  ...PROJECT_PROFILE_INSTRUCTION_WRITE_OPS,
       ...TOKEN_DB_WRITE_OPS,
       ...DELIVERY_WRITE_OPS,
       ...TIMER_WRITE_OPS,
@@ -432,6 +444,7 @@ export function allWriterOps(): Readonly<Record<string, WriterOpSpec>> {
     ...SPAWN_TREE_CLEANUP_WRITE_OPS,
     ...PROJECTS_WRITE_OPS,
     ...CHANNELS_WRITE_OPS,
+    ...INTEGRATIONS_WRITE_OPS,
     ...CI_INCIDENTS_WRITE_OPS,
     ...TEAMS_WRITE_OPS,
     ...TEAM_SPAWN_DELEGATION_WRITE_OPS,
@@ -450,7 +463,7 @@ export function allWriterOps(): Readonly<Record<string, WriterOpSpec>> {
   ...VAULT_WRITE_OPS,
   ...VAULT_EXPIRY_WRITE_OPS,
   ...VAULT_BACKUP_WRITE_OPS,
-  "secretsVault.import": { idempotent: false, fn: importVaultRows },
+  "secretsVault.import": { offLoop: true, idempotent: false, fn: importVaultRows },
   ...MACOS_PRIVACY_WRITE_OPS,
     ...PROVIDER_FLAP_MESSAGES_WRITE_OPS,
     ...PROVIDER_CATALOG_WRITE_OPS,
@@ -460,6 +473,7 @@ export function allWriterOps(): Readonly<Record<string, WriterOpSpec>> {
     ...TOKEN_USAGE_WRITE_OPS,
     ...MAINTENANCE_JOB_WRITE_OPS,
     ...LONG_RUNNING_WORK_WRITE_OPS,
+    ...ISSUE_REFS_WRITE_OPS,
     ...WORKSPACE_WRITE_OPS,
     ...WEB_TOOL_CALL_WRITE_OPS,
     ...CLAUDE_API_BUDGET_WRITE_OPS,

package/src/db/writer-fault-seam.ts

@@ -1,4 +1,3 @@
-import { mainThreadRegistry } from "./main-thread-state";
 // The writer-side fault-injection seam for relocated db ops (ADR 0001 §3.1 H6, S3 leaf L-C #1899).
 //
 // WHY THIS EXISTS. Several timer ops carry test-only crash hooks that must fire INSIDE the op's
@@ -37,7 +36,11 @@ interface ArmedWriterFault {
   readonly threadId: number;
 }
 
-const armed = mainThreadRegistry("writer fault callbacks", new Map<string, ArmedWriterFault>());
+// Deliberately NOT a mainThreadRegistry (#1870 S6a): off-loop op bodies call `writerFault`, and on the
+// writer thread this map is empty, so the lookup is a harmless no-op there. Delivery is kept honest at
+// dispatch: while a fault is armed the in-process backend runs off-loop ops on the arming thread
+// (writer-gateway `dispatchEntry`), and arming refuses under the worker backend.
+const armed = new Map<string, ArmedWriterFault>();
 
 /**
  * Whether a main-thread fault closure can still reach an op body. False once the gateway stands up

package/src/db/writer-gateway.ts

@@ -43,6 +43,7 @@ import { WriterDrain } from "./writer-drain";
 import { errMessage } from "@humwick/sdk";
 import { createWorkerPool, type WorkerPool } from "@humwick/offload";
 import { getDbGeneration, getDbPath } from "./connection.ts";
+import { armedWriterFaultCount } from "./writer-fault-seam.ts";
 import { onLoopWriteTransaction } from "./on-loop-write-transaction.ts";
 // On-loop-block attribution (#1882 / ADR §5). `resolveLoopCallsite` pins the effective callsite onto a
 // submission in the CALLER's context; `captureSyncFrame` times the op body where it actually runs — in
@@ -173,8 +174,9 @@ export interface WriterStats {
    * SQLite lock (H4 §3.6.1). A wedged writer is NOT idle — this is deliberately distinct from
    * `busy:0`, which is how the naive pool-replace path mis-reported the stall. New non-critical
    * writes shed and critical writes are held until the wedged op completes and the FIFO resumes.
+   * #3776 — names the op holding the writer and how long it has run, so health says WHICH job; null when not wedged.
    */
-  wedged: boolean;
+  wedged: { op: string; runningMs: number } | null;
   /**
    * #2276 — how many times the IN-PROCESS drain has yielded the event loop mid-convoy because its
    * time slice was spent. 0 on the worker backend (nothing to slice). A steadily climbing count is
@@ -258,7 +260,7 @@ let drainYields = 0;
 // lock (§3.6.1). Cleared when that in-flight job finally settles (the op completed and released the
 // lock), which re-kicks the FIFO drain. Worker backend only — an in-process op runs synchronously on
 // the main thread, so it cannot be observed mid-stall.
-let wedged = false;
+let wedgedOp: { op: string; startedAt: number } | undefined;
 
 // Test-only fault injection for the precise H5 window: the op has COMMITTED, but its
 // acknowledgement is lost before the caller observes the result. One-shot by design so a retry
@@ -354,14 +356,14 @@ function createFileWriter(dbPath: string): WorkerBackend {
 
 /** Server shutdown keeps already-admitted writes; test/reset teardown remains immediate. */
 export async function drainWriterOnShutdown(): Promise<void> {
-  try { await shutdownDrain.start(() => !draining && !wedged && pendingWriteDepth() === 0 && inFlightWrites() === 0); }
+  try { await shutdownDrain.start(() => !draining && !wedgedOp && pendingWriteDepth() === 0 && inFlightWrites() === 0); }
   finally { await shutdownWriter(); }
 }
 
 export async function shutdownWriter(): Promise<void> {
   const current = backend;
   backend = undefined;
-  wedged = false;
+  wedgedOp = undefined;
   // Reject anything still queued at the gateway so no caller hangs across a teardown.
   const stranded = submissionQueue.splice(0, submissionQueue.length);
   for (const entry of stranded) {
@@ -378,7 +380,8 @@ export function isWriterInitialized(): boolean {
 }
 
 export function writerStats(): WriterStats {
-  if (!backend) return { backend: "uninitialized", queued: 0, busy: 0, highWater: queueHighWater, wedged: false, drainYields };
+  if (!backend) return { backend: "uninitialized", queued: 0, busy: 0, highWater: queueHighWater, wedged: null, drainYields };
+  const wedged = wedgedOp ? { op: wedgedOp.op, runningMs: Math.round(performance.now() - wedgedOp.startedAt) } : null;
   if (backend.kind === "in-process") {
     return { backend: "in-process", queued: pendingWriteDepth(), busy: inFlightWrites(), highWater: queueHighWater, wedged, drainYields };
   }
@@ -479,7 +482,7 @@ function admitOrThrow(op: string, opts: WriteOpts | undefined, count: number): v
   const occupancy = pendingWriteDepth() + inFlightWrites();
   if (occupancy + count > queueHardCap) throw new WriterOverloadedError(op, occupancy);
   if (opts?.critical) return;
-  const workerWedged = wedged;
+  const workerWedged = wedgedOp !== undefined;
   if (workerWedged || occupancy + count > queueHighWater) throw new WriterOverloadedError(op, occupancy);
 }
 
@@ -510,7 +513,7 @@ async function drainLoop(): Promise<void> {
     // second concurrent drain and anything submitted meanwhile is picked up by this same loop when
     // it resumes — FIFO is preserved, the queue is only PAUSED.
     let sliceStartedAt = performance.now();
-    while (submissionQueue.length > 0 && !wedged) {
+    while (submissionQueue.length > 0 && !wedgedOp) {
       const entry = submissionQueue.shift()!;
       const onLoop = backend?.kind === "in-process";
       await dispatchEntry(entry);
@@ -520,7 +523,7 @@ async function drainLoop(): Promise<void> {
         sliceStartedAt = performance.now();
         continue;
       }
-      if (submissionQueue.length === 0 || wedged) continue;
+      if (submissionQueue.length === 0 || wedgedOp) continue;
       if (performance.now() - sliceStartedAt < drainSliceMs) continue;
       drainYields += 1;
       await yieldEventLoop();
@@ -528,7 +531,7 @@ async function drainLoop(): Promise<void> {
     }
   } finally {
     draining = false;
-    shutdownDrain.notify(!wedged && pendingWriteDepth() === 0 && inFlightWrites() === 0);
+    shutdownDrain.notify(!wedgedOp && pendingWriteDepth() === 0 && inFlightWrites() === 0);
   }
 }
 
@@ -551,7 +554,9 @@ async function dispatchEntry(entry: Submission): Promise<void> {
     back.busy = true;
     try {
       const path = getDbPath();
-      if (path && path !== ":memory:" && isOffLoopWriterOp(entry.op)) {
+      // An armed crash seam is a closure on THIS thread, so while one is armed the op runs here instead
+      // of on the file-DB worker (tests only; production never arms). Otherwise the fault would never fire.
+      if (path && path !== ":memory:" && isOffLoopWriterOp(entry.op) && armedWriterFaultCount() === 0) {
         if (back.offLoop && back.offLoopGeneration !== getDbGeneration()) {
           await back.offLoop.pool.destroy();
           back.offLoop = undefined;
@@ -647,6 +652,7 @@ async function dispatchWorker(entry: Submission, back: WorkerBackend): Promise<v
 
   // retrySafe stays false (default): a write must NEVER be auto-re-dispatched (it would repeat its
   // effect). No pool timeout is armed — the deadline is the gateway's own (§3.6.1).
+  const startedAt = performance.now();
   const poolPromise = back.pool.run<WriterJobInput, WriterJobResult>(WRITER_TASK_NAME, input, { labels });
 
   let timer: ReturnType<typeof setTimeout> | undefined;
@@ -662,13 +668,16 @@ async function dispatchWorker(entry: Submission, back: WorkerBackend): Promise<v
     // WEDGED (§3.6.1). The op is still running and still holds the lock; do NOT replace the worker.
     // Surface the caller's INDETERMINATE outcome, hold the FIFO, and resume when the op finally
     // settles (it commits/rolls back and releases the lock on the SAME warm connection).
-    wedged = true;
+    // #3776 — name the op: "writer wedged" alone left an incident to guess which job held the lock.
+    wedgedOp = { op: entry.op, startedAt };
+    console.warn(`[writer-gateway] writer op ${entry.op} has held the writer past its ${writerTimeoutMs}ms deadline; writes are held until it settles`);
     rejectIndeterminate(entry);
     poolPromise.then(
       () => {},
       () => {},
     ).finally(() => {
-      wedged = false;
+      console.warn(`[writer-gateway] wedged writer op ${entry.op} settled after ${Math.round(performance.now() - startedAt)}ms`);
+      wedgedOp = undefined;
       kickDrain();
     }).catch((error) => console.error(`[writer-gateway] resume after wedge failed: ${errMessage(error)}`));
     return;

package/src/dispatch-availability.ts

@@ -1,5 +1,5 @@
-import type { HostView, Orchestrator } from "@humwick/sdk";
-import type { ProviderCatalogEntry } from "@humwick/sdk/provider-catalog";
+import { errMessage, type HostView, type Orchestrator } from "@humwick/sdk";
+import { resolveProviderSelection, type ProviderCatalogEntry } from "@humwick/sdk/provider-catalog";
 import type { DispatchTarget } from "./task-dispatcher";
 import { spawnPlacementRefusal, hostSpawnAdmission, hostIdentitiesById, spawnHostCapAdmission, type SpawnCapOptions } from "./spawn-placement";
 import { liveHostDisabledProviders } from "./host-provider-store";
@@ -17,13 +17,15 @@ export interface LiveTargetAdmission {
   targetUnavailableReason: (target: DispatchTarget) => string | undefined;
 }
 
-export function liveTargetAdmission(orchestrators: readonly Orchestrator[], views: readonly HostView[], orchestratorId?: string, capOpts: SpawnCapOptions = {}): LiveTargetAdmission {
+export function liveTargetAdmission(orchestrators: readonly Orchestrator[], views: readonly HostView[], catalog: ProviderCatalogEntry[], orchestratorId?: string, capOpts: SpawnCapOptions = {}): LiveTargetAdmission {
   const identities = hostIdentitiesById(views);
   const byId = new Map(views.map((view) => [view.id, view]));
   const disabled = liveHostDisabledProviders();
   const capBlock = spawnHostCapAdmission(capOpts);
   const hosts = orchestrators.filter((host) => !orchestratorId || host.id === orchestratorId);
   const targetAdmission = ({ provider, model, effort }: DispatchTarget): TargetAdmission => {
+    try { resolveProviderSelection({ provider, model, effort }, catalog); }
+    catch { return { eligible: false, uncertainties: [] }; }
     let eligible = false;
     const uncertainties: TargetUncertainty[] = [];
     for (const host of hosts) {
@@ -34,9 +36,11 @@ export function liveTargetAdmission(orchestrators: readonly Orchestrator[], view
     }
     return { eligible, uncertainties };
   };
-  const targetUnavailableReason = (target: DispatchTarget) => spawnPlacementRefusal(
-    orchestrators, views, target.provider, target.model, target.effort, orchestratorId, capOpts,
-  );
+  const targetUnavailableReason = (target: DispatchTarget) => {
+    try { resolveProviderSelection(target, catalog); }
+    catch (error) { return errMessage(error); }
+    return spawnPlacementRefusal(orchestrators, views, target.provider, target.model, target.effort, orchestratorId, capOpts);
+  };
   return { targetAdmission, targetUnavailableReason };
 }
 

package/src/ephemeral/{landing-ingress-proof-worker.ts → landing-ingress-proof.test-fixture.ts}

@@ -1,7 +1,7 @@
 /** Precondition setup for the packaged-ephemeral landing-ingress Proof of Life.
  * Delivery and both crash boundaries run through the packaged Relay; this fixture only registers
  * the disposable workspace that its real ephemeral orchestrator will probe. */
-import { initDb } from "../db/schema.ts";
+import { closeDb, openExistingDb } from "../db/connection.ts";
 import { upsertWorkspace } from "../db/workspaces.ts";
 
 const dbPath = process.env.DB_PATH;
@@ -13,7 +13,8 @@ if (!dbPath || !worktreePath || !orchestratorId || !baseSha) {
   throw new Error("usage: landing-ingress-proof-worker <worktree-path> <orchestrator-id> <base-sha>");
 }
 
-initDb(dbPath);
+// The installed Relay already owns the schema; a fixture must not migrate its live DB (#3715).
+openExistingDb(dbPath);
 upsertWorkspace({
   id: workspaceId,
   repoRoot: worktreePath,
@@ -27,4 +28,5 @@ upsertWorkspace({
   orchestratorId,
   metadata: {},
 });
+closeDb();
 console.log(JSON.stringify({ workspaceId }));