@aitne/daemon 0.1.7 → 0.1.9

package/dist/core/fetch-window-prompt-loader.d.ts

@@ -0,0 +1,46 @@
+/**
+ * docs/design/appendices/fetch-window-cost-reduction.md Phase 1 / Phase 1.5 — single
+ * source of truth for the `routine.fetch_window` slim system prompt.
+ *
+ * The same `agent-assets/system-prompts/routine-fetch-window.md` template
+ * is consumed by two backend paths:
+ *   - Claude SDK — passed as `query()`'s `systemPrompt` string by
+ *     `claude-code-core.ts:buildSystemPrompt` (Phase 1).
+ *   - Codex / Gemini CLI — written verbatim as `AGENTS.md` / `GEMINI.md`
+ *     by `skills-compiler.ts:materializeFetchWindowCliSession` (Phase 1.5).
+ *
+ * Hoisting the loader out of `claude-code-core.ts` lets the skills
+ * compiler import it without a cross-backend dependency, and keeps the
+ * disk read + cache amortized across both code paths (one read per
+ * daemon boot regardless of how many sessions of either backend run).
+ *
+ * The template is immutable for the daemon's lifetime, so a single
+ * module-level cache is sufficient. The test reset helper is exported
+ * via `_testInternals` so unit tests can simulate a fresh boot without
+ * reaching into module internals.
+ */
+/**
+ * Load the slim `routine.fetch_window` system-prompt template from disk,
+ * caching the result for the daemon's lifetime.
+ *
+ * Path resolution follows the same shape as `prompts.ts:resolveTaskFlowsDir`:
+ * `__dirname` lives at `packages/daemon/src/core/` (or the matching
+ * `dist/core/` after build), so the repo's `agent-assets/` directory is
+ * four levels up. The cwd fallback only fires in unusual harness layouts.
+ *
+ * Brand tokens (`{APP_NAME}`) are substituted at load time so the slim
+ * template stays aligned with the wide path's substitution contract.
+ * Today the template uses no brand tokens — substitution is a no-op —
+ * but applying it here keeps the loader honest the moment a future edit
+ * introduces `{APP_NAME}`: the Claude SDK systemPrompt and the CLI
+ * AGENTS.md / GEMINI.md both see the substituted product name instead
+ * of a literal "{APP_NAME}" leaking through. APP_NAME is a compile-time
+ * constant so the per-boot cache is still byte-stable.
+ */
+export declare function loadFetchWindowSystemPrompt(): string;
+/**
+ * Test-only — drop the cached prompt so a subsequent call re-reads from
+ * disk. Production never needs this; the prompt is immutable per daemon
+ * boot.
+ */
+export declare function resetFetchWindowSystemPromptForTest(): void;

package/dist/core/fetch-window-prompt-loader.js

@@ -0,0 +1,71 @@
+/**
+ * docs/design/appendices/fetch-window-cost-reduction.md Phase 1 / Phase 1.5 — single
+ * source of truth for the `routine.fetch_window` slim system prompt.
+ *
+ * The same `agent-assets/system-prompts/routine-fetch-window.md` template
+ * is consumed by two backend paths:
+ *   - Claude SDK — passed as `query()`'s `systemPrompt` string by
+ *     `claude-code-core.ts:buildSystemPrompt` (Phase 1).
+ *   - Codex / Gemini CLI — written verbatim as `AGENTS.md` / `GEMINI.md`
+ *     by `skills-compiler.ts:materializeFetchWindowCliSession` (Phase 1.5).
+ *
+ * Hoisting the loader out of `claude-code-core.ts` lets the skills
+ * compiler import it without a cross-backend dependency, and keeps the
+ * disk read + cache amortized across both code paths (one read per
+ * daemon boot regardless of how many sessions of either backend run).
+ *
+ * The template is immutable for the daemon's lifetime, so a single
+ * module-level cache is sufficient. The test reset helper is exported
+ * via `_testInternals` so unit tests can simulate a fresh boot without
+ * reaching into module internals.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { substituteBrandTokens } from "@aitne/shared";
+let cachedFetchWindowSystemPrompt = null;
+/**
+ * Load the slim `routine.fetch_window` system-prompt template from disk,
+ * caching the result for the daemon's lifetime.
+ *
+ * Path resolution follows the same shape as `prompts.ts:resolveTaskFlowsDir`:
+ * `__dirname` lives at `packages/daemon/src/core/` (or the matching
+ * `dist/core/` after build), so the repo's `agent-assets/` directory is
+ * four levels up. The cwd fallback only fires in unusual harness layouts.
+ *
+ * Brand tokens (`{APP_NAME}`) are substituted at load time so the slim
+ * template stays aligned with the wide path's substitution contract.
+ * Today the template uses no brand tokens — substitution is a no-op —
+ * but applying it here keeps the loader honest the moment a future edit
+ * introduces `{APP_NAME}`: the Claude SDK systemPrompt and the CLI
+ * AGENTS.md / GEMINI.md both see the substituted product name instead
+ * of a literal "{APP_NAME}" leaking through. APP_NAME is a compile-time
+ * constant so the per-boot cache is still byte-stable.
+ */
+export function loadFetchWindowSystemPrompt() {
+    if (cachedFetchWindowSystemPrompt !== null)
+        return cachedFetchWindowSystemPrompt;
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        join(here, "..", "..", "..", "..", "agent-assets", "system-prompts", "routine-fetch-window.md"),
+        // Defensive fallback — if the module is invoked from an unexpected
+        // layout we still find the asset by walking up from cwd. Last-resort
+        // only; the relative path above is the canonical resolution.
+        join(process.cwd(), "agent-assets", "system-prompts", "routine-fetch-window.md"),
+    ];
+    for (const path of candidates) {
+        if (existsSync(path)) {
+            cachedFetchWindowSystemPrompt = substituteBrandTokens(readFileSync(path, "utf-8"));
+            return cachedFetchWindowSystemPrompt;
+        }
+    }
+    throw new Error(`routine.fetch_window system prompt not found. Looked in: ${candidates.join(", ")}`);
+}
+/**
+ * Test-only — drop the cached prompt so a subsequent call re-reads from
+ * disk. Production never needs this; the prompt is immutable per daemon
+ * boot.
+ */
+export function resetFetchWindowSystemPromptForTest() {
+    cachedFetchWindowSystemPrompt = null;
+}

package/dist/core/git-project-docs.d.ts

@@ -74,4 +74,3 @@ export declare function readBundledGitProjectDocTemplate(workspaceDir: string, c
 export declare function queueMissingGitProjectInits(options: QueueMissingGitProjectInitsOptions): number;
 export declare function queueGitProjectUpdate(options: QueueGitProjectUpdateOptions): "queued" | "merged" | "debounced" | "skipped";
 export {};
-//# sourceMappingURL=git-project-docs.d.ts.map

package/dist/core/git-project-docs.js

@@ -267,8 +267,8 @@ export function queueMissingGitProjectInits(options) {
         .all()
         .flatMap((row) => scheduleRepoKeys(parseTaskContext(row.task_context))));
     const insert = options.db.prepare(`INSERT INTO agent_schedule
-       (scheduled_for, task_type, task_description, task_context, correlation_id, model, status)
-     VALUES (?, 'git.project.init', ?, ?, ?, NULL, 'pending')`);
+       (scheduled_for, task_type, task_description, task_prompt, task_context, correlation_id, model, status)
+     VALUES (?, 'git.project.init', ?, ?, ?, ?, NULL, 'pending')`);
     for (const repo of options.repos) {
         const contextFile = repoDocContextFilePath(repo);
         if (existsSync(join(options.contextDir, contextFile)))
@@ -290,7 +290,11 @@ export function queueMissingGitProjectInits(options) {
             processKey: "git.project.init",
             ...buildBaseTaskContext(repo, now),
         };
-        insert.run(formatSqliteDatetime(now), `Initialize git project documentation for ${repo.slug}.`, JSON.stringify(taskContext), randomUUID());
+        const initLabel = `Initialize git project documentation for ${repo.slug}.`;
+        insert.run(formatSqliteDatetime(now), 
+        // task_description (label) === task_prompt (agent body); the real
+        // routing is task_context.processKey = "git.project.init".
+        initLabel, initLabel, JSON.stringify(taskContext), randomUUID());
         addScheduleKeysForRepo(existingRepoKeys, repo);
         inserted++;
     }
@@ -344,9 +348,13 @@ export function queueGitProjectUpdate(options) {
         ...buildBaseTaskContext(options.repo, now),
         events: [eventSummary],
     };
+    const updateLabel = `Update git project documentation for ${options.repo.slug}.`;
     options.db.prepare(`INSERT INTO agent_schedule
-       (scheduled_for, task_type, task_description, task_context, correlation_id, model, status)
-     VALUES (?, 'git.project.update', ?, ?, ?, NULL, 'pending')`).run(formatSqliteDatetime(now), `Update git project documentation for ${options.repo.slug}.`, JSON.stringify(taskContext), randomUUID());
+       (scheduled_for, task_type, task_description, task_prompt, task_context, correlation_id, model, status)
+     VALUES (?, 'git.project.update', ?, ?, ?, ?, NULL, 'pending')`).run(formatSqliteDatetime(now), 
+    // task_description (label) === task_prompt (agent body); routing is via
+    // task_context.processKey = "git.project.update".
+    updateLabel, updateLabel, JSON.stringify(taskContext), randomUUID());
     return "queued";
 }
 function parseTaskContext(raw) {
@@ -436,4 +444,3 @@ function isGitProjectEventSummary(value) {
         && typeof record.payload === "object"
         && !Array.isArray(record.payload));
 }
-//# sourceMappingURL=git-project-docs.js.map

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

@@ -41,7 +41,8 @@ export declare class HealthMonitor {
     private readonly startedAt;
     private timer;
     private anomalyBaseline;
-    /** Required context files (relative to context dir). B-007 §5.1. */
+    /** Required context files (relative to context dir). Updated for the
+     *  six-class vault layout (CONTEXT_VAULT_REDESIGN_PLAN). */
     private static readonly REQUIRED_FILES;
     constructor(deps: HealthMonitorDependencies);
     start(): void;
@@ -54,4 +55,3 @@ export declare class HealthMonitor {
     private detectAnomalies;
     private emitAnomaly;
 }
-//# sourceMappingURL=health-monitor.d.ts.map

package/dist/core/health-monitor.js

@@ -25,8 +25,12 @@ export class HealthMonitor {
     // this from getStatus() would couple the two paths and re-create the
     // stale-cache bug, so it is updated only on interval ticks.
     anomalyBaseline = null;
-    /** Required context files (relative to context dir). B-007 §5.1. */
-    static REQUIRED_FILES = ["user/profile.md", "today.md"];
+    /** Required context files (relative to context dir). Updated for the
+     *  six-class vault layout (CONTEXT_VAULT_REDESIGN_PLAN). */
+    static REQUIRED_FILES = [
+        "identity/profile.md",
+        "state/today.md",
+    ];
     constructor(deps) {
         this.db = deps.db;
         this.config = deps.config;
@@ -134,4 +138,3 @@ export class HealthMonitor {
         }));
     }
 }
-//# sourceMappingURL=health-monitor.js.map

package/dist/core/heartbeat.d.ts

@@ -23,4 +23,3 @@ export declare class Heartbeat {
     stop(): void;
     getLastTickAt(): number;
 }
-//# sourceMappingURL=heartbeat.d.ts.map

package/dist/core/heartbeat.js

@@ -45,4 +45,3 @@ export class Heartbeat {
         return this.lastTickAt;
     }
 }
-//# sourceMappingURL=heartbeat.js.map

package/dist/core/injection-policy.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Declarative injection policy table (CONTEXT_VAULT_REDESIGN_PLAN.md §8 +
+ * v4.2 V20 amendment).
+ *
+ * Single source of truth for two parallel opt-out registries that used to
+ * live in two different modules:
+ *
+ *  1. `context-builder.ts:resolveAlwaysInjectionPolicy` — narrow event types
+ *     that opt out of the heavy `<user>` / `<management_rules>` blocks.
+ *  2. `policy-files.ts:POLICY_KEY_GLOBAL_OPTOUT` — process keys that opt out
+ *     of the global `*` policy-file registry merge.
+ *
+ * Both registries track *the same architectural concern*: "this routine is
+ * narrow; do not pay budget for the wide-path always-injected content."
+ * Maintaining them in two files meant the next author adding a narrow
+ * routine had to make two coordinated edits + update a CLAUDE.md footnote.
+ * v4.2 V20 consolidates both behind `getInjectionPolicy(eventOrProcessKey)`.
+ *
+ * **Routine event types and routine process keys are the same string**
+ * (e.g. `routine.morning_routine_journal`). Other process keys (e.g.
+ * `message.dm`) have no opt-out today, so the function's "default" branch
+ * carries them on the wide path. If a future opt-out targets one of the
+ * non-routine surfaces, that decision lives here too.
+ *
+ * **Location rationale**: lives in its own module to break the import
+ * cycle that would form if `getInjectionPolicy` lived in `context-builder.ts`
+ * — `context-builder.ts` imports from `policy-files.ts`, and
+ * `policy-files.ts` now imports from this module. Putting the table in a
+ * leaf module keeps both consumers acyclic.
+ */
+/**
+ * Heavy always-injected blocks that an opt-out can shed.
+ *
+ * CONTEXT_VAULT_REDESIGN_PLAN.md §8.1 line 505 lists three keys —
+ * `user`, `management_rules`, `output_language_policy`. The third is
+ * intentionally omitted here today: `<output_language_policy>` is
+ * injected unconditionally by ContextBuilder (no event currently
+ * opts out) and adding it as a `AlwaysBlockKey` without a paired
+ * consumer at the injection site would be dead schema that the test
+ * suite would silently rubber-stamp. When a future routine
+ * legitimately needs to shed the language block, the right shape is
+ * to (a) extend this enum, (b) plumb the check into the
+ * `<output_language_policy>` emitter, and (c) update the byte-identity
+ * regression guard in `injection-policy.test.ts` — all in the same PR.
+ *
+ * `classes: ReadonlyArray<InjectedClass>` (the second §8.1 field) is
+ * also deferred: ContextBuilder still assembles per-event blocks via
+ * hardcoded path emitters, not class-prefix-driven walks. §6 Phase 2
+ * is the natural moment to introduce it.
+ */
+export type AlwaysBlockKey = "user" | "management_rules";
+/**
+ * The unified policy returned by `getInjectionPolicy`. Both
+ * `context-builder.ts` and `policy-files.ts` read this single shape.
+ */
+export interface InjectionPolicy {
+    /**
+     * Which heavy blocks to inject under `<user>` / `<management_rules>`.
+     * Empty set ⇔ neither block is injected (the narrowest opt-out today).
+     */
+    readonly alwaysBlocks: ReadonlySet<AlwaysBlockKey>;
+    /**
+     * Whether `resolvePolicyRefs(eventOrProcessKey)` should merge the
+     * registry's `*` row. `false` ⇔ event/process key was in the legacy
+     * `POLICY_KEY_GLOBAL_OPTOUT` set. The key must then re-declare any
+     * baseline policy file (e.g. `policies/redaction.md`) inline in its own
+     * `POLICY_FILE_REGISTRY` row.
+     */
+    readonly policyFileGlobalMerge: boolean;
+}
+/**
+ * Resolve the injection policy for an event type / process key string.
+ * Routine event types and routine process keys are the same string, so
+ * this function works for both call sites without translation.
+ *
+ * **Past precedents** (kept here for the next author's benchmark — these
+ * mirror the prose that used to live above `resolveAlwaysInjectionPolicy`):
+ *
+ *  - **Stage B** (`routine.morning_routine_journal`) — Phase 5 of
+ *    `morning-routine-optimization.md`. Drops `<management_rules>` because
+ *    the journal author reads `<journal_skeleton>` + `policies/journal-format.md`
+ *    and never SoT bindings. Keeps `<user>` for the people roster and
+ *    redaction-aware wikilinks. Also drops the `*` policy-file merge
+ *    because the lite-tier skill bundle never invokes MCP; the redaction
+ *    policy is re-declared inline.
+ *  - **Hourly check** (`routine.hourly_check`) — task-flow §"Execution
+ *    budget" explicitly tells the agent NOT to read roadmap / projects /
+ *    user files unless an observation warrants it.
+ *  - **Today refresh** (`routine.today_refresh`) — dashboard-triggered
+ *    manual rewrite of `today.md ## User Schedule`. Skill bundle is
+ *    `[context, today, external-services]`; no identity-aware text.
+ *  - **Observer events** (`github.*`, `git.*`, `schedule.approaching`) —
+ *    `observer.md` profile is structural classification (diff / commit /
+ *    payload vs. category routing); operator identity does not enter the
+ *    loop. Bundles never carry `<user>`-reading skills.
+ *  - **`scheduled.task`** — close-the-loop discipline is self-contained via
+ *    `<today>` + `<task_context>`. NOT generalised to `scheduled.dm` because
+ *    `morning_briefing` legitimately reads `<user>` for name resolution
+ *    and notification preferences.
+ *
+ * Out of scope here: `<today>` (small + always cited), `<agent_identity>`,
+ * `<current_time>`, `<settings>`, `<output_language_policy>`,
+ * `<integration_modes>`. When a routine has no need for `<today>` either,
+ * the right pattern is a dedicated slim builder (see `buildFetchWindowContext`),
+ * not a third boolean on this struct.
+ */
+export declare function getInjectionPolicy(eventOrProcessKey: string): InjectionPolicy;

package/dist/core/injection-policy.js

@@ -0,0 +1,117 @@
+/**
+ * Declarative injection policy table (CONTEXT_VAULT_REDESIGN_PLAN.md §8 +
+ * v4.2 V20 amendment).
+ *
+ * Single source of truth for two parallel opt-out registries that used to
+ * live in two different modules:
+ *
+ *  1. `context-builder.ts:resolveAlwaysInjectionPolicy` — narrow event types
+ *     that opt out of the heavy `<user>` / `<management_rules>` blocks.
+ *  2. `policy-files.ts:POLICY_KEY_GLOBAL_OPTOUT` — process keys that opt out
+ *     of the global `*` policy-file registry merge.
+ *
+ * Both registries track *the same architectural concern*: "this routine is
+ * narrow; do not pay budget for the wide-path always-injected content."
+ * Maintaining them in two files meant the next author adding a narrow
+ * routine had to make two coordinated edits + update a CLAUDE.md footnote.
+ * v4.2 V20 consolidates both behind `getInjectionPolicy(eventOrProcessKey)`.
+ *
+ * **Routine event types and routine process keys are the same string**
+ * (e.g. `routine.morning_routine_journal`). Other process keys (e.g.
+ * `message.dm`) have no opt-out today, so the function's "default" branch
+ * carries them on the wide path. If a future opt-out targets one of the
+ * non-routine surfaces, that decision lives here too.
+ *
+ * **Location rationale**: lives in its own module to break the import
+ * cycle that would form if `getInjectionPolicy` lived in `context-builder.ts`
+ * — `context-builder.ts` imports from `policy-files.ts`, and
+ * `policy-files.ts` now imports from this module. Putting the table in a
+ * leaf module keeps both consumers acyclic.
+ */
+/**
+ * Pre-allocated set shapes — `getInjectionPolicy` returns frozen shared
+ * instances so callers can compare with `Set.has` without per-call alloc.
+ */
+const ALL_BLOCKS = new Set([
+    "user",
+    "management_rules",
+]);
+const USER_ONLY = new Set([
+    "user",
+]);
+const NO_BLOCKS = new Set();
+const DEFAULT_POLICY = {
+    alwaysBlocks: ALL_BLOCKS,
+    policyFileGlobalMerge: true,
+};
+/**
+ * Resolve the injection policy for an event type / process key string.
+ * Routine event types and routine process keys are the same string, so
+ * this function works for both call sites without translation.
+ *
+ * **Past precedents** (kept here for the next author's benchmark — these
+ * mirror the prose that used to live above `resolveAlwaysInjectionPolicy`):
+ *
+ *  - **Stage B** (`routine.morning_routine_journal`) — Phase 5 of
+ *    `morning-routine-optimization.md`. Drops `<management_rules>` because
+ *    the journal author reads `<journal_skeleton>` + `policies/journal-format.md`
+ *    and never SoT bindings. Keeps `<user>` for the people roster and
+ *    redaction-aware wikilinks. Also drops the `*` policy-file merge
+ *    because the lite-tier skill bundle never invokes MCP; the redaction
+ *    policy is re-declared inline.
+ *  - **Hourly check** (`routine.hourly_check`) — task-flow §"Execution
+ *    budget" explicitly tells the agent NOT to read roadmap / projects /
+ *    user files unless an observation warrants it.
+ *  - **Today refresh** (`routine.today_refresh`) — dashboard-triggered
+ *    manual rewrite of `today.md ## User Schedule`. Skill bundle is
+ *    `[context, today, external-services]`; no identity-aware text.
+ *  - **Observer events** (`github.*`, `git.*`, `schedule.approaching`) —
+ *    `observer.md` profile is structural classification (diff / commit /
+ *    payload vs. category routing); operator identity does not enter the
+ *    loop. Bundles never carry `<user>`-reading skills.
+ *  - **`scheduled.task`** — close-the-loop discipline is self-contained via
+ *    `<today>` + `<task_context>`. NOT generalised to `scheduled.dm` because
+ *    `morning_briefing` legitimately reads `<user>` for name resolution
+ *    and notification preferences.
+ *
+ * Out of scope here: `<today>` (small + always cited), `<agent_identity>`,
+ * `<current_time>`, `<settings>`, `<output_language_policy>`,
+ * `<integration_modes>`. When a routine has no need for `<today>` either,
+ * the right pattern is a dedicated slim builder (see `buildFetchWindowContext`),
+ * not a third boolean on this struct.
+ */
+export function getInjectionPolicy(eventOrProcessKey) {
+    // Stage B — drops <management_rules> AND opts out of `*` policy merge.
+    if (eventOrProcessKey === "routine.morning_routine_journal") {
+        return {
+            alwaysBlocks: USER_ONLY,
+            policyFileGlobalMerge: false,
+        };
+    }
+    // Narrow routines (hourly check, today refresh) — drop both heavy
+    // blocks. `*` policy merge is preserved (redaction.md is non-negotiable).
+    if (eventOrProcessKey === "routine.hourly_check" ||
+        eventOrProcessKey === "routine.today_refresh") {
+        return {
+            alwaysBlocks: NO_BLOCKS,
+            policyFileGlobalMerge: true,
+        };
+    }
+    // Observer bucket — github.* / git.* / schedule.approaching.
+    if (eventOrProcessKey.startsWith("github.") ||
+        eventOrProcessKey.startsWith("git.") ||
+        eventOrProcessKey === "schedule.approaching") {
+        return {
+            alwaysBlocks: NO_BLOCKS,
+            policyFileGlobalMerge: true,
+        };
+    }
+    // scheduled.task — close-the-loop, no identity dependency.
+    if (eventOrProcessKey === "scheduled.task") {
+        return {
+            alwaysBlocks: NO_BLOCKS,
+            policyFileGlobalMerge: true,
+        };
+    }
+    return DEFAULT_POLICY;
+}

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

@@ -54,4 +54,3 @@ export interface IntegrationHealthEntry {
 }
 export type IntegrationHealthMap = Readonly<Record<IntegrationKey, IntegrationHealthEntry>>;
 export declare function buildIntegrationHealthMap(db: Database.Database, workspaceDir: string): IntegrationHealthMap;
-//# sourceMappingURL=integration-health.d.ts.map

package/dist/core/integration-health.js

@@ -2,7 +2,7 @@ import { INTEGRATION_DESCRIPTORS, INTEGRATION_KEYS, } from "@aitne/shared";
 import { readIntegrations } from "../db/integrations-store.js";
 import { listProbes, probeKey } from "../db/integration-probe-store.js";
 import { descriptorDefaultFeaturesMap, probeFeaturesMap, } from "./integration-probe.js";
-import { missingDelegatedVariants, missingNativeVariants, } from "./skills-compiler.js";
+import { missingDelegatedVariants, missingNativeVariants, } from "./skills-compiler-variants.js";
 /**
  * Sub-tier classification — registry-driven, not hand-maintained per
  * integration. The rule: a connector that ships `send` (gmail) is
@@ -116,4 +116,3 @@ export function buildIntegrationHealthMap(db, workspaceDir) {
     }
     return out;
 }
-//# sourceMappingURL=integration-health.js.map

package/dist/core/integration-lifecycle.d.ts

@@ -141,4 +141,3 @@ export declare function releaseIntegrationFlipLock(db: Database.Database, key: I
  * mode within the lock window"). Returns null when no lock is held.
  */
 export declare function readIntegrationFlipLock(db: Database.Database, key: IntegrationKey): IntegrationFlipLockRecord | null;
-//# sourceMappingURL=integration-lifecycle.d.ts.map

package/dist/core/integration-lifecycle.js

@@ -299,4 +299,3 @@ export function releaseIntegrationFlipLock(db, key) {
 export function readIntegrationFlipLock(db, key) {
     return readRuntimeState(db, flipLockKey(key));
 }
-//# sourceMappingURL=integration-lifecycle.js.map

package/dist/core/integration-main-backend.d.ts

@@ -73,4 +73,3 @@ export interface NativeCascadeEntry {
  * confirm the new backend binding via the setup wizard.
  */
 export declare function cascadeNativeBindingsOnMainSwitch(db: Database.Database, newMainBackendId: BackendId): NativeCascadeEntry[];
-//# sourceMappingURL=integration-main-backend.d.ts.map

package/dist/core/integration-main-backend.js

@@ -113,16 +113,23 @@ export function cascadeNativeBindingsOnMainSwitch(db, newMainBackendId) {
         if (state.mode !== "native")
             continue;
         const priorNativeBackend = state.nativeBackend;
+        // Defensive — superRefine on `integrationStateSchema` rejects
+        // mode='native' without nativeBackend at the read boundary, and
+        // `readIntegrations` falls back to disabled when parse fails. The
+        // block below stays so the helper is robust to future schema changes
+        // and hand-edited rows, but it is unreachable from the live registry.
+        /* c8 ignore next 8 */
         if (!priorNativeBackend) {
-            // Defensive — superRefine guarantees nativeBackend exists in native
-            // mode. A row missing it indicates registry drift; flip to disabled
-            // and log so the operator notices.
             logger.warn({ key }, "native integration carried no nativeBackend — flipping to disabled (registry drift)");
         }
         if (priorNativeBackend === newMainBackendId)
             continue;
         updateIntegrationState(db, key, {
             mode: "disabled",
+            // `state.deniedTools` is non-nullable on the parsed shape (defaults
+            // to []), but the `??` is preserved to keep the writer defensive
+            // against the same drift covered by the c8-ignored branch above.
+            /* c8 ignore next */
             deniedTools: state.deniedTools ?? [],
             lastChangedAt: now,
         });
@@ -132,6 +139,7 @@ export function cascadeNativeBindingsOnMainSwitch(db, newMainBackendId) {
             // un-truthy branch logs and falls through to here with a synthetic
             // value (`unknown` would be misleading); we mirror what the audit
             // row needs.
+            /* c8 ignore next */
             priorNativeBackend: (priorNativeBackend ?? newMainBackendId),
             newMainBackend: newMainBackendId,
         });
@@ -143,4 +151,3 @@ export function cascadeNativeBindingsOnMainSwitch(db, newMainBackendId) {
     }
     return flipped;
 }
-//# sourceMappingURL=integration-main-backend.js.map

package/dist/core/integration-probe.d.ts

@@ -95,4 +95,3 @@ export declare function probeFeaturesMap(result: ProbeResult): Readonly<Record<s
  * before the user has run a live probe.
  */
 export declare function descriptorDefaultFeaturesMap(integration: IntegrationKey, backend: BackendId): Readonly<Record<string, boolean>> | null;
-//# sourceMappingURL=integration-probe.d.ts.map

package/dist/core/integration-probe.js

@@ -149,4 +149,3 @@ export function descriptorDefaultFeaturesMap(integration, backend) {
     }
     return out;
 }
-//# sourceMappingURL=integration-probe.js.map

package/dist/core/management-md-write-lock.d.ts

@@ -1,5 +1,5 @@
 /**
- * `rules/management.md` write-lock manager — docs/design/21-management-
+ * `policies/management.md` write-lock manager — docs/design/21-management-
  * registry-and-entities.md §11.1.
  *
  * Mirrors the {@link InMemoryTodayWriteLockManager} pattern (see
@@ -65,4 +65,3 @@ export declare function withManagementMdWriteLock<T>(manager: ManagementMdWriteL
     ok: false;
     holder: string;
 }>;
-//# sourceMappingURL=management-md-write-lock.d.ts.map

package/dist/core/management-md-write-lock.js

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import { createLogger } from "../logging.js";
 const logger = createLogger("management-md-write-lock");
 /**
- * `rules/management.md` write-lock manager — docs/design/21-management-
+ * `policies/management.md` write-lock manager — docs/design/21-management-
  * registry-and-entities.md §11.1.
  *
  * Mirrors the {@link InMemoryTodayWriteLockManager} pattern (see
@@ -90,4 +90,3 @@ export async function withManagementMdWriteLock(manager, fn) {
         manager.release(acquired.lockId);
     }
 }
-//# sourceMappingURL=management-md-write-lock.js.map

package/dist/core/management-md.d.ts

@@ -5,10 +5,12 @@ import { type IntegrationsRecord } from "../db/integrations-store.js";
  * Integration Delegation Framework — `integrations.md` render + parse + watch
  * (Phase 1).
  *
- * `integrations.md` lives at `<dataDir>/integrations.md` (top-level, alongside
- * `.env` and `data.db`). It is the human-editable view of the integrations
- * map; the DB (`settings` table, key `"integrations"`) is the authoritative
- * source for the daemon.
+ * After the CONTEXT_VAULT_REDESIGN restructure (§11.5), `integrations.md`
+ * lives at `<contextDir>/policies/integrations.md` — inside the vault,
+ * under the policies class. The legacy `~/.personal-agent/integrations.md`
+ * location is migrated on the first boot post-upgrade by the
+ * `0004-context-vault-restructure` migration. The DB (`settings` table,
+ * key `"integrations"`) remains the authoritative source for the daemon.
  *
  * Write paths:
  *   - `PATCH /api/integrations/:key` → DB update → `renderManagementMd()`
@@ -24,7 +26,20 @@ import { type IntegrationsRecord } from "../db/integrations-store.js";
  * unconditionally, so hand-edits that round-trip cleanly through the
  * parser produce identical bytes on the next render (no churn).
  */
-export declare function getManagementMdPath(dataDir: string): string;
+/**
+ * Resolve the canonical absolute path to the management/integrations
+ * markdown file under the vault: `<contextDir>/policies/integrations.md`.
+ *
+ * `contextDir` is the preferred input — production callers thread
+ * `getContextDir(config, db)` through so the path is correct in both
+ * plain and Obsidian-vault modes. The optional `(dataDir)` fallback to
+ * `<dataDir>/context` exists for test fixtures that don't construct a
+ * full `AgentConfig`; it is NOT correct for Obsidian users (V18) and is
+ * scheduled for removal once every test thread has been audited.
+ */
+export declare function getManagementMdPath(dataDir: string, contextDir?: string): string;
+/** Filename portion only — preserved for callers that need to mirror it. */
+export declare const MANAGEMENT_MD_FILENAME = "integrations.md";
 /**
  * SETUP-FLOW-REDESIGN-PLAN §6.2 — declarative "where do the user's notes
  * live" routing for the agent. The body is regenerated from the
@@ -125,12 +140,12 @@ export declare function parseManagementMd(body: string): ParseResult;
  * handler is wired (SETUP-FLOW-REDESIGN-PLAN §6.2) so any user edit
  * round-trips through the proper inputs.
  */
-export declare function writeManagementMd(dataDir: string, integrations: IntegrationsRecord, notes?: NoteSourcesInput): Promise<string>;
+export declare function writeManagementMd(dataDir: string, integrations: IntegrationsRecord, notes?: NoteSourcesInput, contextDir?: string): Promise<string>;
 /**
  * Read + parse the file from disk. Returns `null` when the file does not
  * exist — callers treat that as "first run, write defaults and move on".
  */
-export declare function readAndParseManagementMd(dataDir: string): Promise<ParseResult | null>;
+export declare function readAndParseManagementMd(dataDir: string, contextDir?: string): Promise<ParseResult | null>;
 export interface ManagementMdBootResult {
     path: string;
     /** True if the file was missing and just created from DB state. */
@@ -153,7 +168,7 @@ export interface ManagementMdBootResult {
  *      file moves back to a known-good state. The owner-DM branch is
  *      Phase 2+; for now we only log.
  */
-export declare function bootstrapManagementMd(dataDir: string, db: Database.Database, workspaceDir?: string, notes?: NoteSourcesInput): Promise<ManagementMdBootResult>;
+export declare function bootstrapManagementMd(dataDir: string, db: Database.Database, workspaceDir?: string, notes?: NoteSourcesInput, contextDir?: string): Promise<ManagementMdBootResult>;
 export interface VariantRejection {
     key: IntegrationKey;
     backend: BackendId;
@@ -216,5 +231,4 @@ export interface ManagementMdWatcherOptions {
  * re-rendered to show the rollback, and (if `sendNotification` is wired)
  * the owner gets a DM explaining which files need to be authored.
  */
-export declare function startManagementMdWatcher(dataDir: string, db: Database.Database, options?: ManagementMdWatcherOptions): ManagementMdWatcherHandle;
-//# sourceMappingURL=management-md.d.ts.map
+export declare function startManagementMdWatcher(dataDir: string, db: Database.Database, options?: ManagementMdWatcherOptions, contextDir?: string): ManagementMdWatcherHandle;