@aitne/daemon 0.1.8 → 0.1.9

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

@@ -127,4 +127,3 @@ export declare function loadPreviousWeekDigest(contextDir: string, isoYearWeek:
  * digest is salvaging what fits.
  */
 export declare function renderPreviousWeekBlock(digest: PreviousWeekDigest): string;
-//# sourceMappingURL=previous-week-digest.d.ts.map

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

@@ -23,8 +23,8 @@
  * `PREVIOUS_WEEK_BLOCK_MAX_CHARS` and truncated with an explicit
  * `...` marker so the LLM can tell when content was elided.
  */
-import { existsSync, statSync } from "node:fs";
-import { readFile } from "node:fs/promises";
+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";
@@ -153,8 +153,14 @@ export async function loadPreviousWeekDigest(contextDir, isoYearWeek) {
     if (!existsSync(fullPath))
         return null;
     let body;
+    let generatedAt;
     try {
-        body = await readFile(fullPath, "utf-8");
+        const [b, st] = await Promise.all([
+            readFile(fullPath, "utf-8"),
+            stat(fullPath),
+        ]);
+        body = b;
+        generatedAt = st.mtime.toISOString();
     }
     catch {
         return null;
@@ -166,13 +172,6 @@ export async function loadPreviousWeekDigest(contextDir, isoYearWeek) {
     const lessons = extractH2Section(body, LESSONS_HEADER_RE);
     if (carryOver === null && focus === null && lessons === null)
         return null;
-    let generatedAt;
-    try {
-        generatedAt = statSync(fullPath).mtime.toISOString();
-    }
-    catch {
-        generatedAt = new Date().toISOString();
-    }
     return {
         period: isoYearWeek,
         generatedAt,
@@ -216,8 +215,9 @@ export function renderPreviousWeekBlock(digest) {
     ].join("\n");
 }
 function indent(text, prefix) {
-    if (text === "")
-        return 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))
@@ -254,4 +254,3 @@ function truncate(text, max) {
         return TRUNCATION_MARKER;
     return text.slice(0, max - TRUNCATION_MARKER.length) + TRUNCATION_MARKER;
 }
-//# sourceMappingURL=previous-week-digest.js.map

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))
@@ -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

@@ -55,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;

package/dist/core/quiet-hours.js

@@ -0,0 +1,93 @@
+/**
+ * Quiet-hours helpers — pure predicates shared by NotificationManager
+ * (proactive DM gating) and the ScheduleWatcher (BROWSER_TASK_REDESIGN_PLAN
+ * §12 Q#5 `scheduled.browser_task` deferral). Extracted so the two
+ * call sites cannot drift on the overnight-window math (00:00 wraparound
+ * is the only non-trivial branch) and so the runtime-settings keys
+ * `quietHoursStart` / `quietHoursEnd` have a single source of truth.
+ *
+ * 100% covered. The notification-manager + scheduler integrations
+ * remain excluded from the coverage gate as I/O-heavy; this helper is
+ * the pure leg they share.
+ */
+import { nowInTimezone } from "@aitne/shared";
+/**
+ * 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 function isInQuietHoursAt(at, window) {
+    const local = nowInTimezone(window.timezone || undefined, at);
+    const currentMinutes = local.hours * 60 + local.minutes;
+    const startMinutes = parseHhMm(window.start);
+    const endMinutes = parseHhMm(window.end);
+    if (startMinutes === endMinutes)
+        return false;
+    if (startMinutes < endMinutes) {
+        // Same-day range.
+        return currentMinutes >= startMinutes && currentMinutes < endMinutes;
+    }
+    // Overnight range.
+    return currentMinutes >= startMinutes || currentMinutes < endMinutes;
+}
+/**
+ * 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 function nextQuietHoursEndMs(from, window) {
+    if (!isInQuietHoursAt(from, window))
+        return null;
+    const startMs = from.getTime();
+    // Bounded probe: walk forward minute-by-minute until we find a
+    // non-quiet moment. Upper bound (24 h) is defence-in-depth — by
+    // construction `start !== end` short-circuits the predicate above
+    // so the loop ALWAYS returns from the body. The while-true shape
+    // (vs. a bounded for-loop) avoids a loop-exit branch the line
+    // counter would otherwise flag as unreachable.
+    let minutes = 1;
+    while (true) {
+        const probeMs = startMs + minutes * 60_000;
+        if (!isInQuietHoursAt(new Date(probeMs), window))
+            return probeMs;
+        minutes++;
+        /* c8 ignore start -- impossible-tail safety net; the inner check
+         * always returns first by construction. */
+        if (minutes > 24 * 60)
+            return probeMs;
+        /* c8 ignore stop */
+    }
+}
+function parseHhMm(value) {
+    // Defensive — the runtime-settings schema constrains the shape but a
+    // hand-crafted config could land here with garbage. NaN segments
+    // collapse to 0 so the predicate degrades gracefully (quiet hours
+    // effectively disabled) rather than misclassifying mid-day as quiet.
+    //
+    // `split(":")` always returns at least one element, so `hStr` is
+    // never undefined — only `mStr` is (the "HH-only" shape, e.g.
+    // `"22"`). Defaulting `mStr` lets `Number.parseInt("0", 10)` return
+    // 0 cleanly; bare `Number.parseInt(undefined as any, 10)` returns
+    // `NaN` which the finite-check below would then reject. Both
+    // branches are pinned by the peer test.
+    const parts = value.split(":");
+    const hStr = parts[0];
+    const mStr = parts[1] ?? "0";
+    const h = Number.parseInt(hStr, 10);
+    const m = Number.parseInt(mStr, 10);
+    if (!Number.isFinite(h) || !Number.isFinite(m))
+        return 0;
+    return h * 60 + m;
+}

package/dist/core/read-sensitive-token-manager.d.ts

@@ -16,4 +16,3 @@ export declare class ScopedReadSensitiveTokenManager implements ReadSensitiveTok
     revoke(scope: string): void;
     isValid(token: string): boolean;
 }
-//# sourceMappingURL=read-sensitive-token-manager.d.ts.map

package/dist/core/read-sensitive-token-manager.js

@@ -26,4 +26,3 @@ export class ScopedReadSensitiveTokenManager {
         return false;
     }
 }
-//# sourceMappingURL=read-sensitive-token-manager.js.map

package/dist/core/recurrence.d.ts

@@ -34,4 +34,3 @@ export declare function computeNextHourly(timezone: string, intervalHours: numbe
  * Format a recurrence rule as a human-readable summary.
  */
 export declare function formatRecurrenceLabel(rule: RecurrenceRule): string;
-//# sourceMappingURL=recurrence.d.ts.map

package/dist/core/recurrence.js

@@ -69,9 +69,9 @@ export function computeNextOccurrence(rule, referenceUtc) {
     }
     // daily / weekly / monthly all carry `time`. The schema guarantees it,
     // but `parseRecurrenceRule` in default-schedules-runner forwards stored
-    // rows verbatim — fall back to "—" so a malformed row degrades to a
+    // rows verbatim — fall back to "00:00" so a malformed row degrades to a
     // never-matching candidate rather than NaN.
-    const { hours, minutes } = parseTime(rule.time ?? "00:00");
+    const { hours, minutes } = parseTime(/* c8 ignore next */ rule.time ?? "00:00");
     const local = nowInTimezone(timezone, referenceUtc);
     switch (rule.frequency) {
         case "daily":
@@ -226,14 +226,14 @@ export function formatRecurrenceLabel(rule) {
                 : `Every ${interval} hours at :${minute}`;
         }
         case "daily":
-            return `Daily at ${rule.time ?? "—"}`;
+            return `Daily at ${ /* c8 ignore next */rule.time ?? "—"}`;
         case "weekly": {
             const days = (rule.daysOfWeek ?? [])
                 .slice()
                 .sort((a, b) => a - b)
                 .map((d) => dayNames[d])
                 .join(", ");
-            return `Weekly on ${days} at ${rule.time ?? "—"}`;
+            return `Weekly on ${days} at ${ /* c8 ignore next */rule.time ?? "—"}`;
         }
         case "monthly": {
             const days = (rule.daysOfMonth ?? [])
@@ -247,11 +247,10 @@ export function formatRecurrenceLabel(rule) {
                 : policy === "skip"
                     ? " (skips months without that day)"
                     : " (falls back to last day of month)";
-            return `Monthly on day ${days} at ${rule.time ?? "—"}${suffix}`;
+            return `Monthly on day ${days} at ${ /* c8 ignore next */rule.time ?? "—"}${suffix}`;
         }
         /* v8 ignore next 2 — closed union exhausted above */
         default:
-            return `${rule.frequency} at ${rule.time ?? "—"}`;
+            return `${rule.frequency} at ${ /* c8 ignore next */rule.time ?? "—"}`;
     }
 }
-//# sourceMappingURL=recurrence.js.map

package/dist/core/reinstall.d.ts

@@ -47,6 +47,11 @@ export interface SpawnTarArgs {
 }
 export interface SpawnTarResult {
     status: number | null;
+    /**
+     * Spawn-level error code (e.g. "ENOENT" when `tar` is absent from PATH).
+     * Optional → backward-compatible with stubs that return only `status`.
+     */
+    errorCode?: string;
 }
 export interface ReinstallDeps {
     contextDir: string;
@@ -104,4 +109,3 @@ export declare function defaultAncillaryDirs(contextDir: string): string[];
  * Format: `<backupDir>/context-pre-reinstall-<ISO-no-colons>.tar.gz`.
  */
 export declare function backupTargetPath(backupDir: string, now: Date): string;
-//# sourceMappingURL=reinstall.d.ts.map

package/dist/core/reinstall.js

@@ -153,11 +153,21 @@ async function createTarballBackup(contextDir, backupPath, spawnTar) {
         leaf,
     });
     if (result.status !== 0) {
+        // On Windows hosts that lack `tar`/`bsdtar` on PATH, `spawnSync` returns
+        // status null with a spawn-level ENOENT instead of a non-zero exit. The
+        // backup-first ordering guarantees nothing was deleted yet, so surface an
+        // actionable message rather than the opaque "exited with status null".
+        if (result.errorCode === "ENOENT" || result.status === null) {
+            throw new Error("Cannot create the safety backup: the 'tar' command was not found on PATH. " +
+                "Install tar/bsdtar (bundled with Windows 10 1803+ and Windows 11) or run the reinstall on a host that has it.");
+        }
         throw new Error(`tar exited with status ${result.status} while writing ${backupPath}`);
     }
 }
 function defaultSpawnTar(args) {
     const result = spawnSync("tar", ["-czf", args.target, "-C", args.parent, args.leaf], { stdio: "ignore" });
-    return { status: result.status };
+    // `spawnSync().error` is typed as plain Error, but a failed spawn carries an
+    // errno `code` (e.g. "ENOENT" when `tar` is absent from PATH on Windows).
+    const errorCode = result.error?.code;
+    return { status: result.status, errorCode };
 }
-//# sourceMappingURL=reinstall.js.map

package/dist/core/release-assets.d.ts

@@ -117,10 +117,25 @@ export declare function writeInstructionAssetStamp(sessionDir: string, status: I
     skillSlugs: readonly string[];
 }): void;
 export declare function sessionInstructionAssetsStale(sessionDir: string, workspaceDir: string): boolean;
-export declare function findBuiltinShadowedUserSkills(dataDir: string, workspaceDir: string): string[];
-export declare function recordSkillAssetStatus(db: Database.Database, dataDir: string, workspaceDir: string, now?: () => Date): SkillAssetStatus;
+/**
+ * `userSkillsRoot` is the absolute user-skills directory. Production callers
+ * derive it via `resolveUserSkillsRoot(config)` from `core/user-skills-root.ts`
+ * (CONTEXT_VAULT_REDESIGN_PLAN.md v4 V11 — post-migration this resolves to
+ * `<contextDir>/policies/skills`). Tests may pass any directory directly so
+ * the helper remains decoupled from `AgentConfig`.
+ */
+export declare function findBuiltinShadowedUserSkills(userSkillsRoot: string, workspaceDir: string): string[];
+/**
+ * Union of every known skill slug — built-in (`<workspaceDir>/agent-assets/
+ * skills`) and user (`userSkillsRoot`, derived via `resolveUserSkillsRoot`).
+ * The Agent loader's `tools.skills` cross-check (AGENT_DEFINITIONS_DESIGN.md
+ * §4.3 step 5) consults this so a user Agent referencing an unknown skill is
+ * warned at load. Returns a `ReadonlySet` matching the loader's
+ * `listSkillSlugs` port shape; either root may be absent (→ empty contribution).
+ */
+export declare function listAllSkillSlugs(userSkillsRoot: string, workspaceDir: string): ReadonlySet<string>;
+export declare function recordSkillAssetStatus(db: Database.Database, userSkillsRoot: string, workspaceDir: string, now?: () => Date): SkillAssetStatus;
 export declare function sourceFileStats(root: string): {
     files: number;
     bytes: number;
 };
-//# sourceMappingURL=release-assets.d.ts.map

package/dist/core/release-assets.js

@@ -464,15 +464,36 @@ function listSkillSlugs(root) {
         .map((entry) => entry.name)
         .sort((a, b) => a.localeCompare(b));
 }
-export function findBuiltinShadowedUserSkills(dataDir, workspaceDir) {
-    const userSkills = new Set(listSkillSlugs(join(dataDir, "skills")));
+/**
+ * `userSkillsRoot` is the absolute user-skills directory. Production callers
+ * derive it via `resolveUserSkillsRoot(config)` from `core/user-skills-root.ts`
+ * (CONTEXT_VAULT_REDESIGN_PLAN.md v4 V11 — post-migration this resolves to
+ * `<contextDir>/policies/skills`). Tests may pass any directory directly so
+ * the helper remains decoupled from `AgentConfig`.
+ */
+export function findBuiltinShadowedUserSkills(userSkillsRoot, workspaceDir) {
+    const userSkills = new Set(listSkillSlugs(userSkillsRoot));
     const builtinSkills = listSkillSlugs(join(workspaceDir, "agent-assets", "skills"));
     return builtinSkills.filter((slug) => userSkills.has(slug));
 }
-export function recordSkillAssetStatus(db, dataDir, workspaceDir, now) {
+/**
+ * Union of every known skill slug — built-in (`<workspaceDir>/agent-assets/
+ * skills`) and user (`userSkillsRoot`, derived via `resolveUserSkillsRoot`).
+ * The Agent loader's `tools.skills` cross-check (AGENT_DEFINITIONS_DESIGN.md
+ * §4.3 step 5) consults this so a user Agent referencing an unknown skill is
+ * warned at load. Returns a `ReadonlySet` matching the loader's
+ * `listSkillSlugs` port shape; either root may be absent (→ empty contribution).
+ */
+export function listAllSkillSlugs(userSkillsRoot, workspaceDir) {
+    const all = new Set(listSkillSlugs(join(workspaceDir, "agent-assets", "skills")));
+    for (const slug of listSkillSlugs(userSkillsRoot))
+        all.add(slug);
+    return all;
+}
+export function recordSkillAssetStatus(db, userSkillsRoot, workspaceDir, now) {
     const status = {
         checkedAt: iso(now),
-        builtinShadowedUserSkills: findBuiltinShadowedUserSkills(dataDir, workspaceDir),
+        builtinShadowedUserSkills: findBuiltinShadowedUserSkills(userSkillsRoot, workspaceDir),
     };
     updateReleaseAssetStatus(db, { skills: status }, status.checkedAt);
     return status;
@@ -486,4 +507,3 @@ export function sourceFileStats(root) {
     }
     return { files, bytes };
 }
-//# sourceMappingURL=release-assets.js.map

package/dist/core/repository-management-docs.d.ts

@@ -237,4 +237,3 @@ export declare const ARCHITECTURE_MARKERS: {
     readonly end: "<!-- architecture:end -->";
     readonly placeholder: "_Architecture analysis pending. Click \"Refresh architecture\" on the Daily git management panel — an agent will read the repository and replace this block with a detailed module / data-flow / integration breakdown._";
 };
-//# sourceMappingURL=repository-management-docs.d.ts.map

package/dist/core/repository-management-docs.js

@@ -217,11 +217,15 @@ export function enqueueArchitectureRefresh(db, repo, now = new Date()) {
         category: repo.category,
         correlationId,
     };
+    const archLabel = `Refresh architecture analysis for ${repo.slug}.`;
     const result = db
         .prepare(`INSERT INTO agent_schedule
-         (scheduled_for, task_type, task_description, task_context, correlation_id, model, status)
-       VALUES (?, 'git.project.refresh_architecture', ?, ?, ?, NULL, 'pending')`)
-        .run(formatSqliteDatetime(now), `Refresh architecture analysis for ${repo.slug}.`, JSON.stringify(taskContext), correlationId);
+         (scheduled_for, task_type, task_description, task_prompt, task_context, correlation_id, model, status)
+       VALUES (?, 'git.project.refresh_architecture', ?, ?, ?, ?, NULL, 'pending')`)
+        .run(formatSqliteDatetime(now), 
+    // task_description (label) === task_prompt (agent body); routing is via
+    // task_context.processKey = "git.project.refresh_architecture".
+    archLabel, archLabel, JSON.stringify(taskContext), correlationId);
     return { scheduleId: Number(result.lastInsertRowid), correlationId };
 }
 /**
@@ -438,7 +442,7 @@ function copyRepositoryReadme(deps, localPath) {
     if (!fileName)
         return null;
     const src = join(localPath, fileName);
-    const relPath = `git/${deps.repo.slug}/README.md`;
+    const relPath = `knowledge/repos/${deps.repo.slug}/README.md`;
     let body;
     try {
         body = readFileSync(src, "utf-8");
@@ -655,8 +659,15 @@ async function appendOverviewDailyLog(deps, params) {
         if (!existsSync(absolutePath))
             return;
         const current = readFileSync(absolutePath, "utf-8");
+        // Normalize CRLF→LF for the split/filter/join + marker work, then
+        // restore the original line ending at the single final emit. Mirrors
+        // `mergeArchitectureSection`, which writes the same overview file and
+        // already treats it as possibly CRLF — without this, a CRLF overview
+        // would collapse to LF here and show a dirty git diff on Windows.
+        const wasCrlf = /\r\n/.test(current);
+        const normalized = wasCrlf ? current.replace(/\r\n/g, "\n") : current;
         const summary = `- ${params.date}: ${params.commitCount} commits; ${params.prEvents} PR/notification events; ${params.workflowEvents} workflow events.`;
-        const withoutOldSameDay = current
+        const withoutOldSameDay = normalized
             .split("\n")
             .filter((line) => keepDailyLogLine(line, params.date))
             .join("\n");
@@ -665,7 +676,8 @@ async function appendOverviewDailyLog(deps, params) {
         const next = withUpdated.includes(marker)
             ? withUpdated.replace(marker, `${marker}\n\n${summary}`)
             : `${withUpdated.trimEnd()}\n\n${marker}\n\n${summary}\n`;
-        writeManagedContextFile(deps, params.overviewPath, next, "repository_management_scan_overview");
+        const out = wasCrlf ? next.replace(/\n/g, "\r\n") : next;
+        writeManagedContextFile(deps, params.overviewPath, out, "repository_management_scan_overview");
     });
 }
 function keepDailyLogLine(line, today) {
@@ -1046,4 +1058,3 @@ export const ARCHITECTURE_MARKERS = {
     end: ARCHITECTURE_END_MARKER,
     placeholder: ARCHITECTURE_PLACEHOLDER,
 };
-//# sourceMappingURL=repository-management-docs.js.map

package/dist/core/retention.d.ts

@@ -57,6 +57,52 @@ export interface RetentionResult {
     integrationWrites: number;
     /** Stale `imminent_event_notifications` rows pruned (Phase 7 §3.2). */
     imminentEventNotifications: number;
+    /**
+     * Phase B-2 audit rows pruned from `browser_automation_workflows`
+     * (`browserAutomationWorkflows` retention day count). Paired with
+     * `browserAutomationTraceDirs` below; the SQL row goes first so a
+     * partial failure does not leave a row pointing at a missing trace
+     * dir.
+     */
+    browserAutomationWorkflows: number;
+    /** Phase B-2 per-workflow trace directories pruned from
+     *  `<PA_DATA_DIR>/automation-traces/`. Same retention horizon as
+     *  `browserAutomationWorkflows`. */
+    browserAutomationTraceDirs: number;
+    /** Phase B-4 — pending purchase tokens past their 5-min TTL flipped
+     *  to expired (and their `cancel_reason` set to `timeout`) during
+     *  the sweep. */
+    browserAutomationPurchaseTokensExpired: number;
+    /** Phase B-4 — consumed-but-not-finalized rows older than the
+     *  per-workflow grace window, flipped to cancelled with reason
+     *  `supervisor_orphan_sweep`. Catches daemon-crash mid-flight + any
+     *  post-consume Playwright stall that left the row stranded. */
+    browserAutomationPurchaseTokensOrphaned: number;
+    /** Phase B-4 — terminal purchase-token rows whose raw `token` was
+     *  rotated to NULL during this sweep. */
+    browserAutomationPurchaseTokensScrubbed: number;
+    /** Phase B-4 — `_replies` audit rows older than the retention
+     *  horizon, deleted during this sweep. */
+    browserAutomationPurchaseRepliesDeleted: number;
+    /**
+     * BROWSER_TASK_REDESIGN_PLAN.md §6.5 — terminal `browser_task` rows
+     * pruned during this sweep (children cascade via FK). Non-terminal
+     * rows are never counted here; boot-recovery owns them.
+     */
+    browserTask: number;
+    /**
+     * BROWSER_TASK_REDESIGN_PLAN.md §5 — pending lite-final-confirm
+     * tokens past their 5-min TTL flipped to `expired` during this sweep
+     * (mirrors B-4's `browserAutomationPurchaseTokensExpired`).
+     */
+    browserTaskFinalConfirmTokensExpired: number;
+    /**
+     * BROWSER_TASK_REDESIGN_PLAN.md §14.11 Q#6 — terminal
+     * lite-final-confirm token rows whose raw `token` was rotated to NULL
+     * during this sweep (mirrors B-4's
+     * `browserAutomationPurchaseTokensScrubbed`).
+     */
+    browserTaskFinalConfirmTokensScrubbed: number;
     /** Whether FTS5 segment optimization ran after content-table deletions. */
     ftsOptimized: boolean;
     /** Whether WAL checkpoint (TRUNCATE) succeeded after all DB operations. */
@@ -76,7 +122,7 @@ export declare function runRetentionCleanup(db: Database.Database, config: Agent
  * newer, zero if equal. Suitable as a sort comparator.
  *
  * Why not a plain string comparison? The `## Weekly YYYY-Www` header in
- * `agent/journal.md` is written by an LLM following the review prompt.
+ * `journal/agent.md` is written by an LLM following the review prompt.
  * The prompt asks for zero-padded ISO week numbers, but compliance is
  * probabilistic — the model may emit `2026-W5` instead of `2026-W05`,
  * or a backfill may use a different convention. Lexicographic compare
@@ -112,7 +158,7 @@ export declare function compareWeeklyKey(a: string, b: string): number;
  */
 export declare function compareMonthlyKey(a: string, b: string): number;
 /**
- * Roll up `agent/journal.md` in place. Three independent passes applied in
+ * Roll up `journal/agent.md` in place. Three independent passes applied in
  * order to a single parsed section list:
  *
  *   1. **Dedup (last-write-wins).** If the same `## Weekly YYYY-Www` or
@@ -150,7 +196,7 @@ export declare function rollupAgentJournal(filePath: string, keepWeeklySections:
  */
 onBeforeWrite?: (content: string) => void): AgentJournalRollupResult;
 /**
- * Read-only health check for `agent/journal.md`. Returns section counts and
+ * Read-only health check for `journal/agent.md`. Returns section counts and
  * any oversized sections without modifying the file. Intended for the health
  * endpoint so the dashboard can surface journal bloat without requiring the
  * operator to watch structured logs.
@@ -161,4 +207,3 @@ export declare function checkAgentJournalHealth(filePath: string, sectionSizeWar
     monthlySections: number;
     oversizedSections: string[];
 };
-//# sourceMappingURL=retention.d.ts.map