terminal-pilot 0.0.19 → 0.0.21

package/node_modules/@poe-code/agent-skill-config/README.md

@@ -0,0 +1,103 @@
+# @poe-code/agent-skill-config
+
+`@poe-code/agent-skill-config` resolves skill references for CLI, SDK, pipeline, and ralph configs, installs declarative skill folders into native agent skill directories, and bridges active skills into the spawning agent at runtime.
+
+## Skill References
+
+Skill refs use one of two forms:
+
+```text
+"<name>"              # bare: poe-code-native skill
+"<agentId>/<name>"    # agent-prefixed: agent-native skill
+```
+
+Examples:
+
+| Ref | Source |
+|-----|--------|
+| `"my-helper"` | `~/.poe-code/skills/my-helper` or `<cwd>/.poe-code/skills/my-helper` |
+| `"claude/my-helper"` | `~/.claude/skills/my-helper` alias for `claude-code` |
+| `"claude-code/my-helper"` | `~/.claude/skills/my-helper` canonical id |
+| `"codex/my-helper"` | `~/.codex/skills/my-helper` |
+
+The agent token accepts canonical ids, aliases, and any casing. It is normalized with `resolveAgentId` from `@poe-code/agent-defs`. The token is not the source agent's native directory name; the source path always comes from `agentSkillConfigs[canonicalId]`, so aliases map to the directory owned by that canonical agent.
+
+## Resolution
+
+Resolution is per ref. Project scope beats user scope; first hit wins.
+
+Bare `<name>`:
+
+1. `<cwd>/.poe-code/skills/<name>`
+2. `~/.poe-code/skills/<name>`
+
+Prefixed `<agentId>/<name>`:
+
+1. `<cwd>/<agentId-local-skill-dir>/<name>`, for example `<cwd>/.claude/skills/<name>`
+2. `~/<agentId-global-skill-dir>/<name>`, for example `~/.claude/skills/<name>`
+
+Per-agent skill directories come from `agentSkillConfigs` in `configs.ts`; resolvers do not hard-code native agent paths.
+
+## Bridge Contract
+
+At spawn time, `bridgeActiveSkills(spawnAgentId, cwd, refs, homeDir, runId)` resolves every ref, then copies each resolved source folder into the spawning agent's native local skill directory under `cwd`, keyed by source basename:
+
+```text
+<cwd>/<spawn-agent-local-skill-dir>/<source-basename>
+```
+
+The source ref's agent prefix never appears in the target path. For a Claude Code spawn, both `"codex/my-helper"` and `"my-helper"` target `.claude/skills/my-helper`.
+
+Resolution failures abort the whole bridge before any copy. Error messages distinguish:
+
+| Kind | Meaning |
+|------|---------|
+| `malformed` | Bad syntax; expected `"<name>"` or `"<agentId>/<name>"`. |
+| `unknown-agent` | Agent token does not resolve to a supported agent; the error lists supported agents. |
+| `not-found` | No skill folder exists at any tier; the error lists searched paths in order. |
+
+Collisions never abort. The bridge emits one `BridgeWarning` per skipped ref, leaves no state for that ref, and continues the batch.
+
+| Warning kind | Skip condition |
+|--------------|----------------|
+| `local-collision` | Target folder already exists in the spawning agent's local skill dir. |
+| `global-collision` | Target folder already exists in the spawning agent's global skill dir. |
+| `self-reference` | The spawning agent references its own native skill. |
+| `intra-batch-collision` | Two refs produce the same target basename; first input ref wins. |
+
+Native skills are never overwritten. Callers, including the spawn runner, surface `manifest.warnings` through the design-system warning channel before launching the agent.
+
+`cleanupBridgedSkills(manifest)` removes only bridge-created targets and empty parent directories recorded in the manifest. It is idempotent.
+
+When bridge creates entries inside a git repository, `.git/info/exclude` gets a per-run marked block containing only successfully bridged target entries. Cleanup removes only that run's marked block.
+
+## Public API
+
+```ts
+import {
+  bridgeActiveSkills,
+  cleanupBridgedSkills,
+  resolveSkillReference,
+  configure,
+  unconfigure,
+  installSkill,
+  resolveAgentSupport,
+  getAgentConfig,
+  resolveSkillDir,
+  supportedAgents,
+} from "@poe-code/agent-skill-config";
+```
+
+Exported types include `AgentSkillConfig`, `AgentSupportResult`, `SkillScope`, `SkillResolution`, `SkillResolutionFailure`, `SkillSource`, `BridgeEntry`, `BridgeManifest`, `BridgeWarning`, `BridgeWarningKind`, `ApplyOptions`, `SkillFile`, `InstallSkillOptions`, and `InstallSkillResult`.
+
+`agentSkillConfigs` is internal and is not exported.
+
+## Config Options
+
+This package exposes no user-facing config options.
+
+Internal agent skill config has two fields: `localSkillDir` and `globalSkillDir`. Callers can read supported resolved config through `resolveAgentSupport()` or `getAgentConfig()`, and can turn a resolved config into an absolute path with `resolveSkillDir()`.
+
+## Environment Variables
+
+This package exposes no public environment variables.

package/node_modules/@poe-code/agent-skill-config/dist/apply.d.ts

@@ -0,0 +1,25 @@
+import type { ApplyOptions, SkillFile } from "./types.js";
+export declare class UnsupportedAgentError extends Error {
+    constructor(agentId: string);
+}
+export declare function configure(agentId: string, options: ApplyOptions): Promise<void>;
+export declare function unconfigure(agentId: string, options: ApplyOptions & {
+    force?: boolean;
+}): Promise<void>;
+export type InstallSkillOptions = {
+    fs: ApplyOptions["fs"];
+    cwd: string;
+    homeDir: string;
+    scope: ApplyOptions["scope"];
+    dryRun?: boolean;
+    observers?: ApplyOptions["observers"];
+};
+export type InstallSkillResult = {
+    skillPath: string;
+    displayPath: string;
+};
+/**
+ * Install a skill for an agent.
+ * Creates folder structure: skillDir/<skill.name>/SKILL.md
+ */
+export declare function installSkill(agentId: string, skill: SkillFile, options: InstallSkillOptions): Promise<InstallSkillResult>;

package/node_modules/@poe-code/agent-skill-config/dist/apply.js

@@ -0,0 +1,159 @@
+import { fileMutation, runMutations, templateMutation } from "@poe-code/config-mutations";
+import { resolveAgentSupport } from "./configs.js";
+import { createTemplateLoader } from "./templates.js";
+export class UnsupportedAgentError extends Error {
+    constructor(agentId) {
+        super(`Unsupported agent: ${agentId}`);
+        this.name = "UnsupportedAgentError";
+    }
+}
+function toHomeRelative(localSkillDir) {
+    if (localSkillDir.startsWith("~/") || localSkillDir === "~") {
+        return localSkillDir;
+    }
+    const normalized = localSkillDir.startsWith("./")
+        ? localSkillDir.slice(2)
+        : localSkillDir;
+    return `~/${normalized}`;
+}
+const bundledSkillTemplateIds = ["poe-generate.md"];
+async function pathExists(fs, targetPath) {
+    try {
+        await fs.stat(targetPath);
+        return true;
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+export async function configure(agentId, options) {
+    const support = resolveAgentSupport(agentId);
+    if (support.status !== "supported") {
+        throw new UnsupportedAgentError(agentId);
+    }
+    const scope = options.scope ?? "global";
+    const config = support.config;
+    const skillDir = scope === "global" ? config.globalSkillDir : toHomeRelative(config.localSkillDir);
+    const homeDir = scope === "global" ? options.homeDir : options.cwd;
+    const templateLoader = createTemplateLoader();
+    for (const templateId of bundledSkillTemplateIds) {
+        const targetPath = `${scope === "global" ? options.homeDir : options.cwd}/${skillDir.slice(2)}/${templateId}`;
+        if (await pathExists(options.fs, targetPath)) {
+            const existing = await options.fs.readFile(targetPath, "utf8");
+            if (existing !== (await templateLoader(templateId))) {
+                throw new Error(`Skill already exists: ${targetPath}`);
+            }
+        }
+    }
+    await runMutations([
+        fileMutation.ensureDirectory({
+            path: skillDir,
+            label: `Ensure directory ${skillDir}`
+        }),
+        ...bundledSkillTemplateIds.map((templateId) => templateMutation.write({
+            target: `${skillDir}/${templateId}`,
+            templateId,
+            label: `Write bundled skill ${templateId} to ${skillDir}`
+        }))
+    ], {
+        fs: options.fs,
+        homeDir,
+        dryRun: options.dryRun,
+        observers: options.observers,
+        templates: templateLoader
+    });
+}
+export async function unconfigure(agentId, options) {
+    const support = resolveAgentSupport(agentId);
+    if (support.status !== "supported") {
+        throw new UnsupportedAgentError(agentId);
+    }
+    const scope = options.scope ?? "global";
+    const config = support.config;
+    const skillDir = scope === "global" ? config.globalSkillDir : toHomeRelative(config.localSkillDir);
+    const homeDir = scope === "global" ? options.homeDir : options.cwd;
+    const templateLoader = createTemplateLoader();
+    const removeBundledSkills = [];
+    for (const templateId of bundledSkillTemplateIds) {
+        const targetPath = `${scope === "global" ? options.homeDir : options.cwd}/${skillDir.slice(2)}/${templateId}`;
+        if (await pathExists(options.fs, targetPath)) {
+            const existing = await options.fs.readFile(targetPath, "utf8");
+            if (existing === (await templateLoader(templateId))) {
+                removeBundledSkills.push(fileMutation.remove({
+                    target: `${skillDir}/${templateId}`,
+                    label: `Remove bundled skill ${templateId} from ${skillDir}`
+                }));
+            }
+        }
+    }
+    await runMutations([
+        ...removeBundledSkills,
+        fileMutation.removeDirectory({
+            path: skillDir,
+            force: options.force,
+            label: `Remove skills directory ${skillDir}`
+        })
+    ], {
+        fs: options.fs,
+        homeDir,
+        dryRun: options.dryRun,
+        observers: options.observers
+    });
+}
+const SKILL_TEMPLATE_ID = "__skill_content__";
+/**
+ * Install a skill for an agent.
+ * Creates folder structure: skillDir/<skill.name>/SKILL.md
+ */
+export async function installSkill(agentId, skill, options) {
+    const support = resolveAgentSupport(agentId);
+    if (support.status !== "supported") {
+        throw new UnsupportedAgentError(agentId);
+    }
+    const scope = options.scope ?? "local";
+    const config = support.config;
+    if (skill.name.length === 0 ||
+        skill.name === "." ||
+        skill.name === ".." ||
+        skill.name.includes("/") ||
+        skill.name.includes("\\") ||
+        skill.name.includes("\n") ||
+        skill.name.includes("\r")) {
+        throw new Error(`Invalid skill name: ${skill.name}`);
+    }
+    // Use home-relative paths for mutations (same pattern as configure/unconfigure)
+    const skillDir = scope === "global" ? config.globalSkillDir : toHomeRelative(config.localSkillDir);
+    const skillFolderPath = `${skillDir}/${skill.name}`;
+    const skillFilePath = `${skillFolderPath}/SKILL.md`;
+    const displayPath = `${scope === "global" ? config.globalSkillDir : config.localSkillDir}/${skill.name}/SKILL.md`;
+    const absoluteSkillPath = `${scope === "global" ? options.homeDir : options.cwd}/${skillFilePath.slice(2)}`;
+    if (await pathExists(options.fs, absoluteSkillPath)) {
+        throw new Error(`Skill already exists: ${displayPath}`);
+    }
+    await runMutations([
+        fileMutation.ensureDirectory({
+            path: skillFolderPath,
+            label: `Ensure skill directory ${skill.name}`
+        }),
+        templateMutation.write({
+            target: skillFilePath,
+            templateId: SKILL_TEMPLATE_ID,
+            label: `Write skill ${skill.name}`
+        })
+    ], {
+        fs: options.fs,
+        homeDir: scope === "global" ? options.homeDir : options.cwd,
+        dryRun: options.dryRun,
+        observers: options.observers,
+        templates: async (templateId) => {
+            if (templateId === SKILL_TEMPLATE_ID) {
+                return skill.content;
+            }
+            throw new Error(`Unknown template: ${templateId}`);
+        }
+    });
+    return { skillPath: skillFilePath, displayPath };
+}

package/node_modules/@poe-code/agent-skill-config/dist/bridge-active-skills.d.ts

@@ -0,0 +1,23 @@
+export interface BridgeEntry {
+    ref: string;
+    sourcePath: string;
+    targetPath: string;
+    createdParents: string[];
+}
+export type BridgeWarningKind = "local-collision" | "global-collision" | "self-reference" | "intra-batch-collision";
+export interface BridgeWarning {
+    kind: BridgeWarningKind;
+    ref: string;
+    sourcePath: string;
+    conflictingPath: string;
+    message: string;
+}
+export interface BridgeManifest {
+    spawnAgentId: string;
+    cwd: string;
+    runId: string;
+    entries: BridgeEntry[];
+    warnings: BridgeWarning[];
+}
+export declare function bridgeActiveSkills(spawnAgentId: string, cwd: string, refs: string[], homeDir: string, runId: string): BridgeManifest;
+export declare function cleanupBridgedSkills(manifest: BridgeManifest): void;

package/node_modules/@poe-code/agent-skill-config/dist/bridge-active-skills.js

@@ -0,0 +1,341 @@
+import * as fs from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import path from "node:path";
+import { getAgentConfig, resolveAgentSupport, resolveSkillDir, supportedAgents } from "./configs.js";
+import { appendExcludeBlock, removeExcludeBlock } from "./git-exclude.js";
+import { resolveSkillReference } from "./resolve-skill-reference.js";
+const activeTargets = new Map();
+const manifestStates = new WeakMap();
+const ownershipFileName = ".poe-code-bridge-owner";
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}
+function pathExists(targetPath) {
+    try {
+        fs.statSync(targetPath);
+        return true;
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+function assertNoSymbolicLink(targetPath) {
+    const parsed = path.parse(path.resolve(targetPath));
+    let current = parsed.root;
+    for (const segment of path.resolve(targetPath).slice(parsed.root.length).split(path.sep)) {
+        if (segment.length === 0) {
+            continue;
+        }
+        current = path.join(current, segment);
+        try {
+            if (fs.lstatSync(current).isSymbolicLink()) {
+                throw new Error(`Refusing to bridge skills through symbolic link: ${current}`);
+            }
+        }
+        catch (error) {
+            if (isNodeError(error) && error.code === "ENOENT") {
+                return;
+            }
+            throw error;
+        }
+    }
+}
+function isDirectory(targetPath) {
+    try {
+        return fs.statSync(targetPath).isDirectory();
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+function formatResolutionFailureError(failures) {
+    const malformed = failures.filter((failure) => failure.kind === "malformed");
+    const unknownAgent = failures.filter((failure) => failure.kind === "unknown-agent");
+    const notFound = failures.filter((failure) => failure.kind === "not-found");
+    const lines = [
+        `Failed to bridge active skills: ${failures.length} skill reference(s) could not be resolved.`
+    ];
+    if (malformed.length > 0) {
+        lines.push("", "Malformed skill references:");
+        for (const failure of malformed) {
+            lines.push(`- ${failure.ref}`);
+        }
+        lines.push('Expected syntax: "<name>" or "<agentId>/<name>".');
+    }
+    if (unknownAgent.length > 0) {
+        lines.push("", "Unknown agent references:");
+        for (const failure of unknownAgent) {
+            lines.push(`- ${failure.ref} (agent token: ${failure.agentInput})`);
+        }
+        lines.push(`Supported agents: ${supportedAgents.join(", ")}.`);
+    }
+    if (notFound.length > 0) {
+        lines.push("", "Not found skill references.");
+        for (const failure of notFound) {
+            lines.push(`- ${failure.ref}`);
+            lines.push("  searched paths:");
+            for (const searchedPath of failure.searchedPaths) {
+                lines.push(`  - ${searchedPath}`);
+            }
+        }
+    }
+    return new Error(lines.join("\n"));
+}
+function copyDirectory(sourcePath, targetPath) {
+    assertNoSymbolicLink(sourcePath);
+    fs.mkdirSync(targetPath, { recursive: true });
+    for (const dirent of fs.readdirSync(sourcePath, { withFileTypes: true })) {
+        const childSource = path.join(sourcePath, dirent.name);
+        const childTarget = path.join(targetPath, dirent.name);
+        if (dirent.isSymbolicLink()) {
+            throw new Error(`Refusing to bridge skill containing symbolic link: ${childSource}`);
+        }
+        if (dirent.isDirectory()) {
+            copyDirectory(childSource, childTarget);
+            continue;
+        }
+        if (dirent.isFile()) {
+            fs.copyFileSync(childSource, childTarget);
+        }
+    }
+}
+function directoryFingerprint(targetPath) {
+    const hash = createHash("sha256");
+    function visit(currentPath, relativePath) {
+        const stats = fs.lstatSync(currentPath);
+        if (stats.isSymbolicLink()) {
+            throw new Error(`Refusing to inspect bridged skill through symbolic link: ${currentPath}`);
+        }
+        if (stats.isDirectory()) {
+            hash.update(`d:${relativePath}\n`);
+            for (const name of fs.readdirSync(currentPath).sort()) {
+                visit(path.join(currentPath, name), path.join(relativePath, name));
+            }
+            return;
+        }
+        if (stats.isFile()) {
+            hash.update(`f:${relativePath}\n`);
+            hash.update(fs.readFileSync(currentPath));
+            return;
+        }
+        throw new Error(`Refusing to bridge unsupported filesystem entry: ${currentPath}`);
+    }
+    visit(targetPath, ".");
+    return hash.digest("hex");
+}
+function ownershipPath(targetPath) {
+    return path.join(targetPath, ownershipFileName);
+}
+function hasOwnershipToken(targetPath, token) {
+    try {
+        return fs.readFileSync(ownershipPath(targetPath), "utf8") === token;
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+function collectMissingParents(targetPath) {
+    const parents = [];
+    let current = path.dirname(targetPath);
+    while (!pathExists(current)) {
+        parents.push(current);
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return parents.reverse();
+}
+function removeDirectoryIfEmpty(targetPath) {
+    try {
+        fs.rmdirSync(targetPath);
+    }
+    catch (error) {
+        if (isNodeError(error) &&
+            (error.code === "ENOENT" || error.code === "ENOTEMPTY" || error.code === "EEXIST")) {
+            return;
+        }
+        throw error;
+    }
+}
+function removeTarget(targetPath) {
+    fs.rmSync(targetPath, { recursive: true, force: true });
+}
+function rollbackEntries(entries) {
+    for (const entry of [...entries].reverse()) {
+        const activeTarget = activeTargets.get(entry.targetPath);
+        if (activeTarget && activeTarget.references > 1) {
+            activeTarget.references -= 1;
+            continue;
+        }
+        activeTargets.delete(entry.targetPath);
+        removeTarget(entry.targetPath);
+        for (const parent of [...(activeTarget?.createdParents ?? entry.createdParents)].reverse()) {
+            removeDirectoryIfEmpty(parent);
+        }
+    }
+}
+function toCwdRelative(cwd, targetPath) {
+    return path.relative(cwd, targetPath);
+}
+function warning(kind, ref, sourcePath, conflictingPath) {
+    const messages = {
+        "intra-batch-collision": `Skipping ${ref}: an earlier bridged skill already targets ${conflictingPath}.`,
+        "local-collision": `Skipping ${ref}: local skill already exists at ${conflictingPath}.`,
+        "global-collision": `Skipping ${ref}: global skill already exists at ${conflictingPath}.`,
+        "self-reference": `Skipping ${ref}: spawning agent already sees this native skill at ${conflictingPath}.`
+    };
+    return {
+        kind,
+        ref,
+        sourcePath,
+        conflictingPath,
+        message: messages[kind]
+    };
+}
+export function bridgeActiveSkills(spawnAgentId, cwd, refs, homeDir, runId) {
+    const spawnConfig = getAgentConfig(spawnAgentId);
+    const spawnSupport = resolveAgentSupport(spawnAgentId);
+    if (!spawnConfig || spawnSupport.status !== "supported" || !spawnSupport.id) {
+        throw new Error(`Unsupported spawn agent "${spawnAgentId}". Supported agents: ${supportedAgents.join(", ")}.`);
+    }
+    const targetDir = resolveSkillDir(spawnConfig, "local", cwd);
+    const globalTargetDir = resolveSkillDir(spawnConfig, "global", cwd, homeDir);
+    const resolutions = refs.map((ref) => resolveSkillReference(ref, cwd, homeDir));
+    const failures = resolutions.filter((resolution) => resolution.kind !== "resolved");
+    if (failures.length > 0) {
+        throw formatResolutionFailureError(failures);
+    }
+    const sources = resolutions.map((source, index) => ({
+        ref: refs[index],
+        source: source,
+        targetPath: path.resolve(targetDir, source.name),
+        globalTargetPath: path.resolve(globalTargetDir, source.name)
+    }));
+    const entries = [];
+    const warnings = [];
+    const claimedTargets = new Set();
+    try {
+        for (const item of sources) {
+            if (claimedTargets.has(item.targetPath)) {
+                warnings.push(warning("intra-batch-collision", item.ref, item.source.sourcePath, item.targetPath));
+                continue;
+            }
+            if (item.source.sourceAgentId === spawnSupport.id) {
+                warnings.push(warning("self-reference", item.ref, item.source.sourcePath, item.source.sourcePath));
+                continue;
+            }
+            const activeTarget = activeTargets.get(item.targetPath);
+            if (activeTarget && pathExists(item.targetPath)) {
+                if (activeTarget.sourcePath === item.source.sourcePath &&
+                    hasOwnershipToken(item.targetPath, activeTarget.token) &&
+                    directoryFingerprint(item.targetPath) === activeTarget.fingerprint) {
+                    activeTarget.references += 1;
+                    claimedTargets.add(item.targetPath);
+                    entries.push({
+                        ref: item.ref,
+                        sourcePath: item.source.sourcePath,
+                        targetPath: item.targetPath,
+                        createdParents: []
+                    });
+                    continue;
+                }
+                activeTargets.delete(item.targetPath);
+            }
+            if (pathExists(item.targetPath)) {
+                warnings.push(warning("local-collision", item.ref, item.source.sourcePath, item.targetPath));
+                continue;
+            }
+            if (isDirectory(item.globalTargetPath)) {
+                warnings.push(warning("global-collision", item.ref, item.source.sourcePath, item.globalTargetPath));
+                continue;
+            }
+            const createdParents = collectMissingParents(item.targetPath);
+            assertNoSymbolicLink(path.dirname(item.targetPath));
+            fs.mkdirSync(path.dirname(item.targetPath), { recursive: true });
+            const token = randomUUID();
+            try {
+                copyDirectory(item.source.sourcePath, item.targetPath);
+                fs.writeFileSync(ownershipPath(item.targetPath), token, "utf8");
+                const fingerprint = directoryFingerprint(item.targetPath);
+                claimedTargets.add(item.targetPath);
+                entries.push({
+                    ref: item.ref,
+                    sourcePath: item.source.sourcePath,
+                    targetPath: item.targetPath,
+                    createdParents
+                });
+                activeTargets.set(item.targetPath, {
+                    createdParents,
+                    fingerprint,
+                    sourcePath: item.source.sourcePath,
+                    references: 1,
+                    token
+                });
+            }
+            catch (error) {
+                removeTarget(item.targetPath);
+                for (const parent of [...createdParents].reverse()) {
+                    removeDirectoryIfEmpty(parent);
+                }
+                throw error;
+            }
+        }
+        let excludeBlockId;
+        if (entries.length > 0) {
+            excludeBlockId = appendExcludeBlock(cwd, runId, entries.map((entry) => toCwdRelative(cwd, entry.targetPath)));
+        }
+        const manifest = {
+            spawnAgentId,
+            cwd,
+            runId,
+            entries,
+            warnings
+        };
+        manifestStates.set(manifest, { excludeBlockId });
+        return manifest;
+    }
+    catch (error) {
+        rollbackEntries(entries);
+        throw error;
+    }
+}
+export function cleanupBridgedSkills(manifest) {
+    const state = manifestStates.get(manifest);
+    if (state?.cleaned) {
+        return;
+    }
+    removeExcludeBlock(manifest.cwd, state?.excludeBlockId ?? manifest.runId);
+    for (const entry of manifest.entries) {
+        const activeTarget = activeTargets.get(entry.targetPath);
+        if (!activeTarget) {
+            continue;
+        }
+        if (activeTarget.references > 1) {
+            activeTarget.references -= 1;
+            continue;
+        }
+        activeTargets.delete(entry.targetPath);
+        if (pathExists(entry.targetPath) &&
+            hasOwnershipToken(entry.targetPath, activeTarget.token) &&
+            directoryFingerprint(entry.targetPath) === activeTarget.fingerprint) {
+            removeTarget(entry.targetPath);
+            for (const parent of [...activeTarget.createdParents].reverse()) {
+                removeDirectoryIfEmpty(parent);
+            }
+        }
+    }
+    if (state) {
+        state.cleaned = true;
+    }
+}

package/node_modules/@poe-code/agent-skill-config/dist/configs.d.ts

@@ -0,0 +1,16 @@
+export interface AgentSkillConfig {
+    globalSkillDir: string;
+    localSkillDir: string;
+}
+export type SkillScope = "global" | "local";
+export declare const supportedAgents: readonly string[];
+export type AgentSupportStatus = "supported" | "unsupported" | "unknown";
+export interface AgentSupportResult {
+    status: AgentSupportStatus;
+    input: string;
+    id?: string;
+    config?: AgentSkillConfig;
+}
+export declare function resolveAgentSupport(input: string, registry?: Record<string, AgentSkillConfig>): AgentSupportResult;
+export declare function getAgentConfig(agentId: string): AgentSkillConfig | undefined;
+export declare function resolveSkillDir(config: AgentSkillConfig, scope: SkillScope, cwd: string, homeDir?: string): string;