@litfamily/litcodex 1.0.0

package/dist/install/marketplace-payload.js

@@ -0,0 +1,178 @@
+import { createHash } from "node:crypto";
+import { cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, renameSync, rmSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { InstallError } from "./errors.js";
+import { readRegularFileBuffer, walkDirectory } from "./file-walk.js";
+import { isSafeManagedMarketplaceRoot, managedMarketplaceRoot } from "./marketplace.js";
+const MARKETPLACE_MANIFEST = join(".agents", "plugins", "marketplace.json");
+const PLUGIN_MANIFEST = join("plugins", "litcodex", ".codex-plugin", "plugin.json");
+const LEGACY_VENDOR_PATHS = [
+    { legacy: "022_handoff", canonical: "handoff" },
+    { legacy: "045_scientific-visualization", canonical: "scientific-visualization" },
+];
+/** Validate and atomically install the package-bundled marketplace into CODEX_HOME. */
+export function materializeManagedMarketplace(opts) {
+    const codexHome = dirname(dirname(opts.targetRoot));
+    if (managedMarketplaceRoot(codexHome) !== opts.targetRoot || !isSafeManagedMarketplaceRoot(codexHome)) {
+        throw payloadError("Unsafe marketplace path or unrecognized cache ownership.", opts.targetRoot);
+    }
+    reconcileLegacyVendorPaths(opts.sourceRoot, opts.targetRoot);
+    const version = readVersion(opts.sourceRoot);
+    if (!existsSync(join(opts.sourceRoot, MARKETPLACE_MANIFEST))) {
+        throw payloadError("Bundled LitCodex marketplace manifest is missing.", opts.sourceRoot);
+    }
+    if (readVersionIfPresent(opts.targetRoot) === version &&
+        existsSync(join(opts.targetRoot, MARKETPLACE_MANIFEST)) &&
+        payloadTreesMatch(opts.sourceRoot, opts.targetRoot)) {
+        return { changed: false, version };
+    }
+    const parent = dirname(opts.targetRoot);
+    mkdirSync(parent, { recursive: true });
+    const stage = mkdtempSync(join(parent, ".litcodex-stage-"));
+    const backup = `${stage}-backup`;
+    let backedUp = false;
+    try {
+        cpSync(opts.sourceRoot, stage, { recursive: true, force: true });
+        readVersion(stage);
+        if (existsSync(opts.targetRoot)) {
+            renameSync(opts.targetRoot, backup);
+            backedUp = true;
+        }
+        renameSync(stage, opts.targetRoot);
+        if (backedUp)
+            rmSync(backup, { recursive: true, force: true });
+        return { changed: true, version };
+    }
+    catch (error) {
+        rmSync(stage, { recursive: true, force: true });
+        if (backedUp && !existsSync(opts.targetRoot))
+            renameSync(backup, opts.targetRoot);
+        throw payloadError("Failed to install the bundled LitCodex marketplace atomically.", opts.targetRoot, error);
+    }
+}
+/** Move only byte/mode-exact, regular legacy vendor roots inside an owned marketplace. */
+function reconcileLegacyVendorPaths(sourceRoot, targetRoot) {
+    const sourceVendorRoot = join(sourceRoot, "plugins", "litcodex", "vendor");
+    const targetVendorRoot = join(targetRoot, "plugins", "litcodex", "vendor");
+    const moves = [];
+    for (const { legacy, canonical } of LEGACY_VENDOR_PATHS) {
+        const legacyPath = join(targetVendorRoot, legacy);
+        const canonicalPath = join(targetVendorRoot, canonical);
+        const legacyStat = lstatIfPresent(legacyPath);
+        if (!legacyStat)
+            continue;
+        if (legacyStat.isSymbolicLink() || !legacyStat.isDirectory()) {
+            throw payloadError("Unsafe legacy vendor path; refusing migration.", legacyPath);
+        }
+        if (lstatIfPresent(canonicalPath)) {
+            throw payloadError("Legacy and canonical vendor paths coexist; refusing migration.", canonicalPath);
+        }
+        const expected = vendorTreeSignature(join(sourceVendorRoot, canonical));
+        const actual = vendorTreeSignature(legacyPath);
+        if (!sameSignature(expected, actual)) {
+            throw payloadError("Legacy vendor path is modified, foreign, or incomplete; refusing migration.", legacyPath);
+        }
+        moves.push([legacyPath, canonicalPath]);
+    }
+    for (const [legacyPath, canonicalPath] of moves)
+        renameSync(legacyPath, canonicalPath);
+}
+function lstatIfPresent(path) {
+    try {
+        return lstatSync(path);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+function vendorTreeSignature(root) {
+    const entries = [];
+    const visit = (directory, relativePath) => {
+        const directoryStat = lstatSync(directory);
+        if (directoryStat.isSymbolicLink() || !directoryStat.isDirectory()) {
+            throw new Error("legacy vendor path is not a real directory");
+        }
+        for (const entry of readdirSync(directory, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name))) {
+            const child = join(directory, entry.name);
+            const childRelativePath = relativePath.length === 0 ? entry.name : `${relativePath}/${entry.name}`;
+            const childStat = lstatSync(child);
+            if (childStat.isSymbolicLink())
+                throw new Error("legacy vendor path contains a symbolic link");
+            if (childStat.isDirectory()) {
+                entries.push(`directory\0${childRelativePath}`);
+                visit(child, childRelativePath);
+            }
+            else if (childStat.isFile()) {
+                const digest = createHash("sha256").update(readRegularFileBuffer(child)).digest("hex");
+                entries.push(`file\0${childRelativePath}\0${digest}\0${childStat.mode & 0o7777}`);
+            }
+            else {
+                throw new Error("legacy vendor path contains an unsupported entry");
+            }
+        }
+    };
+    visit(root, "");
+    return entries.sort();
+}
+function sameSignature(left, right) {
+    return left.length === right.length && left.every((entry, index) => entry === right[index]);
+}
+function readVersion(root) {
+    const path = join(root, PLUGIN_MANIFEST);
+    try {
+        const value = JSON.parse(readFileSync(path, "utf8"));
+        if (typeof value.version === "string" && value.version.length > 0)
+            return value.version;
+    }
+    catch (error) {
+        throw payloadError("Bundled LitCodex plugin manifest is missing or malformed.", path, error);
+    }
+    throw payloadError("Bundled LitCodex plugin manifest has no version.", path);
+}
+function readVersionIfPresent(root) {
+    if (!existsSync(join(root, PLUGIN_MANIFEST)))
+        return null;
+    try {
+        return readVersion(root);
+    }
+    catch {
+        return null;
+    }
+}
+function payloadTreesMatch(sourceRoot, targetRoot) {
+    try {
+        const sourceEntries = treeSignature(sourceRoot);
+        const targetEntries = treeSignature(targetRoot);
+        return (sourceEntries !== null &&
+            targetEntries !== null &&
+            sourceEntries.length === targetEntries.length &&
+            sourceEntries.every((entry, index) => entry === targetEntries[index]));
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return false;
+        throw error;
+    }
+}
+function treeSignature(root) {
+    const entries = [];
+    for (const entry of walkDirectory(root)) {
+        if (entry.kind === "unexpected")
+            return null;
+        if (entry.kind === "directory")
+            entries.push(`directory\0${entry.relativePath}`);
+        else {
+            const digest = createHash("sha256").update(readFileSync(entry.absolutePath)).digest("hex");
+            entries.push(`file\0${entry.relativePath}\0${digest}`);
+        }
+    }
+    return entries.sort();
+}
+function payloadError(message, path, cause) {
+    return new InstallError("LITCODEX_INSTALL_CONFIG_WRITE_FAILED", message, {
+        path,
+        ...(cause === undefined ? {} : { cause: cause instanceof Error ? cause.message : String(cause) }),
+    });
+}

package/dist/install/marketplace.d.ts

@@ -0,0 +1,18 @@
+export declare const LITCODEX_MARKETPLACE: "litcodex";
+export declare const LITCODEX_PLUGIN: "litcodex";
+export declare function managedMarketplaceRoot(codexHome: string): string;
+/** Compare paths through host symlinks such as macOS `/tmp` -> `/private/tmp`. */
+export declare function canonicalMarketplacePath(path: string): string;
+/** The plugin reference Codex consumes: `<plugin>@<marketplace>`. */
+export declare const LITCODEX_PLUGIN_REF: "litcodex@litcodex";
+interface MarketplacePathFs {
+    lstatSync?(path: string): {
+        isSymbolicLink(): boolean;
+        isDirectory(): boolean;
+        isFile?(): boolean;
+    };
+    readFileSync?(path: string, encoding: "utf8"): string;
+}
+/** A native identity authorizes replacing the generated cache, never following a redirected path. */
+export declare function isSafeManagedMarketplaceRoot(codexHome: string, fs?: MarketplacePathFs): boolean;
+export {};

package/dist/install/marketplace.js

@@ -0,0 +1,74 @@
+// M12 / T17 — registration identity constants (S12 §marketplace.ts; A3 Part D).
+//
+import { lstatSync, readFileSync, realpathSync } from "node:fs";
+import { join, resolve } from "node:path";
+export const LITCODEX_MARKETPLACE = "litcodex";
+export const LITCODEX_PLUGIN = "litcodex";
+export function managedMarketplaceRoot(codexHome) {
+    return join(codexHome, "marketplaces", LITCODEX_MARKETPLACE);
+}
+/** Compare paths through host symlinks such as macOS `/tmp` -> `/private/tmp`. */
+export function canonicalMarketplacePath(path) {
+    try {
+        return realpathSync.native(path);
+    }
+    catch {
+        return resolve(path);
+    }
+}
+/** The plugin reference Codex consumes: `<plugin>@<marketplace>`. */
+export const LITCODEX_PLUGIN_REF = `${LITCODEX_PLUGIN}@${LITCODEX_MARKETPLACE}`;
+/** A native identity authorizes replacing the generated cache, never following a redirected path. */
+export function isSafeManagedMarketplaceRoot(codexHome, fs = { lstatSync, readFileSync }) {
+    const root = managedMarketplaceRoot(codexHome);
+    const inspect = fs.lstatSync ?? lstatSync;
+    const read = fs.readFileSync;
+    const directory = (path) => {
+        try {
+            const stat = inspect(path);
+            return !stat.isSymbolicLink() && stat.isDirectory();
+        }
+        catch (error) {
+            return error.code === "ENOENT" ? null : false;
+        }
+    };
+    for (const path of [codexHome, join(codexHome, "marketplaces"), root]) {
+        if (directory(path) === false)
+            return false;
+    }
+    if (directory(root) === null)
+        return true;
+    if (read === undefined)
+        return false;
+    try {
+        for (const relative of [
+            ".agents",
+            ".agents/plugins",
+            "plugins",
+            "plugins/litcodex",
+            "plugins/litcodex/.codex-plugin",
+        ]) {
+            if (directory(join(root, relative)) !== true)
+                return false;
+        }
+        const readIdentity = (relative) => {
+            const path = join(root, relative);
+            const stat = inspect(path);
+            if (stat.isSymbolicLink() || stat.isFile?.() !== true)
+                throw new Error("Unsafe identity file");
+            return JSON.parse(read(path, "utf8"));
+        };
+        const marketplace = readIdentity(".agents/plugins/marketplace.json");
+        const plugin = readIdentity("plugins/litcodex/.codex-plugin/plugin.json");
+        return (marketplace?.["name"] === LITCODEX_MARKETPLACE &&
+            plugin?.["name"] === LITCODEX_PLUGIN &&
+            Array.isArray(marketplace["plugins"]) &&
+            marketplace["plugins"].some((entry) => typeof entry === "object" &&
+                entry !== null &&
+                entry["name"] === LITCODEX_PLUGIN &&
+                entry["source"] === "./plugins/litcodex"));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/install/package-root.d.ts

@@ -0,0 +1,13 @@
+export interface MarketplaceSource {
+    readonly root: string;
+    readonly disposable: boolean;
+    readonly cleanup: () => void;
+}
+export interface MarketplaceSourceOptions {
+    readonly packageRoot?: string;
+    readonly tempParent?: string;
+}
+/** Package root in source and compiled installs; deliberately independent of process.cwd(). */
+export declare function resolvePackageRoot(): string;
+export declare function resolveBundledMarketplaceRoot(): string;
+export declare function resolveBundledMarketplaceSource(opts?: MarketplaceSourceOptions): MarketplaceSource;

package/dist/install/package-root.js

@@ -0,0 +1,25 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { materializeDevelopmentMarketplace } from "./development-marketplace.js";
+/** Package root in source and compiled installs; deliberately independent of process.cwd(). */
+export function resolvePackageRoot() {
+    return fileURLToPath(new URL("../../", import.meta.url));
+}
+export function resolveBundledMarketplaceRoot() {
+    return fileURLToPath(new URL("../../marketplace/", import.meta.url));
+}
+export function resolveBundledMarketplaceSource(opts = {}) {
+    const packageRoot = opts.packageRoot ?? resolvePackageRoot();
+    const bundledRoot = join(packageRoot, "marketplace");
+    if (existsSync(join(bundledRoot, "plugins/litcodex/.codex-plugin/plugin.json"))) {
+        return { root: bundledRoot, disposable: false, cleanup: keepMarketplace };
+    }
+    const developmentSource = materializeDevelopmentMarketplace(packageRoot, opts.tempParent);
+    if (developmentSource !== null)
+        return { ...developmentSource, disposable: true };
+    return { root: bundledRoot, disposable: false, cleanup: keepMarketplace };
+}
+function keepMarketplace() {
+    // Package-bundled payloads live for the process lifetime and require no cleanup.
+}

package/dist/install/plan.d.ts

@@ -0,0 +1,3 @@
+import type { InstallOptions, InstallStep } from "./types.js";
+/** Build the ordered plan. The fixed order is marketplace → plugin → hooks → config → verify. */
+export declare function buildInstallPlan(opts: InstallOptions): readonly InstallStep[];

package/dist/install/plan.js

@@ -0,0 +1,54 @@
+// M12 / T17 — pure install plan builder (S12 §plan.ts; addendum A5.3 pinned argv).
+//
+// `buildInstallPlan` is pure + deterministic: identical flags → identical ordered steps → a
+// byte-stable dry-run rendering free of legacy tokens. The argv every step carries is the literal
+// `codex …` vector that WOULD be spawned (never an exec-wrapper). No environment-dependent reordering.
+import { LITCODEX_PLUGIN_REF } from "./marketplace.js";
+/** Build the ordered plan. The fixed order is marketplace → plugin → hooks → config → verify. */
+export function buildInstallPlan(opts) {
+    // `codex plugin add` is non-interactive and (codex-cli 0.139.x) REJECTS `--no-tui` as an unknown
+    // option — the correct argv is just `codex plugin add <plugin>@<marketplace>`. The accepted
+    // `--no-tui` CLI flag is now a no-op kept for habit/compat (VERIFY-LIVE finding vs codex 0.139.0).
+    const pluginAddArgs = ["codex", "plugin", "add", LITCODEX_PLUGIN_REF];
+    const profileLabel = opts.profile.toUpperCase();
+    const consentLabel = opts.reconfigure ? ", explicit managed reconfigure" : "";
+    const configTitle = `Update Codex config.toml (${profileLabel} / ${opts.effort}${consentLabel}, hard concurrency 20, context and auto-compaction unset for host defaults, non-destructive)`;
+    return [
+        {
+            kind: "marketplace-add",
+            title: `Add LitCodex marketplace: codex plugin marketplace add ${opts.repoUrl}`,
+            command: ["codex", "plugin", "marketplace", "add", opts.repoUrl],
+            skippable: true,
+        },
+        {
+            kind: "plugin-add",
+            title: `Install plugin: ${pluginAddArgs.join(" ")}`,
+            command: pluginAddArgs,
+            skippable: true,
+        },
+        {
+            kind: "hooks-register",
+            title: "Register lit-loop UserPromptSubmit hook (bundled hooks.json)",
+            command: null,
+            skippable: true,
+        },
+        {
+            kind: "agents-install",
+            title: "Install litwork subagent roles and native default route (backup-safe)",
+            command: null,
+            skippable: true,
+        },
+        {
+            kind: "config-update",
+            title: configTitle,
+            command: null,
+            skippable: false,
+        },
+        {
+            kind: "verify",
+            title: "Verify: litcodex doctor",
+            command: null,
+            skippable: false,
+        },
+    ];
+}

package/dist/install/registration.d.ts

@@ -0,0 +1,8 @@
+import { type SpawnLike } from "./codex.js";
+import type { InstallStep, InstallStepResult } from "./types.js";
+export interface RegistrationDeps {
+    readonly spawn: SpawnLike;
+    readonly force?: boolean;
+    readonly refreshPlugin?: boolean;
+}
+export declare function runRegistration(step: InstallStep, codexBin: string, deps: RegistrationDeps, target: "marketplace" | "plugin"): InstallStepResult;

package/dist/install/registration.js

@@ -0,0 +1,62 @@
+import { probeMarketplaceRegistration, probePluginInstalled } from "./codex.js";
+import { InstallError } from "./errors.js";
+import { canonicalMarketplacePath, LITCODEX_MARKETPLACE, LITCODEX_PLUGIN, LITCODEX_PLUGIN_REF } from "./marketplace.js";
+export function runRegistration(step, codexBin, deps, target) {
+    if (target === "marketplace")
+        return registerMarketplace(step, codexBin, deps);
+    return registerPlugin(step, codexBin, deps);
+}
+function registerMarketplace(step, codexBin, deps) {
+    const desired = step.command?.at(-1);
+    const current = probeMarketplaceRegistration(codexBin, deps.spawn);
+    if (current !== null && desired !== undefined && samePath(current.source, desired) && deps.force !== true) {
+        return skipped(step, `${LITCODEX_MARKETPLACE} marketplace already registered`);
+    }
+    const receipts = [];
+    if (current !== null) {
+        if (probePluginInstalled(codexBin, deps.spawn)) {
+            receipts.push(...spawnMutation(codexBin, ["plugin", "remove", LITCODEX_PLUGIN_REF], deps, "plugin"));
+        }
+        receipts.push(...spawnMutation(codexBin, ["plugin", "marketplace", "remove", LITCODEX_MARKETPLACE], deps, "marketplace"));
+    }
+    receipts.push(...spawnStep(step, codexBin, deps, "marketplace"));
+    return ok(step, `${LITCODEX_MARKETPLACE} marketplace registered`, receipts);
+}
+function registerPlugin(step, codexBin, deps) {
+    const present = probePluginInstalled(codexBin, deps.spawn);
+    const receipts = [];
+    if (present && deps.refreshPlugin === true) {
+        receipts.push(...spawnMutation(codexBin, ["plugin", "remove", LITCODEX_PLUGIN_REF], deps, "plugin"));
+    }
+    else if (present && deps.force !== true) {
+        return skipped(step, `${LITCODEX_PLUGIN}@${LITCODEX_MARKETPLACE} plugin already registered`);
+    }
+    receipts.push(...spawnStep(step, codexBin, deps, "plugin"));
+    return ok(step, `${LITCODEX_PLUGIN}@${LITCODEX_MARKETPLACE} plugin registered`, receipts);
+}
+function spawnStep(step, codexBin, deps, target) {
+    return step.command === null ? [] : spawnMutation(codexBin, step.command.slice(1), deps, target);
+}
+function spawnMutation(codexBin, args, deps, target) {
+    const res = deps.spawn(codexBin, args, { stdio: "pipe" });
+    if (!res.error && res.status !== null && res.status === 0)
+        return outputLines(res.stdout, res.stderr);
+    throw new InstallError(target === "marketplace" ? "LITCODEX_INSTALL_MARKETPLACE_ADD_FAILED" : "LITCODEX_INSTALL_PLUGIN_ADD_FAILED", `codex ${args.join(" ")} failed`, { status: res.status, signalKilled: res.status === null, stdout: res.stdout ?? "", stderr: res.stderr ?? "" });
+}
+function outputLines(stdout, stderr) {
+    return `${stdout ?? ""}\n${stderr ?? ""}`
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+}
+function samePath(current, desired) {
+    if (current === null)
+        return false;
+    return canonicalMarketplacePath(current) === canonicalMarketplacePath(desired);
+}
+function ok(step, detail, receipts) {
+    return { kind: step.kind, status: "ok", detail, ...(receipts.length === 0 ? {} : { receipts }) };
+}
+function skipped(step, detail) {
+    return { kind: step.kind, status: "skipped", detail };
+}

package/dist/install/render-plan.d.ts

@@ -0,0 +1,3 @@
+import type { InstallStep } from "./types.js";
+export declare const INSTALL_PLAN_HEADER: "litcodex install plan (Codex)";
+export declare function renderInstallPlan(steps: readonly InstallStep[]): string;

package/dist/install/render-plan.js

@@ -0,0 +1,16 @@
+// M12 / T17 — dry-run plan renderer (S12 §render-plan.ts).
+//
+// `renderInstallPlan` is the exact stdout text for `install --dry-run`: a fixed LitCodex header,
+// numbered step titles in execution order, and the planned agent routes. No exec-wrapper line,
+// no legacy token, no trailing blank line (the caller appends the final "\n").
+import { desiredAgentRoutes } from "./agent-routing.js";
+export const INSTALL_PLAN_HEADER = "litcodex install plan (Codex)";
+export function renderInstallPlan(steps) {
+    const lines = [
+        INSTALL_PLAN_HEADER,
+        ...steps.map((step, i) => `${i + 1}. ${step.title}`),
+        "Agent routes (model/effort):",
+        ...desiredAgentRoutes().map((route) => `  - ${route.role}=${route.model}/${route.effort}`),
+    ];
+    return lines.join("\n");
+}

package/dist/install/runtime-file-policy.d.ts

@@ -0,0 +1,2 @@
+/** Return whether a path relative to the plugin skills root belongs in an installed runtime payload. */
+export declare function isRuntimeSkillPath(relativePath: string): boolean;

package/dist/install/runtime-file-policy.js

@@ -0,0 +1,17 @@
+const REPOSITORY_ONLY_SEGMENTS = /(?:^|\/)(?:tests?|fixtures?|evidence|\.litcodex|\.qa-tmp)(?:\/|$)/;
+const PYTHON_CACHE_SEGMENTS = /(?:^|\/)(?:__pycache__|\.pytest_cache|\.mypy_cache|\.ruff_cache)(?:\/|$)/;
+/** Return whether a path relative to the plugin skills root belongs in an installed runtime payload. */
+export function isRuntimeSkillPath(relativePath) {
+    if (REPOSITORY_ONLY_SEGMENTS.test(relativePath) || PYTHON_CACHE_SEGMENTS.test(relativePath))
+        return false;
+    const basename = relativePath.slice(relativePath.lastIndexOf("/") + 1);
+    if (/\.test\.[^.]+$/.test(basename))
+        return false;
+    if (/^test_[^/]*\.py$/.test(basename))
+        return false;
+    if (/^vitest\.config(?:\.|$)/.test(basename))
+        return false;
+    if (/^(?:test-helpers|doctor-fixtures)(?:\.|$)/.test(basename))
+        return false;
+    return !/\.py[co]$/.test(basename);
+}

package/dist/install/skill-catalog.d.ts

@@ -0,0 +1,17 @@
+import type { ReadonlyFsLike } from "./codex.js";
+/**
+ * The Codex-native skill directories shipped in the LitCodex marketplace payload.
+ *
+ * Keep this catalog explicit: `litcodex doctor` uses it to prove that an installed
+ * marketplace has every supported skill entry point, while the companion test
+ * compares it with the repository's package contract.
+ */
+export declare const CANONICAL_SKILL_IDS: readonly ["autoconference", "autoresearch", "browser-drive", "coding-session-audit", "comment-checker", "debugging", "deep-interview", "frontend-ui-ux", "lit-burnoff", "lit-burnoff-file", "lit-code", "lit-commit", "lit-comprehend", "lit-crucible", "lit-fetch", "lit-handoff", "lit-init", "lit-korean", "lit-loop", "lit-plan", "lit-recap", "lit-scientific-visualization", "lit-team", "litcodex-contribute-bug-fix", "litcodex-doctor", "litcodex-report-bug", "litgoal", "litresearch", "litwork", "lsp", "lsp-setup", "refactor", "review-work", "rules", "skill-observer", "start-work", "structural-search", "visual-qa", "wikify"];
+export declare const CANONICAL_SKILL_RESOURCE_PATHS: readonly ["lsp/references/runtime-triage.md", ...string[]];
+export interface SkillCatalogPayloadReport {
+    readonly complete: boolean;
+    readonly missingSkillIds: readonly string[];
+    readonly missingResourcePaths: readonly string[];
+}
+/** Read-only installed-payload probe used by `litcodex doctor`. */
+export declare function probeSkillCatalogPayload(fs: Pick<ReadonlyFsLike, "existsSync" | "listFilesRecursive" | "readFileBufferSync">, marketplaceRoot: string): SkillCatalogPayloadReport;

package/dist/install/skill-catalog.js

@@ -0,0 +1,111 @@
+import { join } from "node:path";
+import { payloadExact } from "./bundled-skills.js";
+import { AUTOCONFERENCE_PAYLOAD_HASHES, AUTORESEARCH_PAYLOAD_HASHES, BROWSER_DRIVE_PAYLOAD_HASHES, CODING_SESSION_AUDIT_PAYLOAD_HASHES, DEEP_INTERVIEW_PAYLOAD_HASHES, FRONTEND_UIUX_PAYLOAD_HASHES, SKILL_OBSERVER_PAYLOAD_HASHES, STRUCTURAL_SEARCH_PAYLOAD_HASHES, VISUAL_QA_PAYLOAD_HASHES, WIKIFY_PAYLOAD_HASHES, } from "./skill-resource-hashes.js";
+/**
+ * The Codex-native skill directories shipped in the LitCodex marketplace payload.
+ *
+ * Keep this catalog explicit: `litcodex doctor` uses it to prove that an installed
+ * marketplace has every supported skill entry point, while the companion test
+ * compares it with the repository's package contract.
+ */
+export const CANONICAL_SKILL_IDS = [
+    "autoconference",
+    "autoresearch",
+    "browser-drive",
+    "coding-session-audit",
+    "comment-checker",
+    "debugging",
+    "deep-interview",
+    "frontend-ui-ux",
+    "lit-burnoff",
+    "lit-burnoff-file",
+    "lit-code",
+    "lit-commit",
+    "lit-comprehend",
+    "lit-crucible",
+    "lit-fetch",
+    "lit-handoff",
+    "lit-init",
+    "lit-korean",
+    "lit-loop",
+    "lit-plan",
+    "lit-recap",
+    "lit-scientific-visualization",
+    "lit-team",
+    "litcodex-contribute-bug-fix",
+    "litcodex-doctor",
+    "litcodex-report-bug",
+    "litgoal",
+    "litresearch",
+    "litwork",
+    "lsp",
+    "lsp-setup",
+    "refactor",
+    "review-work",
+    "rules",
+    "skill-observer",
+    "start-work",
+    "structural-search",
+    "visual-qa",
+    "wikify",
+];
+export const CANONICAL_SKILL_RESOURCE_PATHS = [
+    "lsp/references/runtime-triage.md",
+    ...Object.keys(AUTOCONFERENCE_PAYLOAD_HASHES)
+        .filter((path) => path !== "SKILL.md")
+        .map((path) => `autoconference/${path}`),
+    ...Object.keys(AUTORESEARCH_PAYLOAD_HASHES)
+        .filter((path) => path !== "SKILL.md")
+        .map((path) => `autoresearch/${path}`),
+    ...Object.keys(BROWSER_DRIVE_PAYLOAD_HASHES)
+        .filter((path) => path !== "SKILL.md")
+        .map((path) => `browser-drive/${path}`),
+    ...Object.keys(DEEP_INTERVIEW_PAYLOAD_HASHES)
+        .filter((path) => path !== "SKILL.md")
+        .map((path) => `deep-interview/${path}`),
+    ...Object.keys(FRONTEND_UIUX_PAYLOAD_HASHES)
+        .filter((path) => path !== "SKILL.md")
+        .map((path) => `frontend-ui-ux/${path}`),
+    ...Object.keys(SKILL_OBSERVER_PAYLOAD_HASHES)
+        .filter((path) => path !== "SKILL.md")
+        .map((path) => `skill-observer/${path}`),
+    ...Object.keys(VISUAL_QA_PAYLOAD_HASHES)
+        .filter((path) => path !== "SKILL.md")
+        .map((path) => `visual-qa/${path}`),
+    ...Object.keys(STRUCTURAL_SEARCH_PAYLOAD_HASHES)
+        .filter((path) => path !== "SKILL.md")
+        .map((path) => `structural-search/${path}`),
+    ...Object.keys(CODING_SESSION_AUDIT_PAYLOAD_HASHES)
+        .filter((path) => path !== "SKILL.md")
+        .map((path) => `coding-session-audit/${path}`),
+    ...Object.keys(WIKIFY_PAYLOAD_HASHES)
+        .filter((path) => path !== "SKILL.md")
+        .map((path) => `wikify/${path}`),
+];
+/** Read-only installed-payload probe used by `litcodex doctor`. */
+export function probeSkillCatalogPayload(fs, marketplaceRoot) {
+    const skillsRoot = join(marketplaceRoot, "plugins", "litcodex", "skills");
+    const missingSkillIds = CANONICAL_SKILL_IDS.filter((skillId) => !fs.existsSync(join(skillsRoot, skillId, "SKILL.md")));
+    const missingResourcePaths = CANONICAL_SKILL_RESOURCE_PATHS.filter((resourcePath) => !fs.existsSync(join(skillsRoot, resourcePath)));
+    const exactPayloads = [
+        ["autoconference", AUTOCONFERENCE_PAYLOAD_HASHES],
+        ["autoresearch", AUTORESEARCH_PAYLOAD_HASHES],
+        ["browser-drive", BROWSER_DRIVE_PAYLOAD_HASHES],
+        ["deep-interview", DEEP_INTERVIEW_PAYLOAD_HASHES],
+        ["frontend-ui-ux", FRONTEND_UIUX_PAYLOAD_HASHES],
+        ["skill-observer", SKILL_OBSERVER_PAYLOAD_HASHES],
+        ["visual-qa", VISUAL_QA_PAYLOAD_HASHES],
+        ["structural-search", STRUCTURAL_SEARCH_PAYLOAD_HASHES],
+        ["coding-session-audit", CODING_SESSION_AUDIT_PAYLOAD_HASHES],
+        ["wikify", WIKIFY_PAYLOAD_HASHES],
+    ];
+    const invalidResourcePaths = exactPayloads
+        .filter(([skillId, hashes]) => !payloadExact(fs, join(skillsRoot, skillId), hashes))
+        .map(([skillId]) => `<${skillId}-payload-integrity>`);
+    const unhealthyResourcePaths = [...missingResourcePaths, ...invalidResourcePaths];
+    return {
+        complete: missingSkillIds.length === 0 && unhealthyResourcePaths.length === 0,
+        missingSkillIds,
+        missingResourcePaths: unhealthyResourcePaths,
+    };
+}

package/dist/install/skill-resource-hashes.d.ts

@@ -0,0 +1 @@
+export { AUTOCONFERENCE_PAYLOAD_HASHES, AUTORESEARCH_PAYLOAD_HASHES, BROWSER_DRIVE_PAYLOAD_HASHES, CODING_SESSION_AUDIT_PAYLOAD_HASHES, DEEP_INTERVIEW_PAYLOAD_HASHES, FRONTEND_UIUX_PAYLOAD_HASHES, SKILL_OBSERVER_PAYLOAD_HASHES, STRUCTURAL_SEARCH_PAYLOAD_HASHES, VISUAL_QA_PAYLOAD_HASHES, WIKIFY_PAYLOAD_HASHES, } from "./generated-skill-payload-hashes.js";

package/dist/install/skill-resource-hashes.js

@@ -0,0 +1 @@
+export { AUTOCONFERENCE_PAYLOAD_HASHES, AUTORESEARCH_PAYLOAD_HASHES, BROWSER_DRIVE_PAYLOAD_HASHES, CODING_SESSION_AUDIT_PAYLOAD_HASHES, DEEP_INTERVIEW_PAYLOAD_HASHES, FRONTEND_UIUX_PAYLOAD_HASHES, SKILL_OBSERVER_PAYLOAD_HASHES, STRUCTURAL_SEARCH_PAYLOAD_HASHES, VISUAL_QA_PAYLOAD_HASHES, WIKIFY_PAYLOAD_HASHES, } from "./generated-skill-payload-hashes.js";

package/dist/install/spinner-motion.d.ts

@@ -0,0 +1,2 @@
+import type { SpinnerMotion } from "./install-ui.js";
+export declare function createBlockingSpinnerMotion(fd: number): SpinnerMotion;