@aitne/daemon 0.1.8 → 0.1.9

package/dist/core/dispatcher-message-handler.js

@@ -45,6 +45,7 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { formatSqliteDatetime, isDocsQAMessage, isMessageEvent, parseSqliteUtcMs, resolveProcessKey, } from "@aitne/shared";
 import { getContextDir } from "../config.js";
+import { resolveUserSkillsRoot } from "./user-skills-root.js";
 import { getModelLabel } from "./backends/model-registry.js";
 import { parseGeminiAuthCode } from "./backends/auth-recovery.js";
 import { tryHandle as tryHandleBangCommand } from "./bang-commands/registry.js";
@@ -78,6 +79,8 @@ export class MessageHandler {
     getAuthRecovery;
     getAuthHealthMonitor;
     getBangCommandRegistry;
+    getPurchaseHandler;
+    getFinalConfirmHandler;
     getCurrentSetupMode;
     beginSetupMode;
     lookupCustomBangCommandForEvent;
@@ -110,6 +113,9 @@ export class MessageHandler {
         this.getAuthRecovery = deps.getAuthRecovery;
         this.getAuthHealthMonitor = deps.getAuthHealthMonitor;
         this.getBangCommandRegistry = deps.getBangCommandRegistry;
+        this.getPurchaseHandler = deps.getPurchaseHandler ?? (() => null);
+        this.getFinalConfirmHandler =
+            deps.getFinalConfirmHandler ?? (() => null);
         this.getCurrentSetupMode = deps.getCurrentSetupMode;
         this.beginSetupMode = deps.beginSetupMode;
         this.lookupCustomBangCommandForEvent = deps.lookupCustomBangCommandForEvent;
@@ -301,10 +307,141 @@ export class MessageHandler {
      * access test casts continue to work.
      */
     async handle(event) {
+        // MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §17.4 / §17.7 — Phase B-4
+        // structural-anti-spoofing inbound classifier. Runs BEFORE the
+        // bang-command interceptor (and BEFORE any inbound recording on
+        // `conversation_sessions.messages`) so a `!~xxxxxxxx` token reply,
+        // `!verify <tail>` slash, or `!cancel-purchase` slash NEVER reaches
+        // the LLM's conversation log. The plan §17.7 invariant — "the agent
+        // must not see used tokens in its conversation log" — is enforced
+        // structurally here: matched inbounds short-circuit `handle()`
+        // entirely after the purchase-handler records the audit row on
+        // `_replies` and emits the consume / verify / cancel follow-up DM.
+        //
+        // Pre-conditions:
+        //   - event.isDm — non-DM channels never carry tokens (§17.3 / §17.4)
+        //   - getPurchaseHandler() is non-null (false in tests; B-4 wired
+        //     at startup binds it)
+        //
+        // The classifier is pure (`classifyAdapterInbound`); the handler
+        // dispatch is async I/O (DB + outbound DM follow-up). On any
+        // exception the classifier falls through to normal processing —
+        // failing closed on the B-4 path could deadlock a legitimate user
+        // who happens to type a `!~`-shaped message that fails some
+        // downstream DB check, so we log + skip on error.
+        if (event.isDm) {
+            const purchaseHandler = this.getPurchaseHandler();
+            const finalConfirmHandler = this.getFinalConfirmHandler();
+            // BROWSER_TASK_REDESIGN_PLAN.md §14.11 Q#6 — jti-prefix dispatch.
+            // The `!~xxxxxxxx` envelope is shared between B-4 purchase tokens
+            // and lite-final-confirm tokens. A pending token of EITHER kind
+            // must consume the reply (and a non-token reply must strict-
+            // cancel pending tokens of EITHER kind on the channel). The
+            // route in code:
+            //
+            //   1. classifyAdapterInbound is purchase-specific by name but
+            //      the `kind === "token_reply"` case carries only the parsed
+            //      `!~xxxxxxxx` string — that envelope is identical across
+            //      both surfaces (see `lite-final-confirm-tokens.parseLite…`).
+            //      Reusing the classifier keeps the shape-validation logic
+            //      in one place.
+            //   2. For `verify` / `cancel_purchase` — purchase-only slashes,
+            //      no lite equivalent — route to the purchase handler when
+            //      wired.
+            //   3. For `token_reply` — query BOTH stores via `lookupByRaw`.
+            //      Both jtis are uuid v4 so a colliding match is bounded by
+            //      uuid uniqueness. If both stores miraculously return a row,
+            //      we route to whichever was issued first (oldest issuedAt
+            //      wins) so the older surface deterministically resolves.
+            //      Whichever store consumed the row writes the audit + DM
+            //      via its own handler.
+            //   4. For `passthrough` — fan strict-cancel-on-non-token-reply
+            //      to BOTH handlers when wired. Each only cancels pending
+            //      rows it knows about on that channel; together they
+            //      preserve the rev3 strict-cancel contract symmetrically.
+            if (purchaseHandler || finalConfirmHandler) {
+                try {
+                    const { classifyAdapterInbound } = await import("../services/browser-history/automation/purchase-tokens.js");
+                    const decision = classifyAdapterInbound(event.content);
+                    const channelRef = `${event.platform}:${event.channel}`;
+                    if (decision.kind === "token_reply") {
+                        const purchaseRow = purchaseHandler?.lookupByRaw(decision.token)
+                            ?? null;
+                        const liteRow = finalConfirmHandler?.lookupByRaw(decision.token)
+                            ?? null;
+                        const { decideTokenReplyRoute } = await import("./dm-token-router.js");
+                        const route = decideTokenReplyRoute({ purchaseRow, liteRow });
+                        if (route.kind === "purchase" && purchaseHandler) {
+                            await purchaseHandler.handleTokenReply({
+                                body: event.content,
+                                channelRef,
+                            });
+                            return;
+                        }
+                        if (route.kind === "lite_final_confirm" && finalConfirmHandler) {
+                            await finalConfirmHandler.handleTokenReply({
+                                body: event.content,
+                                channelRef,
+                            });
+                            return;
+                        }
+                        // route.kind === "none" — neither store recognised the
+                        // token. Fall through to the strict-cancel block below so
+                        // the user's reply still reaches the LLM and any pending
+                        // tokens on the channel get cancelled.
+                    }
+                    else if (decision.kind === "verify") {
+                        if (purchaseHandler) {
+                            await purchaseHandler.handleVerifySlash({
+                                tail: decision.tail,
+                                channelRef,
+                            });
+                        }
+                        // Purchase-only slash: short-circuit even when purchaseHandler
+                        // is unwired so it never enters the lite strict-cancel fan-out
+                        // below (verify/cancel have no lite equivalent — §12 Q#6).
+                        return;
+                    }
+                    else if (decision.kind === "cancel_purchase") {
+                        if (purchaseHandler) {
+                            await purchaseHandler.handleCancelPurchaseSlash({ channelRef });
+                        }
+                        // Purchase-only slash: short-circuit even when purchaseHandler
+                        // is unwired so it never enters the lite strict-cancel fan-out
+                        // below (verify/cancel have no lite equivalent — §12 Q#6).
+                        return;
+                    }
+                    // decision.kind === "passthrough" (or token_reply with no
+                    // match): apply strict-cancel-on-non-token-reply to BOTH
+                    // handlers when wired. Each handler only cancels pending
+                    // rows on the channel it knows about, so a single non-token
+                    // reply cancels tokens of either kind without the two paths
+                    // double-counting. The agent never sees the token surfaces
+                    // by design (§17.7).
+                    if (purchaseHandler) {
+                        await purchaseHandler
+                            .cancelPendingOnNonTokenReply({ channelRef })
+                            .catch((err) => {
+                            logger.warn({ err, channelRef }, "B-4 strict-cancel on non-token reply raised (continuing)");
+                        });
+                    }
+                    if (finalConfirmHandler) {
+                        await finalConfirmHandler
+                            .cancelPendingOnNonTokenReply({ channelRef })
+                            .catch((err) => {
+                            logger.warn({ err, channelRef }, "lite-final-confirm strict-cancel on non-token reply raised (continuing)");
+                        });
+                    }
+                }
+                catch (err) {
+                    logger.warn({ err, correlationId: event.correlationId, platform: event.platform }, "DM-token inbound classifier raised — falling through to normal dispatch");
+                }
+            }
+        }
         // Bang-command interceptor — runs first so `!stop` / `!cost` / `!report`
         // succeed even mid-setup, mid-auth-recovery, etc., and so non-bang DMs
         // received while the agent is paused short-circuit before reaching the
-        // backend (I-3). See docs/design/backlog/messaging-bang-commands.md §6.2.
+        // backend. See docs/design/backlog/messaging-bang-commands.md §6.2.
         const bangCommandRegistry = this.getBangCommandRegistry();
         if (bangCommandRegistry) {
             const handled = await tryHandleBangCommand(bangCommandRegistry, {
@@ -352,6 +489,9 @@ export class MessageHandler {
                 enqueueWikiEvent: async (wikiEvent) => {
                     await this.eventBus.put(wikiEvent);
                 },
+                enqueueBrowserResearchEvent: async (researchEvent) => {
+                    await this.eventBus.put(researchEvent);
+                },
                 enqueueWikiApproval: async (approvalInput) => {
                     // WIKI_BUILDER_DESIGN.md §5.5 / §P2.E — escalate to Approve tier
                     // via the existing agent_schedule approval queue. The dashboard
@@ -749,7 +889,7 @@ export class MessageHandler {
                 // Sync user-authored skills into the workdir before resuming, so any
                 // skill added/edited/deleted via /api/skills since the last turn is
                 // visible to the SDK's `.claude/skills/` discovery. Cheap and idempotent.
-                syncAllUserSkills(sessionDir, join(this.config.dataDir, "skills"));
+                syncAllUserSkills(sessionDir, resolveUserSkillsRoot(this.config));
                 // Phase 1 — stage inbound attachments + bind rows + append
                 // bracketed prompt block. For resume we can't prepend to the
                 // task-flow template (there isn't one on this path), so the
@@ -767,7 +907,7 @@ export class MessageHandler {
                     });
                 }
                 const resumeTranscripts = await this.prompt.transcribeAttachments(resumeStaged);
-                // P2-13: surface adapter-reported missing attachments (e.g. expired
+                // Surface adapter-reported missing attachments (e.g. expired
                 // Discord CDN URLs) so the agent sees a stub describing the file
                 // even when the bytes were unreachable.
                 const resumeMissing = isMessageEvent(event)
@@ -784,7 +924,7 @@ export class MessageHandler {
                         id: row.id,
                         safeFilename: row.safeFilename,
                         mimeType: row.mimeType,
-                        absolutePath: `${sessionDir}/_attachments/${row.safeFilename}`,
+                        absolutePath: join(sessionDir, "_attachments", row.safeFilename),
                         relativePath: `_attachments/${row.safeFilename}`,
                     }))
                     : [];
@@ -895,7 +1035,7 @@ export class MessageHandler {
                 // wouldn't discover it. The sync is a cheap diff operation backed by
                 // a manifest file inside the workdir.
                 if (sessionDir) {
-                    syncAllUserSkills(sessionDir, join(this.config.dataDir, "skills"));
+                    syncAllUserSkills(sessionDir, resolveUserSkillsRoot(this.config));
                 }
                 // Docs-QA sessions are stateless lookups (DOCS_QA_B7_DESIGN.md
                 // §11.6 — "QA panel state lives in React state, not the DB").
@@ -952,7 +1092,7 @@ export class MessageHandler {
                         id: row.id,
                         safeFilename: row.safeFilename,
                         mimeType: row.mimeType,
-                        absolutePath: `${sessionDir}/_attachments/${row.safeFilename}`,
+                        absolutePath: join(sessionDir, "_attachments", row.safeFilename),
                         relativePath: `_attachments/${row.safeFilename}`,
                     }))
                     : [];
@@ -1179,4 +1319,3 @@ export class MessageHandler {
         };
     }
 }
-//# sourceMappingURL=dispatcher-message-handler.js.map

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

@@ -174,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

@@ -207,148 +207,169 @@ export class MorningRoutineRunner {
             }
         }
         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);
             }
         }
-        // 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 `agent/journal.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 = this.pipelineOrchestrator.appendAgentJournalEntry({
+        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");
+                    }
+                    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 (appenderOutcome === null) {
-                    logger.debug({ correlationId: effectiveEvent.correlationId }, "Morning pipeline journal appender skipped — orchestrator constructed without journal-side deps");
-                }
-                else if (appenderOutcome.ok) {
+                if (emitOutcome.emitted) {
                     logger.info({
                         correlationId: effectiveEvent.correlationId,
-                        entryBytes: appenderOutcome.entryText.length,
-                    }, "Morning pipeline agent/journal.md entry appended");
+                        parentAuditRowId: emitOutcome.insertedId,
+                        todayMdHealth,
+                        stageBPresent: pipelineRun.stageBResult !== null,
+                    }, "Morning pipeline parent audit row emitted");
                 }
                 else {
                     logger.warn({
                         correlationId: effectiveEvent.correlationId,
-                        reason: appenderOutcome.reason,
-                    }, "Morning pipeline agent/journal.md entry NOT appended");
+                        reason: emitOutcome.reason,
+                        todayMdHealth,
+                    }, "Morning pipeline parent audit row NOT emitted — pre-routine gate will not fire for this run");
                 }
             }
-            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 {
+            if (todayMdState.kind !== "fresh") {
                 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");
-            }
-        }
-        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 {
-            if (effectiveEvent.data?.deferPostMorningCatchupsUntilStartupReady === true) {
-                logger.info({ eventType: effectiveEvent.type, source: effectiveEvent.source }, "Deferring post-morning catchups until startup messaging is ready");
+                    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 {
-                await this.emitPostMorningCatchups(effectiveEvent);
+                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");
+                }
             }
-            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");
+                }
             }
         }
-        // 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");
-            }
+        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) {
@@ -464,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 {
@@ -504,4 +529,3 @@ export class MorningRoutineRunner {
         }
     }
 }
-//# sourceMappingURL=dispatcher-morning-routine.js.map

package/dist/core/dispatcher-prompt.d.ts

@@ -107,4 +107,3 @@ export declare class PromptAssembler {
         missingReason?: string;
     }>): string;
 }
-//# sourceMappingURL=dispatcher-prompt.d.ts.map

package/dist/core/dispatcher-prompt.js

@@ -69,7 +69,7 @@ export class PromptAssembler {
         if (!contextDir) {
             return base;
         }
-        // B-003 Phase 3 — the `rules/mcp.md` PolicyFileRef is registered with
+        // B-003 Phase 3 — the `policies/mcp.md` PolicyFileRef is registered with
         // `injectIf: ctx.flags?.mcpEnabled === true`. Compute the flag here so
         // every dispatch path (DM, routine, scheduled task, fallback reassembly)
         // injects the policy without each call site having to remember it.
@@ -133,8 +133,8 @@ export class PromptAssembler {
             return [];
         const staged = [];
         for (const ref of event.attachments) {
-            // P2-13: skip adapter-marked missing refs — they have no underlying
-            // row to stage, just metadata for the prompt builder.
+            // Skip adapter-marked missing refs — they have no underlying row
+            // to stage, just metadata for the prompt builder.
             if (ref.missing)
                 continue;
             const row = attachmentStore.get(ref.id);
@@ -225,7 +225,7 @@ export class PromptAssembler {
             }
         }
         if (missing.length > 0) {
-            // P2-13: adapter-reported attachments that couldn't be ingested
+            // Adapter-reported attachments that couldn't be ingested
             // (e.g. Discord CDN URL expired on a stale message). The agent
             // can't see the bytes but should still acknowledge them and ask
             // the user to resend rather than pretending nothing was attached.
@@ -240,4 +240,3 @@ export class PromptAssembler {
         return lines.join("\n");
     }
 }
-//# sourceMappingURL=dispatcher-prompt.js.map

package/dist/core/dispatcher-repository-helpers.d.ts

@@ -36,4 +36,3 @@ export declare function safeRepositoryRunDirName(slug: string): string;
 export declare function parseGithubRepoSlug(value: string | null): [string | null, string | null];
 export declare function normalizeRepositoryClassification(value: unknown): RepositoryDTO["classification"];
 export declare function normalizeRepositoryCategory(value: unknown): RepositoryDTO["category"];
-//# sourceMappingURL=dispatcher-repository-helpers.d.ts.map

package/dist/core/dispatcher-repository-helpers.js

@@ -87,4 +87,3 @@ export function normalizeRepositoryCategory(value) {
         ? value
         : "other";
 }
-//# sourceMappingURL=dispatcher-repository-helpers.js.map