@aitne/daemon 0.1.8 → 0.1.10

package/dist/core/signal-detector.js

@@ -1,5 +1,7 @@
-import { formatSqliteDatetime } from "@aitne/shared";
+import { formatSqliteDatetime, redactSensitiveString } from "@aitne/shared";
+import { hasFeedbackSignalForAction, recordFeedbackSignal, } from "../db/feedback-signals-store.js";
 import { createLogger } from "../logging.js";
+import { resolveAgentId } from "./agents/agent-id-resolver.js";
 const logger = createLogger("signal-detector");
 /**
  * Maximum number of Raw Signal entries kept in user/profile.md. Prevents
@@ -18,7 +20,7 @@ const DEDUP_TTL_MS = 10 * 60 * 1000;
  *
  * Detects behavioral patterns from messaging platforms and appends
  * structured entries to user/profile.md's "Raw Signals" section via the
- * Context File API (PATCH /api/context/user/profile).
+ * Context File API (PATCH /api/context/identity/profile).
  *
  * All writes go through the Daemon's own HTTP API to:
  * - Respect the Context File API mutex (no race conditions)
@@ -37,6 +39,7 @@ const DEDUP_TTL_MS = 10 * 60 * 1000;
  */
 export class SignalDetector {
     config;
+    deps;
     /** Track pending notifications for ignore detection */
     pendingNotifications = new Map();
     /** Rolling dedup cache: signal key → expiry timestamp */
@@ -47,8 +50,9 @@ export class SignalDetector {
     ignoreCheckInterval = null;
     /** API base URL for Context File API (self-referencing) */
     apiBaseUrl;
-    constructor(config) {
+    constructor(config, deps = {}) {
         this.config = config;
+        this.deps = deps;
         this.ignoreThresholdMs = 30 * 60 * 1000; // 30 minutes
         this.apiBaseUrl = `http://localhost:${config.apiPort}`;
     }
@@ -71,10 +75,17 @@ export class SignalDetector {
      * Called by NotificationManager after successful delivery.
      */
     trackNotification(notificationId, platform, content) {
+        const metadata = this.lookupNotificationMetadata(notificationId);
         this.pendingNotifications.set(notificationId, {
             sentAt: Date.now(),
-            platform,
-            content: content.slice(0, 100), // Truncate for signal log
+            // Single fallback to the delivered platform here, not redundantly inside
+            // the lookup — the tracked id's suffix is the delivery platform anyway.
+            platform: metadata.platform ?? platform,
+            channel: metadata.channel,
+            content: (metadata.contentSummary ?? content).slice(0, 100), // Truncate for signal log
+            dispatchId: metadata.dispatchId,
+            notificationType: metadata.notificationType,
+            agentId: metadata.agentId,
         });
     }
     /**
@@ -85,12 +96,24 @@ export class SignalDetector {
         const { platform, emoji, responseTimeMs } = params;
         // Remove from pending (user responded)
         if (params.notificationId) {
-            this.pendingNotifications.delete(params.notificationId);
+            const pendingId = this.resolvePendingNotificationId(params.notificationId);
+            this.pendingNotifications.delete(pendingId);
+            this.recordNotificationOutcome({
+                notificationId: pendingId,
+                reaction: "replied",
+                valence: "positive",
+                evidence: {
+                    emoji,
+                    responseTimeMs,
+                    weight: 0.5,
+                },
+            });
         }
         const signal = {
             timestamp: formatSqliteDatetime(new Date()),
             type: "reaction",
-            detail: `${emoji} on ${platform}${responseTimeMs ? ` (${Math.round(responseTimeMs / 1000)}s)` : ""}`,
+            detail: `${emoji} on ${platform}`
+                + `${responseTimeMs ? ` (${Math.round(responseTimeMs / 1000)}s)` : ""}`,
         };
         void this.appendSignal(signal);
     }
@@ -100,29 +123,68 @@ export class SignalDetector {
      */
     onUserMessage(params) {
         const { content, responseToNotificationId } = params;
+        const pendingNotificationId = responseToNotificationId
+            ? this.resolvePendingNotificationId(responseToNotificationId)
+            : this.findPendingNotificationForReply(params.platform, params.channel);
         // Remove from pending (user responded)
-        if (responseToNotificationId) {
-            this.pendingNotifications.delete(responseToNotificationId);
+        if (pendingNotificationId) {
+            this.pendingNotifications.delete(pendingNotificationId);
         }
         // Detect correction instructions
-        const correctionPatterns = [
-            /shorter|brief|concise/i,
-            /more detail|elaborate|expand/i,
-            /\bin (english|spanish|french|german|portuguese|italian|chinese|japanese|korean|arabic|hindi|russian)\b/i,
-            /bullet points|bulleted list/i,
-        ];
-        for (const pattern of correctionPatterns) {
-            if (pattern.test(content)) {
-                const signal = {
-                    timestamp: formatSqliteDatetime(new Date()),
-                    type: "correction",
-                    detail: `"${content.slice(0, 60)}"`,
-                };
-                void this.appendSignal(signal);
-                return; // Only log the first matching correction
-            }
+        const isCorrection = SignalDetector.isCorrectionContent(content);
+        if (pendingNotificationId) {
+            this.recordNotificationOutcome({
+                notificationId: pendingNotificationId,
+                reaction: isCorrection ? "corrected" : "replied",
+                valence: isCorrection ? "correction" : "positive",
+                evidence: {
+                    excerpt: content.slice(0, 160),
+                    weight: isCorrection ? 1.0 : 0.5,
+                },
+            });
+        }
+        if (isCorrection) {
+            const signal = {
+                timestamp: formatSqliteDatetime(new Date()),
+                type: "correction",
+                detail: `"${content.slice(0, 60)}"`,
+            };
+            void this.appendSignal(signal);
+            return; // Only log the first matching correction
         }
     }
+    /**
+     * Record a positive action correlated with a notification. This is the
+     * narrow "acted" path: callers must have an actual task/action observation,
+     * never silence, before invoking it.
+     *
+     * NOTE — intentional Phase-1.5 seam, no production caller yet (by design).
+     * Firing `acted` deterministically needs the notification's subject
+     * `(source, ref)` in `pendingNotifications` to match a later observation,
+     * but that subject never reaches `trackNotification`: entity-related
+     * proactive DMs are re-authored by an agent turn and delivered via
+     * `POST /api/agent/notify`, which carries only message/platform/priority
+     * (no subject), and the direct `NotificationManager.send()` paths carry
+     * `data:{}`. So this stays correct + silence-safe but dormant — do NOT
+     * wire it from a silence- or substring-heuristic source (that re-opens the
+     * sign-inversion the promotion gate exists to kill). The loop is complete
+     * without it (`explicit` + `replied` drive promotion). See
+     * FEEDBACK_LEARNING_LOOP_DESIGN.md §11 v1.9#2 + v1.11.
+     */
+    onNotificationActed(params) {
+        const pendingId = this.resolvePendingNotificationId(params.notificationId);
+        this.pendingNotifications.delete(pendingId);
+        this.recordNotificationOutcome({
+            notificationId: pendingId,
+            reaction: "acted",
+            valence: "positive",
+            evidence: {
+                actionRef: params.actionRef,
+                detail: params.detail,
+                weight: 0.5,
+            },
+        });
+    }
     /** Check for messages that have been ignored (no response within threshold) */
     checkIgnoredMessages() {
         const now = Date.now();
@@ -136,6 +198,16 @@ export class SignalDetector {
                     detail: `${info.platform}: "${info.content}" unread for ${Math.round(elapsed / 60000)}min`,
                 };
                 void this.appendSignal(signal);
+                this.recordNotificationOutcome({
+                    notificationId: id,
+                    reaction: "ignored",
+                    valence: "neutral",
+                    evidence: {
+                        elapsedMs: elapsed,
+                        weight: 0.25,
+                        initiatesLesson: false,
+                    },
+                });
                 toRemove.push(id);
             }
         }
@@ -145,7 +217,7 @@ export class SignalDetector {
     }
     /**
      * Append a raw signal to user/profile.md's "## Raw Signals" section
-     * via the Context File API (PATCH /api/context/user/profile).
+     * via the Context File API (PATCH /api/context/identity/profile).
      *
      * Uses the Daemon's own HTTP API to ensure:
      * - Write serialization via context mutex
@@ -169,7 +241,7 @@ export class SignalDetector {
         this.recentSignals.set(dedupKey, now + DEDUP_TTL_MS);
         const entry = `- [${signal.timestamp}] [${signal.type}] ${signal.detail}`;
         try {
-            const response = await fetch(`${this.apiBaseUrl}/api/context/user/profile`, {
+            const response = await fetch(`${this.apiBaseUrl}/api/context/identity/profile`, {
                 method: "PATCH",
                 headers: { "Content-Type": "application/json" },
                 body: JSON.stringify({
@@ -211,5 +283,185 @@ export class SignalDetector {
             }
         }
     }
+    static isCorrectionContent(content) {
+        const correctionPatterns = [
+            /shorter|brief|concise/i,
+            /more detail|elaborate|expand/i,
+            /\bin (english|spanish|french|german|portuguese|italian|chinese|japanese|korean|arabic|hindi|russian)\b/i,
+            /bullet points|bulleted list/i,
+            /\b(stop|no)\b.*\b(notify|message|remind|send|doing|do|again|that)\b/i,
+            /\b(do not|don't)\b/i,
+        ];
+        return correctionPatterns.some((pattern) => pattern.test(content));
+    }
+    findPendingNotificationForReply(platform, channel) {
+        const now = Date.now();
+        let candidate = null;
+        for (const [id, info] of this.pendingNotifications) {
+            if (info.platform !== platform)
+                continue;
+            if (channel && info.channel && info.channel !== channel)
+                continue;
+            if (now - info.sentAt > this.ignoreThresholdMs)
+                continue;
+            if (candidate === null || info.sentAt > candidate.sentAt) {
+                candidate = { id, sentAt: info.sentAt };
+            }
+        }
+        return candidate?.id ?? null;
+    }
+    resolvePendingNotificationId(notificationId) {
+        if (this.pendingNotifications.has(notificationId))
+            return notificationId;
+        for (const id of this.pendingNotifications.keys()) {
+            if (id.startsWith(`${notificationId}:`))
+                return id;
+        }
+        return notificationId;
+    }
+    lookupNotificationMetadata(notificationId) {
+        const parsed = SignalDetector.parseTrackedNotificationId(notificationId);
+        if (!this.deps.db || !parsed.dispatchId) {
+            return {
+                dispatchId: parsed.dispatchId,
+                platform: parsed.platform,
+                channel: null,
+                notificationType: null,
+                contentSummary: null,
+                agentId: null,
+                rowId: null,
+            };
+        }
+        const platformValue = parsed.platform;
+        const platformPredicate = platformValue ? "AND platform = ?" : "";
+        const values = platformValue
+            ? [parsed.dispatchId, platformValue]
+            : [parsed.dispatchId];
+        const row = this.deps.db
+            .prepare(`SELECT id, dispatch_id, platform, delivery_channel, notification_type, content_summary
+         FROM notification_log
+         WHERE dispatch_id = ? ${platformPredicate}
+         ORDER BY id DESC
+         LIMIT 1`)
+            .get(...values);
+        const notificationType = row?.notification_type ?? null;
+        return {
+            dispatchId: row?.dispatch_id ?? parsed.dispatchId,
+            platform: row?.platform ?? parsed.platform,
+            channel: row?.delivery_channel ?? null,
+            notificationType,
+            contentSummary: row?.content_summary ?? null,
+            agentId: this.resolveAgentIdForNotification(notificationType),
+            rowId: row?.id ?? null,
+        };
+    }
+    resolveAgentIdForNotification(notificationType) {
+        if (!this.deps.db || !notificationType?.startsWith("routine."))
+            return null;
+        // Runs only after a successful notification_log read on the same db, so a
+        // connection failure would already have surfaced upstream; the registry
+        // lookup + agents existence check are deterministic over a valid handle.
+        return resolveAgentId(this.deps.db, {
+            routine: notificationType.slice("routine.".length),
+        });
+    }
+    recordNotificationOutcome(params) {
+        const db = this.deps.db;
+        if (this.config.feedbackLearningEnabled === false || !db)
+            return;
+        // One guard for the whole behavioral-capture path: the reaction backfill,
+        // dedup probe, and signal insert all touch the same connection, so a single
+        // catch keeps a DB hiccup from crashing the background detector loop
+        // without leaving the reaction column write unguarded.
+        try {
+            const metadata = this.lookupNotificationMetadata(params.notificationId);
+            const dispatchId = metadata.dispatchId;
+            if (!dispatchId)
+                return;
+            this.updateNotificationReaction(db, dispatchId, metadata.platform, params.reaction);
+            if (hasFeedbackSignalForAction(db, {
+                source: "behavioral",
+                actionKind: "notification",
+                actionRef: dispatchId,
+                valence: params.valence,
+                userReaction: params.reaction,
+            })) {
+                return;
+            }
+            const scopeType = metadata.agentId ? "agent_slug" : "agent";
+            const summary = this.buildOutcomeSummary(params.reaction, metadata);
+            const evidence = this.sanitizeEvidence({
+                ...params.evidence,
+                userReaction: params.reaction,
+                notificationLogId: metadata.rowId,
+                notificationType: metadata.notificationType,
+                platform: metadata.platform,
+                contentSummary: metadata.contentSummary,
+            });
+            recordFeedbackSignal(db, {
+                source: "behavioral",
+                valence: params.valence,
+                scopeType,
+                scopeRef: metadata.agentId,
+                actionKind: "notification",
+                actionRef: dispatchId,
+                agentId: metadata.agentId,
+                summary,
+                evidence,
+            });
+        }
+        catch (err) {
+            logger.warn({ err, notificationId: params.notificationId, reaction: params.reaction }, "Failed to record notification outcome");
+        }
+    }
+    updateNotificationReaction(db, dispatchId, platform, reaction) {
+        if (platform) {
+            db.prepare(`UPDATE notification_log
+           SET user_reaction = ?, reacted_at = CURRENT_TIMESTAMP
+           WHERE dispatch_id = ? AND platform = ?`).run(reaction, dispatchId, platform);
+            return;
+        }
+        db.prepare(`UPDATE notification_log
+         SET user_reaction = ?, reacted_at = CURRENT_TIMESTAMP
+         WHERE dispatch_id = ?`).run(reaction, dispatchId);
+    }
+    buildOutcomeSummary(reaction, metadata) {
+        const content = metadata.contentSummary
+            ? ` "${metadata.contentSummary}"`
+            : "";
+        const notificationType = metadata.notificationType
+            ? ` (${metadata.notificationType})`
+            : "";
+        const raw = reaction === "ignored"
+            ? `Owner did not respond to notification${content}${notificationType}`
+            : reaction === "corrected"
+                ? `Owner corrected notification${content}${notificationType}`
+                : reaction === "acted"
+                    ? `Owner acted on notification${content}${notificationType}`
+                    : `Owner responded to notification${content}${notificationType}`;
+        return redactSensitiveString(raw.replace(/\s+/g, " ").trim()).slice(0, 280);
+    }
+    sanitizeEvidence(value) {
+        const out = {};
+        for (const [key, entry] of Object.entries(value)) {
+            if (entry === undefined)
+                continue;
+            if (typeof entry === "string") {
+                out[key] = redactSensitiveString(entry.replace(/[\u0000-\u001f\u007f]/g, " ").slice(0, 500));
+            }
+            else {
+                out[key] = entry;
+            }
+        }
+        return out;
+    }
+    static parseTrackedNotificationId(notificationId) {
+        const idx = notificationId.indexOf(":");
+        if (idx <= 0)
+            return { dispatchId: notificationId || null, platform: null };
+        return {
+            dispatchId: notificationId.slice(0, idx),
+            platform: notificationId.slice(idx + 1) || null,
+        };
+    }
 }
-//# sourceMappingURL=signal-detector.js.map

package/dist/core/skeleton.d.ts

@@ -62,7 +62,7 @@ export declare function resolveTemplatesRoot(workspaceDir: string): string | nul
  *    plain-mode fallback, leaving the agent with no policy files /
  *    routine rulebooks / user profile for prompt injection.
  *  - `api/routes/setup.ts` `/setup/save-rules` — kept as a safety net
- *    for any code path that commits `rules/management.md` without going
+ *    for any code path that commits `policies/management.md` without going
  *    through migrate-context (e.g. the plain-mode first-run flow).
  *
  * When `agent-assets/templates/` is missing (running from a prebuilt
@@ -80,4 +80,3 @@ export declare function ensureSkeletonFiles(contextDir: string, workspaceDir: st
  * it documents the templates tree in the repo, not runtime content.
  */
 export declare function copyTreePreservingExisting(srcDir: string, destDir: string, options?: EnsureSkeletonFilesOptions, relativeDir?: string): void;
-//# sourceMappingURL=skeleton.d.ts.map

package/dist/core/skeleton.js

@@ -5,12 +5,12 @@ import { CONTEXT_DIR_NAMES, CONTEXT_RELATIVE_PATHS } from "./context-paths.js";
 import { preTickProfileQuestions } from "./profile-questions/seed.js";
 import { createLogger } from "../logging.js";
 /**
- * Relative path of the profile-interview queue file, mirrored from the
- * shipped template. Hardcoded here (rather than imported from
- * `context-paths.ts`) because the seed runs before any caller would
- * read it from runtime config.
+ * Relative path of the profile-interview queue file. Sourced from the
+ * central registry — CONTEXT_VAULT_REDESIGN_PLAN.md v4 V10 moved this
+ * from `state/profile-questions.md` to `state/profile-questions.md`,
+ * and a hardcoded duplicate here would silently regress fresh installs.
  */
-const PROFILE_QUESTIONS_REL = "agent/profile-questions.md";
+const PROFILE_QUESTIONS_REL = CONTEXT_RELATIVE_PATHS.agent.profileQuestions;
 const logger = createLogger("skeleton");
 /**
  * Fallback placeholders for `today.md` and `roadmap.md` used when the
@@ -40,8 +40,8 @@ export const FALLBACK_PLACEHOLDERS = Object.freeze({
     // sentinel — a valid YMD so `roadmap-validate.ts:LAST_SYNCED_RE` accepts
     // mid-seed PATCHes, but obviously-stale so it is never mistaken for a real
     // sync timestamp. `(Not yet configured)` bullets under Annual Goals and
-    // Quarterly Focus cause `config.ts:isRoadmapStale` to flag the file and
-    // trigger the `roadmap_refresh` catch-up (see `index.ts:1857` comment).
+    // Quarterly Focus cause `isRoadmapStale` (in `config.ts`) to flag the file
+    // and trigger the `roadmap_refresh` catch-up.
     [CONTEXT_RELATIVE_PATHS.roadmap]: [
         "# Roadmap",
         "> Last synced: 1970-01-01",
@@ -143,7 +143,7 @@ export function resolveTemplatesRoot(workspaceDir) {
  *    plain-mode fallback, leaving the agent with no policy files /
  *    routine rulebooks / user profile for prompt injection.
  *  - `api/routes/setup.ts` `/setup/save-rules` — kept as a safety net
- *    for any code path that commits `rules/management.md` without going
+ *    for any code path that commits `policies/management.md` without going
  *    through migrate-context (e.g. the plain-mode first-run flow).
  *
  * When `agent-assets/templates/` is missing (running from a prebuilt
@@ -252,4 +252,3 @@ export function copyTreePreservingExisting(srcDir, destDir, options = {}, relati
         }
     }
 }
-//# sourceMappingURL=skeleton.js.map

package/dist/core/skill-curation/apply-proposal.d.ts

@@ -68,4 +68,3 @@ export type AutoRevertOutcome = {
 };
 export declare function autoRevertProposal(input: AutoRevertInput): AutoRevertOutcome;
 export {};
-//# sourceMappingURL=apply-proposal.d.ts.map

package/dist/core/skill-curation/apply-proposal.js

@@ -172,4 +172,3 @@ function insertAuditRow(db, action_type, proposalId, source, now) {
         run_id: detail.runId,
     }));
 }
-//# sourceMappingURL=apply-proposal.js.map

package/dist/core/skill-curation/auto-revert.d.ts

@@ -40,4 +40,3 @@ export declare function freezeSection(db: Database.Database, slug: string, secti
  *  proposal that has already been reverted is skipped on subsequent calls
  *  because its status flips to `reverted`. */
 export declare function autoRevertSweep(db: Database.Database, overlay: OverlayStore, options?: AutoRevertSweepOptions): AutoRevertOutcome;
-//# sourceMappingURL=auto-revert.d.ts.map

package/dist/core/skill-curation/auto-revert.js

@@ -6,10 +6,10 @@
 // did not "settle" the drift and is rolled back automatically. The section
 // is then marked `frozen` for two cadence cycles to prevent thrashing.
 //
-// This is the ONLY roll-back path. Owner-driven approve/reject/revert
-// endpoints were removed alongside the approval queue (P22 preview-scope
-// note); the operator's only manual escape is the on/off toggle, which
-// stops new runs and tells SkillsCompiler to render seeds only.
+// This is the ONLY roll-back path. There is no owner-driven approve /
+// reject / revert API — the operator's only manual handle is the on/off
+// toggle (which stops new runs and tells SkillsCompiler to render seeds
+// only).
 //
 // Detection heuristic (deterministic, no LLM):
 //   - Walk every `applied` proposal whose `decided_at` falls within the
@@ -152,4 +152,3 @@ function computeWeightSince(db, slug, section_id, since, now) {
         weight += weightFor(row, now);
     return weight;
 }
-//# sourceMappingURL=auto-revert.js.map

package/dist/core/skill-curation/classify-diff.d.ts

@@ -24,4 +24,3 @@ export declare function exceedsDiffCaps(diff: DiffResult, kind: SectionKind, pre
 /** Number of primary-key entries in a payload — used by diffCapsFor as the
  *  base size and by the smoke test's no_duplicate_entries check. */
 export declare function payloadEntryCount(p: CurationPayloadValue): number;
-//# sourceMappingURL=classify-diff.d.ts.map

package/dist/core/skill-curation/declarations.d.ts

@@ -29,4 +29,3 @@ export declare function loadSkillCurationContext(skillsRoot: string, slug: strin
 /** Walk the skills root and return one record per slug — used by anchor-lint
  *  test and by `/health.skillCuration.misconfigured[]`. */
 export declare function loadAllCurationDeclarations(skillsRoot: string): LoadedCurationDeclaration[];
-//# sourceMappingURL=declarations.d.ts.map

package/dist/core/skill-curation/declarations.js

@@ -167,4 +167,3 @@ export function loadAllCurationDeclarations(skillsRoot) {
     // wiki slugs are enumerated alongside flat skills.
     return listBuiltinSlugs(skillsRoot).map((slug) => loadSkillCurationContext(skillsRoot, slug));
 }
-//# sourceMappingURL=declarations.js.map

package/dist/core/skill-curation/knowledge-map.d.ts

@@ -23,4 +23,3 @@ export declare function snapshotMatchesPath(snapshot: KnowledgeMapSnapshot, path
  *  heading matching `sectionHeading` (compared after stripping leading `## `). */
 export declare function snapshotMatchesSection(snapshot: KnowledgeMapSnapshot, pathSpec: string, sectionHeading: string): boolean;
 export declare function filterSnapshotByScope(snapshot: KnowledgeMapSnapshot, scopePaths: string[]): SnapshotFile[];
-//# sourceMappingURL=knowledge-map.d.ts.map

package/dist/core/skill-curation/knowledge-map.js

@@ -151,4 +151,3 @@ export function snapshotMatchesSection(snapshot, pathSpec, sectionHeading) {
 export function filterSnapshotByScope(snapshot, scopePaths) {
     return snapshot.files.filter((f) => matchScopePath(f.path, scopePaths));
 }
-//# sourceMappingURL=knowledge-map.js.map

package/dist/core/skill-curation/orphan-overlay.d.ts

@@ -13,8 +13,8 @@ export interface OrphanOverlaysReport {
     orphans: OrphanOverlay[];
     scanned_overlays: number;
 }
-/** Walks `PA_DATA_DIR/skills/overlays/<slug>/*.json` and cross-references each
- *  envelope against the current `curation.json` declaration for that slug.
+/** Walks `PA_DATA_DIR/skill-curation-overlays/<slug>/*.json` and cross-references
+ *  each envelope against the current `curation.json` declaration for that slug.
  *  Returns one record per orphan. Does not mutate disk. */
 export declare function detectOrphanOverlays(dataDir: string, skillsRoot: string): OrphanOverlaysReport;
 /** Boot-time scan: emits one log line per orphan + persists a summary in
@@ -32,4 +32,3 @@ export declare function discardOrphanOverlay(dataDir: string, skillsRoot: string
     ok: false;
     reason: string;
 };
-//# sourceMappingURL=orphan-overlay.d.ts.map

package/dist/core/skill-curation/orphan-overlay.js

@@ -1,7 +1,7 @@
 // P22 §5.4 — orphan overlay detector.
 //
 // An overlay is "orphaned" when its on-disk overlay JSON
-// (`PA_DATA_DIR/skills/overlays/<slug>/<section_id>.json`) has no matching
+// (`PA_DATA_DIR/skill-curation-overlays/<slug>/<section_id>.json`) has no matching
 // declaration in the skill's `curation.json`. This happens when a framework
 // PR removes a section from `curation.json` while a previously-applied
 // overlay still exists on disk for that section.
@@ -26,14 +26,14 @@ import { join } from "node:path";
 import { OverlayEnvelope, } from "@aitne/shared";
 import { readFileSync } from "node:fs";
 import { loadAllCurationDeclarations } from "./declarations.js";
-import { OverlayStore } from "./overlay-store.js";
+import { OverlayStore, SKILL_CURATION_OVERLAYS_DIR } from "./overlay-store.js";
 import { createLogger } from "../../logging.js";
 const logger = createLogger("skill-curation-orphan");
-/** Walks `PA_DATA_DIR/skills/overlays/<slug>/*.json` and cross-references each
- *  envelope against the current `curation.json` declaration for that slug.
+/** Walks `PA_DATA_DIR/skill-curation-overlays/<slug>/*.json` and cross-references
+ *  each envelope against the current `curation.json` declaration for that slug.
  *  Returns one record per orphan. Does not mutate disk. */
 export function detectOrphanOverlays(dataDir, skillsRoot) {
-    const overlaysRoot = join(dataDir, "skills", "overlays");
+    const overlaysRoot = join(dataDir, SKILL_CURATION_OVERLAYS_DIR);
     if (!existsSync(overlaysRoot))
         return { orphans: [], scanned_overlays: 0 };
     const declarations = new Map();
@@ -164,4 +164,3 @@ export function discardOrphanOverlay(dataDir, skillsRoot, slug, sectionId) {
     logger.info({ slug, section_id: sectionId, reason: orphan.reason }, "skill_curation.declaration.orphan_overlay_discarded");
     return { ok: true, discarded_path: orphan.overlay_path };
 }
-//# sourceMappingURL=orphan-overlay.js.map

package/dist/core/skill-curation/overlay-store.d.ts

@@ -1,10 +1,13 @@
 import { type CurationPayloadValue, type OverlayEnvelopeValue, type SectionKind } from "@aitne/shared";
+/** Operational overlay root under PA_DATA_DIR. Shared with `orphan-overlay.ts`
+ *  and the migration runner — kept out of the vault per v4 V11. */
+export declare const SKILL_CURATION_OVERLAYS_DIR = "skill-curation-overlays";
 export interface OverlayStorePaths {
-    /** PA_DATA_DIR / skills / overlays / <slug> */
+    /** PA_DATA_DIR / skill-curation-overlays / <slug> */
     overlaysDir(slug: string): string;
-    /** PA_DATA_DIR / skills / overlays / <slug> / <section_id>.json */
+    /** PA_DATA_DIR / skill-curation-overlays / <slug> / <section_id>.json */
     overlayPath(slug: string, sectionId: string): string;
-    /** PA_DATA_DIR / skills / overlays / <slug> / history / <proposal_id>.json */
+    /** PA_DATA_DIR / skill-curation-overlays / <slug> / history / <proposal_id>.json */
     historyPath(slug: string, proposalId: number): string;
     /** agent-assets / skills / <slug> / curation.seed.json */
     seedPath(slug: string, sectionId: string): string;
@@ -38,4 +41,3 @@ export declare function payloadHash(payload: CurationPayloadValue): string;
  *  through the (currently empty) migrator chain. */
 export declare function migrateOverlay(env: OverlayEnvelopeValue): OverlayEnvelopeValue;
 export declare function isKnownSectionKind(value: string): value is SectionKind;
-//# sourceMappingURL=overlay-store.d.ts.map

package/dist/core/skill-curation/overlay-store.js

@@ -1,9 +1,12 @@
 // P22 §1.5, §5.4 — overlay store.
 //
-// Layout (under PA_DATA_DIR):
+// Layout (under PA_DATA_DIR — CONTEXT_VAULT_REDESIGN_PLAN.md v4 V11 moved
+// these out of `<dataDir>/skills/overlays/` because overlays are operational
+// metadata, not vault content; user skill MD files moved into the vault at
+// `<contextDir>/policies/skills/` but the JSON envelopes stay here):
 //
-//   ~/.personal-agent/skills/overlays/<slug>/<section_id>.json   ← active overlay
-//   ~/.personal-agent/skills/overlays/<slug>/history/<proposal_id>.json
+//   ~/.personal-agent/skill-curation-overlays/<slug>/<section_id>.json   ← active overlay
+//   ~/.personal-agent/skill-curation-overlays/<slug>/history/<proposal_id>.json
 //
 // Read precedence at session-materialization time:
 //
@@ -20,6 +23,9 @@ import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
 import { dirname, join } from "node:path";
 import { CurationPayload, OverlayEnvelope, SECTION_KINDS, SKILL_CURATION_SCHEMA_VERSION, } from "@aitne/shared";
+/** Operational overlay root under PA_DATA_DIR. Shared with `orphan-overlay.ts`
+ *  and the migration runner — kept out of the vault per v4 V11. */
+export const SKILL_CURATION_OVERLAYS_DIR = "skill-curation-overlays";
 export class OverlayStore {
     dataDir;
     skillsRoot;
@@ -32,9 +38,9 @@ export class OverlayStore {
         this.skillsRoot = skillsRoot;
     }
     paths = {
-        overlaysDir: (slug) => join(this.dataDir, "skills", "overlays", slug),
-        overlayPath: (slug, sectionId) => join(this.dataDir, "skills", "overlays", slug, `${sectionId}.json`),
-        historyPath: (slug, proposalId) => join(this.dataDir, "skills", "overlays", slug, "history", `${proposalId}.json`),
+        overlaysDir: (slug) => join(this.dataDir, SKILL_CURATION_OVERLAYS_DIR, slug),
+        overlayPath: (slug, sectionId) => join(this.dataDir, SKILL_CURATION_OVERLAYS_DIR, slug, `${sectionId}.json`),
+        historyPath: (slug, proposalId) => join(this.dataDir, SKILL_CURATION_OVERLAYS_DIR, slug, "history", `${proposalId}.json`),
         seedPath: (slug, sectionId) => join(this.skillsRoot, slug, "seeds", `${sectionId}.seed.json`),
     };
     hasOverlay(slug, sectionId) {
@@ -140,4 +146,3 @@ export function migrateOverlay(env) {
 export function isKnownSectionKind(value) {
     return SECTION_KINDS.includes(value);
 }
-//# sourceMappingURL=overlay-store.js.map

package/dist/core/skill-curation/render/convention-notes.d.ts

@@ -1,4 +1,3 @@
 import type { ConventionNotesValue } from "@aitne/shared";
 export declare const RENDERER_VERSION = "convention_notes/1";
 export declare function renderConventionNotes(payload: ConventionNotesValue): string;
-//# sourceMappingURL=convention-notes.d.ts.map

package/dist/core/skill-curation/render/convention-notes.js

@@ -10,4 +10,3 @@ export function renderConventionNotes(payload) {
     })
         .join("\n");
 }
-//# sourceMappingURL=convention-notes.js.map