skillwiki 0.10.49 → 0.10.51

package/dist/chunk-HBQTTYXZ.js

@@ -0,0 +1,1045 @@
+#!/usr/bin/env node
+import {
+  buildSourceReferenceIndex,
+  buildSourceRelocationProjection,
+  classifyRawPath,
+  operationId,
+  projectSourceRelocations,
+  readLogEvents,
+  resolveExistingRegularFileInsideVault,
+  writeLogEvent
+} from "./chunk-GAHMWLWU.js";
+import {
+  ExitCode,
+  RawSourceSchema,
+  err,
+  extractFrontmatter,
+  ok,
+  readPage,
+  scanSensitiveContent,
+  scanVault,
+  splitFrontmatter
+} from "./chunk-IJ7DD7QZ.js";
+
+// src/commands/sources.ts
+import { readFile as readFile4 } from "fs/promises";
+
+// src/utils/source-lifecycle.ts
+import { createHash as createHash3 } from "crypto";
+import { readFile as readFile2, readdir } from "fs/promises";
+import { basename, join, relative, sep } from "path";
+
+// src/utils/source-dispositions.ts
+import { createHash as createHash2 } from "crypto";
+import { readFile } from "fs/promises";
+
+// src/utils/source-action-approval.ts
+import { createHash } from "crypto";
+var VERSION = "swsrc1";
+function sha256(value) {
+  return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function encodeSourceActionApproval(payload) {
+  const middle = Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
+  return `${VERSION}.${middle}.${sha256(middle)}`;
+}
+function decodeSourceActionApproval(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3 || parts[0] !== VERSION || !/^[0-9a-f]{64}$/.test(parts[2] ?? "")) {
+    return err("APPROVAL_INVALID", { message: "invalid source-action approval token" });
+  }
+  if (sha256(parts[1]) !== parts[2]) return err("APPROVAL_INVALID", { message: "source-action approval checksum mismatch" });
+  try {
+    const parsed = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return err("APPROVAL_INVALID", { message: "approval payload must be an object" });
+    return ok(parsed);
+  } catch {
+    return err("APPROVAL_INVALID", { message: "source-action approval payload is invalid" });
+  }
+}
+
+// src/utils/source-dispositions.ts
+var STATUSES = /* @__PURE__ */ new Set(["reviewed-no-op", "deferred", "duplicate", "out-of-scope", "superseded", "reopened"]);
+function bodySha256(text) {
+  const split = splitFrontmatter(text);
+  const body = split.ok ? split.data.body : text;
+  return createHash2("sha256").update(Buffer.from(body, "utf8")).digest("hex");
+}
+function completeSha256(text) {
+  return createHash2("sha256").update(Buffer.from(text, "utf8")).digest("hex");
+}
+function exactActiveSource(path) {
+  const parsed = classifyRawPath(path);
+  if (!parsed.ok) return parsed;
+  if (parsed.data.storage !== "active" || !["articles", "papers"].includes(parsed.data.category)) {
+    return err("SOURCE_DISPOSITION_TARGET_INVALID", { path, message: "dispositions require an exact active raw article or paper" });
+  }
+  return ok(true);
+}
+function validDate(value) {
+  return /^\d{4}-\d{2}-\d{2}$/.test(value) && (/* @__PURE__ */ new Date(`${value}T00:00:00Z`)).toISOString().slice(0, 10) === value;
+}
+function parseSourceDispositionEvent(event) {
+  if (event.kind !== "source-disposition") return ok(null);
+  const metadata = event.metadata;
+  if (!STATUSES.has(metadata.status) || typeof metadata.raw_path !== "string" || typeof metadata.complete_sha256 !== "string" && typeof metadata.body_sha256 !== "string" || typeof metadata.complete_sha256 === "string" && !/^[0-9a-f]{64}$/.test(metadata.complete_sha256) || typeof metadata.body_sha256 === "string" && !/^[0-9a-f]{64}$/.test(metadata.body_sha256) || typeof metadata.reason !== "string") {
+    return err("SOURCE_DISPOSITION_INVALID", { operation_id: event.operation_id });
+  }
+  return ok({
+    operation_id: event.operation_id,
+    occurred_at: event.occurred_at,
+    raw_path: metadata.raw_path,
+    ...typeof metadata.complete_sha256 === "string" ? { complete_sha256: metadata.complete_sha256 } : {},
+    ...typeof metadata.body_sha256 === "string" ? { body_sha256: metadata.body_sha256 } : {},
+    status: metadata.status,
+    reason: metadata.reason,
+    ...typeof metadata.review_after === "string" ? { review_after: metadata.review_after } : {},
+    ...typeof metadata.duplicate_of === "string" ? { duplicate_of: metadata.duplicate_of } : {}
+  });
+}
+function projectSourceDispositions(events) {
+  const dispositions = [];
+  for (const event of events) {
+    const parsed = parseSourceDispositionEvent(event);
+    if (!parsed.ok) return parsed;
+    if (parsed.data) dispositions.push(parsed.data);
+  }
+  return ok(dispositions.sort((a, b) => a.occurred_at.localeCompare(b.occurred_at) || a.operation_id.localeCompare(b.operation_id)));
+}
+async function readSourceDispositions(vault) {
+  const events = await readLogEvents(vault);
+  if (!events.ok) return events;
+  return projectSourceDispositions(events.data);
+}
+function effectiveSourceDisposition(input) {
+  const candidates = input.dispositions.filter((event) => event.raw_path === input.rawPath);
+  const latest = candidates.at(-1);
+  if (!latest) return { lifecycle: "pending", identityMismatch: false };
+  const identityMatches = latest.complete_sha256 ? latest.complete_sha256 === input.completeSha256 : latest.body_sha256 === input.bodySha256;
+  if (!identityMatches) return { lifecycle: "pending", identityMismatch: true, disposition: latest };
+  if (latest.status === "reopened") return { lifecycle: "pending", identityMismatch: false, disposition: latest };
+  if (latest.status === "deferred") {
+    return latest.review_after && latest.review_after > input.today ? { lifecycle: "deferred", identityMismatch: false, disposition: latest } : { lifecycle: "pending", identityMismatch: false, disposition: latest };
+  }
+  return { lifecycle: latest.status, identityMismatch: false, disposition: latest };
+}
+function latestDuplicateTarget(dispositions, rawPath) {
+  const latest = dispositions.filter((event) => event.raw_path === rawPath).at(-1);
+  return latest?.status === "duplicate" ? latest.duplicate_of : void 0;
+}
+async function planSourceDisposition(input) {
+  const target = exactActiveSource(input.rawPath);
+  if (!target.ok) return target;
+  if (!STATUSES.has(input.status)) return err("SOURCE_DISPOSITION_INVALID", { field: "status" });
+  const reason = input.reason.normalize("NFC").trim();
+  if (!reason) return err("SOURCE_DISPOSITION_INVALID", { field: "reason", message: "reason is required" });
+  const sensitive = scanSensitiveContent(reason);
+  if (sensitive.length > 0) return err("SENSITIVE_CONTENT_DETECTED", { findings: sensitive });
+  const today = input.today ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  if (input.status === "deferred" && (!input.reviewAfter || !validDate(input.reviewAfter) || input.reviewAfter <= today)) {
+    return err("SOURCE_DISPOSITION_INVALID", { field: "review_after", message: "deferred requires a future YYYY-MM-DD" });
+  }
+  if (input.status === "duplicate") {
+    if (!input.duplicateOf || input.duplicateOf === input.rawPath) return err("SOURCE_DISPOSITION_INVALID", { field: "duplicate_of" });
+    const duplicateTarget = exactActiveSource(input.duplicateOf);
+    if (!duplicateTarget.ok) return duplicateTarget;
+    const duplicateResolved = await resolveExistingRegularFileInsideVault(input.vault, input.duplicateOf);
+    if (!duplicateResolved.ok) return err("SOURCE_DISPOSITION_INVALID", { field: "duplicate_of", message: "canonical duplicate target not found", cause: duplicateResolved });
+  }
+  const sourceResolved = await resolveExistingRegularFileInsideVault(input.vault, input.rawPath);
+  if (!sourceResolved.ok) return err("FILE_NOT_FOUND", { path: input.rawPath, cause: sourceResolved });
+  const text = await readFile(sourceResolved.data, "utf8");
+  const bodyHash = bodySha256(text);
+  const completeHash = completeSha256(text);
+  const existing = await readSourceDispositions(input.vault);
+  if (!existing.ok) return existing;
+  if (input.status === "duplicate" && input.duplicateOf) {
+    const seen = /* @__PURE__ */ new Set([input.rawPath]);
+    let current = input.duplicateOf;
+    while (current) {
+      if (seen.has(current)) {
+        return err("SOURCE_DISPOSITION_INVALID", {
+          field: "duplicate_of",
+          message: "duplicate dispositions may not create a direct or transitive cycle"
+        });
+      }
+      seen.add(current);
+      current = latestDuplicateTarget(existing.data, current);
+    }
+  }
+  if (input.status === "reopened") {
+    const effective = effectiveSourceDisposition({ dispositions: existing.data, rawPath: input.rawPath, bodySha256: bodyHash, completeSha256: completeHash, today });
+    if (!effective.disposition || effective.lifecycle === "pending") return err("SOURCE_DISPOSITION_INVALID", { field: "status", message: "reopened requires an effective prior disposition" });
+  }
+  const occurredAt = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const operation_id = operationId("source-disposition", [input.rawPath, completeHash, input.status, reason, input.reviewAfter ?? "", input.duplicateOf ?? ""]);
+  const base = {
+    operation_id,
+    occurred_at: occurredAt,
+    raw_path: input.rawPath,
+    complete_sha256: completeHash,
+    status: input.status,
+    reason,
+    ...input.reviewAfter ? { review_after: input.reviewAfter } : {},
+    ...input.duplicateOf ? { duplicate_of: input.duplicateOf } : {}
+  };
+  return ok({ ...base, approval_token: encodeSourceActionApproval({ contract: "source-disposition/v1", ...base }), write: false });
+}
+async function applySourceDisposition(input) {
+  const decoded = decodeSourceActionApproval(input.approve);
+  if (!decoded.ok) return decoded;
+  const occurredAt = typeof decoded.data.occurred_at === "string" ? decoded.data.occurred_at : void 0;
+  const planned = await planSourceDisposition({ ...input, now: occurredAt });
+  if (!planned.ok) return planned;
+  if (planned.data.approval_token !== input.approve) return err("APPROVAL_INVALID", { message: "source disposition approval does not match live state" });
+  const event = await writeLogEvent(input.vault, {
+    schema: "skillwiki-log-event/v1",
+    operation_id: planned.data.operation_id,
+    occurred_at: planned.data.occurred_at,
+    host_id: input.hostId ?? "local",
+    actor: input.actor ?? "skillwiki-cli",
+    kind: "source-disposition",
+    target: input.rawPath,
+    note: input.reason,
+    metadata: {
+      status: input.status,
+      raw_path: input.rawPath,
+      complete_sha256: planned.data.complete_sha256,
+      reason: planned.data.reason,
+      ...input.reviewAfter ? { review_after: input.reviewAfter } : {},
+      ...input.duplicateOf ? { duplicate_of: input.duplicateOf } : {}
+    }
+  });
+  if (!event.ok) return event;
+  return ok({ event_path: event.data.path, operation_id: planned.data.operation_id, created: event.data.created });
+}
+
+// src/utils/source-lifecycle.ts
+function portableDate(value) {
+  if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(value)) return null;
+  const parsed = /* @__PURE__ */ new Date(`${value}T00:00:00Z`);
+  return !Number.isNaN(parsed.getTime()) && parsed.toISOString().slice(0, 10) === value ? value : null;
+}
+function filenameDate(path) {
+  const match = basename(path).match(/^(\d{4}-\d{2}-\d{2})(?:-|$)/);
+  return match ? portableDate(match[1]) : null;
+}
+function captureDate(path, fm) {
+  const ingested = portableDate(fm.ingested);
+  if (ingested) return { captured: ingested, source: "ingested" };
+  const created = portableDate(fm.created);
+  if (created) return { captured: created, source: "created" };
+  const fromName = filenameDate(path);
+  if (fromName) return { captured: fromName, source: "filename" };
+  return { captured: null, source: "unavailable" };
+}
+function ageBucket(captured, today) {
+  if (!captured) return "unknown";
+  const days = Math.floor((Date.parse(`${today}T00:00:00Z`) - Date.parse(`${captured}T00:00:00Z`)) / 864e5);
+  if (!Number.isFinite(days)) return "unknown";
+  if (days <= 7) return "fresh";
+  if (days <= 30) return "aging";
+  if (days <= 90) return "stale";
+  return "old";
+}
+function storageStatus(path) {
+  if (path.startsWith("raw/archived/")) return "archived";
+  if (path.startsWith("raw/duplicates/")) return "duplicate";
+  if (path.startsWith("_archive/raw/")) return "legacy-archived";
+  return "active";
+}
+function supportedSource(path) {
+  return /^raw\/(articles|papers)\/.+\.md$/.test(path) || /^raw\/(archived|duplicates)\/(articles|papers)\/.+\.md$/.test(path) || /^_archive\/raw\/(articles|papers)\/.+\.md$/.test(path);
+}
+function channel(fm, schemaStatus) {
+  if (fm.ingested_by === "wiki-ingest") return "wiki-ingest";
+  if (fm.ingested_by === "proj-work") return "proj-work";
+  if (fm.ingested_by === "manual") return "manual";
+  if (schemaStatus === "legacy" && typeof fm.source === "string") return "web-clipper-legacy";
+  return "unknown";
+}
+function titleFor(path, fm) {
+  if (typeof fm.title === "string" && fm.title.trim()) return fm.title.trim();
+  return basename(path, ".md");
+}
+function classifySchema(fmResult) {
+  if (!fmResult.ok) {
+    return { fm: {}, status: "invalid", issues: ["frontmatter is invalid or incomplete"] };
+  }
+  const fm = fmResult.data;
+  const parsed = RawSourceSchema.safeParse(fm);
+  if (parsed.success) return { fm, status: "valid", issues: [] };
+  const issues = [];
+  if (typeof fm.source === "string" && typeof fm.source_url !== "string") {
+    issues.push("source_url missing; legacy source property found");
+  }
+  if (!portableDate(fm.ingested) && portableDate(fm.created)) issues.push("ingested missing");
+  if (Object.keys(fm).length === 0) issues.push("frontmatter missing");
+  for (const issue of parsed.error.issues.slice(0, 8)) {
+    const message = `${issue.path.join(".") || "frontmatter"}: ${issue.message}`;
+    if (!issues.includes(message)) issues.push(message);
+  }
+  const recognizedLegacy = typeof fm.source === "string" || portableDate(fm.created) !== null;
+  return { fm, status: recognizedLegacy ? "legacy" : "invalid", issues };
+}
+async function scanNonMarkdownSourceFiles(vault) {
+  const targets = [join(vault, "raw", "articles"), join(vault, "raw", "papers")];
+  const out = [];
+  async function walkDir(dir) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walkDir(fullPath);
+      } else if (entry.isFile() && !entry.name.endsWith(".md")) {
+        const rel = relative(vault, fullPath).split(sep).join("/");
+        out.push({ relPath: rel, absPath: fullPath });
+      }
+    }
+  }
+  for (const target of targets) {
+    await walkDir(target);
+  }
+  return out;
+}
+async function inventorySources(input) {
+  const scan = await scanVault(input.vault);
+  if (!scan.ok) return { exitCode: 9, error: scan };
+  const today = input.today ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const legacyPages = scan.data.allMarkdown.filter((page) => page.relPath.startsWith("_archive/raw/"));
+  const pages = [...scan.data.raw, ...legacyPages].filter((page) => supportedSource(page.relPath));
+  const availablePaths = pages.map((page) => page.relPath);
+  const typedPaths = new Set(scan.data.typedKnowledge.map((page) => page.relPath));
+  const otherPages = scan.data.allMarkdown.filter(
+    (page) => !typedPaths.has(page.relPath) && !page.relPath.startsWith("raw/") && !page.relPath.startsWith("_archive/")
+  );
+  const diagnostics = [];
+  const logEvents = await readLogEvents(input.vault);
+  const relocationsResult = logEvents.ok ? projectSourceRelocations(logEvents.data) : logEvents;
+  const relocationProjection = buildSourceRelocationProjection(relocationsResult.ok ? relocationsResult.data : []);
+  const historicalByCurrent = /* @__PURE__ */ new Map();
+  for (const [historical, current] of relocationProjection) {
+    const paths = historicalByCurrent.get(current) ?? [];
+    paths.push(historical);
+    historicalByCurrent.set(current, paths);
+  }
+  for (const paths of historicalByCurrent.values()) paths.sort();
+  const refs = await buildSourceReferenceIndex({
+    typedPages: scan.data.typedKnowledge,
+    otherPages,
+    availableRawPaths: availablePaths,
+    relocationProjection
+  });
+  const dispositionsResult = logEvents.ok ? projectSourceDispositions(logEvents.data) : logEvents;
+  const dispositions = dispositionsResult.ok ? dispositionsResult.data : [];
+  const latestDispositionByPath = /* @__PURE__ */ new Map();
+  for (const disposition of dispositions) latestDispositionByPath.set(disposition.raw_path, disposition);
+  const dispositionReadError = dispositionsResult.ok ? null : dispositionsResult;
+  const items = [];
+  if (!relocationsResult.ok) {
+    diagnostics.push({ raw_path: "meta/log-events", code: "source_relocation_invalid", message: JSON.stringify(relocationsResult) });
+  }
+  for (const unresolved of refs.unresolved) {
+    diagnostics.push({
+      raw_path: unresolved.sourcePath,
+      code: "source_reference_unresolved",
+      message: `${unresolved.kind} reference does not resolve: ${unresolved.target}`
+    });
+  }
+  const occurredAt = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const hostId = input.hostId ?? "local";
+  const actor = input.actor ?? "skillwiki-cli";
+  for (const page of pages) {
+    let text;
+    try {
+      text = await readPage(page);
+    } catch (error) {
+      diagnostics.push({ raw_path: page.relPath, code: "source_unreadable", message: String(error) });
+      const rawPath = page.relPath.split(sep).join("/");
+      const reason = `source unreadable: ${String(error)}`;
+      const stage = "inventory";
+      const opId = operationId("source-skipped", [rawPath, reason, stage, ""]);
+      await writeLogEvent(input.vault, {
+        schema: "skillwiki-log-event/v1",
+        operation_id: opId,
+        occurred_at: occurredAt,
+        host_id: hostId,
+        actor,
+        kind: "source-skipped",
+        target: rawPath,
+        note: reason,
+        metadata: {
+          path: rawPath,
+          reason,
+          stage
+        }
+      });
+      continue;
+    }
+    const classification = classifySchema(extractFrontmatter(text));
+    const date = captureDate(page.relPath, classification.fm);
+    const referencedBy = refs.integratedBy.get(page.relPath) ?? [];
+    const elsewhere = refs.referencedElsewhereBy.get(page.relPath) ?? [];
+    const projectedDisposition = effectiveSourceDisposition({
+      dispositions: latestDispositionByPath.has(page.relPath) ? [latestDispositionByPath.get(page.relPath)] : [],
+      rawPath: page.relPath,
+      bodySha256: bodySha256(text),
+      completeSha256: completeSha256(text),
+      today
+    });
+    const sourceUrl = typeof classification.fm.source_url === "string" ? classification.fm.source_url : typeof classification.fm.source === "string" ? classification.fm.source : null;
+    if (classification.status === "invalid") {
+      diagnostics.push({ raw_path: page.relPath, code: "source_schema_invalid", message: classification.issues.join("; ") });
+    }
+    const storage = storageStatus(page.relPath);
+    items.push({
+      raw_path: page.relPath,
+      current_raw_path: page.relPath,
+      historical_raw_paths: historicalByCurrent.get(page.relPath) ?? [],
+      storage_status: storage,
+      title: titleFor(page.relPath, classification.fm),
+      source_url: sourceUrl,
+      captured: date.captured,
+      date_source: date.source,
+      age_bucket: ageBucket(date.captured, today),
+      capture_channel: channel(classification.fm, classification.status),
+      lifecycle_status: referencedBy.length > 0 ? "integrated" : storage === "duplicate" ? "duplicate" : projectedDisposition.lifecycle,
+      schema_status: classification.status,
+      schema_issues: classification.issues,
+      reference_count: referencedBy.length,
+      referenced_by: referencedBy,
+      referenced_elsewhere: elsewhere,
+      ...projectedDisposition.disposition ? { effective_disposition: projectedDisposition.disposition } : {},
+      ...projectedDisposition.identityMismatch ? { disposition_identity_mismatch: true } : {}
+    });
+  }
+  const nonMarkdownSources = await scanNonMarkdownSourceFiles(input.vault);
+  for (const file of nonMarkdownSources) {
+    let sha2562;
+    try {
+      const bytes = await readFile2(file.absPath);
+      sha2562 = createHash3("sha256").update(bytes).digest("hex");
+    } catch {
+      sha2562 = void 0;
+    }
+    const rawPath = file.relPath.split(sep).join("/");
+    const reason = "non-markdown file in source directory";
+    const stage = "inventory";
+    const opId = operationId("source-skipped", [rawPath, reason, stage, sha2562 ?? ""]);
+    await writeLogEvent(input.vault, {
+      schema: "skillwiki-log-event/v1",
+      operation_id: opId,
+      occurred_at: occurredAt,
+      host_id: hostId,
+      actor,
+      kind: "source-skipped",
+      target: rawPath,
+      note: reason,
+      metadata: {
+        path: rawPath,
+        reason,
+        stage,
+        ...sha2562 ? { sha256: sha2562 } : {}
+      }
+    });
+  }
+  if (dispositionReadError) {
+    diagnostics.push({ raw_path: "meta/log-events", code: "source_disposition_invalid", message: JSON.stringify(dispositionReadError) });
+  }
+  items.sort((a, b) => (b.captured ?? "").localeCompare(a.captured ?? "") || a.raw_path.localeCompare(b.raw_path));
+  return { exitCode: 0, output: { items, diagnostics } };
+}
+function sourceMatches(item, text) {
+  const terms = text.toLocaleLowerCase().split(/\s+/).filter(Boolean);
+  const haystack = `${item.title}
+${item.source_url ?? ""}
+${item.raw_path}`.toLocaleLowerCase();
+  return terms.every((term) => haystack.includes(term));
+}
+
+// src/utils/source-compile.ts
+import { readFile as readFile3 } from "fs/promises";
+var COMPILE_CLAIM_TTL_MS = 2 * 60 * 60 * 1e3;
+var TYPED_PAGE_PATH = /^(entities|concepts|comparisons|queries)\/.+\.md$/;
+var KINDS = /* @__PURE__ */ new Set([
+  "source-compile-claimed",
+  "source-compile-released",
+  "source-compile-published",
+  "source-review"
+]);
+var REVIEW_STATUSES = /* @__PURE__ */ new Set(["open", "accepted", "needs-fix", "dismissed"]);
+function shaField(value) {
+  return typeof value === "string" && /^[0-9a-f]{64}$/.test(value);
+}
+function exactActiveArticleOrPaper(path) {
+  const parsed = classifyRawPath(path);
+  if (!parsed.ok) return parsed;
+  if (parsed.data.storage !== "active" || parsed.data.category !== "articles" && parsed.data.category !== "papers") {
+    return err("SOURCE_COMPILE_TARGET_INVALID", { path, message: "compile turns require an exact active raw article or paper" });
+  }
+  return ok(true);
+}
+function requireInteractive(sessionKind) {
+  if (sessionKind !== "interactive") {
+    return err("SOURCE_COMPILE_SESSION_KIND", { session_kind: sessionKind ?? "unknown", message: "mutating compile/review commands require an interactive session" });
+  }
+  return ok(true);
+}
+function requireReason(reason) {
+  const trimmed = reason.normalize("NFC").trim();
+  if (!trimmed) return err("SOURCE_COMPILE_INVALID", { field: "reason", message: "reason is required" });
+  const sensitive = scanSensitiveContent(trimmed);
+  if (sensitive.length > 0) return err("SENSITIVE_CONTENT_DETECTED", { findings: sensitive });
+  return ok(trimmed);
+}
+function parseSourceCompileEvent(event) {
+  if (!KINDS.has(event.kind)) return ok(null);
+  const metadata = event.metadata;
+  if (typeof metadata.raw_path !== "string") return err("SOURCE_COMPILE_INVALID", { operation_id: event.operation_id });
+  if (event.kind === "source-compile-claimed") {
+    if (!shaField(metadata.complete_sha256) || typeof metadata.expires_at !== "string" || !shaField(metadata.turn_id) || typeof metadata.reason !== "string") {
+      return err("SOURCE_COMPILE_INVALID", { operation_id: event.operation_id });
+    }
+  }
+  if (event.kind === "source-compile-released" && (typeof metadata.reason !== "string" || metadata.complete_sha256 !== void 0 && !shaField(metadata.complete_sha256))) {
+    return err("SOURCE_COMPILE_INVALID", { operation_id: event.operation_id });
+  }
+  if (event.kind === "source-compile-published") {
+    if (!shaField(metadata.complete_sha256) || !shaField(metadata.turn_id) || !Array.isArray(metadata.typed_paths) || metadata.typed_paths.length === 0) {
+      return err("SOURCE_COMPILE_INVALID", { operation_id: event.operation_id });
+    }
+  }
+  if (event.kind === "source-review") {
+    if (!shaField(metadata.turn_id) || !REVIEW_STATUSES.has(metadata.status) || typeof metadata.reason !== "string") {
+      return err("SOURCE_COMPILE_INVALID", { operation_id: event.operation_id });
+    }
+  }
+  return ok({
+    kind: event.kind,
+    operation_id: event.operation_id,
+    occurred_at: event.occurred_at,
+    host_id: event.host_id,
+    actor: event.actor,
+    raw_path: metadata.raw_path,
+    ...typeof metadata.reason === "string" ? { reason: metadata.reason } : {},
+    ...shaField(metadata.complete_sha256) ? { complete_sha256: metadata.complete_sha256 } : {},
+    ...typeof metadata.expires_at === "string" ? { expires_at: metadata.expires_at } : {},
+    ...typeof metadata.session_kind === "string" ? { session_kind: metadata.session_kind } : {},
+    ...shaField(metadata.turn_id) ? { turn_id: metadata.turn_id } : {},
+    ...Array.isArray(metadata.typed_paths) ? { typed_paths: metadata.typed_paths.filter((p) => typeof p === "string") } : {},
+    ...REVIEW_STATUSES.has(metadata.status) ? { status: metadata.status } : {}
+  });
+}
+function projectSourceCompileEvents(events) {
+  const out = [];
+  for (const event of events) {
+    const parsed = parseSourceCompileEvent(event);
+    if (!parsed.ok) return parsed;
+    if (parsed.data) out.push(parsed.data);
+  }
+  return ok(out.sort((a, b) => a.occurred_at.localeCompare(b.occurred_at) || a.operation_id.localeCompare(b.operation_id)));
+}
+async function readSourceCompileEvents(vault) {
+  const events = await readLogEvents(vault);
+  if (!events.ok) return events;
+  return projectSourceCompileEvents(events.data);
+}
+function effectiveCompileState(input) {
+  const mine = input.events.filter((event) => event.raw_path === input.rawPath);
+  const latestWithSha = [...mine].reverse().find((event) => event.complete_sha256);
+  const identityMismatch = Boolean(latestWithSha?.complete_sha256 && latestWithSha.complete_sha256 !== input.completeSha256);
+  if (identityMismatch) return { status: "none", identityMismatch: true, claim: latestWithSha };
+  const latest = mine.at(-1);
+  if (!latest) return { status: "none", identityMismatch: false };
+  const claim = [...mine].reverse().find((event) => event.kind === "source-compile-claimed");
+  const published = [...mine].reverse().find((event) => event.kind === "source-compile-published");
+  const review = [...mine].reverse().find((event) => event.kind === "source-review");
+  if (latest.kind === "source-review") {
+    const status = latest.status === "accepted" || latest.status === "dismissed" ? "review-closed" : "review-open";
+    return { status, identityMismatch: false, claim, published, review };
+  }
+  if (latest.kind === "source-compile-published") {
+    return { status: "review-open", identityMismatch: false, claim, published, review };
+  }
+  if (latest.kind === "source-compile-released") {
+    return { status: "none", identityMismatch: false, claim, published, review };
+  }
+  if (latest.kind === "source-compile-claimed") {
+    const expired = latest.expires_at ? latest.expires_at < input.now : false;
+    return { status: expired ? "none" : "compiling", identityMismatch: false, claim: latest, published, review };
+  }
+  return { status: "none", identityMismatch: false, claim, published, review };
+}
+async function loadContext(input) {
+  const target = exactActiveArticleOrPaper(input.rawPath);
+  if (!target.ok) return target;
+  const resolved = await resolveExistingRegularFileInsideVault(input.vault, input.rawPath);
+  if (!resolved.ok) return err("FILE_NOT_FOUND", { path: input.rawPath, cause: resolved });
+  const text = await readFile3(resolved.data, "utf8");
+  const completeHash = completeSha256(text);
+  const events = await readSourceCompileEvents(input.vault);
+  if (!events.ok) return events;
+  const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const state = effectiveCompileState({ events: events.data, rawPath: input.rawPath, completeSha256: completeHash, now });
+  const inventory = await inventorySources({ vault: input.vault });
+  const item = inventory.output?.items.find((entry) => entry.raw_path === input.rawPath);
+  return ok({
+    text,
+    completeHash,
+    events: events.data,
+    state,
+    lifecycle: item?.lifecycle_status ?? "pending"
+  });
+}
+async function planSourceCompileClaim(input) {
+  const interactive = requireInteractive(input.sessionKind);
+  if (!interactive.ok) return interactive;
+  const reason = requireReason(input.reason);
+  if (!reason.ok) return reason;
+  const ctx = await loadContext(input);
+  if (!ctx.ok) return ctx;
+  if (ctx.data.lifecycle !== "pending") {
+    return err("SOURCE_COMPILE_NOT_PENDING", { path: input.rawPath, lifecycle: ctx.data.lifecycle });
+  }
+  const actor = input.actor ?? "skillwiki-cli";
+  const hostId = input.hostId ?? "local";
+  if (ctx.data.state.status === "compiling" && ctx.data.state.claim) {
+    const held = ctx.data.state.claim;
+    if (held.actor !== actor || held.host_id !== hostId) {
+      return err("SOURCE_COMPILE_CLAIM_HELD", { actor: held.actor, host_id: held.host_id, expires_at: held.expires_at });
+    }
+  }
+  const occurredAt = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const expiresAt = new Date(Date.parse(occurredAt) + COMPILE_CLAIM_TTL_MS).toISOString();
+  const turnId = operationId("source-compile-turn", [input.rawPath, ctx.data.completeHash, occurredAt]);
+  const operation_id = operationId("source-compile-claimed", [input.rawPath, ctx.data.completeHash, actor, hostId, reason.data, occurredAt]);
+  const base = {
+    operation_id,
+    occurred_at: occurredAt,
+    raw_path: input.rawPath,
+    complete_sha256: ctx.data.completeHash,
+    expires_at: expiresAt,
+    turn_id: turnId,
+    contract: "source-compile-claim/v1",
+    actor,
+    host_id: hostId,
+    reason: reason.data,
+    session_kind: input.sessionKind
+  };
+  return ok({
+    operation_id,
+    occurred_at: occurredAt,
+    raw_path: input.rawPath,
+    complete_sha256: ctx.data.completeHash,
+    expires_at: expiresAt,
+    turn_id: turnId,
+    approval_token: encodeSourceActionApproval(base),
+    write: false
+  });
+}
+async function applySourceCompileClaim(input) {
+  const decoded = decodeSourceActionApproval(input.approve);
+  if (!decoded.ok) return decoded;
+  const occurredAt = typeof decoded.data.occurred_at === "string" ? decoded.data.occurred_at : void 0;
+  const planned = await planSourceCompileClaim({ ...input, now: occurredAt });
+  if (!planned.ok) return planned;
+  if (planned.data.approval_token !== input.approve) return err("APPROVAL_INVALID", { message: "source compile claim approval does not match live state" });
+  const event = await writeLogEvent(input.vault, {
+    schema: "skillwiki-log-event/v1",
+    operation_id: planned.data.operation_id,
+    occurred_at: planned.data.occurred_at,
+    host_id: input.hostId ?? "local",
+    actor: input.actor ?? "skillwiki-cli",
+    kind: "source-compile-claimed",
+    target: input.rawPath,
+    note: input.reason,
+    metadata: {
+      raw_path: input.rawPath,
+      complete_sha256: planned.data.complete_sha256,
+      expires_at: planned.data.expires_at,
+      session_kind: input.sessionKind,
+      reason: input.reason.normalize("NFC").trim(),
+      turn_id: planned.data.turn_id
+    }
+  });
+  if (!event.ok) return event;
+  return ok({ event_path: event.data.path, operation_id: planned.data.operation_id, created: event.data.created });
+}
+async function planSourceCompileRelease(input) {
+  const interactive = requireInteractive(input.sessionKind);
+  if (!interactive.ok) return interactive;
+  const reason = requireReason(input.reason);
+  if (!reason.ok) return reason;
+  const ctx = await loadContext(input);
+  if (!ctx.ok) return ctx;
+  if (ctx.data.state.status !== "compiling" || !ctx.data.state.claim) {
+    return err("SOURCE_COMPILE_NOT_HELD", { path: input.rawPath });
+  }
+  const occurredAt = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const operation_id = operationId("source-compile-released", [input.rawPath, ctx.data.completeHash, reason.data, occurredAt]);
+  const base = {
+    operation_id,
+    occurred_at: occurredAt,
+    raw_path: input.rawPath,
+    complete_sha256: ctx.data.completeHash,
+    contract: "source-compile-release/v1",
+    reason: reason.data
+  };
+  return ok({
+    operation_id,
+    occurred_at: occurredAt,
+    raw_path: input.rawPath,
+    complete_sha256: ctx.data.completeHash,
+    approval_token: encodeSourceActionApproval(base),
+    write: false
+  });
+}
+async function applySourceCompileRelease(input) {
+  const decoded = decodeSourceActionApproval(input.approve);
+  if (!decoded.ok) return decoded;
+  const occurredAt = typeof decoded.data.occurred_at === "string" ? decoded.data.occurred_at : void 0;
+  const planned = await planSourceCompileRelease({ ...input, now: occurredAt });
+  if (!planned.ok) return planned;
+  if (planned.data.approval_token !== input.approve) return err("APPROVAL_INVALID", { message: "source compile release approval does not match live state" });
+  const event = await writeLogEvent(input.vault, {
+    schema: "skillwiki-log-event/v1",
+    operation_id: planned.data.operation_id,
+    occurred_at: planned.data.occurred_at,
+    host_id: input.hostId ?? "local",
+    actor: input.actor ?? "skillwiki-cli",
+    kind: "source-compile-released",
+    target: input.rawPath,
+    note: input.reason,
+    metadata: {
+      raw_path: input.rawPath,
+      complete_sha256: planned.data.complete_sha256,
+      reason: input.reason.normalize("NFC").trim()
+    }
+  });
+  if (!event.ok) return event;
+  return ok({ event_path: event.data.path, operation_id: planned.data.operation_id, created: event.data.created });
+}
+function normalizePages(pages) {
+  const cleaned = pages.map((page) => page.replaceAll("\\", "/").trim()).filter(Boolean);
+  if (cleaned.length === 0) return err("SOURCE_COMPILE_PAGES_INVALID", { message: "at least one typed page is required" });
+  for (const page of cleaned) {
+    if (!TYPED_PAGE_PATH.test(page)) return err("SOURCE_COMPILE_PAGES_INVALID", { path: page });
+  }
+  return ok([...new Set(cleaned)]);
+}
+async function planSourceCompilePublished(input) {
+  const interactive = requireInteractive(input.sessionKind);
+  if (!interactive.ok) return interactive;
+  const reason = requireReason(input.reason);
+  if (!reason.ok) return reason;
+  const pages = normalizePages(input.pages);
+  if (!pages.ok) return pages;
+  const ctx = await loadContext(input);
+  if (!ctx.ok) return ctx;
+  if (ctx.data.lifecycle !== "pending" && ctx.data.lifecycle !== "integrated") {
+    return err("SOURCE_COMPILE_NOT_PENDING", { path: input.rawPath, lifecycle: ctx.data.lifecycle });
+  }
+  const turnId = ctx.data.state.claim?.turn_id ?? operationId("source-compile-turn", [input.rawPath, ctx.data.completeHash, input.now ?? ""]);
+  const occurredAt = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const operation_id = operationId("source-compile-published", [input.rawPath, ctx.data.completeHash, pages.data.join(","), occurredAt]);
+  const review_operation_id = operationId("source-review-open", [input.rawPath, turnId, occurredAt]);
+  const base = {
+    operation_id,
+    review_operation_id,
+    occurred_at: occurredAt,
+    raw_path: input.rawPath,
+    complete_sha256: ctx.data.completeHash,
+    typed_paths: pages.data,
+    turn_id: turnId,
+    contract: "source-compile-published/v1",
+    reason: reason.data
+  };
+  return ok({
+    operation_id,
+    review_operation_id,
+    occurred_at: occurredAt,
+    raw_path: input.rawPath,
+    complete_sha256: ctx.data.completeHash,
+    typed_paths: pages.data,
+    turn_id: turnId,
+    approval_token: encodeSourceActionApproval(base),
+    write: false
+  });
+}
+async function applySourceCompilePublished(input) {
+  const decoded = decodeSourceActionApproval(input.approve);
+  if (!decoded.ok) return decoded;
+  const occurredAt = typeof decoded.data.occurred_at === "string" ? decoded.data.occurred_at : void 0;
+  const planned = await planSourceCompilePublished({ ...input, now: occurredAt });
+  if (!planned.ok) return planned;
+  if (planned.data.approval_token !== input.approve) return err("APPROVAL_INVALID", { message: "source compile published approval does not match live state" });
+  const hostId = input.hostId ?? "local";
+  const actor = input.actor ?? "skillwiki-cli";
+  const published = await writeLogEvent(input.vault, {
+    schema: "skillwiki-log-event/v1",
+    operation_id: planned.data.operation_id,
+    occurred_at: planned.data.occurred_at,
+    host_id: hostId,
+    actor,
+    kind: "source-compile-published",
+    target: input.rawPath,
+    note: input.reason,
+    metadata: {
+      raw_path: input.rawPath,
+      complete_sha256: planned.data.complete_sha256,
+      typed_paths: planned.data.typed_paths,
+      turn_id: planned.data.turn_id
+    }
+  });
+  if (!published.ok) return published;
+  const review = await writeLogEvent(input.vault, {
+    schema: "skillwiki-log-event/v1",
+    operation_id: planned.data.review_operation_id ?? operationId("source-review-open", [input.rawPath, planned.data.turn_id ?? "", planned.data.occurred_at]),
+    occurred_at: planned.data.occurred_at,
+    host_id: hostId,
+    actor,
+    kind: "source-review",
+    target: input.rawPath,
+    note: input.reason,
+    metadata: {
+      raw_path: input.rawPath,
+      complete_sha256: planned.data.complete_sha256,
+      turn_id: planned.data.turn_id,
+      status: "open",
+      typed_paths: planned.data.typed_paths,
+      reason: input.reason.normalize("NFC").trim()
+    }
+  });
+  if (!review.ok) return review;
+  return ok({
+    event_path: published.data.path,
+    review_event_path: review.data.path,
+    operation_id: planned.data.operation_id,
+    created: published.data.created
+  });
+}
+async function planSourceReview(input) {
+  const interactive = requireInteractive(input.sessionKind);
+  if (!interactive.ok) return interactive;
+  const reason = requireReason(input.reason);
+  if (!reason.ok) return reason;
+  if (!REVIEW_STATUSES.has(input.status)) return err("SOURCE_COMPILE_INVALID", { field: "status" });
+  const ctx = await loadContext(input);
+  if (!ctx.ok) return ctx;
+  const turnId = ctx.data.state.review?.turn_id ?? ctx.data.state.published?.turn_id ?? ctx.data.state.claim?.turn_id;
+  if (!turnId) return err("SOURCE_COMPILE_REVIEW_MISSING", { path: input.rawPath });
+  const occurredAt = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const operation_id = operationId("source-review", [input.rawPath, turnId, input.status, reason.data, occurredAt]);
+  const typedPaths = ctx.data.state.review?.typed_paths ?? ctx.data.state.published?.typed_paths;
+  const base = {
+    operation_id,
+    occurred_at: occurredAt,
+    raw_path: input.rawPath,
+    complete_sha256: ctx.data.completeHash,
+    turn_id: turnId,
+    status: input.status,
+    contract: "source-review/v1",
+    reason: reason.data
+  };
+  return ok({
+    operation_id,
+    occurred_at: occurredAt,
+    raw_path: input.rawPath,
+    complete_sha256: ctx.data.completeHash,
+    turn_id: turnId,
+    status: input.status,
+    typed_paths: typedPaths,
+    approval_token: encodeSourceActionApproval(base),
+    write: false
+  });
+}
+async function applySourceReview(input) {
+  const decoded = decodeSourceActionApproval(input.approve);
+  if (!decoded.ok) return decoded;
+  const occurredAt = typeof decoded.data.occurred_at === "string" ? decoded.data.occurred_at : void 0;
+  const planned = await planSourceReview({ ...input, now: occurredAt });
+  if (!planned.ok) return planned;
+  if (planned.data.approval_token !== input.approve) return err("APPROVAL_INVALID", { message: "source review approval does not match live state" });
+  const event = await writeLogEvent(input.vault, {
+    schema: "skillwiki-log-event/v1",
+    operation_id: planned.data.operation_id,
+    occurred_at: planned.data.occurred_at,
+    host_id: input.hostId ?? "local",
+    actor: input.actor ?? "skillwiki-cli",
+    kind: "source-review",
+    target: input.rawPath,
+    note: input.reason,
+    metadata: {
+      raw_path: input.rawPath,
+      complete_sha256: planned.data.complete_sha256,
+      turn_id: planned.data.turn_id,
+      status: input.status,
+      ...planned.data.typed_paths ? { typed_paths: planned.data.typed_paths } : {},
+      reason: input.reason.normalize("NFC").trim()
+    }
+  });
+  if (!event.ok) return event;
+  return ok({ event_path: event.data.path, operation_id: planned.data.operation_id, created: event.data.created });
+}
+async function listCompileStatus(input) {
+  const inventory = await inventorySources({ vault: input.vault });
+  if (!inventory.output) return err("SOURCE_COMPILE_INVENTORY_FAILED", { cause: inventory.error });
+  const events = await readSourceCompileEvents(input.vault);
+  if (!events.ok) return events;
+  const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const items = [];
+  for (const item of inventory.output.items) {
+    const textResult = await resolveExistingRegularFileInsideVault(input.vault, item.raw_path);
+    if (!textResult.ok) continue;
+    const text = await readFile3(textResult.data, "utf8");
+    const state = effectiveCompileState({
+      events: events.data,
+      rawPath: item.raw_path,
+      completeSha256: completeSha256(text),
+      now
+    });
+    if (state.status === "none" && !state.identityMismatch) continue;
+    if (state.status === "review-closed") continue;
+    items.push({ raw_path: item.raw_path, status: state.status, identityMismatch: state.identityMismatch });
+  }
+  return ok({ items });
+}
+async function listSourceReviews(input) {
+  const events = await readSourceCompileEvents(input.vault);
+  if (!events.ok) return events;
+  const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const byPath = /* @__PURE__ */ new Map();
+  for (const event of events.data) {
+    const list = byPath.get(event.raw_path) ?? [];
+    list.push(event);
+    byPath.set(event.raw_path, list);
+  }
+  const items = [];
+  for (const [rawPath, pathEvents] of byPath) {
+    const latestSha = [...pathEvents].reverse().find((event) => event.complete_sha256)?.complete_sha256 ?? "0".repeat(64);
+    const state = effectiveCompileState({ events: pathEvents, rawPath, completeSha256: latestSha, now });
+    if (state.status !== "review-open" || !state.review?.status) continue;
+    items.push({ raw_path: rawPath, status: state.review.status, typed_paths: state.review.typed_paths });
+  }
+  return ok({ items });
+}
+
+// src/commands/sources.ts
+function validDate2(value) {
+  return /^\d{4}-\d{2}-\d{2}$/.test(value) && (/* @__PURE__ */ new Date(`${value}T00:00:00Z`)).toISOString().slice(0, 10) === value;
+}
+function validate(input) {
+  if (input.since && !validDate2(input.since)) return err("SOURCES_DATE_INVALID", { field: "since", value: input.since });
+  if (input.olderThan !== void 0 && (!Number.isInteger(input.olderThan) || input.olderThan < 0)) {
+    return err("SOURCES_AGE_INVALID", { field: "older-than", value: input.olderThan });
+  }
+  if (input.limit !== void 0 && (!Number.isInteger(input.limit) || input.limit < 1 || input.limit > 1e4)) {
+    return err("SOURCES_LIMIT_INVALID", { value: input.limit });
+  }
+  if (input.scope && !["articles", "papers", "all"].includes(input.scope)) {
+    return err("SOURCES_SCOPE_INVALID", { value: input.scope });
+  }
+  if (input.sort && !["newest", "oldest"].includes(input.sort)) {
+    return err("SOURCES_SORT_INVALID", { value: input.sort });
+  }
+  return ok(true);
+}
+function channelMatches(item, selected) {
+  if (!selected) return true;
+  const channel2 = item.capture_channel;
+  if (selected === "manual") return channel2 === "manual" || channel2 === "web-clipper-legacy";
+  return channel2 === selected;
+}
+function summary(items) {
+  return {
+    total: items.length,
+    pending: items.filter((item) => item.lifecycle_status === "pending").length,
+    integrated: items.filter((item) => item.lifecycle_status === "integrated").length,
+    valid: items.filter((item) => item.schema_status === "valid").length,
+    legacy: items.filter((item) => item.schema_status === "legacy").length,
+    invalid: items.filter((item) => item.schema_status === "invalid").length,
+    fresh: items.filter((item) => item.age_bucket === "fresh").length,
+    aging: items.filter((item) => item.age_bucket === "aging").length,
+    stale: items.filter((item) => item.age_bucket === "stale").length,
+    old: items.filter((item) => item.age_bucket === "old").length,
+    unknown_age: items.filter((item) => item.age_bucket === "unknown").length
+  };
+}
+async function runSourcesPending(input) {
+  const validated = validate(input);
+  if (!validated.ok) return { exitCode: ExitCode.USAGE, result: validated };
+  const inventory = await inventorySources({ vault: input.vault, today: input.today });
+  if (!inventory.output) {
+    return { exitCode: inventory.exitCode, result: inventory.error };
+  }
+  const today = input.today ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const cutoff = input.olderThan === void 0 ? null : new Date(Date.parse(`${today}T00:00:00Z`) - input.olderThan * 864e5).toISOString().slice(0, 10);
+  let items = inventory.output.items.filter((item) => {
+    if (!input.includeIntegrated && item.lifecycle_status !== "pending") return false;
+    if (!input.includeArchived && item.storage_status === "archived") return false;
+    if (!input.includeDuplicates && item.storage_status === "duplicate") return false;
+    if (!input.includeLegacyArchived && item.storage_status === "legacy-archived") return false;
+    if (input.scope && input.scope !== "all" && !item.raw_path.startsWith(`raw/${input.scope}/`) && !item.raw_path.includes(`/${input.scope}/`)) return false;
+    if (input.since && (!item.captured || item.captured < input.since)) return false;
+    if (cutoff && (!item.captured || item.captured > cutoff)) return false;
+    if (input.match && !sourceMatches(item, input.match)) return false;
+    if (!channelMatches(item, input.ingestedBy)) return false;
+    return true;
+  });
+  if ((input.sort ?? "newest") === "oldest") {
+    items = items.sort((a, b) => (a.captured ?? "9999-99-99").localeCompare(b.captured ?? "9999-99-99") || a.raw_path.localeCompare(b.raw_path));
+  }
+  const counts = summary(items);
+  const unbounded = input.all === true;
+  items = items.slice(0, unbounded ? void 0 : input.limit ?? 50);
+  const compileEvents = await readSourceCompileEvents(input.vault);
+  if (compileEvents.ok && compileEvents.data.length > 0) {
+    const now = `${today}T00:00:00.000Z`;
+    items = await Promise.all(items.map(async (item) => {
+      const resolved = await resolveExistingRegularFileInsideVault(input.vault, item.raw_path);
+      if (!resolved.ok) return item;
+      const text = await readFile4(resolved.data, "utf8");
+      const state = effectiveCompileState({
+        events: compileEvents.data,
+        rawPath: item.raw_path,
+        completeSha256: completeSha256(text),
+        now
+      });
+      return {
+        ...item,
+        ...state.status !== "none" ? { compile_status: state.status } : {},
+        ...state.review?.status ? { review_status: state.review.status } : {}
+      };
+    }));
+  }
+  const visibleRawPaths = new Set(items.map((item) => item.raw_path));
+  const diagnostics = inventory.output.diagnostics.filter(
+    (diagnostic) => visibleRawPaths.has(diagnostic.raw_path) || diagnostic.raw_path === "meta/log-events"
+  );
+  const humanHint = items.length === 0 ? "no pending sources" : items.map((item) => `${item.captured ?? "unknown-date"} ${item.schema_status} ${item.raw_path} \u2014 ${item.title}`).join("\n");
+  return { exitCode: ExitCode.OK, result: ok({ items, summary: counts, diagnostics, humanHint }) };
+}
+
+export {
+  encodeSourceActionApproval,
+  decodeSourceActionApproval,
+  planSourceDisposition,
+  applySourceDisposition,
+  inventorySources,
+  planSourceCompileClaim,
+  applySourceCompileClaim,
+  planSourceCompileRelease,
+  applySourceCompileRelease,
+  planSourceCompilePublished,
+  applySourceCompilePublished,
+  planSourceReview,
+  applySourceReview,
+  listCompileStatus,
+  listSourceReviews,
+  runSourcesPending
+};