@aitne/daemon 0.1.8 → 0.1.10

package/dist/core/browser-history/pre-morning-digest-job.js

@@ -0,0 +1,89 @@
+import { resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { writeFileAtomically } from "../atomic-write.js";
+import { buildPreMorningDigest, digestDateForNow, preMorningDigestRelativePath, renderPreMorningDigestMarkdown, } from "../../services/browser-history/pipeline/pre-morning-digest.js";
+import { preMorningDigestSchema, } from "@aitne/shared";
+import { createLogger } from "../../logging.js";
+const logger = createLogger("browser-history-pre-morning-digest");
+export function digestPaths(contextDir, dateStr) {
+    const contextRelative = preMorningDigestRelativePath(dateStr);
+    const markdownPath = resolve(contextDir, contextRelative);
+    const jsonPath = markdownPath.replace(/\.md$/, ".json");
+    return { markdownPath, jsonPath, contextRelative };
+}
+/**
+ * Build + persist the digest for the agent-day "now" is inside of.
+ * Returns the typed digest so callers (the API route's
+ * rebuild-on-demand path, tests) can use the same code shape as the
+ * cron call site.
+ */
+export function runPreMorningDigestJob(args) {
+    const { db, contextDir, boundary } = args;
+    const nowMs = args.nowMs ?? Date.now();
+    const date = digestDateForNow(boundary, nowMs);
+    const digest = buildPreMorningDigest({
+        db,
+        date,
+        boundary,
+        options: { nowMs },
+    });
+    const paths = digestPaths(contextDir, date);
+    const markdown = renderPreMorningDigestMarkdown(digest);
+    // JSON sidecar first — it is the API's source of truth. Writing the
+    // markdown after means a partial-failure leaves the JSON missing if
+    // the markdown write fails, but never the other way around (which
+    // would let the journal read stale prose with no API parity).
+    writeFileAtomically(paths.jsonPath, JSON.stringify(digest, null, 2) + "\n");
+    writeFileAtomically(paths.markdownPath, markdown);
+    return { date, paths, digest };
+}
+/**
+ * Read the JSON sidecar for the given agent-day, Zod-validate it, and
+ * return the typed digest. Returns null when the file is missing or
+ * the bytes do not parse — the API caller can then rebuild fresh.
+ *
+ * Validation matters here: the journal Stage B task-flow trusts the
+ * file's schema invariants (no raw URLs / titles). Returning unvetted
+ * JSON would let a corrupt sidecar bypass that boundary.
+ */
+export function readPreMorningDigestJsonForDate(contextDir, dateStr) {
+    const { jsonPath } = digestPaths(contextDir, dateStr);
+    if (!existsSync(jsonPath))
+        return null;
+    try {
+        const raw = readFileSync(jsonPath, "utf-8");
+        const parsed = preMorningDigestSchema.safeParse(JSON.parse(raw));
+        return parsed.success ? parsed.data : null;
+    }
+    catch (err) {
+        // A read / parse error is recoverable — caller rebuilds. We log so
+        // the operator can investigate, but do not throw upward into the
+        // request handler.
+        logger.warn({ err, jsonPath }, "Failed to read pre-morning digest JSON sidecar; caller will rebuild");
+        return null;
+    }
+}
+/**
+ * Wrapper safe to register as a fire-and-forget cron callback. Catches
+ * every error so a transient SQL failure or filesystem hiccup cannot
+ * crash the scheduler's cron tick. Returns the result for callers that
+ * want to inspect outcomes (tests / dashboards / future audit hooks).
+ */
+export function safeRunPreMorningDigestJob(args) {
+    try {
+        const result = runPreMorningDigestJob(args);
+        logger.info({
+            date: result.date,
+            clusters: result.digest.clusters.length,
+            shopping: result.digest.shopping.length,
+            reloads: result.digest.reloads.length,
+            pendingOffers: result.digest.pendingOffers.length,
+            newThresholds: result.digest.newThresholdsCount,
+        }, "Pre-morning digest written");
+        return result;
+    }
+    catch (err) {
+        logger.error({ err }, "Pre-morning digest job failed; the morning journal will fall back to the API endpoint");
+        return null;
+    }
+}

package/dist/core/browser-history/research-cluster-fanout.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Day-boundary fan-out helper — enumerates active research clusters
+ * with new meaningful activity in the last 24h and emits one
+ * `routine.research_cluster_update` event per cluster onto the
+ * EventBus. Called once per agent-day from the scheduler's day-boundary
+ * callback (see `bootstrap/index.ts`).
+ *
+ * BROWSER_HISTORY_INTEGRATION_PLAN §10.6 step 3.
+ *
+ * Pure orchestration — no LLM in this path. The fan-out is bounded by
+ * the `limit` parameter (default 25) so a backlog from a long outage
+ * cannot flood the event queue. Clusters that miss this cycle pick up
+ * on the next day-boundary fire; the next cycle's DB query naturally
+ * sees them as "still active with new activity since prior update".
+ */
+import type Database from "better-sqlite3";
+export interface EventBusLike {
+    put(event: import("@aitne/shared").Event): Promise<void>;
+}
+export declare const RESEARCH_CLUSTER_FANOUT_LOOKBACK_MS: number;
+export declare const RESEARCH_CLUSTER_FANOUT_LIMIT = 25;
+export interface FanoutResult {
+    enqueuedSlugs: string[];
+}
+/**
+ * Enumerate active clusters with new meaningful activity since the last
+ * day-boundary cycle and enqueue one `routine.research_cluster_update`
+ * event per cluster. Always returns the slugs it enqueued so the caller
+ * can log a structured summary.
+ *
+ * When `eventBus` is absent (early-boot path before EventBus wiring),
+ * the function returns an empty result without throwing — the next
+ * day-boundary tick re-evaluates and picks up the clusters once
+ * messaging is live.
+ */
+export declare function fanoutResearchClusterUpdates(db: Database.Database, eventBus: EventBusLike | null | undefined, options?: {
+    lookbackMs?: number;
+    limit?: number;
+    nowMs?: number;
+}): Promise<FanoutResult>;

package/dist/core/browser-history/research-cluster-fanout.js

@@ -0,0 +1,47 @@
+/**
+ * Day-boundary fan-out helper — enumerates active research clusters
+ * with new meaningful activity in the last 24h and emits one
+ * `routine.research_cluster_update` event per cluster onto the
+ * EventBus. Called once per agent-day from the scheduler's day-boundary
+ * callback (see `bootstrap/index.ts`).
+ *
+ * BROWSER_HISTORY_INTEGRATION_PLAN §10.6 step 3.
+ *
+ * Pure orchestration — no LLM in this path. The fan-out is bounded by
+ * the `limit` parameter (default 25) so a backlog from a long outage
+ * cannot flood the event queue. Clusters that miss this cycle pick up
+ * on the next day-boundary fire; the next cycle's DB query naturally
+ * sees them as "still active with new activity since prior update".
+ */
+import { listClustersNeedingUpdate } from "../../db/browser-history-store.js";
+import { createResearchCommandEvent } from "./research-events.js";
+export const RESEARCH_CLUSTER_FANOUT_LOOKBACK_MS = 24 * 60 * 60 * 1000;
+export const RESEARCH_CLUSTER_FANOUT_LIMIT = 25;
+/**
+ * Enumerate active clusters with new meaningful activity since the last
+ * day-boundary cycle and enqueue one `routine.research_cluster_update`
+ * event per cluster. Always returns the slugs it enqueued so the caller
+ * can log a structured summary.
+ *
+ * When `eventBus` is absent (early-boot path before EventBus wiring),
+ * the function returns an empty result without throwing — the next
+ * day-boundary tick re-evaluates and picks up the clusters once
+ * messaging is live.
+ */
+export async function fanoutResearchClusterUpdates(db, eventBus, options = {}) {
+    if (!eventBus)
+        return { enqueuedSlugs: [] };
+    const lookbackMs = options.lookbackMs ?? RESEARCH_CLUSTER_FANOUT_LOOKBACK_MS;
+    const limit = options.limit ?? RESEARCH_CLUSTER_FANOUT_LIMIT;
+    const nowMs = options.nowMs ?? Date.now();
+    const rows = listClustersNeedingUpdate(db, lookbackMs, nowMs, limit);
+    const enqueuedSlugs = [];
+    for (const row of rows) {
+        await eventBus.put(createResearchCommandEvent({
+            processKey: "routine.research_cluster_update",
+            slug: row.slug,
+        }));
+        enqueuedSlugs.push(row.slug);
+    }
+    return { enqueuedSlugs };
+}

package/dist/core/browser-history/research-events.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Event factories for browser-history research process keys
+ * (BROWSER_HISTORY_INTEGRATION_PLAN §10.6 / §5.F1).
+ *
+ * Three process keys flow through this module:
+ *   - routine.research_cluster_update   — nightly journal append
+ *   - routine.research_dispatch         — !research accept <slug>
+ *   - routine.research_wiki_summary     — !research wiki <slug>
+ *
+ * Each event is shaped after the wiki-dispatcher pattern
+ * (`packages/daemon/src/core/wiki/dispatcher.ts`) so the EventBus's
+ * generic routing path picks them up: `event.type` IS the process key,
+ * `event.data.slug` carries the cluster identifier, and
+ * `event.data.reply_target` carries the originating DM routing tuple
+ * when a bang command minted the event (so the agent's DM lands back
+ * on the platform the user typed `!research accept` on, not a fan-out
+ * to every connected destination).
+ *
+ * The factory is pure — no DB, no side effects. Callers (bang command
+ * handler, API route) construct the event, push it onto the EventBus,
+ * and the dispatcher resolves backend / model / max_turns from
+ * `process_backend_config`.
+ */
+import { EventPriority, type Event } from "@aitne/shared";
+export declare const RESEARCH_PROCESS_KEYS: readonly ["routine.research_cluster_update", "routine.research_offer_dm", "routine.research_dispatch", "routine.research_wiki_summary"];
+export type ResearchProcessKey = (typeof RESEARCH_PROCESS_KEYS)[number];
+export declare function isResearchProcessKey(value: string): value is ResearchProcessKey;
+export interface ResearchCommandEventInput {
+    processKey: ResearchProcessKey;
+    slug: string;
+    /** Originating DM, if any, for reply routing. */
+    sourceEvent?: Event;
+    /** Extra event payload (for cluster_update: optional `displayName`). */
+    data?: Record<string, unknown>;
+    priority?: EventPriority;
+}
+export declare function createResearchCommandEvent(input: ResearchCommandEventInput): Event;

package/dist/core/browser-history/research-events.js

@@ -0,0 +1,70 @@
+/**
+ * Event factories for browser-history research process keys
+ * (BROWSER_HISTORY_INTEGRATION_PLAN §10.6 / §5.F1).
+ *
+ * Three process keys flow through this module:
+ *   - routine.research_cluster_update   — nightly journal append
+ *   - routine.research_dispatch         — !research accept <slug>
+ *   - routine.research_wiki_summary     — !research wiki <slug>
+ *
+ * Each event is shaped after the wiki-dispatcher pattern
+ * (`packages/daemon/src/core/wiki/dispatcher.ts`) so the EventBus's
+ * generic routing path picks them up: `event.type` IS the process key,
+ * `event.data.slug` carries the cluster identifier, and
+ * `event.data.reply_target` carries the originating DM routing tuple
+ * when a bang command minted the event (so the agent's DM lands back
+ * on the platform the user typed `!research accept` on, not a fan-out
+ * to every connected destination).
+ *
+ * The factory is pure — no DB, no side effects. Callers (bang command
+ * handler, API route) construct the event, push it onto the EventBus,
+ * and the dispatcher resolves backend / model / max_turns from
+ * `process_backend_config`.
+ */
+import { createEvent, EventPriority, isMessageEvent, } from "@aitne/shared";
+export const RESEARCH_PROCESS_KEYS = [
+    "routine.research_cluster_update",
+    "routine.research_offer_dm",
+    "routine.research_dispatch",
+    "routine.research_wiki_summary",
+];
+export function isResearchProcessKey(value) {
+    return RESEARCH_PROCESS_KEYS.includes(value);
+}
+export function createResearchCommandEvent(input) {
+    // Mirror the wiki dispatcher's data-merge order: caller data first,
+    // daemon fields last, so a caller cannot hijack routing by passing
+    // `reply_target` / `slug` in `data`. The factory's typed `slug`
+    // wins over any same-key value in `data`.
+    const replyTarget = input.sourceEvent && isMessageEvent(input.sourceEvent)
+        ? {
+            platform: input.sourceEvent.platform,
+            channel: input.sourceEvent.channel,
+            threadId: input.sourceEvent.threadId,
+            sender: input.sourceEvent.sender,
+        }
+        : undefined;
+    // `RoutineEvent.routine` is the documented contract on every
+    // `routine.*` event (see RoutineEvent in @aitne/shared types.ts). The
+    // dispatcher's `isRoutineEvent` branch reads it; omitting the field
+    // and relying on the fall-through `executeDefault` would make the
+    // `event as RoutineEvent` cast in the dispatcher's executeDefault
+    // branch lie about the runtime shape. Strip the `routine.` prefix to
+    // match the canonical morning/evening/weekly entries.
+    const routineKey = input.processKey.slice("routine.".length);
+    const base = createEvent({
+        type: input.processKey,
+        source: input.sourceEvent ? "browser_history.bang" : "browser_history.cron",
+        priority: input.priority ?? EventPriority.NORMAL,
+        data: {
+            ...(input.data ?? {}),
+            slug: input.slug,
+            ...(input.sourceEvent
+                ? { parent_correlation_id: input.sourceEvent.correlationId }
+                : {}),
+            ...(replyTarget ? { reply_target: replyTarget } : {}),
+        },
+    });
+    const event = { ...base, routine: routineKey };
+    return event;
+}

package/dist/core/channel-timeline.d.ts

@@ -42,4 +42,3 @@ export declare function recordProactiveForwardDeliveries(params: {
     originSessionIds?: Array<number | null | undefined>;
     notificationType: ProactiveForwardType;
 }): ProactiveForwardRecordResult;
-//# sourceMappingURL=channel-timeline.d.ts.map

package/dist/core/channel-timeline.js

@@ -158,4 +158,3 @@ function dedupeNumbers(values) {
         ...new Set(values.filter((value) => typeof value === "number" && Number.isInteger(value) && value > 0)),
     ];
 }
-//# sourceMappingURL=channel-timeline.js.map

package/dist/core/character-block.d.ts

@@ -34,4 +34,3 @@ export declare function buildCharacterBlock(character: string): string | null;
  * relies on to avoid thrashing active session files.
  */
 export declare function applyCharacterBlockRewrite(content: string, character: string): string;
-//# sourceMappingURL=character-block.d.ts.map

package/dist/core/character-block.js

@@ -159,4 +159,3 @@ function findFirstSectionHeading(content) {
     const idx = content.indexOf("\n## ");
     return idx < 0 ? -1 : idx + 1;
 }
-//# sourceMappingURL=character-block.js.map

package/dist/core/context/activity-sources.d.ts

@@ -3,12 +3,12 @@ import type Database from "better-sqlite3";
  * Activity-source enumeration (docs/design/21-management-registry-and-
  * entities.md §9.6). Lifted out of `activity-view-runner.ts` so the
  * dashboard can consume the same union the runner renders into
- * `_activity/<source>.md` (followups doc Issue 3).
+ * `state/activity/<source>.md` (followups doc Issue 3).
  *
  * The "active source set" is the union of three projections:
  *
  *   1. `managed_tasks.app_normalized` — the registered fetches (Section
- *      B of `rules/management.md`).
+ *      B of `policies/management.md`).
  *   2. `entity_source_keys.source_key` — every L2 entity file that
  *      mentions a source key, joined to the entity's date / sync window.
  *   3. `agent_actions.detail->>app_normalized` — recent management_task
@@ -19,7 +19,7 @@ import type Database from "better-sqlite3";
  *   - `active`  — there is a row in `managed_tasks` for this normalized
  *                 form (Settings → Management can edit it).
  *   - `stopped` — the source appears only in (2) or (3); typically a
- *                 recently stopped task whose `_activity/<source>.md`
+ *                 recently stopped task whose `state/activity/<source>.md`
  *                 file is still on disk for the 90-day window. The
  *                 dashboard's Activity tab keeps showing it; the
  *                 Settings → Management page does not (it only edits
@@ -34,4 +34,3 @@ export interface ActivitySourceRef {
     status: "active" | "stopped";
 }
 export declare function enumerateActivitySources(db: Database.Database, cutoffDate: string): ActivitySourceRef[];
-//# sourceMappingURL=activity-sources.d.ts.map

package/dist/core/context/activity-sources.js

@@ -66,4 +66,3 @@ export function enumerateActivitySources(db, cutoffDate) {
     }))
         .sort((a, b) => a.normalized.localeCompare(b.normalized));
 }
-//# sourceMappingURL=activity-sources.js.map

package/dist/core/context/activity-view-reconciler.d.ts

@@ -80,7 +80,7 @@ export interface ActivitySnapshot {
 export declare function activityFileSlugFor(source: string): string | null;
 /**
  * Relative path under `<contextDir>` for the activity file. Matches
- * the §9.6 layout `_activity/<source>.md`. The leading underscore is
+ * the §9.6 layout `state/activity/<source>.md`. The leading underscore is
  * the convention for auto-generated views (same as `_index.md`).
  */
 export declare function relativeActivityPath(slug: string): string;
@@ -107,4 +107,3 @@ export declare function sortRecentlyChangedRows(rows: readonly RecentlyChangedIn
  * deterministically.
  */
 export declare function windowCutoffDate(now: Date, windowDays: number): string;
-//# sourceMappingURL=activity-view-reconciler.d.ts.map

package/dist/core/context/activity-view-reconciler.js

@@ -1,7 +1,7 @@
 import { normalizeAppLabel } from "@aitne/shared";
 /**
  * Activity-view reconciler — pure render + snapshot helpers for
- * `<contextDir>/_activity/<source>.md`
+ * `<contextDir>/state/activity/<source>.md`
  * (docs/design/21-management-registry-and-entities.md §7.2 / §9.6).
  *
  * Inputs:
@@ -11,7 +11,7 @@ import { normalizeAppLabel } from "@aitne/shared";
  *     "Recently changed" section.
  *
  * Output is a chronological per-source view; the LLM's query path
- * (§7.5) reads `_activity/<source>.md` for the date, then follows the
+ * (§7.5) reads `state/activity/<source>.md` for the date, then follows the
  * link into the entity file. The activity file is short on details
  * (entity title + per-entity source metadata + a managed-task tag) so
  * the prompt-injection budget stays modest even with hundreds of
@@ -50,11 +50,11 @@ export function activityFileSlugFor(source) {
 }
 /**
  * Relative path under `<contextDir>` for the activity file. Matches
- * the §9.6 layout `_activity/<source>.md`. The leading underscore is
+ * the §9.6 layout `state/activity/<source>.md`. The leading underscore is
  * the convention for auto-generated views (same as `_index.md`).
  */
 export function relativeActivityPath(slug) {
-    return `_activity/${slug}.md`;
+    return `state/activity/${slug}.md`;
 }
 // ── Render ────────────────────────────────────────────────────────────────
 /**
@@ -160,11 +160,12 @@ function formatRecentlyChanged(row) {
 }
 function formatEntity(entity) {
     const head = entity.timeRange ? `${entity.timeRange} ` : "";
-    // The activity file lives at `_activity/<slug>.md`; entity files
-    // live at `<domain>/<type-plural>/<slug>.md`. From the activity
-    // file's perspective an entity at `work/meetings/foo.md` is at
-    // `../work/meetings/foo.md`.
-    const link = `../${entity.entityRelativePath}`;
+    // After CONTEXT_VAULT_REDESIGN the activity file lives at
+    // `state/activity/<slug>.md` and entity files live at
+    // `knowledge/entities/<domain>/<type-plural>/<slug>.md`. From the
+    // activity file's perspective both trees are siblings under the vault
+    // root; the relative link climbs two levels first.
+    const link = `../../${entity.entityRelativePath}`;
     const title = `[${escapeMd(entity.title)}](${link})`;
     const tail = formatEntityTail(entity);
     return `${head}${title}${tail}`;
@@ -249,4 +250,3 @@ export function windowCutoffDate(now, windowDays) {
     const cutoff = new Date(now.getTime() - windowDays * 86400_000);
     return cutoff.toISOString().slice(0, 10);
 }
-//# sourceMappingURL=activity-view-reconciler.js.map

package/dist/core/context/activity-view-runner.d.ts

@@ -35,4 +35,3 @@ export interface RunActivityViewReconcilerOptions {
  *   - `refreshedMtime`  → number of files that already matched on disk
  */
 export declare function runActivityViewReconciler(opts: RunActivityViewReconcilerOptions): Promise<ReconcilerRunRecord>;
-//# sourceMappingURL=activity-view-runner.d.ts.map

package/dist/core/context/activity-view-runner.js

@@ -9,7 +9,8 @@ import { ACTIVITY_VIEW_WINDOW_DAYS, activityFileSlugFor, relativeActivityPath, r
 const logger = createLogger("activity-view-reconciler");
 /** Runtime-state key for the activity-view reconciler's last run record. */
 export const ACTIVITY_VIEW_RECONCILER_LAST_RUN_KEY = "reconciler.activity_view.last_run";
-const ACTIVITY_DIR = "_activity";
+// CONTEXT_VAULT_REDESIGN: activity views live under state/activity/.
+const ACTIVITY_DIR = "state/activity";
 let runnerMutex = Promise.resolve();
 /**
  * Drive one pass of the activity-view reconciler:
@@ -407,4 +408,3 @@ function persistRunRecord(db, record) {
         logger.warn({ err, record }, "Activity-view reconciler run record persistence failed");
     }
 }
-//# sourceMappingURL=activity-view-runner.js.map

package/dist/core/context/default-schedules-reconciler.d.ts

@@ -1,6 +1,6 @@
 /**
  * SCHEDULED-DM-IMPLEMENTATION-PLAN §6.5 — pure logic for the
- * `## Default Schedules` section of `rules/management.md`. Mirrors
+ * `## Default Schedules` section of `policies/management.md`. Mirrors
  * `policy-index-reconciler.ts` exactly — snapshot → rendered output,
  * with no DB or fs I/O. The runner (`default-schedules-runner.ts`)
  * drives it.
@@ -82,4 +82,3 @@ export declare function extractDefaultSchedulesSection(content: string): string
  * description when no sub_flow is present.
  */
 export declare function deriveDefaultScheduleLabel(subFlow: string | null, description: string): string;
-//# sourceMappingURL=default-schedules-reconciler.d.ts.map

package/dist/core/context/default-schedules-reconciler.js

@@ -1,6 +1,6 @@
 /**
  * SCHEDULED-DM-IMPLEMENTATION-PLAN §6.5 — pure logic for the
- * `## Default Schedules` section of `rules/management.md`. Mirrors
+ * `## Default Schedules` section of `policies/management.md`. Mirrors
  * `policy-index-reconciler.ts` exactly — snapshot → rendered output,
  * with no DB or fs I/O. The runner (`default-schedules-runner.ts`)
  * drives it.
@@ -150,4 +150,3 @@ export function deriveDefaultScheduleLabel(subFlow, description) {
         return description.trim() || EM_DASH;
     return words.charAt(0).toUpperCase() + words.slice(1);
 }
-//# sourceMappingURL=default-schedules-reconciler.js.map

package/dist/core/context/default-schedules-runner.d.ts

@@ -37,4 +37,3 @@ export declare function runDefaultSchedulesReconciler(opts: RunDefaultSchedulesR
  * directly (in-place splice without going through the runner).
  */
 export declare function buildDefaultSchedulesSnapshot(db: Database.Database): DefaultScheduleSnapshotEntry[];
-//# sourceMappingURL=default-schedules-runner.d.ts.map

package/dist/core/context/default-schedules-runner.js

@@ -270,4 +270,3 @@ function persistRunRecord(db, record) {
         logger.warn({ err, record }, "Default-schedules reconciler run record persistence failed");
     }
 }
-//# sourceMappingURL=default-schedules-runner.js.map

package/dist/core/context/domain-index-reconciler.d.ts

@@ -70,6 +70,9 @@ export declare function relativeDomainIndexPath(domain: Domain): string;
  * Validate a relative path looks like a domain index. Used by the
  * runner's safety check before writing — defense-in-depth against a
  * caller-supplied domain that was tampered with.
+ *
+ * After CONTEXT_VAULT_REDESIGN domain indexes live at
+ * `knowledge/entities/<domain>/_index.md`.
  */
 export declare function isDomainIndexPath(relativePath: string): boolean;
 /**
@@ -78,4 +81,3 @@ export declare function isDomainIndexPath(relativePath: string): boolean;
  * for tests that exercise foreign paths).
  */
 export declare function entityDirToDomain(relativeDir: string): Domain | null;
-//# sourceMappingURL=domain-index-reconciler.d.ts.map

package/dist/core/context/domain-index-reconciler.js

@@ -165,20 +165,27 @@ function capitalize(value) {
  * runner uses this to resolve the absolute write target.
  */
 export function relativeDomainIndexPath(domain) {
-    return `${domain}/_index.md`;
+    return `knowledge/entities/${domain}/_index.md`;
 }
 /**
  * Validate a relative path looks like a domain index. Used by the
  * runner's safety check before writing — defense-in-depth against a
  * caller-supplied domain that was tampered with.
+ *
+ * After CONTEXT_VAULT_REDESIGN domain indexes live at
+ * `knowledge/entities/<domain>/_index.md`.
  */
 export function isDomainIndexPath(relativePath) {
     const segments = relativePath.split("/");
-    if (segments.length !== 2)
+    if (segments.length !== 4)
+        return false;
+    if (segments[0] !== "knowledge")
+        return false;
+    if (segments[1] !== "entities")
         return false;
-    if (segments[1] !== "_index.md")
+    if (segments[3] !== "_index.md")
         return false;
-    return DOMAINS.includes(segments[0]);
+    return DOMAINS.includes(segments[2]);
 }
 /**
  * Map an L2 entity directory back to its parent domain. Returns `null`
@@ -196,4 +203,3 @@ export function entityDirToDomain(relativeDir) {
         return null;
     return domain;
 }
-//# sourceMappingURL=domain-index-reconciler.js.map

package/dist/core/context/domain-index-runner.d.ts

@@ -32,4 +32,3 @@ export interface RunDomainIndexReconcilerOptions {
  *   - `refreshedMtime`  → number of files that already matched on disk
  */
 export declare function runDomainIndexReconciler(opts: RunDomainIndexReconcilerOptions): Promise<ReconcilerRunRecord>;
-//# sourceMappingURL=domain-index-runner.d.ts.map

package/dist/core/context/domain-index-runner.js

@@ -228,4 +228,3 @@ function persistRunRecord(db, record) {
         logger.warn({ err, record }, "Domain-index reconciler run record persistence failed");
     }
 }
-//# sourceMappingURL=domain-index-runner.js.map

package/dist/core/context/entity-mirror.d.ts

@@ -185,8 +185,9 @@ export declare function refreshEntityMirrorForPath(opts: RefreshOneOptions): Sin
 export declare function toRelativePath(contextDir: string, absolutePath: string): string | null;
 /**
  * True when the given relative path matches the L2 layout
- * `<domain>/<type-plural>/<slug>.md`. Does NOT validate the slug — that
- * is the parser's job — only the directory shape.
+ * `knowledge/entities/<domain>/<type-plural>/<slug>.md` (CONTEXT_VAULT_REDESIGN
+ * v4 V14). Does NOT validate the slug — that is the parser's job — only the
+ * directory shape and `_*.md` skip.
  */
 export declare function isL2EntityRelativePath(relativePath: string): boolean;
 export interface EntityMirrorWatcherOptions {
@@ -202,10 +203,12 @@ export interface EntityMirrorWatcherOptions {
      * because `shouldIndexPath` filters L2 paths out of the context-
      * index's own watcher (followups item 7).
      *
-     * No fan-out risk: the reconciler outputs (`<domain>/_index.md`,
-     * `_activity/<source>.md`) live outside the entity-mirror watcher's
-     * `<contextDir>/<domain>/<plural>/*.md` patterns and `_*.md` is
-     * explicitly ignored, so the chain cannot loop back through this
+     * No fan-out risk: the reconciler outputs
+     * (`knowledge/entities/<domain>/_index.md`,
+     * `state/activity/<source>.md`) live outside the entity-mirror
+     * watcher's `<contextDir>/knowledge/entities/<domain>/<plural>/*.md`
+     * patterns (domain-index uses `_*.md` which is ignored; Activity
+     * lives under `state/`), so the chain cannot loop back through this
      * observer.
      */
     onEntityChanged?: () => void;
@@ -224,4 +227,3 @@ export interface EntityMirrorWatcherHandle {
     stop(): Promise<void>;
 }
 export declare function startEntityMirrorWatcher(opts: EntityMirrorWatcherOptions): EntityMirrorWatcherHandle;
-//# sourceMappingURL=entity-mirror.d.ts.map

package/dist/core/context/entity-mirror.js

@@ -290,8 +290,11 @@ export function enumerateEntityFiles(contextDir) {
     if (!existsSync(contextDir))
         return [];
     const out = [];
+    // CONTEXT_VAULT_REDESIGN: entity files live under
+    // knowledge/entities/<domain>/<typePlural>/<slug>.md.
+    const entitiesRoot = join(contextDir, "knowledge", "entities");
     for (const domain of L2_DOMAINS) {
-        const domainAbs = join(contextDir, domain);
+        const domainAbs = join(entitiesRoot, domain);
         if (!existsSyncSafe(domainAbs))
             continue;
         let entries;
@@ -336,7 +339,7 @@ export function enumerateEntityFiles(contextDir) {
                     continue;
                 if (file.name.startsWith("_"))
                     continue; // _index.md and friends
-                out.push(`${domain}/${entry.name}/${file.name}`);
+                out.push(`knowledge/entities/${domain}/${entry.name}/${file.name}`);
             }
         }
     }
@@ -532,16 +535,19 @@ export function toRelativePath(contextDir, absolutePath) {
 }
 /**
  * True when the given relative path matches the L2 layout
- * `<domain>/<type-plural>/<slug>.md`. Does NOT validate the slug — that
- * is the parser's job — only the directory shape.
+ * `knowledge/entities/<domain>/<type-plural>/<slug>.md` (CONTEXT_VAULT_REDESIGN
+ * v4 V14). Does NOT validate the slug — that is the parser's job — only the
+ * directory shape and `_*.md` skip.
  */
 export function isL2EntityRelativePath(relativePath) {
     if (!relativePath.endsWith(".md"))
         return false;
     const segments = relativePath.split("/");
-    if (segments.length !== 3)
+    if (segments.length !== 5)
+        return false;
+    const [knowledge, entities, domain, typePlural, fileName] = segments;
+    if (knowledge !== "knowledge" || entities !== "entities")
         return false;
-    const [domain, typePlural, fileName] = segments;
     if (!isDomainEnum(domain))
         return false;
     if (pluralToType(typePlural) === null)
@@ -599,8 +605,15 @@ export function startEntityMirrorWatcher(opts) {
 }
 function defaultEntityWatcherFactory(contextDir) {
     // Watch every L2 directory pattern explicitly so unrelated files
-    // (rules/, routines/, etc.) never trigger a refresh.
-    const patterns = L2_DOMAINS.flatMap((domain) => Array.from(L2_TYPE_PLURALS).map((plural) => join(contextDir, domain, plural, "*.md")));
+    // (policies/, journal/, etc.) never trigger a refresh.
+    //
+    // CONTEXT_VAULT_REDESIGN v4 V14 — entity files live at
+    // `<contextDir>/knowledge/entities/<domain>/<type-plural>/<slug>.md`.
+    // Pre-restructure the pattern was 4-segment
+    // (`<contextDir>/<domain>/<plural>/*.md`); after V14 the migration
+    // moves entities under `knowledge/entities/` and this watcher (plus
+    // `isL2EntityRelativePath`) must match the new 5-segment shape.
+    const patterns = L2_DOMAINS.flatMap((domain) => Array.from(L2_TYPE_PLURALS).map((plural) => join(contextDir, "knowledge", "entities", domain, plural, "*.md")));
     const watcher = chokidar.watch(patterns, {
         ignored: ["**/.git/**", "**/.obsidian/**", "**/.DS_Store", "**/_*.md"],
         persistent: true,
@@ -626,4 +639,3 @@ function defaultEntityWatcherFactory(contextDir) {
     };
 }
 /* c8 ignore stop */
-//# sourceMappingURL=entity-mirror.js.map