@litfamily/litcodex 1.0.0

package/node_modules/@litcodex/lit-loop/dist/skill-loop/types.js

@@ -0,0 +1,246 @@
+import { resolve } from "node:path";
+import { redactSecretsInValue } from "../redaction.js";
+import { SKILL_RENAMES } from "../skill-renames.js";
+export class SkillLoopError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.name = "SkillLoopError";
+        this.code = code;
+    }
+}
+export const SHIPPED_SKILL_IDS = Object.freeze(new Set([
+    "autoconference",
+    "autoresearch",
+    "browser-drive",
+    "coding-session-audit",
+    "comment-checker",
+    "debugging",
+    "deep-interview",
+    "frontend-ui-ux",
+    "lit-commit",
+    "lit-crucible",
+    "lit-init",
+    "lit-korean",
+    "lit-comprehend",
+    "lit-handoff",
+    "lit-loop",
+    "lit-plan",
+    "lit-recap",
+    "lit-scientific-visualization",
+    "litcodex-contribute-bug-fix",
+    "litcodex-doctor",
+    "litcodex-report-bug",
+    "litgoal",
+    "litresearch",
+    "litwork",
+    "lsp",
+    "lsp-setup",
+    "lit-code",
+    "lit-fetch",
+    "refactor",
+    "lit-burnoff",
+    "lit-burnoff-file",
+    ...Object.keys(SKILL_RENAMES),
+    "review-work",
+    "rules",
+    "skill-observer",
+    "start-work",
+    "structural-search",
+    "lit-team",
+    "visual-qa",
+    "wikify",
+]));
+const SHIPPED_SKILL_IDENTITIES = new Set([...SHIPPED_SKILL_IDS].map((skillId) => canonicalPathIdentity(skillId)));
+const PROPOSAL_KEYS = new Set([
+    "schema",
+    "id",
+    "createdAt",
+    "host",
+    "sessionRef",
+    "signal",
+    "targetSkill",
+    "targetRoot",
+    "action",
+    "patch",
+    "createSpec",
+    "rationale",
+    "evidenceRefs",
+    "status",
+    "ledgerEntryId",
+]);
+const PATCH_KEYS = new Set(["file", "oldString", "newString"]);
+const CREATE_SPEC_KEYS = new Set(["files"]);
+const CREATE_FILE_KEYS = new Set(["file", "content"]);
+const ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+const SKILL_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
+const RFC3339 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/u;
+const CONTROL = /[\u0000-\u001f\u007f-\u009f]/u;
+const PORTABLE_FORBIDDEN = /[:*?"<>|\\]/u;
+const DEVICE = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\..*)?$/iu;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertOnlyKeys(record, keys) {
+    if (Object.keys(record).some((key) => !keys.has(key))) {
+        throw new SkillLoopError("PROPOSAL_SCHEMA_INVALID", "the proposal contains an unknown field");
+    }
+}
+function text(record, key, min, max) {
+    const value = record[key];
+    if (typeof value !== "string" || value.length < min || value.length > max) {
+        throw new SkillLoopError("PROPOSAL_SCHEMA_INVALID", `the proposal ${key} field is invalid`);
+    }
+    return value;
+}
+export function canonicalPathIdentity(path) {
+    return path
+        .split("/")
+        .map((segment) => segment
+        .normalize("NFKC")
+        .toLocaleLowerCase("en-US")
+        .replace(/[. ]+$/u, ""))
+        .join("/");
+}
+export function validateTargetSkillIdentity(skillId) {
+    const identity = canonicalPathIdentity(skillId);
+    if (!SKILL_ID.test(skillId) ||
+        identity !== skillId ||
+        DEVICE.test(skillId) ||
+        SHIPPED_SKILL_IDENTITIES.has(identity)) {
+        throw new SkillLoopError("TARGET_NOT_AGENT_OWNED", "the proposal target is not a portable agent-owned id");
+    }
+    return skillId;
+}
+export function validateRelativeFile(file, targetSkill) {
+    if (file.length === 0 ||
+        file.length > 1024 ||
+        file.startsWith("/") ||
+        /^[A-Za-z]:/u.test(file) ||
+        file.includes("//") ||
+        CONTROL.test(file) ||
+        PORTABLE_FORBIDDEN.test(file)) {
+        throw new SkillLoopError("PROPOSAL_PATH_INVALID", "the proposal file path is not portable");
+    }
+    const segments = file.split("/");
+    if (segments.some((segment) => segment === "" || segment === "." || segment === ".." || /[. ]$/u.test(segment) || DEVICE.test(segment))) {
+        throw new SkillLoopError("PROPOSAL_PATH_INVALID", "the proposal file path is not portable");
+    }
+    const identity = canonicalPathIdentity(file);
+    const targetIdentity = canonicalPathIdentity(targetSkill);
+    if (identity === targetIdentity || identity.startsWith(`${targetIdentity}/`)) {
+        throw new SkillLoopError("PROPOSAL_PATH_INVALID", "proposal files are relative to the target skill");
+    }
+    return file;
+}
+function validatePatch(value, targetSkill) {
+    if (!isRecord(value))
+        throw new SkillLoopError("PROPOSAL_SCHEMA_INVALID", "the patch is invalid");
+    assertOnlyKeys(value, PATCH_KEYS);
+    return {
+        file: validateRelativeFile(text(value, "file", 1, 1024), targetSkill),
+        oldString: text(value, "oldString", 1, 65_536),
+        newString: text(value, "newString", 0, 65_536),
+    };
+}
+function validateCreateSpec(value, targetSkill) {
+    if (!isRecord(value))
+        throw new SkillLoopError("PROPOSAL_SCHEMA_INVALID", "the createSpec is invalid");
+    assertOnlyKeys(value, CREATE_SPEC_KEYS);
+    if (!Array.isArray(value["files"]) || value["files"].length < 1 || value["files"].length > 64) {
+        throw new SkillLoopError("PROPOSAL_SCHEMA_INVALID", "the createSpec files are invalid");
+    }
+    const files = value["files"].map((item) => {
+        if (!isRecord(item))
+            throw new SkillLoopError("PROPOSAL_SCHEMA_INVALID", "a createSpec file is invalid");
+        assertOnlyKeys(item, CREATE_FILE_KEYS);
+        return {
+            file: validateRelativeFile(text(item, "file", 1, 1024), targetSkill),
+            content: text(item, "content", 0, 65_536),
+        };
+    });
+    const identities = files.map((file) => canonicalPathIdentity(file.file));
+    if (new Set(identities).size !== files.length) {
+        throw new SkillLoopError("PROPOSAL_PATH_INVALID", "createSpec files collide by canonical path identity");
+    }
+    return { files };
+}
+function assertNoSecret(value) {
+    const serialized = JSON.stringify(value);
+    const redacted = JSON.stringify(redactSecretsInValue(value));
+    if (serialized !== redacted) {
+        throw new SkillLoopError("PROPOSAL_SECRET_REFUSED", "the proposal contained secret-shaped data");
+    }
+}
+export function validateProposal(value, expectedRoot) {
+    if (!isRecord(value) || Buffer.byteLength(JSON.stringify(value)) > 512_000) {
+        throw new SkillLoopError("PROPOSAL_SCHEMA_INVALID", "the proposal is invalid or oversized");
+    }
+    assertOnlyKeys(value, PROPOSAL_KEYS);
+    assertNoSecret(value);
+    const id = text(value, "id", 1, 128);
+    const createdAt = text(value, "createdAt", 1, 64);
+    const targetSkill = text(value, "targetSkill", 1, 128);
+    const targetRoot = text(value, "targetRoot", 1, 2048);
+    const status = value["status"];
+    const action = value["action"];
+    if (!ID.test(id) || !RFC3339.test(createdAt) || Number.isNaN(Date.parse(createdAt))) {
+        throw new SkillLoopError("PROPOSAL_SCHEMA_INVALID", "the proposal identity or timestamp is invalid");
+    }
+    validateTargetSkillIdentity(targetSkill);
+    if (value["schema"] !== "litfamily.skill-proposal/v1" || value["host"] !== "litcodex") {
+        throw new SkillLoopError("PROPOSAL_SCHEMA_INVALID", "the proposal schema or host is invalid");
+    }
+    if (resolve(targetRoot) !== resolve(expectedRoot)) {
+        throw new SkillLoopError("TARGET_NOT_AGENT_OWNED", "the proposal target is not agent-owned");
+    }
+    if (!["patch", "create", "add-reference", "archive"].includes(action)) {
+        throw new SkillLoopError("PROPOSAL_SCHEMA_INVALID", "the proposal action is invalid");
+    }
+    if (!["pending", "approved", "applied", "rejected", "rolled-back"].includes(status)) {
+        throw new SkillLoopError("PROPOSAL_SCHEMA_INVALID", "the proposal status is invalid");
+    }
+    const evidenceRefs = value["evidenceRefs"];
+    if (!Array.isArray(evidenceRefs) ||
+        evidenceRefs.length > 32 ||
+        evidenceRefs.some((item) => typeof item !== "string" || item.length < 1 || item.length > 2048) ||
+        new Set(evidenceRefs).size !== evidenceRefs.length) {
+        throw new SkillLoopError("PROPOSAL_SCHEMA_INVALID", "the proposal evidenceRefs are invalid");
+    }
+    const ledgerEntryId = value["ledgerEntryId"];
+    const terminal = status === "applied" || status === "rejected" || status === "rolled-back";
+    if (terminal !== (typeof ledgerEntryId === "string" && ledgerEntryId.length > 0)) {
+        throw new SkillLoopError("PROPOSAL_SCHEMA_INVALID", "the proposal ledger status invariant is invalid");
+    }
+    let patch;
+    let createSpec;
+    if (action === "patch") {
+        patch = validatePatch(value["patch"], targetSkill);
+        if (value["createSpec"] !== undefined)
+            throw new SkillLoopError("PROPOSAL_SCHEMA_INVALID", "patch forbids createSpec");
+    }
+    else if (action === "create" || action === "add-reference") {
+        createSpec = validateCreateSpec(value["createSpec"], targetSkill);
+        if (value["patch"] !== undefined)
+            throw new SkillLoopError("PROPOSAL_SCHEMA_INVALID", "create forbids patch");
+    }
+    else if (value["patch"] !== undefined || value["createSpec"] !== undefined) {
+        throw new SkillLoopError("PROPOSAL_SCHEMA_INVALID", "archive forbids content payloads");
+    }
+    return {
+        schema: "litfamily.skill-proposal/v1",
+        id,
+        createdAt,
+        host: "litcodex",
+        sessionRef: text(value, "sessionRef", 1, 512),
+        signal: text(value, "signal", 1, 128),
+        targetSkill,
+        targetRoot: resolve(targetRoot),
+        action: action,
+        ...(patch === undefined ? {} : { patch }),
+        ...(createSpec === undefined ? {} : { createSpec }),
+        rationale: text(value, "rationale", 1, 8192),
+        evidenceRefs: evidenceRefs,
+        status: status,
+        ...(typeof ledgerEntryId === "string" ? { ledgerEntryId } : {}),
+    };
+}

package/node_modules/@litcodex/lit-loop/dist/skill-loop/usage.d.ts

@@ -0,0 +1,6 @@
+import type { SkillLoopPaths } from "./paths.js";
+import { type SkillUsageSidecar } from "./types.js";
+export declare function validateUsageSidecar(value: unknown): SkillUsageSidecar;
+export declare function nextAppliedUsage(paths: SkillLoopPaths, skillId: string, timestamp: string): SkillUsageSidecar;
+export declare function nextAppliedUsageFrom(current: SkillUsageSidecar | null, skillId: string, timestamp: string): SkillUsageSidecar;
+export declare function recordAppliedUsage(paths: SkillLoopPaths, skillId: string, timestamp: string): void;

package/node_modules/@litcodex/lit-loop/dist/skill-loop/usage.js

@@ -0,0 +1,119 @@
+import { readUsage, writeUsage } from "./store.js";
+import { SkillLoopError } from "./types.js";
+function validDate(value) {
+    return typeof value === "string" && value.length > 0 && !Number.isNaN(Date.parse(value));
+}
+function validateEntry(value, updatedAt) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const entry = value;
+    const required = [
+        "state",
+        "use_count",
+        "view_count",
+        "patch_count",
+        "created_at",
+        "created_by",
+        "last_used_at",
+        "last_viewed_at",
+        "last_patched_at",
+        "archived_at",
+        "pinned",
+    ];
+    if (Object.keys(entry).length !== required.length || required.some((key) => !Object.hasOwn(entry, key)))
+        return false;
+    if (!["active", "stale", "archived"].includes(entry["state"]))
+        return false;
+    for (const field of ["use_count", "view_count", "patch_count"]) {
+        const count = entry[field];
+        if (typeof count !== "number" || !Number.isInteger(count) || count < 0)
+            return false;
+    }
+    const createdAtValue = entry["created_at"];
+    if (!validDate(createdAtValue) || Date.parse(createdAtValue) > updatedAt)
+        return false;
+    const createdAt = Date.parse(createdAtValue);
+    const useCount = entry["use_count"];
+    const viewCount = entry["view_count"];
+    const patchCount = entry["patch_count"];
+    if (!["agent", "user", "installed", "curator", null].includes(entry["created_by"]))
+        return false;
+    for (const field of ["last_used_at", "last_viewed_at", "last_patched_at", "archived_at"]) {
+        const date = entry[field];
+        if (date !== null) {
+            if (!validDate(date) || Date.parse(date) < createdAt || Date.parse(date) > updatedAt)
+                return false;
+        }
+    }
+    if ((entry["state"] === "archived") !== (entry["archived_at"] !== null))
+        return false;
+    if (useCount > 0 && entry["last_used_at"] === null)
+        return false;
+    if (viewCount > 0 && entry["last_viewed_at"] === null)
+        return false;
+    if (patchCount > 0 && entry["last_patched_at"] === null)
+        return false;
+    return typeof entry["pinned"] === "boolean";
+}
+export function validateUsageSidecar(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new SkillLoopError("USAGE_INVALID", "the usage sidecar is invalid");
+    }
+    const sidecar = value;
+    if (Object.keys(sidecar).some((key) => !["schema", "updatedAt", "skills"].includes(key)) ||
+        sidecar["schema"] !== "litfamily.skill-usage/v1" ||
+        !validDate(sidecar["updatedAt"]) ||
+        typeof sidecar["skills"] !== "object" ||
+        sidecar["skills"] === null ||
+        Array.isArray(sidecar["skills"])) {
+        throw new SkillLoopError("USAGE_INVALID", "the usage sidecar is invalid");
+    }
+    const updatedAt = Date.parse(sidecar["updatedAt"]);
+    for (const [id, entry] of Object.entries(sidecar["skills"])) {
+        if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(id) || !validateEntry(entry, updatedAt)) {
+            throw new SkillLoopError("USAGE_INVALID", "the usage sidecar contains an invalid entry");
+        }
+    }
+    return sidecar;
+}
+export function nextAppliedUsage(paths, skillId, timestamp) {
+    const current = readUsage(paths);
+    return nextAppliedUsageFrom(current, skillId, timestamp);
+}
+export function nextAppliedUsageFrom(current, skillId, timestamp) {
+    const sidecar = current === null
+        ? { schema: "litfamily.skill-usage/v1", updatedAt: timestamp, skills: {} }
+        : validateUsageSidecar(current);
+    const previous = sidecar.skills[skillId];
+    if (previous?.last_patched_at === timestamp && sidecar.updatedAt === timestamp)
+        return sidecar;
+    const entry = previous === undefined
+        ? {
+            state: "active",
+            use_count: 0,
+            view_count: 0,
+            patch_count: 1,
+            created_at: timestamp,
+            created_by: "agent",
+            last_used_at: null,
+            last_viewed_at: null,
+            last_patched_at: timestamp,
+            archived_at: null,
+            pinned: false,
+        }
+        : {
+            ...previous,
+            state: "active",
+            patch_count: previous.patch_count + 1,
+            last_patched_at: timestamp,
+            archived_at: null,
+        };
+    return {
+        schema: "litfamily.skill-usage/v1",
+        updatedAt: timestamp,
+        skills: { ...sidecar.skills, [skillId]: entry },
+    };
+}
+export function recordAppliedUsage(paths, skillId, timestamp) {
+    writeUsage(paths, nextAppliedUsage(paths, skillId, timestamp));
+}

package/node_modules/@litcodex/lit-loop/dist/skill-loop-cli.d.ts

@@ -0,0 +1,8 @@
+export interface SkillLoopCliContext {
+    readonly cwd: string;
+    readonly env: NodeJS.ProcessEnv;
+    readonly stdout: NodeJS.WritableStream;
+    readonly stderr: NodeJS.WritableStream;
+}
+export declare const SKILL_LOOP_SUBCOMMANDS: readonly ["propose", "list", "apply", "reject", "rollback", "review", "curator"];
+export declare function skillLoopCommand(args: readonly string[], context: SkillLoopCliContext): number;

package/node_modules/@litcodex/lit-loop/dist/skill-loop-cli.js

@@ -0,0 +1,111 @@
+import { existsSync, lstatSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { applyProposal, rejectProposal, rollbackMutation } from "./skill-loop/apply.js";
+import { runCurator } from "./skill-loop/curator.js";
+import { agentSkillRoot } from "./skill-loop/paths.js";
+import { runCodexReview } from "./skill-loop/review.js";
+import { listProposals, storeProposal } from "./skill-loop/store.js";
+import { SkillLoopError } from "./skill-loop/types.js";
+const MAX_PROPOSAL_FILE_BYTES = 512_000;
+export const SKILL_LOOP_SUBCOMMANDS = Object.freeze([
+    "propose",
+    "list",
+    "apply",
+    "reject",
+    "rollback",
+    "review",
+    "curator",
+]);
+function writeJson(stream, value) {
+    stream.write(`${JSON.stringify(value)}\n`);
+}
+function readProposalFile(cwd, input) {
+    if (!input)
+        throw new SkillLoopError("PROPOSAL_FILE_REQUIRED", "propose requires one JSON file");
+    const path = resolve(cwd, input);
+    if (!existsSync(path))
+        throw new SkillLoopError("PROPOSAL_FILE_MISSING", "the proposal file was not found");
+    const stat = lstatSync(path);
+    if (stat.isSymbolicLink() || !stat.isFile() || stat.size > MAX_PROPOSAL_FILE_BYTES) {
+        throw new SkillLoopError("PROPOSAL_FILE_UNSAFE", "the proposal file is unsafe or oversized");
+    }
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        throw new SkillLoopError("PROPOSAL_FILE_INVALID", "the proposal file is not valid JSON");
+    }
+}
+function requireSingle(args, command) {
+    if (args.length !== 2 || !args[1])
+        throw new SkillLoopError("SKILL_LOOP_USAGE", `${command} requires one id`);
+    return args[1];
+}
+export function skillLoopCommand(args, context) {
+    try {
+        const command = args[0];
+        if (command === "propose") {
+            if (args.length !== 2)
+                throw new SkillLoopError("SKILL_LOOP_USAGE", "propose requires one JSON file");
+            const proposal = storeProposal(context.cwd, readProposalFile(context.cwd, args[1]), { env: context.env });
+            writeJson(context.stdout, { ok: true, id: proposal.id, status: proposal.status });
+            return 0;
+        }
+        if (command === "list") {
+            if (args.length !== 1)
+                throw new SkillLoopError("SKILL_LOOP_USAGE", "list accepts no arguments");
+            writeJson(context.stdout, { ok: true, proposals: listProposals(context.cwd, { env: context.env }) });
+            return 0;
+        }
+        if (command === "apply") {
+            const result = applyProposal(context.cwd, requireSingle(args, "apply"), { env: context.env });
+            writeJson(context.stdout, {
+                ok: true,
+                id: result.proposal.id,
+                status: result.proposal.status,
+                ledgerId: result.ledger.id,
+                target: resolve(agentSkillRoot(context.env), result.proposal.targetSkill),
+            });
+            return 0;
+        }
+        if (command === "reject") {
+            const result = rejectProposal(context.cwd, requireSingle(args, "reject"), { env: context.env });
+            writeJson(context.stdout, {
+                ok: true,
+                id: result.proposal.id,
+                status: result.proposal.status,
+                ledgerId: result.ledger.id,
+            });
+            return 0;
+        }
+        if (command === "rollback") {
+            const result = rollbackMutation(context.cwd, requireSingle(args, "rollback"), { env: context.env });
+            writeJson(context.stdout, {
+                ok: true,
+                status: result.proposal?.status ?? "rolled-back",
+                ledgerId: result.ledger.id,
+                restoresLedgerEntryId: result.ledger.restoresLedgerEntryId,
+            });
+            return 0;
+        }
+        if (command === "review") {
+            if (args.length !== 1)
+                throw new SkillLoopError("SKILL_LOOP_USAGE", "review accepts no arguments");
+            writeJson(context.stdout, runCodexReview(context.cwd, { env: context.env }));
+            return 0;
+        }
+        if (command === "curator") {
+            if (args.length !== 1)
+                throw new SkillLoopError("SKILL_LOOP_USAGE", "curator accepts no arguments");
+            writeJson(context.stdout, { ok: true, ...runCurator(context.cwd, { env: context.env }) });
+            return 0;
+        }
+        throw new SkillLoopError("SKILL_LOOP_USAGE", "usage: skill-loop <propose|list|apply|reject|rollback|review|curator>");
+    }
+    catch (error) {
+        const code = error instanceof SkillLoopError ? error.code : "SKILL_LOOP_FAILED";
+        const message = error instanceof SkillLoopError ? error.message : "the skill-loop command failed";
+        writeJson(context.stderr, { ok: false, error: { code, message } });
+        return code === "REVIEW_EXEC_BLOCKED" ? 3 : 2;
+    }
+}

package/node_modules/@litcodex/lit-loop/dist/skill-mention-scope.d.ts

@@ -0,0 +1,4 @@
+import type { LitTriggerToken } from "./trigger.js";
+export declare function isCodexSkillMentionToken(prompt: string, tokenIndex: number): boolean;
+export declare function scopedTokenForBareLit(prompt: string, tokenIndex: number): LitTriggerToken | null;
+export declare function suppressesBareLitAfterCodexSkillMention(prompt: string, tokenIndex: number): boolean;

package/node_modules/@litcodex/lit-loop/dist/skill-mention-scope.js

@@ -0,0 +1,69 @@
+import { renamedSkillId } from "./skill-renames.js";
+const LITCODEX_PLUGIN_NAME = "litcodex";
+const CODEX_SKILL_MENTION_PATTERN = /\$([A-Za-z0-9_-]+):([A-Za-z0-9_-]+)/gu;
+export function isCodexSkillMentionToken(prompt, tokenIndex) {
+    let start = tokenIndex;
+    while (start > 0 && !/\s/u.test(prompt[start - 1] ?? "")) {
+        start -= 1;
+    }
+    let end = tokenIndex;
+    while (end < prompt.length && !/\s/u.test(prompt[end] ?? "")) {
+        end += 1;
+    }
+    const mention = prompt.slice(start, end);
+    return mention.startsWith("$") && mention.includes(":") && tokenIndex > start;
+}
+export function scopedTokenForBareLit(prompt, tokenIndex) {
+    const skillName = nearestLitcodexSkillNameBefore(prompt, tokenIndex);
+    if (skillName === null || suppressesBareLitAfterCodexSkillMention(prompt, tokenIndex)) {
+        return null;
+    }
+    return tokenForSkillName(skillName);
+}
+export function suppressesBareLitAfterCodexSkillMention(prompt, tokenIndex) {
+    return nearestLitcodexSkillNameBefore(prompt, tokenIndex) === "start-work";
+}
+function nearestLitcodexSkillNameBefore(prompt, tokenIndex) {
+    let scopedSkillName = null;
+    for (const match of prompt.slice(0, tokenIndex).matchAll(CODEX_SKILL_MENTION_PATTERN)) {
+        const pluginName = match[1]?.toLowerCase();
+        const skillName = match[2]?.toLowerCase();
+        if (pluginName !== LITCODEX_PLUGIN_NAME || skillName === undefined) {
+            continue;
+        }
+        if (tokenForSkillName(skillName) !== null) {
+            scopedSkillName = skillName;
+        }
+    }
+    return scopedSkillName;
+}
+function tokenForSkillName(skillName) {
+    switch (renamedSkillId(skillName) ?? skillName) {
+        case "lit-loop":
+            return "lit-loop";
+        case "lit-plan":
+            return "lit-plan";
+        case "litwork":
+            return "litwork";
+        case "litgoal":
+            return "litgoal";
+        case "litresearch":
+            return "litresearch";
+        case "lit-recap":
+            return "lit-recap";
+        case "lit-comprehend":
+            return "lit-comprehend";
+        case "lit-crucible":
+            return "lit-crucible";
+        case "lit-init":
+            return "lit-init";
+        case "deep-interview":
+            return "deep-interview";
+        case "start-work":
+            return "start-work";
+        case "review-work":
+            return "review-work";
+        default:
+            return null;
+    }
+}

package/node_modules/@litcodex/lit-loop/dist/skill-observer-cli.d.ts

@@ -0,0 +1,3 @@
+export declare const MAX_OBSERVER_STDIN_BYTES = 16384;
+export declare const OBSERVER_STDIN_TIMEOUT_MS = 5000;
+export declare function runSkillObserverCli(stdin: NodeJS.ReadableStream, stdout: NodeJS.WritableStream, stderr: NodeJS.WritableStream): Promise<number>;