@telora/daemon 0.22.239 → 0.22.289

package/dist/focus/listener-spawn.js

@@ -1,667 +0,0 @@
-// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
-// Pinned by: 22 tests -- run: npm run gen:pinned-by -- --list packages/daemon/src/focus/listener-spawn.ts
-// PINNED-BY-END
-import { resolveReadyFocusSpawnAction } from './ready-focus-spawn-action.js';
-import { config, roles, pollState, idleLoggedFocuses, nullRoleSkipWarnedFocuses, lastRolesRefreshAt, healthCheckConsecutiveFailures, POLL_INTERVAL_MS, ROLES_REFRESH_INTERVAL_MS, setPollState, setLastRolesRefreshAt, setLastReadyFocusCount, } from './listener-state.js';
-import { getAgentRoles } from '../queries/roles.js';
-import { hasActiveTeam, getActiveTeamCount, getActiveTeams } from './focus-executor.js';
-import { focusHasTeamActionableWork, resolveFocusVerifyHoldFacts } from './team-actionable-work.js';
-import { applyRespawnGuard } from './focus-respawn-guard.js';
-import { createReadyFocusCapHoldReader, resolveReviewCycleCapHold } from './review-cycle-cap-hold.js';
-import { recordActivity } from '../shell/heartbeat.js';
-import { configForProduct, findProduct } from '../shell/config.js';
-import { isDaemonShuttingDown } from '../shell/shutdown-state.js';
-import { getPendingSpawnFocusIds, getPendingSpawnDirective, clearPendingSpawnDirective, shouldReapPendingSpawnDirective } from '../directive/directive-executor.js';
-import { focusMayRunTeam, decideNullRoleSpawn, shouldWarnNullRoleSkip } from '../spawn/null-role-spawn.js';
-import { clearAnswerRearm } from '../queries/focus-discovery.js';
-import { PENDING_SPAWN_PASS_DEPS, READY_FOCUS_PASS_DEPS } from './pending-spawn-pass-deps.js';
-import { setAwaitingSlotFocuses } from './awaiting-slot.js';
-import { isAuditPhaseFocusRow } from '../audit/audit-shape.js';
-import { isIntakeDraining } from '../shell/intake-control.js';
-import { isRespawnCycleTerminated } from '../spawn/spawn-cooldown.js';
-import { recordPendingSpawnAttempt, isNextSpawnInCooldown } from '../spawn/index.js';
-import { fileRespawnCycleExhaustedEscalation } from '../spawn/respawn-cycle-escalation.js';
-import { gateReviewSpawnOnOperatorHold } from '../spawn/review-hold-park.js';
-import { pendingCodingSpawnSupersededByReview } from './pending-spawn-review-next-step.js';
-import { gatePendingReviewAtApprovedHead } from './pending-review-approved-head.js';
-import { startEscalationSpoolDrain } from '../queries/escalation-spool.js';
-import { recordFiring, classifyLatestUnclassifiedFiring, isMechanismDemoted, markLatestFiringUnacted, SUPERVISION_MECHANISM } from '../completion/supervision-firing-record.js';
-import { createLogger } from '../shell/log.js';
-const log = createLogger({ module: 'listener' });
-/**
- * The spawn-gate skips the ready pass logs at debug and passes over, re-read live
- * each poll (no cooldown penalty; the focus stays in the ready count, so
- * telemetry is honest):
- *   - skip_no_work: surfaced by status, but no open work issue and nothing to
- *     scope (a finished delivery waits on the daemon's advance, not on a team).
- *   - skip_held: held by an in-flight verify (a team would find nothing to commit
- *     and terminate); spawnable the cycle after the hold clears (AC5). debug so a
- *     multi-minute verify does not spin-log at info.
- */
-const QUIET_SKIP_LOG = {
-    skip_no_work: 'has no open team work; not spawning',
-    skip_held: 'held by an in-flight verify; deferring spawn',
-};
-/**
- * Refresh the in-memory agent-role cache when it is older than the refresh
- * interval, so mid-run role changes are picked up. Best-effort: a fetch failure
- * is logged and leaves the prior cache in place. Extracted from
- * processReadyFocuses to keep that function under the size ratchet.
- */
-async function refreshAgentRolesIfStale(organizationId) {
-    if (Date.now() - lastRolesRefreshAt <= ROLES_REFRESH_INTERVAL_MS)
-        return;
-    try {
-        const roleList = await getAgentRoles(organizationId);
-        roles.clear();
-        for (const role of roleList) {
-            roles.set(role.id, role);
-        }
-        setLastRolesRefreshAt(Date.now());
-        log.info(`Refreshed agent roles (${roles.size} roles loaded)`);
-    }
-    catch (err) {
-        log.warn(`Failed to refresh agent roles: ${err.message}`);
-    }
-}
-/**
- * Record the focuses a spawn pass left without a team ONLY because every session
- * slot is in use (focus/awaiting-slot.ts, published as awaiting_slot), replacing
- * that pass's previous record, and log them once for the pass. An empty list
- * clears the record: a pass that leaves nothing waiting publishes nothing.
- */
-function recordSlotBlockedFocuses(pass, focuses) {
-    setAwaitingSlotFocuses(pass, focuses.map((f) => f.focus_id));
-    if (focuses.length === 0 || !config)
-        return;
-    const what = pass === 'ready' ? 'ready focus(es)' : 'queued spawn directive(s)';
-    const names = focuses.map((f) => `"${f.focus_name}"`).join(', ');
-    log.info(`Total session limit reached (${getActiveTeamCount()}/${config.maxTotalSessions} in use) -- ` +
-        `${focuses.length} ${what} waiting for a slot: ${names}`);
-}
-/**
- * Process any focuses ready for agent work.
- *
- * For each ready focus without an active team, spawns a single
- * Agent Team that manages all deliveries within that focus.
- * Also detects focuses that have been deactivated and shuts down
- * their teams. Once every session slot is in use it starts no further team
- * but keeps classifying, so each focus it would otherwise have spawned is
- * recorded as waiting for a slot (recordSlotBlockedFocuses).
- */
-export async function processReadyFocuses(deps = READY_FOCUS_PASS_DEPS) {
-    if (!config)
-        return;
-    // Prevent concurrent processing, and skip cycles during health check backoff
-    if (pollState === 'processing' || pollState === 'backing_off') {
-        return;
-    }
-    setPollState('processing');
-    const awaitingSlot = [];
-    try {
-        // Periodically refresh agent roles to pick up changes.
-        await refreshAgentRolesIfStale(config.organizationId);
-        // Record activity: proves the poll ran even if no work was found
-        recordActivity();
-        // Snapshot active teams before processing (for idle detection)
-        const previouslyActiveIds = new Set(getActiveTeams().keys());
-        // (Deactivation detection runs earlier in the poll loop: checkForDeactivatedFocuses.)
-        const readCapHold = (deps.createCapHoldReader ?? createReadyFocusCapHoldReader)(config.organizationId); // one count read per product this poll
-        // Get ready focuses across all configured products
-        const readyFocuses = [];
-        for (const product of config.products) {
-            try {
-                const focuses = await deps.getReadyFocuses(config.organizationId, product.id);
-                readyFocuses.push(...focuses);
-            }
-            catch (err) {
-                log.warn(`Failed to fetch ready focuses for product ${product.id}: ${err.message}`);
-            }
-        }
-        // Publish the queue depth for the auto-updater's batch-safe idle predicate.
-        // Set before any early-return below so a drained queue is observable.
-        setLastReadyFocusCount(readyFocuses.length);
-        // Track which focuses are ready this cycle (idle logging + FP correlation).
-        const readyFocusIds = new Set(readyFocuses.map(s => s.focus_id));
-        // A focus ready again while an unclassified teardown firing stands -> that
-        // teardown was a false positive (the "no work" prediction was wrong). The
-        // returned set is the respawn-after-teardown group the demotion gate reads.
-        const respawnAfterTeardown = classifyReadyFalsifiedTeardowns(readyFocuses);
-        logNewlyIdleFocuses(previouslyActiveIds, readyFocusIds);
-        if (readyFocuses.length === 0) {
-            return;
-        }
-        // Intake drain (auto-update delivery C): a pending update has been stale
-        // past threshold while the daemon stays busy, so we stop accepting new focus
-        // teams to let the current batch become the safe seam. Active teams continue
-        // to completion; we simply do not spawn more. The held queue does not block
-        // the batch boundary because isBatchSafeIdle honors isIntakeDraining().
-        if (isIntakeDraining()) {
-            log.info(`[listener] Intake drained for pending update -- holding ${readyFocuses.length} ready focus(es); no new teams will spawn`);
-            return;
-        }
-        const productLabel = config.products.length > 1
-            ? ` across ${config.products.length} product(s)`
-            : '';
-        log.info(`Found ${readyFocuses.length} ready focuses${productLabel}`);
-        for (const focus of readyFocuses) {
-            const role = roles.get(focus.assigned_agent_role_id);
-            // Resolve the per-focus spawn-gate decision (pure; see decideFocusSpawn).
-            const action = await resolveReadyFocusSpawnAction(focus, role, deps, config, readCapHold);
-            if (action === 'skip_unknown_role') {
-                log.error(`Unknown agent role: ${focus.assigned_agent_role_id}`);
-                continue;
-            }
-            if (action === 'skip_no_work' || action === 'skip_held') {
-                log.debug(`Focus "${focus.focus_name}" ${QUIET_SKIP_LOG[action]}`);
-                continue;
-            }
-            if (action === 'skip_active_team') {
-                // Focus is active -- clear idle state so we re-log if it goes idle again
-                idleLoggedFocuses.delete(focus.focus_id);
-                // A re-arm flag may have landed while a team is up. Do NOT clear it here:
-                // the answer is consumed only at (re)spawn time via the escalation.answers
-                // resolver, and a still-live team does not re-run assembly mid-session
-                // (the wake-message handoff does not carry answers). Leaving the flag set
-                // lets the force-spawn deliver the answer once this team exits; clearing
-                // it now would strand the answer. The clear happens on the force-spawn
-                // below (one answer -> one re-spawn).
-                continue;
-            }
-            // Skip focuses recently torn down (spawn cooldown) or held at their review-cycle cap (the hold logs once).
-            if (action === 'skip_cooldown' || action === 'skip_cap_held') {
-                continue;
-            }
-            // Every slot is in use: start no further team, but keep classifying so each
-            // focus this pass would otherwise spawn is recorded as waiting for a slot.
-            if (action === 'stop_capacity') {
-                awaitingSlot.push(focus);
-                continue;
-            }
-            // action === 'spawn'. role is guaranteed defined (hasRole was true);
-            // this guard narrows the type and is otherwise unreachable.
-            if (!role)
-                continue;
-            // Block-to-observe: a demoted spawn-gate-vs-exit mechanism does not respawn
-            // a focus we just tore down (record-only; self-lifting).
-            if (respawnSuppressedByDemotion(focus, respawnAfterTeardown))
-                continue;
-            const isRearm = focus.answer_rearm_requested_at != null;
-            // Forced past the no-actionable-delivery skip because the PROMPT is the
-            // notice's carrier; self-limiting (see schemas.ts unclaimedMigrationNoticeOwed).
-            const owesUnclaimedNotice = focus.unclaimed_migration_notice_owed === true;
-            // Clear idle state before spawn attempt -- if spawn succeeds,
-            // the focus is active. If it skips (no actionable deliveries),
-            // spawnFocusTeam logs the skip and we mark it idle here.
-            const wasIdle = idleLoggedFocuses.has(focus.focus_id);
-            idleLoggedFocuses.delete(focus.focus_id);
-            // Use product-scoped config so the team uses the correct repoPath
-            const productEntry = focus.product_id ? findProduct(config, focus.product_id) : undefined;
-            const spawnConfig = productEntry ? configForProduct(config, productEntry) : config;
-            // Spawn a focus team (one team per focus). forceSpawn lets a re-armed
-            // focus spawn past findActionableDeliveries' 'skip' to consume the
-            // pending escalation answer.
-            // Audit-phase focus (explicit read_only=true OR the second structural
-            // signal: audit_origin && not-yet-ratified, TEL-3) spawns read-only, so a
-            // flag-absent audit focus is not driven into scoping/write/commit ahead of
-            // ratification (2f253da6). See isAuditPhaseFocusRow.
-            await spawnReadyFocusTeam(deps, focus, { config: spawnConfig, focusId: focus.focus_id, focusName: focus.focus_name, role, pipelineConfig: focus.pipeline_config, readOnly: isAuditPhaseFocusRow(focus), lastClaudeSessionId: focus.last_claude_session_id, claudeSessionIds: focus.claude_session_ids, engineOverride: focus.engine_override, localModelOverride: focus.local_model_override, orgDefaultEngine: focus.org_default_engine, orgDefaultCodingModel: focus.org_default_coding_model, orgDefaultReviewModel: focus.org_default_review_model, pinnedBranch: focus.branch_name, armedBaselineDeliveryIds: focus.armed_baseline_delivery_ids, forceSpawn: isRearm || owesUnclaimedNotice, requireCodingPass: owesUnclaimedNotice });
-            // Clear the re-arm flag only once a team is actually live to consume the
-            // answer: one answer -> one re-spawn. If the force-spawn did NOT produce an
-            // active team (worktree/governor failure, etc.), leave the flag set so a
-            // later poll retries delivery rather than stranding the answer. (Cooldown
-            // and capacity exit above without reaching here, so they also keep the
-            // flag.) Done before the idle check below so a consumed re-arm is not
-            // re-surfaced next poll.
-            if (isRearm && hasActiveTeam(focus.focus_id)) {
-                await clearAnswerRearm(focus.focus_id, focus.answer_rearm_requested_at).catch((err) => log.warn(`Failed to clear answer re-arm for "${focus.focus_name}": ${err.message}`));
-            }
-            // If the spawn was skipped (no active team after spawn), mark as idle
-            if (!hasActiveTeam(focus.focus_id) && !wasIdle) {
-                const nextPollSec = POLL_INTERVAL_MS / 1000;
-                log.info(`Focus queue idle: "${focus.focus_name}" -- no actionable deliveries after pre-spawn check, next poll in ${nextPollSec}s`);
-                idleLoggedFocuses.add(focus.focus_id);
-            }
-        }
-    }
-    catch (error) {
-        log.error('Error processing ready focuses:', error);
-    }
-    finally {
-        recordSlotBlockedFocuses('ready', awaitingSlot);
-        setPollState(healthCheckConsecutiveFailures > 0 ? 'backing_off' : 'idle');
-    }
-}
-/**
- * Dispose of a pending spawn directive whose focus is absent from the active
- * set: reap it, or keep retrying.
- *
- * If the active-set read was COMPLETE this tick (no product fetch failed), the
- * focus has genuinely left the active set and its directive is a zombie -- reap
- * it once instead of retrying forever. On a fetch-failure tick the absence is
- * untrustworthy (the focus may be missing only because its product's read
- * failed), so the directive is kept and retried next poll.
- */
-function reapOrRetryAbsentPendingFocus(focusId, anyFetchFailed) {
-    if (shouldReapPendingSpawnDirective({ anyFetchFailed, focusPresentInActiveSet: false })) {
-        clearPendingSpawnDirective(focusId);
-        // Focus left the active set -- the blocked episode is over. Clear its
-        // once-per-episode warn marker so a future re-entry warns again.
-        nullRoleSkipWarnedFocuses.delete(focusId);
-        log.info(`[listener] Dropping stale spawn directive for focus ${focusId.slice(0, 8)}: ` +
-            `confirmed absent from every product's active set (focus completed/deactivated).`);
-        return;
-    }
-    log.warn(`[listener] Pending spawn directive for focus ${focusId.slice(0, 8)} but focus not found in active set; ` +
-        `active-set read incomplete this tick (fetch failure) -- retrying next poll.`);
-}
-/**
- * Guard: a pending-spawn focus whose respawn cycle has exhausted its bounds is
- * halted permanently (spawn-cooldown). File the one-per-focus (idempotent)
- * respawn_cycle_exhausted escalation so the terminated cycle is a legible state,
- * and report whether the spawn must be skipped. Extracted from
- * processPendingSpawnFocuses to keep it within its size floor.
- */
-/**
- * Log focuses that were active last cycle but have no ready deliveries now (once,
- * on state change). Extracted from processReadyFocuses to keep it under its size
- * floor.
- */
-function logNewlyIdleFocuses(previouslyActiveIds, readyFocusIds) {
-    for (const focusId of previouslyActiveIds) {
-        if (!readyFocusIds.has(focusId) && !hasActiveTeam(focusId) && !idleLoggedFocuses.has(focusId)) {
-            const nextPollSec = POLL_INTERVAL_MS / 1000;
-            log.info(`Focus queue idle: "${focusId}" -- no actionable deliveries, next poll in ${nextPollSec}s`);
-            idleLoggedFocuses.add(focusId);
-        }
-    }
-}
-/**
- * Falsifiability correlation: a focus that is READY again (getReadyFocuses
- * surfaced it, so it has actionable work) while it still holds an unclassified
- * teardown-at-first-result firing classifies that teardown a FALSE POSITIVE -- its
- * "no team-actionable work" prediction was wrong. The settle sweep TPs any firing
- * that stood past the window, so a still-unclassified one is a QUICK re-ready (the
- * 2026-09-06 storm shape). A no-op for a focus with no such firing.
- */
-export function classifyReadyFalsifiedTeardowns(readyFocuses) {
-    const respawnAfterTeardown = new Set();
-    for (const focus of readyFocuses) {
-        const teardownFalsified = classifyLatestUnclassifiedFiring(SUPERVISION_MECHANISM.TEARDOWN_AT_FIRST_RESULT, focus.focus_id, { borneOut: false, observed: 'focus is ready again -- teardown missed actionable work' });
-        // An exited focus that is ready again IS a spawn-gate-vs-exit respawn: record
-        // it predicting the respawn does work rather than immediately re-exiting. A
-        // re-teardown shortly after (event-phases) classifies this respawn a false
-        // positive (a wasted respawn -- the storm); the settle sweep TPs the rest.
-        // These focuses are the respawn-after-teardown set the demotion gate reads.
-        if (teardownFalsified) {
-            recordFiring({
-                mechanism: SUPERVISION_MECHANISM.SPAWN_GATE_VS_EXIT_RESPAWN,
-                focusId: focus.focus_id,
-                predicted: 'respawn of an exited focus will do work, not immediately re-exit',
-            });
-            respawnAfterTeardown.add(focus.focus_id);
-        }
-    }
-    return respawnAfterTeardown;
-}
-/**
- * Block-to-observe enforcement for the spawn-gate-vs-exit respawn mechanism: when
- * it is DEMOTED (zero true positives over the window) a respawn of a focus we just
- * tore down is suppressed -- recorded, not acted on -- breaking the storm at the
- * spawn side (AC/FRT #10). A no-op unless this focus is in the just-falsified-
- * teardown set AND the mechanism is demoted. The suppressed respawn's firing is
- * marked UNACTED so it is never swept to TP by silence; the demotion lifts only
- * when its acted false positives age out of the demotion window, not merely
- * because the demoted mechanism stopped respawning.
- */
-export function respawnSuppressedByDemotion(focus, respawnAfterTeardown) {
-    if (!respawnAfterTeardown.has(focus.focus_id))
-        return false;
-    if (!isMechanismDemoted(SUPERVISION_MECHANISM.SPAWN_GATE_VS_EXIT_RESPAWN))
-        return false;
-    markLatestFiringUnacted(SUPERVISION_MECHANISM.SPAWN_GATE_VS_EXIT_RESPAWN, focus.focus_id);
-    log.info(`Spawn-gate-vs-exit respawn demoted to observe-only -- not respawning just-torn-down "${focus.focus_name}"`);
-    return true;
-}
-async function skipIfRespawnCycleTerminated(focus, organizationId) {
-    if (!isRespawnCycleTerminated(focus.focus_id))
-        return false;
-    await fileRespawnCycleExhaustedEscalation({
-        organizationId,
-        focusId: focus.focus_id,
-        focusName: focus.focus_name,
-    });
-    return true;
-}
-/**
- * Whether a queued REVIEW directive for this focus is parked on an operator hold
- * (spawn/review-hold-park.ts): the review waits on the escalation, not on billed
- * respawns, and the hold's resolution releases it (clearing the respawn halt).
- * Read BEFORE the respawn-halt check so a halted focus still observes its
- * release. A non-review directive is never parked here.
- */
-export async function pendingReviewParkedOnOperatorHold(focus, deps = {}) {
-    if (getPendingSpawnDirective(focus.focus_id)?.lineage !== 'review')
-        return false;
-    return (await gateReviewSpawnOnOperatorHold(focus, deps)) === 'parked';
-}
-/**
- * The focus branch a review would cover and where its approvals are recorded,
- * resolved against the focus's product (the same repo the spawn would use).
- */
-function reviewHeadTarget(focus) {
-    const productEntry = config && focus.product_id ? findProduct(config, focus.product_id) : undefined;
-    const pc = config && productEntry ? configForProduct(config, productEntry) : config;
-    return {
-        productId: focus.product_id ?? pc?.productId ?? '', focusId: focus.focus_id, branchName: focus.branch_name, repoPath: pc?.repoPath ?? '',
-        ...(pc?.integrationBranch ? { integrationBranch: pc.integrationBranch } : {}),
-    };
-}
-/**
- * The ready-focus pass's spawn. A queued REVIEW directive at an already-approved
- * focus head is dropped first (focus/pending-review-approved-head.ts), so the team
- * spawnFocusTeam starts for the focus's coding work is not a review of the
- * unchanged commit.
- */
-async function spawnReadyFocusTeam(deps, focus, params) {
-    await gatePendingReviewAtApprovedHead(focus, reviewHeadTarget(focus), 'ready', deps.reviewApprovedHead);
-    await deps.spawnFocusTeam(params);
-}
-/**
- * Whether a queued REVIEW directive is declined because the focus head is the
- * commit its current approval already judged (focus/pending-review-approved-head.ts):
- * dropped with its stale review window, or withheld while a hold marker still
- * awaits its release. Read AFTER the operator-hold park, so a resolved hold is
- * released (halt cleared durably) even when the review itself is declined.
- */
-export async function pendingReviewDeclinedAtApprovedHead(focus, deps = {}) {
-    return (await gatePendingReviewAtApprovedHead(focus, reviewHeadTarget(focus), 'pending', deps)) !== 'spawn';
-}
-/**
- * Stage-currency guard: a queued spawn directive belongs to the stage the focus
- * was in when it was stashed (originStageId). If the focus has since LEFT that
- * stage, the directive is stale -- the 2026-09-06 focus 6f866509 case, where a
- * verifying-stage directive was consumed by a spawn 0.4s after the focus moved to
- * reviewing. Drop it rather than consume it, and report whether the spawn must be
- * skipped. A null origin (older entry, or a stash site with no stage) or a null
- * current stage skips the check (fail-open, never a false drop).
- */
-export function dropStalePendingSpawnDirective(focus) {
-    const origin = getPendingSpawnDirective(focus.focus_id)?.originStageId ?? null;
-    const current = focus.current_workflow_stage_id;
-    if (origin === null || current === null || origin === current)
-        return false;
-    clearPendingSpawnDirective(focus.focus_id);
-    log.info(`[listener] Dropping stale pending directive for "${focus.focus_name}" -- it belongs to stage ` +
-        `${origin.slice(0, 8)} but the focus is now in ${current.slice(0, 8)}.`);
-    return true;
-}
-/**
- * The OPERATOR-STOP disposal of a queued spawn directive: drop it, deliberately.
- *
- * A stop is an authoritative halt, so a directive queued while stopped must not
- * silently survive to resume and fire the path the stop was meant to prevent.
- * Dropping also removes the focus from the pending set, so the suppression is
- * logged once per stop, never once per poll.
- *
- * The line NAMES this disposal as the deliberate one it is. It used to be the
- * only trace of either situation, so a directive lost because its session died
- * mid-write read exactly like an operator's choice to drop one, and a reader who
- * saw it concluded the loss had been intended. A delivery that could not reach
- * its session is a DIFFERENT event with its own durable record on the focus
- * (queries/directive-undelivered.ts); this covers only the QUEUED spawn
- * directive, and only because an operator stopped the focus.
- *
- * Extracted from processPendingSpawnFocuses to keep it within its size floor.
- */
-function dropQueuedDirectiveOnOperatorStop(focus) {
-    const pending = getPendingSpawnDirective(focus.focus_id);
-    if (pending)
-        clearPendingSpawnDirective(focus.focus_id);
-    nullRoleSkipWarnedFocuses.delete(focus.focus_id);
-    log.info(`[listener] Focus ${focus.focus_id.slice(0, 8)} ("${focus.focus_name}") is held by an operator stop; ` +
-        `deliberately dropping the queued ${pending?.sessionType ?? 'spawn'} directive so it cannot fire on ` +
-        `resume (not carried to resume). This is an operator's choice, NOT a delivery failure: a directive ` +
-        `whose session ended mid-delivery is recorded on the focus as an undelivered directive instead.`);
-}
-/**
- * Whether a pending spawn directive must be DEFERRED because an in-flight verify
- * hold covers the focus's only open work -- read through the ONE shared predicate,
- * so a sibling delivery's open work outside the verified delivery still spawns
- * (f1, 2026-09-13). A REVIEW-lineage pending directive is EXEMPT (returns false
- * even while held): the review is exactly the work that releases the deliveries
- * the hold is holding, so gating it would deadlock the focus in verify. Mirrors
- * the directive gate's lineage exemption (directive/directive-verify-hold-gate.ts)
- * and the review-always-spawnable rule, so the two disposal sites cannot drift.
- */
-export async function pendingSpawnDeferredByVerifyHold(focusId, deps = {}) {
-    if (getPendingSpawnDirective(focusId)?.lineage === 'review')
-        return false;
-    const facts = await resolveFocusVerifyHoldFacts(focusId, deps);
-    return !focusHasTeamActionableWork({ hasUnheldActionableWork: true, ...facts });
-}
-/**
- * One poll's pending-spawn pass. It starts a drain of the escalation spool
- * (queries/escalation-spool.ts): an escalation a bounded hold spooled when the
- * writer was down, whose queued directive is already gone, so nothing else would
- * carry it. The drain starts even when no directive is queued, but the pass does
- * NOT wait on it (single-flight per spool directory, every filing time-bounded):
- * a slow writer or a backlog never delays the pending-directive spawns that run
- * next.
- */
-export async function runPendingSpawnPass(deps = PENDING_SPAWN_PASS_DEPS) {
-    if (!isDaemonShuttingDown())
-        void startEscalationSpoolDrain(deps.escalationSpool);
-    await processPendingSpawnFocuses(deps);
-}
-/**
- * Spawn teams for focuses that have a pending spawn directive but were
- * not surfaced by getReadyFocuses.
- *
- * getReadyFocuses (daemon-focus-handlers.ts) only returns focuses with
- * queued/coding deliveries (or zero deliveries). A review-stage spawn
- * directive on a focus whose deliveries are all in verify never makes
- * it to processReadyFocuses -- the pending directive sits forever and
- * the team never starts. This function bridges that gap: scan the
- * pending-spawn map directly and spawn for any focus that's not
- * already running.
- */
-export async function processPendingSpawnFocuses(deps = PENDING_SPAWN_PASS_DEPS) {
-    if (!config)
-        return;
-    const awaitingSlot = [];
-    const pendingIds = isDaemonShuttingDown() ? [] : getPendingSpawnFocusIds().filter(id => !hasActiveTeam(id));
-    if (pendingIds.length === 0) {
-        recordSlotBlockedFocuses('pending', awaitingSlot);
-        return;
-    }
-    // Fetch focus details (the metadata spawnFocusTeam needs) for all configured products.
-    const focusDetailsById = new Map();
-    // Whether ANY product's getActiveFocuses read failed this tick. A fetch failure
-    // makes the active set incomplete, so a pending focus can look absent purely
-    // because its product's read failed -- absence is only trustworthy when this is
-    // false. Gates the zombie-directive reap below.
-    let anyFetchFailed = false;
-    for (const product of config.products) {
-        try {
-            const focuses = await deps.getActiveFocuses(config.organizationId, product.id);
-            for (const f of focuses) {
-                if (pendingIds.includes(f.focus_id)) {
-                    focusDetailsById.set(f.focus_id, f);
-                }
-            }
-        }
-        catch (err) {
-            anyFetchFailed = true;
-            log.warn(`[listener] processPendingSpawnFocuses: failed to fetch active focuses for product ${product.id}: ${err.message}`);
-        }
-    }
-    for (const focusId of pendingIds) {
-        const focus = focusDetailsById.get(focusId);
-        if (!focus) {
-            reapOrRetryAbsentPendingFocus(focusId, anyFetchFailed);
-            continue;
-        }
-        // Stale-stage directive, or a non-review directive a review pass supersedes: dropped, never consumed (see helpers).
-        if (dropStalePendingSpawnDirective(focus) || await pendingCodingSpawnSupersededByReview(focus, deps.reviewNextStep))
-            continue;
-        let role;
-        if (!focusMayRunTeam(focus.assigned_agent_role_id)) {
-            // A null assigned_agent_role_id is INERT: no team spawns on it, whatever
-            // the directive's origin (coding or review) or the focus's arm history.
-            // focusMayRunTeam is the SINGLE shared verdict the wedge watchdog reads too,
-            // so the two cannot log contradictory decisions about this focus in one
-            // tick. decideNullRoleSpawn only sub-classifies what to do with the queued
-            // directive:
-            //   - operator stop => an authoritative halt: drop the directive quietly
-            //     (an API unarm also stamps operator_stopped_at, so this covers it).
-            //   - otherwise      => a lifecycle clear (auto_terminate_focus_team cleared
-            //     the arm at completion) or a never-armed focus: REFUSE the directive
-            //     and RECORD the refusal.
-            // The former review-role fallback that SUBSTITUTED the org's seeded
-            // Developer role here -- the arm-gate bypass -- has been removed (focus
-            // fa557d6c). Continuations are unaffected: a review pass / gaps_found
-            // re-queue runs while its deliveries sit in verify (non-terminal), so the
-            // arm is never cleared and the continuation spawns under the HELD role via
-            // the else branch below, never this null-role path.
-            const operatorStopped = !!focus.operator_stopped_at;
-            const pending = getPendingSpawnDirective(focus.focus_id);
-            const decision = decideNullRoleSpawn({ operatorStopped });
-            if (decision.action === 'skip') {
-                // Operator STOP: the deliberate drop (see the helper for why this line
-                // must not read like a lost delivery).
-                dropQueuedDirectiveOnOperatorStop(focus);
-                continue;
-            }
-            // decision.action === 'refuse': a null role that is NOT an operator stop --
-            // a lifecycle clear that outran its work, or a focus never armed. REFUSE the
-            // directive and RECORD it: drop it so it cannot re-fire under a substituted
-            // role, and warn (throttled to once per blocked episode). The focus stays
-            // un-armed with no team running until a human arms it -- arming re-drives the
-            // spawn through the normal ready-focus path.
-            const provenance = focus.first_armed_at != null
-                ? 'its arm was cleared while work remains (a lifecycle clear that outran its work)'
-                : 'it has never been armed';
-            if (pending)
-                clearPendingSpawnDirective(focus.focus_id);
-            if (shouldWarnNullRoleSkip(nullRoleSkipWarnedFocuses, focus.focus_id)) {
-                log.warn(`[listener] Refused a ${pending?.sessionType ?? 'spawn'} directive for focus ${focusId.slice(0, 8)} ("${focus.focus_name}"): ` +
-                    `assigned_agent_role_id is null -- ${provenance}. No team spawns until a human arms it; ` +
-                    `directive dropped (not fulfilled under a substituted role).`);
-            }
-            continue;
-        }
-        else {
-            // Focus has a role again -- any prior null-role blocked episode is over.
-            nullRoleSkipWarnedFocuses.delete(focus.focus_id);
-            role = roles.get(focus.assigned_agent_role_id);
-            if (!role) {
-                log.warn(`[listener] Pending spawn directive for focus ${focusId.slice(0, 8)} ("${focus.focus_name}") references unknown role ${focus.assigned_agent_role_id}; ` +
-                    `skipping spawn.`);
-                continue;
-            }
-        }
-        // Spent-review-budget backstop (focus/review-cycle-cap-hold.ts), read exactly as the ready gate reads it.
-        // A spent budget normally stops this focus by UN-ARMING it (the null-role refusal above); this catches the
-        // case where that release did not land, so the count alone stops the pass. The directive stays queued
-        // (retained, like a verify hold) and spawns once the focus is armed again.
-        const capFocus = { focusId: focus.focus_id, focusName: focus.focus_name, reviewCycleCount: focus.review_cycle_count };
-        if (await resolveReviewCycleCapHold(capFocus, deps.reviewCycleCapHold))
-            continue;
-        // Park focuses with an unhealed team_failure escalation BEFORE attempting
-        // the spawn. spawnFocusTeam applies the same guard, but it returns after
-        // the guard fires without consuming the pending directive -- so the
-        // directive stays queued and this loop re-attempts (and the guard re-logs)
-        // every poll. Checking here skips the misleading "Spawning team" log and
-        // the wasted spawn call; the directive intentionally stays queued so the
-        // (re)review resumes once a human resolves the escalation. The guard
-        // throttles its own log to once per blocked episode.
-        if (await applyRespawnGuard(focus.focus_id, focus.focus_name, deps.respawnGuard)) {
-            continue;
-        }
-        // Spawn cooldown: this path spawns teams for focuses that getReadyFocuses
-        // does NOT surface -- focuses with no actionable/queued deliveries (e.g. a
-        // reviewing-stage spawn over a focus whose deliveries are all in verify).
-        // Such a team idle-exits if its directive can't make progress; without a
-        // gate the directive re-fires every poll and the daemon respawns an
-        // immediately-idle team every cycle (the reinforcing auto-review/idle-spawn
-        // loop). See spawn/guards.ts (the pending-spawn guard).
-        // A review parked on an operator hold waits on the escalation (no spawn, no teardown) and its resolution lifts
-        // the halt; a review at an already-approved head never spawns; else a terminated respawn cycle files + skips.
-        if (await pendingReviewParkedOnOperatorHold(focus, deps.reviewHoldPark) || await pendingReviewDeclinedAtApprovedHead(focus, deps.reviewApprovedHead) || await skipIfRespawnCycleTerminated(focus, config.organizationId)) {
-            continue;
-        }
-        // Fourth controller (D1): never spawn a coding team into a worktree under an
-        // in-flight verify hold. A REVIEW-lineage pending directive is EXEMPT (it
-        // releases the hold) -- see pendingSpawnDeferredByVerifyHold.
-        if (await pendingSpawnDeferredByVerifyHold(focus.focus_id, deps.verifyHold)) {
-            log.info(`[listener] Deferring pending spawn for "${focus.focus_name}" -- under a verify hold`);
-            continue;
-        }
-        if (await isNextSpawnInCooldown(config, focus)) {
-            continue;
-        }
-        // Every slot in use: no spawn; record it as waiting for a slot and keep classifying.
-        if (getActiveTeamCount() >= config.maxTotalSessions) {
-            awaitingSlot.push(focus);
-            continue;
-        }
-        const productEntry = focus.product_id ? findProduct(config, focus.product_id) : undefined;
-        const spawnConfig = productEntry ? configForProduct(config, productEntry) : config;
-        // JUSTIFIED (focus fa557d6c -- the "spawn while reporting no actionable
-        // deliveries" path). This is the load-bearing mechanism that spawns a team
-        // for a queued STAGE DIRECTIVE on a focus getReadyFocuses does NOT surface:
-        // getReadyFocuses is delivery-centric (queued/actionable deliveries), so a
-        // reviewing-stage spawn over a focus whose deliveries are all in verify has no
-        // queued delivery to surface, yet a review directive is legitimately queued.
-        // "No actionable DELIVERIES" is not "nothing to do" -- the queued directive is
-        // the actionable unit; removing this path would strand every such review
-        // spawn. The degenerate case (a directive that makes no progress -> an
-        // idle-exiting team) is bounded above by the respawn cooldown guard
-        // (skipIfRespawnCycleTerminated / isNextSpawnInCooldown), and the arm-gate
-        // bypass subset (a null assigned_agent_role_id) is refused in the null-role
-        // branch above and never reaches here. See docs/DECISIONS.md (2026-09-09).
-        const pendingSessionType = getPendingSpawnDirective(focus.focus_id)?.sessionType;
-        log.info(`[listener] Spawning team for focus "${focus.focus_name}" via a queued ${pendingSessionType ?? 'spawn'} directive ` +
-            `(getReadyFocuses surfaces no queued delivery -- e.g. a review over verify-only deliveries -- but the stage directive is the actionable unit)`);
-        // Audit-phase => read-only spawn (see the processReadyFocuses spawn above).
-        // The pending-spawn focus comes from getActiveFocuses, which carries
-        // audit_origin + ratified_at, so the second signal (TEL-3) resolves here too.
-        await deps.spawnFocusTeam({
-            config: spawnConfig,
-            focusId: focus.focus_id,
-            focusName: focus.focus_name,
-            role,
-            pipelineConfig: focus.pipeline_config,
-            readOnly: isAuditPhaseFocusRow(focus),
-            lastClaudeSessionId: null,
-            claudeSessionIds: focus.claude_session_ids,
-            engineOverride: focus.engine_override,
-            localModelOverride: focus.local_model_override,
-            orgDefaultEngine: focus.org_default_engine,
-            orgDefaultCodingModel: focus.org_default_coding_model,
-            orgDefaultReviewModel: focus.org_default_review_model,
-            pinnedBranch: focus.branch_name,
-            armedBaselineDeliveryIds: focus.armed_baseline_delivery_ids,
-        });
-        // Record a teardown so repeated spawns through this no-actionable-work path
-        // back off exponentially instead of recurring every poll. A team that
-        // genuinely makes progress moves the focus into a state getReadyFocuses
-        // surfaces (and clearSpawnCooldown can reset it); a team that idle-exits is
-        // rate-limited by the growing cooldown. This bounds spawn count on a
-        // wedged-in-verify focus. See spawn/guards.ts (the pending-spawn guard).
-        //
-        // ONLY when a team actually spawned (TEL, delivery 5): if spawnFocusTeam
-        // SKIPPED (e.g. a terminal focus whose deliveries are all terminal now
-        // returns 'skip', or the pre-spawn guards declined), no team exists to tear
-        // down, so recording a teardown here would accrue the respawn streak against
-        // a focus that correctly spawned nothing -- penalising quiet correctness. The
-        // idle-exit backoff is preserved: a genuine spawn leaves hasActiveTeam true at
-        // this point (the team runs asynchronously and exits later).
-        if (hasActiveTeam(focus.focus_id)) {
-            recordPendingSpawnAttempt(focus.focus_id);
-        }
-    }
-    recordSlotBlockedFocuses('pending', awaitingSlot);
-}
-//# sourceMappingURL=listener-spawn.js.map