@litfamily/litopencode 1.0.0

package/skills/visual-qa/scripts/review.mjs

@@ -0,0 +1,188 @@
+const hashPattern = /^sha256:[a-f0-9]{64}$/u;
+const inputKeys = ["design_contract", "evidence_manifest", "source", "capture"];
+
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function timestamp(value) {
+  const time = Date.parse(value);
+  return Number.isFinite(time) ? time : undefined;
+}
+
+// BLOCKED means a capability the review needed was absent: no second reviewer, a
+// review that never finished, or bytes that could not be trusted. FAIL means the
+// review ran to completion and rejected the work. The two are not
+// interchangeable, because a BLOCKED receipt asks for a capability while a FAIL
+// receipt asks for a fix. BLOCKED outranks FAIL, so every absent-capability check
+// below runs before the two verdict checks.
+function blocked(code, reason) {
+  return { code, independent: false, reason, verdict: "BLOCKED" };
+}
+
+function failed(code, reason) {
+  return { code, independent: true, reason, verdict: "FAIL" };
+}
+
+function exact(value, keys) {
+  return object(value) && Object.keys(value).every((key) => keys.includes(key));
+}
+
+function validFinding(finding) {
+  return (
+    exact(finding, ["code", "severity", "evidence_pointers", "message"]) &&
+    typeof finding.code === "string" &&
+    finding.code.length > 0 &&
+    ["critical", "high", "medium", "low", "info"].includes(finding.severity) &&
+    typeof finding.message === "string" &&
+    finding.message.length > 0 &&
+    Array.isArray(finding.evidence_pointers) &&
+    finding.evidence_pointers.length > 0 &&
+    finding.evidence_pointers.every(
+      (pointer) =>
+        exact(pointer, ["path", "hash"]) &&
+        typeof pointer.path === "string" &&
+        pointer.path.length > 0 &&
+        hashPattern.test(pointer.hash)
+    )
+  );
+}
+
+export function validateReviewReceipt(receipt) {
+  const errors = [];
+  if (!object(receipt)) return { ok: false, errors: ["receipt must be an object"] };
+  const receiptKeys = [
+    "schema_id", "review_id", "reviewer_id", "fresh_context_id", "reviewer_capability_class",
+    "input_hashes", "reviewed_inventory", "findings", "confidence", "independence_assertion",
+    "started_at", "ended_at", "timeout_seconds", "timed_out", "cancelled", "cancellation_reason",
+    "round", "verdict"
+  ];
+  if (!exact(receipt, receiptKeys)) errors.push("receipt contains unknown fields");
+  if (receipt.schema_id !== "litfamily.review-receipt/v1alpha1") errors.push("schema_id must be exact v1alpha1");
+  for (const field of ["review_id", "reviewer_id", "fresh_context_id", "reviewer_capability_class"]) {
+    if (typeof receipt[field] !== "string" || receipt[field].length === 0) errors.push(`${field} is required`);
+  }
+  if (
+    !exact(receipt.input_hashes, inputKeys) ||
+    inputKeys.some((key) => !hashPattern.test(receipt.input_hashes[key]))
+  ) {
+    errors.push("input_hashes must contain all immutable hashes");
+  }
+  if (
+    !Array.isArray(receipt.reviewed_inventory) ||
+    receipt.reviewed_inventory.length === 0 ||
+    receipt.reviewed_inventory.length > 10000 ||
+    receipt.reviewed_inventory.some(
+      (item) =>
+        !exact(item, ["id", "kind", "status"]) ||
+        typeof item.id !== "string" ||
+        item.id.length === 0 ||
+        typeof item.kind !== "string" ||
+        item.kind.length === 0 ||
+        !["captured", "not_applicable", "accepted_exception", "blocked"].includes(item.status)
+    ) ||
+    new Set(receipt.reviewed_inventory.map((item) => item.id)).size !== receipt.reviewed_inventory.length
+  ) errors.push("reviewed_inventory must be finite, non-empty, and unique");
+  if (
+    !Array.isArray(receipt.findings) ||
+    receipt.findings.length > 10000 ||
+    receipt.findings.some((finding) => !validFinding(finding))
+  ) errors.push("findings must be finite and contain evidence pointers");
+  if (!Number.isFinite(receipt.confidence) || receipt.confidence < 0 || receipt.confidence > 1) {
+    errors.push("confidence must be between zero and one");
+  }
+  const assertion = receipt.independence_assertion;
+  if (
+    !exact(assertion, ["fresh_context", "same_immutable_inputs", "other_draft_received", "other_verdict_received"]) ||
+    assertion.fresh_context !== true ||
+    assertion.same_immutable_inputs !== true ||
+    assertion.other_draft_received !== false ||
+    assertion.other_verdict_received !== false
+  ) errors.push("independence_assertion must exactly attest independent context");
+  const started = timestamp(receipt.started_at);
+  const ended = timestamp(receipt.ended_at);
+  if (started === undefined || ended === undefined || ended < started) errors.push("review timestamps are invalid");
+  if (!Number.isFinite(receipt.timeout_seconds) || receipt.timeout_seconds <= 0 || receipt.timeout_seconds > 3600) {
+    errors.push("timeout_seconds must be finite and bounded");
+  } else if (started !== undefined && ended !== undefined && ended - started > receipt.timeout_seconds * 1000) {
+    errors.push("review elapsed time exceeds timeout_seconds");
+  }
+  if (typeof receipt.timed_out !== "boolean" || typeof receipt.cancelled !== "boolean") {
+    errors.push("timed_out and cancelled must be boolean");
+  }
+  if (
+    receipt.cancelled &&
+    (typeof receipt.cancellation_reason !== "string" || receipt.cancellation_reason.length === 0)
+  ) errors.push("cancelled review requires cancellation_reason");
+  if (!receipt.cancelled && receipt.cancellation_reason !== null) {
+    errors.push("active review cancellation_reason must be null");
+  }
+  if (!Number.isInteger(receipt.round) || receipt.round < 1 || receipt.round > 2) {
+    errors.push("round must be one or two");
+  }
+  if (!["PASS", "REVISE", "FAIL", "BLOCKED"].includes(receipt.verdict)) errors.push("verdict is invalid");
+  return { ok: errors.length === 0, errors };
+}
+
+function sameInputs(first, second) {
+  return inputKeys.every((key) => first.input_hashes[key] === second.input_hashes[key]);
+}
+
+export function validateReviewIndependence(
+  receipts,
+  { acceptedExceptions = [], now = new Date().toISOString(), maximumAgeSeconds = 600 } = {}
+) {
+  if (!Array.isArray(receipts) || receipts.length !== 2) {
+    return blocked("BLOCKED_INDEPENDENT_REVIEW_UNAVAILABLE", "exactly two fresh review receipts are required");
+  }
+  const validations = receipts.map(validateReviewReceipt);
+  if (receipts.some((receipt) => receipt?.timed_out === true)) {
+    return blocked("BLOCKED_REVIEW_TIMEOUT", "an independent review timed out");
+  }
+  if (receipts.some((receipt) => receipt?.cancelled === true)) {
+    return blocked("BLOCKED_REVIEW_CANCELLED", "an independent review was cancelled");
+  }
+  if (validations.some((result) => !result.ok)) {
+    return blocked("BLOCKED_SCHEMA_OR_PAYLOAD_MISMATCH", "a review receipt is invalid");
+  }
+  const [first, second] = receipts;
+  if (
+    first.review_id === second.review_id ||
+    first.reviewer_id === second.reviewer_id ||
+    first.fresh_context_id === second.fresh_context_id ||
+    first.reviewer_capability_class === second.reviewer_capability_class
+  ) return blocked("BLOCKED_INDEPENDENT_REVIEW_UNAVAILABLE", "review identities, contexts, and capabilities must differ");
+  if (!sameInputs(first, second)) {
+    return blocked("BLOCKED_SCHEMA_OR_PAYLOAD_MISMATCH", "reviewers must inspect identical immutable inputs");
+  }
+  const nowTime = timestamp(now);
+  if (
+    nowTime === undefined ||
+    receipts.some((receipt) => {
+      const ended = timestamp(receipt.ended_at);
+      return ended === undefined || nowTime < ended || nowTime - ended > maximumAgeSeconds * 1000;
+    })
+  ) return blocked("BLOCKED_EVIDENCE_STALE", "review receipts are stale");
+  if (receipts.some((receipt) => receipt.verdict !== "PASS")) {
+    return failed("FAIL_REVIEW_VERDICT", "both independent review receipts must declare PASS");
+  }
+  const gatingFindings = receipts.flatMap((receipt) =>
+    receipt.findings.filter((finding) => ["critical", "high"].includes(finding.severity))
+  );
+  // An exception only forgives while it is still current. This filter lives here, not in the caller,
+  // because this function is an exported entry point with a permissive default: a caller that hands
+  // it raw contract.accepted_exceptions -- the obvious thing to pass -- would otherwise have an
+  // undated or long-expired exception silently forgive a critical finding and return PASS.
+  const currentExceptions = acceptedExceptions.filter((exception) => {
+    const expiry = timestamp(exception?.expires_at);
+    return expiry !== undefined && nowTime <= expiry;
+  });
+  if (
+    gatingFindings.some(
+      (finding) => !currentExceptions.some((exception) => exception.id === finding.code)
+    )
+  ) {
+    return failed("FAIL_REVIEW_GATING_FINDING", "an independent review reports an unaccepted gating finding");
+  }
+  return { independent: true, verdict: "PASS" };
+}

package/skills/visual-qa/scripts/stdin-json.mjs

@@ -0,0 +1,16 @@
+// Bounded stdin reader owned by this skill, used by the offline validator CLI.
+import { parseBoundedJson } from "./bounded-json.mjs";
+
+export const maximumStdinBytes = 1024 * 1024;
+
+export async function readBoundedJsonStream(stream, { maxBytes = maximumStdinBytes } = {}) {
+  const chunks = [];
+  let total = 0;
+  for await (const chunk of stream) {
+    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    total += bytes.length;
+    if (total > maxBytes) throw new Error(`stdin size ${total} bytes exceeds ${maxBytes} bytes`);
+    chunks.push(bytes);
+  }
+  return parseBoundedJson(Buffer.concat(chunks, total), { maxBytes });
+}

package/skills/visual-qa/scripts/strict-json.mjs

@@ -0,0 +1,102 @@
+// Strict JSON reader owned by this skill: duplicate keys, NUL bytes, and trailing
+// data are refused so an evidence payload cannot be read two different ways.
+function fail(message, offset) {
+  throw new Error(`Malformed JSON at byte ${Buffer.byteLength(message.slice(0, offset), "utf8")}: ${message}`);
+}
+
+export function parseStrictJson(text) {
+  if (typeof text !== "string") throw new TypeError("JSON payload must be a UTF-8 string");
+  if (text.includes("\0")) throw new Error("Malformed JSON: NUL bytes are forbidden");
+  let index = 0;
+
+  function whitespace() {
+    while (index < text.length && /\s/u.test(text[index])) index += 1;
+  }
+
+  function string() {
+    const start = index;
+    index += 1;
+    while (index < text.length) {
+      if (text[index] === '"') {
+        index += 1;
+        try {
+          return JSON.parse(text.slice(start, index));
+        } catch {
+          fail("invalid string escape", start);
+        }
+      }
+      if (text[index] === "\\") index += 1;
+      index += 1;
+    }
+    fail("unterminated string", start);
+  }
+
+  function value() {
+    whitespace();
+    const token = text[index];
+    if (token === '"') return string();
+    if (token === "{") return object();
+    if (token === "[") return array();
+    const match = text.slice(index).match(/^(?:-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?|true|false|null)/u);
+    if (match === null) fail("invalid value", index);
+    index += match[0].length;
+    return JSON.parse(match[0]);
+  }
+
+  function object() {
+    index += 1;
+    whitespace();
+    const output = {};
+    const keys = new Set();
+    if (text[index] === "}") {
+      index += 1;
+      return output;
+    }
+    while (index < text.length) {
+      if (text[index] !== '"') fail("object key must be a string", index);
+      const key = string();
+      if (keys.has(key)) throw new Error(`Malformed JSON: duplicate key ${JSON.stringify(key)}`);
+      keys.add(key);
+      whitespace();
+      if (text[index] !== ":") fail("missing colon", index);
+      index += 1;
+      output[key] = value();
+      whitespace();
+      if (text[index] === "}") {
+        index += 1;
+        return output;
+      }
+      if (text[index] !== ",") fail("missing comma", index);
+      index += 1;
+      whitespace();
+    }
+    fail("unterminated object", index);
+  }
+
+  function array() {
+    index += 1;
+    whitespace();
+    const output = [];
+    if (text[index] === "]") {
+      index += 1;
+      return output;
+    }
+    while (index < text.length) {
+      output.push(value());
+      whitespace();
+      if (text[index] === "]") {
+        index += 1;
+        return output;
+      }
+      if (text[index] !== ",") fail("missing comma", index);
+      index += 1;
+      whitespace();
+    }
+    fail("unterminated array", index);
+  }
+
+  const parsed = value();
+  whitespace();
+  if (index !== text.length) fail("trailing non-whitespace", index);
+  return parsed;
+}

package/skills/visual-qa/scripts/tui.mjs

@@ -0,0 +1,149 @@
+const borderConnections = Object.freeze({
+  "┌": "RD",
+  "┐": "LD",
+  "└": "RU",
+  "┘": "LU",
+  "├": "RUD",
+  "┤": "LUD",
+  "┬": "LRD",
+  "┴": "LRU",
+  "┼": "LRUD",
+  "─": "LR",
+  "│": "UD"
+});
+const segmenter = new Intl.Segmenter("und", { granularity: "grapheme" });
+
+function isWide(codePoint) {
+  return (
+    codePoint >= 0x1100 &&
+    (codePoint <= 0x115f ||
+      codePoint === 0x2329 ||
+      codePoint === 0x232a ||
+      (codePoint >= 0x2e80 && codePoint <= 0xa4cf) ||
+      (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+      (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+      (codePoint >= 0xfe10 && codePoint <= 0xfe6f) ||
+      (codePoint >= 0xff01 && codePoint <= 0xff60) ||
+      (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+      (codePoint >= 0x1f300 && codePoint <= 0x1faff) ||
+      (codePoint >= 0x20000 && codePoint <= 0x3fffd))
+  );
+}
+
+function graphemeWidth(text, ambiguousWidth) {
+  if (/^\p{Mark}+$/u.test(text)) return 0;
+  if (text.includes("\u200d") || /\p{Extended_Pictographic}/u.test(text)) return 2;
+  const first = text.codePointAt(0);
+  if (first !== undefined && isWide(first)) return 2;
+  if (ambiguousWidth === 2 && /[·§±×÷α-ωΑ-Ω]/u.test(text)) return 2;
+  return 1;
+}
+
+function consumeStringControl(text, start) {
+  for (let index = start; index < text.length; index += 1) {
+    if (text[index] === "\u0007" || text[index] === "\u009c") return index + 1;
+    if (text[index] === "\u001b" && text[index + 1] === "\\") return index + 2;
+  }
+  return text.length;
+}
+
+function consumeCsi(text, start) {
+  for (let index = start; index < text.length; index += 1) {
+    const code = text.charCodeAt(index);
+    if (code >= 0x40 && code <= 0x7e) return index + 1;
+  }
+  return text.length;
+}
+
+function sanitize(text) {
+  let output = "";
+  for (let index = 0; index < text.length;) {
+    const code = text.charCodeAt(index);
+    if (text[index] === "\u001b") {
+      const next = text[index + 1];
+      if (next === "]" || next === "P" || next === "^" || next === "_" || next === "X") {
+        index = consumeStringControl(text, index + 2);
+      } else if (next === "[") {
+        index = consumeCsi(text, index + 2);
+      } else {
+        index += Math.min(2, text.length - index);
+      }
+      continue;
+    }
+    if ([0x90, 0x98, 0x9d, 0x9e, 0x9f].includes(code)) {
+      index = consumeStringControl(text, index + 1);
+      continue;
+    }
+    if (code === 0x9b) {
+      index = consumeCsi(text, index + 1);
+      continue;
+    }
+    if ((code >= 0 && code < 0x20 && code !== 0x0a && code !== 0x09) || (code >= 0x7f && code <= 0x9f)) {
+      index += 1;
+      continue;
+    }
+    output += text[index];
+    index += 1;
+  }
+  return output;
+}
+
+function inspectRow(text, ambiguousWidth) {
+  const graphemes = [...segmenter.segment(text)].map(({ segment }) => ({
+    text: segment,
+    width: graphemeWidth(segment, ambiguousWidth)
+  }));
+  return { graphemes, text, width: graphemes.reduce((total, item) => total + item.width, 0) };
+}
+
+function borderFindings(rows) {
+  const grid = rows.map((row) => {
+    const cells = new Map();
+    let column = 0;
+    for (const grapheme of row.graphemes) {
+      if (borderConnections[grapheme.text]) cells.set(column, grapheme.text);
+      column += grapheme.width;
+    }
+    return cells;
+  });
+  const directions = Object.freeze({
+    L: [0, -1, "R"],
+    R: [0, 1, "L"],
+    U: [-1, 0, "D"],
+    D: [1, 0, "U"]
+  });
+  const broken = [];
+  for (let row = 0; row < grid.length; row += 1) {
+    for (const [column, character] of grid[row]) {
+      const connections = borderConnections[character];
+      for (const direction of connections) {
+        const [dr, dc, opposite] = directions[direction];
+        const neighbor = grid[row + dr]?.get(column + dc);
+        if (!(borderConnections[neighbor]?.includes(opposite))) {
+          broken.push({ column, direction, row });
+        }
+      }
+    }
+  }
+  const bordered = rows.filter((_, index) => grid[index].size > 0);
+  const widthMismatch = bordered.length > 0 && bordered.some((row) => row.width !== bordered[0].width);
+  if (broken.length === 0 && !widthMismatch) return [];
+  return [{
+    code: "TUI_BORDER_TOPOLOGY_BROKEN",
+    evidence: { broken_edges: broken.slice(0, 100), width_mismatch: widthMismatch },
+    severity: "high"
+  }];
+}
+
+export function inspectTui(text, { ambiguousWidth = 1 } = {}) {
+  if (typeof text !== "string") throw new TypeError("TUI input must be a string");
+  if (ambiguousWidth !== 1 && ambiguousWidth !== 2) throw new Error("ambiguousWidth must be 1 or 2");
+  const sanitized = sanitize(text);
+  const rows = sanitized.split("\n").map((row) => inspectRow(row, ambiguousWidth));
+  return {
+    controlSequencesInert: !/[\u001b\u0000-\u0008\u000b-\u001f\u007f-\u009f]/u.test(sanitized),
+    findings: borderFindings(rows),
+    rows,
+    sanitized
+  };
+}

package/skills/visual-qa/scripts/visual-qa.mjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+import { readBoundedJsonFile } from "./bounded-json.mjs";
+import { readBoundedJsonStream } from "./stdin-json.mjs";
+import { inspectUiArtifact } from "./artifact.mjs";
+import {
+  evaluateCapabilityBlocks,
+  evaluateRendererOwnership,
+  visualQaBlockedCodes,
+  visualQaFailCodes
+} from "./capabilities.mjs";
+import { validateEvidenceManifestText, validateReviewReceiptText } from "./contract-text.mjs";
+import {
+  completionConditionsForTier,
+  evaluateEvidenceFreshness,
+  evaluateTierCompletion,
+  validateEvidenceManifest
+} from "./evidence.mjs";
+import {
+  canonicalEvidenceManifestBytes,
+  evaluateEvidenceManifest,
+  hashBytes,
+  hashCanonicalValue,
+  hashCaptureArtifacts
+} from "./evidence-evaluate.mjs";
+import { inspectPng } from "./png.mjs";
+import { comparePngs, decodePng } from "./png-decode.mjs";
+import {
+  validateReviewIndependence,
+  validateReviewReceipt
+} from "./review.mjs";
+import { inspectTui } from "./tui.mjs";
+
+export {
+  completionConditionsForTier,
+  comparePngs,
+  canonicalEvidenceManifestBytes,
+  decodePng,
+  evaluateCapabilityBlocks,
+  evaluateEvidenceManifest,
+  evaluateRendererOwnership,
+  hashCanonicalValue,
+  hashBytes,
+  hashCaptureArtifacts,
+  evaluateEvidenceFreshness,
+  evaluateTierCompletion,
+  inspectPng,
+  inspectUiArtifact,
+  inspectTui,
+  validateReviewIndependence,
+  validateReviewReceipt,
+  validateReviewReceiptText,
+  validateEvidenceManifest,
+  validateEvidenceManifestText,
+  visualQaBlockedCodes,
+  visualQaFailCodes
+};
+
+export function readBoundedEvidenceManifestFile(filePath, options) {
+  return readBoundedJsonFile(filePath, { ...options, validate: validateEvidenceManifest });
+}
+
+export function readBoundedReviewReceiptFile(filePath, options) {
+  return readBoundedJsonFile(filePath, { ...options, validate: validateReviewReceipt });
+}
+
+export async function runVisualQaCli(argv = process.argv.slice(2)) {
+  if (argv.length !== 1) {
+    throw new Error("Usage: node visual-qa.mjs <capabilities|ownership|freshness|tier|review|png|tui>");
+  }
+  const input = await readBoundedJsonStream(process.stdin);
+  if (argv[0] === "capabilities") return evaluateCapabilityBlocks(input);
+  if (argv[0] === "ownership") return evaluateRendererOwnership(input);
+  if (argv[0] === "freshness") return evaluateEvidenceFreshness(input);
+  if (argv[0] === "tier") return evaluateTierCompletion(input);
+  if (argv[0] === "review") return validateReviewIndependence(input);
+  if (argv[0] === "png") return inspectPng(Buffer.from(input.base64, "base64"));
+  if (argv[0] === "tui") return inspectTui(input.text, input.options);
+  throw new Error(`Unknown visual-QA operation: ${argv[0]}`);
+}
+
+if (process.argv[1] !== undefined && pathToFileURL(process.argv[1]).href === import.meta.url) {
+  runVisualQaCli()
+    .then((output) => process.stdout.write(JSON.stringify(output) + "\n"))
+    .catch((error) => {
+      process.stderr.write(`visual-qa: ${error instanceof Error ? error.message : String(error)}\n`);
+      process.exitCode = 1;
+    });
+}

package/skills/wikify/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 llm-wikify contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/wikify/PROVENANCE.md

@@ -0,0 +1,18 @@
+# Wikify provenance
+
+Ported from the owner source identified by these stable values:
+
+- Owner source identifier: `llm-wikify`
+- Owner source commit: `dfe8f8bc372c3bc153dd57697f4a36f366a63e74`
+- Owner source tree: `ca02699317261cf36f9f89e96186728013778da6`
+- Verified public locator: `https://github.com/wjgoarxiv/llm-wikify/tree/dfe8f8bc372c3bc153dd57697f4a36f366a63e74`
+- License: included MIT license, preserved in `LICENSE`
+
+The pinned locator identifies the verified public owner source; package integrity does not depend on
+network retrieval. Package integrity is local through the managed manifest, scanner, and actual packed bytes.
+
+The LitOpenCode port retains the five command modes and five authored templates. Source tests, product
+docs, examples, installer/TUI/build code, release files, caches, generated distributions, plans,
+session state, and local evidence are excluded. The port connects local inert-source review to
+LitResearch and the existing LitOpenCode review, recap, and handoff surfaces without external-vault
+or host-profile mutation authority.