arkaik 0.1.0 → 0.1.2

package/dist/index.js

@@ -783,10 +783,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path) {
-  if (!path)
+function getElementAtPath(obj, path6) {
+  if (!path6)
     return obj;
-  return path.reduce((acc, key) => acc?.[key], obj);
+  return path6.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1195,11 +1195,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path, issues) {
+function prefixIssues(path6, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path);
+    iss.path.unshift(path6);
     return iss;
   });
 }
@@ -1346,16 +1346,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path = []) => {
+  const processError = (error52, path6 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path6, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else {
-        const fullpath = [...path, ...issue2.path];
+        const fullpath = [...path6, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1382,17 +1382,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path = []) => {
+  const processError = (error52, path6 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path6, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else {
-        const fullpath = [...path, ...issue2.path];
+        const fullpath = [...path6, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1424,8 +1424,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path) {
+  const path6 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path6) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -4761,8 +4761,8 @@ var error3 = () => {
         const sizing = getSizing(issue2.origin);
         if (sizing) {
           const maxValue = Number(issue2.maximum);
-          const unit = getBelarusianPlural(maxValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
-          return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u0432\u044F\u043B\u0456\u043A\u0456: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue2.origin ?? "\u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435"} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 ${sizing.verb} ${adj}${issue2.maximum.toString()} ${unit}`;
+          const unit2 = getBelarusianPlural(maxValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
+          return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u0432\u044F\u043B\u0456\u043A\u0456: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue2.origin ?? "\u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435"} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 ${sizing.verb} ${adj}${issue2.maximum.toString()} ${unit2}`;
         }
         return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u0432\u044F\u043B\u0456\u043A\u0456: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue2.origin ?? "\u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435"} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 \u0431\u044B\u0446\u044C ${adj}${issue2.maximum.toString()}`;
       }
@@ -4771,8 +4771,8 @@ var error3 = () => {
         const sizing = getSizing(issue2.origin);
         if (sizing) {
           const minValue = Number(issue2.minimum);
-          const unit = getBelarusianPlural(minValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
-          return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u043C\u0430\u043B\u044B: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue2.origin} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 ${sizing.verb} ${adj}${issue2.minimum.toString()} ${unit}`;
+          const unit2 = getBelarusianPlural(minValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
+          return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u043C\u0430\u043B\u044B: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue2.origin} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 ${sizing.verb} ${adj}${issue2.minimum.toString()} ${unit2}`;
         }
         return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u043C\u0430\u043B\u044B: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue2.origin} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 \u0431\u044B\u0446\u044C ${adj}${issue2.minimum.toString()}`;
       }
@@ -6831,8 +6831,8 @@ var error20 = () => {
         const sizing = getSizing(issue2.origin);
         if (sizing) {
           const maxValue = Number(issue2.maximum);
-          const unit = getArmenianPlural(maxValue, sizing.unit.one, sizing.unit.many);
-          return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0574\u0565\u056E \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue2.origin ?? "\u0561\u0580\u056A\u0565\u0584")} \u056F\u0578\u0582\u0576\u0565\u0576\u0561 ${adj}${issue2.maximum.toString()} ${unit}`;
+          const unit2 = getArmenianPlural(maxValue, sizing.unit.one, sizing.unit.many);
+          return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0574\u0565\u056E \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue2.origin ?? "\u0561\u0580\u056A\u0565\u0584")} \u056F\u0578\u0582\u0576\u0565\u0576\u0561 ${adj}${issue2.maximum.toString()} ${unit2}`;
         }
         return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0574\u0565\u056E \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue2.origin ?? "\u0561\u0580\u056A\u0565\u0584")} \u056C\u056B\u0576\u056B ${adj}${issue2.maximum.toString()}`;
       }
@@ -6841,8 +6841,8 @@ var error20 = () => {
         const sizing = getSizing(issue2.origin);
         if (sizing) {
           const minValue = Number(issue2.minimum);
-          const unit = getArmenianPlural(minValue, sizing.unit.one, sizing.unit.many);
-          return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0583\u0578\u0584\u0580 \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue2.origin)} \u056F\u0578\u0582\u0576\u0565\u0576\u0561 ${adj}${issue2.minimum.toString()} ${unit}`;
+          const unit2 = getArmenianPlural(minValue, sizing.unit.one, sizing.unit.many);
+          return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0583\u0578\u0584\u0580 \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue2.origin)} \u056F\u0578\u0582\u0576\u0565\u0576\u0561 ${adj}${issue2.minimum.toString()} ${unit2}`;
         }
         return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0583\u0578\u0584\u0580 \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue2.origin)} \u056C\u056B\u0576\u056B ${adj}${issue2.minimum.toString()}`;
       }
@@ -7605,18 +7605,18 @@ var error27 = () => {
         const adj = issue2.inclusive ? "\uC774\uD558" : "\uBBF8\uB9CC";
         const suffix = adj === "\uBBF8\uB9CC" ? "\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4" : "\uC5EC\uC57C \uD569\uB2C8\uB2E4";
         const sizing = getSizing(issue2.origin);
-        const unit = sizing?.unit ?? "\uC694\uC18C";
+        const unit2 = sizing?.unit ?? "\uC694\uC18C";
         if (sizing)
-          return `${issue2.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${issue2.maximum.toString()}${unit} ${adj}${suffix}`;
+          return `${issue2.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${issue2.maximum.toString()}${unit2} ${adj}${suffix}`;
         return `${issue2.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${issue2.maximum.toString()} ${adj}${suffix}`;
       }
       case "too_small": {
         const adj = issue2.inclusive ? "\uC774\uC0C1" : "\uCD08\uACFC";
         const suffix = adj === "\uC774\uC0C1" ? "\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4" : "\uC5EC\uC57C \uD569\uB2C8\uB2E4";
         const sizing = getSizing(issue2.origin);
-        const unit = sizing?.unit ?? "\uC694\uC18C";
+        const unit2 = sizing?.unit ?? "\uC694\uC18C";
         if (sizing) {
-          return `${issue2.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uC791\uC2B5\uB2C8\uB2E4: ${issue2.minimum.toString()}${unit} ${adj}${suffix}`;
+          return `${issue2.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uC791\uC2B5\uB2C8\uB2E4: ${issue2.minimum.toString()}${unit2} ${adj}${suffix}`;
         }
         return `${issue2.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uC791\uC2B5\uB2C8\uB2E4: ${issue2.minimum.toString()} ${adj}${suffix}`;
       }
@@ -8969,8 +8969,8 @@ var error38 = () => {
         const sizing = getSizing(issue2.origin);
         if (sizing) {
           const maxValue = Number(issue2.maximum);
-          const unit = getRussianPlural(maxValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
-          return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u0431\u043E\u043B\u044C\u0448\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue2.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435"} \u0431\u0443\u0434\u0435\u0442 \u0438\u043C\u0435\u0442\u044C ${adj}${issue2.maximum.toString()} ${unit}`;
+          const unit2 = getRussianPlural(maxValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
+          return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u0431\u043E\u043B\u044C\u0448\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue2.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435"} \u0431\u0443\u0434\u0435\u0442 \u0438\u043C\u0435\u0442\u044C ${adj}${issue2.maximum.toString()} ${unit2}`;
         }
         return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u0431\u043E\u043B\u044C\u0448\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue2.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435"} \u0431\u0443\u0434\u0435\u0442 ${adj}${issue2.maximum.toString()}`;
       }
@@ -8979,8 +8979,8 @@ var error38 = () => {
         const sizing = getSizing(issue2.origin);
         if (sizing) {
           const minValue = Number(issue2.minimum);
-          const unit = getRussianPlural(minValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
-          return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u0430\u043B\u0435\u043D\u044C\u043A\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue2.origin} \u0431\u0443\u0434\u0435\u0442 \u0438\u043C\u0435\u0442\u044C ${adj}${issue2.minimum.toString()} ${unit}`;
+          const unit2 = getRussianPlural(minValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
+          return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u0430\u043B\u0435\u043D\u044C\u043A\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue2.origin} \u0431\u0443\u0434\u0435\u0442 \u0438\u043C\u0435\u0442\u044C ${adj}${issue2.minimum.toString()} ${unit2}`;
         }
         return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u0430\u043B\u0435\u043D\u044C\u043A\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue2.origin} \u0431\u0443\u0434\u0435\u0442 ${adj}${issue2.minimum.toString()}`;
       }
@@ -14117,13 +14117,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path = ref.slice(1).split("/").filter(Boolean);
-  if (path.length === 0) {
+  const path6 = ref.slice(1).split("/").filter(Boolean);
+  if (path6.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path[0] === defsKey) {
-    const key = path[1];
+  if (path6[0] === defsKey) {
+    const key = path6[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14532,19 +14532,58 @@ function date4(params) {
 config(en_default());
 
 // ../schema/src/ids.ts
-var SPECIES_IDS = ["flow", "view", "data-model", "api-endpoint", "acceptance"];
+var SPECIES_IDS = ["flow", "view", "data-model", "api-endpoint", "acceptance", "decision"];
 var STATUS_IDS = [
   "idea",
+  "discovery",
   "backlog",
-  "prioritized",
   "development",
   "releasing",
   "live",
-  "archived",
-  "blocked"
+  "archived"
 ];
 var PLATFORM_IDS = ["web", "ios", "android"];
-var EDGE_TYPE_IDS = ["composes", "calls", "displays", "queries", "covers"];
+var EDGE_TYPE_IDS = ["composes", "calls", "displays", "queries", "covers", "supersedes", "generates", "impacts"];
+var VALID_EDGE_SEMANTICS = {
+  composes: [
+    ["flow", "view"],
+    ["flow", "flow"],
+    ["view", "flow"],
+    ["view", "view"]
+  ],
+  // `calls` names the initiator, which is why it runs in both directions
+  // between a view and an endpoint: view → api is the outbound/write
+  // affordance, api → view the inbound/read one a server opens itself (a
+  // webhook, an SSE channel, a push). Both project onto the View card
+  // (docs/graph-model.md § Edge Types). Consumers that walk `calls` must
+  // therefore not assume it points down into the system layer — see
+  // `buildProductUsageIndex` in ./products.ts, which restricts hops by
+  // target species for exactly this reason.
+  calls: [
+    ["view", "api-endpoint"],
+    ["flow", "api-endpoint"],
+    ["api-endpoint", "api-endpoint"],
+    ["api-endpoint", "view"]
+  ],
+  displays: [["view", "data-model"]],
+  queries: [["api-endpoint", "data-model"]],
+  covers: [
+    ["acceptance", "view"],
+    ["acceptance", "flow"]
+  ],
+  // Decision edges (cycle 2). `generates` and `impacts` are deliberately
+  // disjoint: an acceptance is *generated* by a decision, never merely
+  // impacted, so `impacts` does not admit an acceptance target
+  // (docs/superpowers/specs/2026-08-03-decisions-species-design.md §3).
+  supersedes: [["decision", "decision"]],
+  generates: [["decision", "acceptance"]],
+  impacts: [
+    ["decision", "flow"],
+    ["decision", "view"],
+    ["decision", "data-model"],
+    ["decision", "api-endpoint"]
+  ]
+};
 var VALUE_TIER_IDS = ["functional", "emotional", "life-changing", "social-impact"];
 var VALUE_IDS = [
   // functional (14)
@@ -14583,6 +14622,106 @@ var VALUE_IDS = [
   "self-transcendence"
 ];
 
+// ../schema/src/legacy-status.ts
+var LEGACY_STATUS_IDS = ["prioritized", "blocked"];
+var LEGACY_STATUS_ALIASES = {
+  prioritized: "backlog",
+  blocked: "development"
+};
+var STATUS_VOCABULARY_VERSION = 3;
+var BLOCKED_BY_MIGRATION_NOTE = "migrated from legacy blocked status";
+function normalizeStatus(value) {
+  if (STATUS_IDS.includes(value)) return value;
+  return LEGACY_STATUS_ALIASES[value];
+}
+var LEGACY_ALIAS_REMAP = { ...LEGACY_STATUS_ALIASES };
+var LEGACY_VOCABULARY_REMAP = {
+  backlog: "idea",
+  ...LEGACY_STATUS_ALIASES
+};
+function migrateNode(node, remap) {
+  let changed = false;
+  let wasBlocked = node.status === "blocked";
+  const mappedStatus = remap[node.status];
+  const status = mappedStatus ?? node.status;
+  if (mappedStatus !== void 0) changed = true;
+  let metadata = node.metadata;
+  const platformStatuses = node.metadata?.platformStatuses;
+  if (platformStatuses !== void 0) {
+    let anyMapped = false;
+    const next = {};
+    for (const [platform, value] of Object.entries(platformStatuses)) {
+      if (value === "blocked") wasBlocked = true;
+      const mapped = remap[value];
+      next[platform] = mapped ?? value;
+      if (mapped !== void 0) anyMapped = true;
+    }
+    if (anyMapped) {
+      metadata = { ...metadata, platformStatuses: next };
+      changed = true;
+    }
+  }
+  const refs = node.metadata?.refs;
+  if (Array.isArray(refs)) {
+    let anyMapped = false;
+    const nextRefs = refs.map((ref) => {
+      if (ref.status_mapped === void 0) return ref;
+      const mapped = remap[ref.status_mapped];
+      if (mapped === void 0) return ref;
+      anyMapped = true;
+      return { ...ref, status_mapped: mapped };
+    });
+    if (anyMapped) {
+      metadata = { ...metadata, refs: nextRefs };
+      changed = true;
+    }
+  }
+  if (wasBlocked && !metadata?.blocked_by) {
+    metadata = { ...metadata, blocked_by: BLOCKED_BY_MIGRATION_NOTE };
+    changed = true;
+  }
+  if (!changed) return node;
+  return { ...node, status, ...metadata !== void 0 ? { metadata } : {} };
+}
+function migrateStatusVocabulary(bundle) {
+  const current = typeof bundle.schema_version === "number" && bundle.schema_version >= STATUS_VOCABULARY_VERSION;
+  const remap = current ? LEGACY_ALIAS_REMAP : LEGACY_VOCABULARY_REMAP;
+  const nodes = bundle.nodes.map((node) => migrateNode(node, remap));
+  if (current) {
+    const untouched = nodes.every((node, i) => node === bundle.nodes[i]);
+    return untouched ? bundle : { ...bundle, nodes };
+  }
+  return { ...bundle, schema_version: STATUS_VOCABULARY_VERSION, nodes };
+}
+
+// ../schema/src/decision.ts
+var DECISION_STATUS_IDS = [
+  "proposed",
+  "approved",
+  "enacted",
+  "rejected",
+  "deprecated",
+  "superseded"
+];
+function lifecycleStatusForDecision(decisionStatus) {
+  switch (decisionStatus) {
+    case "proposed":
+      return "discovery";
+    case "approved":
+      return "backlog";
+    case "enacted":
+      return "live";
+    case "rejected":
+    case "deprecated":
+    case "superseded":
+      return "archived";
+  }
+}
+function decisionStatusOf(node) {
+  const raw = node.metadata?.decision_status;
+  return DECISION_STATUS_IDS.includes(raw) ? raw : "proposed";
+}
+
 // ../schema/src/enums.ts
 var SpeciesSchema = external_exports.enum(SPECIES_IDS).meta({
   id: "Species",
@@ -14592,6 +14731,10 @@ var StatusSchema = external_exports.enum(STATUS_IDS).meta({
   id: "Status",
   description: "Lifecycle status of a node."
 });
+var AnyStatusSchema = external_exports.enum([...STATUS_IDS, ...LEGACY_STATUS_IDS]).meta({
+  id: "AnyStatus",
+  description: "Lifecycle status as stored: the current vocabulary, or a legacy id (prioritized, blocked) accepted from pre-v3 bundles and migrated on load."
+});
 var PlatformSchema = external_exports.enum(PLATFORM_IDS).meta({
   id: "Platform",
   description: "Target platform."
@@ -14608,6 +14751,10 @@ var ValueSchema = external_exports.enum(VALUE_IDS).meta({
   id: "Value",
   description: "A Bain B2C Elements-of-Value element served by an acceptance (spec \xA73.2)."
 });
+var DecisionStatusSchema = external_exports.enum(DECISION_STATUS_IDS).meta({
+  id: "DecisionStatus",
+  description: "Decision nodes only: proposed \u2192 approved (agreed, not yet reality) \u2192 enacted (in effect); terminal: rejected, deprecated, superseded. Not a lifecycle status \u2014 the node's status field is kept in sync (proposed\u2192discovery, approved\u2192backlog, enacted\u2192live, terminals\u2192archived)."
+});
 
 // ../schema/src/id-gen.ts
 var SPECIES_PREFIXES = {
@@ -14615,8 +14762,12 @@ var SPECIES_PREFIXES = {
   view: "V-",
   "data-model": "DM-",
   "api-endpoint": "API-",
-  acceptance: "AC-"
+  acceptance: "AC-",
+  decision: "DEC-"
 };
+function edgeId(sourceId, targetId) {
+  return `e-${sourceId}-${targetId}`;
+}
 
 // ../schema/src/playlist.ts
 var JunctionCaseSchema = external_exports.lazy(
@@ -14713,6 +14864,7 @@ function parseJournalLines(text) {
 var NODE_REF_FIELDS = {
   "node.updated": ["node_id"],
   "node.status_changed": ["node_id"],
+  "decision.status_changed": ["node_id"],
   "node.deleted": ["node_id"],
   "edge.added": ["source_id", "target_id"],
   "ref.added": ["node_id"],
@@ -14721,6 +14873,12 @@ var NODE_REF_FIELDS = {
   "idea.proposed": ["node_id"],
   "request.filed": ["node_id"]
 };
+function statusesAgree(last, snapshot) {
+  if (last === snapshot) return true;
+  if (typeof snapshot !== "string") return false;
+  if (last === "backlog" && snapshot === "idea") return true;
+  return (normalizeStatus(last) ?? last) === (normalizeStatus(snapshot) ?? snapshot);
+}
 function crossCheckJournal(bundle) {
   const findings = [];
   const journalRaw = bundle.journal;
@@ -14739,9 +14897,15 @@ function crossCheckJournal(bundle) {
   const nodesRaw = Array.isArray(bundle.nodes) ? bundle.nodes : [];
   const edgesRaw = Array.isArray(bundle.edges) ? bundle.edges : [];
   const snapshotNodeStatus = /* @__PURE__ */ new Map();
+  const snapshotDecisionStatus = /* @__PURE__ */ new Map();
   for (const n of nodesRaw) {
     const id = str2(n?.id);
-    if (id !== void 0) snapshotNodeStatus.set(id, n.status);
+    if (id !== void 0) {
+      snapshotNodeStatus.set(id, n.status);
+      const metadata = n.metadata;
+      const decisionStatus = metadata && typeof metadata === "object" && !Array.isArray(metadata) ? metadata.decision_status : void 0;
+      snapshotDecisionStatus.set(id, decisionStatus ?? "proposed");
+    }
   }
   const snapshotEdgeIds = /* @__PURE__ */ new Set();
   for (const e of edgesRaw) {
@@ -14750,10 +14914,10 @@ function crossCheckJournal(bundle) {
   }
   const valid = [];
   journalRaw.forEach((raw, index) => {
-    const path = `journal[${index}]`;
+    const path6 = `journal[${index}]`;
     if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
       findings.push({
-        path,
+        path: path6,
         rule: "journal-event-shape",
         message: `journal[${index}]: each event must be a JSON object.`,
         severity: "error"
@@ -14767,7 +14931,7 @@ function crossCheckJournal(bundle) {
     if (str2(ev.type) === void 0) missing.push("type");
     if (missing.length > 0) {
       findings.push({
-        path,
+        path: path6,
         rule: "journal-event-envelope",
         message: `journal[${index}]: event is missing required envelope field(s): ${missing.join(", ")}.`,
         severity: "error"
@@ -14790,6 +14954,7 @@ function crossCheckJournal(bundle) {
   const ordered = orderEvents(valid.map((v) => v.ev));
   const created = /* @__PURE__ */ new Set();
   const lastProjectStatus = /* @__PURE__ */ new Map();
+  const lastDecisionStatus = /* @__PURE__ */ new Map();
   for (const ev of ordered) {
     if (ev.type === "node.created") {
       const nid = str2(ev.node_id);
@@ -14800,6 +14965,12 @@ function crossCheckJournal(bundle) {
         const to = str2(ev.to);
         if (to !== void 0) lastProjectStatus.set(nid, to);
       }
+    } else if (ev.type === "decision.status_changed") {
+      const nid = str2(ev.node_id);
+      if (nid) {
+        const to = str2(ev.to);
+        if (to !== void 0) lastDecisionStatus.set(nid, to);
+      }
     }
   }
   for (const { ev, index } of valid) {
@@ -14817,6 +14988,19 @@ function crossCheckJournal(bundle) {
         }
       }
     }
+    if (ev.type === "deliverable.shipped" && Array.isArray(ev.node_ids)) {
+      ev.node_ids.forEach((raw, i) => {
+        const ref = str2(raw);
+        if (ref !== void 0 && !everNodes.has(ref)) {
+          findings.push({
+            path: `journal[${index}].node_ids[${i}]`,
+            rule: "journal-dangling-node-ref",
+            message: `journal[${index}] (${ev.type}): references node "${ref}" that never existed in the snapshot or journal.`,
+            severity: "error"
+          });
+        }
+      });
+    }
     if (ev.type === "edge.removed") {
       const ref = str2(ev.edge_id);
       if (ref !== void 0 && !everEdges.has(ref)) {
@@ -14839,7 +15023,7 @@ function crossCheckJournal(bundle) {
       });
     }
     const last = lastProjectStatus.get(nodeId);
-    if (last !== void 0 && last !== status) {
+    if (last !== void 0 && !statusesAgree(last, status)) {
       findings.push({
         path: "journal",
         rule: "journal-status-mismatch",
@@ -14848,6 +15032,18 @@ function crossCheckJournal(bundle) {
       });
     }
   }
+  for (const [nodeId, last] of lastDecisionStatus) {
+    if (!snapshotDecisionStatus.has(nodeId)) continue;
+    const current = snapshotDecisionStatus.get(nodeId) ?? "proposed";
+    if (last !== current) {
+      findings.push({
+        path: "journal",
+        rule: "journal-decision-status-mismatch",
+        message: `Node "${nodeId}": journal's last decision.status_changed.to "${last}" disagrees with snapshot decision_status "${String(current)}".`,
+        severity: "error"
+      });
+    }
+  }
   return findings;
 }
 
@@ -14878,10 +15074,19 @@ var NodeStatusChangedEventSchema = external_exports.object({
   ...envelope,
   type: external_exports.literal("node.status_changed"),
   node_id: external_exports.string(),
-  from: StatusSchema,
-  to: StatusSchema,
+  // History is never rewritten (docs/spec/journal.md): pre-v3 events keep
+  // their legacy status ids, so strict per-type validation must accept them.
+  from: AnyStatusSchema,
+  to: AnyStatusSchema,
   platform: PlatformSchema.optional()
 }).catchall(external_exports.unknown());
+var DecisionStatusChangedEventSchema = external_exports.object({
+  ...envelope,
+  type: external_exports.literal("decision.status_changed"),
+  node_id: external_exports.string(),
+  from: DecisionStatusSchema,
+  to: DecisionStatusSchema
+}).catchall(external_exports.unknown());
 var NodeDeletedEventSchema = external_exports.object({ ...envelope, type: external_exports.literal("node.deleted"), node_id: external_exports.string() }).catchall(external_exports.unknown());
 var EdgeAddedEventSchema = external_exports.object({
   ...envelope,
@@ -14899,6 +15104,16 @@ var ReleaseTaggedEventSchema = external_exports.object({
   notes: external_exports.string().optional(),
   platform: PlatformSchema.optional()
 }).catchall(external_exports.unknown());
+var DeliverableShippedEventSchema = external_exports.object({
+  ...envelope,
+  type: external_exports.literal("deliverable.shipped"),
+  deliverable_id: external_exports.string(),
+  title: external_exports.string(),
+  summary: external_exports.string().optional(),
+  url: external_exports.string().optional(),
+  node_ids: external_exports.array(external_exports.string()).optional(),
+  platform: PlatformSchema.optional()
+}).catchall(external_exports.unknown());
 var IdeaProposedEventSchema = external_exports.object({
   ...envelope,
   type: external_exports.literal("idea.proposed"),
@@ -14936,10 +15151,12 @@ var JOURNAL_EVENT_SCHEMAS = {
   "node.created": NodeCreatedEventSchema,
   "node.updated": NodeUpdatedEventSchema,
   "node.status_changed": NodeStatusChangedEventSchema,
+  "decision.status_changed": DecisionStatusChangedEventSchema,
   "node.deleted": NodeDeletedEventSchema,
   "edge.added": EdgeAddedEventSchema,
   "edge.removed": EdgeRemovedEventSchema,
   "release.tagged": ReleaseTaggedEventSchema,
+  "deliverable.shipped": DeliverableShippedEventSchema,
   "idea.proposed": IdeaProposedEventSchema,
   "request.filed": RequestFiledEventSchema,
   "ref.added": RefAddedEventSchema,
@@ -14950,10 +15167,12 @@ var KnownJournalEventSchema = external_exports.union([
   NodeCreatedEventSchema,
   NodeUpdatedEventSchema,
   NodeStatusChangedEventSchema,
+  DecisionStatusChangedEventSchema,
   NodeDeletedEventSchema,
   EdgeAddedEventSchema,
   EdgeRemovedEventSchema,
   ReleaseTaggedEventSchema,
+  DeliverableShippedEventSchema,
   IdeaProposedEventSchema,
   RequestFiledEventSchema,
   RefAddedEventSchema,
@@ -14964,7 +15183,8 @@ var KnownJournalEventSchema = external_exports.union([
 // ../schema/src/bundle.ts
 var PlatformStatusMapSchema = external_exports.partialRecord(
   PlatformSchema,
-  StatusSchema
+  // legacy-tolerant: migrateStatusVocabulary normalizes on load
+  AnyStatusSchema
 ).meta({ id: "PlatformStatusMap", description: "Per-platform status overrides for view nodes." });
 var PlatformNotesMapSchema = external_exports.partialRecord(
   PlatformSchema,
@@ -14987,7 +15207,8 @@ var RefSchema = external_exports.object({
   external_status: external_exports.string().optional().meta({
     description: 'Mirrored external state, verbatim (e.g. "open", "merged", "In Progress").'
   }),
-  status_mapped: StatusSchema.optional().meta({
+  // legacy-tolerant: migrateStatusVocabulary normalizes on load
+  status_mapped: AnyStatusSchema.optional().meta({
     description: "Optional mapping of external_status into the arkaik lifecycle. Advisory display data \u2014 never mutates node.status."
   }),
   platform: PlatformSchema.optional().meta({ description: "Optional scoping to one platform variant." }),
@@ -14995,6 +15216,9 @@ var RefSchema = external_exports.object({
 }).meta({ id: "Ref", description: "A typed external reference on a node (docs/spec/bundle-format.md \xA7 References)." });
 var NodeMetadataSchema = external_exports.object({
   stage: external_exports.string().optional(),
+  blocked_by: external_exports.string().optional().meta({
+    description: "Non-empty = blocked at the current status. A node id (rendered as a link) or free text naming the dependency."
+  }),
   playlist: FlowPlaylistSchema.optional(),
   platformNotes: PlatformNotesMapSchema.optional(),
   platformStatuses: PlatformStatusMapSchema.optional(),
@@ -15005,6 +15229,21 @@ var NodeMetadataSchema = external_exports.object({
   }),
   values: external_exports.array(ValueSchema).optional().meta({
     description: "Acceptance nodes only: 1..n Bain value elements served (the Why)."
+  }),
+  product: external_exports.string().optional().meta({
+    description: "Product membership (docs/spec/bundle-format.md \xA7 Products); flow, view, and acceptance only."
+  }),
+  decision_status: DecisionStatusSchema.optional().meta({
+    description: "Decision nodes only: proposed | approved | enacted | rejected | deprecated | superseded. The node's lifecycle status is kept in sync (spec \xA72)."
+  }),
+  context: external_exports.string().optional().meta({
+    description: "Decision nodes only: Context \u2014 the Why (markdown)."
+  }),
+  consequences: external_exports.string().optional().meta({
+    description: "Decision nodes only: Consequences \u2014 the How (markdown)."
+  }),
+  decided_at: external_exports.string().optional().meta({
+    description: "Decision nodes only: ISO 8601 date the decision was made."
   })
 }).catchall(external_exports.unknown()).meta({ id: "NodeMetadata", description: "Optional metadata for a node." });
 var NodeSchema = external_exports.object({
@@ -15013,7 +15252,8 @@ var NodeSchema = external_exports.object({
   species: SpeciesSchema,
   title: external_exports.string().meta({ description: "Human-readable node title." }),
   description: external_exports.string().optional().meta({ description: "Optional description of the node's purpose." }),
-  status: StatusSchema,
+  // legacy-tolerant: migrateStatusVocabulary normalizes on load
+  status: AnyStatusSchema,
   platforms: external_exports.array(PlatformSchema).meta({ description: "One or more target platforms." }),
   metadata: NodeMetadataSchema.optional()
 }).meta({ id: "Node" });
@@ -15025,6 +15265,18 @@ var EdgeSchema = external_exports.object({
   edge_type: EdgeTypeSchema,
   metadata: external_exports.record(external_exports.string(), external_exports.unknown()).optional().meta({ description: "Optional edge metadata." })
 }).meta({ id: "Edge" });
+var MapDisplayOptionsSchema = external_exports.object({
+  images: external_exports.boolean().optional().meta({ description: "Screenshot (or cover) art on view cards." }),
+  flow_platforms: external_exports.string().optional().meta({
+    description: "A flow card's platform delivery: rings (default) | bars."
+  }),
+  view_platforms: external_exports.string().optional().meta({
+    description: "A view card's platform availability: chips (default) | rows."
+  }),
+  minimap_color: external_exports.string().optional().meta({
+    description: "What a minimap node's fill encodes: status (default) | species."
+  })
+}).catchall(external_exports.unknown()).meta({ id: "MapDisplayOptions", description: "How a map draws its cards (docs/spec/maps.md \xA7 Display Options)." });
 var MapDefinitionSchema = external_exports.object({
   id: external_exports.string().meta({
     description: "Kebab-case, unique within the project; built-in ids (journey, system) are reserved."
@@ -15043,13 +15295,32 @@ var MapDefinitionSchema = external_exports.object({
   root_node_id: external_exports.string().optional().meta({
     description: "Scope anchor: the subgraph is the undirected neighborhood reachable from this node."
   }),
+  product: external_exports.string().optional().meta({ description: "Product scope; absent = every product." }),
   depth: external_exports.number().optional().meta({ description: "Traversal bound from the root; absent = unbounded." }),
-  layout: external_exports.object({ direction: external_exports.string().optional() }).catchall(external_exports.unknown()).optional().meta({ description: "Renderer layout hints (e.g. direction: DOWN | RIGHT)." })
+  layout: external_exports.object({ direction: external_exports.string().optional() }).catchall(external_exports.unknown()).optional().meta({ description: "Renderer layout hints (e.g. direction: DOWN | RIGHT)." }),
+  display: MapDisplayOptionsSchema.optional().meta({
+    description: "Card rendering; the human twin is project.metadata.map_display[id]."
+  })
 }).catchall(external_exports.unknown()).meta({ id: "MapDefinition", description: "A stored map definition (docs/spec/maps.md \xA7 MapDefinition)." });
+var ProductDefinitionSchema = external_exports.object({
+  id: external_exports.string().meta({ description: "Kebab-case, unique within the project." }),
+  title: external_exports.string().meta({ description: "Display title." }),
+  description: external_exports.string().optional().meta({ description: "What this product is." }),
+  platforms: external_exports.array(PlatformSchema).meta({
+    description: "The platforms this product can ship on; empty means availability is not tracked."
+  }),
+  root_node_id: external_exports.string().optional().meta({ description: "This product's journey anchor." })
+}).catchall(external_exports.unknown()).meta({ id: "ProductDefinition", description: "A product definition (docs/spec/bundle-format.md \xA7 Products)." });
 var ProjectMetadataSchema = external_exports.object({
   view_card_variant: external_exports.enum(["compact", "large"]).optional(),
   maps: external_exports.array(MapDefinitionSchema).optional().meta({
     description: "Stored map definitions (docs/spec/maps.md \xA7 Storage) \u2014 additive; unknown fields preserved."
+  }),
+  map_display: external_exports.record(external_exports.string(), MapDisplayOptionsSchema).optional().meta({
+    description: "Per-map display overrides keyed by map id (docs/spec/maps.md \xA7 Display Options) \u2014 the only path open to the built-in maps."
+  }),
+  products: external_exports.array(ProductDefinitionSchema).optional().meta({
+    description: "Product definitions (docs/spec/bundle-format.md \xA7 Products) \u2014 additive; unknown fields preserved."
   })
 }).catchall(external_exports.unknown()).meta({ id: "ProjectMetadata", description: "Optional project-level UI settings." });
 var ProjectSchema = external_exports.object({
@@ -15086,11 +15357,31 @@ var ProjectBundleSchema = external_exports.object({
 });
 
 // ../schema/src/maps.ts
+var MAP_FLOW_PLATFORMS_MODES = ["rings", "bars"];
+var MAP_VIEW_PLATFORMS_MODES = ["chips", "rows"];
+var MAP_MINIMAP_COLOR_MODES = ["status", "species"];
 var BUILT_IN_MAP_IDS = ["journey", "system"];
 function isBuiltInMapId(id) {
   return BUILT_IN_MAP_IDS.includes(id);
 }
 
+// ../schema/src/products.ts
+var PRODUCT_MEMBERSHIP_SPECIES = ["flow", "view", "acceptance"];
+function resolveProducts(project) {
+  const stored = project?.metadata?.products;
+  if (!Array.isArray(stored)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const products = [];
+  for (const entry of stored) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) continue;
+    const candidate = entry;
+    if (typeof candidate.id !== "string" || candidate.id.trim() === "" || seen.has(candidate.id)) continue;
+    seen.add(candidate.id);
+    products.push(candidate);
+  }
+  return products;
+}
+
 // ../schema/src/validate.ts
 var VALID_STAGES = ["beta", "monitoring", "deprecated"];
 var VALID_VIEW_CARD_VARIANTS = ["compact", "large"];
@@ -15102,32 +15393,13 @@ function estimateDataUriBytes(dataUri) {
   const padding = payload.endsWith("==") ? 2 : payload.endsWith("=") ? 1 : 0;
   return Math.floor(payload.length * 3 / 4) - padding;
 }
-var VALID_EDGE_SEMANTICS = {
-  composes: [
-    ["flow", "view"],
-    ["flow", "flow"],
-    ["view", "flow"],
-    ["view", "view"]
-  ],
-  calls: [
-    ["view", "api-endpoint"],
-    ["flow", "api-endpoint"],
-    ["api-endpoint", "api-endpoint"]
-  ],
-  displays: [["view", "data-model"]],
-  queries: [["api-endpoint", "data-model"]],
-  covers: [
-    ["acceptance", "view"],
-    ["acceptance", "flow"]
-  ]
-};
 function isIsoDate(value) {
   return typeof value === "string" && !Number.isNaN(Date.parse(value));
 }
 function validateBundle(input) {
   const findings = [];
-  const error51 = (path, rule, message) => findings.push({ path, rule, message, severity: "error" });
-  const warn = (path, rule, message) => findings.push({ path, rule, message, severity: "warning" });
+  const error51 = (path6, rule, message) => findings.push({ path: path6, rule, message, severity: "error" });
+  const warn = (path6, rule, message) => findings.push({ path: path6, rule, message, severity: "warning" });
   const result = () => {
     const errors = findings.filter((f) => f.severity === "error");
     const warnings = findings.filter((f) => f.severity === "warning");
@@ -15216,7 +15488,9 @@ function validateBundle(input) {
     }
     const platforms = node.platforms;
     if (!platforms || platforms.length === 0) {
-      error51(`${base}.platforms`, "platforms-non-empty", `Node ${nodeId}: platforms array is empty or missing`);
+      if (species !== "decision") {
+        error51(`${base}.platforms`, "platforms-non-empty", `Node ${nodeId}: platforms array is empty or missing`);
+      }
     } else {
       for (const p of platforms) {
         if (!PLATFORM_IDS.includes(p)) {
@@ -15338,6 +15612,25 @@ function validateBundle(input) {
         }
       });
     }
+    const decisionStatus = md.decision_status;
+    if (decisionStatus !== void 0 && species !== "decision") {
+      warn(
+        `${base}.metadata.decision_status`,
+        "decision-status-wrong-species",
+        `decision_status is meaningful on decision nodes only; "${nodeId}" is a ${species}.`
+      );
+    }
+    if (species === "decision") {
+      const effective = decisionStatusOf({ metadata: node.metadata });
+      const expected = lifecycleStatusForDecision(effective);
+      if (node.status !== expected) {
+        warn(
+          `${base}.status`,
+          "decision-lifecycle-mismatch",
+          `Decision "${nodeId}" is ${effective}, whose lifecycle status should be "${expected}", but status is "${node.status}" (spec \xA72).`
+        );
+      }
+    }
     if (species === "flow") {
       const playlist = md.playlist;
       if (!node.metadata || !playlist || !playlist.entries) {
@@ -15355,27 +15648,59 @@ function validateBundle(input) {
       `project.root_node_id "${rootNodeId}" does not reference an existing node`
     );
   }
+  const checkMapDisplay = (display, path6, subject) => {
+    if (typeof display !== "object" || display === null || Array.isArray(display)) return;
+    const options = display;
+    const modes = [
+      ["flow_platforms", MAP_FLOW_PLATFORMS_MODES],
+      ["view_platforms", MAP_VIEW_PLATFORMS_MODES],
+      ["minimap_color", MAP_MINIMAP_COLOR_MODES]
+    ];
+    for (const [key, allowed] of modes) {
+      const value = options[key];
+      if (value !== void 0 && (typeof value !== "string" || !allowed.includes(value))) {
+        warn(
+          `${path6}.${key}`,
+          "map-unknown-display",
+          `${subject} sets ${key} to "${String(value)}"; expected one of ${allowed.join(", ")} (renderers fall back to the default)`
+        );
+      }
+    }
+    if (options.images !== void 0 && typeof options.images !== "boolean") {
+      warn(
+        `${path6}.images`,
+        "map-unknown-display",
+        `${subject} sets images to a non-boolean value (renderers fall back to the default)`
+      );
+    }
+  };
+  const mapDisplayOverrides = projectMetadata?.map_display;
+  if (typeof mapDisplayOverrides === "object" && mapDisplayOverrides !== null && !Array.isArray(mapDisplayOverrides)) {
+    for (const [mapId, display] of Object.entries(mapDisplayOverrides)) {
+      checkMapDisplay(display, `project.metadata.map_display.${mapId}`, `Map "${mapId}"`);
+    }
+  }
   const storedMaps = projectMetadata?.maps;
   if (Array.isArray(storedMaps)) {
     const seenMapIds = /* @__PURE__ */ new Set();
     storedMaps.forEach((definition, index) => {
       if (typeof definition !== "object" || definition === null || Array.isArray(definition)) return;
       const map2 = definition;
-      const path = `project.metadata.maps[${index}]`;
+      const path6 = `project.metadata.maps[${index}]`;
       const mapId = typeof map2.id === "string" ? map2.id : void 0;
       if (mapId !== void 0) {
         if (seenMapIds.has(mapId)) {
-          warn(`${path}.id`, "map-duplicate-id", `Duplicate map id "${mapId}"`);
+          warn(`${path6}.id`, "map-duplicate-id", `Duplicate map id "${mapId}"`);
         }
         seenMapIds.add(mapId);
         if (isBuiltInMapId(mapId)) {
-          warn(`${path}.id`, "map-shadows-built-in", `Map id "${mapId}" shadows a built-in map and will be ignored`);
+          warn(`${path6}.id`, "map-shadows-built-in", `Map id "${mapId}" shadows a built-in map and will be ignored`);
         }
       }
       const mapRoot = map2.root_node_id;
       if (typeof mapRoot === "string" && !nodeIds.has(mapRoot)) {
         warn(
-          `${path}.root_node_id`,
+          `${path6}.root_node_id`,
           "map-unknown-root",
           `Map "${mapId ?? index}" anchors on "${mapRoot}" which does not reference an existing node`
         );
@@ -15384,7 +15709,7 @@ function validateBundle(input) {
         map2.species.forEach((value, valueIndex) => {
           if (typeof value === "string" && !SPECIES_IDS.includes(value)) {
             warn(
-              `${path}.species[${valueIndex}]`,
+              `${path6}.species[${valueIndex}]`,
               "map-unknown-species",
               `Map "${mapId ?? index}" filters on unknown species "${value}"`
             );
@@ -15395,15 +15720,129 @@ function validateBundle(input) {
         map2.edge_types.forEach((value, valueIndex) => {
           if (typeof value === "string" && !EDGE_TYPE_IDS.includes(value)) {
             warn(
-              `${path}.edge_types[${valueIndex}]`,
+              `${path6}.edge_types[${valueIndex}]`,
               "map-unknown-edge-type",
               `Map "${mapId ?? index}" filters on unknown edge type "${value}"`
             );
           }
         });
       }
+      checkMapDisplay(map2.display, `${path6}.display`, `Map "${mapId ?? index}"`);
+    });
+  }
+  const storedProducts = projectMetadata?.products;
+  const declaredProductIds = /* @__PURE__ */ new Set();
+  if (Array.isArray(storedProducts)) {
+    const seenProductIds = /* @__PURE__ */ new Set();
+    storedProducts.forEach((definition, index) => {
+      if (typeof definition !== "object" || definition === null || Array.isArray(definition)) return;
+      const product = definition;
+      const path6 = `project.metadata.products[${index}]`;
+      const productId = typeof product.id === "string" ? product.id : void 0;
+      if (productId === void 0) return;
+      if (seenProductIds.has(productId)) {
+        warn(`${path6}.id`, "product-duplicate-id", `Duplicate product id "${productId}" \u2014 the first wins`);
+      } else {
+        seenProductIds.add(productId);
+        if (productId.trim() !== "") declaredProductIds.add(productId);
+      }
+      if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(productId)) {
+        warn(`${path6}.id`, "product-invalid-id", `Product id "${productId}" is not kebab-case`);
+      }
     });
   }
+  const hasProducts = declaredProductIds.size > 0;
+  const anchorsByAcceptance = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    if (edge.edge_type !== "covers") continue;
+    const source = typeof edge.source_id === "string" ? edge.source_id : void 0;
+    const target = typeof edge.target_id === "string" ? edge.target_id : void 0;
+    if (source === void 0 || target === void 0) continue;
+    const list = anchorsByAcceptance.get(source) ?? [];
+    list.push(target);
+    anchorsByAcceptance.set(source, list);
+  }
+  const menuByProduct = /* @__PURE__ */ new Map();
+  if (hasProducts) {
+    for (const definition of resolveProducts({ metadata: projectMetadata })) {
+      menuByProduct.set(
+        definition.id,
+        new Set(Array.isArray(definition.platforms) ? definition.platforms : [])
+      );
+    }
+  }
+  const productByNodeId = /* @__PURE__ */ new Map();
+  const indexByNodeId = /* @__PURE__ */ new Map();
+  nodes.forEach((node, index) => {
+    const nodeId = typeof node.id === "string" ? node.id : `#${index}`;
+    const species = node.species;
+    const base = `nodes[${index}]`;
+    indexByNodeId.set(nodeId, index);
+    const metadata = node.metadata ?? {};
+    const membership = typeof metadata.product === "string" ? metadata.product : void 0;
+    const storesMembership = species !== void 0 && PRODUCT_MEMBERSHIP_SPECIES.includes(species);
+    if (membership !== void 0 && !storesMembership) {
+      const detail = SPECIES_IDS.includes(species) ? `${species} membership is derived from consumers and must not be stored` : "metadata.product is only meaningful on flow, view, and acceptance nodes";
+      warn(`${base}.metadata.product`, "product-membership-wrong-species", `Node ${nodeId}: ${detail}`);
+      return;
+    }
+    if (!storesMembership) return;
+    if (membership === void 0) {
+      if (!hasProducts) return;
+      if (species === "acceptance") {
+        if (!anchorsByAcceptance.has(nodeId)) {
+          warn(
+            `${base}.metadata.product`,
+            "acceptance-product-unassigned",
+            `Acceptance ${nodeId} covers nothing and names no product \u2014 it will show only under "All products"`
+          );
+        }
+      } else {
+        warn(
+          `${base}.metadata.product`,
+          "unassigned-membership",
+          `Node ${nodeId}: no product membership \u2014 it will show only under "All products"`
+        );
+      }
+      return;
+    }
+    productByNodeId.set(nodeId, membership);
+    if (!declaredProductIds.has(membership)) {
+      warn(
+        `${base}.metadata.product`,
+        "product-unknown-reference",
+        `Node ${nodeId}: product "${membership}" is not declared on the project`
+      );
+      return;
+    }
+    const menu = menuByProduct.get(membership);
+    const nodePlatforms = Array.isArray(node.platforms) ? node.platforms : [];
+    if (menu) {
+      for (const platform of nodePlatforms) {
+        if (typeof platform === "string" && !menu.has(platform)) {
+          warn(
+            `${base}.platforms`,
+            "product-platform-not-in-menu",
+            `Node ${nodeId}: platform "${platform}" is not in product "${membership}"'s menu`
+          );
+        }
+      }
+    }
+  });
+  if (hasProducts) {
+    for (const [acceptanceId, anchors] of anchorsByAcceptance) {
+      const acceptanceIndex = indexByNodeId.get(acceptanceId);
+      if (acceptanceIndex === void 0) continue;
+      const spanned = new Set(anchors.map((id) => productByNodeId.get(id)).filter((id) => Boolean(id)));
+      if (spanned.size > 1) {
+        warn(
+          `nodes[${acceptanceIndex}].metadata.product`,
+          "acceptance-covers-span-products",
+          `Acceptance ${acceptanceId} covers anchors in ${[...spanned].sort().join(" and ")} \u2014 statuses may conflate products`
+        );
+      }
+    }
+  }
   const edgeIds = /* @__PURE__ */ new Set();
   const edgeSignatures = /* @__PURE__ */ new Set();
   const composesSet = /* @__PURE__ */ new Set();
@@ -15459,33 +15898,33 @@ function validateBundle(input) {
       composesSet.add(`${sourceId}->${targetId}`);
     }
   });
-  const collectPlaylistRefs = (entries, flowId, path, depth = 0) => {
+  const collectPlaylistRefs = (entries, flowId, path6, depth = 0) => {
     if (depth > 50) {
-      error51(path, "playlist-depth", `Flow ${flowId}: playlist nesting too deep (possible cycle)`);
+      error51(path6, "playlist-depth", `Flow ${flowId}: playlist nesting too deep (possible cycle)`);
       return [];
     }
     const refs = [];
     for (const entry of entries) {
       if (entry.type === "view") {
         if (!nodeIds.has(entry.view_id)) {
-          error51(path, "playlist-ref-exists", `Flow ${flowId}: playlist references non-existent view "${entry.view_id}"`);
+          error51(path6, "playlist-ref-exists", `Flow ${flowId}: playlist references non-existent view "${entry.view_id}"`);
         }
         refs.push(entry.view_id);
       } else if (entry.type === "flow") {
         if (!nodeIds.has(entry.flow_id)) {
-          error51(path, "playlist-ref-exists", `Flow ${flowId}: playlist references non-existent flow "${entry.flow_id}"`);
+          error51(path6, "playlist-ref-exists", `Flow ${flowId}: playlist references non-existent flow "${entry.flow_id}"`);
         }
         if (entry.flow_id === flowId) {
-          error51(path, "playlist-self-cycle", `Flow ${flowId}: playlist contains itself (direct cycle)`);
+          error51(path6, "playlist-self-cycle", `Flow ${flowId}: playlist contains itself (direct cycle)`);
         }
         refs.push(entry.flow_id);
       } else if (entry.type === "condition") {
-        if (entry.if_true) refs.push(...collectPlaylistRefs(entry.if_true, flowId, path, depth + 1));
-        if (entry.if_false) refs.push(...collectPlaylistRefs(entry.if_false, flowId, path, depth + 1));
+        if (entry.if_true) refs.push(...collectPlaylistRefs(entry.if_true, flowId, path6, depth + 1));
+        if (entry.if_false) refs.push(...collectPlaylistRefs(entry.if_false, flowId, path6, depth + 1));
       } else if (entry.type === "junction") {
         if (entry.cases) {
           for (const c of entry.cases) {
-            refs.push(...collectPlaylistRefs(c.entries || [], flowId, path, depth + 1));
+            refs.push(...collectPlaylistRefs(c.entries || [], flowId, path6, depth + 1));
           }
         }
       }
@@ -15495,13 +15934,13 @@ function validateBundle(input) {
   nodes.forEach((node, i) => {
     const md = node.metadata;
     if (node.species === "flow" && md?.playlist?.entries) {
-      const path = `nodes[${i}].metadata.playlist`;
+      const path6 = `nodes[${i}].metadata.playlist`;
       const nodeId = node.id;
-      const refs = collectPlaylistRefs(md.playlist.entries, nodeId, path);
+      const refs = collectPlaylistRefs(md.playlist.entries, nodeId, path6);
       for (const ref of refs) {
         if (!composesSet.has(`${nodeId}->${ref}`)) {
           error51(
-            path,
+            path6,
             "playlist-composes-coherence",
             `Flow ${nodeId}: playlist references "${ref}" but no composes edge exists`
           );
@@ -15695,6 +16134,9 @@ function eventAffectsPlatform(ev, platform, nodesById) {
     const edge = ev;
     return onPlatform(edge.source_id) || onPlatform(edge.target_id);
   }
+  if (ev.type === "deliverable.shipped" && Array.isArray(ev.node_ids)) {
+    return ev.node_ids.some(onPlatform);
+  }
   return false;
 }
 function computeChangelog(events, toVersion, options = {}) {
@@ -15708,7 +16150,7 @@ function computeChangelog(events, toVersion, options = {}) {
     }
   }
   if (toIndex === -1) {
-    return { fromVersion: null, toVersion, events: [] };
+    return { fromVersion: null, toVersion, events: [], deliverables: [] };
   }
   const platform = asString(ordered[toIndex].platform);
   let fromIndex = -1;
@@ -15737,9 +16179,65 @@ function computeChangelog(events, toVersion, options = {}) {
     fromVersion: fromIndex >= 0 ? asString(ordered[fromIndex].version) ?? null : null,
     toVersion,
     ...platform ? { platform } : {},
-    events: slice
+    events: slice,
+    deliverables: computeDeliverables(ordered).filter((d) => d.releaseVersion === toVersion)
   };
 }
+function computeDeliverables(events) {
+  const ordered = orderEvents(events);
+  const firstIndex = /* @__PURE__ */ new Map();
+  const latest = /* @__PURE__ */ new Map();
+  ordered.forEach((ev, i) => {
+    if (ev.type !== "deliverable.shipped") return;
+    const id = asString(ev.deliverable_id);
+    if (id === void 0) return;
+    if (!firstIndex.has(id)) firstIndex.set(id, i);
+    latest.set(id, ev);
+  });
+  if (firstIndex.size === 0) return [];
+  const markerLatest = /* @__PURE__ */ new Map();
+  ordered.forEach((ev, i) => {
+    if (ev.type !== "release.tagged") return;
+    const version2 = asString(ev.version);
+    if (version2 !== void 0) markerLatest.set(version2, i);
+  });
+  const windows = [];
+  for (const [version2, toIndex] of markerLatest) {
+    let fromIndex = -1;
+    for (let i = toIndex - 1; i >= 0; i -= 1) {
+      if (ordered[i].type === "release.tagged") {
+        fromIndex = i;
+        break;
+      }
+    }
+    windows.push({ version: version2, from: fromIndex, to: toIndex });
+  }
+  const releaseOf = (index) => {
+    for (const w of windows) {
+      if (index > w.from && index < w.to) return w.version;
+    }
+    return null;
+  };
+  const out = [];
+  for (const [id, anchorIndex] of firstIndex) {
+    const ev = latest.get(id);
+    if (ev === void 0) continue;
+    const summary = asString(ev.summary);
+    const url2 = asString(ev.url);
+    const platform = asString(ev.platform);
+    out.push({
+      deliverable_id: id,
+      title: asString(ev.title) ?? id,
+      ...summary !== void 0 ? { summary } : {},
+      ...url2 !== void 0 ? { url: url2 } : {},
+      node_ids: Array.isArray(ev.node_ids) ? ev.node_ids.filter((n) => typeof n === "string") : [],
+      ...platform !== void 0 ? { platform } : {},
+      ts: asString(ordered[anchorIndex].ts) ?? "",
+      releaseVersion: releaseOf(anchorIndex)
+    });
+  }
+  return out;
+}
 
 // ../schema/src/emit.ts
 var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
@@ -15831,6 +16329,16 @@ function computeRefPromotions(bundle) {
         continue;
       }
       if (target === null) continue;
+      const to = normalizeStatus(target);
+      if (to === void 0) {
+        skipped.push({
+          node_id: node.id,
+          ref_id: ref.id,
+          reason: "no-mapping",
+          detail: `unknown status: ${target}`
+        });
+        continue;
+      }
       if (node.status === "archived") {
         skipped.push({ node_id: node.id, ref_id: ref.id, reason: "archived" });
         continue;
@@ -15845,8 +16353,8 @@ function computeRefPromotions(bundle) {
         continue;
       }
       const from = currentStatus(node, ref.platform);
-      if (from === target) {
-        skipped.push({ node_id: node.id, ref_id: ref.id, reason: "already-there", detail: target });
+      if (from === to) {
+        skipped.push({ node_id: node.id, ref_id: ref.id, reason: "already-there", detail: to });
         continue;
       }
       promotions.push({
@@ -15854,7 +16362,7 @@ function computeRefPromotions(bundle) {
         ref_id: ref.id,
         ...ref.platform ? { platform: ref.platform } : {},
         from,
-        to: target,
+        to,
         external_status: ref.external_status
       });
     }
@@ -15876,7 +16384,8 @@ var DEFAULT_BUNDLE_PATH = "docs/arkaik/bundle.json";
 var DEFAULT_JOURNAL_PATH = "docs/arkaik/journal.jsonl";
 var DEFAULT_SKILLS_DIR = ".claude/skills/arkaik";
 var ASSET_DIR = join(dirname(fileURLToPath(import.meta.url)), "assets", "skill");
-var USAGE = `arkaik init [--product <name>] [--bundle <path>] [--journal <path>] [--skills-dir <path>] [--update]
+var BOOTSTRAP_ASSET_DIR = join(dirname(fileURLToPath(import.meta.url)), "assets", "bootstrap-skill");
+var USAGE = `arkaik init [--product <name>] [--bundle <path>] [--journal <path>] [--skills-dir <path>] [--update] [--bootstrap] [--remove-bootstrap]
 
 Scaffold docs/arkaik/ (bundle.json, journal.jsonl, assets/) in the current
 directory, configure .gitattributes for the journal's union merge, and
@@ -15902,14 +16411,22 @@ Options:
                         (and skip references/values.md). Applies when the
                         skill is installed or upgraded; a same-version
                         \`--update\` run is a no-op.
+  --bootstrap           Also install the one-time \`arkaik-bootstrap\` skill
+                        beside the arkaik skill. Not installed by default: it
+                        is a large skill for a one-time job (bootstrapping
+                        the map from repo history). Install-if-absent with a
+                        plain init; version-gated upgrade with --update.
+  --remove-bootstrap    Remove the installed \`arkaik-bootstrap\` skill and do
+                        nothing else \u2014 no scaffolding. Prints a notice and
+                        exits 0 when it isn't installed.
   -h, --help             Show this help.`;
 function fail(message) {
   console.error(message);
   process.exit(1);
 }
 function parseArgs(args) {
-  const opts = { update: false, noValues: false };
-  const nextValue = (i, flag) => {
+  const opts = { update: false, noValues: false, bootstrap: false, removeBootstrap: false };
+  const nextValue2 = (i, flag) => {
     const value = args[i];
     if (value === void 0) fail(`Missing value for ${flag}
 
@@ -15925,20 +16442,29 @@ ${USAGE}`);
       opts.update = true;
     } else if (arg === "--no-values") {
       opts.noValues = true;
+    } else if (arg === "--bootstrap") {
+      opts.bootstrap = true;
+    } else if (arg === "--remove-bootstrap") {
+      opts.removeBootstrap = true;
     } else if (arg === "--product") {
-      opts.product = nextValue(++i, arg);
+      opts.product = nextValue2(++i, arg);
     } else if (arg === "--bundle") {
-      opts.bundle = nextValue(++i, arg);
+      opts.bundle = nextValue2(++i, arg);
     } else if (arg === "--journal") {
-      opts.journal = nextValue(++i, arg);
+      opts.journal = nextValue2(++i, arg);
     } else if (arg === "--skills-dir") {
-      opts.skillsDir = nextValue(++i, arg);
+      opts.skillsDir = nextValue2(++i, arg);
     } else {
       fail(`Unknown option: ${arg}
 
 ${USAGE}`);
     }
   }
+  if (opts.bootstrap && opts.removeBootstrap) {
+    fail(`--bootstrap and --remove-bootstrap are contradictory; pass one or the other.
+
+${USAGE}`);
+  }
   return opts;
 }
 function defaultProductName() {
@@ -15950,14 +16476,14 @@ function kebabCase(input) {
   const slug = input.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
   return slug || "project";
 }
-function writeIfAbsent(path, content, label) {
-  if (existsSync(path)) {
-    console.log(`Skipping ${label} (already exists): ${path}`);
+function writeIfAbsent(path6, content, label) {
+  if (existsSync(path6)) {
+    console.log(`Skipping ${label} (already exists): ${path6}`);
     return;
   }
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, content);
-  console.log(`Created ${path}`);
+  mkdirSync(dirname(path6), { recursive: true });
+  writeFileSync(path6, content);
+  console.log(`Created ${path6}`);
 }
 function scaffoldBundle(bundlePath, productName) {
   if (existsSync(bundlePath)) {
@@ -16068,6 +16594,49 @@ function updateSkill(skillsDirPath, vars, noValues) {
   const version2 = renderAndWriteSkill(skillsDirPath, vars, noValues);
   console.log(`Upgraded skill v${installedVersion ?? "unknown"} -> v${version2}.`);
 }
+function renderAndWriteBootstrapSkill(bootstrapDirPath, vars) {
+  const rawSkill = readFileSync(join(BOOTSTRAP_ASSET_DIR, "skill.md"), "utf8");
+  mkdirSync(join(bootstrapDirPath, "references"), { recursive: true });
+  writeFileSync(join(bootstrapDirPath, "SKILL.md"), renderTemplate(rawSkill, vars));
+  copyFileSync(join(BOOTSTRAP_ASSET_DIR, "references", "fragments.md"), join(bootstrapDirPath, "references", "fragments.md"));
+  copyFileSync(join(BOOTSTRAP_ASSET_DIR, "references", "waves.md"), join(bootstrapDirPath, "references", "waves.md"));
+  return extractVersion(rawSkill) ?? "unknown";
+}
+function installBootstrapSkill(bootstrapDirPath, vars) {
+  const skillPath = join(bootstrapDirPath, "SKILL.md");
+  if (existsSync(skillPath)) {
+    console.log(
+      `Skipping bootstrap skill install (already exists): ${skillPath}. Use \`arkaik init --update --bootstrap\` to upgrade.`
+    );
+    return;
+  }
+  const version2 = renderAndWriteBootstrapSkill(bootstrapDirPath, vars);
+  console.log(`Installed bootstrap skill v${version2} -> ${skillPath}`);
+}
+function updateBootstrapSkill(bootstrapDirPath, vars) {
+  const packagedVersion = extractVersion(readFileSync(join(BOOTSTRAP_ASSET_DIR, "skill.md"), "utf8"));
+  const skillPath = join(bootstrapDirPath, "SKILL.md");
+  if (!existsSync(skillPath)) {
+    const version3 = renderAndWriteBootstrapSkill(bootstrapDirPath, vars);
+    console.log(`No existing bootstrap skill found at ${skillPath}; installed v${version3}.`);
+    return;
+  }
+  const installedVersion = extractVersion(readFileSync(skillPath, "utf8"));
+  if (installedVersion !== void 0 && packagedVersion !== void 0 && compareVersions(packagedVersion, installedVersion) <= 0) {
+    console.log(`Bootstrap skill already up to date (v${installedVersion}).`);
+    return;
+  }
+  const version2 = renderAndWriteBootstrapSkill(bootstrapDirPath, vars);
+  console.log(`Upgraded bootstrap skill v${installedVersion ?? "unknown"} -> v${version2}.`);
+}
+function removeBootstrapSkill(bootstrapDirPath) {
+  if (!existsSync(bootstrapDirPath)) {
+    console.log(`No bootstrap skill installed at ${bootstrapDirPath}; nothing to remove.`);
+    return;
+  }
+  rmSync(bootstrapDirPath, { recursive: true, force: true });
+  console.log(`Removed bootstrap skill: ${bootstrapDirPath}`);
+}
 function runInit(args) {
   const opts = parseArgs(args);
   const productName = opts.product ?? defaultProductName();
@@ -16078,6 +16647,11 @@ function runInit(args) {
   const bundlePath = resolve(cwd, bundleRelPath);
   const journalPath = resolve(cwd, journalRelPath);
   const skillsDirPath = resolve(cwd, skillsDirRelPath);
+  const bootstrapSkillDirPath = join(dirname(skillsDirPath), "arkaik-bootstrap");
+  if (opts.removeBootstrap) {
+    removeBootstrapSkill(bootstrapSkillDirPath);
+    return;
+  }
   const vars = {
     PRODUCT_NAME: productName,
     PROJECT_ID: kebabCase(productName),
@@ -16086,6 +16660,7 @@ function runInit(args) {
   };
   if (opts.update) {
     updateSkill(skillsDirPath, vars, opts.noValues);
+    if (opts.bootstrap) updateBootstrapSkill(bootstrapSkillDirPath, vars);
     return;
   }
   scaffoldBundle(bundlePath, productName);
@@ -16093,6 +16668,7 @@ function runInit(args) {
   writeIfAbsent(join(dirname(bundlePath), "assets", ".gitkeep"), "", "assets dir");
   ensureGitAttributes(journalRelPath);
   installSkill(skillsDirPath, vars, opts.noValues);
+  if (opts.bootstrap) installBootstrapSkill(bootstrapSkillDirPath, vars);
 }
 
 // src/commands/validate.ts
@@ -16111,7 +16687,9 @@ function readBundle(filePath) {
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
     throw new Error("Bundle must be a JSON object.");
   }
-  return parsed;
+  const record2 = parsed;
+  if (!Array.isArray(record2.nodes)) return record2;
+  return migrateStatusVocabulary(record2);
 }
 function nodesByIdOf(bundle) {
   const nodes = Array.isArray(bundle.nodes) ? bundle.nodes : [];
@@ -16358,6 +16936,10 @@ function renderEventLine(event, nodesById) {
       const platform = str(event.platform);
       return `Released ${version2}${platform ? ` [${platform}]` : ""}`;
     }
+    case "deliverable.shipped": {
+      const url2 = str(event.url);
+      return `Shipped: ${str(event.title) ?? str(event.deliverable_id) ?? "?"}${url2 ? ` (${url2})` : ""}`;
+    }
     case "idea.proposed":
       return `Idea: ${str(event.title) ?? "Untitled"}`;
     case "request.filed": {
@@ -16590,10 +17172,19 @@ ${USAGE4}`);
 ` : `  Initial changes:
 `
   );
-  if (changelog.events.length === 0) {
-    console.log("  (no changes in this release)");
+  const draftDeliverables = changelog.platform ? changelog.deliverables.filter((d) => d.platform === void 0 || d.platform === changelog.platform) : changelog.deliverables;
+  if (draftDeliverables.length > 0) {
+    console.log("  Deliverables:");
+    draftDeliverables.forEach((d) => {
+      console.log(`  - ${d.title}${d.summary ? ` \u2014 ${d.summary}` : ""}${d.url ? ` (${d.url})` : ""}`);
+    });
+    console.log("");
+  }
+  const draftEvents = draftDeliverables.length > 0 ? changelog.events.filter((ev) => ev.type !== "deliverable.shipped") : changelog.events;
+  if (draftEvents.length === 0) {
+    console.log(draftDeliverables.length > 0 ? "  (no other events in this release)" : "  (no changes in this release)");
   } else {
-    changelog.events.forEach((ev) => console.log(`  - ${renderEventLine(ev, nodesById)}`));
+    draftEvents.forEach((ev) => console.log(`  - ${renderEventLine(ev, nodesById)}`));
   }
   console.log("");
   if (compact) {
@@ -16611,56 +17202,180 @@ ${USAGE4}`);
   process.exit(0);
 }
 
-// src/commands/sync.ts
-import { resolve as resolve2 } from "node:path";
-import { writeFileSync as writeFileSync4 } from "node:fs";
+// src/commands/deliverable.ts
+var DEFAULT_BUNDLE_PATH3 = "docs/arkaik/bundle.json";
+var ACTOR2 = "arkaik-cli";
+var USAGE5 = `arkaik deliverable <title> [options] [path]
 
-// src/lib/providers.ts
-var DEFAULT_HTTP_CLIENT = (url2, init) => fetch(url2, init);
-var GITHUB_ISSUE_URL_RE = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/issues\/(\d+)(?:[/?#].*)?$/;
-var GITHUB_PR_URL_RE = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)(?:[/?#].*)?$/;
-function githubHeaders(token) {
-  const headers = {
-    Accept: "application/vnd.github+json",
-    "X-GitHub-Api-Version": "2022-11-28"
-  };
-  if (token) headers.Authorization = `Bearer ${token}`;
-  return headers;
-}
-async function getGithubJson(httpClient, url2, token, refUrl) {
-  const res = await httpClient(url2, { headers: githubHeaders(token) });
-  if (!res.ok) throw new Error(`GitHub API error ${res.status} for ${refUrl}`);
-  const body = await res.json();
-  if (typeof body !== "object" || body === null) {
-    throw new Error(`GitHub API returned a non-object response for ${refUrl}`);
-  }
-  return body;
-}
-async function fetchGithubIssueStatus(ref, ctx) {
-  const m = GITHUB_ISSUE_URL_RE.exec(ref.url);
-  if (!m) throw new Error(`Cannot parse a GitHub issue URL: ${ref.url}`);
-  const [, owner, repo, number4] = m;
-  const body = await getGithubJson(
-    ctx.httpClient,
-    `https://api.github.com/repos/${owner}/${repo}/issues/${number4}`,
-    ctx.token,
-    ref.url
-  );
-  if (typeof body.state !== "string") throw new Error(`GitHub API response missing "state" for ${ref.url}`);
-  return body.state;
+Record a deliverable: append a validated deliverable.shipped event to the
+journal.jsonl sidecar. The bundle file is not modified.
+
+Arguments:
+  title             What shipped, in one line. Required.
+  path              Path to the bundle JSON file (default: ${DEFAULT_BUNDLE_PATH3}).
+
+Options:
+  --id <id>         Stable deliverable id (convention: pr-123). Re-appending
+                    with the same id edits the deliverable (latest-wins
+                    content, anchored at the first occurrence). Default: a
+                    fresh ULID.
+  --summary <s>     A short human note.
+  --url <u>         The PR (or other reference) URL.
+  --nodes <id,id>   Comma-separated ids of graph nodes this touched. Checked
+                    against the snapshot.
+  --platform <p>    Scope to a platform's release rhythm.
+  -h, --help        Show this help.`;
+function fail5(message) {
+  console.error(message);
+  process.exit(1);
 }
-async function fetchGithubPrStatus(ref, ctx) {
-  const m = GITHUB_PR_URL_RE.exec(ref.url);
-  if (!m) throw new Error(`Cannot parse a GitHub pull request URL: ${ref.url}`);
-  const [, owner, repo, number4] = m;
-  const body = await getGithubJson(
-    ctx.httpClient,
-    `https://api.github.com/repos/${owner}/${repo}/pulls/${number4}`,
-    ctx.token,
-    ref.url
-  );
-  if (typeof body.state !== "string") throw new Error(`GitHub API response missing "state" for ${ref.url}`);
-  return body.merged === true ? "merged" : body.state;
+function runDeliverable(args) {
+  let id;
+  let summary;
+  let url2;
+  let nodes;
+  let platform;
+  const positionals = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-h" || arg === "--help") {
+      console.log(USAGE5);
+      process.exit(0);
+    } else if (arg === "--id") {
+      const value = args[++i];
+      if (value === void 0) fail5(`Missing value for --id
+
+${USAGE5}`);
+      id = value;
+    } else if (arg === "--summary") {
+      const value = args[++i];
+      if (value === void 0) fail5(`Missing value for --summary
+
+${USAGE5}`);
+      summary = value;
+    } else if (arg === "--url") {
+      const value = args[++i];
+      if (value === void 0) fail5(`Missing value for --url
+
+${USAGE5}`);
+      url2 = value;
+    } else if (arg === "--nodes") {
+      const value = args[++i];
+      if (value === void 0) fail5(`Missing value for --nodes
+
+${USAGE5}`);
+      nodes = value.split(",").map((n) => n.trim()).filter((n) => n !== "");
+      if (nodes.length === 0) nodes = void 0;
+    } else if (arg === "--platform") {
+      const value = args[++i];
+      if (value === void 0) fail5(`Missing value for --platform
+
+${USAGE5}`);
+      platform = value;
+    } else if (arg.startsWith("-")) {
+      fail5(`Unknown option: ${arg}
+
+${USAGE5}`);
+    } else {
+      positionals.push(arg);
+    }
+  }
+  const title2 = positionals[0];
+  if (title2 === void 0) fail5(`Missing title.
+
+${USAGE5}`);
+  const filePath = positionals[1] ?? DEFAULT_BUNDLE_PATH3;
+  let bundle;
+  try {
+    bundle = readBundle(filePath);
+  } catch (e) {
+    fail5(`FATAL: ${e.message}`);
+  }
+  if (nodes !== void 0) {
+    const nodesById = nodesByIdOf(bundle);
+    const unknown2 = nodes.filter((n) => !nodesById.has(n));
+    if (unknown2.length > 0) {
+      fail5(`FATAL: --nodes references unknown node id(s): ${unknown2.join(", ")}`);
+    }
+  }
+  const deliverableId = id ?? ulid3();
+  let event;
+  try {
+    event = makeEvent(
+      "deliverable.shipped",
+      {
+        deliverable_id: deliverableId,
+        title: title2,
+        ...summary !== void 0 ? { summary } : {},
+        ...url2 !== void 0 ? { url: url2 } : {},
+        ...nodes !== void 0 ? { node_ids: nodes } : {},
+        ...platform !== void 0 ? { platform } : {}
+      },
+      { actor: ACTOR2 }
+    );
+  } catch (e) {
+    fail5(`FATAL: could not build deliverable event \u2014 ${e.message}`);
+  }
+  const journalPath = journalPathFor(filePath);
+  appendJournalEvent(journalPath, event);
+  console.log(
+    `
+  Recorded deliverable ${deliverableId} \u2014 ${title2} -> ${journalPath}
+`
+  );
+  process.exit(0);
+}
+
+// src/commands/sync.ts
+import { resolve as resolve2 } from "node:path";
+import { writeFileSync as writeFileSync4 } from "node:fs";
+
+// src/lib/providers.ts
+var DEFAULT_HTTP_CLIENT = (url2, init) => fetch(url2, init);
+var GITHUB_ISSUE_URL_RE = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/issues\/(\d+)(?:[/?#].*)?$/;
+var GITHUB_PR_URL_RE = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)(?:[/?#].*)?$/;
+function githubHeaders(token) {
+  const headers = {
+    Accept: "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28"
+  };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  return headers;
+}
+async function getGithubJson(httpClient, url2, token, refUrl) {
+  const res = await httpClient(url2, { headers: githubHeaders(token) });
+  if (!res.ok) throw new Error(`GitHub API error ${res.status} for ${refUrl}`);
+  const body = await res.json();
+  if (typeof body !== "object" || body === null) {
+    throw new Error(`GitHub API returned a non-object response for ${refUrl}`);
+  }
+  return body;
+}
+async function fetchGithubIssueStatus(ref, ctx) {
+  const m = GITHUB_ISSUE_URL_RE.exec(ref.url);
+  if (!m) throw new Error(`Cannot parse a GitHub issue URL: ${ref.url}`);
+  const [, owner, repo, number4] = m;
+  const body = await getGithubJson(
+    ctx.httpClient,
+    `https://api.github.com/repos/${owner}/${repo}/issues/${number4}`,
+    ctx.token,
+    ref.url
+  );
+  if (typeof body.state !== "string") throw new Error(`GitHub API response missing "state" for ${ref.url}`);
+  return body.state;
+}
+async function fetchGithubPrStatus(ref, ctx) {
+  const m = GITHUB_PR_URL_RE.exec(ref.url);
+  if (!m) throw new Error(`Cannot parse a GitHub pull request URL: ${ref.url}`);
+  const [, owner, repo, number4] = m;
+  const body = await getGithubJson(
+    ctx.httpClient,
+    `https://api.github.com/repos/${owner}/${repo}/pulls/${number4}`,
+    ctx.token,
+    ref.url
+  );
+  if (typeof body.state !== "string") throw new Error(`GitHub API response missing "state" for ${ref.url}`);
+  return body.merged === true ? "merged" : body.state;
 }
 async function fetchGithubStatus(ref, ctx) {
   if (ref.type === "github-issue") return fetchGithubIssueStatus(ref, ctx);
@@ -16704,15 +17419,15 @@ async function fetchRefStatus(ref, ctx) {
 }
 
 // src/commands/sync.ts
-var DEFAULT_BUNDLE_PATH3 = "docs/arkaik/bundle.json";
-var ACTOR2 = "arkaik-cli";
+var DEFAULT_BUNDLE_PATH4 = "docs/arkaik/bundle.json";
+var ACTOR3 = "arkaik-cli";
 var PROVIDER_LINES = PROVIDERS.map((p) => {
   const state = p.status === "live" ? "live " : "stub ";
   const token = p.tokenEnvVar ? ` (token: ${p.tokenEnvVar})` : "";
   const note = p.status === "stub" ? " \u2014 not yet implemented, refs are reported and skipped" : "";
   return `  ${p.name.padEnd(8)} ${state}\u2014 ${p.refTypes.join(", ")}${token}${note}`;
 }).join("\n");
-var USAGE5 = `arkaik sync [--provider <name>] [--dry-run] [--promote] [path]
+var USAGE6 = `arkaik sync [--provider <name>] [--dry-run] [--promote] [path]
 
 Mirror external ref status into node metadata.refs. Reads every node's
 metadata.refs, queries each ref's provider for its current external status,
@@ -16728,7 +17443,7 @@ Providers (v1):
 ${PROVIDER_LINES}
 
 Arguments:
-  path              Path to the bundle JSON file (default: ${DEFAULT_BUNDLE_PATH3}).
+  path              Path to the bundle JSON file (default: ${DEFAULT_BUNDLE_PATH4}).
 
 Options:
   --provider <name> Only sync refs handled by this provider (${PROVIDERS.map((p) => p.name).join(" | ")}).
@@ -16738,7 +17453,7 @@ Options:
   --dry-run         Report what would change without writing the bundle or
                      appending to the journal.
   -h, --help        Show this help.`;
-function fail5(message) {
+function fail6(message) {
   console.error(message);
   process.exit(1);
 }
@@ -16759,14 +17474,14 @@ function fatalResult(bundlePath, journalPath, dryRun, message) {
 }
 async function runSync(options = {}) {
   const cwd = options.cwd ?? process.cwd();
-  const filePath = resolve2(cwd, options.path ?? DEFAULT_BUNDLE_PATH3);
+  const filePath = resolve2(cwd, options.path ?? DEFAULT_BUNDLE_PATH4);
   const journalPath = journalPathFor(filePath);
   const dryRun = options.dryRun ?? false;
   const promote = options.promote ?? false;
   const httpClient = options.httpClient ?? DEFAULT_HTTP_CLIENT;
   const now = options.now ?? (() => /* @__PURE__ */ new Date());
   const env = options.env ?? process.env;
-  const actor = options.actor ?? ACTOR2;
+  const actor = options.actor ?? ACTOR3;
   if (options.provider !== void 0 && !PROVIDERS.some((p) => p.name === options.provider)) {
     return fatalResult(
       filePath,
@@ -16925,7 +17640,7 @@ function runSyncCli(args) {
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "-h" || arg === "--help") {
-      console.log(USAGE5);
+      console.log(USAGE6);
       process.exit(0);
     } else if (arg === "--dry-run") {
       dryRun = true;
@@ -16933,31 +17648,31 @@ function runSyncCli(args) {
       promote = true;
     } else if (arg === "--provider") {
       const value = args[++i];
-      if (value === void 0) fail5(`Missing value for --provider
+      if (value === void 0) fail6(`Missing value for --provider
 
-${USAGE5}`);
+${USAGE6}`);
       provider = value;
     } else if (arg.startsWith("-")) {
-      fail5(`Unknown option: ${arg}
+      fail6(`Unknown option: ${arg}
 
-${USAGE5}`);
+${USAGE6}`);
     } else {
       positionals.push(arg);
     }
   }
-  const filePath = positionals[0] ?? DEFAULT_BUNDLE_PATH3;
+  const filePath = positionals[0] ?? DEFAULT_BUNDLE_PATH4;
   runSync({ path: filePath, provider, dryRun, promote }).then((result) => {
-    if (!result.ok) fail5(`FATAL: ${result.fatal}`);
+    if (!result.ok) fail6(`FATAL: ${result.fatal}`);
     report(result);
     process.exit(result.errors.length > 0 ? 1 : 0);
-  }).catch((e) => fail5(`FATAL: ${e.message}`));
+  }).catch((e) => fail6(`FATAL: ${e.message}`));
 }
 
 // src/commands/pack.ts
 import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
 import { dirname as dirname4, extname, resolve as resolve3 } from "node:path";
-var DEFAULT_BUNDLE_PATH4 = "docs/arkaik/bundle.json";
-var USAGE6 = `arkaik pack [--no-journal] [--inline-assets] [--out <path>] [path]
+var DEFAULT_BUNDLE_PATH5 = "docs/arkaik/bundle.json";
+var USAGE7 = `arkaik pack [--no-journal] [--inline-assets] [--out <path>] [path]
 
 Produce a single self-contained interchange bundle: fold in the sidecar
 journal (or keep an existing embedded one) and, with --inline-assets, inline
@@ -16965,7 +17680,7 @@ local screenshot files as data: URIs. Written canonically via serializeBundle.
 Unknown top-level keys and unknown fields always round-trip.
 
 Arguments:
-  path              Path to the bundle JSON file (default: ${DEFAULT_BUNDLE_PATH4}).
+  path              Path to the bundle JSON file (default: ${DEFAULT_BUNDLE_PATH5}).
 
 Options:
   --no-journal      Omit the embedded journal[] (Publik-safe posture \u2014 history
@@ -16982,7 +17697,7 @@ Options:
                      implemented.
   --out <path>      Write the packed bundle here instead of stdout.
   -h, --help        Show this help.`;
-function fail6(message) {
+function fail7(message) {
   console.error(message);
   process.exit(1);
 }
@@ -17017,7 +17732,7 @@ function fatalResult2(bundlePath, message) {
 }
 function runPack(options = {}) {
   const cwd = options.cwd ?? process.cwd();
-  const filePath = resolve3(cwd, options.path ?? DEFAULT_BUNDLE_PATH4);
+  const filePath = resolve3(cwd, options.path ?? DEFAULT_BUNDLE_PATH5);
   const noJournal = options.noJournal ?? false;
   const inlineAssets = options.inlineAssets ?? false;
   let bundle;
@@ -17081,7 +17796,7 @@ function runPackCli(args) {
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "-h" || arg === "--help") {
-      console.log(USAGE6);
+      console.log(USAGE7);
       process.exit(0);
     } else if (arg === "--no-journal") {
       noJournal = true;
@@ -17089,21 +17804,21 @@ function runPackCli(args) {
       inlineAssets = true;
     } else if (arg === "--out") {
       const value = args[++i];
-      if (value === void 0) fail6(`Missing value for --out
+      if (value === void 0) fail7(`Missing value for --out
 
-${USAGE6}`);
+${USAGE7}`);
       out = value;
     } else if (arg.startsWith("-")) {
-      fail6(`Unknown option: ${arg}
+      fail7(`Unknown option: ${arg}
 
-${USAGE6}`);
+${USAGE7}`);
     } else {
       positionals.push(arg);
     }
   }
-  const filePath = positionals[0] ?? DEFAULT_BUNDLE_PATH4;
+  const filePath = positionals[0] ?? DEFAULT_BUNDLE_PATH5;
   const result = runPack({ path: filePath, out, noJournal, inlineAssets });
-  if (!result.ok) fail6(`FATAL: ${result.fatal}`);
+  if (!result.ok) fail7(`FATAL: ${result.fatal}`);
   if (result.journalIncluded) {
     console.error(`Journal: embedded ${result.journalEventCount} event(s)`);
   } else if (noJournal) {
@@ -17130,9 +17845,9 @@ import { spawn } from "node:child_process";
 import { mkdtempSync, writeFileSync as writeFileSync6 } from "node:fs";
 import { tmpdir } from "node:os";
 import { join as join4, resolve as resolve4 } from "node:path";
-var DEFAULT_BUNDLE_PATH5 = "docs/arkaik/bundle.json";
+var DEFAULT_BUNDLE_PATH6 = "docs/arkaik/bundle.json";
 var OPEN_URL = "https://arkaik.app/projects";
-var USAGE7 = `arkaik open [--out <path>] [--no-open] [path]
+var USAGE8 = `arkaik open [--out <path>] [--no-open] [path]
 
 Validate the bundle (shape + semantic + snapshot<->journal cross-checks, same
 as "arkaik validate"), and only on success pack it and hand off to arkaik.app
@@ -17141,13 +17856,13 @@ ${OPEN_URL} (the project list's "Import JSON" picker). On an invalid bundle,
 findings are printed and nothing is packed, written, or opened.
 
 Arguments:
-  path            Path to the bundle JSON file (default: ${DEFAULT_BUNDLE_PATH5}).
+  path            Path to the bundle JSON file (default: ${DEFAULT_BUNDLE_PATH6}).
 
 Options:
   --out <path>    Write the packed bundle here instead of a temp file.
   --no-open       Skip launching the browser; still packs and reports the URL.
   -h, --help      Show this help.`;
-function fail7(message) {
+function fail8(message) {
   console.error(message);
   process.exit(1);
 }
@@ -17163,7 +17878,7 @@ function fatalResult3(bundlePath, message) {
 }
 async function runOpen(options = {}) {
   const cwd = options.cwd ?? process.cwd();
-  const filePath = resolve4(cwd, options.path ?? DEFAULT_BUNDLE_PATH5);
+  const filePath = resolve4(cwd, options.path ?? DEFAULT_BUNDLE_PATH6);
   const noOpen = options.noOpen ?? false;
   let v;
   try {
@@ -17204,27 +17919,27 @@ function runOpenCli(args) {
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "-h" || arg === "--help") {
-      console.log(USAGE7);
+      console.log(USAGE8);
       process.exit(0);
     } else if (arg === "--no-open") {
       noOpen = true;
     } else if (arg === "--out") {
       const value = args[++i];
-      if (value === void 0) fail7(`Missing value for --out
+      if (value === void 0) fail8(`Missing value for --out
 
-${USAGE7}`);
+${USAGE8}`);
       out = value;
     } else if (arg.startsWith("-")) {
-      fail7(`Unknown option: ${arg}
+      fail8(`Unknown option: ${arg}
 
-${USAGE7}`);
+${USAGE8}`);
     } else {
       positionals.push(arg);
     }
   }
-  const filePath = positionals[0] ?? DEFAULT_BUNDLE_PATH5;
+  const filePath = positionals[0] ?? DEFAULT_BUNDLE_PATH6;
   runOpen({ path: filePath, out, noOpen }).then((result) => {
-    if (!result.ok) fail7(`FATAL: ${result.fatal}`);
+    if (!result.ok) fail8(`FATAL: ${result.fatal}`);
     if (result.warningLines.length > 0) {
       console.error(`Warnings: ${result.warningLines.length}`);
       result.warningLines.forEach((w) => console.error(`  ${w}`));
@@ -17242,14 +17957,14 @@ ${USAGE7}`);
       console.log(`Import at ${result.url} (drag in ${result.outPath})`);
     }
     process.exit(0);
-  }).catch((e) => fail7(`FATAL: ${e.message}`));
+  }).catch((e) => fail8(`FATAL: ${e.message}`));
 }
 
 // src/commands/push.ts
 import { resolve as resolve5 } from "node:path";
-var DEFAULT_BUNDLE_PATH6 = "docs/arkaik/bundle.json";
+var DEFAULT_BUNDLE_PATH7 = "docs/arkaik/bundle.json";
 var DEFAULT_API_BASE = "https://arkaik.app";
-var USAGE8 = `arkaik push [--include-journal] [--api <base-url>] [path]
+var USAGE9 = `arkaik push [--include-journal] [--api <base-url>] [path]
 arkaik push --delete <id> --key <owner_key> [--api <base-url>]
 
 Publish a project bundle to Publik (anonymous, account-less snapshot
@@ -17268,7 +17983,7 @@ a new id. The owner key printed on success is shown exactly once and cannot
 be recovered \u2014 save it if you may need to delete the snapshot later.
 
 Arguments:
-  path                Path to the bundle JSON file (default: ${DEFAULT_BUNDLE_PATH6}).
+  path                Path to the bundle JSON file (default: ${DEFAULT_BUNDLE_PATH7}).
                        Ignored with --delete.
 
 Options:
@@ -17282,7 +17997,7 @@ Options:
   --key <owner_key>   Owner key for --delete (from the original push's
                        output).
   -h, --help          Show this help.`;
-function fail8(message) {
+function fail9(message) {
   console.error(message);
   process.exit(1);
 }
@@ -17299,7 +18014,7 @@ function fatalResult4(bundlePath, message) {
 }
 async function runPush(options = {}) {
   const cwd = options.cwd ?? process.cwd();
-  const filePath = resolve5(cwd, options.path ?? DEFAULT_BUNDLE_PATH6);
+  const filePath = resolve5(cwd, options.path ?? DEFAULT_BUNDLE_PATH7);
   const includeJournal = options.includeJournal ?? false;
   const apiBase = options.apiBase ?? DEFAULT_API_BASE;
   const httpClient = options.httpClient ?? DEFAULT_HTTP_CLIENT;
@@ -17450,7 +18165,7 @@ async function runPushDelete(options) {
   };
 }
 function reportDelete(id, result) {
-  if (!result.ok) fail8(`FATAL: ${result.fatal}`);
+  if (!result.ok) fail9(`FATAL: ${result.fatal}`);
   if (result.deleted) {
     console.log(`Deleted ${id}`);
     process.exit(0);
@@ -17467,56 +18182,56 @@ function runPushCli(args) {
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "-h" || arg === "--help") {
-      console.log(USAGE8);
+      console.log(USAGE9);
       process.exit(0);
     } else if (arg === "--include-journal") {
       includeJournal = true;
     } else if (arg === "--api") {
       const value = args[++i];
-      if (value === void 0) fail8(`Missing value for --api
+      if (value === void 0) fail9(`Missing value for --api
 
-${USAGE8}`);
+${USAGE9}`);
       apiBase = value;
     } else if (arg === "--delete") {
       const value = args[++i];
-      if (value === void 0) fail8(`Missing value for --delete
+      if (value === void 0) fail9(`Missing value for --delete
 
-${USAGE8}`);
+${USAGE9}`);
       deleteId = value;
     } else if (arg === "--key") {
       const value = args[++i];
-      if (value === void 0) fail8(`Missing value for --key
+      if (value === void 0) fail9(`Missing value for --key
 
-${USAGE8}`);
+${USAGE9}`);
       key = value;
     } else if (arg.startsWith("-")) {
-      fail8(`Unknown option: ${arg}
+      fail9(`Unknown option: ${arg}
 
-${USAGE8}`);
+${USAGE9}`);
     } else {
       positionals.push(arg);
     }
   }
   if (deleteId !== void 0) {
-    if (key === void 0) fail8(`--delete requires --key <owner_key>
+    if (key === void 0) fail9(`--delete requires --key <owner_key>
 
-${USAGE8}`);
+${USAGE9}`);
     if (positionals.length > 0) {
-      fail8(`Unexpected argument(s) with --delete: ${positionals.join(" ")}
+      fail9(`Unexpected argument(s) with --delete: ${positionals.join(" ")}
 
-${USAGE8}`);
+${USAGE9}`);
     }
-    runPushDelete({ id: deleteId, key, apiBase }).then((result) => reportDelete(deleteId, result)).catch((e) => fail8(`FATAL: ${e.message}`));
+    runPushDelete({ id: deleteId, key, apiBase }).then((result) => reportDelete(deleteId, result)).catch((e) => fail9(`FATAL: ${e.message}`));
     return;
   }
-  if (key !== void 0) fail8(`--key is only valid with --delete
+  if (key !== void 0) fail9(`--key is only valid with --delete
 
-${USAGE8}`);
-  const filePath = positionals[0] ?? DEFAULT_BUNDLE_PATH6;
+${USAGE9}`);
+  const filePath = positionals[0] ?? DEFAULT_BUNDLE_PATH7;
   runPush({ path: filePath, includeJournal, apiBase }).then((result) => {
-    if (!result.ok) fail8(`FATAL: ${result.fatal}`);
+    if (!result.ok) fail9(`FATAL: ${result.fatal}`);
     reportPush(result);
-  }).catch((e) => fail8(`FATAL: ${e.message}`));
+  }).catch((e) => fail9(`FATAL: ${e.message}`));
 }
 
 // src/commands/link.ts
@@ -17524,7 +18239,7 @@ import { mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync a
 import { dirname as dirname5, join as join5, resolve as resolve6 } from "node:path";
 var LINK_FILE = "docs/arkaik/arkaik.json";
 var DEFAULT_BASE_URL = "https://arkaik.app";
-var USAGE9 = `arkaik link \u2014 point this repo at a hosted Arkaik project
+var USAGE10 = `arkaik link \u2014 point this repo at a hosted Arkaik project
 
 Usage:
   arkaik link --project <id> [--remote <url>] [path]
@@ -17552,7 +18267,7 @@ async function runLink(argv, options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const doFetch = options.httpClient ?? ((...args) => fetch(...args));
   if (argv.includes("--help") || argv.includes("-h")) {
-    log(USAGE9);
+    log(USAGE10);
     return { ok: true };
   }
   const baseUrl = (flagValue(argv, "--remote") ?? env.ARKAIK_URL ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
@@ -17626,67 +18341,1767 @@ function runLinkCli(argv) {
   });
 }
 
-// src/index.ts
-var USAGE10 = `arkaik \u2014 CLI for Arkaik project bundles
+// src/commands/restore.ts
+import { existsSync as existsSync6, linkSync, mkdirSync as mkdirSync5, readFileSync as readFileSync8, unlinkSync, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join6, resolve as resolve7 } from "node:path";
+var LINK_FILE2 = "docs/arkaik/arkaik.json";
+var DEFAULT_BUNDLE_PATH8 = "docs/arkaik/bundle.json";
+var DEFAULT_API_BASE2 = "https://arkaik.app";
+var USAGE11 = `arkaik restore [options] [path]
 
-Usage:
-  arkaik <command> [options]
+Replace the linked hosted project's bundle AND journal with a local bundle \u2014
+the landing step for a bootstrapped map. Before sending anything, this
+exports the CURRENT hosted state (snapshot + journal) to
+docs/arkaik/.backups/<timestamp>-bundle.json (next to the link file \u2014 not
+wherever the local bundle happens to live) and refuses to proceed if that
+backup cannot be written \u2014 the server keeps no pre-image, so this file is the
+only way back if the restore turns out to be wrong.
 
-Commands:
-  init [options]              Scaffold docs/arkaik/, install the agent skill (--update to upgrade).
-  validate [path]             Validate a project bundle (folds in a journal.jsonl sidecar).
-  log [--node <id>] [path]    Print the journal: project changelog, or one node's timeline.
-  release <version> [path]    Tag a release (append release.tagged) and draft its notes.
-  sync [options] [path]       Mirror external ref status (GitHub issues/PRs) into node refs.
-  pack [options] [path]       Produce a single self-contained interchange bundle (embeds the journal).
-  open [options] [path]       Validate, then hand off the packed bundle to arkaik.app import.
-  push [options] [path]       Validate, pack (journal stripped), and publish to Publik.
-                               --delete <id> --key <owner_key> removes a snapshot.
-  link [options] [path]       Point this repo at a hosted project so an agent can edit it.
-                               --list shows the projects your token can reach.
+Arguments:
+  path                Path to the local bundle JSON file
+                       (default: ${DEFAULT_BUNDLE_PATH8}). Its journal.jsonl
+                       sidecar (or an embedded journal, which wins) is folded
+                       in automatically.
 
 Options:
-  -h, --help        Show this help.
+  --dry-run             Ask the server what this restore WOULD do and print
+                        the delta. Sends nothing destructive and takes no
+                        backup (there is nothing to protect against in this
+                        mode).
+  --allow-history-loss  Proceed even though the outbound journal has fewer
+                        events than the hosted one currently holds. Without
+                        this flag, that shrink refuses outright \u2014 it usually
+                        means a missing/gitignored journal.jsonl or a bundle
+                        from the wrong directory, not an intended history
+                        rewrite.
+  --api <base-url>      Override the remote from docs/arkaik/arkaik.json
+                        (also overridable with $ARKAIK_URL).
+  -h, --help            Show this help.
 
-Run "arkaik <command> --help" for command-specific help.`;
-function main(argv) {
-  const [command, ...rest] = argv;
-  if (command === void 0 || command === "--help" || command === "-h" || command === "help") {
-    console.log(USAGE10);
-    process.exit(0);
+Environment:
+  ARKAIK_TOKEN       Required. Create one at <origin>/settings/tokens.
+  ARKAIK_URL         Optional. Overrides the link file's remote (same as
+                     \`arkaik link\`); --api still wins over this.`;
+function fail10(message) {
+  console.error(message);
+  process.exit(1);
+}
+function fatalResult5(dryRun, message) {
+  return { ok: false, fatal: message, dryRun, requestSent: false };
+}
+async function safeJson(res) {
+  try {
+    return await res.json();
+  } catch {
+    return {};
   }
-  switch (command) {
-    case "init":
-      runInit(rest);
-      return;
-    case "validate":
-      runValidate(rest);
-      return;
-    case "log":
-      runLog(rest);
-      return;
-    case "release":
-      runRelease(rest);
-      return;
-    case "sync":
-      runSyncCli(rest);
-      return;
-    case "pack":
-      runPackCli(rest);
-      return;
-    case "open":
-      runOpenCli(rest);
-      return;
-    case "push":
-      runPushCli(rest);
-      return;
-    case "link":
-      runLinkCli(rest);
+}
+function describeVersionReadFailure(status, baseUrl, projectId) {
+  if (status === 401) return `Unauthorized \u2014 check ARKAIK_TOKEN (create one at ${baseUrl}/settings/tokens).`;
+  if (status === 403) return `Forbidden \u2014 this token lacks the graph:read scope, or does not own project ${projectId}.`;
+  if (status === 404) return `No project "${projectId}" in this account. Run \`arkaik link --list\` to see the ids.`;
+  return `Could not read the project (${status}). Nothing was sent.`;
+}
+function backupNoteFor(backupPath) {
+  if (!backupPath) return "";
+  return ` Your pre-restore backup is at ${backupPath}. Undo this restore with: arkaik restore ${backupPath}`;
+}
+async function interpretPutResponse(res, ctx) {
+  const base = {
+    ok: true,
+    dryRun: ctx.dryRun,
+    bundlePath: ctx.bundlePath,
+    backupPath: ctx.backupPath,
+    requestSent: true,
+    status: res.status
+  };
+  const backupNote = backupNoteFor(ctx.backupPath);
+  if (res.status === 200) {
+    const body2 = await safeJson(res);
+    return {
+      ...base,
+      version: typeof body2.version === "string" ? body2.version : void 0,
+      delta: body2.delta ?? void 0
+    };
+  }
+  const body = await safeJson(res);
+  switch (res.status) {
+    case 404:
+      return { ...base, errorMessage: `Project not found (or not owned by this token). Nothing was written.${backupNote}` };
+    case 428:
+      return {
+        ...base,
+        errorMessage: `The server rejected this request for a missing If-Match header \u2014 this CLI always sends one, so this points at a bug, not a version conflict. Nothing was written.${backupNote}`
+      };
+    case 400:
+      if (body.error === "invalid_dry_run") {
+        return {
+          ...base,
+          errorMessage: `The server rejected the dry-run indicator this CLI sent \u2014 this points at a bug, not a version conflict. Nothing was written.${backupNote}`
+        };
+      }
+      return {
+        ...base,
+        errorMessage: `The server rejected If-Match as malformed \u2014 this points at a bug, not a version conflict. Nothing was written.${backupNote}`
+      };
+    case 412: {
+      const current = typeof body.current === "string" ? body.current : void 0;
+      return {
+        ...base,
+        conflictCurrent: current,
+        errorMessage: `Conflict \u2014 the hosted project changed since this run read version ${ctx.version} (it is now ${current ?? "unknown"}). Nothing was written.${backupNote} Do not retry with the same version \u2014 that would overwrite state that has since moved. Re-run \`arkaik restore\` to read the current state and decide again.`
+      };
+    }
+    case 403:
+      return {
+        ...base,
+        errorMessage: `This bundle exceeds the hosted tier's entity limit (limit ${body.limit ?? "uncapped"}, actual ${body.actual ?? "unknown"}, tier ${body.tier ?? "unknown"}). Nothing was written.${backupNote}`
+      };
+    case 413:
+      return {
+        ...base,
+        errorMessage: `The bundle is too large for the server to accept (limit ${body.limit ?? "5MB"} bytes). Nothing was written.${backupNote}`
+      };
+    case 422:
+      return {
+        ...base,
+        serverFindings: Array.isArray(body.errors) ? body.errors : void 0,
+        errorMessage: `The server's validator rejected the bundle \u2014 see the findings below. Nothing was written.${backupNote}`
+      };
+    default:
+      return {
+        ...base,
+        errorMessage: `Restore failed (${res.status}): ${typeof body.message === "string" ? body.message : "unknown error"}.${backupNote}`
+      };
+  }
+}
+function writeBackupFile(filePath, content) {
+  const tmpPath = `${filePath}.tmp-${process.pid}`;
+  writeFileSync8(tmpPath, content);
+  try {
+    linkSync(tmpPath, filePath);
+  } finally {
+    unlinkSync(tmpPath);
+  }
+}
+async function runRestore(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const env = options.env ?? process.env;
+  const dryRun = options.dryRun ?? false;
+  const allowHistoryLoss = options.allowHistoryLoss ?? false;
+  const httpClient = options.httpClient ?? DEFAULT_HTTP_CLIENT;
+  const linkPath = join6(cwd, LINK_FILE2);
+  if (!existsSync6(linkPath)) {
+    return fatalResult5(dryRun, `No ${LINK_FILE2}. Run \`arkaik link\` first \u2014 restore only targets hosted projects.`);
+  }
+  let link;
+  try {
+    link = JSON.parse(readFileSync8(linkPath, "utf8"));
+  } catch (e) {
+    return fatalResult5(dryRun, `Could not parse ${LINK_FILE2}: ${e.message}`);
+  }
+  const projectId = link.project_id;
+  if (!projectId) return fatalResult5(dryRun, `${LINK_FILE2} has no project_id. Run \`arkaik link --project <id>\`.`);
+  const baseUrl = (options.apiBase ?? env.ARKAIK_URL ?? link.remote ?? DEFAULT_API_BASE2).replace(/\/+$/, "");
+  const encodedProjectId = encodeURIComponent(projectId);
+  const token = env.ARKAIK_TOKEN;
+  if (!token) return fatalResult5(dryRun, `ARKAIK_TOKEN is not set. Create a token at ${baseUrl}/settings/tokens and export it.`);
+  const bundlePath = resolve7(cwd, options.path ?? DEFAULT_BUNDLE_PATH8);
+  if (!existsSync6(bundlePath)) return fatalResult5(dryRun, `No bundle at ${bundlePath}. Run \`arkaik merge\` (or \`arkaik pack\`) first.`);
+  let localRaw;
+  try {
+    localRaw = JSON.parse(readFileSync8(bundlePath, "utf8"));
+  } catch (e) {
+    return fatalResult5(dryRun, `Could not parse ${bundlePath}: ${e.message}`);
+  }
+  if (typeof localRaw !== "object" || localRaw === null || Array.isArray(localRaw)) {
+    return fatalResult5(dryRun, `${bundlePath} is not a bundle object.`);
+  }
+  const local = localRaw;
+  const journalEvents = loadJournalEvents(local, bundlePath);
+  const outboundBundle = { ...local, journal: journalEvents };
+  const headers = { Authorization: `Bearer ${token}` };
+  let version2;
+  try {
+    const projectRes = await httpClient(`${baseUrl}/api/graph/projects/${encodedProjectId}`, { headers });
+    if (!projectRes.ok) {
+      return fatalResult5(dryRun, describeVersionReadFailure(projectRes.status, baseUrl, projectId));
+    }
+    const body = await safeJson(projectRes);
+    if (typeof body.version !== "string" || body.version.length === 0) {
+      return fatalResult5(dryRun, "The project response had no usable version \u2014 cannot set If-Match safely. Nothing was sent.");
+    }
+    version2 = body.version;
+  } catch (e) {
+    return fatalResult5(dryRun, `Could not read the project: ${e.message}`);
+  }
+  const putHeaders = { ...headers, "Content-Type": "application/json", "If-Match": `"${version2}"` };
+  const putBody = JSON.stringify({ bundle: outboundBundle });
+  if (dryRun) {
+    let res2;
+    try {
+      res2 = await httpClient(`${baseUrl}/api/graph/projects/${encodedProjectId}/bundle?dryRun=1`, {
+        method: "PUT",
+        headers: putHeaders,
+        body: putBody
+      });
+    } catch (e) {
+      return { ok: true, dryRun, bundlePath, requestSent: false, errorMessage: `Network error: ${e.message}` };
+    }
+    return interpretPutResponse(res2, { dryRun, bundlePath, version: version2 });
+  }
+  let exported;
+  try {
+    const exportRes = await httpClient(`${baseUrl}/api/graph/projects/${encodedProjectId}/export`, { headers });
+    if (!exportRes.ok) {
+      return fatalResult5(dryRun, `Could not export the current hosted state (${exportRes.status}). Refusing to restore without a backup. Nothing was sent.`);
+    }
+    const body = await safeJson(exportRes);
+    exported = body.bundle;
+  } catch (e) {
+    return fatalResult5(dryRun, `Could not export the current hosted state: ${e.message}. Refusing to restore without a backup.`);
+  }
+  if (typeof exported !== "object" || exported === null || Array.isArray(exported)) {
+    return fatalResult5(dryRun, "The export response was not a bundle. Refusing to restore without a backup. Nothing was sent.");
+  }
+  const exportedBundle = exported;
+  if (!Array.isArray(exportedBundle.journal) || !Array.isArray(exportedBundle.nodes) || !Array.isArray(exportedBundle.edges)) {
+    return fatalResult5(
+      dryRun,
+      "The exported bundle is missing nodes, edges, or a journal array \u2014 an incomplete backup would not cover what restore is about to destroy. Refusing to restore. Nothing was sent."
+    );
+  }
+  const hostedEventCount = exportedBundle.journal.length;
+  if (journalEvents.length < hostedEventCount && !allowHistoryLoss) {
+    return fatalResult5(
+      dryRun,
+      `This restore would replace ${hostedEventCount} hosted journal events with ${journalEvents.length}. Nothing was sent. If that is intended, re-run with --allow-history-loss; otherwise check that ${journalPathFor(bundlePath)} exists and is current.`
+    );
+  }
+  const backupDir = join6(cwd, "docs", "arkaik", ".backups");
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupPath = join6(backupDir, `${stamp}-bundle.json`);
+  const backupContent = `${JSON.stringify(exported, null, 2)}
+`;
+  try {
+    mkdirSync5(backupDir, { recursive: true });
+    writeBackupFile(backupPath, backupContent);
+    JSON.parse(readFileSync8(backupPath, "utf8"));
+  } catch (e) {
+    return fatalResult5(
+      dryRun,
+      `Could not write the pre-restore backup to ${backupPath}: ${e.message}
+Refusing to restore \u2014 this verb replaces the hosted project's snapshot AND journal, and the backup is the only way back.`
+    );
+  }
+  let res;
+  try {
+    res = await httpClient(`${baseUrl}/api/graph/projects/${encodedProjectId}/bundle`, {
+      method: "PUT",
+      headers: putHeaders,
+      body: putBody
+    });
+  } catch (e) {
+    return {
+      ok: true,
+      dryRun,
+      bundlePath,
+      backupPath,
+      requestSent: false,
+      errorMessage: `Network error: ${e.message}. Nothing was sent.${backupNoteFor(backupPath)}`
+    };
+  }
+  return interpretPutResponse(res, { dryRun, bundlePath, backupPath, version: version2 });
+}
+function printDelta(delta) {
+  if (!delta) return;
+  const n = (k) => delta[k] ?? "?";
+  console.log(
+    `  nodes  ${n("nodesBefore")} -> ${n("nodesAfter")}  (+${n("nodesAdded")} -${n("nodesRemoved")} ~${n("nodesChanged")}${delta.nodesMalformed ? `, ${delta.nodesMalformed} malformed` : ""})`
+  );
+  console.log(
+    `  edges  ${n("edgesBefore")} -> ${n("edgesAfter")}  (+${n("edgesAdded")} -${n("edgesRemoved")} ~${n("edgesChanged")}${delta.edgesMalformed ? `, ${delta.edgesMalformed} malformed` : ""})`
+  );
+  console.log(
+    `  events ${n("eventsBefore")} -> ${n("eventsAfter")}  (+${n("eventsAdded")} -${n("eventsDropped")} ~${n("eventsChanged")}${delta.eventsMalformed ? `, ${delta.eventsMalformed} malformed` : ""})`
+  );
+}
+function reportRestore(result) {
+  if (!result.ok) fail10(`FATAL: ${result.fatal}`);
+  if (result.backupPath) {
+    console.log(`Backed up the current hosted project (snapshot + journal) to ${result.backupPath}`);
+  }
+  if (!result.requestSent) {
+    console.error(result.errorMessage ?? "Restore failed before a request could be sent.");
+    process.exit(1);
+  }
+  if (result.status === 200) {
+    if (result.dryRun) {
+      console.log("[dry-run] server preview \u2014 nothing was written:");
+      printDelta(result.delta);
+      console.log("Re-run without --dry-run to apply \u2014 that run takes the backup.");
+    } else {
+      console.log(`Restored. New version ${result.version}.`);
+      printDelta(result.delta);
+      if (result.backupPath) {
+        console.log(`  Undo this restore with: arkaik restore ${result.backupPath}`);
+      }
+    }
+    process.exitCode = 0;
+    return;
+  }
+  console.error(result.errorMessage ?? `Restore failed (${result.status}).`);
+  for (const finding of result.serverFindings ?? []) {
+    console.error(`  ${finding.message ?? JSON.stringify(finding)}`);
+  }
+  process.exit(1);
+}
+function runRestoreCli(argv) {
+  let dryRun = false;
+  let allowHistoryLoss = false;
+  let apiBase;
+  const positionals = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "-h" || arg === "--help") {
+      console.log(USAGE11);
+      process.exitCode = 0;
+      return;
+    } else if (arg === "--dry-run") {
+      dryRun = true;
+    } else if (arg === "--allow-history-loss") {
+      allowHistoryLoss = true;
+    } else if (arg === "--api") {
+      const value = argv[++i];
+      if (value === void 0) fail10(`Missing value for --api
+
+${USAGE11}`);
+      apiBase = value;
+    } else if (arg.startsWith("-")) {
+      fail10(`Unknown option: ${arg}
+
+${USAGE11}`);
+    } else {
+      positionals.push(arg);
+    }
+  }
+  if (positionals.length > 1) fail10(`Unexpected argument(s): ${positionals.slice(1).join(" ")}
+
+${USAGE11}`);
+  runRestore({ path: positionals[0], dryRun, allowHistoryLoss, apiBase }).then((result) => reportRestore(result)).catch((e) => fail10(`FATAL: ${e.message}`));
+}
+
+// src/commands/bootstrap.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { existsSync as existsSync12, mkdirSync as mkdirSync7, renameSync, writeFileSync as writeFileSync12 } from "node:fs";
+import path5 from "node:path";
+
+// src/lib/bootstrap/corpus.ts
+import { spawnSync } from "node:child_process";
+import { existsSync as existsSync8, readdirSync, readFileSync as readFileSync10, writeFileSync as writeFileSync10 } from "node:fs";
+import path2 from "node:path";
+
+// src/lib/bootstrap/paths.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync9 } from "node:fs";
+import path from "node:path";
+var BOOTSTRAP_ROOT = ".arkaik";
+var CORPUS_DIR = ".arkaik/corpus";
+var PLAN_DIR = ".arkaik/bootstrap";
+var FRAGMENTS_DIR = ".arkaik/bootstrap/fragments";
+var MANIFEST_FILE = ".arkaik/bootstrap/manifest.json";
+var PROFILE_FILE = ".arkaik/bootstrap/profile.json";
+var PRS_FILE = ".arkaik/corpus/prs.jsonl";
+var DOCS_FILE = ".arkaik/corpus/docs.json";
+var SURFACES_FILE = ".arkaik/corpus/surfaces.json";
+function at(cwd, relative) {
+  return path.join(cwd, relative);
+}
+function ensureDir(dirPath) {
+  mkdirSync6(dirPath, { recursive: true });
+}
+function ensureGitignored(cwd) {
+  const file2 = path.join(cwd, ".gitignore");
+  const line2 = `${BOOTSTRAP_ROOT}/`;
+  const current = existsSync7(file2) ? readFileSync9(file2, "utf8") : "";
+  const ignored = current.split("\n").map((l) => l.trim()).some((l) => l === line2 || l === BOOTSTRAP_ROOT);
+  if (ignored) return false;
+  const prefix = current.length > 0 && !current.endsWith("\n") ? "\n" : "";
+  writeFileSync9(file2, `${current}${prefix}${line2}
+`);
+  return true;
+}
+
+// src/lib/bootstrap/corpus.ts
+var GH_FIELDS = "number,title,body,mergedAt,labels,files";
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  "dist",
+  "build",
+  "coverage",
+  ".arkaik",
+  "ios",
+  "android",
+  "Pods"
+]);
+var SURFACE_RULES = [
+  { test: /(^|\/)app\/api\/.*\/route\.[tj]sx?$/, kind: "api" },
+  { test: /(^|\/)pages\/api\/.*\.[tj]sx?$/, kind: "api" },
+  { test: /(^|\/)app\/.*\/page\.[tj]sx?$/, kind: "page" },
+  { test: /(^|\/)pages\/(?!api\/).*\.[tj]sx?$/, kind: "page" },
+  { test: /(^|\/)(screens|views)\/[^/]+\.[tj]sx?$/, kind: "screen" },
+  { test: /(^|\/)app\/.*\/route\.[tj]sx?$/, kind: "route" },
+  { test: /(^|\/)components\/[^/]+\.[tj]sx?$/, kind: "component" }
+];
+function normalizePrs(raw) {
+  if (!Array.isArray(raw)) return [];
+  const prs = [];
+  for (const row of raw) {
+    if (typeof row !== "object" || row === null) continue;
+    const r = row;
+    const body = typeof r.body === "string" ? r.body : "";
+    prs.push({
+      // The primary key: readCorpusPrs blind-casts this back to `number`, and
+      // JSON.stringify would silently write NaN as `null` otherwise.
+      number: typeof r.number === "number" && Number.isFinite(r.number) ? r.number : 0,
+      title: typeof r.title === "string" ? r.title : "",
+      body,
+      merged_at: typeof r.mergedAt === "string" ? r.mergedAt : "",
+      labels: Array.isArray(r.labels) ? r.labels.map((l) => typeof l === "string" ? l : String(l?.name ?? "")).filter(Boolean) : [],
+      files: Array.isArray(r.files) ? r.files.map((f) => typeof f === "string" ? f : String(f?.path ?? "")).filter(Boolean) : [],
+      // A Lab Note means user-visible by definition — the story wave's cheapest
+      // signal, and the reason its deliverable copy is nearly free.
+      has_lab_note: /^##\s+Lab Note/m.test(body)
+    });
+  }
+  return prs.sort((a, b) => {
+    const aTime = Date.parse(a.merged_at);
+    const bTime = Date.parse(b.merged_at);
+    const av = Number.isNaN(aTime) ? Infinity : aTime;
+    const bv = Number.isNaN(bTime) ? Infinity : bTime;
+    if (av !== bv) return av - bv;
+    return a.number - b.number;
+  });
+}
+function fetchPrsViaGh(cwd, limit) {
+  const res = spawnSync("gh", ["pr", "list", "--state", "merged", "--limit", String(limit), "--json", GH_FIELDS], {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: 256 * 1024 * 1024
+  });
+  if (res.error) throw new Error(`gh not runnable: ${res.error.message}`);
+  if (res.status !== 0) throw new Error(`gh exited ${res.status}: ${res.stderr.trim()}`);
+  return JSON.parse(res.stdout);
+}
+function fetchPrsViaGit(cwd) {
+  const res = spawnSync("git", ["log", "--merges", "--reverse", "--date=iso-strict", "--pretty=%ad%x1f%s"], {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024
+  });
+  if (res.error) throw new Error(`git not runnable: ${res.error.message}`);
+  if (res.status !== 0) throw new Error(`git log failed: ${(res.stderr ?? "").trim()}`);
+  const lines = res.stdout.split("\n").filter(Boolean);
+  const parsed = lines.map((line2) => {
+    const [date5, subject] = line2.split("");
+    const matched = /^Merge pull request #(\d+) /.exec(subject ?? "");
+    return { date: date5 ?? "", subject: subject ?? "", number: matched ? Number(matched[1]) : void 0 };
+  });
+  const taken = new Set(parsed.map((p) => p.number).filter((n) => n !== void 0));
+  let next = 1;
+  return parsed.map((p) => {
+    let number4 = p.number;
+    if (number4 === void 0) {
+      while (taken.has(next)) next += 1;
+      number4 = next;
+      taken.add(number4);
+    }
+    return { number: number4, title: p.subject, body: "", mergedAt: p.date, labels: [], files: [] };
+  });
+}
+function walk(root, cwd, out) {
+  let entries;
+  try {
+    entries = readdirSync(root, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
+    const full = path2.join(root, entry.name);
+    if (entry.isDirectory()) walk(full, cwd, out);
+    else if (entry.isFile()) out.push(path2.relative(cwd, full).split(path2.sep).join("/"));
+  }
+}
+function listFiles(cwd) {
+  const out = [];
+  walk(cwd, cwd, out);
+  return out.sort();
+}
+function buildDocsManifest(cwd, files) {
+  return files.filter((f) => f.startsWith("docs/") && f.endsWith(".md")).map((f) => {
+    const text = readFileSync10(path2.join(cwd, f), "utf8");
+    const heading = /^#\s+(.+)$/m.exec(text);
+    return { path: f, title: heading ? heading[1].trim() : path2.basename(f, ".md") };
+  });
+}
+function buildSurfaceInventory(files) {
+  const out = [];
+  for (const file2 of files) {
+    const rule = SURFACE_RULES.find((r) => r.test.test(file2));
+    if (rule) out.push({ path: file2, kind: rule.kind });
+  }
+  return out;
+}
+function buildCorpus(options) {
+  const { cwd } = options;
+  const raw = options.fromJson ? JSON.parse(readFileSync10(path2.resolve(cwd, options.fromJson), "utf8")) : options.fromGit ? fetchPrsViaGit(cwd) : fetchPrsViaGh(cwd, options.limit);
+  let prs = normalizePrs(raw);
+  let sinceDroppedUndated = 0;
+  if (options.since) {
+    const floor = Date.parse(options.since);
+    if (Number.isNaN(floor)) {
+      throw new Error(`--since is not a parseable date: ${options.since} (try an ISO date like 2026-01-31)`);
+    }
+    prs = prs.filter((pr) => {
+      const merged = Date.parse(pr.merged_at);
+      if (Number.isNaN(merged)) {
+        sinceDroppedUndated += 1;
+        return false;
+      }
+      return merged >= floor;
+    });
+  }
+  const files = listFiles(cwd);
+  const docs = buildDocsManifest(cwd, files);
+  const surfaces = buildSurfaceInventory(files);
+  ensureDir(at(cwd, CORPUS_DIR));
+  writeFileSync10(at(cwd, PRS_FILE), prs.map((pr) => JSON.stringify(pr)).join("\n") + (prs.length ? "\n" : ""));
+  writeFileSync10(at(cwd, DOCS_FILE), `${JSON.stringify(docs, null, 2)}
+`);
+  writeFileSync10(at(cwd, SURFACES_FILE), `${JSON.stringify(surfaces, null, 2)}
+`);
+  return { prs: prs.length, docs: docs.length, surfaces: surfaces.length, sinceDroppedUndated };
+}
+function readCorpusPrs(cwd) {
+  const file2 = at(cwd, PRS_FILE);
+  if (!existsSync8(file2)) return [];
+  return readFileSync10(file2, "utf8").split("\n").filter(Boolean).map((line2) => JSON.parse(line2));
+}
+
+// src/lib/bootstrap/fragments.ts
+import { existsSync as existsSync9, readFileSync as readFileSync11 } from "node:fs";
+import path3 from "node:path";
+function isArrayOfObjects(value) {
+  return value === void 0 || Array.isArray(value) && value.every((v) => typeof v === "object" && v !== null && !Array.isArray(v));
+}
+var SAFE_UNIT_ID_RE = /^[a-z0-9][a-z0-9-]*$/;
+function fragmentPathFor(cwd, unitId) {
+  if (typeof unitId !== "string" || !SAFE_UNIT_ID_RE.test(unitId)) {
+    throw new Error(
+      `manifest.json has an unsafe work-unit id: ${JSON.stringify(unitId)}. Refusing to resolve a fragment path from it \u2014 ids must be lowercase kebab-case (letters, digits, hyphens only). Fix manifest.json, or re-run \`arkaik bootstrap plan\`, and retry.`
+    );
+  }
+  return path3.join(cwd, FRAGMENTS_DIR, `${unitId}.json`);
+}
+function loadFragments(cwd, manifest) {
+  const loaded = [];
+  const problems = [];
+  const missing = [];
+  for (const unit2 of manifest.units) {
+    let file2;
+    try {
+      file2 = fragmentPathFor(cwd, unit2.id);
+    } catch (err) {
+      problems.push({ unit: String(unit2.id), message: err instanceof Error ? err.message : String(err) });
+      continue;
+    }
+    if (!existsSync9(file2)) {
+      missing.push(unit2.id);
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync11(file2, "utf8"));
+    } catch (err) {
+      problems.push({ unit: unit2.id, message: `not valid JSON: ${err instanceof Error ? err.message : "parse error"}` });
+      continue;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      problems.push({ unit: unit2.id, message: "fragment must be a JSON object" });
+      continue;
+    }
+    const fragment = parsed;
+    for (const key of ["nodes", "edges", "add", "update", "retire", "events"]) {
+      if (!isArrayOfObjects(fragment[key])) {
+        problems.push({ unit: unit2.id, message: `\`${key}\` must be an array of objects` });
+      }
+    }
+    loaded.push({ unit: unit2, fragment });
+  }
+  return { loaded, problems, missing };
+}
+
+// src/lib/bootstrap/index-view.ts
+function tsvField(value, fallback = "") {
+  const str2 = value === void 0 || value === null ? fallback : String(value);
+  return str2.replace(/[\t\r\n]+/g, " ");
+}
+function renderIndex(bundle) {
+  const nodes = Array.isArray(bundle.nodes) ? bundle.nodes : [];
+  const lines = ["id	species	title	product"];
+  for (const node of nodes) {
+    const product = node.metadata && typeof node.metadata === "object" ? node.metadata.product : void 0;
+    lines.push([tsvField(node.id), tsvField(node.species), tsvField(node.title), product ? tsvField(product) : "-"].join("	"));
+  }
+  return `${lines.join("\n")}
+`;
+}
+
+// src/lib/bootstrap/manifest.ts
+import { existsSync as existsSync10, readFileSync as readFileSync12, writeFileSync as writeFileSync11 } from "node:fs";
+import path4 from "node:path";
+
+// src/lib/bootstrap/era-window.ts
+var DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+function eraStart(value) {
+  return Date.parse(value);
+}
+function eraEnd(value) {
+  const parsed = Date.parse(value);
+  if (Number.isNaN(parsed)) return parsed;
+  return DATE_ONLY_RE.test(value) ? parsed + ONE_DAY_MS : parsed;
+}
+
+// src/lib/bootstrap/profile-validate.ts
+var SAFE_ID_RE = /^[a-z0-9][a-z0-9-]*$/;
+var MAX_ID_LENGTH = 64;
+function assertSafeId(kind, id) {
+  if (typeof id !== "string" || !SAFE_ID_RE.test(id) || id.length > MAX_ID_LENGTH) {
+    throw new Error(
+      `profile.json has an invalid ${kind} id: ${JSON.stringify(id)}. Work-unit ids become fragment filenames under ${FRAGMENTS_DIR}/, so they must be lowercase kebab-case (letters, digits and hyphens only, no uppercase, no "/", "..", or whitespace) and at most ${MAX_ID_LENGTH} characters. Fix profile.json and re-run \`arkaik bootstrap plan\`.`
+    );
+  }
+}
+function assertArrayField(field, value) {
+  if (value !== void 0 && !Array.isArray(value)) {
+    throw new Error(
+      `profile.json "${field}" must be an array, got ${typeof value} (${JSON.stringify(value)}). Fix profile.json and re-run \`arkaik bootstrap plan\`.`
+    );
+  }
+}
+function assertEraWindow(era) {
+  if (era.from === void 0 && era.to === void 0) {
+    throw new Error(
+      `profile.json era "${String(era.slug)}" has neither "from" nor "to". An unbounded era would hand that era's wave-3 agent zero PRs (bootstrap slice's date-window filter can't constrain anything), silently contributing nothing to the story. Add at least one date and re-run \`arkaik bootstrap plan\`.`
+    );
+  }
+  for (const [key, value] of [
+    ["from", era.from],
+    ["to", era.to]
+  ]) {
+    if (value === void 0) continue;
+    if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
+      throw new Error(
+        `profile.json era "${String(era.slug)}" has an unparseable "${key}": ${JSON.stringify(value)} (try an ISO date like 2026-01-31). Fix profile.json and re-run \`arkaik bootstrap plan\`.`
+      );
+    }
+  }
+}
+function assertNoOverlappingEras(eras) {
+  const windows = eras.map((e) => ({
+    slug: e.slug,
+    start: e.from !== void 0 ? eraStart(e.from) : -Infinity,
+    end: e.to !== void 0 ? eraEnd(e.to) : Infinity
+  }));
+  for (let i = 0; i < windows.length; i += 1) {
+    for (let j = i + 1; j < windows.length; j += 1) {
+      const a = windows[i];
+      const b = windows[j];
+      if (a.start < b.end && b.start < a.end) {
+        const bothOpenEnded = a.end === Infinity && b.end === Infinity;
+        throw new Error(
+          bothOpenEnded ? `profile.json eras "${a.slug}" and "${b.slug}" both have only a "from" date, so both extend indefinitely and always overlap. Give the earlier era a "to" date (e.g. the later era's "from") and re-run \`arkaik bootstrap plan\`.` : `profile.json eras "${a.slug}" and "${b.slug}" have overlapping date windows. Eras must partition the corpus without overlap \u2014 narrow one or both windows and re-run \`arkaik bootstrap plan\`.`
+        );
+      }
+    }
+  }
+}
+function assertAreas(profile) {
+  for (const rawArea of profile.areas ?? []) {
+    if (rawArea === null || typeof rawArea !== "object") {
+      throw new Error(
+        `profile.json has a malformed area entry: ${JSON.stringify(rawArea)} (expected an object with id, title, paths).`
+      );
+    }
+    const area = rawArea;
+    assertSafeId("area", area.id);
+    if (!Array.isArray(area.paths) || area.paths.length === 0) {
+      throw new Error(
+        `profile.json area "${String(area.id)}" has no paths. An empty slice would hand that unit's agent the entire corpus with no filtering. Add at least one path and re-run \`arkaik bootstrap plan\`.`
+      );
+    }
+  }
+}
+function assertEras(profile) {
+  for (const rawEra of profile.eras ?? []) {
+    if (rawEra === null || typeof rawEra !== "object") {
+      throw new Error(
+        `profile.json has a malformed era entry: ${JSON.stringify(rawEra)} (expected an object with slug, title).`
+      );
+    }
+    const era = rawEra;
+    assertSafeId("era", era.slug);
+    assertEraWindow(era);
+  }
+  assertNoOverlappingEras(profile.eras ?? []);
+}
+function assertValidProfile(profile) {
+  if (!profile) return;
+  assertArrayField("areas", profile.areas);
+  assertArrayField("eras", profile.eras);
+  assertAreas(profile);
+  assertEras(profile);
+}
+
+// src/lib/bootstrap/manifest.ts
+function readProfile(cwd) {
+  const file2 = at(cwd, PROFILE_FILE);
+  if (!existsSync10(file2)) return null;
+  try {
+    return JSON.parse(readFileSync12(file2, "utf8"));
+  } catch (err) {
+    throw new Error(`cannot read ${PROFILE_FILE}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function readManifest(cwd) {
+  const file2 = at(cwd, MANIFEST_FILE);
+  if (!existsSync10(file2)) return null;
+  try {
+    return JSON.parse(readFileSync12(file2, "utf8"));
+  } catch (err) {
+    throw new Error(`cannot read ${MANIFEST_FILE}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function writeManifest(cwd, manifest) {
+  ensureDir(at(cwd, PLAN_DIR));
+  ensureDir(at(cwd, FRAGMENTS_DIR));
+  writeFileSync11(at(cwd, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
+`);
+}
+function detectMode(cwd, bundlePath) {
+  const file2 = path4.resolve(cwd, bundlePath);
+  if (!existsSync10(file2)) return "greenfield";
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync12(file2, "utf8"));
+  } catch (err) {
+    throw new Error(`cannot read bundle at ${bundlePath}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const nodes = parsed !== null && typeof parsed === "object" && Array.isArray(parsed.nodes) ? parsed.nodes : [];
+  return nodes.length === 0 ? "greenfield" : "brownfield";
+}
+function unit(id, wave, title2, scope, slice) {
+  return { id, wave, title: title2, scope, slice, fragment: `${FRAGMENTS_DIR}/${id}.json`, status: "pending" };
+}
+var RECON_SCOPE = "Read the corpus and the repo. Write .arkaik/bootstrap/profile.json declaring products, the platform axis, the areas to fan out over (id, title, code paths), and the thematic eras the merged PRs fall into. Then re-run `arkaik bootstrap plan` to expand waves 1-3.";
+function planUnits(options) {
+  const { mode, bundle, profile, previous } = options;
+  assertValidProfile(profile);
+  const units = [unit("w0-recon", 0, "Recon", RECON_SCOPE, { docs: true })];
+  for (const area of profile?.areas ?? []) {
+    units.push(
+      unit(
+        `w1-${area.id}`,
+        1,
+        `Anatomy \u2014 ${area.title}`,
+        mode === "brownfield" ? `Reconcile the existing map for ${area.title} against the code. Emit add/update/retire; never delete.` : `Map the anatomy of ${area.title}: flows, views, data models, API endpoints, and the edges between them.`,
+        { paths: area.paths }
+      )
+    );
+  }
+  for (const area of profile?.areas ?? []) {
+    units.push(
+      unit(
+        `w2-${area.id}`,
+        2,
+        `Acceptances \u2014 ${area.title}`,
+        `Write acceptances for ${area.title}: one Given/When/Then each, 1-3 value elements, covers edges to real nodes, platform scoping per the platform axis in profile.json.`,
+        { paths: area.paths }
+      )
+    );
+  }
+  for (const era of profile?.eras ?? []) {
+    units.push(
+      unit(
+        `w3-${era.slug}`,
+        3,
+        `Story \u2014 ${era.title}`,
+        `Turn this era's user-visible PRs into deliverables and tag the era as a release. A PR with a Lab Note is user-visible by definition; judge the rest.`,
+        { eras: [era.slug] }
+      )
+    );
+  }
+  if (profile) {
+    units.push(
+      unit("w3-decisions", 3, "Story \u2014 decisions", "Mine decisions from the design docs; emit DEC- nodes, their edges, and their events.", {
+        docs: true
+      }),
+      unit("w3-status-arcs", 3, "Story \u2014 status arcs", "Give each anatomy node an honest 1-3 event status arc ending at its snapshot status.", {
+        docs: false
+      })
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const u of units) {
+    if (seen.has(u.id)) {
+      throw new Error(
+        `duplicate work-unit id "${u.id}" \u2014 check profile.json for a repeated area id or era slug (or one that collides with the reserved "decisions" / "status-arcs" era names).`
+      );
+    }
+    seen.add(u.id);
+  }
+  const previousById = new Map((previous?.units ?? []).map((u) => [u.id, u]));
+  for (const u of units) {
+    const before = previousById.get(u.id);
+    if (before && sameSlice(before, u)) {
+      u.status = before.status;
+      if (before.issueUrl) u.issueUrl = before.issueUrl;
+    }
+  }
+  return { version: 1, mode, bundle, units };
+}
+function sameSlice(before, next) {
+  return JSON.stringify(before.slice) === JSON.stringify(next.slice);
+}
+function renderIssues(manifest) {
+  return manifest.units.filter((u) => u.status === "pending" && !u.issueUrl).map((u) => ({
+    unit: u.id,
+    title: `[bootstrap] ${u.id} \u2014 ${u.title}`,
+    body: [
+      `**Wave ${u.wave}.** ${u.scope}`,
+      "",
+      "### How to work this unit",
+      "",
+      "```bash",
+      `arkaik bootstrap slice ${u.id} > slice.json`,
+      "```",
+      "",
+      `Read \`slice.json\`, then write your fragment to \`${u.fragment}\`.`,
+      "Do not edit the bundle. Do not edit another unit's fragment.",
+      "",
+      "The `arkaik-bootstrap` skill defines the fragment contract and the",
+      "judgment rules for this wave. When the fragment is written, set this",
+      `unit's status to \`done\` in \`${MANIFEST_FILE}\`.`
+    ].join("\n")
+  }));
+}
+
+// src/lib/bootstrap/event-id.ts
+var ENCODING2 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var TIME_LEN2 = 10;
+var RANDOM_LEN2 = 16;
+var FNV_OFFSET = 2166136261;
+var FNV_PRIME = 16777619;
+function fnv1a(input) {
+  let h = FNV_OFFSET;
+  for (let i = 0; i < input.length; i += 1) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, FNV_PRIME);
+  }
+  return h >>> 0;
+}
+function fmix32(hIn) {
+  let h = hIn >>> 0;
+  h ^= h >>> 16;
+  h = Math.imul(h, 2246822507) >>> 0;
+  h ^= h >>> 13;
+  h = Math.imul(h, 3266489909) >>> 0;
+  h ^= h >>> 16;
+  return h >>> 0;
+}
+function encodeTime2(ms) {
+  let remaining = Math.max(0, Math.floor(ms));
+  let out = "";
+  for (let i = 0; i < TIME_LEN2; i += 1) {
+    const digit = remaining % 32;
+    out = ENCODING2[digit] + out;
+    remaining = (remaining - digit) / 32;
+  }
+  return out;
+}
+function keySuffix(key) {
+  let out = "";
+  for (let i = 0; i < RANDOM_LEN2; i += 1) {
+    const h = fmix32(fnv1a(`${i}:${key}`));
+    out += ENCODING2[h % 32];
+  }
+  return out;
+}
+function deterministicEventId(ts, key) {
+  const ms = Date.parse(ts);
+  if (Number.isNaN(ms)) {
+    throw new Error(`deterministicEventId: ts is not a parseable timestamp: ${JSON.stringify(ts)}`);
+  }
+  return encodeTime2(ms) + keySuffix(key);
+}
+
+// src/lib/bootstrap/journal-merge.ts
+function sortEvents(events) {
+  return [...events].sort((a, b) => {
+    const at2 = String(a.ts ?? "");
+    const bt = String(b.ts ?? "");
+    if (at2 !== bt) return at2 < bt ? -1 : 1;
+    const ai = String(a.id ?? "");
+    const bi = String(b.id ?? "");
+    return ai < bi ? -1 : ai > bi ? 1 : 0;
+  });
+}
+function canonicalJson(value) {
+  if (value === void 0) return "null";
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj).filter((k) => obj[k] !== void 0).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalJson(obj[k])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function isOrderSensitive(ev) {
+  if (ev.type === "decision.status_changed") return true;
+  if (ev.type === "node.status_changed") return ev.platform === void 0;
+  return false;
+}
+function eventKey(raw, ts) {
+  const stringify = (value) => typeof value === "string" ? value : canonicalJson(value);
+  const type = String(raw.type ?? "");
+  const parts = [type, `ts=${ts}`];
+  const field = (label, value) => {
+    if (value !== void 0) parts.push(`${label}=${stringify(value)}`);
+  };
+  field("node", raw.node_id);
+  field("deliverable", raw.deliverable_id);
+  field("version", raw.version);
+  field("edge", raw.edge_id);
+  field("ref", raw.ref_id);
+  field("source", raw.source_id);
+  field("target", raw.target_id);
+  field("platform", raw.platform);
+  field("from", raw.from);
+  field("to", raw.to);
+  field("title", raw.title);
+  field("url", raw.url);
+  return parts.join("|");
+}
+function mergeJournal(base, fresh) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const ev of base) {
+    const id = typeof ev.id === "string" ? ev.id : void 0;
+    if (id) byId.set(id, ev);
+  }
+  let added = 0;
+  const conflicts = [];
+  for (const ev of fresh) {
+    const id = typeof ev.id === "string" ? ev.id : void 0;
+    if (!id) continue;
+    const existing = byId.get(id);
+    if (existing) {
+      if (canonicalJson(existing) !== canonicalJson(ev)) {
+        conflicts.push({ id, base: existing, fresh: ev });
+      }
+      continue;
+    }
+    byId.set(id, ev);
+    added += 1;
+  }
+  return { journal: sortEvents([...byId.values()]), added, conflicts };
+}
+
+// src/lib/bootstrap/merge.ts
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function mergeFragments(input) {
+  const errors = [];
+  const projectId = String(input.base.project?.id ?? "");
+  const nodes = /* @__PURE__ */ new Map();
+  const nodeOrigin = /* @__PURE__ */ new Map();
+  for (const node of asArray(input.base.nodes)) {
+    const id = String(node.id);
+    nodes.set(id, { ...node });
+    nodeOrigin.set(id, "(already in the bundle)");
+  }
+  const edges = /* @__PURE__ */ new Map();
+  const edgeOrigin = /* @__PURE__ */ new Map();
+  for (const edge of asArray(input.base.edges)) {
+    const id = String(edge.id ?? edgeId(String(edge.source_id), String(edge.target_id)));
+    edges.set(id, { ...edge });
+    edgeOrigin.set(id, "(already in the bundle)");
+  }
+  const newEvents = [];
+  const counts = { nodesAdded: 0, nodesUpdated: 0, nodesRetired: 0, edgesAdded: 0, eventsAdded: 0 };
+  const orderSensitiveSeen = /* @__PURE__ */ new Map();
+  for (const ev of input.baseJournal) {
+    if (!isOrderSensitive(ev)) continue;
+    const key = `${String(ev.type)}:${String(ev.node_id ?? "")}:${String(ev.ts ?? "")}`;
+    if (!orderSensitiveSeen.has(key)) {
+      orderSensitiveSeen.set(key, { unit: "(already in the journal)", from: ev.from, to: ev.to });
+    }
+  }
+  const eventUnit = /* @__PURE__ */ new Map();
+  const pushEvent = (unitId, ev) => {
+    if (isOrderSensitive(ev)) {
+      const nodeId = String(ev.node_id ?? "");
+      const key = `${String(ev.type)}:${nodeId}:${String(ev.ts ?? "")}`;
+      const existing = orderSensitiveSeen.get(key);
+      if (existing && String(existing.to) !== String(ev.to)) {
+        errors.push({
+          unit: unitId,
+          message: `two \`${String(ev.type)}\` events for node \`${nodeId}\` land at the identical ts ${String(ev.ts)} but disagree on the outcome \u2014 ${JSON.stringify(existing.from)} -> ${JSON.stringify(existing.to)} (from ${existing.unit}) vs ${JSON.stringify(ev.from)} -> ${JSON.stringify(ev.to)} (from ${unitId}). crossCheckJournal reads only the LAST such event's \`to\` per node, and read-back order between events sharing one ts is not guaranteed to match write order \u2014 give one of them a distinct timestamp (\`update\`/\`retire\`: \`changed_ts\`; wave-3 \`events\`: \`ts\`) and re-run.`
+        });
+        return;
+      }
+      if (!existing) {
+        orderSensitiveSeen.set(key, { unit: unitId, from: ev.from, to: ev.to });
+      }
+    }
+    eventUnit.set(String(ev.id), unitId);
+    newEvents.push(ev);
+  };
+  const mintEvent = (unitId, ts, payload, onFail) => {
+    try {
+      const id = deterministicEventId(ts, eventKey(payload, ts));
+      pushEvent(unitId, { id, ts, actor: "bootstrap", ...payload });
+    } catch (err) {
+      errors.push({ unit: unitId, message: `${onFail}: ${err instanceof Error ? err.message : String(err)}` });
+    }
+  };
+  for (const { unit: unit2, fragment } of input.fragments) {
+    for (const raw of [...fragment.nodes ?? [], ...fragment.add ?? []]) {
+      const id = String(raw.id ?? "");
+      if (!id) {
+        errors.push({ unit: unit2.id, message: "a node has no id" });
+        continue;
+      }
+      const { created_ts: createdTs, ...node } = raw;
+      if (!Array.isArray(node.platforms)) node.platforms = [];
+      if (nodes.has(id)) {
+        const existingTitle = String(nodes.get(id)?.title ?? "");
+        const incomingTitle = String(node.title ?? "");
+        const owner = nodeOrigin.get(id);
+        if (existingTitle !== incomingTitle) {
+          errors.push({
+            unit: unit2.id,
+            message: `id collision on \`${id}\`: "${existingTitle}" (from ${owner}) vs "${incomingTitle}" (from ${unit2.id})`
+          });
+        }
+        continue;
+      }
+      nodes.set(id, { ...node, id, project_id: projectId });
+      nodeOrigin.set(id, unit2.id);
+      counts.nodesAdded += 1;
+      const ts = typeof createdTs === "string" && createdTs ? createdTs : input.fallbackTs;
+      mintEvent(
+        unit2.id,
+        ts,
+        { type: "node.created", node_id: id, species: node.species, title: node.title },
+        `cannot mint a node.created event for \`${id}\` (ts ${JSON.stringify(ts)})`
+      );
+    }
+    for (const patch of fragment.update ?? []) {
+      const id = String(patch.id ?? "");
+      const target = nodes.get(id);
+      if (!target) {
+        errors.push({ unit: unit2.id, message: `update targets unknown node \`${id}\`` });
+        continue;
+      }
+      const fromStatus = target.status;
+      const existingMetadata = target.metadata ?? {};
+      const fromDecisionStatus = String(existingMetadata.decision_status ?? "proposed");
+      const rawPatch = patch.patch ?? {};
+      const { metadata: patchMetadata, ...restPatch } = rawPatch;
+      Object.assign(target, restPatch, { id, project_id: projectId });
+      if (patchMetadata !== void 0 && typeof patchMetadata === "object" && patchMetadata !== null) {
+        target.metadata = { ...existingMetadata, ...patchMetadata };
+      }
+      counts.nodesUpdated += 1;
+      const toStatus = target.status;
+      if (Object.prototype.hasOwnProperty.call(rawPatch, "status") && toStatus !== fromStatus) {
+        const ts = typeof patch.changed_ts === "string" && patch.changed_ts ? patch.changed_ts : input.fallbackTs;
+        mintEvent(
+          unit2.id,
+          ts,
+          { type: "node.status_changed", node_id: id, from: fromStatus, to: toStatus },
+          `cannot mint a node.status_changed event for \`${id}\` (ts ${JSON.stringify(ts)})`
+        );
+      }
+      const finalMetadata = target.metadata ?? {};
+      const toDecisionStatus = String(finalMetadata.decision_status ?? "proposed");
+      const patchTouchesDecisionStatus = patchMetadata !== void 0 && typeof patchMetadata === "object" && patchMetadata !== null && Object.prototype.hasOwnProperty.call(patchMetadata, "decision_status");
+      if (patchTouchesDecisionStatus && toDecisionStatus !== fromDecisionStatus) {
+        const ts = typeof patch.changed_ts === "string" && patch.changed_ts ? patch.changed_ts : input.fallbackTs;
+        mintEvent(
+          unit2.id,
+          ts,
+          { type: "decision.status_changed", node_id: id, from: fromDecisionStatus, to: toDecisionStatus },
+          `cannot mint a decision.status_changed event for \`${id}\` (ts ${JSON.stringify(ts)})`
+        );
+      }
+    }
+    for (const retire of fragment.retire ?? []) {
+      const id = String(retire.id ?? "");
+      const target = nodes.get(id);
+      if (!target) {
+        errors.push({ unit: unit2.id, message: `retire targets unknown node \`${id}\`` });
+        continue;
+      }
+      const fromStatus = target.status;
+      target.status = "archived";
+      const metadata = target.metadata ?? {};
+      target.metadata = { ...metadata, retired_reason: retire.reason };
+      counts.nodesRetired += 1;
+      if (fromStatus !== "archived") {
+        const ts = typeof retire.changed_ts === "string" && retire.changed_ts ? retire.changed_ts : input.fallbackTs;
+        mintEvent(
+          unit2.id,
+          ts,
+          { type: "node.status_changed", node_id: id, from: fromStatus, to: "archived" },
+          `cannot mint a node.status_changed event for \`${id}\` (retire, ts ${JSON.stringify(ts)})`
+        );
+      }
+    }
+  }
+  for (const { unit: unit2, fragment } of input.fragments) {
+    for (const raw of fragment.edges ?? []) {
+      const source = String(raw.source_id ?? "");
+      const target = String(raw.target_id ?? "");
+      if (!nodes.has(source) || !nodes.has(target)) {
+        errors.push({
+          unit: unit2.id,
+          message: `edge ${source} -> ${target} references ${!nodes.has(source) ? source : target}, which no fragment created`
+        });
+        continue;
+      }
+      const kindValue = raw.kind;
+      const edgeTypeValue = raw.edge_type;
+      const resolvedType = typeof edgeTypeValue === "string" ? edgeTypeValue : typeof kindValue === "string" ? kindValue : void 0;
+      if (!resolvedType) {
+        errors.push({ unit: unit2.id, message: `edge ${source} -> ${target} has no \`kind\` (its edge type)` });
+        continue;
+      }
+      const id = edgeId(source, target);
+      if (edges.has(id)) {
+        const existingType = String(edges.get(id)?.edge_type ?? "");
+        const owner = edgeOrigin.get(id);
+        if (existingType !== resolvedType) {
+          errors.push({
+            unit: unit2.id,
+            message: `edge ${source} -> ${target} disagrees on type: "${existingType}" (from ${owner}) vs "${resolvedType}" (from ${unit2.id}) \u2014 an edge id encodes only its endpoints, so it can hold exactly one type.`
+          });
+        }
+        continue;
+      }
+      const edge = { ...raw, id, project_id: projectId, source_id: source, target_id: target, edge_type: resolvedType };
+      delete edge.kind;
+      edges.set(id, edge);
+      edgeOrigin.set(id, unit2.id);
+      counts.edgesAdded += 1;
+    }
+  }
+  for (const { unit: unit2, fragment } of input.fragments) {
+    for (const raw of fragment.events ?? []) {
+      const type = String(raw.type ?? "");
+      const ts = String(raw.ts ?? "");
+      if (!type || !ts) {
+        errors.push({ unit: unit2.id, message: "an event is missing `type` or `ts`" });
+        continue;
+      }
+      if (typeof raw.id === "string" && raw.id) {
+        pushEvent(unit2.id, { ...raw, id: raw.id, ts, type });
+        continue;
+      }
+      try {
+        const id = deterministicEventId(ts, eventKey(raw, ts));
+        pushEvent(unit2.id, { ...raw, id, ts, type });
+      } catch (err) {
+        errors.push({ unit: unit2.id, message: `cannot mint an id for a \`${type}\` event: ${err instanceof Error ? err.message : String(err)}` });
+      }
+    }
+  }
+  const { journal, added, conflicts } = mergeJournal(input.baseJournal, newEvents);
+  counts.eventsAdded = added;
+  for (const conflict of conflicts) {
+    const unitId = eventUnit.get(conflict.id);
+    errors.push({
+      unit: unitId,
+      message: `event \`${conflict.id}\` already exists in the journal with different content \u2014 the committed copy always wins, but this looks like a real correction, not a harmless re-run. Committed: ${JSON.stringify(conflict.base)}. Freshly derived: ${JSON.stringify(conflict.fresh)}. merge never rewrites committed history \u2014 correct the committed event by hand (or via \`arkaik log\`) if it's wrong.`
+    });
+  }
+  const bundle = {
+    ...input.base,
+    nodes: [...nodes.values()],
+    edges: [...edges.values()]
+  };
+  delete bundle.journal;
+  return { bundle, journal, errors, counts };
+}
+
+// src/lib/bootstrap/slice.ts
+import { existsSync as existsSync11, readFileSync as readFileSync13 } from "node:fs";
+
+// src/lib/bootstrap/body-budget.ts
+var LAB_NOTE_HEADING_RE = /^##\s+Lab Note.*$/m;
+var NEXT_HEADING_RE = /^##\s+/m;
+var MAX_BODY_CHARS = 4e3;
+function splitLabNoteSection(body) {
+  const heading = LAB_NOTE_HEADING_RE.exec(body);
+  if (!heading) return null;
+  const noteStart = heading.index;
+  const restStart = noteStart + heading[0].length;
+  const next = NEXT_HEADING_RE.exec(body.slice(restStart));
+  const noteEnd = next ? restStart + next.index : body.length;
+  return { before: body.slice(0, noteStart), note: body.slice(noteStart, noteEnd), after: body.slice(noteEnd) };
+}
+function truncationMarker(cutChars) {
+  return `
+
+[\u2026 truncated ${cutChars} characters \u2026]
+
+`;
+}
+function headTruncate(text, budget) {
+  if (text.length <= budget) return text;
+  const cut = text.length - budget;
+  return `${text.slice(0, budget)}${truncationMarker(cut)}`;
+}
+function boundAroundNote(section) {
+  const remaining = Math.max(0, MAX_BODY_CHARS - section.note.length);
+  const beforeBudget = Math.floor(remaining / 2);
+  const afterBudget = remaining - beforeBudget;
+  return `${headTruncate(section.before, beforeBudget)}${section.note}${headTruncate(section.after, afterBudget)}`;
+}
+function boundBody(body) {
+  if (body.length <= MAX_BODY_CHARS) return body;
+  const section = splitLabNoteSection(body);
+  const bounded = section ? boundAroundNote(section) : headTruncate(body, MAX_BODY_CHARS);
+  return bounded.length < body.length ? bounded : body;
+}
+
+// src/lib/bootstrap/slice.ts
+function readJsonArray(file2) {
+  if (!existsSync11(file2)) return [];
+  const parsed = JSON.parse(readFileSync13(file2, "utf8"));
+  return Array.isArray(parsed) ? parsed : [];
+}
+function toPosix(value) {
+  return value.includes("\\") ? value.split("\\").join("/") : value;
+}
+function matchesPaths(filePath, paths) {
+  const file2 = toPosix(filePath);
+  return paths.some((raw) => {
+    const p = toPosix(raw);
+    return file2 === p || file2.startsWith(p.endsWith("/") ? p : `${p}/`);
+  });
+}
+function eraWindows(cwd, slugs) {
+  if (slugs.length === 0) return [];
+  const profile = readProfile(cwd);
+  const bySlug = new Map((profile?.eras ?? []).map((e) => [e.slug, e]));
+  return slugs.map((slug) => {
+    const era = bySlug.get(slug);
+    if (!era) {
+      throw new Error(
+        `era "${slug}" is not declared in ${PROFILE_FILE}'s "eras" list, but a work unit's slice references it. profile.json may have been edited (or the era removed) since \`arkaik bootstrap plan\` last ran. Restore the era in profile.json and re-run \`arkaik bootstrap plan\`, or reconcile the manifest by hand.`
+      );
+    }
+    assertEraWindow(era);
+    return { from: era.from, to: era.to };
+  });
+}
+function matchesEras(mergedAt, windows) {
+  const merged = Date.parse(mergedAt);
+  if (Number.isNaN(merged)) return false;
+  return windows.some((w) => {
+    const start = w.from !== void 0 ? eraStart(w.from) : void 0;
+    const end = w.to !== void 0 ? eraEnd(w.to) : void 0;
+    const usableStart = start !== void 0 && !Number.isNaN(start) ? start : void 0;
+    const usableEnd = end !== void 0 && !Number.isNaN(end) ? end : void 0;
+    if (usableStart === void 0 && usableEnd === void 0) return false;
+    if (usableStart !== void 0 && merged < usableStart) return false;
+    if (usableEnd !== void 0 && merged >= usableEnd) return false;
+    return true;
+  });
+}
+function resolveSlice(cwd, unit2) {
+  const paths = unit2.slice.paths ?? [];
+  const eraSlugs = unit2.slice.eras ?? [];
+  const allPrs = readCorpusPrs(cwd);
+  const surfaces = readJsonArray(at(cwd, SURFACES_FILE));
+  let prs;
+  let surfacesOut;
+  if (paths.length > 0) {
+    prs = allPrs.filter((pr) => pr.files.some((f) => matchesPaths(f, paths)));
+    surfacesOut = surfaces.filter((s) => matchesPaths(s.path, paths));
+  } else if (eraSlugs.length > 0) {
+    const windows = eraWindows(cwd, eraSlugs);
+    prs = allPrs.filter((pr) => matchesEras(pr.merged_at, windows));
+    surfacesOut = [];
+  } else {
+    prs = allPrs;
+    surfacesOut = surfaces;
+  }
+  prs = prs.map((pr) => ({ ...pr, body: boundBody(pr.body) }));
+  const slice = {
+    unit: unit2.id,
+    wave: unit2.wave,
+    scope: unit2.scope,
+    fragment: unit2.fragment,
+    prs,
+    surfaces: surfacesOut
+  };
+  if (unit2.slice.docs) slice.docs = readJsonArray(at(cwd, DOCS_FILE));
+  return slice;
+}
+
+// src/commands/bootstrap.ts
+var USAGE12 = `arkaik bootstrap <subcommand> [options]
+
+Subcommands:
+  corpus [options]        Mine merged PRs, docs and surfaces into .arkaik/corpus/.
+  plan [options]          Emit the work-unit manifest (--issues files GitHub issues).
+  slice <unit>            Print exactly the corpus subset one work unit needs.
+  index [path]            Print a compact id/title/species listing of the map.
+  merge [options]         Assemble fragments onto the bundle, then validate.
+
+Options:
+  -h, --help              Show this help.
+
+Run "arkaik bootstrap <subcommand> --help" for subcommand help.`;
+var CORPUS_USAGE = `arkaik bootstrap corpus [options]
+
+Mine merged PRs, design docs and code surfaces into .arkaik/corpus/.
+
+Options:
+  --from-json <file>  Replay a captured \`gh pr list --json\` payload instead of calling gh.
+  --from-git          Mine merge commits with git instead of gh (loses Lab Notes).
+  --limit <n>         Max PRs to fetch from gh (default: 1000).
+  --since <iso-date>  Keep only PRs merged at or after this date.
+  -h, --help          Show this help.`;
+function fail11(message) {
+  console.error(message);
+  process.exit(1);
+}
+function nextValue(argv, i, flag, usage) {
+  const value = argv[i];
+  if (value === void 0) fail11(`Missing value for ${flag}
+
+${usage}`);
+  return value;
+}
+function writeFileAtomic(filePath, content) {
+  const tmpPath = `${filePath}.tmp-${process.pid}`;
+  writeFileSync12(tmpPath, content);
+  renameSync(tmpPath, filePath);
+}
+function runCorpus(argv) {
+  const cwd = process.cwd();
+  let fromJson;
+  let fromGit = false;
+  let limit = 1e3;
+  let since;
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "-h" || arg === "--help") {
+      console.log(CORPUS_USAGE);
+      process.exit(0);
+    } else if (arg === "--from-json") {
+      fromJson = nextValue(argv, ++i, "--from-json", CORPUS_USAGE);
+    } else if (arg === "--from-git") {
+      fromGit = true;
+    } else if (arg === "--limit") {
+      const raw = nextValue(argv, ++i, "--limit", CORPUS_USAGE);
+      const parsed = Number(raw);
+      if (!Number.isInteger(parsed) || parsed <= 0) {
+        fail11(`--limit must be a positive integer, got: ${raw}
+
+${CORPUS_USAGE}`);
+      }
+      limit = parsed;
+    } else if (arg === "--since") {
+      since = nextValue(argv, ++i, "--since", CORPUS_USAGE);
+    } else {
+      fail11(`Unknown option: ${arg}
+
+${CORPUS_USAGE}`);
+    }
+  }
+  if (!existsSync12(path5.join(cwd, ".git"))) {
+    fail11("`arkaik bootstrap corpus` must run from the repository root (no .git here).");
+  }
+  try {
+    const result = buildCorpus({ cwd, fromJson, fromGit, limit, since });
+    const ignored = ensureGitignored(cwd);
+    console.log(`Corpus written to ${CORPUS_DIR}/`);
+    console.log(`  ${result.prs} merged PRs, ${result.docs} docs, ${result.surfaces} surfaces`);
+    if (result.sinceDroppedUndated > 0) {
+      console.log(`  --since also dropped ${result.sinceDroppedUndated} PR(s) with a missing/unparseable merge date`);
+    }
+    if (ignored) console.log(`  added ${BOOTSTRAP_ROOT}/ to .gitignore`);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+var PLAN_USAGE = `arkaik bootstrap plan [options]
+
+Emit the work-unit manifest at .arkaik/bootstrap/manifest.json. With no recon
+profile only the wave-0 recon unit is planned; re-run after recon writes
+profile.json to expand waves 1-3. Existing unit statuses are preserved for
+units whose scope/slice is unchanged since the last plan.
+
+Options:
+  --bundle <path>  Bundle to bootstrap (default: docs/arkaik/bundle.json).
+  --issues         File one GitHub issue per pending unit instead of driving
+                   in-session. Same manifest, alternate driver: durable and
+                   parallel across machines, at the cost of a cold-start
+                   context tax per unit. A unit that already has a filed
+                   issue (tracked locally in manifest.json, not checked
+                   against GitHub) is skipped, not re-filed.
+  --print          With --issues, print the rendered issues as JSON instead
+                   of filing them \u2014 never calls \`gh\`. Requires --issues.
+  -h, --help       Show this help.`;
+function runPlan(argv) {
+  const cwd = process.cwd();
+  let bundle = "docs/arkaik/bundle.json";
+  let issues = false;
+  let print = false;
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "-h" || arg === "--help") {
+      console.log(PLAN_USAGE);
+      process.exit(0);
+    } else if (arg === "--bundle") {
+      bundle = nextValue(argv, ++i, "--bundle", PLAN_USAGE);
+    } else if (arg === "--issues") {
+      issues = true;
+    } else if (arg === "--print") {
+      print = true;
+    } else {
+      fail11(`Unknown option: ${arg}
+
+${PLAN_USAGE}`);
+    }
+  }
+  if (print && !issues) {
+    fail11(`--print requires --issues
+
+${PLAN_USAGE}`);
+  }
+  if (!existsSync12(path5.join(cwd, ".git"))) {
+    fail11("`arkaik bootstrap plan` must run from the repository root (no .git here).");
+  }
+  try {
+    const mode = detectMode(cwd, bundle);
+    const manifest = planUnits({ mode, bundle, profile: readProfile(cwd), previous: readManifest(cwd) });
+    writeManifest(cwd, manifest);
+    const ignored = ensureGitignored(cwd);
+    if (ignored) console.log(`  added ${BOOTSTRAP_ROOT}/ to .gitignore`);
+    if (issues) {
+      runPlanIssues(cwd, manifest, print);
+      return;
+    }
+    const pending = manifest.units.filter((u) => u.status === "pending").length;
+    console.log(`Planned ${manifest.units.length} units (${pending} pending) in ${mode} mode.`);
+    for (const u of manifest.units) console.log(`  [${u.status}] w${u.wave} ${u.id} \u2014 ${u.title}`);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+function runPlanIssues(cwd, manifest, print) {
+  const rendered = renderIssues(manifest);
+  if (print) {
+    console.log(JSON.stringify(rendered, null, 2));
+    return;
+  }
+  if (rendered.length === 0) {
+    console.log("Every pending unit already has a filed issue \u2014 nothing to do.");
+    return;
+  }
+  let filedThisRun = 0;
+  for (const issue2 of rendered) {
+    const res = spawnSync2("gh", ["issue", "create", "--title", issue2.title, "--body", issue2.body], {
+      cwd,
+      encoding: "utf8"
+    });
+    if (res.error) {
+      console.error(`gh not runnable: ${res.error.message}`);
+      process.exit(1);
+    }
+    if (res.status !== 0) {
+      console.error(`gh issue create failed for ${issue2.unit}: ${(res.stderr ?? "").trim()}`);
+      console.error(
+        `${filedThisRun} of ${rendered.length} issue(s) filed before this failure \u2014 re-run \`arkaik bootstrap plan --issues\` after fixing the problem above; already-filed units are not re-filed.`
+      );
+      process.exit(1);
+    }
+    const url2 = res.stdout.trim();
+    const target = manifest.units.find((u) => u.id === issue2.unit);
+    if (target) target.issueUrl = url2;
+    filedThisRun += 1;
+    writeManifest(cwd, manifest);
+    console.log(`Filed ${issue2.unit}: ${url2}`);
+  }
+}
+var SLICE_USAGE = `arkaik bootstrap slice <unit>
+
+Print exactly the corpus subset one work unit needs, as compact JSON (id,
+scope, matching PRs, matching surfaces, and \u2014 only when the unit asks for it
+\u2014 the docs manifest). Reads .arkaik/bootstrap/manifest.json; run
+\`arkaik bootstrap plan\` first.`;
+function runSlice(argv) {
+  const cwd = process.cwd();
+  const unitId = argv[0];
+  if (unitId === "-h" || unitId === "--help") {
+    console.log(SLICE_USAGE);
+    process.exit(0);
+  }
+  if (unitId === void 0) fail11(`Missing required argument: <unit>
+
+${SLICE_USAGE}`);
+  const manifest = readManifest(cwd);
+  if (!manifest) fail11("No manifest. Run `arkaik bootstrap plan` first.");
+  const unit2 = manifest.units.find((u) => u.id === unitId);
+  if (!unit2) fail11(`Unknown unit: ${unitId}
+Known units: ${manifest.units.map((u) => u.id).join(", ")}`);
+  try {
+    console.log(JSON.stringify(resolveSlice(cwd, unit2)));
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+var INDEX_USAGE = `arkaik bootstrap index [path]
+
+Print a compact id/species/title/product listing of the map, one
+tab-separated line per node (default: docs/arkaik/bundle.json).`;
+function runIndex(argv) {
+  if (argv[0] === "-h" || argv[0] === "--help") {
+    console.log(INDEX_USAGE);
+    process.exit(0);
+  }
+  if (argv[0] !== void 0 && argv[0].startsWith("-")) {
+    fail11(`Unknown option: ${argv[0]}
+
+${INDEX_USAGE}`);
+  }
+  const target = argv[0] ?? path5.join("docs", "arkaik", "bundle.json");
+  try {
+    process.stdout.write(renderIndex(readBundle(path5.resolve(process.cwd(), target))));
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+var MERGE_USAGE = `arkaik bootstrap merge [options]
+
+Assemble every fragment named by the manifest onto the bundle: verify ID
+uniqueness, resolve edge endpoints, apply reconcile ops, synthesize the
+required node.created / node.status_changed / decision.status_changed
+events, validate the result (errors block the write; warnings are reported
+but never block it), and write the bundle plus its journal.jsonl sidecar.
+
+Options:
+  --dry-run    Report what would change (including validation); write nothing.
+  -h, --help   Show this help.`;
+function runMerge(argv) {
+  const cwd = process.cwd();
+  let dryRun = false;
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "-h" || arg === "--help") {
+      console.log(MERGE_USAGE);
+      process.exit(0);
+    } else if (arg === "--dry-run") {
+      dryRun = true;
+    } else {
+      fail11(`Unknown option: ${arg}
+
+${MERGE_USAGE}`);
+    }
+  }
+  const manifest = readManifest(cwd);
+  if (!manifest) {
+    fail11("No manifest. Run `arkaik bootstrap plan` first.");
+  }
+  try {
+    const bundlePath = path5.resolve(cwd, manifest.bundle);
+    const base = existsSync12(bundlePath) ? readBundle(bundlePath) : {
+      schema_version: 3,
+      project: {
+        id: path5.basename(cwd),
+        title: path5.basename(cwd),
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      nodes: [],
+      edges: []
+    };
+    const baseJournal = loadJournalEvents(base, bundlePath);
+    const { loaded, problems, missing } = loadFragments(cwd, manifest);
+    for (const problem of problems) console.error(`fragment ${problem.unit}: ${problem.message}`);
+    if (problems.length > 0) process.exit(1);
+    const fallbackTs = String(base.project?.created_at ?? (/* @__PURE__ */ new Date()).toISOString());
+    const result = mergeFragments({ base, baseJournal, fragments: loaded, fallbackTs });
+    for (const error51 of result.errors) console.error(`merge ${error51.unit}: ${error51.message}`);
+    if (result.errors.length > 0) process.exit(1);
+    const project = result.bundle.project;
+    const lastTs = result.journal.length > 0 ? String(result.journal[result.journal.length - 1].ts) : void 0;
+    result.bundle.project = { ...project, updated_at: lastTs ?? project.updated_at };
+    const validation = validateBundle({ ...result.bundle, journal: result.journal });
+    if (validation.warnings.length > 0) {
+      console.log(`  ${validation.warnings.length} validation warning(s):`);
+      for (const warning of validation.warnings) console.log(`    ${formatFinding(warning)}`);
+    }
+    if (validation.errors.length > 0) {
+      for (const error51 of validation.errors) console.error(formatFinding(error51));
+      console.error("Merged bundle fails validation \u2014 nothing was written. Fix the fragment(s) above and re-run.");
+      process.exit(1);
+    }
+    const serialized = serializeBundle(result.bundle);
+    const journalPath = journalPathFor(bundlePath);
+    const journalText = result.journal.map((e) => JSON.stringify(e)).join("\n") + (result.journal.length ? "\n" : "");
+    if (!dryRun) {
+      mkdirSync7(path5.dirname(bundlePath), { recursive: true });
+      writeFileAtomic(bundlePath, serialized);
+      writeFileAtomic(journalPath, journalText);
+    }
+    console.log(`${dryRun ? "[dry-run] " : ""}Merged ${loaded.length} fragments:`);
+    console.log(
+      `  +${result.counts.nodesAdded} nodes, ~${result.counts.nodesUpdated} updated, ${result.counts.nodesRetired} retired, +${result.counts.edgesAdded} edges, +${result.counts.eventsAdded} events`
+    );
+    console.log(`  bundle ${(Buffer.byteLength(serialized) / 1024).toFixed(0)}KB, journal ${result.journal.length} events`);
+    if (missing.length > 0) console.log(`  ${missing.length} units have no fragment yet: ${missing.join(", ")}`);
+    const wroteOrWould = dryRun ? "would be written" : "written";
+    console.log(
+      validation.warnings.length > 0 ? `Validated (0 errors, ${validation.warnings.length} warnings above) \u2014 ${wroteOrWould}.` : `Validated clean \u2014 ${wroteOrWould}.`
+    );
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+function runBootstrap(argv) {
+  const [sub, ...rest] = argv;
+  if (sub === void 0 || sub === "-h" || sub === "--help" || sub === "help") {
+    console.log(USAGE12);
+    process.exit(0);
+  }
+  switch (sub) {
+    case "corpus":
+      runCorpus(rest);
+      return;
+    case "plan":
+      runPlan(rest);
+      return;
+    case "slice":
+      runSlice(rest);
+      return;
+    case "index":
+      runIndex(rest);
+      return;
+    case "merge":
+      runMerge(rest);
+      return;
+    default:
+      console.error(`Unknown bootstrap subcommand: ${sub}
+
+${USAGE12}`);
+      process.exit(1);
+  }
+}
+
+// src/index.ts
+var USAGE13 = `arkaik \u2014 CLI for Arkaik project bundles
+
+Usage:
+  arkaik <command> [options]
+
+Commands:
+  init [options]              Scaffold docs/arkaik/, install the agent skill (--update to upgrade).
+  validate [path]             Validate a project bundle (folds in a journal.jsonl sidecar).
+  log [--node <id>] [path]    Print the journal: project changelog, or one node's timeline.
+  release <version> [path]    Tag a release (append release.tagged) and draft its notes.
+  deliverable <title> [path]  Record a deliverable (append deliverable.shipped).
+  sync [options] [path]       Mirror external ref status (GitHub issues/PRs) into node refs.
+  pack [options] [path]       Produce a single self-contained interchange bundle (embeds the journal).
+  open [options] [path]       Validate, then hand off the packed bundle to arkaik.app import.
+  push [options] [path]       Validate, pack (journal stripped), and publish to Publik.
+                               --delete <id> --key <owner_key> removes a snapshot.
+  link [options] [path]       Point this repo at a hosted project so an agent can edit it.
+                               --list shows the projects your token can reach.
+  restore [options] [path]    Replace the linked hosted project's bundle + journal (backs up first).
+  bootstrap <sub> [options]   One-time onboarding: mine, plan, slice, merge a map from a repo.
+
+Options:
+  -h, --help        Show this help.
+  -v, --version     Print the version.
+
+Run "arkaik <command> --help" for command-specific help.`;
+var VERSION = "0.1.1";
+function main(argv) {
+  const [command, ...rest] = argv;
+  if (command === void 0 || command === "--help" || command === "-h" || command === "help") {
+    console.log(USAGE13);
+    process.exit(0);
+  }
+  if (command === "--version" || command === "-v" || command === "version") {
+    console.log(VERSION);
+    process.exit(0);
+  }
+  switch (command) {
+    case "init":
+      runInit(rest);
+      return;
+    case "validate":
+      runValidate(rest);
+      return;
+    case "log":
+      runLog(rest);
+      return;
+    case "release":
+      runRelease(rest);
+      return;
+    case "deliverable":
+      runDeliverable(rest);
+      return;
+    case "sync":
+      runSyncCli(rest);
+      return;
+    case "pack":
+      runPackCli(rest);
+      return;
+    case "open":
+      runOpenCli(rest);
+      return;
+    case "push":
+      runPushCli(rest);
+      return;
+    case "link":
+      runLinkCli(rest);
+      return;
+    case "restore":
+      runRestoreCli(rest);
+      return;
+    case "bootstrap":
+      runBootstrap(rest);
       return;
     default:
       console.error(`Unknown command: ${command}
 `);
-      console.error(USAGE10);
+      console.error(USAGE13);
       process.exit(1);
   }
 }