@aitne/daemon 0.1.7 → 0.1.9

package/dist/core/dispatcher-morning-routine.d.ts

@@ -1,12 +1,23 @@
 /**
  * `MorningRoutineRunner` — owns `routine.morning_routine` execution
- * end-to-end: today.md write-lock acquisition, prompt-variant
- * selection (`morning_routine` vs `morning_routine_initial`), tier
- * inheritance for the initial variant, retry chain wrapping
+ * end-to-end: today.md write-lock acquisition, retry chain wrapping
  * (`morningRoutineInProgress` flag), post-run today.md health check
  * (missing / wrong-date), exponential-back-off retry scheduling, and
  * the deferred post-morning catchup emit.
  *
+ * Variant collapse (`docs/design/appendices/morning-routine-optimization.md`
+ * Phase 4 + Phase 7): both the recurring and first-run (no-yesterday)
+ * branches dispatch under the single `routine.morning_routine` process
+ * key and share one merged task-flow file; the agent picks the
+ * first-run branch inline from the absence of `<yesterday>` in its
+ * prompt context. The previous tier-inheritance hack that mirrored
+ * morning_routine's configured tier onto a separate
+ * `routine.morning_routine_initial` process key has been retired (Phase 4),
+ * and Phase 7 (2026-05-16) removed the high-tier seed entirely —
+ * Stage A now lands roadmap.md inline on medium tier using the
+ * daemon-prepared `<roadmap_skeleton>` block emitted by
+ * `MorningRoutinePipelineOrchestrator.buildRoadmapSkeletonBlock`.
+ *
  * Extracted from `core/dispatcher.ts` as part of phase D-2 of
  * `docs/design/appendices/file-split-plan.md`. Pattern B (stateful
  * coordinator): the runner has no mutable state of its own; it
@@ -34,12 +45,9 @@ import type { Event } from "@aitne/shared";
 import type { AgentConfig } from "../config.js";
 import type { EventBus } from "./event-bus.js";
 import type { TodayWriteLockManager } from "./today-write-lock.js";
-import type { IAgentRouter } from "./backends/backend-router.js";
-import type { IContextBuilder, INotificationManager } from "./dispatcher-types.js";
-import type { PromptAssembler } from "./dispatcher-prompt.js";
-import type { DispatcherErrorRouter } from "./dispatcher-error-handling.js";
-import type { ResultProcessor } from "./dispatcher-result-processor.js";
+import type { INotificationManager } from "./dispatcher-types.js";
 import type { RoutineFetchWindowRunner } from "./routine-fetch-window-runner.js";
+import type { MorningRoutinePipelineOrchestrator } from "./morning/orchestrator.js";
 /**
  * Mirrors the union returned by the dispatcher's `diagnoseTodayMdState`.
  * Re-declared (rather than imported) so the runner stays decoupled
@@ -62,15 +70,10 @@ export interface MorningRoutineRunnerDeps {
     db: Database.Database;
     config: AgentConfig;
     eventBus: EventBus;
-    contextBuilder: IContextBuilder;
-    agentRouter: IAgentRouter;
     notificationMgr: INotificationManager;
     todayWriteLock: TodayWriteLockManager | undefined;
-    prompt: PromptAssembler;
-    errorRouter: DispatcherErrorRouter;
-    resultProcessor: ResultProcessor;
     /**
-     * ROUTINE_DATA_ACQUISITION_DESIGN.md Phase 4 / D2 — the pre-pass
+     * docs/design/appendices/routine-data-acquisition.md Phase 4 / D2 — the pre-pass
      * runner spawned before the main morning routine session so external
      * mail / notion data lands in `/api/observations` before the parent
      * agent reads `pending=true`.
@@ -105,18 +108,23 @@ export interface MorningRoutineRunnerDeps {
      * post-morning hourly_check can fire from `emitPostMorningCatchups`.
      */
     triggerHourlyCheck: (source: string) => Promise<unknown>;
+    /**
+     * morning-routine-optimization.md Phase 5/6/7 — the split-stage
+     * pipeline orchestrator owns Stage A (today.md) + Stage B (daily
+     * journal). The legacy monolithic single-session path was retired
+     * once the orchestrator path stabilised; there is no fallback. If
+     * the orchestrator throws, the post-execute `diagnoseTodayMdState`
+     * gate catches the missing today.md and schedules a retry the same
+     * way a Stage-A-internal failure would.
+     */
+    pipelineOrchestrator: MorningRoutinePipelineOrchestrator;
 }
 export declare class MorningRoutineRunner {
     private readonly db;
     private readonly config;
     private readonly eventBus;
-    private readonly contextBuilder;
-    private readonly agentRouter;
     private readonly notificationMgr;
     private readonly todayWriteLock;
-    private readonly prompt;
-    private readonly errorRouter;
-    private readonly resultProcessor;
     private readonly fetchWindowRunner;
     private readonly setMorningRoutineInProgress;
     private readonly rotateDayFiles;
@@ -124,21 +132,21 @@ export declare class MorningRoutineRunner {
     private readonly isRoadmapStale;
     private readonly emitRoadmapRefresh;
     private readonly triggerHourlyCheck;
+    private readonly pipelineOrchestrator;
     constructor(deps: MorningRoutineRunnerDeps);
     /**
-     * Morning routine execution with pre-processing (lock, rotateDayFiles,
-     * prompt variant selection). Only called for routine === "morning_routine".
-     * Tier is resolved by BackendRouter from process-key defaults or user config.
+     * Morning routine execution with pre-processing (lock, rotateDayFiles).
+     * Only called for routine === "morning_routine".
+     *
+     * Variant collapse: both the recurring and first-run (no-yesterday)
+     * branches dispatch under the single `routine.morning_routine` process
+     * key. The merged task-flow lets the agent pick the first-run branch
+     * inline from the absence of `<yesterday>` in its prompt context, so
+     * tier / binding / cost-cap resolution is the same for both day-types.
+     * Tier is resolved by BackendRouter from process-key defaults or user
+     * config.
      */
     executeMorningRoutine(event: Event): Promise<void>;
-    /**
-     * Read the operator-or-preset configured tier for `routine.morning_routine`
-     * so the non-configurable `morning_routine_initial` variant can mirror it.
-     * Returns null when no row exists (fresh install before the setup wizard
-     * applies a preset) or when the pinned model isn't in the registry — the
-     * caller falls back to the router's default tier in those cases.
-     */
-    private inferConfiguredMorningRoutineTier;
     private emitPostMorningCatchups;
     /**
      * Schedule a retry of the morning routine when today.md wasn't generated.
@@ -166,4 +174,3 @@ export declare class MorningRoutineRunner {
      */
     scheduleMorningRetry(event: Event): void;
 }
-//# sourceMappingURL=dispatcher-morning-routine.d.ts.map

package/dist/core/dispatcher-morning-routine.js

@@ -1,12 +1,23 @@
 /**
  * `MorningRoutineRunner` — owns `routine.morning_routine` execution
- * end-to-end: today.md write-lock acquisition, prompt-variant
- * selection (`morning_routine` vs `morning_routine_initial`), tier
- * inheritance for the initial variant, retry chain wrapping
+ * end-to-end: today.md write-lock acquisition, retry chain wrapping
  * (`morningRoutineInProgress` flag), post-run today.md health check
  * (missing / wrong-date), exponential-back-off retry scheduling, and
  * the deferred post-morning catchup emit.
  *
+ * Variant collapse (`docs/design/appendices/morning-routine-optimization.md`
+ * Phase 4 + Phase 7): both the recurring and first-run (no-yesterday)
+ * branches dispatch under the single `routine.morning_routine` process
+ * key and share one merged task-flow file; the agent picks the
+ * first-run branch inline from the absence of `<yesterday>` in its
+ * prompt context. The previous tier-inheritance hack that mirrored
+ * morning_routine's configured tier onto a separate
+ * `routine.morning_routine_initial` process key has been retired (Phase 4),
+ * and Phase 7 (2026-05-16) removed the high-tier seed entirely —
+ * Stage A now lands roadmap.md inline on medium tier using the
+ * daemon-prepared `<roadmap_skeleton>` block emitted by
+ * `MorningRoutinePipelineOrchestrator.buildRoadmapSkeletonBlock`.
+ *
  * Extracted from `core/dispatcher.ts` as part of phase D-2 of
  * `docs/design/appendices/file-split-plan.md`. Pattern B (stateful
  * coordinator): the runner has no mutable state of its own; it
@@ -29,26 +40,28 @@
  *     flipped to true at the start of the execute → executeWithRetry
  *     wrapper and reset in `finally` so the hourly check can resume.
  */
-import { EventPriority, createEvent, formatSqliteDatetime, isBackendId, } from "@aitne/shared";
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { getContextDir } from "../config.js";
-import { findRegisteredModel } from "./backends/model-registry.js";
+import { EventPriority, createEvent, formatSqliteDatetime, } from "@aitne/shared";
 import { flushPendingTodayRefresh } from "./drift-effects.js";
 import { maybeTriggerRoadmapRefresh } from "./schedule-insert-helper.js";
 import { createLogger } from "../logging.js";
 const logger = createLogger("dispatcher-morning-routine");
+/**
+ * Project the runner's discriminated `TodayMdDiagnosis` into the flat
+ * `TodayMdHealth` union the parent-audit-emitter consumes. The two
+ * shapes were kept decoupled so the emitter does not depend on the
+ * dispatcher's types; this helper bridges them at the one call site.
+ * Lift the bridge into a shared module when a second caller needs it
+ * (no-yet).
+ */
+function mapDiagnoseToHealth(state) {
+    return state.kind;
+}
 export class MorningRoutineRunner {
     db;
     config;
     eventBus;
-    contextBuilder;
-    agentRouter;
     notificationMgr;
     todayWriteLock;
-    prompt;
-    errorRouter;
-    resultProcessor;
     fetchWindowRunner;
     setMorningRoutineInProgress;
     rotateDayFiles;
@@ -56,17 +69,13 @@ export class MorningRoutineRunner {
     isRoadmapStale;
     emitRoadmapRefresh;
     triggerHourlyCheck;
+    pipelineOrchestrator;
     constructor(deps) {
         this.db = deps.db;
         this.config = deps.config;
         this.eventBus = deps.eventBus;
-        this.contextBuilder = deps.contextBuilder;
-        this.agentRouter = deps.agentRouter;
         this.notificationMgr = deps.notificationMgr;
         this.todayWriteLock = deps.todayWriteLock;
-        this.prompt = deps.prompt;
-        this.errorRouter = deps.errorRouter;
-        this.resultProcessor = deps.resultProcessor;
         this.fetchWindowRunner = deps.fetchWindowRunner;
         this.setMorningRoutineInProgress = deps.setMorningRoutineInProgress;
         this.rotateDayFiles = deps.rotateDayFiles;
@@ -74,11 +83,19 @@ export class MorningRoutineRunner {
         this.isRoadmapStale = deps.isRoadmapStale;
         this.emitRoadmapRefresh = deps.emitRoadmapRefresh;
         this.triggerHourlyCheck = deps.triggerHourlyCheck;
+        this.pipelineOrchestrator = deps.pipelineOrchestrator;
     }
     /**
-     * Morning routine execution with pre-processing (lock, rotateDayFiles,
-     * prompt variant selection). Only called for routine === "morning_routine".
-     * Tier is resolved by BackendRouter from process-key defaults or user config.
+     * Morning routine execution with pre-processing (lock, rotateDayFiles).
+     * Only called for routine === "morning_routine".
+     *
+     * Variant collapse: both the recurring and first-run (no-yesterday)
+     * branches dispatch under the single `routine.morning_routine` process
+     * key. The merged task-flow lets the agent pick the first-run branch
+     * inline from the absence of `<yesterday>` in its prompt context, so
+     * tier / binding / cost-cap resolution is the same for both day-types.
+     * Tier is resolved by BackendRouter from process-key defaults or user
+     * config.
      */
     async executeMorningRoutine(event) {
         let lockId = null;
@@ -106,41 +123,23 @@ export class MorningRoutineRunner {
         this.rotateDayFiles();
         // Check roadmap staleness BEFORE agent runs (agent may PATCH roadmap, updating mtime)
         const roadmapStaleBeforeMorning = this.isRoadmapStale();
-        // Select prompt variant based on whether yesterday.md exists
-        const contextDir = getContextDir(this.config, this.db);
-        const hasYesterday = existsSync(join(contextDir, "yesterday.md"));
-        const promptKey = hasYesterday
-            ? "routine.morning_routine"
-            : "routine.morning_routine_initial";
-        // Retry runs on the light tier (Sonnet) instead of the configured heavy
-        // tier (Opus). Cost trade-off: a wrong-date or malformed today.md is
-        // cheap to regenerate — the heavy work (mail classification, journal
-        // synthesis, roadmap walk) was already done by the first attempt and its
-        // outputs persisted via /api/context/* writes that survive into the
-        // retry's prompt context. Sonnet at ~1/5 of Opus's per-turn cost keeps
-        // the worst-case retry chain (3 attempts) under $2 instead of $12,
-        // which is the cap the user asked for after observing $25/hour
-        // burn during a date-format loop. See morning-routine fix doc.
+        const promptKey = "routine.morning_routine";
+        // Retry runs on the medium tier (Sonnet) instead of any higher pin the
+        // operator may have configured. Cost trade-off: a wrong-date or
+        // malformed today.md is cheap to regenerate — the heavy work (mail
+        // classification, journal synthesis, roadmap walk) was already done by
+        // the first attempt and its outputs persisted via /api/context/* writes
+        // that survive into the retry's prompt context. Sonnet at ~1/5 of Opus's
+        // per-turn cost keeps the worst-case retry chain (3 attempts) under $2
+        // instead of $12, which is the cap the user asked for after observing
+        // $25/hour burn during a date-format loop. See morning-routine fix doc.
         const retryCount = Number(effectiveEvent.data?.retryCount ?? 0);
         const isRetry = retryCount > 0 || effectiveEvent.data?.isRetry === true;
-        let requestedTier = isRetry
+        const requestedTier = isRetry
             ? "medium"
             : undefined;
-        // `routine.morning_routine_initial` is non-configurable, so plan presets
-        // and operator pins on `routine.morning_routine` are silently ignored
-        // here without explicit inheritance — Max5/Max20/Team/Enterprise users
-        // pinned to Sonnet would still run Opus on the initial variant whenever
-        // `yesterday.md` is missing (cf. plan-presets.ts and process-key.ts §
-        // morning_routine_initial). Mirror morning_routine's configured tier
-        // onto the initial run when available.
-        if (!isRetry && promptKey === "routine.morning_routine_initial") {
-            const inheritedTier = this.inferConfiguredMorningRoutineTier();
-            if (inheritedTier) {
-                requestedTier = inheritedTier;
-            }
-        }
-        logger.info({ hasYesterday, promptKey, roadmapStale: roadmapStaleBeforeMorning, isRetry, retryCount, requestedTier: requestedTier ?? "default" }, "Morning routine prompt selected");
-        // B2 fix + ROUTINE_DATA_ACQUISITION_DESIGN.md Phase 4 / D2 race fix:
+        logger.info({ promptKey, roadmapStale: roadmapStaleBeforeMorning, isRetry, retryCount, requestedTier: requestedTier ?? "default" }, "Morning routine dispatch");
+        // B2 fix + docs/design/appendices/routine-data-acquisition.md Phase 4 / D2 race fix:
         // flip `morningRoutineInProgress=true` BEFORE the pre-pass fires so
         // hourly_check can't squeeze through the cold-start window
         // (`hourlyCheck.trigger` skips when `isMorningRoutineActive()`
@@ -152,9 +151,13 @@ export class MorningRoutineRunner {
         // context build, or main session throws — so a partial-failure path
         // cannot leave the flag stuck `true` and starve hourly_check forever.
         this.setMorningRoutineInProgress(true);
-        let result;
+        // `pipelineRun` is non-null when the orchestrator completed and
+        // Stage A produced an `AgentResult`. A null value means Stage A
+        // threw (caught below); we fall through to `diagnoseTodayMdState`
+        // which detects the missing today.md and schedules a retry.
+        let pipelineRun = null;
         try {
-            // ROUTINE_DATA_ACQUISITION_DESIGN.md Phase 4 / D2 — fire the
+            // docs/design/appendices/routine-data-acquisition.md Phase 4 / D2 — fire the
             // pre-pass fetcher session BEFORE we build the parent's context.
             // The fetcher POSTs to `/api/observations` so the parent's
             // `pending=true` reads see the fresh rows; the rendered
@@ -169,9 +172,7 @@ export class MorningRoutineRunner {
             // retry, observations posted by the original attempt are still
             // available (TTL is days; retries are minutes apart), and Haiku
             // tokens spent re-confirming the same window inflate the retry
-            // cost cap the user explicitly set. The morning_routine_initial
-            // path shares morning_routine's plan via the runner's automatic
-            // key derivation, so no special-casing is required there.
+            // cost cap the user explicitly set.
             const fetchPrepass = isRetry
                 ? null
                 : await this.fetchWindowRunner.run(effectiveEvent, promptKey);
@@ -184,113 +185,191 @@ export class MorningRoutineRunner {
                     },
                 };
             }
-            const context = await this.contextBuilder.build(effectiveEvent);
-            const binding = this.agentRouter.resolveBinding(effectiveEvent, {
-                processKey: promptKey,
-                ...(requestedTier ? { requestedTier } : {}),
-            });
-            const reassemblePrompt = (bid) => this.prompt.assemble(promptKey, promptKey, bid);
-            const prompt = reassemblePrompt(binding.main.backendId);
-            result = await this.errorRouter.executeWithRetry(() => this.agentRouter.execute({
-                prompt,
-                context,
-                event: effectiveEvent,
-                processKey: promptKey,
-                preResolvedBinding: binding,
-                reassemblePrompt,
-                ...(requestedTier ? { requestedTier } : {}),
-            }), effectiveEvent);
+            // Stage A medium + Stage B lite in parallel, with daemon-prepared
+            // `<handoff_parsed>` + `<journal_skeleton>` + `<roadmap_skeleton>`
+            // blocks injected into each stage's prompt context. Stage A's
+            // `AgentResult` (today.md synthesis) is what gates the post-run
+            // today.md health check; Stage B's result (journal author) lands
+            // in `pipelineRun.stageBResult` for the parent-audit row. Stage A
+            // throw propagates here; we catch, log, and let the post-execute
+            // `diagnoseTodayMdState` schedule a retry — same recovery shape
+            // as a Stage-A-internal failure.
+            try {
+                pipelineRun = await this.pipelineOrchestrator.run({
+                    parentEvent: effectiveEvent,
+                    isRetry,
+                    ...(requestedTier ? { requestedTier } : {}),
+                });
+            }
+            catch (err) {
+                logger.error({ err, promptKey, correlationId: effectiveEvent.correlationId }, "Morning pipeline orchestrator threw — falling through to today.md health check + retry");
+                pipelineRun = null;
+            }
         }
         finally {
-            this.setMorningRoutineInProgress(false);
+            // B3 fix: the today.md write-lock is released here (Stage B /
+            // journal / parent-audit do not touch today.md, so early release
+            // is safe), but `morningRoutineInProgress` is NOT cleared here.
+            // Clearing the flag before the authoritative
+            // `routine.morning_routine` success audit row is durable opens a
+            // window where, for a cron-triggered (non-wake) run, both
+            // `isMorningRoutineActive()` and `morningRoutineRanToday()` read
+            // false — an hourly_check tick would then take the
+            // `morning_routine_pending_for_today` branch and enqueue a
+            // spurious morning_routine wake. The flag is instead cleared in
+            // the post-finally try/finally below, AFTER the journal append +
+            // parent-audit emit, on every exit path.
             if (lockId && this.todayWriteLock) {
                 this.todayWriteLock.release(lockId);
             }
         }
-        await this.resultProcessor.processResult(result, effectiveEvent);
-        // Post-morning-routine: verify today.md was generated, retry if not.
-        // This catches agent failures that don't throw (e.g., early stop, context
-        // building succeeded but the PUT /api/context/today call was skipped).
-        //
-        // Distinguish the two failure modes so the operator can tell from the log
-        // whether the agent skipped the write entirely vs. wrote with the wrong
-        // agent-day date. Pre-fix, both paths logged the same "does not exist"
-        // string and the wrong-date case looked indistinguishable from a hard
-        // crash, masking the date-confusion root cause.
-        const todayMdState = this.diagnoseTodayMdState();
-        if (todayMdState.kind !== "fresh") {
-            logger.warn({
-                eventType: effectiveEvent.type,
-                isError: result.isError,
-                numTurns: result.numTurns,
-                todayMdState: todayMdState.kind,
-                ...(todayMdState.kind === "wrong_date"
-                    ? {
-                        writtenDate: todayMdState.writtenDate,
-                        expectedAgentDay: todayMdState.expectedAgentDay,
+        try {
+            // Per-stage `agent_actions` rows are written from inside
+            // `orchestrator.run()` (each stage runs through
+            // `resultProcessor.processResult(stageResult, stageEvent)` so each
+            // row lands with `action_type=routine.morning_routine_today` /
+            // `..._journal`). The parent `routine.morning_routine` audit row
+            // is synthesised below by `emitParentAuditRow` once Stage A success
+            // + today.md health are both confirmed — that is the row the
+            // pre-routine gate (`morningRoutineRanToday`) reads.
+            const stageAResult = pipelineRun !== null ? pipelineRun.stageAResult : null;
+            // Post-morning-routine: verify today.md was generated, retry if not.
+            // This catches agent failures that don't throw (e.g., early stop, context
+            // building succeeded but the PUT /api/context/today call was skipped).
+            //
+            // Distinguish the two failure modes so the operator can tell from the log
+            // whether the agent skipped the write entirely vs. wrote with the wrong
+            // agent-day date. Pre-fix, both paths logged the same "does not exist"
+            // string and the wrong-date case looked indistinguishable from a hard
+            // crash, masking the date-confusion root cause.
+            const todayMdState = this.diagnoseTodayMdState();
+            // Parent audit row emit. The pre-routine gate
+            // (`morningRoutineRanToday` in `bootstrap/schedule-helpers.ts`)
+            // selects on `action_type='routine.morning_routine' AND
+            // result='success'`. The two stages write their own action_types
+            // (`routine.morning_routine_today` / `..._journal`), neither of
+            // which the gate reads — so we synthesise the parent row here,
+            // gated on Stage A success + today.md health.
+            if (pipelineRun !== null) {
+                const todayMdHealth = mapDiagnoseToHealth(todayMdState);
+                // Land the `journal/agent.md` block BEFORE the parent-audit row
+                // emit so the gate-fire moment (which the dashboard / monitoring
+                // tooling reads as "morning routine is done") follows the journal
+                // write, not precedes it. The appender is self-gating on Stage A's
+                // row presence — it returns `stage_a_row_missing` (not throws)
+                // when the row is absent, so we just log the skip reason.
+                try {
+                    const appenderOutcome = await this.pipelineOrchestrator.appendAgentJournalEntry({
+                        correlationId: effectiveEvent.correlationId,
+                    });
+                    if (appenderOutcome === null) {
+                        logger.debug({ correlationId: effectiveEvent.correlationId }, "Morning pipeline journal appender skipped — orchestrator constructed without journal-side deps");
                     }
-                    : {}),
-            }, todayMdState.kind === "missing"
-                ? "Morning routine completed but today.md does not exist — scheduling retry"
-                : "Morning routine completed but today.md has wrong agent-day date — scheduling retry");
-            this.scheduleMorningRetry(effectiveEvent);
-        }
-        else {
-            if (effectiveEvent.data?.deferPostMorningCatchupsUntilStartupReady === true) {
-                logger.info({ eventType: effectiveEvent.type, source: effectiveEvent.source }, "Deferring post-morning catchups until startup messaging is ready");
-            }
-            else {
-                await this.emitPostMorningCatchups(effectiveEvent);
-            }
-            const todayRefreshFlush = flushPendingTodayRefresh(this.db);
-            if (todayRefreshFlush.hadPending) {
-                logger.info({ scheduled: todayRefreshFlush.scheduled }, "Flushed pending today_refresh after morning routine");
-            }
-        }
-        // Post-morning-routine: trigger roadmap refresh if STILL stale after
-        // the agent ran. Re-checking staleness here lets the
-        // `morning_routine_initial` variant populate roadmap.md inline (its
-        // Step 6.8 fully replaces the setup-wizard skeleton in the same
-        // session) without firing a redundant `routine.roadmap_refresh`
-        // afterwards — that doubled post-setup latency by ~1–2 minutes.
-        //
-        // The check is `staleBefore && staleNow`:
-        //   - regular variant on a fresh roadmap: staleBefore=false → skip (unchanged).
-        //   - either variant where agent did nothing to roadmap: still stale → emit.
-        //   - initial variant where agent populated inline: staleNow=false → skip.
-        //   - regular variant where agent happened to spot-update on a stale day:
-        //     staleNow=false → skip the redundant refresh (pure win).
-        if (roadmapStaleBeforeMorning) {
-            if (effectiveEvent.data?.deferPostMorningCatchupsUntilStartupReady === true) {
-                logger.info({ eventType: effectiveEvent.type, source: effectiveEvent.source }, "Deferring roadmap_refresh until startup messaging is ready");
+                    else if (appenderOutcome.ok) {
+                        logger.info({
+                            correlationId: effectiveEvent.correlationId,
+                            entryBytes: appenderOutcome.entryText.length,
+                        }, "Morning pipeline agent/journal.md entry appended");
+                    }
+                    else {
+                        logger.warn({
+                            correlationId: effectiveEvent.correlationId,
+                            reason: appenderOutcome.reason,
+                        }, "Morning pipeline agent/journal.md entry NOT appended");
+                    }
+                }
+                catch (err) {
+                    // Appender failures are best-effort telemetry — never block
+                    // the parent-audit emit / today.md health flow on a journal
+                    // write hiccup. The fs write is atomic + snapshot-backed; the
+                    // only realistic failure mode here is a malformed
+                    // `agent_actions.metadata` JSON that the composer mis-parses.
+                    logger.error({ err, correlationId: effectiveEvent.correlationId }, "Morning pipeline journal appender threw — continuing to parent-audit emit");
+                }
+                const emitOutcome = this.pipelineOrchestrator.emitParentAuditRow({
+                    correlationId: effectiveEvent.correlationId,
+                    startedAt: pipelineRun.startedAt,
+                    todayMdHealth,
+                    ...(stageAResult?.backendId ? { backend: stageAResult.backendId } : {}),
+                });
+                if (emitOutcome.emitted) {
+                    logger.info({
+                        correlationId: effectiveEvent.correlationId,
+                        parentAuditRowId: emitOutcome.insertedId,
+                        todayMdHealth,
+                        stageBPresent: pipelineRun.stageBResult !== null,
+                    }, "Morning pipeline parent audit row emitted");
+                }
+                else {
+                    logger.warn({
+                        correlationId: effectiveEvent.correlationId,
+                        reason: emitOutcome.reason,
+                        todayMdHealth,
+                    }, "Morning pipeline parent audit row NOT emitted — pre-routine gate will not fire for this run");
+                }
             }
-            else if (this.isRoadmapStale()) {
-                this.emitRoadmapRefresh("post_morning_routine");
+            if (todayMdState.kind !== "fresh") {
+                logger.warn({
+                    eventType: effectiveEvent.type,
+                    isError: stageAResult?.isError ?? null,
+                    numTurns: stageAResult?.numTurns ?? null,
+                    orchestratorThrew: pipelineRun === null,
+                    todayMdState: todayMdState.kind,
+                    ...(todayMdState.kind === "wrong_date"
+                        ? {
+                            writtenDate: todayMdState.writtenDate,
+                            expectedAgentDay: todayMdState.expectedAgentDay,
+                        }
+                        : {}),
+                }, todayMdState.kind === "missing"
+                    ? "Morning routine completed but today.md does not exist — scheduling retry"
+                    : "Morning routine completed but today.md has wrong agent-day date — scheduling retry");
+                this.scheduleMorningRetry(effectiveEvent);
             }
             else {
-                logger.info({ eventType: effectiveEvent.type, source: effectiveEvent.source, promptKey }, "Skipping post-morning roadmap_refresh — agent populated roadmap.md inline");
+                if (effectiveEvent.data?.deferPostMorningCatchupsUntilStartupReady === true) {
+                    logger.info({ eventType: effectiveEvent.type, source: effectiveEvent.source }, "Deferring post-morning catchups until startup messaging is ready");
+                }
+                else {
+                    await this.emitPostMorningCatchups(effectiveEvent);
+                }
+                const todayRefreshFlush = flushPendingTodayRefresh(this.db);
+                if (todayRefreshFlush.hadPending) {
+                    logger.info({ scheduled: todayRefreshFlush.scheduled }, "Flushed pending today_refresh after morning routine");
+                }
+            }
+            // Post-morning-routine: trigger roadmap refresh if STILL stale after
+            // the agent ran. Re-checking staleness here lets the first-run
+            // branch of the merged morning routine populate roadmap.md inline
+            // (its Step 6b fully replaces the setup-wizard skeleton in the same
+            // session) without firing a redundant `routine.roadmap_refresh`
+            // afterwards — that doubled post-setup latency by ~1–2 minutes.
+            //
+            // The check is `staleBefore && staleNow`:
+            //   - recurring day on a fresh roadmap: staleBefore=false → skip (unchanged).
+            //   - either branch where agent did nothing to roadmap: still stale → emit.
+            //   - first-run day where agent populated inline: staleNow=false → skip.
+            //   - recurring day where agent happened to spot-update on a stale day:
+            //     staleNow=false → skip the redundant refresh (pure win).
+            if (roadmapStaleBeforeMorning) {
+                if (effectiveEvent.data?.deferPostMorningCatchupsUntilStartupReady === true) {
+                    logger.info({ eventType: effectiveEvent.type, source: effectiveEvent.source }, "Deferring roadmap_refresh until startup messaging is ready");
+                }
+                else if (this.isRoadmapStale()) {
+                    this.emitRoadmapRefresh("post_morning_routine");
+                }
+                else {
+                    logger.info({ eventType: effectiveEvent.type, source: effectiveEvent.source, promptKey }, "Skipping post-morning roadmap_refresh — agent populated roadmap.md inline");
+                }
             }
         }
-    }
-    /**
-     * Read the operator-or-preset configured tier for `routine.morning_routine`
-     * so the non-configurable `morning_routine_initial` variant can mirror it.
-     * Returns null when no row exists (fresh install before the setup wizard
-     * applies a preset) or when the pinned model isn't in the registry — the
-     * caller falls back to the router's default tier in those cases.
-     */
-    inferConfiguredMorningRoutineTier() {
-        try {
-            const row = this.db
-                .prepare("SELECT main_backend, main_model FROM process_backend_config WHERE process_key = 'routine.morning_routine'")
-                .get();
-            if (!row || !isBackendId(row.main_backend))
-                return null;
-            return findRegisteredModel(row.main_backend, row.main_model)?.tier ?? null;
-        }
-        catch (err) {
-            logger.debug({ err }, "Failed to infer morning_routine configured tier");
-            return null;
+        finally {
+            // B3 fix: clear `morningRoutineInProgress` only AFTER the parent
+            // audit row is durable (journal append + emitParentAuditRow above).
+            // Reached on every post-finally exit path — success/catchup,
+            // retry-scheduled, and the `pipelineRun === null` branch — so a
+            // Stage-A failure cannot leak the flag and wedge hourly_check.
+            this.setMorningRoutineInProgress(false);
         }
     }
     async emitPostMorningCatchups(event) {
@@ -406,11 +485,15 @@ export class MorningRoutineRunner {
             if (existing) {
                 return { inserted: false, existingId: existing.id };
             }
+            const retryInstruction = `Morning routine retry (attempt ${retryCount}/${MAX_RETRIES}). Generate today.md per the morning_routine flow.`;
             this.db
                 .prepare(`INSERT INTO agent_schedule
-             (scheduled_for, task_type, task_description, task_context, correlation_id, model, status)
-           VALUES (?, 'wake', ?, ?, ?, NULL, 'pending')`)
-                .run(scheduledFor, `Morning routine retry (attempt ${retryCount}/${MAX_RETRIES}). Generate today.md per the morning_routine flow.`, taskContext, originalCorrelationId);
+             (scheduled_for, task_type, task_description, task_prompt, task_context, correlation_id, model, status)
+           VALUES (?, 'wake', ?, ?, ?, ?, NULL, 'pending')`)
+                .run(scheduledFor, 
+            // task_description (list label) and task_prompt (agent instruction)
+            // are the same string for this system-generated row.
+            retryInstruction, retryInstruction, taskContext, originalCorrelationId);
             return { inserted: true };
         });
         try {
@@ -446,4 +529,3 @@ export class MorningRoutineRunner {
         }
     }
 }
-//# sourceMappingURL=dispatcher-morning-routine.js.map