@litfamily/litopencode 1.0.1 → 1.0.2

package/dist/skill-loop/config.js

@@ -1,215 +0,0 @@
-import path from "node:path";
-import { parseStrictJson } from "../strict-json.js";
-import { defaultOpenCodeConfigRoot } from "../state.js";
-import { assertSkillLoopLockCapability, canonicalPhysicalPath, pinPhysicalDirectory, pinPhysicalDirectoryIfPresent, readSafeRuntimeFile, removeSafeRuntimeFile, withSkillLoopMutationLock, writeSafeRuntimeFile } from "./storage.js";
-import { isStrictRfc3339 } from "./time.js";
-export const defaultSkillLoopConfig = Object.freeze({
-    schemaVersion: 1,
-    autoApply: false,
-    nudgeInterval: 20,
-    curatorIntervalDays: 7,
-    minIdleHours: 2,
-    staleAfterDays: 30,
-    archiveAfterDays: 90
-});
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function positiveInteger(value, label) {
-    if (!Number.isInteger(value) || Number(value) <= 0)
-        throw new Error(`SKILL_LOOP_CONFIG_INVALID: ${label}`);
-    return Number(value);
-}
-export function skillLoopPaths(projectRoot = process.cwd(), configRoot = defaultOpenCodeConfigRoot()) {
-    const project = path.resolve(projectRoot);
-    const runtimeRoot = path.join(project, ".litopencode");
-    const config = path.resolve(configRoot);
-    return {
-        projectRoot: project,
-        runtimeRoot,
-        configRoot: config,
-        skillsRoot: path.join(config, "skills"),
-        configFile: path.join(runtimeRoot, "skill-loop.json"),
-        proposalsDir: path.join(runtimeRoot, "skill-proposals"),
-        usageFile: path.join(runtimeRoot, "skill-usage.json"),
-        ledgerFile: path.join(runtimeRoot, "skill-ledger.jsonl"),
-        blobsDir: path.join(runtimeRoot, "skill-ledger-blobs"),
-        stateFile: path.join(runtimeRoot, "skill-loop-state.json"),
-        pendingReviewFile: path.join(runtimeRoot, "pending-review.json"),
-        backupsDir: path.join(runtimeRoot, "skill-backups"),
-        archiveDir: path.join(runtimeRoot, "skill-archive"),
-        transactionFile: path.join(runtimeRoot, "skill-loop-transaction.json"),
-        observationTransactionFile: path.join(runtimeRoot, "skill-loop-observation-transaction.json")
-    };
-}
-export async function resolveSkillLoopPaths(projectRoot, configRoot) {
-    const project = await pinPhysicalDirectory(projectRoot);
-    const config = await pinPhysicalDirectoryIfPresent(configRoot);
-    return skillLoopPaths(project.physical, config?.physical ?? await canonicalPhysicalPath(configRoot));
-}
-export async function readSkillLoopConfig(projectRoot) {
-    const file = skillLoopPaths(projectRoot).configFile;
-    const bytes = await readSafeRuntimeFile(projectRoot, file, { maxBytes: 64 * 1024 });
-    if (bytes === undefined)
-        return defaultSkillLoopConfig;
-    const raw = bytes.toString("utf8");
-    const parsed = parseStrictJson(raw);
-    if (!isRecord(parsed))
-        throw new Error("SKILL_LOOP_CONFIG_INVALID: object required");
-    const allowed = new Set(Object.keys(defaultSkillLoopConfig));
-    if (Object.keys(parsed).some((key) => !allowed.has(key)))
-        throw new Error("SKILL_LOOP_CONFIG_INVALID: unknown field");
-    if (parsed.schemaVersion !== 1 || parsed.autoApply !== false) {
-        throw new Error("SKILL_LOOP_CONFIG_INVALID: autoApply must be false");
-    }
-    const result = {
-        schemaVersion: 1,
-        autoApply: false,
-        nudgeInterval: positiveInteger(parsed.nudgeInterval, "nudgeInterval"),
-        curatorIntervalDays: positiveInteger(parsed.curatorIntervalDays, "curatorIntervalDays"),
-        minIdleHours: positiveInteger(parsed.minIdleHours, "minIdleHours"),
-        staleAfterDays: positiveInteger(parsed.staleAfterDays, "staleAfterDays"),
-        archiveAfterDays: positiveInteger(parsed.archiveAfterDays, "archiveAfterDays")
-    };
-    if (result.archiveAfterDays < result.staleAfterDays) {
-        throw new Error("SKILL_LOOP_CONFIG_INVALID: archive precedes stale");
-    }
-    return Object.freeze(result);
-}
-export async function writeJsonAtomically(projectRoot, file, value, capability) {
-    if (capability === undefined) {
-        return withSkillLoopMutationLock(projectRoot, (locked) => writeJsonAtomically(projectRoot, file, value, locked));
-    }
-    assertSkillLoopLockCapability(capability, projectRoot);
-    await writeSafeRuntimeFile(projectRoot, file, Buffer.from(`${JSON.stringify(value, null, 2)}\n`, "utf8"));
-}
-function parseIterationState(value) {
-    if (!isRecord(value) || value.schemaVersion !== 1 || !Array.isArray(value.sessions)) {
-        throw new Error("SKILL_LOOP_STATE_INVALID");
-    }
-    const sessions = value.sessions.map((entry) => {
-        if (!isRecord(entry) || typeof entry.sessionRef !== "string" || entry.sessionRef === "" ||
-            !Number.isInteger(entry.count) || Number(entry.count) < 0 || typeof entry.noticePending !== "boolean") {
-            throw new Error("SKILL_LOOP_STATE_INVALID");
-        }
-        return { sessionRef: entry.sessionRef, count: Number(entry.count), noticePending: entry.noticePending };
-    });
-    return { schemaVersion: 1, sessions };
-}
-async function readIterationState(projectRoot, file) {
-    const bytes = await readSafeRuntimeFile(projectRoot, file, { maxBytes: 128 * 1024 });
-    return bytes === undefined ? { schemaVersion: 1, sessions: [] } : parseIterationState(parseStrictJson(bytes.toString("utf8")));
-}
-function parsePendingReviewState(value) {
-    if (!isRecord(value) || value.schemaVersion !== 1 || !Array.isArray(value.sessions))
-        throw new Error("SKILL_LOOP_STATE_INVALID");
-    const sessions = value.sessions.map((entry) => {
-        if (!isRecord(entry) || Object.keys(entry).some((key) => key !== "sessionRef" && key !== "iterationCount" && key !== "queuedAt") ||
-            typeof entry.sessionRef !== "string" || entry.sessionRef === "" || !Number.isInteger(entry.iterationCount) || Number(entry.iterationCount) < 1 ||
-            !isStrictRfc3339(entry.queuedAt))
-            throw new Error("SKILL_LOOP_STATE_INVALID");
-        return { sessionRef: entry.sessionRef, iterationCount: Number(entry.iterationCount), queuedAt: entry.queuedAt };
-    });
-    return Object.freeze({ schemaVersion: 1, sessions: Object.freeze(sessions) });
-}
-async function readPendingReviewStateRaw(projectRoot) {
-    const paths = skillLoopPaths(projectRoot);
-    const bytes = await readSafeRuntimeFile(projectRoot, paths.pendingReviewFile, { maxBytes: 128 * 1024 });
-    return bytes === undefined ? { schemaVersion: 1, sessions: [] } : parsePendingReviewState(parseStrictJson(bytes.toString("utf8")));
-}
-function parseObservationTransaction(value) {
-    if (!isRecord(value) || Object.keys(value).length !== 3 || value.schema !== "litfamily.skill-observation-transaction/v1" ||
-        !Object.hasOwn(value, "state") || !Object.hasOwn(value, "pending"))
-        throw new Error("SKILL_LOOP_STATE_INVALID");
-    return Object.freeze({
-        schema: "litfamily.skill-observation-transaction/v1",
-        state: parseIterationState(value.state),
-        pending: parsePendingReviewState(value.pending)
-    });
-}
-async function recoverObservationTransaction(projectRoot, capability) {
-    assertSkillLoopLockCapability(capability, projectRoot);
-    const paths = skillLoopPaths(projectRoot);
-    const bytes = await readSafeRuntimeFile(projectRoot, paths.observationTransactionFile, { maxBytes: 384 * 1024 });
-    if (bytes === undefined)
-        return false;
-    const transaction = parseObservationTransaction(parseStrictJson(bytes.toString("utf8")));
-    await writeJsonAtomically(projectRoot, paths.stateFile, transaction.state, capability);
-    if (transaction.pending.sessions.length === 0)
-        await removeSafeRuntimeFile(projectRoot, paths.pendingReviewFile);
-    else
-        await writeJsonAtomically(projectRoot, paths.pendingReviewFile, transaction.pending, capability);
-    await removeSafeRuntimeFile(projectRoot, paths.observationTransactionFile);
-    return true;
-}
-export async function readPendingReviewState(projectRoot, options = {}) {
-    if (options.capability !== undefined) {
-        await recoverObservationTransaction(projectRoot, options.capability);
-        return readPendingReviewStateRaw(projectRoot);
-    }
-    const paths = skillLoopPaths(projectRoot);
-    if (await readSafeRuntimeFile(projectRoot, paths.observationTransactionFile, { maxBytes: 384 * 1024 }) === undefined) {
-        return readPendingReviewStateRaw(projectRoot);
-    }
-    return withSkillLoopMutationLock(projectRoot, async (capability) => {
-        await recoverObservationTransaction(projectRoot, capability);
-        return readPendingReviewStateRaw(projectRoot);
-    });
-}
-export async function consumePendingReview(projectRoot, reviewedSessionRefs) {
-    await withSkillLoopMutationLock(projectRoot, async (capability) => {
-        const paths = skillLoopPaths(projectRoot);
-        const current = await readPendingReviewState(projectRoot, { capability });
-        const reviewed = new Set(reviewedSessionRefs);
-        const sessions = current.sessions.filter((entry) => !reviewed.has(entry.sessionRef));
-        if (sessions.length === 0)
-            await removeSafeRuntimeFile(projectRoot, paths.pendingReviewFile);
-        else
-            await writeJsonAtomically(projectRoot, paths.pendingReviewFile, { schemaVersion: 1, sessions }, capability);
-    });
-}
-export async function observeToolIteration(projectRoot, sessionRef, now = new Date().toISOString()) {
-    if (!isStrictRfc3339(now))
-        throw new Error("SKILL_LOOP_STATE_INVALID");
-    return withSkillLoopMutationLock(projectRoot, async (capability) => {
-        const paths = skillLoopPaths(projectRoot);
-        await recoverObservationTransaction(projectRoot, capability);
-        const config = await readSkillLoopConfig(projectRoot);
-        const state = await readIterationState(projectRoot, paths.stateFile);
-        const current = state.sessions.find((entry) => entry.sessionRef === sessionRef) ?? {
-            sessionRef,
-            count: 0,
-            noticePending: false
-        };
-        const surfaceNotice = current.noticePending;
-        const count = current.count + 1;
-        const reviewQueued = count % config.nudgeInterval === 0;
-        const next = {
-            sessionRef,
-            count,
-            noticePending: reviewQueued || (current.noticePending && !surfaceNotice)
-        };
-        const sessions = [next, ...state.sessions.filter((entry) => entry.sessionRef !== sessionRef)].slice(0, 64);
-        const pending = await readPendingReviewStateRaw(projectRoot);
-        const pendingSessions = reviewQueued
-            ? [
-                { sessionRef, iterationCount: count, queuedAt: now },
-                ...pending.sessions.filter((entry) => entry.sessionRef !== sessionRef)
-            ].slice(0, 64)
-            : pending.sessions;
-        const nextState = { schemaVersion: 1, sessions };
-        const nextPending = { schemaVersion: 1, sessions: pendingSessions };
-        await writeJsonAtomically(projectRoot, paths.observationTransactionFile, {
-            schema: "litfamily.skill-observation-transaction/v1",
-            state: nextState,
-            pending: nextPending
-        }, capability);
-        await writeJsonAtomically(projectRoot, paths.stateFile, nextState, capability);
-        if (nextPending.sessions.length === 0)
-            await removeSafeRuntimeFile(projectRoot, paths.pendingReviewFile);
-        else
-            await writeJsonAtomically(projectRoot, paths.pendingReviewFile, nextPending, capability);
-        await removeSafeRuntimeFile(projectRoot, paths.observationTransactionFile);
-        return { surfaceNotice, reviewQueued };
-    });
-}

package/dist/skill-loop/curator.d.ts

@@ -1,18 +0,0 @@
-import { readSkillLoopConfig } from "./config.ts";
-import { readUsageSidecar } from "./usage.ts";
-type CuratorTransition = {
-    readonly skillId: string;
-    readonly from: "active" | "stale";
-    readonly to: "stale" | "archived";
-    readonly archivePath?: string;
-    readonly ledgerEntryId?: string;
-};
-export declare function curatorStatus(projectRoot: string): Promise<{
-    readonly config: Awaited<ReturnType<typeof readSkillLoopConfig>>;
-    readonly usage: Awaited<ReturnType<typeof readUsageSidecar>>;
-}>;
-export declare function runCurator(projectRoot: string, configRoot?: string, now?: string): Promise<{
-    readonly backupPath?: string;
-    readonly transitions: readonly CuratorTransition[];
-}>;
-export {};

package/dist/skill-loop/curator.js

@@ -1,232 +0,0 @@
-import { randomUUID } from "node:crypto";
-import fs from "node:fs/promises";
-import path from "node:path";
-import { assertPathComponentsSafe, inventoryTree, lstatIfPresent } from "../cli/native-skill-tree.js";
-import { assertMutableSkillIdentity, hasAgentOwnedSkillMarker } from "./apply.js";
-import { readSkillLoopConfig, skillLoopPaths } from "./config.js";
-import { appendSkillLedgerBatch, assertProposalLedgerIntegrity, readSkillLedger, readSnapshotFile, snapshotSkill } from "./ledger.js";
-import { listProposals } from "./proposals.js";
-import { anchoredRenameInSkillsRoot, assertSafeRuntimeFileForWrite, assertSkillLoopRootPins, ensureSafeRuntimeDirectory, syncDirectory, withSkillLoopMutationLock, withSkillRootsMutationLock } from "./storage.js";
-import { beginSkillTransaction, completeSkillTransaction, createSkillTransactionId, materializeTransactionSnapshot, recoverSkillTransaction } from "./transaction.js";
-import { isStrictRfc3339 } from "./time.js";
-import { readUsageSidecar, writeUsageSidecar } from "./usage.js";
-function lastActivity(entry) {
-    return Math.max(...[entry.created_at, entry.last_used_at, entry.last_viewed_at, entry.last_patched_at]
-        .filter((value) => value !== null)
-        .map(Date.parse));
-}
-async function isAgentOwned(skillRoot) {
-    const stat = await lstatIfPresent(skillRoot);
-    if (stat === null || stat.isSymbolicLink() || !stat.isDirectory())
-        return false;
-    const inventory = await inventoryTree(skillRoot);
-    if (inventory.unsafe.length > 0)
-        throw new Error("TARGET_PATH_UNSAFE");
-    try {
-        const text = await fs.readFile(path.join(skillRoot, "SKILL.md"), "utf8");
-        return hasAgentOwnedSkillMarker(text);
-    }
-    catch {
-        return false;
-    }
-}
-async function snapshotAgentOwnedSkills(projectRoot, skillsRoot) {
-    const skills = [];
-    let entries = [];
-    try {
-        entries = await fs.readdir(skillsRoot);
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return skills;
-        throw error;
-    }
-    for (const skillId of entries.sort()) {
-        const source = path.join(skillsRoot, skillId);
-        if (await isAgentOwned(source))
-            skills.push({ skillId, snapshot: await snapshotSkill(projectRoot, source) });
-    }
-    return Object.freeze(skills);
-}
-async function backupAgentOwnedSkills(projectRoot, transactionId, backup) {
-    const backupPath = backup.path;
-    await ensureSafeRuntimeDirectory(projectRoot, path.dirname(backupPath));
-    if (await lstatIfPresent(backupPath) !== null || await lstatIfPresent(backup.stagePath) !== null)
-        throw new Error("CURATOR_BACKUP_EXISTS");
-    await fs.mkdir(backup.stagePath, { mode: 0o700 });
-    const marker = path.join(backup.stagePath, ".litopencode-curator-backup.json");
-    await fs.writeFile(marker, `${JSON.stringify({
-        schema: "litfamily.curator-backup/v1",
-        transactionId,
-        markerToken: backup.markerToken,
-        backupPath
-    })}\n`, { encoding: "utf8", mode: 0o600, flag: "wx" });
-    for (const skill of backup.skills) {
-        for (const item of skill.snapshot) {
-            const bytes = await readSnapshotFile(projectRoot, skill.snapshot, item.file);
-            if (bytes === undefined)
-                throw new Error("LEDGER_BLOB_CORRUPT");
-            const destination = path.join(backup.stagePath, skill.skillId, ...item.file.split("/"));
-            await fs.mkdir(path.dirname(destination), { recursive: true, mode: 0o700 });
-            await fs.writeFile(destination, bytes, { mode: 0o600, flag: "wx" });
-        }
-        if (JSON.stringify(await snapshotSkill(projectRoot, path.join(backup.stagePath, skill.skillId))) !== JSON.stringify(skill.snapshot)) {
-            throw new Error("CURATOR_BACKUP_INVALID");
-        }
-    }
-    await syncDirectory(backup.stagePath);
-    await fs.rename(backup.stagePath, backupPath);
-    await syncDirectory(path.dirname(backupPath));
-}
-export async function curatorStatus(projectRoot) {
-    return { config: await readSkillLoopConfig(projectRoot), usage: await readUsageSidecar(projectRoot) };
-}
-export async function runCurator(projectRoot, configRoot, now = new Date().toISOString()) {
-    if (!isStrictRfc3339(now))
-        throw new Error("CURATOR_TIME_INVALID");
-    const requestedConfigRoot = skillLoopPaths(projectRoot, configRoot).configRoot;
-    return withSkillLoopMutationLock(projectRoot, async () => withSkillRootsMutationLock(projectRoot, requestedConfigRoot, (capability, roots) => runCuratorLocked(roots.project.physical, roots.config.physical, now, capability)));
-}
-async function runCuratorLocked(projectRoot, configRoot, now, capability) {
-    const nowMs = Date.parse(now);
-    const paths = skillLoopPaths(projectRoot, configRoot);
-    const request = { kind: "curator", requestId: "curator-run" };
-    await recoverSkillTransaction(projectRoot, paths.configRoot, request, assertMutableSkillIdentity, async (targetSkill) => (await readUsageSidecar(projectRoot, now)).skills[targetSkill]?.pinned === true, capability);
-    await assertSkillLoopRootPins(capability);
-    try {
-        await assertPathComponentsSafe(paths.configRoot, paths.skillsRoot, "Agent-owned skills root");
-    }
-    catch {
-        throw new Error("TARGET_PATH_UNSAFE");
-    }
-    const ledger = await readSkillLedger(projectRoot);
-    const proposals = await listProposals(projectRoot, configRoot);
-    assertProposalLedgerIntegrity(proposals, ledger);
-    await assertSafeRuntimeFileForWrite(projectRoot, paths.ledgerFile);
-    await assertSafeRuntimeFileForWrite(projectRoot, paths.usageFile);
-    const config = await readSkillLoopConfig(projectRoot);
-    const usage = await readUsageSidecar(projectRoot, now);
-    const candidates = [];
-    for (const [skillId, entry] of Object.entries(usage.skills)) {
-        if (entry.pinned || entry.state === "archived")
-            continue;
-        assertMutableSkillIdentity(skillId);
-        const idleDays = (nowMs - lastActivity(entry)) / 86_400_000;
-        if (entry.state === "stale" && idleDays >= config.archiveAfterDays)
-            candidates.push({ skillId, entry, from: "stale", to: "archived" });
-        else if (entry.state === "active" && idleDays >= config.staleAfterDays)
-            candidates.push({ skillId, entry, from: "active", to: "stale" });
-    }
-    if (candidates.length === 0)
-        return { transitions: [] };
-    const stamp = now.replaceAll(":", "-");
-    const backupPath = path.join(paths.backupsDir, stamp);
-    const nextSkills = { ...usage.skills };
-    const planned = [];
-    for (const candidate of candidates) {
-        const skillRoot = path.join(paths.skillsRoot, candidate.skillId);
-        if (!await isAgentOwned(skillRoot))
-            continue;
-        if (candidate.to === "stale") {
-            nextSkills[candidate.skillId] = { ...candidate.entry, state: "stale" };
-            planned.push({ kind: "stale", transition: { skillId: candidate.skillId, from: candidate.from, to: "stale" } });
-            continue;
-        }
-        const before = await snapshotSkill(projectRoot, skillRoot);
-        const archivePath = path.join(paths.archiveDir, stamp, candidate.skillId);
-        await ensureSafeRuntimeDirectory(projectRoot, path.dirname(archivePath));
-        if (await lstatIfPresent(archivePath) !== null)
-            throw new Error("TARGET_ALREADY_EXISTS");
-        nextSkills[candidate.skillId] = { ...candidate.entry, state: "archived", archived_at: now };
-        planned.push({
-            kind: "archive",
-            transition: { skillId: candidate.skillId, from: candidate.from, to: "archived", archivePath },
-            skillRoot,
-            archivePath,
-            before
-        });
-    }
-    const archives = planned.filter((entry) => entry.kind === "archive");
-    if (await lstatIfPresent(backupPath) !== null)
-        throw new Error("CURATOR_BACKUP_EXISTS");
-    await assertSkillLoopRootPins(capability);
-    const markerToken = randomUUID();
-    const backup = Object.freeze({
-        path: backupPath,
-        stagePath: path.join(paths.backupsDir, `.${stamp}.${markerToken}.stage`),
-        markerToken,
-        skills: await snapshotAgentOwnedSkills(projectRoot, paths.skillsRoot)
-    });
-    await assertSkillLoopRootPins(capability);
-    let ledgers = [];
-    const transactionId = createSkillTransactionId();
-    const archiveStagePath = (archive) => path.join(path.dirname(archive.archivePath), `.${archive.transition.skillId}.${transactionId}.stage`);
-    for (const archive of archives) {
-        if (await lstatIfPresent(archive.archivePath) !== null || await lstatIfPresent(archiveStagePath(archive)) !== null)
-            throw new Error("TARGET_ALREADY_EXISTS");
-    }
-    if (await lstatIfPresent(backupPath) !== null || await lstatIfPresent(backup.stagePath) !== null)
-        throw new Error("CURATOR_BACKUP_EXISTS");
-    await beginSkillTransaction(projectRoot, paths.configRoot, {
-        id: transactionId,
-        request,
-        proposalId: null,
-        action: "curator",
-        targets: archives.map((archive) => ({
-            targetSkill: archive.transition.skillId,
-            proposalId: null,
-            action: "curator-archive",
-            before: archive.before,
-            after: [],
-            archivePath: archive.archivePath,
-            archiveStagePath: archiveStagePath(archive)
-        })),
-        includeLedger: true,
-        includeUsage: true,
-        backup,
-        capability
-    });
-    try {
-        await assertSkillLoopRootPins(capability);
-        await backupAgentOwnedSkills(projectRoot, transactionId, backup);
-        await assertSkillLoopRootPins(capability);
-        for (const archive of archives) {
-            await assertSkillLoopRootPins(capability);
-            await materializeTransactionSnapshot(projectRoot, archiveStagePath(archive), archive.archivePath, archive.before);
-            await anchoredRenameInSkillsRoot(capability, archive.transition.skillId, `.${archive.transition.skillId}.${transactionId}.backup`);
-            await assertSkillLoopRootPins(capability);
-        }
-        await writeUsageSidecar(projectRoot, { ...usage, updatedAt: now, skills: nextSkills }, { capability });
-        ledgers = await appendSkillLedgerBatch(projectRoot, archives.map((archive) => ({
-            proposalId: null,
-            actor: "curator",
-            operation: "curator-transition",
-            targetSkill: archive.transition.skillId,
-            targetRoot: paths.skillsRoot,
-            before: archive.before,
-            after: [],
-            reason: "deterministic archive threshold"
-        })), now, { capability });
-        await completeSkillTransaction(projectRoot, paths.configRoot, request, capability);
-    }
-    catch (error) {
-        try {
-            await recoverSkillTransaction(projectRoot, paths.configRoot, request, assertMutableSkillIdentity, async (targetSkill) => (await readUsageSidecar(projectRoot, now)).skills[targetSkill]?.pinned === true, capability);
-        }
-        catch (recoveryError) {
-            throw new Error("SKILL_TRANSACTION_STATE_UNKNOWN", { cause: { original: error, recoveryError } });
-        }
-        throw error;
-    }
-    let ledgerIndex = 0;
-    const transitions = planned.map((entry) => {
-        if (entry.kind === "stale")
-            return entry.transition;
-        const ledger = ledgers[ledgerIndex];
-        ledgerIndex += 1;
-        if (ledger === undefined)
-            throw new Error("SKILL_LEDGER_INVALID");
-        return { ...entry.transition, ledgerEntryId: ledger.id };
-    });
-    return { backupPath, transitions };
-}

package/dist/skill-loop/ledger.d.ts

@@ -1,39 +0,0 @@
-import { type SkillProposal } from "./proposals.ts";
-import { type SkillLoopLockCapability } from "./storage.ts";
-export type SkillSnapshotItem = {
-    readonly file: string;
-    readonly blob: {
-        readonly algorithm: "sha256";
-        readonly digest: string;
-        readonly size: number;
-    };
-};
-export type SkillLedgerOperation = "apply" | "reject" | "rollback" | "curator-transition";
-export type SkillLedgerEntry = {
-    readonly schema: "litfamily.skill-ledger/v1";
-    readonly id: string;
-    readonly createdAt: string;
-    readonly proposalId: string | null;
-    readonly actor: "user" | "curator";
-    readonly operation: SkillLedgerOperation;
-    readonly targetSkill: string;
-    readonly targetRoot: string;
-    readonly before: readonly SkillSnapshotItem[];
-    readonly after: readonly SkillSnapshotItem[];
-    readonly restoresLedgerEntryId?: string;
-    readonly reason?: string;
-};
-export declare function snapshotSkill(projectRoot: string, skillRoot: string): Promise<readonly SkillSnapshotItem[]>;
-export declare function readSnapshotFile(projectRoot: string, snapshot: readonly SkillSnapshotItem[], relativeFile: string): Promise<Buffer | undefined>;
-export declare function assertSnapshotMatches(projectRoot: string, skillRoot: string, expected: readonly SkillSnapshotItem[]): Promise<void>;
-export declare function restoreSnapshot(projectRoot: string, skillRoot: string, snapshot: readonly SkillSnapshotItem[]): Promise<void>;
-export declare function parseSkillSnapshot(value: unknown): readonly SkillSnapshotItem[];
-export declare function readSkillLedger(projectRoot: string): Promise<readonly SkillLedgerEntry[]>;
-export declare function assertProposalLedgerIntegrity(proposals: readonly SkillProposal[], entries: readonly SkillLedgerEntry[]): void;
-export declare function appendSkillLedger(projectRoot: string, entry: Omit<SkillLedgerEntry, "schema" | "id" | "createdAt">, now?: string, options?: {
-    readonly capability?: SkillLoopLockCapability;
-}): Promise<SkillLedgerEntry>;
-export declare function appendSkillLedgerBatch(projectRoot: string, entries: readonly Omit<SkillLedgerEntry, "schema" | "id" | "createdAt">[], now?: string, options?: {
-    readonly capability?: SkillLoopLockCapability;
-}): Promise<readonly SkillLedgerEntry[]>;
-export declare function findSkillLedgerEntry(projectRoot: string, id: string): Promise<SkillLedgerEntry>;