@litfamily/litopencode 1.0.4 → 1.0.6

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

@@ -13,6 +13,62 @@ export type ProviderMenuRow = {
     readonly credentialEnv: string;
 };
 export declare const providerMenu: readonly ProviderMenuRow[];
+export declare const installModelEfforts: readonly ["low", "medium", "high", "xhigh", "max", "ultra"];
+export declare const nativeReasoningEfforts: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
+export declare const defaultOpenAiRoutes: Readonly<{
+    lead: Readonly<{
+        provider: "openai";
+        model: "gpt-6-astra";
+        effort: "xhigh";
+    }>;
+    helper: Readonly<{
+        provider: "openai";
+        model: "gpt-6-luna";
+        effort: "max";
+    }>;
+}>;
+export declare const newGenerationOpenAiModels: Readonly<{
+    readonly astra: "gpt-6-astra";
+    readonly sol: "gpt-6-sol";
+    readonly luna: "gpt-6-luna";
+}>;
+export declare const previousGenerationOpenAiModels: Readonly<{
+    readonly sol: "gpt-5.6-sol";
+    readonly terra: "gpt-5.6-terra";
+    readonly luna: "gpt-5.6-luna";
+    readonly family: "gpt-5.6";
+}>;
+export declare const legacyManagedModelIds: readonly ["gpt-5.4", "gpt-5.5"];
+export declare const legacyFastAliasModels: readonly ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-5.6"];
+export declare const hostLimitModelIds: readonly ["gpt-6-luna", "gpt-5.6-luna"];
+export declare const openaiRows: readonly ModelMenuRow[];
+export declare const openaiProviderModels: Readonly<{
+    "gpt-6-astra": Readonly<{
+        name: "GPT-6 Astra";
+        reasoning: true;
+        temperature: false;
+        tool_call: true;
+    }>;
+    "gpt-6-sol": Readonly<{
+        name: "GPT-6 Sol";
+        reasoning: true;
+        temperature: false;
+        tool_call: true;
+    }>;
+    "gpt-6-luna": Readonly<{
+        name: "GPT-6 Luna";
+        reasoning: true;
+        temperature: false;
+        tool_call: true;
+    }>;
+}>;
+export declare function openAiModelRow(model: string): ModelMenuRow | undefined;
+export declare function openAiModelEfforts(model: string): readonly InstallModelEffort[];
+export declare function isInstallModelEffort(value: string): value is InstallModelEffort;
+export declare function openaiModelHelpLine(): string;
+export declare function shippedDefaultsSummary(): string;
+export declare function legacyFastAliasHelp(): string;
+export declare function modelEffortHelp(): string;
 export declare function hostCatalogPath(): string;
 export declare function modelMenuRows(provider: ModelProvider): readonly ModelMenuRow[];
 export declare function isModelProvider(value: string): value is ModelProvider;

package/dist/cli/model-catalog.js

@@ -3,20 +3,77 @@ import os from "node:os";
 import path from "node:path";
 import { isRecord } from "./json.js";
 export const providerMenu = [
-    { provider: "openai", label: "OpenAI GPT-6 Astra / GPT-5.6 family", credentialEnv: "OPENAI_API_KEY" },
+    { provider: "openai", label: "OpenAI GPT-6 family / GPT-5.6 previous generation", credentialEnv: "OPENAI_API_KEY" },
     { provider: "xai", label: "xAI Grok", credentialEnv: "XAI_API_KEY" }
 ];
-const effortRank = ["low", "medium", "high", "xhigh", "max"];
-// The OpenAI rows are the product policy, not the host catalog. Astra is
-// reasoning-only: all five host-supported effort names are carried through
-// the native `variant`/`reasoningEffort` fields.
-const openaiRows = [
-    { provider: "openai", model: "gpt-6-astra", effort: "xhigh", efforts: ["low", "medium", "high", "xhigh", "max"], hint: "frontier reasoning (recommended lead)" },
-    { provider: "openai", model: "gpt-5.6-sol", effort: "xhigh", efforts: ["high", "xhigh", "max"], hint: "deepest reasoning, slowest (legacy lead)" },
-    { provider: "openai", model: "gpt-5.6-luna", effort: "max", efforts: ["high", "max"], hint: "balanced (recommended helper)" },
-    { provider: "openai", model: "gpt-5.6", effort: "high", efforts: ["high", "xhigh", "max"], hint: "" },
-    { provider: "openai", model: "gpt-5.6-terra", effort: "xhigh", efforts: ["high", "xhigh"], hint: "" }
+export const installModelEfforts = Object.freeze(["low", "medium", "high", "xhigh", "max", "ultra"]);
+export const nativeReasoningEfforts = Object.freeze(["none", "minimal", ...installModelEfforts]);
+export const defaultOpenAiRoutes = Object.freeze({
+    lead: Object.freeze({ provider: "openai", model: "gpt-6-astra", effort: "xhigh" }),
+    helper: Object.freeze({ provider: "openai", model: "gpt-6-luna", effort: "max" })
+});
+export const newGenerationOpenAiModels = Object.freeze({
+    astra: defaultOpenAiRoutes.lead.model,
+    sol: "gpt-6-sol",
+    luna: defaultOpenAiRoutes.helper.model
+});
+export const previousGenerationOpenAiModels = Object.freeze({
+    sol: "gpt-5.6-sol",
+    terra: "gpt-5.6-terra",
+    luna: "gpt-5.6-luna",
+    family: "gpt-5.6"
+});
+export const legacyManagedModelIds = Object.freeze(["gpt-5.4", "gpt-5.5"]);
+export const legacyFastAliasModels = Object.freeze([
+    previousGenerationOpenAiModels.sol,
+    previousGenerationOpenAiModels.terra,
+    previousGenerationOpenAiModels.luna,
+    previousGenerationOpenAiModels.family
+]);
+export const hostLimitModelIds = Object.freeze([
+    defaultOpenAiRoutes.helper.model,
+    previousGenerationOpenAiModels.luna
+]);
+// The OpenAI rows are the product policy, not the host catalog. Keep every
+// supported effort here so the picker, flags, config reader, and route guard
+// all consume one catalog rather than maintaining independent literal lists.
+export const openaiRows = [
+    { provider: "openai", model: defaultOpenAiRoutes.lead.model, effort: defaultOpenAiRoutes.lead.effort, efforts: installModelEfforts, hint: "frontier reasoning (recommended lead)" },
+    { provider: "openai", model: newGenerationOpenAiModels.sol, effort: "xhigh", efforts: installModelEfforts, hint: "coding lead (recommended alternative)" },
+    { provider: "openai", model: defaultOpenAiRoutes.helper.model, effort: defaultOpenAiRoutes.helper.effort, efforts: installModelEfforts.slice(0, 5), hint: "balanced (recommended helper)" },
+    { provider: "openai", model: previousGenerationOpenAiModels.sol, effort: "xhigh", efforts: ["high", "xhigh", "max"], hint: "deepest reasoning, previous generation" },
+    { provider: "openai", model: previousGenerationOpenAiModels.luna, effort: "max", efforts: ["high", "max"], hint: "balanced, previous generation" },
+    { provider: "openai", model: previousGenerationOpenAiModels.family, effort: "high", efforts: ["high", "xhigh", "max"], hint: "previous generation" },
+    { provider: "openai", model: previousGenerationOpenAiModels.terra, effort: "xhigh", efforts: ["high", "xhigh"], hint: "previous generation" }
 ];
+export const openaiProviderModels = Object.freeze({
+    [newGenerationOpenAiModels.astra]: Object.freeze({ name: "GPT-6 Astra", reasoning: true, temperature: false, tool_call: true }),
+    [newGenerationOpenAiModels.sol]: Object.freeze({ name: "GPT-6 Sol", reasoning: true, temperature: false, tool_call: true }),
+    [newGenerationOpenAiModels.luna]: Object.freeze({ name: "GPT-6 Luna", reasoning: true, temperature: false, tool_call: true })
+});
+export function openAiModelRow(model) {
+    return openaiRows.find((row) => row.model === model);
+}
+export function openAiModelEfforts(model) {
+    return openAiModelRow(model)?.efforts ?? [];
+}
+export function isInstallModelEffort(value) {
+    return installModelEfforts.includes(value);
+}
+export function openaiModelHelpLine() {
+    return openaiRows
+        .map((row) => `${row.model}·${row.effort} (${row.efforts.join("/")})`)
+        .join(", ");
+}
+export function shippedDefaultsSummary() {
+    return `GPT-6 Astra/${defaultOpenAiRoutes.lead.effort} lead + planning/review; GPT-6 Luna/${defaultOpenAiRoutes.helper.effort} execution/research helpers`;
+}
+export function legacyFastAliasHelp() {
+    return "The previous-generation GPT-5.6 rows retain their <id>-fast aliases; GPT-6 rows have no inferred -fast alias.";
+}
+export function modelEffortHelp() {
+    return `GPT-6 Astra and Sol accept ${installModelEfforts.join(", ")}; GPT-6 Luna accepts ${openAiModelEfforts(newGenerationOpenAiModels.luna).join(", ")} and rejects ultra.`;
+}
 // Used only when the host catalog (~/.cache/opencode/models.json) is absent or unreadable.
 const fallbackXaiRows = [
     { provider: "xai", model: "grok-4.6", effort: "xhigh", efforts: ["low", "medium", "high", "xhigh"], hint: "frontier reasoning (catalog unavailable)" },
@@ -30,7 +87,7 @@ export function hostCatalogPath() {
     return path.join(base, "opencode", "models.json");
 }
 function isEffort(value) {
-    return typeof value === "string" && effortRank.includes(value);
+    return typeof value === "string" && isInstallModelEffort(value);
 }
 function catalogEfforts(entry) {
     if (!Array.isArray(entry.reasoning_options))
@@ -43,7 +100,7 @@ function catalogEfforts(entry) {
             if (isEffort(value) && !values.includes(value))
                 values.push(value);
     }
-    return values.sort((left, right) => effortRank.indexOf(left) - effortRank.indexOf(right));
+    return values.sort((left, right) => installModelEfforts.indexOf(left) - installModelEfforts.indexOf(right));
 }
 function xaiRowsFromCatalog() {
     let parsed;
@@ -84,10 +141,14 @@ export function isModelProvider(value) {
 export function providerCredentialEnv(provider) {
     return providerMenu.find((row) => row.provider === provider)?.credentialEnv;
 }
-// OpenCode exposes `<id>-fast` as a priority-tier alias for legacy OpenAI
-// rows; Astra has no inferred `-fast` alias and remains an exact model id.
+// OpenCode exposes `<id>-fast` as a priority-tier alias for previous-generation
+// OpenAI rows; GPT-6 rows remain exact model ids.
 export function stripFastSuffix(model) {
-    return model !== "gpt-6-astra-fast" && model.endsWith("-fast") ? model.slice(0, -"-fast".length) : model;
+    return legacyFastAliasModels.includes(model)
+        ? model
+        : model.endsWith("-fast") && legacyFastAliasModels.includes(model.slice(0, -"-fast".length))
+            ? model.slice(0, -"-fast".length)
+            : model;
 }
 export function resolveModelRoute(provider, model, effort, optionName) {
     if (!isModelProvider(provider)) {
@@ -99,7 +160,7 @@ export function resolveModelRoute(provider, model, effort, optionName) {
         throw new Error(optionName + " model " + provider + "/" + model + " is not offered; choose one of " + rows.map((candidate) => candidate.model).join(", "));
     }
     if (effort !== undefined && !row.efforts.includes(effort)) {
-        if (row.model === "gpt-5.6-luna")
+        if (row.model === previousGenerationOpenAiModels.luna)
             throw new Error("Luna effort must be high or max");
         throw new Error(provider + "/" + model + " accepts effort " + row.efforts.join(", ") + " (got " + effort + ")");
     }

package/dist/cli/model-policy.js

@@ -1,11 +1,12 @@
 import { defaultGlobalConfigJson } from "../config.js";
 import { isRecord } from "./json.js";
+import { defaultOpenAiRoutes, legacyManagedModelIds, openAiModelEfforts, previousGenerationOpenAiModels } from "./model-catalog.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 canonicalModels = new Set([defaultOpenAiRoutes.helper.model, previousGenerationOpenAiModels.luna]);
+const offeredEfforts = new Set(openAiModelEfforts(previousGenerationOpenAiModels.luna));
+const astraEfforts = new Set(openAiModelEfforts(defaultOpenAiRoutes.lead.model));
+const legacyModels = new Set(legacyManagedModelIds);
 const managedLegacyRouteKeys = new Set(["provider", "model", "variant", "textVerbosity"]);
 function normalizedRoute(value) {
     if (!isRecord(value) || typeof value.model !== "string")
@@ -93,7 +94,7 @@ export function classifyModelConfig(rawConfig) {
     if (first.qualifiedModel)
         return result("custom", first.dispatchId);
     if (first.provider === "openai" &&
-        first.model === "gpt-6-astra" &&
+        first.model === defaultOpenAiRoutes.lead.model &&
         first.variant !== undefined &&
         astraEfforts.has(first.variant)) {
         return result("astra_managed", first.dispatchId);
@@ -103,7 +104,7 @@ export function classifyModelConfig(rawConfig) {
         (first.variant === undefined || offeredEfforts.has(first.variant))) {
         return result("gpt56_managed", first.dispatchId);
     }
-    if (first.provider === "openai" && /^gpt-5\.6(?:$|-)/u.test(first.model)) {
+    if (first.provider === "openai" && (first.model === previousGenerationOpenAiModels.family || first.model.startsWith(previousGenerationOpenAiModels.family + "-"))) {
         return result("gpt56_other", first.dispatchId);
     }
     return result("custom", first.dispatchId);

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

@@ -14,6 +14,22 @@ export type DestinationState = {
     readonly reason: string;
 };
 export declare function nativeSkillsRoot(root: string): Promise<string>;
+export type NativeSkillsRootLink = {
+    readonly path: string;
+    readonly target: string;
+    readonly gitRepositoryRoot?: string;
+};
+export declare function nativeSkillsRootLink(root: string, homeDir?: string): Promise<NativeSkillsRootLink | undefined>;
+export type ShadowSkillLocationId = "user-agents" | "user-claude" | "project-opencode" | "project-claude" | "project-agents";
+export type ShadowSkillLocation = {
+    readonly id: ShadowSkillLocationId;
+    readonly root: string;
+};
+export type ShadowedSkill = {
+    readonly id: string;
+    readonly locations: readonly ShadowSkillLocation[];
+};
+export declare function detectShadowedSkills(skillIds: readonly string[], managedSkillsRoot: string, homeDir?: string, workDir?: string): Promise<readonly ShadowedSkill[]>;
 export declare function sourceSkillDir(metadata: PackageMetadata, id: string): string;
 export declare function nativeSkillContent(metadata: PackageMetadata, skill: RuntimeSkill): Promise<string>;
 export declare function validateManagedSkillSource(metadata: PackageMetadata, id: ManagedSkillId): Promise<void>;

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

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import { litOpenCodeRuntimeSkills } from "../skills.js";
 import { hasLitOpenCodeGeneratedFileMarker, litOpenCodeGeneratedFrontmatterMarker, stripUserFacingHtmlCommentLines } from "../user-facing-markdown.js";
@@ -9,6 +10,85 @@ import { inspectCanonicalTree } from "./native-canonical-cache.js";
 export async function nativeSkillsRoot(root) {
     return resolveSafeDirectory(root, path.join(root, "skills"), "Native skills destination");
 }
+// Walks upward from `startDir` looking for a `.git` entry (directory or the gitdir-pointer file a
+// worktree/submodule uses), stopping once it reaches `homeDir` or the filesystem root so an
+// unrelated ancestor repository is never reported as the destination.
+async function gitRepositoryRootFor(startDir, homeDir) {
+    const home = path.resolve(homeDir);
+    const fsRoot = path.parse(startDir).root;
+    let current = path.resolve(startDir);
+    while (true) {
+        if ((await lstatIfPresent(path.join(current, ".git"))) !== null)
+            return current;
+        if (current === home || current === fsRoot)
+            return undefined;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
+// Reports the same symlink LitOpenCode intentionally follows for install (resolveSafeDirectory),
+// so users can see where their managed skills actually landed and whether that is a git work tree.
+export async function nativeSkillsRootLink(root, homeDir = os.homedir()) {
+    const skillsPath = path.join(path.resolve(root), "skills");
+    const stat = await lstatIfPresent(skillsPath);
+    if (stat === null || !stat.isSymbolicLink())
+        return undefined;
+    const target = await fs.realpath(skillsPath);
+    const gitRepositoryRoot = await gitRepositoryRootFor(target, homeDir);
+    return { path: skillsPath, target, ...(gitRepositoryRoot === undefined ? {} : { gitRepositoryRoot }) };
+}
+function shadowSkillCandidateRoots(homeDir, workDir) {
+    return [
+        { id: "user-agents", root: path.join(homeDir, ".agents", "skills") },
+        { id: "user-claude", root: path.join(homeDir, ".claude", "skills") },
+        { id: "project-opencode", root: path.join(workDir, ".opencode", "skills") },
+        { id: "project-claude", root: path.join(workDir, ".claude", "skills") },
+        { id: "project-agents", root: path.join(workDir, ".agents", "skills") }
+    ];
+}
+async function statIfPresent(filePath) {
+    try {
+        return await fs.stat(filePath);
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR"))
+            return null;
+        throw error;
+    }
+}
+async function realpathOrResolved(candidate) {
+    try {
+        return await fs.realpath(candidate);
+    }
+    catch {
+        return path.resolve(candidate);
+    }
+}
+// OpenCode also reads skills from these other, unmanaged roots; a same-named skill there can be
+// loaded instead of (or alongside) LitOpenCode's managed copy. This is informational only: it never
+// changes `ok`, because LitOpenCode does not own those directories.
+export async function detectShadowedSkills(skillIds, managedSkillsRoot, homeDir = os.homedir(), workDir = process.cwd()) {
+    const managedRealpath = await realpathOrResolved(managedSkillsRoot);
+    const candidates = shadowSkillCandidateRoots(homeDir, workDir);
+    const shadowed = [];
+    for (const id of skillIds) {
+        const locations = [];
+        for (const candidate of candidates) {
+            const entrypoint = path.join(candidate.root, id, "SKILL.md");
+            const stat = await statIfPresent(entrypoint);
+            if (stat === null || !stat.isFile())
+                continue;
+            if ((await realpathOrResolved(candidate.root)) === managedRealpath)
+                continue;
+            locations.push(candidate);
+        }
+        if (locations.length > 0)
+            shadowed.push({ id, locations });
+    }
+    return shadowed;
+}
 export function sourceSkillDir(metadata, id) {
     return path.join(metadata.packageRoot, "skills", id);
 }

package/dist/cli/native-skills.d.ts

@@ -1,7 +1,9 @@
+import { type NativeSkillsRootLink, type ShadowedSkill } from "./native-skill-integrity.ts";
 import { inspectScientificVisualizationDependencies } from "./scientific-visualization-dependencies.ts";
 import type { InstallReport, PackageMetadata } from "./types.ts";
 export { validateManagedSkillSource } from "./native-skill-integrity.ts";
 export { ensureNativeSkills } from "./native-skill-install.ts";
+export type { NativeSkillsRootLink, ShadowedSkill, ShadowSkillLocation, ShadowSkillLocationId } from "./native-skill-integrity.ts";
 export declare function describeNativeSkillMutation(root: string, metadata: PackageMetadata): Promise<InstallReport["nativeSkills"]>;
 export type NativeSkillInspection = {
     readonly path: string;
@@ -17,6 +19,12 @@ export type NativeSkillInspection = {
     readonly dependencies: {
         readonly "lit-scientific-visualization": ReturnType<typeof inspectScientificVisualizationDependencies>;
     };
+    readonly link?: NativeSkillsRootLink;
+    readonly shadowedSkills: readonly ShadowedSkill[];
     readonly ok: boolean;
 };
-export declare function inspectNativeSkills(root: string, metadata: PackageMetadata): Promise<NativeSkillInspection>;
+export type InspectNativeSkillsOptions = {
+    readonly homeDir?: string;
+    readonly workDir?: string;
+};
+export declare function inspectNativeSkills(root: string, metadata: PackageMetadata, options?: InspectNativeSkillsOptions): Promise<NativeSkillInspection>;

package/dist/cli/native-skills.js

@@ -1,9 +1,19 @@
 import path from "node:path";
 import { litOpenCodeRuntimeSkills } from "../skills.js";
-import { destinationState, assertInstalledCanonicalOwnership, invalidInstalledAssets, validateSkillSource } from "./native-skill-integrity.js";
+import { destinationState, assertInstalledCanonicalOwnership, detectShadowedSkills, invalidInstalledAssets, nativeSkillsRoot, nativeSkillsRootLink, validateSkillSource } from "./native-skill-integrity.js";
 import { inspectScientificVisualizationDependencies } from "./scientific-visualization-dependencies.js";
 export { validateManagedSkillSource } from "./native-skill-integrity.js";
 export { ensureNativeSkills } from "./native-skill-install.js";
+// nativeSkillsRoot() follows the same intentional-symlink resolution install uses; if it fails,
+// fall back to the unresolved path so link/shadow reporting stays best-effort instead of throwing.
+async function bestEffortNativeSkillsRoot(root) {
+    try {
+        return await nativeSkillsRoot(root);
+    }
+    catch {
+        return path.join(root, "skills");
+    }
+}
 export async function describeNativeSkillMutation(root, metadata) {
     const write = [];
     const preserve = [];
@@ -21,15 +31,17 @@ export async function describeNativeSkillMutation(root, metadata) {
                 collisions.push(skill.id);
         }
     }
+    const link = await nativeSkillsRootLink(root);
     return {
         path: path.join(root, "skills"),
         changed: write.length > 0,
         write,
         preserve,
-        collisions
+        collisions,
+        ...(link === undefined ? {} : { link })
     };
 }
-export async function inspectNativeSkills(root, metadata) {
+export async function inspectNativeSkills(root, metadata, options = {}) {
     const present = [];
     const missing = [];
     const managed = [];
@@ -88,6 +100,8 @@ export async function inspectNativeSkills(root, metadata) {
         }
     }
     const uniqueInvalid = [...new Set(invalid)];
+    const link = await nativeSkillsRootLink(root, options.homeDir);
+    const shadowedSkills = await detectShadowedSkills(litOpenCodeRuntimeSkills.map((skill) => skill.id), await bestEffortNativeSkillsRoot(root), options.homeDir, options.workDir);
     return {
         path: path.join(root, "skills"),
         expected: litOpenCodeRuntimeSkills.map((skill) => skill.id),
@@ -100,6 +114,8 @@ export async function inspectNativeSkills(root, metadata) {
         sourceInvalid,
         canonicalCacheFiles,
         dependencies: { "lit-scientific-visualization": inspectScientificVisualizationDependencies() },
+        ...(link === undefined ? {} : { link }),
+        shadowedSkills,
         ok: missing.length === 0 && uniqueInvalid.length === 0
     };
 }

package/dist/cli/types.d.ts

@@ -52,7 +52,7 @@ export type InstallModelRoute = {
 export type InstallModelSelection = InstallModelRoute & {
     readonly helper?: InstallModelRoute;
 };
-export type InstallModelEffort = "low" | "medium" | "high" | "xhigh" | "max";
+export type InstallModelEffort = "low" | "medium" | "high" | "xhigh" | "max" | "ultra";
 export type ModelConfigClass = "fresh" | "managed_legacy" | "gpt56_managed" | "astra_managed" | "gpt56_other" | "custom" | "mixed";
 export type ModelConfigClassification = {
     readonly class: ModelConfigClass;
@@ -167,6 +167,11 @@ export type InstallReport = {
         readonly write: readonly string[];
         readonly preserve: readonly string[];
         readonly collisions: readonly string[];
+        readonly link?: {
+            readonly path: string;
+            readonly target: string;
+            readonly gitRepositoryRoot?: string;
+        };
     };
     readonly hostLimits: {
         readonly path: string;

package/dist/cli.js

@@ -6,6 +6,7 @@ import { createInstallTui, renderLitOpenCodeWordmark, shouldRenderInstallTui } f
 import { runUpdateNotifier } from "./cli/update-notifier.js";
 import { autoUpdateDiagnostic, canContinueAfterAutoUpdate, runInteractiveAutoUpdate } from "./cli/auto-update.js";
 import { LitOpenCodeConfigError } from "./config.js";
+import { defaultOpenAiRoutes, legacyFastAliasHelp, modelEffortHelp, openaiModelHelpLine, shippedDefaultsSummary } from "./cli/model-catalog.js";
 import { fetchPublicSource } from "./lit-fetch.js";
 import { readPackageMetadata } from "./cli/json.js";
 import path from "node:path";
@@ -22,9 +23,9 @@ function helpText() {
         "  npm exec --package @litfamily/litopencode -- litopencode install --permission-prompt",
         "  npm exec --package @litfamily/litopencode -- litopencode install --permission-mode balanced",
         "  npm exec --package @litfamily/litopencode -- litopencode install --yolo",
-        "  npm exec --package @litfamily/litopencode -- litopencode install --provider openai --model gpt-6-astra --effort xhigh",
-        "  npm exec --package @litfamily/litopencode -- litopencode install --provider openai --model gpt-5.6-luna --effort max",
-        "  npm exec --package @litfamily/litopencode -- litopencode install --provider openai --model gpt-5.6-luna --effort high",
+        `  npm exec --package @litfamily/litopencode -- litopencode install --provider openai --model ${defaultOpenAiRoutes.lead.model} --effort ${defaultOpenAiRoutes.lead.effort}`,
+        `  npm exec --package @litfamily/litopencode -- litopencode install --provider openai --model ${defaultOpenAiRoutes.helper.model} --effort ${defaultOpenAiRoutes.helper.effort}`,
+        `  npm exec --package @litfamily/litopencode -- litopencode install --provider openai --model ${defaultOpenAiRoutes.helper.model} --effort high`,
         "",
         "Usage:",
         "  litopencode install [--dry-run] [--root <dir>] --provider <openai|xai> --model <id> [--effort <e>] [--subagent-model <provider/id>] [--subagent-effort <e>] [--yolo]",
@@ -84,12 +85,12 @@ function helpText() {
         "Model routing:",
         "  Interactive terminal installs ask provider (openai | xai), LEAD model (planning/review) and HELPER model (execution/research),",
         "  preselecting the current managed route; --yes and --no-model-prompt keep the current non-picker behavior.",
-        "  openai rows: gpt-6-astra·xhigh (low/medium/high/xhigh/max), gpt-5.6-sol·xhigh, gpt-5.6-luna·max, gpt-5.6·high, gpt-5.6-terra·xhigh.",
-        "  The legacy GPT-5.6 rows retain their <id>-fast aliases; gpt-6-astra-fast is not a model alias.",
+        "  openai rows: " + openaiModelHelpLine() + ".",
+        "  " + legacyFastAliasHelp(),
         "  xai rows: reasoning-capable Grok models from the host catalog, grok-4.6 first; XAI_API_KEY is warned about, never required.",
         "  --provider <p> --model <id> [--effort <e>] writes the lead route; --subagent-model <provider/id> [--subagent-effort <e>] the helper route.",
-        "  Astra accepts low, medium, high, xhigh, or max and uses native reasoning effort; LUNA accepts high or max and rejects xhigh.",
-        "  Without flags/reset, planning and review (including lit-loop) use Astra/xhigh; execution and research helpers use LUNA/max.",
+        "  " + modelEffortHelp(),
+        "  Without flags/reset, planning and review (including lit-loop) use Astra/xhigh; execution and research helpers use GPT-6 Luna/max.",
         "  --model-prompt forces the picker on any existing route (managed keys only); --no-model-prompt and --yes keep current model routes.",
         "",
         "Permission behavior:",

package/dist/config-parser.js

@@ -1,4 +1,5 @@
 import fs from "node:fs/promises";
+import { nativeReasoningEfforts } from "./cli/model-catalog.js";
 export class LitOpenCodeConfigError extends Error {
     constructor(message) {
         super(message);
@@ -8,7 +9,7 @@ export class LitOpenCodeConfigError extends Error {
 const logLevels = new Set(["silent", "error", "info", "debug"]);
 const permissionModes = new Set(["safe", "balanced", "yolo"]);
 const outputStyleIds = new Set(["off", "asd-ste100", "asd-ste100-ko", "eli5", "eli5-ko"]);
-const reasoningEfforts = new Set(["none", "minimal", "low", "medium", "high", "xhigh", "max"]);
+const reasoningEfforts = new Set(nativeReasoningEfforts);
 const textVerbosities = new Set(["low", "medium", "high"]);
 const toolIds = new Set(["read", "write", "edit", "bash", "webfetch", "grep"]);
 const permissions = new Set(["ask", "allow", "deny"]);
@@ -87,7 +88,7 @@ function optionalReasoningEffort(value, filePath, field) {
     if (value === undefined || value === null)
         return undefined;
     if (typeof value !== "string" || !reasoningEfforts.has(value)) {
-        throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: ${field} must be one of none, minimal, low, medium, high, xhigh, max.`);
+        throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: ${field} must be one of ${nativeReasoningEfforts.join(", ")}.`);
     }
     return value;
 }

package/dist/config.d.ts

@@ -4,7 +4,7 @@ export { LitOpenCodeConfigError, readLitOpenCodeConfigFile } from "./config-pars
 export type LogLevel = "silent" | "error" | "info" | "debug";
 export type LitOpenCodeConfigSource = "defaults" | "global" | "project" | "merged";
 export type LitOpenCodePermissionMode = "safe" | "balanced" | "yolo";
-export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max" | "ultra";
 export type TextVerbosity = "low" | "medium" | "high";
 export type BoundedAuthorityConfig = {
     readonly maxEvents: number;

package/dist/config.js

@@ -1,5 +1,6 @@
 import { createRuntimePaths } from "./state.js";
 import { readLitOpenCodeConfigFile } from "./config-parser.js";
+import { defaultOpenAiRoutes } from "./cli/model-catalog.js";
 export { LitOpenCodeConfigError, readLitOpenCodeConfigFile } from "./config-parser.js";
 // The runtime receives a merged config, so keep source ownership alongside
 // (rather than inside) the JSON-shaped config. This never serializes into a
@@ -23,27 +24,27 @@ export const defaultConfig = Object.freeze({
     knowledge: Object.freeze({ capture: true }),
     categories: Object.freeze({
         planning: Object.freeze({
-            provider: "openai",
-            model: "gpt-6-astra",
-            variant: "xhigh",
+            provider: defaultOpenAiRoutes.lead.provider,
+            model: defaultOpenAiRoutes.lead.model,
+            variant: defaultOpenAiRoutes.lead.effort,
             textVerbosity: "medium"
         }),
         execution: Object.freeze({
-            provider: "openai",
-            model: "gpt-5.6-luna",
-            variant: "max",
+            provider: defaultOpenAiRoutes.helper.provider,
+            model: defaultOpenAiRoutes.helper.model,
+            variant: defaultOpenAiRoutes.helper.effort,
             textVerbosity: "medium"
         }),
         review: Object.freeze({
-            provider: "openai",
-            model: "gpt-6-astra",
-            variant: "xhigh",
+            provider: defaultOpenAiRoutes.lead.provider,
+            model: defaultOpenAiRoutes.lead.model,
+            variant: defaultOpenAiRoutes.lead.effort,
             textVerbosity: "medium"
         }),
         research: Object.freeze({
-            provider: "openai",
-            model: "gpt-5.6-luna",
-            variant: "max",
+            provider: defaultOpenAiRoutes.helper.provider,
+            model: defaultOpenAiRoutes.helper.model,
+            variant: defaultOpenAiRoutes.helper.effort,
             textVerbosity: "medium"
         })
     }),

package/dist/features.d.ts

@@ -1,5 +1,5 @@
 export type LitOpenCodeBindingKind = "agent" | "cli" | "command" | "config" | "hook" | "tool";
-export type LitOpenCodeFeatureId = "planning-start-work-loop" | "lit-litwork-activation" | "start-work" | "review-work" | "litresearch" | "durable-ledger" | "bounded-authority-lifecycle" | "agent-roster" | "lit-plan" | "reference-benchmark-claims" | "native-goal-verdict" | "doctor-install" | "search-workflow-ideas" | "lit-fetch" | "guardrails" | "lit-init" | "lit-crucible" | "refactor" | "lit-burnoff" | "lit-burnoff-file" | "comment-checker" | "lit-code" | "debugging" | "lit-commit" | "lsp" | "lsp-setup" | "rules" | "deep-interview" | "structural-search" | "browser-drive" | "lit-korean" | "lit-recap" | "lit-comprehend" | "lit-handoff" | "lit-scientific-visualization" | "frontend-ui-ux" | "visual-qa" | "autoresearch" | "autoconference" | "wikify";
+export type LitOpenCodeFeatureId = "planning-start-work-loop" | "lit-litwork-activation" | "start-work" | "review-work" | "litresearch" | "durable-ledger" | "bounded-authority-lifecycle" | "agent-roster" | "lit-plan" | "reference-benchmark-claims" | "native-goal-verdict" | "doctor-install" | "search-workflow-ideas" | "lit-fetch" | "guardrails" | "lit-init" | "lit-crucible" | "refactor" | "lit-burnoff" | "lit-burnoff-file" | "comment-checker" | "lit-code" | "debugging" | "lit-commit" | "lsp" | "lsp-setup" | "rules" | "deep-interview" | "structural-search" | "browser-drive" | "lit-korean" | "lit-recap" | "lit-comprehend" | "lit-handoff" | "lit-scientific-visualization" | "readme-studio" | "frontend-ui-ux" | "visual-qa" | "autoresearch" | "autoconference" | "wikify";
 export type LitOpenCodeFeatureBinding = {
     readonly kind: LitOpenCodeBindingKind;
     readonly id: string;
@@ -803,5 +803,21 @@ export declare const litOpenCodeFeatures: readonly ({
         description: string;
     })[];
     verification: string[];
+} | {
+    id: "readme-studio";
+    title: string;
+    summary: string;
+    bindings: ({
+        kind: "config";
+        id: string;
+        surface: string;
+        description: string;
+    } | {
+        kind: "cli";
+        id: string;
+        surface: string;
+        description: string;
+    })[];
+    verification: string[];
 })[];
 export declare function findLitOpenCodeFeature(id: string): LitOpenCodeFeature | undefined;

package/dist/features.js

@@ -1059,6 +1059,16 @@ export const litOpenCodeFeatures = Object.freeze([
         verification: ["node --test test/lit-scientific-visualization.test.mjs", "npm run check:pack-payload"]
     },
     frontendUiUxFeature,
+    {
+        id: "readme-studio", title: "README Studio",
+        summary: "Native-installed README production, safe local typography and portable motion assets.",
+        bindings: [
+            { kind: "config", id: "skills/readme-studio/SKILL.md", surface: "OpenCode native skill readme-studio", description: "Loads fact discovery, capability branches and task-local composition recipes." },
+            { kind: "cli", id: "litopencode install", surface: "LitOpenCode native skill installer", description: "Copies all hash-pinned nested resources." },
+            { kind: "cli", id: "litopencode doctor", surface: "LitOpenCode native skill doctor", description: "Rejects missing or altered resources." }
+        ],
+        verification: ["node --test test/runtime-skills.test.mjs test/cli-install-surface.test.mjs test/packed-artifact.test.mjs", "npm run check:managed-skill-manifest"]
+    },
     visualQaFeature
 ]);
 export function findLitOpenCodeFeature(id) {

package/dist/model-route-policy.d.ts

@@ -1,7 +1,7 @@
 import { type LitOpenCodeAgentModelConfig, type LitOpenCodeConfig } from "./config.ts";
 export type ModelRouteDiagnostic = {
     readonly agentId: string;
-    readonly code: "luna_effort_below_high" | "luna_xhigh_forbidden" | "luna_effort_conflict" | "terra_effort_below_high" | "terra_effort_conflict" | "astra_effort_unsupported" | "astra_effort_conflict";
+    readonly code: "luna_effort_below_high" | "luna_xhigh_forbidden" | "luna_effort_conflict" | "terra_effort_below_high" | "terra_effort_conflict" | "astra_effort_unsupported" | "astra_effort_conflict" | "model_effort_unsupported" | "model_effort_conflict";
     readonly model: string;
     readonly effort: string;
 };