yichus 0.2.0 → 0.3.0

package/dist/cli.js

@@ -5,10 +5,10 @@ import { text as text2 } from "stream/consumers";
 import { checkLeanWasmSources, findApiMcpBundle, loadApiEngine } from "@yichus/api-mcp";
 
 // src/run.ts
-import fs5 from "fs";
-import path6 from "path";
+import fs8 from "fs";
+import path8 from "path";
 import { isDeepStrictEqual, parseArgs as parseArgs2 } from "util";
-import { z as z7 } from "zod";
+import { z as z11 } from "zod";
 
 // src/engine-results.ts
 import { z } from "zod";
@@ -270,16 +270,17 @@ function callFailure(tool, result, artifact) {
 }
 
 // src/studio/command.ts
-import path5 from "path";
+import fs7 from "fs";
+import path7 from "path";
 import { parseArgs } from "util";
 
 // src/studio/director.ts
 import fs3 from "fs";
 import path3 from "path";
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // ../../web/system-map-record.js
-var MARKS_VERSION = "yichus-marks-2";
+var MARKS_VERSION = "yichus-marks-3";
 var VOCABULARY = {
   version: MARKS_VERSION,
   fixedPlaces: {
@@ -290,6 +291,7 @@ var VOCABULARY = {
     replyBars: "one bar per entry at the same x, past the hull band  <- entries[]",
     rail: "the bottom of the wall: a handle handed in from outside, with a riser to each use; a ? on the rail where a use is handed in on some paths only  <- uses[how=handed|mixed]",
     rack: "right of the wall: db, model, net, always in this order; struck = the engine checked and found none  <- resources[], ghostResources[]",
+    programBand: "the bottom of the wall, under the rail: one container per pure program, its request openings on its right edge, the engine lanes right of it; empty = the engine found no program  <- programs[]",
     quietLine: "bottom inside the wall: parts on no entry path, one stretch per package, with their forks, sockets, generic letters and steps  <- keyed[], library.applied[], steps[]"
   },
   marks: {
@@ -298,7 +300,8 @@ var VOCABULARY = {
     role: "red word beside the lock: a role beyond sign-in  <- entries[].roles",
     limit: "gauge beside the path: a declared rate limit  <- entries[].limits",
     station: "ring on a path: code touching a table, with the verb and table beside it; filled = writes  <- entries[].reach, wrappers[].effects, entries[].beside.effects",
-    modelRing: "violet ring: the entry reaches the model; the count under the model says how many entries do  <- entries[].model",
+    modelRing: "violet ring: the entry reaches the model  <- entries[].model",
+    reachedBy: "under each resource in the rack: how many routes reach it, the resource drawn at that share of the routes (never smaller than its name)  <- entries[].db, model, net, beside.resources",
     netRing: "orange ring: the entry reaches the network  <- entries[].net",
     guard: "red diamond on the path where the check happens, its name above, failure stem below  <- entries[].guards, wrappers[].guards, entries[].passed[].guards, entries[].beside.guards",
     hull: "translucent region in the hull band: paths merge into it, run one shared stretch, and split; everything inside it runs inside the wrapper  <- wrappers[]",
@@ -306,15 +309,28 @@ var VOCABULARY = {
     token: "small grey word under a path: the value the caller fixes for the wrapper  <- entries[].policy",
     afterDot: "dot in the after band: a call the entry makes after its wrapper returns  <- entries[].beside.calls",
     builder: "plus-disc under a station with the call that builds the handle there  <- uses[how=local].builtBy",
-    unknown: "a ? in a circle on the rail: the engine traced the handle only on some paths  <- uses[how=mixed]",
+    unknown: 'a ? in a circle on the rail, with "partly traced" beside it and a sentence on hover: the engine traced the handle only on some paths  <- uses[how=mixed]',
     fork: "three prongs and a type: a choice keyed on a plain String or Int; under the mark that makes it, else on the quiet line  <- keyed[]",
-    bundle: "one cable with a count: entries with the same wrapper and identical marks; its title names every route; opening it draws each one  <- bundles[]",
+    bundle: 'one cable with how many routes it carries ("4 routes"): entries with the same wrapper and identical marks; its title names every route; opening it draws each one  <- bundles[]',
     anchor: "where the rail starts: platform when no definition of the program can make the handle; ? when the trace stops and the program could  <- uses[].anchor",
-    step: "loop arc with a type on the quiet line: functions of the package take that type and return it  <- steps[]",
+    step: 'loop arc with a type on the quiet line: functions of the package take that type and return it; gathered, a count in words ("8 steps"), as are choices, db uses and generic parts  <- steps[]',
     loop: "loop arc with package names: packages whose types lead back to themselves  <- phases.cycles",
     composes: "hull round a chain: a definition takes the type the chain hands in at each step and applies it  <- library.applied[].fedBy",
     port: "plug strip on the right: a record of functions; each adapter a plug, hollow when nothing plugs it in  <- library.ports[]",
-    generic: "the letter \u2200 with its variables over a part that never looks inside what it carries  <- library.generic[]"
+    generic: "the letter \u2200 with its variables over a part that never looks inside what it carries  <- library.generic[]",
+    program: `large container: a pure program, its step and package named, with its package's own definition count (as the layer stack counts them) and how many more it uses from other packages, the most used named with their counts; routes that act on one step's answer per call are named as its starters ("one step per call of"), and routes that only replay it are named on hover  <- programs[], definitions, usesElsewhere, elsewhere[], starters[advances=false], replays[]`,
+    decision: "bar and number in the program: its decisions, on one scale shared with its engines' bars  <- programs[].decisions",
+    struck: 'on a program, a struck "effects": no definition in its package performs an effect  <- programs[].beside = []',
+    programEffect: "red disc and count on a program: definitions in its own package that perform effects, named in its title  <- programs[].beside[]",
+    request: "opening on the program's right edge: a request constructor its step can return, with its payload's types  <- programs[].requests[]",
+    variant: 'short opening under a request: a constructor of a user sum type its payload carries, with what the program calls it ("BriefCase \u2192 Lawyer") where a total match maps each kind to a plain constructor; eight drawn, the rest counted with their names in a title  <- programs[].requests[].variants[], namings[]',
+    starter: "dashed line from a route's reply bar into the program top: the route calls the step with its values and acts on the answer, found by value flow; a route that runs an engine is named under its loop instead  <- programs[].starters[advances=false]",
+    gap: "struck opening: a request constructor no engine handles  <- programs[].gaps[]",
+    wire: "line from an opening to the lane that handles it, ending in the names of the resources the arm reaches, or a dot each where they do not fit  <- programs[].requests[].handledBy",
+    lane: `thin vertical line on the resource side: an engine that performs the program's requests, its package above it and what it does written from its type (its own parameters \u2192 what its effect yields), its code name and whole type on hover; it ends in the resources its arms reach, then dashed pills under "also" for resources it reaches for no request  <- programs[].engines[], pkgLabel, type, resources, also`,
+    laneFork: "bar and number on a lane: the engine's decisions, on the program's scale; 0 = a rule-free engine  <- programs[].engines[].decisions",
+    replyLoop: `one solid arc from a lane's foot back into the program, with one loop node naming what repeats the step within one call, and "each call of \u2026 runs it" naming the routes that run the rounds  <- programs[].engines[].replies, loop, starters`,
+    replaced: 'a check named "(in place of \u2026)": in the compared base record the same route had that other check at the same place, and it is on that route no longer; says nothing about whether the two do the same  <- compare.replaced[]'
   },
   rule: "every guard, wrapper, socket, fork, handle, station, step and resource the engine records is drawn at its fixed place, in every view; where nothing is drawn, the engine checked and found none."
 };
@@ -330,6 +346,110 @@ var uniqBy = (xs, key) => {
   const seen = /* @__PURE__ */ new Set();
   return xs.filter((x) => !seen.has(key(x)) && seen.add(key(x)));
 };
+var RUNNER = { CompileProgram: "compile", RunProgram: "run" };
+var effectResource = (e) => e.resource || RUNNER[e.kind] || "io";
+var LANE_RES = ["db", "model", "net", "compile", "run", "io"];
+var resOrder = (rs) => LANE_RES.filter((r) => rs.includes(r));
+function programsOf(st, layers = null) {
+  const found = st.programs && st.programs.programs || [];
+  const ownCount = (pkg) => {
+    const lp = layers && layers.packages.find((x) => x.name === pkg);
+    return lp ? lp.definitions.length : null;
+  };
+  return found.map((p) => {
+    const engines = p.engines.map((e) => {
+      const resources = resOrder(uniq(e.handles.flatMap((h) => h.effects.map(effectResource))));
+      return {
+        id: e.id,
+        label: bare(e.id),
+        pkg: pkgOf(e.id),
+        pkgLabel: pkgOf(e.id).split("/").pop(),
+        handles: e.handles.map((h) => h.constructor),
+        resources,
+        // effects the engine performs that are no request's: drawn, not hidden
+        also: resOrder(uniq((e.effects || []).map(effectResource))).filter((r) => !resources.includes(r)),
+        replies: resOrder(uniq(e.replies.map(effectResource))),
+        decisions: +e.decisions,
+        entries: e.entries,
+        truncated: e.truncated,
+        loop: e.loop ? { kind: e.loop.kind, by: e.loop.by, label: e.loop.by ? bare(e.loop.by) : null } : { kind: "sequence", by: null, label: null },
+        starters: (p.starters || []).filter((s) => s.advances && s.via.some((v) => v === e.id || e.entries.includes(s.entry))).map((s) => s.entry),
+        // what it does, from its type: the program's own and standard parameters, and what its effect yields; the whole type on hover
+        type: {
+          takes: e.labels.takes,
+          returns: e.labels.returns,
+          plainTakes: e.labels.plainTakes,
+          yields: e.labels.yields,
+          from: "structure.programs.programs[].engines[].labels"
+        },
+        from: "structure.programs.programs[].engines[]"
+      };
+    });
+    const requests = p.requests.map((q) => ({
+      constructor: q.constructor,
+      fields: q.fields.map((f) => f.label),
+      variants: (q.variants || []).map((v) => ({
+        path: v.path,
+        type: bare(v.type),
+        constructors: v.constructors,
+        // what the program calls each kind: total matches onto plain constructors, the type's own package first
+        namings: (v.namings || []).slice().sort((a, b) => (pkgOf(b.definition) === pkgOf(v.type)) - (pkgOf(a.definition) === pkgOf(v.type))).map((n) => ({
+          definition: n.definition,
+          label: bare(n.definition),
+          type: bare(n.type),
+          names: n.names.map((x) => ({ constructor: x.constructor, name: x.name })),
+          from: "structure.programs.programs[].requests[].variants[].namings[]"
+        })),
+        from: "structure.programs.programs[].requests[].variants[]"
+      })),
+      handledBy: p.engines.filter((e) => e.handles.some((h) => h.constructor === q.constructor)).map((e) => ({
+        engine: e.id,
+        resources: resOrder(uniq(e.handles.find((h) => h.constructor === q.constructor).effects.map(effectResource)))
+      })),
+      gap: p.gaps.some((g) => g.constructor === q.constructor),
+      from: "structure.programs.programs[].requests[] + engines[].handles[]"
+    }));
+    return {
+      id: p.step,
+      label: bare(p.step),
+      pkg: p.package,
+      pkgLabel: p.package.split("/").pop(),
+      result: bare(p.result),
+      requestType: bare(p.requestType),
+      carrier: p.carrier,
+      decisions: +p.decisions,
+      finishes: p.finishes,
+      // definitions: the package's own, as the layer stack counts them; reached: everything the program's definitions use
+      definitions: ownCount(p.package) ?? +(p.ownDefinitions || 0),
+      reached: p.definitions.length,
+      // of what it reaches, the definitions that live in other packages
+      usesElsewhere: p.definitions.filter((d) => pkgOf(d) !== p.package).length,
+      // and which packages those are, the most used first
+      elsewhere: Object.entries(p.definitions.filter((d) => pkgOf(d) !== p.package).reduce((m, d) => ({ ...m, [pkgOf(d)]: (m[pkgOf(d)] || 0) + 1 }), {})).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([pkg, n]) => ({ pkg, label: pkg.split("/").pop(), n, from: "structure.programs.programs[].definitions[]" })),
+      requests,
+      engines,
+      starters: (p.starters || []).map((s) => ({
+        entry: s.entry,
+        path: s.entry.replace(/^route:/, ""),
+        advances: s.advances,
+        via: s.via,
+        from: "structure.programs.programs[].starters[]"
+      })),
+      // routes that call the step and act on nothing it says: they read where the program is
+      replays: (p.replays || []).map((s) => ({ entry: s.entry, path: s.entry.replace(/^route:/, ""), via: s.via, from: "structure.programs.programs[].replays[]" })),
+      // what each reaches, as the structure lens's effect sites say (io when none is a resource)
+      beside: (p.beside || []).map((b) => ({
+        id: b.definition,
+        label: bare(b.definition),
+        kinds: b.kinds,
+        resources: resOrder(uniq((st.ioKinds || []).filter((k) => k.definition === b.definition).flatMap((k) => k.resources))),
+        from: "structure.programs.programs[].beside[], structure.ioKinds[].resources"
+      })),
+      gaps: p.gaps.map((g) => ({ constructor: g.constructor, from: "structure.programs.programs[].gaps[]" })),
+      from: "structure.programs.programs[]"
+    };
+  });
+}
 var outsideResourcesOf = (steps) => uniq((steps || []).map((e) => e.resource).filter((r) => r === "model" || r === "net"));
 function buildSystemMap(engine, { program }) {
   for (const [k, v] of Object.entries(engine)) if (!v.ok) throw new Error(`${k}: ${v.error}`);
@@ -385,6 +505,7 @@ function buildSystemMap(engine, { program }) {
       limits,
       limitComputed: ee.limits.written === "computed",
       reachKinds: ee.reaches,
+      db: ee.resources.includes("db"),
       model: ee.resources.includes("model"),
       net: ee.resources.includes("net"),
       writes: reach.some((e) => isWrite(e.op)),
@@ -539,6 +660,7 @@ function buildSystemMap(engine, { program }) {
     library,
     keyed,
     steps,
+    programs: programsOf(st, layers),
     bundles: routes.length > 12 ? bundlesOf(entries, uses, keyed) : null,
     phases: st.phases,
     evidence: {
@@ -623,6 +745,10 @@ var STRUCTURAL = /* @__PURE__ */ new Set([
   "keyKinds",
   "reachKinds",
   "resources",
+  "replies",
+  "also",
+  "kinds",
+  "within",
   "vars",
   "id"
 ]);
@@ -642,14 +768,14 @@ var VALUE = "a kind of value";
 var TYPES = /* @__PURE__ */ new Set(["type", "types", "signature"]);
 var WORD = /[A-Za-z_][\w/]*::\w+|[A-Za-z_]\w*/g;
 var leaves = (record, visit) => {
-  const walk = (v, key) => {
+  const walk3 = (v, key) => {
     if (typeof v === "string") visit(v, key);
-    else if (Array.isArray(v)) v.forEach((x) => walk(x, key));
+    else if (Array.isArray(v)) v.forEach((x) => walk3(x, key));
     else if (v && typeof v === "object") {
-      for (const [k, x] of Object.entries(v)) if (!skipped(k, x)) walk(x, k);
+      for (const [k, x] of Object.entries(v)) if (!skipped(k, x)) walk3(x, k);
     }
   };
-  walk(record, null);
+  walk3(record, null);
 };
 function nameableParts(map) {
   const found = /* @__PURE__ */ new Map();
@@ -704,13 +830,13 @@ function relabelSystemMap(map, names) {
     if (s.startsWith("/")) return s;
     return s.replace(WORD, (w) => w.includes("::") ? id(w) : STRUCTURAL.has(key) ? w : word(w));
   };
-  const walk = (v, key) => {
+  const walk3 = (v, key) => {
     if (typeof v === "string") return text3(v, key);
-    if (Array.isArray(v)) return v.map((x) => walk(x, key));
-    if (v && typeof v === "object") return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, skipped(k, x) ? x : walk(x, k)]));
+    if (Array.isArray(v)) return v.map((x) => walk3(x, key));
+    if (v && typeof v === "object") return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, skipped(k, x) ? x : walk3(x, k)]));
     return v;
   };
-  const out = walk(map, null);
+  const out = walk3(map, null);
   const pathOf = new Map(map.entries.map((e) => [e.key, e.path]));
   out.bundles = map.bundles && map.bundles.map((b, i) => {
     const paths = b.entries.map((k) => pathOf.get(k));
@@ -720,6 +846,259 @@ function relabelSystemMap(map, names) {
   return out;
 }
 
+// ../../web/what-happens-record.js
+var SCHEMA = "what-happens-1";
+var VOCABULARY2 = {
+  version: MARKS_VERSION,
+  added: ["outcome"],
+  marks: {
+    entryHead: "arrowhead where a request comes in; the rack above the tree has one per described entry, then one dashed line counting the entries no scenario describes, which opens to draw each of them struck  <- entries[], ghosts[]",
+    guard: "red diamond: the declared sign-in or role check, the first branch of every entry that has one; its failure stem ends in a refusal  <- tree node with from.kind=guard",
+    fork: "three prongs: a branch the code takes on the request, the caller, a value read from a table, or a call result; the arm each line takes is written where it leaves  <- tree nodes",
+    station: "ring on a line: an effect on that path, its verb and table beside it; filled = it writes  <- arms[].effects, entry.effects",
+    modelRing: "violet ring: the path reaches the model  <- effects[resource=model]",
+    netRing: "orange ring: the path reaches the network  <- effects[resource=net]",
+    outcome: "the end of a path: a cap with what the request gets back (a constructor, or a refusal with its status and code); red when a claim fails there or a check reports a witness that ends there, green when every obligation that failed there at the base is checked here and holds, hollow and dashed (unchecked) when a claim there is inconclusive or an obligation that failed at the base is no longer checked, grey otherwise  <- leaves",
+    unchecked: "a hollow dashed cap and a ? tick: the engine cannot say whether the claim holds on this path (a step it could not open, a table it could not name, an answer it could not decide), or what failed here at the base is not checked here; never counted as holding  <- claims[verdict=inconclusive], leaves[].gaps, diff.unresolved",
+    struck: 'a struck ghost: something checked and found absent (an entry nobody described, a write a claim says a path must not make, "no base compared" when no earlier version was compared)  <- ghosts[], claims holding with not',
+    bundle: "a cable with a count: a subtree too large for this view; opening it draws that part with a breadcrumb  <- derived from the tree",
+    compared: 'a line under the rack, always there: "compared with <base> \xB7 N fixed \xB7 M still failing", or "no base compared", struck  <- diff',
+    hull: `a shaded box on the line: a step that is not the handler's own work, folded (a wrapper's guard or short-circuit, the platform's declared check or the transaction it runs the plan in, work beside the wrapper, a wrapper's work after the handler); it keeps what the step answers instead of running the handler, one row per arm that skips the handler, read as a side stub (the arm, its struck writes, what the request gets, ticks), then "continue" (a transaction: "runs"), and its effects; opening it draws the step's own tree; drawn inline, the same hull is a light band behind the step and its exits, with its role and where it comes from above its test, so either way it reads as not the handler's own work  <- tree nodes[concern.role], entries[].steps`
+  },
+  rule: "every entry, branch, arm, effect and outcome the engine computes is drawn, a folded step's inside its box and an undescribed entry behind the rack's one line; the author's words appear only on ids the engine computed, in italic, with the code name beside them.",
+  concerns: "where each branch and effect comes from in value flow (concern.layer, effects[].layer): core = the handler's own work, a function it hands its wrapper or its body when it has none; cross = the wrapper its route shape names, shared with other entries; beside = the handler's code outside the wrapper call; platform = the route's declared authority, or the transaction the platform runs a plan in (its arms that give up or cannot confirm skip the handler's work). Roles come from which arms reach the handler, never from names."
+};
+var bare2 = (id) => String(id).split("::").pop();
+var claimKey = (entry, c) => `${entry}\0${c.at}\0${c.parsed}`;
+function walk(tree, f, path10 = []) {
+  if (!tree) return;
+  f(tree, path10);
+  if (tree.kind === "node") for (const arm of tree.arms) {
+    f(arm, path10);
+    walk(arm.next, f, [...path10, arm]);
+  }
+}
+var leavesOf = (tree) => {
+  const out = [];
+  walk(tree, (t) => {
+    if (t.kind === "leaf") out.push(t);
+  });
+  return out;
+};
+function pathEffects(entry) {
+  const out = /* @__PURE__ */ new Map();
+  const go = (t, acc) => {
+    if (!t) return;
+    if (t.kind === "leaf") {
+      out.set(t.id, acc);
+      return;
+    }
+    for (const a of t.arms) go(a.next, [...acc, ...a.effects]);
+  };
+  go(entry.tree, entry.effects || []);
+  return out;
+}
+function heldOn(tree, guards) {
+  const out = /* @__PURE__ */ new Set();
+  const go = (t, held) => {
+    if (!t) return;
+    if (t.kind === "leaf") {
+      if (held) out.add(t.id);
+      return;
+    }
+    const isGuard = t.from?.kind === "call" && guards.includes(bare2(t.from.callee));
+    for (const a of t.arms) go(a.next, held || isGuard && a.arm === "True");
+  };
+  go(tree, false);
+  return out;
+}
+function witnessesOf(access, entries) {
+  if (!access) return [];
+  const findings = (access.report?.findings || []).filter((f) => f.status === "violated");
+  return findings.map((f, i) => {
+    const site = `${f.package}::${f.binding}`;
+    const guards = f.pathCondition?.unlessHeld || [];
+    const leaves2 = entries.flatMap((e) => {
+      const held = heldOn(e.tree, guards);
+      return leavesOf(e.tree).filter((l) => !held.has(l.id) && l.effects.some((x) => x.site === site && bare2(x.primitive) === f.operation && x.tables.includes(f.resource)));
+    }).map((l) => l.id);
+    return {
+      id: `witness:${i + 1}`,
+      check: "access",
+      resource: f.resource,
+      site,
+      operation: f.operation,
+      kind: f.kind,
+      detail: f.detail,
+      leaves: leaves2,
+      ...guards.length ? { unlessHeld: guards } : {},
+      from: guards.length ? "api_access_check report.findings[status=violated], on paths where pathCondition.unlessHeld did not hold" : "api_access_check report.findings[status=violated]"
+    };
+  });
+}
+function buildWhatHappens(engine, { program, base = null, baseLabel = "base" } = {}) {
+  for (const [k, v] of Object.entries(engine)) if (v && !v.ok) throw new Error(`${k}: ${v.error}`);
+  const st = engine.structure;
+  const claims = st.claims || { scenarios: [], undescribed: (st.scenarios || []).map((s) => s.entry) };
+  const byEntry = new Map(claims.scenarios.filter((s) => s.status === "matched").map((s) => [s.entry, s]));
+  const routes = new Map((st.entries || []).map((e) => [e.entry, e]));
+  const entries = st.scenarios.map((s) => {
+    const meta = routes.get(s.entry) || {};
+    const sc = byEntry.get(s.entry);
+    const names = new Map((sc?.names || []).filter((n) => n.status === "named").map((n) => [n.id, n.words]));
+    const copy = (t) => {
+      if (!t) return null;
+      if (t.kind === "leaf") return { ...t, words: names.get(t.id) || null, claims: [], witnesses: [], status: "grey" };
+      return { ...t, words: names.get(t.id) || null, arms: t.arms.map((a) => ({ ...a, words: names.get(a.id) || null, next: copy(a.next) })) };
+    };
+    return {
+      entry: s.entry,
+      handler: s.handler,
+      label: s.entry.replace(/^route:/, ""),
+      authority: meta.authority || null,
+      transport: meta.transport || null,
+      title: sc?.title || null,
+      described: !!sc,
+      effects: s.effects,
+      tree: copy(s.tree),
+      leafCount: Number(s.leafCount),
+      truncated: s.truncated,
+      unsupported: s.unsupported || null,
+      wrapper: s.wrapper || null,
+      steps: s.steps || [],
+      from: "structure.scenarios[]"
+    };
+  });
+  const entryOf = new Map(entries.map((e) => [e.entry, e]));
+  const leafById = new Map(entries.flatMap((e) => leavesOf(e.tree).map((l) => [l.id, l])));
+  const checked = [], notes = [], refused = [], mismatches = [];
+  for (const sc of claims.scenarios) {
+    if (sc.status !== "matched") {
+      mismatches.push({ entry: sc.entry, title: sc.title || null, reason: sc.reason, from: "structure.claims.scenarios[status=mismatch]" });
+      continue;
+    }
+    for (const n of sc.names) if (n.status !== "named") refused.push({ entry: sc.entry, id: n.id, words: n.words, reason: n.reason, from: "structure.claims.scenarios[].names[status=refused]" });
+    for (const x of sc.expect) {
+      if (x.verdict === "not-a-claim") {
+        notes.push({ entry: sc.entry, at: x.at, text: x.claim, from: "structure.claims.scenarios[].expect[verdict=not-a-claim]" });
+        continue;
+      }
+      if (x.verdict === "refused") {
+        refused.push({ entry: sc.entry, id: x.at, words: x.claim, reason: x.reason, from: "structure.claims.scenarios[].expect[verdict=refused]" });
+        continue;
+      }
+      const open = new Map((x.inconclusive || []).map((o) => [o.leaf, o.reasons]));
+      const c = {
+        id: `claim:${checked.length + 1}`,
+        entry: sc.entry,
+        at: x.at,
+        claim: x.claim,
+        parsed: x.parsed,
+        property: x.property,
+        verdict: x.verdict,
+        leaves: x.leaves,
+        failing: x.failing,
+        inconclusive: x.inconclusive || [],
+        from: "structure.claims.scenarios[].expect[]"
+      };
+      checked.push(c);
+      for (const id of x.leaves) {
+        const l = leafById.get(id);
+        if (!l) continue;
+        const verdict = x.failing.includes(id) ? "fails" : open.has(id) ? "inconclusive" : "holds";
+        l.claims.push({ id: c.id, at: x.at, parsed: x.parsed, property: x.property, verdict, ...verdict === "inconclusive" ? { reasons: open.get(id) } : {} });
+      }
+    }
+  }
+  const witnesses = witnessesOf(engine.access, entries);
+  const basePaths = base ? new Map(base.entries.flatMap((e) => [...pathEffects(e)])) : null;
+  for (const w of witnesses) for (const id of w.leaves) leafById.get(id)?.witnesses.push(w.id);
+  for (const l of leafById.values()) {
+    if (l.claims.some((c) => c.verdict === "fails") || l.witnesses.length) l.status = "red";
+    else if (l.claims.some((c) => c.verdict === "inconclusive")) l.status = "unchecked";
+  }
+  let diff = null;
+  if (base) {
+    const baseRed = new Map(base.entries.flatMap((e) => leavesOf(e.tree).filter((l) => l.status === "red").map((l) => [l.id, { entry: e.entry, leaf: l }])));
+    const baseWitness = new Map((base.witnesses || []).map((w) => [w.id, w]));
+    const fixed = [], still = [], gone = [], unresolved = [];
+    for (const [id, { entry, leaf: bl }] of baseRed) {
+      const here = leafById.get(id);
+      if (!here) {
+        gone.push(id);
+        continue;
+      }
+      if (here.status === "red") {
+        still.push(id);
+        continue;
+      }
+      const reasons = [
+        ...bl.claims.filter((c) => c.verdict === "fails").flatMap((c) => {
+          const now = here.claims.find((h) => claimKey(entry, h) === claimKey(entry, c));
+          if (!now) return [`the claim ${c.parsed} at ${c.at} failed here at the base and is not checked here`];
+          return now.verdict === "holds" ? [] : [`the claim ${c.parsed} at ${c.at} failed here at the base and is inconclusive here`];
+        }),
+        ...bl.witnesses.length && !engine.access ? [`the access check reported a witness here at the base and did not run here`] : []
+      ];
+      const baseClaims = bl.claims, baseWitnesses = bl.witnesses.map((w) => baseWitness.get(w)).filter(Boolean);
+      here.base = { outcome: bl.outcome, effects: bl.effects || basePaths.get(id) || [], claims: baseClaims, witnesses: baseWitnesses };
+      if (reasons.length) {
+        here.status = "unchecked";
+        unresolved.push({ id, reasons });
+        continue;
+      }
+      here.status = "green";
+      fixed.push(id);
+    }
+    diff = {
+      base: baseLabel,
+      fixed,
+      stillRed: still,
+      goneAtHead: gone,
+      unresolved,
+      from: "derived: base leaves[status=red] matched by id; each failed claim matched by entry, at and parsed claim; a witness is gone when the access check ran here and reports none on the leaf"
+    };
+  }
+  const ghosts = entries.filter((e) => !e.described).map((e) => ({ entry: e.entry, from: "structure.claims.undescribed[]" }));
+  for (const l of leafById.values()) delete l.effects;
+  return {
+    schema: SCHEMA,
+    marks: MARKS_VERSION,
+    vocabulary: VOCABULARY2,
+    program,
+    entries,
+    ghosts,
+    claims: checked,
+    witnesses,
+    notes,
+    refused,
+    mismatches,
+    diff,
+    counts: {
+      entries: entries.length,
+      described: entries.length - ghosts.length,
+      leaves: leafById.size,
+      steps: entries.reduce((n, e) => n + e.steps.length, 0),
+      wrapped: entries.filter((e) => e.wrapper && e.wrapper.wraps).length,
+      red: [...leafById.values()].filter((l) => l.status === "red").length,
+      green: [...leafById.values()].filter((l) => l.status === "green").length,
+      unchecked: [...leafById.values()].filter((l) => l.status === "unchecked").length
+    },
+    evidence: { tools: ["api_organize:structure", ...engine.access ? ["api_access_check"] : []], derived: ["diff: base red leaves matched by id, their failed obligations by identity"] }
+  };
+}
+function stationLabel(e) {
+  const verb = e.op === "mint id" ? "mint" : e.op;
+  if (e.tables.length) return `${verb} \xB7 ${e.tables.join(", ")}`;
+  if (e.resource === "model" || e.resource === "net") return verb;
+  return `${verb} \xB7 ${bare2(e.primitive)}`;
+}
+function outcomeLabel(o) {
+  if (o.status && !o.constructors.length) return o.shown;
+  const head = o.constructors.length ? o.constructors.join(" | ") : o.value ? `the ${o.value}` : o.shown;
+  return head;
+}
+
 // src/studio/project.ts
 import { createHash } from "crypto";
 import fs from "fs";
@@ -727,17 +1106,17 @@ import path from "path";
 var SKIPPED = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "target", "out"]);
 function projectSources(root) {
   const files = [];
-  const walk = (dir) => {
+  const walk3 = (dir) => {
     for (const entry of fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
       if (entry.name.startsWith(".") || SKIPPED.has(entry.name)) continue;
       const full = path.join(dir, entry.name);
-      if (entry.isDirectory()) walk(full);
+      if (entry.isDirectory()) walk3(full);
       else if (entry.isFile() && entry.name.endsWith(".bosatsu")) {
         files.push({ fileName: path.relative(root, full).split(path.sep).join("/"), source: fs.readFileSync(full, "utf8") });
       }
     }
   };
-  walk(root);
+  walk3(root);
   return files;
 }
 function sourcesHash(files) {
@@ -773,6 +1152,32 @@ var ACCESS_POLICY = {
   "everyone-reads": "PublicReadRoleWrite",
   public: "Public"
 };
+var platform = {
+  id: "platform",
+  kind: "platform",
+  subject: null,
+  ask: "Where do you want your app to run once it is ready?",
+  why: "Each place runs apps differently: some keep a server running, some only run the page people open. Knowing it now means your agent builds the pieces that place can run, instead of rebuilding them later.",
+  choices: [
+    { id: "render", label: "Render", means: "The server, its database, the page and background jobs all run on Render." },
+    { id: "vercel", label: "Vercel", means: "The page people open runs on Vercel; the server and its database run on a second service, because Vercel does not keep a server running." },
+    { id: "netlify", label: "Netlify", means: "The page people open runs on Netlify; the server and its database run on a second service, because Netlify does not keep a server running." },
+    { id: "aws", label: "Amazon Web Services", means: "The server runs on App Runner or ECS with an RDS database." },
+    { id: "gcp", label: "Google Cloud", means: "The server runs on Cloud Run with a Cloud SQL database." },
+    { id: "azure", label: "Microsoft Azure", means: "The server runs on Container Apps or App Service with an Azure PostgreSQL database." },
+    { id: "undecided", label: "Not sure yet", means: "Your agent builds for Render, which holds everything in one place; moving later changes configuration, not the app." }
+  ],
+  fact: "Every app runs somewhere."
+};
+var PLATFORM_SECTION = {
+  render: "Render",
+  vercel: "Vercel",
+  netlify: "Netlify",
+  aws: "AWS",
+  gcp: "Google Cloud",
+  azure: "Microsoft Azure",
+  undecided: "Not decided yet"
+};
 var topology = {
   id: "topology",
   kind: "topology",
@@ -908,6 +1313,10 @@ function saveRequirements(root, requirements) {
 function withNames(requirements, names) {
   return { ...requirements, names: { ...requirements.names, ...names } };
 }
+function withScenarios(requirements, scenarios, drop = []) {
+  const replaced = /* @__PURE__ */ new Set([...scenarios.map((s) => s.entry), ...drop]);
+  return { ...requirements, scenarios: [...(requirements.scenarios ?? []).filter((s) => !replaced.has(s.entry)), ...scenarios] };
+}
 function withAnswer(requirements, answer) {
   return { ...requirements, answers: [...requirements.answers.filter((a) => a.question !== answer.question), answer] };
 }
@@ -915,22 +1324,91 @@ function ensureStudioDir(root) {
   const dir = studioDir(root);
   fs2.mkdirSync(dir, { recursive: true });
   const ignore = path2.join(dir, ".gitignore");
-  if (!fs2.existsSync(ignore)) fs2.writeFileSync(ignore, "state.json\n");
+  const before = fs2.existsSync(ignore) ? fs2.readFileSync(ignore, "utf8") : "";
+  const kept = new Set(before.split("\n").map((line) => line.trim()));
+  const missing = ["state.json", "marks.json", "viewing.json"].filter((name) => !kept.has(name));
+  if (missing.length) fs2.appendFileSync(ignore, `${before && !before.endsWith("\n") ? "\n" : ""}${missing.map((line) => `${line}
+`).join("")}`);
 }
 
-// src/studio/director.ts
-var VerifyProperty = z5.looseObject({
+// src/studio/scenarios.ts
+import { z as z5 } from "zod";
+var Effect = z5.looseObject({ op: z5.string(), tables: z5.array(z5.string()).default([]) });
+var Claim = z5.looseObject({ verdict: z5.string(), parsed: z5.string(), at: z5.string() });
+var Leaf = z5.looseObject({ kind: z5.literal("leaf"), id: z5.string(), words: z5.string().nullable(), outcome: z5.unknown(), claims: z5.array(Claim).default([]) });
+var Tree = z5.lazy(() => z5.union([Leaf, z5.looseObject({
+  kind: z5.literal("node"),
   id: z5.string(),
-  title: z5.string(),
-  status: z5.string(),
-  details: z5.array(z5.string()).default([]),
-  accepted: z5.unknown().optional()
+  test: z5.string(),
+  words: z5.string().nullable(),
+  arms: z5.array(z5.looseObject({ id: z5.string(), pattern: z5.string(), words: z5.string().nullable(), effects: z5.array(Effect).default([]), next: Tree }))
+})]));
+var Entry2 = z5.looseObject({
+  entry: z5.string(),
+  title: z5.string().nullable(),
+  described: z5.boolean(),
+  effects: z5.array(Effect).default([]),
+  tree: Tree.nullable(),
+  unsupported: z5.string().nullable()
+});
+var Checked = z5.looseObject({ entry: z5.string(), at: z5.string(), claim: z5.string(), parsed: z5.string(), verdict: z5.string() });
+var Refused = z5.looseObject({ entry: z5.string(), id: z5.string(), words: z5.string(), reason: z5.string() });
+var WhatHappens = z5.looseObject({
+  entries: z5.array(Entry2),
+  claims: z5.array(Checked),
+  refused: z5.array(Refused),
+  /** Expectations that are not claims in the grammar, so nothing checks them. */
+  notes: z5.array(z5.looseObject({ entry: z5.string(), at: z5.string(), text: z5.string() })),
+  mismatches: z5.array(z5.looseObject({ entry: z5.string(), reason: z5.string() }))
+});
+var effectsText = (effects) => effects.length ? `; effects: ${effects.map(stationLabel).join(", ")}` : "";
+function walk2(tree, visit) {
+  if (!tree) return;
+  if (tree.kind === "leaf") {
+    visit(tree.id, `outcome: ${outcomeLabel(tree.outcome)}`, tree.words, true, tree.claims.length);
+    return;
+  }
+  visit(tree.id, `the program checks ${tree.test}`, tree.words, false, 0);
+  for (const arm of tree.arms) {
+    if (arm.next.id !== arm.id) visit(arm.id, `when ${arm.pattern}${effectsText(arm.effects)}`, arm.words, false, 0);
+    else if (arm.next.kind === "leaf") {
+      const leaf = arm.next;
+      visit(leaf.id, `when ${arm.pattern}${effectsText(arm.effects)}, outcome: ${outcomeLabel(leaf.outcome)}`, leaf.words ?? arm.words, true, leaf.claims.length);
+      continue;
+    }
+    walk2(arm.next, visit);
+  }
+}
+function owed(record) {
+  return record.entries.map((e) => {
+    const unnamed = [], uncovered = [];
+    walk2(e.tree, (id, what, words, leaf, claims) => {
+      if (!words) unnamed.push({ id, what });
+      if (leaf && !claims) uncovered.push(id);
+    });
+    return { entry: e.entry, undescribed: !e.described, unnamed, uncovered };
+  }).filter((o) => o.undescribed || o.unnamed.length || o.uncovered.length);
+}
+function unfollowed(record) {
+  return record.entries.filter((e) => !e.tree).map((e) => ({
+    entry: e.entry,
+    why: e.unsupported ?? "the engine gave no reason"
+  }));
+}
+
+// src/studio/director.ts
+var VerifyProperty = z6.looseObject({
+  id: z6.string(),
+  title: z6.string(),
+  status: z6.string(),
+  details: z6.array(z6.string()).default([]),
+  accepted: z6.unknown().optional()
 });
-var Verify = z5.looseObject({
-  topology: z5.string().optional(),
-  verdict: z5.looseObject({ proven: z5.boolean(), properties: z5.array(VerifyProperty) })
+var Verify = z6.looseObject({
+  topology: z6.string().optional(),
+  verdict: z6.looseObject({ proven: z6.boolean(), properties: z6.array(VerifyProperty) })
 });
-var Protocol = z5.looseObject({ protocol: z5.looseObject({ status: z5.string(), name: z5.string().optional() }).optional(), error: z5.string().optional() });
+var Protocol = z6.looseObject({ protocol: z6.looseObject({ status: z6.string(), name: z6.string().optional() }).optional(), error: z6.string().optional() });
 var caseFile = (root, questionId) => path3.join(studioDir(root), "cases", `${questionId.replace(/[^A-Za-z0-9]+/g, "-").replace(/^-|-$/g, "")}.json`);
 var answerOf = (requirements, id) => requirements.answers.find((a) => a.question === id) ?? null;
 function instancesFor(requirements) {
@@ -949,6 +1427,8 @@ async function judge(root, engine, sources, question, answer, report, verify) {
   if (!answer) return { ...base, status: "unanswered" };
   const byId = (id) => verify.find((p) => p.id === id);
   switch (question.kind) {
+    case "platform":
+      return { ...base, status: "decided" };
     case "topology":
       return {
         ...base,
@@ -1019,24 +1499,41 @@ async function judge(root, engine, sources, question, answer, report, verify) {
 }
 var QUESTION_PROPERTIES = (id) => id.startsWith("access:") || id === "access-coverage" || id === "rmw-transactions" || id === "integrity";
 var GUIDE = {
+  platform: "Deploy",
   topology: "Multi-instance data integrity",
   access: "Owner-scoped data",
   together: "Atomic commands with Yichus/Transaction",
   partial: "Transaction protocols: finite cases, retries, and receipts",
   outside: "Transaction protocols: finite cases, retries, and receipts"
 };
+var askStep = (open) => ({
+  stage: "ask",
+  summary: `${open.length} question${open.length === 1 ? "" : "s"} for you about how the app should behave.`,
+  instructions: [
+    "Ask the person each question below, in its words, with its choices. They may also answer on the studio page.",
+    "Speak in product terms: never quote question ids, code names, file names, tool names or the programming language to the person.",
+    'Do not answer for them and do not pick a default: these are product decisions only they can make. If they are unsure, explain the "why" and the choices.',
+    "Record each answer with yichus_answer (the question id, the choice id, and their own words), then call yichus_next."
+  ],
+  ask: open.map((p) => ({ id: p.question.id, ask: p.question.ask, why: p.question.why, choices: p.question.choices }))
+});
 function nextStep(state, compileErrors) {
   if (!state.description) return {
     stage: "describe",
     summary: "Waiting for a description of what to build.",
     instructions: ["Ask the person what they want to build, in their own words. Call yichus_start with their description, unchanged."]
   };
+  const where = state.properties.find((p) => p.question.kind === "platform");
+  if (!where.answer) return askStep([where]);
+  const deploySection = PLATFORM_SECTION[where.answer.choice];
   if (!state.files.length) return {
     stage: "write",
     summary: "No program yet.",
     instructions: [
+      `Call yichus_reference with topic "deploy" and build what its "${deploySection}" section says: which pieces run where, the database, and how background work starts.`,
       'Call api_guide with section "Required workflow", then write the program as .bosatsu files in this project folder.',
       "For an app that stores records, call api_scaffold first and save its module as a file here. You never need to pass sources: the studio reads every .bosatsu file in the folder.",
+      'Put every decision the app makes in pure functions, and keep the code that reads, writes and calls out free of business rules. When work takes several steps or waits on an outside service (a model, a web page, a payment), write it as one pure step program that a rule-free engine drives: call yichus_reference with topic "portable-programs" before writing it.',
       "Then call yichus_next."
     ]
   };
@@ -1063,16 +1560,32 @@ function nextStep(state, compileErrors) {
     ]
   };
   const unanswered = state.properties.filter((p) => p.status === "unanswered");
-  if (unanswered.length) return {
-    stage: "ask",
-    summary: `${unanswered.length} question${unanswered.length === 1 ? "" : "s"} for you about how the app should behave.`,
+  if (unanswered.length) return askStep(unanswered);
+  const scenarios = state.whatHappens;
+  const owes = scenarios ? owed(scenarios) : [];
+  if (scenarios && (owes.length || scenarios.refused.length || scenarios.notes.length || scenarios.mismatches.length)) return {
+    stage: "scenarios",
+    summary: "Your agent is writing down, in your words, what should happen in each thing your app does.",
     instructions: [
-      "Ask the person each question below, in its words, with its choices. They may also answer on the studio page.",
-      "Speak in product terms: never quote question ids, code names, file names, tool names or the programming language to the person.",
-      'Do not answer for them and do not pick a default: these are product decisions only they can make. If they are unsure, explain the "why" and the choices.',
-      "Record each answer with yichus_answer (the question id, the choice id, and their own words), then call yichus_next."
+      "Write down what should happen in each action below, as the person would say it, and call yichus_scenario with all of them at once. For each action give:",
+      'title: what the person does ("You add a note").',
+      'names: for every id listed under the action, a few words the person would use: the question the app asks itself ("are you signed in?"), each answer, and each outcome ("your note is saved").',
+      'expect: for every outcome, what must and must not happen there, each {"at": an id, "claim": a claim}. A claim is [not] reads TABLE, writes TABLE, refused, returns CONSTRUCTOR, reaches model or reaches net; a claim at an id covers every outcome under it.',
+      "State what the person wants, from their description and answers, never what the code happens to do. Where you cannot tell, ask the person in product terms.",
+      ...scenarios.notes.length ? ["Some expectations are not claims, so nothing checks them (the evidence lists them). Write each as a claim in the grammar above. If what the person expects cannot be said that way, tell them it will not be checked and leave it out."] : [],
+      ...scenarios.mismatches.length ? ["Some scenarios are for actions the app no longer has (the evidence lists them). If the person dropped the action, pass it in drop. If it was renamed or moved, describe the new action and drop the old one in the same call."] : [],
+      ...owes.flatMap((o) => [
+        `${o.entry}${o.undescribed ? " (not described yet)" : ""}:`,
+        ...o.unnamed.map((u) => `  ${u.id}: ${u.what}`),
+        ...o.uncovered.length ? [`  outcomes no claim covers: ${o.uncovered.join(", ")}`] : []
+      ]),
+      "Then call yichus_next."
     ],
-    ask: unanswered.map((p) => ({ id: p.question.id, ask: p.question.ask, why: p.question.why, choices: p.question.choices }))
+    evidence: [
+      ...scenarios.refused.map((r) => `${r.entry}: "${r.words}" at ${r.id} was refused: ${r.reason}`),
+      ...scenarios.notes.map((n) => `${n.entry}: "${n.text}" at ${n.at} is not a claim`),
+      ...scenarios.mismatches.map((m) => `${m.entry}: ${m.reason}`)
+    ]
   };
   const mismatched = state.properties.filter((p) => p.status === "mismatch");
   if (mismatched.length) return {
@@ -1085,16 +1598,29 @@ function nextStep(state, compileErrors) {
     evidence: mismatched.flatMap((p) => p.evidence)
   };
   const broken = state.properties.filter((p) => p.status === "broken" || p.status === "inconclusive");
-  if (broken.length || state.other.length) return {
+  const claims = (scenarios?.claims ?? []).filter((c) => c.verdict !== "holds");
+  const unfollowedEntries = scenarios ? unfollowed(scenarios) : [];
+  const unchecked = (state.whatHappensError ? 1 : 0) + unfollowedEntries.length;
+  const open = broken.length + state.other.length + claims.length + unchecked;
+  if (open) return {
     stage: "fix",
-    summary: `${broken.length + state.other.length} propert${broken.length + state.other.length === 1 ? "y is" : "ies are"} not holding yet.`,
+    summary: `${open} propert${open === 1 ? "y is" : "ies are"} not holding yet.`,
     instructions: [
       "Fix the program so each property below holds. The evidence lines are the engine's own words.",
       ...broken.map((p) => `"${p.question.ask}" The person chose "${p.question.choices.find((c) => c.id === p.answer?.choice)?.label}". Read api_guide section "${GUIDE[p.question.kind]}".`),
       ...state.other.map((o) => `${o.title} (${o.id}) is ${o.status}.`),
-      "Never weaken a rule, delete a check, or declare one server to make a check pass: change the code. Then call yichus_next."
+      ...claims.map((c) => `${c.entry}: the person expects "${c.claim}" at ${c.at}, and the engine finds it ${c.verdict === "fails" ? "fails" : "cannot be decided"} there.`),
+      ...state.whatHappensError ? ["The engine could not follow each action through, so no scenario is checked. If the error below points at the program, fix the program. Otherwise tell the person their scenarios cannot be checked yet, and never tell them their choices hold."] : [],
+      ...unfollowedEntries.length ? ["The engine could not follow some actions through (the evidence says which and why), so nothing the person expects of them is checked. If the reason points at the program, such as an action with too many ways through, change the program so it can be followed. Otherwise tell the person those actions are not checked, and never tell them their choices hold."] : [],
+      "Never weaken a rule, delete a check or a claim, or declare one server to make a check pass: change the code. If a claim misread what the person wants, ask them and correct the scenario. Then call yichus_next."
     ],
-    evidence: [...broken.flatMap((p) => p.evidence), ...state.other.flatMap((o) => o.details)]
+    evidence: [
+      ...broken.flatMap((p) => p.evidence),
+      ...state.other.flatMap((o) => o.details),
+      ...claims.map((c) => `${c.entry} at ${c.at}: ${c.parsed}: ${c.verdict}`),
+      ...state.whatHappensError ? [state.whatHappensError] : [],
+      ...unfollowedEntries.map((u) => `${u.entry} could not be followed: ${u.why}`)
+    ]
   };
   const cases = state.properties.filter((p) => p.status === "needs-case");
   if (cases.length) return {
@@ -1114,7 +1640,8 @@ function nextStep(state, compileErrors) {
     instructions: [
       "Tell the person every property they chose holds, and point them at the studio page for the evidence.",
       ...assumed.length ? ["Say plainly which results depend on running exactly one server."] : [],
-      "When they describe a new feature, change the code and call yichus_next again: new facts can raise new questions."
+      "When they describe a new feature, change the code and call yichus_next again: new facts can raise new questions.",
+      `When they want the app online, follow the "${deploySection}" section of yichus_reference topic "deploy"; api_deploy generates the server.`
     ]
   };
 }
@@ -1135,9 +1662,13 @@ async function direct({ root, engine, requirements, withMap = true, previous = n
     properties: [],
     other: [],
     map: null,
-    mapError: null
+    mapError: null,
+    layers: null,
+    whatHappens: null,
+    whatHappensError: null
   };
   let compileErrors = null;
+  if (requirements.description) base.properties.push(await judge(root, engine, sources, platform, answerOf(requirements, platform.id), Report.parse({}), []));
   if (requirements.description && sources.length) {
     const verify = Verify.parse(await call(engine, "api_verify", { sources, ...instances ? { instances } : {} }));
     base.topology = verify.topology ?? null;
@@ -1146,21 +1677,30 @@ async function direct({ root, engine, requirements, withMap = true, previous = n
     if (compiles && compiles.status !== "proven") compileErrors = compiles.details;
     else {
       const report = Report.parse(await call(engine, "api_report", { sources }));
-      const structureRaw = await call(engine, "api_organize", { sources, lens: "structure" });
+      const structureRaw = await call(engine, "api_organize", { sources, lens: "structure", requirements });
       const structure = Structure.parse(structureRaw);
       for (const question of questionsFor(report, structure, base.names)) {
         base.properties.push(await judge(root, engine, sources, question, answerOf(requirements, question.id), report, verify.verdict.properties));
       }
       base.other = verify.verdict.properties.filter((p) => !QUESTION_PROPERTIES(p.id) && p.status !== "proven" && !isAccepted(p)).map(({ id, title: title2, status, details }) => ({ id, title: title2, status, details }));
+      try {
+        const access = await call(engine, "api_access_check", { sources });
+        base.whatHappens = WhatHappens.parse(buildWhatHappens({ structure: structureRaw, access }, { program: base.project }));
+      } catch (error) {
+        base.whatHappensError = error instanceof Error ? error.message : String(error);
+      }
       if (withMap) {
-        if (previous?.sourcesHash === hash && previous.map) base.map = previous.map;
-        else {
+        if (previous?.sourcesHash === hash && previous.map) {
+          base.map = previous.map;
+          base.layers = previous.layers ?? null;
+        } else {
           try {
             const [abstractions, layers] = [
               await call(engine, "api_organize", { sources, lens: "abstractions" }),
               await call(engine, "api_organize", { sources, lens: "layers" })
             ];
             base.map = buildSystemMap({ report, structure: structureRaw, abstractions, layers }, { program: base.project });
+            base.layers = layers;
           } catch (error) {
             base.mapError = error instanceof Error ? error.message : String(error);
           }
@@ -1185,11 +1725,571 @@ function readState(root) {
 // src/studio/mcp.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { z as z6 } from "zod";
+import { z as z10 } from "zod";
 
-// src/studio/reference.ts
+// src/studio/marks.ts
 import fs4 from "fs";
 import path4 from "path";
+import { z as z8 } from "zod";
+
+// src/studio/person.ts
+import { createHash as createHash2 } from "crypto";
+import { z as z7 } from "zod";
+
+// ../../web/layer-groups.js
+var dimensions = Object.freeze({
+  connections: "packages they connect to",
+  types: "types they share",
+  tables: "tables they touch",
+  none: "no grouping"
+});
+function usesElsewhere(data, nodeOf = new Map(data.packages.map((p) => [p.name, p.name]))) {
+  const pkg = (id) => id.slice(0, id.indexOf("::"));
+  const uses = new Map([...new Set(nodeOf.values())].map((n) => [n, 0]));
+  const add = (from, to, n) => {
+    if (nodeOf.get(from) !== nodeOf.get(to)) uses.set(nodeOf.get(to), uses.get(nodeOf.get(to)) + n);
+  };
+  for (const e of data.crossEdges) add(pkg(e.from), pkg(e.to), 1);
+  for (const e of data.packageEdges) add(e.from, e.to, e.typeNames.length);
+  return uses;
+}
+
+// src/studio/person.ts
+var named = (names, code) => names[code] ?? null;
+var theirs = (words, missing) => words === null ? missing : { theirs: words };
+var Package = z7.looseObject({
+  name: z7.string(),
+  level: z7.number(),
+  reads: z7.array(z7.string()),
+  writes: z7.array(z7.string()),
+  handedIn: z7.array(z7.string())
+});
+var Layers = z7.looseObject({
+  layers: z7.looseObject({ packages: z7.array(Package), packageEdges: z7.array(z7.looseObject({})), crossEdges: z7.array(z7.looseObject({})) })
+});
+function personSections(layers, names, anchors = /* @__PURE__ */ new Map()) {
+  const parsed = Layers.safeParse(layers);
+  if (!parsed.success) return null;
+  const data = parsed.data.layers;
+  const uses = usesElsewhere(data);
+  const levels = [...new Set(data.packages.map((p) => p.level))].sort((a, b) => b - a);
+  return levels.map((level, i) => data.packages.filter((p) => p.level === level).map((p) => {
+    const own = (tables) => [...new Set(tables.filter((t) => !p.handedIn.includes(t)).map((t) => named(names, t)))];
+    const changes = own(p.writes);
+    return { code: p.name, name: named(names, p.name), changes, looks: own(p.reads).filter((t) => !changes.includes(t)), uses: uses.get(p.name) };
+  }).sort((a, b) => b.uses - a.uses).map(({ code, ...section }, k) => {
+    const anchor = `section-${i}-${k}`;
+    anchors.set(code, anchor);
+    return { anchor, ...section };
+  }));
+}
+var Property2 = z7.object({ negated: z7.boolean(), is: z7.enum(["reads", "writes", "refused", "returns", "reaches"]), subject: z7.string().optional() });
+var Claim2 = z7.looseObject({ property: Property2, verdict: z7.enum(["holds", "fails", "inconclusive"]) });
+var Leaf2 = z7.looseObject({
+  kind: z7.literal("leaf"),
+  id: z7.string(),
+  words: z7.string().nullable(),
+  status: z7.enum(["grey", "red", "green", "unchecked"]),
+  outcome: z7.looseObject({ kind: z7.string() }),
+  claims: z7.array(Claim2),
+  witnesses: z7.array(z7.string())
+});
+var Tree2 = z7.lazy(() => z7.union([Leaf2, z7.looseObject({
+  kind: z7.literal("node"),
+  id: z7.string(),
+  words: z7.string().nullable(),
+  arms: z7.array(z7.looseObject({ id: z7.string(), words: z7.string().nullable(), next: Tree2 }))
+})]));
+var Happens = z7.looseObject({
+  entries: z7.array(z7.looseObject({ entry: z7.string(), title: z7.string().nullable(), described: z7.boolean(), tree: Tree2.nullable() })),
+  witnesses: z7.array(z7.looseObject({ id: z7.string(), resource: z7.string() }))
+});
+function sayClaim({ negated, is, subject }, names) {
+  const thing = theirs(subject === void 0 ? null : named(names, subject), "something not named yet");
+  const said = is === "refused" ? ["turned away"] : is === "reaches" ? [subject === "model" ? "asks the AI model" : "reaches the internet"] : [is === "reads" ? "looks at " : is === "writes" ? "changes " : "answers ", thing];
+  return !negated ? said : is === "refused" ? ["not turned away"] : ["never ", ...said];
+}
+function personWhatHappens(record, names, anchors = /* @__PURE__ */ new Map()) {
+  const parsed = Happens.safeParse(record);
+  if (!parsed.success) return null;
+  const reach = new Map(parsed.data.witnesses.map((w) => [w.id, named(names, w.resource)]));
+  const VERDICT = { holds: "holds", fails: "fails", inconclusive: "cannot say" };
+  const at = (id, anchor) => {
+    anchors.set(id, anchor);
+    return anchor;
+  };
+  const step = (t, said, place) => {
+    if (t.kind === "leaf") return {
+      kind: "outcome",
+      anchor: at(t.id, place),
+      words: t.words === said ? null : t.words,
+      refused: t.outcome.kind === "refused",
+      status: t.status,
+      checks: [
+        ...t.claims.map((c) => ({ says: sayClaim(c.property, names), verdict: VERDICT[c.verdict] })),
+        ...t.witnesses.map((w) => ({ says: ["someone else's ", theirs(reach.get(w) ?? null, "records"), " can be reached here"], verdict: "fails" }))
+      ]
+    };
+    return { kind: "choice", anchor: at(t.id, place), words: t.words, ways: t.arms.map((a, k) => {
+      const then = step(a.next, a.next.id === a.id ? a.words : null, `${place}-${k}`);
+      return { anchor: a.next.id === a.id ? then.anchor : at(a.id, `${place}-${k}-way`), words: a.words, then };
+    }) };
+  };
+  const described = parsed.data.entries.filter((e) => e.described);
+  return {
+    actions: described.map((e, i) => ({ anchor: at(e.entry, `action-${i}`), title: e.title, first: e.tree && step(e.tree, null, `action-${i}-step`) })),
+    waiting: parsed.data.entries.length - described.length
+  };
+}
+function personDiagrams(state, names) {
+  const anchors = /* @__PURE__ */ new Map();
+  const sections = personSections(state.layers, names, anchors);
+  const whatHappens = state.whatHappens ? personWhatHappens(state.whatHappens, names, anchors) : null;
+  const drawing = createHash2("sha256").update(JSON.stringify([...anchors])).digest("hex").slice(0, 16);
+  return { sections, whatHappens, anchors, drawing };
+}
+
+// src/studio/marks.ts
+var Mark = z8.object({ at: z8.string().min(1), note: z8.string().trim().min(1).max(280) }).strict();
+var Marks = z8.object({ schemaVersion: z8.literal("yichus-marks-1"), said: z8.string(), marks: z8.array(Mark) });
+var PointArgs = z8.object({ marks: z8.array(Mark) }).strict();
+var marksPath = (root) => path4.join(studioDir(root), "marks.json");
+function loadMarks(root) {
+  const file = marksPath(root);
+  if (!fs4.existsSync(file)) return null;
+  const parsed = Marks.safeParse(JSON.parse(fs4.readFileSync(file, "utf8")));
+  if (!parsed.success) throw new Error(`${file} is not a yichus-marks-1 file: ${z8.prettifyError(parsed.error)}`);
+  return parsed.data;
+}
+function pointable(root) {
+  const state = readState(root);
+  return new Set(state ? personDiagrams(state, loadRequirements(root).names ?? {}).anchors.keys() : []);
+}
+function recordMarks(root, args, now) {
+  const parsed = PointArgs.safeParse(args);
+  if (!parsed.success) return { ok: false, error: `yichus_point needs marks, each with at and a note of at most 280 characters. ${z8.prettifyError(parsed.error)}` };
+  const known = pointable(root);
+  const unknown = parsed.data.marks.map((m) => m.at).filter((at) => !known.has(at));
+  if (unknown.length) return { ok: false, error: `The page draws nothing at ${unknown.join(", ")}. Point at a section (a part's code name as yichus_name took it), an action once yichus_scenario described it, or an id yichus_next listed under a described action; call yichus_next for the latest ids.` };
+  ensureStudioDir(root);
+  fs4.writeFileSync(marksPath(root), `${JSON.stringify(Marks.parse({ schemaVersion: "yichus-marks-1", said: now.toISOString(), marks: parsed.data.marks }), null, 2)}
+`);
+  return { ok: true };
+}
+
+// src/studio/page.ts
+var PAGE_STATUS = {
+  unanswered: ["waiting for your answer", "quiet"],
+  decided: ["decided", "good"],
+  assumed: ["holds, under an assumption", "warn"],
+  proven: ["proven", "good"],
+  bounded: ["holds in every scenario checked", "good"],
+  broken: ["broken", "bad"],
+  mismatch: ["the code says otherwise", "bad"],
+  "needs-case": ["scenario being written", "quiet"],
+  inconclusive: ["not decided yet", "warn"],
+  "no-check": ["no check needed", "quiet"],
+  pending: ["answered, waiting for your agent to check", "quiet"]
+};
+var PAGE_HEADINGS = {
+  asked: "What you asked for",
+  now: "What is happening now",
+  questions: "Questions for you",
+  props: "What your program must do",
+  happens: "What happens when",
+  sections: "How your app is built",
+  map: "The shape of your program"
+};
+var STUDIO_PAGE = `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Yichus studio</title>
+<link rel="stylesheet" href="system-map.css">
+<style>
+  :root { --ink:#0f172a; --muted:#475569; --faint:#94a3b8; --rule:#e2e8f0; --paper:#ffffff; --page:#f6f8fb;
+    --good:#047857; --goodSoft:#ecfdf5; --bad:#b91c1c; --badSoft:#fef2f2; --warn:#92400e; --warnSoft:#fffbeb; --accent:#22675e;
+    --agent:#4f46e5; --agentSoft:rgba(79,70,229,0.16); }
+  * { box-sizing:border-box; }
+  body { margin:0; background:var(--page); color:var(--ink); font:16px/1.55 Inter, system-ui, sans-serif; }
+  main { max-width:1100px; margin:0 auto; padding:24px 16px 64px; }
+  header p { margin:4px 0 0; color:var(--muted); }
+  h1 { font-size:1.6rem; margin:0; font-weight:600; }
+  h2 { font-size:1.15rem; margin:32px 0 8px; }
+  section > p.lede { color:var(--muted); margin:0 0 12px; max-width:70ch; }
+  .frame { background:var(--paper); border:1px solid var(--rule); border-radius:10px; padding:16px; position:relative; }
+  .frame > .tag { position:absolute; top:-10px; left:12px; background:var(--page); padding:0 6px; font-size:0.72rem; letter-spacing:0.08em; text-transform:uppercase; color:var(--accent); font-weight:700; }
+  .yours { border-left:3px solid var(--accent); padding:4px 12px; margin:0; font-style:italic; }
+  .label { font-size:0.75rem; color:var(--muted); text-transform:uppercase; letter-spacing:0.06em; margin:0 0 4px; }
+  .now { font-weight:600; }
+  .question { border-top:1px solid var(--rule); padding:14px 0; }
+  .question:first-of-type { border-top:none; padding-top:4px; }
+  .question .ask { font-weight:600; margin:0 0 4px; }
+  .question .why { color:var(--muted); margin:0 0 8px; font-size:0.94rem; }
+  .choice { display:flex; gap:8px; align-items:flex-start; margin:6px 0; }
+  .choice span small { display:block; color:var(--muted); }
+  textarea { width:100%; min-height:3.2em; font:inherit; border:1px solid var(--rule); border-radius:8px; padding:8px; margin:6px 0; }
+  button { font:inherit; font-weight:600; border:none; border-radius:8px; padding:8px 14px; background:var(--accent); color:#fff; cursor:pointer; }
+  button:disabled { opacity:0.5; cursor:default; }
+  .props { list-style:none; margin:0; padding:0; }
+  .props li { border-top:1px solid var(--rule); padding:12px 0; display:grid; grid-template-columns:1fr auto; gap:4px 16px; }
+  .props li:first-child { border-top:none; }
+  .chip { font-size:0.8rem; font-weight:700; border-radius:999px; padding:2px 10px; white-space:nowrap; align-self:start; justify-self:start; }
+  .chip.good { color:var(--good); background:var(--goodSoft); }
+  .chip.bad { color:var(--bad); background:var(--badSoft); }
+  .chip.warn { color:var(--warn); background:var(--warnSoft); }
+  .chip.quiet { color:var(--muted); background:var(--rule); }
+  .props .choice-said { color:var(--muted); font-size:0.94rem; grid-column:1 / -1; }
+  details { grid-column:1 / -1; font-size:0.88rem; }
+  details pre { white-space:pre-wrap; word-break:break-word; background:var(--page); border-radius:8px; padding:8px; margin:6px 0 0; font-size:0.82rem; }
+  .empty { color:var(--muted); }
+  .studio-action { border-top:1px solid var(--rule); padding:12px 0; }
+  .studio-action:first-child { border-top:none; padding-top:0; }
+  .studio-action h3 { font-size:1rem; margin:0 0 8px; font-weight:600; }
+  .studio-ask, .studio-way { margin:0; }
+  .studio-ways { list-style:none; margin:4px 0 0 9px; padding:0 0 0 14px; border-left:2px solid var(--rule); }
+  .studio-ways > li { position:relative; padding:4px 0; }
+  .studio-ways > li::before { content:''; position:absolute; left:-14px; top:15px; width:10px; border-top:2px solid var(--rule); }
+  .studio-way, .studio-on { color:var(--muted); }
+  .studio-on { margin:4px 0 0; }
+  .studio-fold summary { cursor:pointer; color:var(--muted); }
+  .studio-folded { margin:4px 0 0; padding-left:10px; border-left:2px dashed var(--rule); }
+  .studio-outcome { display:grid; grid-template-columns:20px minmax(0, 1fr); align-items:center; gap:2px 8px; margin:2px 0 0; }
+  .studio-said, .studio-ask, .studio-way, .studio-checks li { overflow-wrap:anywhere; }
+  .studio-end { font-weight:600; }
+  .studio-outcome[data-status="red"] .studio-end { color:var(--bad); }
+  .studio-outcome[data-status="green"] .studio-end { color:var(--good); }
+  .studio-checks { list-style:none; margin:0; padding:0; grid-column:2; display:flex; flex-wrap:wrap; gap:2px 12px; font-size:0.9rem; color:var(--muted); }
+  .studio-checks li { min-width:0; }
+  .studio-checks [data-verdict="fails"] { color:var(--bad); font-weight:600; }
+  .studio-checks [data-verdict="cannot say"] { color:var(--warn); }
+  .studio-unnamed, .studio-waiting { color:var(--faint); }
+  .studio-stack { display:block; max-width:100%; height:auto; }
+  .studio-band { fill:var(--page); }
+  .studio-band[data-shade="1"] { fill:#eef2f7; }
+  .studio-section rect { fill:var(--paper); stroke:var(--faint); }
+  .studio-canvas { fill:var(--paper); }
+  .studio-section-name { fill:var(--ink); }
+  .studio-section[data-named="false"] .studio-section-name { fill:var(--faint); }
+  .studio-section-does { fill:var(--muted); }
+  .agent-layer { position:absolute; left:0; top:0; width:0; height:0; z-index:20; pointer-events:none; }
+  .agent-ring { position:absolute; border-radius:10px; box-shadow:0 0 0 2px var(--agent), 0 0 0 8px var(--agentSoft); }
+  .agent-bubble { position:absolute; pointer-events:auto; background:var(--paper); border:1px solid var(--agent); border-radius:4px 14px 14px 14px;
+    padding:8px 30px 10px 12px; box-shadow:0 10px 28px rgba(15,23,42,0.18); font-size:0.94rem; }
+  .agent-tail { position:absolute; top:-7px; width:12px; height:12px; background:var(--paper); border-left:1px solid var(--agent); border-top:1px solid var(--agent); transform:rotate(45deg); }
+  .agent-bubble[data-side="right"] { border-radius:14px 14px 14px 14px; }
+  .agent-bubble[data-side="right"] .agent-tail { transform:rotate(-45deg); }
+  .agent-who { margin:0 0 2px; font-size:0.72rem; font-weight:700; letter-spacing:0.06em; text-transform:uppercase; color:var(--agent); }
+  .agent-who span { color:var(--muted); font-weight:600; }
+  .agent-says { margin:0; overflow-wrap:anywhere; }
+  .agent-close { position:absolute; top:4px; right:4px; background:none; color:var(--muted); padding:2px 8px; font-size:1rem; line-height:1; }
+  .agent-in { animation:agent-in 280ms ease-out both; }
+  @keyframes agent-in { from { opacity:0; transform:translateY(6px); } to { opacity:1; transform:none; } }
+  @media (prefers-reduced-motion: reduce) { .agent-in { animation:none; } }
+  @media (max-width:640px) { .props li { grid-template-columns:1fr; } }
+</style>
+</head>
+<body>
+<main>
+  <header>
+    <h1>Yichus studio<span id="project"></span></h1>
+    <p id="updated">Waiting for your agent.</p>
+    <p>Ask your agent what anything here means.</p>
+  </header>
+  <section aria-labelledby="h-asked" data-section="asked">
+    <h2 id="h-asked">${PAGE_HEADINGS.asked}</h2>
+    <p class="label">Your words</p>
+    <p class="yours" id="description">Nothing yet. Tell your agent what you want to build.</p>
+  </section>
+  <section aria-labelledby="h-now" data-section="now">
+    <h2 id="h-now">${PAGE_HEADINGS.now}</h2>
+    <div class="frame"><span class="tag">Yichus output</span>
+      <p class="now" id="summary">No checks have run yet.</p>
+    </div>
+  </section>
+  <section aria-labelledby="h-questions" id="questions-section" data-section="questions" hidden>
+    <h2 id="h-questions">${PAGE_HEADINGS.questions}</h2>
+    <p class="lede">Your agent will ask you these too. Answer here or in the chat, whichever is easier.</p>
+    <div class="frame"><span class="tag">Yichus output</span><div id="questions"></div></div>
+  </section>
+  <section aria-labelledby="h-props" data-section="props">
+    <h2 id="h-props">${PAGE_HEADINGS.props}</h2>
+    <div class="frame"><span class="tag">Yichus output</span><ul class="props" id="props"><li class="empty">No properties chosen yet.</li></ul></div>
+  </section>
+  <section aria-labelledby="h-happens" data-section="happens">
+    <h2 id="h-happens">${PAGE_HEADINGS.happens}</h2>
+    <p class="lede">Each thing your app does, every way it can go, and what you get at the end, in the words you and your agent chose.</p>
+    <p class="label">Drawn by Yichus. Words in italics are your agent's, not checked</p>
+    <div class="frame"><div id="happens"><p class="empty">This appears once the program compiles.</p></div></div>
+  </section>
+  <section aria-labelledby="h-sections" data-section="sections">
+    <h2 id="h-sections">${PAGE_HEADINGS.sections}</h2>
+    <p class="lede">The parts of your app, stacked: each layer is built only from the layers below it.</p>
+    <p class="label">Drawn by Yichus. Words in italics are your agent's, not checked</p>
+    <div class="frame"><div id="sections"><p class="empty">This appears once the program compiles.</p></div></div>
+  </section>
+  <section aria-labelledby="h-map" data-section="map">
+    <h2 id="h-map">${PAGE_HEADINGS.map}</h2>
+    <div class="frame"><div class="system-map" id="map"><p class="empty">The map appears once the program compiles.</p></div></div>
+  </section>
+</main>
+<script type="module">
+import { mount } from './system-map.js';
+import { mountSections, mountWhatHappens, reportViewing, showMarks } from './studio-views.js';
+
+const STATUS = ${JSON.stringify(PAGE_STATUS)};
+const el = (tag, props = {}, ...kids) => { const n = Object.assign(document.createElement(tag), props); n.append(...kids); return n; };
+let mapHash = null, drawn = '';
+
+function questionCard(q, saved) {
+  const card = el('div', { className: 'question' });
+  card.dataset.question = q.id;
+  card.append(el('p', { className: 'ask', textContent: q.ask }), el('p', { className: 'why', textContent: q.why }));
+  const name = 'q-' + q.id;
+  for (const c of q.choices) {
+    const input = el('input', { type: 'radio', name, value: c.id, checked: saved?.choice === c.id });
+    card.append(el('label', { className: 'choice' }, input, el('span', {}, c.label, el('small', { textContent: c.means }))));
+  }
+  const words = el('textarea', { placeholder: 'In your own words (optional)', value: saved?.words ?? '' });
+  const status = el('span', { className: 'empty', textContent: saved ? ' Saved. Your agent will check it next.' : '' });
+  const save = el('button', { type: 'button', textContent: 'Save answer' });
+  save.addEventListener('click', async () => {
+    const picked = card.querySelector('input[name="' + CSS.escape(name) + '"]:checked');
+    if (!picked) { status.textContent = ' Pick one of the choices first.'; return; }
+    save.disabled = true;
+    const label = q.choices.find(c => c.id === picked.value).label;
+    const response = await fetch('/answer', { method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ question: q.id, choice: picked.value, words: words.value.trim() || label }) });
+    const result = await response.json();
+    status.textContent = result.ok ? ' Saved. Your agent will check it next.' : ' ' + result.error;
+    save.disabled = false;
+  });
+  card.append(el('p', { className: 'label', textContent: 'Your words' }), words, save, status);
+  return card;
+}
+
+function propertyRow(p, saved) {
+  const stale = saved && (!p.answer || p.answer.answeredAt !== saved.answeredAt);
+  const [words, tone] = STATUS[stale ? 'pending' : p.status];
+  const answer = stale ? saved : p.answer;
+  const label = p.question.choices.find(c => c.id === answer.choice)?.label ?? answer.choice;
+  const li = el('li', {}, el('span', { textContent: p.question.ask }), el('span', { className: 'chip ' + tone, textContent: words }));
+  li.dataset.property = p.question.id;
+  li.append(el('span', { className: 'choice-said', textContent: 'You chose: ' + label + (answer.words && answer.words !== label ? ' ("' + answer.words + '")' : '') }));
+  return li;
+}
+
+async function refresh() {
+  const { state, requirements } = await (await fetch('/state')).json();
+  const savedOf = id => requirements.answers.find(a => a.question === id);
+  if (requirements.description) document.getElementById('description').textContent = requirements.description;
+  if (!state) return;
+  document.getElementById('project').textContent = ': ' + state.project;
+  document.getElementById('updated').textContent = 'Last checked ' + new Date(state.updatedAt).toLocaleTimeString() + '.';
+  document.getElementById('summary').textContent = state.summary;
+  const open = state.properties.filter(p => p.status === 'unanswered' && !savedOf(p.question.id));
+  document.getElementById('questions-section').hidden = !open.length;
+  // Keep a half-written answer: only rebuild cards when the questions change.
+  const qs = document.getElementById('questions');
+  const ids = open.map(p => p.question.id).join(' ');
+  if (qs.dataset.ids !== ids) { qs.dataset.ids = ids; qs.replaceChildren(...open.map(p => questionCard(p.question, savedOf(p.question.id)))); }
+  const chosen = state.properties.filter(p => p.answer || savedOf(p.question.id));
+  document.getElementById('props').replaceChildren(...(chosen.length ? chosen.map(p => propertyRow(p, savedOf(p.question.id)))
+    : [el('li', { className: 'empty', textContent: 'No properties chosen yet.' })]));
+  // Redrawn only when the words or the program change.
+  const views = JSON.stringify([state.whatHappens, state.sections]);
+  if (views !== drawn) {
+    drawn = views;
+    if (state.whatHappens) mountWhatHappens(document.getElementById('happens'), state.whatHappens);
+    if (state.sections) mountSections(document.getElementById('sections'), state.sections);
+  }
+  const map = document.getElementById('map');
+  if (state.map && state.sourcesHash !== mapHash) { mapHash = state.sourcesHash; mount(map, state.map); }
+  else if (!state.map && state.mapError) map.replaceChildren(el('p', { className: 'empty', textContent: 'The map could not be drawn: ' + state.mapError }));
+  // Last, so each note is placed over the pictures as they are now drawn.
+  showMarks(state.marks);
+  viewing(state.drawing);
+}
+
+// What the person has in view goes to the studio, so their agent can follow
+// along when they say "this one".
+const viewing = reportViewing(body => fetch('/viewing', { method: 'POST', headers: { 'content-type': 'application/json' }, body }));
+
+new EventSource('/events').addEventListener('change', () => refresh());
+refresh();
+</script>
+</body>
+</html>
+`;
+
+// src/studio/viewing.ts
+import fs5 from "fs";
+import path5 from "path";
+import { z as z9 } from "zod";
+var PAGE_SECTIONS = ["asked", "now", "questions", "props", "happens", "sections", "map"];
+var Id = z9.string().min(1).max(200);
+var Ids = z9.array(Id).max(1e3);
+var Section = z9.enum(PAGE_SECTIONS);
+var Touched = z9.discriminatedUnion("kind", [
+  z9.object({ kind: z9.literal("section"), id: Section }).strict(),
+  z9.object({ kind: z9.enum(["part", "question", "property"]), id: Id }).strict()
+]);
+var Report2 = z9.object({
+  /** The page's tab is the one in front. */
+  shown: z9.boolean(),
+  sections: z9.array(Section).max(PAGE_SECTIONS.length),
+  /** Anchors of the drawn parts on screen (person.ts). */
+  parts: Ids,
+  questions: Ids,
+  /** Question ids of the properties shown. */
+  properties: Ids,
+  /** Anchors of the folds the person opened. */
+  open: Ids,
+  touched: Touched.nullable(),
+  /** The drawing the anchors belong to (person.ts), or null before one is drawn. */
+  drawing: z9.string().max(64).nullable()
+}).strict();
+var Viewing = Report2.extend({ schemaVersion: z9.literal("yichus-viewing-1"), at: z9.string() }).strict();
+var viewingPath = (root) => path5.join(studioDir(root), "viewing.json");
+function loadViewing(root) {
+  const file = viewingPath(root);
+  if (!fs5.existsSync(file)) return null;
+  const parsed = Viewing.safeParse(JSON.parse(fs5.readFileSync(file, "utf8")));
+  if (!parsed.success) throw new Error(`${file} is not a yichus-viewing-1 file: ${z9.prettifyError(parsed.error)}`);
+  return parsed.data;
+}
+function recordViewing(root, report, now) {
+  const parsed = Report2.safeParse(report);
+  if (!parsed.success) return { ok: false, error: `The page's report is not one this studio reads. ${z9.prettifyError(parsed.error)}` };
+  ensureStudioDir(root);
+  const file = viewingPath(root), written = `${file}.${process.pid}.tmp`;
+  fs5.writeFileSync(written, `${JSON.stringify(Viewing.parse({ schemaVersion: "yichus-viewing-1", at: now.toISOString(), ...parsed.data }), null, 2)}
+`);
+  fs5.renameSync(written, file);
+  return { ok: true };
+}
+
+// src/studio/page-view.ts
+var quoted = (words, missing) => words === null ? missing : `"${words}"`;
+var say = (phrase) => phrase.map((p) => typeof p === "string" ? p : `"${p.theirs}"`).join("");
+var TICK = { holds: "\u2713", fails: "\u2717", "cannot say": "?" };
+var ENDING = {
+  grey: "no expectation is false here",
+  red: "something expected is false here",
+  green: "an ending that was broken is fixed",
+  unchecked: "the check cannot say"
+};
+function ago(from, now) {
+  const seconds = Math.max(0, Math.round((now.getTime() - Date.parse(from)) / 1e3));
+  const [n, unit] = seconds < 120 ? [seconds, "second"] : seconds < 7200 ? [Math.round(seconds / 60), "minute"] : [Math.round(seconds / 3600), "hour"];
+  return `${n} ${unit}${n === 1 ? "" : "s"} ago`;
+}
+function pageText(root, pageUrl, now) {
+  const state = readState(root);
+  const { description, answers, names = {} } = loadRequirements(root);
+  const marks = loadMarks(root);
+  const { sections, whatHappens, anchors, drawing } = state ? personDiagrams(state, names) : { sections: null, whatHappens: null, anchors: /* @__PURE__ */ new Map(), drawing: null };
+  const codeAt = new Map([...anchors].map(([code, anchor]) => [anchor, code]));
+  const said = /* @__PURE__ */ new Map();
+  const part = (anchor, words) => {
+    said.set(codeAt.get(anchor), words);
+    return `[${codeAt.get(anchor)}]`;
+  };
+  const out = [`The studio page${pageUrl ? ` (${pageUrl})` : ""}, as the person sees it now. Words in quotes are yours or the person's; the rest is computed. [ids] are what yichus_point takes.`];
+  const heading = (key) => out.push("", `## ${PAGE_HEADINGS[key]}`);
+  out.push("", "## What the person has in view");
+  const inView = out.length;
+  heading("asked");
+  out.push(description ? `"${description}"` : "Nothing yet.");
+  heading("now");
+  out.push(state ? state.step.summary : "No checks have run yet.");
+  const savedOf = (id) => answers.find((a) => a.question === id);
+  const open = (state?.properties ?? []).filter((p) => p.status === "unanswered" && !savedOf(p.question.id));
+  if (open.length) {
+    heading("questions");
+    for (const { question: q } of open) out.push(`question ${q.id}: ${q.ask}`, ...q.choices.map((c) => `  - ${c.label}: ${c.means}`));
+  }
+  heading("props");
+  const chosen = (state?.properties ?? []).filter((p) => p.answer || savedOf(p.question.id));
+  if (!chosen.length) out.push("No properties chosen yet.");
+  for (const p of chosen) {
+    const saved = savedOf(p.question.id);
+    const stale = saved && (!p.answer || p.answer.answeredAt !== saved.answeredAt);
+    const answer = stale ? saved : p.answer;
+    const label2 = p.question.choices.find((c) => c.id === answer.choice)?.label ?? answer.choice;
+    out.push(`question ${p.question.id}: ${p.question.ask} Status: ${PAGE_STATUS[stale ? "pending" : p.status][0]}. They chose ${label2}${answer.words && answer.words !== label2 ? ` ("${answer.words}")` : ""}.`);
+  }
+  heading("happens");
+  const step = (s, pad) => {
+    if (s.kind === "outcome") {
+      const end = `${s.refused ? "turned away" : "answered"}${s.words ? ` "${s.words}"` : ""}`;
+      return [`${pad}${part(s.anchor, end)} ${end}: ${ENDING[s.status]}`, ...s.checks.map((c) => `${pad}  ${TICK[c.verdict]} ${say(c.says)}`)];
+    }
+    const asks = quoted(s.words, "a check not described yet");
+    return [`${pad}${part(s.anchor, asks)} checks ${asks}`, ...s.ways.flatMap((w) => {
+      const words = quoted(w.words, "a way not described yet");
+      return [`${pad}  way ${words}${w.anchor === w.then.anchor ? "" : ` ${part(w.anchor, words)}`}:`, ...step(w.then, `${pad}    `)];
+    })];
+  };
+  if (!whatHappens) out.push(state?.whatHappensError ? `It could not be drawn: ${state.whatHappensError}` : "This appears once the program compiles.");
+  else {
+    if (!whatHappens.actions.length && !whatHappens.waiting) out.push("The app has no actions yet.");
+    for (const a of whatHappens.actions) {
+      const title2 = quoted(a.title, "an action not described yet");
+      out.push(`${part(a.anchor, title2)} ${title2}`, ...a.first ? step(a.first, "  ") : ["  This action could not be followed."]);
+    }
+    if (whatHappens.waiting) out.push(`${whatHappens.waiting} more ${whatHappens.waiting === 1 ? "action is" : "actions are"} not described yet.`);
+  }
+  heading("sections");
+  const records = (verb, names2) => names2.length ? [`${verb} ${names2.map((n) => quoted(n, "a kind of record not named yet")).join(", ")}`] : [];
+  const does = (s) => [...records("changes", s.changes), ...records("looks at", s.looks)].join(" \xB7 ") || "keeps no records itself";
+  if (!sections) out.push("This appears once the program compiles.");
+  else sections.forEach((layer, i) => {
+    out.push(`layer ${i + 1} of ${sections.length}${i === 0 ? ", the top" : ""}:`);
+    for (const s of layer) {
+      const name = quoted(s.name, "a part not named yet");
+      out.push(`  ${part(s.anchor, name)} ${name}: ${does(s)}`);
+    }
+  });
+  heading("map");
+  if (state?.map) {
+    const parts = nameableParts(state.map);
+    const unnamed = parts.filter((p) => !(p.code in names)).length;
+    out.push(`The system map of the program, drawn with the person's names for ${parts.length - unnamed} of its ${parts.length} parts${unnamed === 1 ? "; the other one shows its code name" : unnamed ? `; the other ${unnamed} show their code names` : ""}. api_abstraction_map gives the map itself.`);
+  } else out.push(state?.mapError ? `The map could not be drawn: ${state.mapError}` : "The map appears once the program compiles.");
+  out.push("", "## Your notes on the page");
+  const report = loadViewing(root);
+  const viewing = report && { ...report, current: report.drawing === drawing };
+  const visible = new Set(!viewing?.current ? [] : viewing.parts.flatMap((a) => codeAt.has(a) ? [codeAt.get(a)] : []));
+  const notes = marks?.marks.filter((m) => anchors.has(m.at)) ?? [];
+  if (!notes.length) out.push("None. yichus_point puts a note over a part of the page.");
+  else out.push(`Said ${ago(marks.said, now)}:`, ...notes.map((m) => `  [${m.at}] "${m.note}"${visible.has(m.at) ? " (on screen)" : ""}`));
+  out.splice(inView, 0, ...inViewLines(viewing, codeAt, said, now));
+  return `${out.join("\n")}
+`;
+}
+function inViewLines(viewing, codeAt, said, now) {
+  if (!viewing) return ["The page has not said what is on screen: it may not be open. Give the person the link yichus_start returned."];
+  const parts = (anchors) => !viewing.current ? [] : anchors.flatMap((a) => codeAt.has(a) ? [`[${codeAt.get(a)}] ${said.get(codeAt.get(a))}`] : []);
+  const list = (what, items) => items.length ? [`${what}:`, ...items.map((i) => `  ${i}`)] : [];
+  const { touched } = viewing;
+  const clicked = !touched ? [] : touched.kind === "section" ? [`Last clicked: in ${PAGE_HEADINGS[touched.id]}.`] : touched.kind === "question" ? [`Last clicked: question ${touched.id}.`] : touched.kind === "property" ? [`Last clicked: the property of question ${touched.id}.`] : parts([touched.id]).map((p) => `Last clicked: ${p}`);
+  return [
+    `The page said this ${ago(viewing.at, now)}. ${viewing.shown ? "Its tab is in front." : "Its tab is behind another one."}`,
+    `On screen: ${viewing.sections.map((s) => PAGE_HEADINGS[s]).join(", ") || "nothing of the page"}.`,
+    ...viewing.current ? [] : ["The pictures have changed since, so which of their parts are in view is not known until the page redraws and says again."],
+    ...list("Parts on screen", parts(viewing.parts)),
+    ...list("Questions on screen", viewing.questions.map((q) => `question ${q}`)),
+    ...list("Properties on screen", viewing.properties.map((q) => `question ${q}`)),
+    ...list("Folds the person opened", parts(viewing.open)),
+    ...clicked
+  ];
+}
+
+// src/studio/reference.ts
+import fs6 from "fs";
+import path6 from "path";
 import { fileURLToPath } from "url";
 
 // src/studio/reference.json
@@ -1198,6 +2298,23 @@ var reference_default = {
     { name: "protocol-specification.txt", from: "docs/protocol-verification.md" },
     { name: "withdrawal-case.json", from: "eval/corpus/webmcp-traps/iteration-003/programs/Q15/twin/case.json" },
     { name: "withdrawal.bosatsu", from: "eval/corpus/webmcp-traps/iteration-003/programs/Q15/twin/ledger.bosatsu" }
+  ],
+  "portable-programs": [
+    { name: "portable-programs.md", from: "docs/studio/portable-programs.md" },
+    { name: "refund-policy.bosatsu", from: "demos/portable/refund-policy.bosatsu" },
+    { name: "refund-desk.bosatsu", from: "demos/portable/refund-desk.bosatsu" },
+    { name: "refund-test.bosatsu", from: "demos/portable/refund-test.bosatsu" },
+    { name: "refund-desk-one-round.bosatsu", from: "demos/portable/limits/refund-desk-one-round.bosatsu" }
+  ],
+  deploy: [
+    { name: "deploy-platforms.md", from: "docs/studio/deploy-platforms.md" }
+  ],
+  guiding: [
+    { name: "the-page.md", from: "docs/studio/the-page.md" }
+  ],
+  porting: [
+    { name: "porting.md", from: "docs/studio/porting.md" },
+    { name: "worker-authority.md", from: "docs/runtime/worker-authority.md" }
   ]
 };
 
@@ -1205,11 +2322,11 @@ var reference_default = {
 var TOPICS = Object.keys(reference_default);
 var BUILT_REFERENCE = fileURLToPath(new URL("./studio-reference/", import.meta.url));
 var REPO_ROOT = fileURLToPath(new URL("../../../../", import.meta.url));
-var builtCopy = (file) => path4.join(BUILT_REFERENCE, file.name);
+var builtCopy = (file) => path6.join(BUILT_REFERENCE, file.name);
 function readReference(topic, locate) {
   if (!TOPICS.includes(topic)) return null;
   return reference_default[topic].map((file) => `===== ${file.name} =====
-${fs4.readFileSync(locate(file), "utf8")}`).join("\n\n");
+${fs6.readFileSync(locate(file), "utf8")}`).join("\n\n");
 }
 
 // src/studio/text.ts
@@ -1250,14 +2367,17 @@ function stepText(state, pageUrl) {
 var INSTRUCTIONS = `Yichus studio: you are building software for a person who will not read the code. Yichus tells you what to do next and proves the properties the person chooses.
 
 The loop:
-1. Ask the person what they want built and call yichus_start with their words.
+1. Ask the person what they want built and call yichus_start with their words. If it replaces an app they already have, read yichus_reference topic "porting" first: reading the old app is yours, and the studio sees only the new one.
 2. After every change to the code, call yichus_next and do exactly what it says. It reads the .bosatsu files in the project folder itself; you never paste sources.
 3. When yichus_next lists questions, put each one to the person with its choices and record their answer with yichus_answer. Never answer for them or pick a default: who may see data, what happens when two people act at once, and what happens when a server or an outside service fails are their product decisions.
 4. Never weaken a rule, delete a check, or declare a single server to make a check pass. Change the code.
-5. Give the person the studio page link from yichus_start. It shows the shape of their program and whether each property they chose holds.
-6. Speak to the person in product terms. They never need the programming language, code names, file names, tool names or question ids; when yichus_next asks you to name parts of the program, use the words they would use.
+5. Give the person the studio page link from yichus_start. It shows the shape of their program, what happens in each thing it does, and whether each property they chose holds. The person reads no documentation: everything they need to know about the steps, the questions, the statuses and the pictures comes from you, a little at a time as it becomes relevant. Read yichus_reference topic "guiding" before you give them the link.
+6. Speak to the person in product terms. They never need the programming language, code names, file names, tool names or question ids; when yichus_next asks you to name parts of the program or describe what happens, use the words they would use.
+7. Build for the place the person chose to run the app (yichus_reference topic "deploy"). Keep every business decision in pure code: work that takes several steps or waits on outside services is one pure step program that a rule-free engine drives (yichus_reference topic "portable-programs").
+8. While you talk with the person, point at what you mean on the studio page with yichus_point: a section of their app, an action, or a step in one, with a sentence or two as you would say it in the chat. The page shows each note over the pictures as yours, not checked, so never use a note to say something holds; the checks say that. Point again as the conversation moves on, and clear the marks when they no longer help.
+9. You drive the conversation, and the person reads the studio page while you talk. Call yichus_page to see what the page shows them, in words: what they asked for, the questions, each property with its status, what happens in each action, the sections of their app, your notes, and what they have on screen and last clicked. Call it whenever they refer to something on the page ("this one", "the red one", "what does that mean"), and after they answer on the page.
 
-Every api_* tool is available too. Leave out sources and the studio supplies the project's files.`;
+Every api_* tool is available too. Leave out sources and the studio supplies the project's files. Pages on yich.us, such as calculators and the playground, come through a separate connection (@yichus/mcp); building needs only this one.`;
 var START = {
   name: "yichus_start",
   description: "Record what the person wants built, in their own words, and get the studio page link to give them. Call this first.",
@@ -1288,14 +2408,53 @@ var NAME = {
     }
   }, required: ["names"] }
 };
+var SCENARIO = {
+  name: "yichus_scenario",
+  description: "Record what should happen in actions yichus_next listed, in the person's words: a title, names for the ids the engine computed, and claims the engine checks on each outcome. A scenario replaces any earlier one for the same action. drop removes the scenario of an action the app no longer has.",
+  inputSchema: { type: "object", properties: {
+    scenarios: { type: "array", items: { type: "object", properties: {
+      entry: { type: "string", description: "The action, as yichus_next listed it (route:/path)." },
+      title: { type: "string", description: "What the person does, in their words." },
+      names: { type: "object", additionalProperties: { type: "string" }, description: "Each id yichus_next listed under the action, with the person's words for it." },
+      expect: {
+        type: "array",
+        items: { type: "object", properties: { at: { type: "string" }, claim: { type: "string" } }, required: ["at", "claim"] },
+        description: "What must and must not happen: [not] reads TABLE, writes TABLE, refused, returns CONSTRUCTOR, reaches model or reaches net, at an id."
+      }
+    }, required: ["entry", "title", "names", "expect"] } },
+    drop: { type: "array", items: { type: "string" }, description: "Actions yichus_next reports the app no longer has, whose scenarios to remove." }
+  } }
+};
+var POINT = {
+  name: "yichus_point",
+  description: "Point at parts of the studio page while you talk with the person: each mark puts your short note over the picture, next to a section of their app, an action, or a step in one, marked as your words and not checked. A call replaces the marks before it; an empty list clears them.",
+  inputSchema: { type: "object", properties: {
+    marks: { type: "array", items: { type: "object", properties: {
+      at: { type: "string", description: "What to point at: a section by its code name as yichus_name took it, an action yichus_scenario described (route:/path), or an id yichus_next listed under a described action." },
+      note: { type: "string", description: "What you are saying about it, in the person's words, at most 280 characters." }
+    }, required: ["at", "note"] } }
+  }, required: ["marks"] }
+};
+var PAGE = {
+  name: "yichus_page",
+  description: "See the studio page as the person sees it now, in words, with the id yichus_point takes for each part: the questions, each property and its status, what happens in each action, the sections of their app and your notes. Also what the person has on screen, the folds they opened and what they last clicked. Call it when the person refers to something on the page.",
+  inputSchema: { type: "object", properties: {} }
+};
 var REFERENCE_TOOL = {
   name: "yichus_reference",
   description: "Reference material yichus_next asks for, such as the protocol case specification with a complete worked case.",
   inputSchema: { type: "object", properties: { topic: { type: "string", enum: TOPICS, description: "The topic yichus_next named." } }, required: ["topic"] }
 };
-var StartArgs = z6.object({ description: z6.string().min(1) });
-var AnswerArgs = z6.object({ question: z6.string().min(1), choice: z6.string().min(1), words: z6.string() });
-var NameArgs = z6.object({ names: z6.record(z6.string().min(1), z6.string().trim().min(1)).refine((names) => Object.keys(names).length > 0) });
+var StartArgs = z10.object({ description: z10.string().min(1) }).strict();
+var AnswerArgs = z10.object({ question: z10.string().min(1), choice: z10.string().min(1), words: z10.string() }).strict();
+var ScenarioInput = z10.object({
+  entry: z10.string().min(1),
+  title: z10.string().trim().min(1),
+  names: z10.record(z10.string().min(1), z10.string().trim().min(1)),
+  expect: z10.array(z10.object({ at: z10.string().min(1), claim: z10.string().trim().min(1) }).strict())
+}).strict();
+var ScenarioArgs = z10.object({ scenarios: z10.array(ScenarioInput).default([]), drop: z10.array(z10.string().min(1)).default([]) }).refine((a) => a.scenarios.length + a.drop.length > 0, "give at least one scenario or one action to drop");
+var NameArgs = z10.object({ names: z10.record(z10.string().min(1), z10.string().trim().min(1)).refine((names) => Object.keys(names).length > 0) });
 var text = (body, structured, isError = false) => ({ content: [{ type: "text", text: body }], ...structured ? { structuredContent: structured } : {}, isError });
 function studioTool(tool) {
   const schema = tool.inputSchema;
@@ -1306,9 +2465,15 @@ function studioTool(tool) {
     inputSchema: { ...schema, required: (schema.required ?? []).filter((name) => name !== "sources") }
   };
 }
+function recordStart(root, args) {
+  const parsed = StartArgs.safeParse(args);
+  if (!parsed.success) return { ok: false, error: `yichus_start needs the person's description, and nothing else. ${z10.prettifyError(parsed.error)}` };
+  saveRequirements(root, { ...loadRequirements(root), description: parsed.data.description });
+  return { ok: true };
+}
 function recordAnswer(root, args, now) {
   const parsed = AnswerArgs.safeParse(args);
-  if (!parsed.success) return { ok: false, error: "yichus_answer needs question, choice and words." };
+  if (!parsed.success) return { ok: false, error: `yichus_answer needs question, choice and words, and nothing else. ${z10.prettifyError(parsed.error)}` };
   const state = readState(root);
   const property = state?.properties.find((p) => p.question.id === parsed.data.question);
   if (!property) return { ok: false, error: `No question ${parsed.data.question} in the latest yichus_next; call yichus_next and use its ids.` };
@@ -1331,8 +2496,21 @@ function recordNames(root, args) {
   saveRequirements(root, withNames(loadRequirements(root), parsed.data.names));
   return { ok: true };
 }
+function recordScenarios(root, args) {
+  const parsed = ScenarioArgs.safeParse(args);
+  if (!parsed.success) return { ok: false, error: `yichus_scenario needs scenarios, each with entry, title, names and expect, or drop. ${z10.prettifyError(parsed.error)}` };
+  const happens = readState(root)?.whatHappens;
+  const entries = new Set(happens?.entries.map((e) => e.entry) ?? []);
+  const unknown = parsed.data.scenarios.map((s) => s.entry).filter((e) => !entries.has(e));
+  if (unknown.length) return { ok: false, error: `No action ${unknown.join(", ")} in the latest yichus_next; the actions are ${[...entries].join(", ") || "none yet"}.` };
+  const gone = new Set(happens?.mismatches.map((m) => m.entry));
+  const kept = parsed.data.drop.filter((e) => !gone.has(e));
+  if (kept.length) return { ok: false, error: `The latest yichus_next does not report ${kept.join(", ")} as gone, so its scenario stays. Only an action the app no longer has can be dropped; replace the scenario of one it still has.` };
+  saveRequirements(root, withScenarios(loadRequirements(root), parsed.data.scenarios, parsed.data.drop));
+  return { ok: true };
+}
 function createStudioMcpServer({ root, engine, catalog, pageUrl, now = () => /* @__PURE__ */ new Date(), locate = builtCopy }) {
-  const server = new Server({ name: "yichus-studio", version: "0.2.0" }, { capabilities: { tools: {} }, instructions: INSTRUCTIONS });
+  const server = new Server({ name: "yichus-studio", version: "0.3.0" }, { capabilities: { tools: {} }, instructions: INSTRUCTIONS });
   const active = /* @__PURE__ */ new Set();
   const track = (task) => {
     active.add(task);
@@ -1343,21 +2521,20 @@ function createStudioMcpServer({ root, engine, catalog, pageUrl, now = () => /*
   let tools = null;
   const catalogTools2 = async () => tools ??= (await catalog()).map(studioTool);
   let last = readState(root);
-  server.setRequestHandler(ListToolsRequestSchema, () => track((async () => ({ tools: [START, NEXT, NAME, ANSWER, REFERENCE_TOOL, ...await catalogTools2()] }))()));
+  server.setRequestHandler(ListToolsRequestSchema, () => track((async () => ({ tools: [START, NEXT, NAME, ANSWER, SCENARIO, POINT, PAGE, REFERENCE_TOOL, ...await catalogTools2()] }))()));
   server.setRequestHandler(CallToolRequestSchema, (request) => track(callTool(request.params)));
   async function callTool(params) {
     const { name, arguments: args = {} } = params;
     if (name === "yichus_start") {
-      const parsed = StartArgs.safeParse(args);
-      if (!parsed.success) return text("yichus_start needs the person's description.", void 0, true);
-      saveRequirements(root, { ...loadRequirements(root), description: parsed.data.description });
-      const page = pageUrl ? `Give the person this link and ask them to keep it open: ${pageUrl}` : "No studio page is running.";
+      const result2 = recordStart(root, args);
+      if (!result2.ok) return text(result2.error, void 0, true);
+      const page = pageUrl ? `Read yichus_reference topic "guiding", then give the person this link and ask them to keep it open: ${pageUrl}` : "No studio page is running.";
       return text(`${page}
 Next: call yichus_next.`, { pageUrl });
     }
     if (name === "yichus_next") {
       last = await direct({ root, engine, requirements: loadRequirements(root), previous: last });
-      const { map: _map, ...rest } = last;
+      const { map: _map, layers: _layers, whatHappens: _whatHappens, ...rest } = last;
       return text(stepText(last, pageUrl), rest);
     }
     if (name === "yichus_answer") {
@@ -1368,6 +2545,18 @@ Next: call yichus_next.`, { pageUrl });
       const result2 = recordNames(root, args);
       return result2.ok ? text("Recorded. Call yichus_next.") : text(result2.error, void 0, true);
     }
+    if (name === "yichus_scenario") {
+      const result2 = recordScenarios(root, args);
+      return result2.ok ? text("Recorded. Call yichus_next: the engine checks every name and claim.") : text(result2.error, void 0, true);
+    }
+    if (name === "yichus_point") {
+      const result2 = recordMarks(root, args, now());
+      return result2.ok ? text("The page shows your notes now. Go on talking with the person.") : text(result2.error, void 0, true);
+    }
+    if (name === "yichus_page") {
+      if (Object.keys(args).length) return text("yichus_page takes no arguments.", void 0, true);
+      return text(pageText(root, pageUrl, now()));
+    }
     if (name === "yichus_reference") {
       const said = readReference(String(args.topic), locate);
       return said ? text(said) : text(`No reference topic ${String(args.topic)}; the topics are ${TOPICS.join(", ")}.`, void 0, true);
@@ -1403,7 +2592,7 @@ Next: call yichus_next.`, { pageUrl });
 }
 
 // src/studio/command.ts
-var STUDIO_COMMANDS = /* @__PURE__ */ new Set(["start", "next", "name", "answer", "reference", "studio"]);
+var STUDIO_COMMANDS = /* @__PURE__ */ new Set(["start", "next", "name", "answer", "scenario", "point", "page", "reference", "studio"]);
 var STUDIO_HELP = `
 Studio (guided building; all take --project DIR, default the current folder):
   yichus studio [--port N]         MCP server on stdio plus the studio page
@@ -1412,6 +2601,9 @@ Studio (guided building; all take --project DIR, default the current folder):
   yichus next [--json]             check the program and print the next step
   yichus name SUBJECT "NAME" ...   plain names the person sees for parts of the program
   yichus answer QUESTION CHOICE [--words TEXT]
+  yichus scenario FILE.json        what should happen in actions: {"scenarios": [...], "drop": [...]}
+  yichus point FILE.json           point at parts of the page: {"marks": [{"at": ..., "note": ...}]}
+  yichus page                      the page as the person sees it now, in words
   yichus reference TOPIC           reference material a step asks for
 `;
 async function runStudioCommand(argv2, io) {
@@ -1424,13 +2616,14 @@ async function runStudioCommand(argv2, io) {
       port: { type: "string" }
     } });
     const [command, ...rest] = positionals;
-    const root = path5.resolve(values.project ?? ".");
+    const root = path7.resolve(values.project ?? ".");
     const expect = (n, usage) => {
       if (rest.length !== n) throw new Error(`Usage: ${usage}`);
     };
     if (command === "start") {
       expect(1, 'yichus start "DESCRIPTION"');
-      saveRequirements(root, { ...loadRequirements(root), description: rest[0] });
+      const result = recordStart(root, { description: rest[0] });
+      if (!result.ok) throw new Error(result.error);
       io.stderr("Recorded the description. Next: yichus next\n");
       return 0;
     }
@@ -1452,6 +2645,25 @@ async function runStudioCommand(argv2, io) {
 `);
       return 0;
     }
+    if (command === "scenario") {
+      expect(1, "yichus scenario FILE.json");
+      const result = recordScenarios(root, JSON.parse(fs7.readFileSync(path7.resolve(rest[0]), "utf8")));
+      if (!result.ok) throw new Error(result.error);
+      io.stderr("Recorded the scenarios. Next: yichus next\n");
+      return 0;
+    }
+    if (command === "point") {
+      expect(1, "yichus point FILE.json");
+      const result = recordMarks(root, JSON.parse(fs7.readFileSync(path7.resolve(rest[0]), "utf8")), io.now());
+      if (!result.ok) throw new Error(result.error);
+      io.stderr("The page shows the notes now.\n");
+      return 0;
+    }
+    if (command === "page") {
+      expect(0, "yichus page");
+      io.stdout(pageText(root, null, io.now()));
+      return 0;
+    }
     if (command === "reference") {
       expect(1, "yichus reference TOPIC");
       const said = readReference(rest[0], io.locate);
@@ -1546,7 +2758,7 @@ function readPointer(value, pointer) {
   return value;
 }
 function objectValue(value, label2) {
-  const parsed = z7.record(z7.string(), z7.unknown()).safeParse(value);
+  const parsed = z11.record(z11.string(), z11.unknown()).safeParse(value);
   if (!parsed.success) throw new Error(`${label2} must be a JSON object`);
   return parsed.data;
 }
@@ -1563,11 +2775,11 @@ var FLAGS = {
   select: { type: "string" },
   expect: { type: "string", multiple: true }
 };
-var TimeoutMs = z7.coerce.number().int().min(1).max(3e5);
+var TimeoutMs = z11.coerce.number().int().min(1).max(3e5);
 function parse(argv2) {
   const { values, positionals, tokens } = parseArgs2({ args: argv2, options: FLAGS, allowPositionals: true, strict: true, tokens: true });
-  const named = tokens.flatMap((token) => token.kind === "option" ? [token.name] : []);
-  const repeated = named.find((name, i) => !("multiple" in FLAGS[name]) && named.indexOf(name) !== i);
+  const named2 = tokens.flatMap((token) => token.kind === "option" ? [token.name] : []);
+  const repeated = named2.find((name, i) => !("multiple" in FLAGS[name]) && named2.indexOf(name) !== i);
   if (repeated) throw new Error(`Repeated --${repeated}`);
   const [command, ...rest] = positionals;
   if (command !== "tools" && command !== "call" && command !== "verify" && command !== "lean") {
@@ -1628,11 +2840,11 @@ function parse(argv2) {
   return opts;
 }
 function closestSibling(file) {
-  const dir = path6.dirname(file);
-  const want = path6.basename(file);
+  const dir = path8.dirname(file);
+  const want = path8.basename(file);
   let names;
   try {
-    names = fs5.readdirSync(dir);
+    names = fs8.readdirSync(dir);
   } catch {
     return void 0;
   }
@@ -1650,11 +2862,11 @@ function closestSibling(file) {
     return row[b.length];
   };
   const scored = names.map((name) => ({ name, d: distance(want, name) })).filter(({ d }) => d <= 2).sort((x, y) => x.d - y.d);
-  return scored.length ? path6.join(dir, scored[0].name) : void 0;
+  return scored.length ? path8.join(dir, scored[0].name) : void 0;
 }
 function readInput(file) {
   try {
-    return fs5.readFileSync(file, "utf8");
+    return fs8.readFileSync(file, "utf8");
   } catch (error) {
     const code = error?.code;
     if (code === "ENOENT") {
@@ -1667,7 +2879,7 @@ function readInput(file) {
   }
 }
 function sourceNames(paths) {
-  const parts = paths.map((p) => path6.resolve(p).split(path6.sep).filter((s) => s !== ""));
+  const parts = paths.map((p) => path8.resolve(p).split(path8.sep).filter((s) => s !== ""));
   const seen = /* @__PURE__ */ new Set();
   parts.forEach((segments, i) => {
     const full = segments.join("/");
@@ -1694,15 +2906,15 @@ async function argumentsFor(opts, io) {
 }
 function clearOutput(opts) {
   if (!opts.output) return;
-  const output = path6.resolve(opts.output);
-  const outputStat = fs5.existsSync(output) ? fs5.statSync(output) : void 0;
+  const output = path8.resolve(opts.output);
+  const outputStat = fs8.existsSync(output) ? fs8.statSync(output) : void 0;
   for (const input of [...opts.sources, opts.args, opts.bundle].filter((p) => !!p && p !== "-")) {
-    const inputStat = fs5.existsSync(input) ? fs5.statSync(input) : void 0;
-    if (path6.resolve(input) === output || outputStat && inputStat && inputStat.dev === outputStat.dev && inputStat.ino === outputStat.ino) {
+    const inputStat = fs8.existsSync(input) ? fs8.statSync(input) : void 0;
+    if (path8.resolve(input) === output || outputStat && inputStat && inputStat.dev === outputStat.dev && inputStat.ino === outputStat.ino) {
       throw new Error("--output must not overwrite an input file");
     }
   }
-  fs5.rmSync(output, { force: true });
+  fs8.rmSync(output, { force: true });
 }
 function rejection(result, unmet) {
   if (result.ok) return `${unmet} --expect ${unmet === 1 ? "expectation was" : "expectations were"} not met`;
@@ -1748,7 +2960,7 @@ async function runCli(argv2, io) {
       if (selected === void 0) throw new Error(`Result field missing: ${opts.select}`);
       const text3 = opts.select !== void 0 && typeof selected === "string" ? selected : `${JSON.stringify(selected, null, 2)}
 `;
-      if (opts.output) fs5.writeFileSync(opts.output, text3);
+      if (opts.output) fs8.writeFileSync(opts.output, text3);
       else io.stdout(text3);
     }
     const artifact = opts.select !== void 0 ? "the unselected result; run without --select to see it" : opts.output ?? "the JSON on standard output";
@@ -1786,173 +2998,18 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { EngineWorkerClient, catalogTools } from "@yichus/api-mcp";
 
 // src/studio/page-server.ts
-import fs6 from "fs";
+import fs9 from "fs";
 import http from "http";
-import path7 from "path";
-
-// src/studio/page.ts
-var STUDIO_PAGE = `<!doctype html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>Yichus studio</title>
-<link rel="stylesheet" href="system-map.css">
-<style>
-  :root { --ink:#0f172a; --muted:#475569; --faint:#94a3b8; --rule:#e2e8f0; --paper:#ffffff; --page:#f6f8fb;
-    --good:#047857; --goodSoft:#ecfdf5; --bad:#b91c1c; --badSoft:#fef2f2; --warn:#92400e; --warnSoft:#fffbeb; --accent:#22675e; }
-  * { box-sizing:border-box; }
-  body { margin:0; background:var(--page); color:var(--ink); font:16px/1.55 Inter, system-ui, sans-serif; }
-  main { max-width:1100px; margin:0 auto; padding:24px 16px 64px; }
-  header p { margin:4px 0 0; color:var(--muted); }
-  h1 { font-size:1.6rem; margin:0; font-weight:600; }
-  h2 { font-size:1.15rem; margin:32px 0 8px; }
-  section > p.lede { color:var(--muted); margin:0 0 12px; max-width:70ch; }
-  a.guide { color:var(--accent); font-weight:600; }
-  .frame { background:var(--paper); border:1px solid var(--rule); border-radius:10px; padding:16px; position:relative; }
-  .frame > .tag { position:absolute; top:-10px; left:12px; background:var(--page); padding:0 6px; font-size:0.72rem; letter-spacing:0.08em; text-transform:uppercase; color:var(--accent); font-weight:700; }
-  .yours { border-left:3px solid var(--accent); padding:4px 12px; margin:0; font-style:italic; }
-  .label { font-size:0.75rem; color:var(--muted); text-transform:uppercase; letter-spacing:0.06em; margin:0 0 4px; }
-  .now { font-weight:600; }
-  .question { border-top:1px solid var(--rule); padding:14px 0; }
-  .question:first-of-type { border-top:none; padding-top:4px; }
-  .question .ask { font-weight:600; margin:0 0 4px; }
-  .question .why { color:var(--muted); margin:0 0 8px; font-size:0.94rem; }
-  .choice { display:flex; gap:8px; align-items:flex-start; margin:6px 0; }
-  .choice span small { display:block; color:var(--muted); }
-  textarea { width:100%; min-height:3.2em; font:inherit; border:1px solid var(--rule); border-radius:8px; padding:8px; margin:6px 0; }
-  button { font:inherit; font-weight:600; border:none; border-radius:8px; padding:8px 14px; background:var(--accent); color:#fff; cursor:pointer; }
-  button:disabled { opacity:0.5; cursor:default; }
-  .props { list-style:none; margin:0; padding:0; }
-  .props li { border-top:1px solid var(--rule); padding:12px 0; display:grid; grid-template-columns:1fr auto; gap:4px 16px; }
-  .props li:first-child { border-top:none; }
-  .chip { font-size:0.8rem; font-weight:700; border-radius:999px; padding:2px 10px; white-space:nowrap; align-self:start; justify-self:start; }
-  .chip.good { color:var(--good); background:var(--goodSoft); }
-  .chip.bad { color:var(--bad); background:var(--badSoft); }
-  .chip.warn { color:var(--warn); background:var(--warnSoft); }
-  .chip.quiet { color:var(--muted); background:var(--rule); }
-  .props .choice-said { color:var(--muted); font-size:0.94rem; grid-column:1 / -1; }
-  details { grid-column:1 / -1; font-size:0.88rem; }
-  details pre { white-space:pre-wrap; word-break:break-word; background:var(--page); border-radius:8px; padding:8px; margin:6px 0 0; font-size:0.82rem; }
-  .empty { color:var(--muted); }
-  @media (max-width:640px) { .props li { grid-template-columns:1fr; } }
-</style>
-</head>
-<body>
-<main>
-  <header>
-    <h1>Yichus studio<span id="project"></span></h1>
-    <p id="updated">Waiting for your agent.</p>
-    <p><a class="guide" href="https://yich.us/start/studio.html#page" target="_blank" rel="noopener">How to read this page</a> (opens in a new tab)</p>
-  </header>
-  <section aria-labelledby="h-asked">
-    <h2 id="h-asked">What you asked for</h2>
-    <p class="label">Your words</p>
-    <p class="yours" id="description">Nothing yet. Tell your agent what you want to build.</p>
-  </section>
-  <section aria-labelledby="h-now">
-    <h2 id="h-now">What is happening now</h2>
-    <div class="frame"><span class="tag">Yichus output</span>
-      <p class="now" id="summary">No checks have run yet.</p>
-    </div>
-  </section>
-  <section aria-labelledby="h-questions" id="questions-section" hidden>
-    <h2 id="h-questions">Questions for you</h2>
-    <p class="lede">Your agent will ask you these too. Answer here or in the chat, whichever is easier. <a class="guide" href="https://yich.us/start/studio.html#questions" target="_blank" rel="noopener">About these questions</a></p>
-    <div class="frame"><span class="tag">Yichus output</span><div id="questions"></div></div>
-  </section>
-  <section aria-labelledby="h-props">
-    <h2 id="h-props">What your program must do</h2>
-    <p class="lede"><a class="guide" href="https://yich.us/start/studio.html#statuses" target="_blank" rel="noopener">What each status means</a></p>
-    <div class="frame"><span class="tag">Yichus output</span><ul class="props" id="props"><li class="empty">No properties chosen yet.</li></ul></div>
-  </section>
-  <section aria-labelledby="h-map">
-    <h2 id="h-map">The shape of your program</h2>
-    <p class="lede"><a class="guide" href="https://yich.us/start/studio.html#shape" target="_blank" rel="noopener">How to read the picture</a></p>
-    <div class="frame"><div class="system-map" id="map"><p class="empty">The map appears once the program compiles.</p></div></div>
-  </section>
-</main>
-<script type="module">
-import { mount } from './system-map.js';
+import path9 from "path";
 
-const STATUS = {
-  unanswered: ['waiting for your answer', 'quiet'], decided: ['decided', 'good'], assumed: ['holds, under an assumption', 'warn'],
-  proven: ['proven', 'good'], bounded: ['holds in every scenario checked', 'good'], broken: ['broken', 'bad'],
-  mismatch: ['the code says otherwise', 'bad'], 'needs-case': ['scenario being written', 'quiet'],
-  inconclusive: ['not decided yet', 'warn'], 'no-check': ['no check needed', 'quiet'], pending: ['answered, waiting for your agent to check', 'quiet'],
-};
-const el = (tag, props = {}, ...kids) => { const n = Object.assign(document.createElement(tag), props); n.append(...kids); return n; };
-let mapHash = null;
-
-function questionCard(q, saved) {
-  const card = el('div', { className: 'question' });
-  card.append(el('p', { className: 'ask', textContent: q.ask }), el('p', { className: 'why', textContent: q.why }));
-  const name = 'q-' + q.id;
-  for (const c of q.choices) {
-    const input = el('input', { type: 'radio', name, value: c.id, checked: saved?.choice === c.id });
-    card.append(el('label', { className: 'choice' }, input, el('span', {}, c.label, el('small', { textContent: c.means }))));
-  }
-  const words = el('textarea', { placeholder: 'In your own words (optional)', value: saved?.words ?? '' });
-  const status = el('span', { className: 'empty', textContent: saved ? ' Saved. Your agent will check it next.' : '' });
-  const save = el('button', { type: 'button', textContent: 'Save answer' });
-  save.addEventListener('click', async () => {
-    const picked = card.querySelector('input[name="' + CSS.escape(name) + '"]:checked');
-    if (!picked) { status.textContent = ' Pick one of the choices first.'; return; }
-    save.disabled = true;
-    const label = q.choices.find(c => c.id === picked.value).label;
-    const response = await fetch('/answer', { method: 'POST', headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ question: q.id, choice: picked.value, words: words.value.trim() || label }) });
-    const result = await response.json();
-    status.textContent = result.ok ? ' Saved. Your agent will check it next.' : ' ' + result.error;
-    save.disabled = false;
-  });
-  card.append(el('p', { className: 'label', textContent: 'Your words' }), words, save, status);
-  return card;
-}
-
-function propertyRow(p, saved) {
-  const stale = saved && (!p.answer || p.answer.answeredAt !== saved.answeredAt);
-  const [words, tone] = STATUS[stale ? 'pending' : p.status];
-  const answer = stale ? saved : p.answer;
-  const label = p.question.choices.find(c => c.id === answer.choice)?.label ?? answer.choice;
-  const li = el('li', {}, el('span', { textContent: p.question.ask }), el('span', { className: 'chip ' + tone, textContent: words }));
-  li.append(el('span', { className: 'choice-said', textContent: 'You chose: ' + label + (answer.words && answer.words !== label ? ' ("' + answer.words + '")' : '') }));
-  return li;
-}
-
-async function refresh() {
-  const { state, requirements } = await (await fetch('/state')).json();
-  const savedOf = id => requirements.answers.find(a => a.question === id);
-  if (requirements.description) document.getElementById('description').textContent = requirements.description;
-  if (!state) return;
-  document.getElementById('project').textContent = ': ' + state.project;
-  document.getElementById('updated').textContent = 'Last checked ' + new Date(state.updatedAt).toLocaleTimeString() + '.';
-  document.getElementById('summary').textContent = state.summary;
-  const open = state.properties.filter(p => p.status === 'unanswered' && !savedOf(p.question.id));
-  document.getElementById('questions-section').hidden = !open.length;
-  // Keep a half-written answer: only rebuild cards when the questions change.
-  const qs = document.getElementById('questions');
-  const ids = open.map(p => p.question.id).join(' ');
-  if (qs.dataset.ids !== ids) { qs.dataset.ids = ids; qs.replaceChildren(...open.map(p => questionCard(p.question, savedOf(p.question.id)))); }
-  const chosen = state.properties.filter(p => p.answer || savedOf(p.question.id));
-  document.getElementById('props').replaceChildren(...(chosen.length ? chosen.map(p => propertyRow(p, savedOf(p.question.id)))
-    : [el('li', { className: 'empty', textContent: 'No properties chosen yet.' })]));
-  const map = document.getElementById('map');
-  if (state.map && state.sourcesHash !== mapHash) { mapHash = state.sourcesHash; mount(map, state.map); }
-  else if (!state.map && state.mapError) map.replaceChildren(el('p', { className: 'empty', textContent: 'The map could not be drawn: ' + state.mapError }));
-}
-
-new EventSource('/events').addEventListener('change', () => refresh());
-refresh();
-</script>
-</body>
-</html>
-`;
+// src/studio/page-assets.json
+var page_assets_default = ["system-map.js", "label-fit.js", "system-map-record.js", "system-map.css", "dom.js", "layer-groups.js", "layer-diagram.js", "source-link.js", "what-happens.js", "what-happens-record.js", "studio-views.js"];
 
 // src/studio/page-server.ts
-var PAGE_ASSETS = ["system-map.js", "label-fit.js", "system-map-record.js", "system-map.css"];
-function personView(state, names) {
+var PAGE_ASSETS = page_assets_default;
+function personView(state, names, marks = null) {
   if (!state) return null;
+  const { sections, whatHappens, anchors, drawing } = personDiagrams(state, names);
   return {
     project: state.project,
     updatedAt: state.updatedAt,
@@ -1964,23 +3021,34 @@ function personView(state, names) {
       status: p.status
     })),
     map: state.map ? relabelSystemMap(state.map, names) : null,
-    mapError: state.mapError
+    mapError: state.mapError,
+    sections,
+    whatHappens,
+    // Sent back with what the person has in view, so a report about an
+    // older drawing is not read against this one.
+    drawing,
+    // A mark on a part the page no longer draws is left out.
+    marks: marks && { said: marks.said, marks: marks.marks.flatMap((m) => anchors.has(m.at) ? [{ anchor: anchors.get(m.at), note: m.note }] : []) }
   };
 }
 function stateBody(root) {
   const { description, answers, names } = loadRequirements(root);
-  return { state: personView(readState(root), names ?? {}), requirements: { description, answers } };
+  return { state: personView(readState(root), names ?? {}, loadMarks(root)), requirements: { description, answers } };
 }
 var STUDIO_PORTS = [4317, 4318, 4319, 4320, 4321, 0];
 async function startPageServer(root, assetsDir, port = null, now = () => /* @__PURE__ */ new Date()) {
   ensureStudioDir(root);
   const clients = /* @__PURE__ */ new Set();
-  const watched = ["state.json", "requirements.json"].map((name) => path7.join(studioDir(root), name));
+  const watched = ["state.json", "requirements.json", "marks.json"].map((name) => path9.join(studioDir(root), name));
   const changed = (now2, before) => {
     if (now2.mtimeMs !== before.mtimeMs || now2.size !== before.size) for (const res of clients) res.write("event: change\ndata: {}\n\n");
   };
-  for (const file of watched) fs6.watchFile(file, { interval: 250 }, changed);
+  for (const file of watched) fs9.watchFile(file, { interval: 250 }, changed);
   const hosts = /* @__PURE__ */ new Set();
+  const takes = /* @__PURE__ */ new Map([
+    ["/answer", (args) => recordAnswer(root, args, now())],
+    ["/viewing", (args) => recordViewing(root, args, now())]
+  ]);
   const server = http.createServer((req, res) => {
     const send = (status, type, body) => {
       res.writeHead(status, { "content-type": type, "cache-control": "no-store", "x-content-type-options": "nosniff" });
@@ -2005,9 +3073,10 @@ async function startPageServer(root, assetsDir, port = null, now = () => /* @__P
     }
     const asset = PAGE_ASSETS.find((a) => url.pathname === `/${a}`);
     if (req.method === "GET" && asset) {
-      return send(200, asset.endsWith(".css") ? "text/css" : "text/javascript", fs6.readFileSync(path7.join(assetsDir, asset), "utf8"));
+      return send(200, asset.endsWith(".css") ? "text/css" : "text/javascript", fs9.readFileSync(path9.join(assetsDir, asset), "utf8"));
     }
-    if (req.method === "POST" && url.pathname === "/answer") {
+    const take = req.method === "POST" ? takes.get(url.pathname) : void 0;
+    if (take) {
       if (req.headers["content-type"] !== "application/json") return send(415, "text/plain", "Send JSON.");
       let body = "";
       req.setEncoding("utf8");
@@ -2020,9 +3089,9 @@ async function startPageServer(root, assetsDir, port = null, now = () => /* @__P
         try {
           args = JSON.parse(body);
         } catch {
-          return send(400, "application/json", JSON.stringify({ ok: false, error: "The answer is not JSON." }));
+          return send(400, "application/json", JSON.stringify({ ok: false, error: "The request is not JSON." }));
         }
-        const result = recordAnswer(root, args, now());
+        const result = take(args);
         send(result.ok ? 200 : 400, "application/json", JSON.stringify(result));
       });
       return;
@@ -2045,7 +3114,7 @@ async function startPageServer(root, assetsDir, port = null, now = () => /* @__P
   return {
     url: `http://127.0.0.1:${bound}/`,
     async close() {
-      for (const file of watched) fs6.unwatchFile(file, changed);
+      for (const file of watched) fs9.unwatchFile(file, changed);
       const closed = new Promise((resolve) => server.close(() => resolve()));
       server.closeAllConnections();
       await closed;