skillwiki 0.10.21 → 0.10.23

package/dist/chunk-EQPU2BPM.js

@@ -0,0 +1,468 @@
+#!/usr/bin/env node
+import {
+  buildSourceReferenceIndex,
+  buildSourceRelocationProjection,
+  classifyRawPath,
+  operationId,
+  projectSourceRelocations,
+  readLogEvents,
+  resolveExistingRegularFileInsideVault,
+  writeLogEvent
+} from "./chunk-QNTBNNEL.js";
+import {
+  extractFrontmatter,
+  readPage,
+  scanSensitiveContent,
+  scanVault,
+  splitFrontmatter
+} from "./chunk-6ZDKTNLA.js";
+import {
+  ExitCode,
+  RawSourceSchema,
+  err,
+  ok
+} from "./chunk-C2DKFJFA.js";
+
+// src/utils/source-lifecycle.ts
+import { basename } 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 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}`
+    });
+  }
+  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) });
+      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 } : {}
+    });
+  }
+  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/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 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,
+  runSourcesPending
+};

package/dist/{chunk-GNS2ZV5P.js → chunk-PQG26AGJ.js}

@@ -5,7 +5,7 @@ import {
   err,
   isVaultSyncKey,
   ok
-} from "./chunk-Y6KRDGI2.js";
+} from "./chunk-C2DKFJFA.js";
 
 // src/utils/dotenv.ts
 import { readFile, writeFile, mkdir } from "fs/promises";