@tea-agent/loop-agent 0.34.3 → 0.34.5

package/dist/worker/console/chat/pi-runtime.js

@@ -32,6 +32,7 @@ import { projectCompactSnapshot, } from "./chat-event-store.js";
 import { extractUsageSample } from "./usage.js";
 import { OPERATOR_CHAT_ALLOWED_TOOLS, authorizeOperatorChatTool, assertNoWriteToolInList, } from "./tools.js";
 import { createOperatorChatResourceLoader, } from "./resource-loader.js";
+import { applySkillAutoInvocationPreferences, isAutoInvocationEnabled, loadResourcePreferences, skillResourceId, } from "./resource-preferences-store.js";
 import { buildModelCallableToolSchemas } from "./tool-adapter.js";
 import { resolveDefaultChatModel, resolveLowChatModel, } from "./model-resolver.js";
 import { filterActiveInterviewTools } from "../interview/tools.js";
@@ -466,7 +467,8 @@ export function projectRuntimeSnapshot(input) {
         ...(skill.baseDir ? { baseDir: field(skill.baseDir, 400) } : {}),
         scope: skill.scope,
         source: field(skill.source, 200) ?? "",
-        enabled: skill.enabled,
+        resourceId: field(skill.resourceId, 200) ?? "",
+        autoInvocationEnabled: skill.autoInvocationEnabled,
         diagnostics: skill.diagnostics.map((diag) => field(diag, 400) ?? ""),
     });
     const projectExtension = (ext) => ({
@@ -645,6 +647,8 @@ export class ConsolePiRuntime {
     revisions = new Map();
     /** RF-01: per-session reload in-flight lock (concurrent second call → PI_SESSION_BUSY). */
     reloadInFlight = new Set();
+    /** Synchronous prompt ownership per session (admission before first await). */
+    promptOwners = new Set();
     /** At most one detached automatic-title task per durable Console session. */
     titleInFlight = new Set();
     /** Composer thinking selection ("auto" = no explicit override). */
@@ -665,6 +669,78 @@ export class ConsolePiRuntime {
         this.loader = createOperatorChatResourceLoader();
         this.bindings = options.bindings ?? createDefaultPiSdkBindings();
     }
+    /** Absolute path for repo-scoped resource preferences (may be undefined in unit tests). */
+    get resourcePreferencesPath() {
+        return this.options.resourcePreferencesPath;
+    }
+    /**
+     * Load repo-scoped skill auto-invocation preferences (fail closed on malformed).
+     * Missing path / missing file → empty prefs (all skills auto-invocation default on).
+     */
+    async loadSkillAutoInvocationPreferences() {
+        const filePath = this.options.resourcePreferencesPath;
+        if (!filePath) {
+            const empty = { schemaVersion: 1, skills: {} };
+            this.cachedSkillPrefs = empty;
+            return empty;
+        }
+        const prefs = await loadResourcePreferences(filePath);
+        this.cachedSkillPrefs = prefs;
+        return prefs;
+    }
+    /**
+     * Build resourceLoaderOptions that inject skillsOverride from stored prefs.
+     * Skills remain in inventory; only disableModelInvocation is forced for
+     * auto-invocation-off preferences. Manual /skill:name is preserved.
+     *
+     * The override re-reads preferences on EVERY invocation so session.reload()
+     * after a PATCH sees the latest resource-preferences.json (not create-time
+     * closure state).
+     */
+    async buildResourceLoaderOptions(base = {}) {
+        const runtime = this;
+        return {
+            ...base,
+            skillsOverride: (current) => {
+                // Synchronous override surface: use last-known prefs via a sync
+                // fail-closed path. Prefer async cache filled by ensurePrefs.
+                const prefs = runtime.cachedSkillPrefs ?? {
+                    schemaVersion: 1,
+                    skills: {},
+                };
+                return {
+                    skills: applySkillAutoInvocationPreferences(current.skills, prefs),
+                    diagnostics: current.diagnostics,
+                };
+            },
+        };
+    }
+    /** Last successfully loaded skill prefs (sync override + snapshot projection). */
+    cachedSkillPrefs;
+    /** Refresh cached prefs before materialization / reload so override sees latest. */
+    async refreshSkillPrefsCache() {
+        const prefs = await this.loadSkillAutoInvocationPreferences();
+        this.cachedSkillPrefs = prefs;
+        return prefs;
+    }
+    /**
+     * Resolve a skill in the current session inventory by server-issued resourceId.
+     * Returns undefined when the id is unknown (caller maps to PI_SKILL_NOT_FOUND).
+     */
+    async findSkillByResourceId(sessionId, resourceId) {
+        const snapshot = await this.getRuntimeSnapshot(sessionId);
+        if (!snapshot)
+            return undefined;
+        const skill = snapshot.skills.find((entry) => entry.resourceId === resourceId);
+        if (!skill)
+            return undefined;
+        return {
+            resourceId: skill.resourceId,
+            name: skill.name,
+            path: skill.path,
+            autoInvocationEnabled: skill.autoInvocationEnabled,
+        };
+    }
     get sessionDir() {
         return this.options.sessionDir;
     }
@@ -820,13 +896,15 @@ export class ConsolePiRuntime {
             ...(init.systemPromptSuffix ? [init.systemPromptSuffix] : []),
         ];
         // Single services construction for formal materialization (+ optional
-        // default-model resolve from the same modelRuntime).
+        // default-model resolve from the same modelRuntime). Repo-scoped skill
+        // auto-invocation prefs inject skillsOverride without touching SKILL.md.
+        await this.refreshSkillPrefsCache().catch(() => undefined);
         const { services } = await this.bindings.createServices({
             cwd: this.options.cwd,
             agentDir,
-            resourceLoaderOptions: {
+            resourceLoaderOptions: await this.buildResourceLoaderOptions({
                 appendSystemPrompt,
-            },
+            }),
         });
         if (this.disposedSessions.has(sessionId))
             return;
@@ -1176,6 +1254,9 @@ export class ConsolePiRuntime {
         }
         this.reloadInFlight.add(sessionId);
         try {
+            // Refresh prefs cache so skillsOverride applied during reload sees
+            // the latest resource-preferences.json written by PATCH.
+            await this.refreshSkillPrefsCache().catch(() => undefined);
             await session.reload();
         }
         catch (error) {
@@ -1198,6 +1279,83 @@ export class ConsolePiRuntime {
      * list, and the session ResourceLoader inventories. Undefined when the
      * session is not active — callers fail closed instead of fabricating data.
      */
+    /**
+     * Browser-safe slash command projection for UI-11.
+     * Sources: current Session extension commands, prompt templates, skills.
+     * Never returns prompt/skill file bodies.
+     */
+    async listSlashCommands(sessionId) {
+        const scrub = (value) => {
+            const raw = String(value ?? "");
+            return raw
+                .replace(/\/Users\/[^\s]+/gi, "~")
+                .replace(/[A-Za-z]:\\Users\\[^\s]+/gi, "~")
+                .slice(0, 240);
+        };
+        try {
+            await this.ensureSessionReady(sessionId);
+        }
+        catch {
+            return [];
+        }
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return [];
+        const out = [];
+        const seen = new Set();
+        const push = (command, label, description, source) => {
+            const name = command.startsWith("/") ? command : `/${command}`;
+            const key = name.toLowerCase();
+            if (!key || key === "/" || seen.has(key))
+                return;
+            seen.add(key);
+            out.push({
+                command: name,
+                label: (label || name).slice(0, 80),
+                description: scrub(description),
+                source,
+            });
+        };
+        try {
+            const cmds = session.extensionRunner?.getRegisteredCommands?.() ?? [];
+            for (const cmd of cmds) {
+                const name = cmd.invocationName || cmd.name;
+                if (!name)
+                    continue;
+                push(String(name), String(cmd.name || name), String(cmd.description || ""), "extension");
+            }
+        }
+        catch {
+            // non-blocking
+        }
+        try {
+            for (const tpl of session.promptTemplates ?? []) {
+                if (!tpl?.name)
+                    continue;
+                push(String(tpl.name), String(tpl.name), String(tpl.description || ""), "prompt");
+            }
+        }
+        catch {
+            // non-blocking
+        }
+        try {
+            const services = this.serviceScopes.get(sessionId);
+            const resourceLoader = services?.resourceLoader;
+            const skills = resourceLoader?.getSkills?.()?.skills ?? [];
+            for (const skill of skills) {
+                if (!skill?.name)
+                    continue;
+                const command = skill.name.startsWith("skill:")
+                    ? `/${skill.name}`
+                    : `/skill:${skill.name}`;
+                push(command, skill.name, String(skill.description || ""), "skill");
+            }
+        }
+        catch {
+            // non-blocking
+        }
+        return out;
+    }
     async getRuntimeSnapshot(sessionId, options) {
         try {
             await this.ensureSessionReady(sessionId);
@@ -1259,7 +1417,7 @@ export class ConsolePiRuntime {
         const skills = [];
         const extensions = [];
         const diagnostics = [];
-        let resolvedResources = [];
+        const resolvedResources = [];
         const resourceFailure = (subface, error) => {
             diagnostics.push({
                 type: "error",
@@ -1283,9 +1441,33 @@ export class ConsolePiRuntime {
             catch (error) {
                 resourceFailure("context files", error);
             }
+            // Preferences are the source of truth for UI auto-invocation state;
+            // loader disableModelInvocation may also reflect frontmatter. Prefer
+            // explicit preference (default on) when projecting autoInvocationEnabled.
+            let skillPrefs = { schemaVersion: 1, skills: {} };
+            try {
+                skillPrefs = await this.loadSkillAutoInvocationPreferences();
+            }
+            catch (error) {
+                diagnostics.push({
+                    type: "error",
+                    code: "PI_RESOURCE_PREFERENCES_MALFORMED",
+                    message: error instanceof Error ? error.message : String(error),
+                    retryable: true,
+                });
+            }
             try {
                 const skillsResult = resourceLoader.getSkills?.();
                 for (const skill of skillsResult?.skills ?? []) {
+                    const resourceId = skillResourceId({
+                        name: skill.name,
+                        filePath: skill.filePath,
+                    });
+                    // Preference off always means autoInvocationEnabled=false even if
+                    // loader already applied disableModelInvocation. Frontmatter-only
+                    // disable (no preference) also surfaces as autoInvocationEnabled=false.
+                    const prefEnabled = isAutoInvocationEnabled(skillPrefs, resourceId);
+                    const autoInvocationEnabled = prefEnabled && skill.disableModelInvocation !== true;
                     skills.push({
                         name: skill.name,
                         description: skill.description ?? "",
@@ -1293,7 +1475,8 @@ export class ConsolePiRuntime {
                         ...(skill.baseDir ? { baseDir: skill.baseDir } : {}),
                         scope: skill.sourceInfo?.scope ?? "unknown",
                         source: skill.sourceInfo?.source ?? "",
-                        enabled: !skill.disableModelInvocation,
+                        resourceId,
+                        autoInvocationEnabled,
                         diagnostics: [],
                     });
                     resolvedResources.push({
@@ -1620,12 +1803,13 @@ export class ConsolePiRuntime {
             OPERATOR_CHAT_SYSTEM_PROMPT_BASE,
             ...(init.systemPromptSuffix ? [init.systemPromptSuffix] : []),
         ];
+        await this.refreshSkillPrefsCache().catch(() => undefined);
         const { services } = await this.bindings.createServices({
             cwd: this.options.cwd,
             agentDir,
-            resourceLoaderOptions: {
+            resourceLoaderOptions: await this.buildResourceLoaderOptions({
                 appendSystemPrompt,
-            },
+            }),
         });
         const modelRuntime = services.modelRuntime;
         const resolvedModel = init.model
@@ -1669,81 +1853,142 @@ export class ConsolePiRuntime {
     hasSession(sessionId) {
         return this.sessions.has(sessionId);
     }
+    /**
+     * Live runtime busy facts for /state reconcile. isPromptRunning is owned by
+     * this Console admission fence; other flags mirror the Pi session when present.
+     */
+    getSessionBusyFacts(sessionId) {
+        const session = this.sessions.get(sessionId);
+        const isPromptRunning = this.promptOwners.has(sessionId);
+        return {
+            isStreaming: session?.isStreaming === true || isPromptRunning,
+            isPromptRunning,
+            isCompacting: session?.isCompacting === true,
+            isBashRunning: session?.isBashRunning === true ||
+                session?.hasPendingBashMessages === true,
+        };
+    }
     /**
      * Send a prompt and stream events. Gate 3: each tool invocation is
      * re-authorized by authorizeOperatorChatTool before the dispatcher runs it
      * (the dispatcher is wired by the HTTP layer, see chat-session.ts).
+     *
+     * Prompt ownership is acquired synchronously before the first await so two
+     * concurrent prompts on the same Session cannot both enter the SDK path.
      */
     async prompt(sessionId, text, onEvent, options) {
-        // First message while creating waits on the same materialization promise.
-        await this.ensureSessionReady(sessionId);
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            throw new Error(`chat session not found: ${sessionId}`);
+        // Synchronous admission fence — before any await.
+        if (this.promptOwners.has(sessionId)) {
+            throw new Error("CHAT_TURN_ACTIVE");
         }
-        // Gate 2 (re-pin before each turn): interview turns pass through the
-        // existing closed interview allow/deny registry. The next ordinary turn
-        // explicitly restores the normal Operator Chat set (baseline + extension
-        // tools, ADR 0012).
-        const requestedTools = OPERATOR_CHAT_ACTIVE_TOOL_NAMES();
-        const activeTools = options?.mode === "requirement-interview"
-            ? filterActiveInterviewTools(requestedTools).allowed
-            : computeOperatorChatActiveToolNames(session);
-        session.setActiveToolsByName(activeTools);
-        const unsub = session.subscribe((event) => {
-            const mapped = mapSdkEvent(sessionId, event);
-            if (mapped)
-                onEvent(mapped);
-            // Pi puts per-assistant-message usage on `message.usage` ({ input, output,
-            // cacheRead, cacheWrite, totalTokens, cost }). Emit on message_end so
-            // multi-step tool turns accumulate like pi-web SessionInfoBar; turn_end
-            // repeats the final message and must not double-count.
-            if (event.type === "message_end") {
-                const usage = extractUsageSample(event);
-                if (usage)
-                    onEvent({ type: "usage", sessionId, usage });
-            }
-        });
+        this.promptOwners.add(sessionId);
+        let unsub;
+        let abortPromise;
         const onAbort = () => {
-            // M1 T08: Stop must abort only the current turn, NOT dispose the
-            // session. SDK AgentSession.abort() aborts the current operation and
-            // waits for the agent to become idle, keeping the session reusable for
-            // the next turn. Only fall back to dispose if the session has no abort()
-            // (e.g. a minimal stub), since a stuck turn should not leak forever.
+            // M1 T08 / AC-R3-003: Stop must abort only the current turn, NEVER
+            // dispose the session. Await session.abort() so ownership settles
+            // after the SDK reports idle. When abort is unavailable, fail closed
+            // non-destructively — Session stays reusable; terminal closeout or
+            // /state reconcile still converges ownership.
+            const session = this.sessions.get(sessionId);
+            if (!session)
+                return;
             try {
                 if (typeof session.abort === "function") {
-                    void session.abort();
-                }
-                else {
-                    session.dispose();
+                    abortPromise = Promise.resolve(session.abort()).catch(() => undefined);
                 }
+                // else: do not call session.dispose() — Stop never destroys Session.
             }
             catch {
                 // ignore
             }
         };
-        options?.signal?.addEventListener("abort", onAbort);
         try {
-            await session.prompt(text, options?.images?.length ? { images: options.images } : undefined);
-            // Wait until the session reports idle / not streaming. The SDK prompt()
-            // resolves when the agent turn completes, but post-turn continuation
-            // (auto-compaction / follow-up) may still be in flight. We poll isIdle.
-            // While polling we emit periodic heartbeat events so the SSE stream
-            // keeps proxies/browsers from timing out (no other data is flowing).
-            await waitForIdle(session, {
-                signal: options?.signal,
-                onHeartbeat: () => onEvent({ type: "heartbeat", sessionId }),
+            // AC-FIX-002: if Stop already fired before readiness, never start model work.
+            if (options?.signal?.aborted) {
+                return;
+            }
+            // First message while creating waits on the same materialization promise.
+            await this.ensureSessionReady(sessionId);
+            // Abort may land during readiness (or between readiness and prompt).
+            if (options?.signal?.aborted) {
+                return;
+            }
+            const session = this.sessions.get(sessionId);
+            if (!session) {
+                throw new Error(`chat session not found: ${sessionId}`);
+            }
+            // Gate 2 (re-pin before each turn): interview turns pass through the
+            // existing closed interview allow/deny registry. The next ordinary turn
+            // explicitly restores the normal Operator Chat set (baseline + extension
+            // tools, ADR 0012).
+            const requestedTools = OPERATOR_CHAT_ACTIVE_TOOL_NAMES();
+            const activeTools = options?.mode === "requirement-interview"
+                ? filterActiveInterviewTools(requestedTools).allowed
+                : computeOperatorChatActiveToolNames(session);
+            session.setActiveToolsByName(activeTools);
+            // Final pre-prompt fence: abort after tool pin must still skip session.prompt.
+            if (options?.signal?.aborted) {
+                return;
+            }
+            unsub = session.subscribe((event) => {
+                const mapped = mapSdkEvent(sessionId, event);
+                if (mapped)
+                    onEvent(mapped);
+                // Pi puts per-assistant-message usage on `message.usage` ({ input, output,
+                // cacheRead, cacheWrite, totalTokens, cost }). Emit on message_end so
+                // multi-step tool turns accumulate like pi-web SessionInfoBar; turn_end
+                // repeats the final message and must not double-count.
+                if (event.type === "message_end") {
+                    const usage = extractUsageSample(event);
+                    if (usage)
+                        onEvent({ type: "usage", sessionId, usage });
+                }
             });
-            onEvent({ type: "agent_settled", sessionId });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            onEvent({ type: "error", sessionId, message });
-            throw error;
+            options?.signal?.addEventListener("abort", onAbort);
+            if (options?.signal?.aborted) {
+                onAbort();
+                if (abortPromise)
+                    await abortPromise.catch(() => undefined);
+                return;
+            }
+            try {
+                await session.prompt(text, options?.images?.length ? { images: options.images } : undefined);
+                // Wait until the session reports idle / not streaming. The SDK prompt()
+                // resolves when the agent turn completes, but post-turn continuation
+                // (auto-compaction / follow-up) may still be in flight. We poll isIdle.
+                // While polling we emit periodic heartbeat events so the SSE stream
+                // keeps proxies/browsers from timing out (no other data is flowing).
+                await waitForIdle(session, {
+                    signal: options?.signal,
+                    onHeartbeat: () => onEvent({ type: "heartbeat", sessionId }),
+                });
+                if (abortPromise)
+                    await abortPromise;
+                // User abort is closed out as Turn state `aborted`; do not publish a
+                // red ordinary error event for intentional Stop.
+                if (!options?.signal?.aborted) {
+                    onEvent({ type: "agent_settled", sessionId });
+                }
+            }
+            catch (error) {
+                if (abortPromise)
+                    await abortPromise.catch(() => undefined);
+                if (options?.signal?.aborted) {
+                    // User abort: swallow ordinary error publication (AC-FIX-003).
+                    return;
+                }
+                const message = error instanceof Error ? error.message : String(error);
+                onEvent({ type: "error", sessionId, message });
+                throw error;
+            }
+            finally {
+                options?.signal?.removeEventListener("abort", onAbort);
+                unsub?.();
+            }
         }
         finally {
-            options?.signal?.removeEventListener("abort", onAbort);
-            unsub();
+            this.promptOwners.delete(sessionId);
         }
     }
     /** Generate exactly one title in an isolated in-memory, tool-less LOW session. */

package/dist/worker/console/chat/resource-preferences-store.js

@@ -0,0 +1,152 @@
+/**
+ * Operator Chat — repo-scoped resource auto-invocation preferences.
+ *
+ * Persists under Console app-data `resource-preferences.json` (per repo
+ * fingerprint). Preferences never touch SKILL.md, Pi settings, or tracked repo
+ * files. Malformed on-disk data fails closed.
+ */
+import { createHash } from "node:crypto";
+import { existsSync, lstatSync } from "node:fs";
+import { readJsonIfExists, writeSecureJson, } from "../app-data.js";
+export const RESOURCE_PREFERENCES_SCHEMA_VERSION = 1;
+export class ResourcePreferencesError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "ResourcePreferencesError";
+        this.code = code;
+    }
+}
+/** Stable server-issued resource id for a discovered skill (path + name). */
+export function skillResourceId(skill) {
+    return createHash("sha256")
+        .update(`skill\0${skill.name}\0${skill.filePath}`, "utf8")
+        .digest("hex")
+        .slice(0, 32);
+}
+function emptyPreferences() {
+    return {
+        schemaVersion: RESOURCE_PREFERENCES_SCHEMA_VERSION,
+        skills: {},
+    };
+}
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+/**
+ * Parse and validate on-disk preferences. Malformed content fails closed with
+ * a structured error (never silently treated as empty-success).
+ */
+export function parseResourcePreferences(raw) {
+    if (raw === undefined)
+        return emptyPreferences();
+    if (!isPlainObject(raw)) {
+        throw new ResourcePreferencesError("PI_RESOURCE_PREFERENCES_MALFORMED", "resource-preferences.json must be a JSON object");
+    }
+    if (raw.schemaVersion !== RESOURCE_PREFERENCES_SCHEMA_VERSION) {
+        throw new ResourcePreferencesError("PI_RESOURCE_PREFERENCES_MALFORMED", `unsupported resource-preferences schemaVersion: ${String(raw.schemaVersion)}`);
+    }
+    if (!isPlainObject(raw.skills)) {
+        throw new ResourcePreferencesError("PI_RESOURCE_PREFERENCES_MALFORMED", "resource-preferences.skills must be an object");
+    }
+    const skills = {};
+    for (const [resourceId, entry] of Object.entries(raw.skills)) {
+        if (typeof resourceId !== "string" || !resourceId.trim()) {
+            throw new ResourcePreferencesError("PI_RESOURCE_PREFERENCES_MALFORMED", "resource-preferences skill key must be a non-empty string");
+        }
+        if (!isPlainObject(entry)) {
+            throw new ResourcePreferencesError("PI_RESOURCE_PREFERENCES_MALFORMED", `resource-preferences entry for ${resourceId} must be an object`);
+        }
+        if (typeof entry.autoInvocationEnabled !== "boolean") {
+            throw new ResourcePreferencesError("PI_RESOURCE_PREFERENCES_MALFORMED", `resource-preferences entry for ${resourceId} missing boolean autoInvocationEnabled`);
+        }
+        if (typeof entry.updatedAt !== "string" || !entry.updatedAt.trim()) {
+            throw new ResourcePreferencesError("PI_RESOURCE_PREFERENCES_MALFORMED", `resource-preferences entry for ${resourceId} missing updatedAt`);
+        }
+        skills[resourceId] = {
+            autoInvocationEnabled: entry.autoInvocationEnabled,
+            updatedAt: entry.updatedAt,
+        };
+    }
+    return {
+        schemaVersion: RESOURCE_PREFERENCES_SCHEMA_VERSION,
+        skills,
+    };
+}
+export async function loadResourcePreferences(filePath) {
+    if (!filePath)
+        return emptyPreferences();
+    if (existsSync(filePath)) {
+        const st = lstatSync(filePath);
+        if (st.isSymbolicLink() || !st.isFile()) {
+            throw new ResourcePreferencesError("PI_RESOURCE_PREFERENCES_MALFORMED", `refusing to read non-regular resource-preferences file: ${filePath}`);
+        }
+    }
+    let raw;
+    try {
+        raw = await readJsonIfExists(filePath);
+    }
+    catch (error) {
+        throw new ResourcePreferencesError("PI_RESOURCE_PREFERENCES_MALFORMED", error instanceof Error ? error.message : String(error));
+    }
+    return parseResourcePreferences(raw);
+}
+/** resourceIds whose auto-invocation is explicitly disabled (default = enabled). */
+export function disabledAutoInvocationIds(prefs) {
+    const disabled = new Set();
+    for (const [id, entry] of Object.entries(prefs.skills)) {
+        if (entry.autoInvocationEnabled === false)
+            disabled.add(id);
+    }
+    return disabled;
+}
+export function isAutoInvocationEnabled(prefs, resourceId) {
+    const entry = prefs.skills[resourceId];
+    if (!entry)
+        return true;
+    return entry.autoInvocationEnabled !== false;
+}
+export async function setSkillAutoInvocationPreference(options) {
+    const current = await loadResourcePreferences(options.filePath);
+    const next = {
+        schemaVersion: RESOURCE_PREFERENCES_SCHEMA_VERSION,
+        skills: {
+            ...current.skills,
+            [options.resourceId]: {
+                autoInvocationEnabled: options.autoInvocationEnabled,
+                updatedAt: options.now ?? new Date().toISOString(),
+            },
+        },
+    };
+    // Default-on entries may be pruned to keep the file sparse when re-enabled.
+    if (options.autoInvocationEnabled === true) {
+        // Keep explicit true only when previously present was false; either way
+        // store the affirmative so UI/history can show last toggle time.
+    }
+    try {
+        await writeSecureJson(options.filePath, next);
+    }
+    catch (error) {
+        throw new ResourcePreferencesError("PI_RESOURCE_PREFERENCES_WRITE_FAILED", error instanceof Error ? error.message : String(error));
+    }
+    return next;
+}
+/**
+ * Apply stored auto-invocation preferences onto a discovered skill list.
+ * Skills remain in inventory (manual /skill:name stays available); only
+ * `disableModelInvocation` is forced true when the preference is off.
+ * Existing frontmatter disableModelInvocation is never cleared.
+ */
+export function applySkillAutoInvocationPreferences(skills, prefs) {
+    const disabled = disabledAutoInvocationIds(prefs);
+    if (disabled.size === 0)
+        return skills;
+    return skills.map((skill) => {
+        const id = skillResourceId(skill);
+        if (!disabled.has(id))
+            return skill;
+        if (skill.disableModelInvocation === true)
+            return skill;
+        return { ...skill, disableModelInvocation: true };
+    });
+}