@noir-ai/create 1.3.0-beta.6 → 1.4.0-beta.1

package/dist/index.d.ts

@@ -8,7 +8,9 @@ declare function ancestorsPath(root: string): string;
 declare function readAncestors(root: string): Record<string, string>;
 /** Write the ancestor map. Ensures `.noir/` exists (a standalone caller may
  *  invoke this before the scaffold has created the dir). Derived state, so the
- *  plain write (no tmp) is fine. */
+ *  plain write (no tmp) is fine. Content-hash dedup — when the serialized
+ *  bytes equal what is already on disk, the rewrite is skipped so a no-op sync
+ *  leaves ancestors.json untouched (no mtime/git churn). */
 declare function writeAncestors(root: string, map: Record<string, string>): void;
 
 /**
@@ -116,7 +118,7 @@ declare function skipIfExists(absPath: string, content: string): WriteOutcome;
  * entries + a {@link buildHostArtifacts} call that materializes per-host files
  * (CLAUDE.md/GEMINI.md for claude/gemini; AGENTS.md + .cursor/.../opencode.json
  * for agents-md/cursor/opencode) via the resolved adapter. The claude default
- * `noir init` stays BYTE-IDENTICAL to v1.1 — fix-wave I1 REMOVED the additive
+ * `noir init` stays BYTE-IDENTICAL to v1.1 — REMOVED the additive
  * root `AGENTS.md` (it was double-importing `.noir/NOIR.md` + RULES.md via
  * CLAUDE.md's existing @-imports; claude's native surface is CLAUDE.md alone).
  *
@@ -184,7 +186,7 @@ declare const MANIFEST_PATH_PARITY: ReadonlyArray<[
  * S10 structure: the manifest is now `[...hostAgnosticEntries(ctx), ...hostSpecificEntries(ctx)]`
  * where the host-specific half comes from {@link buildHostArtifacts} (driven by
  * `resolveAdapter(ctx.host)`). The host-agnostic half is unchanged from v1.1
- * (canonical `.noir/` store + ignore files). Fix-wave I1: {@link buildHostArtifacts}
+ * (canonical `.noir/` store + ignore files). {@link buildHostArtifacts}
  * emits AGENTS.md ONLY for agents-md/cursor/opencode (claude/gemini use their
  * own CLAUDE.md/GEMINI.md — emitting AGENTS.md too would double-import .noir/).
  *
@@ -238,7 +240,7 @@ interface BuildHostArtifactsContext {
  *      gemini's in GEMINI.md, agents-md/cursor/opencode's in AGENTS.md — NO
  *      host emits a separate rules file. (The prior cursor
  *      `.cursor/rules/noir-contract.mdc` host-rules pointer was REMOVED: it
- *      collided with the C3 cursor flat-skill prune of `noir-*.mdc` under
+ *      collided with the cursor flat-skill prune of `noir-*.mdc` under
  *      `.cursor/rules/`, and cursor's rules are already delivered via
  *      AGENTS.md's `@.noir/rules/RULES.md` import.)
  *   3. **Host MCP config** — `regenerate` at `adapter.mcpConfigPath(ctx)`
@@ -250,7 +252,7 @@ interface BuildHostArtifactsContext {
  *
  * Skills are OUT OF SCOPE here — the cli composes `emitSkillsToDir` with
  * `adapter.skillsDir` + the host's `CompileTarget` (claude → `.claude/skills/`
- * as SKILL.md; cursor → `.cursor/rules/<skill>.mdc` FLAT per C3; gemini/
+ * as SKILL.md; cursor → `.cursor/rules/<skill>.mdc` FLAT; gemini/
  * agents-md/opencode have no skill dir → skip).
  */
 declare function buildHostArtifacts(adapter: HostAdapter, ctx: BuildHostArtifactsContext): ManifestEntry[];
@@ -261,14 +263,51 @@ interface MergeResult {
     /** True when ours and theirs diverged in the same region (markers emitted). */
     conflict: boolean;
 }
+/**
+ * Unified line diff for the conflict resolver's stderr preview. Returns a
+ * sequence of {type:'eq'|'del'|'add', line} records, LCS-based, equivalent in
+ * shape to `git diff --no-color`. Pure (no IO) so it unit-tests cleanly and the
+ * resolver can render it through {@link packages/cli/src/theme.ts} (`+` green,
+ * `-` red, context dim). Reuses the SAME LCS machinery {@link mergeThreeWay}
+ * does so there is exactly one line-diff algorithm in the package.
+ *
+ * `context` (default 3) — number of unchanged lines to keep around each hunk
+ * (git-style). 0 → every non-equal line stands alone; large → whole-file blob.
+ * The resolver uses the default; tests pin to a specific shape.
+ */
+interface DiffLine {
+    type: 'eq' | 'del' | 'add';
+    line: string;
+}
+declare function lineDiff(base: string, head: string, context?: number): DiffLine[];
+/**
+ * zdiff3-style conflict markers for an unresolved overlap. Shape:
+ *   `<<<<<<< ours`
+ *   <ours lines>
+ *   `||||||| base`
+ *   <base lines>
+ *   `=======`
+ *   <theirs lines>
+ *   `>>>>>>> theirs`
+ *
+ * `diff3(zdiff3)` writes the SAME shape — included here so the engine + clack
+ * resolver have a single source of truth for marker layout. Returns the marked
+ * region body (no outer delimiters); the caller wraps it with surrounding
+ * context.
+ */
+declare function zdiff3Region(ours: readonly string[], base: readonly string[], theirs: readonly string[]): string[];
 /**
  * Three-way merge of `ours` (the user's current region) against `theirs` (the
  * new template) with `base` (the last-emitted ancestor). Line-level diff3:
  * changes in disjoint line ranges merge; overlapping changes become inline
- * conflict markers (`<<<<<<< ours` / `=======` / `>>>>>>> theirs`). Pure +
- * deterministic (no IO) so it's unit-testable.
+ * conflict markers. Default marker shape is the minimal diff3 form
+ * (`<<<<<<< ours` / `=======` / `>>>>>>> theirs`) — byte-identical to v1.2 so
+ * {@link mergeManagedRegion} stays regression-anchored. Pass `'zdiff3'` to
+ * include the base section (`||||||| base`) — used by the conflict resolver's
+ * 6th "merge (with conflict markers)" option. Pure + deterministic
+ * (no IO) so it's unit-testable.
  */
-declare function mergeThreeWay(base: string, ours: string, theirs: string): MergeResult;
+declare function mergeThreeWay(base: string, ours: string, theirs: string, style?: 'minimal' | 'zdiff3'): MergeResult;
 
 /**
  * Migration model — Nx-style declarative upgrade scripts, hand-rolled.
@@ -408,15 +447,25 @@ interface ScaffoldOptions {
     conflictPolicy?: 'overwrite' | 'preserve';
     /** SP-C: per-file conflict resolver — the UI seam (the engine stays UI-free;
      *    the cli injects a @clack-based resolver). Called when a `regenerate`
-     *    file exists and differs from the template. */
-    onConflict?: (ctx: ConflictContext) => Promise<ConflictResolution> | ConflictResolution;
-    /** SP-D follow-up: three-way merge managed regions (base/ours/theirs) using a
-     *  persisted ancestor snapshot (`.noir/ancestors.json`) instead of
-     *  strip-replace, so a hand-edit inside a `<!-- noir:* -->` region survives a
-     *  template update. Opt-in (default false ⇒ current strip-replace, no
-     *  ancestor file). Single-region managed files only (NOIR.md, ignores);
-     *  multi-region (CLAUDE.md) is a follow-up. */
+     *    file exists and differs from the template. The return type widens to
+     *    accept a rich shape carrying `applyToAll` — the engine then reuses the
+     *    decision for the rest of the run (per artifact CLASS). */
+    onConflict?: (ctx: ConflictContext) => Promise<ConflictResolverReturn> | ConflictResolverReturn;
+    /** Three-way merge managed regions (base/ours/theirs) using a persisted
+     *  ancestor snapshot (`.noir/ancestors.json`) instead of strip-replace, so a
+     *  hand-edit inside a `<!-- noir:* -->` region survives a template update.
+     *  DEFAULT TRUE: ancestor capture is unconditional, so the first merge
+     *  run always has a base. Set to `false` (CLI `--no-merge-regions`) to
+     *  restore strip-replace. Supports BOTH single-region (NOIR.md, ignores) AND
+     *  multi-region (CLAUDE.md CONTEXT+RULES) managed files — the multi-region
+     *  path shipped with SP-H (`managedBlocks` + `mergeManagedRegion` per block). */
     mergeManagedRegions?: boolean;
+    /** Explicit interactivity signal. The engine reads THIS (not
+     *  `process.env`), so a direct API/embedded caller in a TTY that does NOT
+     *  inject {@link onConflict} never hits a @clack prompt. The CLI sets it from
+     *  its global flags (via the `NOIR_NON_INTERACTIVE` bridge bin.ts owns);
+     *  `process.env` remains only a fallback bridge for the CLI layer. */
+    interactive?: boolean;
 }
 interface ScaffoldResult {
     /** Repo-relative paths actually written. */
@@ -441,6 +490,28 @@ interface ScaffoldResult {
     toVersion: string;
     /** The host actually emitted (post-default). */
     host: HostTag;
+    /** Structured conflict report — one record per file that existed AND
+     *  differed from the proposed bytes (regenerate conflict path). Populated in
+     *  `--json`/`--no-input`/non-TTY runs (no prompt fires) so a CI/JSON caller
+     *  can see exactly which files diverged + how they were resolved, without
+     *  grepping stderr. Empty when no conflicts occurred (also on first-run +
+     *  no-op). */
+    conflicts: ConflictRecord[];
+}
+/** One entry in {@link ScaffoldResult.conflicts}. */
+interface ConflictRecord {
+    /** Repo-relative path of the conflicting file. */
+    path: string;
+    /** Artifact class — drives apply-to-all memory scope + report grouping. */
+    mode: ConflictContext['mode'];
+    /** LCS similarity (0-1) between existing and proposed. */
+    similarity?: number;
+    /** sha256 (hex, first 12 chars) of the on-disk bytes at conflict time. */
+    existingSha: string;
+    /** sha256 (hex, first 12 chars) of the proposed bytes. */
+    proposedSha: string;
+    /** Resolution the engine applied (`replace`/`preserve`/`rename`/…). */
+    resolution: ConflictResolution;
 }
 /** SP-C — context passed to {@link ScaffoldOptions.onConflict} when a
  *  `regenerate` file exists and differs from the template. */
@@ -451,9 +522,29 @@ interface ConflictContext {
     existing: string;
     /** The content the scaffold would write. */
     proposed: string;
+    /** Artifact class — drives apply-to-all memory scope (`regenerate` shares
+     *  one decision across a run; `managedBlock`/`managedBlocks` stay per-file).
+     *  Defaults to `'regenerate'` for backward compatibility with SP-C resolvers
+     *  that pre-date the field (the engine always sets it). */
+    mode?: 'regenerate' | 'managedBlock' | 'managedBlocks' | 'skipIfExists' | 'skill' | 'markdown' | 'artifact';
+    /** LCS similarity (0-1) between existing and proposed. Cheap signal for
+     *  the resolver to bias toward `replace` when ~1.0 or `preserve` when ~0. */
+    similarity?: number;
+    /** When the 3-way merge of a managed region hit an overlap, the merged
+     *  bytes WITH zdiff3 conflict markers (selecting `'merge'` writes this). */
+    mergedWithMarkers?: string;
 }
 /** SP-C — how to resolve a `regenerate` conflict. */
-type ConflictResolution = 'replace' | 'preserve' | 'rename' | 'duplicate' | 'cancel';
+type ConflictResolution = 'replace' | 'preserve' | 'rename' | 'duplicate' | 'cancel' | 'merge';
+/** The resolver may return a bare {@link ConflictResolution} (scope
+ *  `'one'`) OR a rich shape carrying `applyToAll`. The engine unwraps both; when
+ *  `applyToAll` is true it stores the choice in its per-run memory keyed by
+ *  artifact CLASS (`regenerate` shares one decision across a run; managedBlock
+ *  stays per-file regardless — user edits there need individual review). */
+type ConflictResolverReturn = ConflictResolution | {
+    resolution: ConflictResolution;
+    applyToAll?: boolean;
+};
 /**
  * Refuse to scaffold when `root` is — or is inside — a `.noir/` directory.
  * (SP-A) Running `noir init`/`create`/`sync` while cwd = `.noir/` would
@@ -531,4 +622,4 @@ declare function loadTemplate(name: string): string;
 /** Resolve a template name to its absolute path (for diagnostics + tests). */
 declare function templatesDir(): string;
 
-export { BRIEF_BLOCK, type BuildHostArtifactsContext, type BuildManifestContext, CURRENT_SCAFFOLD_VERSION, type ConflictContext, type ConflictResolution, type HostTag, MANIFEST_PATH_PARITY, MIGRATIONS, type ManifestEntry, type MergeResult, type MigrationContext, type MigrationResult, type MigrationScript, type ScaffoldMode, type ScaffoldOptions, type ScaffoldResult, type StackInfo, type WriteMode, type WriteOutcome, ancestorsPath, applyInlineConflict, applyWithConflict, assertSafeRoot, buildHostArtifacts, buildManifest, buildRegion, detectStack, loadTemplate, managedBlock, mergeThreeWay, readAncestors, readScaffoldVersion, regenerate, render, runMigrations, scaffold, scaffoldVersionPath, skipIfExists, templatesDir, writeAncestors, writeScaffoldVersion };
+export { BRIEF_BLOCK, type BuildHostArtifactsContext, type BuildManifestContext, CURRENT_SCAFFOLD_VERSION, type ConflictContext, type ConflictRecord, type ConflictResolution, type ConflictResolverReturn, type DiffLine, type HostTag, MANIFEST_PATH_PARITY, MIGRATIONS, type ManifestEntry, type MergeResult, type MigrationContext, type MigrationResult, type MigrationScript, type ScaffoldMode, type ScaffoldOptions, type ScaffoldResult, type StackInfo, type WriteMode, type WriteOutcome, ancestorsPath, applyInlineConflict, applyWithConflict, assertSafeRoot, buildHostArtifacts, buildManifest, buildRegion, detectStack, lineDiff, loadTemplate, managedBlock, mergeThreeWay, readAncestors, readScaffoldVersion, regenerate, render, runMigrations, scaffold, scaffoldVersionPath, skipIfExists, templatesDir, writeAncestors, writeScaffoldVersion, zdiff3Region };

package/dist/index.js

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/ancestors.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
@@ -19,9 +26,15 @@ function readAncestors(root) {
   }
 }
 function writeAncestors(root, map) {
-  mkdirSync(dirname(ancestorsPath(root)), { recursive: true });
-  writeFileSync(ancestorsPath(root), `${JSON.stringify(map, null, 2)}
-`, "utf8");
+  const path = ancestorsPath(root);
+  const next = `${JSON.stringify(map, null, 2)}
+`;
+  try {
+    if (readFileSync(path, "utf8") === next) return;
+  } catch {
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, next, "utf8");
 }
 
 // src/manifest.ts
@@ -253,8 +266,71 @@ function lcsMatch(a, b) {
   }
   return out;
 }
+function lineDiff(base, head, context = 3) {
+  const A = base.split("\n");
+  const B = head.split("\n");
+  const pairs = lcsMatch(A, B);
+  const inA = new Set(pairs.map((p) => p[0]));
+  const inB = new Set(pairs.map((p) => p[1]));
+  const out = [];
+  let i = 0;
+  let j = 0;
+  const bToH = /* @__PURE__ */ new Map();
+  for (const [bi, hi] of pairs) bToH.set(bi, hi);
+  while (i < A.length || j < B.length) {
+    const matched = bToH.get(i);
+    if (matched !== void 0 && matched === j) {
+      out.push({ type: "eq", line: A[i] ?? "" });
+      i++;
+      j++;
+    } else if (matched !== void 0) {
+      out.push({ type: "add", line: B[j] ?? "" });
+      j++;
+    } else if (i < A.length && !inA.has(i)) {
+      out.push({ type: "del", line: A[i] ?? "" });
+      i++;
+    } else if (j < B.length && !inB.has(j)) {
+      out.push({ type: "add", line: B[j] ?? "" });
+      j++;
+    } else {
+      if (i < A.length) i++;
+      else j++;
+    }
+  }
+  return context > 0 ? collapseContext(out, context) : out;
+}
+function collapseContext(lines, context) {
+  const out = [];
+  const keep = new Array(lines.length).fill(false);
+  for (let i = 0; i < lines.length; i++) {
+    const dl = lines[i];
+    if (dl && dl.type !== "eq") {
+      for (let k = Math.max(0, i - context); k <= Math.min(lines.length - 1, i + context); k++) {
+        keep[k] = true;
+      }
+    }
+  }
+  let inRun = false;
+  for (let i = 0; i < lines.length; i++) {
+    const dl = lines[i];
+    if (!dl) continue;
+    if (keep[i]) {
+      out.push(dl);
+      inRun = false;
+    } else {
+      if (!inRun) {
+        out.push({ type: "eq", line: "\u2026" });
+        inRun = true;
+      }
+    }
+  }
+  return out;
+}
+function zdiff3Region(ours, base, theirs) {
+  return ["<<<<<<< ours", ...ours, "||||||| base", ...base, "=======", ...theirs, ">>>>>>> theirs"];
+}
 var eq = (a, b) => a.length === b.length && a.every((v, k) => v === b[k]);
-function mergeThreeWay(base, ours, theirs) {
+function mergeThreeWay(base, ours, theirs, style = "minimal") {
   const t = trivial(base, ours, theirs);
   if (t) return t;
   const B = base.split("\n");
@@ -287,7 +363,11 @@ function mergeThreeWay(base, ours, theirs) {
     else if (eq(oSeg, tSeg)) out.push(...oSeg);
     else {
       conflict = true;
-      out.push("<<<<<<< ours", ...oSeg, "=======", ...tSeg, ">>>>>>> theirs");
+      if (style === "zdiff3") {
+        out.push(...zdiff3Region(oSeg, baseSeg, tSeg));
+      } else {
+        out.push("<<<<<<< ours", ...oSeg, "=======", ...tSeg, ">>>>>>> theirs");
+      }
     }
     if (bBase < B.length) out.push(B[bBase] ?? "");
   }
@@ -458,6 +538,30 @@ ${body.trimEnd()}
 ${block.end}
 `;
 }
+function predictManagedBlock(currentContent, block, regionText) {
+  const stripped = stripManagedBlock(currentContent, block);
+  return stripped ? `${stripped.trimEnd()}
+
+${regionText}` : regionText;
+}
+function predictManagedBlocks(currentContent, regions) {
+  if (regions.length === 0) {
+    throw new Error("predictManagedBlocks requires at least one region");
+  }
+  if (regions.length === 1) {
+    const only = regions[0];
+    if (!only) throw new Error("predictManagedBlocks: undefined region");
+    return predictManagedBlock(currentContent, only.block, only.regionText);
+  }
+  let stripped = currentContent;
+  for (const r of regions) {
+    stripped = stripManagedBlock(stripped, r.block);
+  }
+  const regionsJoined = regions.map((r) => r.regionText).join("\n");
+  return stripped.trim().length > 0 ? `${stripped.trimEnd()}
+
+${regionsJoined}` : regionsJoined;
+}
 function skipIfExists(absPath, content) {
   if (existsSync4(absPath)) {
     return { path: absPath, mode: "skipIfExists", written: false };
@@ -684,11 +788,14 @@ async function scaffold(opts) {
   }
   const fromVersion = readScaffoldVersion(opts.root);
   const stack = detectStack(opts.root);
-  const ancestors = opts.mergeManagedRegions ? readAncestors(opts.root) : {};
-  if (fromVersion !== null && opts.upgrade !== true && opts.force !== true && (opts.mode === "init" || opts.mode === "create")) {
+  const ancestors = readAncestors(opts.root);
+  const mergeManagedRegions = opts.mergeManagedRegions !== false;
+  const hasIdentity = fromVersion !== null || idFile.state === "valid";
+  if (hasIdentity && opts.upgrade !== true && opts.force !== true && (opts.mode === "init" || opts.mode === "create")) {
     if (opts.dryRun !== true) {
+      const where = fromVersion !== null ? `at scaffold ${fromVersion}` : "(pre-1.3.0 project; no scaffold-version stamp)";
       process.stderr.write(
-        `Noir is already initialized in ${opts.root} (scaffold ${fromVersion}). No-op. Use \`noir init --upgrade\` to migrate, or \`--force\` to re-scaffold.
+        `Noir already initialized in ${opts.root} ${where}; run \`noir init --upgrade\` to migrate.
 `
       );
     }
@@ -696,6 +803,7 @@ async function scaffold(opts) {
       written: [],
       skipped: [],
       identical: [],
+      conflicts: [],
       noop: true,
       migrationsRan: [],
       migrationConflicts: [],
@@ -734,6 +842,18 @@ async function scaffold(opts) {
   const written = [];
   const skipped = [];
   const identical = [];
+  const conflictMemory = /* @__PURE__ */ new Map();
+  const conflictRecords = [];
+  const recordConflict = (relPath, mode, existing, proposed, resolution, similarity2) => {
+    conflictRecords.push({
+      path: relPath,
+      mode,
+      similarity: similarity2,
+      existingSha: sha256Hex12(existing),
+      proposedSha: sha256Hex12(proposed),
+      resolution
+    });
+  };
   const groups = groupApplicableByPath(manifest, host, emitRuntimeOnly);
   for (const [relPath, entries] of groups) {
     const abs = join8(opts.root, relPath);
@@ -744,18 +864,44 @@ async function scaffold(opts) {
         continue;
       }
       mkdirSync3(dirname5(abs), { recursive: true });
+      const onDisk = readOptional(abs);
+      let hadMergeConflict = false;
       const regions = managed.map((e) => {
         const block = e.block;
         if (!block) {
           throw new Error(`manifest entry ${e.path}: managedBlock mode missing 'block'`);
         }
         const theirs = buildRegion(block, renderEntry(e, vars));
-        const regionText = opts.mergeManagedRegions ? mergeManagedRegion(abs, e.path, block, theirs, ancestors) : theirs;
-        if (opts.mergeManagedRegions) ancestors[`${e.path}::${block.begin}`] = theirs;
-        return { block, regionText };
+        const merged = mergeManagedRegions ? mergeManagedRegion(abs, e.path, block, theirs, ancestors) : { text: theirs, conflict: false, cleanTheirs: theirs };
+        if (merged.conflict) hadMergeConflict = true;
+        ancestors[`${e.path}::${block.begin}`] = theirs;
+        return { block, regionText: merged.text };
       });
-      managedBlocks(abs, regions);
-      written.push(relPath);
+      if (hadMergeConflict) {
+        const ctxMode = "managedBlocks";
+        const resolution = await resolveManagedConflict(relPath, ctxMode, opts);
+        if (resolution === "cancel") {
+          throw new Error(`scaffold cancelled by user at conflicting file ${relPath}`);
+        }
+        if (resolution !== void 0 && resolution !== "merge") {
+          process.stderr.write(
+            `noir: managed-region conflict in ${relPath} \u2014 wrote inline markers; resolve manually.
+`
+          );
+        } else {
+          process.stderr.write(
+            `noir: managed-region conflict in ${relPath} \u2014 wrote inline markers; resolve manually.
+`
+          );
+        }
+      }
+      const predicted = predictManagedBlocks(onDisk ?? "", regions);
+      if (onDisk !== void 0 && predicted === onDisk) {
+        identical.push(relPath);
+      } else {
+        managedBlocks(abs, regions);
+        written.push(relPath);
+      }
       continue;
     }
     if (!opts.dryRun) mkdirSync3(dirname5(abs), { recursive: true });
@@ -767,7 +913,10 @@ async function scaffold(opts) {
       }
       const body = renderEntry(entry, vars);
       if (entry.mode === "regenerate") {
-        const out = await writeRegenerateWithConflict(abs, entry.path, body, opts);
+        const out = await writeRegenerateWithConflict(abs, entry.path, body, opts, {
+          memory: conflictMemory,
+          record: recordConflict
+        });
         written.push(...out.written);
         skipped.push(...out.skipped);
         identical.push(...out.identical);
@@ -778,10 +927,41 @@ async function scaffold(opts) {
         }
         if (isNoirMdPath(entry.path)) healLegacyNoirMd(abs);
         const theirs = buildRegion(block, body);
-        const regionText = opts.mergeManagedRegions ? mergeManagedRegion(abs, entry.path, block, theirs, ancestors) : theirs;
-        managedBlock2(abs, block, regionText);
-        if (opts.mergeManagedRegions) ancestors[`${entry.path}::${block.begin}`] = theirs;
-        written.push(entry.path);
+        const merged = mergeManagedRegions ? mergeManagedRegion(abs, entry.path, block, theirs, ancestors) : { text: theirs, conflict: false, cleanTheirs: theirs };
+        const regionText = merged.text;
+        ancestors[`${entry.path}::${block.begin}`] = theirs;
+        if (merged.conflict) {
+          const ctxMode = "managedBlock";
+          const onDiskRegion = readOptional(abs);
+          const ctx = {
+            relPath: entry.path,
+            existing: onDiskRegion ?? "",
+            proposed: theirs,
+            mode: ctxMode,
+            similarity: similarity(onDiskRegion ?? "", merged.text),
+            mergedWithMarkers: merged.text
+          };
+          const resolution = await resolveManagedConflictCtx(ctx, opts);
+          if (resolution === "cancel") {
+            throw new Error(`scaffold cancelled by user at conflicting file ${entry.path}`);
+          }
+          if (resolution === "preserve") {
+            identical.push(entry.path);
+            continue;
+          }
+          process.stderr.write(
+            `noir: managed-region conflict in ${entry.path} \u2014 wrote inline markers; resolve manually.
+`
+          );
+        }
+        const onDisk = readOptional(abs);
+        const predicted = predictManagedBlock(onDisk ?? "", block, regionText);
+        if (onDisk !== void 0 && predicted === onDisk) {
+          identical.push(entry.path);
+        } else {
+          managedBlock2(abs, block, regionText);
+          written.push(entry.path);
+        }
       } else {
         const out = skipIfExists(abs, body);
         if (out.written) written.push(entry.path);
@@ -792,13 +972,14 @@ async function scaffold(opts) {
   if ((opts.mode === "init" || opts.mode === "create") && !opts.dryRun) {
     writeScaffoldVersion(opts.root, CURRENT_SCAFFOLD_VERSION);
   }
-  if (opts.mergeManagedRegions && !opts.dryRun) {
+  if (!opts.dryRun) {
     writeAncestors(opts.root, ancestors);
   }
   return {
     written,
     skipped,
     identical,
+    conflicts: conflictRecords,
     noop: false,
     migrationsRan,
     migrationConflicts,
@@ -809,19 +990,57 @@ async function scaffold(opts) {
     host
   };
 }
+function sha256Hex12(s) {
+  const { createHash } = __require("crypto");
+  return createHash("sha256").update(s, "utf8").digest("hex").slice(0, 12);
+}
+function similarity(a, b) {
+  if (a === b) return 1;
+  const A = a.split("\n");
+  const B = b.split("\n");
+  if (A.length === 0 && B.length === 0) return 1;
+  const n = A.length;
+  const m = B.length;
+  const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+  for (let i = n - 1; i >= 0; i--) {
+    const dpi = dp[i] ?? [];
+    const dpi1 = dp[i + 1] ?? [];
+    const ai = A[i] ?? "";
+    for (let j = m - 1; j >= 0; j--) {
+      const bj = B[j] ?? "";
+      dpi[j] = ai === bj ? (dpi1[j + 1] ?? 0) + 1 : Math.max(dpi1[j] ?? 0, dpi[j + 1] ?? 0);
+    }
+  }
+  const lcs = dp[0]?.[0] ?? 0;
+  return n + m === 0 ? 1 : 2 * lcs / (n + m);
+}
 function mergeManagedRegion(abs, relPath, block, theirs, ancestors) {
   const base = ancestors[`${relPath}::${block.begin}`];
-  if (base === void 0) return theirs;
+  if (base === void 0) return { text: theirs, conflict: false, cleanTheirs: theirs };
   const ours = readManagedBlock(abs, block);
-  if (ours === null) return theirs;
-  const res = mergeThreeWay(base, ours, theirs);
-  if (res.conflict) {
-    process.stderr.write(
-      `noir: managed-region conflict in ${relPath} \u2014 wrote inline markers; resolve manually.
-`
-    );
+  if (ours === null) return { text: theirs, conflict: false, cleanTheirs: theirs };
+  const oursNormalized = ours.endsWith("\n") ? ours : `${ours}
+`;
+  const res = mergeThreeWay(base, oursNormalized, theirs, "zdiff3");
+  return { text: res.merged, conflict: res.conflict, cleanTheirs: theirs };
+}
+async function resolveManagedConflictCtx(ctx, opts) {
+  if (opts.onConflict === void 0) return void 0;
+  const ret = await opts.onConflict(ctx);
+  const resolution = typeof ret === "string" ? ret : ret.resolution;
+  if (resolution === "rename" || resolution === "duplicate") {
+    return "merge";
+  }
+  if (resolution === "replace") {
+    return "replace";
   }
-  return res.merged;
+  return resolution;
+}
+async function resolveManagedConflict(relPath, mode, opts) {
+  if (opts.onConflict === void 0) return void 0;
+  const ret = await opts.onConflict({ relPath, existing: "", proposed: "", mode });
+  const resolution = typeof ret === "string" ? ret : ret.resolution;
+  return resolution;
 }
 function readProjectIdFile(root) {
   let raw;
@@ -841,7 +1060,7 @@ function resolveProjectId(opts, idFile) {
   }
   return createProjectId();
 }
-async function writeRegenerateWithConflict(abs, relPath, proposed, opts) {
+async function writeRegenerateWithConflict(abs, relPath, proposed, opts, internals) {
   let existing;
   try {
     existing = readFileSync7(abs, "utf8");
@@ -855,11 +1074,31 @@ async function writeRegenerateWithConflict(abs, relPath, proposed, opts) {
   if (existing === proposed) {
     return { written: [], skipped: [], identical: [relPath] };
   }
-  const resolution = opts.onConflict !== void 0 ? await opts.onConflict({ relPath, existing, proposed }) : opts.conflictPolicy === "preserve" ? "preserve" : "replace";
+  const MODE = "regenerate";
+  const sim = similarity(existing, proposed);
+  let resolution;
+  const remembered = internals.memory.get(MODE);
+  if (remembered !== void 0) {
+    resolution = remembered;
+  } else if (opts.onConflict !== void 0) {
+    const ret = await opts.onConflict({ relPath, existing, proposed, mode: MODE, similarity: sim });
+    const unwrapped = typeof ret === "string" ? ret : ret.resolution;
+    if (typeof ret !== "string" && ret.applyToAll === true) {
+      internals.memory.set(MODE, unwrapped);
+    }
+    resolution = unwrapped;
+  } else {
+    resolution = opts.conflictPolicy === "preserve" ? "preserve" : "replace";
+  }
+  internals.record(relPath, MODE, existing, proposed, resolution, sim);
   switch (resolution) {
     case "replace":
       regenerate(abs, proposed);
       return { written: [relPath], skipped: [], identical: [] };
+    case "merge": {
+      regenerate(abs, proposed);
+      return { written: [relPath], skipped: [], identical: [] };
+    }
     case "rename": {
       const aside = uniqueAside(abs, relPath, ".local");
       renameSync2(abs, aside.abs);
@@ -919,6 +1158,16 @@ function renderEntry(entry, vars) {
   if (entry.content !== void 0) return entry.content;
   throw new Error(`manifest entry ${entry.path}: must define 'content' or 'template'`);
 }
+function readOptional(absPath) {
+  try {
+    return readFileSync7(absPath, "utf8");
+  } catch (err) {
+    if (err instanceof Error && err.code === "ENOENT") {
+      return void 0;
+    }
+    throw err;
+  }
+}
 export {
   BRIEF_BLOCK,
   CURRENT_SCAFFOLD_VERSION,
@@ -932,6 +1181,7 @@ export {
   buildManifest,
   buildRegion,
   detectStack,
+  lineDiff,
   loadTemplate,
   managedBlock2 as managedBlock,
   mergeThreeWay,
@@ -945,6 +1195,7 @@ export {
   skipIfExists,
   templatesDir,
   writeAncestors,
-  writeScaffoldVersion
+  writeScaffoldVersion,
+  zdiff3Region
 };
 //# sourceMappingURL=index.js.map