@litfamily/litcodex 1.0.1 → 1.0.2

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

@@ -1,246 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,119 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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-observer-cli.d.ts

@@ -1,3 +0,0 @@
-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>;

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

@@ -1,116 +0,0 @@
-import { TextDecoder } from "node:util";
-import { recordObservation, SkillObserverError } from "./skill-observer.js";
-export const MAX_OBSERVER_STDIN_BYTES = 16_384;
-export const OBSERVER_STDIN_TIMEOUT_MS = 5_000;
-const OBSERVATION_LOG_RELATIVE_PATH = ".litcodex/skill-observer/observations.jsonl";
-const UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
-function writeJsonLine(stream, value) {
-    stream.write(`${JSON.stringify(value)}\n`);
-}
-function writeInputError(stream, code, message) {
-    writeJsonLine(stream, { ok: false, error: { code, message } });
-}
-function readBoundedStdin(stdin) {
-    return new Promise((resolve) => {
-        const chunks = [];
-        let total = 0;
-        let settled = false;
-        let timeout;
-        const onData = (chunk) => {
-            const bytes = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
-            total += bytes.byteLength;
-            if (total > MAX_OBSERVER_STDIN_BYTES) {
-                finish({ bytes: null, errorCode: "OBSERVER_STDIN_TOO_LARGE" });
-                stdin.pause();
-                const destroy = stdin.destroy;
-                if (typeof destroy === "function")
-                    destroy.call(stdin);
-                return;
-            }
-            chunks.push(bytes);
-        };
-        const onEnd = () => finish({ bytes: Buffer.concat(chunks), errorCode: null });
-        const onError = () => finish({ bytes: null, errorCode: "OBSERVER_STDIN_UNAVAILABLE" });
-        const onClose = () => finish({ bytes: null, errorCode: "OBSERVER_STDIN_UNAVAILABLE" });
-        const cleanup = () => {
-            if (timeout !== undefined)
-                clearTimeout(timeout);
-            stdin.removeListener("data", onData);
-            stdin.removeListener("end", onEnd);
-            stdin.removeListener("error", onError);
-            stdin.removeListener("close", onClose);
-        };
-        const finish = (value) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            resolve(value);
-        };
-        stdin.on("data", onData);
-        stdin.on("end", onEnd);
-        stdin.on("error", onError);
-        stdin.on("close", onClose);
-        timeout = setTimeout(() => {
-            finish({ bytes: null, errorCode: "OBSERVER_STDIN_UNAVAILABLE" });
-            stdin.pause();
-            const destroy = stdin.destroy;
-            if (typeof destroy === "function")
-                destroy.call(stdin);
-        }, OBSERVER_STDIN_TIMEOUT_MS);
-    });
-}
-function storageError(error) {
-    if (error instanceof SkillObserverError) {
-        const message = error.code === "OBSERVER_RECORD_COMMITTED_CLEANUP_FAILED"
-            ? "the record was committed, but cleanup failed; read the log before retrying"
-            : "the observer input was refused or could not be stored";
-        return { ok: false, error: { code: error.code, message } };
-    }
-    return { ok: false, error: { code: "OBSERVER_COMMAND_FAILED", message: "the observer command failed" } };
-}
-export async function runSkillObserverCli(stdin, stdout, stderr) {
-    const input = await readBoundedStdin(stdin);
-    if (input.errorCode !== null) {
-        const message = input.errorCode === "OBSERVER_STDIN_TOO_LARGE"
-            ? "observer input exceeded the byte limit"
-            : "observer input stream was unavailable";
-        writeInputError(stderr, input.errorCode, message);
-        return 2;
-    }
-    const bytes = input.bytes;
-    if (bytes === null) {
-        writeInputError(stderr, "OBSERVER_STDIN_UNAVAILABLE", "observer input stream was unavailable");
-        return 2;
-    }
-    let raw;
-    try {
-        raw = UTF8_DECODER.decode(bytes);
-    }
-    catch {
-        writeInputError(stderr, "OBSERVER_STDIN_INVALID_UTF8", "observer input was not valid UTF-8");
-        return 2;
-    }
-    if (raw.trim().length === 0) {
-        writeInputError(stderr, "OBSERVER_INPUT_EMPTY", "observer input was empty");
-        return 2;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        writeInputError(stderr, "OBSERVER_STDIN_INVALID_JSON", "observer input was not valid JSON");
-        return 2;
-    }
-    try {
-        const root = process.cwd();
-        const record = recordObservation(root, parsed);
-        writeJsonLine(stdout, { ok: true, record, logPath: OBSERVATION_LOG_RELATIVE_PATH });
-        return 0;
-    }
-    catch (error) {
-        writeJsonLine(stderr, storageError(error));
-        return 2;
-    }
-}

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

@@ -1,6 +0,0 @@
-import { type GuardTranscriptInput } from "./guards.js";
-/** Match only the complete observer route or its exact Codex scoped shorthand. */
-export declare function isExactSkillObserverPrompt(prompt: string): boolean;
-export declare const isExactBareSkillObserverPrompt: typeof isExactSkillObserverPrompt;
-/** Apply the existing per-mode idempotency and context-pressure guards. */
-export declare function shouldSuppressSkillObserverInjection(transcriptPath: GuardTranscriptInput): boolean;

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

@@ -1,12 +0,0 @@
-import { transcriptHasContextPressureMarker, transcriptHasDirectiveMarker, } from "./guards.js";
-import { SKILL_OBSERVER_DIRECTIVE_MARKER } from "./markers.js";
-/** Match only the complete observer route or its exact Codex scoped shorthand. */
-export function isExactSkillObserverPrompt(prompt) {
-    return /^\s*(?:skill-observer|\$litcodex:skill-observer)\s*$/iu.test(prompt);
-}
-export const isExactBareSkillObserverPrompt = isExactSkillObserverPrompt;
-/** Apply the existing per-mode idempotency and context-pressure guards. */
-export function shouldSuppressSkillObserverInjection(transcriptPath) {
-    return (transcriptHasDirectiveMarker(transcriptPath, SKILL_OBSERVER_DIRECTIVE_MARKER) ||
-        transcriptHasContextPressureMarker(transcriptPath));
-}

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

@@ -1,18 +0,0 @@
-export declare const OBSERVER_SIGNALS: readonly ["correction", "repetition", "coverage-gap"];
-export declare const OBSERVER_RECORD_STATE_UNKNOWN: "OBSERVER_RECORD_STATE_UNKNOWN";
-export declare const OBSERVER_RECORD_COMMITTED_CLEANUP_FAILED: "OBSERVER_RECORD_COMMITTED_CLEANUP_FAILED";
-export type ObserverSignal = (typeof OBSERVER_SIGNALS)[number];
-export type SkillObservation = {
-    readonly signal: ObserverSignal;
-    readonly skillId: string;
-    readonly observed: string;
-    readonly proposal: string;
-    readonly applied: false;
-};
-export declare class SkillObserverError extends Error {
-    readonly code: string;
-    constructor(code: string, message: string);
-}
-export declare function observationLogPath(root?: string): string;
-export declare function recordObservation(root: string, observation: unknown): SkillObservation;
-export declare function readObservations(root?: string): readonly SkillObservation[];