mulmoterminal 6.8.0 → 7.1.0

package/README.md

@@ -176,15 +176,25 @@ than as bytes (files within the session's working directory only):
 | `.json` | **indented** in a new tab (Chrome and Safari otherwise show one long line) |
 | `.csv` `.tsv` | a **table** in a new tab, with a sticky header that scrolls inside its own box |
 | source, config, logs, and `.txt` — 46 extensions | the app's own **Files** view (`/files?path=`), where CodeMirror highlights it, the tree is right there, and it can be edited |
-| images, PDF, SVG, HTML, video | raw bytes in a new tab, which the browser renders better than an editor would |
+| `.html` `.htm` | the **rendered page** in a new tab, under the same sandboxed policy as the Files pane's Preview: its scripts run at an opaque origin with no fetch or XHR (so they cannot reach the app or its API), and an image beside it loads by its relative path (a relative stylesheet or script does not). The raw route answers `.html` as plain text, so opening one there showed its source |
+| images, PDF, SVG, video, audio | raw bytes in a new tab, which the browser renders better than an editor would |
 | everything else — `.xlsx`, `.docx`, `.zip`, a `Makefile` | the app's own **Files** view. A tab cannot display these, so opening one there is not a view — it is a download starting with no warning. The pane names the file and offers **Open in OS**, which hands it to the application that owns it (Excel for an `.xlsx`) |
 
+**A line after the path is followed.** `src/a.ts:42`, `src/a.ts:42:7` (gcc, clang, `eslint -f unix`,
+stack traces) and `src/a.ts(12,5)` (tsc) are one link. In the pane, and in the Files view, the file
+opens as text with the caret on that line and column — an HTML page, an SVG or a table included, and a
+tab reading in Preview switches to Edit. A route that renders the file in a new tab (`.md`, `.json`,
+`.csv`, `.html` with no cell enlarged) ignores the line. When the pane beside an enlarged cell takes
+the click, the keyboard stays in the terminal; the full-screen Files view, with no terminal beside it,
+puts it in the editor. (ESLint's default output puts the path on a line of its own, with no line number to follow.)
+
 **While a grid cell is enlarged, the [Files pane](#files-view-browse--edit) takes the click first** — every
-row above except the last one, since the pane is the same editor plus a Markdown preview. The
-file opens *beside* the terminal that printed it, and the pane opens itself if it was closed.
-It declines, leaving the routing above untouched, when nothing is enlarged, when the path is
-not under that cell's own directory (the pane cannot walk above its root), or for the raw-bytes
-row, where it would only show an empty editor.
+row above except PDF, video and audio, since the pane is the same editor with a Preview for
+Markdown, HTML and SVG, and shows an image as a picture. The file opens *beside* the terminal
+that printed it, and the pane opens itself if it was closed. It declines, leaving the routing
+above untouched, when nothing is enlarged, when the path is not under that cell's own directory
+(the pane cannot walk above its root), or for a PDF, a video or an audio file, which only a
+browser tab can play.
 
 Highlighting in the Files view covers the JS/TS family, JSON and Markdown (the modes
 `cmEditor.ts` bundles); other languages open as plain text.
@@ -1244,7 +1254,12 @@ rooted at **that terminal's project directory** — so after Claude says "wrote
 you can jump straight there to read or edit it. The left pane is a lazy-loaded directory
 tree; clicking a file opens it in a **CodeMirror** editor (Markdown / JS-TS / JSON
 highlighting, everything else as plain text). Markdown files get a **Preview** toggle
-that renders via the server's sandboxed `…/md` HTML. **Save** (or ⌘/Ctrl-S) writes back.
+that renders via the server's sandboxed `…/md` HTML; a `.csv` / `.tsv` previews as a table (the
+same `…/table` document a clicked path opens, in the app's colours), and an `.html` / `.svg` as the
+page or picture it is. **Save** (or ⌘/Ctrl-S) writes back. **History** lists the versions the pane
+kept of the file (in `~/.mulmoterminal/backups`, taken when it is opened or reloaded here and before a save
+here replaces it — the newest few), to compare with the buffer or restore as an undoable edit (unsaved edits
+are kept as a version first).
 
 **The open view follows the file on disk.** When an agent in another cell — or any editor —
 rewrites what you are looking at, the editor and the preview catch up on their own; there is
@@ -1266,11 +1281,11 @@ shrinks the pane rather than reflowing xterm into garbage. It works in both zoom
 terminals, and whether it's open plus how wide it is are remembered per browser.
 
 **Coming back looks the way you left it.** The pane remembers the open file, the directories
-you had expanded, and — for a Markdown file — whether you were reading it in **Preview** or
+you had expanded, and — for a file with a Preview — whether you were reading it in **Preview** or
 editing it: per cell while the session lasts, and per directory across a browser reload (the
 first pane to open on that directory claims it, so a second terminal in the same repository
 starts on its own empty tree). A remembered Preview only comes back over that same file while
-it is still Markdown the server can render; anything else opens in the editor.
+it is still a file the pane can preview; anything else opens in the editor.
 
 It comes back to **where** you were, too: the line at the top of the editor, the line the caret was
 on, and how far down the tree was scrolled. The top line matters on its own — scrolling moves
@@ -1296,6 +1311,18 @@ finder, the search or a clicked terminal path alike. Switching tabs saves the on
 opening another file does, so only the front tab can hold unsaved edits; each tab keeps its own place
 (Preview or editor, caret, scroll) and the whole strip is remembered with the rest of the pane. Close a
 tab with its **×**, a middle click, or **Delete** while it has focus; ←/→, Home and End move between them.
+The tree follows the tab in front, as VS Code's explorer does: its folders open and its row comes into
+view (a reload still puts the tree back where you left it).
+
+**The tree shows what git sees.** In a git repository a changed file is tinted and lettered as in VS
+Code's explorer — `M` modified, `A` added, `U` untracked, `R` renamed — and a folder holding changes
+carries a dot, so a collapsed tree still says where the agent has been. It is read when the tree
+loads or reloads, after a save or an outside change to the open file, and every thirty seconds.
+
+**The editor marks what changed since the last commit.** A bar beside each line that is new (green)
+or changed (amber), and a notch where lines were removed, as VS Code's gutter shows them — kept up
+to date as you type. **Changes** in the header also shows the removed lines in place, as a unified
+diff. Nothing is marked for a file outside git or one not yet committed.
 
 **HTML pages and images show in the pane too.** An `.html` file has a **Preview** like a Markdown
 file: the page itself, sandboxed as presentHtml pages are — its scripts run on an opaque origin with

package/blueprints/ask/checks/replies.mjs

@@ -1,7 +1,7 @@
 // Reads .blueprint/replies.json — an answer to each question the person asked — and answers one question
 // per mode. Exit 0 is yes.
 //   answer  every question has exactly one reply; a reply found in the documents quotes them (chaff cite)
-//           and names every address it quotes; a reply not found says what was searched. Records the
+//           and names every place it quotes (the address, or the heading of the section there); a reply not found says what was searched. Records the
 //           documents' and FAQ.md's fingerprints.
 //   keep    the documents are unchanged; FAQ.md holds every question after what it held before when the
 //           person asked to keep the answers, and is untouched otherwise
@@ -9,6 +9,7 @@ import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { fromBase } from "./base.mjs";
 const { fail, quotationProblems, readJson } = await import(fromBase("chaff.mjs"));
 const { digest, documentSource, documentsNamed, fingerprint } = await import(fromBase("documents.mjs"));
+const { headingsIn, namesPlace, placeNamesIn, treeOf } = await import(fromBase("places.mjs"));
 
 const REPLIES = ".blueprint/replies.json";
 const REPLIES_PAGE = ".blueprint/replies.md";
@@ -29,6 +30,27 @@ if (answers?.keep === KEEP && documents.includes(FAQ)) fail(`${FAQ} is one of th
 const indented = (line) => "  " + line;
 const nonEmpty = (value) => typeof value === "string" && value.trim() !== "";
 
+// Each document's tree is read once, and only for one of the documents: a source that is not is refused by the
+// quotation check. From it come a section's heading and a place's name (第4条第2項), either of which names the place.
+const placeCache = new Map();
+const placeAt = (source, address) => {
+  const resolved = documentSource(documents)(source);
+  if (!resolved.path) return {};
+  if (!placeCache.has(resolved.path)) {
+    const tree = treeOf(resolved.path);
+    placeCache.set(resolved.path, { headings: headingsIn(tree), names: placeNamesIn(tree) });
+  }
+  const { headings, names } = placeCache.get(resolved.path);
+  return { heading: headings.get(address.trim()), name: names.get(address.trim()) };
+};
+
+// The address as written needs no tree; otherwise the heading or the place's name, from the document's tree.
+const answerNames = (answer, citation) => {
+  if (answer.includes(citation.address.trim())) return true;
+  const { heading, name } = placeAt(String(citation.source), citation.address);
+  return namesPlace(answer, citation.address, heading, name);
+};
+
 const replyProblem = (reply) => {
   if (typeof reply !== "object" || reply === null) return "a reply is not an object";
   if (!nonEmpty(reply.question)) return "a reply names no question";
@@ -39,7 +61,7 @@ const replyProblem = (reply) => {
   if (!Array.isArray(citations)) return `${which}: citations must be an array`;
   if (reply.found && citations.length === 0) return `${which}: an answer found in the documents quotes them`;
   if (!citations.every((citation) => nonEmpty(citation?.address))) return `${which}: every quotation needs an "address"`;
-  const unnamed = citations.filter((citation) => !reply.answer.includes(citation.address.trim()));
+  const unnamed = citations.filter((citation) => !answerNames(reply.answer, citation));
   if (unnamed.length > 0) return `${which}: the answer does not name ${unnamed.map((citation) => citation.address).join(", ")}, which it quotes`;
   if (!reply.found && (!Array.isArray(reply.searched) || !reply.searched.some(nonEmpty))) return `${which}: say what was searched ("searched")`;
   return null;

package/blueprints/ask/skills/answer/SKILL.md

@@ -48,11 +48,15 @@ the answers before anything is kept.
 - `question`: the question exactly as it is in `questions`. One reply per question, none extra.
 - `found`: `true` when the documents answer it. Then at least one citation.
 - `citations`: `source` is the document's path as `documents` names it; `address` is where; `quote` is
-  copied character for character — the check runs `chaff cite` on every one. **Write every cited address in
-  the `answer` text** so the person can open the document there.
+  copied character for character — the check runs `chaff cite` on every one. **Name every cited place in
+  the `answer` text** so the person can open the document there: an article or item as the document numbers it
+  (第4条第2項, Section 3.1), and a section of a Markdown document by its heading, word for word, in 「」 (「作業用フォルダを信頼しておく」;
+  in an English answer, "Getting started") — the check looks for it in those marks.
+  chaff's index for a section (`h1.3`) goes in `address` only — it means nothing to the person.
 - `searched`: when `found` is `false`, the words and places you looked for.
 
-Also write `.blueprint/replies.md` for the person: each question as a heading, the answer, and the quotations.
+Also write `.blueprint/replies.md` for the person: each question as a heading, the answer, and the quotations,
+each with its place named as in the answer (never `h1.3`).
 
 ## Done when
 

package/blueprints/ask/skills/keep/SKILL.md

@@ -17,7 +17,8 @@ run the check and stop.
 Otherwise add to `FAQ.md` in this folder (create it if there is none). **Add after what it already holds;
 never edit or reorder what is there** — the check compares the beginning of the file with what it held
 before. For each question: the question as a `##` heading, word for word; the answer; and where it is
-written (document and address). For a question the documents do not answer, say so — that is worth keeping
+written (the document, and the place named as in the answer: 第4条第2項, or a section's heading in 「」 —
+never chaff's `h1.3`). For a question the documents do not answer, say so — that is worth keeping
 too.
 
 ## Done when

package/blueprints/cloudflare/checks/deploy-check.sh

@@ -0,0 +1,16 @@
+#!/bin/sh
+# The published Worker serves the build this deploy made: the deploy writes a fresh id to .blueprint/build-id and ships
+# the same id as /blueprint-build.txt, and records the URL it published to in .blueprint/deploy-url. The published app
+# answers /api/health, sends the security headers, and its page renders.
+set -eu
+[ -s .blueprint/deploy-url ] || { echo "missing .blueprint/deploy-url; the deploy step writes the URL it published to" >&2; exit 1; }
+url=$(tr -d ' \n\r' < .blueprint/deploy-url)
+url=${url%/}
+case "$url" in https://*) ;; *) echo ".blueprint/deploy-url is not an https URL: $url" >&2; exit 1 ;; esac
+[ -s .blueprint/build-id ] || { echo "missing .blueprint/build-id; the deploy step writes it before deploying" >&2; exit 1; }
+expected=$(cat .blueprint/build-id)
+served=$(curl -fsS --max-time 20 "$url/blueprint-build.txt")
+[ "$served" = "$expected" ] || { echo "$url serves build $served, this deploy made $expected" >&2; exit 1; }
+curl -fsS --max-time 20 "$url/api/health" | grep -q '"ok":true' || { echo "$url/api/health does not answer {\"ok\":true}" >&2; exit 1; }
+curl -s -D - -o /dev/null --max-time 20 "$url/" | tr -d '\r' | grep -qi '^content-security-policy:' || { echo "$url/ is published without a Content-Security-Policy" >&2; exit 1; }
+sh "$(dirname "$0")/page-renders.sh" "$url/"

package/blueprints/cloudflare/checks/handover.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+# The README tells a non-engineer how to run the app on this computer, how to publish a change, and how to back up the
+# data; the first page the finished build shows says where the published app is and what to try to see it works.
+set -eu
+[ -s README.md ] || { echo "missing README.md" >&2; exit 1; }
+grep -q "yarn start" README.md || { echo "README.md does not say how to run it on this computer (yarn start)" >&2; exit 1; }
+grep -q "wrangler deploy\|yarn deploy" README.md || { echo "README.md does not say how to publish a change (yarn deploy)" >&2; exit 1; }
+grep -q "d1 export" README.md || { echo "README.md does not say how to back up the data (wrangler d1 export)" >&2; exit 1; }
+start=.blueprint/start-here.md
+[ -s "$start" ] || { echo "missing $start" >&2; exit 1; }
+[ -s .blueprint/deploy-url ] || { echo "missing .blueprint/deploy-url" >&2; exit 1; }
+url=$(tr -d ' \n\r' < .blueprint/deploy-url)
+grep -qF "${url%/}" "$start" || { echo "$start does not name the published URL (${url%/})" >&2; exit 1; }
+grep -q '^- \[ \] ' "$start" || { echo "$start has no checklist of what to try (- [ ] …)" >&2; exit 1; }

package/blueprints/cloudflare/checks/page-renders.sh

@@ -0,0 +1,28 @@
+#!/bin/sh
+# The served page actually starts: a build can deploy, report its id and answer 200, and still be a
+# blank page because the app threw on load (a missing config does exactly that). Rendered in headless
+# Chrome, the page must show some text. Without a Chrome this cannot be judged, and says so.
+set -eu
+url="$1"
+chrome=""
+for candidate in "${CHROME:-}" "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" google-chrome chromium chromium-browser; do
+  [ -n "$candidate" ] || continue
+  if [ -x "$candidate" ] || command -v "$candidate" >/dev/null 2>&1; then chrome="$candidate"; break; fi
+done
+[ -n "$chrome" ] || { echo "no Chrome found (set CHROME=...); could not confirm that $url renders" >&2; exit 0; }
+# Headless Chrome can print the DOM and then not exit, so it is waited on for the DOM, not for exit.
+RENDER_LIMIT_SECONDS=60
+work=$(mktemp -d)
+"$chrome" --headless=new --disable-gpu --no-first-run --user-data-dir="$work/profile" --virtual-time-budget=15000 --dump-dom "$url" >"$work/dom.html" 2>/dev/null &
+pid=$!
+trap 'kill "$pid" 2>/dev/null || true; rm -rf "$work"' EXIT
+waited=0
+until grep -q "</html>" "$work/dom.html" 2>/dev/null || [ "$waited" -ge "$RENDER_LIMIT_SECONDS" ] || ! kill -0 "$pid" 2>/dev/null; do
+  sleep 1
+  waited=$((waited + 1))
+done
+node -e 'let s="";process.stdin.on("data",(c)=>s+=c).on("end",()=>{
+  const body = (s.match(/<body[^>]*>([\s\S]*)<\/body>/i) || [, ""])[1];
+  const text = body.replace(/<(script|style|noscript)[\s\S]*?<\/\1>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+  if (!text) { console.error(process.argv[1] + " renders a blank page: the app failed to start. Open it in a browser and read the console error."); process.exit(1); }
+})' "$url" <"$work/dom.html"

package/blueprints/cloudflare/checks/prerequisites.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+# Node is new enough for wrangler, and yarn answers. wrangler itself is a dev dependency of the project.
+set -eu
+node -e 'process.exit(Number(process.versions.node.split(".")[0]) >= 22 ? 0 : 1)' ||
+  { echo "Node.js 22 or later is needed (wrangler requires it); this is $(node -v)" >&2; exit 1; }
+yarn --version >/dev/null 2>&1 || { echo "yarn is missing (corepack enable)" >&2; exit 1; }

package/blueprints/cloudflare/checks/scaffold.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+# The layout the later checks rely on exists, and the skeleton builds and its tests pass inside the Workers runtime.
+set -eu
+for f in package.json wrangler.jsonc src/worker/index.ts index.html vitest.config.ts; do
+  [ -f "$f" ] || { echo "missing $f" >&2; exit 1; }
+done
+for d in migrations test; do
+  [ -d "$d" ] || { echo "missing $d/" >&2; exit 1; }
+done
+grep -q '"start"' package.json || { echo "package.json has no start script" >&2; exit 1; }
+grep -q '"d1_databases"' wrangler.jsonc || { echo "wrangler.jsonc binds no D1 database" >&2; exit 1; }
+grep -q '"assets"' wrangler.jsonc || { echo "wrangler.jsonc serves no assets" >&2; exit 1; }
+yarn build
+yarn test

package/blueprints/cloudflare/checks/security-report.sh

@@ -0,0 +1,11 @@
+#!/bin/sh
+# The security review's report exists, walks every OWASP Top 10:2025 category, and leaves no HIGH or
+# MEDIUM finding open or merely accepted. A finding is one line: `- <HIGH|MEDIUM|LOW> <fixed|open|accepted>: …`.
+set -eu
+report=.blueprint/security-review.md
+[ -s "$report" ] || { echo "missing $report" >&2; exit 1; }
+for category in A01 A02 A03 A04 A05 A06 A07 A08 A09 A10; do
+  grep -q "^#.*$category" "$report" || { echo "$report has no section for $category (OWASP Top 10:2025)" >&2; exit 1; }
+done
+open=$(grep -nE '^- (HIGH|MEDIUM) (open|accepted)' "$report" || true)
+[ -z "$open" ] || { printf 'HIGH / MEDIUM findings must be fixed, but are open or accepted in %s:\n%s\n' "$report" "$open" >&2; exit 1; }

package/blueprints/cloudflare/checks/security.sh

@@ -0,0 +1,52 @@
+#!/bin/sh
+# The security review is proven by the running Worker, not by the review's word: the app started with wrangler dev is
+# sent the requests an attack would send (a cross-site state change, a malformed body) and must refuse them, its pages
+# and its API carry the headers a browser needs, its secrets stay out of any repository, its dependencies have no known
+# high-severity hole, and the review's own report and tests are in place.
+set -eu
+sh "$(dirname "$0")/security-report.sh"
+[ -f test/security.test.ts ] || { echo "missing test/security.test.ts" >&2; exit 1; }
+# Local secrets live in .dev.vars (or .env); the folder becomes a repository whenever its person adds git.
+for secrets in .dev.vars .env; do
+  if [ -f "$secrets" ] && ! grep -qxE "/?$(printf '%s' "$secrets" | sed 's/\./\\./g')(\\*)?" .gitignore 2>/dev/null; then
+    echo "$secrets exists and .gitignore does not ignore it; add a line $secrets to .gitignore" >&2
+    exit 1
+  fi
+done
+yarn test >/dev/null || { echo "yarn test fails" >&2; yarn test >&2 || true; exit 1; }
+# Read from the summary, not the exit code: an audit that could not reach the registry must not pass.
+yarn audit --groups dependencies --json 2>/dev/null | node -e 'let s="";process.stdin.on("data",(c)=>s+=c).on("end",()=>{
+  const summary = s.split("\n").filter(Boolean).map((line) => JSON.parse(line)).find((entry) => entry.type === "auditSummary");
+  if (!summary) { console.error("yarn audit did not report a summary (is the registry reachable?)"); process.exit(1); }
+  const { high = 0, critical = 0 } = summary.data.vulnerabilities;
+  if (high + critical > 0) { console.error(`yarn audit: ${high} high and ${critical} critical vulnerabilities in dependencies; run yarn audit --groups dependencies`); process.exit(1); }
+})'
+
+. "$(dirname "$0")/serve.sh"
+base="http://127.0.0.1:$port"
+status() { curl -s -o /dev/null -w '%{http_code}' --max-time 5 "$@"; }
+fail() { echo "$1" >&2; exit 1; }
+
+# A state change sent from another site's page.
+code=$(status -X POST -H "Origin: https://attacker.example" -H "Content-Type: application/json" -d '{}' "$base/api/blueprint-security-probe")
+[ "$code" = 403 ] || fail "POST /api/… from Origin https://attacker.example answered $code; a state change from another origin must be refused with 403 before routing and sign-in"
+
+# The page is served as a static asset, which does not go through the Worker: its headers come from public/_headers.
+for target in / /api/health; do
+  headers=$(curl -s -D - -o /dev/null --max-time 5 "$base$target" | tr -d '\r')
+  has() { printf '%s' "$headers" | grep -qiE "$1"; }
+  has '^x-content-type-options: *nosniff' || fail "$target is served without X-Content-Type-Options: nosniff"
+  has '^content-security-policy:' || fail "$target is served without a Content-Security-Policy"
+  has "^content-security-policy:.*frame-ancestors|^x-frame-options: *(deny|sameorigin)" || fail "$target can be framed by another site (no frame-ancestors in the CSP, no X-Frame-Options)"
+  ! has '^x-powered-by:' || fail "$target carries X-Powered-By"
+done
+
+# A malformed body is refused at the entry, before routing — a Worker reads JSON per route, so a check against a path no
+# route handles proves nothing unless the body is read once, up front — and is answered without the Worker's insides.
+response=$(curl -s --max-time 5 -w '\n%{http_code}' -X POST -H "Origin: $base" -H "Content-Type: application/json" --data '{"broken' "$base/api/blueprint-security-probe")
+code=$(printf '%s' "$response" | tail -n 1)
+body=$(printf '%s' "$response" | sed '$d')
+[ "$code" = 400 ] || fail "a malformed JSON body to /api/… answered $code; it must be refused with 400 where the Worker reads JSON bodies, before routing"
+if printf '%s' "$body" | grep -qE 'node_modules|at [^ ]+ \(|SyntaxError: |src/worker/'; then
+  fail "a malformed JSON body is answered with a stack trace or the parser's error: $(printf '%s' "$body" | head -c 300)"
+fi

package/blueprints/cloudflare/checks/serve.sh

@@ -0,0 +1,24 @@
+# Sourced, not run: builds, then starts the app on this computer with `yarn start --port <port>` (wrangler dev) and waits
+# for /api/health. Sets `port`. wrangler dev runs as a tree of processes (yarn, wrangler, workerd, esbuild) and a parent
+# left behind restarts its workerd, so the EXIT trap stops the whole tree this check started, and nothing else.
+yarn build >/dev/null
+# process.stdout.write, not console.log: with FORCE_COLOR set, console.log colours a number.
+port=$(node -e 'const s = require("node:net").createServer().listen(0, "127.0.0.1", () => { process.stdout.write(String(s.address().port)); s.close(); })')
+log=$(mktemp)
+yarn -s start --port "$port" >"$log" 2>&1 &
+started=$!
+stop_tree() {
+  for child in $(pgrep -P "$1" 2>/dev/null); do stop_tree "$child"; done
+  kill "$1" 2>/dev/null || true
+}
+stop() {
+  stop_tree "$started"
+  rm -f "$log"
+}
+trap stop EXIT INT TERM
+tries=0
+until curl -fsS --max-time 2 "http://127.0.0.1:$port/api/health" >/dev/null 2>&1; do
+  tries=$((tries + 1))
+  [ "$tries" -lt 120 ] || { echo "the app did not answer /api/health on port $port (yarn start --port $port)" >&2; cat "$log" >&2; exit 1; }
+  sleep 0.5
+done

package/blueprints/cloudflare/checks/smoke.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+# Builds, starts the app with wrangler dev on a spare port, and checks that /api/health and / answer.
+set -eu
+. "$(dirname "$0")/serve.sh"
+curl -fsS --max-time 5 "http://127.0.0.1:$port/api/health" | grep -q '"ok":true' || { echo '/api/health did not answer {"ok":true}' >&2; exit 1; }
+curl -fsS --max-time 5 "http://127.0.0.1:$port/" | grep -q 'id="app"' || { echo "/ does not serve the app" >&2; exit 1; }

package/blueprints/cloudflare/checks/spec.sh

@@ -0,0 +1,12 @@
+#!/bin/sh
+# The spec exists and every template placeholder in it was filled or marked undecided.
+set -eu
+[ -s .blueprint/spec.md ] || { echo "missing .blueprint/spec.md" >&2; exit 1; }
+if grep -n '{{' .blueprint/spec.md >&2; then
+  echo "unfilled placeholders are left in .blueprint/spec.md" >&2
+  exit 1
+fi
+# A usecase may hold its spec to more than the template: when it ships its own spec check, that runs too.
+if [ -n "${BLUEPRINT_USECASE:-}" ] && [ -f "$BLUEPRINT_USECASE/checks/spec.sh" ]; then
+  sh "$BLUEPRINT_USECASE/checks/spec.sh"
+fi

package/blueprints/cloudflare/checks/tests-pass.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+# The area's own tests exist (test/<area>.test.ts), and everything builds and passes.
+set -eu
+area="$1"
+[ -f "test/$area.test.ts" ] || { echo "missing test/$area.test.ts" >&2; exit 1; }
+yarn build
+yarn test

package/blueprints/cloudflare/manifest.json

@@ -0,0 +1,22 @@
+{
+  "kind": "base",
+  "slug": "cloudflare",
+  "title": "Cloudflare（Workers + D1 + Vue）",
+  "version": "0.1.0",
+  "description": "Runs on Cloudflare: a Worker for the API, D1 (SQLite) for data, and a Vue screen served as static assets from the same Worker. Developed and checked on this computer with wrangler dev, then published with wrangler deploy after approval. A free Cloudflare account is enough to start.",
+  "platform": "cloudflare",
+  "requires": [
+    {
+      "command": "node",
+      "probe": "node -e \"process.exit(Number(process.versions.node.split('.')[0]) >= 22 ? 0 : 1)\"",
+      "installHint": "Node.js 22 or later (https://nodejs.org/). wrangler needs it."
+    },
+    {
+      "command": "yarn",
+      "probe": "yarn --version",
+      "installHint": "corepack enable"
+    }
+  ],
+  "credentials": ["wrangler login"],
+  "report": ".blueprint/start-here.md"
+}

package/blueprints/cloudflare/plan.json

@@ -0,0 +1,83 @@
+{
+  "steps": [
+    {
+      "id": "spec",
+      "title": "仕様書を書く",
+      "description": "ヒアリングの答えから、土台と用途の仕様の雛形を埋める。決まっていない点は一覧にする。",
+      "skill": "skills/spec",
+      "check": "sh \"$BLUEPRINT_BASE/checks/spec.sh\""
+    },
+    {
+      "id": "prerequisites",
+      "title": "道具の確認",
+      "description": "Node（22 以上）と yarn を確かめる。wrangler はプロジェクトに入れるので、ここでは要らない。",
+      "skill": "skills/prerequisites",
+      "check": "sh \"$BLUEPRINT_BASE/checks/prerequisites.sh\"",
+      "gates": ["review"]
+    },
+    {
+      "id": "scaffold",
+      "title": "アプリの雛形",
+      "description": "Worker の API、D1、Vue の画面、Workers の上で動く試験の土台を一つのフォルダに作る。",
+      "skill": "skills/scaffold",
+      "check": "sh \"$BLUEPRINT_BASE/checks/scaffold.sh\""
+    },
+    {
+      "id": "data",
+      "title": "データの形",
+      "description": "仕様の「扱うもの」を D1 の表にし、マイグレーションと試験を書く。",
+      "skill": "skills/data",
+      "check": "sh \"$BLUEPRINT_BASE/checks/tests-pass.sh\" data"
+    },
+    {
+      "id": "api",
+      "title": "API",
+      "description": "仕様の操作を Worker の API にし、入力を検査し、試験を書く。",
+      "skill": "skills/api",
+      "check": "sh \"$BLUEPRINT_BASE/checks/tests-pass.sh\" api"
+    },
+    {
+      "id": "ui",
+      "title": "画面",
+      "description": "仕様の画面を Vue で作り、API とつなぐ。",
+      "skill": "skills/ui",
+      "check": "sh \"$BLUEPRINT_BASE/checks/tests-pass.sh\" ui"
+    },
+    {
+      "id": "auth",
+      "title": "ログイン",
+      "description": "仕様のログインの方式を入れる。公開したアプリは誰でも開けるので、ログインなしなら何を公開してよいかを仕様どおりに絞る。",
+      "skill": "skills/auth",
+      "check": "sh \"$BLUEPRINT_BASE/checks/tests-pass.sh\" auth"
+    },
+    {
+      "id": "run-check",
+      "title": "起動して確かめる",
+      "description": "ビルドして wrangler dev で手元に起動し、画面と API が応えることを確かめる。",
+      "skill": "skills/run-check",
+      "check": "sh \"$BLUEPRINT_BASE/checks/smoke.sh\""
+    },
+    {
+      "id": "security",
+      "title": "セキュリティ診断",
+      "description": "OWASP Top 10:2025 に沿って作ったものを攻撃する側の目で読み、突ける穴を直して試験で確かめ、報告を書く。判定は手元に起動した Worker に、攻撃と同じ形のリクエスト（別のサイトからの変更、壊れた JSON）を送って確かめる。",
+      "skill": "skills/security",
+      "check": "sh \"$BLUEPRINT_BASE/checks/security.sh\""
+    },
+    {
+      "id": "deploy",
+      "title": "Cloudflare に公開",
+      "description": "D1 のデータベースを作ってマイグレーションを当て、wrangler deploy で公開する。公開した URL が今回のビルドを配っていることを確かめる。",
+      "skill": "skills/deploy",
+      "check": "sh \"$BLUEPRINT_BASE/checks/deploy-check.sh\"",
+      "gates": ["deploy-production", "credential"]
+    },
+    {
+      "id": "handover",
+      "title": "使い方の説明と引き継ぎ",
+      "description": "公開した URL、手元での動かし方、次に直すときの手順、データのバックアップを README と使い始め方に書く。",
+      "skill": "skills/handover",
+      "check": "sh \"$BLUEPRINT_BASE/checks/handover.sh\""
+    }
+  ]
+}

package/blueprints/cloudflare/security/checklist.md

@@ -0,0 +1,10 @@
+# Cloudflare 構成 — 必ず詰める点
+
+- [ ] **公開すると誰でも開ける**。ログインなしにするなら、何を誰に見せてよいかを仕様どおりに絞る。身内だけで使うなら、ログインか Cloudflare Access で入口を閉じる
+- [ ] **SQL は必ずバインド**（`prepare("… ?").bind(value)`）。文字列をつないで SQL を作らない
+- [ ] **入力は API の入口で検査する**（型・長さ・必須）。画面側の検査だけに頼らない
+- [ ] **状態を変える API は、同じオリジンからの呼び出しだけ受ける**（別のサイトから勝手に呼ばれないように）
+- [ ] **セキュリティヘッダーを付ける**。API の応答は Worker で、画面のファイルは `public/_headers` で（静的なファイルは Worker を通らない）。`Content-Security-Policy` に `frame-ancestors 'none'`、`X-Content-Type-Options: nosniff`
+- [ ] **パスワードを保存するなら、平文で保存しない**（Web Crypto の PBKDF2 で塩付きのハッシュにする）
+- [ ] **秘密の値は wrangler の secret に置く**（`wrangler secret put`）。手元では `.dev.vars` に置き、`.dev.vars` を `.gitignore` に入れる。コードや `wrangler.jsonc` に書かない
+- [ ] **データのバックアップ**の手順を README に書く（`wrangler d1 export`）

package/blueprints/cloudflare/skills/api/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: blueprint-cloudflare-api
+description: "Build the spec's operations as the Worker's API, with validation and tests."
+---
+
+# API
+
+1. One route per operation in the spec's API table, in the Worker's `/api/*` handler.
+2. At the entry, before routing and before sign-in:
+   - a POST / PUT / PATCH / DELETE whose `Origin` (or, without one, `Referer`) is not this Worker's own origin is
+     refused with **403**;
+   - a JSON body is read **once**, and a malformed one is refused with **400** for every path. A Worker reads bodies
+     per route by default, which leaves a malformed body to whatever the route does with it.
+3. Validate every body and parameter (zod is fine) and answer 400 with a message when it is wrong; 404 for a missing
+   row. Every error reaches one handler that answers JSON without a stack trace.
+4. `test/api.test.ts`: every route in both directions — the valid request succeeds with the right body, an invalid one
+   is refused with 400 — through `SELF.fetch`.
+
+Done when the check passes: `yarn build` and `yarn test` succeed and `test/` has the api tests.
+
+## Always
+
+- Read `.blueprint/spec.md` first. It is the agreed specification; do not widen it.
+- When you need a decision, ask it through the blueprint question tool and stop. Do not guess.
+- Do not run `git init`: a new repository loses the folder's trust and the next unattended step stops at Claude
+  Code's trust prompt. The user adds git themselves after the build if they want it.
+- Say you are done by stopping; the executor runs the check. Do not claim success yourself.

package/blueprints/cloudflare/skills/auth/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: blueprint-cloudflare-auth
+description: "Put in the sign-in the spec chose; a published Worker is open to anyone."
+---
+
+# Sign-in
+
+A published Worker can be opened by anyone who has its URL. Read the spec's sign-in choice.
+
+- **None**: only what the spec says a visitor may see and do is reachable. Say so on the main screen's footer.
+  `test/auth.test.ts` proves an operation the spec reserves (if any) is refused without a session.
+- **One shared password**: a sign-in screen; the password's PBKDF2 hash (Web Crypto, per-install salt) as a wrangler
+  secret (`.dev.vars` locally, in `.gitignore`); a signed, HttpOnly, Secure, SameSite=Lax session cookie; every `/api`
+  route except `/api/health` and sign-in refuses without it.
+- **One account per person**: a `users` table (PBKDF2 hash with a per-user salt), sign-in and sign-out, roles if the
+  spec lists them, checked on the server for every route. If the spec says only a company's people may sign in,
+  Cloudflare Access in front of the Worker is the simplest door: say so in `.blueprint/open-questions.md`.
+
+`test/auth.test.ts`: a request without a session is refused, with one it passes; a wrong password is refused.
+
+Done when the check passes: `yarn build` and `yarn test` succeed and `test/` has the auth tests.
+
+## Always
+
+- Read `.blueprint/spec.md` first. It is the agreed specification; do not widen it.
+- When you need a decision, ask it through the blueprint question tool and stop. Do not guess.
+- Do not run `git init`: a new repository loses the folder's trust and the next unattended step stops at Claude
+  Code's trust prompt. The user adds git themselves after the build if they want it.
+- Say you are done by stopping; the executor runs the check. Do not claim success yourself.

package/blueprints/cloudflare/skills/data/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: blueprint-cloudflare-data
+description: "Turn the spec's tables into D1 migrations with tests."
+---
+
+# Data
+
+1. One migration file per change in `migrations/` (`0001_….sql`, …), applied by wrangler. Primary keys, NOT NULL and
+   UNIQUE as the spec's table says; foreign keys as the spec's relations say.
+2. A small data-access module per table with bound statements only (`env.DB.prepare("… ?").bind(value)`).
+3. `test/data.test.ts`: in the Workers runtime, every table can be written and read back, and every NOT NULL and UNIQUE
+   is refused when broken.
+
+Done when the check passes: `yarn build` and `yarn test` succeed and `test/` has the data tests.
+
+## Always
+
+- Read `.blueprint/spec.md` first. It is the agreed specification; do not widen it.
+- When you need a decision, ask it through the blueprint question tool and stop. Do not guess.
+- Do not run `git init`: a new repository loses the folder's trust and the next unattended step stops at Claude
+  Code's trust prompt. The user adds git themselves after the build if they want it.
+- Say you are done by stopping; the executor runs the check. Do not claim success yourself.

package/blueprints/cloudflare/skills/deploy/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: blueprint-cloudflare-deploy
+description: "With approval, create the D1 database, apply the migrations, and publish with wrangler deploy."
+---
+
+# Publish to Cloudflare
+
+This step's gates are **deploy-production** and **credential**: the user has approved publishing, and signing in to
+their Cloudflare account.
+
+1. `yarn wrangler whoami`. If not signed in, ask the person, through the blueprint question tool, to run
+   `yarn wrangler login` in this folder themselves and tell you when it is done. Never handle an API token.
+2. Create the database once: `yarn wrangler d1 create <name>` and put the `database_id` it prints into
+   `wrangler.jsonc`. Apply the migrations to it: `yarn wrangler d1 migrations apply DB --remote`. If `wrangler.jsonc`
+   binds R2 buckets, create each once too (`yarn wrangler r2 bucket create <bucket_name>`): the deploy fails on a
+   binding to a bucket that does not exist.
+3. Secrets the app needs: ask the person to run `yarn wrangler secret put <NAME>` themselves.
+4. `yarn build`, then give this build an id and ship it with the site:
+   `node -e 'console.log(require("crypto").randomUUID())' > .blueprint/build-id && cp .blueprint/build-id dist/client/blueprint-build.txt`,
+   then `yarn wrangler deploy`.
+5. Write the URL it published to (`https://…workers.dev`, or the custom domain the spec names) to
+   `.blueprint/deploy-url`, and tell the person the URL.
+
+Done when the check passes: the URL in `.blueprint/deploy-url` serves the id this deploy wrote, answers
+`/api/health`, sends a Content-Security-Policy, and its page renders text in headless Chrome.
+
+## Always
+
+- Read `.blueprint/spec.md` first. It is the agreed specification; do not widen it.
+- When you need a decision, ask it through the blueprint question tool and stop. Do not guess.
+- Never enable billing, deploy to production, delete data or handle a credential unless this step's gates say the
+  user approved exactly that.
+- Say you are done by stopping; the executor runs the check. Do not claim success yourself.