@telora/daemon 0.19.47 → 0.19.74

package/dist/focus-executor.d.ts

@@ -27,40 +27,25 @@
  * When tracing a symbol imported from this file, check those modules first;
  * only the spawn choreography itself is implemented here.
  */
-import { spawn, type ChildProcessWithoutNullStreams, type SpawnOptionsWithoutStdio } from 'node:child_process';
 import type { DaemonConfig, AgentRole, FocusTeamState, PipelineConfig } from './types.js';
-import { createSession, type SessionType } from './supabase.js';
 import { type ResourceGovernor } from '@telora/daemon-core';
-import { createEscalation } from './queries/issues.js';
-import { type FocusTeamPromptContext } from './team-prompt-base.js';
-import { getFocusDeliveries, getFocusIssues, getProductContextForFocus, getProductDeploymentProfileSnapshot } from './queries/focuses.js';
-import { resolveLineageSpec, type SessionContinuity } from './session-lineage.js';
-import { consumePendingSpawnDirective } from './directive-executor.js';
-import { type AssemblyManifestEntry } from './assembly-engine.js';
 import './assembly-resolvers.js';
-import { getLocalModel, getLocalModelSecret, type LocalModelCoordinates } from './queries/local-models.js';
-import { writeLocalModelCodexHome } from './cli/codex-provision.js';
-import { type CodexMcpProxyHandle } from './backends/codex/codex-mcp-proxy.js';
-import { type HostCapability } from './host-control/index.js';
-import { setupTeamLogStreams } from './spawner/helpers.js';
-import { resolveBackend, type AgentBackend, type EngineOverride, type EnginePass } from './backends/index.js';
+import type { SpawnFocusTeamParams } from './spawn/spawn-decision.js';
+export { selectLocalModelRef, codexHomeForSpawn, decideLocalModelRouting, shouldSwapForPass, resolveEffectiveModel, isClaudeModelId, selectPipelineModelForSpawn, selectDirectiveModelForSpawn, resolveLocalModelConfig, surfaceSingleHostModelConflict, resolveSpawnModel, buildAgentArgs, } from './spawn/model-routing.js';
+export type { LocalModelRouting, LocalModelConfig, LocalModelConfigDeps, HostConflictSurfaceDeps, SpawnModelResolution, } from './spawn/model-routing.js';
+export { buildFocusPromptContext, buildSpawnPrompt, buildSpawnMessage, resolveScopingSpawnResume, findQueuedDeliveriesWithoutTaskIssues, buildQueuedDeliveryScopingMessage, } from './spawn/prompt-assembly.js';
+export type { SpawnContext, DirectiveResolution } from './spawn/shared.js';
+export { createInitialTeamState, resolveSpawnWorktree, createTeamSession, resolveReviewContext, resolveEngineForPass, } from './spawn/worktree-session.js';
+export { findActionableDeliveries, resolveActionableDeliveries, resolveDirectiveOrFallback, fetchSpawnContext, DEFAULT_LOOP_CONTEXT_RECIPE, } from './spawn/spawn-decision.js';
+export type { SpawnDecision, ActionableResolution, SpawnFocusTeamParams } from './spawn/spawn-decision.js';
+export { gateLocalModelBackendSpawn, backendUnavailableSessionUpdate, spawnCrashIsolated, persistSpawnFailureAfterRunning, closeTeamProxyQuietly, spawnTeamProcess, governorDeniedSessionUpdate, sandboxUnavailableSessionUpdate, } from './spawn/process-spawn.js';
+export type { SpawnTeamProcessArgs, BackendSpawnGateResult } from './spawn/process-spawn.js';
 export { getActiveTeams, hasActiveTeam, getActiveTeamCount, } from './focus-team-state.js';
 export { mergeFocusBranch, } from './focus-merge.js';
 export { handleTeamCompletion, advanceDeliveryStatuses, isStatusTerminal, isStatusAgentActionable, } from './completion/index.js';
 export type { TeamCompletionParams } from './completion/index.js';
 export { terminateTeam, waitForTeamExit, terminateAllTeams, detectDeactivatedFocuses, checkAndMergeCompletedDeliveries, } from './completion/index.js';
 export type { CompletionEventContext } from './completion/index.js';
-/**
- * Default loop-context assembly recipe for a focus-team spawn.
- *
- * Composed once per spawn into the team prompt. `focus.endpoint_catalog`
- * is placed right after `focus.injections` so the exposed/consumed endpoint
- * catalog reads alongside the tree context -- surfacing cross-product
- * interrelations at scoping time (shift-left) so a dependency on another
- * product can be mapped into the reality tree as an externally-owned obstacle
- * rather than surfacing reactively as a blocked_by_external escalation.
- */
-export declare const DEFAULT_LOOP_CONTEXT_RECIPE: string[];
 /** Inject the resource governor for global concurrency limiting. */
 export declare function initGovernor(gov: ResourceGovernor): void;
 /**
@@ -69,480 +54,10 @@ export declare function initGovernor(gov: ResourceGovernor): void;
  * sets, so callers see the governor FocusEngine actually injected.
  */
 export declare function getGovernor(): ResourceGovernor | null;
-/**
- * Result of the pre-spawn guard. Discriminated union so the caller can
- * distinguish between "no work yet, spawn a planning team" and "actionable
- * deliveries are queued, run them" without conflating null with empty.
- */
-export type SpawnDecision = {
-    kind: 'planning';
-} | {
-    kind: 'execute';
-    deliveries: Awaited<ReturnType<typeof getFocusDeliveries>>;
-} | {
-    kind: 'skip';
-};
-/**
- * Pre-spawn guard: rank-ordered walk that collects every agent-actionable
- * delivery into the spawn set.
- *
- * "Actionable" and "blocking" are independent properties of a status:
- *
- * - actionable = `isStatusAgentActionable(status)` -- queued | coding |
- *   verify_failed. Work the team can pick up.
- * - blocking   = `isStatusBlocking(status)` -- statuses that gate
- *   subsequent ranks (queued, coding, planning, paused).
- *
- * A delivery may be actionable and blocking (queued, coding -- the common
- * case), actionable and non-blocking (`verify_failed` -- has remediation
- * work from a review pass, but the next-ranked queued delivery should not
- * wait on it), or non-actionable and blocking (planning, paused -- gates
- * the queue and the team has nothing to do here).
- *
- * Walk semantics:
- * - Collect every actionable delivery into the spawn set.
- * - Stop the walk when we hit the first blocking-and-not-actionable status
- *   (planning, paused). Lower-ranked deliveries past this point are gated.
- * - Skip past non-blocking non-actionable statuses (done, cancelled, verify)
- *   without breaking the walk.
- *
- * Returns:
- * - 'planning' when the focus has zero deliveries (agent will scope them).
- * - 'execute' with the collected actionable deliveries.
- * - 'skip' when the walk found zero actionable deliveries.
- *
- * Why verify_failed must be in the spawn set: the auto-review loop
- * routes a delivery from `verify` -> `verify_failed` when the review
- * agent finds remediation work, clears `review_requested_at`, and emits a
- * `review_completed` loop trigger. The next poll re-derives phase from
- * `ACTIVE_STATUSES` (which includes verify_failed), so the focus is
- * eligible to spawn. If this guard then skips past `verify_failed`, no
- * team ever picks up the remediation issues and the loop dies after the
- * first pass. See delivery ac5c69f7.
- */
-export declare function findActionableDeliveries(deliveries: Awaited<ReturnType<typeof getFocusDeliveries>>, focusName: string): SpawnDecision;
 /**
  * Generate branch name for focus-level work.
  */
 export declare function generateFocusBranchName(role: AgentRole, focusName: string, focusId: string): string;
-/**
- * Resolve the isolated CODEX_HOME to set on a spawn, or undefined when none
- * applies. Pure + testable: only a codex-engine spawn against a product that
- * carries a provisioned codexHome gets the override; every other case (claude
- * engine, or a cloud product with no codexHome) returns undefined so the spawn
- * environment is byte-for-byte unchanged.
- */
-export declare function codexHomeForSpawn(engineId: string, config: {
-    codexHome?: string;
-}): string | undefined;
-/**
- * Select the per-pass local model ref to resolve for this spawn, or null.
- *
- * Pure + testable. A ref applies ONLY to a codex-engine spawn. The ref resolves
- * under the unified Focus > Workflow > Default precedence (single-sourced in
- * model-resolution.resolveLocalModelRefPrecedence): the focus's per-pass
- * localModelOverride entry wins; absent that, the stage directive's localModel
- * is inherited; absent both, null (the pass runs on the engine's default model).
- * A claude engine or a blank ref returns null so the spawn keeps its
- * per-product / engine-default behavior unchanged.
- */
-export declare function selectLocalModelRef(engineId: string, pass: EnginePass, localModelOverride: Record<string, string | null> | null | undefined, stageDirectiveLocalModel?: string | null): string | null;
-/**
- * Decide what a codex spawn should do with a selected local-model ref, given the
- * resolved coordinates and the Telora-resolved bearer key VALUE. Pure + testable:
- * it holds NO I/O (the DB calls that produce `coords` and `apiKey`, and the
- * CODEX_HOME write / session update, happen in the caller). It only renders the
- * routing DECISION:
- *
- *   - ref null                       -> { kind: 'none' }      (no local model selected)
- *   - ref set but coords null        -> { kind: 'fallback' }  (ref not in registry)
- *   - coords present                 -> { kind: 'route' }      (key optional)
- *
- * Reached only when a ref exists upstream (codex-only is already enforced by
- * `selectLocalModelRef`); `coords` is `getLocalModel(ref)`'s result and `apiKey`
- * is `getLocalModelSecret(ref)`'s result (D8: the key lives in Telora, not host env).
- */
-export type LocalModelRouting = {
-    kind: 'none';
-} | {
-    kind: 'fallback';
-} | {
-    kind: 'route';
-    coords: LocalModelCoordinates;
-    apiKey: string | null;
-};
-export declare function decideLocalModelRouting(ref: string | null, coords: LocalModelCoordinates | null, apiKey: string | null): LocalModelRouting;
-/**
- * Pure gate: should the daemon perform a host-control model swap before this
- * spawn? (Local model host control, D2.) True ONLY when routing resolved a local
- * model for this pass AND the host advertises the optional control capability.
- * A non-controllable host (today's behavior: the operator pre-loads the model in
- * the studio) yields false -> NO swap, spawn proceeds unchanged. A pass with no
- * routed local model (claude, no override) also yields false. Exported so the
- * load-or-skip decision is unit-testable with NO HTTP.
- */
-export declare function shouldSwapForPass(input: {
-    routing: LocalModelRouting;
-    capability: HostCapability;
-}): boolean;
-/**
- * Resolve the effective model id for a spawn, applying the single team-model
- * precedence (focus override -> stage directive -> CLI default) via
- * resolveTeamModel. This is the SAME helper used at stage respawn, so the two
- * paths can never diverge on ordering.
- *
- * The focus-override slot folds in the selected local-Codex model: when this
- * pass routes to a controllable Codex home, `codexModel` IS the focus's
- * explicit pick and must win exactly like a focus pipeline_config.model would.
- * `directiveModel` has already been filtered through
- * selectDirectiveModelForSpawn() (nulled when the backend cannot run it, or
- * when a focus override is present), so it only ever reaches here as a
- * legitimate stage fallback.
- *
- * Pure + testable. Used by spawnFocusTeam to produce effectivePipelineConfig.model.
- */
-export declare function resolveEffectiveModel(directiveModel: string | null | undefined, spawnCodexHome: string | undefined, codexModel: string | undefined, pipelineModel: string | null | undefined): string | null;
-export declare function isClaudeModelId(model: string | null | undefined): boolean;
-/**
- * Select the pipeline model fallback to feed into resolveEffectiveModel().
- *
- * Hosted Codex runs through the user's Codex account. Some registry labels
- * exposed in the UI (for example gpt-5-codex) are not valid `codex exec
- * --model` values for every account, and passing them fails the run before the
- * agent starts. Local-model Codex still needs an explicit model, and Claude
- * keeps the existing pipeline model behavior.
- *
- * Engine-compat (the per-pass bleed guard): product_focuses.pipeline_config.model
- * is a SINGLE focus-wide value shared across passes, but each pass resolves its
- * own engine. A pass whose engine resolved to claude can only run a claude-family
- * model -- so a coding-pass codex model (e.g. gpt-5-codex) selected on the focus
- * must NOT bleed into a claude review pass. When it would, null it so the claude
- * backend picks its own default rather than receiving `--model gpt-5-codex` and
- * erroring out. (The symmetric codex case is handled above + by spawnCodexModel
- * routing; local-codex models reach the spawn via spawnCodexModel, not here.)
- */
-export declare function selectPipelineModelForSpawn(engineId: string, spawnCodexHome: string | undefined, pipelineModel: string | null | undefined): string | null;
-/**
- * Select whether a workflow directive's model may reach the backend.
- *
- * The focus pass selection is the source of truth for team launches. Stage
- * directives contribute prompt/context; their model field is only a legacy
- * fallback when the focus/pass has no selected model and the backend can run
- * that model. In particular, never pass a Claude directive model to Codex.
- */
-export declare function selectDirectiveModelForSpawn(engineId: string, directiveModel: string | null | undefined, focusSelectedModel: string | null | undefined): string | null;
-/**
- * Build CLI args for the team lead via the selected backend.
- *
- * Engine-specific flag construction lives in the backend; resume uses the
- * backend's dedicated resume-arg builder. Exported for the spawner barrel
- * surface (legacy ./team-spawner.js consumers).
- */
-export declare function buildAgentArgs(backend: AgentBackend, config: DaemonConfig, worktreePath: string, pipelineConfig: PipelineConfig | null, resumeSessionId?: string | null, allowedTools?: readonly string[], readOnly?: boolean): string[];
-export interface SpawnFocusTeamParams {
-    config: DaemonConfig;
-    focusId: string;
-    focusName: string;
-    role: AgentRole;
-    pipelineConfig: PipelineConfig | null;
-    readOnly?: boolean;
-    /** Previous Claude Code session ID for --resume support (legacy single slot). */
-    lastClaudeSessionId?: string | null;
-    /**
-     * Per-lineage session-id map from the focus (INJ-A). The spawn resolves its
-     * resume id from the slot matching the lineage being spawned, so a coding
-     * spawn never reads a slot a review spawn wrote.
-     */
-    claudeSessionIds?: Record<string, string> | null;
-    /**
-     * Per-focus engine override (per-pass map {coding, review}); null/absent =
-     * inherit the org default. Fed into resolveBackend() (D3).
-     */
-    engineOverride?: EngineOverride | null;
-    /**
-     * Per-focus selected local model (per-pass map {coding?, review?} of
-     * local_models ids); null/absent = no specific local model selected. When the
-     * resolved engine for a pass is codex and this carries a ref for that pass,
-     * the daemon resolves the ref to coordinates and routes the spawn to that
-     * model's endpoint (D3).
-     */
-    localModelOverride?: Record<string, string | null> | null;
-    /** Org-level default engine id; null/absent = the global default ('claude'). */
-    orgDefaultEngine?: string | null;
-    /**
-     * Force a spawn even when findActionableDeliveries would return 'skip' (all
-     * deliveries verify/done). Set for the escalation answer re-arm path: the
-     * spawn's purpose is to consume a pending answer (delivered by the
-     * escalation.answers resolver in the standard recipe), not to advance a
-     * delivery -- so an idle/exited focus must still spawn. Mirrors the
-     * pending-spawn-directive bypass, which likewise spawns past a 'skip'.
-     */
-    forceSpawn?: boolean;
-}
-/**
- * Phase 1 contract: everything the spawn needs that comes from the DB / assembly
- * layer, fetched up front. `assemblyManifest` is the live accumulator the later
- * phases keep appending to (directive assembly, etc.) before it is persisted.
- */
-export interface SpawnContext {
-    deliveries: Awaited<ReturnType<typeof getFocusDeliveries>>;
-    issues: Awaited<ReturnType<typeof getFocusIssues>>;
-    productContextDocs: Awaited<ReturnType<typeof getProductContextForFocus>>;
-    deploymentProfileSnapshot: Awaited<ReturnType<typeof getProductDeploymentProfileSnapshot>> | null;
-    loopContext: string;
-    prdMilestoneContext: string;
-    assemblyManifest: AssemblyManifestEntry[];
-}
-/**
- * Phase 1: fetch all spawn context (deliveries / issues / product-context /
- * deployment-profile / loop-context) in one Promise.all, then resolve the PRD
- * milestone push-down. Returns null when the context fetch rejects -- the
- * caller treats null as "tear down the freshly-inserted team and return"
- * (activeTeams.delete). The PRD push-down deliberately propagates on throw,
- * matching the pre-extraction behavior (it sits after the try/catch).
- *
- * Behavior-preserving extraction of the original inline block; the log lines,
- * the deployment-profile .catch fallback, the loop-context try/catch fallback,
- * and the manifest accumulation order are byte-identical.
- */
-export declare function fetchSpawnContext(config: DaemonConfig, focusId: string, focusName: string): Promise<SpawnContext | null>;
-/**
- * Phase 2 contract: the actionable-delivery decision. 'skip' tells the caller to
- * tear down (activeTeams.delete + return); 'proceed' carries the consumed
- * pending directive (used downstream in Phase A + spawn-phase tagging), the
- * collected actionable deliveries, and the planning-spawn flag.
- */
-export type ActionableResolution = {
-    kind: 'skip';
-} | {
-    kind: 'proceed';
-    pendingDirective: ReturnType<typeof consumePendingSpawnDirective>;
-    actionableDeliveries: Awaited<ReturnType<typeof getFocusDeliveries>>;
-    isPlanningSpawn: boolean;
-};
-/**
- * Phase 2: consume any pending spawn directive, enforce the rank-ordered
- * pre-spawn guard, and record known-delivery bookkeeping on the team state.
- *
- * Mutates `teamState` exactly as the original inline block did
- * (lastConsumedDirectiveHash, sessionType, planningPhase, knownDeliveryIds,
- * deliveryStageIds, mergedDeliveryIds) and emits the same log lines. Returns
- * 'skip' for the findActionableDeliveries skip case (the caller owns the
- * activeTeams.delete + return so the team-state map stays the orchestrator's
- * responsibility). Behavior byte-identical.
- */
-export declare function resolveActionableDeliveries(args: {
-    focusId: string;
-    focusName: string;
-    deliveries: Awaited<ReturnType<typeof getFocusDeliveries>>;
-    issues: Awaited<ReturnType<typeof getFocusIssues>>;
-    forceSpawn: boolean;
-    teamState: FocusTeamState;
-}): ActionableResolution;
-/**
- * Phase A contract: the resolved directive body + the spawn metadata derived
- * with it, BEFORE the prompt is built. Covers all three paths -- pending
- * directive, current-stage directive, legacy fallback -- in one typed result.
- */
-export interface DirectiveResolution {
-    /** Directive content appended after the role framework; null => legacy prompt. */
-    directiveBody: string | null;
-    /** Directive-declared model (legacy fallback only; filtered downstream). */
-    directiveModel: string | null;
-    /**
-     * Workflow stage directive engine + local-model for this spawn (the Workflow
-     * layer of Focus > Workflow > Default on those two axes), or null. Threaded
-     * into resolveEngineForPass (engine) and resolveSpawnModel (local model) so all
-     * three axes inherit the stage directive when the focus does not override.
-     */
-    directiveEngine: string | null;
-    directiveLocalModel: string | null;
-    /**
-     * Focus model override captured when a pending spawn directive (respawn) was
-     * stored, or null. Threaded into resolveSpawnModel so respawn resolves the
-     * team model under the SAME precedence as initial spawn (focus override ->
-     * stage -> CLI). Null when this spawn did not come from a pending directive
-     * (initial spawn / stage-directive path), where the live pipeline_config.model
-     * already carries the override.
-     */
-    pendingFocusOverrideModel: string | null;
-    /** Workflow stage active at spawn -- stamped as the .stage telemetry lever. */
-    spawnStageName: string | null;
-    /** Lineage + continuity declared by whatever fired this spawn (resolved later). */
-    spawnDirectiveDeclared: {
-        lineage?: string | null;
-        continuity?: SessionContinuity | null;
-    } | null;
-    /** True => no usable directive; build the legacy full focus prompt. */
-    useLegacyFullPrompt: boolean;
-}
-/**
- * Phase A: resolve the team-lead directive body + spawn metadata (no prompt
- * yet). Priority: pending spawn directive > current-stage directive > legacy
- * full prompt. Pushes any assembled directive manifest entries onto the shared
- * `assemblyManifest` accumulator.
- *
- * Behavior-preserving extraction of the original inline Phase A block -- the
- * "Using pending spawn directive" / "Using stage directive" log lines, the
- * "LEGACY PROMPT FALLBACK" warning and every fallbackReason string, and the
- * directive-manifest accumulation are byte-identical.
- */
-export declare function resolveDirectiveOrFallback(args: {
-    config: DaemonConfig;
-    focusId: string;
-    focusName: string;
-    worktreePath: string;
-    pendingDirective: ReturnType<typeof consumePendingSpawnDirective>;
-    assemblyManifest: AssemblyManifestEntry[];
-}): Promise<DirectiveResolution>;
-/**
- * Phase C input: assemble the FocusTeamPromptContext threaded into both the
- * directive and legacy prompt builders. Pure factory -- byte-identical to the
- * original inline object literal; extracted so the orchestrator reads as ordered
- * phase calls rather than inlining the context shape.
- */
-export declare function buildFocusPromptContext(args: {
-    config: DaemonConfig;
-    focusId: string;
-    focusName: string;
-    focusDescription: string | null;
-    deliveries: Awaited<ReturnType<typeof getFocusDeliveries>>;
-    issues: Awaited<ReturnType<typeof getFocusIssues>>;
-    executionConfig: FocusTeamState['executionConfig'];
-    pipelineConfig: PipelineConfig | null;
-    productContextDocs: SpawnContext['productContextDocs'];
-    deploymentProfileSnapshot: SpawnContext['deploymentProfileSnapshot'];
-    readOnly: boolean;
-    loopContext: string;
-    reviewFiledOpenCount: number;
-    engineId: string;
-}): FocusTeamPromptContext;
-/**
- * Phase C: compose the final team-lead message -- role framework + remediation
- * framing + directive body (or the legacy full focus prompt), then the PRD
- * milestone push-down appended last so it reaches BOTH prompt paths. Pure +
- * testable. Byte-identical to the original inline composition.
- */
-export declare function buildSpawnPrompt(args: {
-    role: AgentRole;
-    promptContext: FocusTeamPromptContext;
-    useLegacyFullPrompt: boolean;
-    directiveBody: string | null;
-    prdMilestoneContext: string;
-    /**
-     * True when this spawn is a review-lineage pass (reviewing stage). The
-     * outcome-stamping obligation is appended ONLY for review passes -- a coding
-     * team has nothing to stamp.
-     */
-    isReviewPass?: boolean;
-    /**
-     * The review session's Telora agent_sessions.id (from createTeamSession).
-     * Threaded into the outcome-stamping section so the review agent receives the
-     * exact id product-api validates against -- no reverse-engineering it from the
-     * Claude --resume session id. Only emitted on review passes; ignored otherwise.
-     */
-    agentSessionId?: string;
-}): string;
-/**
- * Outcome of per-pass local-model resolution. The caller applies it:
- *   - none     -> keep the per-product codexHome/codexModel defaults.
- *   - fallback -> ref not in the registry; warn and keep the defaults.
- *   - route    -> provision the per-model CODEX_HOME and route the spawn there,
- *                 optionally injecting the Telora-resolved key.
- */
-export type LocalModelConfig = {
-    kind: 'none';
-} | {
-    kind: 'fallback';
-    ref: string | null;
-} | {
-    kind: 'route';
-    codexHome: string;
-    codexModel: string;
-    apiKey: string | null;
-    coords: LocalModelCoordinates;
-};
-/**
- * The I/O seams resolveLocalModelConfig depends on. Injectable so the route/
- * fallback/none outcomes are unit-testable without the daemon-core
- * module-mock constraint (default to the real implementations in production).
- */
-export interface LocalModelConfigDeps {
-    getLocalModel: typeof getLocalModel;
-    getLocalModelSecret: typeof getLocalModelSecret;
-    writeLocalModelCodexHome: typeof writeLocalModelCodexHome;
-}
-/**
- * Phase: resolve the per-pass local-model routing for a codex spawn.
- *
- * Wraps the fetch (getLocalModel / getLocalModelSecret) + the pure decision
- * (selectLocalModelRef -> decideLocalModelRouting) and, on 'route', provisions
- * the per-model CODEX_HOME (writeLocalModelCodexHome) -- returning the codexHome
- * the caller points the spawn at. The key VALUE comes from Telora (D8), never a
- * host env var. Behavior byte-identical to the original inline block; only the
- * apply-side (session-terminal write on skip, env injection on route) stays in
- * the caller.
- */
-export declare function resolveLocalModelConfig(args: {
-    engineId: string;
-    enginePass: EnginePass;
-    localModelOverride: Record<string, string | null> | null | undefined;
-    /** Stage directive local-model: the Workflow layer inherited when the focus
-     *  does not override this pass. Optional/absent = the stage pins none. */
-    stageDirectiveLocalModel?: string | null;
-}, deps?: Partial<LocalModelConfigDeps>): Promise<LocalModelConfig>;
-/** Injectable I/O seams for surfaceSingleHostModelConflict (test without DB). */
-export interface HostConflictSurfaceDeps {
-    getLocalModel: typeof getLocalModel;
-    createEscalation: typeof createEscalation;
-}
-/**
- * Surface (do NOT silently swap) two DIFFERENT local models bound to the coding
- * vs review pass of one focus that share a single GPU host (#9). On a single
- * card the two bindings force an evict+load swap on every pass alternation and
- * fight over the GPU (the live incident: 0/56 routing attempts succeeded). The
- * daemon must make the conflict VISIBLE rather than thrash silently.
- *
- * Cheap early-out: only when the focus pins a local model for BOTH passes and
- * the two refs differ do we resolve coordinates (two getLocalModel reads) and run
- * the pure detector. A conflict (same host root, different served models) is
- * raised ONCE per focus per daemon run (shouldSurfaceHostConflictOnce) as a log
- * line + a single escalation -- never re-raised every poll. Returns whether a new
- * surfacing was raised this call. Best-effort: an escalation-create failure is
- * logged, never fatal to the spawn.
- */
-export declare function surfaceSingleHostModelConflict(args: {
-    focusId: string;
-    focusName: string;
-    organizationId: string;
-    productId: string | undefined;
-    localModelOverride: Record<string, string | null> | null | undefined;
-}, deps?: Partial<HostConflictSurfaceDeps>): Promise<{
-    surfaced: boolean;
-}>;
-/**
- * The terminal session-update payload written when the resource governor denies a
- * slot for this spawn. Pure -- the caller adds `ended_at` and calls updateSession.
- * Exported so the governor-denied exit_category contract is unit-pinned (the
- * apply-side -- updateSession + governor.releaseSlot + activeTeams.delete -- stays
- * in spawnTeamProcess, exercised by spawn-path-unified.test.ts).
- */
-export declare function governorDeniedSessionUpdate(): {
-    status: string;
-    exit_reason: string;
-    exit_category: string;
-};
-/**
- * The terminal session-update payload written when a required OS sandbox cannot
- * initialize and the spawn is refused (fail-closed). Pure -- the caller adds
- * `ended_at` and calls updateSession. Exported so the sandbox-unavailable
- * exit_category contract is unit-pinned.
- */
-export declare function sandboxUnavailableSessionUpdate(message: string): {
-    status: string;
-    exit_reason: string;
-    exit_category: string;
-};
 /**
  * Log the spawn header (focus / role / model / workers / branch, plus the
  * product line in multi-product mode). Side-effect-only; byte-identical to the
@@ -557,302 +72,6 @@ export declare function logSpawnHeader(args: {
     branchName: string;
     readOnly: boolean;
 }): void;
-/**
- * Build the initial FocusTeamState for a spawn. Pure factory -- no side effects;
- * the caller inserts it into the activeTeams map.
- */
-export declare function createInitialTeamState(args: {
-    focusId: string;
-    focusName: string;
-    role: AgentRole;
-    config: DaemonConfig;
-    executionConfig: FocusTeamState['executionConfig'];
-    pipelineConfig: PipelineConfig | null;
-    branchName: string;
-    readOnly: boolean;
-}): FocusTeamState;
-/**
- * Phase: resolve the focus worktree to spawn into. Reuses the persistent
- * worktree (rebasing onto integration + re-asserting read-only guards) when one
- * exists, else creates one inline. Returns null when the spawn cannot proceed
- * (repo has no commits, or inline creation failed) -- owning its own teardown
- * (activeTeams.delete + recordFocusTeardown) so the caller just returns.
- * Behavior byte-identical to the original inline block.
- */
-export declare function resolveSpawnWorktree(args: {
-    config: DaemonConfig;
-    focusId: string;
-    focusName: string;
-    branchName: string;
-    readOnly: boolean;
-}): Promise<string | null>;
-/**
- * Phase: create the team-lead session row + register it with the telemetry
- * persistence gate, stamping its id onto the team state. Returns null when
- * createSession fails (owning its own activeTeams.delete teardown). The worktree
- * is focus-owned and persists even when session creation fails.
- *
- * `sessionType` is the AUTHORITATIVE lineage (resolved by resolveEngineForPass,
- * matching teamState.sessionType), so the (focus, lineage) pass this segment is
- * opened against is on the SAME lineage the segment carries -- never a stale
- * 'coding' default while the lineage actually resolved to 'review'.
- */
-export declare function createTeamSession(args: {
-    config: DaemonConfig;
-    role: AgentRole;
-    focusId: string;
-    focusName: string;
-    branchName: string;
-    sessionType: SessionType;
-    teamState: FocusTeamState;
-}): Promise<Awaited<ReturnType<typeof createSession>> | null>;
-/**
- * Phase: best-effort review context. When the focus has a recorded
- * review_requested_at, count the open review-filed issues (the remediation
- * directive's working set) and carry the prior findings; also resolve the focus
- * description. A fetch failure leaves the count at zero (normal execution team).
- */
-export declare function resolveReviewContext(args: {
-    config: DaemonConfig;
-    focusId: string;
-    focusName: string;
-    issues: Awaited<ReturnType<typeof getFocusIssues>>;
-}): Promise<{
-    reviewFiledOpenCount: number;
-    priorFindings: Awaited<ReturnType<typeof getFocusIssues>>;
-    focusDescription: string | null;
-}>;
-/**
- * Phase B: resolve the session lineage (pass) and the engine backend for it,
- * stamping lineage + sessionType onto the team state. Returns the lineage spec,
- * the derived engine pass, the resolved engine, and the backend object.
- */
-export declare function resolveEngineForPass(args: {
-    spawnDirectiveDeclared: DirectiveResolution['spawnDirectiveDeclared'];
-    spawnStageName: string | null;
-    engineOverride: EngineOverride | null | undefined;
-    /** Stage directive engine (Workflow layer of the unified engine precedence). */
-    stageDirectiveEngine?: string | null;
-    config: DaemonConfig;
-    orgDefaultEngine: string | null | undefined;
-    focusName: string;
-    teamState: FocusTeamState;
-}): {
-    spawnSpec: ReturnType<typeof resolveLineageSpec>;
-    enginePass: EnginePass;
-    resolvedEngine: ReturnType<typeof resolveBackend>;
-    backend: AgentBackend;
-};
-/**
- * Outcome of resolveSpawnModel:
- *   - 'skip_load' -- a controllable-host model swap (load/unload) FAILED this
- *                    tick; do NOT spawn against a not-yet-loaded model. The caller
- *                    logs an actionable message + skips the spawn so the 30s poll
- *                    re-attempts. Conservative: no terminal session, no escalation.
- *   - 'still_loading' -- the per-host swap is in flight OFF the poll loop (#3),
- *                    or the host is held by another focus's running pass (#4).
- *                    Defer THIS focus's spawn only; retry next poll. The detached
- *                    load is NOT awaited, so the serial poll loop is not stalled.
- *   - 'ready'     -- a ready spawn carrying the CLI args + the env-affecting model bits.
- */
-export type SpawnModelResolution = {
-    kind: 'skip_load';
-    coords: LocalModelCoordinates;
-    dbMessage: string;
-} | {
-    kind: 'still_loading';
-    coords: LocalModelCoordinates;
-    reason: string;
-} | {
-    kind: 'ready';
-    args: string[];
-    effectiveModel: string | null;
-    spawnCodexHome: string | undefined;
-    spawnLocalModelKey: string | null;
-    isLocalModelPass: boolean;
-    /** Translating proxy started for an opt-in local-model pass (else null).
-     *  Carried out so the caller can attach it to the team state for
-     *  close-time teardown + reception read. */
-    mcpProxy?: CodexMcpProxyHandle | null;
-};
-/**
- * Phase: resolve the per-product CODEX_HOME default, apply per-pass local-model
- * routing (fallback / route), select the effective model, and build the CLI
- * args. Returns 'ready' with the args + the model/env bits the spawn needs.
- */
-export declare function resolveSpawnModel(args: {
-    resolvedEngine: ReturnType<typeof resolveBackend>;
-    enginePass: EnginePass;
-    localModelOverride: Record<string, string | null> | null | undefined;
-    /**
-     * Stage directive local-model (Workflow layer of the unified local-model
-     * precedence); inherited when the focus does not override this pass. Null when
-     * the stage pins no local model.
-     */
-    stageDirectiveLocalModel?: string | null;
-    config: DaemonConfig;
-    directiveModel: string | null;
-    /**
-     * Focus override snapshotted on a pending spawn directive (respawn path), or
-     * null. When present it takes precedence over the live pipeline_config.model
-     * for the focus-override slot, so respawn honors the override even if the
-     * focus row's pipeline_config was refetched differently between store and
-     * consume. Null on the initial-spawn / stage-directive path.
-     */
-    pendingFocusOverrideModel: string | null;
-    pipelineConfig: PipelineConfig | null;
-    backend: AgentBackend;
-    worktreePath: string;
-    resumeId: string | null;
-    role: AgentRole;
-    readOnly: boolean;
-    focusName: string;
-    focusId: string;
-}): Promise<SpawnModelResolution>;
-/**
- * Phase: choose the stdin message. A fresh spawn sends the full composed prompt;
- * a resume sends an incremental delta (git diff + prior findings to verify) since
- * the resumed session already holds its role + accumulated context (INJ-D).
- *
- * The scoping case is the one exception that overrides the fresh-vs-resume split:
- * when a NON-read_only (executable) focus has queued deliveries carrying only
- * Context Group issues and zero Task/Bug issues, this returns the role framework
- * PLUS `buildQueuedDeliveryScopingMessage` REGARDLESS of resumeId. The caller pairs
- * this with `resolveScopingSpawnResume`, which forces the spawn fresh (resumeId
- * null) so the directive lands on a new session instead of no-opping a concluded
- * one. Because the fresh session holds no accumulated context, the role framework
- * (identity + Scoping Mandate + status-update rules) is prepended here; only the
- * audit/kickoff DIRECTIVE body carried in `prompt` is dropped, per AC. `readOnlyFocus`
- * focuses are discovery-only (audit-playbook origin): their CG-only deliveries are
- * INTENTIONALLY unscoped, so they are never driven into scoping here --
- * delivery-lifecycle terminalizes them instead.
- */
-export declare function buildSpawnMessage(args: {
-    prompt: string;
-    resumeId: string | null;
-    readOnlyFocus: boolean;
-    /**
-     * The team-lead role + context, used to rebuild JUST the role-framework prefix
-     * (`buildRoleFrameworkPrompt`, WITHOUT the audit/kickoff directive body) for the
-     * forced-fresh scoping message. The scoping spawn lands on a NEW session with no
-     * accumulated context, and stdin is that session's only first-turn instruction
-     * (there is no --system-prompt channel and the worktree CLAUDE.md carries no role
-     * framework), so the scoping directive must carry the role framework itself or
-     * the fresh team lead has no identity / status-update contract / scoping mandate.
-     */
-    role: AgentRole;
-    promptContext: FocusTeamPromptContext;
-    spawnSpec: ReturnType<typeof resolveLineageSpec>;
-    config: DaemonConfig;
-    focusId: string;
-    focusName: string;
-    deliveries: Awaited<ReturnType<typeof getFocusDeliveries>>;
-    issues: Awaited<ReturnType<typeof getFocusIssues>>;
-    worktreePath: string;
-    priorFindings: Awaited<ReturnType<typeof getFocusIssues>>;
-}): Promise<string>;
-/**
- * Decide whether this spawn must be forced fresh to deliver a scoping directive,
- * and return the resume id the spawn should actually use.
- *
- * The wedge this closes: a queued delivery carrying only Context Group issues and
- * zero Task/Bug issues can never cross the queued->coding gate. The daemon
- * re-spawns the focus every poll, but the resume lands on a session that already
- * considers the audit "done" and no-ops in one turn. The fix is to force the
- * scoping spawn FRESH (resumeId null) so `buildQueuedDeliveryScopingMessage`
- * primes a new session as its first instruction rather than a resume-delta a
- * concluded session ignores.
- *
- * Only executable focuses are driven into scoping. A `readOnly` (discovery-only,
- * audit-playbook) focus's CG-only deliveries are intentionally unscoped, so this
- * never forces them fresh -- their resume id passes through unchanged and the
- * delivery reaches a terminal state via the reconciler's discovery-only path.
- *
- * Pure and exported so the fresh-spawn contract is unit-testable without a live
- * spawn.
- */
-export declare function resolveScopingSpawnResume(args: {
-    readOnly: boolean;
-    deliveries: Awaited<ReturnType<typeof getFocusDeliveries>>;
-    issues: Awaited<ReturnType<typeof getFocusIssues>>;
-    resumeId: string | null;
-}): {
-    resumeId: string | null;
-    isScopingSpawn: boolean;
-};
-export declare function findQueuedDeliveriesWithoutTaskIssues(deliveries: Awaited<ReturnType<typeof getFocusDeliveries>>, issues: Awaited<ReturnType<typeof getFocusIssues>>): Awaited<ReturnType<typeof getFocusDeliveries>>;
-export declare function buildQueuedDeliveryScopingMessage(args: {
-    lineage: string;
-    focusName: string;
-    deliveries: Awaited<ReturnType<typeof getFocusDeliveries>>;
-}): string;
-/**
- * Inputs to spawnTeamProcess -- the final phase that takes a fully-resolved
- * spawn (env constituents, args, message, session, backend) and actually
- * launches the team-lead child process.
- */
-export interface SpawnTeamProcessArgs {
-    config: DaemonConfig;
-    focusId: string;
-    focusName: string;
-    session: Awaited<ReturnType<typeof createSession>>;
-    teamState: FocusTeamState;
-    backend: AgentBackend;
-    args: string[];
-    /** Composed prompt on a fresh spawn, or the resume-delta when resuming. */
-    messageToSend: string;
-    logs: ReturnType<typeof setupTeamLogStreams>;
-    worktreePath: string;
-    resumeId: string | null;
-    assemblyManifest: AssemblyManifestEntry[];
-    spawnCodexHome: string | undefined;
-    spawnLocalModelKey: string | null;
-    isLocalModelPass: boolean;
-    effectiveModel: string | null;
-    pendingDirective: ReturnType<typeof consumePendingSpawnDirective>;
-    spawnStageName: string | null;
-    params: SpawnFocusTeamParams;
-}
-export interface BackendSpawnGateResult {
-    allowed: boolean;
-    reason?: string;
-}
-/**
- * Local-model passes depend on a host CLI, so refuse the process launch when
- * the backend's existing availability probe says it cannot run. Cloud passes
- * retain their existing behavior because their authentication can be supplied
- * by the per-spawn environment after the host-level probe runs.
- */
-export declare function gateLocalModelBackendSpawn(backend: AgentBackend, config: DaemonConfig, isLocalModelPass: boolean, host?: string): Promise<BackendSpawnGateResult>;
-export declare function backendUnavailableSessionUpdate(reason: string, category?: string): {
-    status: string;
-    exit_reason: string;
-    exit_category: string;
-};
-/** Attach the error listener in the same synchronous stack frame as spawn(). */
-export declare function spawnCrashIsolated(command: string, args: readonly string[], options: SpawnOptionsWithoutStdio, onError: (error: Error) => void, spawnFn?: typeof spawn): ChildProcessWithoutNullStreams;
-/** Ensure a terminal spawn failure is persisted after any in-flight running transition. */
-export declare function persistSpawnFailureAfterRunning(runningTransition: Promise<unknown> | null, persistFailure: () => Promise<unknown>): Promise<void>;
-/**
- * Final phase: build the levered spawn environment, persist the assembly
- * manifest, write the session lifecycle (starting -> running), acquire the
- * governor slot, wrap the command in the sandbox (fail-closed), spawn the
- * child, write its stdin, and attach the completion/close/error handlers.
- *
- * Owns ALL of its early-return cleanups so the team-state map and governor slot
- * never leak: governor-denied (exit_category 'governor_denied') and
- * sandbox-unavailable (exit_category 'sandbox_unavailable') both mark the
- * session terminal, release the governor slot where one was held, remove the
- * team from activeTeams, and return without spawning. Behavior byte-identical
- * to the original inline tail of spawnFocusTeam.
- */
-/**
- * Close a team's local-model translating proxy if one is engaged, and null it so
- * the call is idempotent across the multiple teardown paths. No-op for every
- * hosted/Claude/flag-off team (mcpProxy undefined/null).
- */
-export declare function closeTeamProxyQuietly(teamState: FocusTeamState): void;
-export declare function spawnTeamProcess(spec: SpawnTeamProcessArgs): Promise<void>;
 /**
  * Spawn a focus team to execute all deliveries in a focus.
  *