@litfamily/litclaude 1.0.6 → 1.0.7

package/plugins/litclaude/lib/skill-loop/apply.mjs

@@ -1,391 +0,0 @@
-import { randomUUID } from "node:crypto";
-import {
-  existsSync,
-  lstatSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  rmSync,
-} from "node:fs";
-import { dirname, join } from "node:path";
-
-import { resolveAgentTarget } from "./authority.mjs";
-import {
-  assertNoSecretStrings,
-  atomicWriteBytes,
-  captureDirectoryIdentity,
-  decodeSkillLoopUtf8,
-  directoryIdentityMatches,
-  ensureSafeDirectoryChain,
-  parseTimestamp,
-  safeIsoPath,
-  withSkillLoopLock,
-} from "./common.mjs";
-import {
-  appendLedgerEntryUnlocked,
-  captureSkillSnapshot,
-  captureStagedSnapshot,
-  materializeSnapshot,
-  proposalReceiptMatches,
-  readLedger,
-  SkillLoopLedgerError,
-} from "./ledger.mjs";
-import { readProposalUnlocked } from "./proposal-reader.mjs";
-import { proposalFilePath, readProposalRecord, transitionProposalRecordUnlocked } from "./proposal-store.mjs";
-import { recoverReviewTransactionUnlocked } from "./review-transaction.mjs";
-import {
-  beginSkillMutationTransactionUnlocked,
-  recoverSkillMutationTransactionUnlocked,
-} from "./mutation-transaction.mjs";
-import { prepareUsageUpdate, writeUsageUnlocked } from "./usage.mjs";
-
-export class SkillLoopApplyError extends Error {
-  constructor(code, message = code) {
-    super(`${code}: ${message}`);
-    this.name = "SkillLoopApplyError";
-    this.code = code;
-  }
-}
-
-function ensureSkillRoot(root, create) {
-  return ensureSafeDirectoryChain(root, [".claude", "skills"], {
-    create,
-    ErrorType: SkillLoopApplyError,
-    code: "TARGET_PATH_UNSAFE",
-  });
-}
-
-function assertTargetIdentity(root, proposal) {
-  return resolveAgentTarget(root, proposal.targetRoot, proposal.targetSkill, {
-    allowMissing: true,
-    requireOwned: false,
-    ErrorType: SkillLoopApplyError,
-  });
-}
-
-function writeStageFile(stage, file, bytes) {
-  const path = join(stage, ...file.split("/"));
-  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-  if (existsSync(path)) throw new SkillLoopApplyError("TARGET_FILE_EXISTS");
-  atomicWriteBytes(path, Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes, "utf8"), SkillLoopApplyError, "TARGET_WRITE_FAILED");
-}
-
-function populateCreate(stage, proposal) {
-  mkdirSync(stage, { mode: 0o700 });
-  const sourceSkill = proposal.createSpec.files.find(({ file }) => file === "SKILL.md")?.content ?? "";
-  const frontmatter = [
-    "---",
-    `name: ${proposal.targetSkill}`,
-    "description: Agent-generated skill approved by the user.",
-    "metadata:",
-    "  litclaudeAgentGenerated: \"true\"",
-    "---",
-    sourceSkill,
-  ].join("\n");
-  writeStageFile(stage, "SKILL.md", frontmatter.endsWith("\n") ? frontmatter : `${frontmatter}\n`);
-  for (const file of proposal.createSpec.files) {
-    if (file.file !== "SKILL.md") writeStageFile(stage, file.file, file.content);
-  }
-}
-
-function buildStage(root, stage, before, proposal) {
-  if (proposal.action === "create") {
-    populateCreate(stage, proposal);
-    return;
-  }
-  materializeSnapshot(root, stage, before);
-  if (proposal.action === "patch") {
-    const path = join(stage, ...proposal.patch.file.split("/"));
-    const details = lstatSync(path, { throwIfNoEntry: false });
-    if (!details?.isFile() || details.isSymbolicLink() || details.nlink !== 1) {
-      throw new SkillLoopApplyError("TARGET_PATH_UNSAFE");
-    }
-    let source;
-    try {
-      source = decodeSkillLoopUtf8(readFileSync(path));
-    } catch {
-      throw new SkillLoopApplyError("TARGET_PATH_UNSAFE", "patch source is not strict UTF-8 text");
-    }
-    const matches = source.split(proposal.patch.oldString).length - 1;
-    if (matches !== 1) throw new SkillLoopApplyError("PATCH_MATCH_NOT_UNIQUE");
-    atomicWriteBytes(path, Buffer.from(source.replace(proposal.patch.oldString, proposal.patch.newString), "utf8"),
-      SkillLoopApplyError, "TARGET_WRITE_FAILED");
-  } else if (proposal.action === "add-reference") {
-    for (const file of proposal.createSpec.files) writeStageFile(stage, file.file, file.content);
-  }
-}
-
-function mapLedgerError(error) {
-  if (!(error instanceof SkillLoopLedgerError)) return error;
-  if (["SNAPSHOT_PATH_UNSAFE", "SNAPSHOT_TOO_LARGE"].includes(error.code)) {
-    return new SkillLoopApplyError("TARGET_PATH_UNSAFE");
-  }
-  return new SkillLoopApplyError("LEDGER_WRITE_FAILED");
-}
-
-export function applyProposal(root, proposalId, {
-  now = new Date().toISOString(),
-  beforeCommit,
-  afterIdentityCapture,
-  beforeProposalCommit,
-  afterCurrentDisplaced,
-  afterLiveMutation,
-  afterUsageCommit,
-  afterLedgerCommit,
-  afterProposalCommit,
-} = {}) {
-  if (parseTimestamp(now) === null) throw new SkillLoopApplyError("APPLY_CLOCK_INVALID");
-  return withSkillLoopLock(root, "transaction", () => {
-    recoverReviewTransactionUnlocked(root);
-    const mutationRecovery = recoverSkillMutationTransactionUnlocked(root);
-    if (mutationRecovery.status === "finalized" && mutationRecovery.kind === "apply"
-      && mutationRecovery.requestId === proposalId) {
-      return {
-        status: "applied",
-        ledgerEntryId: mutationRecovery.ledgerEntry.id,
-        path: mutationRecovery.path,
-        archivePath: mutationRecovery.archivePath,
-        recovered: true,
-      };
-    }
-    const recoveredPreparedMutation = mutationRecovery.status === "rolled-back"
-      && mutationRecovery.kind === "apply" && mutationRecovery.requestId === proposalId;
-    let proposal = readProposalUnlocked(root, proposalId);
-    if (proposal.status === "pending") {
-      proposal = transitionProposalRecordUnlocked(root, proposal.id, "approved");
-    } else if (proposal.status !== "approved") throw new SkillLoopApplyError("PROPOSAL_NOT_APPLICABLE");
-
-    const { target, exists } = assertTargetIdentity(root, proposal);
-    if (proposal.status === "approved") {
-      let current;
-      try {
-        current = captureSkillSnapshot(root, proposal.targetRoot, proposal.targetSkill);
-      } catch (error) {
-        throw mapLedgerError(error);
-      }
-      const prior = readLedger(root).findLast((entry) => proposalReceiptMatches(proposal, entry, {
-        operation: "apply",
-        currentSnapshot: current,
-      }));
-      if (prior) {
-        transitionProposalRecordUnlocked(root, proposal.id, "applied", prior.id);
-        return { status: "applied", ledgerEntryId: prior.id, path: target, recovered: true };
-      }
-    }
-    if (proposal.action === "create" ? exists : !exists) throw new SkillLoopApplyError("TARGET_NOT_AGENT_OWNED");
-    if (exists) resolveAgentTarget(root, proposal.targetRoot, proposal.targetSkill, {
-      allowMissing: false,
-      requireOwned: true,
-      ErrorType: SkillLoopApplyError,
-    });
-
-    let before;
-    try {
-      before = captureSkillSnapshot(root, proposal.targetRoot, proposal.targetSkill);
-    } catch (error) {
-      throw mapLedgerError(error);
-    }
-    const skills = ensureSkillRoot(root, true);
-    const stage = join(skills, `.${proposal.targetSkill}.apply-${randomUUID()}`);
-    const displaced = join(skills, `.${proposal.targetSkill}.apply-before-${randomUUID()}`);
-    let archiveDestination = null;
-    let movedCurrent = false;
-    let installedStage = false;
-    let archivedCurrent = false;
-    let ledgerCommitted = false;
-    let proposalCommitted = false;
-    let usageCommitted = false;
-    let usageUpdate = null;
-    try {
-      if (proposal.action !== "archive") buildStage(root, stage, before, proposal);
-      beforeCommit?.();
-      let liveBefore;
-      try {
-        liveBefore = captureSkillSnapshot(root, proposal.targetRoot, proposal.targetSkill);
-      } catch (error) {
-        throw mapLedgerError(error);
-      }
-      if (JSON.stringify(liveBefore) !== JSON.stringify(before)) throw new SkillLoopApplyError("APPLY_CAS_MISMATCH");
-      const expectedIdentity = captureDirectoryIdentity(target, SkillLoopApplyError, "TARGET_PATH_UNSAFE", {
-        allowMissing: !exists,
-      });
-      afterIdentityCapture?.();
-      if (!directoryIdentityMatches(target, expectedIdentity)) throw new SkillLoopApplyError("APPLY_IDENTITY_MISMATCH");
-      let after;
-      try {
-        after = proposal.action === "archive" ? [] : captureStagedSnapshot(root, stage);
-      } catch (error) {
-        throw mapLedgerError(error);
-      }
-      const stageIdentity = proposal.action === "archive"
-        ? null
-        : captureDirectoryIdentity(stage, SkillLoopApplyError, "TARGET_PATH_UNSAFE");
-      if (proposal.action === "archive") {
-        const archiveRoot = ensureSafeDirectoryChain(root, [".litclaude", "skill-archives", safeIsoPath(now)], {
-          create: true,
-          ErrorType: SkillLoopApplyError,
-          code: "TARGET_PATH_UNSAFE",
-        });
-        archiveDestination = join(archiveRoot, proposal.targetSkill);
-        if (existsSync(archiveDestination)) throw new SkillLoopApplyError("TARGET_IDENTITY_COLLISION");
-      }
-      const ledgerId = `ledger-${randomUUID()}`;
-      const entry = {
-        schema: "litfamily.skill-ledger/v1",
-        id: ledgerId,
-        createdAt: now,
-        proposalId: proposal.id,
-        actor: "user",
-        operation: "apply",
-        targetSkill: proposal.targetSkill,
-        targetRoot: proposal.targetRoot,
-        before,
-        after,
-      };
-      const proposalAfter = { ...proposal, status: "applied", ledgerEntryId: ledgerId };
-      usageUpdate = proposal.action === "patch"
-        ? prepareUsageUpdate(root, proposal.targetSkill, "patch", { now, createdBy: "agent" })
-        : null;
-      beginSkillMutationTransactionUnlocked(root, {
-        schema: "litclaude.skill-mutation-transaction/v1",
-        id: ledgerId,
-        kind: "apply",
-        requestId: proposal.id,
-        createdAt: now,
-        targetRoot: proposal.targetRoot,
-        targetSkill: proposal.targetSkill,
-        action: proposal.action,
-        stageName: stage.split(/[\\/]/u).at(-1),
-        displacedName: displaced.split(/[\\/]/u).at(-1),
-        archiveParts: proposal.action === "archive"
-          ? ["skill-archives", safeIsoPath(now), proposal.targetSkill]
-          : null,
-        beforeIdentity: expectedIdentity,
-        stageIdentity,
-        before,
-        after,
-        ledgerEntry: entry,
-        proposalBefore: proposal,
-        proposalAfter,
-        usageBefore: usageUpdate?.before ?? null,
-        usageAfter: usageUpdate?.after ?? null,
-        configBefore: null,
-        configAfter: null,
-      });
-      if (expectedIdentity !== null) {
-        renameSync(target, displaced);
-        movedCurrent = true;
-        if (!directoryIdentityMatches(displaced, expectedIdentity)) {
-          renameSync(displaced, target);
-          movedCurrent = false;
-          throw new SkillLoopApplyError("APPLY_IDENTITY_MISMATCH");
-        }
-      } else if (!directoryIdentityMatches(target, null)) {
-        throw new SkillLoopApplyError("APPLY_IDENTITY_MISMATCH");
-      }
-      afterCurrentDisplaced?.();
-      if (proposal.action !== "archive") {
-        renameSync(stage, target);
-        installedStage = true;
-      } else {
-        renameSync(displaced, archiveDestination);
-        movedCurrent = false;
-        archivedCurrent = true;
-        if (!directoryIdentityMatches(archiveDestination, expectedIdentity)) {
-          renameSync(archiveDestination, displaced);
-          archivedCurrent = false;
-          movedCurrent = true;
-          throw new SkillLoopApplyError("APPLY_IDENTITY_MISMATCH");
-        }
-      }
-      afterLiveMutation?.();
-      let liveAfter;
-      try {
-        liveAfter = captureSkillSnapshot(root, proposal.targetRoot, proposal.targetSkill);
-      } catch (error) {
-        throw mapLedgerError(error);
-      }
-      if (JSON.stringify(liveAfter) !== JSON.stringify(after)) throw new SkillLoopApplyError("APPLY_CAS_MISMATCH");
-      if (usageUpdate) {
-        writeUsageUnlocked(root, usageUpdate.after);
-        usageCommitted = true;
-        afterUsageCommit?.();
-      }
-      appendLedgerEntryUnlocked(root, entry);
-      ledgerCommitted = true;
-      afterLedgerCommit?.();
-      beforeProposalCommit?.(proposalFilePath(root, proposal.id, false));
-      transitionProposalRecordUnlocked(root, proposal.id, "applied", entry.id);
-      proposalCommitted = true;
-      afterProposalCommit?.();
-      const finalized = recoverSkillMutationTransactionUnlocked(root);
-      if (finalized.status !== "finalized") throw new SkillLoopApplyError("APPLY_STATE_UNKNOWN");
-      return {
-        status: "applied",
-        ledgerEntryId: entry.id,
-        path: target,
-        archivePath: archiveDestination,
-        ...(recoveredPreparedMutation ? { recovered: true } : {}),
-      };
-    } catch (error) {
-      if (ledgerCommitted) {
-        throw new SkillLoopApplyError(
-          proposalCommitted ? "APPLY_COMMITTED_CLEANUP_PENDING" : "APPLY_COMMITTED_METADATA_PENDING",
-          proposalCommitted
-            ? "mutation, ledger, and proposal are committed; recoverable cleanup remains"
-            : "mutation and ledger are committed; retry apply to repair proposal state",
-        );
-      }
-      try {
-        if (installedStage && existsSync(target)) rmSync(target, { recursive: true, force: true });
-        if (movedCurrent && existsSync(displaced)) renameSync(displaced, target);
-        if (archivedCurrent && archiveDestination && existsSync(archiveDestination)) renameSync(archiveDestination, target);
-        if (usageCommitted && usageUpdate) writeUsageUnlocked(root, usageUpdate.before);
-      } catch {
-        throw new SkillLoopApplyError("APPLY_STATE_UNKNOWN");
-      }
-      if (error instanceof SkillLoopApplyError) throw error;
-      throw mapLedgerError(error);
-    } finally {
-      rmSync(stage, { recursive: true, force: true });
-      if (!movedCurrent) rmSync(displaced, { recursive: true, force: true });
-    }
-  }, SkillLoopApplyError, "APPLY_LOCK_FAILED");
-}
-
-export function rejectProposal(root, proposalId, reason = "", options = {}) {
-  assertNoSecretStrings(reason, () => { throw new SkillLoopApplyError("PROPOSAL_SECRET_REFUSED"); });
-  return withSkillLoopLock(root, "transaction", () => {
-    recoverReviewTransactionUnlocked(root);
-    recoverSkillMutationTransactionUnlocked(root);
-    const proposal = readProposalRecord(root, proposalId);
-    if (proposal.status === "pending") {
-      const prior = readLedger(root).findLast((entry) => proposalReceiptMatches(proposal, entry, { operation: "reject" }));
-      if (prior) {
-        transitionProposalRecordUnlocked(root, proposal.id, "rejected");
-        return { ...proposal, status: "rejected", ledgerEntryId: prior.id, recovered: true };
-      }
-    }
-    if (proposal.status !== "pending") throw new SkillLoopApplyError("PROPOSAL_NOT_REJECTABLE");
-    const ledgerEntry = appendLedgerEntryUnlocked(root, {
-      schema: "litfamily.skill-ledger/v1",
-      id: `ledger-${randomUUID()}`,
-      createdAt: new Date().toISOString(),
-      proposalId: proposal.id,
-      actor: "user",
-      operation: "reject",
-      targetSkill: proposal.targetSkill,
-      targetRoot: proposal.targetRoot,
-      before: [],
-      after: [],
-      reason,
-    });
-    try {
-      options.beforeProposalCommit?.(proposalFilePath(root, proposal.id, false));
-      transitionProposalRecordUnlocked(root, proposal.id, "rejected");
-    } catch {
-      throw new SkillLoopApplyError("REJECT_COMMITTED_METADATA_PENDING");
-    }
-    return { ...proposal, status: "rejected", ledgerEntryId: ledgerEntry.id };
-  }, SkillLoopApplyError, "APPLY_LOCK_FAILED");
-}

package/plugins/litclaude/lib/skill-loop/authority.mjs

@@ -1,129 +0,0 @@
-import { lstatSync, opendirSync } from "node:fs";
-import { join } from "node:path";
-
-import { canonicalSkillIds } from "../canonical-skill-catalog.mjs";
-import { readRegularStable } from "../secure-path-read.mjs";
-import {
-  decodeSkillLoopUtf8,
-  ensureSafeDirectoryChain,
-  portablePathIdentity,
-  skillRootFor,
-  skillRootsEquivalent,
-  SKILL_ID,
-} from "./common.mjs";
-
-const protectedIds = new Set(canonicalSkillIds.map(portablePathIdentity));
-
-export function hasAgentOwnershipMarker(text) {
-  if (typeof text !== "string") return false;
-  const normalized = text.replace(/\r\n/gu, "\n");
-  if (!normalized.startsWith("---\n")) return false;
-  const allLines = normalized.split("\n");
-  let close = -1;
-  for (let index = 1; index < allLines.length; index += 1) {
-    if (/^---[\t ]*$/u.test(allLines[index])) {
-      close = index;
-      break;
-    }
-    if (allLines[index].startsWith("---")) return false;
-  }
-  if (close < 0) return false;
-  const lines = allLines.slice(1, close);
-  let inMetadata = false;
-  let metadataSeen = false;
-  let markerSeen = false;
-  const metadataKeys = new Set();
-  for (const raw of lines) {
-    if (/^metadata:\s*(?:#.*)?$/u.test(raw)) {
-      if (metadataSeen) return false;
-      metadataSeen = true;
-      inMetadata = true;
-      continue;
-    }
-    if (/^metadata\s*:/u.test(raw)) return false;
-    if (!inMetadata) continue;
-    if (raw.trim() === "" || /^  #/u.test(raw)) continue;
-    if (!/^\s/u.test(raw)) {
-      inMetadata = false;
-      continue;
-    }
-    const child = /^ {2}([A-Za-z0-9_-]+):\s*(.*?)\s*$/u.exec(raw);
-    if (!child || metadataKeys.has(child[1])) return false;
-    metadataKeys.add(child[1]);
-    if (child[1] === "litclaudeAgentGenerated") {
-      const match = /^(["'])true\1\s*(?:#.*)?$/u.exec(child[2]);
-      if (!match || markerSeen) return false;
-      markerSeen = true;
-    }
-  }
-  return markerSeen;
-}
-
-function readOwnedMarker(root, target, ErrorType, pathCode) {
-  const path = join(target, "SKILL.md");
-  const details = lstatSync(path, { throwIfNoEntry: false });
-  if (!details?.isFile() || details.isSymbolicLink() || details.nlink !== 1) throw new ErrorType(pathCode);
-  const stable = readRegularStable(root, path, undefined, { maxBytes: 1024 * 1024 });
-  if (stable.failure || stable.stat.nlink !== 1) throw new ErrorType(pathCode);
-  try {
-    return hasAgentOwnershipMarker(decodeSkillLoopUtf8(stable.bytes));
-  } catch {
-    throw new ErrorType(pathCode, "SKILL.md is not strict UTF-8 text");
-  }
-}
-
-export function resolveAgentTarget(root, targetRoot, targetSkill, {
-  createRoot = false,
-  allowMissing = false,
-  requireOwned = true,
-  ErrorType,
-  notOwnedCode = "TARGET_NOT_AGENT_OWNED",
-  pathCode = "TARGET_PATH_UNSAFE",
-  collisionCode = "TARGET_IDENTITY_COLLISION",
-  maxDirectoryEntries = null,
-  workCapCode = pathCode,
-} = {}) {
-  if (!ErrorType || !skillRootsEquivalent(root, targetRoot) || !SKILL_ID.test(targetSkill)
-    || protectedIds.has(portablePathIdentity(targetSkill))) throw new ErrorType(notOwnedCode);
-  const skills = ensureSafeDirectoryChain(root, [".claude", "skills"], {
-    create: createRoot,
-    ErrorType,
-    code: pathCode,
-  });
-  const target = join(skillRootFor(root), targetSkill);
-  if (skills === null) {
-    if (allowMissing) return { skills: targetRoot, target, exists: false, owned: false };
-    throw new ErrorType(notOwnedCode);
-  }
-  const requestedIdentity = portablePathIdentity(targetSkill);
-  if (maxDirectoryEntries !== null
-    && (!Number.isSafeInteger(maxDirectoryEntries) || maxDirectoryEntries < 1)) {
-    throw new ErrorType(workCapCode);
-  }
-  let handle;
-  try {
-    handle = opendirSync(skills);
-    let count = 0;
-    let entry;
-    while ((entry = handle.readSync()) !== null) {
-      count += 1;
-      if (maxDirectoryEntries !== null && count > maxDirectoryEntries) {
-        throw new ErrorType(workCapCode);
-      }
-      if (portablePathIdentity(entry.name) === requestedIdentity && entry.name !== targetSkill) {
-        throw new ErrorType(collisionCode);
-      }
-    }
-  } finally {
-    handle?.closeSync();
-  }
-  const details = lstatSync(target, { throwIfNoEntry: false });
-  if (!details) {
-    if (allowMissing) return { skills, target, exists: false, owned: false };
-    throw new ErrorType(notOwnedCode);
-  }
-  if (!details.isDirectory() || details.isSymbolicLink()) throw new ErrorType(pathCode);
-  const owned = readOwnedMarker(root, target, ErrorType, pathCode);
-  if (requireOwned && !owned) throw new ErrorType(notOwnedCode);
-  return { skills, target, exists: true, owned };
-}

package/plugins/litclaude/lib/skill-loop/cli.mjs

@@ -1,67 +0,0 @@
-import { applyProposal, rejectProposal } from "./apply.mjs";
-import { readSkillLoopConfig } from "./config.mjs";
-import { runCurator } from "./curator.mjs";
-import { readLatestHookActivity } from "./hook-state.mjs";
-import { readLedger, rollbackLedgerEntry } from "./ledger.mjs";
-import { listProposals } from "./proposals.mjs";
-import { runReview } from "./review.mjs";
-import { readUsage } from "./usage.mjs";
-
-class SkillLoopCliError extends Error {
-  constructor(code, message = code) {
-    super(message);
-    this.code = code;
-  }
-}
-
-const usage = () => new SkillLoopCliError(
-  "USAGE",
-  "usage: skill-loop review|list|apply <id>|reject <id>|rollback <ledger-id>|curator status|curator run",
-);
-const requireId = (args) => {
-  if (args.length !== 1 || typeof args[0] !== "string" || args[0] === "") throw usage();
-  return args[0];
-};
-
-export function runSkillLoopCli(root, argv) {
-  const [mode, ...args] = argv;
-  if (mode === "list") {
-    if (args.length !== 0) throw usage();
-    return { schema: "litclaude.skill-proposal-list/v1", proposals: listProposals(root) };
-  }
-  if (mode === "review") {
-    if (args.length !== 0) throw usage();
-    return runReview(root);
-  }
-  if (mode === "apply") return applyProposal(root, requireId(args));
-  if (mode === "reject") return rejectProposal(root, requireId(args));
-  if (mode === "rollback") return rollbackLedgerEntry(root, requireId(args));
-  if (mode === "curator") {
-    if (args.length !== 1 || !["status", "run"].includes(args[0])) throw usage();
-    if (args[0] === "run") {
-      return runCurator(root, { lastActivityAt: readLatestHookActivity(root) });
-    }
-    const config = readSkillLoopConfig(root);
-    const usageSidecar = readUsage(root);
-    const proposals = listProposals(root);
-    return {
-      schema: "litclaude.skill-curator-status/v1",
-      lastCuratorRunAt: config.lastCuratorRunAt ?? null,
-      lastActivityAt: readLatestHookActivity(root),
-      activeSkills: Object.values(usageSidecar.skills).filter(({ state }) => state === "active").length,
-      staleSkills: Object.values(usageSidecar.skills).filter(({ state }) => state === "stale").length,
-      archivedSkills: Object.values(usageSidecar.skills).filter(({ state }) => state === "archived").length,
-      pendingProposals: proposals.filter(({ status }) => status === "pending").length,
-      ledgerEntries: readLedger(root).length,
-    };
-  }
-  throw usage();
-}
-
-export function cliErrorPayload(error) {
-  return {
-    status: "error",
-    code: typeof error?.code === "string" ? error.code : "SKILL_LOOP_FAILED",
-    message: typeof error?.message === "string" ? error.message : "skill-loop command failed",
-  };
-}