@litfamily/litopencode 1.0.0

package/dist/cli/command-aliases.js

@@ -0,0 +1,112 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { findLitOpenCodeCommand, litOpenCodeCommands } from "../commands.js";
+import { renamedSkillIds, skillRenameNote } from "../skill-renames.js";
+import { hasLitOpenCodeGeneratedFileMarker, litOpenCodeGeneratedFrontmatterMarker } from "../user-facing-markdown.js";
+import { lstatIfPresent } from "./native-skill-tree.js";
+function commandAliasFile(root, id) {
+    return path.join(root, "command", id + ".md");
+}
+function commandAliasContent(command) {
+    return [
+        "---",
+        "description: " + JSON.stringify(command.title + " - " + command.description),
+        ...(command.agent === undefined ? [] : ["agent: " + command.agent]),
+        litOpenCodeGeneratedFrontmatterMarker,
+        "---",
+        "",
+        command.activationText,
+        ""
+    ].join("\n");
+}
+async function readTextIfPresent(filePath) {
+    try {
+        return await fs.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+export async function describeCommandAliasMutation(root) {
+    const write = [];
+    const preserve = [];
+    for (const command of litOpenCodeCommands) {
+        const filePath = commandAliasFile(root, command.id);
+        const existing = await readTextIfPresent(filePath);
+        if (existing === null || hasLitOpenCodeGeneratedFileMarker(existing)) {
+            write.push(command.id);
+        }
+        else {
+            preserve.push(command.id);
+        }
+    }
+    return {
+        path: path.join(root, "command"),
+        changed: write.length > 0,
+        write,
+        preserve
+    };
+}
+export async function inspectCommandAliases(root) {
+    const present = [];
+    const missing = [];
+    const managed = [];
+    const preserved = [];
+    for (const command of litOpenCodeCommands) {
+        const existing = await readTextIfPresent(commandAliasFile(root, command.id));
+        if (existing === null)
+            missing.push(command.id);
+        else {
+            present.push(command.id);
+            if (hasLitOpenCodeGeneratedFileMarker(existing))
+                managed.push(command.id);
+            else
+                preserved.push(command.id);
+        }
+    }
+    return {
+        path: path.join(root, "command"),
+        expected: litOpenCodeCommands.map((command) => command.id),
+        present,
+        missing,
+        managed,
+        preserved,
+        ok: missing.length === 0
+    };
+}
+export async function ensureCommandAliases(root) {
+    const commandDir = path.join(root, "command");
+    await fs.mkdir(commandDir, { recursive: true });
+    for (const command of litOpenCodeCommands) {
+        const filePath = commandAliasFile(root, command.id);
+        const existing = await readTextIfPresent(filePath);
+        if (existing !== null && !hasLitOpenCodeGeneratedFileMarker(existing))
+            continue;
+        await fs.writeFile(filePath, commandAliasContent(command), "utf8");
+    }
+    for (const id of Object.keys(renamedSkillIds)) {
+        const filePath = commandAliasFile(root, renamedSkillIds[id]);
+        const stat = await lstatIfPresent(filePath);
+        if (stat !== null && (stat.isSymbolicLink() || !stat.isFile())) {
+            throw new Error(`Unsafe command redirect destination: ${filePath}`);
+        }
+        const existing = await readTextIfPresent(filePath);
+        if (existing !== null && !hasLitOpenCodeGeneratedFileMarker(existing))
+            continue;
+        const command = findLitOpenCodeCommand(id);
+        if (command === undefined)
+            throw new Error(`Missing redirect target: ${id}`);
+        await fs.writeFile(filePath, [
+            "---",
+            `description: ${JSON.stringify(`Redirect to /${id}`)}`,
+            ...(command.agent === undefined ? [] : [`agent: ${command.agent}`]),
+            litOpenCodeGeneratedFrontmatterMarker,
+            "---",
+            "",
+            `Invoke /${id} with the supplied arguments and follow its skill contract. Print this line once: ${skillRenameNote(id)}`,
+            ""
+        ].join("\n"), "utf8");
+    }
+}

package/dist/cli/doctor.d.ts

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

package/dist/cli/doctor.js

@@ -0,0 +1,175 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { litOpenCodeAgents, registerLitOpenCodeAgents } from "../agents.js";
+import { defaultGlobalConfigFile, loadConfig, mergeConfigs, readLitOpenCodeConfigFile } from "../config.js";
+import { diagnoseModelRoutes, effectiveAuthoredAgentRoutes, projectModelRoutesForDiagnostics } from "../model-route-policy.js";
+import { litOpenCodeConfigFileForOpenCodeRoot } from "../state.js";
+import { isRecord, readJsonObjectIfPresent, readPackageMetadata } from "./json.js";
+import { inspectCommandAliases } from "./command-aliases.js";
+import { inspectNativeSkills } from "./native-skills.js";
+import { openCodeHostCapabilities } from "./host-capabilities.js";
+import { inspectHostLimits } from "./host-limits.js";
+import { inspectLspCapability } from "./lsp-capability.js";
+import { isLitOpenCodeEntry } from "./plugin-mutation.js";
+import { autoUpdateInstallLockPath, autoUpdateJournalPath, autoUpdateReceiptPath, isAutoUpdateDisabled, readAutoUpdateReceipt } from "./auto-update.js";
+function pluginSpec(metadata) {
+    return metadata.name + "@" + metadata.version;
+}
+function pluginEntryId(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value) && typeof value[0] === "string")
+        return value[0];
+    return "";
+}
+function stripJsonComments(value) {
+    return value.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "");
+}
+async function readOpenCodeConfig(root) {
+    const resolvedRoot = path.resolve(root);
+    const candidates = [path.join(resolvedRoot, "opencode.json"), path.join(resolvedRoot, "opencode.jsonc")];
+    for (const candidate of candidates) {
+        let raw;
+        try {
+            raw = await fs.readFile(candidate, "utf8");
+        }
+        catch (error) {
+            if (error instanceof Error && "code" in error && error.code === "ENOENT")
+                continue;
+            throw error;
+        }
+        try {
+            const parsed = JSON.parse(candidate.endsWith(".jsonc") ? stripJsonComments(raw) : raw);
+            return { path: candidate, config: isRecord(parsed) ? parsed : null, ...(isRecord(parsed) ? {} : { error: "expected object" }) };
+        }
+        catch (error) {
+            return { path: candidate, config: null, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    return { path: candidates[0], config: null };
+}
+async function isLocalPackageEntry(root, value, packageName) {
+    if (!(path.isAbsolute(value) || value.startsWith(".")))
+        return false;
+    const packagePath = path.join(path.isAbsolute(value) ? value : path.resolve(root, value), "package.json");
+    const metadata = await readJsonObjectIfPresent(packagePath);
+    return metadata?.name === packageName;
+}
+async function inspectPlugin(root, metadata) {
+    const expected = pluginSpec(metadata);
+    const openCodeConfig = await readOpenCodeConfig(root);
+    const pluginValue = openCodeConfig.config?.plugin;
+    const entries = Array.isArray(pluginValue) ? pluginValue : [];
+    let configured = null;
+    let present = false;
+    for (const entry of entries) {
+        const id = pluginEntryId(entry);
+        if (id === expected || (await isLocalPackageEntry(root, id, metadata.name))) {
+            configured = id;
+            present = true;
+            break;
+        }
+        if (configured === null && isLitOpenCodeEntry(entry))
+            configured = id;
+    }
+    return {
+        path: openCodeConfig.path,
+        expected,
+        configured,
+        present,
+        ok: present && openCodeConfig.error === undefined,
+        ...(openCodeConfig.error === undefined ? {} : { error: openCodeConfig.error })
+    };
+}
+export async function doctor(root) {
+    const metadata = await readPackageMetadata();
+    const loaded = await loadConfig(root);
+    const openCodeLitConfigPath = litOpenCodeConfigFileForOpenCodeRoot(root);
+    const openCodeLitConfig = await readLitOpenCodeConfigFile(openCodeLitConfigPath);
+    const effectiveOpenCodeConfig = openCodeLitConfig === undefined ? defaultGlobalConfigFile() : mergeConfigs(defaultGlobalConfigFile(), openCodeLitConfig);
+    const effectiveRoutes = effectiveAuthoredAgentRoutes(effectiveOpenCodeConfig, litOpenCodeAgents.map((agent) => agent.id));
+    const routeDiagnostics = diagnoseModelRoutes(effectiveRoutes);
+    let reportedRoutes = effectiveRoutes;
+    if (routeDiagnostics.length === 0) {
+        const projectedTarget = {};
+        registerLitOpenCodeAgents(projectedTarget, effectiveOpenCodeConfig);
+        reportedRoutes = Object.fromEntries(litOpenCodeAgents.map((agent) => [
+            agent.id,
+            projectedTarget.agent?.[agent.id] === undefined
+                ? effectiveRoutes[agent.id]
+                : { ...effectiveRoutes[agent.id], ...projectedTarget.agent[agent.id] }
+        ]));
+    }
+    const runtimeExists = await fs
+        .stat(loaded.paths.runtimeDir)
+        .then(() => true)
+        .catch((error) => {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return false;
+        throw error;
+    });
+    const installPlugin = await inspectPlugin(root, metadata);
+    const commandAliases = await inspectCommandAliases(root);
+    const nativeSkills = await inspectNativeSkills(root, metadata);
+    const hostConfig = await readOpenCodeConfig(root);
+    return {
+        exitCode: 0,
+        stdout: JSON.stringify({
+            package: metadata,
+            capabilities: openCodeHostCapabilities(),
+            hostLimits: { path: hostConfig.path, ...inspectHostLimits(hostConfig.config) },
+            lsp: inspectLspCapability(hostConfig.config),
+            config: {
+                source: loaded.source,
+                sources: loaded.sources,
+                path: loaded.paths.configFile,
+                enabled: loaded.config.enabled,
+                logLevel: loaded.config.logLevel,
+                knowledgeCapture: loaded.config.knowledge.capture
+            },
+            opencodeConfig: {
+                path: openCodeLitConfigPath,
+                exists: openCodeLitConfig !== undefined,
+                permissionMode: effectiveOpenCodeConfig.permissionMode,
+                agents: Object.keys(effectiveOpenCodeConfig.agents),
+                categories: Object.keys(effectiveOpenCodeConfig.categories),
+                effective: projectModelRoutesForDiagnostics(reportedRoutes, routeDiagnostics),
+                routeDiagnostics
+            },
+            state: {
+                runtimeDir: loaded.paths.runtimeDir,
+                runtimeExists,
+                stateFile: loaded.paths.stateFile,
+                logFile: loaded.paths.logFile,
+                ledgerFile: loaded.paths.ledgerFile,
+                boundedAuthority: {
+                    schemaVersion: 3,
+                    stateFile: loaded.paths.lifecycleStateFile,
+                    eventsFile: loaded.paths.lifecycleEventsFile,
+                    ...loaded.config.boundedAuthority
+                },
+                knowledge: {
+                    directory: loaded.paths.knowledgeDir,
+                    authority: loaded.paths.knowledgeClaimsFile,
+                    captureEnabled: loaded.config.knowledge.capture,
+                    normalQueryBudgetBytes: 2048,
+                    hardQueryLimitBytes: 4096,
+                    derivedTruthFiles: false
+                }
+            },
+            autoUpdate: {
+                enabled: !isAutoUpdateDisabled(process.env),
+                installLock: autoUpdateInstallLockPath(),
+                journal: autoUpdateJournalPath(),
+                receipt: autoUpdateReceiptPath(),
+                lastReceipt: await readAutoUpdateReceipt()
+            },
+            install: {
+                ok: installPlugin.ok && commandAliases.ok && nativeSkills.ok,
+                plugin: installPlugin,
+                commandAliases,
+                nativeSkills
+            }
+        }, null, 2)
+    };
+}

package/dist/cli/host-capabilities.d.ts

@@ -0,0 +1,12 @@
+export type HostCapabilityStatus = "hard" | "advisory" | "unavailable";
+export type HostCapability = {
+    readonly status: HostCapabilityStatus;
+    readonly reason: string;
+    readonly observedSource: string;
+};
+export type OpenCodeHostCapabilities = {
+    readonly contextCeiling372k: HostCapability;
+    readonly autoCompaction334800: HostCapability;
+    readonly subagentConcurrency20: HostCapability;
+};
+export declare function openCodeHostCapabilities(): OpenCodeHostCapabilities;

package/dist/cli/host-capabilities.js

@@ -0,0 +1,25 @@
+import { compactionTriggerTokens, contextCeilingTokens } from "./host-limits.js";
+export function openCodeHostCapabilities() {
+    const observedSource = "OpenCode 1.17.18 config schema and session overflow implementation";
+    return {
+        contextCeiling372k: {
+            status: "hard",
+            reason: "OpenCode accepts provider model input and context limits; LitOpenCode configures the exact " + contextCeilingTokens + " token ceiling.",
+            observedSource
+        },
+        autoCompaction334800: {
+            status: "hard",
+            reason: "OpenCode compacts at model input minus the reserved buffer; " +
+                contextCeilingTokens +
+                " minus 37200 yields " +
+                compactionTriggerTokens +
+                ".",
+            observedSource
+        },
+        subagentConcurrency20: {
+            status: "advisory",
+            reason: "Use at most 20 concurrent subagents; OpenCode exposes no verified numeric hard-limit setting.",
+            observedSource
+        }
+    };
+}

package/dist/cli/host-limits.d.ts

@@ -0,0 +1,21 @@
+export declare const contextCeilingTokens = 372000;
+export declare const compactionTriggerTokens = 334800;
+export declare const compactionReserveTokens: number;
+export declare const offeredGpt56Models: readonly ["gpt-5.6-luna"];
+export type HostLimitMutation = {
+    readonly reconfigure: boolean;
+    readonly changed: boolean;
+    readonly contextCeilingTokens: number;
+    readonly compactionTriggerTokens: number;
+    readonly compactionReserveTokens: number;
+};
+export type HostLimitState = {
+    readonly status: "configured" | "unconfigured";
+    readonly contextCeilingTokens: number;
+    readonly compactionTriggerTokens: number;
+    readonly compactionReserveTokens: number;
+};
+export declare function applyHostLimits(config: Record<string, unknown> | null): Record<string, unknown>;
+export declare function describeHostLimitMutation(config: Record<string, unknown> | null, reconfigure: boolean): HostLimitMutation;
+export declare function inspectHostLimits(config: Record<string, unknown> | null): HostLimitState;
+export declare function ensureHostLimits(configPath: string, config: Record<string, unknown> | null, reconfigure: boolean): Promise<void>;

package/dist/cli/host-limits.js

@@ -0,0 +1,83 @@
+import { isRecord } from "./json.js";
+import { writeTextAtomically } from "./install-config.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+export const contextCeilingTokens = 372000;
+export const compactionTriggerTokens = 334800;
+export const compactionReserveTokens = contextCeilingTokens - compactionTriggerTokens;
+export const offeredGpt56Models = ["gpt-5.6-luna"];
+class HostConfigShapeError extends Error {
+    path;
+    constructor(path) {
+        super("Malformed OpenCode host config: " + path + " must be an object.");
+        this.name = "HostConfigShapeError";
+        this.path = path;
+    }
+}
+function optionalRecord(value, path) {
+    if (value === undefined)
+        return {};
+    if (isRecord(value))
+        return value;
+    throw new HostConfigShapeError(path);
+}
+function modelLimit() {
+    return {
+        context: contextCeilingTokens,
+        input: contextCeilingTokens,
+        output: 128000
+    };
+}
+export function applyHostLimits(config) {
+    const current = config ?? { "$schema": "https://opencode.ai/config.json" };
+    const provider = optionalRecord(current.provider, "provider");
+    const openai = optionalRecord(provider.openai, "provider.openai");
+    const models = optionalRecord(openai.models, "provider.openai.models");
+    const nextModels = { ...models };
+    for (const model of offeredGpt56Models) {
+        const currentModel = optionalRecord(models[model], "provider.openai.models." + model);
+        const limit = optionalRecord(currentModel.limit, "provider.openai.models." + model + ".limit");
+        nextModels[model] = { ...currentModel, limit: { ...limit, ...modelLimit() } };
+    }
+    return {
+        ...current,
+        compaction: { ...optionalRecord(current.compaction, "compaction"), auto: true, reserved: compactionReserveTokens },
+        provider: { ...provider, openai: { ...openai, models: nextModels } }
+    };
+}
+export function describeHostLimitMutation(config, reconfigure) {
+    if (!reconfigure) {
+        return {
+            reconfigure,
+            changed: false,
+            contextCeilingTokens,
+            compactionTriggerTokens,
+            compactionReserveTokens
+        };
+    }
+    return {
+        reconfigure,
+        changed: JSON.stringify(config) !== JSON.stringify(applyHostLimits(config)),
+        contextCeilingTokens,
+        compactionTriggerTokens,
+        compactionReserveTokens
+    };
+}
+export function inspectHostLimits(config) {
+    const next = applyHostLimits(config);
+    return {
+        status: JSON.stringify(config) === JSON.stringify(next) ? "configured" : "unconfigured",
+        contextCeilingTokens,
+        compactionTriggerTokens,
+        compactionReserveTokens
+    };
+}
+export async function ensureHostLimits(configPath, config, reconfigure) {
+    if (!reconfigure)
+        return;
+    const next = applyHostLimits(config);
+    if (JSON.stringify(config) === JSON.stringify(next))
+        return;
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    await writeTextAtomically(configPath, JSON.stringify(next, null, 2) + "\n");
+}

package/dist/cli/install-config.d.ts

@@ -0,0 +1,13 @@
+import type { InstallModelSelection, InstallPermissionMode, InstallReport, ModelConfigClassification } from "./types.ts";
+type AtomicWriteOverrides = {
+    readonly rename?: (from: string, to: string) => Promise<void>;
+};
+export declare function writeTextAtomically(filePath: string, text: string, overrides?: AtomicWriteOverrides): Promise<void>;
+export declare function readInstallModelClassification(root: string): Promise<ModelConfigClassification>;
+export declare function readInstallModelSelection(root: string): Promise<InstallModelSelection | undefined>;
+export declare function assertExistingModelRoutesSafe(root: string): Promise<void>;
+export declare function describeInstallRoutes(root: string, hostConfig: Record<string, unknown> | null, selection: InstallModelSelection | undefined, permissionMode: InstallPermissionMode, permissionModeExplicit: boolean, outputStyle: string): Promise<NonNullable<InstallReport["routes"]>>;
+export declare function readExistingOutputStyle(root: string): Promise<string>;
+export declare function describeLitConfigMutation(root: string, selection: InstallModelSelection | undefined, permissionMode: InstallPermissionMode, permissionModeExplicit: boolean, outputStyle?: string): Promise<InstallReport["litopencodeConfig"]>;
+export declare function ensureLitConfig(root: string, selection: InstallModelSelection | undefined, permissionMode: InstallPermissionMode, permissionModeExplicit: boolean, outputStyle?: string): Promise<void>;
+export {};

package/dist/cli/install-config.js

@@ -0,0 +1,201 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { litOpenCodeAgents, registerLitOpenCodeAgents } from "../agents.js";
+import { defaultGlobalConfigFile, defaultGlobalConfigJson, mergeConfigs, readLitOpenCodeConfigFile } from "../config.js";
+import { diagnoseModelRoutes, effectiveAuthoredAgentRoutes, UnsafeModelRouteError } from "../model-route-policy.js";
+import { litOpenCodeConfigFileForOpenCodeRoot } from "../state.js";
+import { isRecord, readJsonObjectIfPresent } from "./json.js";
+import { isModelProvider, modelMenuRows, stripFastSuffix } from "./model-catalog.js";
+import { classifyModelConfig, selectedLitConfig } from "./model-policy.js";
+export async function writeTextAtomically(filePath, text, overrides = {}) {
+    const tempPath = path.join(path.dirname(filePath), "." + path.basename(filePath) + ".tmp-" + randomUUID());
+    try {
+        await fs.writeFile(tempPath, text, { encoding: "utf8", flag: "wx", mode: 0o600 });
+        await (overrides.rename ?? fs.rename)(tempPath, filePath);
+    }
+    catch (error) {
+        await fs.rm(tempPath, { force: true });
+        throw error;
+    }
+}
+async function readValidatedConfig(root) {
+    const filePath = litOpenCodeConfigFileForOpenCodeRoot(root);
+    if ((await readLitOpenCodeConfigFile(filePath)) === undefined)
+        return null;
+    return await readJsonObjectIfPresent(filePath);
+}
+function sameJson(left, right) {
+    return left !== null && JSON.stringify(left) === JSON.stringify(right);
+}
+function uniformExistingVariant(config) {
+    if (config === null || !isRecord(config.categories))
+        return undefined;
+    const variants = Object.values(config.categories).map((category) => isRecord(category) && typeof category.variant === "string" ? category.variant : undefined);
+    const first = variants[0];
+    return first !== undefined && variants.every((variant) => variant === first) ? first : undefined;
+}
+export async function readInstallModelClassification(root) {
+    return classifyModelConfig(await readValidatedConfig(root));
+}
+const installCategories = ["planning", "execution", "review", "research"];
+const installEfforts = ["low", "medium", "high", "xhigh", "max"];
+function existingInstallRoute(value) {
+    if (!isRecord(value) || typeof value.provider !== "string" || !isModelProvider(value.provider))
+        return undefined;
+    if (typeof value.model !== "string" || value.model.includes("/") || value.reasoningEffort !== undefined)
+        return undefined;
+    const model = value.provider === "openai" ? stripFastSuffix(value.model) : value.model;
+    const row = modelMenuRows(value.provider).find((candidate) => candidate.model === model);
+    if (row === undefined)
+        return undefined;
+    if (value.variant === undefined)
+        return { provider: value.provider, model: value.model };
+    if (typeof value.variant !== "string" || !installEfforts.includes(value.variant))
+        return undefined;
+    if (!row.efforts.includes(value.variant))
+        return undefined;
+    return { provider: value.provider, model: value.model, effort: value.variant };
+}
+function sameInstallRoute(left, right) {
+    return left.provider === right.provider && left.model === right.model && left.effort === right.effort;
+}
+export async function readInstallModelSelection(root) {
+    const existing = await readValidatedConfig(root);
+    if (existing === null)
+        return undefined;
+    const categories = existing.categories;
+    if (!isRecord(categories))
+        return undefined;
+    const routes = installCategories.map((category) => existingInstallRoute(categories[category]));
+    const [planning, execution, review, research] = routes;
+    if (planning === undefined || execution === undefined || review === undefined || research === undefined)
+        return undefined;
+    if (!sameInstallRoute(planning, review) || !sameInstallRoute(execution, research))
+        return undefined;
+    return { ...planning, helper: execution };
+}
+export async function assertExistingModelRoutesSafe(root) {
+    const existing = await readValidatedConfig(root);
+    if (existing === null)
+        return;
+    const config = mergeConfigs(defaultGlobalConfigFile(), existing);
+    const diagnostics = diagnoseModelRoutes(effectiveAuthoredAgentRoutes(config, Object.keys(config.agents)));
+    if (diagnostics.length > 0)
+        throw new UnsafeModelRouteError(diagnostics);
+}
+function hostAgents(value) {
+    if (value === undefined)
+        return {};
+    if (!isRecord(value))
+        throw new Error("Malformed OpenCode host config: agent must be an object.");
+    const agents = {};
+    for (const [agentId, agent] of Object.entries(value)) {
+        if (!isRecord(agent))
+            throw new Error(`Malformed OpenCode host config: agent.${agentId} must be an object.`);
+        agents[agentId] = agent;
+    }
+    return agents;
+}
+function sameJsonValue(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+function projectedRoute(agentId, value) {
+    if (!isRecord(value))
+        throw new Error(`Unsafe installer route: managed agent ${agentId} is not an object.`);
+    return {
+        agentId,
+        ...(typeof value.model === "string" ? { model: value.model } : {}),
+        ...(typeof value.variant === "string" ? { variant: value.variant } : {}),
+        ...(typeof value.reasoningEffort === "string" ? { reasoningEffort: value.reasoningEffort } : {}),
+        status: "configured"
+    };
+}
+export async function describeInstallRoutes(root, hostConfig, selection, permissionMode, permissionModeExplicit, outputStyle) {
+    const existing = await readValidatedConfig(root);
+    const selected = selectedLitConfig(existing, selection, permissionMode, permissionModeExplicit, outputStyle);
+    const effective = mergeConfigs(defaultGlobalConfigFile(), selected);
+    const existingAgents = hostAgents(hostConfig?.agent);
+    const target = { agent: { ...existingAgents } };
+    registerLitOpenCodeAgents(target, effective);
+    const registeredAgents = target.agent;
+    if (!isRecord(registeredAgents))
+        throw new Error("Unsafe installer route: registered agent map is malformed.");
+    const managed = Object.fromEntries(litOpenCodeAgents.map((agent) => [agent.id, projectedRoute(agent.id, registeredAgents[agent.id])]));
+    const preservedAgents = Object.entries(existingAgents)
+        .filter(([agentId, agent]) => sameJsonValue(agent, registeredAgents[agentId]))
+        .map(([agentId]) => agentId);
+    const planningAgent = registeredAgents["lit-plan"];
+    const planningPermissions = isRecord(planningAgent) ? planningAgent.permission : undefined;
+    const planningTools = isRecord(planningAgent) ? planningAgent.tools : undefined;
+    if (!isRecord(planningAgent) ||
+        !isRecord(planningPermissions) ||
+        planningPermissions.edit !== "deny" ||
+        planningPermissions.bash !== "deny" ||
+        planningPermissions.task !== "deny" ||
+        !isRecord(planningTools) ||
+        planningTools.write !== false ||
+        planningTools.edit !== false ||
+        planningTools.bash !== false ||
+        planningTools.task !== false) {
+        throw new Error("Unsafe installer route: lit-plan planning-only permissions are not enforced.");
+    }
+    return {
+        managed,
+        preservedAgents,
+        planningOnly: {
+            agentId: "lit-plan",
+            permissions: { edit: "deny", bash: "deny", task: "deny" },
+            tools: { write: false, edit: false, bash: false, task: false }
+        }
+    };
+}
+export async function readExistingOutputStyle(root) {
+    const config = await readValidatedConfig(root);
+    const style = config?.outputStyle;
+    return typeof style === "string" ? style : "off";
+}
+export async function describeLitConfigMutation(root, selection, permissionMode, permissionModeExplicit, outputStyle = "off") {
+    const filePath = litOpenCodeConfigFileForOpenCodeRoot(root);
+    const existing = await readValidatedConfig(root);
+    const defaults = defaultGlobalConfigJson();
+    const selected = selectedLitConfig(existing, selection, permissionMode, permissionModeExplicit, outputStyle);
+    const existingPermissionMode = existing?.permissionMode === "balanced" || existing?.permissionMode === "yolo" ? existing.permissionMode : "safe";
+    const existingOutputStyle = typeof existing?.outputStyle === "string" ? existing.outputStyle : "off";
+    const modelChanged = selection !== undefined && !sameJson(existing, selected);
+    const permissionChanged = permissionModeExplicit
+        ? existingPermissionMode !== permissionMode
+        : permissionMode !== "safe" && existingPermissionMode !== permissionMode;
+    const outputStyleChanged = outputStyle !== "off" && existingOutputStyle !== outputStyle;
+    const existingVariant = uniformExistingVariant(existing);
+    return {
+        path: filePath,
+        alreadyPresent: existing !== null,
+        changed: existing === null || modelChanged || permissionChanged || outputStyleChanged,
+        agents: isRecord(defaults.agents) ? Object.keys(defaults.agents) : [],
+        categories: isRecord(defaults.categories) ? Object.keys(defaults.categories) : [],
+        model: {
+            ...(selection ?? {}),
+            classification: classifyModelConfig(existing),
+            ...(existingVariant === undefined ? {} : { existingVariant }),
+            changed: modelChanged
+        },
+        permissionMode: {
+            mode: permissionModeExplicit || permissionMode !== "safe" ? permissionMode : existingPermissionMode,
+            changed: permissionChanged
+        },
+        outputStyle: {
+            style: outputStyle !== "off" ? outputStyle : existingOutputStyle,
+            changed: outputStyleChanged
+        }
+    };
+}
+export async function ensureLitConfig(root, selection, permissionMode, permissionModeExplicit, outputStyle = "off") {
+    const filePath = litOpenCodeConfigFileForOpenCodeRoot(root);
+    const existing = await readValidatedConfig(root);
+    const next = selectedLitConfig(existing, selection, permissionMode, permissionModeExplicit, outputStyle);
+    if (sameJson(existing, next))
+        return;
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await writeTextAtomically(filePath, JSON.stringify(next, null, 2) + "\n");
+}

package/dist/cli/install-report.d.ts

@@ -0,0 +1,2 @@
+import type { InstallReport } from "./types.ts";
+export declare function renderInstallReport(report: InstallReport): string;