@aitne/daemon 0.1.7 → 0.1.9

package/dist/core/pre-pass-freshness.js

@@ -0,0 +1,9 @@
+/** Stable namespace prefix — also used by lint/audit tooling. */
+export 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 function prePassLastRunRuntimeStateKey(integrationKey) {
+    return `${PRE_PASS_LAST_RUN_KEY_PREFIX}:${integrationKey}`;
+}

package/dist/core/previous-week-digest.d.ts

@@ -0,0 +1,129 @@
+/**
+ * `<previous_week>` digest — extracts the import-targeted
+ * `## Carry Over to Next Week`, `## Next Week Focus`, and
+ * `## Lessons for Next Week` sections from the just-ended ISO week's
+ * `weekly/YYYY-Www.md` and renders them as a compact XML block that the
+ * morning_routine task-flow consumes verbatim **every morning** of the
+ * new ISO week (Mon–Sun, same file across the week).
+ *
+ * Cross-week boundary behaviour: when the daemon clock crosses into a
+ * new ISO week and the Friday weekly_review produced a fresh file,
+ * `getPreviousWeekIsoKey(now)` flips to the new key automatically — no
+ * Monday-only or "first morning of week" gating needed. The block is
+ * a small daily-context input, not a one-shot handoff.
+ *
+ * See `docs/design/appendices/weekly-next-week-leverage.md` for the
+ * end-to-end design (weekly_review task-flow contract → file shape →
+ * ContextBuilder injection → morning_routine consumption).
+ *
+ * Pure: takes contextDir + an ISO year-week key and a clock; returns the
+ * digest or null. No DB, no fs side effects beyond `fs/promises.readFile`
+ * + `fs.statSync` for the mtime fallback. Sized for the morning-routine
+ * cold-start budget — the rendered block is hard-capped at
+ * `PREVIOUS_WEEK_BLOCK_MAX_CHARS` and truncated with an explicit
+ * `...` marker so the LLM can tell when content was elided.
+ */
+/**
+ * Per design — the block is capped at ~600 tokens. Using ~4 chars per
+ * token as a conservative estimate, that's ~2400 characters of body
+ * payload across the three sub-blocks. The XML scaffolding overhead is
+ * negligible against this. Truncation only ever fires when the weekly
+ * file violates its own contract caps (Carry Over ≤5, Focus ≤3,
+ * Lessons ≤3 short bullets each); typical payloads sit an order of
+ * magnitude below this ceiling.
+ */
+export declare const PREVIOUS_WEEK_BLOCK_MAX_CHARS = 2400;
+export interface PreviousWeekDigest {
+    /** ISO year-week the digest was extracted from, e.g. `2026-W19`. */
+    period: string;
+    /** Absolute timestamp the source file was last written (ISO 8601 UTC). */
+    generatedAt: string;
+    /**
+     * Body of `## Carry Over to Next Week`, header excluded, leading /
+     * trailing blank lines trimmed. Empty string when the section is
+     * present but empty or carries only a `- (none)` line.
+     */
+    carryOver: string;
+    /**
+     * Body of `## Next Week Focus`, header excluded, leading / trailing
+     * blank lines trimmed. Empty string when the section is present but
+     * empty.
+     */
+    focus: string;
+    /**
+     * Body of `## Lessons for Next Week`, header excluded, leading /
+     * trailing blank lines trimmed. Empty string when the section is
+     * present but empty. Each bullet in the source file follows
+     * `<observation> → <specific next-week action>`; the digest preserves
+     * the formatting verbatim.
+     */
+    lessons: string;
+}
+/**
+ * Compute the ISO year-week key for the week containing `date`.
+ *
+ * Standard ISO-8601 algorithm: the week containing the year's first
+ * Thursday is week 01. Year-boundary edge cases (e.g. Jan 1 falling on
+ * Friday/Saturday/Sunday belongs to the previous ISO year's W52/W53) are
+ * handled correctly because the `target` Thursday's `getUTCFullYear()`
+ * is the ISO year by construction.
+ *
+ * Returns the zero-padded `YYYY-Www` slug — matches the format the
+ * `compareWeeklyKey` parser in `retention.ts` already understands.
+ */
+export declare function isoYearWeekFromUtc(year: number, month: number, day: number): string;
+/**
+ * ISO year-week key of the week immediately preceding the week that
+ * contains `now` in the given timezone.
+ *
+ * Algorithm: find the Monday of the current ISO week (today minus
+ * `(localDayOfWeek - 1 + 7) % 7` days), then step back another 7 days
+ * to land on the previous ISO week's Monday. The Monday-anchor is
+ * timezone-naive at the calendar-date level by construction.
+ *
+ * Stable across Mon–Sun of the current week: every weekday returns the
+ * same previous-week key. When the daemon clock crosses into a new ISO
+ * week (Mon 00:00 local), this helper rolls forward automatically so
+ * the morning_routine sees the freshly-written weekly file from the
+ * just-ended week.
+ *
+ * Year-boundary cases (current week is `2027-W01`, prev = `2026-W53`)
+ * are handled by `isoYearWeekFromUtc` — see its docstring.
+ */
+export declare function getPreviousWeekIsoKey(timezone: string | undefined, now?: Date): string;
+/**
+ * Load and parse `weekly/<isoYearWeek>.md` from disk, extracting the
+ * three import-targeted sections. Returns null when the file is
+ * missing, empty, unreadable, or contains none of the three sections.
+ *
+ * - Missing file → null (silent skip; caller proceeds without the
+ *   block — explicit no-fail path for the "daemon was down through
+ *   Friday and no weekly_review fired" case).
+ * - File present but none of the three headers found → null. Caller
+ *   skips the block so the agent does not waste tokens on a vestigial
+ *   `<previous_week>` whose body would be empty.
+ * - Any of the three sections present (even if body is empty) → return
+ *   digest with the present body and `""` for the missing ones. The
+ *   renderer emits a `(none recorded)` placeholder so the LLM sees the
+ *   intent ("focus was not declared this week") rather than guessing.
+ */
+export declare function loadPreviousWeekDigest(contextDir: string, isoYearWeek: string): Promise<PreviousWeekDigest | null>;
+/**
+ * Render a `<previous_week>` block from a digest. Stable shape: the
+ * outer element carries `period` and `generated_at` attributes; the
+ * three child elements always appear in `(carry_over, focus, lessons)`
+ * order so the task-flow can describe their semantics without
+ * conditional branching. Sub-blocks render their body verbatim — bullet
+ * markers, indentation, multi-line reasons all preserved as they
+ * appeared in the source weekly file.
+ *
+ * Token-cap: if the joined rendering exceeds
+ * `PREVIOUS_WEEK_BLOCK_MAX_CHARS`, the body sections are truncated
+ * proportionally to their original length and end with the explicit
+ * `...` marker so the LLM can tell content was elided. Truncation
+ * almost never fires because the section caps in the weekly file
+ * keep payloads an order of magnitude below the ceiling — when it
+ * does, it signals the upstream file violated the contract and the
+ * digest is salvaging what fits.
+ */
+export declare function renderPreviousWeekBlock(digest: PreviousWeekDigest): string;

package/dist/core/previous-week-digest.js

@@ -0,0 +1,256 @@
+/**
+ * `<previous_week>` digest — extracts the import-targeted
+ * `## Carry Over to Next Week`, `## Next Week Focus`, and
+ * `## Lessons for Next Week` sections from the just-ended ISO week's
+ * `weekly/YYYY-Www.md` and renders them as a compact XML block that the
+ * morning_routine task-flow consumes verbatim **every morning** of the
+ * new ISO week (Mon–Sun, same file across the week).
+ *
+ * Cross-week boundary behaviour: when the daemon clock crosses into a
+ * new ISO week and the Friday weekly_review produced a fresh file,
+ * `getPreviousWeekIsoKey(now)` flips to the new key automatically — no
+ * Monday-only or "first morning of week" gating needed. The block is
+ * a small daily-context input, not a one-shot handoff.
+ *
+ * See `docs/design/appendices/weekly-next-week-leverage.md` for the
+ * end-to-end design (weekly_review task-flow contract → file shape →
+ * ContextBuilder injection → morning_routine consumption).
+ *
+ * Pure: takes contextDir + an ISO year-week key and a clock; returns the
+ * digest or null. No DB, no fs side effects beyond `fs/promises.readFile`
+ * + `fs.statSync` for the mtime fallback. Sized for the morning-routine
+ * cold-start budget — the rendered block is hard-capped at
+ * `PREVIOUS_WEEK_BLOCK_MAX_CHARS` and truncated with an explicit
+ * `...` marker so the LLM can tell when content was elided.
+ */
+import { existsSync } from "node:fs";
+import { readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { nowInTimezone } from "@aitne/shared";
+import { weeklyReviewPath } from "./context-paths.js";
+/**
+ * Per design — the block is capped at ~600 tokens. Using ~4 chars per
+ * token as a conservative estimate, that's ~2400 characters of body
+ * payload across the three sub-blocks. The XML scaffolding overhead is
+ * negligible against this. Truncation only ever fires when the weekly
+ * file violates its own contract caps (Carry Over ≤5, Focus ≤3,
+ * Lessons ≤3 short bullets each); typical payloads sit an order of
+ * magnitude below this ceiling.
+ */
+export const PREVIOUS_WEEK_BLOCK_MAX_CHARS = 2400;
+const TRUNCATION_MARKER = "...";
+/**
+ * Compute the ISO year-week key for the week containing `date`.
+ *
+ * Standard ISO-8601 algorithm: the week containing the year's first
+ * Thursday is week 01. Year-boundary edge cases (e.g. Jan 1 falling on
+ * Friday/Saturday/Sunday belongs to the previous ISO year's W52/W53) are
+ * handled correctly because the `target` Thursday's `getUTCFullYear()`
+ * is the ISO year by construction.
+ *
+ * Returns the zero-padded `YYYY-Www` slug — matches the format the
+ * `compareWeeklyKey` parser in `retention.ts` already understands.
+ */
+export function isoYearWeekFromUtc(year, month, day) {
+    // Work in UTC Y/M/D so DST never enters the picture — ISO weeks are
+    // timezone-naive at the calendar-date level. `Date.UTC` accepts month
+    // as 0-indexed; the caller passes 1-indexed.
+    const target = new Date(Date.UTC(year, month - 1, day));
+    // Day of week with Monday = 0, Sunday = 6.
+    const dayNr = (target.getUTCDay() + 6) % 7;
+    // Shift target to the Thursday of the same ISO week — the ISO year
+    // and the ISO-week index are anchored on that Thursday.
+    target.setUTCDate(target.getUTCDate() - dayNr + 3);
+    const isoYear = target.getUTCFullYear();
+    // First Thursday of the ISO year — relies on the same shift.
+    const firstThursday = new Date(Date.UTC(isoYear, 0, 4));
+    const firstDayNr = (firstThursday.getUTCDay() + 6) % 7;
+    firstThursday.setUTCDate(firstThursday.getUTCDate() - firstDayNr + 3);
+    const week = 1 +
+        Math.round((target.getTime() - firstThursday.getTime()) / (7 * 24 * 60 * 60 * 1000));
+    return `${isoYear}-W${String(week).padStart(2, "0")}`;
+}
+/**
+ * ISO year-week key of the week immediately preceding the week that
+ * contains `now` in the given timezone.
+ *
+ * Algorithm: find the Monday of the current ISO week (today minus
+ * `(localDayOfWeek - 1 + 7) % 7` days), then step back another 7 days
+ * to land on the previous ISO week's Monday. The Monday-anchor is
+ * timezone-naive at the calendar-date level by construction.
+ *
+ * Stable across Mon–Sun of the current week: every weekday returns the
+ * same previous-week key. When the daemon clock crosses into a new ISO
+ * week (Mon 00:00 local), this helper rolls forward automatically so
+ * the morning_routine sees the freshly-written weekly file from the
+ * just-ended week.
+ *
+ * Year-boundary cases (current week is `2027-W01`, prev = `2026-W53`)
+ * are handled by `isoYearWeekFromUtc` — see its docstring.
+ */
+export function getPreviousWeekIsoKey(timezone, now) {
+    const reference = now ?? new Date();
+    const local = nowInTimezone(timezone, reference);
+    // Anchor a UTC Date on the local Y/M/D so day-of-week arithmetic
+    // happens at the calendar-date level (TZ-naive). Same convention as
+    // `isoYearWeekFromUtc`.
+    const today = new Date(Date.UTC(local.year, local.month - 1, local.day));
+    const dayNr = (today.getUTCDay() + 6) % 7; // Mon = 0
+    // Step back to Monday of this ISO week, then another 7 days to land
+    // on the previous ISO week's Monday.
+    const prevWeekAnchorMs = today.getTime() - (dayNr + 7) * 24 * 60 * 60 * 1000;
+    const prevWeekAnchor = new Date(prevWeekAnchorMs);
+    return isoYearWeekFromUtc(prevWeekAnchor.getUTCFullYear(), prevWeekAnchor.getUTCMonth() + 1, prevWeekAnchor.getUTCDate());
+}
+const CARRY_OVER_HEADER_RE = /^##\s+Carry Over to Next Week\s*$/im;
+const NEXT_WEEK_FOCUS_HEADER_RE = /^##\s+Next Week Focus\s*$/im;
+const LESSONS_HEADER_RE = /^##\s+Lessons for Next Week\s*$/im;
+const ANY_H2_HEADER_RE = /^##\s+\S/m;
+/**
+ * Extract a single H2 section body from a markdown document.
+ *
+ * Returns the lines between `## <header>` (exclusive) and the next H2
+ * (exclusive), trimmed of leading / trailing blank lines. Returns `null`
+ * when the header is absent. Returns an empty string when the header is
+ * present but the body is empty or whitespace-only.
+ *
+ * Header regex matches verbatim — section titles in the weekly file are
+ * load-bearing per the task-flow contract; we deliberately do not
+ * normalize whitespace, case, or pluralization.
+ */
+function extractH2Section(body, headerRe) {
+    const headerMatch = headerRe.exec(body);
+    if (!headerMatch)
+        return null;
+    const after = body.slice(headerMatch.index + headerMatch[0].length);
+    // Skip the newline after the header line.
+    const afterTrimLeading = after.replace(/^\r?\n/, "");
+    const nextHeader = ANY_H2_HEADER_RE.exec(afterTrimLeading);
+    const sectionRaw = nextHeader
+        ? afterTrimLeading.slice(0, nextHeader.index)
+        : afterTrimLeading;
+    return sectionRaw.replace(/^\s*\n+/, "").replace(/\n+\s*$/, "");
+}
+/**
+ * Load and parse `weekly/<isoYearWeek>.md` from disk, extracting the
+ * three import-targeted sections. Returns null when the file is
+ * missing, empty, unreadable, or contains none of the three sections.
+ *
+ * - Missing file → null (silent skip; caller proceeds without the
+ *   block — explicit no-fail path for the "daemon was down through
+ *   Friday and no weekly_review fired" case).
+ * - File present but none of the three headers found → null. Caller
+ *   skips the block so the agent does not waste tokens on a vestigial
+ *   `<previous_week>` whose body would be empty.
+ * - Any of the three sections present (even if body is empty) → return
+ *   digest with the present body and `""` for the missing ones. The
+ *   renderer emits a `(none recorded)` placeholder so the LLM sees the
+ *   intent ("focus was not declared this week") rather than guessing.
+ */
+export async function loadPreviousWeekDigest(contextDir, isoYearWeek) {
+    const relativePath = weeklyReviewPath(isoYearWeek);
+    const fullPath = join(contextDir, relativePath);
+    if (!existsSync(fullPath))
+        return null;
+    let body;
+    let generatedAt;
+    try {
+        const [b, st] = await Promise.all([
+            readFile(fullPath, "utf-8"),
+            stat(fullPath),
+        ]);
+        body = b;
+        generatedAt = st.mtime.toISOString();
+    }
+    catch {
+        return null;
+    }
+    if (!body.trim())
+        return null;
+    const carryOver = extractH2Section(body, CARRY_OVER_HEADER_RE);
+    const focus = extractH2Section(body, NEXT_WEEK_FOCUS_HEADER_RE);
+    const lessons = extractH2Section(body, LESSONS_HEADER_RE);
+    if (carryOver === null && focus === null && lessons === null)
+        return null;
+    return {
+        period: isoYearWeek,
+        generatedAt,
+        carryOver: carryOver ?? "",
+        focus: focus ?? "",
+        lessons: lessons ?? "",
+    };
+}
+/**
+ * Render a `<previous_week>` block from a digest. Stable shape: the
+ * outer element carries `period` and `generated_at` attributes; the
+ * three child elements always appear in `(carry_over, focus, lessons)`
+ * order so the task-flow can describe their semantics without
+ * conditional branching. Sub-blocks render their body verbatim — bullet
+ * markers, indentation, multi-line reasons all preserved as they
+ * appeared in the source weekly file.
+ *
+ * Token-cap: if the joined rendering exceeds
+ * `PREVIOUS_WEEK_BLOCK_MAX_CHARS`, the body sections are truncated
+ * proportionally to their original length and end with the explicit
+ * `...` marker so the LLM can tell content was elided. Truncation
+ * almost never fires because the section caps in the weekly file
+ * keep payloads an order of magnitude below the ceiling — when it
+ * does, it signals the upstream file violated the contract and the
+ * digest is salvaging what fits.
+ */
+export function renderPreviousWeekBlock(digest) {
+    const { carryOver, focus, lessons } = capDigestBodies(digest);
+    return [
+        `<previous_week period="${digest.period}" generated_at="${digest.generatedAt}">`,
+        "  <carry_over>",
+        indent(carryOver || "(none recorded)", "    "),
+        "  </carry_over>",
+        "  <focus>",
+        indent(focus || "(none recorded)", "    "),
+        "  </focus>",
+        "  <lessons>",
+        indent(lessons || "(none recorded)", "    "),
+        "  </lessons>",
+        "</previous_week>",
+    ].join("\n");
+}
+function indent(text, prefix) {
+    // `text` is always non-empty here — render sites guard with
+    // `|| "(none recorded)"` and capDigestBodies never produces "" (truncate
+    // returns the explicit `...` marker for zero-byte budgets).
+    return text
+        .split("\n")
+        .map((line) => (line.length === 0 ? line : prefix + line))
+        .join("\n");
+}
+function capDigestBodies(digest) {
+    const totalLen = digest.carryOver.length + digest.focus.length + digest.lessons.length;
+    if (totalLen <= PREVIOUS_WEEK_BLOCK_MAX_CHARS) {
+        return {
+            carryOver: digest.carryOver,
+            focus: digest.focus,
+            lessons: digest.lessons,
+        };
+    }
+    // Proportional split — preserve the original ratio so one section
+    // does not dominate the remaining budget. Subtract the marker length
+    // from each per-section budget so appended ellipses fit inside the
+    // overall cap.
+    const budget = PREVIOUS_WEEK_BLOCK_MAX_CHARS - 3 * TRUNCATION_MARKER.length;
+    const safeTotal = Math.max(totalLen, 1);
+    const carryBudget = Math.max(0, Math.floor((budget * digest.carryOver.length) / safeTotal));
+    const focusBudget = Math.max(0, Math.floor((budget * digest.focus.length) / safeTotal));
+    const lessonsBudget = Math.max(0, budget - carryBudget - focusBudget);
+    return {
+        carryOver: truncate(digest.carryOver, carryBudget),
+        focus: truncate(digest.focus, focusBudget),
+        lessons: truncate(digest.lessons, lessonsBudget),
+    };
+}
+function truncate(text, max) {
+    if (text.length <= max)
+        return text;
+    if (max <= TRUNCATION_MARKER.length)
+        return TRUNCATION_MARKER;
+    return text.slice(0, max - TRUNCATION_MARKER.length) + TRUNCATION_MARKER;
+}

package/dist/core/profile-questions/seed.d.ts

@@ -2,7 +2,7 @@
  * Profile-interview queue — Layer 1 (skeleton-time deterministic
  * pre-tick).
  *
- * Walks every `[ ]` row in `agent/profile-questions.md ## Pending` and
+ * Walks every `[ ]` row in `state/profile-questions.md ## Pending` and
  * marks rows whose target slot is already filled (per
  * `isSlotFilled` — §3.5.6 of the design). Appends a matching
  * `(reconciled:skeleton)` entry to `## Answered` for each tick.
@@ -36,9 +36,8 @@ export interface PendingRowMeta {
     anchor: string | null;
 }
 /**
- * Run the deterministic Layer 1 pre-tick on `agent/profile-questions.md`
+ * Run the deterministic Layer 1 pre-tick on `state/profile-questions.md`
  * inside `contextDir`. Returns counts for telemetry / logging. Safe to
  * call when the queue file does not exist (returns zeros).
  */
 export declare function preTickProfileQuestions(contextDir: string): SeedResult;
-//# sourceMappingURL=seed.d.ts.map

package/dist/core/profile-questions/seed.js

@@ -2,7 +2,7 @@
  * Profile-interview queue — Layer 1 (skeleton-time deterministic
  * pre-tick).
  *
- * Walks every `[ ]` row in `agent/profile-questions.md ## Pending` and
+ * Walks every `[ ]` row in `state/profile-questions.md ## Pending` and
  * marks rows whose target slot is already filled (per
  * `isSlotFilled` — §3.5.6 of the design). Appends a matching
  * `(reconciled:skeleton)` entry to `## Answered` for each tick.
@@ -17,12 +17,13 @@
  */
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { CONTEXT_RELATIVE_PATHS } from "../context-paths.js";
 import { isSlotFilled } from "./slot-filled.js";
 const PENDING_ROW_RE = /^- \[([ xX])\] \((HIGH|MID|LOW)\) ([a-z][a-z0-9_]*)\s*::\s*(.+)$/;
 const HEADING_RE = /^(#{2,6})\s+(.+?)\s*$/;
-const QUEUE_PATH_REL = "agent/profile-questions.md";
+const QUEUE_PATH_REL = CONTEXT_RELATIVE_PATHS.agent.profileQuestions;
 /**
- * Run the deterministic Layer 1 pre-tick on `agent/profile-questions.md`
+ * Run the deterministic Layer 1 pre-tick on `state/profile-questions.md`
  * inside `contextDir`. Returns counts for telemetry / logging. Safe to
  * call when the queue file does not exist (returns zeros).
  */
@@ -170,4 +171,3 @@ function insertAnsweredEntries(lines, entries) {
         lines.splice(insertAt, 0, ...entries);
     }
 }
-//# sourceMappingURL=seed.js.map

package/dist/core/profile-questions/slot-filled.d.ts

@@ -48,4 +48,3 @@ export interface SlotFilledResult {
  *                 pre-seeded by setup with an unrelated bullet.
  */
 export declare function isSlotFilled(fileBody: string, section: string | null, anchor: string | null): SlotFilledResult;
-//# sourceMappingURL=slot-filled.d.ts.map

package/dist/core/profile-questions/slot-filled.js

@@ -115,4 +115,3 @@ function sectionContainsAnchor(sectionBody, anchor) {
     }
     return false;
 }
-//# sourceMappingURL=slot-filled.js.map

package/dist/core/prompts.d.ts

@@ -110,4 +110,3 @@ export declare function readTaskFlowSources(key: string): {
     bundled: string | null;
     override: string | null;
 };
-//# sourceMappingURL=prompts.d.ts.map

package/dist/core/prompts.js

@@ -133,7 +133,7 @@ function loadFlowVariant(eventType, backendId, integrations) {
 /**
  * INTEGRATION_NATIVE_MODE_DESIGN.md §8.2 — a task-flow variant may
  * include the canonical base flow via the `{{> base }}` directive,
- * mirroring `renderPartialIncludes` for skills (skills-compiler.ts:1296).
+ * mirroring `renderPartialIncludes` for skills in `skills-compiler.ts`.
  * The directive is replaced with the body of `<eventType>.md` with the
  * leading `{context}\n\n` block stripped — the variant carries its own
  * `{context}` at the top, and duplicating the token would double the
@@ -150,8 +150,8 @@ function expandTaskFlowPartials(content, eventType) {
     // Resolve against the BUNDLED base file only — the user-override
     // resolution layer is one-way (variants may override; partial includes
     // pin to canonical assets so a malformed override doesn't cascade into
-    // every variant that includes it). This matches the skill partial
-    // resolver's "read from src verbatim" stance (skills-compiler.ts:612).
+    // every variant that includes it). Matches the skill partial
+    // resolver's "read from src verbatim" stance in `skills-compiler.ts`.
     const dir = resolveTaskFlowsDir();
     const basePath = join(dir, `${eventType}.md`);
     if (!existsSync(basePath))
@@ -166,7 +166,7 @@ function expandTaskFlowPartials(content, eventType) {
     return content.replaceAll("{{> base }}", baseStripped);
 }
 /**
- * ROUTINE_DATA_ACQUISITION_DESIGN.md Phase 1 / F0 — resolve
+ * docs/design/appendices/routine-data-acquisition.md Phase 1 / F0 — resolve
  * `{include:_partials/<name>.md}` directives in a task-flow body by
  * inlining the verbatim contents of `agent-assets/task-flows/_partials/
  * <name>.md`. Runs BEFORE `applyIntegrationModeFilter` so any
@@ -232,7 +232,7 @@ export function expandPartialIncludes(content) {
     });
 }
 /**
- * PRE_PASS_FAN_OUT_DESIGN.md §4.2 Path (a) — load a single
+ * docs/design/appendices/pre-pass-fan-out.md §4.2 Path (a) — load a single
  * `_partials/<name>.md` body for runner-side substitution into the
  * `{integration_partial}` placeholder of `routine.fetch_window.md`.
  * Reuses the same lookup as `expandPartialIncludes` (user-override →
@@ -293,7 +293,7 @@ export function getTaskFlow(eventType, backendId, integrations) {
     const raw = resolveTaskFlowSource(eventType, backendId, integrations);
     if (!raw)
         return raw;
-    // ROUTINE_DATA_ACQUISITION_DESIGN.md F0 — expand
+    // docs/design/appendices/routine-data-acquisition.md F0 — expand
     // `{include:_partials/<name>.md}` directives BEFORE mode filtering so
     // the partial's `<!-- mode:... -->` blocks participate in the same
     // filter pass as the host body. Depth cap = 1; nested includes inside
@@ -422,4 +422,3 @@ function listMdFilesByKey(dir) {
         return new Set();
     }
 }
-//# sourceMappingURL=prompts.js.map

package/dist/core/quiet-hours-sync.d.ts

@@ -12,4 +12,3 @@ import type Database from "better-sqlite3";
  * exercise it without spinning up a Hono app.
  */
 export declare function syncDmSessionTimesToQuietHours(db: Database.Database, newQuietHoursEnd: string): void;
-//# sourceMappingURL=quiet-hours-sync.d.ts.map

package/dist/core/quiet-hours-sync.js

@@ -35,6 +35,13 @@ export function syncDmSessionTimesToQuietHours(db, newQuietHoursEnd) {
         }
         if (ctx.pin_to_quiet_hours_end !== true)
             continue;
+        // SCHEDULE_API_REDESIGN_PLAN §4.1 — hourly rules forbid the `time`
+        // field; stamping one on would write a schema-invalid rule that the
+        // next route PATCH would reject. The morning-briefing pin only
+        // makes sense for daily/weekly/monthly cadences anyway, so skip
+        // rather than corrupt.
+        if (rule.frequency === "hourly")
+            continue;
         if (rule.time === newQuietHoursEnd)
             continue;
         const updated = { ...rule, time: newQuietHoursEnd };
@@ -48,4 +55,3 @@ export function syncDmSessionTimesToQuietHours(db, newQuietHoursEnd) {
        WHERE recurring_schedule_id = ? AND status = 'pending'`).run(row.id);
     }
 }
-//# sourceMappingURL=quiet-hours-sync.js.map

package/dist/core/quiet-hours.d.ts

@@ -0,0 +1,35 @@
+export interface QuietHoursWindow {
+    /** `"HH:MM"` 24-hour. Default `"22:00"`. */
+    start: string;
+    /** `"HH:MM"` 24-hour. Default `"08:00"`. May be earlier than `start`
+     *  in clock terms — an overnight window (`22:00` → `08:00`) is
+     *  supported. */
+    end: string;
+    /** IANA tz identifier (e.g. `"Asia/Tokyo"`). Empty / undefined
+     *  falls back to the system timezone via `nowInTimezone`. */
+    timezone?: string;
+}
+/**
+ * True when `at` falls inside the quiet-hours window.
+ *
+ * Same-day window (e.g. `09:00`–`17:00`) is interpreted as
+ * `start <= now < end`. Overnight window (e.g. `22:00`–`08:00`) is
+ * `now >= start OR now < end`. The half-open upper bound matches the
+ * NotificationManager's prior shipping behavior.
+ *
+ * Returns `false` when `start === end` — that's the "quiet hours
+ * disabled" idiom (e.g. notification-manager tests use `00:00`/`00:00`).
+ */
+export declare function isInQuietHoursAt(at: Date, window: QuietHoursWindow): boolean;
+/**
+ * Returns ms-since-epoch when the quiet-hours window that contains
+ * `from` ends, or `null` when `from` is not inside quiet hours.
+ *
+ * Walks forward minute-by-minute (capped at 24 h) so configured
+ * timezone + overnight windows stay correct without re-deriving the
+ * boundary math. Cost is at most ~1440 cheap `nowInTimezone` calls;
+ * the scheduler calls this at most once per row dispatch tick, and the
+ * NotificationManager only calls it when scheduling a deferred batch
+ * flush — neither path is hot enough to warrant a closed-form variant.
+ */
+export declare function nextQuietHoursEndMs(from: Date, window: QuietHoursWindow): number | null;