@humwick/server 0.130.2 → 0.130.4

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)) },
+});

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

@@ -0,0 +1,288 @@
+import type { pruneWorkspaceOrphanAlerts, pruneOrphanedSharedWorkspaces, claimWorkspaceOrphanAlert, claimWorkspaceHumanEscalationAlert, pruneStaleWorkspaceHumanEscalationAlerts, reelectRepoSteward } from "./workspaces";
+import type { upsertProjectTrustApproval } from "./project-trust-approvals";
+import type { setProjectJournalFields } from "./project-journal";
+import type { promoteLineageCapturedResponse, markSelfResumeContinuationIngested } from "./messages";
+import type { acquireMergePause, acquireMergeLease, releaseMergeLease, releaseExpiredMergeLeases, releaseExpiredMergePauses, renewMergePause, releaseMergePause } from "./merge-lease";
+import type { ingestIntegrationEvent, upsertIntegrationRegistry } from "./integrations";
+import type { refreshPendingLandQueueLease } from "./commands-claim-admission";
+import type { writeEntry, retractEntry } from "./blackboard";
+import type { fencePublishForPush, cancelPendingCommand } from "../commands-db";
+import { randomUUID } from "node:crypto";
+import { getGateway } from "./gateway";
+import { deferLineageReport } from "./deferred-lineage-reports";
+import { applyLineageReportEffects } from "./messages";
+import { evictPendingPresence } from "./presence-buffer";
+import type { deleteOrchestratorRow } from "./orchestrators";
+import type { setUserSecret, createAuthIdentity } from "./auth-identities";
+import type { markWorkspaceCarryPending, confirmWorkspaceCarryPendingForTask } from "./carry-pending-marker";
+import type { ensureContinuationEnvelope, updateContinuationObjective } from "./continuations";
+import type { releaseDriveLease, releaseExpiredDriveLeases } from "./drive-leases";
+import type { finishIdleDigestScan, updateIdleDigestScan, startIdleDigestWindow } from "./idle-digest";
+import type { associateIssue, removeAssociation } from "./issue-associations";
+import type { insertLandGateAttestation } from "./land-gate-attestations";
+import type { insertLandingReceipt } from "./landing-receipts";
+import type { recordIssueLifecycleComment } from "./long-running-work";
+import type { pauseMaintenanceJob, resumeMaintenanceJob } from "./maintenance-pauses";
+import type { updateOpenOperatorDecision, withdrawOpenOperatorDecision } from "./operator-decisions";
+import type { deleteOrchestrator } from "./orchestrators";
+import type { upsertTemplate, resetTemplate } from "./prompt-templates";
+import type { setReviewRefFenceToken, markReviewRefPublished, markReviewRefAnnounced, markReviewRefFailed, markReviewRefClosed, recordReviewRefCleanupDispatch, deleteReviewRefCleanup } from "./review-ref-cleanups";
+import type { insertTaskEvent } from "./task-core";
+import type { clearTeamIdleEntry, setTeamIdleEntry } from "./team-idle";
+import type { updateUserProfile, updateUserAccess } from "./users";
+import type { upsertTokenProfile, updateTokenProfile, deleteTokenProfile } from "../token-db";
+
+export function setUserSecretAsync(...args: Parameters<typeof setUserSecret>): Promise<ReturnType<typeof setUserSecret>> {
+  return getGateway().write("runtimeTail.setUserSecret", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof setUserSecret>>;
+}
+
+export function createAuthIdentityAsync(...args: Parameters<typeof createAuthIdentity>): Promise<ReturnType<typeof createAuthIdentity>> {
+  return getGateway().write("runtimeTail.createAuthIdentity", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof createAuthIdentity>>;
+}
+
+export function retractEntryAsync(...args: Parameters<typeof retractEntry>): Promise<ReturnType<typeof retractEntry>> {
+  return getGateway().write("runtimeTail.retractEntry", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof retractEntry>>;
+}
+
+export function markWorkspaceCarryPendingAsync(...args: Parameters<typeof markWorkspaceCarryPending>): Promise<ReturnType<typeof markWorkspaceCarryPending>> {
+  return getGateway().write("runtimeTail.markWorkspaceCarryPending", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof markWorkspaceCarryPending>>;
+}
+
+export function confirmWorkspaceCarryPendingForTaskAsync(...args: Parameters<typeof confirmWorkspaceCarryPendingForTask>): Promise<ReturnType<typeof confirmWorkspaceCarryPendingForTask>> {
+  return getGateway().write("runtimeTail.confirmWorkspaceCarryPendingForTask", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof confirmWorkspaceCarryPendingForTask>>;
+}
+
+export function ensureContinuationEnvelopeAsync(...args: Parameters<typeof ensureContinuationEnvelope>): Promise<ReturnType<typeof ensureContinuationEnvelope>> {
+  return getGateway().write("runtimeTail.ensureContinuationEnvelope", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof ensureContinuationEnvelope>>;
+}
+
+export function updateContinuationObjectiveAsync(...args: Parameters<typeof updateContinuationObjective>): Promise<ReturnType<typeof updateContinuationObjective>> {
+  return getGateway().write("runtimeTail.updateContinuationObjective", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof updateContinuationObjective>>;
+}
+
+export function releaseDriveLeaseAsync(...args: Parameters<typeof releaseDriveLease>): Promise<ReturnType<typeof releaseDriveLease>> {
+  return getGateway().write("runtimeTail.releaseDriveLease", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof releaseDriveLease>>;
+}
+
+export function releaseExpiredDriveLeasesAsync(...args: Parameters<typeof releaseExpiredDriveLeases>): Promise<ReturnType<typeof releaseExpiredDriveLeases>> {
+  return getGateway().write("runtimeTail.releaseExpiredDriveLeases", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof releaseExpiredDriveLeases>>;
+}
+
+export function finishIdleDigestScanAsync(...args: Parameters<typeof finishIdleDigestScan>): Promise<ReturnType<typeof finishIdleDigestScan>> {
+  return getGateway().write("runtimeTail.finishIdleDigestScan", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof finishIdleDigestScan>>;
+}
+
+export function updateIdleDigestScanAsync(...args: Parameters<typeof updateIdleDigestScan>): Promise<ReturnType<typeof updateIdleDigestScan>> {
+  return getGateway().write("runtimeTail.updateIdleDigestScan", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof updateIdleDigestScan>>;
+}
+
+export function startIdleDigestWindowAsync(...args: Parameters<typeof startIdleDigestWindow>): Promise<ReturnType<typeof startIdleDigestWindow>> {
+  return getGateway().write("runtimeTail.startIdleDigestWindow", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof startIdleDigestWindow>>;
+}
+
+export function associateIssueAsync(...args: Parameters<typeof associateIssue>): Promise<ReturnType<typeof associateIssue>> {
+  return getGateway().write("runtimeTail.associateIssue", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof associateIssue>>;
+}
+
+export function removeAssociationAsync(...args: Parameters<typeof removeAssociation>): Promise<ReturnType<typeof removeAssociation>> {
+  return getGateway().write("runtimeTail.removeAssociation", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof removeAssociation>>;
+}
+
+export function insertLandGateAttestationAsync(...args: Parameters<typeof insertLandGateAttestation>): Promise<ReturnType<typeof insertLandGateAttestation>> {
+  return getGateway().write("runtimeTail.insertLandGateAttestation", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof insertLandGateAttestation>>;
+}
+
+export function insertLandingReceiptAsync(...args: Parameters<typeof insertLandingReceipt>): Promise<ReturnType<typeof insertLandingReceipt>> {
+  return getGateway().write("runtimeTail.insertLandingReceipt", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof insertLandingReceipt>>;
+}
+
+export function recordIssueLifecycleCommentAsync(...args: Parameters<typeof recordIssueLifecycleComment>): Promise<ReturnType<typeof recordIssueLifecycleComment>> {
+  return getGateway().write("runtimeTail.recordIssueLifecycleComment", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof recordIssueLifecycleComment>>;
+}
+
+export function pauseMaintenanceJobAsync(...args: Parameters<typeof pauseMaintenanceJob>): Promise<ReturnType<typeof pauseMaintenanceJob>> {
+  return getGateway().write("runtimeTail.pauseMaintenanceJob", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof pauseMaintenanceJob>>;
+}
+
+export function resumeMaintenanceJobAsync(...args: Parameters<typeof resumeMaintenanceJob>): Promise<ReturnType<typeof resumeMaintenanceJob>> {
+  return getGateway().write("runtimeTail.resumeMaintenanceJob", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof resumeMaintenanceJob>>;
+}
+
+export function releaseMergeLeaseAsync(...args: Parameters<typeof releaseMergeLease>): Promise<ReturnType<typeof releaseMergeLease>> {
+  return getGateway().write("runtimeTail.releaseMergeLease", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof releaseMergeLease>>;
+}
+
+export function releaseExpiredMergeLeasesAsync(...args: Parameters<typeof releaseExpiredMergeLeases>): Promise<ReturnType<typeof releaseExpiredMergeLeases>> {
+  return getGateway().write("runtimeTail.releaseExpiredMergeLeases", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof releaseExpiredMergeLeases>>;
+}
+
+export function releaseExpiredMergePausesAsync(...args: Parameters<typeof releaseExpiredMergePauses>): Promise<ReturnType<typeof releaseExpiredMergePauses>> {
+  return getGateway().write("runtimeTail.releaseExpiredMergePauses", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof releaseExpiredMergePauses>>;
+}
+
+export function renewMergePauseAsync(...args: Parameters<typeof renewMergePause>): Promise<ReturnType<typeof renewMergePause>> {
+  return getGateway().write("runtimeTail.renewMergePause", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof renewMergePause>>;
+}
+
+export function releaseMergePauseAsync(...args: Parameters<typeof releaseMergePause>): Promise<ReturnType<typeof releaseMergePause>> {
+  return getGateway().write("runtimeTail.releaseMergePause", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof releaseMergePause>>;
+}
+
+export function markSelfResumeContinuationIngestedAsync(...args: Parameters<typeof markSelfResumeContinuationIngested>): Promise<ReturnType<typeof markSelfResumeContinuationIngested>> {
+  return getGateway().write("runtimeTail.markSelfResumeContinuationIngested", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof markSelfResumeContinuationIngested>>;
+}
+
+export function updateOpenOperatorDecisionAsync(...args: Parameters<typeof updateOpenOperatorDecision>): Promise<ReturnType<typeof updateOpenOperatorDecision>> {
+  return getGateway().write("runtimeTail.updateOpenOperatorDecision", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof updateOpenOperatorDecision>>;
+}
+
+export function withdrawOpenOperatorDecisionAsync(...args: Parameters<typeof withdrawOpenOperatorDecision>): Promise<ReturnType<typeof withdrawOpenOperatorDecision>> {
+  return getGateway().write("runtimeTail.withdrawOpenOperatorDecision", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof withdrawOpenOperatorDecision>>;
+}
+
+export async function deleteOrchestratorAsync(...args: Parameters<typeof deleteOrchestrator>): Promise<ReturnType<typeof deleteOrchestrator>> {
+  const result = await getGateway().write("runtimeTail.deleteOrchestrator", args, { idempotencyKey: randomUUID() }) as unknown as ReturnType<typeof deleteOrchestratorRow>;
+  if (result.agentId) evictPendingPresence(result.agentId);
+  return result.deleted;
+}
+
+export function upsertTemplateAsync(...args: Parameters<typeof upsertTemplate>): Promise<ReturnType<typeof upsertTemplate>> {
+  return getGateway().write("runtimeTail.upsertTemplate", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof upsertTemplate>>;
+}
+
+export function resetTemplateAsync(...args: Parameters<typeof resetTemplate>): Promise<ReturnType<typeof resetTemplate>> {
+  return getGateway().write("runtimeTail.resetTemplate", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof resetTemplate>>;
+}
+
+export function setReviewRefFenceTokenAsync(...args: Parameters<typeof setReviewRefFenceToken>): Promise<ReturnType<typeof setReviewRefFenceToken>> {
+  return getGateway().write("runtimeTail.setReviewRefFenceToken", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof setReviewRefFenceToken>>;
+}
+
+export function markReviewRefPublishedAsync(...args: Parameters<typeof markReviewRefPublished>): Promise<ReturnType<typeof markReviewRefPublished>> {
+  return getGateway().write("runtimeTail.markReviewRefPublished", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof markReviewRefPublished>>;
+}
+
+export function markReviewRefAnnouncedAsync(...args: Parameters<typeof markReviewRefAnnounced>): Promise<ReturnType<typeof markReviewRefAnnounced>> {
+  return getGateway().write("runtimeTail.markReviewRefAnnounced", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof markReviewRefAnnounced>>;
+}
+
+export function markReviewRefFailedAsync(...args: Parameters<typeof markReviewRefFailed>): Promise<ReturnType<typeof markReviewRefFailed>> {
+  return getGateway().write("runtimeTail.markReviewRefFailed", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof markReviewRefFailed>>;
+}
+
+export function markReviewRefClosedAsync(...args: Parameters<typeof markReviewRefClosed>): Promise<ReturnType<typeof markReviewRefClosed>> {
+  return getGateway().write("runtimeTail.markReviewRefClosed", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof markReviewRefClosed>>;
+}
+
+export function recordReviewRefCleanupDispatchAsync(...args: Parameters<typeof recordReviewRefCleanupDispatch>): Promise<ReturnType<typeof recordReviewRefCleanupDispatch>> {
+  return getGateway().write("runtimeTail.recordReviewRefCleanupDispatch", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof recordReviewRefCleanupDispatch>>;
+}
+
+export function deleteReviewRefCleanupAsync(...args: Parameters<typeof deleteReviewRefCleanup>): Promise<ReturnType<typeof deleteReviewRefCleanup>> {
+  return getGateway().write("runtimeTail.deleteReviewRefCleanup", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof deleteReviewRefCleanup>>;
+}
+
+export function insertTaskEventAsync(...args: Parameters<typeof insertTaskEvent>): Promise<ReturnType<typeof insertTaskEvent>> {
+  return getGateway().write("runtimeTail.insertTaskEvent", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof insertTaskEvent>>;
+}
+
+export function clearTeamIdleEntryAsync(...args: Parameters<typeof clearTeamIdleEntry>): Promise<ReturnType<typeof clearTeamIdleEntry>> {
+  return getGateway().write("runtimeTail.clearTeamIdleEntry", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof clearTeamIdleEntry>>;
+}
+
+export function setTeamIdleEntryAsync(...args: Parameters<typeof setTeamIdleEntry>): Promise<ReturnType<typeof setTeamIdleEntry>> {
+  return getGateway().write("runtimeTail.setTeamIdleEntry", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof setTeamIdleEntry>>;
+}
+
+export function updateUserProfileAsync(...args: Parameters<typeof updateUserProfile>): Promise<ReturnType<typeof updateUserProfile>> {
+  return getGateway().write("runtimeTail.updateUserProfile", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof updateUserProfile>>;
+}
+
+export function updateUserAccessAsync(...args: Parameters<typeof updateUserAccess>): Promise<ReturnType<typeof updateUserAccess>> {
+  return getGateway().write("runtimeTail.updateUserAccess", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof updateUserAccess>>;
+}
+
+export function claimWorkspaceOrphanAlertAsync(...args: Parameters<typeof claimWorkspaceOrphanAlert>): Promise<ReturnType<typeof claimWorkspaceOrphanAlert>> {
+  return getGateway().write("runtimeTail.claimWorkspaceOrphanAlert", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof claimWorkspaceOrphanAlert>>;
+}
+
+export function claimWorkspaceHumanEscalationAlertAsync(...args: Parameters<typeof claimWorkspaceHumanEscalationAlert>): Promise<ReturnType<typeof claimWorkspaceHumanEscalationAlert>> {
+  return getGateway().write("runtimeTail.claimWorkspaceHumanEscalationAlert", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof claimWorkspaceHumanEscalationAlert>>;
+}
+
+export function pruneStaleWorkspaceHumanEscalationAlertsAsync(...args: Parameters<typeof pruneStaleWorkspaceHumanEscalationAlerts>): Promise<ReturnType<typeof pruneStaleWorkspaceHumanEscalationAlerts>> {
+  return getGateway().write("runtimeTail.pruneStaleWorkspaceHumanEscalationAlerts", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof pruneStaleWorkspaceHumanEscalationAlerts>>;
+}
+
+export function reelectRepoStewardAsync(...args: Parameters<typeof reelectRepoSteward>): Promise<ReturnType<typeof reelectRepoSteward>> {
+  return getGateway().write("runtimeTail.reelectRepoSteward", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof reelectRepoSteward>>;
+}
+
+export function upsertTokenProfileAsync(...args: Parameters<typeof upsertTokenProfile>): Promise<ReturnType<typeof upsertTokenProfile>> {
+  return getGateway().write("runtimeTail.upsertTokenProfile", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof upsertTokenProfile>>;
+}
+
+export function updateTokenProfileAsync(...args: Parameters<typeof updateTokenProfile>): Promise<ReturnType<typeof updateTokenProfile>> {
+  return getGateway().write("runtimeTail.updateTokenProfile", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof updateTokenProfile>>;
+}
+
+export function deleteTokenProfileAsync(...args: Parameters<typeof deleteTokenProfile>): Promise<ReturnType<typeof deleteTokenProfile>> {
+  return getGateway().write("runtimeTail.deleteTokenProfile", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof deleteTokenProfile>>;
+}
+
+export function cancelPendingCommandAsync(...args: Parameters<typeof cancelPendingCommand>): Promise<ReturnType<typeof cancelPendingCommand>> {
+  return getGateway().write("runtimeTail.cancelPendingCommand", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof cancelPendingCommand>>;
+}
+
+export function fencePublishForPushAsync(...args: Parameters<typeof fencePublishForPush>): Promise<ReturnType<typeof fencePublishForPush>> {
+  return getGateway().write("runtimeTail.fencePublishForPush", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof fencePublishForPush>>;
+}
+
+export function writeEntryAsync(...args: Parameters<typeof writeEntry>): Promise<ReturnType<typeof writeEntry>> {
+  return getGateway().write("runtimeTail.writeEntry", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof writeEntry>>;
+}
+
+export function refreshPendingLandQueueLeaseAsync(...args: Parameters<typeof refreshPendingLandQueueLease>): Promise<ReturnType<typeof refreshPendingLandQueueLease>> {
+  return getGateway().write("runtimeTail.refreshPendingLandQueueLease", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof refreshPendingLandQueueLease>>;
+}
+
+export function upsertIntegrationRegistryAsync(...args: Parameters<typeof upsertIntegrationRegistry>): Promise<ReturnType<typeof upsertIntegrationRegistry>> {
+  return getGateway().write("runtimeTail.upsertIntegrationRegistry", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof upsertIntegrationRegistry>>;
+}
+
+export function ingestIntegrationEventAsync(...args: Parameters<typeof ingestIntegrationEvent>): Promise<ReturnType<typeof ingestIntegrationEvent>> {
+  return getGateway().write("runtimeTail.ingestIntegrationEvent", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof ingestIntegrationEvent>>;
+}
+
+export function acquireMergeLeaseAsync(...args: Parameters<typeof acquireMergeLease>): Promise<ReturnType<typeof acquireMergeLease>> {
+  return getGateway().write("runtimeTail.acquireMergeLease", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof acquireMergeLease>>;
+}
+
+export function acquireMergePauseAsync(...args: Parameters<typeof acquireMergePause>): Promise<ReturnType<typeof acquireMergePause>> {
+  return getGateway().write("runtimeTail.acquireMergePause", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof acquireMergePause>>;
+}
+
+export async function promoteLineageCapturedResponseAsync(message: Parameters<typeof promoteLineageCapturedResponse>[0]): Promise<ReturnType<typeof promoteLineageCapturedResponse>> {
+  const value = await getGateway().write("runtimeTail.promoteLineageCapturedResponse", [message], { idempotencyKey: randomUUID() }) as unknown as {
+    result: ReturnType<typeof promoteLineageCapturedResponse>; deferred: Array<{ childId: string; messageId: number }>;
+  };
+  for (const effect of value.deferred) deferLineageReport(effect.childId, effect.messageId);
+  applyLineageReportEffects(value.result);
+  return value.result;
+}
+
+export function setProjectJournalFieldsAsync(...args: Parameters<typeof setProjectJournalFields>): Promise<ReturnType<typeof setProjectJournalFields>> {
+  return getGateway().write("runtimeTail.setProjectJournalFields", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof setProjectJournalFields>>;
+}
+
+export function upsertProjectTrustApprovalAsync(...args: Parameters<typeof upsertProjectTrustApproval>): Promise<ReturnType<typeof upsertProjectTrustApproval>> {
+  return getGateway().write("runtimeTail.upsertProjectTrustApproval", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof upsertProjectTrustApproval>>;
+}
+
+export function pruneOrphanedSharedWorkspacesAsync(...args: Parameters<typeof pruneOrphanedSharedWorkspaces>): Promise<ReturnType<typeof pruneOrphanedSharedWorkspaces>> {
+  return getGateway().write("runtimeTail.pruneOrphanedSharedWorkspaces", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof pruneOrphanedSharedWorkspaces>>;
+}
+
+export function pruneWorkspaceOrphanAlertsAsync(...args: Parameters<typeof pruneWorkspaceOrphanAlerts>): Promise<ReturnType<typeof pruneWorkspaceOrphanAlerts>> {
+  return getGateway().write("runtimeTail.pruneWorkspaceOrphanAlerts", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof pruneWorkspaceOrphanAlerts>>;
+}

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

@@ -0,0 +1,97 @@
+import { redactCommandSecrets } from "../command-secrets";
+import { pruneWorkspaceOrphanAlerts, pruneOrphanedSharedWorkspaces, claimWorkspaceOrphanAlert, claimWorkspaceHumanEscalationAlert, pruneStaleWorkspaceHumanEscalationAlerts, reelectRepoSteward } from "./workspaces";
+import { upsertProjectTrustApproval } from "./project-trust-approvals";
+import { setProjectJournalFields } from "./project-journal";
+import { promoteLineageCapturedResponse, markSelfResumeContinuationIngested } from "./messages";
+import { acquireMergePause, acquireMergeLease, releaseMergeLease, releaseExpiredMergeLeases, releaseExpiredMergePauses, renewMergePause, releaseMergePause } from "./merge-lease";
+import { ingestIntegrationEvent, upsertIntegrationRegistry } from "./integrations";
+import { refreshPendingLandQueueLease } from "./commands-claim-admission";
+import { writeEntry, retractEntry } from "./blackboard";
+import { fencePublishForPush, cancelPendingCommand } from "../commands-db";
+import { setUserSecret, createAuthIdentity } from "./auth-identities";
+import { markWorkspaceCarryPending, confirmWorkspaceCarryPendingForTask } from "./carry-pending-marker";
+import { ensureContinuationEnvelope, updateContinuationObjective } from "./continuations";
+import { releaseDriveLease, releaseExpiredDriveLeases } from "./drive-leases";
+import { finishIdleDigestScan, updateIdleDigestScan, startIdleDigestWindow } from "./idle-digest";
+import { associateIssue, removeAssociation } from "./issue-associations";
+import { insertLandGateAttestation } from "./land-gate-attestations";
+import { insertLandingReceipt } from "./landing-receipts";
+import { recordIssueLifecycleComment } from "./long-running-work";
+import { pauseMaintenanceJob, resumeMaintenanceJob } from "./maintenance-pauses";
+import { updateOpenOperatorDecision, withdrawOpenOperatorDecision } from "./operator-decisions";
+import { deleteOrchestratorRow } from "./orchestrators";
+import { upsertTemplate, resetTemplate } from "./prompt-templates";
+import { setReviewRefFenceToken, markReviewRefPublished, markReviewRefAnnounced, markReviewRefFailed, markReviewRefClosed, recordReviewRefCleanupDispatch, deleteReviewRefCleanup } from "./review-ref-cleanups";
+import { insertTaskEvent } from "./task-core";
+import { clearTeamIdleEntry, setTeamIdleEntry } from "./team-idle";
+import { updateUserProfile, updateUserAccess } from "./users";
+import { upsertTokenProfile, updateTokenProfile, deleteTokenProfile } from "../token-db";
+import type { WriterOpSpec } from "./write-ops";
+
+export const RUNTIME_TAIL_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
+  "runtimeTail.setUserSecret": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof setUserSecret>) => setUserSecret(...args) ?? null },
+  "runtimeTail.createAuthIdentity": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof createAuthIdentity>, ctx) => { const values: Parameters<typeof createAuthIdentity> = [...args]; values[1] ??= ctx.now; return createAuthIdentity(...values) ?? null; } },
+  "runtimeTail.retractEntry": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof retractEntry>, ctx) => { const values: Parameters<typeof retractEntry> = [...args]; values[1] ??= ctx.now; return retractEntry(...values) ?? null; } },
+  "runtimeTail.markWorkspaceCarryPending": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof markWorkspaceCarryPending>) => markWorkspaceCarryPending(...args) ?? null },
+  "runtimeTail.confirmWorkspaceCarryPendingForTask": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof confirmWorkspaceCarryPendingForTask>) => confirmWorkspaceCarryPendingForTask(...args) ?? null },
+  "runtimeTail.ensureContinuationEnvelope": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof ensureContinuationEnvelope>, ctx) => { const values: Parameters<typeof ensureContinuationEnvelope> = [...args]; values[1] ??= ctx.now; return ensureContinuationEnvelope(...values) ?? null; } },
+  "runtimeTail.updateContinuationObjective": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof updateContinuationObjective>, ctx) => { const values: Parameters<typeof updateContinuationObjective> = [...args]; values[1] ??= ctx.now; return updateContinuationObjective(...values) ?? null; } },
+  "runtimeTail.releaseDriveLease": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof releaseDriveLease>) => releaseDriveLease(...args) ?? null },
+  "runtimeTail.releaseExpiredDriveLeases": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof releaseExpiredDriveLeases>, ctx) => { const values: Parameters<typeof releaseExpiredDriveLeases> = [...args]; values[0] ??= ctx.now; return releaseExpiredDriveLeases(...values) ?? null; } },
+  "runtimeTail.finishIdleDigestScan": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof finishIdleDigestScan>) => finishIdleDigestScan(...args) ?? null },
+  "runtimeTail.updateIdleDigestScan": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof updateIdleDigestScan>) => updateIdleDigestScan(...args) ?? null },
+  "runtimeTail.startIdleDigestWindow": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof startIdleDigestWindow>) => startIdleDigestWindow(...args) ?? null },
+  "runtimeTail.associateIssue": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof associateIssue>, ctx) => { const values: Parameters<typeof associateIssue> = [...args]; values[4] ??= ctx.now; return associateIssue(...values) ?? null; } },
+  "runtimeTail.removeAssociation": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof removeAssociation>) => removeAssociation(...args) ?? null },
+  "runtimeTail.insertLandGateAttestation": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof insertLandGateAttestation>, ctx) => { const values: Parameters<typeof insertLandGateAttestation> = [...args]; values[1] ??= ctx.now; return insertLandGateAttestation(...values) ?? null; } },
+  "runtimeTail.insertLandingReceipt": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof insertLandingReceipt>, ctx) => { const values: Parameters<typeof insertLandingReceipt> = [...args]; values[1] ??= ctx.now; return insertLandingReceipt(...values) ?? null; } },
+  "runtimeTail.recordIssueLifecycleComment": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof recordIssueLifecycleComment>) => recordIssueLifecycleComment(...args) ?? null },
+  "runtimeTail.pauseMaintenanceJob": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof pauseMaintenanceJob>, ctx) => { const values: Parameters<typeof pauseMaintenanceJob> = [...args]; values[1] ??= ctx.now; return pauseMaintenanceJob(...values) ?? null; } },
+  "runtimeTail.resumeMaintenanceJob": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof resumeMaintenanceJob>) => resumeMaintenanceJob(...args) ?? null },
+  "runtimeTail.releaseMergeLease": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof releaseMergeLease>) => releaseMergeLease(...args) ?? null },
+  "runtimeTail.releaseExpiredMergeLeases": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof releaseExpiredMergeLeases>, ctx) => { const values: Parameters<typeof releaseExpiredMergeLeases> = [...args]; values[0] ??= ctx.now; return releaseExpiredMergeLeases(...values) ?? null; } },
+  "runtimeTail.releaseExpiredMergePauses": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof releaseExpiredMergePauses>, ctx) => { const values: Parameters<typeof releaseExpiredMergePauses> = [...args]; values[0] ??= ctx.now; return releaseExpiredMergePauses(...values) ?? null; } },
+  "runtimeTail.renewMergePause": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof renewMergePause>, ctx) => { const values: Parameters<typeof renewMergePause> = [...args]; values[2] ??= ctx.now; return renewMergePause(...values) ?? null; } },
+  "runtimeTail.releaseMergePause": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof releaseMergePause>) => releaseMergePause(...args) ?? null },
+  "runtimeTail.markSelfResumeContinuationIngested": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof markSelfResumeContinuationIngested>, ctx) => { const values: Parameters<typeof markSelfResumeContinuationIngested> = [...args]; values[1] ??= ctx.now; return markSelfResumeContinuationIngested(...values) ?? null; } },
+  "runtimeTail.updateOpenOperatorDecision": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof updateOpenOperatorDecision>, ctx) => { const values: Parameters<typeof updateOpenOperatorDecision> = [...args]; values[2] ??= ctx.now; return updateOpenOperatorDecision(...values) ?? null; } },
+  "runtimeTail.withdrawOpenOperatorDecision": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof withdrawOpenOperatorDecision>, ctx) => { const values: Parameters<typeof withdrawOpenOperatorDecision> = [...args]; values[1] ??= ctx.now; return withdrawOpenOperatorDecision(...values) ?? null; } },
+  "runtimeTail.deleteOrchestrator": { offLoop: true, idempotent: false, fn: (args: [string], ctx) => deleteOrchestratorRow(args[0], ctx.now) },
+  "runtimeTail.upsertTemplate": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof upsertTemplate>, ctx) => { const values: Parameters<typeof upsertTemplate> = [...args]; values[2] ??= ctx.now; return upsertTemplate(...values) ?? null; } },
+  "runtimeTail.resetTemplate": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof resetTemplate>, ctx) => { const values: Parameters<typeof resetTemplate> = [...args]; values[1] ??= ctx.now; return resetTemplate(...values) ?? null; } },
+  "runtimeTail.setReviewRefFenceToken": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof setReviewRefFenceToken>, ctx) => { const values: Parameters<typeof setReviewRefFenceToken> = [...args]; values[2] ??= ctx.now; return setReviewRefFenceToken(...values) ?? null; } },
+  "runtimeTail.markReviewRefPublished": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof markReviewRefPublished>, ctx) => { const values: Parameters<typeof markReviewRefPublished> = [...args]; values[2] ??= ctx.now; return markReviewRefPublished(...values) ?? null; } },
+  "runtimeTail.markReviewRefAnnounced": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof markReviewRefAnnounced>, ctx) => { const values: Parameters<typeof markReviewRefAnnounced> = [...args]; values[1] ??= ctx.now; return markReviewRefAnnounced(...values) ?? null; } },
+  "runtimeTail.markReviewRefFailed": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof markReviewRefFailed>, ctx) => { const values: Parameters<typeof markReviewRefFailed> = [...args]; values[1] ??= ctx.now; return markReviewRefFailed(...values) ?? null; } },
+  "runtimeTail.markReviewRefClosed": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof markReviewRefClosed>, ctx) => { const values: Parameters<typeof markReviewRefClosed> = [...args]; values[1] ??= ctx.now; return markReviewRefClosed(...values) ?? null; } },
+  "runtimeTail.recordReviewRefCleanupDispatch": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof recordReviewRefCleanupDispatch>, ctx) => { const values: Parameters<typeof recordReviewRefCleanupDispatch> = [...args]; values[3] ??= ctx.now; return recordReviewRefCleanupDispatch(...values) ?? null; } },
+  "runtimeTail.deleteReviewRefCleanup": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof deleteReviewRefCleanup>) => deleteReviewRefCleanup(...args) ?? null },
+  "runtimeTail.insertTaskEvent": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof insertTaskEvent>, ctx) => { const values: Parameters<typeof insertTaskEvent> = [...args]; values[2] ??= ctx.now; return insertTaskEvent(...values) ?? null; } },
+  "runtimeTail.clearTeamIdleEntry": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof clearTeamIdleEntry>) => clearTeamIdleEntry(...args) ?? null },
+  "runtimeTail.setTeamIdleEntry": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof setTeamIdleEntry>) => setTeamIdleEntry(...args) ?? null },
+  "runtimeTail.updateUserProfile": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof updateUserProfile>, ctx) => { const values: Parameters<typeof updateUserProfile> = [...args]; values[1] ??= ctx.now; return updateUserProfile(...values) ?? null; } },
+  "runtimeTail.updateUserAccess": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof updateUserAccess>, ctx) => { const values: Parameters<typeof updateUserAccess> = [...args]; values[1] ??= ctx.now; return updateUserAccess(...values) ?? null; } },
+  "runtimeTail.claimWorkspaceOrphanAlert": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof claimWorkspaceOrphanAlert>, ctx) => { const values: Parameters<typeof claimWorkspaceOrphanAlert> = [...args]; values[2] ??= ctx.now; return claimWorkspaceOrphanAlert(...values) ?? null; } },
+  "runtimeTail.claimWorkspaceHumanEscalationAlert": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof claimWorkspaceHumanEscalationAlert>, ctx) => { const values: Parameters<typeof claimWorkspaceHumanEscalationAlert> = [...args]; values[1] ??= ctx.now; return claimWorkspaceHumanEscalationAlert(...values) ?? null; } },
+  "runtimeTail.pruneStaleWorkspaceHumanEscalationAlerts": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof pruneStaleWorkspaceHumanEscalationAlerts>, ctx) => { const values: Parameters<typeof pruneStaleWorkspaceHumanEscalationAlerts> = [...args]; values[0] ??= ctx.now; return pruneStaleWorkspaceHumanEscalationAlerts(...values) ?? null; } },
+  "runtimeTail.reelectRepoSteward": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof reelectRepoSteward>) => reelectRepoSteward(...args) ?? null },
+  "runtimeTail.upsertTokenProfile": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof upsertTokenProfile>, ctx) => { const values: Parameters<typeof upsertTokenProfile> = [...args]; values[1] ??= ctx.now; return upsertTokenProfile(...values) ?? null; } },
+  "runtimeTail.updateTokenProfile": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof updateTokenProfile>) => updateTokenProfile(...args) ?? null },
+  "runtimeTail.deleteTokenProfile": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof deleteTokenProfile>) => deleteTokenProfile(...args) ?? null },
+  "runtimeTail.cancelPendingCommand": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof cancelPendingCommand>, ctx) => { const values: Parameters<typeof cancelPendingCommand> = [...args]; values[3] ??= ctx.now; return cancelPendingCommand(...values) ?? null; } },
+  "runtimeTail.fencePublishForPush": { offLoop: true, idempotent: false, serializeIdempotencyResult: value => value ? redactCommandSecrets(value as import("../types").Command) : null, fn: (args: Parameters<typeof fencePublishForPush>) => fencePublishForPush(...args) ?? null },
+  "runtimeTail.writeEntry": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof writeEntry>) => writeEntry(...args) ?? null },
+  "runtimeTail.refreshPendingLandQueueLease": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof refreshPendingLandQueueLease>, ctx) => { const values: Parameters<typeof refreshPendingLandQueueLease> = [...args]; values[1] ??= ctx.now; return refreshPendingLandQueueLease(...values) ?? null; } },
+  "runtimeTail.upsertIntegrationRegistry": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof upsertIntegrationRegistry>, ctx) => { const values: Parameters<typeof upsertIntegrationRegistry> = [...args]; values[1] ??= ctx.now; return upsertIntegrationRegistry(...values) ?? null; } },
+  "runtimeTail.ingestIntegrationEvent": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof ingestIntegrationEvent>) => ingestIntegrationEvent(...args) ?? null },
+  "runtimeTail.acquireMergeLease": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof acquireMergeLease>) => acquireMergeLease(...args) ?? null },
+  "runtimeTail.acquireMergePause": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof acquireMergePause>) => acquireMergePause(...args) ?? null },
+  "runtimeTail.promoteLineageCapturedResponse": { offLoop: true, idempotent: false, fn: (args: [Parameters<typeof promoteLineageCapturedResponse>[0]]) => {
+    const deferred: NonNullable<Parameters<typeof promoteLineageCapturedResponse>[1]> = [];
+    return { result: promoteLineageCapturedResponse(args[0], deferred), deferred };
+  } },
+  "runtimeTail.setProjectJournalFields": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof setProjectJournalFields>, ctx) => { const values: Parameters<typeof setProjectJournalFields> = [...args]; values[1] ??= ctx.now; return setProjectJournalFields(...values) ?? null; } },
+  "runtimeTail.upsertProjectTrustApproval": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof upsertProjectTrustApproval>, ctx) => { const values: Parameters<typeof upsertProjectTrustApproval> = [...args]; values[1] ??= ctx.now; return upsertProjectTrustApproval(...values) ?? null; } },
+  "runtimeTail.pruneOrphanedSharedWorkspaces": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof pruneOrphanedSharedWorkspaces>) => pruneOrphanedSharedWorkspaces(...args) ?? null },
+  "runtimeTail.pruneWorkspaceOrphanAlerts": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof pruneWorkspaceOrphanAlerts>) => pruneWorkspaceOrphanAlerts(...args) ?? null },
+});