@aitne/daemon 0.1.7 → 0.1.9

package/dist/core/wiki/import-probe.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, readdirSync, statSync, } from "node:fs";
+import { existsSync, lstatSync, readFileSync, readdirSync, statSync, } from "node:fs";
 import { join, relative } from "node:path";
 const LAYER_DIRS = ["00_inbox", "10_raw", "20_wiki", "30_outputs", "90_meta"];
 const EXPECTED_SCHEMAS = {
@@ -48,9 +48,12 @@ function inventoryLayer(rootPath, dir) {
             lastModifiedAt: null,
         };
     }
-    let stat;
+    // `lstatSync` does NOT follow symlinks; `statSync` does. The probe
+    // needs the symlink-itself state so the wizard can flag a layer-dir
+    // symlink (§7 — refusing the import is the safe default).
+    let lstat;
     try {
-        stat = statSync(full);
+        lstat = lstatSync(full);
     }
     catch {
         return {
@@ -86,7 +89,7 @@ function inventoryLayer(rootPath, dir) {
     return {
         dir,
         exists: true,
-        isSymlink: stat.isSymbolicLink(),
+        isSymlink: lstat.isSymbolicLink(),
         fileCount,
         subdirectories: subdirectories.sort(),
         lastModifiedAt,
@@ -242,4 +245,3 @@ function* walkMarkdown(rootDir) {
 export function formatProbeRelativePath(rootPath, abs) {
     return relative(rootPath, abs).split(/[\\/]/).join("/");
 }
-//# sourceMappingURL=import-probe.js.map

package/dist/core/wiki/index-cache.d.ts

@@ -36,4 +36,3 @@ export declare class WikiIndexCache {
     release(workspaceId: number): Promise<void>;
     shutdown(): Promise<void>;
 }
-//# sourceMappingURL=index-cache.d.ts.map

package/dist/core/wiki/index-cache.js

@@ -149,4 +149,3 @@ function readSnapshotFromDisk(workspace) {
         return { exists: false, content: null, mtimeMs: null, loadedAtMs: Date.now() };
     }
 }
-//# sourceMappingURL=index-cache.js.map

package/dist/core/wiki/multi-url-dispatch.d.ts

@@ -49,4 +49,3 @@ export interface DispatchWikiUrlBatchResult {
  * where a failed enqueue is a daemon-level fault, not a per-URL one.
  */
 export declare function dispatchWikiUrlBatch(input: DispatchWikiUrlBatchInput): Promise<DispatchWikiUrlBatchResult>;
-//# sourceMappingURL=multi-url-dispatch.d.ts.map

package/dist/core/wiki/multi-url-dispatch.js

@@ -54,19 +54,29 @@ export async function dispatchWikiUrlBatch(input) {
     }
     const cap = Math.max(1, Math.min(10, Math.floor(input.concurrencyCap)));
     let cursor = 0;
+    let aborted = false;
     async function worker() {
-        while (cursor < urls.length) {
+        while (!aborted && cursor < urls.length) {
             const url = urls[cursor++];
-            await input.enqueue(createWikiCommandEvent({
-                processKey: "wiki.ingest_url",
-                workspace: input.workspace,
-                sourceEvent: input.sourceEvent,
-                batchId,
-                data: { url },
-            }));
+            try {
+                await input.enqueue(createWikiCommandEvent({
+                    processKey: "wiki.ingest_url",
+                    workspace: input.workspace,
+                    sourceEvent: input.sourceEvent,
+                    batchId,
+                    data: { url },
+                }));
+            }
+            catch (err) {
+                // Honour the "abort the rest of the batch" contract: one failed
+                // enqueue stops sibling workers from claiming more URLs. Without
+                // this flag, Promise.all rejects fast but the other workers keep
+                // running, producing partial-then-unobserved enqueues.
+                aborted = true;
+                throw err;
+            }
         }
     }
     await Promise.all(Array.from({ length: Math.min(cap, urls.length) }, worker));
     return { batchId, queued: urls.length, mode: "parallel" };
 }
-//# sourceMappingURL=multi-url-dispatch.js.map

package/dist/core/wiki/wiki-fts.d.ts

@@ -72,4 +72,3 @@ export declare function backfillWikiFulltext(db: Database.Database, workspaces:
  * route module from a core helper (one-way dependency: routes → core).
  */
 export declare function classifyWikiPathForFts(relPath: string): WikiFtsLayer | null;
-//# sourceMappingURL=wiki-fts.d.ts.map

package/dist/core/wiki/wiki-fts.js

@@ -262,4 +262,3 @@ export function classifyWikiPathForFts(relPath) {
             return null;
     }
 }
-//# sourceMappingURL=wiki-fts.js.map

package/dist/core/wiki/workspaces.d.ts

@@ -26,7 +26,23 @@ export interface WikiWorkspaceRow {
     created_at: string;
     updated_at: string;
 }
-export declare function defaultWikiRoot(dataDir: string): string;
+/**
+ * Fresh-install default root for internal wiki workspaces.
+ *
+ * CONTEXT_VAULT_REDESIGN_PLAN.md v4 V12 — the internal wiki workspace
+ * tree moves under the vault at `<contextDir>/knowledge/wiki/`. The
+ * vault-restructure migration moves any pre-existing internal
+ * workspaces and rewrites `wiki_workspaces.root_path` for them. Fresh
+ * installs land directly on the new layout via this helper.
+ *
+ * The function accepts an `AgentConfig` so it can resolve the runtime
+ * `contextDir` (which may live inside an external Obsidian vault when
+ * `vaultMode="obsidian"`). The legacy `defaultWikiRoot(dataDir)` shape
+ * is preserved for callers that haven't been migrated yet — it falls
+ * back to `<dataDir>/context/knowledge/wiki`, matching the canonical
+ * destination of pre-migration `<dataDir>/wiki/` content.
+ */
+export declare function defaultWikiRoot(configOrDataDir: AgentConfig | string): string;
 export declare function ensureDefaultWikiWorkspace(db: Database.Database, config: AgentConfig): WikiWorkspaceRow;
 /**
  * Create (or re-activate) an external-mode wiki workspace pointed at a
@@ -98,4 +114,3 @@ export interface WikiWorkspaceStats {
     lastCompileAt: string | null;
 }
 export declare function buildWikiWorkspaceStats(row: WikiWorkspaceRow): WikiWorkspaceStats;
-//# sourceMappingURL=workspaces.d.ts.map

package/dist/core/wiki/workspaces.js

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, } from "node:fs";
 import { join, resolve } from "node:path";
-import { validatePrimaryVaultPath } from "../../config.js";
+import { getContextDir, validatePrimaryVaultPath } from "../../config.js";
 import { writeFileAtomically } from "../atomic-write.js";
 export const DEFAULT_WIKI_WORKSPACE_NAME = "default";
 export const DEFAULT_WIKI_SCHEMA_VERSION = 1;
@@ -56,28 +56,41 @@ const FALLBACK_SEEDS = {
         "",
     ].join("\n"),
 };
-export function defaultWikiRoot(dataDir) {
-    return resolve(dataDir, "wiki");
+/**
+ * Fresh-install default root for internal wiki workspaces.
+ *
+ * CONTEXT_VAULT_REDESIGN_PLAN.md v4 V12 — the internal wiki workspace
+ * tree moves under the vault at `<contextDir>/knowledge/wiki/`. The
+ * vault-restructure migration moves any pre-existing internal
+ * workspaces and rewrites `wiki_workspaces.root_path` for them. Fresh
+ * installs land directly on the new layout via this helper.
+ *
+ * The function accepts an `AgentConfig` so it can resolve the runtime
+ * `contextDir` (which may live inside an external Obsidian vault when
+ * `vaultMode="obsidian"`). The legacy `defaultWikiRoot(dataDir)` shape
+ * is preserved for callers that haven't been migrated yet — it falls
+ * back to `<dataDir>/context/knowledge/wiki`, matching the canonical
+ * destination of pre-migration `<dataDir>/wiki/` content.
+ */
+export function defaultWikiRoot(configOrDataDir) {
+    if (typeof configOrDataDir === "string") {
+        return resolve(configOrDataDir, "context", "knowledge", "wiki");
+    }
+    return resolve(getContextDir(configOrDataDir), "knowledge", "wiki");
 }
 export function ensureDefaultWikiWorkspace(db, config) {
-    const rootPath = defaultWikiRoot(config.dataDir);
+    const rootPath = defaultWikiRoot(config);
     // §P5.C — multi-workspace: check the named default specifically
     // rather than "first active workspace". With multiple active rows,
     // `readDefaultWikiWorkspace` returns the oldest active row by id,
     // which may not be the named default at all.
+    //
+    // If the row exists (in any state — including archived `active=0` or
+    // re-targeted to an external path) we leave it alone: the operator
+    // owns that state. Only insert when the row is genuinely missing.
     const existing = readWikiWorkspaceByName(db, DEFAULT_WIKI_WORKSPACE_NAME);
     if (!existing) {
-        const existingNamed = readWikiWorkspaceByName(db, DEFAULT_WIKI_WORKSPACE_NAME);
-        if (existingNamed) {
-            db.prepare(`UPDATE wiki_workspaces
-         SET active = 1,
-             kind = 'internal',
-             root_path = ?,
-             updated_at = CURRENT_TIMESTAMP
-         WHERE name = ?`).run(rootPath, DEFAULT_WIKI_WORKSPACE_NAME);
-        }
-        else {
-            db.prepare(`INSERT INTO wiki_workspaces (
+        db.prepare(`INSERT INTO wiki_workspaces (
          name,
          kind,
          root_path,
@@ -91,7 +104,6 @@ export function ensureDefaultWikiWorkspace(db, config) {
          active,
          updated_at
         ) VALUES (?, 'internal', ?, ?, 'parallel', 3, 0, 0, ?, ?, 1, CURRENT_TIMESTAMP)`).run(DEFAULT_WIKI_WORKSPACE_NAME, rootPath, DEFAULT_WIKI_LANGUAGE, DEFAULT_WIKI_FULL_COMPILE_APPROVAL_USD, DEFAULT_WIKI_SCHEMA_VERSION);
-        }
     }
     seedWikiWorkspaceFiles(rootPath, config.workspaceDir);
     return readWikiWorkspaceByName(db, DEFAULT_WIKI_WORKSPACE_NAME) ?? {
@@ -349,4 +361,3 @@ function writeIfMissing(path, content) {
     }
     writeFileAtomically(path, content.endsWith("\n") ? content : `${content}\n`);
 }
-//# sourceMappingURL=workspaces.js.map

package/dist/core/wiki/write-strategy.d.ts

@@ -67,4 +67,3 @@ export declare function probeWikiWriteStrategyHealth(workspace: WikiWorkspaceRow
  */
 export declare function resolveWikiPath(workspace: WikiWorkspaceRow, relPath: string): string;
 export declare function indexCachePathFor(workspace: WikiWorkspaceRow): string;
-//# sourceMappingURL=write-strategy.d.ts.map

package/dist/core/wiki/write-strategy.js

@@ -1,4 +1,4 @@
-import { dirname, join, relative, resolve } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { writeFileAtomically } from "../atomic-write.js";
 const FALLBACK_ERROR_CODES = new Set(["EPERM", "EACCES", "EROFS", "EBUSY"]);
 export class WikiWriteStrategyResolver {
@@ -44,6 +44,10 @@ export class WikiWriteStrategyResolver {
             return { strategy: "fs", durationMs: Date.now() - start };
         }
         catch (err) {
+            // Errors thrown from atomic-write / fs always carry a `code`; the
+            // `?? ""` fallback is a defensive guard against future callers that
+            // throw a non-fs Error here. Unreachable from the public surface.
+            /* c8 ignore next */
             const code = err.code ?? "";
             if (!FALLBACK_ERROR_CODES.has(code))
                 throw err;
@@ -65,6 +69,12 @@ export class WikiWriteStrategyResolver {
         await this.deps.obsidian.updateNote(input.relPath, ensureTrailingNewline(input.content));
     }
     persistResolved(workspace, strategy) {
+        // Idempotent guard for concurrent auto-mode writes — the caller path
+        // enters this method only when `resolveStrategy` returned "auto",
+        // which by construction means `write_strategy === 'auto'` is the only
+        // pre-state. Hence `'auto' === ('fs'|'cli')` is always false here.
+        // Preserve the guard so two in-flight writes don't double-UPDATE.
+        /* c8 ignore next */
         if (workspace.write_strategy === strategy)
             return;
         this.deps.db
@@ -96,7 +106,14 @@ function ensureTrailingNewline(content) {
 }
 function ensureWithinRoot(root, fullPath) {
     const rel = relative(root, fullPath);
-    return !rel.startsWith("..") && !rel.startsWith("/");
+    // `relative()` returns an absolute path when the two paths are on
+    // different Windows drive letters (e.g. C:\ → D:\evil). The `..` and
+    // empty-string checks are not sufficient there — `isAbsolute` catches
+    // it across platforms. An empty `rel` means fullPath === root, which
+    // is a directory write and never a legal file target.
+    if (rel === "" || rel.startsWith("..") || isAbsolute(rel))
+        return false;
+    return true;
 }
 /**
  * Resolve the workspace-relative directory of a vault-local file. Exposed
@@ -109,4 +126,3 @@ export function resolveWikiPath(workspace, relPath) {
 export function indexCachePathFor(workspace) {
     return dirname(resolveWikiPath(workspace, "20_wiki/_index.md"));
 }
-//# sourceMappingURL=write-strategy.js.map

package/dist/core/workdir.d.ts

@@ -16,6 +16,7 @@
  *    Path: `/tmp/pa-<random>/`
  *    Created per-call, deleted immediately after.
  */
+import type DatabaseNs from "better-sqlite3";
 import type { BackendId, IntegrationKey, IntegrationState, ProcessKey } from "@aitne/shared";
 export { getProfileForEvent, getSkillsForEvent } from "./skills-manifest.js";
 /**
@@ -80,6 +81,26 @@ export declare function createSessionWorkdir(projectRoot: string, eventType: str
      *  `{{schema_version}}` token substitution in skill bodies and the
      *  wiki-agent profile. Undefined falls back to the default workspace. */
     wikiWorkspaceName?: string;
+    /** `evening-review-slimdown.md` §2.1 — runtime context root consulted
+     *  by `resolveSkillManifest`. Production callers thread
+     *  `getContextDir(config)` through; tests and tooling may omit it,
+     *  in which case the conservative "rulebook inactive" branch wins. */
+    contextDir?: string;
+    /** docs/design/appendices/skills-improvement.md §9-§11 + §14 — DB handle for the
+     *  `gmail-lifestyle` / `managed-tasks` predicates. Undefined →
+     *  conservative include. */
+    db?: DatabaseNs.Database | null;
+    /** Inbound DM message text for the *ForDm trigger-phrase fallback.
+     *  Undefined / null for routine and scheduled events. */
+    messageText?: string | null;
+    /** AGENT_DEFINITIONS_DESIGN.md §4.2 — the firing Agent's `tools.skills`,
+     *  composed onto the process-key bundle by `materializeSessionBundle`
+     *  (union, or replace when `skillsReplace`). Empty/undefined is a no-op.
+     *  This disposable path is the ONLY one that carries the override —
+     *  every Agent firing runs in a fresh temp dir created here. */
+    extraSkills?: readonly string[];
+    /** AGENT_DEFINITIONS_DESIGN.md §4.2 — `tools.skills_replace`. */
+    skillsReplace?: boolean;
 }): string;
 export declare function ensureSessionWorkdir(projectRoot: string, dataDir: string, dbSessionId: number, eventType: string, options?: {
     backendId?: BackendId;
@@ -111,6 +132,12 @@ export declare function ensureSessionWorkdir(projectRoot: string, dataDir: strin
     };
     /** WIKI_BUILDER_DESIGN.md §P5.C — see createSessionWorkdir options. */
     wikiWorkspaceName?: string;
+    /** `evening-review-slimdown.md` §2.1 — see createSessionWorkdir options. */
+    contextDir?: string;
+    /** docs/design/appendices/skills-improvement.md §9-§11 + §14 — see createSessionWorkdir options. */
+    db?: DatabaseNs.Database | null;
+    /** docs/design/appendices/skills-improvement.md §9-§11 + §14 — see createSessionWorkdir options. */
+    messageText?: string | null;
 }): string;
 /**
  * Get the deterministic path for a session workdir (without creating it).
@@ -137,8 +164,18 @@ export declare function cleanupStaleWorkdirs(dataDir: string, activeSessionIds:
  *
  * Idempotent — if the files already exist for this backend, it overwrites
  * with the latest content (which is cheap since the source hasn't changed).
+ *
+ * `contextDir` is the runtime context root consulted by
+ * `resolveSkillManifest` for per-event predicates (today: the evening
+ * rulebook gate for `routine.evening_review`). Production callers MUST
+ * pass `getContextDir(config, db)` — without it, a fallback re-materialize
+ * for evening_review evaluates the gate as "rulebook inactive" and drops
+ * `notify` from the fallback backend's manifest even when the operator's
+ * `policies/routines/evening.md` is active, breaking the contract that the
+ * fallback backend behaves identically to the main one
+ * (`evening-review-slimdown.md` §3.5).
  */
-export declare function ensureBackendMaterialized(projectRoot: string, sessionDir: string, backendId: BackendId, eventType: string, processKey?: ProcessKey, configuredServices?: ReadonlySet<string>, mailAccounts?: readonly import("../services/mail/provider.js").MailAccount[], integrations?: Partial<Record<IntegrationKey, IntegrationState>>, character?: string, wikiWorkspaceName?: string): void;
+export declare function ensureBackendMaterialized(projectRoot: string, sessionDir: string, backendId: BackendId, eventType: string, processKey?: ProcessKey, configuredServices?: ReadonlySet<string>, mailAccounts?: readonly import("../services/mail/provider.js").MailAccount[], integrations?: Partial<Record<IntegrationKey, IntegrationState>>, character?: string, wikiWorkspaceName?: string, contextDir?: string, db?: DatabaseNs.Database | null, messageText?: string | null): void;
 /**
  * Validate that every delegated-mode skill AND task-flow variant required by
  * the currently-stored integration state exists on disk. Returns the missing
@@ -245,4 +282,3 @@ export declare function buildConfiguredServices(config: {
     calendar?: unknown;
     github?: unknown;
 }): Set<string>;
-//# sourceMappingURL=workdir.d.ts.map

package/dist/core/workdir.js

@@ -22,10 +22,12 @@ import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 import { DASHBOARD_CHAT_SCOPE, OWNER_DM_SCOPE, } from "../messaging/constants.js";
 import { createLogger } from "../logging.js";
-import { SkillsCompiler, renderMailAccountsMd, EMPTY_MAIL_ACCOUNTS_MD, } from "./skills-compiler.js";
-import { getProfileForEvent, getSkillsForEvent } from "./skills-manifest.js";
+import { SkillsCompiler } from "./skills-compiler.js";
+import { EMPTY_MAIL_ACCOUNTS_MD, renderMailAccountsMd, } from "./skills-compiler-tree.js";
+import { refreshSkillIndexBlock } from "./skills-compiler-skill-index.js";
+import { getProfileForEvent, resolveSkillManifest, resolveSkillManifestForProcess, } from "./skills-manifest.js";
 import { ensureDaemonApiCli } from "./daemon-api-cli.js";
-import { computeInstructionAssetStatus, sessionInstructionAssetsStale, writeInstructionAssetStamp, } from "./release-assets.js";
+import { computeInstructionAssetStatus, readInstructionStampManifest, sessionInstructionAssetsStale, writeInstructionAssetStamp, } from "./release-assets.js";
 const logger = createLogger("workdir");
 export { getProfileForEvent, getSkillsForEvent } from "./skills-manifest.js";
 /**
@@ -105,9 +107,16 @@ export function syncUserSkillDocs(sessionDir, userSkillsDir) {
  * Only directories that already exist are synced — existence means
  * `materializeSessionBundle` (or `ensureBackendMaterialized`) created
  * them for the target backend.
+ *
+ * docs/design/appendices/skills-unification.md Phase 1 item 10 — `.opencode/skills/` was
+ * added when opencode flipped from path (b) (`.claude/skills/` alias) to
+ * path (c) (`.opencode/skills/`). The `.claude/skills/` entry is retained
+ * so a workdir that has materialised a Claude main + opencode fallback
+ * still gets its user-authored skills synced into both trees.
  */
 const SKILL_DIR_ENTRIES = [
     { key: "claude", relDir: join(".claude", "skills") },
+    { key: "opencode", relDir: join(".opencode", "skills") },
     { key: "codex", relDir: join(".codex", "skills") },
     { key: "gemini", relDir: join(".gemini", "skills") },
 ];
@@ -126,6 +135,17 @@ export function syncAllUserSkills(sessionDir, userSkillsDir) {
         const destDir = join(sessionDir, relDir);
         if (existsSync(destDir)) {
             results[key] = syncUserSkillsInto(sessionDir, userSkillsDir, relDir);
+            // docs/design/appendices/skills-unification.md Phase 1 §R4 — splice user-authored slugs
+            // into the `<skill-index>` block so a freshly added user skill
+            // surfaces in Codex/Gemini's AGENTS.md/GEMINI.md listing on the next
+            // turn. No-op for Claude (cwd auto-discovery) and OpenCode (R3 —
+            // never emits an index block); idempotent for backends whose
+            // instruction file is missing or already in sync. Embedded here
+            // (not at every caller) so the dispatcher's per-turn syncs
+            // (`dispatcher-message-handler.ts` resume + fresh-execute paths)
+            // cannot forget to refresh and silently leave the Codex/Gemini
+            // index stale after a mid-session `PUT /api/skills`.
+            refreshSkillIndexBlock(sessionDir, key);
         }
     }
     return results;
@@ -203,7 +223,6 @@ function syncUserSkillsInto(sessionDir, userSkillsDir, destRelativeDir) {
 export function createSessionWorkdir(projectRoot, eventType, userSkillsDir, options) {
     const sessionId = randomUUID().slice(0, 8);
     const sessionDir = join(tmpdir(), `pa-${sessionId}`);
-    const skills = getSkillsForEvent(eventType);
     const backendId = options?.backendId ?? "claude";
     try {
         mkdirSync(sessionDir, { recursive: true, mode: 0o700 });
@@ -217,8 +236,21 @@ export function createSessionWorkdir(projectRoot, eventType, userSkillsDir, opti
             eventType,
             processKey: options?.processKey,
             wikiWorkspaceName: options?.wikiWorkspaceName,
+            ...(options?.contextDir ? { contextDir: options.contextDir } : {}),
+            ...(options?.db !== undefined ? { db: options.db } : {}),
+            ...(options?.messageText !== undefined ? { messageText: options.messageText } : {}),
+            ...(options?.extraSkills && options.extraSkills.length > 0
+                ? { extraSkills: options.extraSkills }
+                : {}),
+            ...(options?.skillsReplace ? { skillsReplace: true } : {}),
         });
-        writeInstructionAssetStamp(sessionDir, computeInstructionAssetStatus(projectRoot));
+        writeInstructionAssetStamp(sessionDir, computeInstructionAssetStatus(projectRoot), 
+        // docs/design/appendices/skills-unification.md Phase 1 item 14 — record the manifest
+        // snapshot the workdir was just materialised against. The next
+        // `ensureSessionWorkdir` call compares this with the live manifest
+        // and re-renders on drift (e.g. evening rulebook activates between
+        // turns, manifest now resolves to a different skill set).
+        { processKey: options?.processKey ?? eventType, skillSlugs: deployed.skills });
         ensureDaemonApiCli(sessionDir);
         // User skills: every skill the user has authored, regardless of event type.
         // Uses the manifest-backed sync so the initial population is consistent
@@ -226,13 +258,17 @@ export function createSessionWorkdir(projectRoot, eventType, userSkillsDir, opti
         let userSync = null;
         if (userSkillsDir) {
             userSync = syncAllUserSkills(sessionDir, userSkillsDir);
+            // docs/design/appendices/skills-unification.md Phase 1 §R4 — splice user-authored
+            // slugs into the `<skill-index>` block AFTER they land on disk.
+            // No-op for Claude (no instruction file index) and OpenCode (R3 —
+            // never gets an index).
+            refreshSkillIndexBlock(sessionDir, backendId);
         }
         logger.debug({
             sessionDir,
             eventType,
             processKey: options?.processKey,
             backendId,
-            skills,
             deployed,
             userSync,
             profile: getProfileForEvent(eventType),
@@ -266,6 +302,65 @@ export function createSessionWorkdir(projectRoot, eventType, userSkillsDir, opti
  * take the fast path.
  */
 const BANG_COMMAND_STAMP = ".aitne-bang-active";
+/**
+ * docs/design/appendices/skills-unification.md Phase 1 item 14 — return true when the live
+ * manifest the dispatcher is about to materialise diverges from the
+ * snapshot recorded in `.aitne-instruction-assets.json`. Three possible
+ * verdicts:
+ *
+ *  - Stamp has no manifest field (pre-Phase-1 stamp): treat as drift so
+ *    the workdir upgrades to the new stamp shape on the next dispatch.
+ *  - Recorded `processKey` differs OR recorded slug set differs from the
+ *    live resolve: drift → force re-materialise.
+ *  - Otherwise stable → no-op.
+ *
+ * Note: the manifest resolver is pure and cheap (no I/O beyond reading a
+ * couple of in-memory tables, plus a single existsSync via
+ * `evening-review-slimdown` when the gate fires), so calling it on every
+ * `ensureSessionWorkdir` invocation is fine. The override path (custom
+ * bang commands) bypasses this check because the dispatcher's
+ * `options.override` already forces re-materialisation.
+ */
+function resolveManifestDriftAgainstStamp(sessionDir, eventType, options) {
+    if (options?.override)
+        return false; // override path force-rematerialises elsewhere
+    const stamp = readInstructionStampManifest(sessionDir);
+    if (!stamp)
+        return true; // Pre-Phase-1 stamp → re-materialise to upgrade
+    const recordedKey = stamp.processKey;
+    const expectedKey = options?.processKey ?? eventType;
+    if (recordedKey !== expectedKey)
+        return true;
+    const manifestOpts = {
+        ...(options?.contextDir ? { contextDir: options.contextDir } : {}),
+        ...(options?.db !== undefined ? { db: options.db } : {}),
+        ...(options?.messageText !== undefined ? { messageText: options.messageText } : {}),
+    };
+    const hasManifestOpts = Object.keys(manifestOpts).length > 0;
+    // Agent `tools.skills` overrides are NOT composed here: they only ever ride
+    // the disposable `createSessionWorkdir` path (one fresh temp dir per Agent
+    // firing, never re-checked for drift). The persistent `ensureSessionWorkdir`
+    // path — DMs / resumable Opus sessions — is never an Agent firing, so its
+    // stamp never carries an extra-skill set and the live resolve below matches.
+    const liveSlugs = options?.processKey
+        ? resolveSkillManifestForProcess(options.processKey, hasManifestOpts ? manifestOpts : undefined)
+        : resolveSkillManifest(eventType, hasManifestOpts ? manifestOpts : undefined);
+    // The stamp records the EFFECTIVE slug set (post fetch_window narrow /
+    // post variant-resolution). The live resolve here returns the manifest
+    // BEFORE the per-backend variant narrow, but since the manifest contains
+    // the canonical slug set the override doesn't change, comparing on the
+    // sorted union is a safe proxy. False-positive drift (re-render when
+    // not strictly needed) is acceptable; the cost is one Markdown emit.
+    const recordedSorted = [...stamp.skillSlugs].sort();
+    const liveSorted = [...liveSlugs].sort();
+    if (recordedSorted.length !== liveSorted.length)
+        return true;
+    for (let i = 0; i < recordedSorted.length; i++) {
+        if (recordedSorted[i] !== liveSorted[i])
+            return true;
+    }
+    return false;
+}
 export function ensureSessionWorkdir(projectRoot, dataDir, dbSessionId, eventType, options) {
     const sessionDir = join(dataDir, "agent-sessions", String(dbSessionId));
     const stampPath = join(sessionDir, BANG_COMMAND_STAMP);
@@ -273,7 +368,19 @@ export function ensureSessionWorkdir(projectRoot, dataDir, dbSessionId, eventTyp
     // an absent-or-present boolean — we never read its content.
     const wasBangActive = existsSync(sessionDir) && existsSync(stampPath);
     const instructionAssetsStale = sessionInstructionAssetsStale(sessionDir, projectRoot);
-    const forceRematerialize = !!options?.override || wasBangActive || instructionAssetsStale;
+    // docs/design/appendices/skills-unification.md Phase 1 item 14 — manifest-snapshot drift
+    // guard. Even when the source assets are byte-identical (asset stamp
+    // matches), the manifest can resolve to a different slug set between
+    // turns (e.g. evening rulebook activates → `notify` enters scope). The
+    // recorded slug set in the stamp file is the per-session checkpoint;
+    // a delta forces re-materialisation so `<skill-index>` and the
+    // per-backend dir reflect the live manifest.
+    const manifestStale = existsSync(sessionDir)
+        && resolveManifestDriftAgainstStamp(sessionDir, eventType, options);
+    const forceRematerialize = !!options?.override
+        || wasBangActive
+        || instructionAssetsStale
+        || manifestStale;
     if (existsSync(sessionDir) && !forceRematerialize) {
         ensureDaemonApiCli(sessionDir);
         if (options?.mailAccounts) {
@@ -282,9 +389,6 @@ export function ensureSessionWorkdir(projectRoot, dataDir, dbSessionId, eventTyp
         logger.debug({ sessionDir, dbSessionId }, "Session workdir already exists (pa-api helper refreshed)");
         return sessionDir;
     }
-    const skills = options?.override?.skillSlugs
-        ? [...options.override.skillSlugs]
-        : getSkillsForEvent(eventType);
     const backendId = options?.backendId ?? "claude";
     const compiler = new SkillsCompiler(projectRoot, options?.configuredServices, options?.mailAccounts, options?.integrations, options?.character);
     try {
@@ -296,13 +400,30 @@ export function ensureSessionWorkdir(projectRoot, dataDir, dbSessionId, eventTyp
             processKey: options?.processKey,
             wikiWorkspaceName: options?.wikiWorkspaceName,
             ...(options?.override ? { override: options.override } : {}),
+            ...(options?.contextDir ? { contextDir: options.contextDir } : {}),
+            ...(options?.db !== undefined ? { db: options.db } : {}),
+            ...(options?.messageText !== undefined ? { messageText: options.messageText } : {}),
         });
-        writeInstructionAssetStamp(sessionDir, computeInstructionAssetStatus(projectRoot));
+        writeInstructionAssetStamp(sessionDir, computeInstructionAssetStatus(projectRoot), 
+        // docs/design/appendices/skills-unification.md Phase 1 item 14 — manifest snapshot
+        // for the per-turn drift guard (see `manifestStale` above).
+        { processKey: options?.processKey ?? eventType, skillSlugs: deployed.skills });
         ensureDaemonApiCli(sessionDir);
         // User-authored skills — initial population via the manifest-backed sync
         // so subsequent mid-session calls (from dispatcher) share the same state.
-        const userSkillsDir = join(dataDir, "skills");
+        // CONTEXT_VAULT_REDESIGN_PLAN.md v4 V11 — user skills root moved to
+        // `<contextDir>/policies/skills`. We derive from `options.contextDir`
+        // when the caller provides it; otherwise fall back to the default
+        // `<dataDir>/context/policies/skills` (matches `getContextDir`'s plain
+        // vault-mode default). The legacy `<dataDir>/skills` path is dead post
+        // CONTEXT_VAULT_REDESIGN — falling back there would resurrect the
+        // Obsidian-mode divergence bug v4 V11 fixed.
+        const userSkillsDir = join(options?.contextDir ?? join(dataDir, "context"), "policies", "skills");
         const userSync = syncAllUserSkills(sessionDir, userSkillsDir);
+        // docs/design/appendices/skills-unification.md Phase 1 §R4 — fold user-authored slugs
+        // into the `<skill-index>` block now that they're on disk. Idempotent
+        // and inexpensive (single instruction-file rewrite).
+        refreshSkillIndexBlock(sessionDir, backendId);
         // Bang-command lifecycle: write the stamp on a successful override turn
         // so the NEXT non-override call detects it and resets. On a successful
         // reset call (no override but stamp existed), drop the stamp so future
@@ -327,7 +448,6 @@ export function ensureSessionWorkdir(projectRoot, dataDir, dbSessionId, eventTyp
             eventType,
             processKey: options?.processKey,
             backendId,
-            skills,
             deployed,
             userSync,
             rematerialized: forceRematerialize,
@@ -371,7 +491,9 @@ function refreshSessionMailAccountsMd(sessionDir, mailAccounts) {
     const rendered = mailAccounts.length === 0
         ? EMPTY_MAIL_ACCOUNTS_MD
         : renderMailAccountsMd(mailAccounts);
-    for (const root of [".claude", ".codex", ".gemini"]) {
+    // docs/design/appendices/skills-unification.md Phase 1 — opencode flipped to its own
+    // `.opencode/skills/` dir, so the refresh walker must include it.
+    for (const root of [".claude", ".opencode", ".codex", ".gemini"]) {
         const mailSkillDir = join(sessionDir, root, "skills", "mail");
         if (!existsSync(mailSkillDir))
             continue;
@@ -445,8 +567,18 @@ export function cleanupStaleWorkdirs(dataDir, activeSessionIds) {
  *
  * Idempotent — if the files already exist for this backend, it overwrites
  * with the latest content (which is cheap since the source hasn't changed).
+ *
+ * `contextDir` is the runtime context root consulted by
+ * `resolveSkillManifest` for per-event predicates (today: the evening
+ * rulebook gate for `routine.evening_review`). Production callers MUST
+ * pass `getContextDir(config, db)` — without it, a fallback re-materialize
+ * for evening_review evaluates the gate as "rulebook inactive" and drops
+ * `notify` from the fallback backend's manifest even when the operator's
+ * `policies/routines/evening.md` is active, breaking the contract that the
+ * fallback backend behaves identically to the main one
+ * (`evening-review-slimdown.md` §3.5).
  */
-export function ensureBackendMaterialized(projectRoot, sessionDir, backendId, eventType, processKey, configuredServices, mailAccounts, integrations, character, wikiWorkspaceName) {
+export function ensureBackendMaterialized(projectRoot, sessionDir, backendId, eventType, processKey, configuredServices, mailAccounts, integrations, character, wikiWorkspaceName, contextDir, db, messageText) {
     const compiler = new SkillsCompiler(projectRoot, configuredServices, mailAccounts, integrations, character);
     const deployed = compiler.materializeSessionBundle({
         backendId,
@@ -454,9 +586,20 @@ export function ensureBackendMaterialized(projectRoot, sessionDir, backendId, ev
         eventType,
         processKey,
         wikiWorkspaceName,
+        ...(contextDir ? { contextDir } : {}),
+        ...(db !== undefined ? { db } : {}),
+        ...(messageText !== undefined ? { messageText } : {}),
     });
-    writeInstructionAssetStamp(sessionDir, computeInstructionAssetStatus(projectRoot));
+    writeInstructionAssetStamp(sessionDir, computeInstructionAssetStatus(projectRoot), 
+    // docs/design/appendices/skills-unification.md Phase 1 item 14 — also captured on the
+    // fallback re-materialisation path so the per-turn drift guard
+    // remains correct across (main, fallback) backend pairs.
+    { processKey: processKey ?? eventType, skillSlugs: deployed.skills });
     ensureDaemonApiCli(sessionDir);
+    // docs/design/appendices/skills-unification.md Phase 1 §R4 — fold any already-synced user
+    // skills (from prior turns on this workdir) into the freshly rendered
+    // `<skill-index>` block. No-op on a clean dir with zero user skills.
+    refreshSkillIndexBlock(sessionDir, backendId);
     logger.debug({ sessionDir, backendId, eventType, processKey, deployed }, "Ensured backend instruction files in session workdir");
 }
 /**
@@ -565,4 +708,3 @@ export function buildConfiguredServices(config, serviceAvailability) {
     }
     return services;
 }
-//# sourceMappingURL=workdir.js.map