@telora/daemon 0.17.33 → 0.17.40

package/dist/directive-executor.js

@@ -1,700 +1,41 @@
 /**
- * Directive Executor.
+ * Directive Executor -- thin orchestrating entry point.
  *
- * Detects focus workflow stage changes and executes the stage's
- * agent_directive. For inject mode: writes /compact + prompt via stdin.
- * For spawn mode: terminates current session, assembles directive content,
- * and stores it for the next spawn cycle to deliver.
+ * "What happens when a stage changes" reads from here: checkDirectives
+ * (called from the daemon poll loop) walks active focuses, syncs each
+ * focus's workflow stage, and edge-triggers the stage's agent_directive.
+ * The real logic lives in focused modules under directive/:
+ *
+ *   - directive/phase-sync.ts        stage detection + phase sync + transition triggers
+ *   - directive/directive-assembly.ts assembly of directive content (recipe + prompt + tools)
+ *   - directive/directive-dispatch.ts inject-to-stdin / spawn-queue execution + bounded retry
+ *   - directive/close-loop-stage.ts  close_loop stage dispatcher (bookkeeper + sweep)
+ *   - directive/stage-tracker.ts     lastProcessedStages map + accessors
+ *   - directive/directive-queue.ts   pendingSpawnDirectives map + identity/guard helpers
+ *
+ * This module RE-EXPORTS the full prior public surface so existing importers
+ * (listener, focus-executor, spawner/spawn-team, completion/team-completion,
+ * tests) are unaffected.
  */
 import { getActiveTeams } from './focus-team-state.js';
-import { resolveAssemblyRecipeWithManifest, } from './assembly-engine.js';
-// Side-effect import: registers assembly resolvers with assembly-engine at module load. Required - do not remove.
-import './assembly-resolvers.js';
-import { resolveLineageSpec } from './session-lineage.js';
-import { fetchFocusWorkflow, fetchFocusWorkflowWithTransitions, getFocusDeliveries, updateFocusStage, updateFocusWorkflowStage, } from './queries/focuses.js';
-import { listPendingEscalations } from './queries/issues.js';
-import { callApi } from './queries/shared.js';
-import { CLOSE_LOOP_MODEL, advanceFocusToDoneWithSweep, buildCloseLoopDirective, decideCloseLoop, getAnchoringDeliveries, } from './close-loop-dispatcher.js';
-import { verifyInjectionWithEvidence } from './queries/verification.js';
-import { ESCALATION_KINDS, FOCUS_STAGE } from '@telora/daemon-core';
-import { deriveFocusPhase } from './focus-phase.js';
-import { sendMessage } from '@telora/daemon-core';
-import { terminateTeam, waitForTeamExit } from './focus-executor.js';
+import { fetchFocusWorkflow } from './queries/focuses.js';
+import { FOCUS_STAGE } from '@telora/daemon-core';
 import { getActiveFocuses } from './supabase.js';
 import { configForProduct } from './config.js';
-import { fetchTransitionGuards } from './queries/guards.js';
-import { executeAdvanceLinkedInjections } from './trigger-executor.js';
-import { createEscalation } from './queries/issues.js';
-import { ESCALATION_REASONS } from '@telora/daemon-core';
 import { emitLoopTrigger } from './loop-event-bus.js';
-// ── Stage tracking (extracted to directive/stage-tracker.ts) ─────
-// The lastProcessedStages map + its accessors now live in a focused module.
-// directive-executor imports the map binding for its in-loop reads/writes and
-// RE-EXPORTS the accessors so existing importers are unaffected.
+import { resolveLineageSpec } from './session-lineage.js';
 import { lastProcessedStages } from './directive/stage-tracker.js';
+import { computeDirectiveHash, getPendingSpawnDirective, shouldSuppressRefireForPendingSpawn, } from './directive/directive-queue.js';
+import { fireFocusTransitionTriggers, shouldRefireStrandedReview, syncFocusPhase, } from './directive/phase-sync.js';
+import { executeDirective, resolveDirectiveExecutionMode, runDirectiveWithRetry, escalateDirectiveFailure, } from './directive/directive-dispatch.js';
+import { dispatchCloseLoopStage } from './directive/close-loop-stage.js';
+// ── Re-exported public surface (callers unchanged) ───────────────
 export { seedLastProcessedStage, getLastProcessedStages } from './directive/stage-tracker.js';
-// ── Pending spawn directives (extracted to directive/directive-queue.ts) ──
-// The pendingSpawnDirectives map + its accessors and the directive identity /
-// spawn-guard helpers now live in a focused module. directive-executor imports
-// the map binding + helpers it calls in-line and RE-EXPORTS the full surface so
-// existing importers (focus-executor, listener, tests) are unaffected.
-import { pendingSpawnDirectives, computeDirectiveHash, SPAWN_GUARD_WINDOW_MS, shouldSkipSpawnDirective, getPendingSpawnDirective, shouldSuppressRefireForPendingSpawn, } from './directive/directive-queue.js';
 export { computeDirectiveHash, SPAWN_GUARD_WINDOW_MS, shouldSkipSpawnDirective, consumePendingSpawnDirective, __setPendingSpawnDirectiveForTesting, hasPendingSpawnDirective, getPendingSpawnDirective, getPendingSpawnFocusIds, shouldSuppressRefireForPendingSpawn, } from './directive/directive-queue.js';
-/**
- * Assemble directive content from a StageDirective's recipe and prompt.
- * Shared by both inject and spawn modes, and by focus-executor for
- * initial spawn with a stage directive.
- */
-export async function assembleDirectiveContent(config, focusId, directive, worktreePath) {
-    const { content } = await assembleDirectiveContentWithManifest(config, focusId, directive, worktreePath);
-    return content;
-}
-/**
- * Assemble directive content AND return the assembly manifest (one entry per
- * recipe source). The composed `content` is identical to
- * assembleDirectiveContent; the manifest lets the spawn path persist what
- * context was injected. The manifest covers ONLY the assembly recipe -- the
- * static directive.prompt / tool guidance are not assembly sources.
- */
-export async function assembleDirectiveContentWithManifest(config, focusId, directive, worktreePath) {
-    const recipe = [...directive.assembly];
-    let assembledContext = '';
-    let manifest = [];
-    if (recipe.length > 0) {
-        try {
-            const deliveries = await getFocusDeliveries(focusId);
-            const assemblyContext = {
-                focusId,
-                deliveryIds: deliveries.map(d => d.id),
-                worktreePath,
-                config,
-                organizationId: config.organizationId,
-                productId: config.productId,
-            };
-            const resolved = await resolveAssemblyRecipeWithManifest(recipe, assemblyContext);
-            assembledContext = resolved.content;
-            manifest = resolved.manifest;
-        }
-        catch (err) {
-            console.warn(`[directive-executor] Assembly resolution failed for focus ${focusId.slice(0, 8)}: ${err.message}`);
-        }
-    }
-    const parts = [];
-    if (assembledContext.trim()) {
-        parts.push(assembledContext);
-    }
-    if (directive.prompt) {
-        parts.push(directive.prompt);
-    }
-    if (directive.tools) {
-        const toolLines = ['## Tool Guidance', ''];
-        if (directive.tools.include.length > 0) {
-            toolLines.push(`**Preferred tools:** ${directive.tools.include.join(', ')}`);
-        }
-        if (directive.tools.discouraged.length > 0) {
-            toolLines.push(`**Discouraged tools:** ${directive.tools.discouraged.join(', ')}`);
-        }
-        if (directive.tools.guidance) {
-            toolLines.push('');
-            toolLines.push(directive.tools.guidance);
-        }
-        parts.push(toolLines.join('\n'));
-    }
-    return { content: parts.join('\n\n'), manifest };
-}
-// ── Core execution ───────────────────────────────────────────────
-/**
- * Resolve the execution mode a directive should dispatch under.
- *
- * Pure + exported for testing. The rule:
- *   - A valid mode ('inject' | 'spawn') passes through unchanged.
- *   - A review-lineage directive whose execution is missing/invalid defaults
- *     to 'spawn'. Review always spawns a fresh team, so 'spawn' is the only
- *     sensible mode for that lineage; defaulting here self-heals malformed or
- *     seed-drifted review directives (e.g. the focus 'review' stage whose
- *     agent_directive lost its execution field -- see the backfill migration)
- *     so the review-spawn path can no longer be silently stranded.
- *   - Anything else is UNRESOLVABLE (returns null). The caller treats null as
- *     a fail-loud condition (throw -> escalate + loop trigger) rather than a
- *     silent no-op.
- *
- * Note: a review-lineage directive defaults to spawn even for a non-empty but
- * unrecognized execution value -- review is always spawnable, so we self-heal
- * rather than fail. Non-review lineages have no safe default and fail loud.
- */
-export function resolveDirectiveExecutionMode(execution, lineage) {
-    if (execution === 'inject' || execution === 'spawn')
-        return execution;
-    if (lineage === 'review')
-        return 'spawn';
-    return null;
-}
-/**
- * Execute a stage directive for a focus.
- *
- * inject mode: sends /compact + assembled context + prompt to the active team's stdin.
- * spawn mode: terminates the current team, assembles directive content, stores for respawn.
- *
- * When the directive's execution mode cannot be resolved to a valid mode
- * (see resolveDirectiveExecutionMode), this THROWS instead of silently
- * no-oping. The throw propagates through runDirectiveWithRetry in
- * checkDirectives, which escalates and emits a loop trigger -- so a malformed
- * directive surfaces a signal instead of stranding the focus.
- *
- * Exported for testing.
- */
-export async function executeDirective(config, focusId, directive, focusWorkflowStageId, stageName) {
-    // Resolve the session lineage + continuity policy DECLARED by the directive
-    // (INJ-B), falling back to the stage-name-derived default when the directive
-    // omits them ('reviewing' -> review/fresh; otherwise coding/resume). The
-    // review-exit gate (focus-completion) still keys off sessionType, which we
-    // derive from the resolved lineage: lineage 'review' tags a review session,
-    // every other lineage tags 'coding'. This drops the old hardcoded
-    // stageName==='reviewing' special-case while preserving the gate contract.
-    const spec = resolveLineageSpec({ declared: directive, stageName });
-    const sessionType = spec.lineage === 'review' ? 'review' : 'coding';
-    const mode = resolveDirectiveExecutionMode(directive.execution, spec.lineage);
-    console.log(`[directive-executor] Executing ${mode ?? `unresolved(${directive.execution})`} directive ` +
-        `for focus ${focusId.slice(0, 8)} (stage ${focusWorkflowStageId.slice(0, 8)})`);
-    if (mode === 'inject') {
-        await executeInjectDirective(config, focusId, directive, sessionType, spec);
-    }
-    else if (mode === 'spawn') {
-        await executeSpawnDirective(config, focusId, directive, sessionType, spec);
-    }
-    else {
-        // Fail loud: an unknown/undefined execution mode on a non-review lineage
-        // cannot be defaulted safely. Throwing routes through runDirectiveWithRetry
-        // -> escalateDirectiveFailure + emitLoopTrigger (checkDirectives) so the
-        // broken directive escalates instead of silently marking the stage
-        // processed.
-        throw new Error(`Unresolvable directive execution mode "${directive.execution}" ` +
-            `(lineage "${spec.lineage}", stage "${stageName ?? 'unknown'}") for focus ${focusId.slice(0, 8)}`);
-    }
-}
-/**
- * Inject mode: send /compact + assembled context + prompt to the active team's stdin.
- */
-export async function executeInjectDirective(config, focusId, directive, sessionType = 'coding', spec = resolveLineageSpec({ declared: directive, stageName: undefined })) {
-    const activeTeams = getActiveTeams();
-    const team = activeTeams.get(focusId);
-    if (!team || !team.leadStdin) {
-        // No active team -- fall back to spawn mode so the directive is
-        // delivered when the next team spawns (e.g., review triggered while
-        // pipeline was stopped; the pipeline gets activated but the team
-        // hasn't spawned yet by the time the directive executor runs).
-        console.log(`[directive-executor] No active team for focus ${focusId.slice(0, 8)} -- ` +
-            `falling back to spawn directive for delivery on next spawn`);
-        const message = await assembleDirectiveContent(config, focusId, directive, null);
-        pendingSpawnDirectives.set(focusId, {
-            message,
-            model: directive.model ?? null,
-            sessionType,
-            lineage: spec.lineage,
-            continuity: spec.continuity,
-            contentHash: computeDirectiveHash(directive),
-        });
-        return;
-    }
-    // Don't retask a live review team. Phase changes can fire while a review
-    // team is still working (e.g., the team mutates delivery state and the
-    // aggregate flips the focus's derived phase). Without this guard, the
-    // resulting inject sends /compact + a coding-stage prompt to the review
-    // team's stdin, which silently converts a reviewer into a developer
-    // mid-flight -- exactly what the sessionType separation is meant to
-    // prevent. Skip the inject and let the review team finish its directive
-    // on its own terms; if a coding-phase directive really is needed, the
-    // listener will spawn a fresh team after the review team exits.
-    if (team.sessionType === 'review') {
-        console.warn(`[directive-executor] Skipping inject for focus ${focusId.slice(0, 8)} -- ` +
-            `active team is a review session; phase-driven retasking would convert it ` +
-            `into a coder. Directive not delivered.`);
-        return;
-    }
-    // Tag the live team with the injected directive's sessionType. Without this,
-    // a keep-alive coding team that receives the reviewing-stage directive does
-    // the review work but stays labelled 'coding'. On a clean review exit (no
-    // gaps filed, no focus_reviews report) handleReviewExit's auto-approve gate
-    // requires sessionType === 'review' (focus-completion.ts), so it never fires:
-    // the verify delivery is left in verify and the next poll re-triggers
-    // auto-review -- an infinite review/respawn loop. Flipping the label here
-    // also arms the `team.sessionType === 'review'` retask guard above for any
-    // subsequent inject. (Guaranteed `!== 'review'` at this point by the guard.)
-    team.sessionType = sessionType;
-    // Keep the team's session-id map slot in step with the injected directive's
-    // lineage so a subsequent resume reads/writes the right slot (INJ-B).
-    team.lineage = spec.lineage;
-    // Step 1: Send /compact command if recipe is specified
-    if (directive.compact) {
-        const compactMessage = `/compact Preserve: ${directive.compact.preserve}. Shed: ${directive.compact.shed}.`;
-        console.log(`[directive-executor] Sending /compact for focus ${focusId.slice(0, 8)}`);
-        sendMessage(team.leadStdin, compactMessage);
-    }
-    // Step 2: Assemble and send context + prompt
-    const fullMessage = await assembleDirectiveContent(config, focusId, directive, team.worktreePath);
-    if (fullMessage.trim()) {
-        console.log(`[directive-executor] Sending directive message to focus ${focusId.slice(0, 8)} ` +
-            `(${fullMessage.length} chars)`);
-        sendMessage(team.leadStdin, fullMessage);
-    }
-}
-/**
- * Spawn mode: terminate the current team, assemble directive content,
- * and store it for the next spawn cycle to deliver.
- */
-async function executeSpawnDirective(config, focusId, directive, sessionType = 'coding', spec = resolveLineageSpec({ declared: directive, stageName: undefined })) {
-    const activeTeams = getActiveTeams();
-    const team = activeTeams.get(focusId);
-    const worktreePath = team?.worktreePath ?? null;
-    // Assemble the directive content before terminating the team
-    // (the team's worktree path is needed for git diff resolution)
-    const message = await assembleDirectiveContent(config, focusId, directive, worktreePath);
-    const contentHash = computeDirectiveHash(directive);
-    // Store the assembled content for the next spawn to pick up
-    pendingSpawnDirectives.set(focusId, {
-        message,
-        model: directive.model ?? null,
-        sessionType,
-        lineage: spec.lineage,
-        continuity: spec.continuity,
-        contentHash,
-    });
-    // If a team was recently spawned, it may have already consumed this exact
-    // directive via the pending spawn directive mechanism. Skip the kill/respawn
-    // churn only when the directive content hash matches what the team last
-    // consumed -- divergent content (e.g. an updated stage directive) must
-    // trigger a respawn so the team operates under fresh intent instead of
-    // waiting for a natural exit.
-    if (team?.startedAt) {
-        const decision = shouldSkipSpawnDirective({
-            team: { startedAt: team.startedAt, lastConsumedDirectiveHash: team.lastConsumedDirectiveHash },
-            contentHash,
-            now: Date.now(),
-        });
-        const ageSec = Math.round((Date.now() - team.startedAt.getTime()) / 1000);
-        if (decision === 'skip') {
-            console.log(`[directive-executor] Team for focus ${focusId.slice(0, 8)} was recently spawned ` +
-                `(${ageSec}s ago) with identical directive content -- skipping respawn`);
-            return;
-        }
-        if (ageSec < SPAWN_GUARD_WINDOW_MS / 1000) {
-            console.log(`[directive-executor] Team for focus ${focusId.slice(0, 8)} was recently spawned ` +
-                `(${ageSec}s ago) but directive content diverged -- proceeding with respawn`);
-        }
-    }
-    // Terminate existing team if one exists
-    if (team) {
-        console.log(`[directive-executor] Terminating existing team for focus ${focusId.slice(0, 8)} before spawn`);
-        terminateTeam(focusId, 'handoff');
-        const exited = await waitForTeamExit(focusId, 30000);
-        if (!exited) {
-            console.warn(`[directive-executor] Team for focus ${focusId.slice(0, 8)} did not exit cleanly`);
-        }
-    }
-    console.log(`[directive-executor] Spawn directive stored for focus ${focusId.slice(0, 8)} ` +
-        `(${message.length} chars, model: ${directive.model ?? 'default'}) -- team will respawn on next poll cycle`);
-}
-// ── Focus transition trigger execution ────────────────────────
-/**
- * Fire on_enter triggers for a focus stage transition.
- *
- * Looks up the workflow transition from lastStageId to currentStageId,
- * fetches triggers on that transition, and executes on_enter triggers.
- * Currently supports advance_linked_injections; other action types
- * are logged and skipped.
- */
-async function fireFocusTransitionTriggers(focusId, lastStageId, currentStageId) {
-    if (!lastStageId)
-        return; // First time seeing this focus, no transition to fire
-    try {
-        // Find the transition between the two stages
-        const workflow = await fetchFocusWorkflowWithTransitions(focusId);
-        const transition = workflow.transitions?.find(t => t.from_stage_id === lastStageId && t.to_stage_id === currentStageId);
-        if (!transition)
-            return; // No transition found (possible for non-standard stage jumps)
-        // Fetch triggers on this transition
-        const resolved = await fetchTransitionGuards(transition.id);
-        const onEnterTriggers = resolved.triggers.filter(t => t.trigger_event === 'on_enter');
-        if (onEnterTriggers.length === 0)
-            return;
-        for (const trigger of onEnterTriggers) {
-            try {
-                if (trigger.action_type === 'advance_linked_injections') {
-                    await executeAdvanceLinkedInjections(focusId, trigger.action_config);
-                }
-                else {
-                    console.log(`[directive-executor] Focus trigger "${trigger.name}" (${trigger.action_type}) ` +
-                        `skipped -- not supported in focus context`);
-                }
-            }
-            catch (err) {
-                console.warn(`[directive-executor] Failed to execute focus trigger "${trigger.name}":`, err.message);
-            }
-        }
-    }
-    catch (err) {
-        console.warn(`[directive-executor] Failed to fire focus transition triggers for ${focusId.slice(0, 8)}:`, err.message);
-    }
-}
-// ── Phase sync ───────────────────────────────────────────────────
-/**
- * New focus workflow lifecycle stage names introduced by D1
- * (20260513152817_focus_workflow_lifecycle_and_tree_closure.sql).
- *
- * When `product_focuses.stage` is one of these, the daemon takes the
- * denormalized `focus.stage` as authoritative and maps it directly to the
- * matching workflow_stages row — this is how the new lifecycle (verify ->
- * review -> close_loop -> done) drives the daemon, rather than the legacy
- * delivery-aggregate phase derivation. The legacy derivation is kept as a
- * fallback for focuses still on the older
- * kickoff/coding/verifying/reviewing/winding_down flow.
- */
-const LIFECYCLE_STAGE_NAMES = new Set([
-    'queued',
-    'verify',
-    'review',
-    'close_loop',
-    'done',
-]);
-/**
- * Decide which workflow stage name a focus should be in.
- *
- * Pure helper, exported for testing. The selection rule is:
- *   1. If `focus.stage` is one of the new lifecycle stage names
- *      (`queued`/`verify`/`review`/`close_loop`/`done`), use it directly.
- *      The denormalized stage is the authoritative signal under the new
- *      workflow.
- *   2. Otherwise, fall back to the legacy phase derived from the delivery
- *      aggregate (kickoff/coding/verifying/reviewing/winding_down/blocked).
- *
- * Note: `review_requested_at` is still read by the legacy derivation for
- * back-compat -- but on the new lifecycle path the `review` stage transition
- * is driven by writes to `product_focuses.stage`, not by writes to
- * `review_requested_at`. This is the Issue 1 contract.
- */
-export function resolveFocusStageName(input) {
-    if (input.focusStage && LIFECYCLE_STAGE_NAMES.has(input.focusStage)) {
-        return input.focusStage;
-    }
-    return deriveFocusPhase({
-        deliveries: input.deliveries,
-        reviewRequestedAt: input.reviewRequestedAt,
-    });
-}
-/**
- * Stage names that represent the focus review window: 'reviewing' on the
- * legacy delivery-aggregate phase derivation, 'review' on the new focus
- * workflow lifecycle. Either means "a review is the gate to done".
- */
-const REVIEW_STAGE_NAMES = new Set(['reviewing', 'review']);
-/**
- * Decide whether to re-fire a focus's review-stage directive even though the
- * edge-trigger (lastProcessedStages) already marked the stage processed.
- *
- * The edge-trigger fires a stage directive exactly once per stage entry. For
- * the review stage that is normally correct -- a clean review completes, clears
- * review_requested_at, and the focus leaves the review phase. But if the review
- * team never spawned or was killed (e.g. a lifecycle SIGTERM) before routing,
- * the focus stays in the review stage with review_requested_at still set and the
- * directive never re-fires: a silent stuck focus (the founding bug of this focus).
- *
- * A focus STILL in the review stage with review_requested_at set is provably
- * stranded -- any completed review clears review_requested_at and moves the
- * phase. So when no review team is running, re-firing the directive is the
- * self-healing recovery: it respawns the review team. Once a team is running the
- * active-team guard suppresses the re-fire, and a successful review auto-approves
- * and leaves the stage -- so the re-fire is bounded, not a per-poll spin.
- *
- * Pure and exported for unit testing.
- */
-export function shouldRefireStrandedReview(input) {
-    if (!input.stageName || !REVIEW_STAGE_NAMES.has(input.stageName))
-        return false;
-    if (!input.reviewRequestedAt)
-        return false;
-    if (input.hasActiveTeam)
-        return false;
-    return true;
-}
-/**
- * Synchronize `product_focuses.current_workflow_stage_id` with the focus's
- * authoritative stage. The authoritative stage is taken from `focus.stage`
- * when it names one of the new lifecycle stages (Issue 1); otherwise the
- * legacy delivery-aggregate phase derivation applies.
- *
- * Returns the stage ID the focus should be in (post-sync). Falls back to
- * the recorded stage id on error so callers don't have to handle a third
- * "unknown" state.
- */
-export async function syncFocusPhase(focus) {
-    try {
-        const deliveries = await getFocusDeliveries(focus.focus_id);
-        const stageName = resolveFocusStageName({
-            focusStage: focus.stage ?? null,
-            deliveries: deliveries.map((d) => ({ executionStatus: d.executionStatus })),
-            reviewRequestedAt: focus.review_requested_at,
-        });
-        const workflow = await fetchFocusWorkflow(focus.focus_id);
-        const stage = workflow.stages.find((s) => s.name === stageName);
-        if (!stage) {
-            console.warn(`[directive-executor] No "${stageName}" stage in workflow for focus ` +
-                `${focus.focus_id.slice(0, 8)}; phase sync skipped.`);
-            return focus.current_workflow_stage_id;
-        }
-        if (stage.id !== focus.current_workflow_stage_id) {
-            await updateFocusWorkflowStage(focus.focus_id, stage.id);
-            console.log(`[directive-executor] Focus ${focus.focus_id.slice(0, 8)} stage -> ${stageName}`);
-        }
-        return stage.id;
-    }
-    catch (err) {
-        console.warn(`[directive-executor] Phase sync failed for focus ${focus.focus_id.slice(0, 8)}:`, err.message);
-        return focus.current_workflow_stage_id;
-    }
-}
-/**
- * Run a directive function with bounded retry and exponential backoff.
- * Returns a result tuple instead of throwing so the caller can decide
- * whether to escalate or continue.
- */
-export async function runDirectiveWithRetry(fn, options) {
-    const maxAttempts = options.maxAttempts ?? 3;
-    const baseDelayMs = options.baseDelayMs ?? 1000;
-    const sleep = options.sleep ?? ((ms) => new Promise(r => setTimeout(r, ms)));
-    let lastError = null;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-        try {
-            await fn();
-            return { ok: true, attempts: attempt, error: null };
-        }
-        catch (err) {
-            lastError = err;
-            if (attempt < maxAttempts) {
-                options.onAttemptFailed?.(attempt, lastError);
-                const delayMs = baseDelayMs * Math.pow(2, attempt - 1);
-                console.warn(`[directive-executor] ${options.label} failed (attempt ${attempt}/${maxAttempts}): ` +
-                    `${lastError.message}. Retrying in ${delayMs}ms...`);
-                await sleep(delayMs);
-            }
-        }
-    }
-    return { ok: false, attempts: maxAttempts, error: lastError };
-}
-/**
- * Escalate when bounded retry of a stage directive is exhausted.
- *
- * Visible signal so operators can find which focus + stage failed and
- * why, instead of a buried console.warn. Mirrors escalatePlanningFailure
- * from focus-completion-event.ts.
- */
-export async function escalateDirectiveFailure(params, deps = { createEscalation }) {
-    const stageLabel = params.stageName ?? 'unknown';
-    try {
-        await deps.createEscalation({
-            organizationId: params.organizationId,
-            sessionId: params.sessionId,
-            issueId: null,
-            reasonType: ESCALATION_REASONS.ERROR_ENCOUNTERED,
-            description: `Stage directive execution for focus "${params.focusName}" failed after ` +
-                `${params.attempts} attempts on stage "${stageLabel}".\n\n` +
-                `**Focus:** ${params.focusName}\n` +
-                `**Focus ID:** ${params.focusId}\n` +
-                `**Stage:** ${stageLabel}\n` +
-                `**Last error:** ${params.error.message}\n\n` +
-                `The focus has been marked as processed for this stage to prevent a ` +
-                `poll-cycle retry loop. A human must investigate why the directive ` +
-                `cannot run (assembly resolver failure, transient network outage, etc.) ` +
-                `and re-trigger the stage if appropriate.`,
-            whatWasTried: `Bounded retry with exponential backoff (${params.attempts} attempts) on ` +
-                `executeDirective for focus "${params.focusName}" stage "${stageLabel}".`,
-            helpNeeded: `Inspect the daemon log for the failing assembly recipe or directive prompt. ` +
-                `If the error is transient, the focus will recover on the next legitimate ` +
-                `phase change. If it is structural (broken resolver, malformed directive), ` +
-                `fix the directive or assembly recipe.`,
-        });
-        console.log(`[directive-executor] Created directive-failure escalation for "${params.focusName}" ` +
-            `(stage "${stageLabel}", ${params.attempts} attempts)`);
-    }
-    catch (err) {
-        console.error(`[directive-executor] Failed to create directive-failure escalation for ` +
-            `"${params.focusName}": ${err.message}`);
-    }
-}
-// ── Close-loop stage dispatcher ──────────────────────────────────
-/**
- * Per-focus tracker for whether the close_loop bookkeeper has been spawned
- * at least once. Used to avoid respawning the bookkeeper on every poll
- * cycle while non-terminal injections are still being worked.
- *
- * Cleared when the focus leaves close_loop (advances to done or is
- * manually reset). The set is in-process state -- on daemon restart it is
- * empty, which is fine because the dispatcher's decideCloseLoop function
- * will see the bookkeeper has not run, respawn it, and the new bookkeeper
- * will sweep idempotently (already-verified injections stay verified;
- * already-escalated ones still surface their open escalation).
- */
-const closeLoopBookkeeperSpawned = new Set();
-/** Test helper: clear the bookkeeper-spawned set. */
-export function __resetCloseLoopStateForTesting() {
-    closeLoopBookkeeperSpawned.clear();
-}
-/**
- * Inspect open escalations and return the set of injection ids that have
- * an active `injection_unverified` escalation (status pending or
- * in_review). Used by the close_loop dispatcher to classify "escalated"
- * injections as terminal.
- *
- * The `metadata.injection_id` field is set by the bookkeeper persona when
- * filing the escalation -- see the close_loop directive prompt.
- */
-export async function getOpenInjectionUnverifiedEscalationIds() {
-    const escalations = await listPendingEscalations();
-    const ids = new Set();
-    for (const e of escalations) {
-        if (e.escalationKind !== ESCALATION_KINDS.INJECTION_UNVERIFIED)
-            continue;
-        const injectionId = e.metadata?.injection_id;
-        if (typeof injectionId === 'string' && injectionId.length > 0) {
-            ids.add(injectionId);
-        }
-    }
-    return ids;
-}
-/**
- * Dispatch the close_loop stage for one focus.
- *
- * Reads the focus's anchored deliveries + injection statuses + open
- * escalations, then runs the pure `decideCloseLoop` to determine whether
- * to short-circuit, spawn a bookkeeper, advance to done, or hold.
- *
- * Returns the decision so the caller (or a test) can log/assert.
- *
- * Idempotent across poll cycles -- the `closeLoopBookkeeperSpawned` set
- * ensures the bookkeeper is spawned at most once per focus visit to
- * close_loop. Tests reset this via `__resetCloseLoopStateForTesting`.
- */
-export async function dispatchCloseLoopStage(config, focus) {
-    const deliveries = await getFocusDeliveries(focus.focus_id);
-    const anchored = getAnchoringDeliveries(deliveries);
-    // Build the per-injection terminal-state snapshot.
-    //
-    // `statusById` is hoisted to function scope so the close_loop sweep (in
-    // the advance_to_done branch below) can reuse the snapshot without a
-    // second round-trip to reality_tree_focus_injections.
-    const states = [];
-    const statusById = new Map();
-    if (anchored.length > 0) {
-        let openEscalationIds;
-        try {
-            openEscalationIds = await getOpenInjectionUnverifiedEscalationIds();
-        }
-        catch (err) {
-            console.warn(`[close-loop-dispatcher] Failed to fetch open injection_unverified escalations ` +
-                `for focus ${focus.focus_id.slice(0, 8)}: ${err.message}`);
-            openEscalationIds = new Set();
-        }
-        let snapshots = [];
-        try {
-            const result = await callApi('reality_tree_focus_injections', { focusId: focus.focus_id });
-            snapshots = result.items ?? [];
-        }
-        catch (err) {
-            console.warn(`[close-loop-dispatcher] Failed to fetch focus injections for ${focus.focus_id.slice(0, 8)}: ` +
-                `${err.message}`);
-        }
-        for (const item of snapshots) {
-            statusById.set(item.injection.id, item.injection.injectionStatus);
-        }
-        for (const delivery of anchored) {
-            const injectionId = delivery.injectionId;
-            states.push({
-                injectionId,
-                injectionStatus: statusById.get(injectionId) ?? null,
-                hasOpenUnverifiedEscalation: openEscalationIds.has(injectionId),
-            });
-        }
-    }
-    const bookkeeperHasRun = closeLoopBookkeeperSpawned.has(focus.focus_id);
-    const decision = decideCloseLoop(deliveries, states, bookkeeperHasRun);
-    switch (decision.kind) {
-        case 'short_circuit_to_done': {
-            try {
-                await updateFocusStage(focus.focus_id, 'done');
-                console.log(`[close-loop-dispatcher] Focus "${focus.focus_name}" has no anchoring injections -- ` +
-                    `short-circuiting close_loop -> done`);
-            }
-            catch (err) {
-                console.warn(`[close-loop-dispatcher] Failed to short-circuit focus ${focus.focus_id.slice(0, 8)} to done: ` +
-                    `${err.message}`);
-            }
-            closeLoopBookkeeperSpawned.delete(focus.focus_id);
-            return decision;
-        }
-        case 'advance_to_done': {
-            // Focus-level injection sweep + stage advance. The helper realizes
-            // anchored injections whose anchoring deliveries closed successfully
-            // but whose status hasn't yet flipped to 'verified' (e.g. deliveries
-            // that exited via review instead of the per-delivery verify gate),
-            // then advances close_loop -> done. On sweep failure, the helper
-            // returns early WITHOUT calling updateFocusStage -- the focus stays
-            // at close_loop and the next poll cycle retries.
-            const outcome = await advanceFocusToDoneWithSweep(focus, anchored, statusById, { verify: verifyInjectionWithEvidence, updateFocusStage });
-            // Clear the bookkeeper-spawned flag only when the focus has
-            // terminally exited close_loop -- either advanced, or attempted to
-            // advance and the stage-update itself failed. A sweep failure leaves
-            // the flag in place so the same bookkeeper context is reused on the
-            // next poll cycle's retry.
-            if (outcome.advanced || outcome.advanceError) {
-                closeLoopBookkeeperSpawned.delete(focus.focus_id);
-            }
-            return decision;
-        }
-        case 'spawn_bookkeeper': {
-            const team = getActiveTeams().get(focus.focus_id);
-            const worktreePath = team?.worktreePath ?? null;
-            try {
-                const message = await assembleDirectiveContent(config, focus.focus_id, decision.directive, worktreePath);
-                const contentHash = computeDirectiveHash(decision.directive);
-                pendingSpawnDirectives.set(focus.focus_id, {
-                    message,
-                    model: decision.directive.model ?? CLOSE_LOOP_MODEL,
-                    sessionType: 'coding',
-                    // The close_loop bookkeeper is a distinct one-shot session: its own
-                    // lineage slot, always fresh -- it must not resume (or clobber) the
-                    // coder's context (INJ-B).
-                    lineage: 'close_loop',
-                    continuity: 'fresh',
-                    contentHash,
-                });
-                if (team) {
-                    terminateTeam(focus.focus_id, 'handoff');
-                    await waitForTeamExit(focus.focus_id, 30000);
-                }
-                closeLoopBookkeeperSpawned.add(focus.focus_id);
-                console.log(`[close-loop-dispatcher] Spawned bookkeeper team for focus "${focus.focus_name}" ` +
-                    `(${anchored.length} anchored injection(s), model: ${CLOSE_LOOP_MODEL})`);
-            }
-            catch (err) {
-                console.warn(`[close-loop-dispatcher] Failed to spawn bookkeeper for focus ${focus.focus_id.slice(0, 8)}: ` +
-                    `${err.message}`);
-            }
-            return decision;
-        }
-        case 'hold': {
-            console.log(`[close-loop-dispatcher] Focus "${focus.focus_name}" held at close_loop: ${decision.reason}`);
-            return decision;
-        }
-    }
-}
-/**
- * Pure helper exported for tests: build the close_loop directive and verify
- * it carries the expected assembly + model. The buildCloseLoopDirective
- * function in close-loop-dispatcher.ts already does this; this is a
- * dispatcher-side smoke export so the tests can grep through it.
- */
-export function getCloseLoopDirectiveForTesting() {
-    return buildCloseLoopDirective();
-}
+export { assembleDirectiveContent, assembleDirectiveContentWithManifest, } from './directive/directive-assembly.js';
+export { fireFocusTransitionTriggers, resolveFocusStageName, shouldRefireStrandedReview, syncFocusPhase, } from './directive/phase-sync.js';
+export { resolveDirectiveExecutionMode, executeDirective, executeInjectDirective, runDirectiveWithRetry, escalateDirectiveFailure, } from './directive/directive-dispatch.js';
+export { __resetCloseLoopStateForTesting, getOpenInjectionUnverifiedEscalationIds, dispatchCloseLoopStage, getCloseLoopDirectiveForTesting, } from './directive/close-loop-stage.js';
 // ── Poll loop integration ────────────────────────────────────────
 /**
  * Check all active focuses for stage changes with directives.