@aitne/daemon 0.1.7 → 0.1.9

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

@@ -0,0 +1,167 @@
+import { nowInTimezone } from "@aitne/shared";
+import { extractTodayAgentPlanRows, } from "../today-agent-plan.js";
+/**
+ * Validators and shape helpers for the `today.md` context file.
+ *
+ * `today.md` is the agent's daily working surface. Its line-1 header is
+ * the canonical agent-day date; its `## Agent Plan` rows feed the
+ * scheduler that fires `→DM` / `→notify` / `→check-in` / `→wake` actions
+ * at their listed times. Both halves are parsed by every downstream
+ * event handler, so the schema is enforced server-side at write time
+ * with explicit messages that the agent can self-correct from.
+ */
+/**
+ * Canonical `## ` section headers, in document order. The validator
+ * walks the file once and requires each to appear after the previous
+ * one — extra sections may sit between them but the relative order is
+ * fixed.
+ */
+export const TODAY_REQUIRED_SECTIONS = [
+    "User Schedule",
+    "User Tasks",
+    "Agent Plan",
+    "Agent Notes",
+    "Agent Log",
+    "Handoff",
+];
+/**
+ * Line 1: `# YYYY-MM-DD (day-of-week)`. Date and dashes are ASCII;
+ * only the optional `(...)` weekday may be localized into the user's
+ * primary language. The capture group is consulted to compare against
+ * the current agent-day date when the route handler passes
+ * `expectedAgentDay`.
+ */
+export const TODAY_H1_RE = /^# \d{4}-\d{2}-\d{2}(?: \([^)]+\))?$/;
+/**
+ * Line 2: `> Day type: Weekday|Weekend | Work focus: on|off | …`.
+ * This line is parsed by every event handler — keep the casing,
+ * pipe separators, and `> ` prefix exact ASCII.
+ */
+export const TODAY_DAY_TYPE_RE = /^> Day type: (Weekday|Weekend) \| Work focus: (on|off) \| Study focus: (on|off) \| Personal focus: (on|off)$/;
+/**
+ * Pre-schema legacy form — first line literally `# Today`. Recognized
+ * only when the route handler explicitly opts in via
+ * `allowLegacyToday`; used to bridge old fixtures during reload paths
+ * that don't carry the agent-day context.
+ */
+export function isLegacyTodayContent(content) {
+    const lines = content.split(/\r?\n/);
+    // `String.prototype.split` always yields a non-empty array, so `lines[0]`
+    // is never undefined; the `?? ""` is a defensive default that types
+    // require but no real input can hit.
+    /* c8 ignore next */
+    return (lines[0] ?? "").trim() === "# Today";
+}
+/**
+ * Validate a `today.md` payload for the canonical schema.
+ *
+ * Returns a human-readable error message string, or `null` if the
+ * content is valid. The caller maps `null` to 200 and any string to
+ * 400. Messages echo both the expected and observed shape so the
+ * agent gets immediate feedback and can correct the offending line in
+ * the same session — see EXECUTION-MODE-DESIGN follow-up
+ * §morning-routine for the rationale.
+ */
+export function validateTodayContent(content, options = {}) {
+    if (options.allowLegacyToday && isLegacyTodayContent(content))
+        return null;
+    const lines = content.split(/\r?\n/);
+    // Same `split` invariant as `isLegacyTodayContent`.
+    /* c8 ignore next */
+    const firstLine = (lines[0] ?? "").trim();
+    if (!TODAY_H1_RE.test(firstLine)) {
+        return ("today.md line 1 must be `# YYYY-MM-DD (day-of-week)`. " +
+            "The date and dashes are ASCII English; only the weekday inside " +
+            "`(...)` may be localized. Do NOT translate the literal `# ` prefix " +
+            "or change the date separator. See the today skill for the full " +
+            "skeleton contract.");
+    }
+    if (!TODAY_DAY_TYPE_RE.test((lines[1] ?? "").trim())) {
+        return ("today.md line 2 must be `> Day type: Weekday|Weekend | Work focus: on|off | Study focus: on|off | Personal focus: on|off`. " +
+            "This line is parsed by every downstream event handler — keep it " +
+            "exact English ASCII with the casing, pipe separators (` | `), and " +
+            "leading `> ` shown above. Do NOT translate `Day type` / `Weekday` / " +
+            "`Work focus` / `on` / `off` etc. into the user's primary_language; " +
+            "the `<output_language_policy>` skeleton-precedence rule covers this " +
+            "line. Example: " +
+            "`> Day type: Weekday | Work focus: on | Study focus: on | Personal focus: on`.");
+    }
+    // Agent-day-date check — rejects wrong-date H1 with a clear error echoing
+    // both values. Without this, a wrong-date PUT silently succeeds (regex
+    // passes) and the dispatcher's post-run hasCurrentAgentDayTodayMd() check
+    // schedules a retry while the same session still has the prompt context
+    // loaded, wasting a heavy-tier turn cycle. With this guard the agent gets
+    // immediate feedback and corrects in-session.
+    if (options.expectedAgentDay) {
+        // TODAY_H1_RE already matched, so the YYYY-MM-DD capture is guaranteed.
+        // No optional-chain — the regex precondition guarantees `[1]` is set.
+        const writtenDate = firstLine.match(/^# (\d{4}-\d{2}-\d{2})/)[1];
+        if (writtenDate !== options.expectedAgentDay) {
+            return (`today.md line 1 date '${writtenDate}' does not match the current ` +
+                `agent-day date '${options.expectedAgentDay}'. ` +
+                `Use the date from <current_agent_day date="..."> in your prompt context — ` +
+                `the agent-day differs from calendar today before the day-boundary hour.`);
+        }
+    }
+    let previousSectionIndex = 1;
+    for (const section of TODAY_REQUIRED_SECTIONS) {
+        const index = lines.findIndex((line, lineIndex) => lineIndex > previousSectionIndex && line.trim() === `## ${section}`);
+        if (index < 0) {
+            return `today.md requires \`## ${section}\` in canonical order.`;
+        }
+        previousSectionIndex = index;
+    }
+    const parsed = extractTodayAgentPlanRows(content);
+    if (parsed.invalidRows.length > 0) {
+        const first = parsed.invalidRows[0];
+        return (`today.md Agent Plan line ${first.line} must match ` +
+            `\`- [ ] HH:MM <action> [work|study|personal|home] →DM|→notify|→check-in|→wake\`. ` +
+            `Got: ${JSON.stringify(first.raw)}`);
+    }
+    return null;
+}
+/**
+ * Project a raw `agent_schedule` row into a `today.md`-reconciliation
+ * candidate: derive the local date/time in the caller's timezone, lift
+ * the task-context blob into an object, and surface the canonical row
+ * id so the route handler can correlate against parsed Agent Plan rows.
+ *
+ * Returns `null` for rows with an unparseable `scheduled_for`, so the
+ * caller can `.filter(Boolean)` past corrupt timestamps without
+ * crashing the reconciliation pass.
+ */
+export function toTodayScheduleCandidate(row, timezone) {
+    const scheduledAt = parseScheduleDate(row.scheduled_for);
+    if (Number.isNaN(scheduledAt.getTime()))
+        return null;
+    const local = nowInTimezone(timezone, scheduledAt);
+    const localDate = `${local.year}-${String(local.month).padStart(2, "0")}-${String(local.day).padStart(2, "0")}`;
+    const localTime = `${String(local.hours).padStart(2, "0")}:${String(local.minutes).padStart(2, "0")}`;
+    return {
+        id: row.id,
+        scheduledFor: row.scheduled_for,
+        localDate,
+        localTime,
+        taskType: row.task_type,
+        status: row.status,
+        description: row.task_description,
+        taskContext: parseJsonObject(row.task_context),
+    };
+}
+function parseScheduleDate(value) {
+    return new Date(value.includes("T") ? value : value.replace(" ", "T") + "Z");
+}
+function parseJsonObject(raw) {
+    if (!raw)
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // Ignore corrupt metadata for reconciliation diagnostics.
+    }
+    return {};
+}

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;
+}>;

package/dist/core/context-vault-aliases.js

@@ -0,0 +1,253 @@
+/**
+ * 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.
+ */
+/**
+ * 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 const VAULT_PATH_ALIASES = [
+    // Directory-prefix renames. Longest first.
+    // `rules/policies/` (legacy capture dir) before `rules/`.
+    { fromPrefix: "rules/policies/", toPrefix: "policies/management-captures/" },
+    // `agent/scratch/` before `agent/`.
+    { fromPrefix: "agent/scratch/", toPrefix: "state/scratch/" },
+    // `agent/journal` (file, with or without `.md`).
+    { fromPrefix: "agent/journal", toPrefix: "journal/agent", exactOnly: true },
+    // `agent/profile-questions` (file, with or without `.md`).
+    {
+        fromPrefix: "agent/profile-questions",
+        toPrefix: "state/profile-questions",
+        exactOnly: true,
+    },
+    // Generic `rules/` and `routines/`.
+    { fromPrefix: "rules/", toPrefix: "policies/" },
+    { fromPrefix: "routines/", toPrefix: "policies/routines/" },
+    // `projects/` → `plans/projects/`.
+    { fromPrefix: "projects/", toPrefix: "plans/projects/" },
+    // Journal subtrees.
+    { fromPrefix: "daily/", toPrefix: "journal/daily/" },
+    { fromPrefix: "weekly/", toPrefix: "journal/weekly/" },
+    { fromPrefix: "monthly/", toPrefix: "journal/monthly/" },
+    // Knowledge subtrees.
+    { fromPrefix: "dossiers/", toPrefix: "knowledge/dossiers/" },
+    // State subtrees.
+    { fromPrefix: "inbox/", toPrefix: "state/inbox/" },
+    { fromPrefix: "_activity/", toPrefix: "state/activity/" },
+    // Identity (user/).
+    { fromPrefix: "user/", toPrefix: "identity/" },
+    // Loose top-level files. `exactOnly` so `today.md.bak` isn't aliased.
+    { fromPrefix: "today", toPrefix: "state/today", exactOnly: true },
+    { fromPrefix: "yesterday", toPrefix: "state/yesterday", exactOnly: true },
+    { fromPrefix: "roadmap", toPrefix: "plans/roadmap", exactOnly: true },
+];
+/**
+ * git/<slug>/overview.md → knowledge/repos/<slug>/overview.md
+ * git/<slug>/journal/<date>.md → journal/repos/<slug>/<date>.md
+ *
+ * These are pattern-aliases (not prefix-aliases) because the slug
+ * segment is part of the canonical destination. Handled separately so
+ * the prefix walker stays a pure prefix scan.
+ */
+const GIT_OVERVIEW_RE = /^git\/([^/]+)\/overview(\.md)?$/;
+const GIT_JOURNAL_RE = /^git\/([^/]+)\/journal\/([^/]+?)(\.md)?$/;
+/**
+ * Management entity / domain-index pattern aliases. Domains live in
+ * `packages/shared/src/management-domains.ts`; the regex matches any
+ * leading segment so the pattern doesn't need to enumerate them. The
+ * caller still gets a stable canonical form regardless.
+ *
+ * `<domain>/_index.md` → `knowledge/entities/<domain>/_index.md`
+ * `<domain>/<type-plural>/<slug>(.md)?` → `knowledge/entities/<domain>/<type-plural>/<slug>(.md)?`
+ *
+ * Recognised domains are pinned to avoid colliding with arbitrary
+ * top-level paths the user may have under the vault root. The list
+ * mirrors `MANAGEMENT_DOMAINS` in `packages/shared/src/management-domains.ts`.
+ */
+const MANAGEMENT_DOMAIN_NAMES = [
+    "work",
+    "travel",
+    "finance",
+    "personal",
+    "health",
+    "learning",
+];
+const DOMAIN_INDEX_RE = new RegExp(`^(?<domain>${MANAGEMENT_DOMAIN_NAMES.join("|")})/_index(\\.md)?$`);
+const DOMAIN_ENTITY_RE = new RegExp(`^(?<domain>${MANAGEMENT_DOMAIN_NAMES.join("|")})/(?<typePlural>[a-z][a-z0-9-]*)/(?<slug>[^/]+?)(\\.md)?$`);
+/**
+ * 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 function aliasVaultPath(relativePath) {
+    // Defensive normalisation — strip a leading slash so the resolver can
+    // be called with either form. Trailing slashes are preserved
+    // (callers like the migration manifest use `state/inbox/` as a dir).
+    const input = relativePath.startsWith("/") ? relativePath.slice(1) : relativePath;
+    // Already canonical — fast path.
+    if (isCanonicalSixClassPath(input)) {
+        return { canonicalPath: input, legacyPath: input, aliased: false };
+    }
+    // Pattern aliases first (git fanout + management entities).
+    const gitOverview = GIT_OVERVIEW_RE.exec(input);
+    if (gitOverview) {
+        const slug = gitOverview[1];
+        const suffix = gitOverview[2] ?? "";
+        return {
+            canonicalPath: `knowledge/repos/${slug}/overview${suffix}`,
+            legacyPath: input,
+            aliased: true,
+        };
+    }
+    const gitJournal = GIT_JOURNAL_RE.exec(input);
+    if (gitJournal) {
+        const slug = gitJournal[1];
+        const date = gitJournal[2];
+        const suffix = gitJournal[3] ?? "";
+        return {
+            canonicalPath: `journal/repos/${slug}/${date}${suffix}`,
+            legacyPath: input,
+            aliased: true,
+        };
+    }
+    const domainIndex = DOMAIN_INDEX_RE.exec(input);
+    if (domainIndex) {
+        const { domain } = domainIndex.groups;
+        const suffix = input.endsWith(".md") ? ".md" : "";
+        return {
+            canonicalPath: `knowledge/entities/${domain}/_index${suffix}`,
+            legacyPath: input,
+            aliased: true,
+        };
+    }
+    const domainEntity = DOMAIN_ENTITY_RE.exec(input);
+    if (domainEntity) {
+        const { domain, typePlural, slug } = domainEntity.groups;
+        const suffix = input.endsWith(".md") ? ".md" : "";
+        return {
+            canonicalPath: `knowledge/entities/${domain}/${typePlural}/${slug}${suffix}`,
+            legacyPath: input,
+            aliased: true,
+        };
+    }
+    // Prefix aliases.
+    for (const alias of VAULT_PATH_ALIASES) {
+        if (alias.exactOnly) {
+            if (input === alias.fromPrefix) {
+                return {
+                    canonicalPath: alias.toPrefix,
+                    legacyPath: input,
+                    aliased: true,
+                };
+            }
+            if (input === `${alias.fromPrefix}.md`) {
+                return {
+                    canonicalPath: `${alias.toPrefix}.md`,
+                    legacyPath: input,
+                    aliased: true,
+                };
+            }
+            continue;
+        }
+        if (input.startsWith(alias.fromPrefix)) {
+            return {
+                canonicalPath: alias.toPrefix + input.slice(alias.fromPrefix.length),
+                legacyPath: input,
+                aliased: true,
+            };
+        }
+    }
+    return { canonicalPath: input, legacyPath: input, aliased: false };
+}
+/**
+ * The six top-level classes the new layout uses. A path that already
+ * starts with one of these is canonical and the resolver short-circuits.
+ */
+const CANONICAL_PREFIXES = [
+    "identity/",
+    "state/",
+    "plans/",
+    "journal/",
+    "knowledge/",
+    "policies/",
+];
+function isCanonicalSixClassPath(input) {
+    if (input === "_index.md" || input === "_index")
+        return true;
+    // `.context-vault-version` is a runtime marker that lives at the
+    // contextDir root; it's not a "vault content" path but consumers
+    // sometimes round-trip it.
+    if (input === ".context-vault-version")
+        return true;
+    for (const prefix of CANONICAL_PREFIXES) {
+        if (input.startsWith(prefix))
+            return true;
+    }
+    return false;
+}
+/**
+ * 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 function findShadowingAliases(aliases = VAULT_PATH_ALIASES) {
+    const shadows = [];
+    for (let i = 0; i < aliases.length; i++) {
+        const earlier = aliases[i];
+        for (let j = i + 1; j < aliases.length; j++) {
+            const later = aliases[j];
+            if (earlier.exactOnly || later.exactOnly)
+                continue;
+            if (later.fromPrefix.startsWith(earlier.fromPrefix)) {
+                shadows.push({ earlier, shadowed: later });
+            }
+        }
+    }
+    return shadows;
+}

package/dist/core/custom-routine-scheduler.d.ts

@@ -3,7 +3,7 @@ import { customRoutineSlugFromKey } from "@aitne/shared";
 import type { EventBus } from "./event-bus.js";
 /**
  * B-007 §5.8 Q3 — user-defined routines registered under
- * `context/routines/custom/<slug>.md`. Each file's YAML frontmatter
+ * `context/policies/routines/custom/<slug>.md`. Each file's YAML frontmatter
  * describes the cadence and the runtime budget; `CustomRoutineScheduler`
  * enumerates them at startup, wires a `node-cron` job per enabled
  * routine, and pushes a `routine.custom.<slug>` event into the EventBus
@@ -17,7 +17,7 @@ import type { EventBus } from "./event-bus.js";
  *   running → stop() → stopped (all cron jobs cleared)
  *
  * No fs.watch is used. The context API route (`src/api/routes/context.ts`)
- * calls `reload()` after every PUT/PATCH/DELETE under `routines/custom/`.
+ * calls `reload()` after every PUT/PATCH/DELETE under `policies/routines/custom/`.
  */
 export interface CustomRoutineSpec {
     slug: string;
@@ -69,7 +69,7 @@ export interface CustomRoutineEnumerationResult {
     }[];
 }
 /**
- * Parse a `routines/custom/<slug>.md` file body into a validated spec.
+ * Parse a `policies/routines/custom/<slug>.md` file body into a validated spec.
  * Pure function — safe to unit-test exhaustively. Returns a discriminated
  * result so callers can log structured errors without throwing.
  */
@@ -81,7 +81,7 @@ export declare function parseCustomRoutineSpec(slug: string, body: string): {
     error: CustomRoutineParseError;
 };
 /**
- * Enumerate every `routines/custom/*.md` file under `contextDir` and
+ * Enumerate every `policies/routines/custom/*.md` file under `contextDir` and
  * parse each into a spec. Errors are returned alongside the successful
  * specs so the scheduler can log them without aborting startup.
  *
@@ -142,10 +142,9 @@ export declare class CustomRoutineScheduler {
     private fire;
 }
 /**
- * Convenience: extract the slug from a `routines/custom/<slug>.md` path.
+ * Convenience: extract the slug from a `policies/routines/custom/<slug>.md` path.
  * Returns null if the path is outside the custom-routine directory.
  * Used by the context API route when deciding whether to call `reload()`.
  */
 export declare function slugFromCustomRoutinePath(relativePath: string): string | null;
 export { customRoutineSlugFromKey };
-//# sourceMappingURL=custom-routine-scheduler.d.ts.map

package/dist/core/custom-routine-scheduler.js

@@ -36,7 +36,7 @@ function hasChecksSection(content) {
     return /^##\s+Checks\s*$/m.test(content);
 }
 /**
- * Parse a `routines/custom/<slug>.md` file body into a validated spec.
+ * Parse a `policies/routines/custom/<slug>.md` file body into a validated spec.
  * Pure function — safe to unit-test exhaustively. Returns a discriminated
  * result so callers can log structured errors without throwing.
  */
@@ -127,7 +127,7 @@ export function parseCustomRoutineSpec(slug, body) {
     };
 }
 /**
- * Enumerate every `routines/custom/*.md` file under `contextDir` and
+ * Enumerate every `policies/routines/custom/*.md` file under `contextDir` and
  * parse each into a spec. Errors are returned alongside the successful
  * specs so the scheduler can log them without aborting startup.
  *
@@ -315,7 +315,7 @@ export class CustomRoutineScheduler {
     }
 }
 /**
- * Convenience: extract the slug from a `routines/custom/<slug>.md` path.
+ * Convenience: extract the slug from a `policies/routines/custom/<slug>.md` path.
  * Returns null if the path is outside the custom-routine directory.
  * Used by the context API route when deciding whether to call `reload()`.
  */
@@ -332,4 +332,3 @@ export function slugFromCustomRoutinePath(relativePath) {
     return slug;
 }
 export { customRoutineSlugFromKey };
-//# sourceMappingURL=custom-routine-scheduler.js.map

package/dist/core/daemon-api-cli.d.ts

@@ -10,11 +10,12 @@ export declare const DAEMON_API_SESSION_ID_ENV = "PA_SESSION_ID";
 export declare const DAEMON_API_EVENT_CORRELATION_ID_ENV = "PA_EVENT_CORRELATION_ID";
 export declare function ensureDaemonApiCli(sessionDir: string): string;
 /**
- * Identity-bearing env vars consumed by the CLI shims when an invoke call
- * targets /api/integrations/*\/invoke. Optional — when omitted, the shim
- * just doesn't attach the corresponding header. Callers pass `sessionBackend`
- * unconditionally on agent backend spawns; `eventId` / `processKey` flow in
- * from the dispatcher so `agent_actions` rows get parent attribution.
+ * Identity-bearing env vars consumed by the CLI shims when a delegated
+ * call targets /api/integrations/*\/exec (or /api/delegated/run).
+ * Optional — when omitted, the shim just doesn't attach the corresponding
+ * header. Callers pass `sessionBackend` unconditionally on agent backend
+ * spawns; `eventId` / `processKey` flow in from the dispatcher so
+ * `agent_actions` rows get parent attribution.
  *
  * DELEGATED-MODE-V2-DESIGN.md §4.2.3.
  */
@@ -30,4 +31,3 @@ export interface DaemonApiCliEnvOptions {
     eventCorrelationId?: string;
 }
 export declare function buildDaemonApiCliEnv(sessionDir: string, apiPort: number, optionsOrReadToken?: string | DaemonApiCliEnvOptions): Record<string, string>;
-//# sourceMappingURL=daemon-api-cli.d.ts.map