@litfamily/litopencode 1.0.0

package/dist/cli/model-policy.js

@@ -0,0 +1,143 @@
+import { defaultGlobalConfigJson } from "../config.js";
+import { isRecord } from "./json.js";
+const categoryIds = ["planning", "execution", "review", "research"];
+const leadCategoryIds = new Set(["planning", "review"]);
+const canonicalModels = new Set(["gpt-5.6-luna"]);
+const legacyModels = new Set(["gpt-5.4", "gpt-5.5"]);
+const offeredEfforts = new Set(["medium", "high", "max"]);
+const astraEfforts = new Set(["low", "medium", "high", "xhigh", "max"]);
+const managedLegacyRouteKeys = new Set(["provider", "model", "variant", "textVerbosity"]);
+function normalizedRoute(value) {
+    if (!isRecord(value) || typeof value.model !== "string")
+        return undefined;
+    const slashIndex = value.model.indexOf("/");
+    const modelProvider = slashIndex > 0 ? value.model.slice(0, slashIndex) : undefined;
+    const model = slashIndex > 0 ? value.model.slice(slashIndex + 1) : value.model;
+    const provider = typeof value.provider === "string" ? value.provider : modelProvider;
+    if (provider === undefined || (modelProvider !== undefined && provider !== modelProvider))
+        return undefined;
+    return {
+        provider,
+        model,
+        dispatchId: slashIndex > 0 ? value.model : provider + "/" + model,
+        qualifiedModel: slashIndex > 0,
+        ...(typeof value.variant === "string" ? { variant: value.variant } : {}),
+        hasLegacyEffort: value.reasoningEffort !== undefined,
+        raw: value
+    };
+}
+function isExactManagedLegacyRoute(route) {
+    const keys = Object.keys(route.raw);
+    return (keys.length === managedLegacyRouteKeys.size &&
+        keys.every((key) => managedLegacyRouteKeys.has(key)) &&
+        route.provider === "openai" &&
+        !route.qualifiedModel &&
+        legacyModels.has(route.model) &&
+        route.variant === "high" &&
+        route.raw.textVerbosity === "medium" &&
+        !route.hasLegacyEffort);
+}
+function result(className, originalDispatchId = null) {
+    return { class: className, originalDispatchId };
+}
+function hasRouteOverride(value) {
+    return isRecord(value) && ["provider", "model", "variant", "reasoningEffort"].some((field) => value[field] !== undefined);
+}
+function originalDispatch(value) {
+    if (typeof value.model !== "string")
+        return null;
+    if (value.model.includes("/"))
+        return value.model;
+    return typeof value.provider === "string" ? value.provider + "/" + value.model : value.model;
+}
+function customOverrides(rawConfig) {
+    const agents = isRecord(rawConfig.agents) ? Object.values(rawConfig.agents).filter(hasRouteOverride) : [];
+    const categories = isRecord(rawConfig.categories)
+        ? Object.entries(rawConfig.categories)
+            .filter(([id]) => !categoryIds.includes(id))
+            .map(([, value]) => value)
+            .filter((value) => isRecord(value))
+        : [];
+    return [...agents, ...categories];
+}
+function uniqueOriginalDispatch(overrides) {
+    const dispatches = [...new Set(overrides.map(originalDispatch).filter((value) => value !== null))];
+    return dispatches.length === 1 ? dispatches[0] : null;
+}
+export function classifyModelConfig(rawConfig) {
+    if (rawConfig === null)
+        return result("fresh");
+    const overrides = customOverrides(rawConfig);
+    if (overrides.length > 0)
+        return result("custom", uniqueOriginalDispatch(overrides));
+    if (!isRecord(rawConfig.categories))
+        return result("fresh");
+    const categories = rawConfig.categories;
+    const keys = Object.keys(categories);
+    const routes = categoryIds.map((id) => normalizedRoute(categories[id]));
+    if (routes.every((route) => route === undefined))
+        return result("fresh");
+    if (keys.length !== categoryIds.length || routes.some((route) => route === undefined)) {
+        return result("mixed");
+    }
+    const definedRoutes = routes.filter((route) => route !== undefined);
+    const first = definedRoutes[0];
+    if (first === undefined)
+        return result("fresh");
+    const homogeneous = definedRoutes.every((route) => route.dispatchId === first.dispatchId && route.variant === first.variant);
+    if (!homogeneous || definedRoutes.some((route) => route.hasLegacyEffort))
+        return result("mixed");
+    if (definedRoutes.every(isExactManagedLegacyRoute)) {
+        return result("managed_legacy", first.dispatchId);
+    }
+    if (first.qualifiedModel)
+        return result("custom", first.dispatchId);
+    if (first.provider === "openai" &&
+        first.model === "gpt-6-astra" &&
+        first.variant !== undefined &&
+        astraEfforts.has(first.variant)) {
+        return result("astra_managed", first.dispatchId);
+    }
+    if (first.provider === "openai" &&
+        canonicalModels.has(first.model) &&
+        (first.variant === undefined || offeredEfforts.has(first.variant))) {
+        return result("gpt56_managed", first.dispatchId);
+    }
+    if (first.provider === "openai" && /^gpt-5\.6(?:$|-)/u.test(first.model)) {
+        return result("gpt56_other", first.dispatchId);
+    }
+    return result("custom", first.dispatchId);
+}
+export function selectedLitConfig(rawConfig, selection, permissionMode = "safe", permissionModeExplicit = false, outputStyle = "off") {
+    const config = rawConfig === null ? defaultGlobalConfigJson() : { ...rawConfig };
+    if (permissionModeExplicit || permissionMode === "balanced" || permissionMode === "yolo") {
+        config.permissionMode = permissionMode;
+    }
+    if (outputStyle !== "off") {
+        config.outputStyle = outputStyle;
+    }
+    if (selection === undefined)
+        return config;
+    const defaults = defaultGlobalConfigJson();
+    const defaultCategories = isRecord(defaults.categories) ? defaults.categories : {};
+    const existingCategories = isRecord(config.categories) ? config.categories : {};
+    const categories = { ...existingCategories };
+    const helper = selection.helper;
+    for (const id of Object.keys(defaultCategories)) {
+        if (!leadCategoryIds.has(id) && helper === undefined)
+            continue;
+        const route = leadCategoryIds.has(id) ? selection : helper;
+        if (route === undefined)
+            continue;
+        const current = isRecord(categories[id]) ? categories[id] : {};
+        const category = { ...current };
+        delete category.reasoningEffort;
+        categories[id] = {
+            ...category,
+            provider: route.provider,
+            model: route.model,
+            ...(route.effort === undefined ? {} : { variant: route.effort })
+        };
+    }
+    return { ...config, categories };
+}

package/dist/cli/model-routing.d.ts

@@ -0,0 +1,5 @@
+import type { InstallModelSelection, InstallPermissionChoice, InstallPermissionMode, ModelConfigClassification, ModelPromptMode, PermissionPromptMode } from "./types.ts";
+export declare function promptOutputStyle(existing: string, promptMode: PermissionPromptMode, dryRun: boolean): Promise<string>;
+export declare function promptPermissionMode(selected: InstallPermissionMode, mode: PermissionPromptMode, dryRun: boolean): Promise<InstallPermissionChoice>;
+export declare function renderModelRouteCard(selection: InstallModelSelection, configPath: string): string;
+export declare function promptModelSelection(selection: InstallModelSelection | undefined, mode: ModelPromptMode, dryRun: boolean, classification: ModelConfigClassification, configPath: string, currentSelection?: InstallModelSelection | undefined): Promise<InstallModelSelection | undefined>;

package/dist/cli/model-routing.js

@@ -0,0 +1,208 @@
+import fsSync from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { markColorMode } from "../lit-mark.js";
+import { isRecord } from "./json.js";
+import { isModelProvider, modelMenuRows, providerCredentialEnv, providerMenu, stripFastSuffix } from "./model-catalog.js";
+const outputStyleOptions = [
+    { id: "off", label: "None / keep current", hint: "No output style applied" },
+    { id: "asd-ste100", label: "ASD-STE100 (English)", hint: "ASD Simplified Technical English" },
+    { id: "asd-ste100-ko", label: "ASD-STE100 (한국어)", hint: "ASD 간소화 기술 영어 (한국어)" },
+    { id: "eli5", label: "ELI5 (English)", hint: "Explain Like I'm 5" },
+    { id: "eli5-ko", label: "ELI5 (한국어)", hint: "쉽게 설명하기" }
+];
+function shouldPromptForInstallChoice(mode, dryRun) {
+    if (dryRun)
+        return false;
+    if (mode === "never")
+        return false;
+    if (mode === "always")
+        return true;
+    return process.stdin.isTTY === true && process.stdout.isTTY === true && process.env.CI === undefined;
+}
+export async function promptOutputStyle(existing, promptMode, dryRun) {
+    if (!shouldPromptForInstallChoice(promptMode, dryRun))
+        return existing;
+    const defaultIndex = Math.max(0, outputStyleOptions.findIndex((opt) => opt.id === existing));
+    const reader = createPromptReader();
+    try {
+        const index = await chooseIndex(reader, "Choose an output style for LitOpenCode responses.", outputStyleOptions, defaultIndex);
+        return outputStyleOptions[index].id;
+    }
+    finally {
+        reader.close();
+    }
+}
+const permissionOptions = [
+    {
+        mode: "safe",
+        label: "Safe / ask-first",
+        hint: "Do not relax OpenCode permissions"
+    },
+    {
+        mode: "balanced",
+        label: "Balanced automation",
+        hint: "Allow routine work but ask for dangerous shell commands such as rm -rf"
+    },
+    {
+        mode: "yolo",
+        label: "Full automation / YOLO",
+        hint: "Allow bash/edit/task/webfetch; lit-plan remains deny-only"
+    }
+];
+function formatChoice(index, label, hint) {
+    return "   " + String(index) + ". " + label + (hint.length === 0 ? "" : "   — " + hint);
+}
+async function askLine(reader, prompt) {
+    return (await reader.question(prompt)).trim();
+}
+function createPromptReader() {
+    if (process.stdin.isTTY === true) {
+        return readline.createInterface({ input: process.stdin, output: process.stdout, terminal: markColorMode() !== "none" });
+    }
+    const answers = fsSync.readFileSync(0, "utf8").split(/\r?\n/u);
+    let index = 0;
+    return {
+        async question(prompt) {
+            process.stdout.write(prompt);
+            const answer = answers[index] ?? "";
+            index += 1;
+            return answer;
+        },
+        close() { }
+    };
+}
+async function chooseIndex(reader, title, choices, defaultIndex) {
+    process.stdout.write("\n" + title + "\n");
+    for (const [index, choice] of choices.entries()) {
+        process.stdout.write(formatChoice(index, choice.label, choice.hint) + "\n");
+    }
+    const answer = await askLine(reader, "Select 0-" + String(choices.length - 1) + " [" + String(defaultIndex) + "]: ");
+    if (answer.length === 0)
+        return defaultIndex;
+    const selected = Number.parseInt(answer, 10);
+    if (/^\d+$/u.test(answer) && Number.isInteger(selected) && selected >= 0 && selected < choices.length)
+        return selected;
+    throw new Error("Invalid selection: " + answer);
+}
+function shouldPromptForModel(mode, selection, dryRun, classification, currentSelection) {
+    if (selection !== undefined || dryRun)
+        return false;
+    if (mode === "never")
+        return false;
+    if (mode === "always")
+        return true;
+    if (process.stdin.isTTY !== true || process.stdout.isTTY !== true || process.env.CI !== undefined)
+        return false;
+    return classification.class === "fresh" || classification.class === "managed_legacy" || currentSelection !== undefined;
+}
+function shouldPromptForPermissions(mode, selected, dryRun) {
+    return selected === "safe" && shouldPromptForInstallChoice(mode, dryRun);
+}
+export async function promptPermissionMode(selected, mode, dryRun) {
+    if (!shouldPromptForPermissions(mode, selected, dryRun))
+        return { mode: selected, explicit: selected !== "safe" };
+    const reader = createPromptReader();
+    try {
+        const index = await chooseIndex(reader, "Choose LitOpenCode permission behavior.", permissionOptions, 0);
+        return { mode: permissionOptions[index].mode, explicit: true };
+    }
+    finally {
+        reader.close();
+    }
+}
+function menuLabel(row) {
+    return row.model.padEnd(13, " ") + " · " + row.effort.padEnd(6, " ");
+}
+async function chooseProvider(reader, title, defaultProvider) {
+    const defaultIndex = Math.max(0, providerMenu.findIndex((row) => row.provider === defaultProvider));
+    const index = await chooseIndex(reader, title, providerMenu.map((row) => ({ label: row.label.padEnd(35, " ") + " (" + row.provider + ")", hint: "" })), defaultIndex);
+    return providerMenu[index].provider;
+}
+async function chooseRoute(reader, title, provider, defaultIndex, preferred) {
+    const rows = modelMenuRows(provider);
+    const preferredModel = preferred === undefined ? undefined : provider === "openai" ? stripFastSuffix(preferred.model) : preferred.model;
+    const preferredIndex = preferredModel === undefined ? -1 : rows.findIndex((row) => row.model === preferredModel);
+    const selectedDefault = preferredIndex >= 0 ? preferredIndex : Math.min(defaultIndex, rows.length - 1);
+    const index = await chooseIndex(reader, title, rows.map((row) => ({ label: menuLabel(row), hint: row.hint })), selectedDefault);
+    const row = rows[index];
+    if (preferred !== undefined &&
+        row.provider === preferred.provider &&
+        row.model === preferredModel) {
+        return preferred;
+    }
+    return { provider: row.provider, model: row.model, effort: row.effort };
+}
+function recommendedHelperIndex(provider) {
+    return Math.max(0, modelMenuRows(provider).findIndex((row) => row.hint.includes("recommended helper")));
+}
+function hostAuthPath() {
+    const dataHome = process.env.XDG_DATA_HOME;
+    const base = dataHome && dataHome.length > 0 ? dataHome : path.join(os.homedir(), ".local", "share");
+    return path.join(base, "opencode", "auth.json");
+}
+function hasProviderCredential(provider) {
+    const envName = providerCredentialEnv(provider);
+    if (envName !== undefined && (process.env[envName] ?? "").length > 0)
+        return true;
+    try {
+        const parsed = JSON.parse(fsSync.readFileSync(hostAuthPath(), "utf8"));
+        return isRecord(parsed) && isRecord(parsed[provider]);
+    }
+    catch {
+        return false;
+    }
+}
+function routeLabel(route) {
+    return route.model + " · " + (route.effort ?? "default");
+}
+export function renderModelRouteCard(selection, configPath) {
+    const helper = selection.helper ?? selection;
+    const providers = helper.provider === selection.provider ? selection.provider : selection.provider + " / " + helper.provider;
+    const warnings = [...new Set([selection.provider, helper.provider])]
+        .filter((provider) => !hasProviderCredential(provider))
+        .map((provider) => {
+        const envName = providerCredentialEnv(provider) ?? provider.toUpperCase() + "_API_KEY";
+        return "│ Warning    " + envName + " is not set and OpenCode has no stored " + provider + " credential; the route is written anyway";
+    });
+    return [
+        "",
+        "╭─ MODEL ROUTE",
+        "│ Provider   " + providers,
+        "│ Lead       " + routeLabel(selection),
+        "│ Helpers    " + routeLabel(helper),
+        "│ Writes     " + configPath + "  (managed keys only)",
+        ...warnings,
+        "╰─ Enter to continue · Ctrl-C to abort (nothing written yet)"
+    ].join("\n") + "\n";
+}
+export async function promptModelSelection(selection, mode, dryRun, classification, configPath, currentSelection = undefined) {
+    if (!shouldPromptForModel(mode, selection, dryRun, classification, currentSelection)) {
+        if (selection !== undefined && !dryRun)
+            process.stdout.write(renderModelRouteCard(selection, configPath));
+        return selection;
+    }
+    const preferredSelection = mode === "auto" ? currentSelection : undefined;
+    const reader = createPromptReader();
+    try {
+        if (classification.class === "managed_legacy") {
+            process.stdout.write("\nManaged GPT-5.4/GPT-5.5 route detected; choosing a route upgrades it.\n");
+        }
+        else if (classification.class !== "fresh") {
+            process.stdout.write("\nExisting route (" + classification.class + ") will be rewritten in managed keys only.\n");
+        }
+        const leadProvider = await chooseProvider(reader, "Choose the provider for LitOpenCode agents.", preferredSelection !== undefined && isModelProvider(preferredSelection.provider) ? preferredSelection.provider : "openai");
+        const lead = await chooseRoute(reader, "Choose the LEAD model (plans and reviews).", leadProvider, 0, preferredSelection);
+        const preferredHelper = preferredSelection?.helper;
+        const helperProvider = await chooseProvider(reader, "Choose the provider for HELPER agents (workers, explorers, librarians).", preferredHelper !== undefined && isModelProvider(preferredHelper.provider) ? preferredHelper.provider : leadProvider);
+        const helper = await chooseRoute(reader, "Choose the HELPER model (spawned and delegated agents).", helperProvider, recommendedHelperIndex(helperProvider), preferredHelper);
+        const chosen = { ...lead, helper };
+        process.stdout.write(renderModelRouteCard(chosen, configPath));
+        await askLine(reader, "");
+        return chosen;
+    }
+    finally {
+        reader.close();
+    }
+}

package/dist/cli/native-canonical-backup.d.ts

@@ -0,0 +1,9 @@
+import { type RetainedCanonicalCache } from "./native-canonical-cache.ts";
+import { type RuntimeSkill } from "./native-skill-integrity.ts";
+export declare function prepareCanonicalBackup(root: string, skillsRoot: string, skill: RuntimeSkill, caches: readonly RetainedCanonicalCache[]): Promise<{
+    backup: string;
+    validateBoundary: () => Promise<void>;
+    validateBeforeMove: () => Promise<void>;
+    validateMoved: () => Promise<void>;
+    complete: () => Promise<void>;
+}>;

package/dist/cli/native-canonical-backup.js

@@ -0,0 +1,96 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { inspectCanonicalTree } from "./native-canonical-cache.js";
+import { installedCanonicalDirectory, managedSkillDefinition } from "./managed-skill-assets.js";
+import { assertInstalledCanonicalOwnership, nativeSkillsRoot } from "./native-skill-integrity.js";
+import { lstatIfPresent } from "./native-skill-tree.js";
+async function directoryIdentity(directory) {
+    const stat = await fs.lstat(directory, { bigint: true });
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+        throw new Error(`Unsafe canonical backup directory: ${directory}`);
+    return `${stat.dev}:${stat.ino}:${stat.birthtimeNs}`;
+}
+async function directoryChain(...directories) {
+    const entries = new Map();
+    for (const directory of directories) {
+        let current = directory;
+        while (!entries.has(current)) {
+            entries.set(current, await directoryIdentity(current));
+            const parent = path.dirname(current);
+            if (parent === current)
+                break;
+            current = parent;
+        }
+    }
+    return entries;
+}
+export async function prepareCanonicalBackup(root, skillsRoot, skill, caches) {
+    const realRoot = await fs.realpath(root);
+    const realSkillsRoot = await fs.realpath(skillsRoot);
+    const parent = path.join(realRoot, ".litopencode-canonical-backups");
+    const relative = path.relative(realSkillsRoot, parent);
+    if (relative === "" || (!relative.startsWith(".." + path.sep) && relative !== ".." && !path.isAbsolute(relative))) {
+        throw new Error("Canonical backup must be outside native skills discovery");
+    }
+    const initial = await directoryChain(realRoot, realSkillsRoot);
+    async function assertInitial() {
+        if (await fs.realpath(root) !== realRoot || await fs.realpath(await nativeSkillsRoot(root)) !== realSkillsRoot) {
+            throw new Error("Canonical backup root changed; retained state must be reviewed");
+        }
+        for (const [directory, identity] of initial) {
+            if (await directoryIdentity(directory) !== identity)
+                throw new Error(`Canonical backup ancestor changed: ${directory}`);
+        }
+    }
+    await assertInitial();
+    try {
+        await fs.mkdir(parent, { mode: 0o700 });
+    }
+    catch (error) {
+        if (!(error instanceof Error && "code" in error && error.code === "EEXIST"))
+            throw error;
+    }
+    initial.set(parent, await directoryIdentity(parent));
+    await assertInitial();
+    const container = path.join(parent, `${skill.id}-${randomUUID()}`);
+    await fs.mkdir(container, { mode: 0o700 });
+    const owned = await directoryChain(container);
+    const backup = path.join(container, "skill");
+    const receipt = { schemaVersion: 1, skill: skill.id, original: path.join(skillsRoot, skill.id), backup, caches };
+    await fs.writeFile(path.join(container, "prepared.json"), JSON.stringify(receipt, null, 2) + "\n", { flag: "wx", mode: 0o600 });
+    async function validateBoundary() {
+        await assertInitial();
+        for (const [directory, identity] of owned) {
+            if (await directoryIdentity(directory) !== identity)
+                throw new Error(`Canonical backup directory changed: ${directory}`);
+        }
+    }
+    async function validateBeforeMove() {
+        await validateBoundary();
+        const current = await assertInstalledCanonicalOwnership(root, skill);
+        if (JSON.stringify(current) !== JSON.stringify(caches))
+            throw new Error("Canonical cache changed before retention");
+        if (await lstatIfPresent(backup) !== null)
+            throw new Error(`Canonical backup destination already exists: ${backup}`);
+        await validateBoundary();
+    }
+    async function validateMoved() {
+        await validateBoundary();
+        await directoryIdentity(backup);
+        const canonical = path.join(backup, installedCanonicalDirectory);
+        await directoryIdentity(canonical);
+        const definition = managedSkillDefinition(skill.id);
+        if (definition === undefined)
+            throw new Error(`Missing canonical definition for ${skill.id}`);
+        const current = await inspectCanonicalTree(canonical, definition.canonicalFiles);
+        if (current.failures.length > 0 || JSON.stringify(current.caches) !== JSON.stringify(caches)) {
+            throw new Error(`Retained canonical bytes changed; preserve backup at ${backup}`);
+        }
+    }
+    async function complete() {
+        await validateMoved();
+        await fs.writeFile(path.join(container, "receipt.json"), JSON.stringify({ ...receipt, state: "retained" }, null, 2) + "\n", { flag: "wx", mode: 0o600 });
+    }
+    return { backup, validateBoundary, validateBeforeMove, validateMoved, complete };
+}

package/dist/cli/native-canonical-cache.d.ts

@@ -0,0 +1,9 @@
+import type { CanonicalManagedAsset } from "./managed-skill-assets.ts";
+export type RetainedCanonicalCache = {
+    readonly path: string;
+    readonly sha256: string;
+};
+export declare function inspectCanonicalTree(root: string, assets: readonly CanonicalManagedAsset[]): Promise<{
+    failures: string[];
+    caches: RetainedCanonicalCache[];
+}>;

package/dist/cli/native-canonical-cache.js

@@ -0,0 +1,37 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { exactTreeFailures, inventoryTree } from "./native-skill-tree.js";
+export async function inspectCanonicalTree(root, assets) {
+    const inventory = await inventoryTree(root);
+    const expected = new Set(assets.map((asset) => asset.path));
+    const failures = [...inventory.unsafe];
+    const caches = [];
+    // Bytecode is opaque user state, never validation input or an executable here.
+    // Its source must still be one of the exact unchanged packaged Python files.
+    for (const asset of assets) {
+        if (!inventory.files.includes(asset.path))
+            continue;
+        const actual = createHash("sha256").update(await fs.readFile(path.join(root, asset.path))).digest("hex");
+        if (actual !== asset.sha256)
+            failures.push(asset.path);
+    }
+    if (failures.length === 0) {
+        for (const file of inventory.files) {
+            if (expected.has(file))
+                continue;
+            const directory = path.posix.dirname(file);
+            if (path.posix.basename(directory) !== "__pycache__")
+                continue;
+            const match = /^(.*)\.(?:cpython-[0-9]+|pypy[0-9]+)(?:\.opt-[0-9]+)?\.pyc$/.exec(path.posix.basename(file));
+            if (match === null)
+                continue;
+            const source = path.posix.join(path.posix.dirname(directory), `${match[1]}.py`);
+            if (!expected.has(source) || !inventory.files.includes(source))
+                continue;
+            caches.push({ path: file, sha256: createHash("sha256").update(await fs.readFile(path.join(root, file))).digest("hex") });
+        }
+    }
+    failures.push(...exactTreeFailures(inventory, [...expected, ...caches.map((cache) => cache.path)]));
+    return { failures: [...new Set(failures)].sort(), caches };
+}

package/dist/cli/native-skill-install.d.ts

@@ -0,0 +1,2 @@
+import type { PackageMetadata } from "./types.ts";
+export declare function ensureNativeSkills(root: string, metadata: PackageMetadata): Promise<void>;

package/dist/cli/native-skill-install.js

@@ -0,0 +1,128 @@
+import { randomUUID } from "node:crypto";
+import { prepareCanonicalBackup } from "./native-canonical-backup.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { litOpenCodeRuntimeSkills } from "../skills.js";
+import { assetPathsForManagedSkill, installedCanonicalDirectory, managedSkillDefinition, previousManagedSkillId } from "./managed-skill-assets.js";
+import { destinationState, assertInstalledCanonicalOwnership, invalidInstalledAssets, nativeSkillContent, nativeSkillsRoot, sourceSkillDir, validateSkillSource } from "./native-skill-integrity.js";
+import { assertContained, lstatIfPresent } from "./native-skill-tree.js";
+async function createStagedSkill(skillsRoot, metadata, skill) {
+    const stage = path.join(skillsRoot, `.${skill.id}.${randomUUID()}.stage`);
+    await fs.mkdir(stage, { recursive: false });
+    try {
+        await fs.writeFile(path.join(stage, "SKILL.md"), await nativeSkillContent(metadata, skill), "utf8");
+        for (const relativePath of assetPathsForManagedSkill(skill.id)) {
+            const destination = path.join(stage, relativePath);
+            assertContained(stage, destination, `Staged native skill ${skill.id}`);
+            await fs.mkdir(path.dirname(destination), { recursive: true });
+            await fs.copyFile(path.join(sourceSkillDir(metadata, skill.id), relativePath), destination);
+        }
+        const definition = managedSkillDefinition(skill.id);
+        if (definition?.canonicalRoot !== undefined) {
+            const canonicalRoot = path.resolve(sourceSkillDir(metadata, skill.id), definition.canonicalRoot);
+            for (const asset of definition.canonicalFiles) {
+                const source = path.join(canonicalRoot, asset.path);
+                const destination = path.join(stage, installedCanonicalDirectory, asset.path);
+                assertContained(canonicalRoot, source, `Canonical source ${skill.id}`);
+                assertContained(stage, destination, `Staged canonical ${skill.id}`);
+                await fs.mkdir(path.dirname(destination), { recursive: true });
+                await fs.copyFile(source, destination);
+            }
+        }
+        const failures = await invalidInstalledAssets(stage, metadata, skill);
+        if (failures.length > 0)
+            throw new Error(`Staged native skill ${skill.id} failed verification: ${failures.join(", ")}`);
+        return stage;
+    }
+    catch (error) {
+        await fs.rm(stage, { recursive: true, force: true });
+        throw error;
+    }
+}
+async function swapStagedSkill(root, skillsRoot, target, stage, skill, caches) {
+    const id = skill.id;
+    if (await lstatIfPresent(target) === null) {
+        await fs.rename(stage, target);
+        return;
+    }
+    const retained = caches.length === 0 ? undefined : await prepareCanonicalBackup(root, skillsRoot, skill, caches);
+    const backup = retained?.backup ?? path.join(skillsRoot, `.${id}.${randomUUID()}.backup`);
+    await retained?.validateBeforeMove();
+    await fs.rename(target, backup);
+    try {
+        await retained?.validateMoved();
+        if (retained !== undefined && await lstatIfPresent(target) !== null)
+            throw new Error(`Native skill target appeared during replacement: ${target}`);
+        await fs.rename(stage, target);
+        await retained?.complete();
+    }
+    catch (error) {
+        try {
+            await retained?.validateMoved();
+            if (retained !== undefined && await lstatIfPresent(target) !== null)
+                throw new Error(`Unsafe rollback target already exists: ${target}`);
+            await fs.rename(backup, target);
+        }
+        catch (rollbackError) {
+            throw new Error(retained === undefined
+                ? `Atomic native skill swap failed for ${id}, and rollback failed; previous tree remains at ${backup}: ${String(error)}; rollback: ${String(rollbackError)}`
+                : `Atomic native skill swap failed for ${id}; rollback unsafe or failed, state unknown; previous tree last recorded at ${backup}: ${String(error)}; rollback: ${String(rollbackError)}`);
+        }
+        throw new Error(`Atomic native skill swap failed for ${id}; previous tree was restored: ${String(error)}`);
+    }
+    if (retained === undefined)
+        await fs.rm(backup, { recursive: true, force: true });
+}
+async function stagedCleanup(stage) {
+    const identity = await fs.lstat(stage, { bigint: true });
+    const real = await fs.realpath(stage);
+    return async () => {
+        if (await lstatIfPresent(stage) === null)
+            return;
+        const current = await fs.lstat(stage, { bigint: true });
+        if (!current.isDirectory() || current.isSymbolicLink() || current.dev !== identity.dev ||
+            current.ino !== identity.ino || current.birthtimeNs !== identity.birthtimeNs || await fs.realpath(stage) !== real) {
+            throw new Error(`Staged cleanup refused changed identity or ancestry; preserve ${stage}`);
+        }
+        await fs.rm(stage, { recursive: true, force: true });
+    };
+}
+export async function ensureNativeSkills(root, metadata) {
+    const skillsRoot = await nativeSkillsRoot(root);
+    await fs.mkdir(skillsRoot, { recursive: true });
+    for (const skill of litOpenCodeRuntimeSkills) {
+        await validateSkillSource(metadata, skill);
+        const previousId = previousManagedSkillId(skill.id);
+        const destination = await destinationState(root, skill);
+        if (destination.kind === "preserved")
+            continue;
+        await assertInstalledCanonicalOwnership(root, skill);
+        const stage = await createStagedSkill(skillsRoot, metadata, skill);
+        const removeStage = await stagedCleanup(stage);
+        try {
+            const current = await destinationState(root, skill);
+            if (current.kind === "preserved") {
+                await removeStage();
+                continue;
+            }
+            const caches = await assertInstalledCanonicalOwnership(root, skill);
+            await swapStagedSkill(root, skillsRoot, path.join(skillsRoot, skill.id), stage, skill, caches);
+            if (previousId !== undefined) {
+                const previousRoot = path.join(skillsRoot, previousId);
+                assertContained(skillsRoot, previousRoot, `Previous native skill ${skill.id}`);
+                const previous = await destinationState(root, { id: previousId });
+                if (previous.kind === "managed")
+                    await fs.rm(previousRoot, { recursive: true });
+            }
+        }
+        catch (error) {
+            try {
+                await removeStage();
+            }
+            catch (cleanupError) {
+                throw new Error(`${String(error)}; ${String(cleanupError)}`);
+            }
+            throw error;
+        }
+    }
+}