@aitne/daemon 0.1.7 → 0.1.9

package/dist/core/morning/roadmap-skeleton-builder.js

@@ -0,0 +1,337 @@
+/**
+ * `buildRoadmapSkeleton` + `gatherRoadmapSkeletonFacts` — assemble the
+ * `<roadmap_skeleton>` MD body that the morning-routine orchestrator
+ * injects into Stage A's prompt on the **first-run** (no-yesterday)
+ * branch.
+ *
+ * Why this exists — `docs/design/appendices/morning-routine-optimization.md`
+ * retires `routine.morning_routine_initial`'s high-tier session.
+ * On the first run after setup, the wizard-installed `roadmap.md`
+ * carries only the `_(Not yet configured)_` placeholder rows. The
+ * legacy initial routine spent a high-tier (Opus) cold-start session
+ * regenerating every section from scratch — read management rules,
+ * survey active projects, scan calendar, query travel bookings, then
+ * compose the markdown. That last step is template assembly and is
+ * what justified the tier upgrade. By doing the deterministic data
+ * gather here and emitting a pre-shaped `<roadmap_skeleton>` block,
+ * Stage A on medium tier can spot-edit the skeleton into
+ * `roadmap.md` via the same `PATCH` paths the recurring branch uses —
+ * collapsing the variant into a single medium-tier flow.
+ *
+ * The skeleton is **scratch data**. Stage A is the only writer of
+ * `roadmap.md`; the skeleton's role is to amortize the "what should I
+ * even put in `## Annual Goals` / `## Quarterly Focus` / `## Preparation
+ * Timeline`" research over a deterministic SQL+fs pass instead of a
+ * judgment-heavy turn. Stage A may reshape, prune, or reword every
+ * section before its `PUT /api/context/roadmap`. There is no
+ * byte-for-byte preservation contract — unlike the journal skeleton —
+ * because `roadmap.md` is daemon-tracked but has no per-field
+ * validator, and Stage A's judgement (active vs. archived projects,
+ * which calendar events count as preparation, which travel rows are
+ * still relevant) is the load-bearing reason this stays on medium tier.
+ *
+ * Gating: the orchestrator only computes the skeleton when
+ * `yesterday.md` is absent (the first-run signal). The recurring
+ * branch leaves `<roadmap_skeleton>` absent and Stage A falls back to
+ * the truncated `<roadmap>` block ContextBuilder injects today; this is
+ * exactly how the variant collapse is supposed to read.
+ *
+ * Two-layer design mirrors `journal-skeleton-builder.ts`:
+ *   - `gatherRoadmapSkeletonFacts(db, contextDir, ...)` — runs SQLite
+ *     aggregations against `travel_bookings`, walks `context/projects/`
+ *     for active project frontmatter, parses `policies/management.md`
+ *     for the operator-declared goals block, and pulls 7-day calendar
+ *     events for the `## Quarterly Focus` synthesis hints. Pure
+ *     read-only, idempotent.
+ *   - `buildRoadmapSkeleton(inputs, facts)` — pure markdown composer
+ *     that emits one section per roadmap.md heading the template
+ *     expects.
+ *
+ * The split keeps the I/O-bound queries testable independently and
+ * lets the pure builder be exercised with synthesized fixtures.
+ */
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Source paths consumed by `gatherRoadmapSkeletonFacts`. All paths are
+ * relative to the daemon's `contextDir`. Centralised here so test
+ * harnesses can substitute the directory without re-implementing the
+ * fs walk.
+ */
+const PROJECTS_REL = "plans/projects";
+const MANAGEMENT_RULES_REL = "policies/management.md";
+/**
+ * Run the SQLite + fs aggregations that feed the skeleton. Pure
+ * read-only; callers own the timezone math (`todayDateStr` is the
+ * filter the `start_date >= ?` predicate joins against).
+ *
+ * `contextDir` must point at the daemon's runtime context directory
+ * (e.g. `~/.personal-agent/context`). Missing files are silent-skipped
+ * — the skeleton renders explicit placeholders so the failure mode is
+ * "Stage A sees an empty section" rather than "Stage A sees no
+ * skeleton at all", which is what the variant collapse depends on.
+ */
+export function gatherRoadmapSkeletonFacts(db, contextDir, todayDateStr) {
+    const activeProjects = readActiveProjects(contextDir);
+    const annualGoals = readAnnualGoals(contextDir);
+    const upcomingTravel = readUpcomingTravel(db, todayDateStr);
+    return { activeProjects, annualGoals, upcomingTravel };
+}
+/**
+ * Compose the `<roadmap_skeleton>` MD body. Pure — every output byte is
+ * a deterministic function of `inputs` + `facts`. Stage A reads this as
+ * scratch input and authors `roadmap.md` per the operator-visible
+ * template (`## Annual Goals` / `## Quarterly Focus` /
+ * `## Preparation Timeline` / `## Agent Action Plan`).
+ *
+ * The composer NEVER emits the `## Agent Action Plan` section — that
+ * is operationally tightly coupled to today's User Tasks + roadmap-
+ * relevant `agent_schedule` rows, both of which Stage A enumerates
+ * inside its own turn from the live observations table. Including a
+ * stale skeleton plan would invite Stage A to copy it verbatim and
+ * mask schedule-fan-out drift.
+ */
+export function buildRoadmapSkeleton(inputs, facts) {
+    const lines = [];
+    const tzLabel = inputs.timezone ?? "system";
+    lines.push("<!-- Stage A: this is daemon-prepared scratch data.");
+    lines.push("     Reshape, prune, or reword before PUT /api/context/roadmap.");
+    lines.push(`     Calendar dates are in ${tzLabel}; today is ${inputs.todayDateStr}.`);
+    lines.push("     No byte-for-byte preservation contract — author per the");
+    lines.push("     roadmap.md operator template. -->");
+    lines.push("");
+    appendAnnualGoalsSection(lines, facts.annualGoals);
+    appendQuarterlyFocusSection(lines, facts, inputs.calendarEvents);
+    appendPreparationTimelineSection(lines, facts.upcomingTravel, inputs.calendarEvents);
+    return lines.join("\n");
+}
+// ── Section emitters ───────────────────────────────────────────────────────
+function appendAnnualGoalsSection(out, goals) {
+    out.push("## Annual Goals");
+    if (goals.length === 0) {
+        out.push("_(Not yet configured — rules/management.md has no `## Annual Goals` section. Stage A: read `<management_rules>` for intent or leave the placeholder for the operator to fill.)_");
+    }
+    else {
+        for (const goal of goals) {
+            out.push(`- ${goal}`);
+        }
+    }
+    out.push("");
+}
+function appendQuarterlyFocusSection(out, facts, calendarEvents) {
+    out.push("## Quarterly Focus");
+    if (facts.activeProjects.length === 0 && calendarEvents.length === 0) {
+        out.push("_(Not yet configured — no active projects under context/projects/ and no calendar events in the next 7 days.)_");
+        out.push("");
+        return;
+    }
+    if (facts.activeProjects.length > 0) {
+        out.push("### Active projects");
+        for (const project of facts.activeProjects) {
+            const parts = [`state: ${project.state}`];
+            if (project.nextMilestone)
+                parts.push(`next: ${project.nextMilestone}`);
+            if (project.due)
+                parts.push(`due: ${project.due}`);
+            out.push(`- ${project.title} (\`${project.slug}\`) — ${parts.join("; ")}`);
+        }
+        out.push("");
+    }
+    if (calendarEvents.length > 0) {
+        out.push("### Near-term calendar (7d)");
+        for (const event of calendarEvents) {
+            const title = event.title.trim().length === 0 ? "(untitled)" : event.title.trim();
+            out.push(`- ${event.date} — ${title}`);
+        }
+        out.push("");
+    }
+}
+function appendPreparationTimelineSection(out, travel, calendarEvents) {
+    out.push("## Preparation Timeline");
+    if (travel.length === 0 && calendarEvents.length === 0) {
+        out.push("_(Not yet configured — no upcoming travel_bookings and no calendar events in the next 7 days.)_");
+        out.push("");
+        return;
+    }
+    if (travel.length > 0) {
+        out.push("### Travel");
+        for (const row of travel) {
+            const dest = row.destination?.trim().length ? row.destination.trim() : "(destination tbd)";
+            const span = formatTravelSpan(row.startDate, row.endDate);
+            const statusSuffix = row.status && row.status !== "upcoming" ? ` [${row.status}]` : "";
+            out.push(`- ${span} — ${row.type}: ${dest}${statusSuffix}`);
+        }
+        out.push("");
+    }
+    if (calendarEvents.length > 0) {
+        out.push("### Calendar (7d)");
+        for (const event of calendarEvents) {
+            const title = event.title.trim().length === 0 ? "(untitled)" : event.title.trim();
+            out.push(`- ${event.date} — ${title}`);
+        }
+        out.push("");
+    }
+}
+function formatTravelSpan(startDate, endDate) {
+    if (startDate && endDate && startDate !== endDate) {
+        return `${startDate} → ${endDate}`;
+    }
+    if (startDate)
+        return startDate;
+    if (endDate)
+        return endDate;
+    return "(dates tbd)";
+}
+// ── fs / SQL readers ───────────────────────────────────────────────────────
+function readActiveProjects(contextDir) {
+    const projectsDir = join(contextDir, PROJECTS_REL);
+    if (!existsSync(projectsDir))
+        return [];
+    let entries;
+    try {
+        entries = readdirSync(projectsDir);
+    }
+    catch {
+        return [];
+    }
+    const summaries = [];
+    for (const name of entries) {
+        if (!name.endsWith(".md"))
+            continue;
+        if (name.startsWith("_"))
+            continue;
+        const full = join(projectsDir, name);
+        let body;
+        try {
+            body = readFileSync(full, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        const project = summarizeProject(name, body);
+        if (project === null)
+            continue;
+        if (project.state === "archived")
+            continue;
+        summaries.push(project);
+    }
+    summaries.sort((a, b) => {
+        const aDue = a.due ?? "9999-12-31";
+        const bDue = b.due ?? "9999-12-31";
+        if (aDue !== bDue)
+            return aDue.localeCompare(bDue);
+        return a.slug.localeCompare(b.slug);
+    });
+    return summaries;
+}
+function summarizeProject(filename, content) {
+    const slug = filename.replace(/\.md$/, "");
+    const { frontmatter, body } = splitFrontmatter(content);
+    const state = readFrontmatterScalar(frontmatter, "state") ?? "active";
+    const title = body.match(/^#\s+(.+)$/m)?.[1]?.trim() || slug;
+    return {
+        slug,
+        title,
+        state,
+        due: readFrontmatterScalar(frontmatter, "due"),
+        nextMilestone: readFrontmatterScalar(frontmatter, "next_milestone"),
+    };
+}
+function readAnnualGoals(contextDir) {
+    const path = join(contextDir, MANAGEMENT_RULES_REL);
+    if (!existsSync(path))
+        return [];
+    let body;
+    try {
+        body = readFileSync(path, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    return extractAnnualGoals(body);
+}
+/**
+ * Pull bullet entries under the first `## Annual Goals` heading. Stops
+ * at the next `## ` heading or end-of-file. Bullets are returned with
+ * the `- ` / `* ` marker stripped and surrounding whitespace trimmed.
+ *
+ * Exported for unit testing only.
+ */
+export function extractAnnualGoals(rulesBody) {
+    const lines = rulesBody.split(/\r?\n/);
+    const out = [];
+    let inside = false;
+    for (const raw of lines) {
+        if (/^##\s+Annual Goals\b/i.test(raw)) {
+            inside = true;
+            continue;
+        }
+        if (!inside)
+            continue;
+        if (/^##\s+/.test(raw))
+            break;
+        const bullet = raw.match(/^\s*[-*]\s+(.+?)\s*$/);
+        if (bullet) {
+            const text = bullet[1].trim();
+            if (text.length > 0)
+                out.push(text);
+        }
+    }
+    return out;
+}
+function readUpcomingTravel(db, todayDateStr) {
+    let rows;
+    try {
+        rows = db
+            .prepare(`SELECT type, destination, start_date, end_date, status
+           FROM travel_bookings
+          WHERE start_date IS NOT NULL
+            AND start_date >= ?
+            AND COALESCE(status, 'upcoming') != 'cancelled'
+          ORDER BY start_date ASC, id ASC
+          LIMIT 20`)
+            .all(todayDateStr);
+    }
+    catch {
+        // The table existed since v4.x but bench / first-launch installs may
+        // not have it; treat the schema gap the same way a row count of 0
+        // is treated — silent skip, skeleton renders the placeholder.
+        return [];
+    }
+    return rows.map((r) => ({
+        type: r.type,
+        destination: r.destination,
+        startDate: r.start_date,
+        endDate: r.end_date,
+        status: r.status,
+    }));
+}
+// ── shared frontmatter helpers ─────────────────────────────────────────────
+//
+// Re-implemented here (rather than imported from context-builder) so the
+// morning-routine modules stay decoupled from the dispatcher's ContextBuilder
+// — the only consumers of those helpers in context-builder are private to
+// the file and not exported. Keeping this layer thin keeps the variant-
+// collapse path self-contained.
+function splitFrontmatter(content) {
+    if (!content.startsWith("---\n")) {
+        return { frontmatter: "", body: content };
+    }
+    const endIdx = content.indexOf("\n---", 4);
+    if (endIdx < 0) {
+        return { frontmatter: "", body: content };
+    }
+    return {
+        frontmatter: content.slice(4, endIdx),
+        body: content.slice(endIdx + 4).replace(/^\n+/, ""),
+    };
+}
+function readFrontmatterScalar(frontmatter, key) {
+    if (!frontmatter)
+        return null;
+    const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const match = frontmatter.match(new RegExp(`^${escapedKey}:\\s*(.+)$`, "m"));
+    if (!match)
+        return null;
+    return match[1].trim().replace(/^['"]|['"]$/g, "");
+}

package/dist/core/output-language-policy.d.ts

@@ -71,4 +71,3 @@ export declare function applyOutputLanguagePointerRewrite(content: string): stri
  * mid-session. See design §13.4 / §13.5.
  */
 export declare function renderOutputLanguagePolicyPointer(): string;
-//# sourceMappingURL=output-language-policy.d.ts.map

package/dist/core/output-language-policy.js

@@ -63,17 +63,17 @@ export function renderOutputLanguagePolicyBlock(primaryLanguage) {
         "      (Identity, Work Pattern, Annual Goals, etc.) — keep English so",
         "      parsers (management-md, profile-importer, journal readers) keep",
         "      working",
-        "    - YAML frontmatter keys, wiki-link targets ([[user/profile]]),",
+        "    - YAML frontmatter keys, wiki-link targets ([[identity/profile]]),",
         "      file paths, tool names, identifiers, env vars",
         "    - Fenced code blocks, JSON, CLI commands, URLs",
-        "    - The agent journal (agent/journal.md is English by",
-        "      rules/journal-format.md)",
-        "    - rules/*.md files (management, redaction, mcp, policies) — these",
-        "      are a structured registry, not prose",
+        "    - The agent journal (journal/agent.md is English by",
+        "      policies/journal-format.md)",
+        "    - policies/*.md files (management, redaction, mcp, management-captures)",
+        "      — these are a structured registry, not prose",
         "",
         "  User-customized headers win:",
         "    - If the running file already uses a translated header (e.g.",
-        `      "## アイデンティティ"), preserve it and write content under it;`,
+        `      "## Identidad"), preserve it and write content under it;`,
         "      do not revert to the English template header",
         "",
         "  Skeleton precedence:",
@@ -185,10 +185,9 @@ export function renderOutputLanguagePolicyPointer() {
         "  or the turn is system-initiated. Character block (tone, formality,",
         "  emoji) overrides locale defaults.",
         "- **Agent-internal surfaces** (this file, skill bodies, the agent",
-        "  journal, API/log/audit, `rules/*.md` registry) → English. Always.",
+        "  journal, API/log/audit, `policies/*.md` registry) → English. Always.",
         "",
         "See `docs/design/appendices/output-language-policy.md` for the full",
         "rule and policy taxonomy.",
     ].join("\n");
 }
-//# sourceMappingURL=output-language-policy.js.map

package/dist/core/overview-write-lock.d.ts

@@ -45,4 +45,3 @@
 export declare function withOverviewWriteLock<T>(path: string, fn: () => T | Promise<T>): Promise<T>;
 /** Test-only: drop all queued work. Never call from production code. */
 export declare function _resetOverviewWriteLocksForTests(): void;
-//# sourceMappingURL=overview-write-lock.d.ts.map

package/dist/core/overview-write-lock.js

@@ -53,4 +53,3 @@ export async function withOverviewWriteLock(path, fn) {
 export function _resetOverviewWriteLocksForTests() {
     tails.clear();
 }
-//# sourceMappingURL=overview-write-lock.js.map

package/dist/core/path-compat.d.ts

@@ -19,4 +19,3 @@ export declare function shellPathForms(absPath: string, homeDir: string): string
  * Windows backslashes are doubled.
  */
 export declare function jsonStringPathForms(forms: string[]): string[];
-//# sourceMappingURL=path-compat.d.ts.map

package/dist/core/path-compat.js

@@ -64,4 +64,3 @@ export function shellPathForms(absPath, homeDir) {
 export function jsonStringPathForms(forms) {
     return unique(forms.map((form) => JSON.stringify(form).slice(1, -1)));
 }
-//# sourceMappingURL=path-compat.js.map

package/dist/core/path-rewrite.d.ts

@@ -13,7 +13,7 @@ import type Database from "better-sqlite3";
  *     watcher writes external-vault paths (not rewritten here), but other
  *     producers may write primary-context paths.
  *   - `md_file_snapshots.file_path` — logical keys like `today`,
- *     `rules/management`. Already relative; NOT rewritten (left as-is).
+ *     `rules/management`. Already relative; NOT rewritten (left as-is). // drift-allow
  *   - `messages.metadata` — currently unused at runtime but open-ended;
  *     generic walk for defense in depth.
  *   - `receipts.obsidian_path` — external vault relative path. NOT
@@ -55,4 +55,3 @@ export declare function rewriteJsonPaths(value: unknown, oldPrefix: string, newP
  */
 export declare function rewritePathsInDb(db: Database.Database, oldPrefix: string, newPrefix: string, targets?: RewriteTarget[]): RewriteStats;
 export {};
-//# sourceMappingURL=path-rewrite.d.ts.map

package/dist/core/path-rewrite.js

@@ -138,4 +138,3 @@ export function rewritePathsInDb(db, oldPrefix, newPrefix, targets = DEFAULT_TAR
     logger.info({ oldPrefix, newPrefix, stats }, "rewritePathsInDb complete");
     return stats;
 }
-//# sourceMappingURL=path-rewrite.js.map

package/dist/core/policy-files.d.ts

@@ -1,9 +1,9 @@
 /**
  * Per-file byte cap. Files larger than this are skipped with a warning —
- * a user who accidentally pastes a 50MB transcript into rules/management.md
- * should not silently blow up prompt assembly. 32KB is comfortably above
- * the size of any realistic policy file (the largest templates under
- * `agent-assets/templates/` are under 4KB).
+ * a user who accidentally pastes a 50MB transcript into
+ * policies/management.md should not silently blow up prompt assembly. 32KB
+ * is comfortably above the size of any realistic policy file (the largest
+ * templates under `agent-assets/templates/` are under 4KB).
  */
 export declare const POLICY_FILE_MAX_BYTES: number;
 /**
@@ -28,13 +28,12 @@ export declare function createPromptInjectionBudget(maxBytes?: number): PromptIn
  * A "policy file" is a natural-language rulebook stored in the vault that
  * the agent should read when executing a particular ProcessKey. Examples:
  *
- *   - `rules/management.md` — Source of Truth bindings (all flows)
- *   - `rules/mcp.md` — MCP usage rules (B-003; inject when any MCP enabled)
- *   - `rules/journal-format.md` — daily journal format (morning routine)
- *   - `rules/redaction.md` — secret patterns (all flows)
- *   - `routines/hourly.md` — hourly check list
- *   - `routines/morning.md` — 04:00 checks (morning routine)
- *   - `routines/custom/<slug>.md` — per-custom-routine check list
+ *   - `policies/mcp.md` — MCP usage rules (B-003; inject when any MCP enabled)
+ *   - `policies/journal-format.md` — daily journal format (morning routine)
+ *   - `policies/redaction.md` — secret patterns (all flows)
+ *   - `policies/routines/hourly.md` — hourly check list
+ *   - `policies/routines/morning.md` — 04:00 checks (morning routine)
+ *   - `policies/routines/custom/<slug>.md` — per-custom-routine check list
  *
  * `appendPolicyBlocks` resolves the set of policy files relevant to a
  * ProcessKey, reads each from the runtime context dir, and returns a
@@ -43,9 +42,25 @@ export declare function createPromptInjectionBudget(maxBytes?: number): PromptIn
  * Phase 1 provides the module. Phase 2 wires it into `prompts.ts` at
  * task-flow assembly time. Phase 3 layers morning-routine-specific blocks
  * on top (journal-format + journal-export).
+ *
+ * Note: `policies/management.md` is NOT in this registry — `ContextBuilder`
+ * injects it once at the top of every session prompt as the
+ * `<management_rules>` block (see `context-builder.ts`). Task-flows
+ * (`routine.morning_routine.md`, `setup.update.md`, …) reference that
+ * XML tag directly, so the authoritative injection path lives there.
+ *
+ * Re-emitting it through `appendPolicyBlocks` (the pre-2026-05-15
+ * shape; see `docs/design/21-management-registry-and-entities.md` §0.2
+ * historical note) was a pure duplicate that (a) doubled the
+ * SoT-bindings text in every prompt, and (b) consumed a slot from the
+ * shared `POLICY_TOTAL_MAX_BYTES` budget that other registry files
+ * (mcp.md, journal-format.md, journal-export.md, …) need to fit
+ * under. The per-file 32 KB cap that previously guarded against a
+ * runaway management.md was ported to `ContextBuilder` so NFR-1b's
+ * safety contract is preserved.
  */
 export interface PolicyFileRef {
-    /** Relative path under contextDir, e.g. `rules/management.md`. */
+    /** Relative path under contextDir, e.g. `policies/management.md`. */
     path: string;
     /** Short label used in the rendered block header. */
     label: string;
@@ -68,6 +83,18 @@ export declare const POLICY_FILE_REGISTRY: Record<string, PolicyFileRef[]>;
  * Pull the set of policy refs for a processKey. Process-specific entries
  * are appended to the global `*` set. Custom routines (keys starting with
  * `routine.custom.`) resolve to their slugged file automatically.
+ *
+ * Whether the `*` merge applies is decided by
+ * `injection-policy.ts:getInjectionPolicy(processKey).policyFileGlobalMerge`
+ * (v4.2 V20 consolidation). The legacy `POLICY_KEY_GLOBAL_OPTOUT` set
+ * that used to live here was retired in favour of that single table —
+ * see `injection-policy.ts` for the architectural rationale.
+ *
+ * Stage B (`routine.morning_routine_journal`) is currently the only
+ * process key with `policyFileGlobalMerge=false`; its
+ * `POLICY_FILE_REGISTRY` row above re-declares `policies/redaction.md`
+ * inline so the lite-tier journal author still respects redaction even
+ * after opting out of the `*` merge.
  */
 export declare function resolvePolicyRefs(processKey: string): PolicyFileRef[];
 export interface AppendPolicyBlocksOptions {
@@ -105,4 +132,3 @@ export declare function loadPolicyBlocks(opts: AppendPolicyBlocksOptions): Polic
  */
 export declare function renderPolicyBlocks(blocks: PolicyBlock[]): string;
 export declare function appendPolicyBlocks(basePrompt: string, opts: AppendPolicyBlocksOptions): string;
-//# sourceMappingURL=policy-files.d.ts.map

package/dist/core/policy-files.js

@@ -1,14 +1,15 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { CONTEXT_RELATIVE_PATHS } from "./context-paths.js";
+import { getInjectionPolicy } from "./injection-policy.js";
 import { createLogger } from "../logging.js";
 const logger = createLogger("policy-files");
 /**
  * Per-file byte cap. Files larger than this are skipped with a warning —
- * a user who accidentally pastes a 50MB transcript into rules/management.md
- * should not silently blow up prompt assembly. 32KB is comfortably above
- * the size of any realistic policy file (the largest templates under
- * `agent-assets/templates/` are under 4KB).
+ * a user who accidentally pastes a 50MB transcript into
+ * policies/management.md should not silently blow up prompt assembly. 32KB
+ * is comfortably above the size of any realistic policy file (the largest
+ * templates under `agent-assets/templates/` are under 4KB).
  */
 export const POLICY_FILE_MAX_BYTES = 32 * 1024;
 /**
@@ -27,10 +28,14 @@ export function createPromptInjectionBudget(maxBytes = POLICY_TOTAL_MAX_BYTES) {
  */
 export const POLICY_FILE_REGISTRY = {
     "*": [
-        {
-            path: CONTEXT_RELATIVE_PATHS.rules.management,
-            label: "Source-of-truth bindings",
-        },
+        // `policies/management.md` is intentionally NOT in this registry.
+        // ContextBuilder's `<management_rules>` block is the authoritative
+        // injection (task-flows reference the XML tag by name); re-adding
+        // a heading-form copy here would duplicate the SoT text in every
+        // prompt AND burn a slot of POLICY_TOTAL_MAX_BYTES that mcp.md /
+        // journal-format.md / journal-export.md need. The per-file 32 KB
+        // cap is enforced by ContextBuilder (NFR-1b). See module-level
+        // JSDoc + design 21 §0.2.
         {
             path: CONTEXT_RELATIVE_PATHS.rules.redaction,
             label: "Redaction patterns",
@@ -63,12 +68,45 @@ export const POLICY_FILE_REGISTRY = {
             label: "Journal export rules",
         },
     ],
-    "routine.morning_routine_initial": [
+    // `routine.morning_routine_initial` is retired — first-run branches
+    // through `routine.morning_routine_today` below. See
+    // morning-routine-optimization.md.
+    // Stage A inherits the global `*` set (redaction + mcp when enabled)
+    // PLUS the user-editable
+    // morning checks. Journal-format / journal-export are deliberately
+    // NOT injected on Stage A — those are Stage B's policy blocks now.
+    // The Vault review context (dossiers/morning.md) is injected by the
+    // review-context appender keyed on processKey, not by this registry.
+    "routine.morning_routine_today": [
         {
             path: CONTEXT_RELATIVE_PATHS.routines.morning,
             label: "Morning routine checks",
         },
     ],
+    // morning-routine-optimization.md Phase 5 — Stage B opts OUT of every
+    // `*` default except `policies/redaction.md`. The opt-out lives in
+    // `injection-policy.ts:getInjectionPolicy("routine.morning_routine_journal").policyFileGlobalMerge=false`
+    // (v4.2 V20 consolidation); `resolvePolicyRefs` reads that flag and
+    // skips the `*` merge entirely. Stage B re-declares the redaction
+    // ref here so it still flows through the same vault-write protections
+    // every other writer sees. `policies/mcp.md` is deliberately omitted —
+    // Stage B uses no MCP tools (skill bundle is `context` + `_safety`
+    // only), so injecting the rulebook would waste lite-tier prompt
+    // budget for no behaviour.
+    "routine.morning_routine_journal": [
+        {
+            path: CONTEXT_RELATIVE_PATHS.rules.redaction,
+            label: "Redaction patterns",
+        },
+        {
+            path: CONTEXT_RELATIVE_PATHS.rules.journalFormat,
+            label: "Daily journal format spec",
+        },
+        {
+            path: CONTEXT_RELATIVE_PATHS.rules.journalExport,
+            label: "Journal export rules",
+        },
+    ],
     "routine.evening_review": [
         {
             path: CONTEXT_RELATIVE_PATHS.routines.evening,
@@ -101,16 +139,29 @@ export const POLICY_FILE_REGISTRY = {
  * Pull the set of policy refs for a processKey. Process-specific entries
  * are appended to the global `*` set. Custom routines (keys starting with
  * `routine.custom.`) resolve to their slugged file automatically.
+ *
+ * Whether the `*` merge applies is decided by
+ * `injection-policy.ts:getInjectionPolicy(processKey).policyFileGlobalMerge`
+ * (v4.2 V20 consolidation). The legacy `POLICY_KEY_GLOBAL_OPTOUT` set
+ * that used to live here was retired in favour of that single table —
+ * see `injection-policy.ts` for the architectural rationale.
+ *
+ * Stage B (`routine.morning_routine_journal`) is currently the only
+ * process key with `policyFileGlobalMerge=false`; its
+ * `POLICY_FILE_REGISTRY` row above re-declares `policies/redaction.md`
+ * inline so the lite-tier journal author still respects redaction even
+ * after opting out of the `*` merge.
  */
 export function resolvePolicyRefs(processKey) {
-    const global = POLICY_FILE_REGISTRY["*"];
+    const policy = getInjectionPolicy(processKey);
+    const global = policy.policyFileGlobalMerge ? POLICY_FILE_REGISTRY["*"] : [];
     const specific = POLICY_FILE_REGISTRY[processKey] ?? [];
     if (processKey.startsWith("routine.custom.")) {
         const slug = processKey.slice("routine.custom.".length);
         return [
             ...global,
             {
-                path: `routines/custom/${slug}.md`,
+                path: `policies/routines/custom/${slug}.md`,
                 label: `Custom routine: ${slug}`,
             },
         ];
@@ -195,4 +246,3 @@ function readPolicyFile(absolute, reader) {
         return null;
     }
 }
-//# sourceMappingURL=policy-files.js.map

package/dist/core/pre-pass-freshness.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Freshness-window helpers for the hourly_check pre-pass harvester
+ * (HOURLY_CHECK_GATE_REDESIGN_PLAN.md §3.4).
+ *
+ * The pre-pass fetcher writes a `runtime_state` row keyed by integration
+ * after every successful per-integration completion. The hourly_check
+ * coordinator's `harvestForGate` reads the row to decide whether the
+ * window is fresh enough to skip pre-pass on this tick.
+ *
+ * The key prefix is intentionally shared across every routine that
+ * spawns `routine.fetch_window` (morning_routine, hourly_check,
+ * evening_review, weekly_review, today_refresh). Sharing means a
+ * morning_routine that just ran at 04:00 suppresses the 05:00
+ * hourly_check pre-pass — exactly what we want to avoid double-fetching.
+ *
+ * Module is intentionally trivial — separated so both the runner (writer)
+ * and the coordinator (reader) can depend on a single string-builder
+ * without a circular import.
+ */
+import type { IntegrationKey } from "@aitne/shared";
+/** Stable namespace prefix — also used by lint/audit tooling. */
+export declare const PRE_PASS_LAST_RUN_KEY_PREFIX = "pre_pass_last_run";
+/**
+ * Build the canonical `runtime_state` key for "when did the pre-pass
+ * last successfully fetch this integration's window?".
+ */
+export declare function prePassLastRunRuntimeStateKey(integrationKey: IntegrationKey): string;