@aitne/daemon 0.1.7 → 0.1.9

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",
@@ -169,59 +188,184 @@ function validatePolicyFileFrontmatter(relativePath, values) {
     }
     return null;
 }
+const DAILY_WEEKDAY_VALUES = new Set([
+    "Monday",
+    "Tuesday",
+    "Wednesday",
+    "Thursday",
+    "Friday",
+    "Saturday",
+    "Sunday",
+]);
+const DAILY_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const NON_NEGATIVE_INT_RE = /^\d+$/;
+export function validateDailySkeletonFrontmatter(content, relativePath) {
+    if (!relativePath.startsWith("journal/daily/"))
+        return [];
+    if (!relativePath.endsWith(".md"))
+        return [];
+    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.
+    if (!frontmatter)
+        return [];
+    const errors = [];
+    const values = frontmatter.values;
+    // 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("journal/daily/".length, relativePath.length - ".md".length);
+    const dateValue = values.date;
+    if (!dateValue) {
+        errors.push({
+            field: "frontmatter.date",
+            received: null,
+            expected: `ISO date matching the file path stem (\`${stem}\`)`,
+        });
+    }
+    else if (!DAILY_DATE_RE.test(dateValue) || dateValue !== stem) {
+        errors.push({
+            field: "frontmatter.date",
+            received: dateValue,
+            expected: `ISO date matching the file path stem (\`${stem}\`)`,
+        });
+    }
+    // weekday — long-form English (Stage B reads this from skeleton).
+    const weekday = values.weekday;
+    if (!weekday) {
+        errors.push({
+            field: "frontmatter.weekday",
+            received: null,
+            expected: "one of Monday / Tuesday / Wednesday / Thursday / Friday / Saturday / Sunday",
+        });
+    }
+    else if (!DAILY_WEEKDAY_VALUES.has(weekday)) {
+        errors.push({
+            field: "frontmatter.weekday",
+            received: weekday,
+            expected: "one of Monday / Tuesday / Wednesday / Thursday / Friday / Saturday / Sunday",
+        });
+    }
+    // agent_generated — must be literally `true` (the skeleton emits
+    // this so downstream consumers can distinguish daemon-authored
+    // journals from any future user-handcrafted variant).
+    const agentGenerated = values.agent_generated;
+    if (!agentGenerated) {
+        errors.push({
+            field: "frontmatter.agent_generated",
+            received: null,
+            expected: "literal `true`",
+        });
+    }
+    else if (agentGenerated !== "true") {
+        errors.push({
+            field: "frontmatter.agent_generated",
+            received: agentGenerated,
+            expected: "literal `true`",
+        });
+    }
+    // calendar_events — non-negative integer (count from skeleton).
+    const calendarEvents = values.calendar_events;
+    if (!calendarEvents) {
+        errors.push({
+            field: "frontmatter.calendar_events",
+            received: null,
+            expected: "non-negative integer",
+        });
+    }
+    else if (!NON_NEGATIVE_INT_RE.test(calendarEvents)) {
+        errors.push({
+            field: "frontmatter.calendar_events",
+            received: calendarEvents,
+            expected: "non-negative integer",
+        });
+    }
+    // messages_handled — non-negative integer (count from skeleton).
+    // Semantic pinned in morning-routine-optimization.md §"messages_handled
+    // semantic": counts incoming user messages only.
+    const messagesHandled = values.messages_handled;
+    if (!messagesHandled) {
+        errors.push({
+            field: "frontmatter.messages_handled",
+            received: null,
+            expected: "non-negative integer",
+        });
+    }
+    else if (!NON_NEGATIVE_INT_RE.test(messagesHandled)) {
+        errors.push({
+            field: "frontmatter.messages_handled",
+            received: messagesHandled,
+            expected: "non-negative integer",
+        });
+    }
+    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;
 }
@@ -234,78 +378,6 @@ function missingField(relativePath, field) {
         message: `${relativePath} frontmatter requires \`${field}\`.`,
     };
 }
-function extractFrontmatter(content) {
-    const lines = content.split(/\r?\n/);
-    /* c8 ignore next — split always yields at least one element, so
-       `lines[0]` is always defined; the `?? ""` is defensive only. */
-    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 next — non-matching lines slip through as documentation;
-           defensive guard for malformed YAML scalars. */
-        if (!match)
-            continue;
-        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;
-        }
-        /* c8 ignore next — `value[i-1]` is always defined when `i > 0` for a
-           string we are iterating with a known length; the `?? ""` is
-           defensive only. */
-        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) {
@@ -322,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

package/dist/core/context-health.js

@@ -12,10 +12,11 @@ export const DOSSIER_FLOW_PATHS = [
     dossierPath("roadmap"),
 ];
 const REQUIRED_CONTEXT_FILES = [
+    // CONTEXT_VAULT_REDESIGN folded contextIndex into rootIndex
+    // (`_index.md`); list once.
     CONTEXT_RELATIVE_PATHS.rootIndex,
     CONTEXT_RELATIVE_PATHS.today,
     CONTEXT_RELATIVE_PATHS.roadmap,
-    CONTEXT_RELATIVE_PATHS.contextIndex,
     CONTEXT_RELATIVE_PATHS.user.index,
     ...USER_AREA_FILE_PATHS,
     CONTEXT_RELATIVE_PATHS.rules.index,
@@ -47,9 +48,8 @@ export const REPAIRABLE_STUB_TARGETS = new Set([
     CONTEXT_RELATIVE_PATHS.user.goals,
 ]);
 const INJECTION_CAPPED_PREFIXES = [
-    "rules/",
-    "routines/",
-    "dossiers/",
+    "policies/",
+    "knowledge/dossiers/",
 ];
 export function buildContextHealthReport(contextDir, now = new Date()) {
     const missingFiles = collectMissingFiles(contextDir);
@@ -176,8 +176,13 @@ function walkIndexFiles(contextDir) {
 }
 function walk(root, prefix, out, include) {
     const dir = join(root, prefix);
+    /* c8 ignore start — top-level callers verify root exists before
+       descending, and recursive calls only target directories returned
+       from readdirSync; the guard catches a race where a subdirectory
+       vanishes mid-walk. */
     if (!existsSync(dir))
         return;
+    /* c8 ignore stop */
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
         const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
         if (entry.name === ".git" ||
@@ -249,28 +254,33 @@ function isTemplatePlaceholderTarget(target) {
         /\bISO-8601\b/.test(target));
 }
 function normalizeRelativePath(path) {
+    /* c8 ignore start — `isAbsolute(path)` and `normalized === ""` only
+       fire for inputs the callers already filter (path="" or absolute);
+       defensive guards. */
     if (isAbsolute(path))
         return null;
     const resolved = resolve("/", path);
     const normalized = relative("/", resolved);
-    /* c8 ignore next — `normalized === ""` only fires for path="" or path=".",
-       which the callers already filter; defensive guard. */
     if (normalized.startsWith("..") || normalized === "")
         return null;
+    /* c8 ignore stop */
     return normalized.replace(/\\/g, "/");
 }
 function resolveRelativeToIndexDir(baseDir, target) {
-    /* c8 ignore next — callers strip absolute paths before invoking; the
-       guard remains so a future caller can safely pass arbitrary input. */
+    /* c8 ignore start — callers strip absolute paths and empty/dot
+       segments before invoking; the guards remain so a future caller can
+       safely pass arbitrary input. */
     if (isAbsolute(target))
         return null;
+    /* c8 ignore stop */
     const stack = baseDir === "." ? [] : baseDir.split("/").filter(Boolean);
     for (const segment of target.split("/")) {
+        /* c8 ignore next */
         if (!segment || segment === ".")
             continue;
         if (segment === "..") {
-            /* c8 ignore next — pop on an empty stack is unreachable from current
-               callers; defensive against deeper traversal payloads. */
+            /* c8 ignore next 2 — pop on an empty stack is unreachable from
+               current callers; defensive against deeper traversal payloads. */
             if (stack.length === 0)
                 return null;
             stack.pop();
@@ -278,17 +288,19 @@ function resolveRelativeToIndexDir(baseDir, target) {
         }
         stack.push(segment);
     }
-    /* c8 ignore next — empty-stack final state is unreachable for callers
+    /* c8 ignore next 2 — empty-stack final state is unreachable for callers
        that normalize relative paths upstream. */
     if (stack.length === 0)
         return null;
     return stack.join("/");
 }
 function isSafeContextRelativePath(path) {
-    /* c8 ignore next — null-byte injection blocked upstream by the JSON/HTTP
-       layer; defensive belt-and-suspenders. */
+    /* c8 ignore start — null-byte injection blocked upstream by the JSON/HTTP
+       layer, and absolute paths are filtered by the validator; defensive
+       belt-and-suspenders. */
     if (isAbsolute(path) || path.includes("\0"))
         return false;
+    /* c8 ignore stop */
     const normalized = normalizeRelativePath(path);
     if (!normalized || normalized !== path.replace(/\\/g, "/"))
         return false;
@@ -301,4 +313,3 @@ function isSafeContextRelativePath(path) {
         segment === ".obsidian" ||
         segment === ".DS_Store");
 }
-//# sourceMappingURL=context-health.js.map