@youweichen/pi-harness 0.0.0-stage → 1.0.0

package/dist/server/session-tree-controller.js

@@ -0,0 +1,250 @@
+import { parseUserAttachments } from "./user-attachments.js";
+import { recallPending } from "./prompt-delivery.js";
+import { SessionTailValidator } from "./session-file-read.js";
+import { randomUUID } from "node:crypto";
+import { existsSync, watch } from "node:fs";
+import { basename, dirname } from "node:path";
+import { collectEntriesForBranchSummary } from "@earendil-works/pi-coding-agent";
+import { projectTree, treeEntryContent, treeRevision, toUiTree } from "./session-tree.js";
+/** Owns operation admission, native-file invalidation and derived message metadata.
+ * The native SessionManager remains the sole owner of entries and the leaf. */
+export class SessionTreeController {
+    host;
+    watcher;
+    watchPath;
+    validator;
+    external = false;
+    operation = false;
+    disposed = false;
+    revision = "";
+    counts = { branchPoints: 0, rootCount: 0 };
+    metadata = new Map();
+    decorated = new WeakMap();
+    constructor(host) {
+        this.host = host;
+    }
+    get busy() { return this.operation; }
+    get externallyModified() { this.checkExternal(); return this.external; }
+    get session() { return this.host.runtime().session; }
+    bindFile() {
+        const path = this.session.sessionFile;
+        if (path === this.watchPath)
+            return;
+        this.watcher?.close();
+        this.watcher = undefined;
+        this.validator?.dispose();
+        this.watchPath = path;
+        this.external = false;
+        this.revision = "";
+        this.validator = path ? new SessionTailValidator(path, this.session.sessionManager, () => { this.checkExternal(); this.host.changed(); }) : undefined;
+        if (path && existsSync(dirname(path))) {
+            this.watcher = watch(dirname(path), { persistent: false }, (_event, file) => {
+                if (!file || file.toString() === basename(path))
+                    this.checkExternal();
+            });
+            this.watcher.on("error", () => { this.external = true; this.host.changed(); });
+        }
+        this.checkExternal();
+    }
+    checkExternal() {
+        if (!this.watchPath || this.external)
+            return;
+        const wasBlocking = this.validator?.blocking;
+        const valid = this.validator?.check(this.session.sessionManager);
+        if (valid === undefined) {
+            if (!wasBlocking && this.validator?.blocking)
+                this.host.changed();
+            return;
+        }
+        if (valid)
+            return;
+        this.external = true;
+        if (!this.session.isIdle)
+            void this.session.abort().catch(() => { });
+        this.host.changed();
+    }
+    async waitForVerification() {
+        const validator = this.validator, session = this.session;
+        await validator?.verify(session.sessionManager);
+        if (this.disposed || !this.host.active() || this.validator !== validator || this.session !== session)
+            throw new Error("对话已切换，请重新操作。");
+        this.assertWritable();
+    }
+    assertWritable() {
+        this.checkExternal();
+        if (this.external)
+            throw new Error("会话文件已被外部修改，请重新打开后继续。");
+        if (this.validator?.blocking)
+            throw new Error("正在校验会话文件，请稍后重试。");
+        if (this.operation)
+            throw new Error("等待当前压缩或切换完成。");
+    }
+    refresh() {
+        this.bindFile();
+        this.checkExternal();
+        const sm = this.session.sessionManager;
+        const revision = treeRevision(sm);
+        if (revision !== this.revision) {
+            const tree = projectTree(sm);
+            this.counts = { branchPoints: tree.branchPoints, rootCount: tree.rootCount };
+            this.metadata.clear();
+            for (const entry of sm.getEntries())
+                this.metadata.set(entry.id, { entryId: entry.id, label: sm.getLabel(entry.id), siblings: tree.siblings(entry.id) });
+            this.revision = revision;
+            this.host.emit({ type: "tree_changed", conversationId: this.host.conversationId, revision, branchPoints: tree.branchPoints });
+        }
+        return { revision, leafId: sm.getLeafId(), ...this.counts, filterMode: this.session.settingsManager.getTreeFilterMode(), skipSummaryPrompt: this.session.settingsManager.getBranchSummarySkipPrompt(), externallyModified: this.external, verifying: this.validator?.blocking ?? false, busy: this.operation || this.session.isCompacting };
+    }
+    decorate(message, entryId) {
+        if (!entryId)
+            return message;
+        const metadata = this.metadata.get(entryId) ?? { entryId };
+        const key = JSON.stringify(metadata);
+        const cached = this.decorated.get(message);
+        if (cached?.key === key)
+            return cached.value;
+        const value = { ...message, ...metadata };
+        const entry = this.session.sessionManager.getEntry(entryId);
+        if (entry?.type === "message" && (entry.message.role === "user" || (entry.message.role === "custom" && entry.message.customType === "file"))) {
+            const content = entry.message.content;
+            const parsed = parseUserAttachments(typeof content === "string" ? content : content.filter(b => b.type === "text").map(b => b.text).join("\n"));
+            if (parsed.attachments.length) {
+                value.questionText = parsed.text;
+                value.userAttachments = parsed.attachments.map((a, index) => ({ path: a.path, mode: a.mode, preview: a.preview.slice(0, 12000), nativeRef: { entryId, index } }));
+            }
+        }
+        this.decorated.set(message, { key, value });
+        return value;
+    }
+    async request(request, onResult) {
+        const context = { conversationId: this.host.conversationId, reqId: request.reqId };
+        let restoredQueue;
+        let ownsOperation = false;
+        const reply = (status, extra = {}) => { onResult?.(status); this.host.emit({ type: "tree_navigate_result", ...context, status, restoredQueue, ...extra }); };
+        const session = this.session;
+        const sm = session.sessionManager;
+        try {
+            if (request.conversationId !== this.host.conversationId || !this.host.active())
+                throw new Error("只能操作当前活动对话。");
+            const validate = () => {
+                if (!this.host.active() || this.session !== session)
+                    throw new Error("对话已切换，请重新操作。");
+                this.checkExternal();
+                if (this.external)
+                    throw new Error("会话文件已被外部修改，请重新打开后继续。");
+                if (this.validator?.blocking)
+                    throw new Error("正在校验会话文件，请稍后重试。");
+            };
+            if (request.type === "tree_get") {
+                const filter = request.filter ?? session.settingsManager.getTreeFilterMode();
+                if (!["default", "no-tools", "user-only", "labeled-only", "all"].includes(filter))
+                    throw new Error("Invalid tree filter");
+                const state = this.refresh();
+                this.host.emit({ type: "tree", ...context, revision: state.revision, leafId: state.leafId, ...toUiTree(sm, filter, (request.query ?? "").slice(0, 1000)) });
+                return;
+            }
+            if (request.type === "tree_content") {
+                const entry = sm.getEntry(request.entryId);
+                if (!entry)
+                    throw new Error("Entry not found");
+                this.host.emit({ type: "tree_content_result", ...context, entryId: entry.id, content: treeEntryContent(entry), toolCallId: entry.type === "message" && entry.message.role === "toolResult" ? entry.message.toolCallId : undefined });
+                return;
+            }
+            if (request.type === "tree_preview") {
+                if (!sm.getEntry(request.targetId))
+                    throw new Error("Entry not found");
+                try {
+                    const result = collectEntriesForBranchSummary(sm, sm.getLeafId(), request.targetId);
+                    this.host.emit({ type: "tree_preview_result", ...context, entryCount: result.entries.length, commonAncestorId: result.commonAncestorId });
+                }
+                catch {
+                    this.host.emit({ type: "tree_preview_result", ...context });
+                }
+                return;
+            }
+            if (!this.host.admitted())
+                throw new Error("服务正在排空，请稍后重试。");
+            if (request.type === "tree_label") {
+                validate();
+                if (!sm.getEntry(request.entryId))
+                    throw new Error("Entry not found");
+                if (request.label !== null && (typeof request.label !== "string" || request.label.length > 200))
+                    throw new Error("Label must be at most 200 characters");
+                sm.appendLabelChange(request.entryId, request.label?.trim() || undefined);
+                reply("ok");
+                return;
+            }
+            if (this.operation || session.isCompacting) {
+                reply("busy");
+                return;
+            }
+            if (!session.isIdle && !(request.type === "tree_navigate" && request.abortRunning)) {
+                reply("busy");
+                return;
+            }
+            if (request.type !== "session_reopen")
+                validate();
+            this.operation = true;
+            ownsOperation = true;
+            this.host.changed();
+            if (request.type === "session_reopen") {
+                if (!session.sessionFile)
+                    throw new Error("Session file is not available");
+                const result = await this.host.runtime().switchSession(session.sessionFile);
+                if (!result.cancelled) {
+                    this.watcher?.close();
+                    this.watchPath = undefined;
+                    this.external = false;
+                    await this.host.replaced();
+                    this.bindFile();
+                }
+                reply(result.cancelled ? "cancelled" : "ok");
+                return;
+            }
+            if (request.type === "tree_navigate") {
+                if (!sm.getEntry(request.targetId))
+                    throw new Error("Entry not found");
+                if (!["none", "default", "custom"].includes(request.summary))
+                    throw new Error("Invalid summary mode");
+                if (!session.isIdle) {
+                    restoredQueue = recallPending(session);
+                    await session.abort(); // SDK abort waits for idle / agent_settled, not agent_end.
+                    await this.validator?.verify(sm); // Validate the final records written by our own abort.
+                    validate();
+                    if (!session.isIdle) {
+                        reply("busy");
+                        return;
+                    }
+                }
+                validate();
+                if (request.summary !== "none")
+                    this.host.summary({ id: randomUUID() });
+                const result = await session.navigateTree(request.targetId, { summarize: request.summary !== "none", customInstructions: request.summary === "custom" ? request.customInstructions?.slice(0, 16000) : undefined, replaceInstructions: request.replaceInstructions, label: request.label?.slice(0, 200) });
+                reply(result.aborted ? "aborted" : result.cancelled ? "cancelled" : "ok", { editorText: result.editorText });
+                return;
+            }
+            const entryId = request.type === "session_clone" ? sm.getLeafId() : request.entryId;
+            if (!entryId || !sm.getEntry(entryId))
+                throw new Error("会话没有可派生的节点。");
+            const position = request.type === "session_clone" ? "at" : request.position;
+            if (position !== "at" && position !== "before")
+                throw new Error("Invalid fork position");
+            const result = await this.host.runtime().fork(entryId, { position });
+            if (!result.cancelled)
+                await this.host.replaced();
+            reply(result.cancelled ? "cancelled" : "ok", { editorText: result.selectedText });
+        }
+        catch (error) {
+            reply("error", { error: error instanceof Error ? error.message : String(error) });
+        }
+        finally {
+            if (ownsOperation) {
+                this.operation = false;
+                this.host.summary(undefined);
+            }
+            this.refresh();
+            this.host.changed();
+        }
+    }
+    dispose() { this.disposed = true; this.validator?.dispose(); this.watcher?.close(); this.watcher = undefined; }
+}

package/dist/server/session-tree.js

@@ -0,0 +1,191 @@
+import { stripVTControlCharacters } from "node:util";
+const settingsTypes = new Set(["label", "context_edit", "custom", "model_change", "thinking_level_change", "session_info"]);
+function text(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content.map(block => block && block.type === "text" && typeof block.text === "string" ? block.text : "").join("");
+}
+/** Matches the pinned CLI's filtering, including exclusions preceding its mode switch. */
+export function treeNodeVisible(node, leafId, filter) {
+    const e = node.entry;
+    if (e.type === "usage")
+        return false;
+    if (e.type === "message" && e.message.role === "assistant" && e.id !== leafId) {
+        const m = e.message;
+        if (!text(m.content).trim() && (!m.stopReason || m.stopReason === "stop" || m.stopReason === "toolUse"))
+            return false;
+    }
+    switch (filter) {
+        case "user-only": return e.type === "message" && e.message.role === "user";
+        case "labeled-only": return node.label !== undefined;
+        case "no-tools": return !settingsTypes.has(e.type) && !(e.type === "message" && e.message.role === "toolResult");
+        case "all": return true;
+        default: return !settingsTypes.has(e.type);
+    }
+}
+/** Search intentionally follows CLI: only the first 200 content characters of messages. */
+export function treeSearchText(node) {
+    const e = node.entry;
+    let body;
+    switch (e.type) {
+        case "message":
+            body = `${e.message.role} ${"content" in e.message ? text(e.message.content).slice(0, 200) : ""} ${e.message.role === "bashExecution" ? e.message.command : ""}`;
+            break;
+        case "custom_message":
+            body = `${e.customType} ${text(e.content).slice(0, 200)}`;
+            break;
+        case "branch_summary":
+            body = `branch summary ${e.summary}`;
+            break;
+        case "compaction":
+            body = "compaction";
+            break;
+        case "model_change":
+            body = `model ${e.modelId}`;
+            break;
+        case "thinking_level_change":
+            body = `thinking ${e.thinkingLevel}`;
+            break;
+        case "session_info":
+            body = `title ${e.name ?? ""}`;
+            break;
+        case "custom":
+            body = `custom ${e.customType}`;
+            break;
+        case "context_edit":
+            body = `context edit ${e.replacement === null ? "omit" : "replace"} ${e.targetId}`;
+            break;
+        case "label":
+            body = `label ${e.label ?? ""}`;
+            break;
+        default: body = "";
+    }
+    return `${node.label ?? ""} ${body}`.toLowerCase();
+}
+export function treeEntryContent(e) {
+    switch (e.type) {
+        case "message": return e.message.role === "bashExecution" ? e.message.command : "content" in e.message ? text(e.message.content) || (e.message.role === "assistant" ? e.message.errorMessage ?? "" : "") : "";
+        case "custom_message": return text(e.content);
+        case "compaction":
+        case "branch_summary": return e.summary;
+        case "model_change": return `${e.provider}/${e.modelId}`;
+        case "thinking_level_change": return e.thinkingLevel;
+        case "session_info": return e.name ?? "";
+        case "label": return e.label ?? "";
+        case "custom": return e.customType;
+        case "context_edit": return `${e.targetId}: ${e.replacement ? text(e.replacement.content) : "omit"}`;
+        case "usage": return e.kind;
+    }
+}
+function kind(e) {
+    if (e.type === "message")
+        return e.message.role === "user" ? "user" : e.message.role === "assistant" ? "assistant" : e.message.role === "toolResult" ? "tool" : "custom";
+    switch (e.type) {
+        case "compaction": return "compaction";
+        case "branch_summary": return "branchSummary";
+        case "context_edit": return "contextEdit";
+        case "model_change": return "model";
+        case "thinking_level_change": return "thinking";
+        case "label": return "label";
+        case "session_info":
+        case "usage": return "info";
+        default: return "custom";
+    }
+}
+/** No persisted tree cache: derive a bounded view and linear-time navigation index. */
+export function projectTree(sm) {
+    const roots = sm.getTree();
+    const leafId = sm.getLeafId();
+    const flat = [];
+    const byId = new Map();
+    const stack = [...roots].reverse();
+    while (stack.length) {
+        const node = stack.pop();
+        if (byId.has(node.entry.id))
+            continue;
+        flat.push(node);
+        byId.set(node.entry.id, node);
+        for (let i = node.children.length - 1; i >= 0; i--)
+            stack.push(node.children[i]);
+    }
+    const active = new Set();
+    for (let id = leafId; id && !active.has(id); id = byId.get(id)?.entry.parentId ?? null)
+        active.add(id);
+    const orderedFlat = [];
+    const order = (nodes) => [...nodes].sort((a, b) => Number(active.has(b.entry.id)) - Number(active.has(a.entry.id)));
+    const orderedStack = order(roots).reverse();
+    while (orderedStack.length) {
+        const node = orderedStack.pop();
+        orderedFlat.push(node);
+        const children = order(node.children);
+        for (let i = children.length - 1; i >= 0; i--)
+            orderedStack.push(children[i]);
+    }
+    const latest = new Map();
+    for (let i = flat.length - 1; i >= 0; i--) {
+        const node = flat[i];
+        let best = node;
+        for (const child of node.children) {
+            const candidate = latest.get(child.entry.id) ?? child;
+            if (best === node || candidate.entry.timestamp >= best.entry.timestamp)
+                best = candidate;
+        }
+        latest.set(node.entry.id, best);
+    }
+    const branchPoints = flat.filter(n => n.children.length > 1).length;
+    const siblingMap = new Map();
+    for (const group of [roots, ...flat.map(n => n.children)]) {
+        const peers = group.filter(n => treeNodeVisible(n, leafId, "default"));
+        if (peers.length < 2)
+            continue;
+        peers.forEach((node, i) => siblingMap.set(node.entry.id, { index: i + 1, count: peers.length, prevTarget: i > 0 ? latest.get(peers[i - 1].entry.id)?.entry.id : undefined, nextTarget: i + 1 < peers.length ? latest.get(peers[i + 1].entry.id)?.entry.id : undefined }));
+    }
+    const siblings = (entryId) => siblingMap.get(entryId);
+    function view(filter = "default", query = "", limit = 5000) {
+        const tokens = query.toLowerCase().split(/\s+/).filter(Boolean);
+        const visible = new Map();
+        const nodes = [];
+        let truncated = false;
+        for (const node of orderedFlat) {
+            const e = node.entry;
+            const parent = e.parentId ? visible.get(e.parentId) : undefined;
+            const rootId = parent?.root ?? e.id;
+            if (!treeNodeVisible(node, leafId, filter) || !tokens.every(token => treeSearchText(node).includes(token))) {
+                visible.set(e.id, { id: parent?.id ?? null, depth: parent?.depth ?? -1, root: rootId });
+                continue;
+            }
+            const depth = (parent?.depth ?? -1) + 1;
+            visible.set(e.id, { id: e.id, depth, root: rootId });
+            if (nodes.length >= limit) {
+                truncated = true;
+                continue;
+            }
+            const m = e.type === "message" ? e.message : undefined;
+            nodes.push({ id: e.id, parentId: e.parentId, visibleParentId: parent?.id ?? null, depth, rootId, kind: kind(e), preview: stripVTControlCharacters(treeEntryContent(e)).replace(/\s+/g, " ").slice(0, 120), timestamp: Date.parse(e.timestamp), label: node.label, onActivePath: active.has(e.id), isLeaf: e.id === leafId, childCount: node.children.length, toolName: m?.role === "toolResult" ? m.toolName : undefined, model: m?.role === "assistant" ? m.model : e.type === "model_change" ? e.modelId : undefined, stopReason: m?.role === "assistant" && (m.stopReason === "error" || m.stopReason === "aborted") ? m.stopReason : undefined, summaryFromId: e.type === "branch_summary" ? e.fromId : undefined });
+        }
+        const childCounts = new Map();
+        for (const n of nodes)
+            childCounts.set(n.visibleParentId, (childCounts.get(n.visibleParentId) ?? 0) + 1);
+        const layout = new Map();
+        const multipleRoots = (childCounts.get(null) ?? 0) > 1;
+        for (const n of nodes) {
+            const parent = n.visibleParentId ? layout.get(n.visibleParentId) : undefined;
+            const justBranched = (childCounts.get(n.visibleParentId) ?? 0) > 1;
+            const indent = parent
+                ? parent.indent + (justBranched || (parent.justBranched && parent.indent > 0) ? 1 : 0)
+                : multipleRoots ? 1 : 0;
+            layout.set(n.id, { indent, justBranched });
+            n.depth = multipleRoots ? Math.max(0, indent - 1) : indent;
+        }
+        return { nodes, truncated };
+    }
+    return { branchPoints, rootCount: roots.length, leafId, siblings, view };
+}
+export function treeRevision(sm) {
+    // Every label change appends an entry, including clears and replacements.
+    return `${sm.getSessionId()}:${sm.getEntryCount()}:${sm.getLeafId() ?? "root"}`;
+}
+export function toUiTree(sm, filter = "default", query = "") { return projectTree(sm).view(filter, query); }
+export function siblingInfo(sm, entryId) { return projectTree(sm).siblings(entryId); }

package/dist/server/settings-service.js

@@ -0,0 +1,53 @@
+import { extensionKey } from "./client-state.js";
+import { extensionDisplay } from "./extension-display.js";
+export class SettingsService {
+    host;
+    settings;
+    pendingReload = false;
+    constructor(host) {
+        this.host = host;
+        this.settings = host.stateStore.getSettings(host.clientId);
+    }
+    get current() { return this.settings; }
+    hasPendingReload() { return this.pendingReload; }
+    consumePendingReload() { const pending = this.pendingReload; this.pendingReload = false; return pending; }
+    push() {
+        let skills = [];
+        let extensions = [];
+        try {
+            const loader = this.host.getSession().resourceLoader;
+            skills = loader.getSkills().skills.map(skill => ({ name: skill.name, description: skill.description, enabled: true }));
+            extensions = loader.getExtensions().extensions.filter(extension => !extension.hidden).map(extension => {
+                const path = extension.sourceInfo?.path ?? extension.path;
+                return { id: extensionKey(extension), ...extensionDisplay(path, extension.sourceInfo?.origin === "package" ? extension.sourceInfo.source : undefined), path, enabled: true };
+            });
+        }
+        catch { /* The first session may still be attaching. */ }
+        this.host.emit({ type: "settings_state", settings: {
+                editResendNewSession: this.settings.editResendNewSession ?? false,
+                thinkingWrap: this.settings.thinkingWrap,
+                toolsWrap: this.settings.toolsWrap,
+                disabledPlugins: this.settings.disabledPlugins ?? [],
+                effectiveSystemPrompt: this.host.effectiveSystemPrompt(),
+                skills,
+                extensions,
+            } });
+    }
+    async set(partial) {
+        this.host.stateStore.saveSettings(this.host.clientId, partial);
+        this.settings = this.host.stateStore.getSettings(this.host.clientId);
+        this.push();
+        this.host.flushSnapshot();
+    }
+    async applyRuntime() {
+        if (this.host.isStreaming()) {
+            this.pendingReload = true;
+            return;
+        }
+        await this.host.reloadSession();
+        if (this.host.isDisposed())
+            return;
+        this.push();
+        this.host.flushSnapshot();
+    }
+}

package/dist/server/skills-service.js

@@ -0,0 +1,87 @@
+import { createHash } from "node:crypto";
+import { join, relative, dirname, basename } from "node:path";
+import { homedir } from "node:os";
+import { DefaultPackageManager, SettingsManager, ProjectTrustStore, loadSkills } from "@earendil-works/pi-coding-agent";
+import { settingsVersion, sourceOf } from "./extensions-model.js";
+/** Discover native resources without loading extension entry points or installing dependencies. */
+export async function nativeSkills(cwd, agentDir, change, valid = () => true) {
+    const trusted = new ProjectTrustStore(agentDir).get(cwd) === true;
+    const settings = SettingsManager.create(cwd, agentDir, { projectTrusted: trusted });
+    const fail = () => { const errors = settings.drainErrors(); if (errors.length)
+        throw Error(errors.map(e => e.error.message).join("\n")); };
+    fail();
+    const version = settingsVersion(cwd, agentDir);
+    const manager = new DefaultPackageManager({ cwd, agentDir, settingsManager: settings });
+    const resources = (await manager.resolve(async () => "skip")).skills;
+    const entries = resources.flatMap(resource => {
+        const loaded = loadSkills({ cwd, agentDir, includeDefaults: false, skillPaths: [resource.path] }).skills;
+        return loaded.map(skill => ({ resource, skill, id: createHash("sha256").update(`${resource.metadata.scope}:${resource.metadata.source}:${resource.path}:${skill.filePath}`).digest("hex") }));
+    });
+    if (change) {
+        if (!valid())
+            throw Error("Workspace changed");
+        if (change.version !== version || version !== settingsVersion(cwd, agentDir))
+            throw Error("Pi settings changed; refresh before applying changes");
+        const target = entries.find(entry => entry.id === change.id);
+        if (!target || target.resource.metadata.scope === "temporary")
+            throw Error("Skill unavailable");
+        const { path, metadata } = target.resource;
+        const project = metadata.scope === "project";
+        if (project && !trusted)
+            throw Error("Project is not trusted");
+        // A toggle must never affect multiple skills discovered from one custom directory.
+        if (entries.filter(entry => entry.resource === target.resource).length !== 1)
+            throw Error("Manage this shared skill directory in native settings");
+        const config = project ? settings.getProjectSettings() : settings.getGlobalSettings();
+        const base = (resource) => resource.metadata.packageRoot ?? resource.metadata.baseDir ?? (project ? join(cwd, ".pi") : agentDir);
+        const matches = (pattern, resource) => {
+            const normalized = pattern.slice(1).replace(/^\.[\\/]/, "").replaceAll("\\", "/");
+            const paths = [resource.path, relative(base(resource), resource.path)];
+            if (basename(resource.path) === "SKILL.md")
+                paths.push(dirname(resource.path), relative(base(resource), dirname(resource.path)));
+            return paths.some(value => value.replaceAll("\\", "/") === normalized);
+        };
+        const override = (patterns) => {
+            const removed = patterns.filter(p => /^[+-]/.test(p) && matches(p, target.resource));
+            const retained = patterns.filter(p => !removed.includes(p));
+            for (const resource of resources) {
+                if (resource === target.resource || resource.metadata.scope !== metadata.scope || resource.metadata.origin !== metadata.origin || metadata.origin === "package" && resource.metadata.source !== metadata.source)
+                    continue;
+                for (const pattern of removed)
+                    if (matches(pattern, resource))
+                        retained.push(`${pattern[0]}${resource.path}`);
+            }
+            return [...retained, `${change.enabled ? "+" : "-"}${path}`];
+        };
+        if (metadata.origin === "package") {
+            const packages = [...(config.packages ?? [])];
+            const index = packages.findIndex(entry => sourceOf(entry) === metadata.source);
+            if (index < 0)
+                throw Error("Package no longer configured");
+            const entry = packages[index];
+            const declaration = typeof entry === "string" ? { source: entry } : entry;
+            // [] means none, unlike an absent filter. Preserve that baseline when enabling one.
+            const patterns = declaration.skills?.length === 0 && declaration.autoload !== false ? ["!**"] : declaration.skills ?? [];
+            packages[index] = { ...declaration, skills: override(patterns) };
+            if (project)
+                settings.setProjectPackages(packages);
+            else
+                settings.setPackages(packages);
+        }
+        else {
+            const paths = override(config.skills ?? []);
+            if (project)
+                settings.setProjectSkillPaths(paths);
+            else
+                settings.setSkillPaths(paths);
+        }
+        await settings.flush();
+        fail();
+        return nativeSkills(cwd, agentDir);
+    }
+    return {
+        version,
+        paths: [...new Set([join(agentDir, "skills"), join(homedir(), ".agents/skills"), join(cwd, ".pi/skills"), ...resources.map(r => r.metadata.packageRoot).filter((path) => !!path)])],
+        skills: entries.map(({ id, skill, resource }) => ({ id, name: skill.name, description: skill.description, path: skill.filePath, enabled: resource.enabled, source: resource.metadata.origin === "package" ? "package" : resource.metadata.scope, scope: resource.metadata.scope, canToggle: resource.metadata.scope !== "temporary" && entries.filter(e => e.resource === resource).length === 1, promptVisible: !skill.disableModelInvocation })),
+    };
+}