@humwick/server 0.130.0 → 0.130.2

package/src/services/restart-spawn.ts

@@ -16,7 +16,7 @@ import { resolveWhoamiRole } from "../mcp/identity-projection";
 import { listManagedOrchestratorsForAgent } from "../orchestrator-lookup";
 import { applyDefaultSharedMcp } from "../shared-mcp";
 import { buildSpawnCommand, generateSpawnRequestId, resolveSpawnModelParams, resolveSpawnModelParamsAsync } from "../spawn-command";
-import { SUCCESSOR_LAUNCH, runnerRuntimeTokenEnv } from "../runtime-tokens";
+import { SUCCESSOR_LAUNCH, runnerRuntimeTokenEnv, runnerRuntimeTokenEnvAsync, type RunnerRuntimeTokenInput } from "../runtime-tokens";
 import { restartEffortState } from "./self-effort";
 // #2033 — from isolated-workspace-placement.ts, NOT ./spawn-identity: that module also exports
 // buildProspectiveSpawnIdentity, which imports mcp/identity.ts → self-resume.ts → restart-spawn.ts,
@@ -27,7 +27,7 @@ import { restartInstructionParamsForAgent, restartInstructionParamsForAgentAsync
 import { launchedProjectRole, projectRoleRestartError, refuseSyncProjectRoleRestart, restartProjectRole } from "./restart-project-role";
 import { authContextFromSystem } from "./auth-context";
 import { markManagedAgentRunning } from "./managed-running";
-import type { AgentCard, AgentProfile, Command, Orchestrator, SpawnApprovalMode } from "../types";
+import type { AgentCard, AgentProfile, SpawnPolicy, Command, Orchestrator, SpawnApprovalMode } from "../types";
 
 export type SelfRestartReason = "upgrade" | "token-remint" | "manual" | "reset-unconfirmed";
 type RestartOptions = { resumeId?: string; continuation?: string; generation?: number; reason?: string };
@@ -116,30 +116,9 @@ function buildRestartSpawnParamsForAgent(
       requestedBy,
       // Override the policy builder's normal mint so stable team/project bindings are also
       // carried by the fresh token, not merely preserved incidentally on the agent row.
-      env: runnerRuntimeTokenEnv({ authority: SUCCESSOR_LAUNCH,
-        agentId: agent.id,
-        orchestratorId: policy.value.orchestratorId,
-        cwd: policy.value.cwd,
-        provider: policy.value.provider,
-        label: policy.value.label,
-        policyName: policy.value.name,
-        spawnRequestId: requestId,
-        createdBy: requestedBy,
-        profile: policy.value.profile || undefined,
-        // #2245 — the successor's posture comes from the POLICY (server config, unforgeable), the
-        // same value `buildManagedSpawnParams` launches it with; stamp it into the signed constraints.
-        approvalMode: policy.value.permissionMode,
-        ...(agent.teamId ? { teamId: agent.teamId } : {}),
-        ...(projectId ? { projectId } : {}),
-        ...([...stewardExtraCwdPrefixes, ...isolatedExtraCwdPrefixes].length
-          ? { extraCwdPrefixes: [...stewardExtraCwdPrefixes, ...isolatedExtraCwdPrefixes] }
-          : {}),
-      }),
-      ...(opts.continuation ? { prompt: opts.continuation } : {}),
-      ...(restartResumeWorkspace ? { resumeWorkspace: restartResumeWorkspace } : {}),
-      // F5 — carry the self-restart generation marker on BOTH successor spawns (policy and
-      // dashboard/non-policy), so the audit lineage is symmetric regardless of branch.
-      ...(opts.generation ? { extra: { selfRestart: { generation: opts.generation, reason: opts.reason } } } : {}),
+      env: runnerRuntimeTokenEnv(managedRestartTokenInput(agent, policy.value, requestId, requestedBy, projectId,
+        [...stewardExtraCwdPrefixes, ...isolatedExtraCwdPrefixes])),
+      ...managedRestartOptions(opts, restartResumeWorkspace),
     };
     return opts.resumeId ? withResumeParams(params, opts.resumeId, agent.id) : params;
   }
@@ -160,7 +139,7 @@ function buildRestartSpawnParamsForAgent(
   const resolvedProfile = withResolvedProvisioning(profileName ? getAgentProfile(profileName)?.value : undefined, provider);
   const agentProfile = resolvedProfile ? applyDefaultSharedMcp(resolvedProfile) : undefined;
   const workspaceMode = stringValue(agent.meta?.workspaceMode) ?? "inherit";
-  const resolvedModel = resolveSpawnModelParams(provider, model, effort, { modelSource: "runtime", skipDefaultWhenEmpty: true });
+  const resolvedModel = resolveSpawnModelParams(provider, model, effort, { modelSource: "runtime" });
   const projectedInstructions = restartInstructionParamsForAgent(agent, { spawnRequestId: predecessorSpawnRequestId, cwd }) ?? {};
   // #1598 — canonicalize so a worktree/subdir cwd binds to its owning checkout's project.
   const projectId = resolveProjectForCanonicalCwd(cwd).project?.id;
@@ -175,7 +154,7 @@ function buildRestartSpawnParamsForAgent(
     cwd,
     orchestrator.baseDir,
   );
-  return buildRestartSpawnCommand(agent, predecessorSpawnRequestId, agentProfile, projectedInstructions, opts, {
+  const options = {
     provider,
     modelParams: resolvedModel,
     cwd,
@@ -185,7 +164,10 @@ function buildRestartSpawnParamsForAgent(
     policyName: policyName || undefined,
     spawnRequestId: requestId,
     requestedBy,
-  }, { orchestratorId: orchestrator.id, projectId, extraCwdPrefixes: stewardExtraCwdPrefixes });
+  };
+  const tokenContext = { orchestratorId: orchestrator.id, projectId, extraCwdPrefixes: stewardExtraCwdPrefixes };
+  return buildRestartSpawnCommand(agent, predecessorSpawnRequestId, agentProfile, projectedInstructions, opts, options, tokenContext,
+    runnerRuntimeTokenEnv(restartTokenInput(agent, options, tokenContext)));
 }
 
 /** Worker-safe restart command construction used by HTTP/orchestrator/self-restart flows. */
@@ -233,14 +215,8 @@ async function buildRestartSpawnParamsForAgentAsync(
     const params = {
       ...await buildManagedSpawnParamsAsync(relaunchPolicy(policy.value, relaunch.effort), requestId, { createdBy: requestedBy, authority: SUCCESSOR_LAUNCH, identityAgentId: agent.id, gitRepoRoot }),
       ...relaunch.carried, agentId: agent.id, requestedBy,
-      env: runnerRuntimeTokenEnv({ authority: SUCCESSOR_LAUNCH, agentId: agent.id, orchestratorId: policy.value.orchestratorId, cwd: policy.value.cwd,
-        provider: policy.value.provider, label: policy.value.label, policyName: policy.value.name, spawnRequestId: requestId,
-        createdBy: requestedBy, profile: policy.value.profile || undefined, ...(agent.teamId ? { teamId: agent.teamId } : {}),
-        approvalMode: policy.value.permissionMode,
-        ...(projectId ? { projectId } : {}), ...(combinedExtraCwdPrefixes.length ? { extraCwdPrefixes: combinedExtraCwdPrefixes } : {}), }),
-      ...(opts.continuation ? { prompt: opts.continuation } : {}),
-      ...(restartResumeWorkspace ? { resumeWorkspace: restartResumeWorkspace } : {}),
-      ...(opts.generation ? { extra: { selfRestart: { generation: opts.generation, reason: opts.reason } } } : {}),
+      env: await runnerRuntimeTokenEnvAsync(managedRestartTokenInput(agent, policy.value, requestId, requestedBy, projectId, combinedExtraCwdPrefixes)),
+      ...managedRestartOptions(opts, restartResumeWorkspace),
     };
     return opts.resumeId ? withResumeParams(params, opts.resumeId, agent.id) : params;
   }
@@ -257,15 +233,55 @@ async function buildRestartSpawnParamsForAgentAsync(
   const profileName = role ? role.profileName : stringValue(agent.meta?.profile);
   const resolvedProfile = role ? undefined : await withResolvedProvisioningAsync(profileName ? getAgentProfile(profileName)?.value : undefined, provider);
   const agentProfile = role?.agentProfile ?? (resolvedProfile ? applyDefaultSharedMcp(resolvedProfile) : undefined);
-  const resolvedModel = await resolveSpawnModelParamsAsync(provider, model, effort, { modelSource: "runtime", skipDefaultWhenEmpty: true });
+  const resolvedModel = await resolveSpawnModelParamsAsync(provider, model, effort, { modelSource: "runtime" });
   const projectedInstructions = await restartInstructionParamsForAgentAsync(agent, { spawnRequestId: predecessorSpawnRequestId, cwd, ...(role ? { profile: role.agentProfile } : {}) }) ?? {};
   const projectId = resolveProjectForCanonicalCwd(cwd).project?.id;
   const stewardExtraCwdPrefixes = stewardWorktreeCwdPrefixes(isProvenStewardAgent(agent.id, policyName), cwd, orchestrator.baseDir);
-  return buildRestartSpawnCommand(agent, predecessorSpawnRequestId, agentProfile, projectedInstructions, opts, {
+  const options = {
     provider, modelParams: resolvedModel, cwd, workspaceMode, profile: profileName || undefined,
     ...relaunch.carried, ...role?.spawn, policyName: policyName || undefined, spawnRequestId: requestId,
     requestedBy,
-  }, { orchestratorId: orchestrator.id, projectId, extraCwdPrefixes: stewardExtraCwdPrefixes });
+  };
+  const tokenContext = { orchestratorId: orchestrator.id, projectId, extraCwdPrefixes: stewardExtraCwdPrefixes };
+  return buildRestartSpawnCommand(agent, predecessorSpawnRequestId, agentProfile, projectedInstructions, opts, options, tokenContext,
+    await runnerRuntimeTokenEnvAsync(restartTokenInput(agent, options, tokenContext)));
+}
+
+function managedRestartOptions(opts: RestartOptions, restartResumeWorkspace: ReturnType<typeof resumeWorkspaceForRestart>) {
+  return {
+    ...(opts.continuation ? { prompt: opts.continuation } : {}),
+    ...(restartResumeWorkspace ? { resumeWorkspace: restartResumeWorkspace } : {}),
+    // F5 — carry the self-restart generation marker on BOTH successor spawns (policy and
+    // dashboard/non-policy), so the audit lineage is symmetric regardless of branch.
+    ...(opts.generation ? { extra: { selfRestart: { generation: opts.generation, reason: opts.reason } } } : {}),
+  };
+}
+
+function managedRestartTokenInput(agent: AgentCard, policy: SpawnPolicy, requestId: string, requestedBy: string, projectId: string | undefined, extraCwdPrefixes: string[]): RunnerRuntimeTokenInput {
+  return {
+    authority: SUCCESSOR_LAUNCH, agentId: agent.id, orchestratorId: policy.orchestratorId,
+    cwd: policy.cwd, provider: policy.provider, label: policy.label, policyName: policy.name,
+    spawnRequestId: requestId, createdBy: requestedBy, profile: policy.profile || undefined,
+    // #2245: both successor paths stamp the policy's current posture into signed constraints.
+    approvalMode: policy.permissionMode,
+    ...(agent.teamId ? { teamId: agent.teamId } : {}),
+    ...(projectId ? { projectId } : {}),
+    ...(extraCwdPrefixes.length ? { extraCwdPrefixes } : {}),
+  };
+}
+
+type RestartTokenContext = Pick<RunnerRuntimeTokenInput, "orchestratorId" | "projectId" | "extraCwdPrefixes">;
+const restartApprovalMode = (agent: AgentCard): SpawnApprovalMode => (stringValue(agent.meta?.approvalMode) as SpawnApprovalMode | undefined) ?? "guarded";
+const restartLabel = (agent: AgentCard): string | undefined => (stringValue(agent.meta?.label) ?? agent.label) || undefined;
+
+/** The successor token a non-policy restart carries; the sync twin and the writer-op path mint the same input. */
+function restartTokenInput(agent: AgentCard, options: Omit<Parameters<typeof buildSpawnCommand>[0], "env">, tokenContext: RestartTokenContext): RunnerRuntimeTokenInput {
+  return { ...tokenContext, authority: SUCCESSOR_LAUNCH,
+    agentId: agent.id, cwd: options.cwd, provider: options.provider, label: restartLabel(agent),
+    policyName: options.policyName, spawnRequestId: options.spawnRequestId,
+    createdBy: options.requestedBy, profile: options.profile, approvalMode: restartApprovalMode(agent),
+    ...(agent.teamId ? { teamId: agent.teamId } : {}),
+  };
 }
 
 function buildRestartSpawnCommand(
@@ -275,25 +291,21 @@ function buildRestartSpawnCommand(
   projectedInstructions: Record<string, unknown>,
   opts: RestartOptions,
   options: Omit<Parameters<typeof buildSpawnCommand>[0], "env">,
-  tokenContext: Pick<Parameters<typeof runnerRuntimeTokenEnv>[0], "orchestratorId" | "projectId" | "extraCwdPrefixes">,
+  tokenContext: RestartTokenContext,
+  env: Record<string, string>,
 ): Record<string, unknown> {
   const memorySeam = parseMemorySeam(projectedInstructions.memorySeam);
   const resumeWorkspace = resumeWorkspaceForRestart(agent);
   const providerArgs = metaStringArray(agent.meta, "providerArgs");
-  const approvalMode = (stringValue(agent.meta?.approvalMode) as SpawnApprovalMode | undefined) ?? "guarded";
-  const label = (stringValue(agent.meta?.label) ?? agent.label) || undefined;
+  const approvalMode = restartApprovalMode(agent);
+  const label = restartLabel(agent);
   const params = buildSpawnCommand({
     ...options,
     orchestratorId: tokenContext.orchestratorId,
     headless: true, requestedAt: Date.now(),
     ...(opts.continuation ? { prompt: opts.continuation } : {}),
     ...(opts.generation ? { extra: { selfRestart: { generation: opts.generation, reason: opts.reason } } } : {}),
-    env: runnerRuntimeTokenEnv({ ...tokenContext, authority: SUCCESSOR_LAUNCH,
-      agentId: agent.id, cwd: options.cwd, provider: options.provider, label,
-      policyName: options.policyName, spawnRequestId: options.spawnRequestId,
-      createdBy: options.requestedBy, profile: options.profile, approvalMode,
-      ...(agent.teamId ? { teamId: agent.teamId } : {}),
-    }),
+    env,
     agentId: agent.id, tags: agent.tags, systemTags: agent.systemTags, capabilities: agent.capabilities,
     label,
     approvalMode, permissionMode: approvalMode,

package/src/services/self-care-state.ts

@@ -2,9 +2,10 @@ import { renderLiveRunsSection } from "../live-runs-section";
 import { renderOpenDecisionsSection } from "../operator-decisions-section";
 import { renderIdleEpicsSection } from "./idle-epics";
 import { renderPlanWakeDigest } from "./plan-wake-digest";
+import { renderPausedRunsSection } from "./workflow-pause-text";
 
 /** Stored live state survives every self-care boundary; tracker refresh must never block a wake. */
 export function renderSelfCareState(agentId: string): string {
   return [renderLiveRunsSection(agentId), renderOpenDecisionsSection(agentId),
-    renderIdleEpicsSection(agentId, [], false), renderPlanWakeDigest(agentId)].filter(Boolean).join("\n\n");
+    renderIdleEpicsSection(agentId, [], false), renderPlanWakeDigest(agentId), renderPausedRunsSection(agentId)].filter(Boolean).join("\n\n");
 }

package/src/services/self-effort.ts

@@ -1,5 +1,5 @@
 import { stringValue, type SpawnProvider } from "@humwick/sdk";
-import { VALID_EFFORTS, findProviderCatalog, findProviderCatalogModel, type ProviderCatalogEntry } from "@humwick/sdk/provider-catalog";
+import { findProviderCatalog, findProviderCatalogModel, type ProviderCatalogEntry } from "@humwick/sdk/provider-catalog";
 import { findConfirmedEffortSwitch, findLaunchEffort, type LaunchEffort } from "../db/commands-effort-read";
 import { getAgentEffortState } from "../db/agent-effort-state";
 import { SELF_EFFORT_BAND, getSelfEffortCeiling, type SelfEffortIdentity } from "../db/self-effort-permissions";
@@ -44,7 +44,7 @@ export function resolveSpawnSelfEffort(
     if (!(base ?? known?.defaultEffort)) throw new ValidationError("selfEffort without selfEffortCeiling needs a base effort: set effort, or pass selfEffortCeiling");
     return { band: true };
   }
-  const levels = known?.efforts ?? VALID_EFFORTS;
+  const levels = known?.efforts ?? [];
   if (!levels.includes(ceiling)) {
     throw new ValidationError(`selfEffortCeiling ${ceiling} is not an effort ${known ? `${known.provider} model ${known.alias}` : provider} offers (${levels.join(", ")})`);
   }
@@ -90,7 +90,7 @@ export function selfEffortBase(agent: AgentCard): string | undefined {
 
 /** One step down and one step up from `base` on `ladder`, clamped at both ends. */
 export function selfEffortBand(base: string, ladder: readonly string[]): { floor: string; ceiling: string } {
-  const levels = ladder.includes(base) ? ladder : VALID_EFFORTS;
+  const levels = ladder.includes(base) ? ladder : [base];
   const at = levels.indexOf(base);
   return { floor: levels[Math.max(0, at - 1)]!, ceiling: levels[Math.min(levels.length - 1, at + 1)]! };
 }
@@ -119,7 +119,7 @@ export function selfEffortPolicyFor(agent: AgentCard, grant: SelfEffortGrant, mo
   if ("ceiling" in grant) return { ceiling: grant.ceiling };
   const base = selfEffortBase(agent);
   if (!base) throw new ValidationError("your self-change band has no base effort; ask your coordinator to set your effort");
-  return { band: true, base, ...selfEffortBand(base, modelEfforts ?? agentCatalogModel(agent)?.efforts ?? VALID_EFFORTS) };
+  return { band: true, base, ...selfEffortBand(base, modelEfforts ?? agentCatalogModel(agent)?.efforts ?? [base]) };
 }
 
 /** #2950 H3 — a restart successor launches at the agent's desired effort (#2984: applied or still pending),
@@ -138,7 +138,7 @@ export function restartEffortState(agent: AgentCard): { effort?: string; carried
 export function assertSelfEffortAllowed(agent: AgentCard, level: string, modelEfforts: readonly string[] | undefined): SelfEffortPolicy {
   const policy = spawnSelfEffortPolicy(agent, modelEfforts);
   if (!policy) throw new ValidationError("selfEffort is not enabled for you, so you cannot change your own effort; ask your coordinator");
-  const ladder = modelEfforts?.includes(policy.ceiling) ? modelEfforts : VALID_EFFORTS;
+  const ladder = modelEfforts ?? agentCatalogModel(agent)?.efforts ?? [];
   const at = ladder.indexOf(level);
   if (at < 0 || at > ladder.indexOf(policy.ceiling)) {
     throw new ValidationError(policy.band

package/src/services/send-message.ts

@@ -45,6 +45,7 @@ import {
 import { recentFinalResponseCaptureIds } from "../db/lineage-startup-captures";
 import { yieldToEventLoop } from "../event-loop-yield";
 import { markAgentWorkFinal } from "./work-finality";
+import { agentProviderState } from "../provider-state";
 import { planSend, type DeliveryReceipt } from "../agent-ref";
 import { receiptWithChannelSuppression } from "./channel-suppression-receipt";
 import { emitMessageDeliveryUpdated, emitMessageQueued, emitNewMessages } from "../sse";
@@ -203,7 +204,8 @@ function resolveSendTarget(input: SendMessageInput, from: string): DeliveryRecei
   }
   // excludeId: a bare ref must never resolve back to its own author — that self-loop silently
   // swallows the message (the reddit-briefing → telegram bridge break, #290).
-  const plan = planSend(input.to, listAgents(), { excludeId: from });
+  const agents = listAgents();
+  const plan = planSend(input.to, agents, { excludeId: from });
   // Ambiguous is a real "can't decide" → reject on every transport (categorically unlike
   // not_found, which stores). HTTP → 409, MCP → invalid-params.
   if (plan.kind === "ambiguous") throw new AmbiguousTargetError(plan.message);
@@ -215,6 +217,8 @@ function resolveSendTarget(input: SendMessageInput, from: string): DeliveryRecei
   // direct (incl. a single OFFLINE match — receipt already carries reason "recipient offline")
   // / fanout / passthrough: adopt the canonical (possibly rewritten) id + the receipt.
   input.to = plan.to;
+  const providerState = agentProviderState(agents.find(agent => agent.id === plan.to));
+  if (providerState?.reason === "providerSetupRequired") throw new ValidationError(providerState.message ?? providerState.recommendedAction ?? "Provider setup required; restart the runner after completing setup.");
   return plan.receipt;
 }
 

package/src/services/spawn-agent.ts

@@ -44,7 +44,7 @@ import { emitCommandEvent } from "../command-events";
 import { redactCommandSecrets } from "../command-secrets";
 import { buildSpawnCommand, generateSpawnRequestId } from "../spawn-command"; import { systemTagsForSpawn } from "../agent-system-tags";
 import { resolveSpawnLandBlocked } from "../land-block";
-import { runnerRuntimeTokenEnv } from "../runtime-tokens";
+import { runnerRuntimeTokenEnvAsync } from "../runtime-tokens";
 import { liveSpawnQuota } from "../spawn-quota";
 import { resolveCanonicalHost } from "../host-identity";
 import { resolveSpawnHostAnchor } from "../spawn-targets";
@@ -59,6 +59,7 @@ import { isolatedSpawnGitRepoError, resolveSpawnRepoRoot } from "./spawn-repo-pr
 import { autoSeedProjectForCwdAsync } from "./project"; import { applyProjectCapabilityGates } from "../project-trust";
 import { assertProjectRoleMcpCwd, assertProjectRoleMcpTrusted, projectRoleProfile, projectRoleProvenance, projectRoleSpawnDefaults, withRoleProfile } from "../project-roles";
 import { spawnWarnings } from "./spawn-warnings";
+import { enforceSpawnPolicy, spawnerKind, spawnPolicyTask, type AppliedSpawnPolicy } from "./spawn-policy";
 import { resolveSpawnProjectRole } from "./spawn-project-role";
 import { profileProviderPin, resolveSpawnLaunch } from "./spawn-launch";
 import { hydrateTaskContext, projectTaskHydration } from "./task-context-hydration";
@@ -210,6 +211,8 @@ export interface SpawnAgentInput extends SelfEffortSpawnInput {
   roleSnapshot?: import("../project-roles").ProjectRole;
   workflowCaller?: WorkflowSpawnQuota;
   roleSha?: string; workflowRunId?: string; roleProfile?: string; taskRepoCwd?: string; roleHost?: string;
+  /** #3736 — the workflows of the run tree spawning this step, for a spawn-policy `require.workflow`. Service-only. */
+  workflowNames?: string[];
   prompt?: string;
   systemPromptAppend?: string;
   /**
@@ -324,6 +327,8 @@ export interface SpawnAgentResult {
   dispatchDecision?: Awaited<ReturnType<typeof dispatchTaskAsync>>;
   /** #3043 — the spawn went ahead, but the caller should know (a role read from a stale default branch). */
   warnings?: string[];
+  /** #3736 — the project spawn-policy rules that applied to this spawn. */
+  spawnPolicy?: AppliedSpawnPolicy;
 }
 
 /** Reject when a component token's signed resource constraints disallow the target (#323). */
@@ -428,6 +433,11 @@ export async function spawnAgent(input: SpawnAgentInput, ctx: AuthContext): Prom
   });
 
   assertOrchestratorSupportsLaunchMode(orchestrator, launchMode, input.providerArgs);
+  // #3736 — the project's spawn policy, before any side effect: a refusal names the rule, the allowed set and the hint.
+  const spawnPolicy = await enforceSpawnPolicy(
+    { projectId: lazyRoot?.projectId ?? resolveProjectForCwd(resolvedCwd)?.id, ...(lazyRoot ? {} : { checkout: { cwd: resolvedCwd, orchestratorId: orchestrator.id } }) },
+    { spawner: spawnerKind(ctx, input, caller), task: spawnPolicyTask(linkedTask), subject: { role: projectRole?.name, profile: profileName, workflows: input.workflowNames } },
+  );
 
   // Resolve + validate the named agent profile server-side (was HTTP-only; the MCP path passed
   // the name through unvalidated). Omitted profile uses Relay's spawn default so coordinator
@@ -703,7 +713,7 @@ export async function spawnAgent(input: SpawnAgentInput, ctx: AuthContext): Prom
   // Child runner token. `agentInitiated` (set whenever an agent is the caller) forces a
   // non-spawn-capable child (no grandchildren); `spawnedBy` stamps authoritative lineage the
   // child can't forge (it registers with spawnedBy = caller, read from the signed token).
-  const env = { ...callerEnv, ...runnerRuntimeTokenEnv({
+  const env = { ...callerEnv, ...await runnerRuntimeTokenEnvAsync({
     agentId: targetAgentId,
     orchestratorId: orchestrator.id,
     cwd: resolvedCwd,
@@ -900,6 +910,7 @@ export async function spawnAgent(input: SpawnAgentInput, ctx: AuthContext): Prom
     ...(autoScaffoldedTask ? { task: autoScaffoldedTask } : {}),
     ...(taskDispatchDecision ? { dispatchDecision: taskDispatchDecision } : {}),
     ...(warnings.length ? { warnings } : {}),
+    ...(spawnPolicy ? { spawnPolicy } : {}),
   };
 }
 

package/src/services/spawn-chain-inspector.ts

@@ -24,7 +24,7 @@ import { join } from "node:path";
 import type { LaunchMode, SpawnProvider } from "@humwick/sdk";
 import { withResolvedProvisioning } from "../db";
 import { getAgentProfile } from "../config-store";
-import { buildSpawnCommand } from "../spawn-command";
+import { buildSpawnCommand, resolveSpawnModelParams } from "../spawn-command";
 import { spawnOptionsFromControl } from "../../orchestrator/src/control";
 import type { SpawnOptions } from "../../orchestrator/src/spawn/types";
 import { buildEnv, buildRunnerCommand } from "../../orchestrator/src/spawn/command";
@@ -139,18 +139,10 @@ export function prepareSpawnChain(opts: SpawnChainRequest, observe?: SpawnChainP
     prompt: opts.spawn?.prompt,
     systemPromptAppend: opts.spawn?.systemPromptAppend,
     headless: opts.spawn?.headless ?? true,
-    ...(opts.spawn?.model || opts.spawn?.effort || opts.spawn?.contextWindowTokens !== undefined
-      ? {
-        modelParams: {
-          ...(opts.spawn.model ? { model: opts.spawn.model, providerModel: opts.spawn.model } : {}),
-          ...(opts.spawn.effort ? { effort: opts.spawn.effort } : {}),
-          // #2595 — window passes through the same payload field production threads.
-          ...(typeof opts.spawn.contextWindowTokens === "number" && Number.isSafeInteger(opts.spawn.contextWindowTokens) && opts.spawn.contextWindowTokens > 0
-            ? { contextWindowTokens: opts.spawn.contextWindowTokens }
-            : {}),
-        },
-      }
-      : {}),
+    modelParams: {
+      ...resolveSpawnModelParams(provider, opts.spawn?.model, opts.spawn?.effort),
+      ...(opts.spawn?.contextWindowTokens !== undefined ? { contextWindowTokens: opts.spawn.contextWindowTokens } : {}),
+    },
   } as Parameters<typeof buildSpawnCommand>[0]);
 
   return prepareCommandChain(cmdParams, opts, observe);
@@ -216,6 +208,7 @@ export function prepareCommandChain(
     provider: cli.provider,
     ...(cli.model ? { model: cli.model } : {}),
     ...(cli.effort ? { effort: cli.effort } : {}),
+    ...(cli.modelRecord ? { modelRecord: cli.modelRecord } : {}),
     // #2595 — the real runner CLI carries the window as a flag; carry it through the same seam.
     ...(cli.contextWindowTokens !== undefined ? { contextWindowTokens: cli.contextWindowTokens } : {}),
     runnerId: "inspector",

package/src/services/spawn-policy.ts

@@ -0,0 +1,68 @@
+// #3736 — the one spawn-policy check. spawnAgent runs it for every spawn (relay_spawn_agent,
+// relay_task_dispatch, POST /api/agents/spawn, workflow steps, sub-coordinators); the workflow
+// auto-start asks it which workflow a Task's work runs through. A project without the file, or with
+// an invalid or unreadable one, is not restricted: stored config never fails a spawn.
+import { stringValue, type AgentCard } from "@humwick/sdk";
+import {
+  matchSpawnPolicy, SPAWN_POLICY_FILE, spawnPolicyAtCommit, spawnPolicyRefusal, spawnPolicyWorkflow,
+  type SpawnerKind, type SpawnPolicy, type SpawnPolicySubject, type SpawnPolicyTask,
+} from "@humwick/sdk/spawn-policy";
+import { ValidationError } from "../db";
+import type { AuthContext } from "./auth-context";
+import { readProjectConfigFirst, type ProjectCheckout } from "./project-config-read";
+
+/** Where the policy is read: the spawn's own checkout first, then the project's registered roots. */
+export interface SpawnPolicyWhere {
+  projectId?: string;
+  checkout?: ProjectCheckout;
+}
+
+/** The rules that applied, for the caller's receipt. */
+export interface AppliedSpawnPolicy {
+  file: string;
+  ref: string;
+  sha: string;
+  rules: string[];
+}
+
+interface LoadedSpawnPolicy {
+  policy: SpawnPolicy;
+  ref: string;
+  sha: string;
+}
+
+async function loadSpawnPolicy(where: SpawnPolicyWhere): Promise<LoadedSpawnPolicy | undefined> {
+  if (!where.projectId) return undefined;
+  const { lookup } = await readProjectConfigFirst(where.projectId, where.checkout ? [where.checkout] : [], SPAWN_POLICY_FILE, spawnPolicyAtCommit, "spawns are not restricted until it is fixed");
+  return lookup?.status === "found" ? { policy: lookup.config, ref: lookup.ref, sha: lookup.sha } : undefined;
+}
+
+/** A workflow run's step, a sub-coordinator, any other agent, or a caller with no agent (dashboard, operator). */
+export function spawnerKind(ctx: AuthContext, input: { workflowRunId?: string }, caller: AgentCard | undefined): SpawnerKind {
+  if (ctx.actor.kind === "system" && input.workflowRunId) return "workflow";
+  if (!caller) return "operator";
+  return stringValue(caller.meta?.profile) === "sub-coordinator" ? "sub-coordinator" : "coordinator";
+}
+
+export function spawnPolicyTask(task: { id: number; tags?: readonly string[]; paths?: readonly string[] } | undefined): SpawnPolicyTask | undefined {
+  return task ? { id: task.id, ...(task.tags ? { tags: task.tags } : {}), ...(task.paths ? { paths: task.paths } : {}) } : undefined;
+}
+
+/** Refuses a spawn the project's policy does not allow (a `ValidationError` naming the rule, the
+ *  allowed set and the hint); otherwise the rules that applied, if any. */
+export async function enforceSpawnPolicy(where: SpawnPolicyWhere, facts: { spawner: SpawnerKind; task?: SpawnPolicyTask; subject: SpawnPolicySubject }): Promise<AppliedSpawnPolicy | undefined> {
+  const loaded = await loadSpawnPolicy(where);
+  if (!loaded) return undefined;
+  const rules = matchSpawnPolicy(loaded.policy, facts);
+  if (!rules.length) return undefined;
+  const refusal = spawnPolicyRefusal(rules, facts.subject, facts.task);
+  if (refusal) throw new ValidationError(refusal);
+  return { file: SPAWN_POLICY_FILE, ref: loaded.ref, sha: loaded.sha, rules: rules.map((rule) => rule.name) };
+}
+
+/** The workflow the project's policy routes this Task's work through, and the rule that says so. */
+export async function spawnPolicyWorkflowFor(where: SpawnPolicyWhere, facts: { spawner: SpawnerKind; task: SpawnPolicyTask }): Promise<{ workflow: string; rule: string } | undefined> {
+  const loaded = await loadSpawnPolicy(where);
+  const chosen = loaded && spawnPolicyWorkflow(matchSpawnPolicy(loaded.policy, facts));
+  return chosen ? { workflow: chosen.workflow, rule: chosen.rule.name } : undefined;
+}

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

@@ -4,11 +4,11 @@ import { getGateway } from "../db/gateway";
 import { getAgentAsync } from "../db";
 import { shutdownAgent } from "./shutdown-agent";
 import { currentStop } from "./workflow-effects";
-import { invoke, testOptions, type Supervisor } from "./workflow-supervisor-state";
+import { invoke, supervisorNow, type Supervisor } from "./workflow-supervisor-state";
 
 /** Every retry resumes the same outbox effect; only host witnesses release reservations. */
 export async function performSpawnTreeCleanup(sup: Supervisor, effect: WorkflowEffect): Promise<boolean> {
-  const now = (testOptions.now ?? Date.now)();
+  const now = supervisorNow();
   if (typeof effect.result?.nextAttemptAt === "number" && effect.result.nextAttemptAt > now) return false;
   const agentId = String(effect.payload.agentId);
   await getGateway().write("spawnTree.prepareCleanup", { agentId });

package/src/services/task-dispatch.ts

@@ -105,6 +105,7 @@ export interface TaskDispatchSpawnInput {
   /** #3045 — the workflow run dispatching this step; #3091 the base profile its step pins, the run's checkout standing in
    *  for the Task's repo root, and the host its role is read on first. Service-only. */
   workflowRunId?: string;
+  workflowNames?: string[];
   workflowCaller?: SpawnAgentInput["workflowCaller"];
   roleProfile?: string;
   taskRepoCwd?: string;
@@ -139,6 +140,7 @@ export async function spawnTaskDispatch(input: TaskDispatchSpawnInput, ctx: Auth
       role,
       roleSha, roleSnapshot,
       workflowRunId,
+      workflowNames: input.workflowNames,
       workflowCaller: input.workflowCaller,
       roleProfile,
       taskRepoCwd,
@@ -173,6 +175,7 @@ export async function spawnTaskDispatch(input: TaskDispatchSpawnInput, ctx: Auth
     ...(decision ? { decision } : {}),
     ...(reviewTaskId !== undefined ? { reviewTaskId } : {}),
     ...(spawn.warnings ? { warnings: spawn.warnings } : {}),
+    ...(spawn.spawnPolicy ? { spawnPolicy: spawn.spawnPolicy } : {}),
     ...(verbose ? { command: summarizeSpawnCommandForCaller(spawn.command) } : {}),
   };
 }

package/src/services/task-state-reconcile.ts

@@ -4,8 +4,9 @@
 // live in src/db/task-state-reconcile.ts; every change is applied by its conditional writer, which
 // re-checks the rule in the transaction, then audited here with one `task.reconciled` relay event.
 import { errMessage } from "@humwick/sdk";
-import { isSqliteBusyError, withFastFailConnection, writerLockAvailable } from "../db/connection";
-import { getIssueRef, updateIssueRef } from "../db/issue-refs";
+import { writerLockAvailable } from "../db/connection";
+import { getIssueRef } from "../db/issue-refs";
+import { updateIssueRefAsync } from "../db/issue-refs-async";
 import { applyTaskStateReconcileAsync, listTaskStateReconcileCandidatesAsync } from "../db/task-state-reconcile-async";
 import { TASK_RECONCILE_ACTOR, type TaskReconcileRule, type TaskStateReconcileApplied } from "../db/task-state-reconcile";
 import { emitRelayEvent } from "../events";
@@ -104,19 +105,10 @@ async function refreshIssueRefs(refIds: string[], opts: TaskStateReconcileOption
     try {
       const live = await (opts.adapterResolver ?? resolveIssueTrackerAdapter)(ref).getStatus(ref);
       const status = live.status === "open" || live.status === "closed" ? live.status : ref.status;
-      // The tracker read can take long: re-check the lock right before the write, and bound the write itself.
+      // The tracker read can take long: re-check the lock right before the write. The write itself waits on
+      // the writer thread, never on the loop (#1870 S7).
       if (steps.contended()) break;
-      const written = await steps.timed(() => {
-        try {
-          withFastFailConnection(STEP_BUSY_TIMEOUT_MS, () => updateIssueRef(ref.id, { status, title: live.title, closeReason: live.closeReason, statusSyncedAt: Date.now() }));
-          return true;
-        } catch (error) {
-          if (!isSqliteBusyError(error)) throw error;
-          result.moreWork = true;
-          return false;
-        }
-      });
-      if (!written) break;
+      await updateIssueRefAsync(ref.id, { status, title: live.title, closeReason: live.closeReason, statusSyncedAt: Date.now() });
       closedAny ||= status === "closed";
     } catch (error) {
       refreshFailedAt.set(id, now);

package/src/services/team-templates.ts

@@ -1,6 +1,7 @@
 import { isRecord, SPAWN_PROVIDERS, VALID_WORKSPACE_MODES, APPROVAL_MODES, VALID_AGENT_LIFECYCLES } from "@humwick/sdk";
 import { getTeam, ValidationError } from "../db";
-import { deleteConfig, getConfig, listConfig, setConfig } from "../config-store";
+import { getConfig, listConfig } from "../config-store";
+import { deleteConfigAsync, setConfigAsync } from "../config-store-write";
 import { TEAM_TEMPLATE_NAMESPACE } from "../team-template-config";
 import { cleanString, optionalEnum } from "../validation";
 import type { AuthContext } from "./auth-context";
@@ -47,11 +48,11 @@ function withTimestamps(template: TeamTemplate, existing?: TeamTemplate): TeamTe
   };
 }
 
-export function saveTeamTemplate(input: Record<string, unknown>, updatedBy?: string): TeamTemplate {
+export async function saveTeamTemplateAsync(input: Record<string, unknown>, updatedBy?: string): Promise<TeamTemplate> {
   if (input.teamId !== undefined && input.composition !== undefined) {
     throw new ValidationError("teamId capture and manual composition are mutually exclusive");
   }
-  if (input.teamId !== undefined) return captureTeamTemplateFromTeam(cleanString(input.teamId, "teamId", { required: true, max: 120 })!, input, updatedBy);
+  if (input.teamId !== undefined) return captureTeamTemplateFromTeamAsync(cleanString(input.teamId, "teamId", { required: true, max: 120 })!, input, updatedBy);
   const slug = templateSlug(input);
   const existing = getConfig<TeamTemplate>(TEAM_TEMPLATE_NAMESPACE, slug)?.value;
   const template = withTimestamps({
@@ -64,7 +65,7 @@ export function saveTeamTemplate(input: Record<string, unknown>, updatedBy?: str
     ...(cleanString(input.definitionOfDone, "definitionOfDone", { max: 4000 }) ? { definitionOfDone: cleanString(input.definitionOfDone, "definitionOfDone", { max: 4000 }) } : {}),
     ...(input.planSkeleton !== undefined ? { planSkeleton: input.planSkeleton as TeamTemplate["planSkeleton"] } : {}),
   }, existing);
-  return setConfig(TEAM_TEMPLATE_NAMESPACE, template.slug, template, updatedBy).value as TeamTemplate;
+  return (await setConfigAsync(TEAM_TEMPLATE_NAMESPACE, template.slug, template, updatedBy)).value as TeamTemplate;
 }
 
 export function listTeamTemplates(): TeamTemplate[] {
@@ -75,8 +76,8 @@ export function getTeamTemplate(slug: string): TeamTemplate | null {
   return getConfig<TeamTemplate>(TEAM_TEMPLATE_NAMESPACE, slug)?.value ?? null;
 }
 
-export function deleteTeamTemplate(slug: string, updatedBy?: string): boolean {
-  return deleteConfig(TEAM_TEMPLATE_NAMESPACE, slug, updatedBy);
+export function deleteTeamTemplateAsync(slug: string, updatedBy?: string): Promise<boolean> {
+  return deleteConfigAsync(TEAM_TEMPLATE_NAMESPACE, slug, updatedBy);
 }
 
 function parseFrozenComposition(raw: string): Array<Record<string, unknown>> {
@@ -107,7 +108,7 @@ function compositionFromFrozenSnapshot(raw: string): TeamTemplateCompositionEntr
   return composition;
 }
 
-export function captureTeamTemplateFromTeam(teamId: string, input: Record<string, unknown> = {}, updatedBy?: string): TeamTemplate {
+export async function captureTeamTemplateFromTeamAsync(teamId: string, input: Record<string, unknown> = {}, updatedBy?: string): Promise<TeamTemplate> {
   const team = getTeam(teamId);
   if (!team) throw new ValidationError(`team ${teamId} not found`);
   if (!team.composition) throw new ValidationError("team has no frozen composition snapshot; dissolve it before capture");
@@ -123,7 +124,7 @@ export function captureTeamTemplateFromTeam(teamId: string, input: Record<string
     ...(team.brief ? { brief: team.brief } : {}),
     ...(team.definitionOfDone ? { definitionOfDone: team.definitionOfDone } : {}),
   }, existing);
-  return setConfig(TEAM_TEMPLATE_NAMESPACE, template.slug, template, updatedBy).value as TeamTemplate;
+  return (await setConfigAsync(TEAM_TEMPLATE_NAMESPACE, template.slug, template, updatedBy)).value as TeamTemplate;
 }
 
 function cleanWait(value: unknown): number {

package/src/services/transient-agent-reaper.ts

@@ -15,6 +15,7 @@ import { activeAgentKeep } from "./agent-keep";
 import { automaticDisposalBlocker } from "./automatic-disposal";
 import { agentGenerationKey } from "../db/agent-shutdown-in-flight";
 import { workflowAgentObligation } from "./workflow-agent-obligation";
+import { workflowRunPaused } from "../db/workflow-task-read-ops";
 import type { AgentCard, Command, WorkspaceRecord } from "../types";
 import { emitCommandEvent } from "../command-events";
 
@@ -356,7 +357,8 @@ export async function reapTransientAgents(context: { signal?: AbortSignal } = {}
     if (completedProviderTurns(agent) === 0) { transientTracker.delete(agent.id); waiting.push(agent.id); continue; }
     // #3234 — an empty branch is not completion while the workflow still awaits this agent's delivery.
     const runId = workflowRunIdOf(agent);
-    if (runId && await workflowAgentObligation(runId, agent.id)) { transientTracker.delete(agent.id); waiting.push(agent.id); continue; }
+    // #3757 — a paused run keeps all its step agents.
+    if (runId && (workflowRunPaused(runId) || await workflowAgentObligation(runId, agent.id))) { transientTracker.delete(agent.id); waiting.push(agent.id); continue; }
     const entry = transientTracker.get(agent.id) ?? { firstIdleAt: now };
     transientTracker.set(agent.id, entry);
     const idleForMs = now - entry.firstIdleAt;