@hobocode/thought-layer 0.2.2 → 0.4.0

package/dist/tl.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // bin/tl.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 
 // core/scoring.ts
 var CONFIDENCE_GOAL = 0.85;
@@ -397,11 +397,564 @@ Pick one with --path .thought-layer/<name>.json, or set ${STATE_ENV} for the ses
   }
 }
 
+// core/scaffold-io.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2, resolve as resolve2 } from "path";
+
+// core/scaffold.ts
+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 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 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"]),
+    personality: Array.isArray(guide["personality"]) ? guide["personality"].filter((x) => typeof x === "string") : [],
+    palette: {
+      primary: role("primary", palette[0]?.hex || "#1f3a5f"),
+      accent: role("accent|secondary", 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")
+    },
+    displayFont: fontOf(typography["display"], "Inter"),
+    bodyFont: fontOf(typography["body"], "Inter"),
+    voiceTone: str(voice["tone"]),
+    logoSvg: chosen?.svg || void 0,
+    pricing: str(answers["pricing-model"]) || void 0
+  };
+}
+function indexHtml(spec, opts) {
+  const domain = (opts.domain || "https://example.com").replace(/\/+$/, "");
+  const founder = opts.founderName || "";
+  const social = opts.socialImage || `${domain}/og-image.png`;
+  const name = esc(spec.brandName);
+  const headline = esc(spec.tagline || spec.brandName);
+  const lead = esc(spec.pitch || spec.positioning);
+  const desc = esc(spec.pitch || spec.positioning || spec.brandName);
+  const fonts = `https://fonts.googleapis.com/css2?family=${fam(spec.displayFont)}:wght@400;600;700;800&family=${fam(spec.bodyFont)}:wght@400;500;600&display=swap`;
+  const graph = [
+    { "@type": "Organization", "@id": `${domain}/#org`, name: spec.brandName, url: `${domain}/`, ...founder ? { founder: { "@id": `${domain}/#founder` } } : {} },
+    ...founder ? [{ "@type": "Person", "@id": `${domain}/#founder`, name: founder, worksFor: { "@id": `${domain}/#org` } }] : [],
+    { "@type": "WebSite", "@id": `${domain}/#website`, url: `${domain}/`, name: spec.brandName, publisher: { "@id": `${domain}/#org` } },
+    { "@type": "WebPage", "@id": `${domain}/#webpage`, url: `${domain}/`, name: `${spec.brandName}${spec.tagline ? " - " + spec.tagline : ""}`, isPartOf: { "@id": `${domain}/#website` }, about: { "@id": `${domain}/#org` }, description: spec.pitch || spec.positioning || spec.brandName }
+  ];
+  const jsonLd = JSON.stringify({ "@context": "https://schema.org", "@graph": graph }).replace(/</g, "\\u003c").replace(/>/g, "\\u003e");
+  const lockup = spec.logoSvg ? spec.logoSvg : `<span class="wordmark">${name}</span>`;
+  const pills = spec.personality.map((t) => `<li class="pill">${esc(t)}</li>`).join("");
+  const positioningSection = spec.positioning ? `<section class="value" aria-labelledby="value-h"><div class="wrap"><h2 id="value-h">Who it is for</h2><p>${esc(spec.positioning)}</p>${pills ? `<ul class="pills" aria-label="What it stands for">${pills}</ul>` : ""}</div></section>` : "";
+  const pricingSection = spec.pricing ? `<section class="pricing" aria-labelledby="pricing-h"><div class="wrap"><h2 id="pricing-h">Pricing</h2><p class="price">${esc(spec.pricing)}</p></div></section>` : "";
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${name}${spec.tagline ? " - " + headline : ""}</title>
+<meta name="description" content="${desc}">
+<link rel="canonical" href="${domain}/">
+<meta property="og:type" content="website">
+<meta property="og:title" content="${name}">
+<meta property="og:description" content="${desc}">
+<meta property="og:url" content="${domain}/">
+<meta property="og:image" content="${esc(social)}">
+<meta name="twitter:card" content="summary_large_image">
+<meta name="twitter:title" content="${name}">
+<meta name="twitter:description" content="${desc}">
+<meta name="twitter:image" content="${esc(social)}">
+<link href="${esc(fonts)}" rel="stylesheet">
+<script type="application/ld+json">${jsonLd}</script>
+<style>
+:root{--p:${spec.palette.primary};--a:${spec.palette.accent};--ink:${spec.palette.ink};--su:${spec.palette.surface};--mu:${spec.palette.muted};--disp:'${spec.displayFont}',system-ui,sans-serif;--body:'${spec.bodyFont}',system-ui,sans-serif}
+*{margin:0;padding:0;box-sizing:border-box}
+html{scroll-behavior:smooth}
+body{background:var(--su);color:var(--ink);font-family:var(--body);line-height:1.6;-webkit-font-smoothing:antialiased}
+.wrap{max-width:960px;margin:0 auto;padding:0 24px}
+a{color:var(--a)}
+:focus-visible{outline:3px solid var(--a);outline-offset:2px}
+.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);border:0}
+header{padding:24px 0}
+header .wrap{display:flex;align-items:center;justify-content:space-between;gap:16px}
+.wordmark{font-family:var(--disp);font-weight:800;font-size:22px;color:var(--p)}
+.logo svg,.logo img{height:36px;width:auto}
+.cta{display:inline-block;background:var(--p);color:#fff;text-decoration:none;font-weight:600;padding:12px 22px;border-radius:10px;border:0;cursor:pointer;font-size:15px}
+.cta.alt{background:var(--a)}
+.hero{padding:72px 0 56px}
+.hero h1{font-family:var(--disp);font-weight:800;font-size:clamp(34px,6vw,60px);line-height:1.05;color:var(--ink);letter-spacing:-0.02em;max-width:14ch}
+.hero p.lead{font-size:clamp(17px,2.4vw,22px);opacity:.82;margin:20px 0 28px;max-width:42ch}
+.signup{display:flex;gap:10px;flex-wrap:wrap;max-width:460px}
+.signup input[type=email]{flex:1 1 220px;padding:12px 14px;border:1px solid var(--mu);border-radius:10px;font:inherit;background:#fff;color:var(--ink)}
+.value,.pricing{padding:48px 0;border-top:1px solid color-mix(in srgb,var(--mu) 40%,transparent)}
+.value h2,.pricing h2{font-family:var(--disp);font-weight:700;font-size:28px;margin-bottom:12px}
+.value p{max-width:54ch;opacity:.85}
+ul.pills{list-style:none;display:flex;flex-wrap:wrap;gap:10px;margin-top:22px}
+.pill{font-size:13px;font-weight:600;color:var(--p);background:color-mix(in srgb,var(--p) 12%,transparent);padding:6px 14px;border-radius:999px}
+.pricing .price{font-family:var(--disp);font-size:24px;font-weight:700;color:var(--p);margin-top:8px}
+footer{padding:48px 0;border-top:1px solid color-mix(in srgb,var(--mu) 40%,transparent);color:var(--mu);font-size:13px}
+@media (max-width:640px){.hero{padding:48px 0 40px}header .wrap{flex-direction:column;align-items:flex-start}}
+</style>
+</head>
+<body>
+<header><div class="wrap"><div class="logo">${lockup}</div><a class="cta" href="#get-started">Get early access</a></div></header>
+<main>
+<section class="hero" aria-labelledby="hero-h"><div class="wrap">
+<h1 id="hero-h">${headline}</h1>
+<p class="lead">${lead}</p>
+<form name="signups" id="get-started" method="POST" data-netlify="true" class="signup">
+<input type="hidden" name="form-name" value="signups">
+<label class="sr-only" for="email">Email address</label>
+<input id="email" type="email" name="email" placeholder="you@email.com" required>
+<button type="submit" class="cta alt">Get early access</button>
+</form>
+</div></section>
+${positioningSection}
+${pricingSection}
+</main>
+<footer><div class="wrap"><p>${name}${founder ? ` - by ${esc(founder)}` : ""}. Scaffolded by The Thought Layer.</p></div></footer>
+</body>
+</html>
+`;
+}
+function companionFiles(spec, opts) {
+  const domain = (opts.domain || "https://example.com").replace(/\/+$/, "");
+  const name = spec.brandName;
+  const summary = spec.pitch || spec.positioning || name;
+  const llms = `# ${name}
+
+> ${summary}
+
+## About
+${name}${spec.tagline ? ` - ${spec.tagline}` : ""}. ${spec.positioning || summary}
+
+## Pages
+- [Home](${domain}/) - ${spec.tagline || summary}
+
+## FAQ
+- What is ${name}? ${summary}
+- Who is it for? ${spec.positioning || "See the home page."}
+`;
+  const robots = `User-agent: *
+Allow: /
+
+User-agent: GPTBot
+Allow: /
+
+User-agent: ClaudeBot
+Allow: /
+
+User-agent: PerplexityBot
+Allow: /
+
+User-agent: Google-Extended
+Allow: /
+
+Sitemap: ${domain}/sitemap.xml
+`;
+  const sitemap = `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+  <url><loc>${domain}/</loc><changefreq>weekly</changefreq><priority>1.0</priority></url>
+</urlset>
+`;
+  const redirects = `/*  /index.html  200
+`;
+  const netlifyToml = `[build]
+  publish = "."
+
+[[redirects]]
+  from = "/*"
+  to = "/index.html"
+  status = 200
+`;
+  const seoDoc = `# SEO and deployment
+
+This static site was scaffolded deterministically by The Thought Layer. It is ready to deploy (drag the publish folder onto https://app.netlify.com/drop, or use the deploy step). Everything below is already in place; the lines marked TO FILL need your input.
+
+## In place
+- **Structured data**: schema.org JSON-LD (@graph) with Organization, WebSite, and WebPage in index.html.
+- **/llms.txt**: an AI-crawler summary at the site root.
+- **robots.txt**: allows search + AI crawlers and points to the sitemap.
+- **sitemap.xml**: lists the home page.
+- **Canonical + Open Graph + Twitter Card** meta on the page.
+- **_redirects** and **netlify.toml**: SPA fallback (/* -> /index.html).
+- **Email capture**: a Netlify Forms signup ("signups") - submissions appear in your Netlify dashboard after deploy, no backend needed.
+- Semantic, accessible HTML (landmarks, heading order, labelled form, visible focus).
+
+## TO FILL
+- **Domain**: replace ${domain} with your real domain in index.html (canonical/OG), llms.txt, robots.txt, sitemap.xml. Pass --domain to the scaffold tool to set it up front.
+- **Founder + sameAs**: add a Person with real sameAs profile links (LinkedIn, X) to the JSON-LD, and cross-reference the Organization. Pass --founder to seed the name.
+- **Social image**: add a 1200x630 image at /og-image.png (referenced by og:image / twitter:image).
+- **The product**: this is a landing/coming-soon page. Build the actual product with the thought-layer-build skill (/tl-build).
+`;
+  return {
+    "llms.txt": llms,
+    "robots.txt": robots,
+    "sitemap.xml": sitemap,
+    "_redirects": redirects,
+    "netlify.toml": netlifyToml,
+    "SEO.md": seoDoc
+  };
+}
+function buildStarterSite(spec, opts = {}) {
+  return { files: { "index.html": indexHtml(spec, opts), ...companionFiles(spec, opts) } };
+}
+function scaffoldManifest(publishDir, builtAt, provenance) {
+  return {
+    app: "thought-layer",
+    kind: "build",
+    version: 1,
+    builtAt,
+    producer: "scaffold",
+    publishDir,
+    entry: "index.html",
+    stack: "static",
+    hasBackend: false,
+    backendNote: null,
+    buildCommand: null,
+    installCommand: null,
+    nodeVersion: "20",
+    provenance,
+    requirements: { total: 0, built: 0, deferred: 0, deferredIds: [] },
+    seo: { jsonLd: true, llmsTxt: true, sitemap: true, robots: true, canonical: true, openGraph: true, socialImage: false, semanticHtml: true, seoDoc: true, netlifyToml: true },
+    artifacts: { traceability: null, decisions: null, seo: "SEO.md" },
+    verified: { buildRan: true, publishDirExists: true, entryLoads: true, notes: "deterministic static scaffold; landing page + SEO files written" }
+  };
+}
+
+// core/scaffold-io.ts
+function runScaffold(opts, ctx) {
+  try {
+    const loaded = loadStateFile(opts.path);
+    const spec = extractScaffoldSpec(loaded.state);
+    const { files } = buildStarterSite(spec, { domain: opts.domain, founderName: opts.founderName, socialImage: opts.socialImage });
+    const outDir = opts.outDir || "dist";
+    const outAbs = isAbsolute2(outDir) ? outDir : resolve2(process.cwd(), outDir);
+    mkdirSync2(outAbs, { recursive: true });
+    for (const [name, content] of Object.entries(files)) {
+      writeFileSync2(join2(outAbs, name), content);
+    }
+    const prd = loaded.state.prd && typeof loaded.state.prd === "object" ? loaded.state.prd : null;
+    const grill = loaded.state.grill && typeof loaded.state.grill === "object" ? loaded.state.grill : null;
+    const manifest = scaffoldManifest(outDir, ctx.builtAt, {
+      stateFile: loaded.path,
+      prdTs: prd && typeof prd["ts"] === "number" ? prd["ts"] : null,
+      grillDone: !!(grill && grill["done"] === true),
+      fromSpeedrun: loaded.state.kit?.cursor?.phase === "speedrun"
+    });
+    const manifestPath = join2(dirname2(loaded.path), "build.json");
+    mkdirSync2(dirname2(manifestPath), { recursive: true });
+    writeFileSync2(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+    const names = Object.keys(files);
+    return {
+      ok: true,
+      message: `Scaffolded a deployable static site for "${spec.brandName}" -> ${outAbs} (${names.length} files: ${names.join(", ")}). Manifest: ${manifestPath}. Deploy the publish dir, or build the full product with /tl-build.`,
+      details: { publishDir: outDir, outAbs, files: names, manifestPath, brandName: spec.brandName, hadBrand: loaded.state.brand != null }
+    };
+  } catch (e) {
+    return { ok: false, message: `tl_scaffold error: ${e.message}`, details: {} };
+  }
+}
+
+// core/deploy-io.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3, join as join3, relative, resolve as resolve3 } from "path";
+
+// core/deploy.ts
+import { createHash } from "crypto";
+var sha1Hex = (data) => createHash("sha1").update(data).digest("hex");
+function buildFileDigests(files) {
+  const digests = {};
+  const pathForDigest = {};
+  for (const [path, buf] of Object.entries(files)) {
+    const key = normalizeKey(path);
+    const sha = sha1Hex(buf);
+    digests[key] = sha;
+    if (!(sha in pathForDigest)) pathForDigest[sha] = key;
+  }
+  return { digests, pathForDigest };
+}
+function normalizeKey(path) {
+  const posix = path.replace(/\\/g, "/").replace(/^\.?\/*/, "");
+  return "/" + posix;
+}
+function uploadPath(key) {
+  return key.replace(/^\/+/, "").split("/").map(encodeURIComponent).join("/");
+}
+function sanitizeSiteName(raw) {
+  return String(raw || "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40).replace(/-+$/g, "");
+}
+function parseAnonymousOutput(output) {
+  const claim = output.match(/https:\/\/app\.netlify\.com\/claim\S*/);
+  const live = output.match(/https:\/\/[a-z0-9-]+\.netlify\.app\S*/i);
+  return {
+    url: live ? stripTrailingPunctuation(live[0]) : null,
+    claimUrl: claim ? stripTrailingPunctuation(claim[0]) : null
+  };
+}
+var stripTrailingPunctuation = (s) => s.replace(/[).,]+$/, "");
+function deployRecord(input) {
+  return { app: "thought-layer", kind: "deploy", version: 1, provider: "netlify", ...input };
+}
+
+// core/deploy-io.ts
+var NETLIFY_API = "https://api.netlify.com/api/v1";
+function readBuild(target) {
+  const statePath = resolveStatePath(target);
+  const manifestPath = join3(dirname3(statePath), "build.json");
+  if (!existsSync2(manifestPath)) {
+    throw new Error(
+      `No build.json found at ${manifestPath}. Run the build first: the thought-layer-build skill (/tl-build) or the tl_scaffold tool (\`tl scaffold\`) writes the manifest the deploy reads.`
+    );
+  }
+  const manifest = JSON.parse(readFileSync2(manifestPath, "utf8"));
+  const projectRoot = dirname3(dirname3(statePath));
+  const publishDirAbs = resolvePublishDir(manifest.publishDir, projectRoot);
+  return { manifest, manifestPath, publishDirAbs, stateFile: statePath };
+}
+function resolvePublishDir(publishDir, projectRoot) {
+  const candidates = [resolve3(projectRoot, publishDir), resolve3(process.cwd(), publishDir)];
+  for (const c of candidates) if (existsSync2(c)) return c;
+  throw new Error(
+    `Publish dir "${publishDir}" from build.json does not exist (looked in ${candidates.join(" and ")}). Re-run the build, or fix publishDir in build.json.`
+  );
+}
+function walkPublishDir(dir) {
+  const files = {};
+  const walk = (d) => {
+    for (const name of readdirSync2(d)) {
+      const full = join3(d, name);
+      const st = statSync(full);
+      if (st.isDirectory()) walk(full);
+      else if (st.isFile()) {
+        const rel = relative(dir, full).split(/[\\/]/).join("/");
+        files["/" + rel] = readFileSync2(full);
+      }
+    }
+  };
+  walk(dir);
+  return files;
+}
+async function netlifyJson(url, init, token) {
+  const res = await fetch(url, {
+    ...init,
+    headers: { Authorization: `Bearer ${token}`, ...init.headers || {} }
+  });
+  const body = await res.text();
+  if (!res.ok) {
+    throw new Error(`Netlify API ${res.status} ${res.statusText} on ${init.method || "GET"} ${url}: ${body.slice(0, 400)}`);
+  }
+  return body ? JSON.parse(body) : {};
+}
+async function digestDeploy(files, opts) {
+  let siteId = opts.siteId;
+  let adminUrl = "";
+  let siteUrl = "";
+  if (!siteId) {
+    const body = opts.siteName ? JSON.stringify({ name: sanitizeSiteName(opts.siteName) }) : JSON.stringify({});
+    const site = await netlifyJson(`${NETLIFY_API}/sites`, { method: "POST", headers: { "Content-Type": "application/json" }, body }, opts.token);
+    siteId = String(site["id"] || "");
+    adminUrl = String(site["admin_url"] || "");
+    siteUrl = String(site["ssl_url"] || site["url"] || "");
+  }
+  const { digests, pathForDigest } = buildFileDigests(files);
+  const deploy = await netlifyJson(
+    `${NETLIFY_API}/sites/${siteId}/deploys`,
+    { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ files: digests }) },
+    opts.token
+  );
+  const deployId = String(deploy["id"] || "");
+  const required = Array.isArray(deploy["required"]) ? deploy["required"] : [];
+  if (!adminUrl) adminUrl = String(deploy["admin_url"] || "");
+  let uploaded = 0;
+  for (const sha of required) {
+    const key = pathForDigest[sha];
+    const buf = key ? files[key] : void 0;
+    if (!key || !buf) continue;
+    const r = await fetch(`${NETLIFY_API}/deploys/${deployId}/files/${uploadPath(key)}`, {
+      method: "PUT",
+      headers: { Authorization: `Bearer ${opts.token}`, "Content-Type": "application/octet-stream" },
+      body: new Uint8Array(buf)
+      // Buffer is a Uint8Array; this satisfies BodyInit cleanly.
+    });
+    if (!r.ok) throw new Error(`Netlify upload ${r.status} for ${key}: ${(await r.text()).slice(0, 200)}`);
+    uploaded++;
+  }
+  let state = String(deploy["state"] || "");
+  for (let i = 0; i < 30 && state !== "ready" && state !== "error"; i++) {
+    await new Promise((r) => setTimeout(r, 1e3));
+    const d = await netlifyJson(`${NETLIFY_API}/deploys/${deployId}`, { method: "GET" }, opts.token);
+    state = String(d["state"] || "");
+    if (!siteUrl) siteUrl = String(d["ssl_url"] || d["deploy_ssl_url"] || "");
+  }
+  if (state === "error") throw new Error(`Netlify deploy ${deployId} reported state "error".`);
+  return { url: siteUrl, adminUrl, siteId: String(siteId), deployId, uploaded, state: state || "uploaded" };
+}
+function hasNetlifyCli() {
+  try {
+    const r = spawnSync("netlify", ["--version"], { encoding: "utf8", timeout: 15e3 });
+    return r.status === 0;
+  } catch {
+    return false;
+  }
+}
+function cliSupportsAnonymous() {
+  try {
+    const r = spawnSync("netlify", ["deploy", "--help"], { encoding: "utf8", timeout: 15e3 });
+    return `${r.stdout || ""}${r.stderr || ""}`.includes("--allow-anonymous");
+  } catch {
+    return false;
+  }
+}
+function anonymousDeploy(publishDirAbs) {
+  const r = spawnSync(
+    "netlify",
+    ["deploy", "--dir", publishDirAbs, "--prod", "--allow-anonymous"],
+    { encoding: "utf8", timeout: 18e4 }
+  );
+  const raw = `${r.stdout || ""}
+${r.stderr || ""}`.trim();
+  if (r.status !== 0) {
+    throw new Error(`netlify deploy --allow-anonymous failed (exit ${r.status}). Output:
+${raw.slice(0, 800)}`);
+  }
+  return { ...parseAnonymousOutput(raw), raw };
+}
+async function runDeploy(opts, ctx) {
+  let build;
+  try {
+    build = readBuild(opts.path);
+  } catch (e) {
+    return { ok: false, message: e.message, details: {} };
+  }
+  const { manifest, publishDirAbs, stateFile } = build;
+  const files = walkPublishDir(publishDirAbs);
+  const fileCount = Object.keys(files).length;
+  if (fileCount === 0) {
+    return { ok: false, message: `Publish dir ${publishDirAbs} is empty - nothing to deploy.`, details: {} };
+  }
+  const backendWarn = manifest.hasBackend ? ` WARNING: build.json says hasBackend:true${manifest.backendNote ? ` (${manifest.backendNote})` : ""}; this static deploy publishes only the front end - the server part needs serverless functions or a separate host.` : "";
+  const token = process.env.NETLIFY_AUTH_TOKEN || process.env.NETLIFY_TOKEN || "";
+  const writeRecord = (rec) => {
+    const recPath = join3(dirname3(stateFile), "deploy.json");
+    mkdirSync3(dirname3(recPath), { recursive: true });
+    writeFileSync3(recPath, JSON.stringify(rec, null, 2) + "\n");
+    return recPath;
+  };
+  if (opts.dryRun) {
+    const { digests } = buildFileDigests(files);
+    return {
+      ok: true,
+      message: `Dry run: would deploy ${fileCount} files from ${publishDirAbs} (entry ${manifest.entry}) to Netlify via the ${opts.anonymous ? "anonymous CLI" : token ? "BYO-token digest" : "(no token set - would use the anonymous CLI or guide you)"} path.${backendWarn}`,
+      details: { dryRun: true, publishDir: publishDirAbs, entry: manifest.entry, fileCount, files: Object.keys(digests), hasBackend: manifest.hasBackend }
+    };
+  }
+  const wantAnonymous = opts.anonymous || !token;
+  if (wantAnonymous) {
+    const guide = (lead, needs) => ({
+      ok: false,
+      message: lead + `To go live, choose one:
+  1. BYO token (deploys into your own account, owned immediately): set NETLIFY_AUTH_TOKEN and re-run.
+  2. No account: a current Netlify CLI (\`npm i -g netlify-cli@latest\`) then re-run - uses netlify deploy --allow-anonymous for a 1-hour claimable URL.
+  3. Manual: drag ${publishDirAbs} onto https://app.netlify.com/drop.`,
+      details: { publishDir: publishDirAbs, needs }
+    });
+    if (!hasNetlifyCli()) {
+      return guide(
+        opts.anonymous ? "Anonymous deploy needs the Netlify CLI, which is not installed. " : "No NETLIFY_AUTH_TOKEN is set and the Netlify CLI is not installed. ",
+        "token-or-cli"
+      );
+    }
+    if (!cliSupportsAnonymous()) {
+      return guide(
+        "Your Netlify CLI is too old for --allow-anonymous (it shipped 2026-03). ",
+        "newer-cli-or-token"
+      );
+    }
+    try {
+      const { url, claimUrl, raw } = anonymousDeploy(publishDirAbs);
+      const recPath = writeRecord(
+        deployRecord({
+          deployedAt: ctx.deployedAt,
+          mode: "anonymous",
+          publishDir: manifest.publishDir,
+          fileCount,
+          url,
+          adminUrl: null,
+          claimUrl,
+          siteId: null,
+          deployId: null,
+          hasBackend: manifest.hasBackend,
+          backendNote: manifest.backendNote,
+          buildProducer: manifest.producer,
+          stateFile
+        })
+      );
+      return {
+        ok: true,
+        message: `Deployed anonymously.${url ? ` Live: ${url}` : ""}${claimUrl ? `
+Claim it within 1 hour (transfers ownership to your account): ${claimUrl}` : ""}
+Recorded ${recPath}.${backendWarn}` + (!url || !claimUrl ? `
+(Could not parse a URL from the CLI output - see details.raw.)` : ""),
+        details: { mode: "anonymous", url, claimUrl, fileCount, raw }
+      };
+    } catch (e) {
+      return { ok: false, message: e.message, details: { mode: "anonymous" } };
+    }
+  }
+  try {
+    const r = await digestDeploy(files, { token, siteName: opts.siteName, siteId: opts.siteId });
+    const recPath = writeRecord(
+      deployRecord({
+        deployedAt: ctx.deployedAt,
+        mode: "token",
+        publishDir: manifest.publishDir,
+        fileCount,
+        url: r.url || null,
+        adminUrl: r.adminUrl || null,
+        claimUrl: null,
+        siteId: r.siteId,
+        deployId: r.deployId,
+        hasBackend: manifest.hasBackend,
+        backendNote: manifest.backendNote,
+        buildProducer: manifest.producer,
+        stateFile
+      })
+    );
+    return {
+      ok: true,
+      message: `Deployed to your Netlify account (${r.uploaded} file${r.uploaded === 1 ? "" : "s"} uploaded, state ${r.state}).${r.url ? ` Live: ${r.url}` : ""}${r.adminUrl ? `
+Manage: ${r.adminUrl}` : ""}
+It is owned by your account - no claim needed. Re-deploy to the same site with --site ${r.siteId}.
+Recorded ${recPath}.${backendWarn}`,
+      details: { mode: "token", url: r.url, adminUrl: r.adminUrl, siteId: r.siteId, deployId: r.deployId, uploaded: r.uploaded, state: r.state }
+    };
+  } catch (e) {
+    return { ok: false, message: `Deploy failed: ${e.message}`, details: { mode: "token" } };
+  }
+}
+
 // bin/tl.ts
 var HELP = `tl - read/write a portable Thought Layer state file (default: .thought-layer/state.json)
 
   tl read [path] [--json]            where the run stands
   tl list [dir]                      list the state files under .thought-layer/ (juggle several ideas)
+  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
   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})
@@ -436,7 +989,7 @@ function parseArgs(argv) {
 function readData(flags) {
   const d = flags["data"];
   if (d === void 0) return void 0;
-  const raw = d === "-" || d === true ? readFileSync2(0, "utf8") : String(d);
+  const raw = d === "-" || d === true ? readFileSync3(0, "utf8") : String(d);
   try {
     return JSON.parse(raw);
   } catch {
@@ -476,6 +1029,37 @@ function main() {
     console.log(HELP);
     process.exit(0);
   }
+  if (args[0] === "scaffold") {
+    const r2 = runScaffold(
+      {
+        path: typeof flags["path"] === "string" ? flags["path"] : void 0,
+        outDir: typeof flags["out"] === "string" ? flags["out"] : void 0,
+        domain: typeof flags["domain"] === "string" ? flags["domain"] : void 0,
+        founderName: typeof flags["founder"] === "string" ? flags["founder"] : void 0
+      },
+      { builtAt: (/* @__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] === "deploy") {
+    runDeploy(
+      {
+        path: typeof flags["path"] === "string" ? flags["path"] : void 0,
+        dryRun: flags["dry-run"] === true,
+        anonymous: flags["anonymous"] === true,
+        siteName: typeof flags["name"] === "string" ? flags["name"] : void 0,
+        siteId: typeof flags["site"] === "string" ? flags["site"] : void 0
+      },
+      { deployedAt: (/* @__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;
+  }
   let payload;
   try {
     payload = buildOp(args, flags);