arcane-cli 1.16.0 → 1.17.0

package/dist/index.js

@@ -6,7 +6,7 @@ const require = __createRequire(import.meta.url);
 import { Command } from "commander";
 import { createRequire as createRequire3 } from "module";
 import { fileURLToPath } from "url";
-import { dirname as dirname14, join as join23 } from "path";
+import { dirname as dirname14, join as join29 } from "path";
 
 // src/commands/init.ts
 import { select as select3, confirm as confirm2, input as input3 } from "@inquirer/prompts";
@@ -62,6 +62,10 @@ var WRITE_SUBCOMMANDS = /* @__PURE__ */ new Set([
   "notes"
 ]);
 var AMBIGUOUS_AS_WRITE = /* @__PURE__ */ new Set(["branch", "config", "remote", "worktree"]);
+var AMBIGUOUS_READ_FORMS = {
+  worktree: /* @__PURE__ */ new Set(["list"]),
+  remote: /* @__PURE__ */ new Set(["get-url"])
+};
 var READ_SUBCOMMANDS = /* @__PURE__ */ new Set([
   "status",
   "rev-parse",
@@ -97,6 +101,7 @@ var DEFAULT_TIMEOUTS_MS = {
 };
 function classifyGitCommand(args) {
   let subcommand;
+  let form;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (GLOBAL_FLAGS_WITH_SEPARATE_VALUE.has(arg)) {
@@ -105,10 +110,12 @@ function classifyGitCommand(args) {
     }
     if (arg.startsWith("-")) continue;
     subcommand = arg;
+    form = args[i + 1];
     break;
   }
   if (!subcommand) return "read";
   if (NETWORK_SUBCOMMANDS.has(subcommand)) return "network";
+  if (form !== void 0 && AMBIGUOUS_READ_FORMS[subcommand]?.has(form)) return "read";
   if (WRITE_SUBCOMMANDS.has(subcommand) || AMBIGUOUS_AS_WRITE.has(subcommand)) return "write";
   if (READ_SUBCOMMANDS.has(subcommand)) return "read";
   return "write";
@@ -299,15 +306,15 @@ async function isUneditedTrackedFile(cwd, relativePath) {
 // src/modules/real-path.ts
 import { realpathSync } from "fs";
 import { basename, dirname, join, resolve } from "path";
-function resolveRealPath(path4) {
+function resolveRealPath(path5) {
   const missing = [];
-  let existing = path4;
+  let existing = path5;
   for (; ; ) {
     try {
       return join(realpathSync.native(existing), ...missing);
     } catch {
       const parent = dirname(existing);
-      if (parent === existing) return resolve(path4);
+      if (parent === existing) return resolve(path5);
       missing.unshift(basename(existing));
       existing = parent;
     }
@@ -1431,8 +1438,8 @@ var CLIENT_SHIM_PATH_PATTERNS = [
   /^\.claude\/commands\/spell-[a-z0-9-]+\.md$/,
   /^\.agents\/skills\/spell-[a-z0-9-]+\/SKILL\.md$/
 ];
-function isClientShimPath(path4) {
-  const normalized = path4.replace(/\\/g, "/").replace(/^\.\//, "");
+function isClientShimPath(path5) {
+  const normalized = path5.replace(/\\/g, "/").replace(/^\.\//, "");
   return CLIENT_SHIM_PATH_PATTERNS.some((pattern) => pattern.test(normalized));
 }
 var FRONTMATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
@@ -1515,11 +1522,11 @@ var STORE_SPELL_PATH_PATTERN = /^spells\/(spell-[a-z0-9-]+)\.md$/;
 function storeSpellPath(id) {
   return `${USER_TIER_SPELLS_DIR}/${id}.md`;
 }
-function spellIdFromCanonicalPath(path4) {
-  return path4.replace(/\\/g, "/").match(CANONICAL_SPELL_PATH_PATTERN)?.[1];
+function spellIdFromCanonicalPath(path5) {
+  return path5.replace(/\\/g, "/").match(CANONICAL_SPELL_PATH_PATTERN)?.[1];
 }
-function spellIdFromStorePath(path4) {
-  return path4.replace(/\\/g, "/").match(STORE_SPELL_PATH_PATTERN)?.[1];
+function spellIdFromStorePath(path5) {
+  return path5.replace(/\\/g, "/").match(STORE_SPELL_PATH_PATTERN)?.[1];
 }
 function absoluteStoreSpellPath(storeRoot, id) {
   return resolve2(storeRoot, storeSpellPath(id)).replace(/\\/g, "/");
@@ -1618,9 +1625,9 @@ async function renderUserFanout(storeRoot, spellIds, fallbackDir) {
   }
   return { files, missing };
 }
-async function classifyTarget(path4) {
+async function classifyTarget(path5) {
   try {
-    const stats = await lstat2(path4);
+    const stats = await lstat2(path5);
     return stats.isFile() ? "file" : "other";
   } catch (err) {
     if (err.code === "ENOENT") return "absent";
@@ -2231,29 +2238,29 @@ var AgentConfigValidationError = class extends Error {
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function requireRecord(value, path4, issues) {
+function requireRecord(value, path5, issues) {
   if (!isRecord2(value)) {
-    issues.push(`${path4} must be an object`);
+    issues.push(`${path5} must be an object`);
     return void 0;
   }
   return value;
 }
-function requireString(value, path4, issues) {
+function requireString(value, path5, issues) {
   if (typeof value !== "string" || value.trim().length === 0) {
-    issues.push(`${path4} must be a non-empty string`);
+    issues.push(`${path5} must be a non-empty string`);
   }
 }
-function requireBoolean(value, path4, issues) {
-  if (typeof value !== "boolean") issues.push(`${path4} must be a boolean`);
+function requireBoolean(value, path5, issues) {
+  if (typeof value !== "boolean") issues.push(`${path5} must be a boolean`);
 }
-function requireStringArray(value, path4, issues) {
+function requireStringArray(value, path5, issues) {
   if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
-    issues.push(`${path4} must be an array of strings`);
+    issues.push(`${path5} must be an array of strings`);
   }
 }
-function requireEnum(value, allowed, path4, issues) {
+function requireEnum(value, allowed, path5, issues) {
   if (typeof value !== "string" || !allowed.has(value)) {
-    issues.push(`${path4} must be one of: ${[...allowed].join(", ")}`);
+    issues.push(`${path5} must be one of: ${[...allowed].join(", ")}`);
   }
 }
 function validateOptionalClient(clients, key, property, expected, issues) {
@@ -5913,12 +5920,12 @@ ${verb} ${orphansToReport.length} orphaned file(s) (tracked before this update,
   if (conversions.length > 0) {
     console.log(`
   Converted ${conversions.length} symlinked managed file(s) to regular files (#357):`);
-    const describe = {
+    const describe3 = {
       "index-symlink": "the index tracked it as a symlink (mode 120000); rewritten and staged as a regular file",
       symlink: "was a symlink in the working tree; now a regular file (stage the typechange with git add)",
       "path-body": "its body was only a link target, a symlink written out as text; rewritten as a real file"
     };
-    for (const c of conversions) console.log(`    ${c.file} \u2014 ${describe[c.shape]}`);
+    for (const c of conversions) console.log(`    ${c.file} \u2014 ${describe3[c.shape]}`);
     if (conversions.some((c) => c.shape === "index-symlink")) {
       console.log(
         "  Commit the staged typechange, or every other checkout keeps reading a link whose target is the file's own text."
@@ -6103,6 +6110,56 @@ async function checkForUpdate(currentVersion, feedUrl, cachePath = DEFAULT_CACHE
   }
 }
 
+// src/modules/state/versions.ts
+function compareVersions(a, b) {
+  const parse3 = (v) => /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/.exec(v);
+  const pa = parse3(a);
+  const pb = parse3(b);
+  if (!pa || !pb) return a < b ? -1 : a > b ? 1 : 0;
+  for (let i = 1; i <= 3; i++) {
+    const diff = Number(pa[i]) - Number(pb[i]);
+    if (diff !== 0) return diff;
+  }
+  const sa = pa[4];
+  const sb = pb[4];
+  if (sa === sb) return 0;
+  if (sa === void 0) return 1;
+  if (sb === void 0) return -1;
+  return sa < sb ? -1 : 1;
+}
+async function collectVersions(manifest, packageVersion, options) {
+  const warnings = [];
+  let lookup = null;
+  if (options.online) {
+    let feedUrl = options.feedUrl ?? "";
+    if (feedUrl === "") {
+      try {
+        feedUrl = getFeedUrl();
+      } catch {
+        feedUrl = "";
+      }
+    }
+    lookup = feedUrl ? await checkForUpdate(packageVersion, feedUrl, options.cachePath) : { current: packageVersion, latest: null, updateAvailable: false, error: "Feed URL unavailable" };
+    if (lookup.latest === null) {
+      warnings.push(
+        `versions.latest: the npm lookup gave no answer${lookup.error ? ` (${lookup.error})` : ""}; latest and drift.cli_behind_latest are null`
+      );
+    }
+  }
+  const latest = lookup?.latest ?? null;
+  const versions = {
+    files: manifest.version,
+    cli: packageVersion,
+    latest,
+    drift: {
+      files_behind_cli: compareVersions(manifest.version, packageVersion) < 0,
+      cli_behind_latest: latest === null ? null : compareVersions(packageVersion, latest) < 0
+    },
+    components: manifest.components.map((component) => ({ name: component.name, installedVersion: component.installedVersion })).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)
+  };
+  return { versions, warnings, lookup };
+}
+
 // src/modules/diagram-generator.ts
 function generateVersionDriftDiagram(repoFilesVersion, installedCliVersion, npmLatestVersion) {
   if (repoFilesVersion === installedCliVersion && installedCliVersion === npmLatestVersion) {
@@ -6156,13 +6213,8 @@ async function runStatus(targetDir, packageVersion, options = {}) {
     console.log("No components installed.");
     return;
   }
-  let feedUrl;
-  try {
-    feedUrl = getFeedUrl();
-  } catch {
-    feedUrl = "";
-  }
-  const versionResult = feedUrl ? await checkForUpdate(packageVersion, feedUrl) : { current: packageVersion, latest: null, updateAvailable: false, error: "Feed URL unavailable" };
+  const { versions, lookup } = await collectVersions(manifest, packageVersion, { online: true });
+  const versionResult = lookup ?? { current: packageVersion, latest: null, updateAvailable: false };
   const nameWidth = Math.max(
     "Component".length,
     ...manifest.components.map((c) => c.name.length)
@@ -6219,25 +6271,25 @@ async function runStatus(targetDir, packageVersion, options = {}) {
     }
   }
   console.log("");
-  const latestStr = versionResult.error ? "unable to check" : versionResult.latest ?? manifest.version;
-  let footer = `  Installed: ${packageVersion}  Latest: ${latestStr}`;
+  const latestStr = versionResult.error ? "unable to check" : versions.latest ?? versions.files;
+  let footer = `  Installed: ${versions.cli}  Latest: ${latestStr}`;
   if (versionResult.updateAvailable) {
     footer += "  (spell update available)";
   }
   console.log(footer);
-  if (versionResult.latest !== null) {
+  if (versions.latest !== null) {
     const diagram = generateVersionDriftDiagram(
-      manifest.version,
-      packageVersion,
-      versionResult.latest
+      versions.files,
+      versions.cli,
+      versions.latest
     );
     if (diagram !== null) {
       console.log("");
       if (process.stdout.isTTY) {
         console.log("  Version drift:");
-        console.log(`    repo-files:    ${manifest.version}`);
-        console.log(`    installed-cli: ${packageVersion}`);
-        console.log(`    latest (npm):  ${versionResult.latest}`);
+        console.log(`    repo-files:    ${versions.files}`);
+        console.log(`    installed-cli: ${versions.cli}`);
+        console.log(`    latest (npm):  ${versions.latest}`);
       } else {
         console.log("```mermaid");
         console.log(diagram);
@@ -6252,9 +6304,1059 @@ async function runStatus(targetDir, packageVersion, options = {}) {
   }
 }
 
+// src/modules/state/agents.ts
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile11 } from "fs/promises";
+import { join as join13 } from "path";
+async function fileRevision(path5) {
+  try {
+    return `sha256:${createHash2("sha256").update(await readFile11(path5)).digest("hex")}`;
+  } catch {
+    return null;
+  }
+}
+async function collectAgents(targetDir, options = {}) {
+  let resolved;
+  try {
+    resolved = await resolveRoster(targetDir, "repo", options.homeDir);
+  } catch (error) {
+    if (error instanceof AgentRosterNotFoundError) return { agents: null, warnings: [] };
+    throw error;
+  }
+  const origin = resolved.fromUserTier ? "user" : "repo";
+  const warnings = [];
+  const entries = [];
+  for (const entry of resolved.roster.roster) {
+    const definitionPath = join13(resolved.definitionsDir, `${entry.definition}.yaml`);
+    const definition_revision = await fileRevision(definitionPath);
+    if (definition_revision === null) {
+      warnings.push(`agents: the definition file for "${entry.definition}" (${entry.id}) is missing from its definitions directory; definition_revision is null`);
+    }
+    entries.push({
+      definition: entry.definition,
+      name: entry.name,
+      id: entry.id,
+      epithet: entry.epithet ?? null,
+      origin,
+      definition_revision
+    });
+  }
+  return {
+    agents: {
+      schema: "roster-v2",
+      naming_strategy: resolved.roster.naming_strategy,
+      agent_profile: resolved.roster.agent_profile,
+      entries
+    },
+    warnings
+  };
+}
+
+// src/modules/state/books.ts
+import { createHash as createHash3 } from "crypto";
+import { readFile as readFile13 } from "fs/promises";
+import { join as join15 } from "path";
+
+// src/modules/state/decisions.ts
+import { readFile as readFile12 } from "fs/promises";
+import { join as join14 } from "path";
+var HEADING = /^## ([A-Z]{2,5})-(\d{3,})\b(.*)$/gm;
+function headingAnchor(heading) {
+  return heading.trim().toLowerCase().replace(/[^\p{L}\p{N} _-]/gu, "").replace(/ /g, "-");
+}
+function titleAfterId(rest) {
+  return rest.replace(/^\s*[—–:-]+\s*/u, "").trim();
+}
+function parseDecisions(content) {
+  const text = content.replace(/\r\n?/g, "\n");
+  const positions = [];
+  let match;
+  HEADING.lastIndex = 0;
+  while ((match = HEADING.exec(text)) !== null) {
+    positions.push({ id: `${match[1]}-${match[2]}`, heading: `${match[1]}-${match[2]}${match[3]}`, index: match.index });
+  }
+  const entries = [];
+  const warnings = [];
+  positions.forEach(({ id, heading, index }, i) => {
+    const end = i + 1 < positions.length ? positions[i + 1].index : text.length;
+    const section = text.slice(index, end);
+    const dateMatch = /^\*\*Date:\*\*\s*(\d{4}-\d{2}-\d{2})/m.exec(section);
+    const statusMatch = /^\*\*Status:\*\*\s*(\S+)/m.exec(section);
+    if (!dateMatch && !statusMatch) {
+      warnings.push(`indexes.decisions: ${id} has no **Date:** or **Status:** line and was skipped`);
+      return;
+    }
+    entries.push({
+      id,
+      title: titleAfterId(heading.slice(id.length)),
+      status: statusMatch ? statusMatch[1] : null,
+      date: dateMatch ? dateMatch[1] : null,
+      anchor: headingAnchor(heading)
+    });
+  });
+  return { entries, warnings };
+}
+function parseAdrs(decisionsContent) {
+  return parseDecisions(decisionsContent).entries.map(({ id, date, status }) => ({ id, date, status }));
+}
+function countAcceptedAdrsInWindow(adrs, fromDate, toDate) {
+  return adrs.filter(
+    (adr) => adr.status === "Accepted" && adr.date !== null && adr.date >= fromDate && adr.date <= toDate
+  ).length;
+}
+async function collectDecisions(root) {
+  let content;
+  try {
+    content = await readFile12(join14(root, "DECISIONS.md"), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return { decisions: null, warnings: [] };
+    return {
+      decisions: null,
+      warnings: [`indexes.decisions: DECISIONS.md could not be read (${error instanceof Error ? error.message : String(error)})`]
+    };
+  }
+  const { entries, warnings } = parseDecisions(content);
+  return {
+    decisions: entries.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0),
+    warnings
+  };
+}
+
+// src/modules/state/books.ts
+var ITEM = /^\s*- \[( |x|X)\] (.*)$/;
+var HEADING2 = /^#{1,6}\s+(.+?)\s*#*\s*$/;
+var TEXT_LIMIT = 200;
+function normalizeItemText(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function itemLocator(section, text) {
+  const slug = section === null ? "" : headingAnchor(section);
+  const hash = createHash3("sha256").update(normalizeItemText(text), "utf8").digest("hex").slice(0, 12);
+  return `${slug === "" ? "root" : slug}/${hash}`;
+}
+function parseBook(content) {
+  const items = [];
+  let section = null;
+  let open = 0;
+  let done = 0;
+  for (const line of content.split(/\r?\n/)) {
+    const heading = HEADING2.exec(line);
+    if (heading) {
+      section = heading[1];
+      continue;
+    }
+    const item = ITEM.exec(line);
+    if (!item) continue;
+    const checked = item[1] !== " ";
+    const text = item[2].trim();
+    if (checked) done++;
+    else open++;
+    items.push({
+      text: text.length > TEXT_LIMIT ? text.slice(0, TEXT_LIMIT) : text,
+      section,
+      locator: itemLocator(section, text),
+      checked
+    });
+  }
+  return { open, done, items };
+}
+async function collectBook(root, fileName) {
+  let content;
+  try {
+    content = await readFile13(join15(root, fileName), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return { book: null, warnings: [] };
+    return {
+      book: null,
+      warnings: [`indexes: ${fileName} could not be read (${error instanceof Error ? error.message : String(error)})`]
+    };
+  }
+  return { book: parseBook(content), warnings: [] };
+}
+
+// src/modules/state/config.ts
+function collectConfig(manifest) {
+  return {
+    tracking_mode: manifest.tracking_mode ?? null,
+    external_provider: manifest.external_provider ?? null,
+    push_policy: manifest.push_policy ?? null,
+    role: manifest.role ?? null,
+    business_root: manifest.business_root ?? null,
+    spell_scope: manifest.spell_scope ?? null,
+    content_sensitivity: manifest.content_sensitivity ?? null
+  };
+}
+
+// src/modules/state/features.ts
+import { readdir as readdir7, readFile as readFile14 } from "fs/promises";
+import { join as join16 } from "path";
+import { parse as parse2 } from "yaml";
+var FEATURES_DIR = "features";
+var PRD_FILE = "PRD.md";
+var FRONTMATTER = /^(?:# [^\n]*\n+)?---\n([\s\S]*?)\n---(?:\n|$)/;
+var H1 = /^# (.+?)\s*$/m;
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringOrNull(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return null;
+}
+function idOrNull(value) {
+  if (typeof value === "number" || typeof value === "string") return value;
+  return null;
+}
+function featureTracking(frontmatter) {
+  const nested = frontmatter["tracking"];
+  const source = isRecord3(nested) ? nested : "tracking_mode" in frontmatter || "external_provider" in frontmatter ? frontmatter : null;
+  if (source === null) return null;
+  return {
+    tracking_mode: stringOrNull(source["tracking_mode"]),
+    external_provider: stringOrNull(source["external_provider"]),
+    adoWorkItemId: idOrNull(source["adoWorkItemId"]),
+    githubIssueId: idOrNull(source["githubIssueId"])
+  };
+}
+function parsePrd(content, displayPath) {
+  const text = content.replace(/\r\n?/g, "\n");
+  const heading = H1.exec(text);
+  const empty = { title: heading ? heading[1] : null, status: null, implementation_status: null, tracking: null };
+  const match = FRONTMATTER.exec(text);
+  if (!match) return { fields: empty, warning: `features: ${displayPath} has no frontmatter` };
+  let parsed;
+  try {
+    parsed = parse2(match[1]);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message.split("\n")[0] : String(error);
+    return { fields: empty, warning: `features: ${displayPath} has malformed frontmatter (${reason})` };
+  }
+  if (!isRecord3(parsed)) return { fields: empty, warning: `features: ${displayPath} has frontmatter that is not a map` };
+  return {
+    fields: {
+      title: stringOrNull(parsed["title"]) ?? empty.title,
+      status: stringOrNull(parsed["status"]),
+      implementation_status: stringOrNull(parsed["implementation_status"]),
+      tracking: featureTracking(parsed)
+    },
+    warning: null
+  };
+}
+async function collectFeatures(root) {
+  const dir = join16(root, FEATURES_DIR);
+  let slugs;
+  try {
+    const entries = await readdir7(dir, { withFileTypes: true });
+    slugs = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name);
+  } catch (error) {
+    if (error.code === "ENOENT") return { features: null, warnings: [] };
+    return {
+      features: null,
+      warnings: [`features: ${FEATURES_DIR}/ could not be read (${error instanceof Error ? error.message : String(error)})`]
+    };
+  }
+  const warnings = [];
+  const features = [];
+  for (const slug of slugs) {
+    const path5 = `${FEATURES_DIR}/${slug}/${PRD_FILE}`;
+    let content;
+    try {
+      content = await readFile14(join16(dir, slug, PRD_FILE), "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") continue;
+      warnings.push(`features: ${path5} could not be read (${error instanceof Error ? error.message : String(error)})`);
+      continue;
+    }
+    const { fields, warning } = parsePrd(content, path5);
+    if (warning !== null) warnings.push(warning);
+    features.push({ slug, ...fields, path: path5 });
+  }
+  features.sort((a, b) => a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0);
+  return { features, warnings };
+}
+
+// src/modules/state/serialize.ts
+import path4 from "path";
+var object = (keys) => ({ kind: "object", keys });
+var array = (items, sortBy) => ({
+  kind: "array",
+  items,
+  ...sortBy === void 0 ? {} : { sortBy }
+});
+var book = object({
+  open: void 0,
+  done: void 0,
+  items: array(object({ text: void 0, section: void 0, locator: void 0, checked: void 0 }))
+});
+var STATE_SHAPE = object({
+  schema_version: void 0,
+  generated_at: void 0,
+  generator: object({ name: void 0, version: void 0 }),
+  repository: object({ root: void 0, scope: void 0, role: void 0, profile: void 0 }),
+  versions: object({
+    files: void 0,
+    cli: void 0,
+    latest: void 0,
+    drift: object({ files_behind_cli: void 0, cli_behind_latest: void 0 }),
+    components: array(object({ name: void 0, installedVersion: void 0 }), ["name"])
+  }),
+  git: object({
+    branch: void 0,
+    detached: void 0,
+    trunk: void 0,
+    ahead: void 0,
+    behind: void 0,
+    uncommitted: void 0,
+    remote: object({ provider: void 0, url: void 0 }),
+    worktrees: array(object({ path: void 0, branch: void 0 }), ["path"]),
+    pull_request: object({ id: void 0, url: void 0, state: void 0 })
+  }),
+  indexes: object({
+    decisions: array(
+      object({ id: void 0, title: void 0, status: void 0, date: void 0, anchor: void 0 }),
+      ["id"]
+    ),
+    todos: book,
+    ideas: book,
+    done: book,
+    journal: array(object({ date: void 0, slug: void 0, title: void 0, path: void 0 }), ["date", "slug"])
+  }),
+  config: object({
+    tracking_mode: void 0,
+    external_provider: void 0,
+    push_policy: void 0,
+    role: void 0,
+    business_root: void 0,
+    spell_scope: void 0,
+    content_sensitivity: void 0
+  }),
+  registry: object({
+    updated: void 0,
+    ventures: array(
+      object({
+        slug: void 0,
+        name: void 0,
+        aliases: void 0,
+        status: void 0,
+        visibility: void 0,
+        ownership: void 0,
+        tracking: void 0,
+        repos: array(object({ name: void 0, remote: void 0, default: void 0, local_path: void 0 }))
+      }),
+      ["slug"]
+    )
+  }),
+  features: array(
+    object({
+      slug: void 0,
+      title: void 0,
+      status: void 0,
+      implementation_status: void 0,
+      tracking: object({
+        tracking_mode: void 0,
+        external_provider: void 0,
+        adoWorkItemId: void 0,
+        githubIssueId: void 0
+      }),
+      path: void 0
+    }),
+    ["slug"]
+  ),
+  agents: object({
+    schema: void 0,
+    naming_strategy: void 0,
+    agent_profile: void 0,
+    entries: array(
+      object({
+        definition: void 0,
+        name: void 0,
+        id: void 0,
+        epithet: void 0,
+        origin: void 0,
+        definition_revision: void 0
+      })
+    )
+  }),
+  warnings: array(void 0, [])
+});
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function compareScalars(a, b) {
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  const left = String(a);
+  const right = String(b);
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function sortedBy(values, keys) {
+  const indexed = values.map((value, index) => ({ value, index }));
+  indexed.sort((a, b) => {
+    for (const key of keys) {
+      const result = compareScalars(
+        isRecord4(a.value) ? a.value[key] : void 0,
+        isRecord4(b.value) ? b.value[key] : void 0
+      );
+      if (result !== 0) return result;
+    }
+    return a.index - b.index;
+  });
+  return indexed.map((entry) => entry.value);
+}
+function canonicalize(value, shape) {
+  if (value === null || value === void 0 || shape === void 0) return value;
+  if (shape.kind === "array") {
+    if (!Array.isArray(value)) return value;
+    const items = value.map((item) => canonicalize(item, shape.items));
+    if (shape.sortBy === void 0) return items;
+    if (shape.sortBy.length === 0) return [...items].sort(compareScalars);
+    return sortedBy(items, shape.sortBy);
+  }
+  if (!isRecord4(value)) return value;
+  const ordered = {};
+  for (const [key, keyShape] of Object.entries(shape.keys)) {
+    if (!(key in value) || value[key] === void 0) continue;
+    ordered[key] = canonicalize(value[key], keyShape);
+  }
+  for (const [key, extra] of Object.entries(value)) {
+    if (key in ordered || key in shape.keys || extra === void 0) continue;
+    ordered[key] = extra;
+  }
+  return ordered;
+}
+function serializeState(doc) {
+  return `${JSON.stringify(canonicalize(doc, STATE_SHAPE), null, 2)}
+`;
+}
+function toPosixRelative(root, target) {
+  const relative4 = path4.relative(root, target);
+  if (relative4 === "") return ".";
+  if (path4.isAbsolute(relative4)) return relative4.replace(/\\/g, "/");
+  return relative4.split(path4.sep).join("/");
+}
+
+// src/modules/state/git.ts
+function remoteProvider(url) {
+  const host = remoteHost(url).toLowerCase();
+  if (host === "github.com" || host.endsWith(".github.com")) return "github";
+  if (host === "dev.azure.com" || host.endsWith(".dev.azure.com") || host.endsWith(".visualstudio.com")) return "ado";
+  return "other";
+}
+function remoteHost(url) {
+  const scheme = /^[a-z][a-z0-9+.-]*:\/\/(?:[^@/]*@)?([^/:]+)/i.exec(url);
+  if (scheme) return scheme[1];
+  const scp = /^(?:[^@/]+@)?([^:/]+):/.exec(url);
+  return scp ? scp[1] : "";
+}
+function stripUserinfo(url) {
+  return url.replace(/^([a-z][a-z0-9+.-]*:\/\/)[^@/]*@/i, "$1");
+}
+function parseWorktreeList(porcelain, root) {
+  const worktrees = [];
+  for (const block of porcelain.replace(/\r\n/g, "\n").split(/\n\n+/)) {
+    const lines = block.split("\n").filter((line) => line.length > 0);
+    const pathLine = lines.find((line) => line.startsWith("worktree "));
+    if (!pathLine) continue;
+    const branchLine = lines.find((line) => line.startsWith("branch "));
+    const branch = branchLine ? branchLine.slice("branch ".length).replace(/^refs\/heads\//, "") : null;
+    const absolute = resolveRealPath(pathLine.slice("worktree ".length));
+    worktrees.push({ path: toPosixRelative(root, absolute), branch });
+  }
+  return worktrees.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+async function probe(read) {
+  try {
+    return { ok: true, value: await read() };
+  } catch (error) {
+    return { ok: false, error };
+  }
+}
+function describe(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function collectGit(cwd, root, options = {}) {
+  const git = options.runGit ?? runGit;
+  const warnings = [];
+  const inside = await probe(() => git(cwd, ["rev-parse", "--is-inside-work-tree"]));
+  if (!inside.ok || inside.value.stdout.trim() !== "true") {
+    warnings.push(
+      inside.ok ? "git: not a git repository; the git section is null" : `git: could not determine whether this is a git repository (${describe(inside.error)}); the git section is null`
+    );
+    return { git: null, warnings };
+  }
+  let branch = null;
+  let detached = false;
+  const symbolic = await probe(() => git(cwd, ["symbolic-ref", "--short", "-q", "HEAD"]));
+  if (symbolic.ok && symbolic.value.stdout.trim() !== "") {
+    branch = symbolic.value.stdout.trim();
+  } else {
+    const head = await probe(() => git(cwd, ["rev-parse", "--short", "HEAD"]));
+    if (head.ok) {
+      branch = head.value.stdout.trim();
+      detached = true;
+    } else {
+      warnings.push(`git.branch: HEAD could not be read (${describe(head.error)})`);
+    }
+  }
+  let trunk = null;
+  const originHead = await probe(() => git(cwd, ["symbolic-ref", "--short", "-q", "refs/remotes/origin/HEAD"]));
+  if (originHead.ok && originHead.value.stdout.trim() !== "") {
+    trunk = originHead.value.stdout.trim().replace(/^origin\//, "");
+  } else {
+    for (const candidate of ["main", "master"]) {
+      const exists = await probe(() => git(cwd, ["rev-parse", "--verify", "--quiet", `refs/heads/${candidate}`]));
+      if (exists.ok) {
+        trunk = candidate;
+        break;
+      }
+    }
+  }
+  let ahead = null;
+  let behind = null;
+  const upstream = await probe(() => git(cwd, ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"]));
+  if (upstream.ok) {
+    const counts = await probe(() => git(cwd, ["rev-list", "--left-right", "--count", "@{upstream}...HEAD"]));
+    if (counts.ok) {
+      const [left, right] = counts.value.stdout.trim().split(/\s+/);
+      behind = Number.parseInt(left, 10);
+      ahead = Number.parseInt(right, 10);
+      if (Number.isNaN(ahead) || Number.isNaN(behind)) {
+        ahead = behind = null;
+        warnings.push(`git.ahead/behind: unexpected rev-list output "${counts.value.stdout.trim()}"`);
+      }
+    } else {
+      warnings.push(`git.ahead/behind: rev-list failed (${describe(counts.error)})`);
+    }
+  } else if (isTimeout(upstream.error)) {
+    warnings.push(`git.ahead/behind: ${describe(upstream.error)}`);
+  }
+  let uncommitted = null;
+  const status = await probe(() => git(cwd, ["status", "--porcelain", "-uall"]));
+  if (status.ok) {
+    const lines = status.value.stdout.trim();
+    uncommitted = lines.length === 0 ? 0 : lines.split("\n").length;
+  } else {
+    warnings.push(`git.uncommitted: status failed (${describe(status.error)})`);
+  }
+  let remote = null;
+  const remotes = await probe(() => git(cwd, ["remote"], { commandClass: "read" }));
+  if (!remotes.ok) {
+    warnings.push(`git.remote: remote list failed (${describe(remotes.error)})`);
+  } else if (remotes.value.stdout.split(/\r?\n/).includes("origin")) {
+    const url = await probe(() => git(cwd, ["remote", "get-url", "origin"]));
+    if (url.ok) {
+      const raw = url.value.stdout.trim();
+      remote = { provider: remoteProvider(raw), url: stripUserinfo(raw) };
+    } else {
+      warnings.push(`git.remote: remote get-url failed (${describe(url.error)})`);
+    }
+  }
+  let worktrees = null;
+  const list = await probe(() => git(cwd, ["worktree", "list", "--porcelain"]));
+  if (list.ok) {
+    worktrees = parseWorktreeList(list.value.stdout, root);
+  } else {
+    warnings.push(`git.worktrees: worktree list failed (${describe(list.error)})`);
+  }
+  return {
+    git: { branch, detached, trunk, ahead, behind, uncommitted, remote, worktrees, pull_request: null },
+    warnings
+  };
+}
+function isTimeout(error) {
+  return error instanceof Error && error.name === "GitTimeoutError";
+}
+
+// src/modules/state/journal.ts
+import { readdir as readdir8, readFile as readFile15 } from "fs/promises";
+import { join as join17 } from "path";
+var JOURNAL_DIR = "journal";
+var ENTRY_NAME = /^(\d{4}-\d{2}-\d{2})-(.+)\.md$/;
+function journalTitle(content) {
+  const text = content.replace(/\r\n?/g, "\n");
+  const frontmatter = /^---\n([\s\S]*?)\n---/.exec(text);
+  if (frontmatter) {
+    const title = /^title:\s*(.+)$/m.exec(frontmatter[1]);
+    if (title) return title[1].trim().replace(/^(["'])(.*)\1$/, "$2");
+  }
+  const heading = /^# (.+?)\s*$/m.exec(text);
+  return heading ? heading[1].trim() : null;
+}
+async function collectJournal(root) {
+  const dir = join17(root, JOURNAL_DIR);
+  let names;
+  try {
+    const entries = await readdir8(dir, { withFileTypes: true });
+    names = entries.filter((entry) => entry.isFile() && !entry.name.startsWith(".")).map((entry) => entry.name);
+  } catch (error) {
+    if (error.code === "ENOENT") return { journal: null, warnings: [] };
+    return {
+      journal: null,
+      warnings: [`indexes.journal: ${JOURNAL_DIR}/ could not be read (${error instanceof Error ? error.message : String(error)})`]
+    };
+  }
+  const warnings = [];
+  const journal = [];
+  for (const name of names) {
+    const match = ENTRY_NAME.exec(name);
+    if (!match) {
+      warnings.push(`indexes.journal: ${JOURNAL_DIR}/${name} does not match YYYY-MM-DD-<slug>.md and was skipped`);
+      continue;
+    }
+    let title = null;
+    try {
+      title = journalTitle(await readFile15(join17(dir, name), "utf8"));
+    } catch (error) {
+      warnings.push(`indexes.journal: ${JOURNAL_DIR}/${name} could not be read (${error instanceof Error ? error.message : String(error)})`);
+    }
+    if (title === null) warnings.push(`indexes.journal: ${JOURNAL_DIR}/${name} has no title: frontmatter or # heading`);
+    journal.push({ date: match[1], slug: match[2], title, path: `${JOURNAL_DIR}/${name}` });
+  }
+  journal.sort((a, b) => a.date < b.date ? -1 : a.date > b.date ? 1 : a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0);
+  return { journal, warnings };
+}
+
+// src/modules/exec.ts
+import { execFile as execFile2 } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { win32 } from "path";
+var EXTERNAL_CLI_TIMEOUT_MS = 1e4;
+function execFileWithTimeout(file, args, timeoutMs, options = {}) {
+  return new Promise((resolve10, reject) => {
+    const child = execFile2(
+      file,
+      args,
+      {
+        timeout: timeoutMs,
+        killSignal: "SIGTERM",
+        windowsHide: true,
+        encoding: "utf8",
+        ...options.env ? { env: { ...process.env, ...options.env } } : {}
+      },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve10({ stdout, stderr });
+      }
+    );
+    child.stdin?.end();
+  });
+}
+function defaultProbes() {
+  return {
+    platform: process.platform,
+    pathEnv: process.env["PATH"] ?? process.env["Path"],
+    readText: (path5) => {
+      try {
+        return readFileSync(path5, "utf8");
+      } catch {
+        return void 0;
+      }
+    },
+    exists: (path5) => existsSync(path5)
+  };
+}
+var MSI_LAUNCHER_LINE = /^\s*"%~dp0\\\.\.\\python\.exe"\s+-IBm\s+azure\.cli\s+%\*\s*$/im;
+function resolveAzureCli(probes = defaultProbes()) {
+  const plain = { file: "az", prefixArgs: [] };
+  if (probes.platform !== "win32") return plain;
+  for (const raw of (probes.pathEnv ?? "").split(";")) {
+    const dir = raw.trim().replace(/^"(.*)"$/, "$1");
+    if (!dir || !win32.isAbsolute(dir)) continue;
+    const launcher = probes.readText(win32.join(dir, "az.cmd"));
+    if (launcher === void 0) continue;
+    if (!MSI_LAUNCHER_LINE.test(launcher)) return plain;
+    const interpreter = win32.resolve(dir, "..", "python.exe");
+    if (!probes.exists(interpreter)) return plain;
+    return { file: interpreter, prefixArgs: ["-IBm", "azure.cli"], env: { AZ_INSTALLER: "MSI" } };
+  }
+  return plain;
+}
+
+// src/modules/state/pull-request.ts
+function parseAdoRemote(url) {
+  const https = /^https?:\/\/(?:[^@/]*@)?dev\.azure\.com\/([^/]+)\/([^/]+)\/_git\/([^/?#]+)/i.exec(url);
+  if (https) return { org: https[1], project: decodeURIComponent(https[2]), repo: decodeURIComponent(https[3]) };
+  const legacy = /^https?:\/\/(?:[^@/]*@)?([^./]+)\.visualstudio\.com\/(?:DefaultCollection\/)?([^/]+)\/_git\/([^/?#]+)/i.exec(url);
+  if (legacy) return { org: legacy[1], project: decodeURIComponent(legacy[2]), repo: decodeURIComponent(legacy[3]) };
+  const ssh = /^(?:ssh:\/\/)?git@(?:ssh\.|vs-ssh\.)?(?:dev\.azure\.com|visualstudio\.com)[:/]v3\/([^/]+)\/([^/]+)\/([^/?#]+)/i.exec(url);
+  if (ssh) return { org: ssh[1], project: decodeURIComponent(ssh[2]), repo: decodeURIComponent(ssh[3]) };
+  return null;
+}
+function describe2(error) {
+  if (error instanceof Error) {
+    const code = error.code;
+    if (code === "ENOENT") return "the CLI is not installed";
+    if (error.killed) return `timed out after ${EXTERNAL_CLI_TIMEOUT_MS}ms`;
+    return error.message.split("\n")[0];
+  }
+  return String(error);
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function lookupGitHub(branch, exec) {
+  let stdout;
+  try {
+    ({ stdout } = await exec("gh", ["pr", "list", "--head", branch, "--state", "open", "--json", "number,url,state"], EXTERNAL_CLI_TIMEOUT_MS));
+  } catch (error) {
+    return { pull_request: null, warnings: [`git.pull_request: gh pr list failed (${describe2(error)})`] };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return { pull_request: null, warnings: ["git.pull_request: gh pr list printed something other than JSON"] };
+  }
+  if (!Array.isArray(parsed)) return { pull_request: null, warnings: ["git.pull_request: gh pr list printed something other than a list"] };
+  const first = parsed.find(isRecord5);
+  if (!first) return { pull_request: null, warnings: [] };
+  if (typeof first["number"] !== "number" || typeof first["url"] !== "string" || typeof first["state"] !== "string") {
+    return { pull_request: null, warnings: ["git.pull_request: gh pr list printed an entry without number, url and state"] };
+  }
+  return { pull_request: { id: first["number"], url: first["url"], state: first["state"] }, warnings: [] };
+}
+async function lookupAdo(branch, remoteUrl, exec, launch) {
+  const coordinates = parseAdoRemote(remoteUrl);
+  if (!coordinates) {
+    return { pull_request: null, warnings: ["git.pull_request: the Azure DevOps remote URL names no organization, project and repository"] };
+  }
+  const orgUrl = `https://dev.azure.com/${coordinates.org}`;
+  let stdout;
+  try {
+    ({ stdout } = await exec(
+      launch.file,
+      [
+        ...launch.prefixArgs,
+        "repos",
+        "pr",
+        "list",
+        "--source-branch",
+        branch,
+        "--status",
+        "active",
+        "--org",
+        orgUrl,
+        "--project",
+        coordinates.project,
+        "--repository",
+        coordinates.repo,
+        "--output",
+        "json"
+      ],
+      EXTERNAL_CLI_TIMEOUT_MS,
+      launch.env ? { env: launch.env } : {}
+    ));
+  } catch (error) {
+    return { pull_request: null, warnings: [`git.pull_request: az repos pr list failed (${describe2(error)})`] };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return { pull_request: null, warnings: ["git.pull_request: az repos pr list printed something other than JSON"] };
+  }
+  if (!Array.isArray(parsed)) return { pull_request: null, warnings: ["git.pull_request: az repos pr list printed something other than a list"] };
+  const first = parsed.find(isRecord5);
+  if (!first) return { pull_request: null, warnings: [] };
+  const id = first["pullRequestId"];
+  const status = first["status"];
+  if (typeof id !== "number" || typeof status !== "string") {
+    return { pull_request: null, warnings: ["git.pull_request: az repos pr list printed an entry without pullRequestId and status"] };
+  }
+  return {
+    pull_request: {
+      id,
+      url: `${orgUrl}/${encodeURIComponent(coordinates.project)}/_git/${encodeURIComponent(coordinates.repo)}/pullrequest/${id}`,
+      state: status
+    },
+    warnings: []
+  };
+}
+async function collectPullRequest(git, options = {}) {
+  const exec = options.exec ?? execFileWithTimeout;
+  if (git.remote === null) return { pull_request: null, warnings: [] };
+  if (git.branch === null || git.detached) {
+    return { pull_request: null, warnings: ["git.pull_request: no branch is checked out, so there is nothing to look up"] };
+  }
+  switch (git.remote.provider) {
+    case "github":
+      return lookupGitHub(git.branch, exec);
+    case "ado":
+      return lookupAdo(git.branch, git.remote.url, exec, options.azureLaunch ?? resolveAzureCli());
+    default:
+      return { pull_request: null, warnings: [`git.pull_request: no pull-request lookup for a ${git.remote.provider} remote`] };
+  }
+}
+
+// src/modules/state/registry.ts
+import { readFile as readFile16 } from "fs/promises";
+import { hostname } from "os";
+import { join as join18 } from "path";
+var DEFAULT_BUSINESS_ROOT = "ventures";
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringOrNull2(value) {
+  return typeof value === "string" ? value : null;
+}
+function localPathFor(clones, machine) {
+  if (!isRecord6(clones)) return null;
+  const wanted = machine.toLowerCase();
+  for (const [key, value] of Object.entries(clones)) {
+    if (key.toLowerCase() === wanted) return typeof value === "string" ? value : null;
+  }
+  return null;
+}
+function repoEntry(raw, options, machine) {
+  const repo = isRecord6(raw) ? raw : {};
+  const entry = {
+    name: stringOrNull2(repo["name"]),
+    remote: stringOrNull2(repo["remote"]),
+    default: repo["default"] === true
+  };
+  if (options.includeLocalPaths) entry.local_path = localPathFor(repo["clones"], machine);
+  return entry;
+}
+function ventureEntry(slug, raw, options, machine) {
+  const venture = isRecord6(raw) ? raw : {};
+  const aliases = Array.isArray(venture["aliases"]) ? venture["aliases"].filter((a) => typeof a === "string") : [];
+  const repos = Array.isArray(venture["repos"]) ? venture["repos"].map((repo) => repoEntry(repo, options, machine)) : [];
+  return {
+    slug,
+    name: stringOrNull2(venture["name"]),
+    aliases,
+    status: stringOrNull2(venture["status"]),
+    visibility: stringOrNull2(venture["visibility"]),
+    ownership: stringOrNull2(venture["ownership"]),
+    tracking: venture["tracking"] ?? null,
+    repos
+  };
+}
+function parseRegistry(raw, options) {
+  const machine = options.hostname ?? hostname();
+  const registry = isRecord6(raw) ? raw : {};
+  const ventures = [];
+  const source = registry["ventures"];
+  if (Array.isArray(source)) {
+    for (const entry of source) {
+      if (isRecord6(entry) && typeof entry["slug"] === "string") ventures.push(ventureEntry(entry["slug"], entry, options, machine));
+    }
+  } else if (isRecord6(source)) {
+    for (const [slug, entry] of Object.entries(source)) ventures.push(ventureEntry(slug, entry, options, machine));
+  }
+  ventures.sort((a, b) => a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0);
+  return { updated: stringOrNull2(registry["updated"]), ventures };
+}
+async function collectRegistry(root, manifest, options) {
+  if (manifest.role !== "hub") return { registry: null, warnings: [] };
+  const businessRoot = manifest.business_root ?? DEFAULT_BUSINESS_ROOT;
+  const relativePath = `${businessRoot}/registry.json`;
+  let content;
+  try {
+    content = await readFile16(join18(root, businessRoot, "registry.json"), "utf8");
+  } catch (error) {
+    const reason = error.code === "ENOENT" ? "is missing" : `could not be read (${error instanceof Error ? error.message : String(error)})`;
+    return { registry: null, warnings: [`registry: this repository is a hub but ${relativePath} ${reason}`] };
+  }
+  let raw;
+  try {
+    raw = JSON.parse(content);
+  } catch (error) {
+    return {
+      registry: null,
+      warnings: [`registry: ${relativePath} is not valid JSON (${error instanceof Error ? error.message : String(error)})`]
+    };
+  }
+  return { registry: parseRegistry(raw, options), warnings: [] };
+}
+
+// src/modules/state/types.ts
+var STATE_SCHEMA_VERSION = "1.0.0";
+
+// src/modules/state/collect.ts
+async function guarded(section, warnings, run, fallback) {
+  try {
+    const result = await run();
+    warnings.push(...result.warnings);
+    return result.value;
+  } catch (error) {
+    if (error instanceof AgentConfigValidationError) throw error;
+    warnings.push(`${section}: collector failed (${error instanceof Error ? error.message : String(error)}); the section is null`);
+    return fallback;
+  }
+}
+async function collectState(cwd, packageVersion, options) {
+  const manifest = await readManifest(cwd);
+  const root = resolveRealPath(cwd);
+  const warnings = [];
+  const resolvedScope = resolveInstallScope(cwd, manifest.scope, false);
+  if (resolvedScope.misplacedUserManifest) warnings.push(`repository.scope: ${misplacedUserManifestMessage(cwd)}`);
+  const versions = await guarded(
+    "versions",
+    warnings,
+    async () => {
+      const result = await collectVersions(manifest, packageVersion, {
+        online: options.online,
+        ...options.feedUrl === void 0 ? {} : { feedUrl: options.feedUrl },
+        ...options.cachePath === void 0 ? {} : { cachePath: options.cachePath }
+      });
+      return { value: result.versions, warnings: result.warnings };
+    },
+    {
+      files: manifest.version,
+      cli: packageVersion,
+      latest: null,
+      drift: { files_behind_cli: false, cli_behind_latest: null },
+      components: []
+    }
+  );
+  const git = await guarded(
+    "git",
+    warnings,
+    async () => {
+      const result = await collectGit(cwd, root, options.runGit === void 0 ? {} : { runGit: options.runGit });
+      return { value: result.git, warnings: result.warnings };
+    },
+    null
+  );
+  if (options.online && git !== null) {
+    git.pull_request = await guarded(
+      "git.pull_request",
+      warnings,
+      async () => {
+        const result = await collectPullRequest(git, options.exec === void 0 ? {} : { exec: options.exec });
+        return { value: result.pull_request, warnings: result.warnings };
+      },
+      null
+    );
+  }
+  const decisions = await guarded(
+    "indexes.decisions",
+    warnings,
+    async () => {
+      const result = await collectDecisions(root);
+      return { value: result.decisions, warnings: result.warnings };
+    },
+    null
+  );
+  const book2 = (fileName) => guarded(
+    `indexes.${fileName}`,
+    warnings,
+    async () => {
+      const result = await collectBook(root, fileName);
+      return { value: result.book, warnings: result.warnings };
+    },
+    null
+  );
+  const todos = await book2("TODO.md");
+  const ideas = await book2("IDEAS.md");
+  const done = await book2("DONE.md");
+  const journal = await guarded(
+    "indexes.journal",
+    warnings,
+    async () => {
+      const result = await collectJournal(root);
+      return { value: result.journal, warnings: result.warnings };
+    },
+    null
+  );
+  const registry = await guarded(
+    "registry",
+    warnings,
+    async () => {
+      const result = await collectRegistry(root, manifest, {
+        includeLocalPaths: options.includeLocalPaths,
+        ...options.hostname === void 0 ? {} : { hostname: options.hostname }
+      });
+      return { value: result.registry, warnings: result.warnings };
+    },
+    null
+  );
+  const features = await guarded(
+    "features",
+    warnings,
+    async () => {
+      const result = await collectFeatures(root);
+      return { value: result.features, warnings: result.warnings };
+    },
+    null
+  );
+  const agents = await guarded(
+    "agents",
+    warnings,
+    async () => {
+      const result = await collectAgents(cwd, options.homeDir === void 0 ? {} : { homeDir: options.homeDir });
+      return { value: result.agents, warnings: result.warnings };
+    },
+    null
+  );
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  return {
+    schema_version: STATE_SCHEMA_VERSION,
+    generated_at: now().toISOString(),
+    generator: { name: "arcane-cli", version: packageVersion },
+    repository: {
+      root,
+      scope: resolvedScope.scope,
+      role: manifest.role ?? "consumer",
+      profile: manifest.profile
+    },
+    versions,
+    git,
+    indexes: { decisions, todos, ideas, done, journal },
+    config: collectConfig(manifest),
+    registry,
+    features,
+    agents,
+    warnings
+  };
+}
+
+// src/commands/state.ts
+var USAGE_POINTER = "spell state prints one JSON document to stdout: run `spell state --json` (spell status is the human view).";
+function writeStdout(text) {
+  return new Promise((resolve10, reject) => {
+    process.stdout.write(text, (error) => error ? reject(error) : resolve10());
+  });
+}
+async function runState(targetDir, packageVersion, options = {}, deps = {}) {
+  if (!options.json) {
+    console.error(USAGE_POINTER);
+    process.exitCode = 2;
+    return;
+  }
+  const collect = deps.collect ?? collectState;
+  let text;
+  try {
+    const doc = await collect(targetDir, packageVersion, {
+      online: options.online === true,
+      includeLocalPaths: options.includeLocalPaths === true
+    });
+    text = serializeState(doc);
+  } catch (error) {
+    if (error instanceof ManifestNotFoundError) {
+      console.error('Not initialized. Run "spell init" first.');
+    } else if (error instanceof AgentConfigValidationError) {
+      console.error(error.message);
+    } else {
+      console.error(`spell state: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    await (deps.write ?? writeStdout)(text);
+  } catch (error) {
+    console.error(`spell state: stdout is not writable (${error instanceof Error ? error.message : String(error)})`);
+    process.exitCode = 1;
+  }
+}
+
 // src/commands/uninstall.ts
 import { rm as rm5 } from "fs/promises";
-import { dirname as dirname10, join as join13, resolve as resolve6 } from "path";
+import { dirname as dirname10, join as join19, resolve as resolve6 } from "path";
 import { confirm as confirm3 } from "@inquirer/prompts";
 async function runUninstall(options, targetDir) {
   let manifest;
@@ -6326,9 +7428,9 @@ Run \`spell unblock-push\` first (interactive), then uninstall.`
   }
   let removed = 0;
   let leftBehindLinks = 0;
-  const skip = (path4, err) => {
+  const skip = (path5, err) => {
     if (err instanceof LinkedDirectoryError) leftBehindLinks++;
-    console.log(`  ! Skipped ${path4}: ${skipReason(err, targetDir)}`);
+    console.log(`  ! Skipped ${path5}: ${skipReason(err, targetDir)}`);
   };
   for (const component of manifest.components) {
     for (const file of component.files) {
@@ -6340,7 +7442,7 @@ Run \`spell unblock-push\` first (interactive), then uninstall.`
       }
     }
   }
-  await rm5(join13(targetDir, ".arcane.json"), { force: true });
+  await rm5(join19(targetDir, ".arcane.json"), { force: true });
   const agentOutputs = [
     ".github/agents",
     ".arcane/agents",
@@ -6351,10 +7453,10 @@ Run \`spell unblock-push\` first (interactive), then uninstall.`
     try {
       validateRealTargetPath(targetDir, output);
     } catch (err) {
-      if (await fileExists(join13(targetDir, output))) skip(output, err);
+      if (await fileExists(join19(targetDir, output))) skip(output, err);
       continue;
     }
-    await rm5(join13(targetDir, output), { recursive: true, force: true });
+    await rm5(join19(targetDir, output), { recursive: true, force: true });
   }
   const markerFiles = [
     "CLAUDE.md",
@@ -6432,10 +7534,10 @@ async function uninstallUserTier(options, storeRoot, manifest) {
       console.log(`  ! Skipped ${file}: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
-  await rm5(join13(storeRoot, ".arcane.json"), { force: true });
-  await rm5(join13(storeRoot, "agents"), { recursive: true, force: true });
-  await rm5(join13(storeRoot, "agents.yaml"), { force: true });
-  await removeDirectoryIfEmpty(join13(storeRoot, USER_TIER_SPELLS_DIR));
+  await rm5(join19(storeRoot, ".arcane.json"), { force: true });
+  await rm5(join19(storeRoot, "agents"), { recursive: true, force: true });
+  await rm5(join19(storeRoot, "agents.yaml"), { force: true });
+  await removeDirectoryIfEmpty(join19(storeRoot, USER_TIER_SPELLS_DIR));
   await removeDirectoryIfEmpty(storeRoot);
   for (const line of describeFanoutOutcomes(fanout.outcomes)) console.log(`  ${line}`);
   const pruned = fanout.outcomes.filter((o) => o.status === "pruned").length;
@@ -6447,8 +7549,8 @@ async function uninstallUserTier(options, storeRoot, manifest) {
 }
 
 // src/commands/doctor.ts
-import { access as access4, readdir as readdir9, readFile as readFile13, mkdir as mkdir7, copyFile as fsCopyFile } from "fs/promises";
-import { join as join16, dirname as dirname11, resolve as resolve7 } from "path";
+import { access as access4, readdir as readdir11, readFile as readFile19, mkdir as mkdir7, copyFile as fsCopyFile } from "fs/promises";
+import { join as join22, dirname as dirname11, resolve as resolve7 } from "path";
 
 // src/config/incidents.ts
 var INCIDENT_QUEUE = [
@@ -6516,8 +7618,8 @@ function evaluateIncidentGate(records) {
 }
 
 // src/modules/denylist-scan.ts
-import { readFile as readFile11, readdir as readdir7 } from "fs/promises";
-import { join as join14, relative } from "path";
+import { readFile as readFile17, readdir as readdir9 } from "fs/promises";
+import { join as join20, relative } from "path";
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -6534,7 +7636,7 @@ async function scanFile(absolutePath, displayPath, rules) {
   const findings = [];
   let content;
   try {
-    content = await readFile11(absolutePath, "utf8");
+    content = await readFile17(absolutePath, "utf8");
   } catch {
     return findings;
   }
@@ -6563,12 +7665,12 @@ async function collectScannableFiles(root, repoRoot = root, extensions = DEFAULT
   const collected = [];
   let entries;
   try {
-    entries = await readdir7(root, { withFileTypes: true });
+    entries = await readdir9(root, { withFileTypes: true });
   } catch {
     return collected;
   }
   for (const entry of entries) {
-    const absolutePath = join14(root, entry.name);
+    const absolutePath = join20(root, entry.name);
     if (entry.isDirectory()) {
       if (SKIP_DIRECTORIES.has(entry.name)) continue;
       collected.push(...await collectScannableFiles(absolutePath, repoRoot, extensions));
@@ -6589,65 +7691,6 @@ async function scanRepository(repoRoot, rules, extensions, excludePrefixes = [])
   return findings;
 }
 
-// src/modules/exec.ts
-import { execFile as execFile2 } from "child_process";
-import { existsSync, readFileSync } from "fs";
-import { win32 } from "path";
-var EXTERNAL_CLI_TIMEOUT_MS = 1e4;
-function execFileWithTimeout(file, args, timeoutMs, options = {}) {
-  return new Promise((resolve10, reject) => {
-    const child = execFile2(
-      file,
-      args,
-      {
-        timeout: timeoutMs,
-        killSignal: "SIGTERM",
-        windowsHide: true,
-        encoding: "utf8",
-        ...options.env ? { env: { ...process.env, ...options.env } } : {}
-      },
-      (error, stdout, stderr) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolve10({ stdout, stderr });
-      }
-    );
-    child.stdin?.end();
-  });
-}
-function defaultProbes() {
-  return {
-    platform: process.platform,
-    pathEnv: process.env["PATH"] ?? process.env["Path"],
-    readText: (path4) => {
-      try {
-        return readFileSync(path4, "utf8");
-      } catch {
-        return void 0;
-      }
-    },
-    exists: (path4) => existsSync(path4)
-  };
-}
-var MSI_LAUNCHER_LINE = /^\s*"%~dp0\\\.\.\\python\.exe"\s+-IBm\s+azure\.cli\s+%\*\s*$/im;
-function resolveAzureCli(probes = defaultProbes()) {
-  const plain = { file: "az", prefixArgs: [] };
-  if (probes.platform !== "win32") return plain;
-  for (const raw of (probes.pathEnv ?? "").split(";")) {
-    const dir = raw.trim().replace(/^"(.*)"$/, "$1");
-    if (!dir || !win32.isAbsolute(dir)) continue;
-    const launcher = probes.readText(win32.join(dir, "az.cmd"));
-    if (launcher === void 0) continue;
-    if (!MSI_LAUNCHER_LINE.test(launcher)) return plain;
-    const interpreter = win32.resolve(dir, "..", "python.exe");
-    if (!probes.exists(interpreter)) return plain;
-    return { file: interpreter, prefixArgs: ["-IBm", "azure.cli"], env: { AZ_INSTALLER: "MSI" } };
-  }
-  return plain;
-}
-
 // src/modules/platform-policy.ts
 var SANCTIONED_MERGE_METHODS = ["merge", "rebase"];
 function compareToLadder(effective, declaredButBlocked, interactionNote) {
@@ -6815,7 +7858,7 @@ function decodeAdoSegment(raw) {
   if (!decoded || decoded.startsWith("-")) return null;
   return decoded;
 }
-function parseAdoRemote(url) {
+function parseAdoRemote2(url) {
   const match = /dev\.azure\.com\/([^/]+)\/([^/]+)\/_git\/([^/?]+)/.exec(url) ?? /([^./]+)\.visualstudio\.com\/([^/]+)\/_git\/([^/?]+)/.exec(url);
   if (!match) return null;
   const [, rawOrg, rawProject, rawRepo] = match;
@@ -6828,8 +7871,8 @@ function parseAdoRemote(url) {
 }
 
 // src/modules/placeholders.ts
-import { readdir as readdir8, readFile as readFile12 } from "fs/promises";
-import { join as join15 } from "path";
+import { readdir as readdir10, readFile as readFile18 } from "fs/promises";
+import { join as join21 } from "path";
 var PLACEHOLDER_STANDARD_FILE = "spell-authoring-standards.md";
 var RUNTIME_PLACEHOLDERS_START = "<!-- runtime-placeholders:start -->";
 var RUNTIME_PLACEHOLDERS_END = "<!-- runtime-placeholders:end -->";
@@ -6924,7 +7967,7 @@ function parseRuntimePlaceholders(standardContent) {
 async function scanGovernancePlaceholders(governanceDir) {
   let standard;
   try {
-    standard = await readFile12(join15(governanceDir, PLACEHOLDER_STANDARD_FILE), "utf8");
+    standard = await readFile18(join21(governanceDir, PLACEHOLDER_STANDARD_FILE), "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return { status: "skipped", reason: `${PLACEHOLDER_STANDARD_FILE} is not installed` };
@@ -6938,12 +7981,12 @@ async function scanGovernancePlaceholders(governanceDir) {
       reason: `${PLACEHOLDER_STANDARD_FILE} has no runtime-placeholders list (an older version?)`
     };
   }
-  const files = (await readdir8(governanceDir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => entry.name).sort();
+  const files = (await readdir10(governanceDir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => entry.name).sort();
   const activeDocs = [];
   const templateDocs = [];
   const findings = [];
   for (const file of files) {
-    const content = await readFile12(join15(governanceDir, file), "utf8");
+    const content = await readFile18(join21(governanceDir, file), "utf8");
     const status = parseFrontmatterStatus(content);
     if (status === "template") templateDocs.push(file);
     if (status !== "active") continue;
@@ -6955,7 +7998,7 @@ async function scanGovernancePlaceholders(governanceDir) {
 }
 
 // src/commands/doctor.ts
-function isRecord3(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function checkNodeVersion() {
@@ -6974,14 +8017,14 @@ async function checkNodeVersion() {
 async function checkVSCodeExtension(id, label2, homeDir = resolveHomeDir()) {
   const name = `VS Code extension: ${label2}`;
   const flavours = [
-    { dir: join16(homeDir, ".vscode", "extensions"), bin: "code" },
-    { dir: join16(homeDir, ".vscode-insiders", "extensions"), bin: "code-insiders" }
+    { dir: join22(homeDir, ".vscode", "extensions"), bin: "code" },
+    { dir: join22(homeDir, ".vscode-insiders", "extensions"), bin: "code-insiders" }
   ];
   let installBin = null;
   for (const flavour of flavours) {
     let entries;
     try {
-      entries = await readdir9(flavour.dir);
+      entries = await readdir11(flavour.dir);
     } catch {
       continue;
     }
@@ -7003,15 +8046,15 @@ async function checkVSCodeExtension(id, label2, homeDir = resolveHomeDir()) {
 }
 async function checkArcaneManifest(targetDir) {
   const name = "Arcane manifest (.arcane.json)";
-  const manifestPath2 = join16(targetDir, ".arcane.json");
+  const manifestPath2 = join22(targetDir, ".arcane.json");
   try {
     await access4(manifestPath2);
   } catch {
-    const selfHostedManifestPath = join16(targetDir, "src", "assets", ".arcane.json");
+    const selfHostedManifestPath = join22(targetDir, "src", "assets", ".arcane.json");
     try {
-      const raw = await readFile13(selfHostedManifestPath, "utf8");
+      const raw = await readFile19(selfHostedManifestPath, "utf8");
       const manifest = JSON.parse(raw);
-      if (isRecord3(manifest) && manifest["selfHosted"] === true && manifest["tracking_mode"] === "internal") {
+      if (isRecord7(manifest) && manifest["selfHosted"] === true && manifest["tracking_mode"] === "internal") {
         return {
           name,
           passed: true,
@@ -7028,9 +8071,9 @@ async function checkArcaneManifest(targetDir) {
     };
   }
   try {
-    const raw = await readFile13(manifestPath2, "utf8");
+    const raw = await readFile19(manifestPath2, "utf8");
     const manifest = JSON.parse(raw);
-    if (!isRecord3(manifest) || typeof manifest["version"] !== "string" || !manifest["version"] || !Array.isArray(manifest["components"])) {
+    if (!isRecord7(manifest) || typeof manifest["version"] !== "string" || !manifest["version"] || !Array.isArray(manifest["components"])) {
       return {
         name,
         passed: false,
@@ -7113,7 +8156,7 @@ async function checkSessionContinuity(targetDir) {
   const results = [];
   for (const file of SESSION_CONTINUITY_FILES) {
     const name = `Session file: ${file}`;
-    const filePath = join16(targetDir, file);
+    const filePath = join22(targetDir, file);
     try {
       await access4(filePath);
       results.push({ name, passed: true, message: "present" });
@@ -7131,7 +8174,7 @@ async function checkSessionContinuity(targetDir) {
 async function fixSessionContinuity(targetDir, assetsDir) {
   const created = [];
   for (const file of SESSION_CONTINUITY_FILES) {
-    const destPath = join16(targetDir, file);
+    const destPath = join22(targetDir, file);
     try {
       await access4(destPath);
     } catch {
@@ -7142,7 +8185,7 @@ async function fixSessionContinuity(targetDir, assetsDir) {
         );
         continue;
       }
-      const srcPath = join16(assetsDir, file);
+      const srcPath = join22(assetsDir, file);
       await mkdir7(dirname11(destPath), { recursive: true });
       await fsCopyFile(srcPath, destPath);
       created.push(file);
@@ -7270,7 +8313,7 @@ async function checkGovernancePlaceholders(targetDir) {
   const name = "Governance placeholders (ARC-051)";
   let scan;
   try {
-    scan = await scanGovernancePlaceholders(join16(targetDir, ".arcane", "governance"));
+    scan = await scanGovernancePlaceholders(join22(targetDir, ".arcane", "governance"));
   } catch (err) {
     return {
       name,
@@ -7357,10 +8400,10 @@ async function checkNewlyAvailableComponents(targetDir) {
 }
 async function checkMcpConfig(targetDir) {
   const name = "MCP config (per-server timeout, I12)";
-  const filePath = join16(targetDir, ".mcp.json");
+  const filePath = join22(targetDir, ".mcp.json");
   let raw;
   try {
-    raw = await readFile13(filePath, "utf8");
+    raw = await readFile19(filePath, "utf8");
   } catch {
     return { name, passed: true, blocking: false, message: "no .mcp.json \u2014 nothing to check" };
   }
@@ -7375,7 +8418,7 @@ async function checkMcpConfig(targetDir) {
       message: ".mcp.json exists but contains invalid JSON"
     };
   }
-  if (!isRecord3(rawParsed)) {
+  if (!isRecord7(rawParsed)) {
     return {
       name,
       passed: false,
@@ -7433,17 +8476,17 @@ async function checkMcpConfig(targetDir) {
   };
 }
 function isDelegation(value) {
-  return isRecord3(value) && typeof value["id"] === "string" && typeof value["status"] === "string" && typeof value["scope"] === "string" && Array.isArray(value["excludedActions"]);
+  return isRecord7(value) && typeof value["id"] === "string" && typeof value["status"] === "string" && typeof value["scope"] === "string" && Array.isArray(value["excludedActions"]);
 }
 function isDelegationsFile(value) {
-  return isRecord3(value) && Array.isArray(value["delegations"]) && value["delegations"].every(isDelegation);
+  return isRecord7(value) && Array.isArray(value["delegations"]) && value["delegations"].every(isDelegation);
 }
 async function checkDelegations(targetDir) {
   const name = "Standing delegations (T13)";
-  const filePath = join16(targetDir, ".arcane", "delegations.json");
+  const filePath = join22(targetDir, ".arcane", "delegations.json");
   let raw;
   try {
-    raw = await readFile13(filePath, "utf8");
+    raw = await readFile19(filePath, "utf8");
   } catch {
     return { name, passed: true, blocking: false, message: "no delegations recorded" };
   }
@@ -7501,7 +8544,7 @@ async function checkPlatformBranchPolicy(targetDir) {
     const result = evaluateGitHubMergePolicy(rulesets);
     return { name, passed: result.passed, blocking: false, message: result.message };
   }
-  const ado = parseAdoRemote(url);
+  const ado = parseAdoRemote2(url);
   if (ado) {
     const policies = await fetchAdoMergeTypePolicies(ado.org, ado.project, ado.repo, "main");
     if (policies === null) {
@@ -7543,7 +8586,7 @@ async function checkManagedFileModes(targetDir) {
     if (!isClientShimPath(file) || asLinks.includes(file)) continue;
     let body;
     try {
-      body = await readFile13(join16(targetDir, file), "utf-8");
+      body = await readFile19(join22(targetDir, file), "utf-8");
     } catch {
       continue;
     }
@@ -7594,19 +8637,19 @@ async function checkSpellScope(targetDir, homeDir = resolveHomeDir()) {
   }
   let spellCount = 0;
   let probed = false;
-  const probe = "spell-status.md";
+  const probe2 = "spell-status.md";
   try {
-    const entries = await readdir9(join16(storeRoot, USER_TIER_SPELLS_DIR));
+    const entries = await readdir11(join22(storeRoot, USER_TIER_SPELLS_DIR));
     const spells = entries.filter((e) => e.startsWith("spell-") && e.endsWith(".md"));
     spellCount = spells.length;
-    probed = spells.includes(probe);
+    probed = spells.includes(probe2);
   } catch {
   }
   if (spellCount === 0 || !probed) {
     return {
       name,
       passed: false,
-      message: `the user tier at ${storeRoot} holds ${spellCount} spell(s)${spellCount > 0 && !probed ? ` and not ${probe}` : ""} \u2014 this repository expects it to supply every spell. Run \`spell update --user\`.`
+      message: `the user tier at ${storeRoot} holds ${spellCount} spell(s)${spellCount > 0 && !probed ? ` and not ${probe2}` : ""} \u2014 this repository expects it to supply every spell. Run \`spell update --user\`.`
     };
   }
   const majorMinor = (v) => v.split(".").slice(0, 2).join(".");
@@ -7630,7 +8673,7 @@ async function checkSpellScope(targetDir, homeDir = resolveHomeDir()) {
     name,
     passed: true,
     blocking: false,
-    message: `user \u2014 ${spellCount} spell(s) from ${storeRoot} (v${store.version}), ${probe} present${repoExpectsAgents ? ", agent roster present in the tier" : ""}`
+    message: `user \u2014 ${spellCount} spell(s) from ${storeRoot} (v${store.version}), ${probe2} present${repoExpectsAgents ? ", agent roster present in the tier" : ""}`
   };
 }
 async function runDoctor(targetDir, options = {}, assetsDir) {
@@ -7714,16 +8757,16 @@ async function runDoctor(targetDir, options = {}, assetsDir) {
 }
 
 // src/commands/ward.ts
-import { readFile as readFile15 } from "fs/promises";
+import { readFile as readFile21 } from "fs/promises";
 
 // src/modules/ward.ts
-import { readdir as readdir10, readFile as readFile14 } from "fs/promises";
-import { join as join17, relative as relative2 } from "path";
+import { readdir as readdir12, readFile as readFile20 } from "fs/promises";
+import { join as join23, relative as relative2 } from "path";
 async function scanFileAllRules(absolutePath, displayPath, rules) {
   const findings = [];
   let content;
   try {
-    content = await readFile14(absolutePath, "utf8");
+    content = await readFile20(absolutePath, "utf8");
   } catch {
     return findings;
   }
@@ -7776,12 +8819,12 @@ async function scanFilenames(root, rules, repoRoot = root) {
   const findings = [];
   let entries;
   try {
-    entries = await readdir10(root, { withFileTypes: true });
+    entries = await readdir12(root, { withFileTypes: true });
   } catch {
     return findings;
   }
   for (const entry of entries) {
-    const absolutePath = join17(root, entry.name);
+    const absolutePath = join23(root, entry.name);
     if (entry.isDirectory()) {
       if (SKIP_DIRECTORIES.has(entry.name)) continue;
       findings.push(...await scanFilenames(absolutePath, rules, repoRoot));
@@ -7818,7 +8861,7 @@ async function runWard(repoRoot, options = {}) {
     const findings2 = await scanFileAllRules(absolutePath, displayPath, allRules);
     if (findings2.length > 0) {
       try {
-        fileLines.set(displayPath, (await readFile14(absolutePath, "utf8")).split("\n"));
+        fileLines.set(displayPath, (await readFile20(absolutePath, "utf8")).split("\n"));
       } catch {
       }
     }
@@ -7846,7 +8889,7 @@ function parseTermsFileContent(raw) {
 }
 async function readTermsFile(filePath) {
   try {
-    return parseTermsFileContent(await readFile15(filePath, "utf8"));
+    return parseTermsFileContent(await readFile21(filePath, "utf8"));
   } catch (error) {
     console.warn(
       `\u26A0 arcane: could not read --terms-file "${filePath}": ${error.message}`
@@ -8057,7 +9100,7 @@ async function runBlockPush(targetDir) {
 }
 
 // src/modules/credential-store.ts
-import { createHash as createHash2, randomBytes } from "crypto";
+import { createHash as createHash4, randomBytes } from "crypto";
 var CHUNK_SIZE = 1e3;
 var MAX_CHUNKS = 64;
 var INDEX_NAME = "session/index";
@@ -8071,7 +9114,7 @@ var KeychainUnavailableError = class extends Error {
   }
 };
 function sha256Hex(value) {
-  return createHash2("sha256").update(value, "utf8").digest("hex");
+  return createHash4("sha256").update(value, "utf8").digest("hex");
 }
 function chunkName(gen, n) {
   return `${CHUNK_PREFIX}${gen}/${n}`;
@@ -8215,17 +9258,17 @@ import { execFile as execFile3 } from "child_process";
 import * as client from "openid-client";
 
 // src/modules/result-pages.ts
-import { createHash as createHash3 } from "crypto";
-import { readFile as readFile16 } from "fs/promises";
-import { join as join18 } from "path";
+import { createHash as createHash5 } from "crypto";
+import { readFile as readFile22 } from "fs/promises";
+import { join as join24 } from "path";
 var RESULT_KINDS = ["success", "denied", "failure"];
 function resultPagePath(kind) {
-  return join18("sign-in", `sign-in-callback-${kind}.html`);
+  return join24("sign-in", `sign-in-callback-${kind}.html`);
 }
 function styleHashes(html) {
   return [...html.matchAll(/<style\b[^>]*>([\s\S]*?)<\/style\s*>/gi)].map((match) => {
     const text = match[1].replace(/\r\n?/g, "\n");
-    return `'sha256-${createHash3("sha256").update(text, "utf8").digest("base64")}'`;
+    return `'sha256-${createHash5("sha256").update(text, "utf8").digest("base64")}'`;
   });
 }
 function resultPageHeaders(html) {
@@ -8268,7 +9311,7 @@ var PLAIN_RESULT_PAGES = {
 async function loadResultPages(assetsDir) {
   try {
     const [success, denied, failure] = await Promise.all(
-      RESULT_KINDS.map(async (kind) => resultPage(await readFile16(join18(assetsDir, resultPagePath(kind)), "utf8")))
+      RESULT_KINDS.map(async (kind) => resultPage(await readFile22(join24(assetsDir, resultPagePath(kind)), "utf8")))
     );
     return { success, denied, failure };
   } catch {
@@ -8480,7 +9523,7 @@ function openInDefaultBrowser(url) {
 import { execFileSync } from "child_process";
 import { mkdirSync, readFileSync as readFileSync2, renameSync, rmSync, writeFileSync, existsSync as existsSync2 } from "fs";
 import { userInfo } from "os";
-import { dirname as dirname12, join as join19 } from "path";
+import { dirname as dirname12, join as join25 } from "path";
 
 // src/modules/keychain-backend.ts
 import { createRequire as createRequire2 } from "module";
@@ -8614,7 +9657,7 @@ function restrictToCurrentUser(filePath) {
   });
 }
 function insecureSessionFilePath(homeDir) {
-  return join19(userTierRoot(homeDir), INSECURE_SESSION_FILE_NAME);
+  return join25(userTierRoot(homeDir), INSECURE_SESSION_FILE_NAME);
 }
 function createSessionStorage(options = {}) {
   const keychain = new ChunkedSecretStore(options.keychainBackend ?? createKeychainBackend());
@@ -8882,15 +9925,15 @@ async function runWhoami(options, deps = defaultWhoamiDeps()) {
 
 // src/commands/report.ts
 import { access as access5 } from "fs/promises";
-import { join as join22 } from "path";
+import { join as join28 } from "path";
 
 // src/modules/show-report/generate.ts
-import { mkdir as mkdir8, readdir as readdir11, readFile as readFile18, writeFile as writeFile11 } from "fs/promises";
-import { basename as basename4, dirname as dirname13, isAbsolute, join as join21, relative as relative3, resolve as resolve9 } from "path";
+import { mkdir as mkdir8, readdir as readdir13, readFile as readFile24, writeFile as writeFile11 } from "fs/promises";
+import { basename as basename4, dirname as dirname13, isAbsolute, join as join27, relative as relative3, resolve as resolve9 } from "path";
 
 // src/modules/show-report/model.ts
-import { readFile as readFile17 } from "fs/promises";
-import { join as join20 } from "path";
+import { readFile as readFile23 } from "fs/promises";
+import { join as join26 } from "path";
 
 // src/modules/show-report/plan-parser.ts
 function parseFrontmatter(content) {
@@ -9076,28 +10119,6 @@ function stripMarkdown2(text) {
   return text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\*\*/g, "").replace(/`/g, "").trim();
 }
 
-// src/modules/show-report/decisions-parser.ts
-function parseAdrs(decisionsContent) {
-  const headingPattern = /^## ARC-(\d{3})\b/gm;
-  const positions = [];
-  let match;
-  while ((match = headingPattern.exec(decisionsContent)) !== null) {
-    positions.push({ id: `ARC-${match[1]}`, index: match.index });
-  }
-  return positions.map(({ id, index }, i) => {
-    const end = i + 1 < positions.length ? positions[i + 1].index : decisionsContent.length;
-    const section = decisionsContent.slice(index, end);
-    const dateMatch = /^\*\*Date:\*\*\s*(\d{4}-\d{2}-\d{2})/m.exec(section);
-    const statusMatch = /^\*\*Status:\*\*\s*(\S+)/m.exec(section);
-    return { id, date: dateMatch ? dateMatch[1] : null, status: statusMatch ? statusMatch[1] : null };
-  });
-}
-function countAcceptedAdrsInWindow(adrs, fromDate, toDate) {
-  return adrs.filter(
-    (adr) => adr.status === "Accepted" && adr.date !== null && adr.date >= fromDate && adr.date <= toDate
-  ).length;
-}
-
 // src/modules/show-report/sources.ts
 async function runGitTextOrNull(cwd, args) {
   try {
@@ -9161,9 +10182,9 @@ async function getCast(cwd, fromRef, toRef, generatedOutputs = []) {
 }
 
 // src/modules/show-report/model.ts
-async function readOptional(path4) {
+async function readOptional(path5) {
   try {
-    return await readFile17(path4, "utf8");
+    return await readFile23(path5, "utf8");
   } catch {
     return null;
   }
@@ -9259,13 +10280,13 @@ function buildCorrections(ledgerRows, programName) {
   };
 }
 async function buildShowReportModel(options) {
-  const planAbsPath = join20(options.rootDir, options.planRelPath);
-  const queueAbsPath = join20(options.rootDir, options.queueRelPath);
+  const planAbsPath = join26(options.rootDir, options.planRelPath);
+  const queueAbsPath = join26(options.rootDir, options.queueRelPath);
   const ledgerRelPath = "docs/verification-ledger.md";
-  const ledgerAbsPath = join20(options.rootDir, ledgerRelPath);
-  const decisionsAbsPath = join20(options.rootDir, "DECISIONS.md");
+  const ledgerAbsPath = join26(options.rootDir, ledgerRelPath);
+  const decisionsAbsPath = join26(options.rootDir, "DECISIONS.md");
   const [planContent, queueContent, ledgerContent, decisionsContent] = await Promise.all([
-    readFile17(planAbsPath, "utf8"),
+    readFile23(planAbsPath, "utf8"),
     readOptional(queueAbsPath),
     readOptional(ledgerAbsPath),
     readOptional(decisionsAbsPath)
@@ -9455,13 +10476,13 @@ function programNameFromTitle(title) {
 function deterministicCompiledAt(frontmatter) {
   return frontmatter.completed ?? frontmatter.activated ?? frontmatter.created ?? "unknown";
 }
-function toPosix(path4) {
-  return path4.replace(/\\/g, "/");
+function toPosix(path5) {
+  return path5.replace(/\\/g, "/");
 }
 async function programFromPlan(rootDir, slug, planRelPath) {
   let planContent;
   try {
-    planContent = await readFile18(join21(rootDir, planRelPath), "utf8");
+    planContent = await readFile24(join27(rootDir, planRelPath), "utf8");
   } catch {
     return { skipped: { slug, reason: `no PLAN.md at ${planRelPath}` } };
   }
@@ -9473,16 +10494,16 @@ async function programFromPlan(rootDir, slug, planRelPath) {
     program: {
       slug,
       planRelPath,
-      queueRelPath: toPosix(join21(dirname13(planRelPath), "OPERATOR-QUEUE.md")),
+      queueRelPath: toPosix(join27(dirname13(planRelPath), "OPERATOR-QUEUE.md")),
       ledgerProgramName: programNameFromTitle(frontmatter.title ?? slug)
     }
   };
 }
 async function discoverPrograms(rootDir) {
-  const plansDir = join21(rootDir, "docs", "plans");
+  const plansDir = join27(rootDir, "docs", "plans");
   let entries;
   try {
-    entries = (await readdir11(plansDir, { withFileTypes: true })).filter((e) => e.isDirectory());
+    entries = (await readdir13(plansDir, { withFileTypes: true })).filter((e) => e.isDirectory());
   } catch (error) {
     if (error.code === "ENOENT") return { programs: [], skipped: [] };
     throw error;
@@ -9504,16 +10525,16 @@ async function programFromPlanPath(rootDir, planPath) {
 function normalizeLineEndings2(content) {
   return content.replace(/\r\n?/g, "\n");
 }
-async function readOptionalFile(path4) {
+async function readOptionalFile(path5) {
   try {
-    return await readFile18(path4, "utf8");
+    return await readFile24(path5, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw error;
   }
 }
 async function generateReport(rootDir, program2, templateHtml, theme = "auto") {
-  const planContent = await readFile18(join21(rootDir, program2.planRelPath), "utf8");
+  const planContent = await readFile24(join27(rootDir, program2.planRelPath), "utf8");
   const frontmatter = parseFrontmatter(planContent);
   const model = await buildShowReportModel({
     rootDir,
@@ -9533,7 +10554,7 @@ async function generateReport(rootDir, program2, templateHtml, theme = "auto") {
   };
 }
 async function runReportGeneration(options) {
-  const templateHtml = await readFile18(options.templatePath, "utf8");
+  const templateHtml = await readFile24(options.templatePath, "utf8");
   const theme = options.theme ?? "auto";
   const drifted = [];
   const repaired = [];
@@ -9551,12 +10572,12 @@ async function runReportGeneration(options) {
       [`${outRel}/show-report.html`, generated.html]
     ];
     for (const [relPath, expected] of outputs) {
-      const actual = await readOptionalFile(join21(options.rootDir, relPath));
+      const actual = await readOptionalFile(join27(options.rootDir, relPath));
       if (actual === null || normalizeLineEndings2(actual) !== normalizeLineEndings2(expected)) {
         drifted.push(`${relPath} does not match a regeneration from its sources.`);
         if (options.mode === "write") {
           await mkdir8(outAbs, { recursive: true });
-          await writeFile11(join21(options.rootDir, relPath), expected, "utf8");
+          await writeFile11(join27(options.rootDir, relPath), expected, "utf8");
           repaired.push(relPath);
         }
       }
@@ -9567,7 +10588,7 @@ async function runReportGeneration(options) {
 
 // src/commands/report.ts
 async function runReport(targetDir, options = {}, assetsDir) {
-  const templatePath = join22(assetsDir, "report", "show-report.template.html");
+  const templatePath = join28(assetsDir, "report", "show-report.template.html");
   try {
     await access5(templatePath);
   } catch {
@@ -9637,14 +10658,14 @@ async function runReport(targetDir, options = {}, assetsDir) {
     return;
   }
   console.log(`Show report: wrote ${result.repaired.length} file(s).`);
-  for (const path4 of result.repaired) console.log(`  ${path4}`);
+  for (const path5 of result.repaired) console.log(`  ${path5}`);
 }
 
 // src/index.ts
 import { realpathSync as realpathSync2 } from "fs";
 var require3 = createRequire3(import.meta.url);
 var pkg = require3("../package.json");
-var ASSETS_DIR = process.env["ARCANE_ASSETS_DIR"] ?? join23(dirname14(fileURLToPath(import.meta.url)), "assets");
+var ASSETS_DIR = process.env["ARCANE_ASSETS_DIR"] ?? join29(dirname14(fileURLToPath(import.meta.url)), "assets");
 var program = new Command();
 var USER_FLAG_DESCRIPTION = "Operate on the per-user tier at ~/.arcane \u2014 spells shared by every repository on this machine, fanned out to ~/.agents/skills (Codex, Copilot) and ~/.claude/commands (Claude Code)";
 var USER_TIER_AGENTS_DESCRIPTION = "Operate on the per-user tier at ~/.arcane \u2014 one agent roster shared by every repository on this machine, rendered to ~/.copilot/agents (VS Code agent modes)";
@@ -9758,6 +10779,15 @@ withManifestFlags(
 program.command("status").description("Show installed components and check for updates").option("--user", USER_FLAG_DESCRIPTION).action(async (opts) => {
   await runStatus(targetDirFor(opts), pkg.version, { user: opts.user });
 });
+program.command("state").description("Export this repository's Arcane state as one JSON document (schema https://arcaneai.net/schemas/state/v1)").option("--json", "Print the document to stdout (required; `spell status` is the human view)").option(
+  "--online",
+  "Also look up the latest published arcane-cli version and this branch's open pull request (gh / az). Off by default: a plain run makes no network request"
+).option(
+  "--include-local-paths",
+  "Hub only: add each registered repository's clone path on this machine. Other machines' paths are never exported"
+).action(async (opts) => {
+  await runState(process.cwd(), pkg.version, opts);
+});
 program.command("uninstall").description("Remove all installed Arcane framework files").option("--yes", "Skip confirmation prompt").option("--dry-run", "Preview what would be removed without deleting files").option("--user", USER_FLAG_DESCRIPTION).action(async (opts) => {
   await runUninstall({ yes: opts.yes, dryRun: opts.dryRun, user: opts.user }, targetDirFor(opts));
 });