@humwick/server 0.130.2 → 0.130.3

package/src/services/spawn-agent.ts

@@ -1,9 +1,10 @@
+import { taskLinkedRepoCwd } from "./task-repo-cwd";
+export { taskLinkedRepoCwd } from "./task-repo-cwd";
 import { writeChildEnv } from "@humwick/sdk/env";
 import { bindSpawnProjectCheckout } from "./project-checkout-binding";
-import { REPORT_VERBOSITIES, resolveReportVerbosity } from "@humwick/sdk";
+import { REPORT_VERBOSITIES, resolveReportVerbosity, DEFAULT_USER_ID, errMessage, isRecord, stringValue, type LaunchMode, type ReportVerbosity, type SpawnProvider, type TaskDispatch } from "@humwick/sdk";
 import { cleanCallerSpawnEnv } from "../spawn-env";
-import { optionalEnum } from "../validation";
-import { optionalNonNegativeInt } from "../validation";
+import { optionalEnum, optionalNonNegativeInt } from "../validation";
 import { cleanSpawnBudget } from "../spawn-budget";
 import { teamId as newTeamId } from "../db/teams";
 import { getGateway } from "../db/gateway";
@@ -35,8 +36,7 @@ import type { WorkflowSpawnQuota } from "../db/spawn-in-flight";
 // deliberately out of scope here — this slice converges the two external TRANSPORTS.
 import { resolveSpawnApprovalMode } from "./spawn-approval";
 import { assertOrchestratorSupportsLaunchMode, resolveSpawnLaunchMode } from "../launch-mode";
-import { DEFAULT_USER_ID, errMessage, isRecord, stringValue, type LaunchMode, type ReportVerbosity, type SpawnProvider, type TaskDispatch } from "@humwick/sdk";
-import { addProjectRootAsync, countLiveSpawnedAgents, createActivityEventAsync, getAgent, getProject, getTaskDetailAsync, listAgents, listProjects, listWorkspaces, recordTaskSpawnRequestedAsync, reportedRepoRootForCwd, resolveAgentOwnershipAsync, resolveProjectForCwd, rootsForProject, ValidationError, withResolvedProvisioningAsync } from "../db";
+import { addProjectRootAsync, countLiveSpawnedAgents, createActivityEventAsync, getAgent, getProject, listAgents, listWorkspaces, recordTaskSpawnRequestedAsync, reportedRepoRootForCwd, resolveAgentOwnershipAsync, resolveProjectForCwd, rootsForProject, ValidationError, withResolvedProvisioningAsync } from "../db";
 import { acquireCoordinatorTeam } from "./team";
 import { countInFlightSpawnCommands } from "../commands-db";
 import { createSpawnCommandWithinQuotaAsync } from "../commands-write";
@@ -54,7 +54,7 @@ import { profileNotFoundMessage } from "../spawn-profile-errors";
 import { composeSpawnInstructionsWithEventsAsync } from "../project-instructions";
 import { applyDefaultSharedMcp, type SharedMcpSpawnOverride } from "../shared-mcp";
 import { findGitRepoRoot, isInsideGitWorkTree, pathVisibleLocally } from "./canonical-root";
-import { selectSpawnCwdPlacement } from "./spawn-cwd-placement";
+import { selectSpawnCwdPlacement, spawnBuildWork } from "./spawn-cwd-placement";
 import { isolatedSpawnGitRepoError, resolveSpawnRepoRoot } from "./spawn-repo-probe";
 import { autoSeedProjectForCwdAsync } from "./project"; import { applyProjectCapabilityGates } from "../project-trust";
 import { assertProjectRoleMcpCwd, assertProjectRoleMcpTrusted, projectRoleProfile, projectRoleProvenance, projectRoleSpawnDefaults, withRoleProfile } from "../project-roles";
@@ -152,35 +152,6 @@ export function acquisitionManifestFor(projectId: string, cwd: string): {
   };
 }
 
-export async function taskLinkedRepoCwd(taskId: number, callerCwd?: string): Promise<string> {
-  const task = await getTaskDetailAsync(taskId);
-  if (!task) throw new ValidationError(`task ${taskId} not found or not a deliverable task`);
-  // #2844 — a Task created with `repo:` but no linked issue still names its project repo.
-  const repos = [...new Set([...task.issues.map((issue) => issue.repo), task.repo].filter((repo): repo is string => Boolean(repo)))];
-  if (repos.length === 0) {
-    throw new ValidationError(`task ${taskId} has no linked issue repo; pass cwd/orchestratorId explicitly`);
-  }
-  const candidates = listProjects()
-    .filter((project) => project.issueRepo && repos.includes(project.issueRepo))
-    .flatMap((project) => rootsForProject(project.id).map((root) => ({ project, root })));
-  if (candidates.length === 0) {
-    // #1627 — this refusal is real and names its own cause: with no registered root, relay has no
-    // way to turn "repo owner/name" into a checkout path on a specific host. What made it a trap
-    // was the NEXT step: following its advice (pass cwd + orchestratorId) used to hit the isolated
-    // precondition's local-filesystem probe and get told the repo was "not a git repo". That lie is
-    // fixed at assertIsolatedSpawnHasGitRepo, so the remedy below now works. Name the tool so it is
-    // mechanical rather than a step you have to know exists.
-    throw new ValidationError(`task ${taskId} links repo ${repos.join(", ")} but no Relay project root is registered for it, so relay cannot resolve a checkout path for it; pass cwd + orchestratorId explicitly, or register the checkout with relay_project_add_root`);
-  }
-  const matchingCallerRoot = callerCwd
-    ? candidates
-      .filter((candidate) => isPathWithinBase(callerCwd, candidate.root.rootPath))
-      .sort((a, b) => b.root.rootPath.length - a.root.rootPath.length)[0]
-    : undefined;
-  if (matchingCallerRoot) return matchingCallerRoot.root.rootPath;
-  if (candidates.length === 1) return candidates[0]!.root.rootPath;
-  throw new ValidationError(`task ${taskId} links repo ${repos.join(", ")} with multiple registered roots; pass cwd explicitly`);
-}
 
 /**
  * A normalized spawn request — every transport validates its own wire shape (enums,
@@ -390,7 +361,7 @@ export async function spawnAgent(input: SpawnAgentInput, ctx: AuthContext): Prom
   const lineageAgent: AgentCard | undefined = (lineageAgentId ? getAgent(lineageAgentId) : undefined) ?? undefined;
   const callerCwd = stringValue(caller?.meta?.cwd) ?? stringValue(lineageAgent?.meta?.cwd);
   const taskDefaultCwd = input.taskId !== undefined && (!input.orchestratorId || input.role !== undefined) && !input.cwd
-    ? input.taskRepoCwd ?? await taskLinkedRepoCwd(input.taskId, callerCwd)
+    ? input.taskRepoCwd ?? await taskLinkedRepoCwd(input.taskId, callerCwd, caller ?? lineageAgent)
     : undefined;
   const requestedCwd = input.cwd ?? taskDefaultCwd ?? (input.role !== undefined ? callerCwd : undefined);
   const roleSpawn = input.roleSnapshot ? { role: input.roleSnapshot, warnings: [] } : input.role === undefined && input.roleSha === undefined ? undefined : await resolveSpawnProjectRole({ role: input.role, roleSha: input.roleSha, profile: input.profile, orchestratorId: input.orchestratorId, cwd: requestedCwd, preferHost: input.roleHost ?? caller?.machine ?? lineageAgent?.machine, allowedOrchestratorIds: ctx.constraints?.orchestrators, canSpawn: canSpawn(ctx) });
@@ -429,7 +400,7 @@ export async function spawnAgent(input: SpawnAgentInput, ctx: AuthContext): Prom
     provider: resolvedProvider, orchestratorId: input.orchestratorId, requestedCwd: repoSource ? undefined : requestedCwd, repoSource,
     resumeWorkspace: input.resumeWorkspace, caller, lineageMachine: lineageAgent?.machine,
     callerCwd, allowedOrchestratorIds: ctx.constraints?.orchestrators,
-    shared: workspaceMode === "shared", workspaceMode, canLand: !landBlockResolution.landBlocked, model: modelParams.model, effort: modelParams.effort,
+    shared: workspaceMode === "shared", workspaceMode, canLand: !landBlockResolution.landBlocked, buildWork: spawnBuildWork(profileName, (input.dispatch ?? linkedTask?.dispatch ?? profileSpawnDefaults.dispatch)?.type), model: modelParams.model, effort: modelParams.effort,
   });
 
   assertOrchestratorSupportsLaunchMode(orchestrator, launchMode, input.providerArgs);
@@ -486,7 +457,7 @@ export async function spawnAgent(input: SpawnAgentInput, ctx: AuthContext): Prom
 
   if (shouldAutoScaffoldTask(input, profileName)) {
     const brief = spawnBrief(input)!;
-    linkedTask = createTaskEntity({
+    linkedTask = await createTaskEntity({
       title: taskTitleFromBrief(brief, input.label),
       intent: brief,
       latestSteer: input.steer,
@@ -544,7 +515,7 @@ export async function spawnAgent(input: SpawnAgentInput, ctx: AuthContext): Prom
   // disk. That's only trustworthy when the spawn's target orchestrator actually shares this
   // filesystem — a remote orchestrator's host can coincidentally have the same path with
   // DIFFERENT content, so the gate is told explicitly rather than inferring from path existence.
-  if (agentProfile.sources?.project) agentProfile = applyProjectCapabilityGates(agentProfile, resolvedCwd, registeredProjectBeforeAutoSeed, { orchestratorLocal: isOrchestratorLocalToRelay(orchestrator), ...(projectRole ? { pinnedMcpCommit: projectRole.source.sha } : {}) });
+  if (agentProfile.sources?.project) agentProfile = (await applyProjectCapabilityGates(agentProfile, resolvedCwd, registeredProjectBeforeAutoSeed, { orchestratorLocal: isOrchestratorLocalToRelay(orchestrator), ...(projectRole ? { pinnedMcpCommit: projectRole.source.sha } : {}) }));
   if (projectRole) assertProjectRoleMcpTrusted(projectRole, agentProfile);
 
   // N7 — project hooks/MCP are executable code and are gated against the project
@@ -599,7 +570,7 @@ export async function spawnAgent(input: SpawnAgentInput, ctx: AuthContext): Prom
   }
 
   // #3107 — the lineage coordinator's active team; a coordinator takes its project's seat, never a dissolved id.
-  const callerTeam = lineageAgentId ? acquireCoordinatorTeam(lineageAgentId) : undefined;
+  const callerTeam = lineageAgentId ? (await acquireCoordinatorTeam(lineageAgentId)) : undefined;
   const privateTeamId = profileName === "sub-coordinator" ? newTeamId() : undefined;
   const launchTeamId = privateTeamId ?? callerTeam?.id;
 
@@ -885,7 +856,7 @@ export async function spawnAgent(input: SpawnAgentInput, ctx: AuthContext): Prom
         requestedBy,
         ...(currentTask?.latestSteer ? { steer: currentTask.latestSteer } : {}),
       });
-      autoSubscribeTaskCoordinator(requestedBy, input.taskId);
+      (await autoSubscribeTaskCoordinator(requestedBy, input.taskId));
     } catch (err) {
       console.warn(`task ${input.taskId} spawn attribution skipped: ${errMessage(err)}`);
     }

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

@@ -50,7 +50,7 @@ export interface SpawnChainInspection {
   settings: Record<string, unknown> | null;
   /** The effective launch argv the adapter would exec. */
   argv: string[];
-  /** The launch command (claude / claude-rig). */
+  /** The launch command (e.g. claude). */
   command: string;
   /** relay-provisioned-hooks/<ref> dir for the baseline guard. */
   baselineHookAssetDir: string | undefined;

package/src/services/spawn-cwd-placement.ts

@@ -1,16 +1,21 @@
 import { basename, join, relative } from "node:path";
 import { hostname } from "node:os";
-import { normalizeGitRemoteIdentity, stringValue, type AgentCard, type Orchestrator, type SpawnProvider, type WorkspaceMode, type ProjectRoot } from "@humwick/sdk";
-import { listAgents, listOrchestrators, listWorkspaces, resolveProjectForCwd, rootsForProject, ValidationError } from "../db";
+import { normalizeGitRemoteIdentity, stringValue, type AgentCard, type Orchestrator, type SpawnProvider, type WorkspaceMode, type ProjectRoot, type TaskDispatch } from "@humwick/sdk";
+import { getOrchestrator, listAgents, listOrchestrators, listWorkspaces, resolveProjectForCwd, rootsForProject, ValidationError } from "../db";
+import { listHostViews } from "../db/hosts-views";
 import { unboundOnHost, unboundProjectRoots } from "../db/project-lifecycle";
 import { isOrchestratorLocalToRelay, isPathWithinBase, sameHostIdentity } from "../utils";
 import { findGitRepoRoot } from "./canonical-root";
 import { TERMINAL_WORKSPACE_STATUSES } from "../workspace-phase";
-import { selectSpawnPlacement, spawnPlacementCandidates, isRelayHost } from "../spawn-placement";
+import { selectSpawnPlacement, spawnPlacementCandidates, isRelayHost, type SpawnCapOptions } from "../spawn-placement";
 import { remoteUrlFromGitRemote } from "./git-remote";
 import { probeHostRepo, probeLocalSourceRepo } from "./spawn-repo-probe";
 import { hostProjectReadiness } from "./host-project-readiness";
 
+export function spawnBuildWork(profile: string, type?: TaskDispatch["type"]): boolean {
+  return type ? !["review", "research", "ops"].includes(type) : !["reviewer", "qa", "probe", "sec-ops"].includes(profile.toLowerCase());
+}
+
 /** Resolve host and working directory together so capacity routing keeps the caller's repo. */
 export async function selectSpawnCwdPlacement(input: {
   provider: SpawnProvider;
@@ -26,15 +31,16 @@ export async function selectSpawnCwdPlacement(input: {
   shared: boolean;
   workspaceMode?: WorkspaceMode;
   canLand?: boolean;
+  buildWork?: boolean;
   model?: string;
   effort?: string;
 }): Promise<{ orchestrator: Orchestrator; placementReason: string; resolvedCwd: string; lazyRoot?: ProjectRoot }> {
   const platformRule = input.workspaceMode === "isolated" && !input.shared && input.resumeWorkspace?.mode !== "attach"
     ? await sourcePlacementPlatforms(input) : undefined;
-  const capOpts = { ...(input.caller ? { callerAgentId: input.caller.id } : {}), attach: input.resumeWorkspace?.mode === "attach" };
+  const capOpts: SpawnCapOptions = { ...(input.caller ? { callerAgentId: input.caller.id } : {}), attach: input.resumeWorkspace?.mode === "attach", buildWork: input.buildWork };
   const earlyPlacement = !input.orchestratorId && input.resumeWorkspace?.mode !== "attach"
     ? spawnPlacementCandidates(input.provider, input.requestedCwd, input.allowedOrchestratorIds,
-      input.shared, input.model, input.effort, input.workspaceMode, platformRule, input.canLand, capOpts)
+      input.shared, input.model, input.effort, input.buildWork === false ? undefined : input.workspaceMode, platformRule, input.canLand, capOpts)
     : undefined;
   const survivors = earlyPlacement?.candidates.map((host) => host.id) ?? input.allowedOrchestratorIds;
   // Preserve selection's detailed exclusion error without probing hosts already ruled out.
@@ -43,6 +49,16 @@ export async function selectSpawnCwdPlacement(input: {
     input.model, input.effort, input.workspaceMode, platformRule, input.canLand, capOpts);
   const { attachWorkspace, hostCwds, allowedOrchestratorIds, lazyRoots, exclusions: checkoutExclusions = [] } = await omittedHostContext({ ...input, allowedOrchestratorIds: survivors });
   const requestedCwd = input.repoSource && !hostCwds ? input.repoSource : input.requestedCwd;
+  // Review/QA setup depends on the target checkout HEAD; a caller's policy base cannot vouch for it (#3805).
+  if (input.workspaceMode === "isolated" && input.buildWork === false && !input.resumeWorkspace) {
+    const views = new Map(listHostViews(Date.now()).map((view) => [view.id, view]));
+    const hosts = input.orchestratorId ? [getOrchestrator(input.orchestratorId)].filter((host): host is Orchestrator => !!host) : earlyPlacement?.candidates ?? [];
+    const lightHosts = await Promise.all(hosts.filter((host) => isRelayHost(host, host.hostId ? views.get(host.hostId) : undefined)).map(async (host) => {
+      const probe = await probeHostRepo(host, requestedCwd ?? hostCwds?.get(host.id) ?? input.callerCwd ?? host.baseDir, undefined, true);
+      return probe.kind === "present" && probe.workspaceDepsDisabled === true ? host.id : undefined;
+    }));
+    capOpts.workspaceDepsDisabledHosts = lightHosts.filter((id): id is string => id !== undefined);
+  }
   // #3169/#3625 — capacity ranks only hosts whose own checkout is ready for the project (refresh hook, toolchain).
   const readiness = hostProjectReadiness();
   const readinessExclusions: string[] = [];

package/src/services/spawn-issue-activity.ts

@@ -1,6 +1,8 @@
+import { resolveIssueRefFromStringAsync } from "../db/issue-refs-async";
+
 import { isRecord } from "@humwick/sdk";
 import { resolveProjectForCwd, spawnIssuePromptAsync } from "../db";
-import { resolveIssueRefFromString } from "../db/issue-refs";
+
 import { defaultIssueRepo } from "../config";
 import { parseJson } from "../utils";
 import { recordAndEmitIssueActivity } from "./issue-activity";
@@ -32,8 +34,8 @@ export async function recordSpawnPromptIssueActivity(agent: AgentCard, spawnRequ
       if (!num || seen.has(num)) continue;
       seen.add(num);
       try {
-        const issueRef = resolveIssueRefFromString({ ref: `#${num}`, defaultRepo: issueRepo });
-        recordAndEmitIssueActivity({
+        const issueRef = await resolveIssueRefFromStringAsync({ ref: `#${num}`, defaultRepo: issueRepo });
+        await recordAndEmitIssueActivity({
           agentId: agent.id,
           action: "edit",
           issueRefId: issueRef.id,
@@ -58,7 +60,7 @@ export async function recordSpawnPromptIssueActivity(agent: AgentCard, spawnRequ
  * as recordSpawnPromptIssueActivity so prompt + branch refs for the same issue
  * are deduplicated at the DB layer.
  */
-export function recordWorkspaceIssueActivity(workspace: WorkspaceRecord): void {
+export async function recordWorkspaceIssueActivity(workspace: WorkspaceRecord): Promise<void> {
   const agentId = workspace.ownerAgentId;
   if (!agentId || workspace.mode !== "isolated") return;
 
@@ -86,8 +88,8 @@ export function recordWorkspaceIssueActivity(workspace: WorkspaceRecord): void {
 
   for (const num of seen) {
     try {
-      const issueRef = resolveIssueRefFromString({ ref: `#${num}`, defaultRepo: issueRepo });
-      recordAndEmitIssueActivity({
+      const issueRef = await resolveIssueRefFromStringAsync({ ref: `#${num}`, defaultRepo: issueRepo });
+      await recordAndEmitIssueActivity({
         agentId,
         action: "edit",
         issueRefId: issueRef.id,

package/src/services/spawn-launch.ts

@@ -1,7 +1,7 @@
 import { memoryRetirementMessage } from "../memory-retirement";
 // #3121 — the provider, model and effort a spawn launches with, resolved in one place: spawnAgent uses it, and a
 // caller that must know a launch before anything spawns (a workflow's start check) asks the same seam.
-import type { SpawnProvider, TaskDispatch } from "@humwick/sdk";
+import { errMessage, type SpawnProvider, type TaskDispatch } from "@humwick/sdk";
 import { isProviderEnabled, type ProviderCatalogEntry } from "@humwick/sdk/provider-catalog";
 import { builtInProfileSpawnDefaults, profileProviderRefusal } from "../agent-profile-catalog";
 import { DEFAULT_SPAWN_PROFILE_NAME, getAgentProfile } from "../config-store";
@@ -14,6 +14,7 @@ import { captureDispatchContext, withProbeUncertainty, type DispatchSnapshot } f
 import { finalizeLaunchDecision } from "./spawn-launch-decision";
 import type { SpawnCapOptions } from "../spawn-placement";
 import { resolveProjectRoleForProvider } from "./spawn-project-role";
+import { PinnedHostCapacityError } from "../spawn-admission";
 
 export interface SpawnLaunchInput {
   profile?: string;
@@ -82,6 +83,21 @@ export async function resolveSpawnLaunch(input: SpawnLaunchInput, captured?: Dis
     mustResolveAvailable: mustResolveAvailableFor(input.dispatchShape), orchestratorId: input.orchestratorId, spawnCap: input.spawnCap,
     avoidProviders: input.avoidProviders,
   });
+  try {
+    return await resolveLaunch(input, snapshot);
+  } catch (error) {
+    if (!input.orchestratorId || !snapshot.pinnedHostAtAgentCap) throw error;
+    // #3816 — prove capacity is the only refusal using the same full launch resolver.
+    try {
+      await resolveSpawnLaunch({ ...input, spawnCap: { ...input.spawnCap, attach: true } });
+    } catch {
+      throw error;
+    }
+    throw new PinnedHostCapacityError(errMessage(error), input.orchestratorId);
+  }
+}
+
+async function resolveLaunch(input: SpawnLaunchInput, snapshot: DispatchSnapshot): Promise<SpawnLaunch> {
   const { catalog } = snapshot;
   let provider = input.provider;
   const profile = input.profile ? getAgentProfile(input.profile)?.value : undefined;

package/src/services/spawn-loss-escalation.ts

@@ -224,7 +224,7 @@ export async function escalateLostSpawnCommand(command: Command): Promise<SpawnL
   // A child that DID register is alive regardless of what happened to its command row; never
   // convert a bookkeeping loss into a phantom failure for a running agent.
   if (spawnRequestId && await spawnWatchdogHasRegisteredAsync(spawnRequestId)) return null;
-  notifyAgentSpawnFailed({
+  await notifyAgentSpawnFailed({
     parent,
     ...(spawnRequestId ? { spawnRequestId } : {}),
     ...(isRecord(command.params) && stringValue(command.params.provider) ? { provider: stringValue(command.params.provider)! } : {}),

package/src/services/spawn-registration-watchdog.ts

@@ -209,12 +209,12 @@ export async function reapUnregisteredSpawnCommands(
     const representativeId = unconfirmedIds[unconfirmedIds.length - 1] ?? group.rows[group.rows.length - 1]!.id;
     if (undispatchable) {
       lostSpawnCommandIds.push(representativeId);
-      notifyAgentSpawnFailed({ parent: group.parent, spawnRequestId: group.spawnRequestId, provider: group.provider, reason });
+      await notifyAgentSpawnFailed({ parent: group.parent, spawnRequestId: group.spawnRequestId, provider: group.provider, reason });
       continue;
     }
     if (group.latestUpdatedAt >= notifyCutoff) {
       notifiedUnconfirmedSpawnCommandIds.push(representativeId);
-      notifyAgentSpawnUnconfirmed({
+      await notifyAgentSpawnUnconfirmed({
         parent: group.parent,
         spawnRequestId: group.spawnRequestId,
         provider: group.provider,

package/src/services/spawn-repo-probe.ts

@@ -1,4 +1,5 @@
 import { cleanLandPlacement, readRepoLandPlacement } from "@humwick/sdk/land-gates";
+import { repoWorkspaceDepsDisabled } from "@humwick/sdk/worktree-config";
 import { existsSync } from "node:fs";
 import { isAbsolute } from "node:path";
 import { isRecord, normalizeGitRemoteIdentity, ValidationError, type Orchestrator } from "@humwick/sdk";
@@ -9,7 +10,7 @@ import { findGitRepoRoot } from "./canonical-root";
 import { runGit, toProjectGitResult } from "./git-process";
 import { remoteUrlFromGitRemoteAsync } from "./git-remote";
 
-export type RepoProbe = { kind: "present"; repoRoot?: string; remoteIdentity?: string; placementPlatforms?: string[]; toolchainError?: string }
+export type RepoProbe = { kind: "present"; repoRoot?: string; remoteIdentity?: string; placementPlatforms?: string[]; workspaceDepsDisabled?: boolean; toolchainError?: string }
   /** `occupied`: the path exists but is not inside a git checkout, so no clone can land there (#3347). */
   | { kind: "absent"; occupied?: boolean } | { kind: "timeout" } | { kind: "unavailable"; reason?: string };
 
@@ -77,17 +78,18 @@ export async function probeLocalSourceRepo(path: string, baseRef?: string | null
   if (!root) return { kind: "absent", occupied: true };
   const remote = await remoteUrlFromGitRemoteAsync(root, { refresh: true });
   let placementPlatforms: string[] | undefined;
+  const workspaceDepsDisabled = await repoWorkspaceDepsDisabled(placementGit(root));
   if (baseRef !== undefined) {
     try {
       placementPlatforms = await readRepoLandPlacement(baseRef ?? undefined, placementGit(root));
     } catch (error) { return { kind: "unavailable", reason: String(error) }; }
   }
-  return { kind: "present", repoRoot: root, ...(placementPlatforms ? { placementPlatforms } : {}), ...(remote ? { remoteIdentity: normalizeGitRemoteIdentity(remote) } : {}) };
+  return { kind: "present", repoRoot: root, workspaceDepsDisabled, ...(placementPlatforms ? { placementPlatforms } : {}), ...(remote ? { remoteIdentity: normalizeGitRemoteIdentity(remote) } : {}) };
 }
 
 async function probeRemoteRepo(host: Orchestrator, path: string, baseRef?: string | null, toolchain = false): Promise<RepoProbe> {
   if (!host.apiUrl || !isTrustedOrchestratorApiUrl(host.apiUrl)) return { kind: "unavailable" };
-  const result = await fetchHostJson<{ isGitRepo: boolean; definite?: boolean; pathExists?: boolean; repoRoot?: string; remoteIdentity?: string; placementPlatforms?: string[]; placementError?: string; toolchainError?: string }>(host.apiUrl, "/api/repo/identity", {
+  const result = await fetchHostJson<{ isGitRepo: boolean; definite?: boolean; pathExists?: boolean; repoRoot?: string; remoteIdentity?: string; placementPlatforms?: string[]; workspaceDepsDisabled?: boolean; placementError?: string; toolchainError?: string }>(host.apiUrl, "/api/repo/identity", {
     query: new URLSearchParams({ path, ...(toolchain ? { toolchain: "1" } : {}), ...(baseRef ? { baseRef } : baseRef === null ? { placement: "1" } : {}) }), timeoutMs: toolchain ? 50_000 : 20_000,
     validate: (body) => {
       if (!isRecord(body) || typeof body.isGitRepo !== "boolean"
@@ -101,14 +103,14 @@ async function probeRemoteRepo(host: Orchestrator, path: string, baseRef?: strin
       let placementPlatforms: string[] | undefined;
       try { placementPlatforms = cleanLandPlacement({ placement: { platforms: body.placementPlatforms } })?.platforms; }
       catch (error) { console.warn(`${host.id}: invalid repository placement: ${String(error)}`); }
-      return { ok: true, value: { ...(typeof body.toolchainError === "string" ? { toolchainError: body.toolchainError } : {}), isGitRepo: body.isGitRepo, definite: body.definite === true, pathExists: body.pathExists === true, ...(typeof body.placementError === "string" ? { placementError: body.placementError } : {}), ...(placementPlatforms ? { placementPlatforms } : {}),
+      return { ok: true, value: { workspaceDepsDisabled: body.workspaceDepsDisabled === true, ...(typeof body.toolchainError === "string" ? { toolchainError: body.toolchainError } : {}), isGitRepo: body.isGitRepo, definite: body.definite === true, pathExists: body.pathExists === true, ...(typeof body.placementError === "string" ? { placementError: body.placementError } : {}), ...(placementPlatforms ? { placementPlatforms } : {}),
         ...(typeof body.repoRoot === "string" ? { repoRoot: body.repoRoot } : {}),
         ...(typeof body.remoteIdentity === "string" ? { remoteIdentity: body.remoteIdentity } : {}) } };
     },
   });
   if (result.ok && baseRef !== undefined && result.value.placementError) return { kind: "unavailable", reason: result.value.placementError };
   if (result.ok) return result.value.isGitRepo
-    ? { kind: "present", ...(result.value.toolchainError ? { toolchainError: result.value.toolchainError } : {}), ...(result.value.repoRoot ? { repoRoot: result.value.repoRoot } : {}), ...(result.value.placementPlatforms ? { placementPlatforms: result.value.placementPlatforms } : {}), ...(result.value.remoteIdentity ? { remoteIdentity: result.value.remoteIdentity } : {}) }
+    ? { kind: "present", workspaceDepsDisabled: result.value.workspaceDepsDisabled, ...(result.value.toolchainError ? { toolchainError: result.value.toolchainError } : {}), ...(result.value.repoRoot ? { repoRoot: result.value.repoRoot } : {}), ...(result.value.placementPlatforms ? { placementPlatforms: result.value.placementPlatforms } : {}), ...(result.value.remoteIdentity ? { remoteIdentity: result.value.remoteIdentity } : {}) }
     // Old orchestrators also returned false for a killed/timed-out probe (#2715).
     : result.value.definite === true ? { kind: "absent", ...(result.value.pathExists ? { occupied: true } : {}) } : { kind: "unavailable" };
   const failure = result.failure;

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

@@ -2,36 +2,35 @@ import { errMessage, stringValue } from "@humwick/sdk";
 import type { WorkflowEffect } from "@humwick/kernel/workflow.pilot";
 import { getGateway } from "../db/gateway";
 import { getAgentAsync } from "../db";
+import { isTerminalCommandStatus } from "../db/command-terminal-status";
 import { shutdownAgent } from "./shutdown-agent";
 import { currentStop } from "./workflow-effects";
-import { invoke, supervisorNow, type Supervisor } from "./workflow-supervisor-state";
+import { invoke, retryResult, 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 = 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 });
   const targets = await getGateway().read("spawnTree.cleanupTargets", { agentId });
   const retry: Array<{ spawnRequestId: string; error: string }> = [];
+  let inFlight = false;
   for (const target of targets) {
     if (target.processGone) continue;
     try {
       const agent = await getAgentAsync(target.agentId);
       const generation = stringValue(agent?.meta?.spawnRequestId) ?? target.spawnRequestId;
-      const { id, prior } = await currentStop(`${effect.id}:stop:${target.spawnRequestId}:${generation}`, command =>
-        command.result?.targetNotFound !== true || now - command.updatedAt >= 15 * 60_000);
+      const { id, prior } = await currentStop(`${effect.id}:stop:${target.spawnRequestId}:${generation}`, now);
       const command = prior ?? (await shutdownAgent({
         ...(agent ? { agentId: agent.id } : {}), spawnRequestId: generation, orchestratorId: target.orchestratorId,
         commandId: id, requireProcessTreeProof: true, graceful: false, force: true,
         reason: String(effect.payload.reason), requestedVia: "bus", requestedBy: "workflow",
       }, { actor: { id: "workflow", kind: "system" }, scopes: [] })).command;
       if (command.status !== "succeeded" || command.result?.processTreeStopped !== true) retry.push({ spawnRequestId: target.spawnRequestId, error: `shutdown ${command.id}: ${command.status}` });
+      if (!isTerminalCommandStatus(command.status)) inFlight = true;
     } catch (error) { retry.push({ spawnRequestId: target.spawnRequestId, error: errMessage(error) }); }
   }
-  const delay = Math.min(60_000, 1000 * 2 ** Math.min(effect.attempts, 6));
-  await invoke(sup, "settleEffect", { id: effect.id, status: retry.length ? "pending" : "done", result: {
-    targets: targets.length, retry, checkedAt: now, ...(retry.length ? { nextAttemptAt: now + delay } : {}),
-  } });
+  const result = { targets: targets.length, retry, checkedAt: now, ...(inFlight ? { inFlight } : {}) };
+  await invoke(sup, "settleEffect", { id: effect.id, status: retry.length ? "pending" : "done", result: retry.length ? retryResult(effect.result, result, now) : result });
   return retry.length === 0;
 }

package/src/services/steward-reaper.ts

@@ -164,13 +164,13 @@ export async function reapIdleStewards(opts: { now?: number; signal?: AbortSigna
       if (entry.attempts >= STEWARD_REAP_MAX_ATTEMPTS) {
         if (!entry.alarmed) {
           entry.alarmed = true;
-          raiseOperatorAlarm({
+          (await raiseOperatorAlarm({
             clientId: `steward-zombie-blocking-${agent.id}`,
             source: "steward-reaper",
             subject: "Steward zombie is blocking a repo/host steward slot",
             detail: `Steward \`${agent.id}\` (${agent.label ?? "unlabelled"}, host ${agent.machine ?? "unknown"}) ignored ${entry.attempts} shutdown attempt(s) and is holding the one-per-repo/host steward slot — no new steward can spawn there until it is killed. Investigate and terminate it manually.`,
             metadata: { maintenanceJobId: "steward-reaper", agentId: agent.id, label: agent.label, machine: agent.machine, attempts: entry.attempts },
-          });
+          }));
         }
         reapTracker.set(agent.id, entry);
         alarmed.push(agent.id);
@@ -192,7 +192,7 @@ export async function reapIdleStewards(opts: { now?: number; signal?: AbortSigna
       entry.lastAt = now;
       reapTracker.set(agent.id, entry);
       if (graceful) {
-        requestTransientAgentShutdown(agent, {
+        (await requestTransientAgentShutdown(agent, {
           reason: disabled ? "steward-disabled" : "steward-orphan-idle",
           requestedBy: "steward-reaper",
           activityTitle: disabled ? "Orphaned steward reaped (spawning disabled)" : "Orphaned steward reaped",
@@ -201,7 +201,7 @@ export async function reapIdleStewards(opts: { now?: number; signal?: AbortSigna
             : "Steward has no live managed policy state and has been idle past the keepalive grace; reaping.",
           landReason: disabled ? "steward-disabled" : "steward-orphan-idle",
           now,
-        });
+        }));
       } else {
         // A plain agent-targeted `agent.shutdown` — graceful or not — is INERT against a runner that
         // has stopped reading its own commands (runner-core keys kill-hardness off the command TYPE,

package/src/services/task-context-hydration.ts

@@ -48,6 +48,10 @@ export interface TaskHydrationFacets {
   /** #2728 — the Task's `context` facet (free-text facts a coordinator must not resend by message). */
   context?: string;
   doneWhen?: string;
+  /** #3808 — the Task's `terminalStage` (deployed = deploy/live proof happens after land). */
+  terminalStage?: string;
+  /** #3808 — the Task's `onDeploy` follow-up, run after the deploy, not by the worker. */
+  onDeploy?: string;
   issues: ResolvedIssueSpec[];
   /** Decisions/rules: discussion + milestone write-throughs and steers (the narrative ledger). */
   decisions: TaskEvent[];
@@ -165,12 +169,28 @@ function renderContextFacet(value: string | undefined): string {
   return `\nContext (Task data):\n${fence(truncate(text, TASK_CONTEXT_LIMIT))}\n`;
 }
 
+/** #3808 — post-deploy criteria rendered apart from the worker's acceptance: they are checked after land
+ *  (QA / onDeploy) and must never read as unmet delivery criteria. Empty when the Task has none, so the
+ *  template line collapses to a blank line (the `{{context}}` seam's shape). */
+function renderAfterLandFacet(facets: Pick<TaskHydrationFacets, "terminalStage" | "onDeploy">): string {
+  const onDeploy = facets.onDeploy?.trim();
+  const deployed = facets.terminalStage === "deployed";
+  if (!onDeploy && !deployed) return "";
+  const parts = [
+    "\nAfter land (checked by QA/onDeploy once the change is live; NOT yours and never blocks delivery — deliver `complete` when code, tests and the delivery gate pass):",
+  ];
+  if (deployed) parts.push("- Terminal stage is deployed: deploy, live-check and independent-reproduction criteria in the acceptance above belong here, not to your delivery.");
+  if (onDeploy) parts.push(`- onDeploy follow-up:\n${fence(truncate(onDeploy, TASK_CONTEXT_LIMIT))}`);
+  return `${parts.join("\n")}\n`;
+}
+
 export function renderTaskHydration(facets: TaskHydrationFacets): string {
   const issues = facets.issues.length ? facets.issues.map(renderIssue).join("\n") : "- none linked";
   const decisions = facets.decisions.length ? facets.decisions.map(renderEvent).join("\n") : "- none recorded";
   const history = facets.history.length ? facets.history.map(renderEvent).join("\n") : "- none yet";
   const memory = facets.memory ? `\n${fence(facets.memory)}\n` : "";
   const context = renderContextFacet(facets.context);
+  const afterLand = renderAfterLandFacet(facets);
   const rendered = renderTemplate("task.hydration", {
     taskId: String(facets.taskId),
     title: inlineSafe(facets.title),
@@ -180,6 +200,7 @@ export function renderTaskHydration(facets: TaskHydrationFacets): string {
     intent: fence(facets.intent || "(no intent recorded)"),
     context,
     doneWhen: fence(facets.doneWhen || "(no explicit acceptance recorded)"),
+    afterLand,
     issues,
     decisions,
     history,
@@ -187,7 +208,8 @@ export function renderTaskHydration(facets: TaskHydrationFacets): string {
     steer: fence(facets.steer || "(no steer provided — proceed toward the acceptance above)"),
   }).trimEnd();
   // Saved operator templates can predate {{context}}; required Task data must still reach the worker (#3245).
-  return context && !rendered.includes(context.trim()) ? `${rendered}\n${context}`.trimEnd() : rendered;
+  const withContext = context && !rendered.includes(context.trim()) ? `${rendered}\n${context}`.trimEnd() : rendered;
+  return afterLand && !withContext.includes(afterLand.trim()) ? `${withContext}\n${afterLand}`.trimEnd() : withContext;
 }
 
 function hasTaskMemory(envelope: TaskMemoryEnvelope): boolean {
@@ -346,6 +368,8 @@ export async function hydrateTaskContext(input: HydrateTaskContextInput): Promis
     intent: task.intent ?? task.title,
     ...(task.context?.trim() ? { context: task.context } : {}),
     ...(task.doneWhen ? { doneWhen: task.doneWhen } : {}),
+    ...(task.terminalStage ? { terminalStage: task.terminalStage } : {}),
+    ...(task.onDeploy?.trim() ? { onDeploy: task.onDeploy } : {}),
     issues,
     decisions,
     history,