@aitne/daemon 0.1.7 → 0.1.9

package/dist/db/recurring-schedules.d.ts

@@ -11,6 +11,16 @@ export interface RecurringScheduleRow {
      *  'sonnet' / 'opus' is the explicit escape hatch (PATCH `model`).
      *  See schema.ts comment on `recurring_schedules.model`. */
     model: string | null;
+    /** NULL when the operator has not pinned a tier; concrete
+     *  'lite' / 'medium' / 'high' overrides the dispatcher's process-key
+     *  default at execution time. Propagated through to every generated
+     *  agent_schedule row by `generateNextScheduleRow`. */
+    tier_override: string | null;
+    /** SCHEDULE_API_REDESIGN_PLAN §4.3a — snapshot of the operator's
+     *  backend pin at write time. Companions `model` so a registered
+     *  full model id resolves to a (backend, model) tuple at dispatch.
+     *  NULL when no model pin (alias rows, pure-tier rows, legacy rows). */
+    backend_id: string | null;
     recurrence_rule: string;
     enabled: number;
     last_scheduled_id: number | null;
@@ -27,6 +37,10 @@ export interface RecurringScheduleDTO {
     recurrenceRule: RecurrenceRule;
     /** Mirrors `RecurringScheduleRow.model` — null when no override. */
     model: string | null;
+    /** Mirrors `RecurringScheduleRow.tier_override` — null when no override. */
+    tier: string | null;
+    /** Mirrors `RecurringScheduleRow.backend_id` — null when no model pin. */
+    backendId: string | null;
     enabled: boolean;
     nextRunAt: string | null;
     recurrenceLabel: string;
@@ -41,7 +55,19 @@ export declare function createRecurringSchedule(db: Database.Database, params: {
     prompt?: string;
     recurrenceRule: RecurrenceRule;
     model?: string;
+    /** Abstract tier override — 'lite' | 'medium' | 'high'. Schema CHECK
+     *  enforces the enum at write time. */
+    tier?: string;
+    /** SCHEDULE_API_REDESIGN_PLAN §4.3a — captured backend pin that
+     *  companions `model`. The route's `validateModelToken` resolves a
+     *  registered model id to (backendId, modelId) and passes both in.
+     *  Schema CHECK enforces the BackendId enum at write time. */
+    backendId?: string;
     taskContext?: Record<string, unknown>;
+    /** Initial enabled state. Defaults to `true` (existing callers' behaviour).
+     *  The Agent loader passes the §6.4-resolved value so a disabled Agent's
+     *  recurring row is created disabled (and fires nothing). */
+    enabled?: boolean;
 }): RecurringScheduleDTO;
 export declare function listRecurringSchedules(db: Database.Database, options?: {
     enabledOnly?: boolean;
@@ -52,10 +78,26 @@ export declare function updateRecurringSchedule(db: Database.Database, id: numbe
     /** `string` sets an override; `null` clears it; `undefined` = no change. */
     prompt?: string | null;
     recurrenceRule?: RecurrenceRule;
-    model?: string;
+    /** `string` sets the model token; `null` clears it; `undefined` = no
+     *  change. Pair with `backendId` when setting a registered model id;
+     *  legacy aliases ('sonnet' / 'opus') should rewrite to `tier`
+     *  upstream and pass `model: null, backendId: null` here. */
+    model?: string | null;
+    /** `string` sets the backend pin; `null` clears it; `undefined` = no
+     *  change. See `model` — these two fields move together. */
+    backendId?: string | null;
+    /** `string` sets an override; `null` clears it; `undefined` = no change. */
+    tier?: string | null;
     taskContext?: Record<string, unknown>;
     enabled?: boolean;
-}): RecurringScheduleDTO | null;
+}, 
+/**
+ * AGENT_DEFINITIONS_DESIGN.md §11.3.2 — when an Agent-owned rule edit
+ * supersedes a pending materialisation, the loader's recurring-schedule
+ * adapter passes `"agent_definition_changed"` so the cancelled row records
+ * `task_context.skipReason`. Dashboard / API edits omit it (no tag).
+ */
+cancelReason?: string): RecurringScheduleDTO | null;
 export declare function deleteRecurringSchedule(db: Database.Database, id: number): boolean;
 /**
  * Reconciliation: for each enabled recurring schedule with no pending/running
@@ -67,4 +109,3 @@ export declare function deleteRecurringSchedule(db: Database.Database, id: numbe
  * @returns Number of new agent_schedule rows generated.
  */
 export declare function reconcileRecurringSchedules(db: Database.Database): number;
-//# sourceMappingURL=recurring-schedules.d.ts.map

package/dist/db/recurring-schedules.js

@@ -10,6 +10,8 @@ function rowToDTO(row) {
         prompt: row.task_prompt,
         recurrenceRule: rule,
         model: row.model,
+        tier: row.tier_override,
+        backendId: row.backend_id,
         enabled: row.enabled === 1,
         nextRunAt: row.next_run_at,
         recurrenceLabel: formatRecurrenceLabel(rule),
@@ -19,7 +21,33 @@ function rowToDTO(row) {
     };
 }
 // ── CRUD ─────────────────────────────────────────────────────────────
+/**
+ * Task types that MUST NOT become recurring rows.
+ * `reconcileRecurringSchedules` copies the parent row's `task_context`
+ * verbatim into every generated `agent_schedule` occurrence, so a recurring
+ * `browser_task` reuses a single fixed `preGeneratedTaskId` on each fire —
+ * the dispatcher's `getBrowserTask` dedup then hits `row_already_exists` and
+ * silently no-ops every occurrence after the first, so the recurring browser
+ * task only ever runs once. Recurring browser tasks are explicitly out of
+ * scope per BROWSER_TASK_REDESIGN_PLAN.md (one-shot scheduleAt path only);
+ * close the hole here rather than enable an undesigned feature.
+ *
+ * Note: `dm` / `dm_session` are intentionally NOT listed — the scheduler
+ * dispatches them per-occurrence with no preGeneratedTaskId dedup
+ * (`handleDirectDm` / a fresh `scheduled.dm` event), so recurring DMs /
+ * briefings are a supported, designed feature.
+ */
+const NON_RECURRING_ELIGIBLE_TASK_TYPES = new Set([
+    "browser_task",
+]);
 export function createRecurringSchedule(db, params) {
+    // Reject task types that can't safely recur (browser_task) as recurring
+    // task types. See NON_RECURRING_ELIGIBLE_TASK_TYPES — copying such a row's
+    // task_context into every occurrence reuses a single fixed
+    // preGeneratedTaskId, so only the first fire ever runs.
+    if (NON_RECURRING_ELIGIBLE_TASK_TYPES.has(params.taskType)) {
+        throw new Error(`task_type '${params.taskType}' is not supported for recurring schedules`);
+    }
     const rule = params.recurrenceRule;
     const nextOccurrence = computeNextOccurrence(rule, new Date());
     const nextRunAt = nextOccurrence ? formatSqliteDatetime(nextOccurrence) : null;
@@ -29,16 +57,24 @@ export function createRecurringSchedule(db, params) {
     // (`agent.task`, `agent.dm_task`, etc.). A concrete value is reserved
     // for explicit operator pins via the API.
     const persistedModel = params.model ?? null;
+    const persistedTier = params.tier ?? null;
+    const persistedBackendId = params.backendId ?? null;
     const persistedPrompt = params.prompt ?? null;
+    // Default to enabled so every existing caller (the /api/recurring-schedules
+    // route, scheduled-DM, repository runs) is unchanged; the Agent loader passes
+    // an explicit §6.4-resolved value so a disabled Agent's row is created off.
+    const persistedEnabled = params.enabled ?? true;
     const result = db.prepare(`
     INSERT INTO recurring_schedules
-      (task_type, task_description, task_prompt, task_context, model, recurrence_rule, enabled, next_run_at)
-    VALUES (?, ?, ?, ?, ?, ?, 1, ?)
-  `).run(params.taskType, params.description, persistedPrompt, JSON.stringify(params.taskContext ?? {}), persistedModel, JSON.stringify(rule), nextRunAt);
+      (task_type, task_description, task_prompt, task_context, model, tier_override, backend_id, recurrence_rule, enabled, next_run_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(params.taskType, params.description, persistedPrompt, JSON.stringify(params.taskContext ?? {}), persistedModel, persistedTier, persistedBackendId, JSON.stringify(rule), persistedEnabled ? 1 : 0, nextRunAt);
     const row = db.prepare("SELECT * FROM recurring_schedules WHERE id = ?").get(result.lastInsertRowid);
-    // Generate the first agent_schedule row
-    if (nextOccurrence) {
-        generateNextScheduleRow(db, row.id, params.taskType, rule, params.description, persistedPrompt, params.taskContext ?? {}, persistedModel, nextOccurrence);
+    // Generate the first agent_schedule row. Skip when the row is created
+    // disabled — the reconciler gates materialisation on `enabled = 1`, so a
+    // disabled row must not eagerly fire once before its first reconcile pass.
+    if (nextOccurrence && persistedEnabled) {
+        generateNextScheduleRow(db, row.id, params.taskType, rule, params.description, persistedPrompt, params.taskContext ?? {}, persistedModel, persistedTier, persistedBackendId, nextOccurrence);
     }
     // Re-read to get updated last_scheduled_id
     const updated = db.prepare("SELECT * FROM recurring_schedules WHERE id = ?").get(row.id);
@@ -56,7 +92,14 @@ export function getRecurringSchedule(db, id) {
     const row = db.prepare("SELECT * FROM recurring_schedules WHERE id = ?").get(id);
     return row ? rowToDTO(row) : null;
 }
-export function updateRecurringSchedule(db, id, params) {
+export function updateRecurringSchedule(db, id, params, 
+/**
+ * AGENT_DEFINITIONS_DESIGN.md §11.3.2 — when an Agent-owned rule edit
+ * supersedes a pending materialisation, the loader's recurring-schedule
+ * adapter passes `"agent_definition_changed"` so the cancelled row records
+ * `task_context.skipReason`. Dashboard / API edits omit it (no tag).
+ */
+cancelReason) {
     const existing = db.prepare("SELECT * FROM recurring_schedules WHERE id = ?").get(id);
     if (!existing)
         return null;
@@ -78,6 +121,21 @@ export function updateRecurringSchedule(db, id, params) {
         updates.push("model = ?");
         values.push(params.model);
     }
+    // SCHEDULE_API_REDESIGN_PLAN §4.3a — `backendId: null` is the explicit
+    // clear; `backendId: <BackendId>` sets the pin; `undefined` leaves the
+    // column untouched. The route's validator pairs this with `model`
+    // every time a registered model id resolves; pure-tier and alias
+    // paths leave both NULL.
+    if (params.backendId !== undefined) {
+        updates.push("backend_id = ?");
+        values.push(params.backendId);
+    }
+    // `tier: null` is the explicit clear; `tier: <enum>` sets the
+    // override; `undefined` leaves the column untouched.
+    if (params.tier !== undefined) {
+        updates.push("tier_override = ?");
+        values.push(params.tier);
+    }
     if (params.taskContext !== undefined) {
         updates.push("task_context = ?");
         values.push(JSON.stringify(params.taskContext));
@@ -92,23 +150,28 @@ export function updateRecurringSchedule(db, id, params) {
     values.push(id);
     db.prepare(`UPDATE recurring_schedules SET ${updates.join(", ")} WHERE id = ?`).run(...values);
     // If recurrence rule changed or re-enabled, recompute next_run_at
-    // and cancel the old pending agent_schedule row
+    // and cancel the old pending agent_schedule row. AGENT_DEFINITIONS_DESIGN.md
+    // §11.3.2: a pending materialisation derived from the *old* rule is
+    // superseded; cancelling it (status='skipped') + recomputing next_run_at is
+    // the re-materialisation. `running` rows are deliberately left alone (the
+    // WHERE clause filters to `pending` only). `cancelReason`, when supplied by
+    // an Agent-driven edit, tags the skipped row's `task_context.skipReason` so
+    // the cause is attributable.
     if (params.recurrenceRule !== undefined || params.enabled !== undefined) {
         const row = db.prepare("SELECT * FROM recurring_schedules WHERE id = ?").get(id);
         if (row.enabled) {
-            // Cancel any existing pending row for this recurring schedule
-            db.prepare("UPDATE agent_schedule SET status = 'skipped' WHERE recurring_schedule_id = ? AND status = 'pending'").run(id);
+            cancelPendingScheduleRows(db, id, cancelReason);
             const rule = JSON.parse(row.recurrence_rule);
             const nextOccurrence = computeNextOccurrence(rule, new Date());
             const nextRunAt = nextOccurrence ? formatSqliteDatetime(nextOccurrence) : null;
             db.prepare("UPDATE recurring_schedules SET next_run_at = ? WHERE id = ?").run(nextRunAt, id);
             if (nextOccurrence) {
-                generateNextScheduleRow(db, id, row.task_type, rule, row.task_description ?? "", row.task_prompt, JSON.parse(row.task_context || "{}"), row.model, nextOccurrence);
+                generateNextScheduleRow(db, id, row.task_type, rule, row.task_description ?? "", row.task_prompt, JSON.parse(row.task_context || "{}"), row.model, row.tier_override, row.backend_id, nextOccurrence);
             }
         }
         else {
             // Disabled — cancel pending rows and clear next_run_at
-            db.prepare("UPDATE agent_schedule SET status = 'skipped' WHERE recurring_schedule_id = ? AND status = 'pending'").run(id);
+            cancelPendingScheduleRows(db, id, cancelReason);
             db.prepare("UPDATE recurring_schedules SET next_run_at = NULL WHERE id = ?").run(id);
         }
     }
@@ -127,26 +190,59 @@ export function deleteRecurringSchedule(db, id) {
     return true;
 }
 // ── Reconciliation ───────────────────────────────────────────────────
+/**
+ * Cancel every still-`pending` agent_schedule row backing a recurring
+ * schedule (status → `skipped`). When `reason` is supplied it is recorded on
+ * each cancelled row's `task_context.skipReason` (AGENT_DEFINITIONS_DESIGN.md
+ * §11.3.2 — attributes an Agent-definition-driven re-materialisation).
+ * `running` rows are never touched (the WHERE filters to `pending`).
+ */
+function cancelPendingScheduleRows(db, recurringId, reason) {
+    if (reason) {
+        db.prepare(`UPDATE agent_schedule
+          SET status = 'skipped',
+              task_context = json_set(COALESCE(task_context, '{}'), '$.skipReason', ?)
+        WHERE recurring_schedule_id = ? AND status = 'pending'`).run(reason, recurringId);
+        return;
+    }
+    db.prepare("UPDATE agent_schedule SET status = 'skipped' WHERE recurring_schedule_id = ? AND status = 'pending'").run(recurringId);
+}
 /**
  * Generate a single agent_schedule row for a recurring schedule.
  */
-function generateNextScheduleRow(db, recurringId, taskType, rule, description, prompt, taskContext, model, nextOccurrence) {
+function generateNextScheduleRow(db, recurringId, taskType, rule, description, prompt, taskContext, model, tier, backendId, nextOccurrence) {
     const scheduledFor = formatSqliteDatetime(nextOccurrence);
+    // AGENT_DEFINITIONS_DESIGN.md §7.2 — stamp the owning Agent's slug into the
+    // materialised row's `task_context` so the dispatcher's agent_id resolution
+    // (§8.1 step 1) attributes the execution without a join. Built-in routines
+    // own no recurring row, so this is the user-Agent path only; a recurring row
+    // with no paired Agent (a raw `/api/recurring-schedules` row) leaves the key
+    // unset. The `agents` table is always present (created by `applySchema`).
+    const owner = db
+        .prepare("SELECT id FROM agents WHERE recurring_schedule_id = ? LIMIT 1")
+        .get(recurringId);
     // Recurring materialization is an internal tick — the parent
     // `recurring_schedules` row already represents the user-facing
     // commitment, so mark each generated agent_schedule as `low` to keep
     // it out of roadmap's `Scheduled:` entries (the recurring cadence
     // itself is visible via `routine.roadmap_refresh` reading recurring
     // schedules separately, not via this mechanical materialization).
-    const result = db.prepare(`
-    INSERT INTO agent_schedule
-      (scheduled_for, task_type, task_description, task_prompt, task_context, model, status, recurring_schedule_id)
-    VALUES (?, ?, ?, ?, ?, ?, 'pending', ?)
-  `).run(scheduledFor, taskType, description, prompt, JSON.stringify({
+    const context = {
         ...taskContext,
         recurringScheduleId: recurringId,
         importance: "low",
-    }), model, recurringId);
+    };
+    if (owner)
+        context.agent_id = owner.id;
+    const result = db.prepare(`
+    INSERT INTO agent_schedule
+      (scheduled_for, task_type, task_description, task_prompt, task_context, model, tier_override, backend_id, status, recurring_schedule_id)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?)
+  `).run(scheduledFor, taskType, description, 
+    // The dispatcher reads task_prompt directly (no description fallback), so
+    // materialized rows must always carry it: use the rule's prompt override
+    // when set, else fall back to its description body.
+    prompt ?? description, JSON.stringify(context), model, tier, backendId, recurringId);
     db.prepare("UPDATE recurring_schedules SET last_scheduled_id = ? WHERE id = ?").run(result.lastInsertRowid, recurringId);
 }
 /**
@@ -190,7 +286,7 @@ export function reconcileRecurringSchedules(db) {
                 continue;
             const nextRunAt = formatSqliteDatetime(nextOccurrence);
             db.prepare("UPDATE recurring_schedules SET next_run_at = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(nextRunAt, row.id);
-            generateNextScheduleRow(db, row.id, row.task_type, rule, row.task_description ?? "", row.task_prompt, JSON.parse(row.task_context || "{}"), row.model, nextOccurrence);
+            generateNextScheduleRow(db, row.id, row.task_type, rule, row.task_description ?? "", row.task_prompt, JSON.parse(row.task_context || "{}"), row.model, row.tier_override, row.backend_id, nextOccurrence);
             generated++;
         }
         catch (rowErr) {
@@ -210,4 +306,3 @@ export function reconcileRecurringSchedules(db) {
     }
     return generated;
 }
-//# sourceMappingURL=recurring-schedules.js.map

package/dist/db/repositories-store.d.ts

@@ -1,4 +1,5 @@
 import type Database from "better-sqlite3";
+import type { BackendId } from "@aitne/shared";
 import type { GitWatchedRepoSetting } from "../settings/runtime-settings.js";
 /**
  * Unified Repositories store — see
@@ -94,7 +95,7 @@ export interface RepositoryUpdateInput {
     pollIntervalSec?: number | null;
 }
 export type TriggerWorkdirMode = "temp" | "local-clone";
-export type TriggerBackend = "claude" | "codex" | "gemini";
+export type TriggerBackend = BackendId;
 export interface RepositoryTriggerRow {
     id: string;
     repository_id: string;
@@ -293,4 +294,3 @@ export declare function recordManagementScan(db: Database.Database, repositoryId
  * `intervalMs` ago (or never ran).
  */
 export declare function listManagementDueForScan(db: Database.Database, intervalMs: number, now?: number): RepositoryDTO[];
-//# sourceMappingURL=repositories-store.d.ts.map

package/dist/db/repositories-store.js

@@ -10,6 +10,15 @@ export class RepositoryStoreError extends Error {
 // ── Slug helper ──────────────────────────────────────────────────────
 const SLUG_MAX = 60;
 const SLUG_PATTERN = /[^a-z0-9._-]+/g;
+// Defense-in-depth (C3): the SLUG_PATTERN allows `.` so legitimate slugs
+// like `v1.2.3` or `my.tool` survive sanitization. A *pure-dot* slug
+// (`.`, `..`, `...`) is structurally legal under that pattern but
+// catastrophic downstream: `path.join(contextDir, "git/../overview.md")`
+// normalises the `..` segment and redirects the agent's architecture
+// write to a top-level context file. Reject pure-dot candidates here so
+// no caller — direct store user, future API loosening, or fixture import
+// — can produce a slug that escapes the `git/<slug>/` namespace.
+const PURE_DOT_PATTERN = /^\.+$/;
 function lastPathSegment(value) {
     const trimmed = value.replace(/[\\/]+$/g, "");
     const segments = trimmed.split(/[\\/]+/).filter((s) => s.length > 0);
@@ -59,11 +68,31 @@ export function deriveSlug(input) {
             .replace(SLUG_PATTERN, "-")
             .replace(/^-+|-+$/g, "")
             .slice(0, SLUG_MAX);
-        if (sanitized.length > 0)
-            return sanitized;
+        if (sanitized.length === 0)
+            continue;
+        // Pure-dot slugs are rejected even though they sanitize cleanly — see
+        // PURE_DOT_PATTERN comment above for the path-traversal rationale.
+        if (PURE_DOT_PATTERN.test(sanitized))
+            continue;
+        return sanitized;
     }
+    // Final fallback. The id-prefix is normally hex/colon (e.g.
+    // `local:<sha1[:12]>`, `github:<owner>/<repo>`) and sanitizes to a safe
+    // slug, but a synthetic id could theoretically reduce to dots-only —
+    // harden that branch too with a deterministic hash escape via the
+    // existing `pathHash12` helper (sha1, 12-char hex prefix).
     const fallback = (input.id ?? "row").slice(0, 12);
-    return `repo-${fallback.toLowerCase().replace(SLUG_PATTERN, "-")}`;
+    const fallbackSlug = fallback
+        .toLowerCase()
+        .replace(SLUG_PATTERN, "-")
+        .replace(/^-+|-+$/g, "");
+    if (fallbackSlug.length === 0 || PURE_DOT_PATTERN.test(fallbackSlug)) {
+        // input.id is non-undefined whenever this branch fires — a missing
+        // id sanitizes to "row" which never matches the pure-dot / empty
+        // guard above. The `?? "row"` is purely defensive.
+        return `repo-${pathHash12(input.id ?? /* c8 ignore next */ "row")}`;
+    }
+    return `repo-${fallbackSlug}`;
 }
 function pathHash12(path) {
     return createHash("sha1").update(path).digest("hex").slice(0, 12);
@@ -110,6 +139,9 @@ function findRepositoryWithEquivalentLocalPath(db, localPath, excludeId) {
     for (const row of rows) {
         if (excludeId !== null && row.id === excludeId)
             continue;
+        // SQL filter already excludes NULL local_path; the JS guard is
+        // defensive against schema drift.
+        /* c8 ignore next */
         if (!row.local_path)
             continue;
         if (localPathCompareKey(row.local_path) === targetKey)
@@ -263,9 +295,15 @@ export function createRepository(db, input, now = Date.now()) {
         const duplicateGithub = db
             .prepare("SELECT id FROM repositories WHERE github_owner = ? AND github_repo = ? LIMIT 1")
             .get(input.githubOwner, input.githubRepo);
+        /* c8 ignore start — `id` (`github:<owner>/<repo>`) is derived from
+           the same fields, so the id-based existence check above already
+           catches every duplicate. The owner/repo SELECT here is defensive
+           against future id-derivation changes that decouple the slug from
+           the github fields. */
         if (duplicateGithub) {
             throw new RepositoryStoreError("duplicate_github", `GitHub remote ${input.githubOwner}/${input.githubRepo} is already registered`);
         }
+        /* c8 ignore stop */
     }
     if (input.localPath) {
         const duplicateLocal = findRepositoryWithEquivalentLocalPath(db, input.localPath, null);
@@ -751,4 +789,3 @@ export function listManagementDueForScan(db, intervalMs, now = Date.now()) {
         .all(cutoff);
     return rows.map(rowToDTO);
 }
-//# sourceMappingURL=repositories-store.js.map

package/dist/db/runtime-state.d.ts

@@ -29,7 +29,7 @@ export declare function clearDegradedMode(db: Database.Database): void;
  * Latched "setup completed" marker (Management Mode bootstrap bypass).
  *
  * Written the first time `runVaultHealthProbe` observes
- * `rules/management.md` in either the fallback or primary vault
+ * `policies/management.md` in either the fallback or primary vault
  * location. It stays latched during normal operation — a user whose
  * vault later becomes unreachable should enter degraded mode, NOT fall
  * back into bootstrapping where the 503 gate is disabled. Explicit reset
@@ -58,4 +58,34 @@ export declare function setUserPaused(db: Database.Database, state: UserPausedSt
 export declare function getUserPaused(db: Database.Database): UserPausedState | null;
 export declare function clearUserPaused(db: Database.Database): void;
 export declare function isUserPaused(db: Database.Database): boolean;
-//# sourceMappingURL=runtime-state.d.ts.map
+/**
+ * CONTEXT_VAULT_REDESIGN_PLAN.md §11.3.4 / V16 — explicit acknowledgement
+ * that an Obsidian-mode user has consented to the vault restructure
+ * reorganizing their Obsidian sidebar. Until present, the bootstrap layer
+ * defers migration `0004-context-vault-restructure` and records pending
+ * state so the dashboard can render a consent surface. Headless installs
+ * can set `PA_VAULT_RESTRUCTURE_ACK=1`; that path also writes this key
+ * (source="env") so subsequent boots short-circuit the env check.
+ */
+export declare const VAULT_RESTRUCTURE_ACK_KEY = "context_vault_restructure_acknowledged_at";
+export interface VaultRestructureAck {
+    at: string;
+    source: "env" | "dashboard" | "cli";
+}
+export declare function getVaultRestructureAck(db: Database.Database): VaultRestructureAck | null;
+export declare function setVaultRestructureAck(db: Database.Database, ack: VaultRestructureAck): void;
+/**
+ * Surfaced via `/api/health` so the dashboard can render a "vault
+ * restructure pending" banner. Written when the bootstrap defers the
+ * migration on Obsidian + no-ack; cleared once the migration applies or
+ * the vault has already reached the target layout.
+ */
+export declare const VAULT_RESTRUCTURE_PENDING_CONSENT_KEY = "context_vault_restructure_pending_consent";
+export interface VaultRestructurePendingConsent {
+    since: string;
+    reason: "obsidian_consent_required";
+    contextDir: string;
+}
+export declare function getVaultRestructurePendingConsent(db: Database.Database): VaultRestructurePendingConsent | null;
+export declare function setVaultRestructurePendingConsent(db: Database.Database, state: VaultRestructurePendingConsent): void;
+export declare function clearVaultRestructurePendingConsent(db: Database.Database): void;

package/dist/db/runtime-state.js

@@ -63,7 +63,7 @@ export function clearDegradedMode(db) {
  * Latched "setup completed" marker (Management Mode bootstrap bypass).
  *
  * Written the first time `runVaultHealthProbe` observes
- * `rules/management.md` in either the fallback or primary vault
+ * `policies/management.md` in either the fallback or primary vault
  * location. It stays latched during normal operation — a user whose
  * vault later becomes unreachable should enter degraded mode, NOT fall
  * back into bootstrapping where the 503 gate is disabled. Explicit reset
@@ -101,4 +101,35 @@ export function clearUserPaused(db) {
 export function isUserPaused(db) {
     return getUserPaused(db) !== null;
 }
-//# sourceMappingURL=runtime-state.js.map
+/**
+ * CONTEXT_VAULT_REDESIGN_PLAN.md §11.3.4 / V16 — explicit acknowledgement
+ * that an Obsidian-mode user has consented to the vault restructure
+ * reorganizing their Obsidian sidebar. Until present, the bootstrap layer
+ * defers migration `0004-context-vault-restructure` and records pending
+ * state so the dashboard can render a consent surface. Headless installs
+ * can set `PA_VAULT_RESTRUCTURE_ACK=1`; that path also writes this key
+ * (source="env") so subsequent boots short-circuit the env check.
+ */
+export const VAULT_RESTRUCTURE_ACK_KEY = "context_vault_restructure_acknowledged_at";
+export function getVaultRestructureAck(db) {
+    return readRuntimeState(db, VAULT_RESTRUCTURE_ACK_KEY);
+}
+export function setVaultRestructureAck(db, ack) {
+    writeRuntimeState(db, VAULT_RESTRUCTURE_ACK_KEY, ack);
+}
+/**
+ * Surfaced via `/api/health` so the dashboard can render a "vault
+ * restructure pending" banner. Written when the bootstrap defers the
+ * migration on Obsidian + no-ack; cleared once the migration applies or
+ * the vault has already reached the target layout.
+ */
+export const VAULT_RESTRUCTURE_PENDING_CONSENT_KEY = "context_vault_restructure_pending_consent";
+export function getVaultRestructurePendingConsent(db) {
+    return readRuntimeState(db, VAULT_RESTRUCTURE_PENDING_CONSENT_KEY);
+}
+export function setVaultRestructurePendingConsent(db, state) {
+    writeRuntimeState(db, VAULT_RESTRUCTURE_PENDING_CONSENT_KEY, state);
+}
+export function clearVaultRestructurePendingConsent(db) {
+    deleteRuntimeState(db, VAULT_RESTRUCTURE_PENDING_CONSENT_KEY);
+}

package/dist/db/schema.d.ts

@@ -1,4 +1,3 @@
 import type Database from "better-sqlite3";
 /** Apply the complete schema and seed data to a database. Idempotent. */
 export declare function applySchema(db: Database.Database): void;
-//# sourceMappingURL=schema.d.ts.map