@litfamily/litopencode 1.0.1 → 1.0.2

package/dist/skill-loop/apply.js

@@ -1,483 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { assertPathComponentsSafe, inventoryTree, lstatIfPresent } from "../cli/native-skill-tree.js";
-import { litOpenCodeRuntimeSkills, litOpenCodeStaticOnlySkills } from "../skills.js";
-import { hasLitOpenCodeGeneratedFileMarker } from "../user-facing-markdown.js";
-import { resolveSkillLoopPaths, skillLoopPaths } from "./config.js";
-import { appendSkillLedger, assertProposalLedgerIntegrity, assertSnapshotMatches, readSkillLedger, readSnapshotFile, restoreSnapshot, snapshotSkill } from "./ledger.js";
-import { canonicalRelativeIdentity, listProposals, SkillProposalError, updateProposal } from "./proposals.js";
-import { anchoredAssertSkillPathAbsent, anchoredCopyIntoSkillsRoot, anchoredRenameInSkillsRoot, anchoredVerifySkillTree, assertSafeRuntimeFileForWrite, assertSkillLoopRootPins, ensureSafeRuntimeDirectory, withSkillLoopMutationLock, withSkillRootsMutationLock } from "./storage.js";
-import { beginSkillTransaction, completeSkillTransaction, createSkillTransactionId, materializeTransactionSnapshot, recoverSkillTransaction } from "./transaction.js";
-import { bumpSkillUsage, readUsageSidecar, setSkillUsageLifecycle } from "./usage.js";
-export const litOpenCodeAgentGeneratedMarker = 'litopencodeAgentGenerated: "true"';
-export class SkillApplyError extends Error {
-    code;
-    constructor(code, message = code) {
-        super(message);
-        this.name = "SkillApplyError";
-        this.code = code;
-    }
-}
-const shippedSkillIds = new Set([
-    ...litOpenCodeRuntimeSkills.map((skill) => skill.id),
-    ...litOpenCodeStaticOnlySkills.map((skill) => skill.id)
-]);
-const shippedSkillIdentities = new Set([...shippedSkillIds].map(canonicalRelativeIdentity));
-export function assertMutableSkillIdentity(targetSkill) {
-    if (shippedSkillIdentities.has(canonicalRelativeIdentity(targetSkill))) {
-        throw new SkillApplyError("TARGET_NOT_AGENT_OWNED");
-    }
-}
-export function hasAgentOwnedSkillMarker(text) {
-    if (!text.startsWith("---\n"))
-        return false;
-    const end = text.indexOf("\n---\n", 4);
-    if (end < 0)
-        return false;
-    const lines = text.slice(4, end).split("\n");
-    const metadataIndexes = lines.flatMap((line, index) => /^metadata:\s*(?:#.*)?$/u.test(line) ? [index] : []);
-    if (metadataIndexes.length !== 1)
-        return false;
-    const children = [];
-    for (const line of lines.slice(metadataIndexes[0] + 1)) {
-        if (/^\s*(?:#.*)?$/u.test(line))
-            continue;
-        const indentation = /^ */u.exec(line)?.[0].length ?? 0;
-        if (indentation === 0 || line.includes("\t"))
-            break;
-        children.push({ indent: indentation, line: line.slice(indentation) });
-    }
-    const directIndent = Math.min(...children.map((child) => child.indent));
-    const markers = children.filter((child) => child.indent === directIndent &&
-        /^litopencodeAgentGenerated:\s*(?:"true"|'true')\s*(?:#.*)?$/u.test(child.line));
-    return Number.isFinite(directIndent) && markers.length === 1;
-}
-function addAgentMarker(text, targetSkill) {
-    if (hasAgentOwnedSkillMarker(text))
-        return text;
-    if (!text.startsWith("---\n")) {
-        return `---\nname: ${targetSkill}\ndescription: Agent-owned skill.\nmetadata:\n  ${litOpenCodeAgentGeneratedMarker}\n---\n\n${text}`;
-    }
-    const end = text.indexOf("\n---\n", 4);
-    if (end < 0)
-        throw new SkillApplyError("PROPOSAL_CONTENT_INVALID");
-    const frontmatter = text.slice(4, end);
-    const marked = /^metadata:\s*$/mu.test(frontmatter)
-        ? frontmatter.replace(/^metadata:\s*$/mu, `metadata:\n  ${litOpenCodeAgentGeneratedMarker}`)
-        : `${frontmatter}\nmetadata:\n  ${litOpenCodeAgentGeneratedMarker}`;
-    return `---\n${marked}\n---\n${text.slice(end + "\n---\n".length)}`;
-}
-async function assertAgentOwnedTarget(skillRoot, proposal) {
-    assertMutableSkillIdentity(proposal.targetSkill);
-    let siblingNames = [];
-    try {
-        siblingNames = await fs.readdir(path.dirname(skillRoot));
-    }
-    catch (error) {
-        if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
-            throw error;
-    }
-    const targetIdentity = canonicalRelativeIdentity(proposal.targetSkill);
-    if (siblingNames.some((name) => name !== proposal.targetSkill && canonicalRelativeIdentity(name) === targetIdentity)) {
-        throw new SkillApplyError("TARGET_ALREADY_EXISTS");
-    }
-    const stat = await lstatIfPresent(skillRoot);
-    if (stat === null) {
-        if (proposal.action !== "create")
-            throw new SkillApplyError("TARGET_NOT_AGENT_OWNED");
-        return false;
-    }
-    await assertExistingAgentOwnedSkill(skillRoot);
-    if (proposal.action === "create")
-        throw new SkillApplyError("TARGET_ALREADY_EXISTS");
-    return true;
-}
-async function assertExistingAgentOwnedSkill(skillRoot) {
-    const stat = await lstatIfPresent(skillRoot);
-    if (stat === null)
-        throw new SkillApplyError("TARGET_NOT_AGENT_OWNED");
-    if (stat.isSymbolicLink() || !stat.isDirectory())
-        throw new SkillApplyError("TARGET_PATH_UNSAFE");
-    const inventory = await inventoryTree(skillRoot);
-    if (inventory.unsafe.length > 0)
-        throw new SkillApplyError("TARGET_PATH_UNSAFE");
-    const entry = path.join(skillRoot, "SKILL.md");
-    const entryStat = await lstatIfPresent(entry);
-    if (entryStat === null || entryStat.isSymbolicLink() || !entryStat.isFile())
-        throw new SkillApplyError("TARGET_NOT_AGENT_OWNED");
-    const content = await fs.readFile(entry, "utf8");
-    if (hasLitOpenCodeGeneratedFileMarker(content) || !hasAgentOwnedSkillMarker(content))
-        throw new SkillApplyError("TARGET_NOT_AGENT_OWNED");
-}
-async function assertAgentOwnedSnapshot(projectRoot, snapshot) {
-    if (snapshot.length === 0)
-        return;
-    const entry = await readSnapshotFile(projectRoot, snapshot, "SKILL.md");
-    if (entry === undefined)
-        throw new SkillApplyError("TARGET_NOT_AGENT_OWNED");
-    const content = entry.toString("utf8");
-    if (hasLitOpenCodeGeneratedFileMarker(content) || !hasAgentOwnedSkillMarker(content))
-        throw new SkillApplyError("TARGET_NOT_AGENT_OWNED");
-}
-async function buildStage(skillRoot, proposal, exists, stage) {
-    const parent = path.dirname(skillRoot);
-    await fs.mkdir(parent, { recursive: true });
-    if (exists)
-        await fs.cp(skillRoot, stage, { recursive: true, errorOnExist: true, force: false });
-    else
-        await fs.mkdir(stage, { mode: 0o700 });
-    try {
-        if (proposal.action === "patch") {
-            const patch = proposal.patch;
-            if (patch === undefined)
-                throw new SkillApplyError("PROPOSAL_SCHEMA_INVALID");
-            const file = path.join(stage, ...patch.file.split("/"));
-            const content = await fs.readFile(file, "utf8").catch(() => { throw new SkillApplyError("PATCH_TARGET_MISSING"); });
-            const occurrences = content.split(patch.oldString).length - 1;
-            if (occurrences !== 1)
-                throw new SkillApplyError("PATCH_MATCH_NOT_UNIQUE");
-            await fs.writeFile(file, content.replace(patch.oldString, patch.newString), "utf8");
-        }
-        else if (proposal.action === "create" || proposal.action === "add-reference") {
-            const spec = proposal.createSpec;
-            if (spec === undefined)
-                throw new SkillApplyError("PROPOSAL_SCHEMA_INVALID");
-            for (const item of spec.files) {
-                const file = path.join(stage, ...item.file.split("/"));
-                if (proposal.action === "add-reference" && await lstatIfPresent(file) !== null)
-                    throw new SkillApplyError("TARGET_ALREADY_EXISTS");
-                await fs.mkdir(path.dirname(file), { recursive: true });
-                const content = item.file === "SKILL.md" ? addAgentMarker(item.content, proposal.targetSkill) : item.content;
-                await fs.writeFile(file, content, { encoding: "utf8", mode: 0o600, flag: proposal.action === "add-reference" ? "wx" : "w" });
-            }
-        }
-        const entry = await fs.readFile(path.join(stage, "SKILL.md"), "utf8").catch(() => { throw new SkillApplyError("PROPOSAL_CONTENT_INVALID"); });
-        if (!hasAgentOwnedSkillMarker(entry))
-            throw new SkillApplyError("PROPOSAL_CONTENT_INVALID");
-        return stage;
-    }
-    catch (error) {
-        await fs.rm(stage, { recursive: true, force: true });
-        throw error;
-    }
-}
-async function swapStage(capability, targetSkill, stage, backup, currentExists) {
-    if (!currentExists) {
-        await anchoredRenameInSkillsRoot(capability, stage, targetSkill);
-        return;
-    }
-    await anchoredRenameInSkillsRoot(capability, targetSkill, backup);
-    try {
-        await anchoredRenameInSkillsRoot(capability, stage, targetSkill);
-    }
-    catch (error) {
-        await anchoredRenameInSkillsRoot(capability, backup, targetSkill);
-        throw error;
-    }
-}
-async function targetPinned(projectRoot, targetSkill) {
-    return (await readUsageSidecar(projectRoot)).skills[targetSkill]?.pinned === true;
-}
-async function recoverRequest(projectRoot, configRoot, request, capability) {
-    return recoverSkillTransaction(projectRoot, configRoot, request, assertMutableSkillIdentity, (targetSkill) => targetPinned(projectRoot, targetSkill), capability);
-}
-async function recoverAfterFailure(projectRoot, configRoot, request, capability, original) {
-    try {
-        await recoverRequest(projectRoot, configRoot, request, capability);
-    }
-    catch (recoveryError) {
-        throw new Error("SKILL_TRANSACTION_STATE_UNKNOWN", { cause: { original, recoveryError } });
-    }
-}
-function rollbackOrigin(reference, entries) {
-    const byId = new Map(entries.map((entry) => [entry.id, entry]));
-    const visited = new Set();
-    let current = reference;
-    let depth = 0;
-    while (current.operation === "rollback") {
-        if (current.restoresLedgerEntryId === undefined || visited.has(current.id))
-            throw new Error("SKILL_LEDGER_INVALID");
-        visited.add(current.id);
-        const restored = byId.get(current.restoresLedgerEntryId);
-        if (restored === undefined)
-            throw new Error("SKILL_LEDGER_INVALID");
-        current = restored;
-        depth += 1;
-    }
-    return { origin: current, depth };
-}
-async function withUserSkillRootLock(projectRoot, configRoot, run) {
-    try {
-        return await withSkillRootsMutationLock(projectRoot, configRoot, run);
-    }
-    catch (error) {
-        if (error instanceof Error && error.message === "SKILL_LOOP_PATH_UNSAFE")
-            throw new SkillApplyError("TARGET_PATH_UNSAFE");
-        throw error;
-    }
-}
-async function applyProposalLocked(id, projectRoot, configRoot, capability) {
-    const paths = skillLoopPaths(projectRoot, configRoot);
-    const request = { kind: "apply", requestId: id };
-    const recovery = await recoverRequest(projectRoot, paths.configRoot, request, capability);
-    await assertSkillLoopRootPins(capability);
-    const entries = await readSkillLedger(projectRoot);
-    const proposals = await listProposals(projectRoot, configRoot);
-    assertProposalLedgerIntegrity(proposals, entries);
-    let proposal = proposals.find((candidate) => candidate.id === id);
-    if (proposal === undefined)
-        throw new SkillProposalError("PROPOSAL_NOT_FOUND");
-    if (recovery === "committed" && proposal.status === "applied" && proposal.ledgerEntryId !== undefined) {
-        return { proposal, ledgerEntryId: proposal.ledgerEntryId, appliedPath: path.join(paths.skillsRoot, proposal.targetSkill) };
-    }
-    if (proposal.status !== "pending" && proposal.status !== "approved")
-        throw new SkillApplyError("PROPOSAL_STATUS_INVALID");
-    const skillRoot = path.join(paths.skillsRoot, proposal.targetSkill);
-    try {
-        await assertPathComponentsSafe(paths.configRoot, skillRoot, `Agent-owned skill ${proposal.targetSkill}`);
-    }
-    catch {
-        throw new SkillApplyError("TARGET_PATH_UNSAFE");
-    }
-    const exists = await assertAgentOwnedTarget(skillRoot, proposal);
-    if (await targetPinned(projectRoot, proposal.targetSkill))
-        throw new SkillApplyError("TARGET_PINNED");
-    await assertSafeRuntimeFileForWrite(projectRoot, paths.ledgerFile);
-    await assertSafeRuntimeFileForWrite(projectRoot, paths.usageFile);
-    const before = await snapshotSkill(projectRoot, skillRoot);
-    const transactionId = createSkillTransactionId();
-    const stageName = `.${proposal.targetSkill}.${transactionId}.stage`;
-    const backupName = `.${proposal.targetSkill}.${transactionId}.backup`;
-    const draftStage = path.join(paths.runtimeRoot, "skill-transaction-staging", transactionId, proposal.targetSkill);
-    let archive;
-    let archiveStage;
-    if (proposal.action === "archive") {
-        archive = path.join(paths.archiveDir, new Date().toISOString().replaceAll(":", "-"), proposal.targetSkill);
-        archiveStage = path.join(path.dirname(archive), `.${proposal.targetSkill}.${transactionId}.stage`);
-        await ensureSafeRuntimeDirectory(projectRoot, path.dirname(archive));
-        if (await lstatIfPresent(archive) !== null || await lstatIfPresent(archiveStage) !== null)
-            throw new SkillApplyError("TARGET_ALREADY_EXISTS");
-    }
-    else {
-        await ensureSafeRuntimeDirectory(projectRoot, path.dirname(draftStage));
-        await buildStage(skillRoot, proposal, exists, draftStage);
-    }
-    const after = proposal.action === "archive" ? [] : await snapshotSkill(projectRoot, draftStage);
-    if (archive !== undefined && (await lstatIfPresent(archive) !== null || await lstatIfPresent(archiveStage) !== null)) {
-        throw new SkillApplyError("TARGET_ALREADY_EXISTS");
-    }
-    await beginSkillTransaction(projectRoot, paths.configRoot, {
-        id: transactionId,
-        request,
-        proposalId: proposal.id,
-        action: proposal.action,
-        targets: [{ targetSkill: proposal.targetSkill, proposalId: proposal.id, action: proposal.action, before, after,
-                ...(archive === undefined ? {} : { archivePath: archive, archiveStagePath: archiveStage }) }],
-        includeLedger: true,
-        includeUsage: true,
-        includeProposal: true,
-        capability
-    });
-    try {
-        if (proposal.status === "pending")
-            proposal = await updateProposal(proposal, { status: "approved" }, projectRoot, configRoot, { capability });
-        await assertSkillLoopRootPins(capability);
-        if (proposal.action === "archive") {
-            await materializeTransactionSnapshot(projectRoot, archiveStage, archive, before);
-            await anchoredRenameInSkillsRoot(capability, proposal.targetSkill, backupName);
-            await anchoredAssertSkillPathAbsent(capability, proposal.targetSkill);
-        }
-        else {
-            await anchoredCopyIntoSkillsRoot(capability, draftStage, stageName, after);
-            await anchoredVerifySkillTree(capability, stageName, after);
-            await swapStage(capability, proposal.targetSkill, stageName, backupName, exists);
-            await anchoredVerifySkillTree(capability, proposal.targetSkill, after);
-        }
-        await assertSkillLoopRootPins(capability);
-        await fs.rm(path.join(paths.runtimeRoot, "skill-transaction-staging", transactionId), { recursive: true, force: true });
-        const ledger = await appendSkillLedger(projectRoot, {
-            proposalId: proposal.id,
-            actor: "user",
-            operation: "apply",
-            targetSkill: proposal.targetSkill,
-            targetRoot: paths.skillsRoot,
-            before,
-            after,
-            reason: proposal.rationale
-        }, new Date().toISOString(), { capability });
-        proposal = await updateProposal(proposal, { status: "applied", ledgerEntryId: ledger.id }, projectRoot, configRoot, { capability });
-        if (proposal.action === "archive")
-            await setSkillUsageLifecycle(projectRoot, proposal.targetSkill, "archived", ledger.createdAt, { capability });
-        else
-            await bumpSkillUsage(projectRoot, proposal.targetSkill, "patch", ledger.createdAt, { capability });
-        await completeSkillTransaction(projectRoot, paths.configRoot, request, capability);
-        return { proposal, ledgerEntryId: ledger.id, appliedPath: skillRoot };
-    }
-    catch (error) {
-        await recoverAfterFailure(projectRoot, paths.configRoot, request, capability, error);
-        await fs.rm(path.join(paths.runtimeRoot, "skill-transaction-staging", transactionId), { recursive: true, force: true }).catch(() => undefined);
-        throw error;
-    }
-}
-export async function applyProposal(id, projectRoot, configRoot) {
-    const requestedConfigRoot = skillLoopPaths(projectRoot, configRoot).configRoot;
-    return withSkillLoopMutationLock(projectRoot, async () => withUserSkillRootLock(projectRoot, requestedConfigRoot, (capability, roots) => applyProposalLocked(id, roots.project.physical, roots.config.physical, capability)));
-}
-async function rejectProposalLocked(id, projectRoot, configRoot, capability) {
-    const paths = skillLoopPaths(projectRoot, configRoot);
-    const request = { kind: "reject", requestId: id };
-    const recovery = await recoverRequest(projectRoot, paths.configRoot, request, capability);
-    const entries = await readSkillLedger(projectRoot);
-    const proposals = await listProposals(projectRoot, configRoot);
-    assertProposalLedgerIntegrity(proposals, entries);
-    const proposal = proposals.find((candidate) => candidate.id === id);
-    if (proposal === undefined)
-        throw new SkillProposalError("PROPOSAL_NOT_FOUND");
-    if (recovery === "committed" && proposal.status === "rejected")
-        return proposal;
-    if (proposal.status !== "pending")
-        throw new SkillApplyError("PROPOSAL_STATUS_INVALID");
-    await beginSkillTransaction(projectRoot, paths.configRoot, {
-        id: createSkillTransactionId(), request, proposalId: proposal.id, action: "reject", targets: [], includeLedger: true, includeProposal: true, capability
-    });
-    try {
-        await appendSkillLedger(projectRoot, {
-            proposalId: proposal.id,
-            actor: "user",
-            operation: "reject",
-            targetSkill: proposal.targetSkill,
-            targetRoot: paths.skillsRoot,
-            before: [],
-            after: [],
-            reason: proposal.rationale
-        }, new Date().toISOString(), { capability });
-        const rejected = await updateProposal(proposal, { status: "rejected" }, projectRoot, configRoot, { capability });
-        await completeSkillTransaction(projectRoot, paths.configRoot, request, capability);
-        return rejected;
-    }
-    catch (error) {
-        await recoverAfterFailure(projectRoot, paths.configRoot, request, capability, error);
-        throw error;
-    }
-}
-export async function rejectProposal(id, projectRoot, configRoot) {
-    const requestedConfigRoot = skillLoopPaths(projectRoot, configRoot).configRoot;
-    return withSkillLoopMutationLock(projectRoot, async (capability) => {
-        const paths = await resolveSkillLoopPaths(projectRoot, requestedConfigRoot);
-        return rejectProposalLocked(id, paths.projectRoot, paths.configRoot, capability);
-    });
-}
-async function rollbackLedgerEntryLocked(id, projectRoot, configRoot, capability) {
-    const paths = skillLoopPaths(projectRoot, configRoot);
-    const request = { kind: "rollback", requestId: id };
-    const recovery = await recoverRequest(projectRoot, paths.configRoot, request, capability);
-    await assertSkillLoopRootPins(capability);
-    const entries = await readSkillLedger(projectRoot);
-    const proposals = await listProposals(projectRoot, configRoot);
-    assertProposalLedgerIntegrity(proposals, entries);
-    if (recovery === "committed") {
-        const committed = entries.find((candidate) => candidate.operation === "rollback" && candidate.restoresLedgerEntryId === id);
-        if (committed !== undefined)
-            return { ledgerEntryId: committed.id, restoredLedgerEntryId: id };
-    }
-    const reference = entries.find((candidate) => candidate.id === id);
-    if (reference === undefined)
-        throw new Error("LEDGER_ENTRY_NOT_FOUND");
-    if (reference.operation !== "apply" && reference.operation !== "curator-transition" && reference.operation !== "rollback") {
-        throw new SkillApplyError("LEDGER_ENTRY_NOT_ROLLBACK_ELIGIBLE");
-    }
-    if (entries.some((candidate) => candidate.operation === "rollback" && candidate.restoresLedgerEntryId === reference.id)) {
-        throw new SkillApplyError("LEDGER_ENTRY_ALREADY_ROLLED_BACK");
-    }
-    if (path.resolve(reference.targetRoot) !== path.resolve(paths.skillsRoot))
-        throw new SkillApplyError("PROPOSAL_TARGET_ROOT_MISMATCH");
-    const referenceProposal = reference.proposalId === null ? undefined : proposals.find((candidate) => candidate.id === reference.proposalId);
-    if (reference.proposalId !== null && (referenceProposal === undefined || referenceProposal.ledgerEntryId !== reference.id)) {
-        throw new SkillProposalError("PROPOSAL_INTEGRITY_INVALID");
-    }
-    const skillRoot = path.join(paths.skillsRoot, reference.targetSkill);
-    assertMutableSkillIdentity(reference.targetSkill);
-    try {
-        await assertPathComponentsSafe(paths.configRoot, skillRoot, `Agent-owned skill ${reference.targetSkill}`);
-    }
-    catch {
-        throw new SkillApplyError("TARGET_PATH_UNSAFE");
-    }
-    await assertSnapshotMatches(projectRoot, skillRoot, reference.after);
-    await assertAgentOwnedSnapshot(projectRoot, reference.before);
-    await assertAgentOwnedSnapshot(projectRoot, reference.after);
-    if (reference.after.length > 0)
-        await assertExistingAgentOwnedSkill(skillRoot);
-    if (await targetPinned(projectRoot, reference.targetSkill))
-        throw new SkillApplyError("TARGET_PINNED");
-    const before = await snapshotSkill(projectRoot, skillRoot);
-    const transactionId = createSkillTransactionId();
-    const stageName = `.${reference.targetSkill}.${transactionId}.stage`;
-    const backupName = `.${reference.targetSkill}.${transactionId}.backup`;
-    const draftStage = path.join(paths.runtimeRoot, "skill-transaction-staging", transactionId, reference.targetSkill);
-    if (reference.before.length > 0) {
-        await ensureSafeRuntimeDirectory(projectRoot, path.dirname(draftStage));
-        await restoreSnapshot(projectRoot, draftStage, reference.before);
-    }
-    await beginSkillTransaction(projectRoot, paths.configRoot, {
-        id: transactionId,
-        request,
-        proposalId: reference.proposalId,
-        action: "rollback",
-        targets: [{ targetSkill: reference.targetSkill, proposalId: reference.proposalId, action: "rollback", before, after: reference.before }],
-        includeLedger: true,
-        includeUsage: true,
-        includeProposal: referenceProposal !== undefined,
-        capability
-    });
-    try {
-        if (reference.before.length === 0) {
-            await anchoredRenameInSkillsRoot(capability, reference.targetSkill, backupName);
-            await anchoredAssertSkillPathAbsent(capability, reference.targetSkill);
-        }
-        else {
-            await anchoredCopyIntoSkillsRoot(capability, draftStage, stageName, reference.before);
-            await anchoredVerifySkillTree(capability, stageName, reference.before);
-            await swapStage(capability, reference.targetSkill, stageName, backupName, reference.after.length > 0);
-            await anchoredVerifySkillTree(capability, reference.targetSkill, reference.before);
-        }
-        await assertSkillLoopRootPins(capability);
-        await fs.rm(path.join(paths.runtimeRoot, "skill-transaction-staging", transactionId), { recursive: true, force: true });
-        const after = await snapshotSkill(projectRoot, skillRoot);
-        const ledger = await appendSkillLedger(projectRoot, {
-            proposalId: reference.proposalId,
-            actor: "user",
-            operation: "rollback",
-            targetSkill: reference.targetSkill,
-            targetRoot: reference.targetRoot,
-            before,
-            after,
-            restoresLedgerEntryId: reference.id
-        }, new Date().toISOString(), { capability });
-        if (referenceProposal !== undefined) {
-            const { depth } = rollbackOrigin(reference, entries);
-            const status = (depth + 1) % 2 === 0 ? "applied" : "rolled-back";
-            await updateProposal(referenceProposal, { status, ledgerEntryId: ledger.id }, projectRoot, configRoot, { capability });
-        }
-        const { origin } = rollbackOrigin(reference, entries);
-        await setSkillUsageLifecycle(projectRoot, reference.targetSkill, reference.before.length === 0 ? "archived" : origin.operation === "curator-transition" ? "stale" : "active", ledger.createdAt, { capability });
-        await completeSkillTransaction(projectRoot, paths.configRoot, request, capability);
-        return { ledgerEntryId: ledger.id, restoredLedgerEntryId: reference.id };
-    }
-    catch (error) {
-        await recoverAfterFailure(projectRoot, paths.configRoot, request, capability, error);
-        await fs.rm(path.join(paths.runtimeRoot, "skill-transaction-staging", transactionId), { recursive: true, force: true }).catch(() => undefined);
-        throw error;
-    }
-}
-export async function rollbackLedgerEntry(id, projectRoot, configRoot) {
-    const requestedConfigRoot = skillLoopPaths(projectRoot, configRoot).configRoot;
-    return withSkillLoopMutationLock(projectRoot, async () => withUserSkillRootLock(projectRoot, requestedConfigRoot, (capability, roots) => rollbackLedgerEntryLocked(id, roots.project.physical, roots.config.physical, capability)));
-}
-export function skillLoopErrorCode(error) {
-    if (error instanceof SkillApplyError || error instanceof SkillProposalError)
-        return error.code;
-    if (error instanceof Error && /^[A-Z][A-Z0-9_]+$/u.test(error.message))
-        return error.message;
-    return "SKILL_LOOP_FAILED";
-}

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

@@ -1,50 +0,0 @@
-import { type SkillLoopLockCapability } from "./storage.ts";
-export type SkillLoopConfig = {
-    readonly schemaVersion: 1;
-    readonly autoApply: false;
-    readonly nudgeInterval: number;
-    readonly curatorIntervalDays: number;
-    readonly minIdleHours: number;
-    readonly staleAfterDays: number;
-    readonly archiveAfterDays: number;
-};
-export type SkillLoopPaths = {
-    readonly projectRoot: string;
-    readonly runtimeRoot: string;
-    readonly configRoot: string;
-    readonly skillsRoot: string;
-    readonly configFile: string;
-    readonly proposalsDir: string;
-    readonly usageFile: string;
-    readonly ledgerFile: string;
-    readonly blobsDir: string;
-    readonly stateFile: string;
-    readonly pendingReviewFile: string;
-    readonly backupsDir: string;
-    readonly archiveDir: string;
-    readonly transactionFile: string;
-    readonly observationTransactionFile: string;
-};
-export declare const defaultSkillLoopConfig: SkillLoopConfig;
-export declare function skillLoopPaths(projectRoot?: string, configRoot?: string): SkillLoopPaths;
-export declare function resolveSkillLoopPaths(projectRoot: string, configRoot: string): Promise<SkillLoopPaths>;
-export declare function readSkillLoopConfig(projectRoot: string): Promise<SkillLoopConfig>;
-export declare function writeJsonAtomically(projectRoot: string, file: string, value: unknown, capability?: SkillLoopLockCapability): Promise<void>;
-export type PendingReviewSession = {
-    readonly sessionRef: string;
-    readonly iterationCount: number;
-    readonly queuedAt: string;
-};
-type PendingReviewState = {
-    readonly schemaVersion: 1;
-    readonly sessions: readonly PendingReviewSession[];
-};
-export declare function readPendingReviewState(projectRoot: string, options?: {
-    readonly capability?: SkillLoopLockCapability;
-}): Promise<PendingReviewState>;
-export declare function consumePendingReview(projectRoot: string, reviewedSessionRefs: readonly string[]): Promise<void>;
-export declare function observeToolIteration(projectRoot: string, sessionRef: string, now?: string): Promise<{
-    readonly surfaceNotice: boolean;
-    readonly reviewQueued: boolean;
-}>;
-export {};