@aitne/daemon 0.1.8 → 0.1.10

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

@@ -0,0 +1,216 @@
+/**
+ * Frontmatter parser for the six-class vault contract
+ * (CONTEXT_VAULT_REDESIGN_PLAN.md §5).
+ *
+ * Parses the advisory `kind` / `authority` / `mutability` / `slug` / `title`
+ * fields from a Markdown file's YAML frontmatter and returns structured
+ * advisories that the daemon's write-step uses to log warnings.
+ *
+ * **Phase 1 contract (advisory only).** A missing or malformed field logs
+ * a warning and proceeds; nothing rejects the write. The Phase 2 cut-over
+ * is gated behind `runtimeSettings.contextVault.enforceFrontmatter` (not
+ * exposed yet) — when that lands, the same advisory shape will become a
+ * 4xx structured-error response.
+ *
+ * **Coexistence with `context-frontmatter.ts`.** The legacy validator
+ * (`type`, `owner`, `updated`, plus daily-skeleton / policy-file rules)
+ * is unchanged and remains the strict gate for the surfaces it already
+ * covers. The new parser is additive: it reads the new fields without
+ * interpreting the old ones, so a file can carry both shapes during the
+ * Phase 1 → Phase 2 transition. The single YAML extractor is shared via
+ * `readContextFrontmatterValues` so the two paths cannot diverge on what
+ * they consider "frontmatter."
+ */
+import { readContextFrontmatterValues } from "../context-frontmatter-extract.js";
+/** Class — top-level directory class in the six-class layout. */
+export const VAULT_FRONTMATTER_KINDS = [
+    "identity",
+    "state",
+    "plan",
+    "journal",
+    "knowledge",
+    "policy",
+];
+/** Authority — who owns the file. */
+export const VAULT_FRONTMATTER_AUTHORITIES = [
+    "user",
+    "agent",
+    "mixed",
+];
+/** Mutability — how writes are permitted to modify the file. */
+export const VAULT_FRONTMATTER_MUTABILITIES = [
+    "replace",
+    "patch",
+    "append",
+    "readonly",
+];
+const SLUG_RE = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+const SLUG_MAX_LENGTH = 128;
+/**
+ * Map from frontmatter `kind` value to its enforcing top-level directory.
+ * `plan` and `policy` are singular in frontmatter but plural in the path
+ * (`plans/`, `policies/`); the lookup is keyed by the frontmatter value.
+ */
+const KIND_TO_PATH_PREFIX = {
+    identity: "identity/",
+    state: "state/",
+    plan: "plans/",
+    journal: "journal/",
+    knowledge: "knowledge/",
+    policy: "policies/",
+};
+/**
+ * Parse the optional vault frontmatter from a Markdown file. Returns the
+ * parsed values plus a list of advisories that callers (the write-step
+ * chokepoint) translate into structured log warnings.
+ *
+ * `relativePath` is required so a stated `kind` can be cross-checked
+ * against the path's top-level directory. Pass the path the writer is
+ * targeting (e.g. `identity/profile.md`); the helper is a no-op for any
+ * non-`.md` path and for files that are out-of-scope per §5.3.
+ */
+export function parseVaultFrontmatter(content, relativePath) {
+    const result = {
+        values: {},
+        advisories: [],
+    };
+    if (!shouldParseVaultFrontmatter(relativePath))
+        return result;
+    const values = readContextFrontmatterValues(content);
+    if (values === null) {
+        result.advisories.push({
+            code: "missing_frontmatter",
+            message: `${relativePath} has no YAML frontmatter; vault contract requires \`kind\`, \`authority\`, \`mutability\`.`,
+        });
+        return result;
+    }
+    const kindRaw = values.kind;
+    if (!kindRaw) {
+        result.advisories.push({
+            code: "missing_kind",
+            message: `${relativePath} frontmatter missing \`kind\` (one of: ${VAULT_FRONTMATTER_KINDS.join(", ")}).`,
+        });
+    }
+    else if (!isKind(kindRaw)) {
+        result.advisories.push({
+            code: "invalid_kind",
+            message: `${relativePath} frontmatter \`kind: ${kindRaw}\` is not one of: ${VAULT_FRONTMATTER_KINDS.join(", ")}.`,
+        });
+    }
+    else {
+        result.values.kind = kindRaw;
+        const expectedPrefix = KIND_TO_PATH_PREFIX[kindRaw];
+        if (!relativePath.startsWith(expectedPrefix)) {
+            result.advisories.push({
+                code: "kind_path_mismatch",
+                message: `${relativePath} declares \`kind: ${kindRaw}\` but path does not begin with \`${expectedPrefix}\`.`,
+            });
+        }
+    }
+    const authorityRaw = values.authority;
+    if (!authorityRaw) {
+        result.advisories.push({
+            code: "missing_authority",
+            message: `${relativePath} frontmatter missing \`authority\` (one of: ${VAULT_FRONTMATTER_AUTHORITIES.join(", ")}).`,
+        });
+    }
+    else if (!isAuthority(authorityRaw)) {
+        result.advisories.push({
+            code: "invalid_authority",
+            message: `${relativePath} frontmatter \`authority: ${authorityRaw}\` is not one of: ${VAULT_FRONTMATTER_AUTHORITIES.join(", ")}.`,
+        });
+    }
+    else {
+        result.values.authority = authorityRaw;
+    }
+    const mutabilityRaw = values.mutability;
+    if (!mutabilityRaw) {
+        result.advisories.push({
+            code: "missing_mutability",
+            message: `${relativePath} frontmatter missing \`mutability\` (one of: ${VAULT_FRONTMATTER_MUTABILITIES.join(", ")}).`,
+        });
+    }
+    else if (!isMutability(mutabilityRaw)) {
+        result.advisories.push({
+            code: "invalid_mutability",
+            message: `${relativePath} frontmatter \`mutability: ${mutabilityRaw}\` is not one of: ${VAULT_FRONTMATTER_MUTABILITIES.join(", ")}.`,
+        });
+    }
+    else {
+        result.values.mutability = mutabilityRaw;
+    }
+    const slugRaw = values.slug;
+    if (slugRaw) {
+        if (slugRaw.length > SLUG_MAX_LENGTH || !SLUG_RE.test(slugRaw)) {
+            result.advisories.push({
+                code: "invalid_slug",
+                message: `${relativePath} frontmatter \`slug: ${slugRaw}\` must be kebab-case (a-z, 0-9, hyphen), 1-${SLUG_MAX_LENGTH} chars, no leading/trailing hyphen.`,
+            });
+        }
+        else {
+            result.values.slug = slugRaw;
+        }
+    }
+    const titleRaw = values.title;
+    if (titleRaw) {
+        result.values.title = titleRaw;
+    }
+    return result;
+}
+/**
+ * The set of writeable vault paths whose frontmatter the new parser
+ * advises on. Phase 1 scope: any `.md` file under one of the six class
+ * directories OR a legacy top-level path that still maps cleanly under
+ * the upcoming layout (so the alias resolver in PR-3 transparently
+ * routes both). `_index.md` files are excluded — they are
+ * machine-rebuilt or user-curated navigation, not authored content.
+ */
+export function shouldParseVaultFrontmatter(relativePath) {
+    if (!relativePath.endsWith(".md"))
+        return false;
+    if (relativePath.endsWith("/_index.md"))
+        return false;
+    if (relativePath === "_index.md")
+        return false;
+    // New six-class prefixes (the layout PR-3 lands).
+    for (const prefix of Object.values(KIND_TO_PATH_PREFIX)) {
+        if (relativePath.startsWith(prefix))
+            return true;
+    }
+    // Legacy prefixes that map 1:1 under the new layout. The advisory still
+    // applies pre-migration so authors writing new content during the
+    // transition can opt into the new fields early.
+    const legacyPrefixes = [
+        "user/",
+        "rules/",
+        "routines/",
+        "projects/",
+        "daily/",
+        "weekly/",
+        "monthly/",
+        "dossiers/",
+        "inbox/",
+        "agent/",
+        "git/",
+    ];
+    for (const prefix of legacyPrefixes) {
+        if (relativePath.startsWith(prefix))
+            return true;
+    }
+    // Loose top-level files that pass through the rewriter.
+    if (relativePath === "today.md" ||
+        relativePath === "yesterday.md" ||
+        relativePath === "roadmap.md") {
+        return true;
+    }
+    return false;
+}
+function isKind(value) {
+    return VAULT_FRONTMATTER_KINDS.includes(value);
+}
+function isAuthority(value) {
+    return VAULT_FRONTMATTER_AUTHORITIES.includes(value);
+}
+function isMutability(value) {
+    return VAULT_FRONTMATTER_MUTABILITIES.includes(value);
+}

package/dist/core/context-validation/index.d.ts

@@ -16,4 +16,4 @@ export { SNAPSHOT_DEBOUNCE_MS, parseEntryTimestamp, clearEntriesBefore, trimBull
 export { validateBuiltInRoutineRulebook, explainCustomRoutineValidationError, extractRoutineFrontmatter, readRoutineFrontmatterScalar, validateBaseYamlSyntax, } from "./routine-rulebook.js";
 export { TODAY_REQUIRED_SECTIONS, TODAY_H1_RE, TODAY_DAY_TYPE_RE, isLegacyTodayContent, validateTodayContent, toTodayScheduleCandidate, type TodayScheduleCandidate, type AgentPlanScheduleCandidate, } from "./today.js";
 export { validateContextContent, prepareContextContentForWrite, type ResolvedContextTarget, type ContentWriteValidationOptions, type ContextContentValidationError, } from "./prepare-write.js";
-//# sourceMappingURL=index.d.ts.map
+export { parseVaultFrontmatter, shouldParseVaultFrontmatter, VAULT_FRONTMATTER_AUTHORITIES, VAULT_FRONTMATTER_KINDS, VAULT_FRONTMATTER_MUTABILITIES, type VaultFrontmatter, type VaultFrontmatterAdvisory, type VaultFrontmatterAdvisoryCode, type VaultFrontmatterAuthority, type VaultFrontmatterKind, type VaultFrontmatterMutability, type VaultFrontmatterParseResult, } from "./frontmatter.js";

package/dist/core/context-validation/index.js

@@ -16,4 +16,4 @@ export { SNAPSHOT_DEBOUNCE_MS, parseEntryTimestamp, clearEntriesBefore, trimBull
 export { validateBuiltInRoutineRulebook, explainCustomRoutineValidationError, extractRoutineFrontmatter, readRoutineFrontmatterScalar, validateBaseYamlSyntax, } from "./routine-rulebook.js";
 export { TODAY_REQUIRED_SECTIONS, TODAY_H1_RE, TODAY_DAY_TYPE_RE, isLegacyTodayContent, validateTodayContent, toTodayScheduleCandidate, } from "./today.js";
 export { validateContextContent, prepareContextContentForWrite, } from "./prepare-write.js";
-//# sourceMappingURL=index.js.map
+export { parseVaultFrontmatter, shouldParseVaultFrontmatter, VAULT_FRONTMATTER_AUTHORITIES, VAULT_FRONTMATTER_KINDS, VAULT_FRONTMATTER_MUTABILITIES, } from "./frontmatter.js";

package/dist/core/context-validation/prepare-write.d.ts

@@ -62,7 +62,7 @@ export interface ContextContentValidationError {
  *
  *   - `today` → `validateTodayContent` (400)
  *   - `roadmap` → `validateRoadmap` (400 with path hint)
- *   - `routines/custom/*` → `parseCustomRoutineSpec` (400)
+ *   - `policies/routines/custom/*` → `parseCustomRoutineSpec` (400)
  *   - `routines/*` (excluding `_index`) → `validateBuiltInRoutineRulebook` (400)
  *   - everything else → frontmatter validation (422) + `.base` YAML check (400)
  *
@@ -92,4 +92,3 @@ export declare function prepareContextContentForWrite(target: ResolvedContextTar
     status: 400 | 422;
     path?: string;
 };
-//# sourceMappingURL=prepare-write.d.ts.map

package/dist/core/context-validation/prepare-write.js

@@ -1,5 +1,6 @@
 import { parseCustomRoutineSpec } from "../custom-routine-scheduler.js";
 import { validateContextFileFrontmatter } from "../context-frontmatter.js";
+import { isAgentDefinitionPath, validateAgentDefinitionMarkdown, } from "../agents/validate-agent-md.js";
 import { normalizeRoadmapForWrite, validateRoadmap, validateRoadmapTransition, } from "../roadmap-validate.js";
 import { explainCustomRoutineValidationError, validateBaseYamlSyntax, validateBuiltInRoutineRulebook, } from "./routine-rulebook.js";
 import { validateTodayContent } from "./today.js";
@@ -9,7 +10,7 @@ import { validateTodayContent } from "./today.js";
  *
  *   - `today` → `validateTodayContent` (400)
  *   - `roadmap` → `validateRoadmap` (400 with path hint)
- *   - `routines/custom/*` → `parseCustomRoutineSpec` (400)
+ *   - `policies/routines/custom/*` → `parseCustomRoutineSpec` (400)
  *   - `routines/*` (excluding `_index`) → `validateBuiltInRoutineRulebook` (400)
  *   - everything else → frontmatter validation (422) + `.base` YAML check (400)
  *
@@ -17,14 +18,14 @@ import { validateTodayContent } from "./today.js";
  * the success branch and the typed error to the matching HTTP status.
  */
 export function validateContextContent(target, content, options) {
-    if (target.base === "today") {
+    if (target.base === "state/today") {
         const message = validateTodayContent(content, {
             allowLegacyToday: options?.allowLegacyToday ?? false,
             expectedAgentDay: options?.expectedAgentDay,
         });
         return message ? { message, status: 400 } : null;
     }
-    if (target.base === "roadmap") {
+    if (target.base === "plans/roadmap") {
         const result = validateRoadmap(content);
         if (!result.ok && result.error) {
             return {
@@ -35,8 +36,8 @@ export function validateContextContent(target, content, options) {
         }
         return null;
     }
-    if (target.base.startsWith("routines/custom/")) {
-        const slug = target.base.slice("routines/custom/".length);
+    if (target.base.startsWith("policies/routines/custom/")) {
+        const slug = target.base.slice("policies/routines/custom/".length);
         const result = parseCustomRoutineSpec(slug, content);
         if (!result.ok) {
             return {
@@ -46,11 +47,21 @@ export function validateContextContent(target, content, options) {
         }
         return null;
     }
-    if (target.base.startsWith("routines/") && target.base !== "routines/_index") {
+    if (target.base.startsWith("policies/routines/") && target.base !== "policies/routines/_index") {
         const message = validateBuiltInRoutineRulebook(target.base, content);
         return message ? { message, status: 400 } : null;
     }
     const relativePath = `${target.base}${target.ext}`;
+    // policies/agents/<slug>/agent.md — user Agent definitions are written
+    // through this same chokepoint (AGENT_DEFINITIONS_DESIGN.md §3.3). Their
+    // frontmatter is the nested `agentDefinitionSchema`, not the context-vault
+    // rule schema, so validate the agent-definition shape here (400 with the
+    // offending fields) instead of falling through to the generic frontmatter
+    // validator — which would wrongly demand `type`/`owner`/`updated`.
+    if (isAgentDefinitionPath(relativePath)) {
+        const message = validateAgentDefinitionMarkdown(relativePath, content);
+        return message ? { message, status: 400 } : null;
+    }
     if (!options?.skipFrontmatterValidation) {
         const frontmatterError = validateContextFileFrontmatter(content, relativePath);
         if (frontmatterError) {
@@ -76,7 +87,7 @@ export function validateContextContent(target, content, options) {
  * suitable for the API error response.
  */
 export function prepareContextContentForWrite(target, content, options) {
-    if (target.base !== "roadmap") {
+    if (target.base !== "plans/roadmap") {
         const contentError = validateContextContent(target, content, {
             allowLegacyToday: options?.allowLegacyToday,
             expectedAgentDay: options?.expectedAgentDay,
@@ -132,4 +143,3 @@ function formatRoadmapValidationError(error) {
     const line = error.line ? `line ${error.line}: ` : "";
     return `${line}${error.message}`;
 }
-//# sourceMappingURL=prepare-write.js.map

package/dist/core/context-validation/routine-rulebook.d.ts

@@ -6,12 +6,12 @@ import type { CustomRoutineParseError } from "../custom-routine-scheduler.js";
  * the morning / evening / weekly task-flow prompts and must declare the
  * canonical frontmatter shape so the loader can dispatch by slug + type.
  *
- * Custom routines (`routines/custom/*.md`) are user-authored and parsed
+ * Custom routines (`policies/routines/custom/*.md`) are user-authored and parsed
  * by `parseCustomRoutineSpec`; we only translate the structured error
  * into a human-readable message here so the API can surface a 400
  * response that the agent can self-correct from in-session.
  *
- * `.base` files (today: only `projects/_active.base`) carry the active
+ * `.base` files (today: only `plans/projects/_active.base`) carry the active
  * project list as inline YAML. Validation is deliberately syntactic
  * (no schema check) so the file can evolve without a daemon edit; the
  * loader does the per-row validation when it parses.
@@ -57,4 +57,3 @@ export declare function readRoutineFrontmatterScalar(frontmatter: string, field:
  * so that a malformed PATCH cannot wedge the project-list reader.
  */
 export declare function validateBaseYamlSyntax(content: string): string | null;
-//# sourceMappingURL=routine-rulebook.d.ts.map

package/dist/core/context-validation/routine-rulebook.js

@@ -5,12 +5,12 @@
  * the morning / evening / weekly task-flow prompts and must declare the
  * canonical frontmatter shape so the loader can dispatch by slug + type.
  *
- * Custom routines (`routines/custom/*.md`) are user-authored and parsed
+ * Custom routines (`policies/routines/custom/*.md`) are user-authored and parsed
  * by `parseCustomRoutineSpec`; we only translate the structured error
  * into a human-readable message here so the API can surface a 400
  * response that the agent can self-correct from in-session.
  *
- * `.base` files (today: only `projects/_active.base`) carry the active
+ * `.base` files (today: only `plans/projects/_active.base`) carry the active
  * project list as inline YAML. Validation is deliberately syntactic
  * (no schema check) so the file can evolve without a daemon edit; the
  * loader does the per-row validation when it parses.
@@ -30,7 +30,7 @@ export function validateBuiltInRoutineRulebook(path, content) {
     if (frontmatter === null) {
         return "Routine rulebooks require YAML frontmatter.";
     }
-    const expectedSlug = path.slice("routines/".length);
+    const expectedSlug = path.slice("policies/routines/".length);
     const typeRaw = readRoutineFrontmatterScalar(frontmatter, "type");
     if (!typeRaw) {
         return "Routine rulebooks require `type: rule` in frontmatter.";
@@ -153,4 +153,3 @@ export function validateBaseYamlSyntax(content) {
     }
     return null;
 }
-//# sourceMappingURL=routine-rulebook.js.map

package/dist/core/context-validation/section.d.ts

@@ -1,7 +1,7 @@
 /**
  * Pure helpers for locating `## Section` blocks in context-file markdown.
  *
- * Used by `/api/context` PATCH handlers and by `agent/journal` trim/clear
+ * Used by `/api/context` PATCH handlers and by `journal/agent` trim/clear
  * logic. No I/O, no Hono — keep these importable from any layer.
  *
  * Section names are normalized case- and whitespace-insensitively so that
@@ -38,4 +38,3 @@ export declare function sumLength(lines: string[], upToIndex: number): number;
  * style hints when a PATCH targets a section that does not exist.
  */
 export declare function getAvailableSections(content: string): string[];
-//# sourceMappingURL=section.d.ts.map

package/dist/core/context-validation/section.js

@@ -1,7 +1,7 @@
 /**
  * Pure helpers for locating `## Section` blocks in context-file markdown.
  *
- * Used by `/api/context` PATCH handlers and by `agent/journal` trim/clear
+ * Used by `/api/context` PATCH handlers and by `journal/agent` trim/clear
  * logic. No I/O, no Hono — keep these importable from any layer.
  *
  * Section names are normalized case- and whitespace-insensitively so that
@@ -32,8 +32,13 @@ export function findSection(content, sectionName) {
     let sectionStart = -1;
     let headerEnd = -1;
     for (let i = 0; i < lines.length; i++) {
-        if (lines[i].startsWith("## ")) {
-            const lineNormalized = normalizeSection(lines[i]);
+        // CRLF-tolerant: split("\n") leaves a trailing \r on CRLF files (Windows
+        // daemon, or an Obsidian/git vault synced with core.autocrlf). Strip it
+        // for the header comparison only; the raw byte offsets (incl. \r) are
+        // preserved for write-back.
+        const line = lines[i].endsWith("\r") ? lines[i].slice(0, -1) : lines[i];
+        if (line.startsWith("## ")) {
+            const lineNormalized = normalizeSection(line);
             if (lineNormalized === normalized) {
                 sectionStart = i;
                 const lineStart = sumLength(lines, i);
@@ -49,7 +54,9 @@ export function findSection(content, sectionName) {
     // Find end: next ## header or EOF
     let sectionEnd = content.length;
     for (let i = sectionStart + 1; i < lines.length; i++) {
-        if (lines[i].startsWith("## ")) {
+        // CRLF-tolerant header check (see note in the start-scan above).
+        const line = lines[i].endsWith("\r") ? lines[i].slice(0, -1) : lines[i];
+        if (line.startsWith("## ")) {
             sectionEnd = sumLength(lines, i);
             break;
         }
@@ -76,7 +83,8 @@ export function sumLength(lines, upToIndex) {
 export function getAvailableSections(content) {
     return content
         .split("\n")
+        // CRLF-tolerant: strip a trailing \r before matching/normalizing headers.
+        .map((l) => (l.endsWith("\r") ? l.slice(0, -1) : l))
         .filter((l) => l.startsWith("## "))
         .map((l) => normalizeSection(l));
 }
-//# sourceMappingURL=section.js.map

package/dist/core/context-validation/snapshot-debounce.d.ts

@@ -3,17 +3,17 @@
  *
  * `SNAPSHOT_DEBOUNCE_MS` is the floor the route handler enforces between
  * snapshot rows persisted to `md_file_snapshots`. Without it a busy section
- * (e.g. `agent/journal` Raw Signals) would write a new row per append.
+ * (e.g. `journal/agent` Raw Signals) would write a new row per append.
  *
  * The trim/clear helpers run during PATCH against bullet-list sections
- * that grow unbounded — `agent/journal` Raw Signals (timestamp-clear) and
+ * that grow unbounded — `journal/agent` Raw Signals (timestamp-clear) and
  * any section with a `maxEntries` cap (FIFO trim). They preserve
  * continuation lines (indented) and inter-entry blank lines, leaving
  * non-bullet decoration (headings, prose) untouched.
  */
 /**
  * Minimum elapsed milliseconds between two snapshot rows for the same
- * file. 5 minutes — picked so a chatty section (`agent/journal`) does
+ * file. 5 minutes — picked so a chatty section (`journal/agent`) does
  * not write a snapshot per append, while still capturing the dominant
  * state of the file every ~5 min for forensics.
  *
@@ -49,4 +49,3 @@ export declare function trimBulletEntries(body: string, maxEntries: number): {
     body: string;
     trimmed: number;
 };
-//# sourceMappingURL=snapshot-debounce.d.ts.map

package/dist/core/context-validation/snapshot-debounce.js

@@ -3,17 +3,17 @@
  *
  * `SNAPSHOT_DEBOUNCE_MS` is the floor the route handler enforces between
  * snapshot rows persisted to `md_file_snapshots`. Without it a busy section
- * (e.g. `agent/journal` Raw Signals) would write a new row per append.
+ * (e.g. `journal/agent` Raw Signals) would write a new row per append.
  *
  * The trim/clear helpers run during PATCH against bullet-list sections
- * that grow unbounded — `agent/journal` Raw Signals (timestamp-clear) and
+ * that grow unbounded — `journal/agent` Raw Signals (timestamp-clear) and
  * any section with a `maxEntries` cap (FIFO trim). They preserve
  * continuation lines (indented) and inter-entry blank lines, leaving
  * non-bullet decoration (headings, prose) untouched.
  */
 /**
  * Minimum elapsed milliseconds between two snapshot rows for the same
- * file. 5 minutes — picked so a chatty section (`agent/journal`) does
+ * file. 5 minutes — picked so a chatty section (`journal/agent`) does
  * not write a snapshot per append, while still capturing the dominant
  * state of the file every ~5 min for forensics.
  *
@@ -107,4 +107,3 @@ export function trimBulletEntries(body, maxEntries) {
     const kept = lines.filter((_, i) => !removeSet.has(i));
     return { body: kept.join("\n"), trimmed: excess };
 }
-//# sourceMappingURL=snapshot-debounce.js.map

package/dist/core/context-validation/today.d.ts

@@ -82,4 +82,3 @@ export declare function toTodayScheduleCandidate(row: {
     task_context: string | null;
     status: string;
 }, timezone: string | undefined): TodayScheduleCandidate | null;
-//# sourceMappingURL=today.d.ts.map

package/dist/core/context-validation/today.js

@@ -165,4 +165,3 @@ function parseJsonObject(raw) {
     }
     return {};
 }
-//# sourceMappingURL=today.js.map

package/dist/core/context-vault-aliases.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Legacy vault-path alias resolver (CONTEXT_VAULT_REDESIGN_PLAN.md
+ * §7.3 + §14.3 + v4 V8).
+ *
+ * **Why it exists.** The vault restructure moves files from
+ * `user/` / `rules/` / `routines/` / `projects/` / `daily/` / etc. into
+ * six class directories (`identity/`, `state/`, `plans/`, `journal/`,
+ * `knowledge/`, `policies/`). All daemon code is updated in lockstep, but
+ * shipped agent assets (≥186 `curl` invocations across task-flows and
+ * SKILL.md files) still spell paths the old way until the PR-6 content
+ * sweep lands. Without a translation layer, every legacy `curl -X PATCH
+ * /api/context/today.md` would 404 the moment the new layout boots.
+ *
+ * **Why not HTTP 308.** The shipped `curl` invocations omit `-L`, so an
+ * HTTP 3xx would terminate the request rather than follow it. The
+ * resolver therefore performs the mapping **in-process before any HTTP
+ * routing**, and the route handler emits its normal `200/201/4xx` for
+ * the canonical path.
+ *
+ * **Where to call it.** Anywhere the daemon converts a vault-path
+ * string into a filesystem read/write — primarily the
+ * `/api/context/<path>` chokepoint in `api/routes/context/index.ts`,
+ * and the snapshot-restore + DB path-key migration in `setup-migrate.ts`.
+ * The single helper guarantees old and new spellings cannot drift.
+ *
+ * **Scope.** Only the path *string* is translated. PATCH section names,
+ * HTTP verbs, request bodies, and snapshot trigger labels are all left
+ * untouched — the legacy aliases are 1:1 with the new spellings, no
+ * shape changes ride along.
+ *
+ * **Lifecycle.** The alias is intended to live for **one minor release**
+ * (one `aitne` version) — long enough for the PR-6 agent-asset content
+ * sweep to rewrite every shipped reference. After that the aliases stay
+ * but emit an operator-visible warning, and the final removal lands in
+ * the subsequent minor release. The mechanism itself is idempotent and
+ * cheap; the lifetime cap is for prose-correctness, not safety.
+ */
+/**
+ * Outcome of a single alias resolution.
+ *
+ *  - `result.aliased = false` → the path was already in canonical form
+ *    (or did not match any legacy pattern). The handler proceeds as is.
+ *  - `result.aliased = true`  → the path was legacy. `canonicalPath` is
+ *    what the handler should treat as the request target; `legacyPath`
+ *    is what the client originally sent (for telemetry + warning
+ *    headers).
+ */
+export interface VaultPathAliasResult {
+    readonly canonicalPath: string;
+    readonly legacyPath: string;
+    readonly aliased: boolean;
+}
+/**
+ * Vault-path alias table. Each entry maps a legacy *path prefix* (with
+ * trailing slash if it's a directory; bare filename otherwise) to its
+ * canonical six-class equivalent.
+ *
+ * **Order matters.** Longer / more-specific prefixes must come first so
+ * `rules/policies/` rewrites before the more general `rules/` would
+ * shadow it. The exported `VAULT_PATH_ALIASES` constant is the sorted
+ * source of truth — entries here MUST be added in longest-prefix-first
+ * order at write time so a reader can scan top-down without reordering.
+ */
+export interface VaultPathAlias {
+    readonly fromPrefix: string;
+    readonly toPrefix: string;
+    /**
+     * Optional sentinel for the "exact bare filename" case (e.g.
+     * `today.md` ↔ `today`). When set, the alias only fires if the input
+     * matches the prefix exactly OR the prefix followed by `.md`. This
+     * prevents a stray `today.md.bak` from being silently aliased.
+     */
+    readonly exactOnly?: boolean;
+}
+/**
+ * Sorted longest-prefix-first. Used by `aliasVaultPath` to translate
+ * legacy paths and by the migration's JSON-blob rewrite step
+ * (`rewriteJsonBlobs` in `db/migrations/context-vault-restructure.ts`)
+ * to rewrite vault paths embedded in `agent_actions.detail`,
+ * `observations.payload`, and `messages.metadata`.
+ */
+export declare const VAULT_PATH_ALIASES: readonly VaultPathAlias[];
+/**
+ * Translate a vault-relative path from its legacy spelling to its
+ * canonical six-class spelling. Returns the input verbatim (with
+ * `aliased=false`) if no rule applies.
+ *
+ * Idempotent: calling the resolver on an already-canonical path is a
+ * no-op. This is what makes it safe to invoke unconditionally at every
+ * entry point.
+ *
+ * The resolver does not validate that the resulting path is reachable
+ * on disk — that is the caller's job (e.g. `safePath` for the HTTP
+ * route). The job here is purely string translation.
+ */
+export declare function aliasVaultPath(relativePath: string): VaultPathAliasResult;
+/**
+ * Diagnostic helper — returns every alias entry whose `fromPrefix` would
+ * shadow another. Used by a peer test to assert the static table stays
+ * in longest-prefix-first order. The `aliases` parameter defaults to the
+ * production table; tests pass a deliberately mis-ordered list to exercise
+ * the shadow-detection branch.
+ */
+export declare function findShadowingAliases(aliases?: ReadonlyArray<VaultPathAlias>): Array<{
+    earlier: VaultPathAlias;
+    shadowed: VaultPathAlias;
+}>;