@aitne/daemon 0.1.8 → 0.1.10

package/dist/core/context-file-serializer.d.ts

@@ -0,0 +1,92 @@
+/**
+ * `serializeContextFileWrite` — daemon-wide per-absolute-path promise-chain
+ * mutex. The single source of truth for "this read-modify-write block on
+ * `<abs>` does not interleave with any other writer to the same path",
+ * across BOTH the HTTP context routes and the in-process daemon-direct
+ * writers (today-direct-writer, agent-journal-appender, roadmap-maintenance,
+ * dispatcher-scheduled-tasks' weekly-interests journal appender).
+ *
+ * Why this exists
+ * ---------------
+ * Before this module landed, the HTTP route's in-router `withWriteLock`
+ * serialized only HTTP-vs-HTTP writes within a single router instance.
+ * Daemon-direct writers (which fire from cron ticks and scheduled-task
+ * pre-hooks) ran their own `readFileSync` → mutate → `writeFileAtomically`
+ * sequence with no shared coordination, so a concurrent HTTP `PATCH` and
+ * a hourly_check `appendAgentLogLine` could both read the same pre-state,
+ * each compute their own "next", and the second `rename` would silently
+ * drop the first writer's bullet.
+ *
+ * The named cross-session locks (`morningRoutineLock`, `roadmapWriteLock`)
+ * are NOT a substitute: they're a fast-fail X-Lock-Id gate for cross-session
+ * coordination (HTTP returns 409 when held by another session), not an
+ * await-the-current-writer mutex. Direct writers gracefully `acquire() →
+ * skip` when the lock is held; that is acceptable for "best-effort log
+ * line" callers but loses morning-routine journal entries and roadmap
+ * maintenance traces when it fires.
+ *
+ * Contract
+ * --------
+ * - `fn` is invoked at most once per call, after every previously-enqueued
+ *   `fn` for the same absolute path has settled.
+ * - Errors thrown by `fn` propagate to the caller AND release the queue —
+ *   a poisoning `fn` does not block successors.
+ * - The map entry is dropped when this call is the tail of the chain, so
+ *   the map's footprint tracks "paths with currently-pending writers"
+ *   rather than the unbounded history.
+ *
+ * Multi-path acquisitions
+ * -----------------------
+ * Callers that need to atomically read one path and write another (e.g.
+ * `POST /api/context/archive-today` rotating today.md → yesterday.md)
+ * must acquire BOTH serializers, nested with a deterministic order.
+ * Convention: acquire in **alphabetical order by absolute path**. The
+ * fixed order prevents AB/BA deadlock against any other multi-path
+ * caller that follows the same rule. Pattern:
+ *
+ *   return serializeContextFileWrite(pathA, () =>
+ *     serializeContextFileWrite(pathB, () => { ... }));
+ *
+ * where `pathA < pathB` lexicographically.
+ *
+ * Convention for new writers
+ * --------------------------
+ * **Every new writer that targets a context file must go through this
+ * helper.** "Context file" = any `.md` file under the configured
+ * `contextDir` (see `core/context-paths.ts`). The bug class this fence
+ * prevents (HTTP PATCH and a daemon-direct writer reading the same
+ * pre-state and clobbering each other) re-emerges silently the moment
+ * a new writer skips it. There is no compile-time enforcement — the
+ * grep for `writeFileAtomically` followed by a `contextDir`-anchored
+ * path is the audit signal. When adding a writer, wrap the entire
+ * read-modify-write block (not just the write) so the read sees the
+ * post-state of any previously-enqueued writer.
+ *
+ * Out of scope
+ * ------------
+ * - Cross-process coordination (multiple daemon processes touching the
+ *   same context dir). The daemon is single-process by design; running
+ *   two on one DATA_DIR is unsupported elsewhere too.
+ * - Read serialization. Reads are not gated. A reader can observe an
+ *   intermediate post-rename state, which is the same guarantee
+ *   `writeFileAtomically` already gives.
+ *
+ * Resetting state in tests
+ * ------------------------
+ * `_resetContextFileSerializerForTesting()` clears the in-flight map so
+ * a test that exercises the queue can start from a known state in the
+ * next test. Production code MUST NOT call it.
+ */
+export declare function serializeContextFileWrite<T>(absolutePath: string, fn: () => T | Promise<T>): Promise<T>;
+/**
+ * Test-only reset. Production callers MUST NOT invoke this — clearing
+ * the map mid-flight would let two writers run concurrently against the
+ * same path, which is the exact bug this module exists to prevent.
+ */
+export declare function _resetContextFileSerializerForTesting(): void;
+/**
+ * Test-only inspector. Returns the number of paths with at least one
+ * pending writer. Exposed so tests can assert the map shrinks back to
+ * zero after the chain drains, catching map-leak regressions.
+ */
+export declare function _pendingPathCountForTesting(): number;

package/dist/core/context-file-serializer.js

@@ -0,0 +1,126 @@
+/**
+ * `serializeContextFileWrite` — daemon-wide per-absolute-path promise-chain
+ * mutex. The single source of truth for "this read-modify-write block on
+ * `<abs>` does not interleave with any other writer to the same path",
+ * across BOTH the HTTP context routes and the in-process daemon-direct
+ * writers (today-direct-writer, agent-journal-appender, roadmap-maintenance,
+ * dispatcher-scheduled-tasks' weekly-interests journal appender).
+ *
+ * Why this exists
+ * ---------------
+ * Before this module landed, the HTTP route's in-router `withWriteLock`
+ * serialized only HTTP-vs-HTTP writes within a single router instance.
+ * Daemon-direct writers (which fire from cron ticks and scheduled-task
+ * pre-hooks) ran their own `readFileSync` → mutate → `writeFileAtomically`
+ * sequence with no shared coordination, so a concurrent HTTP `PATCH` and
+ * a hourly_check `appendAgentLogLine` could both read the same pre-state,
+ * each compute their own "next", and the second `rename` would silently
+ * drop the first writer's bullet.
+ *
+ * The named cross-session locks (`morningRoutineLock`, `roadmapWriteLock`)
+ * are NOT a substitute: they're a fast-fail X-Lock-Id gate for cross-session
+ * coordination (HTTP returns 409 when held by another session), not an
+ * await-the-current-writer mutex. Direct writers gracefully `acquire() →
+ * skip` when the lock is held; that is acceptable for "best-effort log
+ * line" callers but loses morning-routine journal entries and roadmap
+ * maintenance traces when it fires.
+ *
+ * Contract
+ * --------
+ * - `fn` is invoked at most once per call, after every previously-enqueued
+ *   `fn` for the same absolute path has settled.
+ * - Errors thrown by `fn` propagate to the caller AND release the queue —
+ *   a poisoning `fn` does not block successors.
+ * - The map entry is dropped when this call is the tail of the chain, so
+ *   the map's footprint tracks "paths with currently-pending writers"
+ *   rather than the unbounded history.
+ *
+ * Multi-path acquisitions
+ * -----------------------
+ * Callers that need to atomically read one path and write another (e.g.
+ * `POST /api/context/archive-today` rotating today.md → yesterday.md)
+ * must acquire BOTH serializers, nested with a deterministic order.
+ * Convention: acquire in **alphabetical order by absolute path**. The
+ * fixed order prevents AB/BA deadlock against any other multi-path
+ * caller that follows the same rule. Pattern:
+ *
+ *   return serializeContextFileWrite(pathA, () =>
+ *     serializeContextFileWrite(pathB, () => { ... }));
+ *
+ * where `pathA < pathB` lexicographically.
+ *
+ * Convention for new writers
+ * --------------------------
+ * **Every new writer that targets a context file must go through this
+ * helper.** "Context file" = any `.md` file under the configured
+ * `contextDir` (see `core/context-paths.ts`). The bug class this fence
+ * prevents (HTTP PATCH and a daemon-direct writer reading the same
+ * pre-state and clobbering each other) re-emerges silently the moment
+ * a new writer skips it. There is no compile-time enforcement — the
+ * grep for `writeFileAtomically` followed by a `contextDir`-anchored
+ * path is the audit signal. When adding a writer, wrap the entire
+ * read-modify-write block (not just the write) so the read sees the
+ * post-state of any previously-enqueued writer.
+ *
+ * Out of scope
+ * ------------
+ * - Cross-process coordination (multiple daemon processes touching the
+ *   same context dir). The daemon is single-process by design; running
+ *   two on one DATA_DIR is unsupported elsewhere too.
+ * - Read serialization. Reads are not gated. A reader can observe an
+ *   intermediate post-rename state, which is the same guarantee
+ *   `writeFileAtomically` already gives.
+ *
+ * Resetting state in tests
+ * ------------------------
+ * `_resetContextFileSerializerForTesting()` clears the in-flight map so
+ * a test that exercises the queue can start from a known state in the
+ * next test. Production code MUST NOT call it.
+ */
+const pendingWrites = new Map();
+export async function serializeContextFileWrite(absolutePath, fn) {
+    const previous = pendingWrites.get(absolutePath) ?? Promise.resolve();
+    // The chain pattern: each caller awaits its predecessor (swallowing
+    // the predecessor's error so a poisoning fn does not block successors)
+    // and then runs its own `fn`. The map stores the "outer" Promise that
+    // resolves only after this call's `fn` settles, so the next caller
+    // chains onto it.
+    let resolveSelf;
+    const self = new Promise((resolve) => {
+        resolveSelf = resolve;
+    });
+    pendingWrites.set(absolutePath, self);
+    try {
+        await previous.catch(() => {
+            // Predecessor errors are surfaced to the predecessor's caller —
+            // we deliberately do not propagate them here, so a single
+            // poisoning fn does not cascade through the queue.
+        });
+        return await fn();
+    }
+    finally {
+        resolveSelf();
+        // Drop the map entry when we're the tail. If a later caller has
+        // already chained on, `pendingWrites.get(absolutePath)` !== `self`
+        // and we leave the map alone.
+        if (pendingWrites.get(absolutePath) === self) {
+            pendingWrites.delete(absolutePath);
+        }
+    }
+}
+/**
+ * Test-only reset. Production callers MUST NOT invoke this — clearing
+ * the map mid-flight would let two writers run concurrently against the
+ * same path, which is the exact bug this module exists to prevent.
+ */
+export function _resetContextFileSerializerForTesting() {
+    pendingWrites.clear();
+}
+/**
+ * Test-only inspector. Returns the number of paths with at least one
+ * pending writer. Exposed so tests can assert the map shrinks back to
+ * zero after the chain drains, catching map-leak regressions.
+ */
+export function _pendingPathCountForTesting() {
+    return pendingWrites.size;
+}

package/dist/core/context-frontmatter-extract.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Shared YAML-frontmatter extractor used by both the legacy strict
+ * validator (`context-frontmatter.ts`) and the new vault-contract parser
+ * (`context-validation/frontmatter.ts`). Extracting this into its own
+ * module is the prerequisite for keeping the two parsers in lock-step on
+ * what they consider "frontmatter" while letting each interpret the
+ * resulting key/value map under its own rules.
+ *
+ * The parser is intentionally minimal — it covers the line-scalar shapes
+ * Aitne's frontmatter actually uses today (single-line strings, quoted or
+ * unquoted, with `#`-anchored inline comments). YAML block scalars (`|`,
+ * `>`) and nested mappings remain unsupported by design: every Aitne
+ * frontmatter field is a single scalar today, and accepting richer YAML
+ * here would silently parse multi-line `origin:` blocks as the literal
+ * `"|"` value while losing the actual content — exactly the regression
+ * the policy-file validator guards against.
+ */
+export interface ExtractedFrontmatter {
+    values: Record<string, string>;
+    body: string;
+}
+/**
+ * Extract the YAML frontmatter from a Markdown file. Returns `null` if
+ * the file does not start with `---\n` or never closes the block.
+ */
+export declare function extractContextFrontmatter(content: string): ExtractedFrontmatter | null;
+/**
+ * Convenience wrapper — returns just the parsed scalar map (or `null` if
+ * no frontmatter is present). Callers that only need to look up a field
+ * value avoid the body-slice cost via this entry point.
+ */
+export declare function readContextFrontmatterValues(content: string): Record<string, string> | null;

package/dist/core/context-frontmatter-extract.js

@@ -0,0 +1,98 @@
+/**
+ * Shared YAML-frontmatter extractor used by both the legacy strict
+ * validator (`context-frontmatter.ts`) and the new vault-contract parser
+ * (`context-validation/frontmatter.ts`). Extracting this into its own
+ * module is the prerequisite for keeping the two parsers in lock-step on
+ * what they consider "frontmatter" while letting each interpret the
+ * resulting key/value map under its own rules.
+ *
+ * The parser is intentionally minimal — it covers the line-scalar shapes
+ * Aitne's frontmatter actually uses today (single-line strings, quoted or
+ * unquoted, with `#`-anchored inline comments). YAML block scalars (`|`,
+ * `>`) and nested mappings remain unsupported by design: every Aitne
+ * frontmatter field is a single scalar today, and accepting richer YAML
+ * here would silently parse multi-line `origin:` blocks as the literal
+ * `"|"` value while losing the actual content — exactly the regression
+ * the policy-file validator guards against.
+ */
+/**
+ * Extract the YAML frontmatter from a Markdown file. Returns `null` if
+ * the file does not start with `---\n` or never closes the block.
+ */
+export function extractContextFrontmatter(content) {
+    const lines = content.split(/\r?\n/);
+    if (lines[0].trim() !== "---")
+        return null;
+    const end = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+    if (end < 0)
+        return null;
+    const values = {};
+    for (const rawLine of lines.slice(1, end)) {
+        const line = rawLine.trim();
+        if (line === "" || line.startsWith("#"))
+            continue;
+        const match = /^([A-Za-z0-9_-]+)\s*:\s*(.*?)\s*$/.exec(line);
+        /* c8 ignore start — non-matching lines slip through as documentation;
+           defensive guard for malformed YAML scalars. */
+        if (!match)
+            continue;
+        /* c8 ignore stop */
+        values[match[1]] = parseYamlScalar(match[2]);
+    }
+    return {
+        values,
+        body: lines.slice(end + 1).join("\n"),
+    };
+}
+/**
+ * Convenience wrapper — returns just the parsed scalar map (or `null` if
+ * no frontmatter is present). Callers that only need to look up a field
+ * value avoid the body-slice cost via this entry point.
+ */
+export function readContextFrontmatterValues(content) {
+    const extracted = extractContextFrontmatter(content);
+    return extracted === null ? null : extracted.values;
+}
+function parseYamlScalar(value) {
+    return stripYamlQuotes(stripYamlInlineComment(value).trim());
+}
+function stripYamlInlineComment(value) {
+    let quote = null;
+    let escaped = false;
+    for (let i = 0; i < value.length; i++) {
+        const char = value[i];
+        if (quote === '"') {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === "\\") {
+                escaped = true;
+            }
+            else if (char === '"') {
+                quote = null;
+            }
+            continue;
+        }
+        if (quote === "'") {
+            if (char === "'")
+                quote = null;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (char === "#" && (i === 0 || /\s/.test(value[i - 1]))) {
+            return value.slice(0, i).trimEnd();
+        }
+    }
+    return value;
+}
+function stripYamlQuotes(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}

package/dist/core/context-frontmatter.d.ts

@@ -7,6 +7,14 @@ export interface ExpectedContextFrontmatter {
     type: string;
     owners: readonly string[];
 }
+/**
+ * Path-prefix predicate consumed by the write chokepoint to decide
+ * whether the strict frontmatter validator should fire. After the
+ * vault restructure (CONTEXT_VAULT_REDESIGN_PLAN.md §3) the prefixes
+ * are the new class-prefixed paths. Legacy prefixes are normalised by
+ * the API alias resolver upstream, so the matcher only ever sees
+ * canonical paths.
+ */
 export declare function shouldValidateContextFileFrontmatter(relativePath: string): boolean;
 export declare function validateContextFileFrontmatter(content: string, relativePath: string): ContextFrontmatterValidationError | null;
 export interface DailySkeletonFrontmatterDriftError {
@@ -16,4 +24,3 @@ export interface DailySkeletonFrontmatterDriftError {
 }
 export declare function validateDailySkeletonFrontmatter(content: string, relativePath: string): DailySkeletonFrontmatterDriftError[];
 export declare function expectedFrontmatterForPath(relativePath: string): ExpectedContextFrontmatter | null;
-//# sourceMappingURL=context-frontmatter.d.ts.map

package/dist/core/context-frontmatter.js

@@ -1,23 +1,43 @@
+import { extractContextFrontmatter } from "./context-frontmatter-extract.js";
 import { CONTEXT_FRONTMATTER_TYPES, CONTEXT_RELATIVE_PATHS, } from "./context-paths.js";
 const VALID_TYPES = new Set(CONTEXT_FRONTMATTER_TYPES);
 const VALID_OWNERS = new Set(["agent", "shared", "user"]);
+/**
+ * Path-prefix predicate consumed by the write chokepoint to decide
+ * whether the strict frontmatter validator should fire. After the
+ * vault restructure (CONTEXT_VAULT_REDESIGN_PLAN.md §3) the prefixes
+ * are the new class-prefixed paths. Legacy prefixes are normalised by
+ * the API alias resolver upstream, so the matcher only ever sees
+ * canonical paths.
+ */
 export function shouldValidateContextFileFrontmatter(relativePath) {
     if (!relativePath.endsWith(".md"))
         return false;
-    return (relativePath.startsWith("user/") ||
-        relativePath.startsWith("rules/") ||
-        relativePath.startsWith("projects/") ||
-        relativePath.startsWith("git-repos/") ||
-        relativePath.startsWith("daily/") ||
-        relativePath.startsWith("weekly/") ||
-        relativePath.startsWith("monthly/") ||
-        relativePath.startsWith("dossiers/") ||
-        relativePath === CONTEXT_RELATIVE_PATHS.contextIndex);
+    // Agent definitions (`policies/agents/<slug>/agent.md`) carry the nested
+    // `agentDefinitionSchema` frontmatter, NOT the context-vault rule frontmatter
+    // (type/owner/updated). They are shape-validated at the write boundary by
+    // `validateAgentDefinitionMarkdown` and semantically by the agent loader, so
+    // the generic validator must not flag their (correctly) absent `type`.
+    // Excluding the whole subtree also stops the Vault Health scan
+    // (context-health.ts) from false-flagging every agent.md.
+    // AGENT_DEFINITIONS_DESIGN.md §3.3 / §9.5.
+    if (relativePath.startsWith("policies/agents/"))
+        return false;
+    return (relativePath.startsWith("identity/") ||
+        relativePath.startsWith("policies/") ||
+        relativePath.startsWith("plans/projects/") ||
+        relativePath.startsWith("knowledge/repos/legacy-registry/") ||
+        relativePath.startsWith("journal/daily/") ||
+        relativePath.startsWith("journal/weekly/") ||
+        relativePath.startsWith("journal/monthly/") ||
+        relativePath.startsWith("knowledge/dossiers/") ||
+        relativePath === CONTEXT_RELATIVE_PATHS.contextIndex ||
+        relativePath === CONTEXT_RELATIVE_PATHS.rootIndex);
 }
 export function validateContextFileFrontmatter(content, relativePath) {
     if (!shouldValidateContextFileFrontmatter(relativePath))
         return null;
-    const frontmatter = extractFrontmatter(content);
+    const frontmatter = extractContextFrontmatter(content);
     if (!frontmatter) {
         return {
             code: "missing_frontmatter",
@@ -81,7 +101,7 @@ export function validateContextFileFrontmatter(content, relativePath) {
 const POLICY_SLUG_RE = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
 const POLICY_STATUSES = new Set(["active", "paused", "removed"]);
 const POLICY_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
-const POLICY_INDEX_PATH = "rules/policies/_index.md";
+const POLICY_INDEX_PATH = "policies/management-captures/_index.md";
 // MANAGEMENT-POLICY-CAPTURE-PLAN §4.1.1 — `extractFrontmatter` is a flat
 // line-scalar parser; it does NOT expand YAML block scalars. A policy
 // file written as `origin: |\n  …` produces `values.origin === "|"` —
@@ -91,7 +111,7 @@ const POLICY_INDEX_PATH = "rules/policies/_index.md";
 // `origin` becomes necessary, expand the extractor first.
 const POLICY_BLOCK_SCALAR_MARKER_RE = /^[|>][-+]?$/;
 function validatePolicyFileFrontmatter(relativePath, values) {
-    if (!relativePath.startsWith("rules/policies/"))
+    if (!relativePath.startsWith("policies/management-captures/"))
         return null;
     if (relativePath === POLICY_INDEX_PATH)
         return null;
@@ -120,8 +140,7 @@ function validatePolicyFileFrontmatter(relativePath, values) {
             message: `${relativePath} frontmatter slug must be kebab-case (a-z, 0-9, hyphen), 1-64 chars, no leading/trailing hyphen.`,
         };
     }
-    const filenameStem = relativePath
-        .slice("rules/policies/".length, -".md".length);
+    const filenameStem = relativePath.slice("policies/management-captures/".length, -".md".length);
     if (slug !== filenameStem) {
         return {
             code: "invalid_slug",
@@ -181,11 +200,11 @@ const DAILY_WEEKDAY_VALUES = new Set([
 const DAILY_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 const NON_NEGATIVE_INT_RE = /^\d+$/;
 export function validateDailySkeletonFrontmatter(content, relativePath) {
-    if (!relativePath.startsWith("daily/"))
+    if (!relativePath.startsWith("journal/daily/"))
         return [];
     if (!relativePath.endsWith(".md"))
         return [];
-    const frontmatter = extractFrontmatter(content);
+    const frontmatter = extractContextFrontmatter(content);
     // Missing frontmatter is already a 422 from validateContextFileFrontmatter
     // (`missing_frontmatter`); don't double-fire here. Return an empty list so
     // the generic validator owns the "no frontmatter at all" message.
@@ -193,10 +212,10 @@ export function validateDailySkeletonFrontmatter(content, relativePath) {
         return [];
     const errors = [];
     const values = frontmatter.values;
-    // date — must equal the path's date stem (daily/YYYY-MM-DD.md).
+    // date — must equal the path's date stem (journal/daily/YYYY-MM-DD.md).
     // The daemon's PUT route also pins line 1 of the body via H1 date,
     // so this is the frontmatter-side of the same contract.
-    const stem = relativePath.slice("daily/".length, relativePath.length - ".md".length);
+    const stem = relativePath.slice("journal/daily/".length, relativePath.length - ".md".length);
     const dateValue = values.date;
     if (!dateValue) {
         errors.push({
@@ -283,58 +302,70 @@ export function validateDailySkeletonFrontmatter(content, relativePath) {
     return errors;
 }
 export function expectedFrontmatterForPath(relativePath) {
-    if (relativePath === "user/_index.md") {
+    if (relativePath === "identity/_index.md") {
         return { type: "index", owners: ["shared"] };
     }
-    if (relativePath.startsWith("user/")) {
+    if (relativePath.startsWith("identity/")) {
         return { type: "user", owners: ["shared"] };
     }
-    if (relativePath === "rules/_index.md") {
+    if (relativePath === "policies/_index.md") {
         return { type: "index", owners: ["shared"] };
     }
-    // MANAGEMENT-POLICY-CAPTURE-PLAN §4.1.1 / §4.3 — policy files use the
-    // existing `rule` type plus a `kind: policy` discriminator, and the
-    // policies sub-index is agent-owned (the `management-policy` skill is
-    // its sole writer). These rules MUST precede the generic `rules/`
-    // catch-all below; first match wins.
-    if (relativePath === "rules/policies/_index.md") {
+    // MANAGEMENT-POLICY-CAPTURE-PLAN §4.1.1 / §4.3 — policy capture files
+    // use the existing `rule` type plus a `kind: policy` discriminator,
+    // and the captures sub-index is agent-owned (the `management-policy`
+    // skill is its sole writer). These rules MUST precede the generic
+    // `policies/` catch-all below; first match wins.
+    if (relativePath === "policies/management-captures/_index.md") {
         return { type: "index", owners: ["agent"] };
     }
-    if (relativePath.startsWith("rules/policies/")) {
+    if (relativePath.startsWith("policies/management-captures/")) {
         return { type: "rule", owners: ["agent"] };
     }
-    if (relativePath.startsWith("rules/")) {
+    // Routine and skill sub-indices retain index frontmatter even though
+    // they live under the policies/ prefix.
+    if (relativePath === "policies/routines/_index.md") {
+        return { type: "index", owners: ["shared"] };
+    }
+    if (relativePath === "policies/skills/_index.md") {
+        return { type: "index", owners: ["shared"] };
+    }
+    if (relativePath.startsWith("policies/")) {
         return { type: "rule", owners: ["agent", "shared", "user"] };
     }
-    if (relativePath === "projects/_index.md") {
+    if (relativePath === "plans/projects/_index.md") {
         return { type: "index", owners: ["shared"] };
     }
-    if (relativePath.startsWith("projects/")) {
+    if (relativePath.startsWith("plans/projects/")) {
         return { type: "project", owners: ["shared"] };
     }
-    if (relativePath.startsWith("git-repos/")) {
+    if (relativePath.startsWith("knowledge/repos/legacy-registry/")) {
         return { type: "git-repo", owners: ["shared"] };
     }
-    if (relativePath.startsWith("daily/")) {
+    if (relativePath.startsWith("journal/daily/")) {
         return { type: "daily", owners: ["agent"] };
     }
-    if (relativePath.startsWith("weekly/")) {
+    if (relativePath.startsWith("journal/weekly/")) {
         return { type: "weekly", owners: ["agent"] };
     }
-    if (relativePath.startsWith("monthly/")) {
+    if (relativePath.startsWith("journal/monthly/")) {
         return { type: "monthly", owners: ["agent"] };
     }
-    // B-004 — agent-owned dossiers + system-prose context index. Validated
-    // on write via the same chokepoint so the Vault Health dashboard never
+    // Agent-owned dossiers + system-prose context index. Validated on
+    // write via the same chokepoint so the Vault Health dashboard never
     // flags a file that the API just permitted.
     if (relativePath === CONTEXT_RELATIVE_PATHS.dossiers.index) {
         return { type: "index", owners: ["agent"] };
     }
-    if (relativePath.startsWith("dossiers/")) {
+    if (relativePath.startsWith("knowledge/dossiers/")) {
         return { type: "dossier", owners: ["agent"] };
     }
-    if (relativePath === CONTEXT_RELATIVE_PATHS.contextIndex) {
-        return { type: "index", owners: ["agent"] };
+    // contextIndex and rootIndex collapse to the same `_index.md` after
+    // CONTEXT_VAULT_REDESIGN. The file is mixed-authorship (V15) — user
+    // prose around a `<!-- reconciler-section -->` block — so `shared` is
+    // the canonical owner; `agent` is grandfathered from the pre-V15 era.
+    if (relativePath === CONTEXT_RELATIVE_PATHS.rootIndex) {
+        return { type: "index", owners: ["shared", "agent"] };
     }
     return null;
 }
@@ -347,77 +378,6 @@ function missingField(relativePath, field) {
         message: `${relativePath} frontmatter requires \`${field}\`.`,
     };
 }
-function extractFrontmatter(content) {
-    const lines = content.split(/\r?\n/);
-    // `split` always returns at least one element; `lines[0]` is defined.
-    if (lines[0].trim() !== "---")
-        return null;
-    const end = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
-    if (end < 0)
-        return null;
-    const values = {};
-    for (const rawLine of lines.slice(1, end)) {
-        const line = rawLine.trim();
-        if (line === "" || line.startsWith("#"))
-            continue;
-        const match = /^([A-Za-z0-9_-]+)\s*:\s*(.*?)\s*$/.exec(line);
-        /* c8 ignore start — non-matching lines slip through as documentation;
-           defensive guard for malformed YAML scalars. */
-        if (!match)
-            continue;
-        /* c8 ignore stop */
-        values[match[1]] = parseYamlScalar(match[2]);
-    }
-    return {
-        values,
-        body: lines.slice(end + 1).join("\n"),
-    };
-}
-function parseYamlScalar(value) {
-    return stripYamlQuotes(stripYamlInlineComment(value).trim());
-}
-function stripYamlInlineComment(value) {
-    let quote = null;
-    let escaped = false;
-    for (let i = 0; i < value.length; i++) {
-        const char = value[i];
-        if (quote === '"') {
-            if (escaped) {
-                escaped = false;
-            }
-            else if (char === "\\") {
-                escaped = true;
-            }
-            else if (char === '"') {
-                quote = null;
-            }
-            continue;
-        }
-        if (quote === "'") {
-            if (char === "'")
-                quote = null;
-            continue;
-        }
-        if (char === '"' || char === "'") {
-            quote = char;
-            continue;
-        }
-        // `value[i-1]` is always defined when `i > 0` for a string we are
-        // iterating with a known length; no nullish fallback needed.
-        if (char === "#" && (i === 0 || /\s/.test(value[i - 1]))) {
-            return value.slice(0, i).trimEnd();
-        }
-    }
-    return value;
-}
-function stripYamlQuotes(value) {
-    const trimmed = value.trim();
-    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
-        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
-        return trimmed.slice(1, -1);
-    }
-    return trimmed;
-}
 function isIsoDateString(value) {
     const dateOnly = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
     if (dateOnly) {
@@ -434,4 +394,3 @@ function isIsoDateString(value) {
     const parsed = new Date(value);
     return !Number.isNaN(parsed.getTime());
 }
-//# sourceMappingURL=context-frontmatter.js.map

package/dist/core/context-health.d.ts

@@ -48,4 +48,3 @@ export declare const DOSSIER_FLOW_PATHS: readonly [string, string, string, strin
 export declare const REPAIRABLE_STUB_TARGETS: Set<string>;
 export declare function buildContextHealthReport(contextDir: string, now?: Date): ContextHealthReport;
 export declare function normalizeRepairStubPath(input: string): string | null;
-//# sourceMappingURL=context-health.d.ts.map