@litfamily/litcodex 1.0.0 → 1.0.2

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

@@ -1,12 +0,0 @@
-export const DEFAULT_SKILL_LOOP_CONFIG = Object.freeze({
-    autoApply: false,
-    nudgeInterval: 10,
-    curator: Object.freeze({
-        intervalDays: 7,
-        minimumIdleHours: 2,
-        staleAfterDays: 30,
-        archiveAfterDays: 90,
-        delete: false,
-        consolidation: false,
-    }),
-});

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

@@ -1,14 +0,0 @@
-export interface CuratorOptions {
-    readonly env?: NodeJS.ProcessEnv | undefined;
-    readonly now?: () => Date;
-    readonly lastActivityAt?: Date;
-    readonly id?: () => string;
-}
-export interface CuratorResult {
-    readonly stale: readonly string[];
-    readonly archived: readonly string[];
-    readonly skipped: readonly string[];
-    readonly ledgerIds: readonly string[];
-}
-export declare function runCurator(workspaceRoot: string, options?: CuratorOptions): CuratorResult;
-export declare function assertCuratorNeverDeletes(): false;

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

@@ -1,112 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { DEFAULT_SKILL_LOOP_CONFIG } from "./config.js";
-import { snapshotIsAgentOwned } from "./ownership.js";
-import { skillLoopPaths } from "./paths.js";
-import { readUsage, snapshotSkill, withAgentMutationLock, withSkillLoopLock } from "./store.js";
-import { recoverMutationJournalWhileLocked, writeMutationJournal } from "./transaction.js";
-import { SkillLoopError } from "./types.js";
-import { validateUsageSidecar } from "./usage.js";
-const DAY = 24 * 60 * 60 * 1000;
-function mostRecent(entry) {
-    return Math.max(...[entry.created_at, entry.last_used_at, entry.last_viewed_at, entry.last_patched_at, entry.archived_at]
-        .filter((value) => value !== null)
-        .map((value) => Date.parse(value)));
-}
-function nextSidecar(sidecar, skillId, entry, timestamp) {
-    return {
-        schema: "litfamily.skill-usage/v1",
-        updatedAt: timestamp,
-        skills: { ...sidecar.skills, [skillId]: entry },
-    };
-}
-export function runCurator(workspaceRoot, options = {}) {
-    const paths = skillLoopPaths(workspaceRoot, options.env);
-    return withSkillLoopLock(paths, () => withAgentMutationLock(paths, () => {
-        recoverMutationJournalWhileLocked(workspaceRoot, options.env, { operation: "curator-transition" });
-        const rawUsage = readUsage(paths);
-        if (rawUsage === null)
-            return { stale: [], archived: [], skipped: [], ledgerIds: [] };
-        let sidecar = validateUsageSidecar(rawUsage);
-        const instant = (options.now ?? (() => new Date()))();
-        const timestamp = instant.toISOString();
-        const lastActivity = options.lastActivityAt?.getTime() ?? Date.parse(sidecar.updatedAt);
-        if (instant.getTime() - lastActivity < DEFAULT_SKILL_LOOP_CONFIG.curator.minimumIdleHours * 60 * 60 * 1000) {
-            return { stale: [], archived: [], skipped: Object.keys(sidecar.skills).sort(), ledgerIds: [] };
-        }
-        const stale = [];
-        const archived = [];
-        const skipped = [];
-        const ledgerIds = [];
-        for (const skillId of Object.keys(sidecar.skills).sort()) {
-            const entry = sidecar.skills[skillId];
-            if (entry === undefined || entry.pinned || entry.state === "archived") {
-                skipped.push(skillId);
-                continue;
-            }
-            const ageDays = (instant.getTime() - mostRecent(entry)) / DAY;
-            const transition = entry.state === "active" && ageDays >= DEFAULT_SKILL_LOOP_CONFIG.curator.staleAfterDays
-                ? "stale"
-                : entry.state === "stale" && ageDays >= DEFAULT_SKILL_LOOP_CONFIG.curator.archiveAfterDays
-                    ? "archived"
-                    : null;
-            if (transition === null) {
-                skipped.push(skillId);
-                continue;
-            }
-            const before = snapshotSkill(paths, skillId);
-            if (before.length === 0 || !snapshotIsAgentOwned(paths, before)) {
-                skipped.push(skillId);
-                continue;
-            }
-            const runId = `${timestamp.replace(/[:.]/gu, "-")}-${randomUUID()}`;
-            const after = transition === "archived" ? [] : before;
-            const transitioned = {
-                ...entry,
-                state: transition,
-                archived_at: transition === "archived" ? timestamp : null,
-            };
-            const updated = nextSidecar(sidecar, skillId, transitioned, timestamp);
-            const ledger = {
-                schema: "litfamily.skill-ledger/v1",
-                id: (options.id ?? (() => `ledger-${randomUUID()}`))(),
-                createdAt: timestamp,
-                proposalId: null,
-                actor: "curator",
-                operation: "curator-transition",
-                targetSkill: skillId,
-                targetRoot: paths.agentRoot,
-                before,
-                after,
-                reason: transition === "archived"
-                    ? "usage exceeded the archive threshold"
-                    : "usage exceeded the stale threshold",
-            };
-            writeMutationJournal(workspaceRoot, {
-                schema: "litcodex.skill-transaction/v1",
-                operation: "curator-transition",
-                ledger,
-                usageAfter: updated,
-                copies: [
-                    { kind: "backup", relativePath: `${runId}/${skillId}` },
-                    ...(transition === "archived"
-                        ? [{ kind: "archive", relativePath: `${skillId}/${runId}` }]
-                        : []),
-                ],
-            }, options.env);
-            recoverMutationJournalWhileLocked(workspaceRoot, options.env, { operation: "curator-transition" });
-            sidecar = updated;
-            ledgerIds.push(ledger.id);
-            if (transition === "archived")
-                archived.push(skillId);
-            else
-                stale.push(skillId);
-        }
-        return { stale, archived, skipped, ledgerIds };
-    }));
-}
-export function assertCuratorNeverDeletes() {
-    if (DEFAULT_SKILL_LOOP_CONFIG.curator.delete !== false) {
-        throw new SkillLoopError("CURATOR_CONFIG_INVALID", "the curator delete setting must remain false");
-    }
-    return false;
-}

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

@@ -1,19 +0,0 @@
-interface PendingOptions {
-    readonly now?: () => Date;
-    readonly env?: NodeJS.ProcessEnv | undefined;
-    readonly beforeRead?: ((path: string) => void) | undefined;
-    /** Test-only race seam; production callers leave this unset. */
-    readonly afterEnumerate?: (() => void) | undefined;
-    /** Test-only race seam; production callers leave this unset. */
-    readonly beforeWrite?: ((path: string) => void) | undefined;
-    /** Test-only last-boundary race seam; production callers leave this unset. */
-    readonly afterWriteVerify?: ((path: string) => void) | undefined;
-}
-export declare function markPendingReviews(workspaceRoot: string, input: unknown, options?: PendingOptions): {
-    readonly marked: number;
-    readonly skipped: number;
-};
-export declare function pendingReviewNotice(workspaceRoot: string, options?: PendingOptions): string | null;
-export declare function pendingReviewDirectories(workspaceRoot: string, options?: PendingOptions): string[];
-export declare function markReviewsComplete(workspaceRoot: string, timestamp: string): void;
-export {};

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

@@ -1,435 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import { closeSync, constants, fstatSync, lstatSync, opendirSync, openSync, readSync, realpathSync } from "node:fs";
-import { basename, dirname, join, relative, resolve, sep } from "node:path";
-import { normalizeSessionId } from "../state-paths.js";
-import { SkillLoopError } from "./types.js";
-const PENDING_SCHEMA = "litcodex.skill-review-pending/v1";
-const MAX_GOALS_BYTES = 64_000;
-const MAX_SESSION_DIRECTORY_ENTRIES = 64;
-const MAX_SESSION_DIRECTORIES = 16;
-const SOURCE_FILE_CAPS = new Map([
-    ["brief.md", 64_000],
-    ["goals.json", MAX_GOALS_BYTES],
-    ["ledger.jsonl", 256_000],
-]);
-const MAX_SESSION_SOURCE_BYTES = 384_000;
-const ANCHORED_PENDING_WRITE = `
-import {
-  closeSync,
-  constants,
-  existsSync,
-  fsyncSync,
-  lstatSync,
-  openSync,
-  readFileSync,
-  realpathSync,
-  renameSync,
-  unlinkSync,
-  writeSync,
-} from "node:fs";
-import { randomBytes } from "node:crypto";
-
-const [expectedRealPath, expectedDev, expectedIno, expectedUid, expectedMode, expectedBirthtimeMs] = process.argv.slice(1);
-const matches = () => {
-  const stat = lstatSync(".");
-  return stat.isDirectory() &&
-    !stat.isSymbolicLink() &&
-    String(stat.dev) === expectedDev &&
-    String(stat.ino) === expectedIno &&
-    String(stat.uid) === expectedUid &&
-    String(stat.mode) === expectedMode &&
-    String(stat.birthtimeMs) === expectedBirthtimeMs &&
-    (stat.mode & 0o022) === 0 &&
-    realpathSync.native(".") === expectedRealPath;
-};
-
-if (!matches()) process.exit(41);
-const bytes = readFileSync(0);
-if (bytes.byteLength > 16_384) process.exit(42);
-const temporary = ".pending-review.json.litcodex-" + process.pid + "-" + randomBytes(8).toString("hex");
-let fileDescriptor;
-let directoryDescriptor;
-try {
-  fileDescriptor = openSync(
-    temporary,
-    constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW,
-    0o600,
-  );
-  let offset = 0;
-  while (offset < bytes.byteLength) {
-    const written = writeSync(fileDescriptor, bytes, offset, bytes.byteLength - offset, null);
-    if (written <= 0) throw new Error("short write");
-    offset += written;
-  }
-  fsyncSync(fileDescriptor);
-  closeSync(fileDescriptor);
-  fileDescriptor = undefined;
-  if (!matches()) throw new Error("directory authority changed before rename");
-  renameSync(temporary, "pending-review.json");
-  directoryDescriptor = openSync(".", constants.O_RDONLY | constants.O_NOFOLLOW);
-  fsyncSync(directoryDescriptor);
-  closeSync(directoryDescriptor);
-  directoryDescriptor = undefined;
-  if (!matches()) throw new Error("directory authority changed after rename");
-} finally {
-  if (fileDescriptor !== undefined) closeSync(fileDescriptor);
-  if (directoryDescriptor !== undefined) closeSync(directoryDescriptor);
-  if (existsSync(temporary)) unlinkSync(temporary);
-}
-`;
-function record(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function sameStat(left, right) {
-    return (left.dev === right.dev &&
-        left.ino === right.ino &&
-        left.uid === right.uid &&
-        left.mode === right.mode &&
-        left.nlink === right.nlink &&
-        left.size === right.size &&
-        left.mtimeMs === right.mtimeMs &&
-        left.ctimeMs === right.ctimeMs &&
-        left.birthtimeMs === right.birthtimeMs);
-}
-function captureDirectoryPin(path, expectedRealPath) {
-    const stat = lstatSync(path);
-    const uid = typeof process.getuid === "function" ? process.getuid() : stat.uid;
-    if (stat.isSymbolicLink() ||
-        !stat.isDirectory() ||
-        (stat.uid !== uid && stat.uid !== 0) ||
-        (stat.mode & 0o022) !== 0 ||
-        realpathSync.native(path) !== expectedRealPath) {
-        throw new SkillLoopError("REVIEW_SESSION_UNSAFE", "a lit-loop directory authority is unsafe");
-    }
-    return {
-        path,
-        realPath: expectedRealPath,
-        dev: stat.dev,
-        ino: stat.ino,
-        uid: stat.uid,
-        mode: stat.mode,
-        birthtimeMs: stat.birthtimeMs,
-    };
-}
-function sameDirectoryPin(left, right) {
-    return (left.path === right.path &&
-        left.realPath === right.realPath &&
-        left.dev === right.dev &&
-        left.ino === right.ino &&
-        left.uid === right.uid &&
-        left.mode === right.mode &&
-        left.birthtimeMs === right.birthtimeMs);
-}
-function verifyDirectoryAuthority(authority) {
-    for (const expected of authority) {
-        let current;
-        try {
-            current = captureDirectoryPin(expected.path, expected.realPath);
-        }
-        catch {
-            throw new SkillLoopError("REVIEW_SESSION_UNSAFE", "a lit-loop directory authority changed");
-        }
-        if (!sameDirectoryPin(current, expected)) {
-            throw new SkillLoopError("REVIEW_SESSION_UNSAFE", "a lit-loop directory authority changed");
-        }
-    }
-}
-function appendDirectoryAuthority(authority, path, expectedRealPath) {
-    verifyDirectoryAuthority(authority);
-    let pin;
-    try {
-        pin = captureDirectoryPin(path, expectedRealPath);
-    }
-    catch {
-        throw new SkillLoopError("REVIEW_SESSION_UNSAFE", "a lit-loop directory authority is unsafe");
-    }
-    verifyDirectoryAuthority(authority);
-    return [...authority, pin];
-}
-function workspaceAuthority(workspaceRoot) {
-    const workspace = resolve(workspaceRoot);
-    let physical;
-    try {
-        physical = realpathSync.native(workspace);
-    }
-    catch {
-        throw new SkillLoopError("REVIEW_SESSION_UNSAFE", "the workspace authority is unavailable");
-    }
-    return [captureDirectoryPin(workspace, physical)];
-}
-function childAuthorityOrNull(authority, path, expectedRealPath) {
-    verifyDirectoryAuthority(authority);
-    try {
-        lstatSync(path);
-    }
-    catch (error) {
-        if (error.code === "ENOENT") {
-            verifyDirectoryAuthority(authority);
-            return null;
-        }
-        throw new SkillLoopError("REVIEW_SESSION_UNSAFE", "a lit-loop directory could not be inspected safely");
-    }
-    return appendDirectoryAuthority(authority, path, expectedRealPath);
-}
-function pinnedBytes(path, cap, authority, beforeRead) {
-    verifyDirectoryAuthority(authority);
-    let before;
-    try {
-        before = lstatSync(path);
-    }
-    catch (error) {
-        if (error.code === "ENOENT") {
-            verifyDirectoryAuthority(authority);
-            return null;
-        }
-        throw new SkillLoopError("REVIEW_SESSION_UNSAFE", "a lit-loop source could not be inspected safely");
-    }
-    if (before.size > cap)
-        throw new SkillLoopError("REVIEW_SESSION_LIMIT", "a lit-loop source exceeded its byte cap");
-    const uid = typeof process.getuid === "function" ? process.getuid() : before.uid;
-    if (before.isSymbolicLink() ||
-        !before.isFile() ||
-        before.nlink !== 1 ||
-        (before.uid !== uid && before.uid !== 0) ||
-        dirname(path) !== authority.at(-1)?.path) {
-        throw new SkillLoopError("REVIEW_SESSION_UNSAFE", "a lit-loop source path is unsafe");
-    }
-    beforeRead?.(path);
-    verifyDirectoryAuthority(authority);
-    let descriptor;
-    try {
-        descriptor = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
-        const opened = fstatSync(descriptor);
-        const current = lstatSync(path);
-        if (!opened.isFile() ||
-            opened.isSymbolicLink() ||
-            opened.nlink !== 1 ||
-            !sameStat(opened, before) ||
-            !sameStat(current, before)) {
-            throw new SkillLoopError("REVIEW_SESSION_UNSAFE", "a lit-loop source changed before descriptor read");
-        }
-        const bytes = Buffer.alloc(opened.size);
-        let total = 0;
-        while (total < opened.size) {
-            const count = readSync(descriptor, bytes, total, opened.size - total, total);
-            if (count === 0)
-                break;
-            total += count;
-        }
-        const after = fstatSync(descriptor);
-        const pathAfter = lstatSync(path);
-        verifyDirectoryAuthority(authority);
-        if (!sameStat(after, before) || !sameStat(pathAfter, before)) {
-            throw new SkillLoopError("REVIEW_SESSION_UNSAFE", "a lit-loop source changed during descriptor read");
-        }
-        return bytes.subarray(0, total);
-    }
-    catch (error) {
-        if (error instanceof SkillLoopError)
-            throw error;
-        throw new SkillLoopError("REVIEW_SESSION_UNSAFE", "a lit-loop source could not be opened without following links");
-    }
-    finally {
-        if (descriptor !== undefined)
-            closeSync(descriptor);
-    }
-}
-function validatedSession(session, loopRoot, beforeRead) {
-    const directory = session.path;
-    const goalsPath = join(directory, "goals.json");
-    const bytes = pinnedBytes(goalsPath, MAX_GOALS_BYTES, session.authority, beforeRead);
-    if (bytes === null)
-        return null;
-    let goals;
-    try {
-        goals = JSON.parse(bytes.toString("utf8"));
-    }
-    catch {
-        return null;
-    }
-    if (!record(goals) || goals["version"] !== 1 || !Array.isArray(goals["goals"]) || goals["goals"].length === 0) {
-        return null;
-    }
-    if (goals["goals"].some((goal) => !record(goal) ||
-        typeof goal["id"] !== "string" ||
-        !["pending", "in_progress", "complete", "failed", "blocked"].includes(goal["status"]))) {
-        return null;
-    }
-    if (directory === loopRoot)
-        return "unscoped";
-    const directoryId = basename(directory);
-    const declared = typeof goals["sessionId"] === "string" ? normalizeSessionId(goals["sessionId"]) : directoryId;
-    return declared === directoryId ? directoryId : null;
-}
-function sessionDirectories(workspaceRoot, beforeRead, afterEnumerate) {
-    const workspace = resolve(workspaceRoot);
-    const stateRoot = join(workspace, ".litcodex");
-    const loopRoot = join(stateRoot, "lit-loop");
-    const baseAuthority = workspaceAuthority(workspace);
-    const physicalWorkspace = baseAuthority[0]?.realPath;
-    const stateAuthority = childAuthorityOrNull(baseAuthority, stateRoot, join(physicalWorkspace, ".litcodex"));
-    if (stateAuthority === null)
-        return [];
-    const loopAuthority = childAuthorityOrNull(stateAuthority, loopRoot, join(physicalWorkspace, ".litcodex", "lit-loop"));
-    if (loopAuthority === null)
-        return [];
-    const directories = [{ path: loopRoot, authority: loopAuthority }];
-    const handle = opendirSync(loopRoot);
-    let visited = 0;
-    try {
-        for (let entry = handle.readSync(); entry !== null; entry = handle.readSync()) {
-            visited += 1;
-            if (visited > MAX_SESSION_DIRECTORY_ENTRIES) {
-                throw new SkillLoopError("REVIEW_SESSION_LIMIT", "the lit-loop session directory cap was exceeded");
-            }
-            if (!entry.isDirectory() || entry.isSymbolicLink())
-                continue;
-            if (directories.length >= MAX_SESSION_DIRECTORIES) {
-                throw new SkillLoopError("REVIEW_SESSION_LIMIT", "the lit-loop session count cap was exceeded");
-            }
-            const path = join(loopRoot, entry.name);
-            const relation = relative(loopRoot, path);
-            if (relation.length === 0 || relation.includes(sep) || relation === ".." || relation.startsWith(`..${sep}`)) {
-                throw new SkillLoopError("REVIEW_SESSION_UNSAFE", "a lit-loop session path escaped its root");
-            }
-            const authority = appendDirectoryAuthority(loopAuthority, path, join(loopAuthority.at(-1)?.realPath, relation));
-            directories.push({ path, authority });
-        }
-    }
-    finally {
-        handle.closeSync();
-    }
-    for (const directory of directories)
-        verifyDirectoryAuthority(directory.authority);
-    afterEnumerate?.();
-    for (const directory of directories)
-        verifyDirectoryAuthority(directory.authority);
-    return directories.filter((directory) => validatedSession(directory, loopRoot, beforeRead) !== null);
-}
-function readPending(session, beforeRead) {
-    const path = join(session.path, "pending-review.json");
-    const bytes = pinnedBytes(path, 16_384, session.authority, beforeRead);
-    if (bytes === null)
-        return null;
-    try {
-        const value = JSON.parse(bytes.toString("utf8"));
-        if (value.schema !== PENDING_SCHEMA ||
-            typeof value.sessionRef !== "string" ||
-            typeof value.createdAt !== "string" ||
-            (value.status !== "pending" && value.status !== "reviewed")) {
-            return null;
-        }
-        return value;
-    }
-    catch {
-        return null;
-    }
-}
-function writePending(session, pending, beforeWrite, afterWriteVerify) {
-    const path = join(session.path, "pending-review.json");
-    verifyDirectoryAuthority(session.authority);
-    beforeWrite?.(path);
-    verifyDirectoryAuthority(session.authority);
-    afterWriteVerify?.(path);
-    const pin = session.authority.at(-1);
-    if (pin === undefined)
-        throw new SkillLoopError("REVIEW_SESSION_UNSAFE", "the pending write authority is missing");
-    const content = `${JSON.stringify(pending, null, 2)}\n`;
-    if (Buffer.byteLength(content) > 16_384) {
-        throw new SkillLoopError("REVIEW_SESSION_LIMIT", "the pending review state exceeded its byte cap");
-    }
-    const result = spawnSync(process.execPath, [
-        "--input-type=module",
-        "--eval",
-        ANCHORED_PENDING_WRITE,
-        pin.realPath,
-        String(pin.dev),
-        String(pin.ino),
-        String(pin.uid),
-        String(pin.mode),
-        String(pin.birthtimeMs),
-    ], {
-        cwd: session.path,
-        env: {},
-        input: content,
-        encoding: "utf8",
-        stdio: ["pipe", "pipe", "pipe"],
-        maxBuffer: 1_024,
-        timeout: 5_000,
-    });
-    if (result.error !== undefined || result.status !== 0) {
-        throw new SkillLoopError("REVIEW_SESSION_UNSAFE", "the anchored pending-state write was refused");
-    }
-    verifyDirectoryAuthority(session.authority);
-}
-function sourceDigest(session, beforeRead) {
-    const hash = createHash("sha256");
-    let aggregate = 0;
-    for (const [name, cap] of SOURCE_FILE_CAPS) {
-        const path = join(session.path, name);
-        const bytes = pinnedBytes(path, cap, session.authority, beforeRead);
-        if (bytes === null)
-            continue;
-        if (aggregate + bytes.byteLength > MAX_SESSION_SOURCE_BYTES) {
-            throw new SkillLoopError("REVIEW_SESSION_LIMIT", "a lit-loop session source exceeded its byte cap");
-        }
-        aggregate += bytes.byteLength;
-        hash.update(name);
-        hash.update(bytes);
-    }
-    return hash.digest("hex");
-}
-export function markPendingReviews(workspaceRoot, input, options = {}) {
-    void input;
-    if (options.env?.["LITFAMILY_SKILL_REVIEW"] === "1")
-        return { marked: 0, skipped: 0 };
-    let marked = 0;
-    let skipped = 0;
-    const loopRoot = join(resolve(workspaceRoot), ".litcodex", "lit-loop");
-    for (const session of sessionDirectories(workspaceRoot, options.beforeRead, options.afterEnumerate)) {
-        const existing = readPending(session, options.beforeRead);
-        const digest = sourceDigest(session, options.beforeRead);
-        if (existing !== null && (existing.status === "pending" || existing.sourceDigest === digest)) {
-            skipped += 1;
-            continue;
-        }
-        const sessionRef = validatedSession(session, loopRoot, options.beforeRead);
-        if (sessionRef === null) {
-            skipped += 1;
-            continue;
-        }
-        writePending(session, {
-            schema: PENDING_SCHEMA,
-            sessionRef,
-            createdAt: (options.now ?? (() => new Date()))().toISOString(),
-            status: "pending",
-            sourceDigest: digest,
-        }, options.beforeWrite, options.afterWriteVerify);
-        marked += 1;
-    }
-    return { marked, skipped };
-}
-export function pendingReviewNotice(workspaceRoot, options = {}) {
-    const pending = sessionDirectories(workspaceRoot, options.beforeRead, options.afterEnumerate)
-        .map((session) => ({ session, value: readPending(session, options.beforeRead) }))
-        .filter((item) => item.value !== null && item.value.status === "pending" && item.value.surfacedAt === undefined);
-    if (pending.length === 0)
-        return null;
-    const timestamp = (options.now ?? (() => new Date()))().toISOString();
-    for (const item of pending)
-        writePending(item.session, { ...item.value, surfacedAt: timestamp }, options.beforeWrite, options.afterWriteVerify);
-    return `${pending.length} skill review${pending.length === 1 ? "" : "s"} pending — run \`litcodex skill-loop review\`.`;
-}
-export function pendingReviewDirectories(workspaceRoot, options = {}) {
-    return sessionDirectories(workspaceRoot, options.beforeRead, options.afterEnumerate)
-        .filter((session) => readPending(session, options.beforeRead)?.status === "pending")
-        .map((session) => session.path);
-}
-export function markReviewsComplete(workspaceRoot, timestamp) {
-    for (const session of sessionDirectories(workspaceRoot)) {
-        const pending = readPending(session);
-        if (pending?.status === "pending")
-            writePending(session, { ...pending, status: "reviewed", reviewedAt: timestamp });
-    }
-}

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

@@ -1,6 +0,0 @@
-import type { skillLoopPaths } from "./paths.js";
-import type { SkillSnapshotItem } from "./types.js";
-export declare function markerPresent(content: string): boolean;
-export declare function stampMarker(content: string, skillId: string): string;
-export declare function decodeSkillItem(paths: ReturnType<typeof skillLoopPaths>, item: SkillSnapshotItem): string;
-export declare function snapshotIsAgentOwned(paths: ReturnType<typeof skillLoopPaths>, snapshot: readonly SkillSnapshotItem[]): boolean;