@humwick/server 0.130.1 → 0.130.3

package/src/maintenance/teams.ts

@@ -1,18 +1,7 @@
-import {
-  clearTeamZeroMembersSince,
-  countLiveTeamMembers,
-  createActivityEventAsync,
-  agentsWithPendingOwnRelayRun,
-  getAgent,
-  getCrashReport,
-  hasTerminalEvent,
-  getTeamBusyState,
-  getTeamRoster,
-  listActiveTeams,
-  setTeamZeroMembersSince,
-  TEAM_AUTO_REAP_SUMMARY_PREFIX,
-} from "../db";
-import { clearTeamIdleEntry, coordinatorsWithPendingTimers, getTeamIdleEntries, setTeamIdleEntry } from "../db/team-idle";
+import { setTeamIdleEntryAsync, clearTeamIdleEntryAsync } from "../db/runtime-tail-async";
+import { setTeamZeroMembersSinceAsync, clearTeamZeroMembersSinceAsync } from "../db/teams-async";
+import { countLiveTeamMembers, createActivityEventAsync, agentsWithPendingOwnRelayRun, getAgent, getCrashReport, hasTerminalEvent, getTeamBusyState, getTeamRoster, listActiveTeams, TEAM_AUTO_REAP_SUMMARY_PREFIX } from "../db";
+import { coordinatorsWithPendingTimers, getTeamIdleEntries } from "../db/team-idle";
 import { openWorkflowRunHolders } from "../db/workflow-task-read-ops";
 import { STALE_TTL_MS, stewardFallbackTarget } from "../config";
 import { agentProviderState } from "../provider-state";
@@ -48,13 +37,13 @@ function memberIsAlive(member: AgentCard, freshCutoff: number): boolean {
  * after its land, a graceful shutdown). This watchdog must surface ONLY a genuine silent death:
  * an agent that went quiet with NO terminal event of any kind.
  */
-function detectSilentMembers(
+async function detectSilentMembers(
   teamId: string,
   coordinatorId: string | undefined,
   now: number,
   thresholdMs: number,
   out: { pingedMembers: string[]; watchedMembers: number },
-): void {
+): Promise<void> {
   const freshCutoff = now - thresholdMs;
   const watch = teamMemberWatchTracker.get(teamId) ?? new Map<string, TeamMemberWatch>();
   teamMemberWatchTracker.set(teamId, watch);
@@ -85,7 +74,7 @@ function detectSilentMembers(
     if (getCrashReport(memberId) || hasTerminalEvent(memberId, entry.epoch)) continue;
     if (!coordinatorId) continue;
     const minutes = Math.floor(gapMs / 60_000);
-    notifyTarget(
+    await notifyTarget(
       "team.member_silent",
       { teamId, agentId: memberId },
       coordinatorId,
@@ -179,7 +168,7 @@ async function detectGoneCoordinator(
     watch.escalated = true; // the committed no-target audit is the complete no-silent-dissolve action
     return;
   }
-  const sent = notifyTarget(
+  const sent = await notifyTarget(
     "team.coordinator_gone",
     { teamId, agentId: coordinatorId, parent: resolveCoordinatorAgentId(coordinatorId) ?? undefined },
     escalationTarget,
@@ -222,10 +211,10 @@ function teamIdlePayload(teamId: string, coordinatorId: string, thresholdMinutes
   };
 }
 
-function notifyTeamIdle(teamId: string, coordinatorId: string, thresholdMinutes: number, idleForMs: number, firstNoBusyAt: number): string | null {
+async function notifyTeamIdle(teamId: string, coordinatorId: string, thresholdMinutes: number, idleForMs: number, firstNoBusyAt: number): Promise<string | null> {
   const roundedIdleMinutes = Math.max(thresholdMinutes, Math.floor(idleForMs / 60_000));
   const payload = teamIdlePayload(teamId, coordinatorId, thresholdMinutes, idleForMs, firstNoBusyAt);
-  return notifyTarget(
+  return await notifyTarget(
     "team.idle",
     { teamId, agentId: coordinatorId },
     coordinatorId,
@@ -270,7 +259,7 @@ export async function runTeamIdleWatchdog(input: { now?: number; signal?: AbortS
     seen.add(team.id);
     // #634 — runs every cycle, independent of the team-level idle gate below: a single silent
     // member must surface even while OTHER members keep the team "busy".
-    detectSilentMembers(team.id, team.coordinatorId, now, thresholdMs, memberSilence);
+    await detectSilentMembers(team.id, team.coordinatorId, now, thresholdMs, memberSilence);
     // #412/#468 — coordinator-gone escalation, also every cycle and independent of the idle gate: a
     // dead coordinator must surface even if the team isn't (yet) idle, and the idle-ping path can't
     // reach it (it would just ping the void).
@@ -299,7 +288,7 @@ export async function runTeamIdleWatchdog(input: { now?: number; signal?: AbortS
       ? busy.busyMemberIds.filter((id) => id !== team.coordinatorId)
       : busy.busyMemberIds;
     if (busyMemberIds.length > 0) {
-      if (existingEntry) clearTeamIdleEntry(team.id);
+      if (existingEntry) (await clearTeamIdleEntryAsync(team.id));
       teamIdleTracker.delete(team.id);
       busyTeamIds.push(team.id);
       continue;
@@ -311,7 +300,7 @@ export async function runTeamIdleWatchdog(input: { now?: number; signal?: AbortS
     }
 
     const entry = existingEntry ?? { firstNoBusyAt: now, pinged: false };
-    if (!existingEntry) setTeamIdleEntry(team.id, entry);
+    if (!existingEntry) (await setTeamIdleEntryAsync(team.id, entry));
     teamIdleTracker.set(team.id, entry);
     const idleForMs = now - entry.firstNoBusyAt;
     if (idleForMs < thresholdMs) {
@@ -328,10 +317,10 @@ export async function runTeamIdleWatchdog(input: { now?: number; signal?: AbortS
       continue;
     }
 
-    const sent = notifyTeamIdle(team.id, team.coordinatorId, config.thresholdMinutes, idleForMs, entry.firstNoBusyAt);
+    const sent = await notifyTeamIdle(team.id, team.coordinatorId, config.thresholdMinutes, idleForMs, entry.firstNoBusyAt);
     if (!sent) continue;
     entry.pinged = true;
-    setTeamIdleEntry(team.id, entry);
+    (await setTeamIdleEntryAsync(team.id, entry));
     pingedTeamIds.push(team.id);
   }
 
@@ -341,7 +330,7 @@ export async function runTeamIdleWatchdog(input: { now?: number; signal?: AbortS
   // coordinator that was already told. Skip the sweep instead; the next full pass reclaims them.
   if (!signal?.aborted) {
     for (const key of teamIdleTracker.keys()) if (!seen.has(key)) {
-      clearTeamIdleEntry(key);
+      (await clearTeamIdleEntryAsync(key));
       teamIdleTracker.delete(key);
     }
     for (const key of teamMemberWatchTracker.keys()) if (!seen.has(key)) teamMemberWatchTracker.delete(key);
@@ -385,7 +374,7 @@ export async function reapZeroMemberTeams(context: { signal?: AbortSignal } = {}
     const live = countLiveTeamMembers(team.id, cutoff);
     if (live > 0) {
       if (team.zeroMembersSince !== undefined) {
-        clearTeamZeroMembersSince(team.id);
+        (await clearTeamZeroMembersSinceAsync(team.id));
         clearedTeamIds.push(team.id);
       }
       continue;
@@ -393,7 +382,7 @@ export async function reapZeroMemberTeams(context: { signal?: AbortSignal } = {}
 
     zeroMemberTeams++;
     if (team.zeroMembersSince === undefined) {
-      setTeamZeroMembersSince(team.id, now);
+      (await setTeamZeroMembersSinceAsync(team.id, now));
       trackedTeamIds.push(team.id);
       continue;
     }
@@ -401,7 +390,7 @@ export async function reapZeroMemberTeams(context: { signal?: AbortSignal } = {}
 
     const outcomeSummary = `${TEAM_AUTO_REAP_SUMMARY_PREFIX} zero live members for ${grace}ms`;
     // Leave outcomeStatus null (unknown): an abandoned team is NOT a failed one.
-    const dissolved = dissolveTeamById(team.id, { outcomeSummary });
+    const dissolved = await dissolveTeamById(team.id, { outcomeSummary });
     await createActivityEventAsync({
       clientId: `team-reap-${team.id}-${now}`,
       kind: "state",

package/src/maintenance/workspaces.ts

@@ -1,19 +1,9 @@
+import { releaseExpiredMergeLeasesAsync, reelectRepoStewardAsync } from "../db/runtime-tail-async";
+import { deleteWorkspaceAsync } from "../db/lifecycle-tail-async";
+import { createCommandAsync } from "../commands-write";
 import { releaseExpiredStewardHandbacks } from "./steward-handback";
-import { createCommand } from "../commands-db";
-import {
-  agentsWithRunningCommandTimers,
-  createActivityEventAsync,
-  deleteWorkspace,
-  getAgent,
-  getRepoSteward,
-  getWorkspace,
-  listOrchestrators,
-  listWorkspaces,
-  patchWorkspaceMetadata,
-  reelectRepoSteward,
-  releaseExpiredMergeLeases,
-  updateWorkspaceStatusAsync,
-  setWorkspaceBranchAsync, patchWorkspaceMetadataAsync} from "../db";
+
+import { agentsWithRunningCommandTimers, createActivityEventAsync, getAgent, getRepoSteward, getWorkspace, listOrchestrators, listWorkspaces, patchWorkspaceMetadata, updateWorkspaceStatusAsync, setWorkspaceBranchAsync, patchWorkspaceMetadataAsync } from "../db";
 import type { WorkspaceMergePreview, WorkspaceRecord, WorkspaceStatus } from "../types";
 import { reconcileLandedWorkspace } from "../branch-landed";
 import { workspaceStewardEligible } from "../steward-queue";
@@ -187,7 +177,7 @@ export async function scanWorkspaceConflicts(context: { signal?: AbortSignal } =
       // a landing steward would spawn, find nothing to resolve, and re-strand the row. Route it to
       // the branch agent's COORDINATOR (owner/fallback) via the custody path instead — they own the
       // decision to rebase or abandon. (The event-driven auto-merge hook escalates the same way.)
-      const targets = routeWorkspaceCustodyEscalation({
+      const targets = await routeWorkspaceCustodyEscalation({
         workspace: ws,
         subject: "Workspace land keeps reverting (moved base)",
         body: `Workspace \`${ws.branch ?? ws.id}\` in ${ws.repoRoot} keeps getting its tip reverted as ${p.baseRef ?? "base"} moves under it (#1242); it can't auto-land. Please coordinate a rebase or clean-up.`,
@@ -360,7 +350,7 @@ export async function workspaceGC(context: { signal?: AbortSignal } = {}): Promi
   const now = Date.now();
   const cutoff = now - WORKSPACE_RETENTION_MS;
   const reviewCutoff = now - WORKSPACE_REVIEW_TTL_MS;
-  const releasedLeaseRepos = releaseExpiredMergeLeases(now);
+  const releasedLeaseRepos = (await releaseExpiredMergeLeasesAsync(now));
 
   const all = listWorkspaces();
   // #1726 — reclaim expired-terminal rows in a BOUNDED batch. GC can be paused for long stretches
@@ -376,7 +366,7 @@ export async function workspaceGC(context: { signal?: AbortSignal } = {}): Promi
   const terminalIds: string[] = [];
   for (const ws of terminalBatch) {
     if (signal?.aborted) break;
-    deleteWorkspace(ws.id);
+    (await deleteWorkspaceAsync(ws.id));
     terminalIds.push(ws.id);
   }
   // Rows the abort left undeleted are still expired and terminal, so they stay in the backlog the
@@ -394,7 +384,7 @@ export async function workspaceGC(context: { signal?: AbortSignal } = {}): Promi
   for (const ws of all) {
     if (signal?.aborted) break;
     if (!STRANDABLE_STATUSES.has(ws.status) || ws.mode !== "isolated" || !ws.worktreePath) continue;
-    reelectRepoSteward(ws.repoRoot);
+    (await reelectRepoStewardAsync(ws.repoRoot));
     const fresh = getWorkspace(ws.id);
     if (!fresh || !STRANDABLE_STATUSES.has(fresh.status)) continue;
     const ownerAlive = isOwnerAlive(fresh.ownerAgentId);
@@ -487,7 +477,7 @@ export async function workspaceGC(context: { signal?: AbortSignal } = {}): Promi
       const proof = landedElsewhere === "confirmed" ? "ancestor" : landedElsewhere;
       await reconcileLandedWorkspace(fresh, zeroCommitCloseOut
         ? { strategy: preview && !("available" in preview) ? preview.strategy : "rebase-ff", baseRef, ahead: 0, unmergedAhead: 0, dirtyCount: 0 }
-        : { strategy: preview && !("available" in preview) ? preview.strategy : "rebase-ff", baseRef, headSha: currentTip, landed: true, landedSha: currentTip });
+        : { strategy: preview && !("available" in preview) ? preview.strategy : "rebase-ff", baseRef, headSha: currentTip, landed: true, landedSha: currentTip }, landedElsewhere === "confirmed" ? currentTip : undefined);
       await patchWorkspaceMetadataAsync(fresh.id, {
         landedElsewhere: true,
         landedElsewhereAt: now,
@@ -518,7 +508,7 @@ export async function workspaceGC(context: { signal?: AbortSignal } = {}): Promi
     // resolve. (A stranded row that is genuinely in `conflict` status is already handed to a steward
     // by the conflict-scan path; the GC backstop's job here is custody, not conflict resolution.)
     const strandedHours = Math.round((now - strandedAt) / (60 * 60 * 1000));
-    const targets = routeWorkspaceCustodyEscalation({
+    const targets = await routeWorkspaceCustodyEscalation({
       workspace: fresh,
       subject: "Stranded workspace needs an owner",
       body: `Workspace \`${fresh.branch ?? fresh.id}\` in ${fresh.repoRoot} is ${fresh.status} and has been stranded for ${strandedHours}h. Please coordinate ${fresh.status === "conflict" ? "conflict resolution" : "review/merge"} or clean up the worktree.`,
@@ -530,13 +520,13 @@ export async function workspaceGC(context: { signal?: AbortSignal } = {}): Promi
       // fallback configured). Marking this "escalated" would silently swallow the strand and
       // repeat every sweep forever. Instead leave it UNescalated (don't stamp escalatedAt, so
       // the next sweep retries once recipients exist) and raise a louder operator-visible alarm.
-      raiseOperatorAlarm({
+      (await raiseOperatorAlarm({
         clientId: `workspace-gc-unescalatable-${fresh.id}:${strandedAt}:${Math.floor(now / escalationMs)}`,
         source: "workspace-gc",
         subject: "Stranded workspace has no one to escalate to",
         detail: `${fresh.branch ?? fresh.id} in ${fresh.repoRoot} has been ${fresh.status} for ${strandedHours}h but has no owner, coordinator, or fallback configured to escalate to. Configure AGENT_RELAY_WORKSPACE_STEWARD_FALLBACK or reclaim the worktree manually.`,
         metadata: { maintenanceJobId: "workspace-gc", workspaceId: fresh.id, repoRoot: fresh.repoRoot, branch: fresh.branch, status: fresh.status, strandedAt },
-      });
+      }));
       continue;
     }
     escalationTargets.push(...targets);
@@ -589,7 +579,7 @@ export async function workspaceGC(context: { signal?: AbortSignal } = {}): Promi
     // operator alarm when it resolves to nobody) instead of `stewardAgentId ?? fallback`.
     // Most strandable workspaces have no steward, so the old notice silently dropped while
     // the state change still happened.
-    const targets = routeWorkspaceCustodyEscalationOrAlarm({
+    const targets = await routeWorkspaceCustodyEscalationOrAlarm({
       source: "workspace-gc",
       workspace: fresh,
       type: "workspace.auto_abandoned",
@@ -620,12 +610,12 @@ export async function workspaceGC(context: { signal?: AbortSignal } = {}): Promi
     if (signal?.aborted) break;
     const orch = orchestrators.find((candidate) => workspacePathWithinBase(repoRoot, candidate.baseDir));
     if (!orch?.agentId) continue;
-    const command = createCommand({
+    const command = (await createCommandAsync({
       type: "workspace.prune",
       source: "system",
       target: orch.agentId,
       params: { repoRoot, requestedBy: "workspace-gc", requestedAt: now },
-    });
+    }));
     emitCommand(command);
     pruneCommands.push(command.id);
   }
@@ -696,7 +686,7 @@ export async function refreshIdleWorkspaces(context: { signal?: AbortSignal } =
     if (gitAhead !== undefined && gitAhead > 0) { skipped.push(`${ws.id}:ahead`); continue; }
     if (gitDirtyCount !== undefined && gitDirtyCount > 0) { skipped.push(`${ws.id}:dirty`); continue; }
 
-    const command = createCommand({
+    const command = (await createCommandAsync({
       type: "workspace.idle-refresh",
       source: "system",
       target: orch.agentId,
@@ -711,7 +701,7 @@ export async function refreshIdleWorkspaces(context: { signal?: AbortSignal } =
         requestedBy: "workspace-idle-refresh",
         requestedAt: now,
       },
-    });
+    }));
     emitCommand(command);
     dispatched.push(ws.id);
   }

package/src/managed-policy-escalation.ts

@@ -28,11 +28,11 @@ function managedPolicyEscalationRecipients(policy: SpawnPolicy, state: ManagedAg
 // agent — often the repo steward that lands branches — is down. Route those to the same
 // recipients as the offline branch, and when there is no reachable recipient raise an
 // operator-visible alarm instead of silently dropping the signal.
-export function escalateManagedSpawnFailure(
+export async function escalateManagedSpawnFailure(
   policy: SpawnPolicy,
   state: ManagedAgentState,
   opts: { phase: "failed" | "register-timeout" | "spawn-backoff"; error: string },
-): void {
+): Promise<void> {
   const recipients = managedPolicyEscalationRecipients(policy, state);
   const queuedMessages = queuedPolicyMessageCount(policy.name);
   const subject = opts.phase === "failed"
@@ -55,17 +55,17 @@ export function escalateManagedSpawnFailure(
     error: opts.error,
   };
   if (!recipients.length) {
-    raiseOperatorAlarm({
+    (await raiseOperatorAlarm({
       clientId: `managed-policy-alarm-${opts.phase}-${policy.name}-${policy.orchestratorId}`,
       source: "lifecycle-manager",
       subject,
       detail: `${body}\nNo owner, coordinator, or fallback is reachable to page.`,
       view: "managed-agents",
       metadata: payload,
-    });
+    }));
     return;
   }
-  routeNotification({
+  await routeNotification({
     type: "agent.spawn_failed",
     scope: { target: `policy:${policy.name}` },
     recipients,
@@ -85,14 +85,14 @@ export function escalateManagedSpawnFailure(
   });
 }
 
-export function escalateOfflineOrchestrator(policy: SpawnPolicy, state: ManagedAgentState, orch: Orchestrator | null | undefined): void {
+export async function escalateOfflineOrchestrator(policy: SpawnPolicy, state: ManagedAgentState, orch: Orchestrator | null | undefined): Promise<void> {
   if (state.consecutiveFailures < ORCHESTRATOR_OFFLINE_ESCALATION_FAILURES) return;
   const recipients = managedPolicyEscalationRecipients(policy, state);
   if (!recipients.length) return;
   const host = orch?.hostname ? `${orch.hostname} (${policy.orchestratorId})` : policy.orchestratorId;
   const queuedMessages = queuedPolicyMessageCount(policy.name);
   const nextRetry = state.backoffUntil ? new Date(state.backoffUntil).toISOString() : "not scheduled";
-  routeNotification({
+  await routeNotification({
     type: "agent.spawn_failed",
     scope: { target: `policy:${policy.name}` },
     recipients,

package/src/managed-policy.ts

@@ -1,3 +1,4 @@
+import { runnerRuntimeTokenEnvAsync, type RunnerLaunchAuthority, type RunnerRuntimeTokenInput } from "./runtime-tokens";
 import { getManifest } from "@humwick/providers";
 import { getAgentProfile, resolveAgentProfileKey } from "./config-store";
 import { effectiveProviderCatalogListAsync, ValidationError, withResolvedProvisioning, withResolvedProvisioningAsync } from "./db";
@@ -7,14 +8,12 @@ import { getAgent } from "./db/agents";
 import { getOrchestratorAsync } from "./db/orchestrators-async";
 import { composeProfileSpawnInstructions, composeProfileSpawnInstructionsAsync } from "./project-instructions";
 import { getSelfEffortCeiling } from "./db/self-effort-permissions";
-import { runnerRuntimeTokenEnv, type RunnerLaunchAuthority } from "./runtime-tokens";
-import { gatewayBackend } from "./db/gateway";
 import { recordedLaunchMode, resolveHostLaunchMode } from "./launch-mode";
 import { buildSpawnCommand, generateSpawnAgentId, resolveSpawnModelParams, resolveSpawnModelParamsAsync } from "./spawn-command";
 import { applyDefaultSharedMcp } from "./shared-mcp";
 import { AGENT_SYSTEM_TAGS, systemTagsForSpawn } from "./agent-system-tags";
 import { buildWhoamiDefaultForAgent } from "./mcp/identity-projection";
-import { isStewardPolicy, isGenuineStewardPolicy, stewardWorktreeCwdPrefixes } from "./steward-spawn-guard";
+import { isGenuineStewardPolicy, stewardWorktreeCwdPrefixes } from "./steward-spawn-guard";
 // #2033 — from isolated-workspace-placement.ts, NOT ./services/spawn-identity: that module also
 // exports buildProspectiveSpawnIdentity, which imports mcp/identity.ts → self-resume.ts →
 // restart-spawn.ts → managed-policy.ts, and importing it here would close that into a cycle.
@@ -66,7 +65,7 @@ function systemTagsForManagedPolicy(policy: SpawnPolicy): string[] {
   return tags;
 }
 
-export function buildManagedSpawnParams(policy: SpawnPolicy, requestId: string, ctx: ManagedSpawnContext): Record<string, unknown> {
+export async function buildManagedSpawnParams(policy: SpawnPolicy, requestId: string, ctx: ManagedSpawnContext): Promise<Record<string, unknown>> {
   if (policy.profile) policy = { ...policy, profile: resolveAgentProfileKey(policy.profile) ?? policy.profile };
   assertManagedProviderEnabled(managedPolicyProviderDisabledMessage(policy));
   const agentId = ctx.identityAgentId ?? generateSpawnAgentId();
@@ -97,7 +96,8 @@ export function buildManagedSpawnParams(policy: SpawnPolicy, requestId: string,
   const composed = composeProfileSpawnInstructions(managedInstructionInput(policy, agentProfile, agentRelayIdentity, orchestratorHost, alwaysOnAppend));
 
   return buildManagedCommand({ policy, requestId, ctx, agentId, prompt, agentProfile, orchestrator, extraCwdPrefixes, composed,
-    modelParams: resolveSpawnModelParams(policy.provider, policy.model, policy.effort, { skipDefaultWhenEmpty: !isStewardPolicy(policy) }),
+    modelParams: resolveSpawnModelParams(policy.provider, policy.model, policy.effort),
+    env: (await runnerRuntimeTokenEnvAsync(managedTokenInput(policy, requestId, ctx, agentId, extraCwdPrefixes))),
   });
 }
 
@@ -147,6 +147,7 @@ function buildManagedCommand(input: {
   extraCwdPrefixes: string[];
   composed: ReturnType<typeof composeProfileSpawnInstructions>;
   modelParams: ReturnType<typeof resolveSpawnModelParams>;
+  env: Record<string, string>;
 }): Record<string, unknown> {
   const { policy, requestId, ctx, agentId, prompt, agentProfile, orchestrator, extraCwdPrefixes, composed, modelParams } = input;
   return buildSpawnCommand({
@@ -177,26 +178,31 @@ function buildManagedCommand(input: {
     headless: true,
     policyName: policy.name,
     spawnRequestId: requestId,
-    env: runnerRuntimeTokenEnv({
-      agentId,
-      orchestratorId: policy.orchestratorId,
-      cwd: policy.cwd,
-      provider: policy.provider,
-      label: policy.label,
-      policyName: policy.name,
-      spawnRequestId: requestId,
-      createdBy: ctx.createdBy,
-      authority: ctx.authority,
-      profile: policy.profile || undefined,
-      // #2245 — the same posture this launch is given above; stamped into the signed constraints.
-      approvalMode: policy.permissionMode,
-      ...(extraCwdPrefixes.length ? { extraCwdPrefixes } : {}),
-    }),
+    env: input.env,
     requestedBy: ctx.createdBy,
     requestedAt: ctx.requestedAt ?? Date.now(),
   });
 }
 
+/** The runner token a managed launch carries; the sync builder and the writer-op builder mint the same input. */
+function managedTokenInput(policy: SpawnPolicy, requestId: string, ctx: ManagedSpawnContext, agentId: string, extraCwdPrefixes: string[]): RunnerRuntimeTokenInput {
+  return {
+    agentId,
+    orchestratorId: policy.orchestratorId,
+    cwd: policy.cwd,
+    provider: policy.provider,
+    label: policy.label,
+    policyName: policy.name,
+    spawnRequestId: requestId,
+    createdBy: ctx.createdBy,
+    authority: ctx.authority,
+    profile: policy.profile || undefined,
+    // #2245 — the same posture this launch is given above; stamped into the signed constraints.
+    approvalMode: policy.permissionMode,
+    ...(extraCwdPrefixes.length ? { extraCwdPrefixes } : {}),
+  };
+}
+
 // #2656 — backstop for every managed launch path (policy start/restart routes, agent restart): no
 // new process starts on a disabled provider. The lifecycle manager parks the policy before this.
 function assertManagedProviderEnabled(message: string | undefined): void {
@@ -205,15 +211,12 @@ function assertManagedProviderEnabled(message: string | undefined): void {
 
 /** Worker-safe counterpart used by every runtime managed launch path.  The synchronous builder
  * remains for in-process unit fixtures; production must never borrow its main-thread connection. */
-export function buildManagedSpawnParamsAsync(policy: SpawnPolicy, requestId: string, ctx: ManagedSpawnContext): Record<string, unknown> | Promise<Record<string, unknown>> {
+export async function buildManagedSpawnParamsAsync(policy: SpawnPolicy, requestId: string, ctx: ManagedSpawnContext): Promise<Record<string, unknown>> {
   if (effectiveManagedPolicyWorkspaceMode(policy) === "isolated" && ctx.gitRepoRoot === undefined) {
-    return getOrchestratorAsync(policy.orchestratorId).then(async (host) => buildManagedSpawnParamsAsync(policy, requestId, {
-      ...ctx, gitRepoRoot: host ? await resolveSpawnRepoRoot(host, policy.cwd) : null,
-    }));
+    const host = await getOrchestratorAsync(policy.orchestratorId);
+    ctx = { ...ctx, gitRepoRoot: host ? await resolveSpawnRepoRoot(host, policy.cwd) : null };
   }
-  // Preserve immediate in-process command construction for durable policy wake callers. The worker
-  // backend never enters this synchronous branch, so it cannot reopen the closed-main DB path.
-  return gatewayBackend() === "in-process" ? buildManagedSpawnParams(policy, requestId, ctx) : buildManagedSpawnParamsWorkerAsync(policy, requestId, ctx);
+  return buildManagedSpawnParamsWorkerAsync(policy, requestId, ctx);
 }
 
 async function buildManagedSpawnParamsWorkerAsync(policy: SpawnPolicy, requestId: string, ctx: ManagedSpawnContext): Promise<Record<string, unknown>> {
@@ -231,6 +234,7 @@ async function buildManagedSpawnParamsWorkerAsync(policy: SpawnPolicy, requestId
   const extraCwdPrefixes = managedCwdPrefixes(policy, requestId, ctx, orchestrator);
   const composed = await composeProfileSpawnInstructionsAsync(managedInstructionInput(policy, agentProfile, agentRelayIdentity, orchestratorHost, alwaysOnAppend));
   return buildManagedCommand({ policy, requestId, ctx, agentId, prompt, agentProfile, orchestrator, extraCwdPrefixes, composed,
-    modelParams: await resolveSpawnModelParamsAsync(policy.provider, policy.model, policy.effort, { skipDefaultWhenEmpty: !isStewardPolicy(policy) }),
+    modelParams: await resolveSpawnModelParamsAsync(policy.provider, policy.model, policy.effort),
+    env: await runnerRuntimeTokenEnvAsync(managedTokenInput(policy, requestId, ctx, agentId, extraCwdPrefixes)),
   });
 }

package/src/managed-provider-gate.ts

@@ -1,9 +1,10 @@
+import { upsertManagedAgentStateAsync, updateManagedAgentStateAsync } from "./db/lifecycle-tail-async";
 // #2656 — "off means nothing new starts on it": a managed policy whose provider is disabled (operator
 // switch or all models disabled) must not launch. The lifecycle manager parks the policy with a
 // visible reason instead of spawning — no backoff churn, no crash loop — and its normal reconcile
 // tick resumes the policy on its own once the provider is re-enabled.
 import { findProviderCatalog, providerDisabledMessage, type ProviderCatalogEntry } from "@humwick/sdk/provider-catalog";
-import { getManagedAgentState, updateManagedAgentState, upsertManagedAgentState } from "./config-store";
+import { getManagedAgentState } from "./config-store";
 import { effectiveProviderCatalogList } from "./provider-catalog-store";
 import type { ManagedAgentState, SpawnPolicy } from "./types";
 
@@ -17,11 +18,11 @@ export function managedPolicyProviderDisabledMessage(policy: Pick<SpawnPolicy, "
  * Record the skipped launch on the policy's state (`stopped` + lastError) so the dashboard shows why.
  * Returns the new state only when it changed, so a caller emits once rather than every tick.
  */
-export function parkManagedPolicyForDisabledProvider(policy: SpawnPolicy, message: string): ManagedAgentState | undefined {
+export async function parkManagedPolicyForDisabledProvider(policy: SpawnPolicy, message: string): Promise<ManagedAgentState | undefined> {
   const state = getManagedAgentState(policy.name);
   if (state?.status === "stopped" && state.lastError === message) return undefined;
   const next = state
-    ? updateManagedAgentState(policy.name, { status: "stopped", spawnRequestId: undefined, lastError: message })
-    : upsertManagedAgentState({ policyName: policy.name, status: "stopped", orchestratorId: policy.orchestratorId, provider: policy.provider, restartCount: 0, consecutiveFailures: 0, lastError: message });
+    ? (await updateManagedAgentStateAsync(policy.name, { status: "stopped", spawnRequestId: undefined, lastError: message }))
+    : (await upsertManagedAgentStateAsync({ policyName: policy.name, status: "stopped", orchestratorId: policy.orchestratorId, provider: policy.provider, restartCount: 0, consecutiveFailures: 0, lastError: message }));
   return next ?? undefined;
 }

package/src/managed-spawn-reservation.ts

@@ -1,4 +1,5 @@
-import { getManagedAgentState, getSpawnPolicy, upsertManagedAgentState } from "./config-store";
+import { upsertManagedAgentStateAsync } from "./db/lifecycle-tail-async";
+import { getManagedAgentState, getSpawnPolicy } from "./config-store";
 import type { ManagedAgentState, SpawnPolicy } from "./types";
 
 /** True only while an async preparation still owns the policy's starting reservation. */
@@ -15,9 +16,9 @@ export function managedSpawnReservationCurrent(policy: SpawnPolicy, policySnapsh
 }
 
 /** Return a preparation's own reservation to its pre-spawn state when the host drains. */
-export function restoreDrainedSpawnReservation(policy: SpawnPolicy, requestId: string, prior: ManagedAgentState | null): void {
+export async function restoreDrainedSpawnReservation(policy: SpawnPolicy, requestId: string, prior: ManagedAgentState | null): Promise<void> {
   const current = getManagedAgentState(policy.name);
   if (current?.status !== "starting" || current.spawnRequestId !== requestId) return;
-  upsertManagedAgentState(prior ?? { policyName: policy.name, status: "stopped", orchestratorId: policy.orchestratorId,
-    provider: policy.provider, spawnRequestId: undefined, restartCount: 0, consecutiveFailures: 0 });
+  (await upsertManagedAgentStateAsync(prior ?? { policyName: policy.name, status: "stopped", orchestratorId: policy.orchestratorId,
+    provider: policy.provider, spawnRequestId: undefined, restartCount: 0, consecutiveFailures: 0 }));
 }

package/src/mcp/index.ts

@@ -1,5 +1,6 @@
 import { normalizeOutputArgs, outputToolDefinition, presentToolOutput } from "./output-levels";
 import { PROMPT_TOOLS, relayPrompt } from "./prompts";
+import { PROJECT_PROFILE_INSTRUCTION_TOOLS, relayProjectProfileInstructions } from "./project-profile-instructions";
 import { PromptVersionConflictError } from "../prompt-version-errors";
 import { memoryRetirementMessage } from "../memory-retirement";
 import { GUIDE_TOOLS, relayGuide } from "./guides";
@@ -60,6 +61,7 @@ const MCP_PROTOCOL_VERSION = "2024-11-05";
 const MCP_BODY_OVERHEAD_BYTES = ARTIFACT_BODY_OVERHEAD_BYTES;
 const TOOLS: ToolDefinition[] = [
   ...PROMPT_TOOLS,
+  ...PROJECT_PROFILE_INSTRUCTION_TOOLS,
   ...WEB_TOOL_CALL_TOOLS,
   ...MESSAGING_TOOLS,
   ...ARTIFACT_TOOLS,
@@ -215,6 +217,7 @@ async function callTool(auth: VerifiedMcpAuthContext, params: unknown, signal?:
     else if (name === "relay_hosts") result = await relayHosts(auth, args);
     else if (name === "relay_host_gate_budget") result = await relayHostGateBudget(auth, args);
     else if (name === "relay_prompt") result = await relayPrompt(auth, args);
+    else if (name === "relay_project_profile_instructions") result = await relayProjectProfileInstructions(auth, args);
     else if (name === "relay_service_access") result = await relayServiceAccess(auth, args);
     else if (name.startsWith("relay_secret_")) result = await relaySecretTool(auth, name, args);
     else if (name === "relay_my_agents") result = await relayMyAgents(auth, args);
@@ -223,7 +226,7 @@ async function callTool(auth: VerifiedMcpAuthContext, params: unknown, signal?:
     else if (name === "relay_agent_keep") result = await relayAgentKeep(auth, args);
     else if (name === "relay_codex_reset_consume") result = await relayCodexResetConsume(args);
     else if (name === "relay_claude_api_budget") result = await relayClaudeApiBudget(args);
-    else if (name === "relay_profile_trust") result = relayProfileTrust(auth, args);
+    else if (name === "relay_profile_trust") result = await relayProfileTrust(auth, args);
     else if (name.startsWith("relay_routing_policy_")) result = await relayRoutingPolicyTool(auth, name, args);
     else if (name === "relay_agent_action") result = await relayAgentAction(auth, args);
     else if (name === "relay_set_effort") result = await relaySetEffort(auth, args);
@@ -236,7 +239,7 @@ async function callTool(auth: VerifiedMcpAuthContext, params: unknown, signal?:
     else if (name === "relay_workspace_merge_resume") result = await relayWorkspaceMutation(auth, "resume-merge", args);
     else if (name === "relay_red_main_recover") result = await relayRedMainRecover(auth, args);
     else if (name === "relay_workspace_release") result = await relayWorkspaceMutation(auth, "release-claim", args);
-    else if (name.startsWith("relay_merge_")) result = relayMergeTool(auth, name, args); else if (name.startsWith("relay_maintenance_")) result = await relayMaintenanceTool(auth, name, args); else if (name.startsWith("relay_team_")) result = await relayTeamTool(auth, name, args); else if (name === "relay_decision") result = relayDecisionTool(auth, args);
+    else if (name.startsWith("relay_merge_")) result = (await relayMergeTool(auth, name, args)); else if (name.startsWith("relay_maintenance_")) result = await relayMaintenanceTool(auth, name, args); else if (name.startsWith("relay_team_")) result = await relayTeamTool(auth, name, args); else if (name === "relay_decision") result = (await relayDecisionTool(auth, args));
     else if (name.startsWith("relay_plan_")) result = await relayPlanTool(auth, name, args);
     else if (name === "relay_task_deliver") result = await relayTaskDeliverTool(auth, name, args);
     else if (TASK_VALIDATION_TOOLS.some((tool) => tool.name === name)) result = await relayTaskValidationTool(auth, name, args);
@@ -249,16 +252,16 @@ async function callTool(auth: VerifiedMcpAuthContext, params: unknown, signal?:
     else if (name === "relay_task_comment" || name === "relay_task_close_bridge") result = await relayTaskWeaveTool(auth, name, args);
     else if (name === "relay_release_readiness") result = await relayReleaseTool(name, args);
     else if (name.startsWith("relay_task_")) result = await relayTaskTool(auth, name, args);
-    else if (name.startsWith("relay_blackboard_")) result = relayBlackboardTool(auth, name, args);
+    else if (name.startsWith("relay_blackboard_")) result = (await relayBlackboardTool(auth, name, args));
     // #2591 — the journal tools must claim their prefix BEFORE the generic relay_project_
     // dispatcher, or they would fall through to relayProjectTool as "unknown tool".
-    else if (name.startsWith("relay_project_journal_")) result = relayProjectJournalTool(auth, name, args);
-    else if (name === "relay_project_ingest_claudemd") result = await relayProjectIngestClaudeMd(auth, args); else if (name.startsWith("relay_project_")) result = await relayProjectTool(auth, name, args); else if (name.startsWith("relay_issue_ref_")) result = relayIssueRefTool(auth, name, args); else if (name.startsWith("relay_issue_association_")) result = relayIssueAssociationTool(auth, name, args); else if (name.startsWith("relay_issue_activity_")) result = await relayIssueActivityTool(auth, name, args); else if (name.startsWith("relay_issue_lifecycle_")) result = await relayIssueLifecycleTool(auth, name, args);
+    else if (name.startsWith("relay_project_journal_")) result = (await relayProjectJournalTool(auth, name, args));
+    else if (name === "relay_project_ingest_claudemd") result = await relayProjectIngestClaudeMd(auth, args); else if (name.startsWith("relay_project_")) result = await relayProjectTool(auth, name, args); else if (name.startsWith("relay_issue_ref_")) result = await relayIssueRefTool(auth, name, args); else if (name.startsWith("relay_issue_association_")) result = (await relayIssueAssociationTool(auth, name, args)); else if (name.startsWith("relay_issue_activity_")) result = await relayIssueActivityTool(auth, name, args); else if (name.startsWith("relay_issue_lifecycle_")) result = await relayIssueLifecycleTool(auth, name, args);
     else if (name === "relay_subscribe" || name === "relay_unsubscribe" || name === "relay_list_subscriptions" || name === "relay_why_notified" || name === "relay_notification_preview") result = await relayNotificationSubscriptionTool(auth, name, args);
-    else if (name === "relay_notify_ntfy") result = relayNotifyNtfy(args);
+    else if (name === "relay_notify_ntfy") result = (await relayNotifyNtfy(args));
     else if (name === "relay_delete_channel_binding") result = await relayDeleteChannelBinding(args, auth);
     else if (name === "relay_channel_output") result = await relayChannelOutput(args, auth);
-    else if (name === "relay_send_to_channel") result = relayEgressToChannel(args, auth);
+    else if (name === "relay_send_to_channel") result = (await relayEgressToChannel(args, auth));
     else throw new ValidationError(`unknown tool: ${wireName}`);
 
     return toolResult(presentToolOutput(name, result, verbosity, args));
@@ -292,9 +295,9 @@ async function visibleTools(auth: McpAuthContext, generation: ToolGeneration): P
       alwaysOn: auth.component?.role === "provider" && Boolean(constraints.profile || auth.component.sub.startsWith("runner:")),
       allowUnknownGroups: true,
     })
-    : null;
+    : auth.component?.role === "provider" ? resolveRelayTools({}, { alwaysOn: false }) : null;
   if (auth.component?.role === "provider") {
-    for (const name of RELAY_TOOL_GROUPS[SELF_CARE_TOOL_GROUP]!) allowedNames?.add(name);
+    for (const name of resolveRelayTools({ groups: [SELF_CARE_TOOL_GROUP] }, { alwaysOn: false })) allowedNames?.add(name);
   }
   // #1570 — an explicit per-tool allowlist narrows the surface further (still ∩ scopes ∩ groups). This
   // is the Codex-worker provider-split: it trims the always-loaded MCP set the client eager-loads every

package/src/mcp/output-descriptions.ts

@@ -27,14 +27,14 @@ export const OUTPUT_DESCRIPTIONS: Record<string, string> = {
   relay_kernel_listEntities: "List entities.",
   relay_kernel_listEvents: "List events.",
   relay_kernel_listInstances: "List workflow instances.",
-  relay_list_artifacts: "List artifacts; relay_read_artifact reads bodies.",
+  relay_list_artifacts: "List artifacts (metadata only).",
   relay_list_subscriptions: "Your subscriptions",
   relay_list_timers: "List your scheduled timers.",
   relay_maintenance_jobs: "Job health; jobId reads runbook.",
   relay_maintenance_pauses: "Maintenance pauses.",
   relay_merge_pauses: "Merge holds",
   relay_notification_preview: "Preview notification routing.",
-  relay_plan_get: "Read plan; mode:resume selects the frontier view.",
+  relay_plan_get: "Read plan; mode:resume reads the frontier.",
   relay_plan_list: "List team plans.",
   relay_project_checkout: "Inspect, bind, unbind (keeps files) or remove (deletes files) a checkout.",
   relay_project_get: "Read project and roots.",
@@ -44,7 +44,7 @@ export const OUTPUT_DESCRIPTIONS: Record<string, string> = {
   relay_project_search: "Search memory; read full bodies by returned ids.",
   relay_prompt: "Read/edit prompts; writes need expectedVersion; restore/adopt append.",
   relay_read_artifact: "Page artifact text; binary returns download command.",
-  relay_recall: "Search history; read a returned ref for the segment.",
+  relay_recall: "Search history; read a returned ref.",
   relay_release_readiness: "Read release readiness.",
   relay_routing_policy_get: "Read policy",
   relay_run: "Run shell work. Long work: waitMs:0, END YOUR TURN and await completion; never poll.",
@@ -53,17 +53,17 @@ export const OUTPUT_DESCRIPTIONS: Record<string, string> = {
   relay_task_close_bridge: "Read Task close-bridge state.",
   relay_task_get: "Read Task hydration.",
   relay_task_history: "Read Task history.",
-  relay_task_list: "List your Tasks; mine:false lists all.",
+  relay_task_list: "Tasks.",
   relay_task_memory_read: "Read Task continuation.",
   relay_task_needs_validation: "List Tasks awaiting validation.",
   relay_team_get: "Read team and roster summary.",
   relay_team_template_get: "Read saved",
   relay_team_template_list: "Saved",
-  relay_web_tool_calls: "Page web calls newest first; times are epoch milliseconds.",
+  relay_web_tool_calls: "Page web calls, newest first; epoch ms.",
   relay_why_notified: "Explain delivery.",
-  relay_workflow_cancel: "Cancel run and reap agents.",
-  relay_workflow_get: "Read run status; history and result pages are opt-in.",
-  relay_workflow_resume: "Resume or answer/escalate a decision.",
+  relay_workflow_cancel: "Cancel run; reap agents.",
+  relay_workflow_get: "Read run status; history opt-in.",
+  relay_workflow_resume: "Resume, pause/unpause, re-pin, or answer decisions.",
   relay_workflow_start: "Start Task workflow.",
   relay_workspace_deps: "Check or refresh workspace dependencies.",
   relay_workspace_list: "List workspaces.",