@hobocode/thought-layer 0.6.1 → 0.8.5

package/dist/tl.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // bin/tl.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 
 // core/scoring.ts
 var CONFIDENCE_GOAL = 0.85;
@@ -72,6 +72,21 @@ var KIT_WRITTEN_QIDS = [
 // core/progress.ts
 var APP = "thought-layer";
 var PROGRESS_FORMAT = 2;
+var KNOWN_STATE_KEYS = [
+  "version",
+  "answers",
+  "feedback",
+  "bizModel",
+  "grill",
+  "assets",
+  "research",
+  "swot",
+  "prd",
+  "naming",
+  "brand",
+  "governance",
+  "kit"
+];
 function emptyState() {
   return {
     version: 2,
@@ -85,6 +100,7 @@ function emptyState() {
     prd: null,
     naming: null,
     brand: null,
+    governance: null,
     kit: null
   };
 }
@@ -101,12 +117,12 @@ function parseProgress(text) {
   const rawFormat = payload["format"];
   const formatNewer = typeof rawFormat === "number" && rawFormat > PROGRESS_FORMAT;
   const s = payload["state"] && typeof payload["state"] === "object" ? payload["state"] : {};
-  const obj = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+  const obj3 = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
   const state = {
     ...s,
     version: 2,
-    answers: obj(s["answers"]),
-    feedback: obj(s["feedback"]),
+    answers: obj3(s["answers"]),
+    feedback: obj3(s["feedback"]),
     bizModel: s["bizModel"] ?? null,
     grill: s["grill"] ?? null,
     assets: s["assets"] ?? null,
@@ -115,6 +131,7 @@ function parseProgress(text) {
     prd: s["prd"] ?? null,
     naming: s["naming"] ?? null,
     brand: s["brand"] ?? null,
+    governance: s["governance"] ?? null,
     kit: s["kit"] ?? null
   };
   return {
@@ -139,6 +156,7 @@ function buildProgress(state, writer, exportedAt) {
     prd,
     naming,
     brand,
+    governance,
     kit,
     version: _v,
     exportedAt: _ea,
@@ -163,6 +181,7 @@ function buildProgress(state, writer, exportedAt) {
       prd: prd ?? null,
       naming: naming ?? null,
       brand: brand ?? null,
+      governance: governance ?? null,
       kit: kit ?? null,
       ...rest
     }
@@ -245,7 +264,7 @@ function summarizeState(state) {
     if (s === "green" || s === "yellow" || s === "red") byStatus[s]++;
     else byStatus.ungraded++;
   }
-  const artifacts = ["bizModel", "grill", "assets", "research", "swot", "prd", "naming", "brand"].filter((k) => state[k] != null);
+  const artifacts = ["bizModel", "grill", "assets", "research", "swot", "prd", "naming", "brand", "governance"].filter((k) => state[k] != null);
   const kit = state.kit && typeof state.kit === "object" ? state.kit : null;
   return {
     answered,
@@ -315,11 +334,11 @@ function saveStateFile(state, opts) {
 }
 
 // core/state-ops.ts
-var ARTIFACT_KEYS = ["bizModel", "grill", "assets", "research", "swot", "prd", "naming", "brand"];
+var ARTIFACT_KEYS = ["bizModel", "grill", "assets", "research", "swot", "prd", "naming", "brand", "governance"];
 var END_STATES = ["open", "pass", "setAside"];
 function applyStateOp(p, ctx) {
   const { ts, exportedAt } = ctx;
-  const fail = (message) => ({ ok: false, message, details: {} });
+  const fail4 = (message) => ({ ok: false, message, details: {} });
   try {
     if (p.op === "list") {
       const files = listStateFiles(p.path);
@@ -328,8 +347,8 @@ function applyStateOp(p, ctx) {
       }
       const rows = files.map((f) => {
         try {
-          const sum = summarizeState(loadStateFile(f.path).state);
-          return { name: f.name, path: f.path, answered: sum.answered, artifacts: sum.artifacts };
+          const sum2 = summarizeState(loadStateFile(f.path).state);
+          return { name: f.name, path: f.path, answered: sum2.answered, artifacts: sum2.artifacts };
         } catch {
           return { name: f.name, path: f.path, answered: 0, artifacts: [], unreadable: true };
         }
@@ -342,24 +361,24 @@ Pick one with --path .thought-layer/<name>.json, or set ${STATE_ENV} for the ses
     const loaded = loadStateFile(p.path);
     const save = (next) => saveStateFile(next, { target: p.path, ts, exportedAt }).path;
     if (p.op === "read" || p.op === "export") {
-      const sum = summarizeState(loaded.state);
+      const sum2 = summarizeState(loaded.state);
       let message;
       if (loaded.exists) {
-        message = `Loaded ${loaded.path}: ${sum.answered}/${sum.totalAnswerable} answered (${sum.byStatus.green} green, ${sum.byStatus.yellow} yellow, ${sum.byStatus.red} red), artifacts: ${sum.artifacts.join(", ") || "none"}. Resume at ${sum.cursor ? `stage ${sum.cursor.backboneStage ?? "?"} (${sum.cursor.phase ?? "?"})` : "the beginning"}.`;
+        message = `Loaded ${loaded.path}: ${sum2.answered}/${sum2.totalAnswerable} answered (${sum2.byStatus.green} green, ${sum2.byStatus.yellow} yellow, ${sum2.byStatus.red} red), artifacts: ${sum2.artifacts.join(", ") || "none"}. Resume at ${sum2.cursor ? `stage ${sum2.cursor.backboneStage ?? "?"} (${sum2.cursor.phase ?? "?"})` : "the beginning"}.`;
       } else {
         const others = listStateFiles().filter((f) => f.path !== loaded.path);
         const hint = others.length ? ` Other state files here: ${others.map((f) => f.name).join(", ")} (pick one with --path, or 'tl list').` : "";
         message = `No state file yet at ${loaded.path}.${hint} Start a fresh run; it will be created on first write.`;
       }
-      return { ok: true, message, details: { path: loaded.path, exists: loaded.exists, summary: sum, state: loaded.state } };
+      return { ok: true, message, details: { path: loaded.path, exists: loaded.exists, summary: sum2, state: loaded.state } };
     }
     if (p.op === "answer") {
-      if (!p.qId || typeof p.value !== "string") return fail("answer needs a qId and a string value.");
+      if (!p.qId || typeof p.value !== "string") return fail4("answer needs a qId and a string value.");
       const path = save(setAnswer(loaded.state, p.qId, p.value, ts));
       return { ok: true, message: `Recorded answer for "${p.qId}" and saved ${path}.`, details: { path, qId: p.qId } };
     }
     if (p.op === "feedback") {
-      if (!p.qId || !p.personas?.length) return fail("feedback needs a qId and at least one persona.");
+      if (!p.qId || !p.personas?.length) return fail4("feedback needs a qId and at least one persona.");
       const endState = END_STATES.includes(p.endState || "") ? p.endState : "open";
       const mode = p.mode || (p.personas.length > 1 ? "panel" : p.personas[0].persona);
       const entry = buildFeedbackEntry({ mode, personas: p.personas, endState, round: p.round, ts });
@@ -376,24 +395,24 @@ Pick one with --path .thought-layer/<name>.json, or set ${STATE_ENV} for the ses
     }
     if (p.op === "artifact") {
       const key = p.artifact;
-      if (!ARTIFACT_KEYS.includes(key)) return fail(`artifact needs a key in: ${ARTIFACT_KEYS.join(", ")}.`);
-      if (p.value == null) return fail("artifact needs a value object.");
+      if (!ARTIFACT_KEYS.includes(key)) return fail4(`artifact needs a key in: ${ARTIFACT_KEYS.join(", ")}.`);
+      if (p.value == null) return fail4("artifact needs a value object.");
       const path = save(setArtifact(loaded.state, key, normalizeArtifactValue(key, p.value), ts));
       return { ok: true, message: `Stored ${key} artifact and saved ${path}.`, details: { path, artifact: key } };
     }
     if (p.op === "cursor") {
-      if (!p.cursor) return fail("cursor needs a cursor object.");
+      if (!p.cursor) return fail4("cursor needs a cursor object.");
       const path = save(setCursor(loaded.state, p.cursor, ts));
       return { ok: true, message: `Saved resume cursor (stage ${p.cursor.backboneStage ?? "?"}, ${p.cursor.phase ?? "?"}) to ${path}.`, details: { path } };
     }
     if (p.op === "park") {
-      if (!p.key || !p.note) return fail("park needs a key and a note.");
+      if (!p.key || !p.note) return fail4("park needs a key and a note.");
       const path = save(parkNote(loaded.state, p.key, p.note, ts));
       return { ok: true, message: `Parked a note under "${p.key}" and saved ${path}.`, details: { path, key: p.key } };
     }
-    return fail(`Unknown op "${p.op}". Use read, answer, feedback, artifact, cursor, park, or export.`);
+    return fail4(`Unknown op "${p.op}". Use read, answer, feedback, artifact, cursor, park, or export.`);
   } catch (e) {
-    return fail(`tl_state error: ${e.message}`);
+    return fail4(`tl_state error: ${e.message}`);
   }
 }
 
@@ -405,26 +424,26 @@ import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2, resolve
 var esc = (s) => String(s ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 var fam = (f) => f.trim().replace(/\s+/g, "+");
 function extractScaffoldSpec(state) {
-  const obj = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
-  const str = (v) => typeof v === "string" ? v : "";
-  const brand = obj(state.brand);
-  const guide = obj(brand["guide"]);
+  const obj3 = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+  const str4 = (v) => typeof v === "string" ? v : "";
+  const brand = obj3(state.brand);
+  const guide = obj3(brand["guide"]);
   const answers = state.answers || {};
   const palette = Array.isArray(guide["palette"]) ? guide["palette"] : [];
   const role = (re, fb) => {
     const m = palette.find((p) => p?.name && new RegExp(re, "i").test(p.name));
     return m?.hex || fb;
   };
-  const typography = obj(guide["typography"]);
-  const fontOf = (slot, fb) => str(obj(slot)["family"]) || fb;
-  const voice = obj(guide["voice"]);
+  const typography = obj3(guide["typography"]);
+  const fontOf = (slot, fb) => str4(obj3(slot)["family"]) || fb;
+  const voice = obj3(guide["voice"]);
   const logos = Array.isArray(brand["logos"]) ? brand["logos"] : [];
   const chosen = logos.find((l) => l?.id === brand["chosenLogoId"]) || logos[0];
   return {
-    brandName: str(guide["brandName"]) || "Your Product",
-    tagline: str(guide["tagline"]),
-    pitch: str(answers["pitch"]) || str(answers["what-statement"]),
-    positioning: str(guide["positioning"]),
+    brandName: str4(guide["brandName"]) || "Your Product",
+    tagline: str4(guide["tagline"]),
+    pitch: str4(answers["pitch"]) || str4(answers["what-statement"]),
+    positioning: str4(guide["positioning"]),
     personality: Array.isArray(guide["personality"]) ? guide["personality"].filter((x) => typeof x === "string") : [],
     palette: {
       primary: role("primary", palette[0]?.hex || "#1f3a5f"),
@@ -435,9 +454,9 @@ function extractScaffoldSpec(state) {
     },
     displayFont: fontOf(typography["display"], "Inter"),
     bodyFont: fontOf(typography["body"], "Inter"),
-    voiceTone: str(voice["tone"]),
+    voiceTone: str4(voice["tone"]),
     logoSvg: chosen?.svg || void 0,
-    pricing: str(answers["pricing-model"]) || void 0
+    pricing: str4(answers["pricing-model"]) || void 0
   };
 }
 function indexHtml(spec, opts) {
@@ -734,11 +753,11 @@ function dedupeSortEnv(envVars) {
 function normalizeDatabase(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
   const r = raw;
-  const str = (v, fb) => typeof v === "string" && v.trim() ? v.trim() : fb;
+  const str4 = (v, fb) => typeof v === "string" && v.trim() ? v.trim() : fb;
   return {
-    provider: str(r["provider"], "neon"),
-    schemaFile: str(r["schemaFile"], "schema.sql"),
-    envVar: str(r["envVar"], "DATABASE_URL")
+    provider: str4(r["provider"], "neon"),
+    schemaFile: str4(r["schemaFile"], "schema.sql"),
+    envVar: str4(r["envVar"], "DATABASE_URL")
   };
 }
 function normalizeEnvVars(raw) {
@@ -769,15 +788,15 @@ function normalizeBackendMeta(raw) {
   const database = normalizeDatabase(r["database"]);
   const hasFunctionsDir = typeof r["functionsDir"] === "string" && r["functionsDir"].trim().length > 0;
   if (kind === null && envVars.length === 0 && database === null && !hasFunctionsDir) return null;
-  const str = (v, fb) => typeof v === "string" && v.trim() ? v.trim() : fb;
+  const str4 = (v, fb) => typeof v === "string" && v.trim() ? v.trim() : fb;
   return {
     backendKind: kind ?? "serverless",
-    functionsDir: str(r["functionsDir"], "netlify/functions"),
-    runtime: str(r["runtime"], "nodejs20.x"),
-    nodeVersion: str(r["nodeVersion"], "20"),
+    functionsDir: str4(r["functionsDir"], "netlify/functions"),
+    runtime: str4(r["runtime"], "nodejs20.x"),
+    nodeVersion: str4(r["nodeVersion"], "20"),
     envVars,
     database,
-    guide: str(r["guide"], "BACKEND.md")
+    guide: str4(r["guide"], "BACKEND.md")
   };
 }
 var SECRET_NAME_RE = /(KEY|SECRET|TOKEN|PASSWORD|PASSWD|DATABASE_URL|DB_URL|CONN|DSN|CREDENTIAL|PRIVATE|AUTH)/;
@@ -1172,10 +1191,10 @@ Static deploy: the front end is live. This build also declares a backend that th
     return `${lead} To run the backend, follow ${guide}: provision Neon Postgres, set ${envList} in your host environment, then run netlify deploy with the functions present.`;
   })() : "";
   const token = process.env.NETLIFY_AUTH_TOKEN || process.env.NETLIFY_TOKEN || "";
-  const writeRecord = (rec) => {
+  const writeRecord = (rec2) => {
     const recPath = join4(dirname3(stateFile), "deploy.json");
     mkdirSync3(dirname3(recPath), { recursive: true });
-    writeFileSync4(recPath, JSON.stringify(rec, null, 2) + "\n");
+    writeFileSync4(recPath, JSON.stringify(rec2, null, 2) + "\n");
     return recPath;
   };
   if (opts.dryRun) {
@@ -1447,6 +1466,1747 @@ ${notes.join("\n")}` : ""}` + (!url ? `
   };
 }
 
+// core/sync-io.ts
+import { spawnSync as spawnSync3 } from "child_process";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync3, readdirSync as readdirSync3, writeFileSync as writeFileSync5 } from "fs";
+import { homedir } from "os";
+import { dirname as dirname4, isAbsolute as isAbsolute3, join as join5, resolve as resolve4 } from "path";
+
+// core/sync.ts
+function slugify(name) {
+  return String(name || "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40).replace(/-+$/g, "");
+}
+function emptySyncConfig() {
+  return { schema: 1, workspaces: [] };
+}
+var str = (v, fb = "") => typeof v === "string" ? v : fb;
+function parseSyncConfig(text) {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return emptySyncConfig();
+  }
+  const list = Array.isArray(raw["workspaces"]) ? raw["workspaces"] : [];
+  const workspaces = [];
+  for (const w of list) {
+    if (!w || typeof w !== "object") continue;
+    const r = w;
+    const cloneDir = str(r["cloneDir"]).trim();
+    if (!cloneDir) continue;
+    const ws = {
+      name: str(r["name"]).trim() || cloneDir,
+      repo: str(r["repo"]).trim(),
+      defaultBranch: str(r["defaultBranch"]).trim() || "main",
+      cloneDir
+    };
+    const active = str(r["activeSession"]).trim();
+    if (active) ws.activeSession = active;
+    workspaces.push(ws);
+  }
+  const cfg = { schema: 1, workspaces };
+  const aw = str(raw["activeWorkspace"]).trim();
+  if (aw) cfg.activeWorkspace = aw;
+  return cfg;
+}
+function serializeSyncConfig(cfg) {
+  return JSON.stringify({ schema: 1, activeWorkspace: cfg.activeWorkspace, workspaces: cfg.workspaces }, null, 2) + "\n";
+}
+function selectWorkspace(cfg, name) {
+  if (name) return cfg.workspaces.find((w) => w.name === name) || null;
+  if (cfg.activeWorkspace) {
+    const w = cfg.workspaces.find((ws) => ws.name === cfg.activeWorkspace);
+    if (w) return w;
+  }
+  return cfg.workspaces.length === 1 ? cfg.workspaces[0] : null;
+}
+function defaultSessionsDir(home) {
+  return `${home}/.thought-layer/sessions`;
+}
+function parseGitStatus(out) {
+  const lines = String(out || "").split("\n").filter((l) => l.length > 0);
+  let branch = null;
+  let ahead = 0;
+  let behind = 0;
+  const files = [];
+  for (const line of lines) {
+    if (line.startsWith("## ")) {
+      const header = line.slice(3);
+      branch = header.split(/\.\.\.| /)[0] || null;
+      const a = header.match(/ahead (\d+)/);
+      const b = header.match(/behind (\d+)/);
+      if (a) ahead = Number(a[1]);
+      if (b) behind = Number(b[1]);
+    } else {
+      files.push(line.slice(3).trim());
+    }
+  }
+  return { branch, ahead, behind, dirty: files.length > 0, files };
+}
+
+// core/merge.ts
+var num = (v) => typeof v === "number" && !Number.isNaN(v) ? v : 0;
+var genAt = (v) => v && typeof v === "object" ? num(v["generatedAt"]) : 0;
+var jsonEq = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+var rec = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+function mergeProgressStates(ours, theirs, opts) {
+  const coarse = [];
+  const oursNewer = opts.oursTs > opts.theirsTs;
+  const answers = {};
+  const oa = rec(ours.answers);
+  const ta = rec(theirs.answers);
+  for (const k of /* @__PURE__ */ new Set([...Object.keys(oa), ...Object.keys(ta)])) {
+    const inO = k in oa;
+    const inT = k in ta;
+    if (inO && !inT) answers[k] = oa[k];
+    else if (!inO && inT) answers[k] = ta[k];
+    else if (jsonEq(oa[k], ta[k])) answers[k] = oa[k];
+    else {
+      answers[k] = oursNewer ? oa[k] : ta[k];
+      coarse.push(`answers.${k}`);
+    }
+  }
+  const feedback = {};
+  const of = rec(ours.feedback);
+  const tf = rec(theirs.feedback);
+  for (const k of /* @__PURE__ */ new Set([...Object.keys(of), ...Object.keys(tf)])) {
+    const o = of[k];
+    const t = tf[k];
+    if (o != null && t == null) feedback[k] = o;
+    else if (o == null && t != null) feedback[k] = t;
+    else if (jsonEq(o, t)) feedback[k] = o;
+    else {
+      const oR = num(rec(o)["round"]);
+      const tR = num(rec(t)["round"]);
+      const oTs = num(rec(o)["ts"]);
+      const tTs = num(rec(t)["ts"]);
+      const pickOurs = oR !== tR ? oR > tR : oTs !== tTs ? oTs > tTs : oursNewer;
+      feedback[k] = pickOurs ? o : t;
+      coarse.push(`feedback.${k}`);
+    }
+  }
+  const artifact = (key) => {
+    const o = ours[key];
+    const t = theirs[key];
+    if (o == null && t == null) return null;
+    if (o != null && t == null) return o;
+    if (o == null && t != null) return t;
+    if (jsonEq(o, t)) return o;
+    const og = genAt(o);
+    const tg = genAt(t);
+    const pickOurs = og !== tg ? og > tg : oursNewer;
+    coarse.push(key);
+    return pickOurs ? o : t;
+  };
+  const merged = {
+    version: 2,
+    answers,
+    feedback,
+    bizModel: artifact("bizModel"),
+    grill: artifact("grill"),
+    assets: artifact("assets"),
+    research: artifact("research"),
+    swot: artifact("swot"),
+    prd: artifact("prd"),
+    naming: artifact("naming"),
+    brand: artifact("brand"),
+    governance: artifact("governance"),
+    kit: mergeKit(ours.kit, theirs.kit, oursNewer)
+  };
+  for (const src of oursNewer ? [theirs, ours] : [ours, theirs]) {
+    for (const k of Object.keys(src)) {
+      if (!KNOWN_STATE_KEYS.includes(k)) merged[k] = src[k];
+    }
+  }
+  return { state: merged, coarse: Array.from(new Set(coarse)).sort() };
+}
+function mergeKit(o, t, oursNewer) {
+  if (!o && !t) return null;
+  if (o && !t) return o;
+  if (!o && t) return t;
+  const oo = o;
+  const tt = t;
+  const modulesRun = Array.from(/* @__PURE__ */ new Set([...oo.modulesRun || [], ...tt.modulesRun || []]));
+  const parked = {};
+  for (const src of [oo.parked || {}, tt.parked || {}]) {
+    for (const [k, v] of Object.entries(src)) {
+      parked[k] = Array.from(/* @__PURE__ */ new Set([...parked[k] || [], ...Array.isArray(v) ? v : []]));
+    }
+  }
+  const newer = oursNewer ? oo : tt;
+  const older = oursNewer ? tt : oo;
+  const panelMeta = { ...older.panelMeta || {}, ...newer.panelMeta || {} };
+  const kit = {
+    schema: Math.max(num(oo.schema) || 1, num(tt.schema) || 1),
+    updatedAt: Math.max(num(oo.updatedAt), num(tt.updatedAt))
+  };
+  if (modulesRun.length) kit.modulesRun = modulesRun;
+  if (Object.keys(parked).length) kit.parked = parked;
+  const cursor = newer.cursor ?? older.cursor;
+  if (cursor) kit.cursor = cursor;
+  if (Object.keys(panelMeta).length) kit.panelMeta = panelMeta;
+  return kit;
+}
+
+// core/sync-io.ts
+function hasGit() {
+  try {
+    return spawnSync3("git", ["--version"], { encoding: "utf8", timeout: 15e3 }).status === 0;
+  } catch {
+    return false;
+  }
+}
+function hasGh() {
+  try {
+    return spawnSync3("gh", ["--version"], { encoding: "utf8", timeout: 15e3 }).status === 0;
+  } catch {
+    return false;
+  }
+}
+function ghAuthed() {
+  try {
+    return spawnSync3("gh", ["auth", "status"], { encoding: "utf8", timeout: 2e4 }).status === 0;
+  } catch {
+    return false;
+  }
+}
+function syncConfigPath() {
+  return process.env["THOUGHT_LAYER_SYNC_CONFIG"] || join5(homedir(), ".thought-layer", "sync.json");
+}
+function loadConfig() {
+  const p = syncConfigPath();
+  if (!existsSync4(p)) return emptySyncConfig();
+  try {
+    return parseSyncConfig(readFileSync3(p, "utf8"));
+  } catch {
+    return emptySyncConfig();
+  }
+}
+function saveConfig(cfg) {
+  const p = syncConfigPath();
+  mkdirSync4(dirname4(p), { recursive: true });
+  writeFileSync5(p, serializeSyncConfig(cfg));
+}
+function git(dir, args, timeout = 12e4) {
+  const r = spawnSync3("git", dir ? ["-C", dir, ...args] : args, { encoding: "utf8", timeout });
+  return { status: r.status ?? 1, out: r.stdout || "", err: r.stderr || "" };
+}
+function isGitRepo(dir) {
+  return existsSync4(join5(dir, ".git")) && git(dir, ["rev-parse", "--is-inside-work-tree"]).status === 0;
+}
+function dirNonEmpty(dir) {
+  try {
+    return existsSync4(dir) && readdirSync3(dir).length > 0;
+  } catch {
+    return false;
+  }
+}
+var absDir = (d, cwd = process.cwd()) => isAbsolute3(d) ? d : resolve4(cwd, d);
+var GITATTRIBUTES = `# The kit reconciles session JSON itself; never let git textually merge it
+# (which would corrupt the envelope). -merge keeps our copy in the working tree
+# on a conflict; the kit then rebuilds the merged result from the clean blobs.
+.thought-layer/*.json -merge
+`;
+var GITIGNORE = `# A Thought Layer sessions repo holds session state only. Built product
+# artifacts and secrets never sync here.
+build.json
+deploy.json
+*.local
+.env
+.env.*
+!.env.example
+dist/
+.netlify/
+node_modules/
+# Delivered artifacts (tl artifacts) ARE intentionally tracked, even though the
+# same filenames are ignored elsewhere in the tree.
+!artifacts/
+!artifacts/**
+`;
+var README = `# Thought Layer sessions
+
+This private repo is the home for Thought Layer session files. Each session is one
+file under \`.thought-layer/<name>.json\` (the portable validation and design state).
+Use the kit to work with them:
+
+    tl sync open --name <session>     pull and resume a session
+    tl sync save --name <session>     snapshot the current state, commit, and push
+    tl sync list                      list the sessions in this repo
+
+Collaboration is handled by GitHub: add a collaborator to this repo in its GitHub
+settings, and they can clone it and run the kit against the same sessions.
+The kit reconciles concurrent edits itself (newest wins per field, conflicts are
+reported), so git never has to merge the JSON by hand.
+`;
+function writeCloneScaffold(cloneDir) {
+  mkdirSync4(join5(cloneDir, STATE_DIR), { recursive: true });
+  const put = (name, body) => {
+    const p = join5(cloneDir, name);
+    if (!existsSync4(p)) writeFileSync5(p, body);
+  };
+  put(".gitattributes", GITATTRIBUTES);
+  put(".gitignore", GITIGNORE);
+  put("README.md", README);
+}
+var ok = (message, details = {}) => ({ ok: true, message, details });
+var fail = (message, details = {}) => ({ ok: false, message, details });
+var collaboratorPointer = (repo) => `To collaborate, add people to ${repo} in its GitHub settings (Settings, Collaborators). They clone it and run the kit; the kit never changes GitHub permissions.`;
+async function runSync(opts, ctx) {
+  if (!hasGit()) {
+    return fail("git is not installed. Install git, then re-run. The sync feature stores your session files in your own private GitHub repo.", { needs: "git" });
+  }
+  try {
+    switch (opts.op) {
+      case "init":
+        return syncInit(opts);
+      case "save":
+        return syncSave(opts, ctx);
+      case "list":
+        return syncList(opts);
+      case "open":
+        return syncOpen(opts, ctx);
+      case "pull":
+        return syncPull(opts, ctx);
+      case "push":
+        return syncPush(opts);
+      case "status":
+        return syncStatus(opts);
+      default:
+        return fail(`Unknown sync op "${opts.op}". Use one of: init, save, list, open, pull, push, status.`);
+    }
+  } catch (e) {
+    return fail(`Sync ${opts.op} failed: ${e.message}`);
+  }
+}
+function resolveWorkspace(opts, cfg) {
+  if (opts.dir && opts.dir.trim()) return { cloneDir: absDir(opts.dir), ws: null };
+  const env = process.env["THOUGHT_LAYER_SESSIONS_DIR"];
+  if (env && env.trim()) return { cloneDir: absDir(env), ws: null };
+  const ws = selectWorkspace(cfg, opts.workspace);
+  if (ws) return { cloneDir: ws.cloneDir, ws };
+  return { cloneDir: defaultSessionsDir(homedir()), ws: null };
+}
+function syncInit(opts) {
+  const repo = (opts.repo || "").trim();
+  if (!repo) return fail("Pass the private repo to use: tl sync init --repo <owner/name or url> [--name <label>] [--dir <path>].");
+  const home = homedir();
+  const label = (opts.name || "").trim();
+  const cloneDir = opts.dir ? absDir(opts.dir) : !label || slugify(label) === "personal" ? defaultSessionsDir(home) : join5(home, ".thought-layer", `sessions-${slugify(label)}`);
+  if (dirNonEmpty(cloneDir)) {
+    if (isGitRepo(cloneDir)) return fail(`${cloneDir} is already a git repo. It looks initialized; use tl sync list or pick another --dir.`, { cloneDir });
+    return fail(`${cloneDir} already exists and is not empty. Pick another --dir or remove it first.`, { cloneDir });
+  }
+  const isOwnerName = /^[\w.-]+\/[\w.-]+$/.test(repo);
+  const useGh = isOwnerName && hasGh() && ghAuthed();
+  mkdirSync4(dirname4(cloneDir), { recursive: true });
+  let cloned = false;
+  if (useGh) {
+    cloned = spawnSync3("gh", ["repo", "clone", repo, cloneDir], { encoding: "utf8", timeout: 18e4 }).status === 0;
+    if (!cloned) {
+      const created = spawnSync3("gh", ["repo", "create", repo, "--private"], { encoding: "utf8", timeout: 18e4 });
+      if (created.status !== 0) {
+        return fail(`Could not clone or create ${repo} with gh. Create the private repo on GitHub yourself, then re-run. gh said: ${(created.stderr || "").slice(0, 300)}`);
+      }
+      cloned = spawnSync3("gh", ["repo", "clone", repo, cloneDir], { encoding: "utf8", timeout: 18e4 }).status === 0;
+    }
+  } else {
+    const url = isOwnerName ? `https://github.com/${repo}.git` : repo;
+    cloned = git(null, ["clone", url, cloneDir], 18e4).status === 0;
+    if (!cloned) {
+      return fail(
+        isOwnerName && !hasGh() ? `Could not clone https://github.com/${repo}.git. Create the private repo on GitHub first (or install gh and run gh auth login so the kit can create it), then re-run.` : `Could not clone ${repo}. Check the repo path or URL and your git access, then re-run.`,
+        { repo, cloneDir }
+      );
+    }
+  }
+  writeCloneScaffold(cloneDir);
+  git(cloneDir, ["add", "-A"]);
+  const committed = git(cloneDir, ["commit", "-m", "Initialize Thought Layer sessions"]).status === 0;
+  let branch = git(cloneDir, ["rev-parse", "--abbrev-ref", "HEAD"]).out.trim() || "main";
+  if (committed && branch === "HEAD") {
+    git(cloneDir, ["branch", "-M", "main"]);
+    branch = "main";
+  }
+  let pushed = false;
+  if (committed) pushed = git(cloneDir, ["push", "-u", "origin", branch]).status === 0;
+  const cfg = loadConfig();
+  const wsName = label || "personal";
+  const ws = { name: wsName, repo, defaultBranch: branch, cloneDir };
+  cfg.workspaces = [...cfg.workspaces.filter((w) => w.cloneDir !== cloneDir && w.name !== wsName), ws];
+  cfg.activeWorkspace = wsName;
+  saveConfig(cfg);
+  return ok(
+    `Initialized the "${wsName}" sessions workspace at ${cloneDir} (repo ${repo}).${committed ? pushed ? " Pushed the initial commit." : " Committed locally; push it once your git access is set." : " The repo already had content; left it as is."}
+${collaboratorPointer(repo)}
+Save your first session with: tl sync save --name <name>${label ? ` --workspace ${wsName}` : ""}.`,
+    { cloneDir, repo, workspace: wsName, branch, committed, pushed }
+  );
+}
+function syncSave(opts, ctx) {
+  const cfg = loadConfig();
+  const { cloneDir, ws } = resolveWorkspace(opts, cfg);
+  if (!isGitRepo(cloneDir)) return fail(`No sessions workspace at ${cloneDir}. Run tl sync init --repo <owner/name> first.`, { cloneDir });
+  const slug = slugify(opts.name || ws?.activeSession?.replace(/\.json$/, "") || "");
+  if (!slug) return fail("Name the session: tl sync save --name <name> (for example photobooth, peptide, blogging).");
+  const targetPath = join5(cloneDir, STATE_DIR, `${slug}.json`);
+  const existed = existsSync4(targetPath);
+  const useExplicit = !!(opts.path && opts.path.trim() || (process.env["THOUGHT_LAYER_STATE"] || "").trim());
+  const loadTarget = useExplicit ? opts.path : existed ? targetPath : opts.path;
+  const source = loadStateFile(loadTarget).state;
+  saveStateFile(source, { target: targetPath, ts: ctx.ts, exportedAt: ctx.exportedAt });
+  git(cloneDir, ["add", "-A"]);
+  const msg = opts.message || `${existed ? "Update" : "Save"} session ${slug}`;
+  const commit = git(cloneDir, ["commit", "-m", msg]);
+  const committed = commit.status === 0;
+  let pushed = false;
+  let pushNote = "";
+  if (committed && !opts.noPush) {
+    const p = git(cloneDir, ["push"]);
+    pushed = p.status === 0;
+    if (!pushed) pushNote = ` Could not push (${(p.err || "").split("\n")[0] || "see git output"}); commit is local, run tl sync push when ready.`;
+  }
+  if (ws) {
+    ws.activeSession = `${slug}.json`;
+    saveConfig(cfg);
+  }
+  return ok(
+    `${existed ? "Updated" : "Saved"} session ${slug} in ${cloneDir}.${committed ? opts.noPush ? " Committed locally (no push)." : pushed ? " Committed and pushed." : pushNote : " Nothing changed since the last save."}`,
+    { cloneDir, session: `${slug}.json`, path: targetPath, committed, pushed }
+  );
+}
+function syncList(opts) {
+  const cfg = loadConfig();
+  const { cloneDir } = resolveWorkspace(opts, cfg);
+  if (!isGitRepo(cloneDir)) return fail(`No sessions workspace at ${cloneDir}. Run tl sync init --repo <owner/name> first.`, { cloneDir });
+  const files = listStateFiles(cloneDir);
+  if (!files.length) return ok(`No sessions yet in ${cloneDir}. Create one with tl sync save --name <name>.`, { cloneDir, sessions: [] });
+  const rows = files.map((f) => {
+    try {
+      const sum2 = summarizeState(loadStateFile(f.path).state);
+      return { name: f.name, path: f.path, answered: sum2.answered, artifacts: sum2.artifacts };
+    } catch {
+      return { name: f.name, path: f.path, answered: 0, artifacts: [], unreadable: true };
+    }
+  });
+  const lines = rows.map((r) => `  ${r.name}: ${r.answered} answered${r.artifacts.length ? `, artifacts ${r.artifacts.join(", ")}` : ""}${"unreadable" in r ? " (unreadable)" : ""}`).join("\n");
+  return ok(`${files.length} session(s) in ${cloneDir}:
+${lines}
+Open one with tl sync open --name <name>.`, { cloneDir, sessions: rows });
+}
+function syncOpen(opts, ctx) {
+  const cfg = loadConfig();
+  const { cloneDir, ws } = resolveWorkspace(opts, cfg);
+  if (!isGitRepo(cloneDir)) return fail(`No sessions workspace at ${cloneDir}. Run tl sync init --repo <owner/name> first.`, { cloneDir });
+  const slug = slugify(opts.name || "");
+  if (!slug) return fail("Name the session to open: tl sync open --name <name>. List them with tl sync list.");
+  const pullResult = pullAndReconcile(cloneDir, ctx);
+  const targetPath = join5(cloneDir, STATE_DIR, `${slug}.json`);
+  if (!existsSync4(targetPath)) {
+    return fail(`No session "${slug}" in ${cloneDir} after pulling. List them with tl sync list, or create it with tl sync save --name ${slug}.`, { cloneDir });
+  }
+  if (ws) {
+    ws.activeSession = `${slug}.json`;
+    saveConfig(cfg);
+  }
+  return ok(
+    `Opened session ${slug} (pulled latest${pullResult.merged ? `, reconciled local and remote edits${pullResult.coarse.length ? ` (review: ${pullResult.coarse.join(", ")})` : ""}` : ""}).
+Work on it by pointing the kit at this file:
+  export THOUGHT_LAYER_STATE="${targetPath}"
+or pass --path "${targetPath}" to tl read/answer/artifact. Save with tl sync save --name ${slug}.`,
+    { cloneDir, session: `${slug}.json`, path: targetPath, merged: pullResult.merged, coarse: pullResult.coarse }
+  );
+}
+function pullAndReconcile(cloneDir, ctx) {
+  const branch = git(cloneDir, ["rev-parse", "--abbrev-ref", "HEAD"]).out.trim() || "main";
+  if (git(cloneDir, ["fetch", "origin", branch], 12e4).status !== 0) {
+    return { merged: false, coarse: [], note: "no remote branch to fetch yet" };
+  }
+  const local = git(cloneDir, ["rev-parse", "HEAD"]).out.trim();
+  const remote = git(cloneDir, ["rev-parse", `origin/${branch}`]).out.trim();
+  if (!remote || local === remote) return { merged: false, coarse: [], note: "up to date" };
+  const base = git(cloneDir, ["merge-base", local, remote]).out.trim();
+  if (base === remote) return { merged: false, coarse: [], note: "local is ahead; nothing to pull" };
+  if (base === local) {
+    git(cloneDir, ["merge", "--ff-only", `origin/${branch}`], 12e4);
+    return { merged: false, coarse: [], note: "fast-forward" };
+  }
+  const changed = git(cloneDir, ["diff", "--name-only", local, remote]).out.split("\n").map((s) => s.trim()).filter(Boolean);
+  git(cloneDir, ["merge", "--no-ff", "--no-commit", `origin/${branch}`], 12e4);
+  const coarseAll = [];
+  let reconciled = 0;
+  for (const rel of changed) {
+    if (rel.startsWith(`${STATE_DIR}/`) && rel.endsWith(".json")) {
+      const ours = readShow(cloneDir, local, rel);
+      const theirs = readShow(cloneDir, remote, rel);
+      if (ours && theirs) {
+        try {
+          const op = parseProgress(ours);
+          const tp = parseProgress(theirs);
+          const { state, coarse } = mergeProgressStates(op.state, tp.state, { oursTs: op.writer?.ts ?? 0, theirsTs: tp.writer?.ts ?? 0 });
+          writeFileSync5(join5(cloneDir, rel), serializeProgress(buildProgress(state, { kind: "kit", ts: ctx.ts }, ctx.exportedAt)));
+          coarseAll.push(...coarse);
+          reconciled++;
+        } catch {
+          if (theirs) writeFileSync5(join5(cloneDir, rel), theirs);
+        }
+      } else if (theirs && !ours) {
+        writeFileSync5(join5(cloneDir, rel), theirs);
+        reconciled++;
+      }
+    } else {
+      const theirs = readShow(cloneDir, remote, rel);
+      if (theirs !== null) writeFileSync5(join5(cloneDir, rel), theirs);
+    }
+    git(cloneDir, ["add", "--", rel]);
+  }
+  git(cloneDir, ["add", "-A"]);
+  git(cloneDir, ["commit", "--no-edit", "-m", "Reconcile sessions (kit merge)"]);
+  return { merged: reconciled > 0, coarse: Array.from(new Set(coarseAll)).sort(), note: `reconciled ${reconciled} session file(s)` };
+}
+function readShow(cloneDir, ref, rel) {
+  const r = git(cloneDir, ["show", `${ref}:${rel}`]);
+  return r.status === 0 ? r.out : null;
+}
+function syncPull(opts, ctx) {
+  const cfg = loadConfig();
+  const { cloneDir } = resolveWorkspace(opts, cfg);
+  if (!isGitRepo(cloneDir)) return fail(`No sessions workspace at ${cloneDir}. Run tl sync init first.`, { cloneDir });
+  const r = pullAndReconcile(cloneDir, ctx);
+  const push = git(cloneDir, ["push"]);
+  return ok(
+    `Pulled ${cloneDir}.${r.merged ? ` Reconciled local and remote edits${r.coarse.length ? ` (a coarse tie-break dropped one side for: ${r.coarse.join(", ")})` : ""}.` : " Already up to date or fast-forwarded."}${r.merged && push.status === 0 ? " Pushed the reconciliation." : ""}`,
+    { cloneDir, merged: r.merged, coarse: r.coarse }
+  );
+}
+function syncPush(opts) {
+  const cfg = loadConfig();
+  const { cloneDir } = resolveWorkspace(opts, cfg);
+  if (!isGitRepo(cloneDir)) return fail(`No sessions workspace at ${cloneDir}. Run tl sync init first.`, { cloneDir });
+  git(cloneDir, ["add", "-A"]);
+  const committed = git(cloneDir, ["commit", "-m", opts.message || "Sync sessions"]).status === 0;
+  const p = git(cloneDir, ["push"]);
+  if (p.status !== 0) return fail(`Push failed: ${(p.err || "").split("\n")[0] || "see git output"}. Pull first (tl sync pull), then push.`, { cloneDir });
+  return ok(`Pushed ${cloneDir}.${committed ? " Committed pending changes." : " Nothing new to commit; pushed any local commits."}`, { cloneDir, committed });
+}
+function syncStatus(opts) {
+  const cfg = loadConfig();
+  const { cloneDir, ws } = resolveWorkspace(opts, cfg);
+  if (!isGitRepo(cloneDir)) {
+    const known = cfg.workspaces.length ? ` Known workspaces: ${cfg.workspaces.map((w) => w.name).join(", ")}.` : "";
+    return fail(`No sessions workspace at ${cloneDir}. Run tl sync init --repo <owner/name> first.${known}`, { cloneDir, workspaces: cfg.workspaces });
+  }
+  const st = parseGitStatus(git(cloneDir, ["status", "--porcelain=v1", "--branch"]).out);
+  const sessions = listStateFiles(cloneDir).length;
+  return ok(
+    `Workspace ${ws?.name || "(by dir)"} at ${cloneDir}: ${sessions} session(s), branch ${st.branch || "?"}, ${st.ahead} ahead, ${st.behind} behind, ${st.dirty ? `${st.files.length} uncommitted change(s)` : "clean"}.${ws?.activeSession ? ` Active session: ${ws.activeSession}.` : ""}`,
+    { cloneDir, workspace: ws?.name || null, sessions, ...st }
+  );
+}
+
+// core/artifacts-io.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync6 } from "fs";
+import { basename, dirname as dirname5, join as join6 } from "path";
+
+// core/model.ts
+function num2(v, fallback = 0) {
+  const n = Number(v);
+  return Number.isFinite(n) ? n : fallback;
+}
+function sum(arr) {
+  return arr.reduce((a, b) => a + b, 0);
+}
+function computeProjection(assumptions) {
+  if (!assumptions?.parties?.length) return null;
+  const horizon = Math.min(Math.max(assumptions.horizonMonths || 36, 6), 120);
+  const parties = assumptions.parties;
+  const fixedCosts = assumptions.fixedCosts || [];
+  const oneTimeCosts = assumptions.oneTimeCosts || [];
+  const counts = {};
+  parties.forEach((p) => {
+    counts[p.id] = num2(p.startingCount);
+  });
+  const rows = [];
+  let cumulative = 0;
+  let breakEvenMonth = null;
+  let cumBreakEvenMonth = null;
+  for (let m = 1; m <= horizon; m++) {
+    const row = {
+      month: m,
+      parties: {},
+      revenue: 0,
+      variableCost: 0,
+      cacSpend: 0,
+      fixedCost: 0,
+      oneTimeCost: 0,
+      totalCost: 0,
+      grossProfit: 0,
+      netProfit: 0,
+      cumulative: 0
+    };
+    for (const p of parties) {
+      const prev = counts[p.id] ?? 0;
+      const newUnits = num2(p.monthlyNewBase) * Math.pow(1 + num2(p.monthlyNewGrowthPct) / 100, m - 1);
+      const churned = prev * (num2(p.monthlyChurnPct) / 100);
+      const count = Math.max(0, prev + newUnits - churned);
+      counts[p.id] = count;
+      const revenue = count * num2(p.revenuePerUnitPerMonth);
+      const varCost = count * num2(p.variableCostPerUnitPerMonth);
+      const cac = newUnits * num2(p.cacPerUnit);
+      row.parties[p.id] = { count, newUnits, churned, revenue, varCost, cac };
+      row.revenue += revenue;
+      row.variableCost += varCost;
+      row.cacSpend += cac;
+    }
+    for (const f of fixedCosts) {
+      if (m >= num2(f.startMonth, 1)) row.fixedCost += num2(f.monthlyAmount);
+    }
+    for (const o of oneTimeCosts) {
+      if (num2(o.month, 1) === m) row.oneTimeCost += num2(o.amount);
+    }
+    row.totalCost = row.variableCost + row.cacSpend + row.fixedCost + row.oneTimeCost;
+    row.grossProfit = row.revenue - row.variableCost;
+    row.netProfit = row.revenue - row.totalCost;
+    cumulative += row.netProfit;
+    row.cumulative = cumulative;
+    if (breakEvenMonth === null && row.netProfit > 0) breakEvenMonth = m;
+    if (cumBreakEvenMonth === null && cumulative > 0) cumBreakEvenMonth = m;
+    rows.push(row);
+  }
+  const last = rows[rows.length - 1];
+  if (!last) return null;
+  const year1 = rows.slice(0, 12);
+  return {
+    rows,
+    summary: {
+      horizon,
+      breakEvenMonth,
+      cumBreakEvenMonth,
+      year1Revenue: sum(year1.map((r) => r.revenue)),
+      year1Net: sum(year1.map((r) => r.netProfit)),
+      totalRevenue: sum(rows.map((r) => r.revenue)),
+      totalNet: cumulative,
+      maxDrawdown: Math.min(...rows.map((r) => r.cumulative), 0),
+      endingMRR: last.revenue,
+      endingCounts: Object.fromEntries(parties.map((p) => [p.id, last.parties[p.id]?.count || 0]))
+    }
+  };
+}
+function fmtMoney(n, currency = "USD") {
+  try {
+    return new Intl.NumberFormat("en-US", { style: "currency", currency, maximumFractionDigits: 0 }).format(n);
+  } catch {
+    return `$${Math.round(n).toLocaleString()}`;
+  }
+}
+
+// core/artifacts.ts
+var obj = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+var str2 = (v) => typeof v === "string" ? v : "";
+var esc2 = (s) => String(s ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var fam2 = (f) => String(f).trim().replace(/\s+/g, "+");
+function brandTokens(guide) {
+  if (!guide || !Array.isArray(guide.palette) || !guide.palette.length) return null;
+  const role = (re, fb) => guide.palette.find((p) => p?.name && new RegExp(re, "i").test(p.name))?.hex || fb;
+  return {
+    primary: role("primary", guide.palette[0]?.hex || "#1f3a5f"),
+    accent: role("accent|secondary", guide.palette[1]?.hex || "#e8743b"),
+    ink: role("ink|text|dark|black", "#16202b"),
+    surface: role("surface|background|light|paper|off.?white|cream", "#f7f8fa"),
+    muted: role("muted|gray|grey|neutral|border", "#8a9099"),
+    display: guide.typography?.display?.family || "Inter",
+    body: guide.typography?.body?.family || "Inter"
+  };
+}
+var SVG_FONTS = `<style><![CDATA[@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&family=IBM+Plex+Mono:wght@400;500&display=swap');.s{font-family:'Inter',system-ui,sans-serif}.d{font-family:'Inter',system-ui,sans-serif}.m{font-family:'IBM Plex Mono',ui-monospace,monospace}]]></style>`;
+function svgFontBlock(t) {
+  if (!t) return { style: SVG_FONTS, disp: "d" };
+  const style = `<style><![CDATA[@import url('https://fonts.googleapis.com/css2?family=${fam2(t.display)}:wght@600;700;800&family=${fam2(t.body)}:wght@400;500;600&family=IBM+Plex+Mono:wght@400;500&display=swap');.s{font-family:'${t.body}',system-ui,sans-serif}.d{font-family:'${t.display}','${t.body}',sans-serif}.m{font-family:'IBM Plex Mono',ui-monospace,monospace}]]></style>`;
+  return { style, disp: "d" };
+}
+function wrapText(text, maxWidthPx, fontSizePx, avg = 0.54) {
+  const maxChars = Math.max(6, Math.floor(maxWidthPx / (fontSizePx * avg)));
+  const out = [];
+  let line = "";
+  for (let word of String(text).trim().split(/\s+/)) {
+    while (word.length > maxChars) {
+      if (line) {
+        out.push(line);
+        line = "";
+      }
+      out.push(word.slice(0, maxChars - 1) + "-");
+      word = word.slice(maxChars - 1);
+    }
+    const test = line ? line + " " + word : word;
+    if (test.length > maxChars && line) {
+      out.push(line);
+      line = word;
+    } else line = test;
+  }
+  if (line) out.push(line);
+  return out.length ? out : [""];
+}
+function glossaryMarkdown(grill) {
+  const terms = grill?.glossary || [];
+  return `# Domain Glossary
+
+${terms.map((g) => `- **${g.term}**: ${g.definition}`).join("\n")}
+`;
+}
+var REQ_CATS = ["persona", "journey", "ux", "functional", "business-rule", "data", "integration", "non-functional", "metric"];
+function requirementsMarkdown(grill) {
+  const reqs = (grill?.requirements || []).map((r) => ({
+    id: r.id || "",
+    category: r.category || "functional",
+    text: r.text ?? r.statement ?? ""
+  }));
+  let md = "# Requirements\n";
+  for (const cat of REQ_CATS) {
+    const inCat = reqs.filter((r) => r.category === cat);
+    if (!inCat.length) continue;
+    md += `
+## ${cat.replace("-", " ").replace(/\b\w/g, (c) => c.toUpperCase())}
+
+`;
+    md += inCat.map((r) => `- **${r.id}** ${r.text}`).join("\n") + "\n";
+  }
+  return md;
+}
+function swotMarkdown(swot) {
+  if (!swot) return "";
+  const quads = [
+    ["strengths", "Strengths"],
+    ["weaknesses", "Weaknesses"],
+    ["opportunities", "Opportunities"],
+    ["threats", "Threats"]
+  ];
+  let md = "# SWOT Analysis\n";
+  for (const [k, label] of quads) {
+    const items = (swot[k] || []).filter((x) => x && x.trim());
+    md += `
+## ${label}
+
+${items.length ? items.map((i) => `- ${i}`).join("\n") : "_(none)_"}
+`;
+  }
+  return md;
+}
+function brandGuideMarkdown(guide) {
+  if (!guide) return "";
+  const pal = (guide.palette || []).map((p) => `- **${p.name}** \`${p.hex}\` (${p.role})`).join("\n");
+  const msg = (guide.messaging || []).map((m) => `- ${m}`).join("\n");
+  const dos = (guide.voice?.dos || []).map((d) => `- ${d}`).join("\n");
+  const donts = (guide.voice?.donts || []).map((d) => `- ${d}`).join("\n");
+  const disp = guide.typography?.display;
+  const body = guide.typography?.body;
+  return `# Brand Style Guide: ${guide.brandName || ""}
+
+> ${guide.tagline || ""}
+
+**Positioning.** ${guide.positioning || ""}
+
+**Personality.** ${(guide.personality || []).join(", ")}
+
+## Voice and Tone
+${guide.voice?.tone || ""}
+
+**Do**
+${dos || "- (none)"}
+
+**Don't**
+${donts || "- (none)"}
+
+## Color Palette
+${pal || "- (none)"}
+
+## Typography
+- **Display:** ${disp?.family || ""} (${disp?.weights || ""}). Usage: ${disp?.usage || ""}
+- **Body:** ${body?.family || ""} (${body?.weights || ""}). Usage: ${body?.usage || ""}
+
+## Logo Direction
+${guide.logoDirection || ""}
+
+## Imagery and Iconography
+${guide.imagery || ""}
+
+## Messaging Examples
+${msg || "- (none)"}
+`;
+}
+function collectTodos(feedback) {
+  const out = [];
+  for (const [qId, v] of Object.entries(feedback || {})) {
+    const todos = v?.todos;
+    if (todos?.length) out.push({ qId, summaries: todos.map((t) => t.summary || "to-do") });
+  }
+  return out;
+}
+var SEO_DEPLOY_SECTION = `## Discoverability and SEO (required)
+Build the product so both people and AI assistants can find and trust it. Implement all of the following:
+- Structured data: add schema.org JSON-LD as one linked @graph. Always include an Organization and a Person (the founder), cross-referenced (Organization.founder and Person.worksFor) and each with a sameAs array pointing to real profiles. Add a WebSite node and the type that matches the page (WebPage, SoftwareApplication, or Product). Add FAQPage wherever there is an FAQ, HowTo for any step-by-step process, BreadcrumbList on every real sub-page, and Article or BlogPosting on real article pages. Never add a schema type that does not match visible on-page content.
+- llms.txt: create /llms.txt at the site root with an H1 title, a one-paragraph summary in a blockquote, sections that link the key pages, and a short FAQ, so AI crawlers can extract what the site is and does.
+- sitemap.xml listing every real page, and robots.txt that allows crawling and points to the sitemap.
+- A canonical link on every page.
+- Open Graph and Twitter Card meta on every page, plus a 1200x630 social image.
+- Semantic, accessible HTML: landmark elements, headings in order, alt text on images, labelled form controls, and a visible focus style.
+- An SEO README at SEO.md that documents every item above: where each lives and how to update it later (especially the Organization and Person sameAs links and the social image).
+
+## Deployment (Netlify recommended)
+Netlify is the simplest way to ship this. Include what it needs and give the founder a paste-ready deploy path:
+- Add a netlify.toml with the build command and publish directory. For a single-page app, add a SPA redirect (/* to /index.html with status 200).
+- Document two deploy options in SEO.md or a DEPLOY.md:
+  1. Continuous deploy: push the repo to GitHub and connect it at app.netlify.com, so every push to the main branch deploys automatically.
+  2. CLI deploy: run the build, then "npx netlify-cli deploy --prod --dir <publish-directory>".
+- Make sure llms.txt, robots.txt, sitemap.xml, and the social image sit in the publish directory so they are served at the site root.
+`;
+function buildKitPrompt(grill, prdMarkdown, assumptions, brand, feedback = {}) {
+  const projection = assumptions ? computeProjection(assumptions) : null;
+  let bizSummary = "";
+  if (projection && assumptions) {
+    const s = projection.summary;
+    bizSummary = `Business model: ${(assumptions.parties || []).map((p) => `${p.name} (${p.role})`).join(", ")}. Monthly break-even at month ${s.breakEvenMonth ?? "beyond horizon"}; cumulative break-even at month ${s.cumBreakEvenMonth ?? "beyond horizon"}; year-1 revenue about ${fmtMoney(s.year1Revenue, assumptions.currency)}; max cash drawdown about ${fmtMoney(Math.abs(s.maxDrawdown), assumptions.currency)}.`;
+  }
+  const groups = collectTodos(feedback);
+  const todoBlock = groups.length ? `
+## Open validation to-dos (the founder set these aside; treat as known gaps, not blockers)
+${groups.map((g) => `- ${g.qId}: ${g.summaries.join("; ")}`).join("\n")}
+` : "";
+  const hasGuide = !!brand?.guide;
+  return `# Build This Product
+
+You are an expert full-stack engineering agent. Build version 1 of the product specified below. Work iteratively: scaffold, implement the critical user journeys first, then the remaining requirements. Ask nothing; every decision you need is in this document, and where genuinely unspecified, choose the simplest option consistent with the PRD and note it in a DECISIONS.md.
+
+## Ground rules
+- Honor the Domain Glossary exactly: use its terms for entities, fields, and UI labels (ubiquitous language).
+- Every requirement has an ID (R-1, R-2, ...). Track them in a TRACEABILITY.md mapping requirement to implementation to test.
+- Respect the "Out of Scope" list absolutely. Do not build excluded features.
+- Mobile and desktop must both work.${hasGuide ? "\n- Apply the brand identity in the Brand section below to all UI, copy, color, and type, and to any generated assets." : ""}
+${bizSummary ? `
+## Business context
+${bizSummary}
+` : ""}${hasGuide ? `
+## Brand identity (apply consistently)
+${brandGuideMarkdown(brand.guide)}
+(The kit also includes Logo.svg and a rendered LookBook.html.)
+` : ""}${todoBlock}
+${SEO_DEPLOY_SECTION}
+---
+
+${prdMarkdown || "(PRD not yet composed; generate the PRD first)"}
+
+---
+
+${requirementsMarkdown(grill)}
+
+---
+
+${glossaryMarkdown(grill)}
+`;
+}
+function swotInfographicSvg(swot, brand) {
+  const t = brandTokens(brand?.guide);
+  const { style: fontStyle, disp } = svgFontBlock(t);
+  const surface = t?.surface || "#f7f8fa";
+  const ink = t?.ink || "#0f1729";
+  const W = 1e3, spineX = W / 2, R = 34, LH = 19, FS = 13.5;
+  const headerH = 104, footerH = 42, gapRow = 26;
+  const PANEL = { L: { x: 28, w: 444 }, R: { x: 528, w: 444 } };
+  const textW = 360;
+  const quads = [
+    { key: "strengths", label: "STRENGTHS", color: "#059669", icon: "up", side: -1, row: 0 },
+    { key: "weaknesses", label: "WEAKNESSES", color: "#dc2626", icon: "down", side: -1, row: 1 },
+    { key: "opportunities", label: "OPPORTUNITIES", color: "#4f46e5", icon: "search", side: 1, row: 0 },
+    { key: "threats", label: "THREATS", color: "#d97706", icon: "warn", side: 1, row: 1 }
+  ].map((q) => ({
+    ...q,
+    items: (swot?.[q.key] || []).map((x) => String(x || "").trim()).filter(Boolean).slice(0, 8).map((s) => wrapText(s, textW, FS))
+  }));
+  const bulletsH = (q) => q.items.length ? q.items.reduce((a, lines) => a + lines.length * LH + 10, 0) : 26;
+  const quadH = (q) => 94 + bulletsH(q) + 14;
+  const rowH = [Math.max(quadH(quads[0]), quadH(quads[2])), Math.max(quadH(quads[1]), quadH(quads[3]))];
+  const rowY = [headerH + gapRow, 0];
+  rowY[1] = rowY[0] + rowH[0] + gapRow;
+  const footerTop = rowY[1] + rowH[1] + gapRow;
+  const H = footerTop + footerH;
+  const icon = (type, cx, cy) => {
+    const P = (d, w = 5) => `<path d="${d}" fill="none" stroke="#ffffff" stroke-width="${w}" stroke-linecap="round" stroke-linejoin="round"/>`;
+    if (type === "up") return P(`M${cx} ${cy + 13} L${cx} ${cy - 13} M${cx - 9} ${cy - 4} L${cx} ${cy - 13} L${cx + 9} ${cy - 4}`);
+    if (type === "down") return P(`M${cx} ${cy - 13} L${cx} ${cy + 13} M${cx - 9} ${cy + 4} L${cx} ${cy + 13} L${cx + 9} ${cy + 4}`);
+    if (type === "search") return `<circle cx="${cx - 3}" cy="${cy - 3}" r="9.5" fill="none" stroke="#ffffff" stroke-width="4.5"/>` + P(`M${cx + 4} ${cy + 4} L${cx + 13} ${cy + 13}`);
+    return P(`M${cx} ${cy - 15} L${cx + 15} ${cy + 12} L${cx - 15} ${cy + 12} Z`, 4.5) + `<rect x="${cx - 2.5}" y="${cy - 6}" width="5" height="11" rx="2.5" fill="#ffffff"/><circle cx="${cx}" cy="${cy + 9}" r="2.7" fill="#ffffff"/>`;
+  };
+  const quadrant = (q) => {
+    const pan = q.side < 0 ? PANEL.L : PANEL.R;
+    const top = rowY[q.row], rh = rowH[q.row];
+    const my = top + 40;
+    const mx = spineX + q.side * 70;
+    const innerEdge = mx - q.side * R;
+    const textX = pan.x + 42, dotX = pan.x + 26;
+    let b = `<rect x="${pan.x}" y="${top + 10}" width="${pan.w}" height="${rh - 10}" rx="18" fill="${q.color}" opacity="0.06"/>`;
+    b += `<rect x="${pan.x}" y="${top + 10}" width="${pan.w}" height="${rh - 10}" rx="18" fill="none" stroke="${q.color}" stroke-opacity="0.18"/>`;
+    b += `<line x1="${spineX}" y1="${my}" x2="${innerEdge}" y2="${my}" stroke="${q.color}" stroke-width="2.5"/>`;
+    b += `<circle cx="${spineX}" cy="${my}" r="4.5" fill="${q.color}"/>`;
+    b += `<circle cx="${mx}" cy="${my}" r="${R + 6}" fill="${q.color}" opacity="0.15"/>`;
+    b += `<circle cx="${mx}" cy="${my}" r="${R}" fill="${q.color}"/>`;
+    b += icon(q.icon, mx, my);
+    const tabW = Math.round(q.label.length * 8.6) + 30, tabH = 34, tabY = my - tabH / 2;
+    const tabX = q.side < 0 ? mx - R - 12 - tabW : mx + R + 12;
+    b += `<rect x="${tabX}" y="${tabY}" width="${tabW}" height="${tabH}" rx="8" fill="${q.color}"/>`;
+    b += `<text class="${disp}" x="${tabX + tabW / 2}" y="${tabY + 22}" text-anchor="middle" font-size="13.5" font-weight="700" letter-spacing="1.5" fill="#ffffff">${esc2(q.label)}</text>`;
+    let y = top + 94;
+    if (!q.items.length) return b + `<text class="s" x="${textX}" y="${y}" font-size="13" fill="#9ca3af">(none yet)</text>`;
+    for (const lines of q.items) {
+      b += `<circle cx="${dotX}" cy="${y - 4}" r="3" fill="${q.color}"/>`;
+      b += `<text class="s" x="${textX}" y="${y}" font-size="13.5" fill="#374151">` + lines.map((ln, i) => `<tspan x="${textX}"${i ? ` dy="${LH}"` : ""}>${esc2(ln)}</tspan>`).join("") + `</text>`;
+      y += lines.length * LH + 10;
+    }
+    return b;
+  };
+  let body = `<rect width="${W}" height="${H}" fill="${surface}"/>`;
+  body += `<line x1="${spineX}" y1="${headerH}" x2="${spineX}" y2="${footerTop}" stroke="#cfd5de" stroke-width="2"/>`;
+  body += quads.map(quadrant).join("");
+  body += `<rect x="0" y="0" width="${W}" height="${headerH}" fill="${ink}"/>`;
+  body += `<text class="m" x="40" y="38" font-size="11" letter-spacing="3" fill="#ffffff" fill-opacity="0.5">THE THOUGHT LAYER</text>`;
+  body += `<text class="m" x="${W - 40}" y="38" font-size="11" letter-spacing="3" fill="#ffffff" fill-opacity="0.5" text-anchor="end">STRATEGY</text>`;
+  body += `<text class="${disp}" x="${spineX}" y="74" font-size="46" font-weight="700" letter-spacing="6" fill="#ffffff" text-anchor="middle">SWOT ANALYSIS</text>`;
+  body += `<rect x="0" y="${footerTop}" width="${W}" height="${footerH}" fill="${ink}"/>`;
+  body += `<text class="m" x="${spineX}" y="${footerTop + 26}" font-size="11" fill="#ffffff" fill-opacity="0.55" text-anchor="middle">The Thought Layer, generated locally</text>`;
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${H}" viewBox="0 0 ${W} ${H}">${fontStyle}${body}</svg>`;
+}
+function bizModelInfographicSvg(assumptions, brand) {
+  const projection = computeProjection(assumptions);
+  if (!projection || !assumptions) return null;
+  const s = projection.summary;
+  const cur = assumptions.currency || "USD";
+  const t = brandTokens(brand?.guide);
+  const { style: fontStyle, disp } = svgFontBlock(t);
+  const surface = t?.surface || "#f7f8fa";
+  const ink = t?.ink || "#0f1729";
+  const accent = t?.accent || "#4f46e5";
+  const W = 1e3, spineX = W / 2, M = 28, LH = 19, FS = 13.5;
+  const headerH = 104, footerH = 42;
+  const PANEL = { L: { x: 28, w: 444 }, R: { x: 528, w: 444 } };
+  const metrics = [
+    ["Year 1 revenue", fmtMoney(s.year1Revenue, cur)],
+    ["Monthly break-even", s.breakEvenMonth ? `Month ${s.breakEvenMonth}` : "Beyond horizon"],
+    ["Max cash drawdown", fmtMoney(s.maxDrawdown, cur)],
+    [`MRR at month ${s.horizon}`, fmtMoney(s.endingMRR, cur)]
+  ];
+  const milestones = assumptions.milestones || [];
+  const partyLines = (assumptions.parties || []).slice(0, 7).map((p) => wrapText(`${p.name} (${p.role}): ${fmtMoney(Number(p.revenuePerUnitPerMonth) || 0, cur)}/unit/mo, CAC ${fmtMoney(Number(p.cacPerUnit) || 0, cur)}`, PANEL.L.w - 60, FS));
+  const msLines = [...milestones].sort((a, b) => (a.month || 0) - (b.month || 0)).slice(0, 9).map((m) => ({ month: m.month ?? 0, lines: wrapText(m.label || "", PANEL.R.w - 92, FS) }));
+  const narrLines = assumptions.narrative ? wrapText(assumptions.narrative, W - 96, 12.5) : [];
+  const cardsY = headerH + 26, cardH = 84, cardGap = 18;
+  const cardW = (W - M * 2 - cardGap * 3) / 4;
+  const panelTop = cardsY + cardH + 34;
+  const listTop = panelTop + 60;
+  let ly = listTop;
+  partyLines.forEach((lines) => {
+    ly += lines.length * LH + 10;
+  });
+  let ry = listTop;
+  msLines.forEach((m) => {
+    ry += m.lines.length * LH + 10;
+  });
+  const colBottom = Math.max(ly, ry, listTop + 26);
+  const panelBottom = colBottom + 6;
+  const narrTop = panelBottom + 30;
+  const narrPanelH = narrLines.length * 17 + 36;
+  const footerTop = narrLines.length ? narrTop + narrPanelH + 14 : panelBottom + 24;
+  const H = footerTop + footerH;
+  const tab = (label, x, y2) => {
+    const w = Math.round(label.length * 8.6) + 28, h = 32;
+    return `<rect x="${x}" y="${y2}" width="${w}" height="${h}" rx="8" fill="${accent}"/><text class="${disp}" x="${x + w / 2}" y="${y2 + 21}" text-anchor="middle" font-size="13" font-weight="700" letter-spacing="1.5" fill="#ffffff">${esc2(label)}</text>`;
+  };
+  let body = `<rect width="${W}" height="${H}" fill="${surface}"/>`;
+  metrics.forEach((m, i) => {
+    const x = M + i * (cardW + cardGap);
+    body += `<rect x="${x}" y="${cardsY}" width="${cardW}" height="${cardH}" rx="14" fill="${accent}" opacity="0.08"/>`;
+    body += `<rect x="${x}" y="${cardsY}" width="${cardW}" height="${cardH}" rx="14" fill="none" stroke="${accent}" stroke-opacity="0.2"/>`;
+    body += `<text class="s" x="${x + 18}" y="${cardsY + 30}" font-size="11.5" fill="#6b7280">${esc2(m[0])}</text>`;
+    body += `<text class="${disp}" x="${x + 18}" y="${cardsY + 62}" font-size="22" font-weight="700" fill="${accent}">${esc2(m[1])}</text>`;
+  });
+  body += `<rect x="${PANEL.L.x}" y="${panelTop}" width="${PANEL.L.w}" height="${panelBottom - panelTop}" rx="18" fill="${accent}" opacity="0.05"/>`;
+  body += `<rect x="${PANEL.R.x}" y="${panelTop}" width="${PANEL.R.w}" height="${panelBottom - panelTop}" rx="18" fill="${accent}" opacity="0.05"/>`;
+  body += `<line x1="${spineX}" y1="${panelTop}" x2="${spineX}" y2="${panelBottom}" stroke="#cfd5de" stroke-width="2"/>`;
+  body += tab("PARTIES", PANEL.L.x + 22, panelTop + 16);
+  body += tab("MILESTONES", PANEL.R.x + 22, panelTop + 16);
+  let y = listTop;
+  if (!partyLines.length) body += `<text class="s" x="${PANEL.L.x + 24}" y="${y}" font-size="13" fill="#9ca3af">(no parties)</text>`;
+  partyLines.forEach((lines) => {
+    body += `<circle cx="${PANEL.L.x + 26}" cy="${y - 4}" r="3" fill="${accent}"/>`;
+    body += `<text class="s" x="${PANEL.L.x + 40}" y="${y}" font-size="13.5" fill="#374151">` + lines.map((ln, i) => `<tspan x="${PANEL.L.x + 40}"${i ? ` dy="${LH}"` : ""}>${esc2(ln)}</tspan>`).join("") + `</text>`;
+    y += lines.length * LH + 10;
+  });
+  let my = listTop;
+  if (!msLines.length) body += `<text class="s" x="${PANEL.R.x + 24}" y="${my}" font-size="13" fill="#9ca3af">(no milestones)</text>`;
+  msLines.forEach((m) => {
+    body += `<text class="m" x="${PANEL.R.x + 24}" y="${my}" font-size="11" font-weight="500" fill="${accent}">M${esc2(m.month)}</text>`;
+    body += `<text class="s" x="${PANEL.R.x + 60}" y="${my}" font-size="13.5" fill="#374151">` + m.lines.map((ln, i) => `<tspan x="${PANEL.R.x + 60}"${i ? ` dy="${LH}"` : ""}>${esc2(ln)}</tspan>`).join("") + `</text>`;
+    my += m.lines.length * LH + 10;
+  });
+  if (narrLines.length) {
+    body += `<rect x="${M}" y="${narrTop}" width="${W - M * 2}" height="${narrPanelH}" rx="14" fill="${accent}" opacity="0.05"/>`;
+    body += `<text class="m" x="${M + 18}" y="${narrTop + 22}" font-size="10.5" letter-spacing="1.5" fill="#9ca3af">NOTES</text>`;
+    body += `<text class="s" x="${M + 18}" y="${narrTop + 42}" font-size="12.5" fill="#6b7280">` + narrLines.map((ln, i) => `<tspan x="${M + 18}"${i ? ` dy="17"` : ""}>${esc2(ln)}</tspan>`).join("") + `</text>`;
+  }
+  body += `<rect x="0" y="0" width="${W}" height="${headerH}" fill="${ink}"/>`;
+  body += `<text class="m" x="40" y="38" font-size="11" letter-spacing="3" fill="#ffffff" fill-opacity="0.5">THE THOUGHT LAYER</text>`;
+  body += `<text class="m" x="${W - 40}" y="38" font-size="11" letter-spacing="3" fill="#ffffff" fill-opacity="0.5" text-anchor="end">FINANCIALS</text>`;
+  body += `<text class="${disp}" x="${spineX}" y="74" font-size="44" font-weight="700" letter-spacing="4" fill="#ffffff" text-anchor="middle">BUSINESS MODEL</text>`;
+  body += `<rect x="0" y="${footerTop}" width="${W}" height="${footerH}" fill="${ink}"/>`;
+  body += `<text class="m" x="${spineX}" y="${footerTop + 26}" font-size="11" fill="#ffffff" fill-opacity="0.55" text-anchor="middle">The Thought Layer, figures are your assumptions, computed locally</text>`;
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${H}" viewBox="0 0 ${W} ${H}">${fontStyle}${body}</svg>`;
+}
+function brandLookbookHtml(guide, logoSvg) {
+  if (!guide) return "";
+  const role = (re, fb) => (guide.palette || []).find((p) => p?.name && new RegExp(re, "i").test(p.name))?.hex || fb;
+  const primary = role("primary", guide.palette?.[0]?.hex || "#1a1a2e");
+  const accent = role("accent|secondary", guide.palette?.[1]?.hex || "#e94f37");
+  const ink = role("ink|text|dark|black", "#14141b");
+  const surface = role("surface|background|light|paper|off.?white|cream", "#fbfaf7");
+  const muted = role("muted|gray|grey|neutral|border", "#8a8a99");
+  const disp = guide.typography?.display?.family || "Georgia";
+  const body = guide.typography?.body?.family || "system-ui";
+  const fontsUrl = `https://fonts.googleapis.com/css2?family=${fam2(disp)}:wght@400;600;700&family=${fam2(body)}:wght@400;500;600&display=swap`;
+  const name = esc2(guide.brandName || "Your Brand");
+  const tagline = esc2(guide.tagline || "");
+  const messaging = guide.messaging || [];
+  const hero = esc2(messaging[0] || guide.positioning || guide.brandName || "");
+  const lockup = logoSvg || `<span class="wordmark">${name}</span>`;
+  const initials = (guide.brandName || "B").split(/\s+/).map((w) => w[0] || "").join("").slice(0, 2).toUpperCase();
+  const swatches = (guide.palette || []).map((p) => `<div class="sw"><div class="chip" style="background:${esc2(p.hex)}"></div><div class="swmeta"><strong>${esc2(p.name)}</strong><code>${esc2(p.hex)}</code><span>${esc2(p.role)}</span></div></div>`).join("");
+  const traits = (guide.personality || []).map((tr) => `<span class="pill">${esc2(tr)}</span>`).join("");
+  const dos = (guide.voice?.dos || []).map((d) => `<li>${esc2(d)}</li>`).join("");
+  const donts = (guide.voice?.donts || []).map((d) => `<li>${esc2(d)}</li>`).join("");
+  return `<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>${name} Brand Look Book</title><link href="${fontsUrl}" rel="stylesheet"><style>
+:root{--p:${primary};--a:${accent};--ink:${ink};--su:${surface};--mu:${muted};--disp:'${disp}',Georgia,serif;--body:'${body}',system-ui,sans-serif}
+*{margin:0;padding:0;box-sizing:border-box}body{background:var(--su);color:var(--ink);font-family:var(--body);line-height:1.6}
+.wrap{max-width:960px;margin:0 auto;padding:0 28px}
+section{padding:60px 0;border-bottom:1px solid color-mix(in srgb,var(--mu) 30%,transparent)}
+.eyebrow{font-size:12px;letter-spacing:2px;text-transform:uppercase;color:var(--mu);font-weight:600;margin-bottom:16px}
+h2{font-family:var(--disp);font-size:30px;font-weight:700}
+.wordmark{font-family:var(--disp);font-size:44px;font-weight:700;color:var(--su)}
+.cover{background:var(--p);color:var(--su);padding:84px 0}
+.cover .lockup{display:inline-block;margin-bottom:26px}.cover .lockup svg{height:64px;width:auto}
+.cover h1{font-family:var(--disp);font-size:clamp(32px,6vw,58px);font-weight:700;line-height:1.08;margin:12px 0}
+.cover p{font-size:18px;opacity:.85;max-width:640px}
+.pill{display:inline-block;background:color-mix(in srgb,var(--a) 16%,transparent);color:#fff;border:1px solid color-mix(in srgb,#fff 30%,transparent);border-radius:999px;padding:6px 14px;font-size:13px;font-weight:600;margin:0 8px 8px 0}
+.swatches{display:grid;grid-template-columns:repeat(auto-fit,minmax(150px,1fr));gap:16px}
+.sw{border:1px solid color-mix(in srgb,var(--mu) 28%,transparent);border-radius:12px;overflow:hidden;background:#fff}
+.chip{height:80px}.swmeta{padding:12px 14px;font-size:13px;display:flex;flex-direction:column;gap:2px}
+.swmeta code,.swmeta span{color:var(--mu);font-size:12px}
+.big{font-family:var(--disp);font-size:62px;font-weight:700;line-height:1.05}
+.row{font-family:var(--disp);font-size:24px;margin-top:6px;color:var(--a)}
+.bodyspec{font-size:16px;max-width:640px;margin-top:16px}
+.voice{display:grid;grid-template-columns:1fr 1fr;gap:22px;margin-top:8px}
+.col{border:1px solid color-mix(in srgb,var(--mu) 28%,transparent);border-radius:12px;padding:18px 20px;background:#fff}
+.col h3{font-size:13px;text-transform:uppercase;letter-spacing:1px;margin-bottom:10px}
+.col ul{list-style:none}.col li{padding:5px 0 5px 22px;position:relative;font-size:14px}
+.col li:before{position:absolute;left:0}.do li:before{content:"+";color:var(--a);font-weight:700}.dont li:before{content:"x";color:var(--mu)}
+.apps{display:grid;grid-template-columns:1fr 1fr;gap:20px}
+.mock{border:1px solid color-mix(in srgb,var(--mu) 28%,transparent);border-radius:14px;overflow:hidden;background:#fff}
+.cap{font-size:12px;color:var(--mu);padding:8px 14px;border-top:1px solid color-mix(in srgb,var(--mu) 22%,transparent)}
+.appbar{display:flex;align-items:center;justify-content:space-between;padding:13px 18px;background:var(--su);border-bottom:1px solid color-mix(in srgb,var(--mu) 22%,transparent)}
+.appbar .lk svg{height:24px}.appbar .lk .wordmark{font-size:18px;color:var(--ink)}
+.appbar nav{font-size:12px;color:var(--mu);display:flex;gap:14px}
+.appbody{height:118px;background:repeating-linear-gradient(0deg,transparent,transparent 22px,color-mix(in srgb,var(--mu) 9%,transparent) 23px)}
+.card{aspect-ratio:1.75;background:var(--p);color:var(--su);padding:22px;display:flex;flex-direction:column;justify-content:space-between}
+.card .lk svg{height:26px}.card .nm{font-family:var(--disp);font-size:22px;font-weight:700}.card .tg{font-size:12px;opacity:.8}
+.slide{padding:26px;background:var(--su)}.slide .kicker{font-size:11px;letter-spacing:1.5px;text-transform:uppercase;color:var(--a);font-weight:600}
+.slide h4{font-family:var(--disp);font-size:25px;font-weight:700;margin-top:6px;line-height:1.15}.slide .bar{width:46px;height:4px;background:var(--a);margin-top:14px;border-radius:2px}
+.avatar{height:158px;display:flex;align-items:center;justify-content:center}.circle{width:84px;height:84px;border-radius:50%;background:var(--a);color:#fff;display:flex;align-items:center;justify-content:center;font-family:var(--disp);font-weight:700;font-size:30px}
+.foot{padding:36px 0;color:var(--mu);font-size:12px}
+@media(max-width:680px){.voice,.apps{grid-template-columns:1fr}}
+</style></head><body>
+<section class="cover"><div class="wrap">
+<div class="lockup">${lockup}</div>
+<div class="eyebrow" style="color:rgba(255,255,255,.7)">Brand Look Book</div>
+<h1>${hero}</h1>${tagline ? `<p>${tagline}</p>` : ""}
+<div style="margin-top:20px">${traits}</div>
+</div></section>
+<section><div class="wrap"><div class="eyebrow">Positioning</div><h2>${name}</h2>
+<p style="font-size:18px;max-width:680px;margin-top:8px">${esc2(guide.positioning || "")}</p></div></section>
+<section><div class="wrap"><div class="eyebrow">Color</div><h2>Palette</h2><div class="swatches" style="margin-top:20px">${swatches}</div></div></section>
+<section><div class="wrap"><div class="eyebrow">Type</div><h2>Typography</h2>
+<div class="big" style="margin-top:18px">${name}</div><div class="row">${esc2(disp)} for display</div>
+<p class="bodyspec">Set in ${esc2(body)} for body and UI. ${esc2(messaging[1] || "The quick brown fox jumps over the lazy dog 0123456789.")}</p></div></section>
+<section><div class="wrap"><div class="eyebrow">Voice</div><h2>How the brand sounds</h2>
+<p style="max-width:680px;margin-top:8px">${esc2(guide.voice?.tone || "")}</p>
+<div class="voice"><div class="col do"><h3>Do</h3><ul>${dos || "<li>(none)</li>"}</ul></div><div class="col dont"><h3>Don't</h3><ul>${donts || "<li>(none)</li>"}</ul></div></div></div></section>
+<section><div class="wrap"><div class="eyebrow">In the wild</div><h2>The identity applied</h2>
+<div class="apps" style="margin-top:20px">
+<div class="mock"><div class="appbar"><span class="lk">${lockup}</span><nav><span>Home</span><span>Pricing</span><span>Sign in</span></nav></div><div class="appbody"></div><div class="cap">App and website header</div></div>
+<div class="mock"><div class="card"><span class="lk" style="filter:brightness(0) invert(1)">${lockup}</span><div><div class="nm">${name}</div><div class="tg">${tagline}</div></div></div><div class="cap">Business card</div></div>
+<div class="mock"><div class="slide"><div class="kicker">${esc2((guide.personality || [])[0] || "Brand")}</div><h4>${hero}</h4><div class="bar"></div></div><div class="cap">Slide title</div></div>
+<div class="mock"><div class="avatar"><div class="circle">${esc2(initials)}</div></div><div class="cap">Social avatar</div></div>
+</div></div></section>
+<div class="wrap foot">${name} brand look book, generated locally by The Thought Layer. Type: ${esc2(disp)} / ${esc2(body)}.</div>
+</body></html>`;
+}
+var kindOf = (path) => path.endsWith(".md") ? "markdown" : path.endsWith(".svg") ? "svg" : path.endsWith(".html") ? "html" : path.endsWith(".json") ? "json" : "text";
+function buildArtifactSet(state, opts) {
+  const files = {};
+  const sources = {};
+  const add = (path, content, source) => {
+    if (content && content.trim()) {
+      files[path] = content;
+      sources[path] = source;
+    }
+  };
+  const brand = state.brand && typeof state.brand === "object" ? state.brand : null;
+  const grill = state.grill && typeof state.grill === "object" ? state.grill : null;
+  const swot = state.swot && typeof state.swot === "object" ? state.swot : null;
+  const prd = obj(state.prd);
+  const bizModel = obj(state.bizModel);
+  const research = obj(state.research);
+  const assumptions = bizModel["assumptions"] || null;
+  const prdMarkdown = str2(prd["markdown"]);
+  add("PRD.md", prdMarkdown, "prd");
+  if (grill?.requirements?.length) add("Requirements.md", requirementsMarkdown(grill), "grill");
+  if (grill?.glossary?.length) add("DomainGlossary.md", glossaryMarkdown(grill), "grill");
+  add("BuildPrompt.md", buildKitPrompt(grill, prdMarkdown, assumptions, brand, state.feedback), "prd+grill+bizModel+brand");
+  const swotHasItems = !!swot && Object.values(swot).some((v) => Array.isArray(v) && v.some((x) => x && String(x).trim()));
+  if (swotHasItems) {
+    add("SWOT.md", swotMarkdown(swot), "swot");
+    add("SWOT.svg", swotInfographicSvg(swot, brand), "swot");
+  }
+  const bizSvg = bizModelInfographicSvg(assumptions, brand);
+  if (bizSvg) add("BusinessModel.svg", bizSvg, "bizModel");
+  if (research["brief"]) {
+    add("MarketResearch.md", `# Market Research
+
+_${str2(research["description"])}_
+
+${str2(research["brief"])}`, "research");
+  }
+  const governance = obj(state.governance);
+  if (str2(governance["report"]).trim()) {
+    add("Compliance.md", str2(governance["report"]), "governance");
+  }
+  if (brand?.guide) {
+    add("Brand/BrandStyleGuide.md", brandGuideMarkdown(brand.guide), "brand");
+    const chosen = (brand.logos || []).find((l) => l.id === brand.chosenLogoId) || (brand.logos || [])[0];
+    if (chosen?.svg) add("Brand/Logo.svg", chosen.svg, "brand");
+    add("Brand/LookBook.html", brandLookbookHtml(brand.guide, chosen?.svg), "brand");
+  }
+  try {
+    const spec = extractScaffoldSpec(state);
+    const site = buildStarterSite(spec, { domain: opts.domain, founderName: opts.founderName });
+    for (const [name, content] of Object.entries(site.files)) add(`LandingPage/${name}`, content, "scaffold");
+  } catch {
+  }
+  const brandName = str2(obj(brand?.guide)["brandName"]) || "Your Product";
+  add("README.md", readmeIndex(files, brandName), "index");
+  const manifest = {
+    app: "thought-layer",
+    kind: "artifacts",
+    version: 1,
+    generatedAt: opts.generatedAt,
+    brandName,
+    files: Object.keys(files).sort().map((path) => ({
+      path,
+      bytes: Buffer.byteLength(files[path], "utf8"),
+      kind: kindOf(path),
+      source: sources[path] || "index"
+    }))
+  };
+  return { files, manifest };
+}
+function readmeIndex(files, brandName) {
+  const has = (p) => p in files;
+  const lines = [];
+  const row = (p, desc) => {
+    if (has(p)) lines.push(`- **${p}**: ${desc}`);
+  };
+  row("PRD.md", "Complete product requirements document");
+  row("Requirements.md", "Numbered, testable requirements by category");
+  row("DomainGlossary.md", "Ubiquitous language for the domain");
+  row("BuildPrompt.md", "Paste into an AI coding agent (Claude Code, Cursor) to build version 1");
+  row("BusinessModel.svg", "The numbers as a one-page infographic");
+  row("SWOT.md", "Strengths, weaknesses, opportunities, threats");
+  row("SWOT.svg", "The SWOT as a poster infographic");
+  row("MarketResearch.md", "The market research brief");
+  row("Compliance.md", "Governance, licensing, and tax requirements to review with your legal and tax advisors");
+  row("Brand/BrandStyleGuide.md", "Brand voice, palette, and typography");
+  row("Brand/Logo.svg", "The chosen logo (vector, editable)");
+  row("Brand/LookBook.html", "The identity applied; open in any browser");
+  row("LandingPage/index.html", "A deployable landing page; drag onto app.netlify.com/drop");
+  return `# ${brandName}: Thought Layer artifacts
+
+Everything The Thought Layer built for this idea, delivered to your own repo.
+
+${lines.join("\n")}
+`;
+}
+
+// core/artifacts-io.ts
+var ok2 = (message, details = {}) => ({ ok: true, message, details });
+var fail2 = (message, details = {}) => ({ ok: false, message, details });
+var STATE_DIR_ARTIFACTS = ["build.json", "deploy.json", "TRACEABILITY.md", "DECISIONS.md"];
+var ROOT_ARTIFACTS = ["BACKEND.md", "schema.sql", "netlify.toml", ".env.example"];
+var kindOf2 = (path) => path.endsWith(".md") ? "markdown" : path.endsWith(".svg") ? "svg" : path.endsWith(".html") ? "html" : path.endsWith(".json") ? "json" : "text";
+function repoOwnerName(repo) {
+  const m = String(repo || "").trim().match(/(?:github\.com[:/])?([\w.-]+)\/([\w.-]+?)(?:\.git)?$/);
+  if (!m) return null;
+  if (m[1] === "." || m[1] === "..") return null;
+  return `${m[1]}/${m[2]}`;
+}
+function runArtifacts(opts, ctx) {
+  try {
+    const cfg = loadConfig();
+    const { cloneDir, ws } = resolveWorkspace(opts, cfg);
+    if (!isGitRepo(cloneDir)) {
+      return fail2(`No sessions workspace at ${cloneDir}. Run tl sync init --repo <owner/name> first, then save a session.`, { cloneDir });
+    }
+    const slug = slugify(opts.name || ws?.activeSession?.replace(/\.json$/, "") || "");
+    if (!slug) return fail2("Name the session whose artifacts to deliver: tl artifacts --name <name>.");
+    const sessionPath = join6(cloneDir, STATE_DIR, `${slug}.json`);
+    const useExplicit = !!(opts.path && opts.path.trim() || (process.env["THOUGHT_LAYER_STATE"] || "").trim());
+    const loadTarget = useExplicit ? opts.path : existsSync5(sessionPath) ? sessionPath : opts.path;
+    const loaded = loadStateFile(loadTarget);
+    if (!loaded.exists) {
+      return fail2(`No session "${slug}" found (looked at ${loaded.path}). Save it first with tl sync save --name ${slug}.`, { cloneDir });
+    }
+    const { files, manifest } = buildArtifactSet(loaded.state, {
+      generatedAt: ctx.generatedAt,
+      domain: opts.domain,
+      founderName: opts.founderName
+    });
+    const srcStateDir = dirname5(loaded.path);
+    const srcRoot = basename(srcStateDir) === STATE_DIR ? dirname5(srcStateDir) : srcStateDir;
+    const extra = [];
+    const copyIfPresent = (fromDir, fname) => {
+      const from = join6(fromDir, fname);
+      if (!existsSync5(from)) return;
+      try {
+        const content = readFileSync4(from, "utf8");
+        const rel = `Deploy/${fname}`;
+        files[rel] = content;
+        extra.push({ path: rel, bytes: Buffer.byteLength(content, "utf8"), kind: kindOf2(rel), source: "build/deploy" });
+      } catch {
+      }
+    };
+    STATE_DIR_ARTIFACTS.forEach((f) => copyIfPresent(srcStateDir, f));
+    ROOT_ARTIFACTS.forEach((f) => copyIfPresent(srcRoot, f));
+    manifest.files = [...manifest.files, ...extra].sort((a, b) => a.path.localeCompare(b.path));
+    const baseRel = join6("artifacts", slug);
+    const baseAbs = join6(cloneDir, baseRel);
+    for (const [rel, content] of Object.entries(files)) {
+      const dest = join6(baseAbs, rel);
+      mkdirSync5(dirname5(dest), { recursive: true });
+      writeFileSync6(dest, content);
+    }
+    writeFileSync6(join6(baseAbs, "artifacts.json"), JSON.stringify(manifest, null, 2) + "\n");
+    const fileCount = Object.keys(files).length + 1;
+    if (opts.noDeliver) {
+      return ok2(
+        `Generated ${fileCount} artifact file(s) into ${baseAbs} (local only; not committed).`,
+        { cloneDir, dir: baseAbs, session: slug, files: Object.keys(files), count: fileCount, committed: false, pushed: false }
+      );
+    }
+    git(cloneDir, ["add", "-f", "--", baseRel]);
+    const msg = opts.message || `Deliver artifacts for ${slug}`;
+    const committed = git(cloneDir, ["commit", "-m", msg]).status === 0;
+    let pushed = false;
+    let pushNote = "";
+    if (committed && !opts.noPush) {
+      const p = git(cloneDir, ["push"]);
+      pushed = p.status === 0;
+      if (!pushed) pushNote = ` Could not push (${(p.err || "").split("\n")[0] || "see git output"}); commit is local, run tl sync push when ready.`;
+    }
+    const branch = git(cloneDir, ["rev-parse", "--abbrev-ref", "HEAD"]).out.trim() || ws?.defaultBranch || "main";
+    const ownerName = repoOwnerName(ws?.repo || "");
+    const githubBase = ownerName ? `https://github.com/${ownerName}/blob/${branch}/${baseRel}` : null;
+    const urls = {};
+    if (githubBase) for (const rel of Object.keys(files)) urls[rel] = `${githubBase}/${rel.split("/").map(encodeURIComponent).join("/")}`;
+    return ok2(
+      `Delivered ${fileCount} artifact file(s) for "${slug}" to ${baseRel} in ${cloneDir}.${committed ? opts.noPush ? " Committed locally (no push)." : pushed ? " Committed and pushed." : pushNote : " Nothing changed since the last delivery."}${githubBase ? `
+View on GitHub: ${githubBase}` : ""}`,
+      { cloneDir, dir: baseRel, session: slug, files: Object.keys(files), count: fileCount, committed, pushed, branch, repo: ownerName, githubBase, urls }
+    );
+  } catch (e) {
+    return fail2(`tl_artifacts error: ${e.message}`);
+  }
+}
+
+// core/notion-io.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync7 } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname6, join as join7 } from "path";
+
+// core/notion.ts
+var NOTION_FREE_FILE_LIMIT = 5 * 1024 * 1024;
+var RICH_TEXT_MAX = 2e3;
+var CHILDREN_MAX = 100;
+var obj2 = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+var str3 = (v) => typeof v === "string" ? v : "";
+var rtSeg = (content, ann, link) => ({
+  type: "text",
+  text: { content, ...link ? { link: { url: link } } : {} },
+  ...ann ? { annotations: ann } : {}
+});
+function chunkRichText(text, ann, link) {
+  const s = String(text ?? "");
+  if (s.length <= RICH_TEXT_MAX) return [rtSeg(s, ann, link)];
+  const out = [];
+  for (let i = 0; i < s.length; i += RICH_TEXT_MAX) out.push(rtSeg(s.slice(i, i + RICH_TEXT_MAX), ann, link));
+  return out;
+}
+function inline(text) {
+  const out = [];
+  const re = /\*\*([^*]+)\*\*|`([^`]+)`/g;
+  let last = 0;
+  let m;
+  while (m = re.exec(text)) {
+    if (m.index > last) out.push(...chunkRichText(text.slice(last, m.index)));
+    if (m[1] != null) out.push(...chunkRichText(m[1], { bold: true }));
+    else if (m[2] != null) out.push(...chunkRichText(m[2], { code: true }));
+    last = re.lastIndex;
+  }
+  if (last < text.length) out.push(...chunkRichText(text.slice(last)));
+  return out.length ? out : [rtSeg("")];
+}
+var para = (text) => ({ object: "block", type: "paragraph", paragraph: { rich_text: inline(text) } });
+var heading = (level, text) => {
+  const t = `heading_${level}`;
+  return { object: "block", type: t, [t]: { rich_text: inline(text) } };
+};
+var bullet = (text) => ({ object: "block", type: "bulleted_list_item", bulleted_list_item: { rich_text: inline(text) } });
+var numbered = (text) => ({ object: "block", type: "numbered_list_item", numbered_list_item: { rich_text: inline(text) } });
+var quote = (text) => ({ object: "block", type: "quote", quote: { rich_text: inline(text) } });
+var callout = (text, emoji = "\u{1F4A1}") => ({ object: "block", type: "callout", callout: { rich_text: inline(text), icon: { type: "emoji", emoji } } });
+var divider = () => ({ object: "block", type: "divider", divider: {} });
+var codeBlock = (text, language = "plain text") => ({ object: "block", type: "code", code: { rich_text: chunkRichText(text), language } });
+function table(headers, rows) {
+  const toRow = (cells) => ({ object: "block", type: "table_row", table_row: { cells: cells.map((c) => chunkRichText(c)) } });
+  return {
+    object: "block",
+    type: "table",
+    table: { table_width: headers.length, has_column_header: true, has_row_header: false, children: [toRow(headers), ...rows.map(toRow)] }
+  };
+}
+function markdownToBlocks(md) {
+  const lines = String(md ?? "").split("\n");
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    const raw = lines[i] ?? "";
+    const t = raw.trim();
+    if (t.startsWith("```")) {
+      const buf = [];
+      i++;
+      while (i < lines.length && !(lines[i] ?? "").trim().startsWith("```")) {
+        buf.push(lines[i] ?? "");
+        i++;
+      }
+      i++;
+      out.push(codeBlock(buf.join("\n")));
+      continue;
+    }
+    if (!t) {
+      i++;
+      continue;
+    }
+    if (t === "---" || t === "***" || t === "___") {
+      out.push(divider());
+      i++;
+      continue;
+    }
+    const mh = t.match(/^(#{1,6})\s+(.*)$/);
+    if (mh) {
+      out.push(heading(Math.min(3, mh[1].length), mh[2]));
+      i++;
+      continue;
+    }
+    if (t.startsWith("> ")) {
+      out.push(quote(t.slice(2)));
+      i++;
+      continue;
+    }
+    const mb = t.match(/^[-*]\s+(.*)$/);
+    if (mb) {
+      out.push(bullet(mb[1]));
+      i++;
+      continue;
+    }
+    const mn = t.match(/^\d+\.\s+(.*)$/);
+    if (mn) {
+      out.push(numbered(mn[1]));
+      i++;
+      continue;
+    }
+    out.push(para(t));
+    i++;
+  }
+  return out;
+}
+function chunkChildren(blocks, size = CHILDREN_MAX) {
+  const out = [];
+  for (let i = 0; i < blocks.length; i += size) out.push(blocks.slice(i, i + size));
+  return out.length ? out : [[]];
+}
+function artifactCategory(path) {
+  if (path.startsWith("Brand/")) return "Brand";
+  if (path.startsWith("Deploy/")) return "Deploy";
+  if (path.startsWith("LandingPage/")) return "Landing";
+  if (path.endsWith(".svg")) return "Infographic";
+  if (path === "BuildPrompt.md") return "Build prompt";
+  return "Doc";
+}
+var WIKI_AREAS = [
+  { key: "big-idea", title: "The Big Idea", emoji: "\u{1F4A1}" },
+  { key: "business-model", title: "Business Model", emoji: "\u{1F4B0}" },
+  { key: "brand", title: "Brand", emoji: "\u{1F3A8}" },
+  { key: "market-research", title: "Market Research", emoji: "\u{1F4CA}" },
+  { key: "strategy", title: "Strategy", emoji: "\u{1F4C8}" },
+  { key: "product", title: "Product (PRD)", emoji: "\u{1F4CB}" },
+  { key: "compliance", title: "Compliance & Tax", emoji: "\u2696\uFE0F" },
+  { key: "decision-science", title: "Decision Science", emoji: "\u{1F9ED}" },
+  { key: "library", title: "Library", emoji: "\u{1F4DA}" }
+];
+function buildWikiPlan(state, opts = {}) {
+  const answers = obj2(state.answers);
+  const brand = state.brand && typeof state.brand === "object" ? state.brand : null;
+  const guide = brand?.guide || null;
+  const grill = state.grill && typeof state.grill === "object" ? state.grill : null;
+  const swot = state.swot && typeof state.swot === "object" ? state.swot : null;
+  const prd = obj2(state.prd);
+  const bizModel = obj2(state.bizModel);
+  const research = obj2(state.research);
+  const assumptions = bizModel["assumptions"] || null;
+  const brandName = str3(guide?.brandName) || "Your Product";
+  const oneLiner = str3(answers["what-statement"]) || str3(answers["pitch"]) || str3(guide?.positioning);
+  const overview = [];
+  if (oneLiner) overview.push(callout(oneLiner, "\u{1F4A1}"));
+  overview.push(para("This private workspace was generated by The Thought Layer. Each section below is a page; the Artifacts database links the files delivered to your repo."));
+  const areaBlocks = {};
+  {
+    const b = [];
+    if (oneLiner) b.push(heading(2, "What it is"), callout(oneLiner, "\u{1F3AF}"));
+    if (guide?.positioning) b.push(heading(2, "Who it is for"), para(guide.positioning));
+    const press = str3(answers["press-release"]);
+    if (press) b.push(heading(2, "The press release"), ...markdownToBlocks(press));
+    areaBlocks["big-idea"] = b;
+  }
+  {
+    const b = [];
+    const proj = computeProjection(assumptions);
+    if (proj && assumptions) {
+      const s = proj.summary;
+      const cur = assumptions.currency || "USD";
+      b.push(heading(2, "The numbers"));
+      b.push(callout(
+        `Year 1 revenue ${fmtMoney(s.year1Revenue, cur)}. Monthly break-even ${s.breakEvenMonth ? `month ${s.breakEvenMonth}` : "beyond horizon"}. Max cash drawdown ${fmtMoney(s.maxDrawdown, cur)}. MRR at month ${s.horizon} is ${fmtMoney(s.endingMRR, cur)}.`,
+        "\u{1F4B0}"
+      ));
+      const rows = (assumptions.parties || []).slice(0, 12).map((p) => [
+        str3(p.name) || p.id,
+        str3(p.role),
+        String(p.startingCount ?? ""),
+        String(p.monthlyNewBase ?? ""),
+        `${p.monthlyChurnPct ?? 0}%`,
+        fmtMoney(Number(p.revenuePerUnitPerMonth) || 0, cur),
+        fmtMoney(Number(p.cacPerUnit) || 0, cur)
+      ]);
+      b.push(heading(2, "Parties"), table(["Party", "Role", "Start", "New/mo", "Churn", "Rev/unit/mo", "CAC"], rows));
+      if (assumptions.narrative) b.push(heading(2, "Notes"), para(assumptions.narrative));
+    }
+    areaBlocks["business-model"] = b;
+  }
+  {
+    const b = [];
+    if (guide) {
+      b.push(...markdownToBlocks(brandGuideMarkdown(guide)));
+      const pal = (guide.palette || []).filter((p) => p?.hex);
+      if (pal.length) b.push(heading(2, "Palette"), table(["Color", "Hex", "Role"], pal.map((p) => [str3(p.name), str3(p.hex), str3(p.role)])));
+    }
+    areaBlocks["brand"] = b;
+  }
+  {
+    const b = [];
+    const brief = str3(research["brief"]);
+    if (brief) {
+      const desc = str3(research["description"]);
+      if (desc) b.push(callout(desc, "\u{1F4CA}"));
+      b.push(...markdownToBlocks(brief));
+    }
+    areaBlocks["market-research"] = b;
+  }
+  {
+    const b = [];
+    const hasSwot = !!swot && Object.values(swot).some((v) => Array.isArray(v) && v.some((x) => x && String(x).trim()));
+    if (hasSwot) b.push(...markdownToBlocks(swotMarkdown(swot)));
+    areaBlocks["strategy"] = b;
+  }
+  {
+    const b = [];
+    const prdMd = str3(prd["markdown"]);
+    if (prdMd) b.push(...markdownToBlocks(prdMd));
+    if (grill?.requirements?.length) {
+      b.push(divider());
+      b.push(...markdownToBlocks(requirementsMarkdown(grill)));
+    }
+    if (grill?.glossary?.length) {
+      b.push(divider());
+      b.push(...markdownToBlocks(glossaryMarkdown(grill)));
+    }
+    areaBlocks["product"] = b;
+  }
+  {
+    const b = [];
+    const report = str3(obj2(state.governance)["report"]);
+    if (report.trim()) b.push(...markdownToBlocks(report));
+    areaBlocks["compliance"] = b;
+  }
+  {
+    const b = [];
+    const dq = Object.keys(answers).filter((k) => /^(dq|decision)/i.test(k) && str3(answers[k]).trim());
+    if (dq.length) {
+      b.push(heading(2, "Decision records"));
+      for (const k of dq) b.push(bullet(`**${k}**: ${str3(answers[k])}`));
+    }
+    areaBlocks["decision-science"] = b;
+  }
+  areaBlocks["library"] = [];
+  const areas = WIKI_AREAS.map((a) => ({ ...a, blocks: areaBlocks[a.key] || [] })).filter((a) => a.blocks.length > 0);
+  const urls = opts.urls || {};
+  const files = opts.manifest?.files || [];
+  const artifacts = files.filter((f) => !(f.path.startsWith("LandingPage/") && f.path !== "LandingPage/index.html")).map((f) => ({ name: f.path, path: f.path, category: artifactCategory(f.path), bytes: f.bytes, ...urls[f.path] ? { url: urls[f.path] } : {} }));
+  return { title: `${brandName} workspace`, icon: "\u{1F680}", overview, areas, artifacts };
+}
+
+// core/notion-io.ts
+var NOTION_API = "https://api.notion.com/v1";
+var NOTION_VERSION = "2022-06-28";
+var MIN_INTERVAL_MS = 350;
+var TOKEN_ENVS = ["THOUGHT_LAYER_NOTION_TOKEN", "NOTION_TOKEN"];
+var ok3 = (message, details = {}) => ({ ok: true, message, details });
+var fail3 = (message, details = {}) => ({ ok: false, message, details });
+function notionConfigPath() {
+  return process.env["THOUGHT_LAYER_NOTION_CONFIG"] || join7(homedir2(), ".thought-layer", "notion.json");
+}
+function loadNotionConfig() {
+  const p = notionConfigPath();
+  if (!existsSync6(p)) return { schema: 1, sessions: {} };
+  try {
+    const raw = JSON.parse(readFileSync5(p, "utf8"));
+    const sessions = raw["sessions"] && typeof raw["sessions"] === "object" ? raw["sessions"] : {};
+    return { schema: 1, sessions };
+  } catch {
+    return { schema: 1, sessions: {} };
+  }
+}
+function saveNotionConfig(cfg) {
+  const p = notionConfigPath();
+  mkdirSync6(dirname6(p), { recursive: true });
+  writeFileSync7(p, JSON.stringify(cfg, null, 2) + "\n");
+}
+function pageIdFromInput(s) {
+  const t = String(s || "").trim();
+  const dashed = t.match(/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/);
+  if (dashed) return dashed[0].toLowerCase();
+  const runs = t.match(/[0-9a-fA-F]{32}/g);
+  if (!runs || !runs.length) return null;
+  const id = runs[runs.length - 1].toLowerCase();
+  return `${id.slice(0, 8)}-${id.slice(8, 12)}-${id.slice(12, 16)}-${id.slice(16, 20)}-${id.slice(20)}`;
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var Notion = class {
+  constructor(token) {
+    this.token = token;
+  }
+  token;
+  last = 0;
+  async call(method, path, body) {
+    for (let attempt = 0; ; attempt++) {
+      const wait = MIN_INTERVAL_MS - (Date.now() - this.last);
+      if (wait > 0) await sleep(wait);
+      this.last = Date.now();
+      const res = await fetch(`${NOTION_API}${path}`, {
+        method,
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          "Notion-Version": NOTION_VERSION,
+          "Content-Type": "application/json"
+        },
+        ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+      });
+      if (res.status === 429 && attempt < 4) {
+        const retry = Number(res.headers.get("Retry-After")) || Math.pow(2, attempt);
+        await sleep(retry * 1e3);
+        continue;
+      }
+      let json = {};
+      try {
+        json = await res.json();
+      } catch {
+      }
+      return { status: res.status, json };
+    }
+  }
+  async pageExists(id) {
+    const r = await this.call("GET", `/pages/${id}`);
+    return r.status === 200 && r.json["archived"] !== true;
+  }
+  async createPage(parentPageId, title, emoji) {
+    const r = await this.call("POST", "/pages", {
+      parent: { page_id: parentPageId },
+      ...emoji ? { icon: { type: "emoji", emoji } } : {},
+      properties: { title: { title: [{ text: { content: title } }] } }
+    });
+    if (r.status !== 200) throw new Error(notionErr("create page", r));
+    return String(r.json["id"]);
+  }
+  // Replace a page's content: delete every existing child, then append the new
+  // blocks in <=100-block batches.
+  async replaceChildren(pageId, blocks) {
+    let cursor;
+    do {
+      const q = cursor ? `?start_cursor=${cursor}&page_size=100` : "?page_size=100";
+      const r = await this.call("GET", `/blocks/${pageId}/children${q}`);
+      if (r.status !== 200) break;
+      for (const b of r.json["results"] || []) await this.call("DELETE", `/blocks/${b.id}`);
+      cursor = r.json["has_more"] ? String(r.json["next_cursor"]) : void 0;
+    } while (cursor);
+    for (const batch of chunkChildren(blocks)) {
+      if (!batch.length) continue;
+      const r = await this.call("PATCH", `/blocks/${pageId}/children`, { children: batch });
+      if (r.status !== 200) throw new Error(notionErr("append blocks", r));
+    }
+  }
+  async createArtifactsDb(parentPageId, artifacts) {
+    const cats = Array.from(new Set(artifacts.map((a) => a.category)));
+    const r = await this.call("POST", "/databases", {
+      parent: { type: "page_id", page_id: parentPageId },
+      title: [{ text: { content: "Artifacts" } }],
+      icon: { type: "emoji", emoji: "\u{1F4CE}" },
+      properties: {
+        Name: { title: {} },
+        Category: { select: { options: cats.map((c) => ({ name: c })) } },
+        Size: { rich_text: {} },
+        Link: { url: {} }
+      }
+    });
+    if (r.status !== 200) throw new Error(notionErr("create database", r));
+    return String(r.json["id"]);
+  }
+  async addArtifactRow(dbId, a) {
+    await this.call("POST", "/pages", {
+      parent: { database_id: dbId },
+      properties: {
+        Name: { title: [{ text: { content: a.name } }] },
+        Category: { select: { name: a.category } },
+        Size: { rich_text: [{ text: { content: humanSize(a.bytes) } }] },
+        ...a.url ? { Link: { url: a.url } } : {}
+      }
+    });
+  }
+};
+function notionErr(what, r) {
+  const msg = String(r.json["message"] || "").slice(0, 200);
+  return `Notion ${what} failed (${r.status})${msg ? `: ${msg}` : ""}`;
+}
+function humanSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+async function runWiki(opts) {
+  try {
+    const cfg = loadConfig();
+    const { cloneDir, ws } = resolveWorkspace(opts, cfg);
+    if (!isGitRepo(cloneDir)) {
+      return fail3(`No sessions workspace at ${cloneDir}. Run tl sync init then tl artifacts before building the wiki.`, { cloneDir });
+    }
+    const slug = slugify(opts.name || ws?.activeSession?.replace(/\.json$/, "") || "");
+    if (!slug) return fail3("Name the session to publish: tl wiki --name <name>.");
+    const sessionPath = join7(cloneDir, STATE_DIR, `${slug}.json`);
+    const useExplicit = !!(opts.path && opts.path.trim() || (process.env["THOUGHT_LAYER_STATE"] || "").trim());
+    const loaded = loadStateFile(useExplicit ? opts.path : existsSync6(sessionPath) ? sessionPath : opts.path);
+    if (!loaded.exists) return fail3(`No session "${slug}" found (looked at ${loaded.path}). Save it first with tl sync save --name ${slug}.`, { cloneDir });
+    const artifactsDir = join7(cloneDir, "artifacts", slug);
+    let manifest = null;
+    const manifestPath = join7(artifactsDir, "artifacts.json");
+    if (existsSync6(manifestPath)) {
+      try {
+        manifest = JSON.parse(readFileSync5(manifestPath, "utf8"));
+      } catch {
+        manifest = null;
+      }
+    }
+    const branch = git(cloneDir, ["rev-parse", "--abbrev-ref", "HEAD"]).out.trim() || ws?.defaultBranch || "main";
+    const ownerName = repoOwnerName(ws?.repo || "");
+    const urls = {};
+    if (ownerName && manifest) {
+      const base = `https://github.com/${ownerName}/blob/${branch}/artifacts/${slug}`;
+      for (const f of manifest.files) urls[f.path] = `${base}/${f.path.split("/").map(encodeURIComponent).join("/")}`;
+    }
+    const plan = buildWikiPlan(loaded.state, { manifest, urls });
+    const blockCount = plan.overview.length + plan.areas.reduce((n, a) => n + a.blocks.length, 0);
+    if (opts.dryRun) {
+      const areaList = plan.areas.map((a) => `${a.emoji} ${a.title} (${a.blocks.length} blocks)`).join(", ");
+      return ok3(
+        `Dry run for "${plan.title}": ${plan.areas.length} area page(s), ${blockCount} blocks total, ${plan.artifacts.length} artifact(s) in the database.
+Areas: ${areaList || "(none with content yet)"}.${manifest ? "" : "\nNo delivered artifacts found; run tl artifacts first to populate the Artifacts database with GitHub links."}`,
+        { title: plan.title, areas: plan.areas.map((a) => ({ key: a.key, blocks: a.blocks.length })), blockCount, artifacts: plan.artifacts.length, delivered: !!manifest }
+      );
+    }
+    const token = TOKEN_ENVS.map((e) => process.env[e]).find((v) => v && v.trim())?.trim() || "";
+    if (!token) {
+      return fail3(
+        "No Notion token. Create an internal integration at https://www.notion.so/my-integrations, copy its secret, and set THOUGHT_LAYER_NOTION_TOKEN. Then share a Notion page with the integration and pass it as --parent-page.",
+        { needs: "token" }
+      );
+    }
+    const ncfg = loadNotionConfig();
+    const entry = ncfg.sessions[slug] || {};
+    const notion = new Notion(token);
+    let rootId = opts.replace ? "" : entry.rootPageId || "";
+    if (rootId && !await notion.pageExists(rootId)) rootId = "";
+    if (!rootId) {
+      const parentInput = opts.parentPage || process.env["THOUGHT_LAYER_NOTION_PARENT"] || "";
+      const parentId = pageIdFromInput(parentInput);
+      if (!parentId) {
+        return fail3(
+          "No Notion parent page. Share a page with your integration in Notion (Share, then add your integration), then pass it as --parent-page <id or url>.",
+          { needs: "parent-page" }
+        );
+      }
+      if (!await notion.pageExists(parentId)) {
+        return fail3(`Notion cannot see the parent page ${parentId}. In Notion, open the page, click Share, and add your integration so it has access.`, { needs: "share" });
+      }
+      rootId = await notion.createPage(parentId, plan.title, plan.icon);
+      entry.areaPageIds = {};
+      entry.artifactsDbId = void 0;
+    }
+    await notion.replaceChildren(rootId, plan.overview);
+    const areaIds = entry.areaPageIds || {};
+    for (const area of plan.areas) {
+      let pid = areaIds[area.key] || "";
+      if (pid && !await notion.pageExists(pid)) pid = "";
+      if (!pid) pid = await notion.createPage(rootId, `${area.emoji} ${area.title}`, area.emoji);
+      areaIds[area.key] = pid;
+      await notion.replaceChildren(pid, area.blocks);
+    }
+    let dbId = entry.artifactsDbId || "";
+    if (plan.artifacts.length && (!dbId || opts.replace)) {
+      dbId = await notion.createArtifactsDb(rootId, plan.artifacts);
+      for (const a of plan.artifacts) await notion.addArtifactRow(dbId, a);
+    }
+    ncfg.sessions[slug] = { rootPageId: rootId, areaPageIds: areaIds, artifactsDbId: dbId || void 0, updatedAt: Date.now() };
+    saveNotionConfig(ncfg);
+    const rootUrl = `https://www.notion.so/${rootId.replace(/-/g, "")}`;
+    return ok3(
+      `Built the "${plan.title}" wiki in Notion: ${plan.areas.length} area page(s), ${blockCount} blocks, ${plan.artifacts.length} artifact(s) listed.${manifest ? "" : " No delivered artifacts were found, so the Artifacts database links are empty; run tl artifacts first."}
+Open it: ${rootUrl}`,
+      { title: plan.title, rootPageId: rootId, rootUrl, areas: plan.areas.length, blockCount, artifacts: plan.artifacts.length }
+    );
+  } catch (e) {
+    return fail3(`tl_wiki error: ${e.message}`);
+  }
+}
+
 // bin/tl.ts
 var HELP = `tl - read/write a portable Thought Layer state file (default: .thought-layer/state.json)
 
@@ -1455,6 +3215,12 @@ var HELP = `tl - read/write a portable Thought Layer state file (default: .thoug
   tl scaffold [--out dist] [--domain x.com] [--founder "Name"]  deterministic deployable static site from the spec + brand
   tl deploy [--dry-run] [--anonymous] [--name x] [--site id]  take build.json's publish dir live to a user-owned Netlify URL
             [--static-only] [--provision-db] [--apply-schema]   when build.json has a backend: ships functions+env by default; flags opt out or add Neon provision/schema
+  tl sync <init|save|list|open|pull|push|status>             store/sync your session files in your own private GitHub repo
+            [--repo owner/name] [--name x] [--dir p] [--workspace w] [--message m] [--no-push]
+  tl artifacts [--name x] [--workspace w]                    deliver the full asset bundle (PRD, brand, infographics, landing, deploy rules) to your sessions repo
+            [--no-push] [--no-deliver] [--domain x.com] [--founder "Name"]
+  tl wiki [--parent-page id|url] [--name x]                  build/refresh a private Notion wiki from the session + delivered artifacts
+            [--workspace w] [--replace] [--dry-run]            (set THOUGHT_LAYER_NOTION_TOKEN; share a Notion page with your integration)
   tl export [path]                   handoff check
   tl answer <qId> <value> [path]     record an answer
   tl feedback --data '<json>'        record a panel verdict ({qId,mode,personas,endState,round})
@@ -1489,7 +3255,7 @@ function parseArgs(argv) {
 function readData(flags) {
   const d = flags["data"];
   if (d === void 0) return void 0;
-  const raw = d === "-" || d === true ? readFileSync3(0, "utf8") : String(d);
+  const raw = d === "-" || d === true ? readFileSync6(0, "utf8") : String(d);
   try {
     return JSON.parse(raw);
   } catch {
@@ -1563,6 +3329,61 @@ function main() {
     });
     return;
   }
+  if (args[0] === "sync") {
+    runSync(
+      {
+        op: typeof args[1] === "string" ? args[1] : "status",
+        name: typeof flags["name"] === "string" ? flags["name"] : void 0,
+        repo: typeof flags["repo"] === "string" ? flags["repo"] : void 0,
+        dir: typeof flags["dir"] === "string" ? flags["dir"] : void 0,
+        workspace: typeof flags["workspace"] === "string" ? flags["workspace"] : void 0,
+        message: typeof flags["message"] === "string" ? flags["message"] : void 0,
+        noPush: flags["no-push"] === true,
+        path: typeof flags["path"] === "string" ? flags["path"] : void 0
+      },
+      { ts: Date.now(), exportedAt: (/* @__PURE__ */ new Date()).toISOString() }
+    ).then((r2) => {
+      if (flags["json"]) console.log(JSON.stringify(r2.details, null, 2));
+      else console.log(r2.message);
+      process.exit(r2.ok ? 0 : 1);
+    });
+    return;
+  }
+  if (args[0] === "artifacts") {
+    const r2 = runArtifacts(
+      {
+        path: typeof flags["path"] === "string" ? flags["path"] : void 0,
+        name: typeof flags["name"] === "string" ? flags["name"] : void 0,
+        workspace: typeof flags["workspace"] === "string" ? flags["workspace"] : void 0,
+        dir: typeof flags["dir"] === "string" ? flags["dir"] : void 0,
+        message: typeof flags["message"] === "string" ? flags["message"] : void 0,
+        noPush: flags["no-push"] === true,
+        noDeliver: flags["no-deliver"] === true,
+        domain: typeof flags["domain"] === "string" ? flags["domain"] : void 0,
+        founderName: typeof flags["founder"] === "string" ? flags["founder"] : void 0
+      },
+      { generatedAt: (/* @__PURE__ */ new Date()).toISOString() }
+    );
+    if (flags["json"]) console.log(JSON.stringify(r2.details, null, 2));
+    else console.log(r2.message);
+    process.exit(r2.ok ? 0 : 1);
+  }
+  if (args[0] === "wiki") {
+    runWiki({
+      path: typeof flags["path"] === "string" ? flags["path"] : void 0,
+      name: typeof flags["name"] === "string" ? flags["name"] : void 0,
+      workspace: typeof flags["workspace"] === "string" ? flags["workspace"] : void 0,
+      dir: typeof flags["dir"] === "string" ? flags["dir"] : void 0,
+      parentPage: typeof flags["parent-page"] === "string" ? flags["parent-page"] : void 0,
+      replace: flags["replace"] === true,
+      dryRun: flags["dry-run"] === true
+    }).then((r2) => {
+      if (flags["json"]) console.log(JSON.stringify(r2.details, null, 2));
+      else console.log(r2.message);
+      process.exit(r2.ok ? 0 : 1);
+    });
+    return;
+  }
   let payload;
   try {
     payload = buildOp(args, flags);