@humwick/server 0.130.0 → 0.130.1

package/public/index.html

@@ -13,7 +13,7 @@
   <link rel="icon" href="favicon.svg" type="image/svg+xml">
   <link rel="manifest" href="manifest.webmanifest">
   <link rel="apple-touch-icon" href="icons/apple-touch-icon.png">
-  <script type="module" crossorigin src="./assets/index-BK0WV6hF.js"></script>
+  <script type="module" crossorigin src="./assets/index-BU3uWo2t.js"></script>
   <link rel="modulepreload" crossorigin href="./assets/rolldown-runtime-QTnfLwEv.js">
   <link rel="modulepreload" crossorigin href="./assets/legacy-storage-carry-C-tBSxRA.js">
   <link rel="modulepreload" crossorigin href="./assets/dist-DeW2Y1R5.js">

package/runner/plugins/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-relay-runner",
   "description": "Thin Humwick runner bridge for Claude Code",
-  "version": "0.130.0",
+  "version": "0.130.1",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/scripts/cd-config.ts

@@ -27,6 +27,19 @@ export function resolveCanonicalRelayDbPath(env: NodeJS.ProcessEnv = process.env
   return resolve(env.DB_PATH || join(defaultStateDir(), "agent-relay.db"));
 }
 
+/** #3301 — the deploy ledger lives only on the hub. Off the hub a release publishes and stops. */
+export function hasCanonicalDeployLedger(env: NodeJS.ProcessEnv = process.env): boolean {
+  return existsSync(resolveCanonicalRelayDbPath(env));
+}
+
+function openCanonicalDeployLedger(): void {
+  const path = resolveCanonicalRelayDbPath();
+  if (!existsSync(path)) {
+    throw new Error(`no deploy ledger at ${path}: deploys run on the hub. CD deploys a published release there, or run \`bun run release --deploy-only\` on the hub.`);
+  }
+  openExistingDb(path);
+}
+
 /**
  * #1763 — the git repository cd-watcher's detached child `git fetch`es against every
  * tick. cd-watcher provisions and owns a DEDICATED clone here, deliberately separate
@@ -146,7 +159,7 @@ export function withDeployLedgerDb<T>(dbPath: string, fn: () => T): T {
 
 /** Claim the one live-ledger lease; both the watcher and release.ts use this path. */
 export function claimCanonicalDeployLease(input: { commitSha: string; version: string; hosts: DeployHost[]; initiatedBy: string; attachedEventId?: string; previousSha?: string }): DeployEvent | null {
-  openExistingDb(resolveCanonicalRelayDbPath());
+  openCanonicalDeployLedger();
   const attached = input.attachedEventId ? getDeployEvent(input.attachedEventId) : undefined;
   if (attached && (attached.status !== "pending" || attached.commitSha !== input.commitSha)) {
     throw new Error(`deploy event ${input.attachedEventId} is not a pending lease for ${input.commitSha}`);
@@ -193,7 +206,7 @@ export function startDeployLeaseHeartbeat(id: string): ReturnType<typeof setInte
 
 /** Explicit emergency recovery; normal crash recovery remains the bounded TTL. */
 export function clearCanonicalDeployLease(id: string): boolean {
-  openExistingDb(resolveCanonicalRelayDbPath());
+  openCanonicalDeployLedger();
   return !!forceFailDeployEvent({ id, reason: "force-cleared by operator via release.ts" });
 }
 
@@ -206,7 +219,7 @@ export function clearCanonicalDeployLease(id: string): boolean {
  * the clock, is the authority here).
  */
 export function markCanonicalDeploySucceeded(id: string): boolean {
-  openExistingDb(resolveCanonicalRelayDbPath());
+  openCanonicalDeployLedger();
   return !!reconcilePendingDeployEvent({
     id, status: "succeeded", requireLeaseExpired: false,
     reason: "marked succeeded by operator via release.ts (#1532)",

package/src/commands-db.ts

@@ -814,8 +814,8 @@ export function updateCommand(id: string, input: UpdateCommandInput, opts: Updat
   return applyCommandUpdatePostCommit(result.previousStatus, result.command);
 }
 
-export function deleteCommand(id: string): boolean {
-  const existing = getCommand(id);
+/** Whether the public DELETE may cancel this command. Shared by the sync and async delete paths. */
+export function commandDeletable(existing: Command | null): existing is Command {
   if (!existing) return false;
   if (existing.type === "workspace.merge" && !isLegacyUnfencedWorkspaceMerge(existing)) return false;
   if (!["pending", "accepted"].includes(existing.status)) return false;
@@ -823,7 +823,11 @@ export function deleteCommand(id: string): boolean {
   // cancelable (see updateCommand's post-claim-cancel guard). Report "cannot cancel" honestly rather
   // than a false success: without this the updateCommand guard would no-op the cancel yet we'd still
   // return true, telling the caller a claimed push was canceled when it was not.
-  if (existing.status === "accepted" && isClaimGatedReviewCommand(existing.type)) return false;
+  return !(existing.status === "accepted" && isClaimGatedReviewCommand(existing.type));
+}
+
+export function deleteCommand(id: string): boolean {
+  if (!commandDeletable(getCommand(id))) return false;
   updateCommand(id, { status: "canceled", error: "canceled" });
   return true;
 }

package/src/commands-write.ts

@@ -11,6 +11,7 @@ import { STALE_TTL_MS } from "./config.ts";
 import { bufferedLiveAgentIds } from "./db/presence-buffer.ts";
 import { getGateway } from "./db/gateway.ts";
 import {
+  commandDeletable,
   commandUpdateHasPostCommitEffects,
   type CreateCommandOptions,
   type CreateCommandWriteArgs,
@@ -120,6 +121,13 @@ export async function updateCommandAsync(
   return result.command;
 }
 
+/** Public DELETE (#1870 S6a): the cancel is a normal off-loop patch, so it never writes on the main thread. */
+export async function deleteCommandAsync(id: string): Promise<boolean> {
+  if (!commandDeletable(await getCommandAsync(id))) return false;
+  await updateCommandAsync(id, { status: "canceled", error: "canceled" });
+  return true;
+}
+
 /** Atomically cancel only if the command is still in the caller's expected live statuses. */
 export function cancelCommandIfStatusAsync(
   args: CancelCommandIfStatusWriteArgs,

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

@@ -29,6 +29,7 @@ export const ACTIVITY_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object
     fn: (args: ActivityCreateOpArgs, ctx: WriterOpContext): ActivityEvent => createActivityEvent(args.input, ctx.now),
   },
   "activity.recordIssueActivity": {
+    offLoop: true,
     idempotent: false,
     fn: (args: ActivityRecordIssueOpArgs, ctx: WriterOpContext): ActivityEvent => recordIssueActivity(args.input, ctx.now),
   },

package/src/db/agent-lifecycle-write-ops.ts

@@ -66,6 +66,7 @@ export const AGENT_LIFECYCLE_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> =
       instanceSuperseded(args.agentId, args.expectedEpoch) ? [] : releaseWorkspaceClaimsForAgent(args.agentId, args.now),
   },
   "agents.seedContinuationObjective": {
+    offLoop: true,
     idempotent: true,
     fn: (args: AgentsSeedContinuationOpArgs, ctx: WriterOpContext): null => {
       seedContinuationObjectiveFromSpawnPrompt(args.agentId, args.spawnRequestId, ctx.now);

package/src/db/agent-meta.ts

@@ -1,4 +1,3 @@
-import { mainThreadRegistry } from "./main-thread-state";
 // Agent meta has two storage temperatures: small runtime fields change on status frames, while the
 // launch projection is fixed for the life of a runner instance. Keep the latter out of `agents.meta`
 // so a hot status update never has to carry it through its JSON patch.
@@ -7,7 +6,8 @@ import { isRecord } from "@humwick/sdk";
 
 export const AGENT_META_WARN_BYTES = 64 * 1024;
 
-const warnedOversizeMeta = mainThreadRegistry("agent-meta.ts:warnedOversizeMeta", new Set<string>());
+// Log dedupe only, so a per-thread copy is correct: the writer thread warns once itself (#1870 S6c).
+const warnedOversizeMeta = new Set<string>();
 
 export interface StoredAgentMeta {
   meta: Record<string, unknown>;

package/src/db/agent-ownership-write-ops.ts

@@ -23,10 +23,12 @@ export interface AgentOwnershipReassignOpArgs { fromUserId: string; toUserId: st
 
 export const AGENT_OWNERSHIP_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
   "agent-ownership.set": {
+    offLoop: true,
     idempotent: true,
     fn: (args: AgentOwnershipSetOpArgs, ctx: WriterOpContext): AgentOwnership => setAgentOwnership(args.input, ctx.now),
   },
   "agent-ownership.delete": {
+    offLoop: true,
     idempotent: true,
     fn: (args: AgentOwnershipDeleteOpArgs): null => {
       deleteAgentOwnership(args.agentId);
@@ -36,6 +38,7 @@ export const AGENT_OWNERSHIP_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> =
   // Back-compat migration sweep (#392) — re-running converges (`INSERT ... WHERE NOT EXISTS`), so no
   // args and idempotent: true.
   "agent-ownership.seedDefault": {
+    offLoop: true,
     idempotent: true,
     fn: (_args: unknown, ctx: WriterOpContext): null => {
       seedDefaultAgentOwnership(ctx.now);
@@ -44,6 +47,7 @@ export const AGENT_OWNERSHIP_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> =
   },
   // #3567 H4 admin handover — re-applying finds nothing left on the old owner, so it converges.
   "agent-ownership.reassign": {
+    offLoop: true,
     idempotent: true,
     fn: (args: AgentOwnershipReassignOpArgs, ctx: WriterOpContext): string[] => reassignAgentOwnership(args.fromUserId, args.toUserId, ctx.now),
   },

package/src/db/agents-async.ts

@@ -52,8 +52,12 @@ export async function upsertAgentAsync(
 ): Promise<AgentCard> {
   // #2111 — allocated before the await, per the ordinal-timing rule at the top of setStatusAsync.
   const seq = nextLifecycleSeq();
-  const { agent, contextState } = (await getGateway().write("agents.upsert", { input, opts, seq })) as unknown as UpsertAgentTxResult;
-  if (contextState) await recordContextSnapshotAsync(input.id, contextState);
+  return finishAgentUpsertAsync(input.id, (await getGateway().write("agents.upsert", { input, opts, seq })) as unknown as UpsertAgentTxResult);
+}
+
+/** The registration's follow-ups after its row committed. Shared with `upsertOrchestratorAsync`. */
+export async function finishAgentUpsertAsync(inputId: string, { agent, contextState }: UpsertAgentTxResult): Promise<AgentCard> {
+  if (contextState) await recordContextSnapshotAsync(inputId, contextState);
   evictPendingPresence(agent.id);
   // Both effects settle on the writer. The `spawnRequestId` guard is `seedContinuationObjectiveFromSpawnPrompt`'s
   // own first condition, hoisted here so a registration without one costs no thread hop at all.

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

@@ -73,27 +73,32 @@ export interface AgentsRevokeOrphanedTokensOpArgs { graceMs: number; lagGraceMs:
 export interface AgentsRevokeTokensForAgentOpArgs { agentId: string; reason?: LineageRevokeReason }
 
 export const AGENTS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
-  "agents.pruneIdentityArchive": { idempotent: true, fn: (_args: Record<string, never>, ctx: WriterOpContext) => pruneAgentIdentityArchive(ctx.now) },
-  "agents.idleSelfCare": { idempotent: false, fn: (args: { id: string; epoch: number }, ctx: WriterOpContext) => applyIdleSelfCare(args, ctx.now) },
+  "agents.pruneIdentityArchive": { offLoop: true, idempotent: true, fn: (_args: Record<string, never>, ctx: WriterOpContext) => pruneAgentIdentityArchive(ctx.now) },
+  "agents.idleSelfCare": { offLoop: true, idempotent: false, fn: (args: { id: string; epoch: number }, ctx: WriterOpContext) => applyIdleSelfCare(args, ctx.now) },
   "agents.upsert": {
+    offLoop: true,
     idempotent: true,
     fn: (args: AgentsUpsertOpArgs, ctx: WriterOpContext): UpsertAgentTxResult =>
       upsertAgentInternal(args.input, args.opts, ctx.now, args.seq),
   },
   "agents.setLabel": {
+    offLoop: true,
     idempotent: true,
     fn: (args: AgentsSetLabelOpArgs): boolean => setLabel(args.id, args.label),
   },
   "agents.setKeep": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { id: string; keep: AgentKeep | null }): boolean => setAgentKeepState(args.id, args.keep),
   },
   "agents.setTeam": {
+    offLoop: true,
     idempotent: true,
     fn: (args: AgentsSetTeamOpArgs, ctx: WriterOpContext): AgentCard | null =>
       setAgentTeam(args.agentId, args.teamId, ctx.now),
   },
   "agents.setTags": {
+    offLoop: true,
     idempotent: true,
     fn: (args: AgentsSetTagsOpArgs, ctx: WriterOpContext): AgentCard | null =>
       setTags(args.id, args.tags, ctx.now),
@@ -115,16 +120,19 @@ export const AGENTS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.f
       markReady(args.id, args.ready, args.guard, ctx.now, args.seq),
   },
   "agents.mergeMeta": {
+    offLoop: true,
     idempotent: true,
     fn: (args: AgentsMergeMetaOpArgs, ctx: WriterOpContext): boolean =>
       mergeAgentMeta(args.id, args.meta, args.guard, ctx.now),
   },
   "agents.markReadyNotified": {
+    offLoop: true,
     idempotent: true,
     fn: (args: AgentsMarkReadyNotifiedOpArgs, ctx: WriterOpContext): boolean =>
       markAgentReadyNotified(args.id, ctx.now),
   },
   "agents.clearMetaKeys": {
+    offLoop: true,
     idempotent: true,
     fn: (args: AgentsClearMetaKeysOpArgs): boolean => clearAgentMetaKeys(args.id, args.keys),
   },
@@ -135,11 +143,13 @@ export const AGENTS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.f
       recordAgentExitDiagnosticsInternal(args.id, args.diagnostics, ctx.now, args.seq),
   },
   "agents.heartbeat": {
+    offLoop: true,
     idempotent: true,
     fn: (args: AgentsHeartbeatOpArgs, ctx: WriterOpContext): boolean =>
       heartbeat(args.id, args.guard, args.runtime, ctx.now),
   },
   "agents.recordContextSnapshot": {
+    offLoop: true,
     idempotent: true,
     fn: (args: AgentsRecordContextSnapshotOpArgs, ctx: WriterOpContext): null => {
       recordContextSnapshot(args.agentId, args.context, ctx.now);
@@ -147,16 +157,19 @@ export const AGENTS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.f
     },
   },
   "agents.reapStale": {
+    offLoop: true,
     idempotent: true,
     fn: (args: AgentsReapStaleOpArgs, ctx: WriterOpContext): string[] =>
       reapStaleAgentsInternal(args.ttlMs, args.lagGraceMs, ctx.now, args.protectedIds, args.seq),
   },
   "agents.pruneOffline": {
+    offLoop: true,
     idempotent: true,
     fn: (args: AgentsPruneOfflineOpArgs, ctx: WriterOpContext) =>
       pruneOfflineAgentsWithFinality(args, ctx.now),
   },
   "agents.delete": {
+    offLoop: true,
     idempotent: true,
     fn: (args: AgentsDeleteOpArgs, ctx: WriterOpContext): boolean => deleteAgentInternal(args.id, ctx.now),
   },
@@ -167,6 +180,7 @@ export const AGENTS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.f
       revokeOrphanedRuntimeTokens(args.graceMs, args.lagGraceMs, ctx.now),
   },
   "agents.revokeTokensForAgent": {
+    offLoop: true,
     idempotent: true,
     fn: (args: AgentsRevokeTokensForAgentOpArgs, ctx: WriterOpContext): string[] =>
       revokeRuntimeTokensForAgent(args.agentId, ctx.now, args.reason),

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

@@ -13,6 +13,7 @@ import type { WriterOpContext, WriterOpSpec } from "./write-ops.ts";
 
 export const ARTIFACTS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
   "artifacts.upsertBlob": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { input: Parameters<typeof upsertArtifactBlob>[0] }, ctx: WriterOpContext) =>
       upsertArtifactBlob({ ...args.input, createdAt: args.input.createdAt ?? ctx.now }),
@@ -22,23 +23,27 @@ export const ARTIFACTS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Objec
     idempotent: false,
     fn: (args: { input: Parameters<typeof createArtifact>[0] }, ctx: WriterOpContext) => createArtifact(args.input, ctx.now),
   },
-  "artifacts.pin": { idempotent: true, fn: (args: { id: string; pinned: boolean; readScope?: import("./artifacts").ArtifactReadScope }) => setArtifactPinned(args.id, args.pinned, args.readScope) },
-  "artifacts.delete": { idempotent: true, fn: (args: { id: string }) => deleteArtifact(args.id, false) },
-  "artifacts.deleteBlob": { idempotent: true, fn: (args: { digest: string }) => deleteArtifactBlob(args.digest) },
+  "artifacts.pin": { offLoop: true, idempotent: true, fn: (args: { id: string; pinned: boolean; readScope?: import("./artifacts").ArtifactReadScope }) => setArtifactPinned(args.id, args.pinned, args.readScope) },
+  "artifacts.delete": { offLoop: true, idempotent: true, fn: (args: { id: string }) => deleteArtifact(args.id, false) },
+  "artifacts.deleteBlob": { offLoop: true, idempotent: true, fn: (args: { digest: string }) => deleteArtifactBlob(args.digest) },
   "artifacts.link": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { input: Parameters<typeof linkArtifact>[0] }, ctx: WriterOpContext) => linkArtifact(args.input, ctx.now),
   },
   "artifacts.linkExistingEntity": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { input: Parameters<typeof linkArtifactToExistingEntity>[0] }, ctx: WriterOpContext) => linkArtifactToExistingEntity(args.input, ctx.now),
   },
   "artifacts.deleteLinksForEntity": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { entityType: Parameters<typeof deleteArtifactLinksForEntity>[0]; entityId: string | number }) =>
       deleteArtifactLinksForEntity(args.entityType, args.entityId),
   },
   "artifacts.sweep": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { input?: Parameters<typeof sweepArtifacts>[0] }, ctx: WriterOpContext) =>
       sweepArtifacts({ ...args.input, now: args.input?.now ?? ctx.now }, false),

package/src/db/bus-outbox-write-ops.ts

@@ -49,6 +49,7 @@ export const BUS_OUTBOX_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Obje
   // the same end state (no rows older than the threshold), so it is idempotent and needs no key. `ctx.now`
   // is the submission-time wall-clock (H6).
   "bus.prune": {
+    offLoop: true,
     idempotent: true,
     fn: (args: BusPruneOpArgs, ctx: WriterOpContext): { changes: number } => ({
       changes: pruneOutbox(args.retentionMs, ctx.now),

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

@@ -14,15 +14,18 @@ import type { WriterOpContext, WriterOpSpec } from "./write-ops.ts";
 
 export const CHANNELS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
   "channels.deleteBinding": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { id: string; fence: ChannelBindingSessionFence }) => deleteChannelBindingBody(args.id, args.fence),
   },
   "channels.upsertBinding": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { input: UpsertChannelBindingInput; presence?: PresenceSnapshot; fence?: ChannelBindingSessionFence }, ctx: WriterOpContext) =>
       upsertChannelBindingBody(args.input, ctx.now, args.presence, args.fence),
   },
   "channels.registerAgent": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { agentId: string; expectedEpoch: number; presence?: PresenceSnapshot }, ctx: WriterOpContext) => {
       // Re-read under this operation's BEGIN IMMEDIATE. A card captured before an await may now be
@@ -36,6 +39,7 @@ export const CHANNELS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object
     },
   },
   "channels.evaluatePoolBindings": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { presence?: PresenceSnapshot }, ctx: WriterOpContext) => evaluatePoolBindingsBody(ctx.now, args.presence),
   },

package/src/db/claude-api-budget-ops.ts

@@ -7,9 +7,9 @@ export const CLAUDE_API_BUDGET_READ_OPS = {
   "apiBudget.status": (args: { now: number; budgetId?: ApiBudgetId }) => apiBudgetStatus(args.now, args.budgetId),
 };
 export const CLAUDE_API_BUDGET_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = {
-  "apiBudget.reconcile": { idempotent: true, fn: (args: { now: number }) => reconcileApiBudgetSessions(args.now) },
-  "apiBudget.pace": { idempotent: true, fn: (args: { leadTimeMs: number; now: number; budgetId?: ApiBudgetId }) => apiBudgetPace(args.leadTimeMs, args.now, args.budgetId) },
-  "apiBudget.configure": { idempotent: true, fn: (args: { input: ApiBudgetConfig; now: number }) => configureApiBudget(args.input, args.now) },
-  "apiBudget.reserve": { idempotent: true, fn: (args: { input: ApiBudgetReserve; now: number }) => reserveApiBudget(args.input, args.now) },
-  "apiBudget.report": { idempotent: true, fn: (args: { input: ApiBudgetReport; now: number }) => reportApiBudget(args.input, args.now) },
+  "apiBudget.reconcile": { offLoop: true, idempotent: true, fn: (args: { now: number }) => reconcileApiBudgetSessions(args.now) },
+  "apiBudget.pace": { offLoop: true, idempotent: true, fn: (args: { leadTimeMs: number; now: number; budgetId?: ApiBudgetId }) => apiBudgetPace(args.leadTimeMs, args.now, args.budgetId) },
+  "apiBudget.configure": { offLoop: true, idempotent: true, fn: (args: { input: ApiBudgetConfig; now: number }) => configureApiBudget(args.input, args.now) },
+  "apiBudget.reserve": { offLoop: true, idempotent: true, fn: (args: { input: ApiBudgetReserve; now: number }) => reserveApiBudget(args.input, args.now) },
+  "apiBudget.report": { offLoop: true, idempotent: true, fn: (args: { input: ApiBudgetReport; now: number }) => reportApiBudget(args.input, args.now) },
 };

package/src/db/claude-app-oauth.ts

@@ -44,13 +44,13 @@ function put(args: Put): boolean {
 
 export const CLAUDE_APP_OAUTH_READ_OPS = { "claudeAppOAuth.get": get };
 export const CLAUDE_APP_OAUTH_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = {
-  "claudeAppOAuth.put": { idempotent: false, fn: put },
-  "claudeAppOAuth.take": { idempotent: false, fn: (args: Key) => {
+  "claudeAppOAuth.put": { offLoop: true, idempotent: false, fn: put },
+  "claudeAppOAuth.take": { offLoop: true, idempotent: false, fn: (args: Key) => {
     const value = get(args);
     getDb().query("DELETE FROM claude_app_oauth WHERE resource=? AND kind=? AND key=?").run(args.resource, args.kind, args.key);
     return value;
   } },
-  "claudeAppOAuth.issue": { idempotent: false, fn: (args: Put & { refreshKey?: string; clientId: string }) => {
+  "claudeAppOAuth.issue": { offLoop: true, idempotent: false, fn: (args: Put & { refreshKey?: string; clientId: string }) => {
     // Consume and replace in the same writer transaction; concurrent refreshes cannot resurrect a revoked family.
     let old: { clientId: string; family: string; type: string; used?: boolean } | undefined;
     if (args.refreshKey) {
@@ -65,7 +65,7 @@ export const CLAUDE_APP_OAUTH_WRITE_OPS: Readonly<Record<string, WriterOpSpec>>
       .run(JSON.stringify({ ...old, used: true }), args.resource, args.kind, args.refreshKey!);
     return "ok";
   } },
-  "claudeAppOAuth.revoke": { idempotent: true, fn: (args: Key & { clientId: string }) => {
+  "claudeAppOAuth.revoke": { offLoop: true, idempotent: true, fn: (args: Key & { clientId: string }) => {
     const value = get(args);
     const credential = value ? JSON.parse(value) as { clientId: string; family: string } : null;
     if (credential?.clientId === args.clientId) removeFamily(args.resource, credential.family);

package/src/db/codex-reset-consumes-write-ops.ts

@@ -3,16 +3,19 @@ import type { WriterOpContext, WriterOpSpec } from "./write-ops.ts";
 
 export const CODEX_RESET_CONSUMES_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
   "codexResetConsumes.begin": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { input: Parameters<typeof beginCodexResetConsume>[0] }, ctx: WriterOpContext) =>
       beginCodexResetConsume({ ...args.input, now: args.input.now ?? ctx.now }),
   },
   "codexResetConsumes.complete": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { input: Parameters<typeof completeCodexResetConsume>[0] }, ctx: WriterOpContext) =>
       completeCodexResetConsume({ ...args.input, now: args.input.now ?? ctx.now }),
   },
   "codexResetConsumes.prune": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { olderThan?: number }, ctx: WriterOpContext) => pruneCodexResetConsumes(args.olderThan ?? ctx.now),
   },

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

@@ -100,11 +100,13 @@ function markLandingReplay(result: unknown): unknown {
 
 export const COMMANDS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
   "commands.claimPending": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { id: string; expectedType?: string; ownerToken?: string }, ctx) =>
       claimPendingCommand(args.id, args.expectedType, args.ownerToken, ctx.now),
   },
   "commands.createAgentCleanupIfAbsent": {
+    offLoop: true,
     idempotent: false,
     fn: (args: { target: string; id: string }, ctx: WriterOpContext) => hasActiveAgentCleanup(args.target) ? null
       : createCommandInternal({ id: args.id, input: { type: "agent.cleanup", source: "system", target: args.target,
@@ -117,10 +119,12 @@ export const COMMANDS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object
     fn: (args: { command: Command }, ctx: WriterOpContext) => settleAgentCleanupWorkspaces(args.command, ctx.now),
   },
   "commands.reconcileScheduler": {
+    offLoop: true,
     idempotent: true,
     fn: (args: Parameters<typeof reconcileSchedulerCommandsBody>[0], ctx: WriterOpContext) => reconcileSchedulerCommandsBody(args, ctx.now),
   },
   "commands.createLegacyLanding": {
+    offLoop: true,
     idempotent: false,
     fn: (args: CreateLegacyLandingArgs, ctx: WriterOpContext) => createLegacyLandingBody(args, ctx.now),
     serializeIdempotencyResult: redactCreateResult,
@@ -136,61 +140,74 @@ export const COMMANDS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object
     recordIdempotencyResult: (result) => (result as { claimed?: boolean } | null)?.claimed === true,
   },
   "commands.acceptLandingProgress": {
+    offLoop: true,
     idempotent: false,
     fn: (args: AcceptLandingProgressArgs, ctx: WriterOpContext) => acceptLandingProgressBody(args, ctx.now),
   },
   "commands.acceptLandingResult": {
+    offLoop: true,
     idempotent: false,
     fn: (args: AcceptLandingResultArgs, ctx: WriterOpContext) => acceptLandingResultBody(args, ctx.now),
     replayIdempotencyResult: markLandingReplay,
   },
   "commands.resolveLegacyPublication": {
+    offLoop: true,
     idempotent: true,
     fn: (args: ResolveLegacyPublicationArgs, ctx: WriterOpContext) => resolveLegacyPublicationBody(args, ctx.now),
   },
   "commands.acquireLegacyPublishFence": {
+    offLoop: true,
     idempotent: false,
     fn: (args: AcquireLegacyPublishFenceArgs, ctx: WriterOpContext) => acquireLegacyPublishFenceBody(args, ctx.now),
   },
   "commands.acquireKernelPublishFence": {
+    offLoop: true,
     idempotent: false,
     fn: (args: AcquireKernelPublishFenceArgs, ctx: WriterOpContext) => acquireKernelPublishFenceBody(args, ctx.now),
   },
   "commands.requestLandingRetirement": {
+    offLoop: true,
     idempotent: false,
     fn: (args: RequestLandingRetirementArgs, ctx: WriterOpContext) =>
       requestLandingRetirementBody(args, ctx.now),
   },
   "commands.grantKernelDryRunOwnership": {
+    offLoop: true,
     idempotent: false,
     fn: (args: GrantKernelDryRunOwnershipArgs, ctx: WriterOpContext) =>
       grantKernelDryRunOwnershipBody(args, ctx.now),
   },
   "commands.consumeLegacyPublishPermit": {
+    offLoop: true,
     idempotent: false,
     fn: (args: ConsumeLegacyPublishPermitArgs, ctx: WriterOpContext) => consumeLegacyPublishPermitBody(args, ctx.now),
   },
   "commands.recordExecutionProof": {
+    offLoop: true,
     idempotent: false,
     fn: (args: RecordExecutionProofArgs, ctx: WriterOpContext) => recordExecutionProofBody(args, ctx.now),
     replayIdempotencyResult: markLandingReplay,
   },
   "commands.terminalizeLegacyLanding": {
+    offLoop: true,
     idempotent: false,
     fn: (args: TerminalizeLegacyLandingArgs, ctx: WriterOpContext) => terminalizeLegacyLandingBody(args, ctx.now),
     replayIdempotencyResult: markLandingReplay,
   },
   "commands.cancelPendingLegacyLandings": {
+    offLoop: true,
     idempotent: true,
     fn: (args: CancelPendingLegacyLandingsArgs, ctx: WriterOpContext) => cancelPendingLegacyLandingsBody(args, ctx.now),
   },
   // #2609 — the withdraw's legacy-lane mid-flight cancel (pending delegates to the never-started
   // path; accepted/running is a fenced status CAS + publish-permit retirement).
   "commands.cancelLegacyLandingExecution": {
+    offLoop: true,
     idempotent: false,
     fn: (args: CancelLegacyLandingExecutionArgs, ctx: WriterOpContext) => cancelLegacyLandingExecutionBody(args, ctx.now),
   },
   "commands.backfillLegacyLandingPage": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { rows: BackfillLegacyLandingRow[] }, ctx: WriterOpContext) => backfillLegacyLandingPageBody(args, ctx.now),
   },
@@ -221,6 +238,7 @@ export const COMMANDS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object
   // only when `commandUpdateHasPostCommitEffects` says there is something to do. Idempotent: the
   // terminal-event record is guarded by an existence check and the pill re-sets the same meta keys.
   "commands.applyUpdatePostCommit": {
+    offLoop: true,
     idempotent: true,
     fn: (args: ApplyCommandUpdatePostCommitOpArgs): null => {
       applyCommandUpdatePostCommit(args.previousStatus, args.command);
@@ -230,6 +248,7 @@ export const COMMANDS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object
   // Spawn reaping must not overwrite a concurrent async success settlement. The status predicate
   // lives inside this writer transaction, making the rows-changed result a real CAS winner signal.
   "commands.cancelIfStatus": {
+    offLoop: true,
     idempotent: false,
     fn: (args: CancelCommandIfStatusWriteArgs, ctx: WriterOpContext) => cancelCommandIfStatusInternal(args, ctx.now),
     serializeIdempotencyResult: redactCancelResult,
@@ -243,6 +262,7 @@ export const COMMANDS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object
   // submission recovers the SAME {command, created} from the ledger (so the emit survives an
   // indeterminate ack), while a genuine later re-drive presents a fresh id and finds `created:false`.
   "commands.createKernelIfAbsent": {
+    offLoop: true,
     idempotent: false,
     fn: (args: CreateKernelCommandIfAbsentArgs, ctx: WriterOpContext) => {
       let input = args.input;
@@ -278,6 +298,7 @@ export const COMMANDS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object
   // One caller's quota admission is all-or-nothing: the live + in-flight reads and INSERT share this
   // operation's transaction, rather than independent-caller coalescing/savepoints.
   "commands.createSpawnWithinQuota": {
+    offLoop: true,
     idempotent: false,
     fn: (args: CreateSpawnCommandWithinQuotaWriteArgs, ctx: WriterOpContext) =>
       createSpawnCommandWithinQuotaInternal(args, ctx.now),

package/src/db/config-store-write-ops.ts

@@ -43,6 +43,7 @@ export const CONFIG_STORE_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Ob
   // retry would double-bump/duplicate. The gateway requires an idempotencyKey (the facade supplies a
   // per-submission one) and dedups on it in the SAME transaction as the write.
   "config.set": {
+    offLoop: true,
     idempotent: false,
     idempotencySnapshotKey: (args: SetConfigOpArgs) => JSON.stringify([args.namespace, args.key]),
     fn: (args: SetConfigOpArgs, ctx: WriterOpContext): ConfigEntry =>
@@ -51,6 +52,7 @@ export const CONFIG_STORE_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Ob
   // Idempotent by construction: deleting again finds no row (`existing` null → early false) and writes
   // nothing, so re-applying converges. No key required.
   "config.delete": {
+    offLoop: true,
     idempotent: true,
     fn: (args: DeleteConfigOpArgs, ctx: WriterOpContext): boolean =>
       deleteConfigInternal(args.namespace, args.key, args.updatedBy, ctx.now),

package/src/db/continuation-archives-write-ops.ts

@@ -3,11 +3,13 @@ import type { WriterOpContext, WriterOpSpec } from "./write-ops.ts";
 
 export const CONTINUATION_ARCHIVES_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
   "continuationArchives.archive": {
+    offLoop: true,
     idempotent: false,
     fn: (args: { input: Parameters<typeof archiveContinuationSegment>[0] }, ctx: WriterOpContext) =>
       archiveContinuationSegment({ ...args.input, now: args.input.now ?? ctx.now }),
   },
   "continuationArchives.compact": {
+    offLoop: true,
     idempotent: false,
     fn: (args: { input: Parameters<typeof archiveAndAdvanceContinuation>[0] }, ctx: WriterOpContext) =>
       archiveAndAdvanceContinuation({ ...args.input, now: args.input.now ?? ctx.now }),

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

@@ -40,23 +40,27 @@ export interface ApplyDeliveryActionOpArgs {
 
 export const DELIVERY_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
   "delivery.recordChannelFanoutSuppression": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { messageId: number; channelAgentId: string; reason: string }, ctx: WriterOpContext) =>
       recordChannelFanoutSuppression(args.messageId, args.channelAgentId, args.reason, ctx.now),
   },
   "delivery.recordAttempt": {
+    offLoop: true,
     idempotent: false,
     idempotencySnapshotKey: (args: RecordDeliveryAttemptOpArgs) => String(args.messageId),
     fn: (args: RecordDeliveryAttemptOpArgs, ctx: WriterOpContext) =>
       recordMessageDeliveryAttempt(args.messageId, args.input, ctx.now),
   },
   "delivery.applyAction": {
+    offLoop: true,
     idempotent: false,
     idempotencySnapshotKey: (args: ApplyDeliveryActionOpArgs) => String(args.messageId),
     fn: (args: ApplyDeliveryActionOpArgs, ctx: WriterOpContext) =>
       applyMessageDeliveryAction(args.messageId, args.input, ctx.now),
   },
   "delivery.reevaluate": {
+    offLoop: true,
     idempotent: true,
     fn: (args: ApplyDeliveryActionOpArgs, ctx: WriterOpContext) =>
       applyMessageDeliveryAction(args.messageId, args.input, ctx.now),
@@ -66,6 +70,7 @@ export const DELIVERY_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object
   // elapsed time (chiefly tests) needs to drive it directly rather than only via real wall-clock
   // submission time. Production callers omit it and get ctx.now, per H6.
   "delivery.expireQueued": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { now?: number }, ctx: WriterOpContext) => expireQueuedMessagesWithNotices(args?.now ?? ctx.now),
   },