qlogicagent 2.13.3 → 2.13.5

package/dist/runtime/infra/model-registry.test.js

@@ -0,0 +1,253 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { ModelRegistry } from "./model-registry.js";
+afterEach(() => {
+    vi.unstubAllEnvs();
+});
+describe("ModelRegistry", () => {
+    it("does not hydrate local catalog models before the llmrouter catalog refreshes", () => {
+        const registry = new ModelRegistry({
+            providers: [
+                {
+                    providerId: "deepseek",
+                    strategy: "weighted-round-robin",
+                    keys: [{ id: "deepseek-test", key: "test-key", weight: 1, enabled: true }],
+                },
+            ],
+            models: [{ id: "deepseek:deepseek-v4-flash", enabled: true }],
+            bindings: { textGeneration: "deepseek:deepseek-v4-flash" },
+        });
+        const resolved = registry.getActiveModel("textGeneration");
+        expect(registry.listModels({ provider: "deepseek" })).toEqual([]);
+        expect(registry.getBinding("textGeneration")).toBeNull();
+        expect(resolved).toBeNull();
+    });
+    it("uses only llmrouter-supplied reasoning mode and does not infer missing model capabilities", () => {
+        const registry = new ModelRegistry();
+        registry.replaceCatalogModels([
+            {
+                id: "deepseek:deepseek-v4-flash",
+                provider: "deepseek",
+                model: "deepseek-v4-flash",
+                displayName: "DeepSeek V4 Flash",
+                purposes: ["textGeneration"],
+                enabled: true,
+                nativeModelId: "deepseek-v4-flash",
+            },
+            {
+                id: "qwen:qwq-plus",
+                provider: "qwen",
+                model: "qwq-plus",
+                displayName: "QwQ Plus",
+                purposes: ["textGeneration"],
+                enabled: true,
+                nativeModelId: "qwq-plus",
+                reasoningMode: "effort",
+                streamRequired: true,
+            },
+        ]);
+        expect(registry.getModel("deepseek:deepseek-v4-flash")?.reasoningMode).toBeUndefined();
+        expect(registry.getModel("deepseek:deepseek-v4-flash")?.streamRequired).toBeUndefined();
+        expect(registry.getModel("qwen:qwq-plus")).toMatchObject({
+            reasoningMode: "effort",
+            streamRequired: true,
+        });
+    });
+    it("uses public model aliases as stable saved ids and native ids for upstream calls", () => {
+        const registry = new ModelRegistry({
+            providers: [
+                {
+                    providerId: "volcengine",
+                    strategy: "weighted-round-robin",
+                    keys: [{ id: "volcengine-test", key: "test-key", weight: 1, enabled: true }],
+                },
+            ],
+            models: [{ id: "volcengine:doubao-seedream-4-5", enabled: true }],
+            bindings: { imageGeneration: "volcengine:doubao-seedream-4-5" },
+        });
+        registry.replaceCatalogProviders([{
+                id: "volcengine",
+                name: "Doubao / Volcengine",
+                transport: "volcengine-responses",
+                baseUrl: "https://ark.cn-beijing.volces.com/api/v3",
+                models: [{ id: "doubao-seedream-4-5" }],
+            }]);
+        registry.replaceCatalogModels([{
+                id: "volcengine:doubao-seedream-4-5",
+                provider: "volcengine",
+                model: "doubao-seedream-4-5",
+                displayName: "Doubao Seedream 4.5",
+                purposes: ["imageGeneration"],
+                enabled: true,
+                nativeModelId: "doubao-seedream-4-5-251128",
+                transport: "volcengine-responses",
+            }]);
+        const resolved = registry.getActiveModel("imageGeneration");
+        resolved?.keyHandle.release({ success: true });
+        expect(registry.getBinding("imageGeneration")?.model).toBe("doubao-seedream-4-5");
+        expect(registry.getBinding("imageGeneration")?.nativeModelId).toBe("doubao-seedream-4-5-251128");
+        expect(resolved?.model).toBe("doubao-seedream-4-5-251128");
+    });
+    it("uses llmrouter catalog base URLs for known providers so protocol-specific routes stay correct", () => {
+        const registry = new ModelRegistry();
+        registry.addProvider("deepseek", { baseUrl: "https://api.deepseek.com" });
+        registry.addKey("deepseek", "test-key");
+        registry.replaceCatalogProviders([{
+                id: "deepseek",
+                name: "DeepSeek",
+                transport: "anthropic-messages",
+                baseUrl: "https://api.deepseek.com/anthropic",
+                models: [{ id: "deepseek-v4-flash" }],
+            }]);
+        registry.addModel({
+            id: "deepseek:deepseek-v4-flash",
+            provider: "deepseek",
+            model: "deepseek-v4-flash",
+            displayName: "DeepSeek V4 Flash",
+            purposes: ["textGeneration"],
+            enabled: true,
+            nativeModelId: "deepseek-v4-flash",
+            transport: "anthropic-messages",
+            baseUrl: "https://api.deepseek.com",
+        });
+        registry.setBinding("textGeneration", "deepseek:deepseek-v4-flash");
+        const resolved = registry.getActiveModel("textGeneration");
+        resolved?.keyHandle.release({ success: true });
+        expect(resolved?.baseUrl).toBe("https://api.deepseek.com/anthropic");
+    });
+    it("can resolve a full API key by key id without exposing it in overview data", () => {
+        const registry = new ModelRegistry();
+        registry.addProvider("deepseek", { baseUrl: "https://api.deepseek.com" });
+        const keyId = registry.addKey("deepseek", "sk-live-full-value");
+        expect(registry.getKeyById(keyId)).toBe("sk-live-full-value");
+        expect(registry.getKeyById("missing-key")).toBeNull();
+    });
+    it("persists local pause and removal state for the injected llmrouter key", () => {
+        vi.stubEnv("QLOGIC_LLMROUTER_INFERENCE_KEY", "sk-qllm-env");
+        const registry = new ModelRegistry({
+            providers: [],
+            models: [],
+            bindings: {},
+        });
+        expect(registry.getKeyById("llmrouter-env")).toBe("sk-qllm-env");
+        expect(registry.getAllProviderStatus()[0]?.keys[0]).toMatchObject({
+            id: "llmrouter-env",
+            enabled: true,
+            healthStatus: "healthy",
+        });
+        expect(registry.updateKey("llmrouter-env", { enabled: false })).toBe(true);
+        expect(registry.getKeyById("llmrouter-env")).toBe("sk-qllm-env");
+        expect(registry.hasConfiguredKeyForProviderVariant("llmrouter")).toBe(false);
+        expect(registry.hasAvailableKeyForProviderVariant("llmrouter")).toBe(false);
+        expect(registry.getAllProviderStatus()[0]?.keys[0]).toMatchObject({
+            id: "llmrouter-env",
+            enabled: false,
+            healthStatus: "disabled",
+        });
+        expect(registry.updateKey("llmrouter-env", { enabled: true })).toBe(true);
+        expect(registry.hasConfiguredKeyForProviderVariant("llmrouter")).toBe(true);
+        expect(registry.removeKey("llmrouter-env")).toBe(true);
+        expect(registry.getKeyById("llmrouter-env")).toBeNull();
+        expect(registry.hasConfiguredKeyForProviderVariant("llmrouter")).toBe(false);
+        expect(registry.getAllProviderStatus().some(status => status.providerId === "llmrouter")).toBe(false);
+        expect(registry.updateKey("llmrouter-env", { enabled: true })).toBe(false);
+    });
+    it("routes an explicitly bound Volcengine Plan model through the Plan transport and base URL", () => {
+        const registry = new ModelRegistry();
+        registry.addProvider("volcengine-plan", { baseUrl: "https://ark.cn-beijing.volces.com/api/coding/v3" });
+        registry.addKey("volcengine-plan", "test-key");
+        registry.addModel({
+            id: "volcengine-plan:ark-code-latest",
+            provider: "volcengine-plan",
+            model: "ark-code-latest",
+            displayName: "Ark Code Latest",
+            purposes: ["textGeneration"],
+            baseUrl: "https://ark.cn-beijing.volces.com/api/coding/v3",
+            enabled: true,
+            nativeModelId: "ark-code-latest",
+            transport: "openai-chat",
+        });
+        registry.setBinding("textGeneration", "volcengine-plan:ark-code-latest");
+        const resolved = registry.getActiveModel("textGeneration");
+        resolved?.keyHandle.release({ success: true });
+        expect(resolved).toMatchObject({
+            provider: "volcengine-plan",
+            model: "ark-code-latest",
+            baseUrl: "https://ark.cn-beijing.volces.com/api/coding/v3",
+        });
+    });
+    it("routes an explicitly bound Qwen Coding Plan model through the Coding Plan base URL", () => {
+        const registry = new ModelRegistry();
+        registry.addProvider("qwen-coding", { baseUrl: "https://coding.dashscope.aliyuncs.com/apps/anthropic" });
+        registry.addKey("qwen-coding", "test-key");
+        registry.addModel({
+            id: "qwen-coding:qwen3-coder-plus",
+            provider: "qwen-coding",
+            model: "qwen3-coder-plus",
+            displayName: "Qwen3 Coder Plus",
+            purposes: ["textGeneration"],
+            baseUrl: "https://coding.dashscope.aliyuncs.com/apps/anthropic",
+            enabled: true,
+            nativeModelId: "qwen3-coder-plus",
+            transport: "anthropic-messages",
+        });
+        registry.setBinding("textGeneration", "qwen-coding:qwen3-coder-plus");
+        const resolved = registry.getActiveModel("textGeneration");
+        resolved?.keyHandle.release({ success: true });
+        expect(resolved).toMatchObject({
+            provider: "qwen-coding",
+            model: "qwen3-coder-plus",
+            baseUrl: "https://coding.dashscope.aliyuncs.com/apps/anthropic",
+        });
+    });
+    it("ignores pre-profile global provider settings when loading an owner profile", () => {
+        const home = fs.mkdtempSync(path.join(os.tmpdir(), "qlc-model-registry-"));
+        try {
+            vi.stubEnv("QLOGICAGENT_HOME", home);
+            vi.stubEnv("QLOGIC_LLMROUTER_USER_ID", "user/alice");
+            const preProfilePath = path.join(home, "settings.json");
+            fs.writeFileSync(preProfilePath, JSON.stringify({
+                providers: [
+                    {
+                        providerId: "deepseek",
+                        strategy: "weighted-round-robin",
+                        keys: [{ id: "pre-profile-key", key: "test-key", weight: 1, enabled: true }],
+                    },
+                ],
+                models: [{ id: "deepseek:deepseek-v4-flash", enabled: true }],
+                bindings: { textGeneration: "deepseek:deepseek-v4-flash" },
+                permissionMode: "ask",
+            }), "utf-8");
+            const profilePath = path.join(home, "profiles", "user%2Falice", "settings.json");
+            fs.mkdirSync(path.dirname(profilePath), { recursive: true });
+            fs.writeFileSync(profilePath, JSON.stringify({
+                providers: [],
+                models: [{ id: "deepseek:deepseek-v4-pro", enabled: true }],
+                bindings: { textGeneration: "deepseek:deepseek-v4-pro" },
+            }), "utf-8");
+            const registry = new ModelRegistry();
+            expect(registry.load()).toBe(true);
+            expect(registry.getProviderStatus("deepseek")?.keys ?? []).toHaveLength(0);
+            expect(registry.getBinding("textGeneration")).toBeNull();
+            registry.replaceCatalogModels([{
+                    id: "deepseek:deepseek-v4-pro",
+                    provider: "deepseek",
+                    model: "deepseek-v4-pro",
+                    displayName: "DeepSeek V4 Pro",
+                    purposes: ["textGeneration"],
+                    enabled: true,
+                    nativeModelId: "deepseek-v4-pro",
+                }]);
+            expect(registry.getBinding("textGeneration")?.id).toBe("deepseek:deepseek-v4-pro");
+            const profile = JSON.parse(fs.readFileSync(profilePath, "utf-8"));
+            expect(profile.permissionMode).toBeUndefined();
+            expect(profile.providers).toHaveLength(0);
+            expect(profile.migrations).toBeUndefined();
+        }
+        finally {
+            fs.rmSync(home, { recursive: true, force: true });
+        }
+    });
+});

package/dist/runtime/infra/process-config-port.d.ts

@@ -0,0 +1,2 @@
+import type { ConfigPort } from "../ports/index.js";
+export declare function createProcessConfigPort(env?: NodeJS.ProcessEnv): ConfigPort;

package/dist/runtime/infra/process-config-port.js

@@ -0,0 +1,5 @@
+export function createProcessConfigPort(env = process.env) {
+    return {
+        get: (key) => env[key],
+    };
+}

package/dist/runtime/infra/profile-storage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/infra/profile-storage.test.js

@@ -0,0 +1,41 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { AgentConfigStore } from "./agent-config-store.js";
+import { createProject } from "./project-store.js";
+const tmpDirs = [];
+function makeTempDir() {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "profile-storage-"));
+    tmpDirs.push(dir);
+    return dir;
+}
+function profileDir(home) {
+    return path.join(home, "profiles", "user%2Falice");
+}
+afterEach(() => {
+    vi.unstubAllEnvs();
+    for (const dir of tmpDirs.splice(0)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe("owner profile storage", () => {
+    it("stores project registry inside the active owner profile", () => {
+        const home = makeTempDir();
+        vi.stubEnv("QLOGICAGENT_HOME", home);
+        vi.stubEnv("QLOGIC_LLMROUTER_USER_ID", "user/alice");
+        createProject({ name: "Alice Project", workspaceDir: path.join(home, "workspace") });
+        expect(fs.existsSync(path.join(profileDir(home), "projects.json"))).toBe(true);
+        expect(fs.existsSync(path.join(home, "projects.json"))).toBe(false);
+    });
+    it("stores agent config inside the active owner profile", async () => {
+        const home = makeTempDir();
+        vi.stubEnv("QLOGICAGENT_HOME", home);
+        vi.stubEnv("QLOGIC_LLMROUTER_USER_ID", "user/alice");
+        const store = new AgentConfigStore();
+        await store.load();
+        await store.setAgentConfig("default", { model: "deepseek-v4-flash" });
+        expect(fs.existsSync(path.join(profileDir(home), "agent-configs.json"))).toBe(true);
+        expect(fs.existsSync(path.join(home, "agent-configs.json"))).toBe(false);
+    });
+});

package/dist/runtime/infra/project-instructions-store.d.ts

@@ -0,0 +1,30 @@
+/**
+ * ProjectInstructionsStore — CRUD for project-scoped rule/instruction files.
+ *
+ * Storage location: `<workspace>/.qlogicagent/rules/*.md`
+ * Unified directory for all project instructions and rules.
+ */
+export interface InstructionFile {
+    filename: string;
+    content: string;
+    sizeBytes: number;
+}
+export declare class ProjectInstructionsStore {
+    private dir;
+    constructor(cwd: string);
+    /** List all instruction files for the project. */
+    list(): InstructionFile[];
+    /** Read a single instruction file. */
+    read(filename: string): InstructionFile | null;
+    /** Write (create or update) an instruction file. */
+    write(filename: string, content: string): InstructionFile;
+    /** Delete an instruction file. */
+    remove(filename: string): boolean;
+    /**
+     * Load all instruction files and concatenate into a single block
+     * for agent system context injection.
+     */
+    loadAll(): string;
+    private isValidFilename;
+    private getDirSize;
+}

package/dist/runtime/infra/project-instructions-store.js

@@ -0,0 +1,124 @@
+/**
+ * ProjectInstructionsStore — CRUD for project-scoped rule/instruction files.
+ *
+ * Storage location: `<workspace>/.qlogicagent/rules/*.md`
+ * Unified directory for all project instructions and rules.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { getProjectRulesDir } from "./agent-paths.js";
+import { INSTRUCTIONS_MAX_FILE_SIZE, INSTRUCTIONS_MAX_DIR_SIZE } from "../config/tunable-defaults.js";
+const MAX_FILE_SIZE = INSTRUCTIONS_MAX_FILE_SIZE;
+const MAX_DIR_SIZE = INSTRUCTIONS_MAX_DIR_SIZE;
+export class ProjectInstructionsStore {
+    dir;
+    constructor(cwd) {
+        this.dir = getProjectRulesDir(cwd);
+    }
+    /** List all instruction files for the project. */
+    list() {
+        if (!fs.existsSync(this.dir))
+            return [];
+        const files = [];
+        for (const entry of fs.readdirSync(this.dir)) {
+            if (!entry.endsWith(".md"))
+                continue;
+            const filePath = path.join(this.dir, entry);
+            try {
+                const stat = fs.statSync(filePath);
+                if (!stat.isFile())
+                    continue;
+                const content = fs.readFileSync(filePath, "utf8");
+                files.push({ filename: entry, content, sizeBytes: stat.size });
+            }
+            catch {
+                // skip unreadable files
+            }
+        }
+        return files;
+    }
+    /** Read a single instruction file. */
+    read(filename) {
+        if (!this.isValidFilename(filename))
+            return null;
+        const filePath = path.join(this.dir, filename);
+        if (!fs.existsSync(filePath))
+            return null;
+        try {
+            const content = fs.readFileSync(filePath, "utf8");
+            const stat = fs.statSync(filePath);
+            return { filename, content, sizeBytes: stat.size };
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Write (create or update) an instruction file. */
+    write(filename, content) {
+        if (!this.isValidFilename(filename)) {
+            throw new Error(`Invalid filename: must end with .md and contain no path separators`);
+        }
+        const bytes = Buffer.byteLength(content, "utf8");
+        if (bytes > MAX_FILE_SIZE) {
+            throw new Error(`File too large: ${bytes} bytes exceeds ${MAX_FILE_SIZE} limit`);
+        }
+        // Check total dir size (excluding this file)
+        const currentSize = this.getDirSize(filename);
+        if (currentSize + bytes > MAX_DIR_SIZE) {
+            throw new Error(`Total instructions size would exceed ${MAX_DIR_SIZE} byte limit`);
+        }
+        fs.mkdirSync(this.dir, { recursive: true });
+        const filePath = path.join(this.dir, filename);
+        fs.writeFileSync(filePath, content, "utf8");
+        return { filename, content, sizeBytes: bytes };
+    }
+    /** Delete an instruction file. */
+    remove(filename) {
+        if (!this.isValidFilename(filename))
+            return false;
+        const filePath = path.join(this.dir, filename);
+        if (!fs.existsSync(filePath))
+            return false;
+        fs.unlinkSync(filePath);
+        return true;
+    }
+    /**
+     * Load all instruction files and concatenate into a single block
+     * for agent system context injection.
+     */
+    loadAll() {
+        const files = this.list();
+        if (files.length === 0)
+            return "";
+        const parts = files.map((f) => `<!-- file: ${f.filename}>\n${f.content}`);
+        return `<project-instructions>\n${parts.join("\n\n")}\n</project-instructions>`;
+    }
+    isValidFilename(filename) {
+        if (!filename.endsWith(".md"))
+            return false;
+        if (filename.includes("/") || filename.includes("\\"))
+            return false;
+        if (filename.includes(".."))
+            return false;
+        if (filename.startsWith("."))
+            return false;
+        return true;
+    }
+    getDirSize(excludeFilename) {
+        if (!fs.existsSync(this.dir))
+            return 0;
+        let total = 0;
+        for (const entry of fs.readdirSync(this.dir)) {
+            if (entry === excludeFilename)
+                continue;
+            const filePath = path.join(this.dir, entry);
+            try {
+                const stat = fs.statSync(filePath);
+                if (stat.isFile())
+                    total += stat.size;
+            }
+            catch { /* skip */ }
+        }
+        return total;
+    }
+}

package/dist/runtime/infra/project-skill-manifest.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Project skill enablement manifest — the per-project opt-in list for the
+ * single-store skill registry.
+ *
+ * Stored at `<cwd>/.qlogicagent/skills-enabled.json`:
+ *   { "version": 1, "enabled": ["skill-a", "skill-b"] }
+ *
+ * Only project-scoped skills need listing here; globally-scoped skills
+ * (see skill-lifecycle `enabledScope`) are active everywhere regardless.
+ */
+export interface ProjectSkillManifest {
+    version: 1;
+    enabled: string[];
+}
+/** Read the enablement manifest for a project. Returns empty manifest if absent/malformed. */
+export declare function readProjectSkillManifest(cwd: string): ProjectSkillManifest;
+/** The set of project-scoped skill names enabled in this project. */
+export declare function readEnabledSkills(cwd: string): Set<string>;
+/** Enable a (project-scoped) skill in this project. Idempotent. Returns true if newly added. */
+export declare function enableSkill(cwd: string, name: string): boolean;
+/** Disable (un-enable) a skill in this project. Idempotent. Returns true if removed. */
+export declare function disableSkill(cwd: string, name: string): boolean;
+/** Skills that are project-scoped (active only where a project manifest enables them). */
+export declare function readProjectScopedSkills(): Set<string>;
+/** Mark a skill project-scoped (learned/created). Idempotent. Returns true if newly added. */
+export declare function markProjectScoped(name: string): boolean;
+/** Unmark a skill (promote to global). Idempotent. Returns true if removed. */
+export declare function unmarkProjectScoped(name: string): boolean;
+/** Globally muted skills (inactive everywhere). */
+export declare function readGloballyDisabledSkills(): Set<string>;
+/** Mute/unmute a global skill everywhere. Idempotent. Returns true if the registry changed. */
+export declare function setSkillGloballyDisabled(name: string, disabled: boolean): boolean;

package/dist/runtime/infra/project-skill-manifest.js

@@ -0,0 +1,160 @@
+/**
+ * Project skill enablement manifest — the per-project opt-in list for the
+ * single-store skill registry.
+ *
+ * Stored at `<cwd>/.qlogicagent/skills-enabled.json`:
+ *   { "version": 1, "enabled": ["skill-a", "skill-b"] }
+ *
+ * Only project-scoped skills need listing here; globally-scoped skills
+ * (see skill-lifecycle `enabledScope`) are active everywhere regardless.
+ */
+import { readFileSync, writeFileSync, mkdirSync, renameSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getProjectSkillManifestPath, getOwnerProfileDir } from "./agent-paths.js";
+function emptyManifest() {
+    return { version: 1, enabled: [] };
+}
+/** Read the enablement manifest for a project. Returns empty manifest if absent/malformed. */
+export function readProjectSkillManifest(cwd) {
+    try {
+        const raw = JSON.parse(readFileSync(getProjectSkillManifestPath(cwd), "utf8"));
+        if (!raw || typeof raw !== "object" || !Array.isArray(raw.enabled)) {
+            return emptyManifest();
+        }
+        const enabled = [
+            ...new Set((raw.enabled).filter((x) => typeof x === "string" && x.trim().length > 0)),
+        ];
+        return { version: 1, enabled };
+    }
+    catch {
+        return emptyManifest();
+    }
+}
+/** The set of project-scoped skill names enabled in this project. */
+export function readEnabledSkills(cwd) {
+    return new Set(readProjectSkillManifest(cwd).enabled);
+}
+function writeProjectSkillManifest(cwd, manifest) {
+    const p = getProjectSkillManifestPath(cwd);
+    mkdirSync(dirname(p), { recursive: true });
+    // Atomic write: tmp + rename (mirrors skill-lifecycle store I/O).
+    const tmp = p + ".tmp";
+    writeFileSync(tmp, JSON.stringify(manifest, null, 2), "utf8");
+    renameSync(tmp, p);
+}
+/** Enable a (project-scoped) skill in this project. Idempotent. Returns true if newly added. */
+export function enableSkill(cwd, name) {
+    const manifest = readProjectSkillManifest(cwd);
+    if (manifest.enabled.includes(name))
+        return false;
+    manifest.enabled.push(name);
+    manifest.enabled.sort();
+    writeProjectSkillManifest(cwd, manifest);
+    return true;
+}
+/** Disable (un-enable) a skill in this project. Idempotent. Returns true if removed. */
+export function disableSkill(cwd, name) {
+    const manifest = readProjectSkillManifest(cwd);
+    const idx = manifest.enabled.indexOf(name);
+    if (idx === -1)
+        return false;
+    manifest.enabled.splice(idx, 1);
+    writeProjectSkillManifest(cwd, manifest);
+    return true;
+}
+function getScopedRegistryPath() {
+    return join(getOwnerProfileDir(), "skills-scoped.json");
+}
+function readScopedRegistry() {
+    try {
+        const raw = JSON.parse(readFileSync(getScopedRegistryPath(), "utf8"));
+        if (!raw || typeof raw !== "object" || !Array.isArray(raw.scoped)) {
+            return { version: 1, scoped: [] };
+        }
+        const scoped = [
+            ...new Set((raw.scoped).filter((x) => typeof x === "string" && x.trim().length > 0)),
+        ];
+        return { version: 1, scoped };
+    }
+    catch {
+        return { version: 1, scoped: [] };
+    }
+}
+function writeScopedRegistry(registry) {
+    const p = getScopedRegistryPath();
+    mkdirSync(dirname(p), { recursive: true });
+    const tmp = p + ".tmp";
+    writeFileSync(tmp, JSON.stringify(registry, null, 2), "utf8");
+    renameSync(tmp, p);
+}
+/** Skills that are project-scoped (active only where a project manifest enables them). */
+export function readProjectScopedSkills() {
+    return new Set(readScopedRegistry().scoped);
+}
+/** Mark a skill project-scoped (learned/created). Idempotent. Returns true if newly added. */
+export function markProjectScoped(name) {
+    const registry = readScopedRegistry();
+    if (registry.scoped.includes(name))
+        return false;
+    registry.scoped.push(name);
+    registry.scoped.sort();
+    writeScopedRegistry(registry);
+    return true;
+}
+/** Unmark a skill (promote to global). Idempotent. Returns true if removed. */
+export function unmarkProjectScoped(name) {
+    const registry = readScopedRegistry();
+    const idx = registry.scoped.indexOf(name);
+    if (idx === -1)
+        return false;
+    registry.scoped.splice(idx, 1);
+    writeScopedRegistry(registry);
+    return true;
+}
+function getDisabledRegistryPath() {
+    return join(getOwnerProfileDir(), "skills-disabled.json");
+}
+function readDisabledRegistry() {
+    try {
+        const raw = JSON.parse(readFileSync(getDisabledRegistryPath(), "utf8"));
+        if (!raw || typeof raw !== "object" || !Array.isArray(raw.disabled)) {
+            return { version: 1, disabled: [] };
+        }
+        const disabled = [
+            ...new Set((raw.disabled).filter((x) => typeof x === "string" && x.trim().length > 0)),
+        ];
+        return { version: 1, disabled };
+    }
+    catch {
+        return { version: 1, disabled: [] };
+    }
+}
+function writeDisabledRegistry(registry) {
+    const p = getDisabledRegistryPath();
+    mkdirSync(dirname(p), { recursive: true });
+    const tmp = p + ".tmp";
+    writeFileSync(tmp, JSON.stringify(registry, null, 2), "utf8");
+    renameSync(tmp, p);
+}
+/** Globally muted skills (inactive everywhere). */
+export function readGloballyDisabledSkills() {
+    return new Set(readDisabledRegistry().disabled);
+}
+/** Mute/unmute a global skill everywhere. Idempotent. Returns true if the registry changed. */
+export function setSkillGloballyDisabled(name, disabled) {
+    const registry = readDisabledRegistry();
+    const idx = registry.disabled.indexOf(name);
+    if (disabled) {
+        if (idx !== -1)
+            return false;
+        registry.disabled.push(name);
+        registry.disabled.sort();
+    }
+    else {
+        if (idx === -1)
+            return false;
+        registry.disabled.splice(idx, 1);
+    }
+    writeDisabledRegistry(registry);
+    return true;
+}

package/dist/runtime/infra/project-skill-manifest.test.d.ts

@@ -0,0 +1 @@
+export {};