@humwick/server 0.130.0 → 0.130.1

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

@@ -27,6 +27,7 @@ export const HOSTS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.fr
   // Idempotent by construction (re-registration converges; conflict/join tags flip only on the
   // transition), so no idempotencyKey is required.
   "hosts.upsertFromRegistration": {
+    offLoop: true,
     idempotent: true,
     fn: (a: HostRegistrationInput, ctx) => upsertHostFromRegistrationInternal(a, ctx.now),
   },
@@ -36,42 +37,52 @@ export const HOSTS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.fr
   // the gateway's bounded-queue shedding policy, dropping a utilization update is the correct
   // outcome, because the next beat supersedes it 30 s later (§8).
   "hosts.recordUtilization": {
+    offLoop: true,
     idempotent: true,
     fn: (a: Parameters<typeof recordHostUtilizationInternal>[0]) => recordHostUtilizationInternal(a),
   },
   "hosts.setLabel": {
+    offLoop: true,
     idempotent: true,
     fn: (a: { id: string; label: string }) => setHostLabelInternal(a.id, a.label),
   },
   "hosts.setTags": {
+    offLoop: true,
     idempotent: true,
     fn: (a: { id: string; tags: string[] }) => setHostTagsInternal(a.id, a.tags),
   },
   "hosts.acceptHardware": {
+    offLoop: true,
     idempotent: true,
     fn: (a: { id: string }) => acceptHostHardwareInternal(a.id),
   },
   "hosts.setEnabled": {
+    offLoop: true,
     idempotent: true,
     fn: (a: { id: string; enabled: boolean }) => setHostEnabledInternal(a.id, a.enabled),
   },
   "hosts.setLandingPlacement": {
+    offLoop: true,
     idempotent: true,
     fn: (a: { id: string; noLandingWorkspaces: boolean | null }) => setHostLandingPlacementInternal(a.id, a.noLandingWorkspaces),
   },
   "hosts.setAgentCap": {
+    offLoop: true,
     idempotent: true,
     fn: (a: { id: string; maxAgents: number | null }) => setHostPlacementPolicyInternal(a.id, "maxAgents", a.maxAgents),
   },
   "hosts.setLandingCap": {
+    offLoop: true,
     idempotent: true,
     fn: (a: { id: string; maxLandingSlots: number | null }) => setHostPlacementPolicyInternal(a.id, "maxLandingSlots", a.maxLandingSlots),
   },
   "hosts.setGateBudget": {
+    offLoop: true,
     idempotent: true,
     fn: (a: { id: string } & HostGatePolicyPatch) => { const { id, ...patch } = a; return setHostGatePolicyInternal(id, patch); },
   },
   "hosts.setAdmission": {
+    offLoop: true,
     idempotent: true,
     fn: (a: { id: string; flags: Pick<HostPolicy, "spawnEnabled" | "gatesEnabled"> }, ctx) => {
       const host = setHostAdmissionInternal(a.id, a.flags);
@@ -80,14 +91,17 @@ export const HOSTS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.fr
     },
   },
   "hosts.setPolicy": {
+    offLoop: true,
     idempotent: true,
     fn: (a: { id: string; policy: HostPolicy }) => setHostPolicyInternal(a.id, a.policy),
   },
   "hosts.claimAlias": {
+    offLoop: true,
     idempotent: true,
     fn: (a: { hostId: string; alias: string; source: string }, ctx) => claimHostAliasInternal(a.hostId, a.alias, a.source, ctx.now),
   },
   "hosts.releaseAlias": {
+    offLoop: true,
     idempotent: true,
     fn: (a: { alias: string }) => releaseHostAliasInternal(a.alias),
   },

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

@@ -4,20 +4,24 @@ import type { WriterOpContext, WriterOpSpec } from "./write-ops.ts";
 
 export const INBOX_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
   "inbox.setThreadState": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { input: Parameters<typeof setInboxThreadState>[0] }, ctx: WriterOpContext) =>
       setInboxThreadState(args.input, ctx.now),
   },
   "inbox.setDraft": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { input: Parameters<typeof setInboxDraft>[0] }, ctx: WriterOpContext) =>
       setInboxDraft(args.input, ctx.now, false),
   },
   "inbox.deleteDraft": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { operatorId: string; peerId: string }) => deleteInboxDraft(args.operatorId, args.peerId),
   },
   "inbox.createHistoryImport": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { input: Parameters<typeof createChatHistoryImport>[0] }, ctx: WriterOpContext) =>
       createChatHistoryImport(args.input, ctx.now, false),

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

@@ -7,6 +7,7 @@ import type { WriterOpContext, WriterOpSpec } from "./write-ops.ts";
 
 export const INSIGHTS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
   "insights.observations.record": {
+    offLoop: true,
     // An observation is append-only; callers must provide the per-request key carried by the facade.
     idempotent: false,
     fn: (args: { input: Parameters<typeof recordObservation>[1] }, ctx: WriterOpContext) =>

package/src/db/macos-privacy.ts

@@ -68,5 +68,5 @@ export function reconcileMacosPrivacy(args: { orchestratorId: string; prompts: M
 }
 
 export const MACOS_PRIVACY_WRITE_OPS = {
-  "macosPrivacy.reconcile": { idempotent: true, fn: reconcileMacosPrivacy },
+  "macosPrivacy.reconcile": { offLoop: true, idempotent: true, fn: reconcileMacosPrivacy },
 };

package/src/db/message-reads-write-ops.ts

@@ -6,15 +6,18 @@ export const MESSAGE_READS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = O
   // Both writes converge on retry: INSERT OR IGNORE/read-state updates and deleting an absent row
   // are no-ops, so a phantom-failure retry is safe without a caller key.
   "messageReads.markRead": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { messageId: number; agentId: string }, ctx: WriterOpContext) => markRead(args.messageId, args.agentId, ctx.now),
   },
   "messageReads.delete": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { id: number }) => deleteMessage(args.id, false),
   },
   // #3054 — re-derives each drifted pair from the source tables at write time, so a stale snapshot is harmless.
   "messageReads.reconcileReplyObligations": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { pairs: Array<{ messageId: number; agentId: string }> }) => {
       for (const { messageId, agentId } of args.pairs) reconcileReplyObligation(messageId, agentId);

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

@@ -52,6 +52,7 @@ export interface MessageClaimOpArgs {
 
 export const MESSAGE_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
   "messages.flushCoordinatorDigests": {
+    offLoop: true,
     idempotent: true,
     fn: (_args: unknown, ctx: WriterOpContext) => flushCoordinatorDigestsBody(ctx.now),
   },
@@ -77,6 +78,7 @@ export const MESSAGE_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.
   // A keyed reaction row is an upsert/delete, so replaying the same request converges on the
   // requested state. The lookup and mutation execute in the same writer transaction.
   "messages.reaction": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { input: Parameters<typeof setMessageReaction>[0] }, ctx: WriterOpContext) =>
       setMessageReaction(args.input, ctx.now),
@@ -84,11 +86,13 @@ export const MESSAGE_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.
   // The expiry sweep, eligibility reads, message CAS, linked-task transition, and renewal all run
   // in this single writer transaction. A separate release/read hop would race a concurrent claimer.
   "messages.claim": {
+    offLoop: true,
     idempotent: true,
     fn: (args: MessageClaimOpArgs, ctx: WriterOpContext) =>
       claimMessageBody(args.messageId, args.agentId, args.guard, ctx.now),
   },
   "messages.renewClaim": {
+    offLoop: true,
     idempotent: true,
     fn: (args: MessageClaimOpArgs, ctx: WriterOpContext) =>
       renewMessageClaimBody(args.messageId, args.agentId, args.guard, ctx.now),

package/src/db/orchestrators-async.ts

@@ -4,13 +4,17 @@ import { getGateway } from "./gateway.ts";
 import { coalesceLifecycleWrite } from "./lifecycle-write-window.ts";
 import { nextLifecycleSeq } from "./lifecycle-seq.ts";
 import { evictPendingPresence } from "./presence-buffer.ts";
-import type { getOrchestrator, listOrchestrators, OrchestratorRosterResult, upsertOrchestrator } from "./orchestrators.ts";
+import type { getOrchestrator, listOrchestrators, OrchestratorRosterResult, registerOrchestratorOp, upsertOrchestrator } from "./orchestrators.ts";
+import { finishAgentUpsertAsync } from "./agents-async.ts";
 import { emitWorkspaceUpsert } from "./workspaces.ts";
 import type { ManagedAgent, OrchestratorRuntimeInput, OrchestratorUpgradeState, QueuedSpawn } from "../types.ts";
 import { STALE_TTL_MS } from "../config.ts";
 
-export function upsertOrchestratorAsync(input: Parameters<typeof upsertOrchestrator>[0]): Promise<ReturnType<typeof upsertOrchestrator>> {
-  return getGateway().write("orchestrators.register", input, { critical: true }) as unknown as Promise<ReturnType<typeof upsertOrchestrator>>;
+export async function upsertOrchestratorAsync(input: Parameters<typeof upsertOrchestrator>[0]): Promise<ReturnType<typeof upsertOrchestrator>> {
+  const seq = nextLifecycleSeq(); // before the await, per the ordinal-timing rule (lifecycle-seq.ts)
+  const { orchestrator, agent, contextState } = await getGateway().write("orchestrators.register", { input, seq }, { critical: true }) as unknown as ReturnType<typeof registerOrchestratorOp>;
+  await finishAgentUpsertAsync(agent.id, { agent, contextState });
+  return orchestrator;
 }
 
 export function getOrchestratorAsync(id: string): Promise<ReturnType<typeof getOrchestrator>> {

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

@@ -3,6 +3,7 @@
 import {
   orchestratorHeartbeatInternal,
   reapStaleOrchestratorsInternal,
+  registerOrchestratorOp,
   reportOrchestratorRosterRow,
   setOrchestratorUpgradeState,
   upsertOrchestrator,
@@ -14,10 +15,13 @@ import type { WriterOpContext, WriterOpSpec } from "./write-ops.ts";
 
 export const ORCHESTRATORS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
   "orchestrators.register": {
+    offLoop: true,
     idempotent: true,
-    fn: (input: Parameters<typeof upsertOrchestrator>[0]) => upsertOrchestrator(input),
+    // The agent row's follow-ups (presence eviction, pool binding, steward election) run in the facade.
+    fn: (a: { input: Parameters<typeof upsertOrchestrator>[0]; seq: number }, ctx) => registerOrchestratorOp(a.input, ctx.now, a.seq),
   },
   "orchestrators.heartbeat": {
+    offLoop: true,
     idempotent: true,
     fn: (a: { id: string; runtime: OrchestratorRuntimeInput; seq?: number }, ctx) => {
       const orchestrator = orchestratorHeartbeatInternal(a.id, a.runtime, ctx.now);
@@ -42,10 +46,12 @@ export const ORCHESTRATORS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = O
     fn: (a: { id: string; agents: ManagedAgent[]; queuedSpawns?: QueuedSpawn[] }, ctx) => reportOrchestratorRosterRow(a.id, a.agents, a.queuedSpawns, ctx.now),
   },
   "orchestrators.upgrade.set": {
+    offLoop: true,
     idempotent: true,
     fn: (a: { id: string; state: OrchestratorUpgradeState | null }) => setOrchestratorUpgradeState(a.id, a.state),
   },
   "orchestrators.reap": {
+    offLoop: true,
     idempotent: true,
     fn: (a: { cutoff: number; seq: number }, ctx) => reapStaleOrchestratorsInternal(ctx.now - STALE_TTL_MS, a.seq),
   },

package/src/db/orchestrators.ts

@@ -14,7 +14,7 @@ import {
 } from "../contracts";
 import { STALE_TTL_MS, DAY_MS, CLAIM_LEASE_MS, POOL_CLAIM_LEASE_MS, WORKSPACE_MERGE_LEASE_MS } from "../config";
 import { matchAgents } from "../agent-ref";
-import { deleteAgent, heartbeat, upsertAgent } from "./agents.ts";
+import { deleteAgent, heartbeat, upsertAgent, upsertAgentInternal, type UpsertAgentTxResult } from "./agents.ts";
 import { evictPendingPresence } from "./presence-buffer.ts";
 import { getDb, writeTransaction } from "./connection.ts";
 import { fencedColumnSql, nextLifecycleSeq } from "./lifecycle-seq.ts";
@@ -259,8 +259,8 @@ function mergeOrchestratorRuntimeMeta(meta: Record<string, unknown>, input: Orch
   };
 }
 
-export function upsertOrchestrator(input: RegisterOrchestratorInput): Orchestrator {
-  const now = Date.now();
+/** The orchestrator row write alone (no agent registration); returns the agent registration to follow. */
+function writeOrchestratorRow(input: RegisterOrchestratorInput, now: number): RegisterAgentInput {
   // #1554 — the command-delivery key. Built from the SAME helper the orchestrator's command poller
   // binds with, so a registered host is always addressed under the exact id it polls under.
   const agentId = orchestratorAgentId(input.id);
@@ -311,7 +311,7 @@ export function upsertOrchestrator(input: RegisterOrchestratorInput): Orchestrat
   });
 
   // Also register as an agent so the orchestrator can receive messages
-  upsertAgent({
+  return {
     id: agentId,
     name: `Orchestrator (${input.hostname})`,
     tags: ["orchestrator", input.hostname],
@@ -329,11 +329,23 @@ export function upsertOrchestrator(input: RegisterOrchestratorInput): Orchestrat
       ...(input.protocolVersion !== undefined ? { protocolVersion: input.protocolVersion } : {}),
       ...(input.gitSha ? { gitSha: input.gitSha } : {}),
     },
-  });
+  };
+}
 
+export function upsertOrchestrator(input: RegisterOrchestratorInput): Orchestrator {
+  upsertAgent(writeOrchestratorRow(input, Date.now()));
   return getOrchestrator(input.id)!;
 }
 
+/** #1870 S6c — the whole registration as one off-loop op: the orchestrator row and its agent row
+ *  commit together. The agent's main-thread follow-ups (presence eviction, pool binding, steward
+ *  election) run in the facade from the returned `agent`/`contextState`. */
+export function registerOrchestratorOp(input: RegisterOrchestratorInput, now: number, seq: number): { orchestrator: Orchestrator } & UpsertAgentTxResult {
+  const agentInput = writeOrchestratorRow(input, now);
+  const tx = upsertAgentInternal(agentInput, undefined, now, seq);
+  return { orchestrator: getOrchestrator(input.id)!, ...tx };
+}
+
 export function getOrchestrator(id: string): Orchestrator | null {
   const row = getDb().query("SELECT * FROM orchestrators WHERE id = ?").get(id) as any;
   return row ? rowToOrchestrator(row) : null;

package/src/db/prompt-versions-ops.ts

@@ -10,6 +10,7 @@ export const PROMPT_VERSION_READ_OPS = {
 
 export const PROMPT_VERSION_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = {
   "prompts.write": {
+    offLoop: true,
     idempotent: false,
     fn: (args: PromptWrite, ctx: WriterOpContext) => writePromptVersion(args, ctx.now),
   },

package/src/db/provider-catalog-write-ops.ts

@@ -9,8 +9,8 @@ import type { SpawnProvider } from "../types.ts";
 import type { WriterOpContext, WriterOpSpec } from "./write-ops.ts";
 
 export const PROVIDER_CATALOG_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
-  "providerCatalog.upsert": { idempotent: false, fn: (args: { input: ProviderModelOverrideInput }, ctx: WriterOpContext) => upsertProviderModelOverride(args.input, ctx.now) },
-  "providerCatalog.setDisabled": { idempotent: false, fn: (args: { provider: SpawnProvider; alias: string; disabled: boolean; updatedBy?: string }, ctx: WriterOpContext) => setProviderModelDisabled(args.provider, args.alias, args.disabled, args.updatedBy, ctx.now) },
-  "providerCatalog.remove": { idempotent: false, fn: (args: { provider: SpawnProvider; alias: string; updatedBy?: string }, ctx: WriterOpContext) => removeProviderModelOverride(args.provider, args.alias, args.updatedBy, ctx.now) },
-  "providerCatalog.setDefault": { idempotent: false, fn: (args: { provider: SpawnProvider; alias: string; updatedBy?: string }, ctx: WriterOpContext) => setProviderDefaultModel(args.provider, args.alias, args.updatedBy, ctx.now) },
+  "providerCatalog.upsert": { offLoop: true, idempotent: false, fn: (args: { input: ProviderModelOverrideInput }, ctx: WriterOpContext) => upsertProviderModelOverride(args.input, ctx.now) },
+  "providerCatalog.setDisabled": { offLoop: true, idempotent: false, fn: (args: { provider: SpawnProvider; alias: string; disabled: boolean; updatedBy?: string }, ctx: WriterOpContext) => setProviderModelDisabled(args.provider, args.alias, args.disabled, args.updatedBy, ctx.now) },
+  "providerCatalog.remove": { offLoop: true, idempotent: false, fn: (args: { provider: SpawnProvider; alias: string; updatedBy?: string }, ctx: WriterOpContext) => removeProviderModelOverride(args.provider, args.alias, args.updatedBy, ctx.now) },
+  "providerCatalog.setDefault": { offLoop: true, idempotent: false, fn: (args: { provider: SpawnProvider; alias: string; updatedBy?: string }, ctx: WriterOpContext) => setProviderDefaultModel(args.provider, args.alias, args.updatedBy, ctx.now) },
 });

package/src/db/provider-flap-messages-write-ops.ts

@@ -3,6 +3,7 @@ import type { WriterOpSpec } from "./write-ops.ts";
 
 export const PROVIDER_FLAP_MESSAGES_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
   "providerFlapMessages.ensureIndex": {
+    offLoop: true,
     idempotent: true,
     fn: () => {
       ensureProviderFlapMessagesIndex();

package/src/db/provider-quota-lease-write-ops.ts

@@ -17,6 +17,7 @@ export const PROVIDER_QUOTA_LEASE_WRITE_OPS: Readonly<Record<string, WriterOpSpe
       acquireProviderQuotaLeaseInTx(normalizeProviderQuotaLeaseAcquireInput({ ...args.input, now: args.input.now ?? ctx.now })),
   },
   "providerQuotaLeases.release": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { input: Parameters<typeof releaseProviderQuotaLeaseInTx>[0] }) => releaseProviderQuotaLeaseInTx(args.input),
   },

package/src/db/provider-quota-write-ops.ts

@@ -54,6 +54,7 @@ export const PROVIDER_QUOTA_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> =
   // It returns concrete messages for main-thread SSE fanout; never call notifySystemMessage in a
   // worker, whose listener set is intentionally not shared with the server.
   "providerQuotas.routeNotification": {
+    offLoop: true,
     // Routing inserts message rows. The effect facade supplies a stable per-effect key so a
     // post-commit acknowledgement loss returns these exact messages instead of routing twice.
     idempotent: false,
@@ -63,6 +64,7 @@ export const PROVIDER_QUOTA_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> =
     fn: (args: { input: RouteNotificationInput; now?: number }, ctx: WriterOpContext) => routeProviderQuotaNotificationInTx(args.input, args.now ?? ctx.now),
   },
   "providerQuotas.pruneHistory": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { olderThan: number }) => ({ changes: pruneProviderQuotaHistory(args.olderThan) }),
   },

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

@@ -26,18 +26,19 @@ import type { WriterOpContext, WriterOpSpec } from "./write-ops.ts";
 
 export const PROVISIONING_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
   // Creating a capability mints a random id, so the generic durable ledger owns phantom-ACK retry.
-  "provisioning.capabilities.create": { idempotent: false, fn: (args: CreateProvisioningCapabilityInput, ctx: WriterOpContext) => createProvisioningCapability(args, ctx.now) },
-  "provisioning.capabilities.update": { idempotent: true, fn: (args: { id: string; patch: UpdateProvisioningCapabilityInput }, ctx: WriterOpContext) => updateProvisioningCapability(args.id, args.patch, ctx.now) },
-  "provisioning.capabilities.delete": { idempotent: true, fn: (args: { id: string }) => deleteProvisioningCapability(args.id) },
+  "provisioning.capabilities.create": { offLoop: true, idempotent: false, fn: (args: CreateProvisioningCapabilityInput, ctx: WriterOpContext) => createProvisioningCapability(args, ctx.now) },
+  "provisioning.capabilities.update": { offLoop: true, idempotent: true, fn: (args: { id: string; patch: UpdateProvisioningCapabilityInput }, ctx: WriterOpContext) => updateProvisioningCapability(args.id, args.patch, ctx.now) },
+  "provisioning.capabilities.delete": { offLoop: true, idempotent: true, fn: (args: { id: string }) => deleteProvisioningCapability(args.id) },
   // The capability lookup and its variant insert/update execute under one writer lock.
-  "provisioning.variants.createMcp": { idempotent: false, fn: (args: { capabilityId: string; input: CreateMcpProvisioningVariantInput }, ctx: WriterOpContext) => createMcpProvisioningVariant(args.capabilityId, args.input, ctx.now) },
-  "provisioning.variants.patch": { idempotent: true, fn: (args: { id: string; patch: PatchProvisioningAssetVariantInput }, ctx: WriterOpContext) => patchProvisioningAssetVariant(args.id, args.patch, ctx.now) },
-  "provisioning.variants.validate": { idempotent: true, fn: (args: { id: string }, ctx: WriterOpContext) => validateProvisioningAssetVariant(args.id, ctx.now) },
-  "provisioning.assets.upsert": { idempotent: false, fn: (args: UpsertProvisioningAssetInput, ctx: WriterOpContext) => upsertProvisioningAsset(args, ctx.now) },
+  "provisioning.variants.createMcp": { offLoop: true, idempotent: false, fn: (args: { capabilityId: string; input: CreateMcpProvisioningVariantInput }, ctx: WriterOpContext) => createMcpProvisioningVariant(args.capabilityId, args.input, ctx.now) },
+  "provisioning.variants.patch": { offLoop: true, idempotent: true, fn: (args: { id: string; patch: PatchProvisioningAssetVariantInput }, ctx: WriterOpContext) => patchProvisioningAssetVariant(args.id, args.patch, ctx.now) },
+  "provisioning.variants.validate": { offLoop: true, idempotent: true, fn: (args: { id: string }, ctx: WriterOpContext) => validateProvisioningAssetVariant(args.id, ctx.now) },
+  "provisioning.assets.upsert": { offLoop: true, idempotent: false, fn: (args: UpsertProvisioningAssetInput, ctx: WriterOpContext) => upsertProvisioningAsset(args, ctx.now) },
   "provisioning.assets.importGithub": {
+    offLoop: true,
     idempotent: false,
     fn: (args: { input: ImportProvisioningAssetFromGitHubInput; source: GitHubVendoredSource; definition: ResolvedAssetDefinition; now: number; target?: ProvisioningGitHubImportTarget }) =>
       upsertImportedAssetBody(args.input, args.source, args.definition, args.now, args.target),
   },
-  "provisioning.assets.delete": { idempotent: true, fn: (args: { kind: ProvisioningAssetKind; name: string; provider?: AgentProfileProvider }) => deleteProvisioningAsset(args.kind, args.name, args.provider) },
+  "provisioning.assets.delete": { offLoop: true, idempotent: true, fn: (args: { kind: ProvisioningAssetKind; name: string; provider?: AgentProfileProvider }) => deleteProvisioningAsset(args.kind, args.name, args.provider) },
 });

package/src/db/routing-policy.ts

@@ -60,5 +60,5 @@ export function writeRoutingPolicy(args: RoutingPolicyWrite, now: number) {
 
 export const ROUTING_POLICY_READ_OPS = { "routingPolicy.get": () => readRoutingPolicy() };
 export const ROUTING_POLICY_WRITE_OPS = {
-  "routingPolicy.set": { idempotent: false, fn: (args: RoutingPolicyWrite, ctx: { now: number }) => writeRoutingPolicy(args, ctx.now) },
+  "routingPolicy.set": { offLoop: true, idempotent: false, fn: (args: RoutingPolicyWrite, ctx: { now: number }) => writeRoutingPolicy(args, ctx.now) },
 };

package/src/db/secrets-broker-write-ops.ts

@@ -14,10 +14,10 @@ import type { WriterOpContext, WriterOpSpec } from "./write-ops.ts";
 export const SECRETS_BROKER_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
   // Caller-generated ids + INSERT OR IGNORE make both inserts safe to replay.
   "secretsBroker.audit.record": { idempotent: true, offLoop: true, fn: (a: SecretAuditInput, ctx: WriterOpContext) => recordSecretAudit(a, ctx.now) },
-  "secretsBroker.link.create": { idempotent: true, fn: (a: SecretUploadLinkInput, ctx: WriterOpContext) => createSecretUploadLink(a, ctx.now) },
+  "secretsBroker.link.create": { offLoop: true, idempotent: true, fn: (a: SecretUploadLinkInput, ctx: WriterOpContext) => createSecretUploadLink(a, ctx.now) },
   // A replayed claim must not hand the link out twice: the ledger returns the first claim's result.
-  "secretsBroker.link.claim": { idempotent: false, fn: (a: { tokenHash: string }, ctx: WriterOpContext) => claimSecretUploadLink(a.tokenHash, ctx.now) },
-  "secretsBroker.loginLatch.set": { idempotent: true, fn: (a: { fingerprint: string; state: SecretBrokerLoginLatchState }, ctx: WriterOpContext) => setSecretBrokerLoginLatch(a, ctx.now) },
-  "secretsBroker.loginLatch.clear": { idempotent: true, fn: (a: { fingerprint: string }) => clearSecretBrokerLoginLatch(a.fingerprint) },
-  "secretsBroker.link.finish": { idempotent: true, fn: (a: Parameters<typeof finishSecretUploadLink>[0]) => finishSecretUploadLink(a) },
+  "secretsBroker.link.claim": { offLoop: true, idempotent: false, fn: (a: { tokenHash: string }, ctx: WriterOpContext) => claimSecretUploadLink(a.tokenHash, ctx.now) },
+  "secretsBroker.loginLatch.set": { offLoop: true, idempotent: true, fn: (a: { fingerprint: string; state: SecretBrokerLoginLatchState }, ctx: WriterOpContext) => setSecretBrokerLoginLatch(a, ctx.now) },
+  "secretsBroker.loginLatch.clear": { offLoop: true, idempotent: true, fn: (a: { fingerprint: string }) => clearSecretBrokerLoginLatch(a.fingerprint) },
+  "secretsBroker.link.finish": { offLoop: true, idempotent: true, fn: (a: Parameters<typeof finishSecretUploadLink>[0]) => finishSecretUploadLink(a) },
 });

package/src/db/secrets-vault-write.ts

@@ -87,11 +87,11 @@ export function editVaultMetadata(args: { name: string; patch: VaultMetadataPatc
   });
 }
 export const VAULT_WRITE_OPS = {
-  "secretsVault.metadata": { idempotent: true, fn: editVaultMetadata },
-  "secretsVault.delete": { idempotent: false, fn: deleteVaultSecret },
-  "secretsVault.set": { idempotent: true, fn: setVaultRow },
-  "secretsVault.request": { idempotent: false, fn: (args: Parameters<typeof fileVaultDecision>[0]) => fileVaultDecision(args) },
-  "secretsVault.withdraw": { idempotent: true, fn: withdrawVaultDecisions },
-  "secretsVault.expire": { idempotent: true, fn: expireVaultDecisions },
-  "secretsVault.answer": { idempotent: true, fn: (args: { id: number; now: number }) => answerOpenOperatorDecision(args.id, { answers: {}, answeredBy: "vault-form", now: args.now }) },
+  "secretsVault.metadata": { offLoop: true, idempotent: true, fn: editVaultMetadata },
+  "secretsVault.delete": { offLoop: true, idempotent: false, fn: deleteVaultSecret },
+  "secretsVault.set": { offLoop: true, idempotent: true, fn: setVaultRow },
+  "secretsVault.request": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof fileVaultDecision>[0]) => fileVaultDecision(args) },
+  "secretsVault.withdraw": { offLoop: true, idempotent: true, fn: withdrawVaultDecisions },
+  "secretsVault.expire": { offLoop: true, idempotent: true, fn: expireVaultDecisions },
+  "secretsVault.answer": { offLoop: true, idempotent: true, fn: (args: { id: number; now: number }) => answerOpenOperatorDecision(args.id, { answers: {}, answeredBy: "vault-form", now: args.now }) },
 };

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

@@ -16,6 +16,7 @@ function parsedParams(raw: string): Record<string, unknown> {
 
 export const SERVICES_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
   "services.spawnWatchdog.markUnconfirmed": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { rows: SpawnCommandPatchRow[]; now: number; phase: "dispatch_unacknowledged" | "registration_unconfirmed" }) => {
       const changed: string[] = [];
@@ -31,6 +32,7 @@ export const SERVICES_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object
     },
   },
   "services.spawnWatchdog.markConfirmed": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { rows: SpawnCommandPatchRow[]; now: number }) => {
       const changed: string[] = [];
@@ -46,6 +48,7 @@ export const SERVICES_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object
     },
   },
   "services.providerFlap.persist": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { agentId: string; kind: string; episodeCount: number; lastEpisodeAt: number; latestSuppressedSeq: number }) => {
       const row = getDb().query(`

package/src/db/spawn-tree-cleanup.ts

@@ -35,12 +35,14 @@ export const SPAWN_TREE_CLEANUP_READ_OPS = {
 
 export const SPAWN_TREE_CLEANUP_WRITE_OPS = {
   "spawnTree.markTransferred": {
+    offLoop: true,
     idempotent: true,
     fn: ({ id }: { id: string }): void => {
       getDb().query("UPDATE spawn_tree_stops SET cleanup_effect_id = id WHERE id = ?").run(id);
     },
   },
   "spawnTree.stopGoneCallers": {
+    offLoop: true,
     idempotent: true,
     fn: (_args: undefined, ctx: { now: number }): void => {
       const rows = getDb().query(`WITH launches AS MATERIALIZED (
@@ -70,6 +72,7 @@ export const SPAWN_TREE_CLEANUP_WRITE_OPS = {
     },
   },
   "spawnTree.prepareCleanup": {
+    offLoop: true,
     idempotent: true,
     fn: ({ agentId }: { agentId: string }, ctx: { now: number }): void => {
       const ids = spawnTreeParentIds(agentId).filter(id => delegatedLaunch(id));

package/src/db/team-spawn-delegation.ts

@@ -45,5 +45,5 @@ export function setTeamSpawnDelegationBody(args: SetTeamDelegationArgs, now: num
 }
 
 export const TEAM_SPAWN_DELEGATION_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = {
-  "teams.spawnDelegation.set": { idempotent: true, fn: (args: SetTeamDelegationArgs, ctx) => setTeamSpawnDelegationBody(args, ctx.now) },
+  "teams.spawnDelegation.set": { offLoop: true, idempotent: true, fn: (args: SetTeamDelegationArgs, ctx) => setTeamSpawnDelegationBody(args, ctx.now) },
 };

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

@@ -10,8 +10,8 @@ import {
 import type { WriterOpContext, WriterOpSpec } from "./write-ops.ts";
 
 export const TEAMS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
-  "teams.zeroMembers.set": { idempotent: true, fn: (a: { teamId: string; ts: number }) => setTeamZeroMembersSince(a.teamId, a.ts) },
-  "teams.zeroMembers.clear": { idempotent: true, fn: (a: { teamId: string }, ctx) => clearTeamZeroMembersSince(a.teamId, ctx.now) },
-  "teams.brief.set": { idempotent: true, fn: (a: Parameters<typeof setTeamBrief>[0], ctx) => setTeamBrief(a, ctx.now) },
-  "teams.dissolve": { idempotent: false, fn: (a: { teamId: string; input?: Parameters<typeof dissolveTeam>[1] }, ctx) => dissolveTeam(a.teamId, a.input, ctx.now) },
+  "teams.zeroMembers.set": { offLoop: true, idempotent: true, fn: (a: { teamId: string; ts: number }) => setTeamZeroMembersSince(a.teamId, a.ts) },
+  "teams.zeroMembers.clear": { offLoop: true, idempotent: true, fn: (a: { teamId: string }, ctx) => clearTeamZeroMembersSince(a.teamId, ctx.now) },
+  "teams.brief.set": { offLoop: true, idempotent: true, fn: (a: Parameters<typeof setTeamBrief>[0], ctx) => setTeamBrief(a, ctx.now) },
+  "teams.dissolve": { offLoop: true, idempotent: false, fn: (a: { teamId: string; input?: Parameters<typeof dissolveTeam>[1] }, ctx) => dissolveTeam(a.teamId, a.input, ctx.now) },
 });

package/src/db/timer-cutover-write-ops.ts

@@ -242,6 +242,7 @@ function rebaseBootstrapEpoch(args: {
 
 export const TIMER_CUTOVER_WRITE_OPS = {
   "timers.cutover.releaseInterruptedTransfer": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { now?: number } | undefined, ctx: WriterOpContext) =>
       releaseInterruptedCutoverTransfer(args?.now ?? ctx.now),
@@ -249,26 +250,32 @@ export const TIMER_CUTOVER_WRITE_OPS = {
   // A kernel batch has already durably changed timer state by the time these run. Never shed the
   // resume cursor/journal acknowledgement or a restart will repeat a committed side effect.
   "timers.cutoverOperation.commitBackfillBatch": {
+    offLoop: true,
     idempotent: false,
     fn: (args: Parameters<typeof commitBackfillBatch>[0]) => commitBackfillBatch(args),
   },
   "timers.cutoverOperation.commitBootstrapBatch": {
+    offLoop: true,
     idempotent: false,
     fn: (args: Parameters<typeof commitBootstrapBatch>[0]) => commitBootstrapBatch(args),
   },
   "timers.cutoverOperation.commitTransferBatch": {
+    offLoop: true,
     idempotent: false,
     fn: (args: Parameters<typeof commitTransferBatch>[0]) => commitTransferBatch(args),
   },
   "timers.cutoverOperation.appendJournal": {
+    offLoop: true,
     idempotent: false,
     fn: (args: Parameters<typeof appendOperationJournal>[0]) => appendOperationJournal(args),
   },
   "timers.cutoverOperation.complete": {
+    offLoop: true,
     idempotent: false,
     fn: (args: Parameters<typeof completeOperation>[0]) => completeOperation(args),
   },
   "timers.cutoverOperation.rebaseBootstrapEpoch": {
+    offLoop: true,
     idempotent: false,
     fn: (args: Parameters<typeof rebaseBootstrapEpoch>[0]) => rebaseBootstrapEpoch(args),
   },

package/src/db/timer-ingress-write-ops.ts

@@ -78,12 +78,15 @@ export interface AcceptTimerIngressBootstrapOpArgs {
 
 export const TIMER_INGRESS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
   "timerIngress.acceptCreate": {
+    offLoop: true,
     idempotent: true,
     fn: (args: AcceptTimerIngressCreateOpArgs) =>
       acceptTimerIngressCreateInTx({ source: args.source, storedKey: args.storedKey, at: args.at }),
   },
 
   "timerIngress.acceptCancel": {
+
+    offLoop: true,
     idempotent: true,
     fn: (args: AcceptTimerIngressCancelOpArgs) =>
       acceptTimerIngressCancelInTx({
@@ -95,6 +98,8 @@ export const TIMER_INGRESS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = O
   },
 
   "timerIngress.acceptBootstrapCreate": {
+
+    offLoop: true,
     idempotent: true,
     fn: (args: AcceptTimerIngressBootstrapOpArgs) =>
       acceptTimerIngressBootstrapCreateInTx({
@@ -107,6 +112,7 @@ export const TIMER_INGRESS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = O
 
   /** Collapse one unsettled intent to `terminal` (supersede / tombstone / malformed quarantine). */
   "timerIngress.settleTerminal": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { seq: number; reason: TimerIngressTerminalReason; error?: string; ownerId: string; at: number }) =>
       settleTimerIngressTerminal({
@@ -120,6 +126,7 @@ export const TIMER_INGRESS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = O
 
   /** CAS-claim an intent for apply (state + lease). Returns false when another applier holds it. */
   "timerIngress.claim": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { seq: number; ownerId: string; leaseMs: number; at: number }) =>
       claimTimerIngressIntent({ seq: args.seq, ownerId: args.ownerId, leaseMs: args.leaseMs, at: args.at }),
@@ -127,6 +134,7 @@ export const TIMER_INGRESS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = O
 
   /** Settle a successfully applied intent and advance the terminal-inclusive watermark. */
   "timerIngress.settleApplied": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { seq: number; ownerId: string; at: number }) => {
       settleTimerIngressApplied({ seq: args.seq, ownerId: args.ownerId, at: args.at });
@@ -136,6 +144,7 @@ export const TIMER_INGRESS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = O
 
   /** Drop our lease after a failed apply so the next pass retries immediately, keeping the error. */
   "timerIngress.releaseAfterFailure": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { seq: number; error: string; ownerId: string }) => {
       releaseTimerIngressLeaseAfterFailure({ seq: args.seq, error: args.error, ownerId: args.ownerId });