@@ -579,7 +579,9 @@ Implementation is not accepted on benchmark evidence alone. Required automated c
   created in the target's own directory and published via a single exclusive `linkSync`
   (create-if-absent, first writer wins); and a no-clobber test proving publication refuses ANY
   pre-existing target — complete or partial alike, byte-for-byte unchanged — for both the default healed
-  sibling and an explicit `--save-script=<path>`.
+  sibling and an explicit `--save-script=<path>`, **and for an ordinary (non-repair) `open`/`close
+  --save-script` recording whose target already exists** — the writer entry point and publish primitive
+  are shared, so the refusal is uniform, not repair-only (see "Scope" below).
 
 Extend the settle benchmark (`~/.agent-device-bench/rnnav-matrix.py` pattern, external harness) with a
 replay arm only after these contracts pass: measure clean replay and one induced divergence repaired
@@ -809,6 +811,20 @@ a complete, review-worthy repair artifact for any other reader — but it no lon
 publish decision. Auto-versioned output names (e.g. `.healed.2.ad`) are explicitly **out of scope** here —
 a separate naming change, not part of this decision.
 
+**Scope: this refusal is uniform across repair AND ordinary recording, not repair-only.** Everything
+above is written in the context of decision 6's repair-armed heal, but `publishHealedScriptAtomically`
+(`src/daemon/session-script-writer.ts`) is the single publish primitive `SessionScriptWriter.write` calls
+for every `--save-script` target, with no repair-armed-vs-ordinary branch — a repair-armed heal
+(`saveScriptBoundary` set) and an ordinary, non-repair `open --save-script`/`close --save-script`
+recording (`saveScriptBoundary` absent) publish through the exact same exclusive `linkSync`. Before this
+decision, ordinary recording published via a separate atomic rename-replace path
+(`publishOverwriteAtomically`, since removed), silently overwriting an existing target; that overwrite
+path is gone. An ordinary recording whose target already exists is now refused exactly like a healed
+repair publish would be: `EEXIST` surfaces as the same `AppError`, the existing file is left
+byte-for-byte unchanged, and the caller must remove it or choose a different `--save-script=<path>`.
+There is no `--force`/`--overwrite` escape hatch for either path today; that is tracked as a future
+follow-up (#1258), not part of this decision.
+
 **Repair-session tombstone (R7 ownership).** When a bounded-expiry escape hatch idle-reaps (or a daemon
 shutdown tears down) a repair-armed transaction that has **not** reached `COMPLETE`, the teardown aborts
 (no publish, per the state machine) and must leave a **tombstone** rather than deleting the session record
@@ -929,7 +945,9 @@ each states its dependencies explicitly.
    `REPAIR_SESSION_EXPIRED` tombstone for an incomplete-transaction reap/shutdown (keyed by session key,
    owner + bounded expiry, cleared by a fresh `replay --save-script`); and race-safe atomic publication
    (temp file in the target's own directory, published via a single exclusive `linkSync` that refuses ANY
-   pre-existing target — complete or partial, default or explicit path alike — never overwriting one).
+   pre-existing target — complete or partial, default or explicit path alike, and uniformly for an
+   ordinary non-repair recording's target too, since the publish primitive is shared — never overwriting
+   one; see "Scope" under Decision 6 above).
 
 ## Migration progress
 
 
@@ -410,6 +410,69 @@ test('write() now refuses an explicit --save-script=<path> pointing at an existi
   expect(fs.readFileSync(outPath, 'utf8')).toBe(before);
 });
 
+// (e) the refuse-on-exist publish primitive is shared with ORDINARY
+// (non-repair) recording too — no `saveScriptBoundary` at all, i.e. a plain
+// `open --save-script`/`close --save-script` session, never `replay
+// --save-script`. Before the maintainer-approved uniform simplification,
+// this path published via a separate atomic rename-replace and silently
+// overwrote an existing target; that overwrite path is gone (see the ADR's
+// "Scope" note under decision 6). This is the coverage gap the reviewer
+// flagged on #1235: only repair-armed (`saveScriptBoundary` set, even to 0)
+// sessions were exercised above.
+test('an ordinary (non-repair) recording now refuses an existing target too (behavior change: no more rename-replace overwrite)', () => {
+  const root = fs.mkdtempSync(
+    path.join(os.tmpdir(), 'agent-device-script-writer-ordinary-clobber-'),
+  );
+  const writer = new SessionScriptWriter(path.join(root, 'sessions'));
+  const outPath = path.join(root, 'flows', 'existing.ad');
+  fs.mkdirSync(path.dirname(outPath), { recursive: true });
+  fs.writeFileSync(outPath, 'context platform=ios device="x"\nclick id="old"\n');
+  const before = fs.readFileSync(outPath, 'utf8');
+
+  const session = makeIosSession('default', {
+    recordSession: true,
+    // No saveScriptBoundary: an ordinary open/close --save-script recording,
+    // never armed via `replay --save-script` — this is NOT a repair.
+    saveScriptPath: outPath,
+    actions: [action({ command: 'click', positionals: ['id="new"'] })],
+  });
+
+  // Unlike a repair-armed write (which returns `{written:false, error}`), an
+  // ordinary (non-repair-armed) write's catch block RETHROWS an AppError
+  // (`write()`: `if (repairArmed) return {...}; if (error instanceof
+  // AppError) throw error;`) — so refusal here surfaces as a thrown error,
+  // not a returned result.
+  expect(() => writer.write(session)).toThrow(/already exists/);
+  // The pre-existing target is left byte-for-byte unchanged — refused, not
+  // clobbered.
+  expect(fs.readFileSync(outPath, 'utf8')).toBe(before);
+});
+
+// (f) confirm the absent-target case still succeeds for ordinary recording —
+// the refusal is scoped to an EXISTING target, not a blanket block.
+test('an ordinary (non-repair) recording still publishes cleanly when its target does not exist yet', () => {
+  const root = fs.mkdtempSync(
+    path.join(os.tmpdir(), 'agent-device-script-writer-ordinary-absent-'),
+  );
+  const writer = new SessionScriptWriter(path.join(root, 'sessions'));
+  const outPath = path.join(root, 'flows', 'fresh.ad');
+
+  const session = makeIosSession('default', {
+    recordSession: true,
+    // No saveScriptBoundary: ordinary recording, not a repair.
+    saveScriptPath: outPath,
+    actions: [action({ command: 'click', positionals: ['id="new"'] })],
+  });
+
+  const result = writer.write(session);
+  expect(result.written).toBe(true);
+  expect(result.written && result.path).toBe(outPath);
+  const parsed = parseReplayScriptDetailed(fs.readFileSync(outPath, 'utf8'));
+  expect(parsed.actions.map((a) => a.positionals[0])).toEqual(['id="new"']);
+  // Ordinary recording never carries the repair-only completeness sentinel.
+  expect(fs.readFileSync(outPath, 'utf8')).not.toContain(HEAL_COMPLETE_SENTINEL);
+});
+
 test('close --save-script=<explicit path> clears the defaulted marker, and a write to that (absent) explicit path succeeds', () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-script-writer-close-explicit-'));
   const writer = new SessionScriptWriter(path.join(root, 'sessions'));
 
@@ -548,9 +548,13 @@ function armReplaySaveScriptStep(params: {
   if (!session) return;
   session.recordSession = true;
   if (typeof saveScript === 'string') {
-    // An EXPLICIT `--save-script=<path>` clears the defaulted marker so the
-    // clobber guard never refuses a path the caller directed (invariant: the
-    // marker is set iff the current `saveScriptPath` was defaulted).
+    // An EXPLICIT `--save-script=<path>` clears the defaulted marker
+    // (invariant: the marker is set iff the current `saveScriptPath` was
+    // defaulted, not caller-directed). This no longer affects the publish
+    // decision either way — the writer's refuse-on-exist guard is uniform
+    // (`publishHealedScriptAtomically`) and refuses ANY pre-existing target,
+    // an explicit caller-directed path included, exactly like the default
+    // healed sibling.
     session.saveScriptPath = expandSessionPath(saveScript);
     session.saveScriptDefaultedHealedPath = false;
   } else if (session.saveScriptPath === undefined) {
 
@@ -23,8 +23,12 @@ export function recordActionEntry(
     session.recordSession = true;
     if (typeof entry.flags.saveScript === 'string') {
       // ADR 0012 decision 6: an explicit `--save-script=<path>` (e.g. `close
-      // --save-script=<path>`) clears the defaulted-healed marker so the
-      // writer's clobber guard never refuses an overwrite the caller directed.
+      // --save-script=<path>`) clears the defaulted-healed marker, since this
+      // path was no longer defaulted to the healed sibling. This marker plays
+      // no role in the publish decision itself: the writer's refuse-on-exist
+      // guard is uniform (see `publishHealedScriptAtomically`) and refuses
+      // ANY pre-existing target — an explicit, caller-DIRECTED path included.
+      // Directing the path is not the same as authorizing an overwrite.
       session.saveScriptPath = expandSessionPath(entry.flags.saveScript);
       session.saveScriptDefaultedHealedPath = false;
     }
 
@@ -55,7 +55,12 @@ export const HEAL_COMPLETE_SENTINEL = '# agent-device:heal-complete';
  *   after a divergence but before the plan finishes from committing a PREFIX;
  *   every non-completion teardown (divergence-only exit, daemon shutdown,
  *   idle-reap) lands here too.
- * Ordinary (non-repair) recording is never blocked (no `saveScriptBoundary`).
+ * Ordinary (non-repair) recording is never blocked here (no `saveScriptBoundary`) —
+ * this gate only decides whether `write()` attempts a publish AT ALL. It says
+ * nothing about what happens once it does: `publishHealedScriptAtomically`'s
+ * refuse-on-exist applies to that attempted publish uniformly, repair-armed or
+ * not (see its doc comment) — ordinary recording is never blocked from trying,
+ * but it can still be refused if the target already exists.
  */
 function isRepairArmedWriteBlocked(session: SessionState): boolean {
   if (session.saveScriptBoundary === undefined) return false;
@@ -98,9 +103,16 @@ export class SessionScriptWriter {
       // SURFACED (no-clobber refusal, bare-`@ref`, or a filesystem error alike)
       // so close/teardown can report it and keep the session for retry — never
       // swallowed into a silent `{written:false}`. Ordinary (non-repair)
-      // recording keeps its existing behavior: an unexpected AppError still
-      // fails loud (none is raised on that path today), an fs error is a quiet
-      // skip.
+      // recording keeps its existing SHAPE of behavior: an AppError still
+      // fails loud (thrown, not swallowed into `{written:false}`) and any other
+      // fs error is a quiet skip — but an AppError is no longer only
+      // theoretical here. Since `publishHealedScriptAtomically` refuses ANY
+      // pre-existing target uniformly (maintainer-approved: refuse-on-exist
+      // applies to ordinary recording too, not just repair heals), an ordinary
+      // `open`/`close --save-script` write against an existing target now
+      // throws that same no-clobber AppError, surfacing here as a genuine
+      // "fails loud" case rather than the "none is raised on that path" it was
+      // before that change.
       if (repairArmed) {
         return { written: false, error: toRepairCommitFailure(error, scriptPath) };
       }
@@ -149,6 +161,15 @@ function formatSessionScript(session: SessionState, appendCompleteSentinel: bool
  * target — complete or partial, the default healed sibling or an explicit
  * `--save-script=<path>` alike.
  *
+ * This is `write()`'s ONLY publish primitive, called unconditionally for
+ * every target — a repair-armed heal AND an ordinary, non-repair
+ * `open`/`close --save-script` recording alike. There is no
+ * repair-armed-vs-ordinary branch here (an earlier design had one —
+ * `publishOverwriteAtomically`, rename-replace for ordinary writes — since
+ * removed): an ordinary recording's target is refused exactly like a healed
+ * repair's, never silently overwritten. `--force`/`--overwrite` is a future
+ * escape hatch (#1258), not implemented today.
+ *
  * The temp file is created in the SAME DIRECTORY as the target (never
  * `/tmp`), so the publish itself is a single intra-directory `linkSync`:
  * atomic create-exclusive, first writer wins. That single primitive is
 
@@ -282,9 +282,12 @@ export type SessionState = {
   /**
    * ADR 0012 decision 6: set when `saveScriptPath` was DEFAULTED to the
    * `<original-stem>.healed.ad` sibling (no explicit `--save-script=<out>`).
-   * The writer refuses to clobber an existing default healed script, so a
-   * second repair against the same original never destroys an unreviewed
-   * prior `.healed.ad` diff.
+   * Bookkeeping only — it does not gate the writer's refuse-on-exist
+   * decision, which is uniform regardless of this flag (see
+   * `publishHealedScriptAtomically`): a second repair against the same
+   * original is refused at the default healed sibling exactly like an
+   * explicit `--save-script=<path>` or an ordinary recording's target would
+   * be, never destroying an unreviewed prior `.healed.ad` diff.
    */
   saveScriptDefaultedHealedPath?: boolean;
   /**