@nggaigc/cli 0.1.16 → 0.1.17

package/dist/independent-skill.test.js

@@ -1,965 +0,0 @@
-import { createHash, generateKeyPairSync, randomBytes, sign, } from "node:crypto";
-import { spawn } from "node:child_process";
-import { createServer } from "node:http";
-import { copyFile, mkdtemp, mkdir, readFile, readdir, rename, rm, symlink, writeFile, } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { main } from "./bin.js";
-import { runSkillStartCommand } from "./skill-command.js";
-import { prepareIndependentSkill, projectActiveSkillCatalog, rollbackIndependentSkill, startIndependentSkill, } from "./independent-skill.js";
-const keypair = generateKeyPairSync("ed25519");
-const publicKeyPem = keypair.publicKey
-    .export({ type: "spki", format: "pem" })
-    .toString();
-const trust = {
-    keyId: "ngg-test-independent-skill-1",
-    publicKeyPem,
-    spkiSha256: createHash("sha256")
-        .update(keypair.publicKey.export({ type: "spki", format: "der" }))
-        .digest("hex"),
-};
-const sha256 = (value) => createHash("sha256").update(value).digest("hex");
-const managedRootFiles = [
-    "skill-sources/nggaigc/SKILL.md",
-    "skill-sources/nggaigc/agents/openai.yaml",
-    "skill-sources/nggaigc/references/catalog-and-updates.md",
-    "skill-sources/nggaigc/references/source.json",
-    "skill-sources/nggaigc/scripts/ngg_client.mjs",
-    "plugins/nggaigc/runtime/bootstrap-public.json",
-    "plugins/nggaigc/runtime/launch-ngg-client.cjs",
-    "plugins/nggaigc/runtime/ngg-session.mjs",
-    "plugins/nggaigc/runtime/windows-credential.ps1",
-];
-async function managedRootDigest() {
-    const root = path.resolve(import.meta.dirname, "../../..");
-    const parts = [];
-    for (const relative of managedRootFiles)
-        parts.push(Buffer.from(relative), await readFile(path.join(root, relative)));
-    return sha256(Buffer.concat(parts));
-}
-function canonical(value) {
-    if (Array.isArray(value))
-        return `[${value.map(canonical).join(",")}]`;
-    if (value !== null && typeof value === "object")
-        return `{${Object.entries(value)
-            .sort(([a], [b]) => a.localeCompare(b, "en"))
-            .map(([key, child]) => `${JSON.stringify(key)}:${canonical(child)}`)
-            .join(",")}}`;
-    return JSON.stringify(value);
-}
-function credentialFrame(value) {
-    const payload = Buffer.from(JSON.stringify(value));
-    const bytes = Buffer.alloc(payload.length + 4);
-    bytes.writeUInt32BE(payload.length, 0);
-    payload.copy(bytes, 4);
-    payload.fill(0);
-    return bytes;
-}
-async function testCredentialOperation(distribution, target, operation, input, epoch) {
-    const powershell = path.join(process.env.SystemRoot ?? "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
-    const args = [
-        "-NoLogo",
-        "-NoProfile",
-        "-NonInteractive",
-        "-File",
-        path.join(distribution, "windows-credential.ps1"),
-        "-Distribution",
-        distribution,
-        "-Operation",
-        operation,
-        "-NodePath",
-        process.execPath,
-        "-Target",
-        target,
-    ];
-    if (epoch)
-        args.push("-ExpectedEpoch", epoch);
-    const child = spawn(powershell, args, {
-        windowsHide: true,
-        stdio: ["pipe", "pipe", "pipe"],
-        env: {
-            SystemRoot: process.env.SystemRoot,
-            LOCALAPPDATA: process.env.LOCALAPPDATA,
-            USERPROFILE: process.env.USERPROFILE,
-            PATH: process.env.PATH,
-        },
-    });
-    const chunks = [];
-    child.stdout.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
-    child.stderr.resume();
-    child.stdin.end(input);
-    const code = await new Promise((resolve, reject) => {
-        child.once("error", reject);
-        child.once("exit", (value) => resolve(value ?? 1));
-    });
-    const value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        throw new Error("TEST_CREDENTIAL_RESPONSE_INVALID");
-    return { code, value: value };
-}
-function crc32(bytes) {
-    let crc = 0xffffffff;
-    for (const byte of bytes) {
-        crc ^= byte;
-        for (let bit = 0; bit < 8; bit++)
-            crc = (crc >>> 1) ^ (crc & 1 ? 0xedb88320 : 0);
-    }
-    return (crc ^ 0xffffffff) >>> 0;
-}
-function storedZip(entries) {
-    const local = [];
-    const central = [];
-    let offset = 0;
-    for (const [name, body] of Object.entries(entries)) {
-        const label = Buffer.from(name, "utf8");
-        const head = Buffer.alloc(30);
-        const checksum = crc32(body);
-        head.writeUInt32LE(0x04034b50, 0);
-        head.writeUInt16LE(20, 4);
-        head.writeUInt32LE(checksum, 14);
-        head.writeUInt32LE(body.length, 18);
-        head.writeUInt32LE(body.length, 22);
-        head.writeUInt16LE(label.length, 26);
-        local.push(head, label, body);
-        const dir = Buffer.alloc(46);
-        dir.writeUInt32LE(0x02014b50, 0);
-        dir.writeUInt16LE(0x0314, 4);
-        dir.writeUInt16LE(20, 6);
-        dir.writeUInt32LE(checksum, 16);
-        dir.writeUInt32LE(body.length, 20);
-        dir.writeUInt32LE(body.length, 24);
-        dir.writeUInt16LE(label.length, 28);
-        dir.writeUInt32LE((0o100644 << 16) >>> 0, 38);
-        dir.writeUInt32LE(offset, 42);
-        central.push(dir, label);
-        offset += head.length + label.length + body.length;
-    }
-    const middle = Buffer.concat(central);
-    const end = Buffer.alloc(22);
-    end.writeUInt32LE(0x06054b50, 0);
-    end.writeUInt16LE(Object.keys(entries).length, 8);
-    end.writeUInt16LE(Object.keys(entries).length, 10);
-    end.writeUInt32LE(middle.length, 12);
-    end.writeUInt32LE(offset, 16);
-    return Buffer.concat([...local, middle, end]);
-}
-function fixture(id, version = "1.0.0", files = {
-    "SKILL.md": `---\nname: ${id.slice(6)}\ndescription: A local test ability.\n---\n\nCreate a local test marker only when requested.\n`,
-}, requires = []) {
-    const compatibility = {
-        rootSkill: { minimum: "1.0.0", maximumExclusive: "2.0.0" },
-        platform: { minimum: "0.1.0", maximumExclusive: "1.0.0" },
-    };
-    const payload = {
-        schemaVersion: "ngg-skill-package/v1",
-        artifactId: id,
-        packageVersion: version,
-        compatibility,
-        files: Object.entries(files).map(([filePath, content]) => ({
-            path: filePath,
-            sha256: sha256(content),
-            sizeBytes: Buffer.byteLength(content),
-            executable: false,
-        })),
-    };
-    const bytes = storedZip({
-        ...Object.fromEntries(Object.entries(files).map(([name, content]) => [
-            name,
-            Buffer.from(content),
-        ])),
-        "skill-package.v1.json": Buffer.from(JSON.stringify(payload)),
-    });
-    const manifest = {
-        id,
-        version,
-        lifecycle: { status: "published" },
-        requires,
-        package: {
-            sha256: sha256(bytes),
-            sizeBytes: bytes.length,
-            signature: {
-                algorithm: "ed25519",
-                keyId: trust.keyId,
-                value: sign(null, bytes, keypair.privateKey).toString("base64"),
-            },
-            compatibility,
-        },
-    };
-    const entry = {
-        id,
-        version,
-        state: "active",
-        manifestSha256: sha256(canonical(manifest)),
-        manifest,
-    };
-    return { entry, bytes };
-}
-const workdirs = [];
-afterEach(async () => {
-    for (const directory of workdirs.splice(0))
-        await rm(directory, { recursive: true, force: true });
-});
-async function setup(...items) {
-    const directory = await mkdtemp(path.join(os.tmpdir(), "nggaigc-independent-skill-"));
-    workdirs.push(directory);
-    const index = {
-        schemaVersion: "nggaigc-independent-skill-index/v1",
-        releaseId: "release.test.1",
-        entries: items.map((item) => item.entry),
-    };
-    let calls = 0;
-    const fetcher = ((url) => {
-        calls++;
-        const item = items.find((candidate) => new URL(String(url)).pathname.endsWith(`/${candidate.entry.id}/${candidate.entry.version}`));
-        if (!item)
-            return Promise.resolve(new Response(null, { status: 404 }));
-        const response = new Response(Uint8Array.from(item.bytes), { status: 200 });
-        Object.defineProperty(response, "url", { value: String(url) });
-        return Promise.resolve(response);
-    });
-    const prepare = (skillId, skillVersion = "1.0.0", override = {}) => prepareIndependentSkill({
-        index,
-        skillId,
-        skillVersion,
-        rootSkillVersion: "1.1.14",
-        platformVersion: "0.1.12",
-        codexHome: path.join(directory, ".codex"),
-        trust,
-        fetcher,
-        ...override,
-    });
-    return {
-        directory,
-        index,
-        prepare,
-        fetcher,
-        get calls() {
-            return calls;
-        },
-    };
-}
-describe("independent skill package stage 1", () => {
-    it("maps the W3 independent identity to the safe hyphenated local slug without touching root", async () => {
-        const rootDigest = await managedRootDigest();
-        const source = path.resolve(import.meta.dirname, "../../../skill-sources/w3-multimodal-video");
-        const ability = fixture("skill.w3-multimodal-video", "1.0.0", {
-            "SKILL.md": await readFile(path.join(source, "SKILL.md"), "utf8"),
-            "references/workflow.md": await readFile(path.join(source, "references/workflow.md"), "utf8"),
-        });
-        const test = await setup(ability);
-        const ready = await test.prepare(ability.entry.id);
-        expect(ready.skillPath).toBe(path.join(test.directory, ".codex/skills/w3-multimodal-video/SKILL.md"));
-        expect(await readFile(ready.skillPath, "utf8")).toContain("name: w3-multimodal-video");
-        expect(await managedRootDigest()).toBe(rootDigest);
-    });
-    it("hands off the actual W3 docs-only package through the generic start-skill command in a synthetic loopback catalog", async () => {
-        const sourceRoot = path.resolve(import.meta.dirname, "../../..");
-        const skillSource = path.join(sourceRoot, "skill-sources/w3-multimodal-video");
-        const files = {
-            "SKILL.md": await readFile(path.join(skillSource, "SKILL.md"), "utf8"),
-            "references/workflow.md": await readFile(path.join(skillSource, "references/workflow.md"), "utf8"),
-        };
-        const ability = fixture("skill.w3-multimodal-video", "1.0.0", files);
-        const syntheticTrust = {
-            ...trust,
-            keyId: "ngg-signing-synthetic-w3-only",
-        };
-        const rootManifest = JSON.parse(await readFile(path.join(sourceRoot, "release/catalog-bundles/nggaigc-root-and-wan-1.1.10/manifests/skill.nggaigc.1.1.10.json"), "utf8"));
-        const manifest = structuredClone(rootManifest);
-        manifest.schemaVersion = "1.1";
-        manifest.id = ability.entry.id;
-        manifest.version = ability.entry.version;
-        manifest.role = "independent_skill";
-        manifest.metadata = {
-            name: "W3 多模态视频生成",
-            summary: "以已验证素材生成视频的独立 Codex 引导。",
-        };
-        manifest.dependencies = [
-            {
-                kind: "capability",
-                id: "capability.w3.multimodal-video",
-                version: "1.0.0",
-                required: true,
-            },
-        ];
-        manifest.execution = {
-            mode: "local_codex",
-            entrypoint: "SKILL.md",
-            clientProtocol: 1,
-        };
-        manifest.documentation = Object.fromEntries(["overview", "usage", "pricing", "input", "output"].map((field) => [
-            field,
-            "docs/api/w3-video-generations.md",
-        ]));
-        delete manifest.catalogResolution;
-        manifest.package = {
-            version: ability.entry.version,
-            artifactPath: "packages/skills/w3-multimodal-video-1.0.0.zip",
-            sha256: sha256(ability.bytes),
-            sizeBytes: ability.bytes.length,
-            signature: {
-                algorithm: "ed25519",
-                keyId: syntheticTrust.keyId,
-                value: sign(null, ability.bytes, keypair.privateKey).toString("base64"),
-            },
-            compatibility: ability.entry.manifest.package.compatibility,
-        };
-        const capability = JSON.parse(await readFile(path.join(sourceRoot, "release/catalog-candidates/w3-video-1.0.0/capability.w3.multimodal-video.1.0.0.json"), "utf8"));
-        capability.lifecycle = { status: "published" };
-        const root = structuredClone(rootManifest);
-        root.version = "1.1.14";
-        const releaseId = "synthetic-w3-host-fixture-only";
-        const snapshot = {
-            releaseId,
-            catalogVersion: "3.0.0",
-            releaseSha256: "d".repeat(64),
-            entries: [capability, manifest, root].map((item) => ({
-                kind: item.kind,
-                id: item.id,
-                version: item.version,
-                manifestSha256: sha256(canonical(item)),
-                manifest: item,
-            })),
-        };
-        const working = await setup();
-        const codexHome = path.join(working.directory, ".codex");
-        const installedRoot = path.join(codexHome, "skills", "nggaigc");
-        const rootFiles = [
-            ["skill-sources/nggaigc/SKILL.md", "SKILL.md"],
-            ["skill-sources/nggaigc/agents/openai.yaml", "agents/openai.yaml"],
-            [
-                "skill-sources/nggaigc/references/catalog-and-updates.md",
-                "references/catalog-and-updates.md",
-            ],
-            [
-                "skill-sources/nggaigc/references/source.json",
-                "references/source.json",
-            ],
-            [
-                "skill-sources/nggaigc/scripts/ngg_client.mjs",
-                "scripts/ngg_client.mjs",
-            ],
-            [
-                "plugins/nggaigc/runtime/bootstrap-public.json",
-                "scripts/bootstrap-public.json",
-            ],
-            [
-                "plugins/nggaigc/runtime/launch-ngg-client.cjs",
-                "scripts/launch-ngg-client.cjs",
-            ],
-            ["plugins/nggaigc/runtime/ngg-session.mjs", "scripts/ngg-session.mjs"],
-            [
-                "plugins/nggaigc/runtime/windows-credential.ps1",
-                "scripts/windows-credential.ps1",
-            ],
-        ];
-        for (const [from, to] of rootFiles) {
-            const destination = path.join(installedRoot, to);
-            await mkdir(path.dirname(destination), { recursive: true });
-            await copyFile(path.join(sourceRoot, from), destination);
-        }
-        const rootPackageFiles = {};
-        for (const [, name] of rootFiles)
-            rootPackageFiles[name] = await readFile(path.join(installedRoot, name), "utf8");
-        const rootPackage = fixture("skill.nggaigc", "1.1.14", rootPackageFiles);
-        root.package = {
-            version: root.version,
-            artifactPath: "packages/skills/nggaigc-1.1.14.zip",
-            sha256: sha256(rootPackage.bytes),
-            sizeBytes: rootPackage.bytes.length,
-            signature: {
-                algorithm: "ed25519",
-                keyId: syntheticTrust.keyId,
-                value: sign(null, rootPackage.bytes, keypair.privateKey).toString("base64"),
-            },
-            compatibility: rootPackage.entry.manifest.package.compatibility,
-        };
-        snapshot.entries[2].manifestSha256 = sha256(canonical(root));
-        const requests = [];
-        let corruptPackage = false;
-        let wrongAdmission = false;
-        const server = createServer((request, response) => {
-            const url = request.url ?? "";
-            requests.push(`${request.method} ${url}`);
-            if (url === "/v1/catalog") {
-                response.writeHead(200, { "Content-Type": "application/json" });
-                response.end(JSON.stringify(snapshot));
-                return;
-            }
-            if (url === "/v1/skill-start/admit") {
-                const chunks = [];
-                request.on("data", (chunk) => chunks.push(chunk));
-                request.on("end", () => {
-                    const body = JSON.parse(Buffer.concat(chunks).toString("utf8"));
-                    if (!body || typeof body !== "object" || Array.isArray(body))
-                        throw new Error("FIXTURE_REQUEST_INVALID");
-                    response.writeHead(201, { "Content-Type": "application/json" });
-                    response.end(JSON.stringify({
-                        status: "admitted",
-                        ...body,
-                        releaseId: wrongAdmission ? "wrong-release" : releaseId,
-                    }));
-                });
-                return;
-            }
-            if (url.startsWith("/v1/skill-packages/")) {
-                const bytes = corruptPackage ? Buffer.from("tampered") : ability.bytes;
-                response.writeHead(200, {
-                    "Content-Type": "application/zip",
-                    "Content-Length": String(bytes.length),
-                });
-                response.end(bytes);
-                return;
-            }
-            response.writeHead(404);
-            response.end();
-        });
-        await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
-        const address = server.address();
-        if (!address || typeof address === "string")
-            throw new Error("FIXTURE_ADDRESS");
-        const localOrigin = `http://127.0.0.1:${address.port}`;
-        const launcher = {
-            main: async (args) => {
-                if (args[0] === "catalog-snapshot")
-                    return (await (await fetch(`${localOrigin}/v1/catalog`)).json());
-                if (args[0] === "skill-admit")
-                    return (await (await fetch(`${localOrigin}/v1/skill-start/admit`, {
-                        method: "POST",
-                        headers: { "Content-Type": "application/json" },
-                        body: JSON.stringify({
-                            kind: args[1],
-                            id: args[2],
-                            version: args[3],
-                            manifestSha256: args[4],
-                            releaseId: args[5],
-                        }),
-                    })).json());
-                throw new Error("UNSUPPORTED_SYNTHETIC_COMMAND");
-            },
-        };
-        const fetcher = (async (url) => {
-            const requested = new URL(String(url));
-            const answer = await fetch(`${localOrigin}${requested.pathname}${requested.search}`);
-            Object.defineProperty(answer, "url", { value: requested.href });
-            return answer;
-        });
-        const options = {
-            codexHome,
-            launcher,
-            trust: syntheticTrust,
-            fetcher,
-            rootSkillVersion: "1.1.14",
-            platformVersion: "0.1.12",
-        };
-        try {
-            const output = [];
-            const errors = [];
-            const invoke = (home = codexHome) => main(["start-skill", ability.entry.id, ability.entry.version], {
-                startSkill: runSkillStartCommand,
-                skillOptions: { ...options, codexHome: home },
-                output: (line) => output.push(line),
-                error: (line) => errors.push(line),
-            });
-            expect(await invoke()).toBe(0);
-            const ready = JSON.parse(output.at(-1));
-            expect(ready).toMatchObject({ status: "ready", reused: false });
-            expect(ready.skillPath).toBe(path.join(codexHome, "skills/w3-multimodal-video/SKILL.md"));
-            expect(await readFile(ready.skillPath, "utf8")).toBe(files["SKILL.md"]);
-            expect(await readFile(path.join(path.dirname(ready.skillPath), "references/workflow.md"), "utf8")).toBe(files["references/workflow.md"]);
-            expect(await invoke()).toBe(0);
-            expect(JSON.parse(output.at(-1)).reused).toBe(true);
-            expect(requests.filter((item) => item.includes("/v1/skill-packages/"))).toHaveLength(1);
-            wrongAdmission = true;
-            expect(await invoke(path.join(working.directory, "wrong-release-home"))).toBe(1);
-            expect(JSON.parse(errors.at(-1)).error.code).toBe("START_ADMISSION_REJECTED");
-            wrongAdmission = false;
-            corruptPackage = true;
-            expect(await invoke(path.join(working.directory, "tampered-home"))).toBe(1);
-            expect(JSON.parse(errors.at(-1)).error.code).toBe("PACKAGE_VERIFICATION_FAILED");
-            if (process.env.NGG_W3_KEEP_FIXTURE === "1") {
-                const rootFileSha256 = Object.fromEntries(await Promise.all(rootFiles.map(async ([, name]) => [
-                    name,
-                    sha256(await readFile(path.join(installedRoot, name))),
-                ])));
-                await writeFile(path.join(working.directory, "w3-synthetic.zip"), ability.bytes);
-                await writeFile(path.join(working.directory, "root-synthetic.zip"), rootPackage.bytes);
-                await writeFile(path.join(working.directory, "catalog-snapshot.json"), JSON.stringify(snapshot, null, 2));
-                await writeFile(path.join(working.directory, "evidence.json"), JSON.stringify({
-                    syntheticOnly: true,
-                    noRealCredentialsOrPaidRequests: true,
-                    testTrust: syntheticTrust,
-                    releaseId,
-                    packageSha256: sha256(ability.bytes),
-                    rootPackageSha256: sha256(rootPackage.bytes),
-                    rootManifestSha256: sha256(canonical(root)),
-                    skillManifestSha256: sha256(canonical(manifest)),
-                    capabilityManifestSha256: sha256(canonical(capability)),
-                    files: Object.fromEntries(Object.entries(files).map(([name, content]) => [
-                        name,
-                        sha256(content),
-                    ])),
-                    rootFileSha256,
-                    ready,
-                    reused: true,
-                    wrongReleaseRejected: true,
-                    tamperedPackageRejected: true,
-                    loopbackRequests: requests,
-                }, null, 2));
-                workdirs.splice(workdirs.indexOf(working.directory), 1);
-                console.log(`W3_SYNTHETIC_FIXTURE=${working.directory}`);
-            }
-        }
-        finally {
-            await new Promise((resolve) => server.close(() => resolve()));
-        }
-    });
-    it("discovers and installs a new local Skill without changing root bytes, then reuses the signed cache", async () => {
-        const rootDigest = await managedRootDigest();
-        const ability = fixture("skill.local-marker");
-        const test = await setup(ability);
-        const first = await test.prepare(ability.entry.id);
-        expect(first.reused).toBe(false);
-        expect(await readFile(first.skillPath, "utf8")).toContain("local test marker");
-        expect((await test.prepare(ability.entry.id)).reused).toBe(true);
-        expect(test.calls).toBe(1);
-        const laterAbility = fixture("skill.later-published");
-        const laterCatalog = await setup(laterAbility);
-        const added = await laterCatalog.prepare(laterAbility.entry.id);
-        expect(await readFile(added.skillPath, "utf8")).toContain("local test marker");
-        expect(await managedRootDigest()).toBe(rootDigest);
-    });
-    it("installs required dependencies in order and fails closed for missing or cyclic requirements", async () => {
-        const dependency = fixture("skill.local-dependency");
-        const ability = fixture("skill.local-marker", "1.0.0", undefined, [
-            { id: dependency.entry.id, version: dependency.entry.version },
-        ]);
-        const test = await setup(ability, dependency);
-        await test.prepare(ability.entry.id);
-        expect(test.calls).toBe(2);
-        expect(await readFile(path.join(test.directory, ".codex/skills/local-dependency/SKILL.md"), "utf8")).toContain("local test marker");
-        const missing = await setup(ability);
-        await expect(missing.prepare(ability.entry.id)).rejects.toMatchObject({
-            code: "DEPENDENCY_UNAVAILABLE",
-        });
-        expect(missing.calls).toBe(0);
-        const cycleA = fixture("skill.local-a", "1.0.0", undefined, [
-            { id: "skill.local-b", version: "1.0.0" },
-        ]);
-        const cycleB = fixture("skill.local-b", "1.0.0", undefined, [
-            { id: "skill.local-a", version: "1.0.0" },
-        ]);
-        const cycle = await setup(cycleA, cycleB);
-        await expect(cycle.prepare(cycleA.entry.id)).rejects.toMatchObject({
-            code: "DEPENDENCY_CYCLE",
-        });
-        expect(cycle.calls).toBe(0);
-    });
-    it("does not hand off the target when a later required package fails, while retaining an earlier verified shared dependency", async () => {
-        const first = fixture("skill.required-first");
-        const later = fixture("skill.required-later");
-        const target = fixture("skill.target", "1.0.0", undefined, [
-            { id: first.entry.id, version: first.entry.version },
-            { id: later.entry.id, version: later.entry.version },
-        ]);
-        const test = await setup(first, later, target);
-        const fetcher = ((url, init) => new URL(String(url)).pathname.endsWith("/skill.required-later/1.0.0")
-            ? Promise.reject(new Error("injected later dependency interruption"))
-            : test.fetcher(url, init));
-        await expect(startIndependentSkill({
-            index: test.index,
-            skillId: target.entry.id,
-            skillVersion: target.entry.version,
-            rootSkillVersion: "1.1.14",
-            platformVersion: "0.1.12",
-            codexHome: path.join(test.directory, ".codex"),
-            trust,
-            fetcher,
-            admit: (identity) => Promise.resolve({ ...identity, status: "admitted" }),
-        })).rejects.toMatchObject({ code: "PACKAGE_DOWNLOAD_FAILED" });
-        expect(await readFile(path.join(test.directory, ".codex/skills/required-first/SKILL.md"), "utf8")).toContain("local test marker");
-        expect(await readdir(path.join(test.directory, ".codex/skills"))).toEqual([
-            "required-first",
-        ]);
-    });
-    it("rejects tampered bytes, wrong trust key, wrong identity and unsafe paths before installation", async () => {
-        const ability = fixture("skill.local-marker");
-        const test = await setup(ability);
-        const wrongKey = generateKeyPairSync("ed25519")
-            .publicKey.export({ type: "spki", format: "pem" })
-            .toString();
-        await expect(test.prepare(ability.entry.id, "1.0.0", {
-            trust: { ...trust, publicKeyPem: wrongKey },
-        })).rejects.toMatchObject({ code: "PACKAGE_VERIFICATION_FAILED" });
-        await expect(test.prepare(ability.entry.id, "1.0.0", {
-            fetcher: ((url) => {
-                const response = new Response(Buffer.from("tampered"));
-                Object.defineProperty(response, "url", { value: String(url) });
-                return Promise.resolve(response);
-            }),
-        })).rejects.toMatchObject({ code: "PACKAGE_VERIFICATION_FAILED" });
-        const wrongIdentity = fixture("skill.other-marker");
-        await expect(test.prepare(ability.entry.id, "1.0.0", {
-            fetcher: ((url) => {
-                const response = new Response(Uint8Array.from(wrongIdentity.bytes));
-                Object.defineProperty(response, "url", { value: String(url) });
-                return Promise.resolve(response);
-            }),
-        })).rejects.toMatchObject({ code: "PACKAGE_VERIFICATION_FAILED" });
-        const unsafe = fixture("skill.unsafe-marker", "1.0.0", {
-            "SKILL.md": "safe",
-            "references/../escape.md": "bad",
-        });
-        const unsafeTest = await setup(unsafe);
-        await expect(unsafeTest.prepare(unsafe.entry.id)).rejects.toMatchObject({
-            code: "PACKAGE_VERIFICATION_FAILED",
-        });
-    });
-    it("keeps the existing version on download failure or invalid update and rejects a foreign target", async () => {
-        const old = fixture("skill.local-marker", "1.0.0");
-        const next = fixture("skill.local-marker", "1.1.0", {
-            "SKILL.md": "new version",
-        });
-        const other = fixture("skill.other-marker");
-        const test = await setup(old, next, other);
-        const first = await test.prepare(old.entry.id);
-        const otherResult = await test.prepare(other.entry.id);
-        const userFile = path.join(test.directory, "user-work.txt");
-        const credentialSentinel = path.join(test.directory, "credential-sentinel.bin");
-        await writeFile(userFile, "independent user content");
-        await writeFile(credentialSentinel, randomBytes(32));
-        const protectedPaths = [
-            otherResult.skillPath,
-            userFile,
-            credentialSentinel,
-        ];
-        const protectedDigests = await Promise.all(protectedPaths.map(async (file) => sha256(await readFile(file))));
-        const expectProtected = async () => expect(await Promise.all(protectedPaths.map(async (file) => sha256(await readFile(file))))).toEqual(protectedDigests);
-        await expect(test.prepare(next.entry.id, next.entry.version, {
-            fetcher: () => Promise.reject(new Error("offline")),
-        })).rejects.toMatchObject({ code: "PACKAGE_DOWNLOAD_FAILED" });
-        expect(await readFile(first.skillPath, "utf8")).toContain("local test marker");
-        await expectProtected();
-        await expect(test.prepare(next.entry.id, next.entry.version, {
-            fetcher: ((url) => {
-                const response = new Response(Buffer.from("bad"));
-                Object.defineProperty(response, "url", { value: String(url) });
-                return Promise.resolve(response);
-            }),
-        })).rejects.toMatchObject({ code: "PACKAGE_VERIFICATION_FAILED" });
-        expect(await readFile(first.skillPath, "utf8")).toContain("local test marker");
-        await expectProtected();
-        await expect(test.prepare(next.entry.id, next.entry.version, {
-            beforeActivate: () => Promise.reject(new Error("injected activation interruption")),
-        })).rejects.toMatchObject({ code: "INSTALL_FAILED" });
-        expect(await readFile(first.skillPath, "utf8")).toContain("local test marker");
-        await expectProtected();
-        await expect(test.prepare(next.entry.id, next.entry.version, {
-            afterActivate: async (target) => {
-                await writeFile(path.join(target, "SKILL.md"), "tampered after rename");
-            },
-        })).rejects.toMatchObject({ code: "INSTALL_FAILED" });
-        expect(await readFile(first.skillPath, "utf8")).toContain("local test marker");
-        await expectProtected();
-        const second = await test.prepare(next.entry.id, next.entry.version);
-        expect(await readFile(second.skillPath, "utf8")).toBe("new version");
-        await expectProtected();
-        const foreign = await setup(fixture("skill.foreign"));
-        const target = path.join(foreign.directory, ".codex/skills/foreign");
-        await writeFile(path.join(foreign.directory, "foreign.txt"), "untouched");
-        await expect(foreign.prepare("skill.foreign", "1.0.0", {
-            origin: "https://example.com/",
-        })).rejects.toMatchObject({ code: "PACKAGE_SOURCE_REJECTED" });
-        expect(await readFile(path.join(foreign.directory, "foreign.txt"), "utf8")).toBe("untouched");
-        expect(target).toContain("foreign");
-    });
-    it("keeps backup and staging state outside discoverable skills and rejects tampered crash recovery", async () => {
-        const old = fixture("skill.local-marker", "1.0.0");
-        const next = fixture("skill.local-marker", "1.1.0", {
-            "SKILL.md": "new version",
-        });
-        const test = await setup(old, next);
-        await test.prepare(old.entry.id);
-        const codexHome = path.join(test.directory, ".codex");
-        const target = path.join(codexHome, "skills/local-marker");
-        const backup = path.join(codexHome, ".nggaigc-managed/.nggaigc-backup-local-marker");
-        await rename(target, backup);
-        await writeFile(path.join(backup, "SKILL.md"), "tampered");
-        await expect(test.prepare(next.entry.id, next.entry.version)).rejects.toMatchObject({
-            code: "ROLLBACK_PENDING",
-        });
-        expect(test.calls).toBe(1);
-        expect(await readdir(path.join(codexHome, "skills"))).toEqual([]);
-        const clean = await setup(old, next);
-        await clean.prepare(old.entry.id);
-        const cleanHome = path.join(clean.directory, ".codex");
-        await rename(path.join(cleanHome, "skills/local-marker"), path.join(cleanHome, ".nggaigc-managed/.nggaigc-backup-local-marker"));
-        const recovered = await clean.prepare(next.entry.id, next.entry.version);
-        expect(await readFile(recovered.skillPath, "utf8")).toBe("new version");
-        expect(await readdir(path.join(cleanHome, "skills"))).toEqual([
-            "local-marker",
-        ]);
-        expect(await readFile(path.join(cleanHome, ".nggaigc-managed/.nggaigc-backup-local-marker/SKILL.md"), "utf8")).toContain("local test marker");
-    });
-    it("rolls back only the target Skill to a still active signed version", async () => {
-        const old = fixture("skill.local-marker", "1.0.0");
-        const next = fixture("skill.local-marker", "1.1.0", {
-            "SKILL.md": "new version",
-        });
-        const other = fixture("skill.other-marker");
-        const test = await setup(old, next, other);
-        await test.prepare(old.entry.id);
-        const otherResult = await test.prepare(other.entry.id);
-        const userFile = path.join(test.directory, "user-owned.txt");
-        const credentialSentinel = path.join(test.directory, "isolated-credential.bin");
-        await writeFile(userFile, "do not modify");
-        await writeFile(credentialSentinel, randomBytes(32));
-        const protectedPaths = [
-            otherResult.skillPath,
-            userFile,
-            credentialSentinel,
-        ];
-        const before = await Promise.all(protectedPaths.map(async (file) => sha256(await readFile(file))));
-        await test.prepare(next.entry.id, next.entry.version);
-        const restored = await rollbackIndependentSkill({
-            index: test.index,
-            skillId: old.entry.id,
-            skillVersion: old.entry.version,
-            installedVersion: next.entry.version,
-            rootSkillVersion: "1.1.14",
-            platformVersion: "0.1.12",
-            codexHome: path.join(test.directory, ".codex"),
-            trust,
-        });
-        expect(await readFile(restored.skillPath, "utf8")).toContain("local test marker");
-        expect(await readFile(otherResult.skillPath, "utf8")).toContain("local test marker");
-        expect(await Promise.all(protectedPaths.map(async (file) => sha256(await readFile(file))))).toEqual(before);
-        const disabledIndex = {
-            ...test.index,
-            entries: test.index.entries.map((entry) => entry.id === old.entry.id && entry.version === old.entry.version
-                ? { ...entry, state: "disabled" }
-                : entry),
-        };
-        await expect(rollbackIndependentSkill({
-            index: disabledIndex,
-            skillId: old.entry.id,
-            skillVersion: old.entry.version,
-            installedVersion: next.entry.version,
-            rootSkillVersion: "1.1.14",
-            platformVersion: "0.1.12",
-            codexHome: path.join(test.directory, ".codex"),
-            trust,
-        })).rejects.toMatchObject({ code: "CATALOG_INVALID" });
-    });
-    it.skipIf(process.platform !== "win32")("keeps A, B, user work and the exact isolated credential unchanged across interrupted A update and A rollback", async () => {
-        const old = fixture("skill.local-a", "1.0.0");
-        const next = fixture("skill.local-a", "1.1.0", {
-            "SKILL.md": "updated A",
-        });
-        const other = fixture("skill.local-b");
-        const test = await setup(old, next, other);
-        const oldA = await test.prepare(old.entry.id);
-        const installedB = await test.prepare(other.entry.id);
-        const skillA = path.dirname(oldA.skillPath);
-        const skillB = path.dirname(installedB.skillPath);
-        const digestDirectory = async (directory) => {
-            const parts = [];
-            for (const name of (await readdir(directory)).sort())
-                parts.push(Buffer.from(name), await readFile(path.join(directory, name)));
-            return sha256(Buffer.concat(parts));
-        };
-        const userFile = path.join(test.directory, "user-owned.txt");
-        await writeFile(userFile, "user work must remain exact");
-        const userHash = sha256(await readFile(userFile));
-        const oldAHash = await digestDirectory(skillA);
-        const bHash = await digestDirectory(skillB);
-        const distribution = path.join(test.directory, "isolated-bridge");
-        await mkdir(distribution);
-        const workspace = path.resolve(import.meta.dirname, "../../..");
-        for (const [source, name] of [
-            [
-                "plugins/nggaigc/runtime/windows-credential.ps1",
-                "windows-credential.ps1",
-            ],
-            ["plugins/nggaigc/runtime/ngg-session.mjs", "ngg-session.mjs"],
-            [
-                "plugins/nggaigc/runtime/bootstrap-public.json",
-                "bootstrap-public.json",
-            ],
-            ["skill-sources/nggaigc/scripts/ngg_client.mjs", "ngg_client.mjs"],
-        ])
-            await copyFile(path.join(workspace, source), path.join(distribution, name));
-        const target = `NGGAIGC/Codex/test-${randomBytes(16).toString("hex")}`;
-        const token = `ngg_v1_${randomBytes(32).toString("base64url")}`;
-        let epoch;
-        try {
-            const setup = await testCredentialOperation(distribution, target, "setup", credentialFrame({
-                schemaVersion: "ngg-credential-input/v1",
-                origin: "https://api.nggaigc.com",
-                token,
-            }));
-            expect(setup.code).toBe(0);
-            epoch = setup.value.credentialEpoch;
-            expect(epoch).toMatch(/^[a-f0-9]{32}$/);
-            const status = await testCredentialOperation(distribution, target, "status");
-            expect(status.code).toBe(0);
-            expect(status.value.credentialEpoch).toBe(epoch);
-            const protectedState = async () => {
-                expect(await digestDirectory(skillB)).toBe(bHash);
-                expect(sha256(await readFile(userFile))).toBe(userHash);
-                const current = await testCredentialOperation(distribution, target, "status");
-                expect(current).toEqual(status);
-            };
-            await expect(test.prepare(next.entry.id, next.entry.version, {
-                beforeActivate: () => Promise.reject(new Error("injected interruption after A backup")),
-            })).rejects.toMatchObject({ code: "INSTALL_FAILED" });
-            expect(await digestDirectory(skillA)).toBe(oldAHash);
-            await protectedState();
-            const updated = await test.prepare(next.entry.id, next.entry.version);
-            expect(await readFile(updated.skillPath, "utf8")).toBe("updated A");
-            await protectedState();
-            const restored = await rollbackIndependentSkill({
-                index: test.index,
-                skillId: old.entry.id,
-                skillVersion: old.entry.version,
-                installedVersion: next.entry.version,
-                rootSkillVersion: "1.1.14",
-                platformVersion: "0.1.12",
-                codexHome: path.join(test.directory, ".codex"),
-                trust,
-            });
-            expect(restored.skillPath).toBe(oldA.skillPath);
-            expect(await digestDirectory(skillA)).toBe(oldAHash);
-            await protectedState();
-        }
-        finally {
-            if (epoch) {
-                const deleted = await testCredentialOperation(distribution, target, "delete-exact", undefined, epoch);
-                expect(deleted.code).toBe(0);
-                expect(deleted.value.status).toBe("credential-deleted");
-            }
-        }
-    });
-    it("rejects a catalog manifest hash mismatch and incompatible root", async () => {
-        const ability = fixture("skill.local-marker");
-        const test = await setup(ability);
-        const wrongIndex = {
-            ...test.index,
-            entries: [{ ...ability.entry, manifestSha256: "0".repeat(64) }],
-        };
-        await expect(test.prepare(ability.entry.id, "1.0.0", { index: wrongIndex })).rejects.toMatchObject({ code: "CATALOG_INVALID" });
-        await expect(test.prepare(ability.entry.id, "1.0.0", { rootSkillVersion: "2.0.0" })).rejects.toMatchObject({ code: "PACKAGE_INCOMPATIBLE" });
-        expect(test.calls).toBe(0);
-    });
-    it("rejects duplicate identity, incompatible platform and tampered signed cache", async () => {
-        const ability = fixture("skill.local-marker");
-        const duplicate = await setup(ability, ability);
-        await expect(duplicate.prepare(ability.entry.id)).rejects.toMatchObject({
-            code: "DEPENDENCY_UNAVAILABLE",
-        });
-        const test = await setup(ability);
-        await expect(test.prepare(ability.entry.id, "1.0.0", { platformVersion: "2.0.0" })).rejects.toMatchObject({ code: "PACKAGE_INCOMPATIBLE" });
-        const result = await test.prepare(ability.entry.id);
-        await writeFile(result.skillPath, "tampered");
-        await expect(test.prepare(ability.entry.id)).rejects.toMatchObject({
-            code: "INSTALL_CONFLICT",
-        });
-    });
-    it("does not follow redirects, send credentials or write through a foreign symlink", async () => {
-        const ability = fixture("skill.local-marker");
-        const test = await setup(ability);
-        const seen = [];
-        await expect(test.prepare(ability.entry.id, "1.0.0", {
-            fetcher: ((url, init) => {
-                seen.push({ url: String(url), init });
-                return Promise.resolve(new Response(null, {
-                    status: 302,
-                    headers: { location: "https://example.com/evil" },
-                }));
-            }),
-        })).rejects.toMatchObject({ code: "PACKAGE_DOWNLOAD_FAILED" });
-        expect(seen).toHaveLength(1);
-        expect(seen[0]?.url).toBe("https://api.nggaigc.com/v1/skill-packages/skill.local-marker/1.0.0?releaseId=release.test.1");
-        expect(seen[0]?.init).toMatchObject({
-            redirect: "error",
-            credentials: "omit",
-            cache: "no-store",
-        });
-        expect(JSON.stringify(seen[0]?.init)).not.toContain("Authorization");
-        const outside = path.join(test.directory, "outside");
-        await mkdir(outside);
-        const target = path.join(test.directory, ".codex", "skills", "local-marker");
-        await symlink(outside, target, "junction");
-        await expect(test.prepare(ability.entry.id)).rejects.toMatchObject({
-            code: "INSTALL_CONFLICT",
-        });
-        expect(await readFile(path.join(outside, "SKILL.md"), "utf8").catch(() => "missing")).toBe("missing");
-    });
-    it("projects the existing active catalog shape instead of introducing a second release source", async () => {
-        const folder = path.resolve(import.meta.dirname, "../../../release/catalog-bundles/seedream-5-lite-1.1.0/manifests");
-        const manifest = JSON.parse(await readFile(path.join(folder, "skill.seedream-5-lite.image-generation.1.0.0.json"), "utf8"));
-        const capability = JSON.parse(await readFile(path.join(folder, "capability.seedream-5-lite.image-generation.1.0.0.json"), "utf8"));
-        const index = projectActiveSkillCatalog({
-            releaseId: "release.existing",
-            entries: [
-                {
-                    kind: "skill",
-                    id: "skill.seedream-5-lite.image-generation",
-                    version: "1.0.0",
-                    manifestSha256: sha256(canonical(manifest)),
-                    manifest,
-                },
-                {
-                    kind: "capability",
-                    id: "capability.seedream-5-lite.image-generation",
-                    version: "1.0.0",
-                    manifestSha256: sha256(canonical(capability)),
-                    manifest: capability,
-                },
-            ],
-        });
-        expect(index.entries).toHaveLength(1);
-        expect(index.entries[0]?.id).toBe("skill.seedream-5-lite.image-generation");
-        expect(index.entries[0]?.manifestSha256).toBe(sha256(canonical(manifest)));
-    });
-    it("binds server admission to the exact release before free local preparation", async () => {
-        const ability = fixture("skill.local-marker");
-        const test = await setup(ability);
-        const base = {
-            index: test.index,
-            skillId: ability.entry.id,
-            skillVersion: ability.entry.version,
-            rootSkillVersion: "1.1.14",
-            platformVersion: "0.1.12",
-            codexHome: path.join(test.directory, ".codex"),
-            trust,
-        };
-        await expect(startIndependentSkill({
-            ...base,
-            admit: () => Promise.reject(Object.assign(new Error("insufficient"), {
-                code: "INSUFFICIENT_CREDITS",
-            })),
-        })).rejects.toMatchObject({ code: "INSUFFICIENT_CREDITS" });
-        expect(test.calls).toBe(0);
-        await expect(startIndependentSkill({
-            ...base,
-            admit: (identity) => Promise.resolve({
-                ...identity,
-                releaseId: "wrong",
-                status: "admitted",
-            }),
-        })).rejects.toMatchObject({ code: "START_ADMISSION_REJECTED" });
-        expect(test.calls).toBe(0);
-        const result = await startIndependentSkill({
-            ...base,
-            fetcher: ((url) => {
-                const response = new Response(Uint8Array.from(ability.bytes));
-                Object.defineProperty(response, "url", { value: String(url) });
-                return Promise.resolve(response);
-            }),
-            admit: (identity) => Promise.resolve({ ...identity, status: "admitted" }),
-        });
-        expect(await readFile(result.skillPath, "utf8")).toContain("local test marker");
-    });
-});