projectstore-claude 0.29.2 → 0.29.4

package/node_modules/projectstore/scripts/reconcile.mjs

@@ -29,7 +29,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join, basename } from "node:path";
 import { spawnSync } from "node:child_process";
-import { resolve } from "node:path";
 import {
   readConfig,
   readConfigAt,
@@ -40,7 +39,8 @@ import {
   slugIdentity,
   displayNumberOf,
   compareArtifactOrder,
-  writeFileAtomic, isMain,
+  writeFileAtomic,
+  isMain,
   commandForm,
 } from "./lib.mjs";
 import { childEnv } from "./harness.mjs";
@@ -63,11 +63,19 @@ function runGenerator(script) {
     env: _env || childEnv(process.env, { projectRoot: _projectDir || projectRoot() }),
   });
   if (r.status !== 0) return { error: (r.stderr || "generator failed").trim() };
-  try { return JSON.parse(r.stdout); } catch { return { error: "unparseable generator output" }; }
+  try {
+    return JSON.parse(r.stdout);
+  } catch {
+    return { error: "unparseable generator output" };
+  }
 }
 
 const normalize = (s) =>
-  s.split("\n").filter((l) => !l.startsWith("generated_at:")).join("\n").trimEnd();
+  s
+    .split("\n")
+    .filter((l) => !l.startsWith("generated_at:"))
+    .join("\n")
+    .trimEnd();
 
 const errMsg = (e) => String((e && e.message) || e);
 
@@ -78,9 +86,9 @@ const errMsg = (e) => String((e && e.message) || e);
 // cannot provide them; the class-wide selectors skip, like bare invocation.
 export function resolveSelection(layout, onlyRaw) {
   const validSelectors = () =>
-    [layout.kanban ? "kanban" : null, "codemap", "graph", "indexes",
-     ...layout.folders.map((f) => `indexes=${f.path}`)]
-      .filter(Boolean).join(", ");
+    [layout.kanban ? "kanban" : null, "codemap", "graph", "indexes", ...layout.folders.map((f) => `indexes=${f.path}`)]
+      .filter(Boolean)
+      .join(", ");
   if (onlyRaw == null) {
     return {
       explicit: false,
@@ -91,7 +99,10 @@ export function resolveSelection(layout, onlyRaw) {
     };
   }
   const sel = { explicit: true, kanban: false, codemap: false, graph: false, indexes: [] };
-  const parts = String(onlyRaw).split(",").map((s) => s.trim()).filter(Boolean);
+  const parts = String(onlyRaw)
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
   if (!parts.length) return { error: `empty --only selection — valid: ${validSelectors()}` };
   for (const raw of parts) {
     if (raw === "kanban") {
@@ -118,7 +129,8 @@ export function resolveSelection(layout, onlyRaw) {
         return { error: `no folder "${p}" in this layout — valid: ${validSelectors()}` };
       }
       const existing = sel.indexes.find((x) => x.path === p);
-      if (existing) existing.named = true; // upgrade, whatever the order
+      if (existing)
+        existing.named = true; // upgrade, whatever the order
       else sel.indexes.push({ path: p, named: true });
     } else {
       return { error: `unknown selector "${raw}" — valid: ${validSelectors()}` };
@@ -156,7 +168,7 @@ const SKIP = {
 function derivedTarget(script, explicit = false, fallbackPath = null) {
   const g = runGenerator(script);
   if (g.error) return { ...(fallbackPath ? { path: fallbackPath } : {}), error: g.error };
-  let onDisk = null;
+  let onDisk;
   try {
     onDisk = existsSync(g.path) ? readFileSync(g.path, "utf8") : null;
   } catch (e) {
@@ -195,7 +207,8 @@ export function rebuildIndexRows(original, folder, artifacts) {
   const inFolder = artifacts.filter((a) =>
     folder.kind === "epic"
       ? a.kind === "epic" && a.rel.startsWith(`${folder.path}/`)
-      : a.kind === folder.kind && a.rel === `${folder.path}/${basename(a.rel)}`);
+      : a.kind === folder.kind && a.rel === `${folder.path}/${basename(a.rel)}`,
+  );
   // Ordering per SPEC-002 contract 8: date ascending (date:, else created:),
   // display number then slug as tiebreak — the grandfathered ADR-001…N order
   // survives because same-date groups tiebreak by number.
@@ -292,7 +305,8 @@ export function writeIndexWithRetry(readmePath, rebuild, { attempts = 3 } = {})
 // shrinks the staleness window to microseconds (spec contract 1).
 function applyDerived(script, explicit, fallbackPath) {
   const t = derivedTarget(script, explicit, fallbackPath);
-  if (t.error) return { ...(t.path ? { path: t.path } : {}), changed: t.changed === true, written: false, error: t.error };
+  if (t.error)
+    return { ...(t.path ? { path: t.path } : {}), changed: t.changed === true, written: false, error: t.error };
   if (t.skipped) return { path: t.path, changed: false, written: false, skipped: t.skipped, stats: t.stats };
   if (!t.changed) return { path: t.path, changed: false, written: false, stats: t.stats };
   try {
@@ -307,7 +321,11 @@ export function runReconcile({ write = false, only = null, projectDir = null, en
   _projectDir = projectDir;
   _env = env;
   const cfg = projectDir ? readConfigAt(projectDir) : readConfig();
-  if (!cfg) { const e = new Error(`No projectstore config. Run ${commandForm("bind")} first.`); e.code = "UNBOUND"; throw e; }
+  if (!cfg) {
+    const e = new Error(`No projectstore config. Run ${commandForm("bind")} first.`);
+    e.code = "UNBOUND";
+    throw e;
+  }
   const layout = loadLayout(cfg.layout);
   const sel = resolveSelection(layout, only);
   if (sel.error) throw new Error(sel.error);
@@ -334,15 +352,24 @@ export function runReconcile({ write = false, only = null, projectDir = null, en
   const kanbanPath = layout.kanban ? join(cfg.vault_path, layout.kanban.file || "kanban.md") : null;
   if (!sel.kanban) out.kanban = { skipped: "not selected" };
   else if (!layout.kanban) out.kanban = { skipped: "layout has no kanban" };
-  else out.kanban = write ? applyDerived("kanban.mjs", sel.explicit, kanbanPath) : derivedTarget("kanban.mjs", sel.explicit, kanbanPath);
+  else
+    out.kanban = write
+      ? applyDerived("kanban.mjs", sel.explicit, kanbanPath)
+      : derivedTarget("kanban.mjs", sel.explicit, kanbanPath);
 
   const codemapPath = join(cfg.vault_path, "code-map.md");
   if (!sel.codemap) out.codemap = { skipped: "not selected" };
-  else out.codemap = write ? applyDerived("codemap.mjs", sel.explicit, codemapPath) : derivedTarget("codemap.mjs", sel.explicit, codemapPath);
+  else
+    out.codemap = write
+      ? applyDerived("codemap.mjs", sel.explicit, codemapPath)
+      : derivedTarget("codemap.mjs", sel.explicit, codemapPath);
 
   const graphPath = join(cfg.vault_path, "graph.md");
   if (!sel.graph) out.graph = { skipped: "not selected" };
-  else out.graph = write ? applyDerived("graph.mjs", sel.explicit, graphPath) : derivedTarget("graph.mjs", sel.explicit, graphPath);
+  else
+    out.graph = write
+      ? applyDerived("graph.mjs", sel.explicit, graphPath)
+      : derivedTarget("graph.mjs", sel.explicit, graphPath);
 
   out.indexes = [];
   for (const { path: folderPath, named } of sel.indexes) {
@@ -359,7 +386,13 @@ export function runReconcile({ write = false, only = null, projectDir = null, en
       if (r.unusable) {
         // Pre-flighted named targets can only reach this via a race.
         if (named) {
-          out.indexes.push({ path: readmePath, folder: folder.path, changed: false, written: false, error: r.unusable });
+          out.indexes.push({
+            path: readmePath,
+            folder: folder.path,
+            changed: false,
+            written: false,
+            error: r.unusable,
+          });
         }
         continue;
       }
@@ -374,7 +407,11 @@ export function runReconcile({ write = false, only = null, projectDir = null, en
       const t = rebuildIndex(cfg, folder, artifacts);
       if (t === null) {
         if (named) {
-          out.indexes.push({ path: readmePath, folder: folder.path, error: "absent or no managed index table (changed since pre-flight)" });
+          out.indexes.push({
+            path: readmePath,
+            folder: folder.path,
+            error: "absent or no managed index table (changed since pre-flight)",
+          });
         }
         continue;
       }

package/node_modules/projectstore/scripts/run-host.mjs

@@ -0,0 +1,139 @@
+// projectstore — run-host.mjs: one asynchronous runner for a host command.
+//
+// The install verbs ran every child through spawnSync, which blocks the event
+// loop: nothing can animate while it waits. The shell fetch of install and
+// upgrade (the story "Install and upgrade fetch a shell-rooted harness at the
+// bin's own version, once per run; plan and uninstall never fetch") is the
+// first child a person watches for seconds, so it gets a runner that yields:
+// a spawn with stdin ignored and both outputs piped, resolved with spawnSync's
+// own result shape so a caller written for one reads the other. APPLY's host
+// commands move onto it in a later story (the APPLY story adds `signal`).
+//
+//   runHost(bin, argv, { env, cwd, budget, spawn, shell })
+//     → Promise<{ status, signal, stdout, stderr, error }>
+//   startFailure(err, { bin, resolved, cwd }) → what Node could not say
+//   HOST_BUDGET_MS                            → the outer bound, 120 s
+//
+// Leaf module: node built-ins only. Only install-harness.mjs and
+// fetch-shell.mjs import it; hooks, doctor, surfaces and lib never do (the
+// portability suite asserts it), so the SessionStart graph never loads it.
+
+import { spawn as nodeSpawn } from "node:child_process";
+import { statSync } from "node:fs";
+
+// The bound every host command gets, ours, outside whatever the child sets
+// for itself (npm's per-request timeouts, retried, can outlast it).
+export const HOST_BUDGET_MS = 120000;
+
+// How long the pipes may drain after the child exits. A grandchild that keeps
+// a pipe open must not hold the run: `close` waited 3 s for one where `exit`
+// came at 99 ms (measured 2026-10-09).
+const DRAIN_MS = 200;
+
+// spawnSync's shape, asynchronously: `status` is the exit code, or null when
+// the child never started or was stopped; `error` carries the start failure
+// (never close's -2), or ETIMEDOUT when the budget ran out. Output is decoded
+// as UTF-8 by the streams themselves, so a character split across two writes
+// stays whole (measured). The budget's SIGTERM settles at once: a child that
+// ignores it, or a grandchild still writing, is left to the OS — its pipes are
+// destroyed and its handle unref'd, so nothing of it keeps this process open.
+// `shell` exists for win32, where npm is npm.cmd and runs only through a
+// shell; that path is unverified, as the install spec says of Windows.
+export function runHost(
+  bin,
+  argv,
+  { env = process.env, cwd = process.cwd(), budget = HOST_BUDGET_MS, spawn = nodeSpawn, shell = false } = {},
+) {
+  return new Promise((settle) => {
+    const out = [],
+      err = [];
+    let child = null,
+      done = false,
+      timer = null,
+      drain = null,
+      exited = null;
+    const release = () => {
+      for (const s of [child?.stdout, child?.stderr]) {
+        try {
+          s?.destroy();
+        } catch {}
+      }
+      try {
+        child?.unref?.();
+      } catch {}
+    };
+    const finish = (r) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      clearTimeout(drain);
+      settle({ status: null, signal: null, stdout: out.join(""), stderr: err.join(""), error: undefined, ...r });
+    };
+    try {
+      child = spawn(bin, argv, { env, cwd, stdio: ["ignore", "pipe", "pipe"], shell });
+    } catch (e) {
+      finish({ error: e });
+      return;
+    }
+    for (const [s, sink] of [
+      [child.stdout, out],
+      [child.stderr, err],
+    ]) {
+      if (!s) continue;
+      s.setEncoding("utf8");
+      s.on("data", (d) => sink.push(d));
+      // A stream that ends after the exit may be the last one the drain waits on.
+      s.on("end", () => {
+        if (exited && drained()) finish(exited);
+      });
+      s.on("error", () => {});
+    }
+    const drained = () => [child.stdout, child.stderr].every((s) => !s || s.readableEnded || s.destroyed);
+    child.on("error", (e) => {
+      finish({ error: e, status: null });
+      release();
+    });
+    child.on("exit", (code, signal) => {
+      exited = { status: code, signal };
+      if (drained()) {
+        finish(exited);
+        return;
+      }
+      drain = setTimeout(() => {
+        finish(exited);
+        release();
+      }, DRAIN_MS);
+    });
+    timer = setTimeout(() => {
+      try {
+        child.kill("SIGTERM");
+      } catch {}
+      finish({
+        status: null,
+        signal: "SIGTERM",
+        error: Object.assign(new Error(`${bin} ran past its ${budget} ms budget and was stopped`), {
+          code: "ETIMEDOUT",
+        }),
+      });
+      release();
+    }, budget);
+  });
+}
+
+// What Node cannot say: spawnSync reports a working directory that does not
+// exist and a binary not on PATH with the same `spawnSync <bin> ENOENT`
+// (measured 2026-10-05), and spawn the same `spawn <bin> ENOENT`. The
+// filesystem tells them apart, in this order (the install spec, contract 19);
+// any other error passes through as Node wrote it.
+export function startFailure(err, { bin, resolved, cwd }) {
+  let dir = false;
+  try {
+    dir = statSync(cwd).isDirectory();
+  } catch {}
+  if (!dir)
+    return `${bin} could not start: the working directory ${JSON.stringify(String(cwd))} is not an existing directory`;
+  if (!resolved) return `${bin} could not start: it was not found on PATH`;
+  if (["ENOENT", "EACCES", "ENOEXEC"].includes(err?.code))
+    return `${bin} could not start: ${resolved} exists but could not be run (${err.code})`;
+  return String(err?.message || err);
+}

package/node_modules/projectstore/scripts/scaffold.mjs

@@ -0,0 +1,244 @@
+// projectstore — scaffold.mjs
+//
+// A vault's skeleton — the layout's folders, their README indexes and the
+// vault's own README — as a plan and an apply: the one place it is written,
+// for the CLI's `scaffold` verb, for `init` (binding.mjs) and, through the
+// bin, for the session command and the Codex skill. So a vault made in a
+// session, by `init` and by `setup` is the same bytes (the front-door ADR's
+// decision 7). Before this module a session wrote the READMEs itself, picking
+// each folder's name and description "based on the folder kind": two sessions
+// wrote two vaults, and the SessionStart skeleton's Purpose column, which
+// reads a folder's README prose, repeated whatever words the model chose.
+// The names and descriptions are data now: templates/<lang>/strings.json →
+// folders.<kind>, in the binding's language, with no English fallback.
+//
+// The shape is binding.mjs's. planScaffold() is pure over the filesystem: one
+// row per folder, per folder README and for the vault README, each `create`
+// or `exists`, and the reasons it refuses before anything is written.
+// applyScaffold() writes the `create` rows and nothing else. A file that
+// exists is never rewritten, whatever its content: the index rows inside a
+// README are reconcile's, and a README edited by hand is the person's. "The
+// layout's folders are missing" means the plan has a `create` row — a folder
+// that is there without its README counts, because reconcile drops an index
+// it cannot find without a word (the locale spec, contract 5).
+//
+// A leaf: lib.mjs and node built-ins only. binding.mjs imports this module,
+// so the reverse import would be a cycle. Normative: the story "Scaffold is a
+// core verb, and init creates a whole vault…" (PS-CORE).
+
+import { existsSync, statSync, mkdirSync } from "node:fs";
+import { join, basename } from "node:path";
+import {
+  pluginRoot,
+  loadLayout,
+  loadTemplate,
+  loadStrings,
+  renderTemplate,
+  writeFileAtomic,
+  commandForm,
+  fromTerminalIn,
+} from "./lib.mjs";
+import { packageCommand } from "./harness.mjs";
+
+const README = "README.md";
+
+const kindsOf = (layout) => [...new Set((layout.folders || []).map((f) => f.kind))];
+const usable = (v) => typeof v === "string" && v.trim() !== "";
+const pathKind = (p) => {
+  try {
+    return statSync(p).isDirectory() ? "dir" : "file";
+  } catch {
+    return null;
+  }
+};
+
+// What a layout needs from a language before anything is written: the vault
+// README's template, the folder README's when a folder asks for one, and a
+// name and a description for every kind the layout's folders declare —
+// `diagram` included, though no command creates one. planScaffold refuses on
+// exactly this list and doctor's checkLayoutTemplates warns on it, so the two
+// cannot disagree about what a language lacks.
+export function missingScaffoldRequirements(layout, lang, root = pluginRoot()) {
+  const missing = [];
+  const templates = ["vault-readme", ...((layout.folders || []).some((f) => f.readme) ? ["folder-readme"] : [])];
+  for (const name of templates) {
+    if (!existsSync(join(root, "templates", String(lang), `${name}.md.tmpl`))) {
+      missing.push({
+        what: "template",
+        name,
+        message: `language "${lang}" has no ${name} template (templates/${lang}/${name}.md.tmpl)`,
+      });
+    }
+  }
+  const strings = loadStrings(lang, root);
+  for (const kind of kindsOf(layout)) {
+    const s = strings && strings.folders && strings.folders[kind];
+    if (!s || !usable(s.name) || !usable(s.description)) {
+      missing.push({
+        what: "string",
+        name: kind,
+        message: `language "${lang}" has no name and description for the folder kind "${kind}" (templates/${lang}/strings.json → folders.${kind})`,
+      });
+    }
+  }
+  return missing;
+}
+
+// The vault README's folder table: a row per layout folder, its name linked
+// to the folder's README (to the folder, when the layout asks for none) and
+// its description — the same strings the folder READMEs carry, so the two
+// never call one folder by two names.
+function folderRows(layout, strings) {
+  return layout.folders
+    .map((f) => {
+      const s = strings.folders[f.kind];
+      return `| [${s.name}](${f.path}/${f.readme ? README : ""}) | ${s.description} |`;
+    })
+    .join("\n");
+}
+
+// What `scaffold` would write into `vault`. A vault that does not exist yet
+// is planned as all `create` — what `init` plans before its mkdir. Refusal
+// codes: LAYOUT, TEMPLATE, STRINGS, NOT_A_DIRECTORY, FOLDER_IS_FILE; every
+// one is exit 1 upstream, and any one means nothing is written. A `create`
+// row carries the bytes it would write; an `exists` row carries none.
+export function planScaffold(vault, { layout, language, root = pluginRoot() } = {}) {
+  const refusals = [];
+  const rows = [];
+  const plan = { vault, layout, language, rows, creates: 0, refusals, ok: false };
+  let spec;
+  try {
+    spec = loadLayout(layout, root);
+    if (!spec || !Array.isArray(spec.folders)) throw new Error("it declares no folders");
+  } catch (e) {
+    refusals.push({ code: "LAYOUT", message: `the layout "${layout}" does not load: ${e.message}` });
+    return plan;
+  }
+  for (const m of missingScaffoldRequirements(spec, language, root))
+    refusals.push({ code: m.what === "template" ? "TEMPLATE" : "STRINGS", message: m.message });
+  if (pathKind(vault) === "file")
+    refusals.push({ code: "NOT_A_DIRECTORY", message: `${vault} is a file, not a vault directory` });
+  if (refusals.length) return plan;
+  const strings = loadStrings(language, root);
+  const folderTemplate = spec.folders.some((f) => f.readme) ? loadTemplate(language, "folder-readme", root) : null;
+  const row = (type, rel, render = null) => {
+    const abs = join(vault, rel);
+    const action = existsSync(abs) ? "exists" : "create";
+    rows.push({ type, rel, abs, action, ...(render && action === "create" ? { content: render() } : {}) });
+  };
+  for (const f of spec.folders) {
+    if (pathKind(join(vault, f.path)) === "file")
+      refusals.push({
+        code: "FOLDER_IS_FILE",
+        message: `${f.path} exists in ${vault} as a file — the layout's ${f.kind} folder cannot be created there`,
+      });
+    row("folder", f.path);
+    if (f.readme) {
+      const s = strings.folders[f.kind];
+      row("readme", `${f.path}/${README}`, () =>
+        renderTemplate(folderTemplate, { folder_name: s.name, folder_description: s.description }),
+      );
+    }
+  }
+  // Last, and from the basename alone: nothing path-dependent beyond the
+  // directory's name, so a vault made here and one made by `init` elsewhere
+  // under the same name are byte-identical.
+  row("vault-readme", README, () =>
+    renderTemplate(loadTemplate(language, "vault-readme", root), {
+      vault_name: basename(vault),
+      folder_rows: folderRows(spec, strings),
+    }),
+  );
+  plan.creates = rows.filter((r) => r.action === "create").length;
+  plan.ok = refusals.length === 0;
+  return plan;
+}
+
+// Writes the plan's `create` rows and nothing else: every folder first —
+// writeFileAtomic never mkdirs — then each README, its absence checked again
+// at the moment of writing, so a file that appeared after the plan (another
+// session, a hand) is reported as there and never rewritten. The vault root is
+// the caller's to make: `init` makes it, and a binding whose vault vanished is
+// refused upstream, never recreated here behind the person's back.
+export function applyScaffold(plan) {
+  if (!plan.ok)
+    throw Object.assign(new Error(plan.refusals.map((r) => r.message).join("; ")), {
+      code: plan.refusals[0] ? plan.refusals[0].code : "REFUSED",
+    });
+  if (pathKind(plan.vault) !== "dir")
+    throw Object.assign(new Error(`${plan.vault} does not exist — scaffold never creates the vault itself`), {
+      code: "MISSING",
+    });
+  const made = new Set();
+  for (const r of plan.rows) {
+    if (r.type !== "folder" || r.action !== "create" || existsSync(r.abs)) continue;
+    mkdirSync(r.abs, { recursive: true });
+    made.add(r.rel);
+  }
+  for (const r of plan.rows) {
+    if (r.type === "folder" || r.action !== "create" || existsSync(r.abs)) continue;
+    writeFileAtomic(r.abs, r.content);
+    made.add(r.rel);
+  }
+  return {
+    created: plan.rows.filter((r) => made.has(r.rel)).map((r) => r.rel),
+    exists: plan.rows.filter((r) => !made.has(r.rel)).map((r) => r.rel),
+  };
+}
+
+// The result a front-end reports: the rows and what became of them, never a
+// file body. `path` is vault-relative.
+export function scaffoldResult(plan, done = null) {
+  return {
+    vault_path: plan.vault,
+    layout: plan.layout,
+    language: plan.language,
+    rows: plan.rows.map((r) => ({ type: r.type, path: r.rel, action: r.action })),
+    creates: plan.creates,
+    wrote: Boolean(done),
+    created: done ? done.created : [],
+    exists: done ? done.exists : plan.rows.filter((r) => r.action === "exists").map((r) => r.rel),
+    refusals: plan.refusals,
+  };
+}
+
+const shown = (r) => (r.type === "folder" ? `${r.rel}/` : r.rel);
+
+// The plan as text. A bare plan ends with the command that writes it, in both
+// forms — the session's and the core's through npx, since a git-marketplace
+// install has no bin on PATH — and with `--write`, because at a terminal that
+// form shows this plan again and asks. Each stands alone on its line after a
+// blank one, and the lead names `project`, where the terminal's form runs
+// (the story "User-facing text says where to run…", rules 1, 4 and 6).
+// `asking`: the question follows on the same stream, so the closing lines are
+// left out. After an apply, what was created and what was already there.
+export function renderScaffoldPlan(plan, done = null, { env = process.env, asking = false, project = null } = {}) {
+  if (!plan.ok) return [...plan.refusals.map((r) => r.message), "Nothing written."].join("\n") + "\n";
+  const where = `${plan.vault} (layout ${plan.layout}, language ${plan.language})`;
+  if (done) {
+    const lines = [
+      `Scaffolded ${where}`,
+      ...plan.rows.filter((r) => done.created.includes(r.rel)).map((r) => `  created  ${shown(r)}`),
+    ];
+    lines.push(
+      done.exists.length
+        ? `Created ${done.created.length}; ${done.exists.length} already there, left as ${done.exists.length === 1 ? "it was" : "they were"}.`
+        : `Created ${done.created.length}.`,
+    );
+    return lines.join("\n") + "\n";
+  }
+  const lines = [`Scaffold ${where}`, ...plan.rows.map((r) => `  ${r.action}  ${shown(r)}`), ""];
+  const there = plan.rows.length - plan.creates;
+  if (!plan.creates) lines.push("Nothing to create: every folder and README the layout declares is there.");
+  else {
+    lines.push(`${plan.creates} to create${there ? `; ${there} already there, never rewritten` : ""}.`);
+    if (!asking)
+      lines.push(
+        `To write them, in a session or ${project ? fromTerminalIn(project) : "from a terminal in this project"}:`,
+        "",
+        `  ${commandForm("scaffold", { env })}`,
+        `  ${packageCommand([], "scaffold", { args: "--write" })}`,
+      );
+  }
+  return lines.join("\n") + "\n";
+}