qlogicagent 2.13.3 → 2.13.5

package/dist/runtime/infra/mcp-bridge.js

@@ -0,0 +1,161 @@
+/**
+ * MCP Bridge — exports qlogicagent tools as MCP (Model Context Protocol) servers
+ * for injection into external ACP agent sessions.
+ *
+ * When an ACP agent's session is created, we inject MCP servers that expose
+ * qlogicagent's native tools (media_generate, memory_*, web_search, etc.)
+ * so external agents can call them.
+ *
+ * Architecture:
+ *   qlogicagent ─── ACP ───→ external agent
+ *       └── MCP bridge server ◄── tools/call ── external agent
+ *
+ * The bridge server runs as a stdio child process. Each external agent
+ * session gets its own MCP bridge server instance.
+ */
+import { join } from "node:path";
+// ── Exported Tool Manifest ──────────────────────────────────
+/**
+ * Tools exported via MCP bridge.
+ * These represent qlogicagent capabilities that external agents can call.
+ */
+export const MCP_BRIDGE_TOOLS = [
+    {
+        name: "media_generate",
+        description: "Generate images or videos using AI models.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                prompt: { type: "string", description: "Generation prompt" },
+                type: { type: "string", enum: ["image", "video"], description: "Media type" },
+            },
+            required: ["prompt"],
+        },
+    },
+    {
+        name: "media_status",
+        description: "Check status of an async media generation job.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                jobId: { type: "string", description: "Job ID to check" },
+            },
+            required: ["jobId"],
+        },
+    },
+    {
+        name: "memory_read",
+        description: "Read from persistent memory.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                key: { type: "string", description: "Memory key to read" },
+            },
+            required: ["key"],
+        },
+    },
+    {
+        name: "memory_write",
+        description: "Write to persistent memory.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                key: { type: "string", description: "Memory key" },
+                value: { type: "string", description: "Value to store" },
+            },
+            required: ["key", "value"],
+        },
+    },
+    {
+        name: "memory_search",
+        description: "Search persistent memory by query.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Search query" },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "web_search",
+        description: "Search the web for information.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Search query" },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "web_fetch",
+        description: "Fetch content from a URL.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "URL to fetch" },
+            },
+            required: ["url"],
+        },
+    },
+    {
+        name: "team_status",
+        description: "Get status of all agent team members.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "team_message",
+        description: "Send a message to another team member agent.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                targetAgentId: { type: "string", description: "Target agent ID" },
+                message: { type: "string", description: "Message to send" },
+            },
+            required: ["targetAgentId", "message"],
+        },
+    },
+];
+// ── MCP Bridge ──────────────────────────────────────────────
+export class McpBridge {
+    bridgeScriptPath;
+    constructor(distDir) {
+        // Located at dist/runtime/infra/mcp-bridge-server.js
+        this.bridgeScriptPath = join(distDir, "runtime", "infra", "mcp-bridge-server.js");
+    }
+    /**
+     * Check whether an ACP agent supports MCP server injection.
+     */
+    canInjectMcp(capabilities) {
+        return capabilities?.supportsMcp === true;
+    }
+    /**
+     * Generate the MCP server config to inject into an ACP session.
+     * This config tells the ACP agent how to spawn our MCP bridge server.
+     *
+     * @param parentRpcPort - Port/path for the bridge to call back to qlogicagent
+     * @param sessionId - Current session ID for scoping
+     */
+    getMcpServerConfig(parentRpcPort, sessionId) {
+        return {
+            name: "qlogicagent-tools",
+            command: process.execPath,
+            args: [this.bridgeScriptPath],
+            env: {
+                QLOGICAGENT_PARENT_RPC: parentRpcPort,
+                QLOGICAGENT_SESSION_ID: sessionId,
+            },
+        };
+    }
+    /**
+     * Get the list of tools that the MCP bridge will expose.
+     * Can be used for display or capability checking.
+     */
+    getExportedTools() {
+        return MCP_BRIDGE_TOOLS;
+    }
+}

package/dist/runtime/infra/media-persistence.d.ts

@@ -0,0 +1,87 @@
+/**
+ * MediaPersistence — Auto-download generated media to local storage.
+ *
+ * When LLM tools generate files (images, videos, audio) and return
+ * cloud URLs, this service downloads them to a persistent local directory
+ * so the user can access them offline without manual intervention.
+ *
+ * Storage layout:
+ *   <project>/assets/images/image_20260520_143022_abc.png
+ *   <project>/assets/videos/video_20260520_143055_def.mp4
+ *   <project>/assets/audio/audio_20260520_143100_ghi.mp3
+ *   <project>/assets/models/  <project>/assets/files/
+ *
+ * 产出归项目工作区可见的 assets/ 目录(按类型分),项目级、所有会话共享 —— 文件树可见可
+ * 管理。文件名带时间戳+随机后缀保证多会话不冲突。(旧版曾存于 .qlogicagent/sessions/<id>/media/)
+ *
+ * Integration:
+ *   Called from the tool result pipeline in tool-loop.ts.
+ *   When a tool result's `details.mediaUrls` contains URLs,
+ *   each URL is downloaded and the local path is added to details.
+ */
+export interface MediaDownloadResult {
+    /** Original cloud URL. */
+    remoteUrl: string;
+    /** Local file path after download. */
+    localPath: string;
+    /** File size in bytes. */
+    bytes: number;
+    /** MIME type (from Content-Type header). */
+    mimeType: string;
+}
+export interface MediaPersistenceConfig {
+    /**
+     * Project working directory. Media downloads to:
+     *   `{projectDir}/assets/{images|videos|audio|models|files}/`
+     * 项目工作区可见目录,所有会话共享。
+     */
+    projectDir?: string;
+    /** Maximum file size to download (bytes). Default: 500MB. */
+    maxFileSize?: number;
+    /** Download timeout per file (ms). Default: 300_000 (5 min). */
+    timeoutMs?: number;
+}
+export declare class MediaPersistence {
+    private projectDir;
+    private readonly maxFileSize;
+    private readonly timeoutMs;
+    constructor(config?: MediaPersistenceConfig);
+    /** Update project root directory. */
+    setProjectDir(projectDir: string): void;
+    /**
+     * Resolve the media directory for a given media type.
+     * Path: <project>/assets/<typeSubdir>/   (项目工作区可见目录,文件树可见可管理)
+     *
+     * 产出归项目级 assets 目录(images/videos/audio/models/files),所有会话共享 —— 一个项目
+     * 不同会话的产出始终在工作区可见目录,而非会话级隐藏目录。文件名带时间戳+随机后缀保证不冲突。
+     */
+    private resolveMediaDir;
+    /**
+     * Download a remote URL to local storage.
+     * Returns the local file path and metadata.
+     *
+     * Robustness:
+     *   - Validates path length (Windows 260 char limit)
+     *   - Cleans up partial files on download failure/timeout
+     *   - Handles abort/network errors gracefully
+     */
+    download(remoteUrl: string, hint?: {
+        type?: string;
+        sessionId?: string;
+    }): Promise<MediaDownloadResult>;
+    /**
+     * Download multiple URLs. Returns results for successful downloads.
+     * Failed downloads are logged but don't throw.
+     */
+    downloadAll(urls: string[], hint?: {
+        type?: string;
+        sessionId?: string;
+    }, log?: {
+        warn: (msg: string) => void;
+    }): Promise<MediaDownloadResult[]>;
+    /** Get the project-level assets root (<project>/assets). */
+    getMediaDir(): string;
+    /** Get the project directory (for testing/inspection). */
+    getProjectDir(): string | null;
+}
+export declare function toFileMediaUrl(filePath: string): string;

package/dist/runtime/infra/media-persistence.js

@@ -0,0 +1,278 @@
+/**
+ * MediaPersistence — Auto-download generated media to local storage.
+ *
+ * When LLM tools generate files (images, videos, audio) and return
+ * cloud URLs, this service downloads them to a persistent local directory
+ * so the user can access them offline without manual intervention.
+ *
+ * Storage layout:
+ *   <project>/assets/images/image_20260520_143022_abc.png
+ *   <project>/assets/videos/video_20260520_143055_def.mp4
+ *   <project>/assets/audio/audio_20260520_143100_ghi.mp3
+ *   <project>/assets/models/  <project>/assets/files/
+ *
+ * 产出归项目工作区可见的 assets/ 目录(按类型分),项目级、所有会话共享 —— 文件树可见可
+ * 管理。文件名带时间戳+随机后缀保证多会话不冲突。(旧版曾存于 .qlogicagent/sessions/<id>/media/)
+ *
+ * Integration:
+ *   Called from the tool result pipeline in tool-loop.ts.
+ *   When a tool result's `details.mediaUrls` contains URLs,
+ *   each URL is downloaded and the local path is added to details.
+ */
+import { basename, extname, join, normalize } from "node:path";
+import { mkdirSync, existsSync, createWriteStream } from "node:fs";
+import { copyFile, stat, writeFile } from "node:fs/promises";
+import { pipeline } from "node:stream/promises";
+import { Readable } from "node:stream";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { MEDIA_MAX_DOWNLOAD_SIZE, MEDIA_DOWNLOAD_TIMEOUT_MS } from "../config/tunable-defaults.js";
+// ── Constants (from tunable-defaults) ───────────────────────────────────────
+const DEFAULT_MAX_SIZE = MEDIA_MAX_DOWNLOAD_SIZE;
+const DEFAULT_TIMEOUT_MS = MEDIA_DOWNLOAD_TIMEOUT_MS;
+// ── MIME → Extension ─────────────────────────────────────────
+const MIME_EXT_MAP = {
+    "image/png": ".png", "image/jpeg": ".jpg", "image/gif": ".gif",
+    "image/webp": ".webp", "image/svg+xml": ".svg", "image/avif": ".avif",
+    "video/mp4": ".mp4", "video/webm": ".webm", "video/quicktime": ".mov",
+    "audio/mpeg": ".mp3", "audio/wav": ".wav", "audio/ogg": ".ogg",
+    "audio/aac": ".aac", "audio/mp4": ".m4a", "audio/flac": ".flac",
+    "application/pdf": ".pdf",
+    "model/gltf-binary": ".glb", "model/gltf+json": ".gltf",
+};
+// ── Core Service ─────────────────────────────────────────────
+export class MediaPersistence {
+    projectDir;
+    maxFileSize;
+    timeoutMs;
+    constructor(config) {
+        this.projectDir = config?.projectDir ?? null;
+        this.maxFileSize = config?.maxFileSize ?? DEFAULT_MAX_SIZE;
+        this.timeoutMs = config?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    }
+    /** Update project root directory. */
+    setProjectDir(projectDir) {
+        this.projectDir = projectDir;
+    }
+    /**
+     * Resolve the media directory for a given media type.
+     * Path: <project>/assets/<typeSubdir>/   (项目工作区可见目录,文件树可见可管理)
+     *
+     * 产出归项目级 assets 目录(images/videos/audio/models/files),所有会话共享 —— 一个项目
+     * 不同会话的产出始终在工作区可见目录,而非会话级隐藏目录。文件名带时间戳+随机后缀保证不冲突。
+     */
+    resolveMediaDir(type) {
+        if (!this.projectDir) {
+            throw new Error("MediaPersistence requires projectDir — call setProjectDir() first");
+        }
+        return join(this.projectDir, "assets", mediaTypeSubdir(type));
+    }
+    /**
+     * Download a remote URL to local storage.
+     * Returns the local file path and metadata.
+     *
+     * Robustness:
+     *   - Validates path length (Windows 260 char limit)
+     *   - Cleans up partial files on download failure/timeout
+     *   - Handles abort/network errors gracefully
+     */
+    async download(remoteUrl, hint) {
+        // Determine target directory — 产出归项目工作区可见目录 <project>/assets/<type>/
+        const targetDir = this.resolveMediaDir(hint?.type);
+        // Path length safety check (#2: Windows 260 char limit)
+        // Reserve 60 chars for filename (prefix_timestamp_rand.ext)
+        if (targetDir.length + 60 > 255) {
+            throw new Error(`Media path too long (${targetDir.length} chars) — would exceed OS limit. Use a shorter project path.`);
+        }
+        if (!existsSync(targetDir)) {
+            mkdirSync(targetDir, { recursive: true });
+        }
+        const dataUrl = parseDataUrl(remoteUrl);
+        if (dataUrl) {
+            if (dataUrl.bytes.length > this.maxFileSize) {
+                throw new Error(`File too large: ${dataUrl.bytes.length} bytes (max: ${this.maxFileSize})`);
+            }
+            const ext = MIME_EXT_MAP[dataUrl.mimeType] ?? ".bin";
+            const localPath = join(targetDir, generateFilename(hint?.type ?? mimeFromCategory(dataUrl.mimeType), ext));
+            await writeFile(localPath, dataUrl.bytes);
+            return { remoteUrl, localPath, bytes: dataUrl.bytes.length, mimeType: dataUrl.mimeType };
+        }
+        const localSourcePath = resolveLocalSourcePath(remoteUrl);
+        if (localSourcePath) {
+            const sourceStat = await stat(localSourcePath);
+            if (sourceStat.size > this.maxFileSize) {
+                throw new Error(`File too large: ${sourceStat.size} bytes (max: ${this.maxFileSize})`);
+            }
+            const mimeType = guessMimeType(localSourcePath);
+            const sourceExt = extname(localSourcePath).toLowerCase();
+            const ext = sourceExt || MIME_EXT_MAP[mimeType] || ".bin";
+            const localPath = join(targetDir, generateFilename(hint?.type ?? mimeFromCategory(mimeType), ext));
+            if (normalize(localSourcePath) !== normalize(localPath)) {
+                await copyFile(localSourcePath, localPath);
+            }
+            return { remoteUrl, localPath, bytes: sourceStat.size, mimeType };
+        }
+        // Fetch with timeout
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        let localPath = "";
+        try {
+            const res = await fetch(remoteUrl, { signal: controller.signal });
+            if (!res.ok) {
+                throw new Error(`Download failed: ${res.status} ${res.statusText}`);
+            }
+            // Check content length
+            const contentLength = parseInt(res.headers.get("content-length") ?? "0", 10);
+            if (contentLength > this.maxFileSize) {
+                throw new Error(`File too large: ${contentLength} bytes (max: ${this.maxFileSize})`);
+            }
+            const mimeType = res.headers.get("content-type")?.split(";")[0].trim() || "application/octet-stream";
+            const ext = guessExtension(remoteUrl, mimeType);
+            const filename = generateFilename(hint?.type ?? mimeFromCategory(mimeType), ext);
+            localPath = join(targetDir, filename);
+            // Stream to disk
+            const body = res.body;
+            if (!body)
+                throw new Error("No response body");
+            const writable = createWriteStream(localPath);
+            await pipeline(Readable.fromWeb(body), writable);
+            // Get actual size from disk (content-length may be absent)
+            const { size } = await import("node:fs/promises").then(fs => fs.stat(localPath));
+            // Verify file is not empty (partial download protection)
+            if (size === 0) {
+                await import("node:fs/promises").then(fs => fs.unlink(localPath).catch(() => { }));
+                throw new Error("Download produced empty file (connection dropped)");
+            }
+            return { remoteUrl, localPath, bytes: size, mimeType };
+        }
+        catch (err) {
+            // Cleanup partial file on failure (#5: timeout/abort leaves partial file)
+            if (localPath) {
+                try {
+                    const { unlink } = await import("node:fs/promises");
+                    await unlink(localPath);
+                }
+                catch { /* file may not exist yet */ }
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /**
+     * Download multiple URLs. Returns results for successful downloads.
+     * Failed downloads are logged but don't throw.
+     */
+    async downloadAll(urls, hint, log) {
+        const results = [];
+        for (const url of urls) {
+            try {
+                const result = await this.download(url, hint);
+                results.push(result);
+            }
+            catch (err) {
+                log?.warn(`media-persistence: failed to download ${url}: ${err.message}`);
+            }
+        }
+        return results;
+    }
+    /** Get the project-level assets root (<project>/assets). */
+    getMediaDir() {
+        if (!this.projectDir) {
+            throw new Error("MediaPersistence requires projectDir — call setProjectDir() first");
+        }
+        return join(this.projectDir, "assets");
+    }
+    /** Get the project directory (for testing/inspection). */
+    getProjectDir() {
+        return this.projectDir;
+    }
+}
+// ── Helpers ──────────────────────────────────────────────────
+/**
+ * media 类型 → assets 子目录。产出按类型归档到工作区可见的 assets/ 下。
+ * type 取值来自工具结果的 mediaBaseType(image/video/tts/music/3d)。
+ */
+function mediaTypeSubdir(type) {
+    switch (type) {
+        case "image": return "images";
+        case "video": return "videos";
+        case "tts":
+        case "music":
+        case "audio":
+        case "voice": return "audio";
+        case "3d": return "models";
+        default: return "files";
+    }
+}
+function generateFilename(prefix, ext) {
+    const d = new Date();
+    const ts = `${d.getFullYear()}${String(d.getMonth() + 1).padStart(2, "0")}${String(d.getDate()).padStart(2, "0")}_${String(d.getHours()).padStart(2, "0")}${String(d.getMinutes()).padStart(2, "0")}${String(d.getSeconds()).padStart(2, "0")}`;
+    const rand = Math.random().toString(36).slice(2, 6);
+    return `${prefix}_${ts}_${rand}${ext}`;
+}
+function guessExtension(url, mimeType) {
+    // Try MIME map first
+    if (MIME_EXT_MAP[mimeType])
+        return MIME_EXT_MAP[mimeType];
+    // Try URL extension
+    try {
+        const pathname = new URL(url).pathname;
+        const lastDot = pathname.lastIndexOf(".");
+        if (lastDot > 0) {
+            const ext = pathname.slice(lastDot).toLowerCase().split("?")[0];
+            if (ext.length <= 5)
+                return ext;
+        }
+    }
+    catch { /* ignore */ }
+    return ".bin";
+}
+function mimeFromCategory(mimeType) {
+    if (mimeType.startsWith("image/"))
+        return "image";
+    if (mimeType.startsWith("video/"))
+        return "video";
+    if (mimeType.startsWith("audio/"))
+        return "audio";
+    if (mimeType.startsWith("model/"))
+        return "3d";
+    return "file";
+}
+function parseDataUrl(url) {
+    const match = /^data:([^;,]+)?(;base64)?,(.*)$/s.exec(url);
+    if (!match)
+        return null;
+    const mimeType = match[1] || "application/octet-stream";
+    const payload = match[3] ?? "";
+    const bytes = match[2]
+        ? Buffer.from(payload, "base64")
+        : Buffer.from(decodeURIComponent(payload), "utf8");
+    return { mimeType, bytes };
+}
+function resolveLocalSourcePath(url) {
+    if (/^[a-zA-Z]:[\\/]/.test(url) || url.startsWith("\\\\"))
+        return url;
+    if (!url.startsWith("file:"))
+        return null;
+    try {
+        return fileURLToPath(url);
+    }
+    catch {
+        const raw = url.replace(/^file:\/+/, "");
+        const decoded = decodeURIComponent(raw);
+        return decoded.replace(/^\/([a-zA-Z]:[\\/])/, "$1").replace(/\//g, "\\");
+    }
+}
+function guessMimeType(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    const found = Object.entries(MIME_EXT_MAP).find(([, candidate]) => candidate === ext);
+    if (found)
+        return found[0];
+    if (basename(filePath).toLowerCase().endsWith(".wave"))
+        return "audio/wav";
+    return "application/octet-stream";
+}
+export function toFileMediaUrl(filePath) {
+    return pathToFileURL(filePath).href;
+}

package/dist/runtime/infra/migrate-project-skills.d.ts

@@ -0,0 +1,21 @@
+/**
+ * One-shot migration: fold legacy per-project skill directories
+ * (`<projectRoot>/.qlogicagent/skills/<name>/`) into the single global store,
+ * marking them project-scoped and enabling them in the originating project.
+ *
+ * Idempotent — a no-op once the legacy directory is gone, so it is safe to call
+ * on every project activation. Conflict-safe — if a DIFFERENT skill of the same
+ * name already exists in the store, the legacy copy is LEFT IN PLACE with a loud
+ * warning and never silently overwritten.
+ */
+export interface SkillMigrationResult {
+    migrated: string[];
+    conflicts: string[];
+    /** Already present in the store with identical content; legacy copy reconciled. */
+    reconciled: string[];
+}
+/**
+ * Migrate one project's legacy skills into the global store. Best-effort and
+ * idempotent. Returns a summary of what happened.
+ */
+export declare function migrateProjectSkills(projectRoot: string): SkillMigrationResult;

package/dist/runtime/infra/migrate-project-skills.js

@@ -0,0 +1,131 @@
+/**
+ * One-shot migration: fold legacy per-project skill directories
+ * (`<projectRoot>/.qlogicagent/skills/<name>/`) into the single global store,
+ * marking them project-scoped and enabling them in the originating project.
+ *
+ * Idempotent — a no-op once the legacy directory is gone, so it is safe to call
+ * on every project activation. Conflict-safe — if a DIFFERENT skill of the same
+ * name already exists in the store, the legacy copy is LEFT IN PLACE with a loud
+ * warning and never silently overwritten.
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { getProjectAgentDir, getUserSkillsDir } from "./agent-paths.js";
+import { enableSkill, markProjectScoped } from "./project-skill-manifest.js";
+function readSkillFile(dir) {
+    for (const f of ["SKILL.md", "SKILL.md.disabled"]) {
+        try {
+            const p = join(dir, f);
+            if (statSync(p).isFile())
+                return readFileSync(p, "utf8");
+        }
+        catch {
+            /* continue */
+        }
+    }
+    return null;
+}
+function legacyIsActive(dir) {
+    try {
+        return statSync(join(dir, "SKILL.md")).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Migrate one project's legacy skills into the global store. Best-effort and
+ * idempotent. Returns a summary of what happened.
+ */
+export function migrateProjectSkills(projectRoot) {
+    const result = { migrated: [], conflicts: [], reconciled: [] };
+    if (!projectRoot)
+        return result;
+    const legacyDir = join(getProjectAgentDir(projectRoot), "skills");
+    let entries;
+    try {
+        if (!statSync(legacyDir).isDirectory())
+            return result;
+        entries = readdirSync(legacyDir);
+    }
+    catch {
+        return result; // no legacy dir — nothing to migrate
+    }
+    const storeDir = getUserSkillsDir();
+    mkdirSync(storeDir, { recursive: true });
+    for (const name of entries) {
+        if (name.startsWith("."))
+            continue;
+        const srcDir = join(legacyDir, name);
+        let srcContent;
+        try {
+            if (!statSync(srcDir).isDirectory())
+                continue;
+            srcContent = readSkillFile(srcDir);
+        }
+        catch {
+            continue;
+        }
+        if (srcContent === null)
+            continue; // no SKILL.md / .disabled — skip
+        const active = legacyIsActive(srcDir);
+        const destDir = join(storeDir, name);
+        if (existsSync(destDir)) {
+            const destContent = readSkillFile(destDir);
+            if (destContent !== null && destContent === srcContent) {
+                // Identical — finish bookkeeping and drop the legacy copy.
+                markProjectScoped(name);
+                if (active)
+                    enableSkill(projectRoot, name);
+                try {
+                    rmSync(srcDir, { recursive: true, force: true });
+                }
+                catch { /* best-effort */ }
+                result.reconciled.push(name);
+            }
+            else {
+                // Name collision with different content — never overwrite; keep legacy + warn.
+                console.warn(`[skill-migration] CONFLICT: "${name}" already exists in the global store with different ` +
+                    `content. Left the legacy copy at ${srcDir}; resolve it manually.`);
+                result.conflicts.push(name);
+            }
+            continue;
+        }
+        // No collision — move the whole skill dir into the store.
+        try {
+            renameSync(srcDir, destDir);
+        }
+        catch {
+            console.warn(`[skill-migration] Failed to move "${name}" into the store; left legacy copy at ${srcDir}.`);
+            result.conflicts.push(name);
+            continue;
+        }
+        // Disabled-only legacy skill → normalize to SKILL.md so it is resolvable in the
+        // store, but do NOT enable it in the project (preserve the "off" intent).
+        if (!existsSync(join(destDir, "SKILL.md"))) {
+            const disabled = join(destDir, "SKILL.md.disabled");
+            try {
+                if (existsSync(disabled))
+                    renameSync(disabled, join(destDir, "SKILL.md"));
+            }
+            catch { /* ignore */ }
+        }
+        markProjectScoped(name);
+        if (active)
+            enableSkill(projectRoot, name);
+        result.migrated.push(name);
+    }
+    // Drop the legacy skills dir once fully drained (no conflicts left behind).
+    try {
+        if (readdirSync(legacyDir).length === 0)
+            rmSync(legacyDir, { recursive: true, force: true });
+    }
+    catch {
+        /* best-effort */
+    }
+    if (result.migrated.length > 0 || result.conflicts.length > 0) {
+        console.warn(`[skill-migration] project ${projectRoot}: migrated ${result.migrated.length}, ` +
+            `conflicts ${result.conflicts.length}, reconciled ${result.reconciled.length}.`);
+    }
+    return result;
+}

package/dist/runtime/infra/migrate-project-skills.test.d.ts

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