@fro.bot/systematic 3.6.2 → 3.8.0

package/dist/cli.js

@@ -2,6 +2,8 @@
 // @bun
 import {
   applyEdits,
+  discoverSkills,
+  extractString,
   findAgentsInDir,
   findCommandsInDir,
   findSkillsInDir,
@@ -11,22 +13,781 @@ import {
   parse,
   parseFrontmatter,
   parseTree
-} from "./index-1mb4baxr.js";
+} from "./index-hjbt4p5s.js";
 
 // src/cli.ts
-import fs4 from "fs";
+import fs5 from "fs";
+import os2 from "os";
 import path4 from "path";
 
+// src/lib/agent-resolver.ts
+import fs from "fs";
+function buildAgentCatalog(agentsDir) {
+  const infos = findAgentsInDir(agentsDir);
+  const byName = new Map;
+  const entries = [];
+  for (const info of infos) {
+    const content = fs.readFileSync(info.file, "utf8");
+    const entry = parseValidatedAgentEntry(content, info.file);
+    try {
+      resolveToolAllowlist(entry.toolsSource);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Agent file "${info.file}": ${message}`);
+    }
+    const existing = byName.get(entry.name);
+    if (existing) {
+      existing.push(info.category ?? "(root)");
+    } else {
+      byName.set(entry.name, [info.category ?? "(root)"]);
+    }
+    entries.push(entry);
+  }
+  const duplicates = [...byName.entries()].filter(([, cats]) => cats.length > 1);
+  if (duplicates.length > 0) {
+    const detail = duplicates.map(([name, cats]) => `"${name}" (categories: ${cats.join(", ")})`).join("; ");
+    throw new Error(`Duplicate persona name(s) detected while flattening the agent catalog: ${detail}. ` + "Persona names must be unique across categories once category is dropped.");
+  }
+  return entries.sort((a, b) => a.name.localeCompare(b.name));
+}
+function parseValidatedAgentEntry(content, sourceFile) {
+  const { data, body, parseError } = parseFrontmatter(content);
+  if (parseError) {
+    throw new Error(`Failed to parse YAML frontmatter in agent file "${sourceFile}".`);
+  }
+  const name = extractString(data, "name");
+  if (name.trim() === "") {
+    throw new Error(`Agent file "${sourceFile}" is missing a non-empty "name" in its frontmatter.`);
+  }
+  const description = extractString(data, "description");
+  if (description.trim() === "") {
+    throw new Error(`Agent file "${sourceFile}" is missing a non-empty "description" in its frontmatter.`);
+  }
+  const prompt = body.trim();
+  if (prompt === "") {
+    throw new Error(`Agent file "${sourceFile}" has an empty persona body (system prompt).`);
+  }
+  return {
+    name,
+    description,
+    body: prompt,
+    toolsSource: extractRawToolsSource(data, sourceFile)
+  };
+}
+function extractRawToolsSource(data, sourceFile) {
+  if (!("tools" in data))
+    return;
+  const value = data.tools;
+  if (typeof value !== "string") {
+    throw new Error(`Agent file "${sourceFile}" has a "tools" frontmatter value that is not a string; expected a comma-separated list (e.g. "Read, Grep, Glob, Bash").`);
+  }
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    throw new Error(`Agent file "${sourceFile}" declares an empty "tools" frontmatter value.`);
+  }
+  return trimmed;
+}
+var DEFAULT_READONLY_TOOLS = ["read", "grep", "find", "ls"];
+var OPENCODE_TO_PI_TOOL = {
+  Read: "read",
+  Grep: "grep",
+  Glob: "find",
+  Bash: "bash",
+  Edit: "edit",
+  Write: "write"
+};
+function unknownDeclaredToolError(toolName) {
+  const error = new Error(`Unknown declared tool "${toolName}" in persona frontmatter; refusing to map ` + "to a Pi built-in (fail-closed). Known tools: " + `${Object.keys(OPENCODE_TO_PI_TOOL).join(", ")}.`);
+  error.name = "UnknownDeclaredToolError";
+  return error;
+}
+function resolveToolAllowlist(toolsSource) {
+  if (toolsSource === undefined) {
+    return { tools: [...DEFAULT_READONLY_TOOLS] };
+  }
+  const declared = toolsSource.split(",").map((t) => t.trim()).filter((t) => t !== "");
+  const mapped = [];
+  for (const name of declared) {
+    if (name === "Task") {
+      throw unknownDeclaredToolError(name);
+    }
+    const piName = OPENCODE_TO_PI_TOOL[name];
+    if (!piName) {
+      throw unknownDeclaredToolError(name);
+    }
+    mapped.push(piName);
+  }
+  return { tools: mapped };
+}
+
+// src/lib/capability-snapshot.ts
+var CAPABILITY_SNAPSHOT_SCHEMA_VERSION = "cli-capabilities.v1";
+var CAPABILITY_SNAPSHOT_COMMAND = "systematic capabilities";
+var CAPABILITY_SOURCE_IDS = [
+  "config:custom",
+  "config:global",
+  "config:project",
+  "config:user",
+  "discovery:agents",
+  "discovery:skills",
+  "host:runtime",
+  "package"
+];
+var CONFIG_SOURCE_KINDS = ["custom", "project", "user"];
+var CONFIG_AUTHORITY_FIELD_PATHS = [
+  "bootstrap.enabled",
+  "bootstrap.file",
+  "skills_as_commands",
+  "workflow_guard.debug",
+  "workflow_guard.mode"
+];
+var CONFIG_PROTECTED_FIELD_PATHS = [
+  "workflow_guard",
+  "agents.*.model",
+  "agents.*.permission",
+  "agents.*.skills",
+  "agents.*.variant",
+  "categories.*.model",
+  "categories.*.permission",
+  "categories.*.skills",
+  "categories.*.variant"
+];
+var CONFIG_SOURCE_ERROR_CODES = [
+  "parse-failed",
+  "read-failed",
+  "schema-invalid",
+  "source-invalid"
+];
+var CONFIG_SOURCE_KIND_SET = new Set(CONFIG_SOURCE_KINDS);
+var CONFIG_AUTHORITY_FIELD_PATH_SET = new Set(CONFIG_AUTHORITY_FIELD_PATHS);
+var CONFIG_PROTECTED_FIELD_PATH_SET = new Set(CONFIG_PROTECTED_FIELD_PATHS);
+var CONFIG_SOURCE_ERROR_CODE_SET = new Set(CONFIG_SOURCE_ERROR_CODES);
+var CAPABILITY_SOURCE_PRESENCE = ["absent", "invalid", "present"];
+var CAPABILITY_STATUSES = ["available", "unknown", "unavailable"];
+var CAPABILITY_FACT_IDS = [
+  "config-authority",
+  "config-field-authority",
+  "config-protected-field",
+  "discovery-summary",
+  "discovery-source-issue",
+  "host-runtime"
+];
+var CAPABILITY_DISCOVERY_IDS = ["agents", "skills"];
+var CAPABILITY_LIMITATION_CODES = [
+  "authority-unproven",
+  "discovery-not-collected",
+  "host-runtime-unobservable"
+];
+var CAPABILITY_ERROR_CODES = [
+  "source-malformed",
+  "source-read-failed",
+  "source-unsupported",
+  "structural-invalid"
+];
+var CAPABILITY_SOURCE_ID_SET = new Set(CAPABILITY_SOURCE_IDS);
+var CAPABILITY_SOURCE_PRESENCE_SET = new Set(CAPABILITY_SOURCE_PRESENCE);
+var CAPABILITY_STATUS_SET = new Set(CAPABILITY_STATUSES);
+var CAPABILITY_FACT_ID_SET = new Set(CAPABILITY_FACT_IDS);
+var CAPABILITY_DISCOVERY_ID_SET = new Set(CAPABILITY_DISCOVERY_IDS);
+var CAPABILITY_LIMITATION_CODE_SET = new Set(CAPABILITY_LIMITATION_CODES);
+var CAPABILITY_ERROR_CODE_SET = new Set(CAPABILITY_ERROR_CODES);
+var MAX_DISPLAY_ID_LENGTH = 128;
+var MAX_PACKAGE_NAME_LENGTH = 128;
+var MAX_PACKAGE_VERSION_LENGTH = 64;
+var MAX_DISCOVERY_COUNT = 1e5;
+var MAX_DISCOVERY_ROOTS = 32;
+function compareText(left, right) {
+  if (left < right)
+    return -1;
+  if (left > right)
+    return 1;
+  return 0;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function assertRecord(value, label) {
+  if (!isRecord(value))
+    throw new TypeError(`${label} must be an object`);
+}
+function assertAllowedKeys(value, allowedKeys, label) {
+  const allowed = new Set(allowedKeys);
+  for (const key of Object.keys(value)) {
+    if (!allowed.has(key))
+      throw new TypeError(`${label} has unknown key ${key}`);
+  }
+}
+function assertString(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`${label} must be a non-empty string`);
+  }
+}
+function assertEnum(value, values, label) {
+  if (typeof value !== "string" || !values.has(value)) {
+    throw new TypeError(`${label} is not an allowed value`);
+  }
+}
+function normalizeDisplayId(value, label) {
+  assertString(value, label);
+  const normalized = value.replaceAll("\\", "/").replace(/^\.\//, "");
+  if (normalized.length > MAX_DISPLAY_ID_LENGTH || normalized.startsWith("/") || normalized.includes("..") || !/^[A-Za-z0-9._:-]+(?:\/[A-Za-z0-9._:-]+)*$/.test(normalized)) {
+    throw new TypeError(`${label} must be a bounded relative display ID`);
+  }
+  return normalized;
+}
+function normalizePackageName(value) {
+  assertString(value, "package.name");
+  if (value.length > MAX_PACKAGE_NAME_LENGTH || !/^@?[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)?$/.test(value)) {
+    throw new TypeError("package.name is not an allowed package identity");
+  }
+  return value;
+}
+function normalizePackageVersion(value) {
+  assertString(value, "package.version");
+  if (value.length > MAX_PACKAGE_VERSION_LENGTH || !/^[A-Za-z0-9][A-Za-z0-9.+_-]*$/.test(value)) {
+    throw new TypeError("package.version is not an allowed version identity");
+  }
+  return value;
+}
+function normalizeExecutable(value) {
+  assertString(value, "argv[0]");
+  const segments = value.replaceAll("\\", "/").split("/");
+  const executable = segments.at(-1) ?? "";
+  if (executable.length === 0 || executable.length > MAX_DISPLAY_ID_LENGTH || !/^[A-Za-z0-9._:-]+$/.test(executable)) {
+    throw new TypeError("argv[0] is not an allowed executable identity");
+  }
+  return executable;
+}
+function normalizeArgv(argv) {
+  if (argv.length < 2) {
+    throw new TypeError("argv must include an executable and capabilities command");
+  }
+  const executable = normalizeExecutable(argv[0] ?? "");
+  if (argv[1] !== "capabilities") {
+    throw new TypeError("argv must identify the capabilities command");
+  }
+  return {
+    executable,
+    subcommand: "capabilities"
+  };
+}
+function canonicalizePath(value) {
+  assertString(value, "root.path");
+  const normalizedSeparators = value.replaceAll("\\", "/");
+  const absolute = normalizedSeparators.startsWith("/");
+  const segments = [];
+  for (const segment of normalizedSeparators.split("/")) {
+    if (segment === "" || segment === ".")
+      continue;
+    if (segment === "..") {
+      if (segments.length > 0 && segments.at(-1) !== "..")
+        segments.pop();
+      else if (!absolute)
+        segments.push(segment);
+      continue;
+    }
+    segments.push(segment);
+  }
+  const joined = segments.join("/");
+  return absolute ? `/${joined}` : joined;
+}
+function normalizeObservedAt(options) {
+  const observedAt = options.observedAt;
+  if (observedAt !== undefined) {
+    assertString(observedAt, "observedAt");
+    const parsed = new Date(observedAt);
+    if (Number.isNaN(parsed.getTime())) {
+      throw new TypeError("observedAt must be a valid timestamp");
+    }
+    return parsed.toISOString();
+  }
+  const now = options.clock?.() ?? Date.now();
+  const timestamp = now instanceof Date ? now : new Date(now);
+  if (Number.isNaN(timestamp.getTime())) {
+    throw new TypeError("clock must return a valid timestamp");
+  }
+  return timestamp.toISOString();
+}
+function normalizePackage(value) {
+  assertRecord(value, "package");
+  assertAllowedKeys(value, ["name", "version"], "package");
+  return {
+    name: normalizePackageName(value.name),
+    version: normalizePackageVersion(value.version)
+  };
+}
+function normalizeRoots(roots) {
+  const normalized = roots.map((root, index) => {
+    assertRecord(root, `roots[${index}]`);
+    assertAllowedKeys(root, ["id", "path"], `roots[${index}]`);
+    const id = normalizeDisplayId(root.id, `roots[${index}].id`);
+    const path = canonicalizePath(root.path);
+    return { id, path };
+  });
+  normalized.sort((left, right) => {
+    const pathOrder = compareText(left.path, right.path);
+    return pathOrder !== 0 ? pathOrder : compareText(left.id, right.id);
+  });
+  const unique = [];
+  let previousPath;
+  for (const root of normalized) {
+    if (root.path === previousPath)
+      continue;
+    previousPath = root.path;
+    unique.push({ id: root.id });
+  }
+  unique.sort((left, right) => compareText(left.id, right.id));
+  return unique;
+}
+function normalizeSources(sources) {
+  const normalized = sources.map(normalizeSource);
+  normalized.sort(compareSources);
+  const unique = [];
+  const seen = new Set;
+  for (const source of normalized) {
+    const key = source.canonicalPath ?? `source:${source.sourceId}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    unique.push(source);
+  }
+  unique.sort((left, right) => compareText(left.sourceId, right.sourceId));
+  return unique.map(({ canonicalPath: _canonicalPath, ...source }) => source);
+}
+function compareSources(left, right) {
+  const pathOrder = compareText(left.canonicalPath ?? "", right.canonicalPath ?? "");
+  if (pathOrder !== 0)
+    return pathOrder;
+  const sourceOrder = compareText(left.sourceId, right.sourceId);
+  if (sourceOrder !== 0)
+    return sourceOrder;
+  return compareText(left.presence, right.presence);
+}
+function normalizeSource(source, index) {
+  assertRecord(source, `sources[${index}]`);
+  assertAllowedKeys(source, ["errorCode", "path", "presence", "sourceId", "sourceKind"], `sources[${index}]`);
+  assertEnum(source.sourceId, CAPABILITY_SOURCE_ID_SET, `sources[${index}].sourceId`);
+  assertEnum(source.presence, CAPABILITY_SOURCE_PRESENCE_SET, `sources[${index}].presence`);
+  assertSourceKind(source, index);
+  const canonicalPath = source.path === undefined ? undefined : canonicalizePath(source.path);
+  if (source.presence === "invalid") {
+    assertEnum(source.errorCode, CAPABILITY_ERROR_CODE_SET, `sources[${index}].errorCode`);
+    return {
+      errorCode: source.errorCode,
+      kind: "source",
+      presence: source.presence,
+      sourceId: source.sourceId,
+      ...source.sourceKind === undefined ? {} : { sourceKind: source.sourceKind },
+      canonicalPath
+    };
+  }
+  if (source.errorCode !== undefined) {
+    throw new TypeError(`sources[${index}].errorCode is only valid for invalid sources`);
+  }
+  return {
+    kind: "source",
+    presence: source.presence,
+    sourceId: source.sourceId,
+    ...source.sourceKind === undefined ? {} : { sourceKind: source.sourceKind },
+    canonicalPath
+  };
+}
+function assertSourceKind(source, index) {
+  if (source.sourceKind === undefined)
+    return;
+  assertEnum(source.sourceKind, CONFIG_SOURCE_KIND_SET, `sources[${index}].sourceKind`);
+  if (source.sourceId !== configSourceId(source.sourceKind)) {
+    throw new TypeError(`sources[${index}].sourceKind does not match sourceId`);
+  }
+}
+function configSourceId(sourceKind) {
+  return `config:${sourceKind}`;
+}
+function configErrorCode(errorCode) {
+  return errorCode === "read-failed" ? "source-read-failed" : "source-malformed";
+}
+function normalizeConfigObservation(config) {
+  assertRecord(config, "config");
+  assertAllowedKeys(config, ["authorities", "protectedFields", "sources"], "config");
+  if (!Array.isArray(config.sources)) {
+    throw new TypeError("config.sources must be an array");
+  }
+  if (!Array.isArray(config.authorities)) {
+    throw new TypeError("config.authorities must be an array");
+  }
+  if (!Array.isArray(config.protectedFields)) {
+    throw new TypeError("config.protectedFields must be an array");
+  }
+  const sources = config.sources.map((source, index) => {
+    assertRecord(source, `config.sources[${index}]`);
+    assertAllowedKeys(source, ["errorCode", "kind", "path", "presence"], `config.sources[${index}]`);
+    assertEnum(source.kind, CONFIG_SOURCE_KIND_SET, `config.sources[${index}].kind`);
+    assertEnum(source.presence, CAPABILITY_SOURCE_PRESENCE_SET, `config.sources[${index}].presence`);
+    const pathValue = source.path;
+    if (pathValue !== undefined) {
+      assertString(pathValue, `config.sources[${index}].path`);
+      canonicalizePath(pathValue);
+    }
+    if (source.errorCode !== undefined) {
+      assertEnum(source.errorCode, CONFIG_SOURCE_ERROR_CODE_SET, `config.sources[${index}].errorCode`);
+    }
+    return {
+      ...source.errorCode === undefined ? {} : { errorCode: configErrorCode(source.errorCode) },
+      ...pathValue === undefined ? {} : { path: pathValue },
+      presence: source.presence,
+      sourceId: configSourceId(source.kind),
+      sourceKind: source.kind
+    };
+  });
+  const facts = [];
+  for (const source of sources) {
+    if (source.presence !== "invalid" || source.errorCode === undefined)
+      continue;
+    facts.push({
+      errorCode: source.errorCode,
+      factId: "config-authority",
+      sourceId: source.sourceId,
+      status: "unavailable"
+    });
+  }
+  config.authorities.forEach((authority, index) => {
+    assertRecord(authority, `config.authorities[${index}]`);
+    assertAllowedKeys(authority, ["fieldPath", "sourceKind"], `config.authorities[${index}]`);
+    assertEnum(authority.fieldPath, CONFIG_AUTHORITY_FIELD_PATH_SET, `config.authorities[${index}].fieldPath`);
+    assertEnum(authority.sourceKind, CONFIG_SOURCE_KIND_SET, `config.authorities[${index}].sourceKind`);
+    facts.push({
+      factId: "config-field-authority",
+      fieldPath: authority.fieldPath,
+      kind: "authority",
+      sourceId: configSourceId(authority.sourceKind),
+      status: "available"
+    });
+  });
+  config.protectedFields.forEach((protectedField, index) => {
+    assertRecord(protectedField, `config.protectedFields[${index}]`);
+    assertAllowedKeys(protectedField, ["fieldPath", "outcome", "sourceKind"], `config.protectedFields[${index}]`);
+    assertEnum(protectedField.fieldPath, CONFIG_PROTECTED_FIELD_PATH_SET, `config.protectedFields[${index}].fieldPath`);
+    assertEnum(protectedField.sourceKind, CONFIG_SOURCE_KIND_SET, `config.protectedFields[${index}].sourceKind`);
+    if (protectedField.outcome !== "blocked") {
+      throw new TypeError(`config.protectedFields[${index}].outcome must be blocked`);
+    }
+    facts.push({
+      factId: "config-protected-field",
+      fieldPath: protectedField.fieldPath,
+      kind: "protection",
+      outcome: "blocked",
+      sourceId: configSourceId(protectedField.sourceKind),
+      status: "available"
+    });
+  });
+  return { facts, sources };
+}
+function normalizeFact(value, label) {
+  assertRecord(value, label);
+  assertAllowedKeys(value, [
+    "errorCode",
+    "factId",
+    "fieldPath",
+    "kind",
+    "limitationCode",
+    "outcome",
+    "sourceId",
+    "status",
+    "count",
+    "discoveryId",
+    "winningRoots"
+  ], label);
+  assertEnum(value.factId, CAPABILITY_FACT_ID_SET, `${label}.factId`);
+  if (value.factId === "config-field-authority") {
+    return normalizeAuthorityFact(value, label);
+  }
+  if (value.factId === "config-protected-field") {
+    return normalizeProtectionFact(value, label);
+  }
+  if (value.factId === "discovery-summary") {
+    return normalizeDiscoveryFact(value, label);
+  }
+  if (value.factId === "discovery-source-issue") {
+    return normalizeDiscoverySourceIssueFact(value, label);
+  }
+  return normalizeStatusFact(value, label);
+}
+function normalizeAuthorityFact(value, label) {
+  assertNoDiscoveryFields(value, label);
+  assertEnum(value.fieldPath, CONFIG_AUTHORITY_FIELD_PATH_SET, `${label}.fieldPath`);
+  if (value.kind !== "authority") {
+    throw new TypeError(`${label}.kind must be authority`);
+  }
+  assertAvailableFactSource(value, label);
+  return {
+    factId: "config-field-authority",
+    fieldPath: value.fieldPath,
+    kind: "authority",
+    sourceId: value.sourceId,
+    status: "available"
+  };
+}
+function normalizeProtectionFact(value, label) {
+  assertNoDiscoveryFields(value, label);
+  assertEnum(value.fieldPath, CONFIG_PROTECTED_FIELD_PATH_SET, `${label}.fieldPath`);
+  if (value.kind !== "protection") {
+    throw new TypeError(`${label}.kind must be protection`);
+  }
+  if (value.outcome !== "blocked") {
+    throw new TypeError(`${label}.outcome must be blocked`);
+  }
+  assertAvailableFactSource(value, label);
+  return {
+    factId: "config-protected-field",
+    fieldPath: value.fieldPath,
+    kind: "protection",
+    outcome: "blocked",
+    sourceId: value.sourceId,
+    status: "available"
+  };
+}
+function assertAvailableFactSource(value, label) {
+  assertEnum(value.sourceId, CAPABILITY_SOURCE_ID_SET, `${label}.sourceId`);
+  if (value.status !== "available") {
+    throw new TypeError(`${label}.status must be available`);
+  }
+}
+function normalizeStatusFact(value, label) {
+  assertNoDiscoveryFields(value, label);
+  if (value.kind !== undefined && value.kind !== "status") {
+    throw new TypeError(`${label}.kind must be status`);
+  }
+  assertEnum(value.status, CAPABILITY_STATUS_SET, `${label}.status`);
+  if (value.sourceId !== undefined) {
+    assertEnum(value.sourceId, CAPABILITY_SOURCE_ID_SET, `${label}.sourceId`);
+  }
+  switch (value.status) {
+    case "available":
+      return normalizeAvailableFact(value, label);
+    case "unknown":
+      return normalizeUnknownFact(value, label);
+    case "unavailable":
+      return normalizeUnavailableFact(value, label);
+  }
+}
+function assertNoDiscoveryFields(value, label) {
+  if (value.count !== undefined || value.discoveryId !== undefined || value.winningRoots !== undefined) {
+    throw new TypeError(`${label} discovery fields require discovery kind`);
+  }
+}
+function normalizeDiscoveryFact(value, label) {
+  if (value.status === "unavailable") {
+    return normalizeUnavailableDiscoveryFact(value, label);
+  }
+  if (value.status !== "available") {
+    throw new TypeError(`${label}.status must be available or unavailable`);
+  }
+  assertAvailableDiscoveryFact(value, label);
+  assertEnum(value.discoveryId, CAPABILITY_DISCOVERY_ID_SET, `${label}.discoveryId`);
+  const expectedSourceId = `discovery:${value.discoveryId}`;
+  if (value.sourceId !== expectedSourceId) {
+    throw new TypeError(`${label}.sourceId does not match discoveryId`);
+  }
+  assertEnum(value.sourceId, CAPABILITY_SOURCE_ID_SET, `${label}.sourceId`);
+  const count = value.count;
+  if (typeof count !== "number" || !Number.isSafeInteger(count) || count < 0 || count > MAX_DISCOVERY_COUNT) {
+    throw new TypeError(`${label}.count must be a bounded integer`);
+  }
+  if (!Array.isArray(value.winningRoots)) {
+    throw new TypeError(`${label}.winningRoots must be an array`);
+  }
+  if (value.winningRoots.length > MAX_DISCOVERY_ROOTS) {
+    throw new TypeError(`${label}.winningRoots exceeds the bounded limit`);
+  }
+  const winningRoots = value.winningRoots.map((root, index) => {
+    assertString(root, `${label}.winningRoots[${index}]`);
+    return normalizeDisplayId(root, `${label}.winningRoots[${index}]`);
+  });
+  winningRoots.sort(compareText);
+  return {
+    count,
+    discoveryId: value.discoveryId,
+    factId: "discovery-summary",
+    kind: "discovery",
+    sourceId: value.sourceId,
+    status: "available",
+    winningRoots: [...new Set(winningRoots)]
+  };
+}
+function normalizeDiscoverySourceIssueFact(value, label) {
+  if (value.kind !== "status") {
+    throw new TypeError(`${label}.kind must be status`);
+  }
+  if (value.status !== "unavailable") {
+    throw new TypeError(`${label}.status must be unavailable`);
+  }
+  if (value.sourceId !== "discovery:skills") {
+    throw new TypeError(`${label}.sourceId must be discovery:skills`);
+  }
+  if (value.errorCode !== "source-malformed" && value.errorCode !== "source-read-failed") {
+    throw new TypeError(`${label}.errorCode is not a discovery source error`);
+  }
+  if (value.count !== undefined || value.discoveryId !== undefined || value.fieldPath !== undefined || value.limitationCode !== undefined || value.outcome !== undefined || value.winningRoots !== undefined) {
+    throw new TypeError(`${label} has invalid discovery source issue fields`);
+  }
+  return {
+    errorCode: value.errorCode,
+    factId: "discovery-source-issue",
+    kind: "status",
+    sourceId: "discovery:skills",
+    status: "unavailable"
+  };
+}
+function normalizeUnavailableDiscoveryFact(value, label) {
+  if (value.kind !== undefined && value.kind !== "status") {
+    throw new TypeError(`${label}.kind must be status`);
+  }
+  if (value.sourceId === undefined) {
+    throw new TypeError(`${label}.sourceId is required`);
+  }
+  if (value.count !== undefined || value.discoveryId !== undefined || value.winningRoots !== undefined) {
+    throw new TypeError(`${label} unavailable discovery fields are invalid`);
+  }
+  assertEnum(value.sourceId, CAPABILITY_SOURCE_ID_SET, `${label}.sourceId`);
+  return normalizeUnavailableFact(value, label);
+}
+function assertAvailableDiscoveryFact(value, label) {
+  if (value.kind !== "discovery") {
+    throw new TypeError(`${label}.kind must be discovery`);
+  }
+  if (value.errorCode !== undefined || value.limitationCode !== undefined || value.outcome !== undefined) {
+    throw new TypeError(`${label} available discovery fields are invalid`);
+  }
+}
+function normalizeAvailableFact(value, label) {
+  if (value.sourceId !== undefined || value.errorCode !== undefined) {
+    throw new TypeError(`${label} available facts cannot include source or error metadata`);
+  }
+  if (value.limitationCode !== undefined) {
+    throw new TypeError(`${label} available facts cannot include a limitation`);
+  }
+  return {
+    factId: value.factId,
+    kind: "status",
+    status: "available"
+  };
+}
+function normalizeUnknownFact(value, label) {
+  assertEnum(value.limitationCode, CAPABILITY_LIMITATION_CODE_SET, `${label}.limitationCode`);
+  if (value.sourceId !== undefined || value.errorCode !== undefined) {
+    throw new TypeError(`${label} unknown facts cannot include source or error metadata`);
+  }
+  return {
+    factId: value.factId,
+    kind: "status",
+    limitationCode: value.limitationCode,
+    status: "unknown"
+  };
+}
+function normalizeUnavailableFact(value, label) {
+  assertEnum(value.errorCode, CAPABILITY_ERROR_CODE_SET, `${label}.errorCode`);
+  if (value.limitationCode !== undefined) {
+    throw new TypeError(`${label} unavailable facts cannot include a limitation`);
+  }
+  return {
+    errorCode: value.errorCode,
+    factId: value.factId,
+    kind: "status",
+    ...value.sourceId === undefined ? {} : { sourceId: value.sourceId },
+    status: "unavailable"
+  };
+}
+function normalizeFacts(facts) {
+  const normalized = facts.map((fact, index) => normalizeFact(fact, `facts[${index}]`));
+  normalized.sort(compareFacts);
+  return normalized;
+}
+function compareFacts(left, right) {
+  const factOrder = compareText(left.factId, right.factId);
+  if (factOrder !== 0)
+    return factOrder;
+  const fieldOrder = compareText(factField(left, "fieldPath"), factField(right, "fieldPath"));
+  if (fieldOrder !== 0)
+    return fieldOrder;
+  const statusOrder = compareText(left.status, right.status);
+  if (statusOrder !== 0)
+    return statusOrder;
+  const sourceOrder = compareText(factField(left, "sourceId"), factField(right, "sourceId"));
+  if (sourceOrder !== 0)
+    return sourceOrder;
+  const discoveryOrder = compareText(factField(left, "discoveryId"), factField(right, "discoveryId"));
+  if (discoveryOrder !== 0)
+    return discoveryOrder;
+  return compareText(factField(left, "errorCode"), factField(right, "errorCode"));
+}
+function factField(fact, field) {
+  if (field === "discoveryId" && "discoveryId" in fact)
+    return fact.discoveryId;
+  if (field === "errorCode" && "errorCode" in fact)
+    return fact.errorCode;
+  if (field === "fieldPath" && "fieldPath" in fact)
+    return fact.fieldPath;
+  if (field === "sourceId" && "sourceId" in fact)
+    return fact.sourceId ?? "";
+  return "";
+}
+function buildCapabilitySnapshot(options) {
+  assertRecord(options, "options");
+  assertAllowedKeys(options, [
+    "argv",
+    "clock",
+    "config",
+    "facts",
+    "observedAt",
+    "outputSink",
+    "package",
+    "roots",
+    "sources"
+  ], "options");
+  if (!Array.isArray(options.argv))
+    throw new TypeError("argv must be an array");
+  if (!Array.isArray(options.roots))
+    throw new TypeError("roots must be an array");
+  if (options.sources !== undefined && !Array.isArray(options.sources)) {
+    throw new TypeError("sources must be an array");
+  }
+  if (options.facts !== undefined && !Array.isArray(options.facts)) {
+    throw new TypeError("facts must be an array");
+  }
+  const configObservation = options.config ? normalizeConfigObservation(options.config) : { facts: [], sources: [] };
+  const snapshot = {
+    command: CAPABILITY_SNAPSHOT_COMMAND,
+    facts: normalizeFacts([
+      ...options.facts ?? [],
+      ...configObservation.facts
+    ]),
+    identity: {
+      argv: normalizeArgv(options.argv),
+      package: normalizePackage(options.package)
+    },
+    observedAt: normalizeObservedAt(options),
+    roots: normalizeRoots(options.roots),
+    schemaVersion: CAPABILITY_SNAPSHOT_SCHEMA_VERSION,
+    sources: normalizeSources([
+      ...options.sources ?? [],
+      ...configObservation.sources
+    ])
+  };
+  const serialized = JSON.stringify(snapshot);
+  options.outputSink?.(serialized);
+  return snapshot;
+}
+
 // src/lib/pi-subagents-export.ts
 import * as crypto2 from "crypto";
-import * as fs2 from "fs";
+import * as fs3 from "fs";
 import * as os from "os";
 import * as path2 from "path";
 import { fileURLToPath } from "url";
 
 // src/lib/pi-subagents-personas.ts
 import * as crypto from "crypto";
-import * as fs from "fs";
+import * as fs2 from "fs";
 import * as path from "path";
 var CURATED_PERSONAS = [
   {
@@ -293,7 +1054,7 @@ function generateAll(repoRoot) {
     const fullPath = path.join(repoRoot, curatedEntry.relPath);
     let rawContent;
     try {
-      rawContent = fs.readFileSync(fullPath, "utf-8");
+      rawContent = fs2.readFileSync(fullPath, "utf-8");
     } catch (err) {
       throw new Error(`Failed to read ${curatedEntry.relPath}: ${err.message}`);
     }
@@ -362,7 +1123,7 @@ function assertAnchoredPathSafe(anchor, targetPath) {
     current = path2.join(current, part);
     let stat;
     try {
-      stat = fs2.lstatSync(current);
+      stat = fs3.lstatSync(current);
     } catch {
       continue;
     }
@@ -375,11 +1136,11 @@ function assertAnchoredPathSafe(anchor, targetPath) {
 function assertCanonicalRootWithinAnchor(anchor, root) {
   let canonicalAnchor;
   try {
-    canonicalAnchor = fs2.realpathSync(anchor);
+    canonicalAnchor = fs3.realpathSync(anchor);
   } catch (err) {
     throw new Error(`Cannot resolve safety anchor ${anchor}: ${err instanceof Error ? err.message : String(err)}`);
   }
-  const canonicalRoot = fs2.realpathSync(root);
+  const canonicalRoot = fs3.realpathSync(root);
   if (canonicalRoot !== canonicalAnchor && !canonicalRoot.startsWith(canonicalAnchor + path2.sep)) {
     throw new Error(`Refusing to operate on ${canonicalRoot}: canonical path escapes safety anchor ` + `${canonicalAnchor} (raced-symlink ancestor detected after resolution)`);
   }
@@ -414,11 +1175,11 @@ function validateManifestObject(parsed) {
   }
   return null;
 }
-var HAS_O_NOFOLLOW = typeof fs2.constants.O_NOFOLLOW === "number";
+var HAS_O_NOFOLLOW = typeof fs3.constants.O_NOFOLLOW === "number";
 function verifyManifestPathIdentity(manifestPath, openedStat) {
   let linkStat;
   try {
-    linkStat = fs2.lstatSync(manifestPath);
+    linkStat = fs3.lstatSync(manifestPath);
   } catch (err) {
     return `Cannot verify manifest path after open: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -429,9 +1190,9 @@ function verifyManifestPathIdentity(manifestPath, openedStat) {
   return null;
 }
 function openManifestFd(manifestPath) {
-  const openFlags = fs2.constants.O_RDONLY | (HAS_O_NOFOLLOW ? fs2.constants.O_NOFOLLOW : 0);
+  const openFlags = fs3.constants.O_RDONLY | (HAS_O_NOFOLLOW ? fs3.constants.O_NOFOLLOW : 0);
   try {
-    return { kind: "fd", fd: fs2.openSync(manifestPath, openFlags) };
+    return { kind: "fd", fd: fs3.openSync(manifestPath, openFlags) };
   } catch (err) {
     if (err.code === "ENOENT")
       return { kind: "result", result: { kind: "absent" } };
@@ -474,7 +1235,7 @@ function readManifestStrict(agentsRoot) {
     return opened.result;
   const { fd } = opened;
   try {
-    const stat = fs2.fstatSync(fd);
+    const stat = fs3.fstatSync(fd);
     if (!stat.isFile())
       return {
         kind: "malformed",
@@ -485,14 +1246,14 @@ function readManifestStrict(agentsRoot) {
       if (identityError !== null)
         return { kind: "malformed", error: identityError };
     }
-    return parseManifestContents(fs2.readFileSync(fd, "utf-8"));
+    return parseManifestContents(fs3.readFileSync(fd, "utf-8"));
   } catch (err) {
     return {
       kind: "malformed",
       error: `Cannot read manifest: ${err instanceof Error ? err.message : String(err)}`
     };
   } finally {
-    fs2.closeSync(fd);
+    fs3.closeSync(fd);
   }
 }
 function writeManifest(agentsRoot, manifest) {
@@ -501,7 +1262,7 @@ function writeManifest(agentsRoot, manifest) {
 }
 function statOrNull(p) {
   try {
-    return fs2.lstatSync(p);
+    return fs3.lstatSync(p);
   } catch {
     return null;
   }
@@ -509,7 +1270,7 @@ function statOrNull(p) {
 function assertRealAgentsRoot(agentsRoot) {
   let stat = null;
   try {
-    stat = fs2.lstatSync(agentsRoot);
+    stat = fs3.lstatSync(agentsRoot);
   } catch {}
   if (stat !== null) {
     if (stat.isSymbolicLink())
@@ -517,7 +1278,7 @@ function assertRealAgentsRoot(agentsRoot) {
     if (!stat.isDirectory())
       throw new Error(`Refusing to write under ${agentsRoot}: not a directory`);
   }
-  return fs2.realpathSync(agentsRoot);
+  return fs3.realpathSync(agentsRoot);
 }
 function safeFilePathOrThrow(agentsRoot, filename) {
   if (path2.basename(filename) !== filename || path2.isAbsolute(filename)) {
@@ -539,7 +1300,7 @@ function safeFilePath(agentsRoot, filename) {
 function acquireLock(agentsRoot) {
   const lockPath = path2.join(agentsRoot, LOCK_FILENAME);
   try {
-    return { ok: true, fd: fs2.openSync(lockPath, "wx") };
+    return { ok: true, fd: fs3.openSync(lockPath, "wx") };
   } catch (err) {
     if (err.code === "EEXIST") {
       return {
@@ -557,10 +1318,10 @@ function acquireLock(agentsRoot) {
 }
 function releaseLock(agentsRoot, fd) {
   try {
-    fs2.closeSync(fd);
+    fs3.closeSync(fd);
   } catch {}
   try {
-    fs2.unlinkSync(path2.join(agentsRoot, LOCK_FILENAME));
+    fs3.unlinkSync(path2.join(agentsRoot, LOCK_FILENAME));
   } catch {}
 }
 function withLock(agentsRoot, fn) {
@@ -582,11 +1343,11 @@ function atomicWriteString(destPath, content) {
   const parentDir = path2.dirname(destPath);
   const tmpPath = path2.join(parentDir, `.${path2.basename(destPath)}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
   try {
-    fs2.writeFileSync(tmpPath, content, { flag: "w", mode: 420 });
-    fs2.renameSync(tmpPath, destPath);
+    fs3.writeFileSync(tmpPath, content, { flag: "w", mode: 420 });
+    fs3.renameSync(tmpPath, destPath);
   } catch (err) {
     try {
-      fs2.unlinkSync(tmpPath);
+      fs3.unlinkSync(tmpPath);
     } catch {}
     throw err;
   }
@@ -595,7 +1356,7 @@ function snapshotFiles(filePaths) {
   const backup = new Map;
   for (const p of filePaths) {
     try {
-      backup.set(p, fs2.readFileSync(p, "utf-8"));
+      backup.set(p, fs3.readFileSync(p, "utf-8"));
     } catch (err) {
       if (err.code === "ENOENT") {
         backup.set(p, undefined);
@@ -614,10 +1375,10 @@ function restoreFromBackup(backup) {
   for (const [p, content] of backup) {
     try {
       if (content === undefined) {
-        if (fs2.existsSync(p))
-          fs2.unlinkSync(p);
+        if (fs3.existsSync(p))
+          fs3.unlinkSync(p);
       } else {
-        fs2.writeFileSync(p, content, "utf-8");
+        fs3.writeFileSync(p, content, "utf-8");
       }
     } catch {
       failed.push(p);
@@ -766,11 +1527,11 @@ function generateEntries(repoRoot, configOptions) {
 function findPackageRoot() {
   const thisFile = fileURLToPath(import.meta.url);
   const dir = path2.resolve(path2.dirname(thisFile), "..", "..");
-  if (fs2.existsSync(path2.join(dir, "package.json")))
+  if (fs3.existsSync(path2.join(dir, "package.json")))
     return dir;
   let candidate = path2.dirname(thisFile);
   for (let i = 0;i < 8; i++) {
-    if (fs2.existsSync(path2.join(candidate, "package.json")))
+    if (fs3.existsSync(path2.join(candidate, "package.json")))
       return candidate;
     const parent = path2.dirname(candidate);
     if (parent === candidate)
@@ -780,7 +1541,7 @@ function findPackageRoot() {
   throw new Error("Could not locate package root (no package.json found)");
 }
 function planExistingEntry(absRoot, filename, hash, owned) {
-  const diskContent = fs2.readFileSync(path2.join(absRoot, filename), "utf-8");
+  const diskContent = fs3.readFileSync(path2.join(absRoot, filename), "utf-8");
   const diskHash = crypto2.createHash("sha256").update(diskContent).digest("hex");
   if (owned.has(filename)) {
     return diskHash !== hash ? { action: "update", filename } : { action: "skip", filename };
@@ -796,7 +1557,7 @@ function planEntryActions(absRoot, entries, owned) {
   for (const entry of entries) {
     if (entry.status === "excluded-critical" || !entry.content)
       continue;
-    const exists = fs2.existsSync(path2.join(absRoot, entry.filename));
+    const exists = fs3.existsSync(path2.join(absRoot, entry.filename));
     actions.push(exists ? planExistingEntry(absRoot, entry.filename, entry.hash, owned) : { action: "create", filename: entry.filename });
   }
   return actions;
@@ -809,7 +1570,7 @@ function planRemoveActions(absRoot, manifest, currentFilenames) {
     if (currentFilenames.has(mEntry.filename))
       continue;
     const safe = safeFilePath(absRoot, mEntry.filename);
-    if (safe !== null && fs2.existsSync(safe))
+    if (safe !== null && fs3.existsSync(safe))
       removes.push({ action: "remove", filename: mEntry.filename });
   }
   return removes;
@@ -852,13 +1613,13 @@ function classifyOneExportEntry(absRoot, entry, owned) {
   const safePath = safeFilePath(absRoot, entry.filename);
   if (safePath === null)
     return { kind: "refuse", reason: "Filename would escape agents root" };
-  if (fs2.existsSync(safePath) && !owned.has(entry.filename))
+  if (fs3.existsSync(safePath) && !owned.has(entry.filename))
     return {
       kind: "refuse",
       reason: "File exists but is not owned by a previous export (user file)"
     };
-  if (fs2.existsSync(safePath)) {
-    const diskHash = crypto2.createHash("sha256").update(fs2.readFileSync(safePath, "utf-8")).digest("hex");
+  if (fs3.existsSync(safePath)) {
+    const diskHash = crypto2.createHash("sha256").update(fs3.readFileSync(safePath, "utf-8")).digest("hex");
     if (diskHash === entry.hash)
       return { kind: "skip", safePath };
   }
@@ -904,19 +1665,19 @@ function makeExportError(error) {
 function prepareExportRoot(agentsRoot) {
   let preStat = null;
   try {
-    preStat = fs2.lstatSync(agentsRoot);
+    preStat = fs3.lstatSync(agentsRoot);
   } catch {}
   if (preStat?.isSymbolicLink())
     return makeExportError(`Refusing to write under ${agentsRoot}: not a real directory (symlink detected)`);
   try {
-    fs2.mkdirSync(agentsRoot, { recursive: true });
+    fs3.mkdirSync(agentsRoot, { recursive: true });
     return assertRealAgentsRoot(agentsRoot);
   } catch (err) {
     return makeExportError(err instanceof Error ? err.message : String(err));
   }
 }
 function assertHashMatchesOrThrow(filePath, expectedHash, filename, verb) {
-  const diskContent = fs2.readFileSync(filePath, "utf-8");
+  const diskContent = fs3.readFileSync(filePath, "utf-8");
   const diskHash = crypto2.createHash("sha256").update(diskContent).digest("hex");
   if (diskHash !== expectedHash) {
     throw new Error(`Refusing to ${verb} "${filename}": content on disk does not match the ` + `manifest hash (drifted or tampered). Resolve manually or re-export/refresh first.`);
@@ -930,7 +1691,7 @@ function findStalePaths(absRoot, prevManifest, currentFilenames) {
     if (currentFilenames.has(mEntry.filename))
       continue;
     const safe = safeFilePath(absRoot, mEntry.filename);
-    if (safe === null || !fs2.existsSync(safe))
+    if (safe === null || !fs3.existsSync(safe))
       continue;
     assertHashMatchesOrThrow(safe, mEntry.hash, mEntry.filename, "remove stale file");
     stale.push({ path: safe, filename: mEntry.filename, hash: mEntry.hash });
@@ -984,9 +1745,9 @@ function exportPersonas(agentsRoot, configOptions) {
     ], [
       ...toWrite.map(({ entry, safePath }) => () => atomicWriteString(safePath, entry.content ?? "")),
       ...staleOwned.map(({ path: p, filename, hash }) => () => {
-        if (fs2.existsSync(p)) {
+        if (fs3.existsSync(p)) {
           assertHashMatchesOrThrow(p, hash, filename, "remove stale file");
-          fs2.unlinkSync(p);
+          fs3.unlinkSync(p);
         }
       }),
       () => writeManifest(absRoot, newManifest())
@@ -1014,13 +1775,13 @@ function classifyOneRefreshEntry(absRoot, entry, owned) {
   const safePath = safeFilePath(absRoot, entry.filename);
   if (safePath === null)
     return { kind: "ignore" };
-  const exists = fs2.existsSync(safePath);
+  const exists = fs3.existsSync(safePath);
   if (exists && !owned.has(entry.filename))
     return { kind: "skip-unowned", safePath };
   if (!exists && !owned.has(entry.filename))
     return { kind: "skip-unexported" };
   if (exists) {
-    const diskHash = crypto2.createHash("sha256").update(fs2.readFileSync(safePath, "utf-8")).digest("hex");
+    const diskHash = crypto2.createHash("sha256").update(fs3.readFileSync(safePath, "utf-8")).digest("hex");
     if (diskHash === entry.hash)
       return { kind: "keep", safePath };
   }
@@ -1049,7 +1810,7 @@ function classifyRefreshEntries(absRoot, entries, owned) {
 }
 function validateRefreshRoot(agentsRoot) {
   const absRoot = path2.resolve(agentsRoot);
-  if (!fs2.existsSync(absRoot))
+  if (!fs3.existsSync(absRoot))
     return {
       status: "error",
       updated: 0,
@@ -1057,7 +1818,7 @@ function validateRefreshRoot(agentsRoot) {
       error: `Agents root does not exist: ${absRoot}. Run export first.`
     };
   try {
-    const stat = fs2.lstatSync(absRoot);
+    const stat = fs3.lstatSync(absRoot);
     if (stat.isSymbolicLink())
       return {
         status: "error",
@@ -1154,7 +1915,7 @@ function collectCleanupPaths(absRoot, manifest) {
   const targets = [];
   for (const entry of manifest.files) {
     const safe = safeFilePath(absRoot, entry.filename);
-    if (safe === null || !fs2.existsSync(safe))
+    if (safe === null || !fs3.existsSync(safe))
       continue;
     assertHashMatchesOrThrow(safe, entry.hash, entry.filename, "delete");
     targets.push({ path: safe, filename: entry.filename, hash: entry.hash });
@@ -1162,7 +1923,7 @@ function collectCleanupPaths(absRoot, manifest) {
   const manifestPath = path2.join(absRoot, MANIFEST_FILENAME);
   return {
     targets,
-    manifestPath: fs2.existsSync(manifestPath) ? manifestPath : null
+    manifestPath: fs3.existsSync(manifestPath) ? manifestPath : null
   };
 }
 function cleanup(agentsRoot, configOptions) {
@@ -1172,7 +1933,7 @@ function cleanup(agentsRoot, configOptions) {
     throw new Error(`Refusing to operate on ${absRootCandidate}: not a real directory (symlink detected)`);
   const anchor = anchorForScope(configOptions, absRootCandidate);
   assertAnchoredPathSafe(anchor, absRootCandidate);
-  if (!fs2.existsSync(absRootCandidate))
+  if (!fs3.existsSync(absRootCandidate))
     return { status: "ok" };
   const absRoot = assertCanonicalRootWithinAnchor(anchor, absRootCandidate);
   const lockResult = withLock(absRoot, () => {
@@ -1189,15 +1950,15 @@ function cleanup(agentsRoot, configOptions) {
     ];
     const tx2 = runWithRollback(pathsToWatch, [
       ...targets.map(({ path: p, filename, hash }) => () => {
-        if (fs2.existsSync(p)) {
+        if (fs3.existsSync(p)) {
           assertHashMatchesOrThrow(p, hash, filename, "delete");
-          fs2.unlinkSync(p);
+          fs3.unlinkSync(p);
         }
       }),
       ...manifestPath ? [
         () => {
-          if (fs2.existsSync(manifestPath))
-            fs2.unlinkSync(manifestPath);
+          if (fs3.existsSync(manifestPath))
+            fs3.unlinkSync(manifestPath);
         }
       ] : []
     ]);
@@ -1217,7 +1978,7 @@ function cleanup(agentsRoot, configOptions) {
 }
 
 // src/lib/setup.ts
-import fs3 from "fs";
+import fs4 from "fs";
 import path3 from "path";
 var SYSTEMATIC_PACKAGE_NAME = "@fro.bot/systematic";
 var PI_PACKAGE_IDENTIFIER = `npm:${SYSTEMATIC_PACKAGE_NAME}`;
@@ -1228,12 +1989,12 @@ function createSetupError(message) {
   return error;
 }
 var DEFAULT_OPS = {
-  writeFileSync: fs3.writeFileSync,
-  renameSync: fs3.renameSync,
-  unlinkSync: fs3.unlinkSync,
-  chmodSync: fs3.chmodSync
+  writeFileSync: fs4.writeFileSync,
+  renameSync: fs4.renameSync,
+  unlinkSync: fs4.unlinkSync,
+  chmodSync: fs4.chmodSync
 };
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function errorMessage(error) {
@@ -1253,7 +2014,7 @@ function isPiSystematicIdentifier(identifier) {
 }
 function lstatOrNull(targetPath) {
   try {
-    return fs3.lstatSync(targetPath);
+    return fs4.lstatSync(targetPath);
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return null;
@@ -1262,8 +2023,8 @@ function lstatOrNull(targetPath) {
   }
 }
 function assertRealpathUnderCwd(dir, cwd) {
-  const realDir = fs3.realpathSync(dir);
-  const realCwd = fs3.realpathSync(cwd);
+  const realDir = fs4.realpathSync(dir);
+  const realCwd = fs4.realpathSync(cwd);
   const relative2 = path3.relative(realCwd, realDir);
   if (relative2.startsWith("..") || path3.isAbsolute(relative2)) {
     throw createSetupError(`Refusing to write under ${dir}: resolved directory escapes the project root`);
@@ -1278,7 +2039,7 @@ function assertParentTrusted(parentDir, cwd) {
     assertRealpathUnderCwd(parentDir, cwd);
     return;
   }
-  fs3.mkdirSync(parentDir, { recursive: true });
+  fs4.mkdirSync(parentDir, { recursive: true });
   assertRealpathUnderCwd(parentDir, cwd);
 }
 var OPENCODE_TARGET_CANDIDATES = [
@@ -1300,7 +2061,7 @@ function resolveOpenCodeTargetPath(cwd) {
   return path3.join(cwd, "opencode.jsonc");
 }
 var IS_WINDOWS = process.platform === "win32";
-var OPEN_FLAGS = IS_WINDOWS ? fs3.constants.O_RDONLY : fs3.constants.O_RDONLY | fs3.constants.O_NOFOLLOW | fs3.constants.O_NONBLOCK;
+var OPEN_FLAGS = IS_WINDOWS ? fs4.constants.O_RDONLY : fs4.constants.O_RDONLY | fs4.constants.O_NOFOLLOW | fs4.constants.O_NONBLOCK;
 function assertWindowsPreOpenTrust(targetPath) {
   const preStat = lstatOrNull(targetPath);
   if (preStat && (preStat.isSymbolicLink() || !preStat.isFile())) {
@@ -1312,7 +2073,7 @@ function openTrustedExisting(targetPath) {
     assertWindowsPreOpenTrust(targetPath);
   let fd;
   try {
-    fd = fs3.openSync(targetPath, OPEN_FLAGS);
+    fd = fs4.openSync(targetPath, OPEN_FLAGS);
   } catch (error) {
     if (error instanceof Error && "code" in error) {
       if (error.code === "ENOENT")
@@ -1324,13 +2085,13 @@ function openTrustedExisting(targetPath) {
     throw error;
   }
   try {
-    const stat = fs3.fstatSync(fd);
+    const stat = fs4.fstatSync(fd);
     if (!stat.isFile()) {
       throw createSetupError(`Refusing to read ${targetPath}: not a regular file`);
     }
-    return { bytes: fs3.readFileSync(fd), mode: stat.mode & 511 };
+    return { bytes: fs4.readFileSync(fd), mode: stat.mode & 511 };
   } finally {
-    fs3.closeSync(fd);
+    fs4.closeSync(fd);
   }
 }
 function atomicWrite(targetPath, content, originalBytes, mode, ops) {
@@ -1362,7 +2123,7 @@ function makeTempPath(parentDir, basename2) {
   return path3.join(parentDir, `.${basename2}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
 }
 function cleanupTemp(tempPath, ops) {
-  if (!fs3.existsSync(tempPath))
+  if (!fs4.existsSync(tempPath))
     return;
   try {
     ops.unlinkSync(tempPath);
@@ -1407,7 +2168,7 @@ function setupOpenCode(cwd, ops) {
   const rawText = existing.bytes.toString("utf8");
   assertNoDuplicateTopLevelKeys(rawText, targetPath, ["plugin", "plugins"], "OpenCode config");
   const parsed = parseOpenCodeJsonc(rawText, targetPath);
-  if (!isRecord(parsed)) {
+  if (!isRecord2(parsed)) {
     throw createSetupError(`Invalid OpenCode config in ${targetPath}: root must be an object`);
   }
   if (Object.hasOwn(parsed, "plugins")) {
@@ -1439,12 +2200,12 @@ function setupOpenCode(cwd, ops) {
 function getPiEntryIdentifier(entry) {
   if (typeof entry === "string")
     return entry;
-  if (isRecord(entry) && typeof entry.source === "string")
+  if (isRecord2(entry) && typeof entry.source === "string")
     return entry.source;
   return null;
 }
 function assertPiTaggedEntryUsable(entry, targetPath) {
-  if (!isRecord(entry))
+  if (!isRecord2(entry))
     return;
   if (entry.autoload === false) {
     throw createSetupError(`Invalid Pi settings in ${targetPath}: the existing \`${SYSTEMATIC_PACKAGE_NAME}\` package entry has \`autoload: false\`, which may prevent Systematic from loading; remove that flag or the entry before re-running setup`);
@@ -1471,7 +2232,7 @@ function setupPi(cwd, ops) {
   } catch (error) {
     throw createSetupError(`Invalid Pi settings in ${targetPath}: unable to parse JSON (${errorMessage(error)})`);
   }
-  if (!isRecord(parsed)) {
+  if (!isRecord2(parsed)) {
     throw createSetupError(`Invalid Pi settings in ${targetPath}: root must be an object`);
   }
   const existingPackages = parsed.packages;
@@ -1513,19 +2274,27 @@ function setupHarness(harness, cwd, opsOverride) {
 }
 
 // src/cli.ts
-var getPackageVersion = () => {
+function readPackageMetadata(packageRoot) {
   try {
-    const packageJsonPath = path4.resolve(import.meta.dirname, "..", "package.json");
-    if (!fs4.existsSync(packageJsonPath))
-      return "unknown";
-    const content = fs4.readFileSync(packageJsonPath, "utf8");
+    const packageJsonPath = path4.join(packageRoot, "package.json");
+    if (!fs5.existsSync(packageJsonPath))
+      return {};
+    const content = fs5.readFileSync(packageJsonPath, "utf8");
     const parsed = JSON.parse(content);
-    return parsed.version ?? "unknown";
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {};
+    }
+    const record = parsed;
+    return {
+      ...typeof record.name === "string" ? { name: record.name } : {},
+      ...typeof record.version === "string" ? { version: record.version } : {}
+    };
   } catch {
-    return "unknown";
+    return {};
   }
-};
-var VERSION = getPackageVersion();
+}
+var PACKAGE_ROOT = path4.resolve(import.meta.dirname, "..");
+var VERSION = readPackageMetadata(PACKAGE_ROOT).version ?? "unknown";
 var HELP = `
 systematic - OpenCode plugin for systematic engineering workflows
 
@@ -1534,6 +2303,7 @@ Usage:
 
 Commands:
   list [type]                  List available skills, agents, or commands
+  capabilities                 Read-only standalone-CLI observation; not a host-runtime or canonical-registry view
   config [subcommand]          Configuration management
     show                       Show configuration
     path                       Print config file locations
@@ -1550,6 +2320,7 @@ Options:
 
 Examples:
   systematic list skills
+  systematic capabilities
   systematic list agents
   systematic config show
   systematic setup --harness opencode
@@ -1572,6 +2343,161 @@ Scope:
   project   <cwd>/.pi/agents (default)
   global    $PI_CODING_AGENT_DIR/agents or ~/.pi/agent/agents
 `;
+function defaultCapabilityRoots() {
+  const configDir = process.env.XDG_CONFIG_HOME ? path4.join(process.env.XDG_CONFIG_HOME, "opencode") : path4.join(os2.homedir(), ".config/opencode");
+  return {
+    agentsRoot: path4.join(PACKAGE_ROOT, "agents"),
+    configDir,
+    cwd: process.cwd(),
+    homeDir: os2.homedir(),
+    opencodeConfigDirOverride: process.env.OPENCODE_CONFIG_DIR?.trim() || undefined,
+    packageRoot: PACKAGE_ROOT
+  };
+}
+function sourceErrorForSkillIssue(issue) {
+  return issue === "read-failed" ? "source-read-failed" : "source-malformed";
+}
+function discoverySummaryFact(discoveryId, count, winningRoots) {
+  return {
+    count,
+    discoveryId,
+    factId: "discovery-summary",
+    kind: "discovery",
+    sourceId: `discovery:${discoveryId}`,
+    status: "available",
+    winningRoots
+  };
+}
+function unavailableDiscoveryFact(discoveryId, errorCode) {
+  return {
+    errorCode,
+    factId: "discovery-summary",
+    sourceId: `discovery:${discoveryId}`,
+    status: "unavailable"
+  };
+}
+function discoverySourceIssueFact(errorCode) {
+  return {
+    errorCode,
+    factId: "discovery-source-issue",
+    kind: "status",
+    sourceId: "discovery:skills",
+    status: "unavailable"
+  };
+}
+function collectSkillFacts(roots) {
+  let issue;
+  try {
+    const skills = discoverSkills({
+      configDir: roots.configDir,
+      homeDir: roots.homeDir,
+      onIssue: (nextIssue) => {
+        issue ??= nextIssue;
+      },
+      opencodeConfigDirOverride: roots.opencodeConfigDirOverride,
+      startDir: roots.cwd
+    });
+    const winningRoots = [...new Set(skills.map((skill) => skill.root))].sort();
+    const facts = [discoverySummaryFact("skills", skills.length, winningRoots)];
+    if (issue !== undefined) {
+      facts.push(discoverySourceIssueFact(sourceErrorForSkillIssue(issue)));
+    }
+    return facts;
+  } catch {
+    return [discoverySourceIssueFact("source-malformed")];
+  }
+}
+function collectAgentFact(agentsRoot) {
+  try {
+    const catalog = buildAgentCatalog(agentsRoot);
+    return discoverySummaryFact("agents", catalog.length, ["agents"]);
+  } catch {
+    return unavailableDiscoveryFact("agents", "structural-invalid");
+  }
+}
+function collectDiscoveryFacts(roots) {
+  return [
+    {
+      factId: "host-runtime",
+      limitationCode: "host-runtime-unobservable",
+      status: "unknown"
+    },
+    ...collectSkillFacts(roots),
+    collectAgentFact(roots.agentsRoot)
+  ];
+}
+function collectConfigMetadata(roots, injected) {
+  if (injected !== undefined)
+    return injected;
+  try {
+    return loadConfigWithSources(roots.cwd, {
+      customConfigDir: roots.opencodeConfigDirOverride ?? null,
+      homeDir: roots.homeDir,
+      invalidSource: "report",
+      userConfigDir: roots.configDir,
+      warningSink: () => {
+        return;
+      }
+    }).metadata;
+  } catch {
+    return;
+  }
+}
+function resolveCapabilityRootPath(root) {
+  try {
+    return fs5.realpathSync(root);
+  } catch {
+    return path4.resolve(root);
+  }
+}
+function capabilityRoots(roots) {
+  return [
+    { id: "agents", path: resolveCapabilityRootPath(roots.agentsRoot) },
+    { id: "cwd", path: resolveCapabilityRootPath(roots.cwd) },
+    { id: "package", path: resolveCapabilityRootPath(roots.packageRoot) },
+    {
+      id: "skills",
+      path: resolveCapabilityRootPath(path4.join(roots.packageRoot, "skills"))
+    },
+    { id: "user", path: resolveCapabilityRootPath(roots.homeDir) }
+  ];
+}
+function capabilityPackage(packageRoot) {
+  const metadata = readPackageMetadata(packageRoot);
+  return {
+    name: metadata.name ?? "unknown",
+    version: metadata.version ?? "unknown"
+  };
+}
+function runCapabilities(options) {
+  const outputSink = options.outputSink ?? ((value) => console.log(value));
+  const errorSink = options.errorSink ?? ((message) => console.error(message));
+  const isFullArgv = options.argv.length === 2 && options.argv[0] === "systematic" && options.argv[1] === "capabilities";
+  const isCommandOnlyArgv = options.argv.length === 1 && options.argv[0] === "capabilities";
+  if (!isFullArgv && !isCommandOnlyArgv) {
+    errorSink("Usage: systematic capabilities");
+    return 2;
+  }
+  const builderArgv = isFullArgv ? options.argv : ["systematic", "capabilities"];
+  try {
+    buildCapabilitySnapshot({
+      argv: builderArgv,
+      clock: options.clock,
+      config: collectConfigMetadata(options.roots, options.config),
+      facts: collectDiscoveryFacts(options.roots),
+      outputSink,
+      package: capabilityPackage(options.roots.packageRoot),
+      roots: capabilityRoots(options.roots)
+    });
+    return 0;
+  } catch {
+    errorSink("Capabilities diagnostic unavailable");
+    return 1;
+  }
+}
+function runCapabilitiesCli(options) {
+  return runCapabilities(options);
+}
 function isHarness(value) {
   return value === "opencode" || value === "pi";
 }
@@ -1637,15 +2563,15 @@ function configShow() {
 `);
   console.log(`  User config:    ${paths.userConfig}`);
   console.log(`  Project config: ${paths.projectConfig}`);
-  if (fs4.existsSync(paths.projectConfig)) {
+  if (fs5.existsSync(paths.projectConfig)) {
     console.log(`
 Project configuration:`);
-    console.log(fs4.readFileSync(paths.projectConfig, "utf-8"));
+    console.log(fs5.readFileSync(paths.projectConfig, "utf-8"));
   }
-  if (fs4.existsSync(paths.userConfig)) {
+  if (fs5.existsSync(paths.userConfig)) {
     console.log(`
 User configuration:`);
-    console.log(fs4.readFileSync(paths.userConfig, "utf-8"));
+    console.log(fs5.readFileSync(paths.userConfig, "utf-8"));
   }
 }
 function configPath() {
@@ -1807,46 +2733,64 @@ function piSubagentsCommand(rest) {
       process.exit(1);
   }
 }
-var args = process.argv.slice(2);
-var command = args[0];
-switch (command) {
-  case "list":
-    listItems(args[1] || "skills");
-    break;
-  case "setup":
-    setupCommand(args.slice(1));
-    break;
-  case "pi-subagents":
-    piSubagentsCommand(args.slice(1));
-    break;
-  case "config":
-    switch (args[1]) {
-      case "show":
-      case undefined:
-        configShow();
-        break;
-      case "path":
-        configPath();
-        break;
-      default:
-        console.error(`Unknown config subcommand: ${args[1]}`);
-        console.log("Available: show, path");
-        process.exit(1);
+function runLegacyCli(args) {
+  const command = args[0];
+  switch (command) {
+    case "list":
+      listItems(args[1] || "skills");
+      break;
+    case "capabilities": {
+      const status = runCapabilitiesCli({
+        argv: ["systematic", ...args],
+        errorSink: console.error,
+        outputSink: console.log,
+        roots: defaultCapabilityRoots()
+      });
+      if (status !== 0)
+        process.exit(status);
+      break;
     }
-    break;
-  case "version":
-  case "--version":
-  case "-v":
-    console.log(`systematic v${VERSION}`);
-    break;
-  case "help":
-  case "--help":
-  case "-h":
-  case undefined:
-    console.log(HELP);
-    break;
-  default:
-    console.error(`Unknown command: ${command}`);
-    console.log(HELP);
-    process.exit(1);
+    case "setup":
+      setupCommand(args.slice(1));
+      break;
+    case "pi-subagents":
+      piSubagentsCommand(args.slice(1));
+      break;
+    case "config":
+      switch (args[1]) {
+        case "show":
+        case undefined:
+          configShow();
+          break;
+        case "path":
+          configPath();
+          break;
+        default:
+          console.error(`Unknown config subcommand: ${args[1]}`);
+          console.log("Available: show, path");
+          process.exit(1);
+      }
+      break;
+    case "version":
+    case "--version":
+    case "-v":
+      console.log(`systematic v${VERSION}`);
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+    case undefined:
+      console.log(HELP);
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      console.log(HELP);
+      process.exit(1);
+  }
+}
+if (import.meta.main) {
+  runLegacyCli(process.argv.slice(2));
 }
+export {
+  runCapabilitiesCli
+};