@iowarp/clio-coder 0.4.3 → 0.4.5

package/dist/{context-E3VC7RX5.js → context-S2EEC3EJ.js}

@@ -1,7 +1,14 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  MAX_PAGE_ATTEMPTS
+} from "./chunk-LVFANMOH.js";
+import "./chunk-KPRLAMP4.js";
+import "./chunk-PPEZJWUG.js";
+import "./chunk-B5GGDIHT.js";
+import "./chunk-ZZFWWYLX.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/cli/context.ts
 init_esm_shims();
@@ -10,7 +17,7 @@ var HELP = `Usage:
   clio-coder context
   clio-coder context init [--yes] [--preview|--heuristic] [--adopt] [--propose|--apply|--rewrite]
   clio-coder context refresh [--wiki]
-  clio-coder context wiki [--update] [--status] [--depth auto|simple|medium|detailed]
+  clio-coder context wiki [--update|--retry-pending] [--status] [--depth auto|simple|medium|detailed]
                     [--target <id>] [--model <id>] [--thinking off|low|medium|high]
   clio-coder context reset [--all] [--yes]
   clio-coder context index [--json]
@@ -35,6 +42,34 @@ function printWikiProgress(event) {
   process.stderr.write(`clio-coder context wiki: ${event.message}${detail}
 `);
 }
+function wikiRecoveryLines(meta) {
+  const pending = meta?.plan?.pages.filter((page) => page.status !== "written") ?? [];
+  if (pending.length === 0) return [];
+  const exhausted = pending.filter((page) => page.attempts >= MAX_PAGE_ATTEMPTS).length;
+  const failures = pending.filter((page) => page.lastFailure);
+  return [
+    `pending: ${pending.length} page(s)${exhausted > 0 ? `; ${exhausted} exhausted ordinary writer attempts` : ""}`,
+    ...failures.slice(0, 8).map((page) => `${page.path}: ${page.lastFailure?.phase}: ${page.lastFailure?.detail}`),
+    ...failures.length > 8 ? [`${failures.length - 8} more page failures retained in wiki metadata`] : [],
+    "Run `clio-coder context wiki --retry-pending` to retry pending pages once, including exhausted pages, without replanning."
+  ];
+}
+function printWikiOutcome(prefix, result, meta) {
+  const pending = result.pending ?? meta?.plan?.pages.filter((page) => page.status !== "written").length ?? 0;
+  const complete = meta?.plan ? meta.plan.pages.filter((page) => page.status === "written").length : meta?.generation?.pagesWritten ?? Math.max(0, result.pages - pending);
+  const published = `${result.pages} published page${result.pages === 1 ? "" : "s"}`;
+  const progress = `${complete} complete, ${pending} pending`;
+  const outcome = pending > 0 ? "incomplete" : result.status === "noop" ? "unchanged" : "generated";
+  process.stdout.write(`${prefix}: ${outcome} (${published}; ${progress})
+`);
+  if (pending > 0) {
+    const recovery = wikiRecoveryLines(meta);
+    process.stdout.write(
+      `${recovery.length > 0 ? recovery.join("\n") : "Run `clio-coder context wiki --update` to continue pending pages."}
+`
+    );
+  }
+}
 function compactMetric(value, suffix) {
   if (value < 1e3) return `${value}${suffix}`;
   return `${(value / 1e3).toFixed(1)}k${suffix}`;
@@ -63,18 +98,15 @@ function formatGenerationStatus(generation) {
   return `generation: ${generation.mode} (${details.join("; ")})`;
 }
 async function printContextStatus() {
-  const context = await import("./context-2OHRKS42.js");
-  const preload = await import("./preload-P6DGH2PZ.js");
+  const context = await import("./context-P5YSEO55.js");
+  const preload = await import("./preload-65U34NG6.js");
   const cwd = process.cwd();
   const clio = context.loadProjectClioMd(cwd);
   const state = context.readClioState(cwd);
   const localStandardIsEffective = clio.files.some((file) => file.path === join(resolve(cwd), "CLIO-CODER.md"));
   const clioMdState = clio.files.length === 0 && clio.errors.length === 0 ? "none" : clio.errors.length > 0 ? "malformed" : localStandardIsEffective && state?.contextSources !== void 0 && context.adoptionSourcesChanged(state.contextSources, { cwd }) ? "stale" : "ok";
   const prompt = context.renderPromptContext(cwd);
-  const preloadClass = preload.classifyProjectPreload({
-    hasClioMd: prompt.clioMd !== null,
-    text: prompt.text
-  });
+  const preloadClass = preload.selectProjectPreload(prompt, null).classification;
   const codewiki = context.readCodewiki(cwd);
   const codewikiCount = codewiki ? context.codewikiEntries(codewiki).length : 0;
   const codewikiState = !codewiki ? "absent" : state && !context.isStale(state.fingerprint, context.computeFingerprint(cwd, codewiki)) ? "fresh" : "stale (run clio-coder context refresh)";
@@ -113,8 +145,8 @@ async function runRefreshCommand(args) {
     return 2;
   }
   try {
-    const { runContextRefresh } = await import("./context-2OHRKS42.js");
-    const wikiEntry = updateWiki ? await import("./wiki-generate-C7IQOXSP.js") : null;
+    const { runContextRefresh, readWikiMeta } = await import("./context-P5YSEO55.js");
+    const wikiEntry = updateWiki ? await import("./wiki-generate-7BV7XWIY.js") : null;
     const result = await runContextRefresh({
       cwd: process.cwd(),
       io: {
@@ -134,11 +166,7 @@ async function runRefreshCommand(args) {
         );
         return 1;
       }
-      process.stdout.write(
-        result.wiki.status === "noop" ? `clio-coder context refresh: wiki unchanged (${result.wiki.pages} page${result.wiki.pages === 1 ? "" : "s"})
-` : `clio-coder context refresh: wiki updated (${result.wiki.pages} page${result.wiki.pages === 1 ? "" : "s"})
-`
-      );
+      printWikiOutcome("clio-coder context refresh: wiki", result.wiki, readWikiMeta(process.cwd()));
     }
     return 0;
   } catch (err) {
@@ -148,7 +176,7 @@ async function runRefreshCommand(args) {
   }
 }
 async function runWikiStatusCommand() {
-  const context = await import("./context-2OHRKS42.js");
+  const context = await import("./context-P5YSEO55.js");
   const cwd = process.cwd();
   const meta = context.readWikiMeta(cwd);
   if (!meta) {
@@ -168,10 +196,11 @@ async function runWikiStatusCommand() {
     lines.push(
       `depth: ${depth} (requested ${requestedDepth}; ${sourceFiles} source files; ${pagesWritten}/${pagesPlanned} planned pages written)`
     );
-    if (pagesWritten < pagesPlanned) {
+    if (pagesWritten < pagesPlanned && !meta.plan) {
       lines.push(`pending: ${pagesPlanned - pagesWritten} page(s); run \`clio-coder context wiki --update\` to finish`);
     }
   }
+  lines.push(...wikiRecoveryLines(meta));
   if (currentHead !== meta.gitHead) {
     lines.push(`staleness: gitHead differs from current HEAD (${currentHead ?? "none"})`);
   }
@@ -188,6 +217,7 @@ function isThinkingLevel(value) {
 }
 async function runWikiCommand(args) {
   let forceUpdate = false;
+  let retryPending = false;
   let status = false;
   let depth = "auto";
   let target;
@@ -203,6 +233,10 @@ async function runWikiCommand(args) {
       forceUpdate = true;
       continue;
     }
+    if (arg === "--retry-pending") {
+      retryPending = true;
+      continue;
+    }
     if (arg === "--status") {
       status = true;
       continue;
@@ -242,8 +276,8 @@ async function runWikiCommand(args) {
   }
   if (status) return runWikiStatusCommand();
   try {
-    const context = await import("./context-2OHRKS42.js");
-    const { modelWikiGenerate, resolveDocumenterModelId } = await import("./wiki-generate-C7IQOXSP.js");
+    const context = await import("./context-P5YSEO55.js");
+    const { modelWikiGenerate, resolveDocumenterModelId } = await import("./wiki-generate-7BV7XWIY.js");
     const route = {
       ...target !== void 0 ? { target } : {},
       ...model !== void 0 ? { model } : {},
@@ -252,6 +286,7 @@ async function runWikiCommand(args) {
     const result = await context.runWikiGenerate({
       cwd: process.cwd(),
       ...forceUpdate ? { mode: "update" } : {},
+      ...retryPending ? { retryPending: true } : {},
       depth,
       model: await resolveDocumenterModelId(route),
       generate: modelWikiGenerate({ route }),
@@ -262,11 +297,7 @@ async function runWikiCommand(args) {
 `);
       return 1;
     }
-    process.stdout.write(
-      result.status === "noop" ? `clio-coder context wiki: unchanged (${result.pages} page${result.pages === 1 ? "" : "s"})
-` : `clio-coder context wiki: generated ${result.pages} page${result.pages === 1 ? "" : "s"}
-`
-    );
+    printWikiOutcome("clio-coder context wiki", result, context.readWikiMeta(process.cwd()));
     return 0;
   } catch (err) {
     process.stderr.write(`clio-coder context wiki failed: ${err instanceof Error ? err.message : String(err)}
@@ -285,21 +316,21 @@ async function runContextCommand(args) {
   }
   switch (verb) {
     case "init":
-      return (await import("./init-J477LKZH.js")).runInitCommand(rest);
+      return (await import("./init-S3GZQ5ZF.js")).runInitCommand(rest);
     case "refresh":
       return runRefreshCommand(rest);
     case "wiki":
       return runWikiCommand(rest);
     case "reset":
-      return (await import("./context-clear-BW4O37TG.js")).runContextClearCommand(rest);
+      return (await import("./context-clear-TMEQCOTH.js")).runContextClearCommand(rest);
     case "index":
-      return (await import("./context-index-HNG3MOME.js")).runContextIndexCommand(rest);
+      return (await import("./context-index-HP2JFUWA.js")).runContextIndexCommand(rest);
     case "map":
-      return (await import("./context-map-COB37XXN.js")).runContextMapCommand(rest);
+      return (await import("./context-map-INTXD54D.js")).runContextMapCommand(rest);
     case "replay":
-      return (await import("./context-working-set-VDS25HXZ.js")).runContextReplayCommand(rest);
+      return (await import("./context-working-set-CNLSQN5K.js")).runContextReplayCommand(rest);
     case "working-set":
-      return (await import("./context-working-set-VDS25HXZ.js")).runContextWorkingSetCommand(rest);
+      return (await import("./context-working-set-CNLSQN5K.js")).runContextWorkingSetCommand(rest);
     default:
       process.stderr.write(`clio-coder context: unknown subcommand ${verb}
 `);
@@ -310,4 +341,4 @@ async function runContextCommand(args) {
 export {
   runContextCommand
 };
-//# sourceMappingURL=context-E3VC7RX5.js.map
+//# sourceMappingURL=context-S2EEC3EJ.js.map

package/dist/context-clear-TMEQCOTH.js

@@ -0,0 +1,183 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  runContextClear
+} from "./chunk-SDWNDICN.js";
+import "./chunk-PECBKCDK.js";
+import "./chunk-ODUTYZIU.js";
+import "./chunk-P5SC4DLJ.js";
+import "./chunk-GNQRWTMY.js";
+import "./chunk-ONRTXOZY.js";
+import "./chunk-WLMSOT73.js";
+import "./chunk-6CDNRHWH.js";
+import "./chunk-F34AR6O3.js";
+import "./chunk-U44YYLVV.js";
+import "./chunk-UQIVHSE4.js";
+import "./chunk-USZA7GWL.js";
+import "./chunk-LVFANMOH.js";
+import "./chunk-WTQGRBHV.js";
+import "./chunk-7WUZEB2M.js";
+import "./chunk-O5F25NIE.js";
+import "./chunk-5DDOTTG4.js";
+import "./chunk-YEJIG7LN.js";
+import "./chunk-CXQ37WJH.js";
+import "./chunk-HGSLRG33.js";
+import "./chunk-7YJWEF2L.js";
+import "./chunk-SD7SHNDW.js";
+import "./chunk-T52TPHYC.js";
+import "./chunk-QH3ZTUOA.js";
+import "./chunk-LQTKDAUO.js";
+import "./chunk-22PQ4TX4.js";
+import "./chunk-DZK63TZJ.js";
+import "./chunk-DNHVRBH4.js";
+import "./chunk-TZ7MFRG4.js";
+import "./chunk-KF6GFW6O.js";
+import "./chunk-K2HL3GBL.js";
+import "./chunk-7HBHHVCK.js";
+import "./chunk-2GPGAE5W.js";
+import "./chunk-SL2RDHKO.js";
+import "./chunk-YGDMBK7O.js";
+import "./chunk-V552WL53.js";
+import "./chunk-RLTT5GVY.js";
+import "./chunk-KECNXMDE.js";
+import "./chunk-4SVIVOMC.js";
+import "./chunk-NTK3WTHM.js";
+import "./chunk-WXA2CFJO.js";
+import "./chunk-CBSKDFWL.js";
+import "./chunk-LY4N4TTL.js";
+import "./chunk-OQM5IVJY.js";
+import "./chunk-LUL5Z66S.js";
+import "./chunk-M6TAYK66.js";
+import "./chunk-KQ6IDQIB.js";
+import "./chunk-L4N3DWNW.js";
+import "./chunk-WJIMKGD6.js";
+import "./chunk-MDU3C27C.js";
+import "./chunk-R2P2U3ZS.js";
+import "./chunk-NTTS3O53.js";
+import "./chunk-M4KFUXS7.js";
+import "./chunk-GH5ZR6JP.js";
+import "./chunk-VQD7NH7Z.js";
+import "./chunk-O3VV6IVK.js";
+import "./chunk-5ZMXGW7P.js";
+import "./chunk-B6UM3OZC.js";
+import "./chunk-MYI32N4R.js";
+import "./chunk-EHOSNVVM.js";
+import "./chunk-TEG3RYVZ.js";
+import "./chunk-MCJKEGHO.js";
+import "./chunk-77CZRFTE.js";
+import "./chunk-J2FYEQ5L.js";
+import "./chunk-FKIOX6DS.js";
+import "./chunk-DVNAPPXU.js";
+import "./chunk-5CY4Q6QI.js";
+import "./chunk-FQOOGXBH.js";
+import "./chunk-UHW5V7HC.js";
+import "./chunk-KMF54VH3.js";
+import "./chunk-5A6XR3RJ.js";
+import "./chunk-EFSEIZE6.js";
+import "./chunk-B5ZTR6KZ.js";
+import "./chunk-HL26ADLH.js";
+import "./chunk-VHKTOLEW.js";
+import "./chunk-KPRLAMP4.js";
+import "./chunk-W2RJEH6Q.js";
+import "./chunk-CVDAFGPW.js";
+import "./chunk-PPEZJWUG.js";
+import "./chunk-WDV62RKY.js";
+import "./chunk-GD55RTIW.js";
+import "./chunk-E3LEPLQ2.js";
+import "./chunk-ICO4TQ2F.js";
+import "./chunk-SE4ZKILO.js";
+import "./chunk-U2MSJ57E.js";
+import "./chunk-C27U2TYG.js";
+import "./chunk-GJ24ODAX.js";
+import "./chunk-LTR5QCLS.js";
+import "./chunk-6EXUUOSN.js";
+import "./chunk-ZTNFYMIO.js";
+import "./chunk-HHVJNVUJ.js";
+import "./chunk-HXHFDHB6.js";
+import "./chunk-VNBICSS2.js";
+import "./chunk-2QPI3TR3.js";
+import "./chunk-TK2BMCBZ.js";
+import "./chunk-B5GGDIHT.js";
+import "./chunk-ZZFWWYLX.js";
+import "./chunk-SRCEQKQS.js";
+import "./chunk-TN5FW4XY.js";
+import "./chunk-5CMARGPF.js";
+import "./chunk-DXVMLM3Z.js";
+import "./chunk-CKK25WN3.js";
+import "./chunk-CTTI7G3T.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/cli/context-clear.ts
+init_esm_shims();
+import { stdin as input, stdout as output } from "node:process";
+import { createInterface } from "node:readline/promises";
+var HELP = `Usage:
+  clio-coder context reset [--all] [--yes]
+
+Clear accumulated project context owned by the context engine:
+.clio-coder/codewiki.json, .clio-coder/state.json, .clio-coder/handoffs/, and .clio-coder/proposals/.
+
+Preserves by default: CLIO-CODER.md, CLIO-CODER.override.md, .clio-coder/agents/, .clio-coder/skills/, and .clio-coder/wiki/.
+
+Options:
+  --all       also remove the local CLIO-CODER.md after a second confirmation; overrides stay human-owned
+  --yes, -y   answer every confirmation, required when stdin is not a terminal
+`;
+function hasFlag(args, name) {
+  return args.includes(name);
+}
+async function confirm(question) {
+  if (!input.isTTY) return false;
+  const rl = createInterface({ input, output });
+  try {
+    const answer = await rl.question(question);
+    const normalized = answer.trim().toLowerCase();
+    return normalized === "y" || normalized === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function runContextClearCommand(args) {
+  if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  for (const arg of args) {
+    if (arg !== "--all" && arg !== "--yes" && arg !== "-y") {
+      process.stderr.write(`clio-coder context reset: unknown flag ${arg}
+`);
+      process.stdout.write(HELP);
+      return 2;
+    }
+  }
+  const all = hasFlag(args, "--all");
+  const assumeYes = hasFlag(args, "--yes") || hasFlag(args, "-y");
+  if (!assumeYes && !input.isTTY) {
+    process.stderr.write("clio-coder context reset: stdin is not a terminal; pass --yes to confirm non-interactively\n");
+  }
+  const answer = (question) => assumeYes ? Promise.resolve(true) : confirm(question);
+  try {
+    await runContextClear({
+      cwd: process.cwd(),
+      all,
+      io: {
+        stdout: (s) => process.stdout.write(s),
+        stderr: (s) => process.stderr.write(s)
+      },
+      confirmContext: () => answer(
+        "Clear .clio-coder/codewiki.json, .clio-coder/state.json, .clio-coder/handoffs/, and .clio-coder/proposals/? [y/N] "
+      ),
+      confirmAll: () => answer("Also remove CLIO-CODER.md? [y/N] ")
+    });
+    return 0;
+  } catch (err) {
+    process.stderr.write(`clio-coder context reset failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  }
+}
+export {
+  runContextClearCommand
+};
+//# sourceMappingURL=context-clear-TMEQCOTH.js.map

package/dist/{context-index-HNG3MOME.js → context-index-HP2JFUWA.js}

@@ -1,25 +1,27 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  coordinateCodewikiWrite,
   readClioState,
   statePath,
   writeClioState
-} from "./chunk-MXHC5QYU.js";
+} from "./chunk-WTQGRBHV.js";
+import {
+  coordinateCodewikiWrite
+} from "./chunk-7WUZEB2M.js";
 import {
   codewikiPath,
   structuralCodewikiHash
-} from "./chunk-LBMZMYH2.js";
+} from "./chunk-W2RJEH6Q.js";
 import {
   detectProjectProfile
-} from "./chunk-XAKHZX5N.js";
-import "./chunk-33YXPOE3.js";
-import "./chunk-7CR24IG7.js";
-import "./chunk-IKCO5N3L.js";
-import "./chunk-3I7MS7N2.js";
-import "./chunk-WEPFGWHJ.js";
+} from "./chunk-CVDAFGPW.js";
+import "./chunk-PPEZJWUG.js";
+import "./chunk-WDV62RKY.js";
+import "./chunk-2QPI3TR3.js";
+import "./chunk-TK2BMCBZ.js";
+import "./chunk-ZZFWWYLX.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/cli/context-index.ts
 init_esm_shims();
@@ -115,4 +117,4 @@ async function runContextIndexCommand(args) {
 export {
   runContextIndexCommand
 };
-//# sourceMappingURL=context-index-HNG3MOME.js.map
+//# sourceMappingURL=context-index-HP2JFUWA.js.map

package/dist/{context-map-COB37XXN.js → context-map-INTXD54D.js}

@@ -3,22 +3,26 @@ import {
   WIKI_DEPTH_STRATEGY,
   areaForPath,
   classifyDepth
-} from "./chunk-R6Q67RJH.js";
+} from "./chunk-PECBKCDK.js";
 import {
-  CLIO_ARTIFACT_DIR
-} from "./chunk-GYV6VZOC.js";
+  coordinateCodewikiWrite
+} from "./chunk-7WUZEB2M.js";
 import {
-  readCodewiki
-} from "./chunk-LBMZMYH2.js";
-import "./chunk-WEPFGWHJ.js";
+  CLIO_ARTIFACT_DIR
+} from "./chunk-NTTS3O53.js";
+import "./chunk-W2RJEH6Q.js";
+import "./chunk-2QPI3TR3.js";
+import "./chunk-TK2BMCBZ.js";
+import "./chunk-ZZFWWYLX.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/cli/context-map.ts
 init_esm_shims();
 import { execFileSync } from "node:child_process";
-import { mkdirSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
 
 // src/domains/context/wiki/map-seed.ts
@@ -410,7 +414,8 @@ var HELP = `Usage:
 Write an archify architecture seed for the current repository from the codewiki
 index, without model calls. The seed is the starting spec for the archify skill:
 components are the largest directory areas, connections are collapsed import
-edges, and sources point at indexed files and lines.
+edges. The index is reconciled with current files before mapping; sources are
+pinned only when clean Git evidence matches those files.
 
 Options:
   --out <path>    where to write the seed (default: ${CLIO_ARTIFACT_DIR}/maps/<repo>.architecture.json)
@@ -422,19 +427,40 @@ function defaultMapSeedPath(cwd) {
 function gitValue(cwd, args) {
   try {
     const out = execFileSync("git", args, { cwd, timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] }).toString("utf8").trim();
-    return out.length > 0 ? out : null;
+    return out;
   } catch {
     return null;
   }
 }
-function repositoryFacts(cwd) {
-  const remote = gitValue(cwd, ["remote", "get-url", "origin"]);
+function repositoryFacts(cwd, codewiki, indexedHead) {
   const revision = gitValue(cwd, ["rev-parse", "--verify", "HEAD"]);
-  if (!remote || !revision) return void 0;
+  const status = gitValue(cwd, ["status", "--porcelain", "--untracked-files=normal"]);
+  if (!revision || status === null) return { sourceState: "unknown" };
+  if (status !== "" || revision !== indexedHead) return { sourceState: "dirty" };
+  if (gitValue(cwd, ["rev-parse", "--show-prefix"]) !== "") return { sourceState: "unknown" };
+  const tree = gitValue(cwd, ["ls-tree", "-r", "-z", revision]);
+  if (tree === null) return { sourceState: "unknown" };
+  const blobs = /* @__PURE__ */ new Map();
+  for (const entry of tree.split("\0")) {
+    const match = /^100[0-7]{3} blob ([a-f0-9]{40})\t([\s\S]+)$/.exec(entry);
+    if (match) blobs.set(match[2], match[1]);
+  }
+  try {
+    for (const file of codewiki.files) {
+      const contents = readFileSync(path.join(cwd, file.path));
+      const indexedHash = createHash("sha256").update(contents.toString("utf8")).digest("hex").slice(0, 16);
+      const blob = createHash("sha1").update(`blob ${contents.length}\0`).update(contents).digest("hex");
+      if (indexedHash !== file.hash || blobs.get(file.path) !== blob) return { sourceState: "dirty" };
+    }
+  } catch {
+    return { sourceState: "unknown" };
+  }
+  const remote = gitValue(cwd, ["remote", "get-url", "origin"]);
+  if (!remote) return { sourceState: "clean" };
   let url = remote.endsWith(".git") ? remote.slice(0, -4) : remote;
   const ssh = /^git@([^:]+):(.+)$/.exec(url);
   if (ssh) url = `https://${ssh[1]}/${ssh[2]}`;
-  return { url, revision };
+  return { sourceState: "clean", repository: { url, revision } };
 }
 async function runContextMapCommand(args) {
   if (args.includes("--help") || args.includes("-h")) {
@@ -464,16 +490,38 @@ async function runContextMapCommand(args) {
     return 2;
   }
   const cwd = process.cwd();
-  const codewiki = readCodewiki(cwd);
-  if (!codewiki) {
+  let reconciled;
+  try {
+    reconciled = await coordinateCodewikiWrite(
+      cwd,
+      (current, workspace) => current ? {
+        kind: "ensure",
+        cwd: workspace,
+        current,
+        language: current.language,
+        // Map evidence must reconcile actual inputs, even if a state file
+        // happens to carry a matching fingerprint from another operation.
+        previous: null
+      } : null,
+      { requireExisting: true }
+    );
+  } catch (error) {
+    process.stderr.write(
+      `clio-coder context map: index refresh failed: ${error instanceof Error ? error.message : String(error)}
+`
+    );
+    return 1;
+  }
+  if (!reconciled) {
     process.stderr.write(
       "clio-coder context map: no codewiki index in .clio-coder/codewiki.json; run `clio-coder context index` first\n"
     );
     return 1;
   }
-  const seed = buildArchitectureSeed(codewiki, {
+  const facts = repositoryFacts(cwd, reconciled.codewiki, reconciled.worker.fingerprint.gitHead);
+  const seed = buildArchitectureSeed(reconciled.codewiki, {
     title: path.basename(cwd),
-    repository: repositoryFacts(cwd)
+    repository: facts.repository
   });
   const target = out ? path.resolve(cwd, out) : defaultMapSeedPath(cwd);
   mkdirSync(path.dirname(target), { recursive: true });
@@ -482,7 +530,9 @@ async function runContextMapCommand(args) {
     path: target,
     components: seed.components.length,
     connections: seed.connections.length,
-    repository: seed.meta.repository ?? null
+    repository: seed.meta.repository ?? null,
+    index: "reconciled",
+    sourceState: facts.sourceState
   };
   if (json) {
     process.stdout.write(`${JSON.stringify(payload, null, 2)}
@@ -492,7 +542,7 @@ async function runContextMapCommand(args) {
   process.stdout.write(
     [
       `clio-coder context map wrote ${target}`,
-      `  ${payload.components} components, ${payload.connections} connections${payload.repository ? `, sources pinned at ${payload.repository.revision.slice(0, 12)}` : "; no GitHub origin at a full revision, so no source citations"}`,
+      `  ${payload.components} components, ${payload.connections} connections${payload.repository ? `, sources pinned at ${payload.repository.revision.slice(0, 12)}` : `; no source citations (source state: ${payload.sourceState}; requires verified clean files and a GitHub origin at a full revision)`}`,
       payload.repository ? "  next: validate and deliver it with the archify skill, passing --repo-root ." : "  next: validate and deliver it with the archify skill (without --repo-root)",
       ""
     ].join("\n")
@@ -502,4 +552,4 @@ async function runContextMapCommand(args) {
 export {
   runContextMapCommand
 };
-//# sourceMappingURL=context-map-COB37XXN.js.map
+//# sourceMappingURL=context-map-INTXD54D.js.map