@noir-ai/create 1.14.0-beta.1 → 1.15.0-beta.1

package/dist/index.js

@@ -63,6 +63,10 @@ var MANIFEST_PATH_PARITY = [
   [P.noirMd, paths.noirMd],
   [P.rulesMd, paths.rulesMd]
 ];
+var REFRESHABLE_SEED_KIND = {
+  [P.envExample]: "envExample",
+  [P.rulesMd]: "rulesSeed"
+};
 function buildManifest(ctx) {
   return [...hostAgnosticEntries(ctx), ...buildHostArtifacts(resolveAdapter(ctx.host), ctx)];
 }
@@ -82,13 +86,17 @@ function hostAgnosticEntries(ctx) {
       description: "user config seed (host + mode)"
     },
     {
+      // Refreshable: the variable set Noir documents grows between releases,
+      // and this file is pure documentation the user is never asked to edit —
+      // so an upgrade may replace an untouched older copy of it.
       path: P.envExample,
       mode: "skipIfExists",
       template: "env.example.tmpl",
+      refreshIfStale: true,
       description: ".noir/.env.example committable documentation (never loaded)"
     },
     {
-      // §8.1: init creates the REAL env file, not just the example. The body is
+      // init creates the REAL env file, not just the example. The body is
       // all-comment, so the file parses to an EMPTY overlay and creating it
       // changes no behaviour — it exists so the user never has to copy the
       // example by hand. `fileMode: 0o600` because the file holds tokens the
@@ -108,13 +116,16 @@ function hostAgnosticEntries(ctx) {
       description: "NOIR.md auto-brief (project id pointer)"
     },
     {
+      // Refreshable: shipped as a starting contract the user is INVITED to
+      // rewrite, so only the never-edited copy may be swapped for a newer one.
       path: P.rulesMd,
       mode: "skipIfExists",
       template: "rules-seed.md.tmpl",
+      refreshIfStale: true,
       description: "AI working-rules seed"
     },
     {
-      // Slice E (spec §9): the `.noir/` runtime map — what init just wrote,
+      // The `.noir/` runtime map — what init just wrote,
       // what appears later (and which command creates it), and where to go
       // next. Host-agnostic: it describes the canonical store, which every
       // host shares. Co-owned (README_BLOCK) so user notes survive while the
@@ -289,7 +300,7 @@ function buildHostArtifacts(adapter, ctx) {
   return entries;
 }
 var SESSION_START_HOOK_SCRIPT = `#!/usr/bin/env node
-// Noir C3 SessionStart hook \u2014 injects the skill router contract at session start.
+// Noir SessionStart hook \u2014 injects the skill router contract at session start.
 // The mutable contract lives in .noir/router.md (a Noir managed block, so user
 // edits outside the markers survive noir sync). This script is a pure runner.
 import { readFileSync, existsSync } from 'node:fs';
@@ -470,176 +481,292 @@ function mergeThreeWay(base, ours, theirs, style = "minimal") {
 }
 
 // src/migrations/index.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join5 } from "path";
 
-// src/migrations/runner.ts
-function runMigrations(root, from, to, opts = {}) {
-  const window = pickWindow(from ?? "0.0.0", to, MIGRATIONS);
-  const ctx = { root, dryRun: opts.dryRun === true };
-  const aggregate = { changed: [], conflicts: [], notes: [] };
-  const ran = [];
-  for (const script of window) {
-    ran.push(`${script.from}\u2192${script.to}`);
-    let res;
-    try {
-      res = script.run(ctx);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      aggregate.conflicts.push(`<runner>:${script.from}\u2192${script.to} threw: ${msg}`);
-      continue;
-    }
-    aggregate.changed.push(...res.changed);
-    aggregate.conflicts.push(...res.conflicts);
-    aggregate.notes.push(...res.notes);
-  }
-  return {
-    ...aggregate,
-    from,
-    to,
-    ran
-  };
-}
-function pickWindow(from, to, scripts) {
-  return scripts.filter((s) => compareVer(s.from) >= compareVer(from) && compareVer(s.to) <= compareVer(to)).sort((a, b) => compareVer(a.to) - compareVer(b.to));
-}
-function compareVer(v) {
-  const parts = v.split("-")[0]?.split(".") ?? [];
-  let n = 0;
-  for (let i = 0; i < 3; i++) {
-    const p = Number(parts[i] ?? "0");
-    n = n * 1e3 + (Number.isFinite(p) ? p : 0);
-  }
-  return n;
+// src/template.ts
+var TOKEN = /\{\{\s*([^}{}]+?)\s*\}\}/g;
+function render(template, vars) {
+  return template.replace(TOKEN, (whole, name) => {
+    if (!Object.hasOwn(vars, name)) return whole;
+    const v = vars[name];
+    if (v === void 0 || v === null) return whole;
+    return String(v);
+  });
 }
 
-// src/migrations/index.ts
-var synthetic = {
-  from: "1.0.0",
-  to: "1.0.0",
-  description: "no-op synthetic migration (runner smoke test)",
-  run: (ctx) => {
-    const result = { changed: [], conflicts: [], notes: [] };
-    if (process.env.NOIR_TEST_FORCE_CONFLICT === "1" && !ctx.dryRun) {
-      const file = join3(ctx.root, ".noir", "scaffold-version");
-      if (existsSync3(file)) {
-        const prev = readFileSync2(file, "utf8");
-        const merged = applyInlineConflict(prev, "noir-scaffold=1.0.0\n", "ours", "theirs");
-        writeFileSync2(file, merged, "utf8");
-        result.conflicts.push(".noir/scaffold-version");
-      }
-    }
-    result.notes.push("synthetic 1.0.0\u21921.0.0 migration ran");
-    return result;
-  }
-};
-var ENV_POINTER_MARKER = "# noir:env-pointer";
-var ENV_POINTER_BLOCK = [
-  ENV_POINTER_MARKER,
-  "# This file is safe to commit: it holds no secrets.",
-  "# Project-scoped values and secrets belong in .noir/.env (gitignored, mode",
-  "# 0600). .noir/.env.example documents the full variable set; `noir env`",
-  "# reports which source wins for each key.",
-  ""
-].join("\n");
-function appendSeparated(prev, block) {
-  if (prev.length === 0) return block;
-  if (prev.endsWith("\n\n")) return `${prev}${block}`;
-  return prev.endsWith("\n") ? `${prev}
-${block}` : `${prev}
+// src/template-history.ts
+var ENV_EXAMPLE_1_1_0 = `# .noir/.env.example \u2014 committable documentation of the format.
+#
+# This file is a TEMPLATE and is never loaded. Noir reads \`.noir/.env\`, which
+# \`noir init\` already created for you at mode 0600 \u2014 edit that file and
+# uncomment the entries you need. Keep this example in git so the variable set
+# stays discoverable.
+#
+# ---------------------------------------------------------------------------
+# The block below is the same header \`.noir/.env\` carries (spec 12.1).
+# ---------------------------------------------------------------------------
+#
+# .noir/.env \u2014 project-scoped configuration for this repo.
+#
+# This file is the recommended home for project-scoped configuration and
+# secrets. Precedence:
+#   1. run profile env     run.profiles.<n>.env      (per-invocation; merges OVER)
+#   2. .noir/.env          <- recommended home for project-scoped configuration
+#   3. real environment    CI / container / launchd / shell rc
+#   4. built-in default
+#
+# A real environment variable is a FALLBACK: it applies only to keys this file
+# leaves unset. A machine-global export therefore cannot shadow a value here.
+# Run \`noir env\` to see which source is winning for each key.
+#
+# Keep this file private: chmod 600 .noir/.env
+# It is gitignored by Noir's managed .gitignore block, and Noir REFUSES to load
+# it if it is tracked by git (a cloned repo could redirect credentials).
+# Never commit \`.noir/.env\`. (THIS file is the committable one.)
 
-${block}`;
-}
-var envPointer = {
-  from: "1.0.0",
-  to: "1.1.0",
-  description: "point .noir/config.yml at .noir/.env (the secrets home)",
-  run: (ctx) => {
-    const result = { changed: [], conflicts: [], notes: [] };
-    const rel = ".noir/config.yml";
-    const abs = join3(ctx.root, ".noir", "config.yml");
-    if (!existsSync3(abs)) {
-      result.notes.push(`${rel}: absent \u2014 the template seed carries the pointer`);
-      return result;
-    }
-    let prev;
-    try {
-      prev = readFileSync2(abs, "utf8");
-    } catch (err) {
-      result.conflicts.push(rel);
-      result.notes.push(`${rel}: unreadable (${errorMessage(err)}) \u2014 left untouched`);
-      return result;
-    }
-    if (prev.includes(ENV_POINTER_MARKER)) {
-      result.notes.push(`${rel}: already carries ${ENV_POINTER_MARKER}`);
-      return result;
-    }
-    if (ctx.dryRun) {
-      result.changed.push(rel);
-      result.notes.push(`${rel}: would append the .noir/.env pointer`);
-      return result;
-    }
-    try {
-      writeFileSync2(abs, appendSeparated(prev, ENV_POINTER_BLOCK), "utf8");
-    } catch (err) {
-      result.conflicts.push(rel);
-      result.notes.push(`${rel}: write failed (${errorMessage(err)}) \u2014 left untouched`);
-      return result;
-    }
-    result.changed.push(rel);
-    result.notes.push(`${rel}: appended the .noir/.env pointer`);
-    return result;
+# --- Integrations -----------------------------------------------------------
+# ClickUp \u2014 only if the noir-clickup integration is enabled.
+# CLICKUP_API_TOKEN=pk_00000000000000000000000000000000
+#
+# CLICKUP_TEAM_ID is NOT an env var \u2014 Noir never reads it. Workspace binding
+# (team/list/space ids) is config.yml instead:
+#   integrations:
+#     clickup:
+#       teamId: "ABC123"   # optional \u2014 only for custom task IDs (#ABC-123)
+
+# --- Remote embedders (context.embedder.kind: remote) -----------------------
+# The default local embedder (kind: local) needs no key.
+# OPENAI_API_KEY=sk-000000000000000000000000000000000000000000000000
+# VOYAGE_API_KEY=pa-0000000000000000000000000000000000000000000000
+# COHERE_API_KEY=0000000000000000000000000000000000000000
+#
+# Ollama (kind: ollama) reads its base URL from config.yml
+# (context.embedder.baseURL); this variable is the fallback:
+# OLLAMA_BASE_URL=http://localhost:11434
+
+# --- Model provider key -----------------------------------------------------
+# There is NO fixed "model key" variable, and setting one is not enough on its
+# own. \`apiKeyEnv\` is a NAME, not an interpolation: the config stores the
+# variable NAME and Noir reads process.env[<that name>] at call time. Write the
+# bare name \u2014 never \`\${...}\` \u2014 in .noir/config.yml:
+#
+#   model:
+#     providers:
+#       anthropic:
+#         apiKeyEnv: ANTHROPIC_API_KEY   # -> reads $ANTHROPIC_API_KEY
+#     tiers:
+#       default:
+#         provider: anthropic
+#
+# Only \`run.profiles.<name>.env\` interpolates \`\${VAR}\`. With no provider
+# configured the model layer degrades to templates \u2014 Noir never makes a silent
+# paid call. \`ANTHROPIC_API_KEY\` is the conventional example, not a variable
+# Noir looks up on its own:
+# ANTHROPIC_API_KEY=sk-ant-0000000000000000000000000000000000000000000000
+
+# --- Run profile selection --------------------------------------------------
+# Selects a \`run.profiles.<name>\` entry for \`noir run\`.
+# Precedence: --profile flag > NOIR_PROFILE > run.defaultProfile > host default.
+# NOIR_PROFILE=work
+
+# --- Update kill-switches ---------------------------------------------------
+# NOIR_DISABLE_UPDATE_CHECK=1   # suppress the background startup check only
+# NOIR_DISABLE_UPDATES=1        # make \`noir update\` refuse (exit 2)
+
+# See docs/reference/environment.md for every variable Noir reads.
+`;
+var ENV_EXAMPLE_1_2_0 = `# .noir/.env.example \u2014 the committable reference for .noir/.env.
+#
+# What .noir/.env is for
+# ----------------------
+# .noir/.env is this project's configuration-and-secrets file. \`noir init\`
+# creates it at mode 0600 and gitignores it, and Noir loads it on every
+# command. For every key it defines, it WINS over your shell environment, so it
+# is the recommended home for project-scoped values and secrets.
+#
+# Precedence (highest wins):
+#   1. run profile env     run.profiles.<n>.env      (per-invocation; merges over)
+#   2. .noir/.env          the project-scoped file this example documents
+#   3. real environment    CI / container / launchd / shell rc
+#   4. built-in default
+#
+# A real environment variable is only a FALLBACK for keys .noir/.env leaves
+# unset. For a value scoped to one invocation, add a \`run.profiles.<name>.env\`
+# entry and reference it there as \`\${VAR}\`, so the literal value stays out of
+# config.yml; values that must not be committed belong in \`.noir/.env\`
+# (gitignored) or the real environment. \`noir env\` reports the winning source
+# for each key.
+#
+# What to commit
+# --------------
+# Keep .noir/.env OUT of git: it holds real secrets, Noir's managed .gitignore
+# block excludes it, and Noir refuses to load a copy that IS tracked (a cloned
+# repo could redirect credentials). chmod 600 .noir/.env to keep it private.
+# Never commit the real file \u2014 commit THIS example, so the keys stay
+# discoverable and documented.
+#
+# Every line below is documentation. Copy a key to .noir/.env and set a real
+# value to enable it.
+#
+# Full reference: docs/reference/environment.md
+
+# --- Host gateway (Claude Code via Z.AI / LiteLLM / OpenRouter / Kimi ...) ---
+# Point the host at an Anthropic-shaped endpoint instead of api.anthropic.com.
+#
+# ANTHROPIC_BASE_URL \u2014 the gateway's base URL. Host ONLY: give the origin (for
+#   example https://gateway.example) and NOT the /v1/messages path \u2014 the host
+#   appends that itself.
+# ANTHROPIC_AUTH_TOKEN \u2014 sent as \`Authorization: Bearer <token>\`. It is the
+#   HEADER variant of a credential: AUTH_TOKEN becomes Bearer, while
+#   ANTHROPIC_API_KEY becomes x-api-key. Do not set BOTH \u2014 that is an auth
+#   conflict.
+# ANTHROPIC_DEFAULT_HAIKU_MODEL / _SONNET_MODEL / _OPUS_MODEL \u2014 remap the
+#   haiku / sonnet / opus aliases to the model ids your gateway serves.
+# API_TIMEOUT_MS \u2014 per-request timeout in milliseconds (Claude Code default is
+#   600000).
+# CLAUDE_CODE_AUTO_COMPACT_WINDOW \u2014 auto-compact window (100000 to 1000000).
+#
+# ANTHROPIC_BASE_URL=https://gateway.example
+# ANTHROPIC_AUTH_TOKEN=replace-with-your-gateway-token
+# ANTHROPIC_DEFAULT_HAIKU_MODEL=replace-with-your-gateway-haiku-model
+# ANTHROPIC_DEFAULT_SONNET_MODEL=replace-with-your-gateway-sonnet-model
+# ANTHROPIC_DEFAULT_OPUS_MODEL=replace-with-your-gateway-opus-model
+# API_TIMEOUT_MS=600000
+# CLAUDE_CODE_AUTO_COMPACT_WINDOW=1000000
+
+# --- Integrations ---
+# CLICKUP_API_TOKEN \u2014 the token for the noir-clickup integration; set it only
+#   when that integration is enabled.
+# CLICKUP_TEAM_ID is NOT an env var. Noir never reads it \u2014 workspace binding
+#   (team / list / space ids) belongs in .noir/config.yml under
+#   integrations.clickup.
+# CLICKUP_API_TOKEN=replace-with-your-clickup-token
+
+# --- Remote embedders (context.embedder.kind: remote) ---
+# The default local embedder (kind: local) needs no key. The three API-key
+# variables below apply only when config.yml selects a remote embedder.
+# OPENAI_API_KEY=replace-with-your-openai-key
+# VOYAGE_API_KEY=replace-with-your-voyage-key
+# COHERE_API_KEY=replace-with-your-cohere-key
+#
+# Ollama (kind: ollama) reads its base URL from config.yml
+# (context.embedder.baseURL); this variable is the fallback:
+# OLLAMA_BASE_URL=http://localhost:11434
+
+# --- Model provider key (read via apiKeyEnv in .noir/config.yml) ---
+# There is no fixed "model key" variable, and setting a key is not enough on
+# its own. \`apiKeyEnv\` is a NAME, not an interpolation: config.yml stores the
+# variable NAME, and Noir reads process.env[<that name>] at call time. Write
+# the bare name \u2014 never \`\${...}\` \u2014 in .noir/config.yml:
+#
+#   model:
+#     providers:
+#       anthropic:
+#         apiKeyEnv: ANTHROPIC_API_KEY   # -> reads $ANTHROPIC_API_KEY
+#
+# Only \`run.profiles.<name>.env\` interpolates \`\${VAR}\`. With no provider
+# configured the model layer degrades to templates \u2014 Noir never makes a silent
+# paid call. \`ANTHROPIC_API_KEY\` is the conventional example, not a variable
+# Noir looks up on its own.
+# ANTHROPIC_API_KEY=replace-with-your-anthropic-key
+
+# --- Run profile selection (noir run) ---
+# Selects a \`run.profiles.<name>\` entry for \`noir run\`.
+# Precedence: --profile flag > NOIR_PROFILE > run.defaultProfile > host default.
+# NOIR_PROFILE=work
+
+# --- Update kill-switches ---
+# NOIR_DISABLE_UPDATE_CHECK=1   # suppress the background startup check only
+# NOIR_DISABLE_UPDATES=1        # make \`noir update\` refuse (exit 2)
+
+# See docs/reference/environment.md for every variable Noir reads.
+`;
+var RULES_SEED_1_1_0 = `# Noir working rules
+
+> Canonical AI working-contract for this project. The host context file (CLAUDE.md) @imports this.
+> Keep LEAN: every line must be failure-backed, tool-enforceable, decision-encoding, or triggerable \u2014 else delete it.
+> Edit freely \u2014 Noir re-emits only the @import pointer, never this body.
+
+## Identity & scope
+- This project uses **Noir** (discipline/context/memory layer) inside **Claude Code**.
+- Noir is an orchestration layer \u2014 the host CLI is the execution engine; Noir is the spec/context/memory brain.
+- Stay in scope: do only what the current Noir task (\`.noir/tasks/\`) requires. Surface scope creep BEFORE acting.
+
+## Anti-assumption contract
+- **Never fabricate** facts, APIs, file contents, or command output. Use only what you have read or verified.
+- **Never assume** \u2014 if a path, signature, or convention is unclear, STOP and ask before acting.
+- Cite the file/line or command you relied on for any non-obvious claim.
+- Detect non-conventional setups; do not paper over them with assumed conventions.
+
+## Spec-Driven Development workflow
+- Follow the Noir SDD lifecycle: intake \u2192 clarify \u2192 spec \u2192 plan \u2192 execute \u2192 verify \u2192 document.
+- Gates are observable: every gate decision is recorded (approved / forced / skipped). \`--force\` requires a reason.
+- Do not edit/run/execute before facts are gathered AND the human confirms understanding.
+
+## Verification (run before claiming done)
+- \`pnpm build && pnpm lint && pnpm typecheck && pnpm test\` \u2014 all green, with real output. No hedging.
+- Report failures truthfully with the actual output; never claim green without evidence.
+
+## Coding standards & architecture
+- Follow existing patterns; match surrounding code's style, naming, comment density.
+- Architecture decisions live in \`.noir/decisions/\` (ADR-style) \u2014 read them before cross-cutting changes.
+- See \`docs/roadmap.md\` for direction and \`docs/specs/\` for design.
+
+## Conventions gotchas (project-specific \u2014 fill in)
+- Commits stay local until explicitly pushed.
+- The full test suite runs offline/free (no network in CI).
+`;
+var SEED_TEMPLATE_HISTORY = [
+  {
+    scaffoldVersion: "1.1.0",
+    envExample: ENV_EXAMPLE_1_1_0,
+    rulesSeed: RULES_SEED_1_1_0
+  },
+  {
+    scaffoldVersion: "1.2.0",
+    envExample: ENV_EXAMPLE_1_2_0,
+    rulesSeed: RULES_SEED_1_1_0
   }
-};
-var MIGRATIONS = [synthetic, envPointer];
-function errorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
+];
+function isStaleSeed(seed, fileBytes, currentRender) {
+  if (fileBytes === currentRender) return false;
+  return SEED_TEMPLATE_HISTORY.some((entry) => entry[seed] === fileBytes);
 }
-function applyInlineConflict(ours, theirs, oursLabel = "ours", theirsLabel = "theirs") {
-  return `<<<<<<< ${oursLabel}
-${ours}=======
-${theirs}>>>>>>> ${theirsLabel}
-`;
+
+// src/template-loader.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, join as join3, resolve } from "path";
+import { fileURLToPath } from "url";
+var DEFAULT_TEMPLATES_DIR = resolveTemplatesDir();
+function resolveTemplatesDir() {
+  const override = process.env.NOIR_TEMPLATES_DIR;
+  if (override && override.length > 0) return resolve(override);
+  const here = dirname2(fileURLToPath(import.meta.url));
+  return join3(here, "..", "templates");
 }
-function applyWithConflict(ours, theirs, path) {
-  if (ours === theirs) return { text: ours, conflicted: false };
-  return {
-    text: applyInlineConflict(ours, theirs, path, path),
-    conflicted: true
-  };
+function loadTemplate(name) {
+  return readFileSync2(join3(DEFAULT_TEMPLATES_DIR, name), "utf8");
+}
+function templatesDir() {
+  return DEFAULT_TEMPLATES_DIR;
 }
-
-// src/scaffold.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync7, renameSync as renameSync2, rmSync as rmSync2 } from "fs";
-import { basename as basename2, dirname as dirname5, join as join8 } from "path";
-import {
-  createProjectId,
-  paths as paths2,
-  readManagedBlock,
-  resolveNoirCommand,
-  sha256Hex12
-} from "@noir-ai/core";
-
-// src/scaffold-version.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname3, join as join5 } from "path";
-import { NOIR_DIR as NOIR_DIR2 } from "@noir-ai/core";
 
 // src/writers.ts
 import {
   closeSync,
-  existsSync as existsSync4,
+  existsSync as existsSync3,
   openSync,
   readFileSync as readFileSync3,
   renameSync,
   rmSync,
-  writeFileSync as writeFileSync3,
+  writeFileSync as writeFileSync2,
   writeSync
 } from "fs";
-import { basename, dirname as dirname2, join as join4 } from "path";
+import { basename, dirname as dirname3, join as join4 } from "path";
 import { atomicWriteFile, stripManagedBlock, writeManagedRegion } from "@noir-ai/core";
 function regenerate(absPath, content) {
-  const dir = dirname2(absPath);
+  const dir = dirname3(absPath);
   const tmp = join4(
     dir,
     `.${basename(absPath)}.tmp.${process.pid}.${Math.random().toString(36).slice(2)}`
@@ -691,7 +818,7 @@ function managedBlocks(absPath, regions) {
   const next = stripped.trim().length > 0 ? `${stripped.trimEnd()}
 
 ${regionsJoined}` : regionsJoined;
-  writeFileSync3(absPath, next, "utf8");
+  writeFileSync2(absPath, next, "utf8");
   return { path: absPath, mode: "managedBlock", written: true };
 }
 function buildRegion(block, body) {
@@ -725,15 +852,19 @@ function predictManagedBlocks(currentContent, regions) {
 ${regionsJoined}` : regionsJoined;
 }
 function skipIfExists(absPath, content, fileMode) {
-  if (existsSync4(absPath)) {
+  if (existsSync3(absPath)) {
     return { path: absPath, mode: "skipIfExists", written: false };
   }
   atomicWriteFile(absPath, content, fileMode !== void 0 ? { mode: fileMode } : {});
   return { path: absPath, mode: "skipIfExists", written: true };
 }
+function refreshSeed(absPath, content) {
+  atomicWriteFile(absPath, content);
+  return { path: absPath, mode: "skipIfExists", written: true };
+}
 function mergeJson(absPath, patch, dedupSubstring) {
   let existing = {};
-  if (existsSync4(absPath)) {
+  if (existsSync3(absPath)) {
     try {
       existing = JSON.parse(readFileSync3(absPath, "utf8"));
     } catch {
@@ -743,7 +874,7 @@ function mergeJson(absPath, patch, dedupSubstring) {
   const merged = deepMergePreservingHooks(existing, patch, dedupSubstring);
   const content = `${JSON.stringify(merged, null, 2)}
 `;
-  if (existsSync4(absPath)) {
+  if (existsSync3(absPath)) {
     try {
       if (readFileSync3(absPath, "utf8") === content) {
         return { path: absPath, mode: "mergeJson", written: false };
@@ -777,16 +908,214 @@ function deepMergePreservingHooks(existing, patch, dedupSubstring) {
   return out;
 }
 
+// src/migrations/runner.ts
+function runMigrations(root, from, to, opts = {}) {
+  const window = pickWindow(from ?? "0.0.0", to, MIGRATIONS);
+  const ctx = { root, dryRun: opts.dryRun === true };
+  const aggregate = { changed: [], conflicts: [], notes: [] };
+  const ran = [];
+  for (const script of window) {
+    ran.push(`${script.from}\u2192${script.to}`);
+    let res;
+    try {
+      res = script.run(ctx);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      aggregate.conflicts.push(`<runner>:${script.from}\u2192${script.to} threw: ${msg}`);
+      continue;
+    }
+    aggregate.changed.push(...res.changed);
+    aggregate.conflicts.push(...res.conflicts);
+    aggregate.notes.push(...res.notes);
+  }
+  return {
+    ...aggregate,
+    from,
+    to,
+    ran
+  };
+}
+function pickWindow(from, to, scripts) {
+  return scripts.filter((s) => compareVer(s.from) >= compareVer(from) && compareVer(s.to) <= compareVer(to)).sort((a, b) => compareVer(a.to) - compareVer(b.to));
+}
+function compareVer(v) {
+  const parts = v.split("-")[0]?.split(".") ?? [];
+  let n = 0;
+  for (let i = 0; i < 3; i++) {
+    const p = Number(parts[i] ?? "0");
+    n = n * 1e3 + (Number.isFinite(p) ? p : 0);
+  }
+  return n;
+}
+
+// src/migrations/index.ts
+var synthetic = {
+  from: "1.0.0",
+  to: "1.0.0",
+  description: "no-op synthetic migration (runner smoke test)",
+  run: (ctx) => {
+    const result = { changed: [], conflicts: [], notes: [] };
+    if (process.env.NOIR_TEST_FORCE_CONFLICT === "1" && !ctx.dryRun) {
+      const file = join5(ctx.root, ".noir", "scaffold-version");
+      if (existsSync4(file)) {
+        const prev = readFileSync4(file, "utf8");
+        const merged = applyInlineConflict(prev, "noir-scaffold=1.0.0\n", "ours", "theirs");
+        writeFileSync3(file, merged, "utf8");
+        result.conflicts.push(".noir/scaffold-version");
+      }
+    }
+    result.notes.push("synthetic 1.0.0\u21921.0.0 migration ran");
+    return result;
+  }
+};
+var ENV_POINTER_MARKER = "# noir:env-pointer";
+var ENV_POINTER_BLOCK = [
+  ENV_POINTER_MARKER,
+  "# This file is safe to commit: it holds no secrets.",
+  "# Project-scoped values and secrets belong in .noir/.env (gitignored, mode",
+  "# 0600). .noir/.env.example documents the full variable set; `noir env`",
+  "# reports which source wins for each key.",
+  ""
+].join("\n");
+function appendSeparated(prev, block) {
+  if (prev.length === 0) return block;
+  if (prev.endsWith("\n\n")) return `${prev}${block}`;
+  return prev.endsWith("\n") ? `${prev}
+${block}` : `${prev}
+
+${block}`;
+}
+var envPointer = {
+  from: "1.0.0",
+  to: "1.1.0",
+  description: "point .noir/config.yml at .noir/.env (the secrets home)",
+  run: (ctx) => {
+    const result = { changed: [], conflicts: [], notes: [] };
+    const rel = ".noir/config.yml";
+    const abs = join5(ctx.root, ".noir", "config.yml");
+    if (!existsSync4(abs)) {
+      result.notes.push(`${rel}: absent \u2014 the template seed carries the pointer`);
+      return result;
+    }
+    let prev;
+    try {
+      prev = readFileSync4(abs, "utf8");
+    } catch (err) {
+      result.conflicts.push(rel);
+      result.notes.push(`${rel}: unreadable (${errorMessage(err)}) \u2014 left untouched`);
+      return result;
+    }
+    if (prev.includes(ENV_POINTER_MARKER)) {
+      result.notes.push(`${rel}: already carries ${ENV_POINTER_MARKER}`);
+      return result;
+    }
+    if (ctx.dryRun) {
+      result.changed.push(rel);
+      result.notes.push(`${rel}: would append the .noir/.env pointer`);
+      return result;
+    }
+    try {
+      writeFileSync3(abs, appendSeparated(prev, ENV_POINTER_BLOCK), "utf8");
+    } catch (err) {
+      result.conflicts.push(rel);
+      result.notes.push(`${rel}: write failed (${errorMessage(err)}) \u2014 left untouched`);
+      return result;
+    }
+    result.changed.push(rel);
+    result.notes.push(`${rel}: appended the .noir/.env pointer`);
+    return result;
+  }
+};
+var DOC_SEEDS = [
+  { rel: ".noir/.env.example", kind: "envExample", template: "env.example.tmpl" },
+  { rel: ".noir/rules/RULES.md", kind: "rulesSeed", template: "rules-seed.md.tmpl" }
+];
+var envTemplates = {
+  from: "1.1.0",
+  to: "1.2.0",
+  description: "refresh the .env.example doc seed and keep RULES.md in step",
+  run: (ctx) => {
+    const result = { changed: [], conflicts: [], notes: [] };
+    for (const seed of DOC_SEEDS) {
+      const abs = join5(ctx.root, seed.rel);
+      if (!existsSync4(abs)) {
+        result.notes.push(`${seed.rel}: absent \u2014 nothing to refresh`);
+        continue;
+      }
+      let prev;
+      try {
+        prev = readFileSync4(abs, "utf8");
+      } catch (err) {
+        result.conflicts.push(seed.rel);
+        result.notes.push(`${seed.rel}: unreadable (${errorMessage(err)}) \u2014 left untouched`);
+        continue;
+      }
+      const current = render(loadTemplate(seed.template), {});
+      if (!isStaleSeed(seed.kind, prev, current)) {
+        result.notes.push(`${seed.rel}: user-owned or already current \u2014 left untouched`);
+        continue;
+      }
+      if (ctx.dryRun) {
+        result.changed.push(seed.rel);
+        result.notes.push(`${seed.rel}: would refresh to the current seed`);
+        continue;
+      }
+      try {
+        refreshSeed(abs, current);
+      } catch (err) {
+        result.conflicts.push(seed.rel);
+        result.notes.push(`${seed.rel}: refresh failed (${errorMessage(err)}) \u2014 left untouched`);
+        continue;
+      }
+      result.changed.push(seed.rel);
+      result.notes.push(`${seed.rel}: refreshed to the current seed`);
+    }
+    return result;
+  }
+};
+var MIGRATIONS = [synthetic, envPointer, envTemplates];
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function applyInlineConflict(ours, theirs, oursLabel = "ours", theirsLabel = "theirs") {
+  return `<<<<<<< ${oursLabel}
+${ours}=======
+${theirs}>>>>>>> ${theirsLabel}
+`;
+}
+function applyWithConflict(ours, theirs, path) {
+  if (ours === theirs) return { text: ours, conflicted: false };
+  return {
+    text: applyInlineConflict(ours, theirs, path, path),
+    conflicted: true
+  };
+}
+
+// src/scaffold.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync7, renameSync as renameSync2, rmSync as rmSync2 } from "fs";
+import { basename as basename2, dirname as dirname5, join as join8 } from "path";
+import {
+  createProjectId,
+  loadProjectInfo,
+  paths as paths2,
+  readManagedBlock,
+  resolveNoirCommand,
+  sha256Hex12
+} from "@noir-ai/core";
+
 // src/scaffold-version.ts
-var CURRENT_SCAFFOLD_VERSION = "1.1.0";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname4, join as join6 } from "path";
+import { NOIR_DIR as NOIR_DIR2 } from "@noir-ai/core";
+var CURRENT_SCAFFOLD_VERSION = "1.2.0";
 var PREFIX = "noir-scaffold=";
 function scaffoldVersionPath(root) {
-  return join5(root, NOIR_DIR2, "scaffold-version");
+  return join6(root, NOIR_DIR2, "scaffold-version");
 }
 function readScaffoldVersion(root) {
   let raw;
   try {
-    raw = readFileSync4(scaffoldVersionPath(root), "utf8");
+    raw = readFileSync5(scaffoldVersionPath(root), "utf8");
   } catch {
     return null;
   }
@@ -801,14 +1130,14 @@ function readScaffoldVersion(root) {
 }
 function writeScaffoldVersion(root, version) {
   const file = scaffoldVersionPath(root);
-  mkdirSync2(dirname3(file), { recursive: true });
+  mkdirSync2(dirname4(file), { recursive: true });
   regenerate(file, `${PREFIX}${version}
 `);
 }
 
 // src/stack-detect.ts
-import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync5 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync6 } from "fs";
+import { join as join7 } from "path";
 var NODE_FRAMEWORKS = [
   ["next", "next"],
   ["vite", "vite"],
@@ -835,7 +1164,7 @@ var PYTHON_FRAMEWORKS = [
 ];
 function readJson(file) {
   try {
-    return JSON.parse(readFileSync5(file, "utf8"));
+    return JSON.parse(readFileSync6(file, "utf8"));
   } catch {
     return void 0;
   }
@@ -845,11 +1174,11 @@ function detectStack(root) {
   const frameworks = /* @__PURE__ */ new Set();
   let monorepo = false;
   let packageManager = null;
-  const pjPath = join6(root, "package.json");
+  const pjPath = join7(root, "package.json");
   if (existsSync5(pjPath)) {
     const pj = readJson(pjPath);
     if (pj) {
-      const hasTs = Boolean(pj.devDependencies?.typescript) || existsSync5(join6(root, "tsconfig.json"));
+      const hasTs = Boolean(pj.devDependencies?.typescript) || existsSync5(join7(root, "tsconfig.json"));
       languages.add(hasTs ? "typescript" : "javascript");
       const deps = /* @__PURE__ */ new Set([
         ...Object.keys(pj.dependencies ?? {}),
@@ -868,22 +1197,22 @@ function detectStack(root) {
       }
     }
   }
-  if (existsSync5(join6(root, "pnpm-workspace.yaml"))) {
+  if (existsSync5(join7(root, "pnpm-workspace.yaml"))) {
     monorepo = true;
     packageManager = packageManager ?? "pnpm";
   }
-  if (existsSync5(join6(root, "turbo.json")) || existsSync5(join6(root, "nx.json"))) {
+  if (existsSync5(join7(root, "turbo.json")) || existsSync5(join7(root, "nx.json"))) {
     monorepo = true;
   }
   if (!packageManager) {
-    if (existsSync5(join6(root, "pnpm-lock.yaml"))) packageManager = "pnpm";
-    else if (existsSync5(join6(root, "yarn.lock"))) packageManager = "yarn";
-    else if (existsSync5(join6(root, "package-lock.json"))) packageManager = "npm";
+    if (existsSync5(join7(root, "pnpm-lock.yaml"))) packageManager = "pnpm";
+    else if (existsSync5(join7(root, "yarn.lock"))) packageManager = "yarn";
+    else if (existsSync5(join7(root, "package-lock.json"))) packageManager = "npm";
   }
-  if (existsSync5(join6(root, "pyproject.toml")) || existsSync5(join6(root, "requirements.txt")) || existsSync5(join6(root, "Pipfile")) || existsSync5(join6(root, "setup.py"))) {
+  if (existsSync5(join7(root, "pyproject.toml")) || existsSync5(join7(root, "requirements.txt")) || existsSync5(join7(root, "Pipfile")) || existsSync5(join7(root, "setup.py"))) {
     languages.add("python");
-    if (existsSync5(join6(root, "pyproject.toml"))) {
-      const raw = safeRead(join6(root, "pyproject.toml"));
+    if (existsSync5(join7(root, "pyproject.toml"))) {
+      const raw = safeRead(join7(root, "pyproject.toml"));
       if (raw) {
         for (const [dep, id] of PYTHON_FRAMEWORKS) {
           if (pyprojectHasDep(raw, dep)) frameworks.add(id);
@@ -891,13 +1220,13 @@ function detectStack(root) {
       }
     }
   }
-  if (existsSync5(join6(root, "go.mod"))) {
+  if (existsSync5(join7(root, "go.mod"))) {
     languages.add("go");
     packageManager = packageManager ?? "go-modules";
   }
-  if (existsSync5(join6(root, "Cargo.toml"))) {
+  if (existsSync5(join7(root, "Cargo.toml"))) {
     languages.add("rust");
-    const raw = safeRead(join6(root, "Cargo.toml"));
+    const raw = safeRead(join7(root, "Cargo.toml"));
     if (raw) {
       if (/^\s*actix-web\b/m.test(raw)) frameworks.add("actix-web");
       if (/^\s*actix\s*=/m.test(raw)) frameworks.add("actix");
@@ -938,10 +1267,10 @@ function detectStack(root) {
     }
   }
   let ci = null;
-  if (existsSync5(join6(root, ".github", "workflows"))) ci = "github";
-  else if (existsSync5(join6(root, ".gitlab-ci.yml"))) ci = "gitlab";
-  else if (existsSync5(join6(root, ".circleci", "config.yml"))) ci = "circleci";
-  else if (existsSync5(join6(root, "Jenkinsfile"))) ci = "jenkins";
+  if (existsSync5(join7(root, ".github", "workflows"))) ci = "github";
+  else if (existsSync5(join7(root, ".gitlab-ci.yml"))) ci = "gitlab";
+  else if (existsSync5(join7(root, ".circleci", "config.yml"))) ci = "circleci";
+  else if (existsSync5(join7(root, "Jenkinsfile"))) ci = "jenkins";
   const aiFiles = [
     ["AGENTS.md", "agents-md"],
     ["CLAUDE.md", "claude"],
@@ -951,10 +1280,10 @@ function detectStack(root) {
   ];
   const existingAiFiles = [];
   for (const [p, kind] of aiFiles) {
-    const full = join6(root, p);
+    const full = join7(root, p);
     if (existsSync5(full)) existingAiFiles.push({ path: p, kind });
   }
-  const cursorRulesDir = join6(root, ".cursor", "rules");
+  const cursorRulesDir = join7(root, ".cursor", "rules");
   try {
     if (existsSync5(cursorRulesDir)) {
       const entries = readdirSync(cursorRulesDir);
@@ -978,7 +1307,7 @@ function detectStack(root) {
 }
 function safeRead(file) {
   try {
-    return readFileSync5(file, "utf8");
+    return readFileSync6(file, "utf8");
   } catch {
     return void 0;
   }
@@ -990,35 +1319,6 @@ function pyprojectHasDep(raw, dep) {
   return new RegExp(`${before}${esc}${after}`, "m").test(raw);
 }
 
-// src/template.ts
-var TOKEN = /\{\{\s*([^}{}]+?)\s*\}\}/g;
-function render(template, vars) {
-  return template.replace(TOKEN, (whole, name) => {
-    if (!Object.hasOwn(vars, name)) return whole;
-    const v = vars[name];
-    if (v === void 0 || v === null) return whole;
-    return String(v);
-  });
-}
-
-// src/template-loader.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { dirname as dirname4, join as join7, resolve } from "path";
-import { fileURLToPath } from "url";
-var DEFAULT_TEMPLATES_DIR = resolveTemplatesDir();
-function resolveTemplatesDir() {
-  const override = process.env.NOIR_TEMPLATES_DIR;
-  if (override && override.length > 0) return resolve(override);
-  const here = dirname4(fileURLToPath(import.meta.url));
-  return join7(here, "..", "templates");
-}
-function loadTemplate(name) {
-  return readFileSync6(join7(DEFAULT_TEMPLATES_DIR, name), "utf8");
-}
-function templatesDir() {
-  return DEFAULT_TEMPLATES_DIR;
-}
-
 // src/scaffold.ts
 var EMITTED_IN = {
   regenerate: { sync: true, upgrade: true },
@@ -1039,9 +1339,17 @@ function assertSafeRoot(root) {
     cur = parent;
   }
 }
+function readConfiguredHost(root) {
+  if (!existsSync6(paths2.config(root))) return "claude";
+  try {
+    return loadProjectInfo(root).config.host;
+  } catch {
+    return "claude";
+  }
+}
 async function scaffold(opts) {
   assertSafeRoot(opts.root);
-  const host = opts.host ?? "claude";
+  const host = opts.host ?? readConfiguredHost(opts.root);
   const transport = opts.transport ?? "stdio";
   if (transport === "streamable-http" && !opts.url) {
     throw new Error("transport 'streamable-http' requires opts.url");
@@ -1071,11 +1379,13 @@ async function scaffold(opts) {
       written: [],
       skipped: [],
       identical: [],
+      refreshed: [],
       conflicts: [],
       fileModes: {},
       noop: true,
       migrationsRan: [],
       migrationConflicts: [],
+      migrationChanged: [],
       stack,
       projectId,
       fromVersion,
@@ -1085,12 +1395,14 @@ async function scaffold(opts) {
   }
   const migrationsRan = [];
   const migrationConflicts = [];
-  if (opts.mode === "init" && opts.upgrade === true && fromVersion !== null) {
+  const migrationChanged = [];
+  if (opts.mode === "init" && opts.upgrade === true && (fromVersion !== null || idFile.state === "valid")) {
     const m = runMigrations(opts.root, fromVersion, CURRENT_SCAFFOLD_VERSION, {
       dryRun: opts.dryRun === true
     });
     migrationsRan.push(...m.ran);
     migrationConflicts.push(...m.conflicts);
+    migrationChanged.push(...m.changed);
   }
   const command = resolveNoirCommand();
   const manifest = buildManifest({
@@ -1114,6 +1426,7 @@ async function scaffold(opts) {
   const written = [];
   const skipped = [];
   const identical = [];
+  const refreshed = [];
   const fileModes = {};
   const conflictMemory = /* @__PURE__ */ new Map();
   const conflictRecords = [];
@@ -1180,21 +1493,34 @@ async function scaffold(opts) {
     if (!opts.dryRun) mkdirSync3(dirname5(abs), { recursive: true });
     for (const entry of entries) {
       if (opts.dryRun) {
-        if (entry.mode === "skipIfExists") {
+        if (entry.mode !== "skipIfExists") {
+          written.push(entry.path);
+          continue;
+        }
+        const seedKind = refreshableSeedKind(entry, emitContext);
+        if (seedKind === void 0) {
           if (existsSync6(abs)) {
             skipped.push(entry.path);
           } else {
             written.push(entry.path);
             if (entry.fileMode !== void 0) fileModes[entry.path] = entry.fileMode;
           }
-        } else {
+          continue;
+        }
+        const plan = planSeedWrite(abs, seedKind, renderEntry(entry, vars));
+        if (plan === "create") {
           written.push(entry.path);
+          if (entry.fileMode !== void 0) fileModes[entry.path] = entry.fileMode;
+        } else if (plan === "refresh") {
+          refreshed.push(entry.path);
+        } else {
+          skipped.push(entry.path);
         }
         continue;
       }
       const body = renderEntry(entry, vars);
       if (entry.mode === "regenerate") {
-        const out = await writeRegenerateWithConflict(abs, entry.path, body, opts, {
+        const out = await writeWithConflict(abs, entry.path, body, opts, {
           memory: conflictMemory,
           record: recordConflict
         });
@@ -1249,12 +1575,40 @@ async function scaffold(opts) {
         if (out.written) written.push(entry.path);
         else identical.push(entry.path);
       } else {
-        const out = skipIfExists(abs, body, entry.fileMode);
-        if (out.written) {
+        const seedKind = refreshableSeedKind(entry, emitContext);
+        if (seedKind === void 0) {
+          const out = skipIfExists(abs, body, entry.fileMode);
+          if (out.written) {
+            written.push(entry.path);
+            if (entry.fileMode !== void 0) fileModes[entry.path] = entry.fileMode;
+          } else {
+            skipped.push(entry.path);
+          }
+          continue;
+        }
+        const plan = planSeedWrite(abs, seedKind, body);
+        if (plan === "create") {
+          skipIfExists(abs, body, entry.fileMode);
           written.push(entry.path);
           if (entry.fileMode !== void 0) fileModes[entry.path] = entry.fileMode;
-        } else {
+        } else if (plan === "refresh") {
+          refreshSeed(abs, body);
+          refreshed.push(entry.path);
+        } else if (plan === "keep") {
           skipped.push(entry.path);
+        } else {
+          const out = await writeWithConflict(abs, entry.path, body, opts, {
+            memory: conflictMemory,
+            record: recordConflict,
+            artifactClass: "skipIfExists",
+            // No resolver answered (no TTY, `--no-input`, CI): keep the user's
+            // file. An explicit overwrite policy is an instruction rather than a
+            // missing answer, so `--force` still replaces.
+            defaultResolution: opts.conflictPolicy === "overwrite" ? "replace" : "preserve"
+          });
+          written.push(...out.written);
+          skipped.push(...out.skipped);
+          identical.push(...out.identical);
         }
       }
     }
@@ -1269,11 +1623,13 @@ async function scaffold(opts) {
     written,
     skipped,
     identical,
+    refreshed,
     conflicts: conflictRecords,
     fileModes,
     noop: false,
     migrationsRan,
     migrationConflicts,
+    migrationChanged,
     stack,
     projectId,
     fromVersion,
@@ -1347,7 +1703,29 @@ function resolveProjectId(opts, idFile) {
   }
   return createProjectId();
 }
-async function writeRegenerateWithConflict(abs, relPath, proposed, opts, internals) {
+function planSeedWrite(abs, seed, currentRender) {
+  let existing;
+  try {
+    existing = readOptional(abs);
+  } catch {
+    return "keep";
+  }
+  if (existing === void 0) return "create";
+  if (isStaleSeed(seed, existing, currentRender)) return "refresh";
+  if (existing === currentRender) return "keep";
+  return "conflict";
+}
+function refreshableSeedKind(entry, emitContext) {
+  if (emitContext !== "upgrade" || entry.refreshIfStale !== true) return void 0;
+  const kind = REFRESHABLE_SEED_KIND[entry.path];
+  if (kind === void 0) {
+    throw new Error(
+      `manifest entry ${entry.path}: 'refreshIfStale' is set but no recorded seed is declared for that path`
+    );
+  }
+  return kind;
+}
+async function writeWithConflict(abs, relPath, proposed, opts, internals) {
   let existing;
   try {
     existing = readFileSync7(abs, "utf8");
@@ -1361,7 +1739,7 @@ async function writeRegenerateWithConflict(abs, relPath, proposed, opts, interna
   if (existing === proposed) {
     return { written: [], skipped: [], identical: [relPath] };
   }
-  const MODE = "regenerate";
+  const MODE = internals.artifactClass ?? "regenerate";
   const sim = similarity(existing, proposed);
   let resolution;
   const remembered = internals.memory.get(MODE);
@@ -1375,7 +1753,7 @@ async function writeRegenerateWithConflict(abs, relPath, proposed, opts, interna
     }
     resolution = unwrapped;
   } else {
-    resolution = opts.conflictPolicy === "preserve" ? "preserve" : "replace";
+    resolution = opts.conflictPolicy === "preserve" ? "preserve" : internals.defaultResolution ?? "replace";
   }
   internals.record(relPath, MODE, existing, proposed, resolution, sim);
   switch (resolution) {
@@ -1460,6 +1838,7 @@ export {
   CURRENT_SCAFFOLD_VERSION,
   MANIFEST_PATH_PARITY,
   MIGRATIONS,
+  SEED_TEMPLATE_HISTORY,
   ancestorsPath,
   applyInlineConflict,
   applyWithConflict,
@@ -1468,6 +1847,7 @@ export {
   buildManifest,
   buildRegion,
   detectStack,
+  isStaleSeed,
   lineDiff,
   loadTemplate,
   managedBlock2 as managedBlock,