quiver-cli 1.3.1 → 2.0.0

package/template/.agents/skills/design/impeccable/scripts/live-commit-manual-edits.mjs

@@ -1,1200 +0,0 @@
-#!/usr/bin/env node
-/**
- * CLI helper: apply pending live copy edits as one AI-owned batch.
- *
- * The browser Save path stages copy edits in .impeccable/live. This script is
- * called by /manual-edit-commit when the user clicks Apply copy edits. It gives
- * the local AI runner the full staged batch plus evidence, validates the files
- * the runner reports touching, and clears only entries reported as applied.
- *
- * Usage:
- *   node live-commit-manual-edits.mjs
- *   node live-commit-manual-edits.mjs --page-url=/
- *
- * Output JSON:
- *   { applied, failed, files, cleared, count, pageUrl }
- */
-
-import { buildManualEditEvidence } from './live-manual-edit-evidence.mjs';
-import { readBuffer, readBufferStrict, writeBuffer, countByPage } from './live/manual-edits-buffer.mjs';
-import { isGeneratedFile } from './lib/is-generated.mjs';
-import {
-  runCopyEditBatchAgent,
-  runCopyEditPostApplyChecks,
-} from './live-copy-edit-agent.mjs';
-import fs from 'node:fs';
-import path from 'node:path';
-
-const ROLLBACK_EXTENSIONS = new Set([
-  '.astro',
-  '.cjs',
-  '.css',
-  '.eex',
-  '.ex',
-  '.heex',
-  '.htm',
-  '.html',
-  '.js',
-  '.json',
-  '.jsx',
-  '.md',
-  '.mdx',
-  '.mjs',
-  '.scss',
-  '.svelte',
-  '.svg',
-  '.ts',
-  '.tsx',
-  '.txt',
-  '.vue',
-  '.yaml',
-  '.yml',
-]);
-const ROLLBACK_SKIP_DIRS = new Set([
-  '.astro',
-  '.git',
-  '.impeccable',
-  '.next',
-  '.nuxt',
-  '.svelte-kit',
-  'build',
-  'coverage',
-  'dist',
-  'node_modules',
-  'out',
-]);
-const DEFAULT_REPAIR_ATTEMPTS = 3;
-
-function argVal(args, name) {
-  const prefix = name + '=';
-  for (const arg of args) {
-    if (arg === name) return true;
-    if (arg.startsWith(prefix)) return arg.slice(prefix.length);
-  }
-  return null;
-}
-
-function countOps(entries) {
-  let count = 0;
-  for (const entry of entries || []) count += Array.isArray(entry.ops) ? entry.ops.length : 0;
-  return count;
-}
-
-function summarizeAppliedEntries(entries, appliedEntryIds) {
-  const ids = new Set(appliedEntryIds);
-  const out = [];
-  for (const entry of entries || []) {
-    if (!ids.has(entry.id)) continue;
-    for (const op of entry.ops || []) {
-      out.push({
-        id: entry.id,
-        ref: op.ref,
-        originalText: op.originalText,
-        newText: op.newText,
-      });
-    }
-  }
-  return out;
-}
-
-function normalizeFailedEntries(batch, result, fallbackReason) {
-  const failed = [];
-  const failedByEntryId = new Map();
-  for (const item of result?.failed || []) {
-    const entryId = item.entryId || item.id || null;
-    if (!entryId) continue;
-    failedByEntryId.set(entryId, item);
-  }
-
-  for (const entry of batch.entries || []) {
-    const item = failedByEntryId.get(entry.id);
-    if (!item) continue;
-    failed.push({
-      id: entry.id,
-      reason: item.reason || item.message || fallbackReason || 'failed',
-      candidates: Array.isArray(item.candidates) && item.candidates.length > 0
-        ? item.candidates
-        : candidatesForEntry(batch, entry.id),
-    });
-  }
-  return failed;
-}
-
-function mergeFailedEntries(...groups) {
-  const out = [];
-  const indexById = new Map();
-  for (const item of groups.flatMap((group) => Array.isArray(group) ? group : [])) {
-    if (!item || typeof item !== 'object') continue;
-    const id = typeof item.id === 'string' && item.id ? item.id : null;
-    if (!id) {
-      out.push(item);
-      continue;
-    }
-    const existingIndex = indexById.get(id);
-    if (existingIndex === undefined) {
-      indexById.set(id, out.length);
-      out.push(item);
-      continue;
-    }
-    out[existingIndex] = {
-      ...out[existingIndex],
-      ...item,
-      candidates: item.candidates || out[existingIndex].candidates,
-      checks: item.checks || out[existingIndex].checks,
-    };
-  }
-  return out;
-}
-
-function candidatesForEntry(batch, entryId) {
-  return (batch.candidates || [])
-    .filter((candidate) => candidate.entryId === entryId)
-    .flatMap((candidate) => [
-      ...(candidate.sourceHint ? [candidate.sourceHint] : []),
-      ...(candidate.textMatches || []),
-      ...(candidate.objectKeyMatches || []),
-      ...(candidate.locatorMatches || []),
-      ...(candidate.contextTextMatches || []),
-    ])
-    .slice(0, 12);
-}
-
-function uniqueStrings(values) {
-  return [...new Set(values.filter((value) => typeof value === 'string' && value.trim()))];
-}
-
-function allEntryIds(batch) {
-  return (batch?.entries || []).map((entry) => entry.id).filter(Boolean);
-}
-
-function mergeUniqueStrings(...groups) {
-  return uniqueStrings(groups.flatMap((group) => Array.isArray(group) ? group : []));
-}
-
-function repairAttemptLimit(env = process.env) {
-  const value = Number(env.IMPECCABLE_LIVE_MANUAL_EDIT_REPAIR_ATTEMPTS || DEFAULT_REPAIR_ATTEMPTS);
-  if (!Number.isFinite(value)) return DEFAULT_REPAIR_ATTEMPTS;
-  return Math.max(1, Math.min(10, Math.trunc(value)));
-}
-
-function summarizeRepairFailures(failures = []) {
-  return failures.map((failure) => {
-    const out = {
-      reason: failure.reason || failure.detail || 'validation_failed',
-    };
-    if (failure.id || failure.entryId) out.entryId = failure.id || failure.entryId;
-    if (failure.ref) out.ref = failure.ref;
-    if (failure.detail) out.detail = failure.detail;
-    if (failure.file) out.file = failure.file;
-    if (failure.message) out.message = failure.message;
-    if (failure.marker) out.marker = failure.marker;
-    if (Array.isArray(failure.files)) out.files = failure.files.slice(0, 8);
-    if (Array.isArray(failure.candidates)) {
-      out.candidates = failure.candidates.slice(0, 8).map((candidate) => ({
-        file: candidate.file,
-        line: candidate.line,
-        kind: candidate.kind,
-        reason: candidate.reason,
-      }));
-    }
-    if (Array.isArray(failure.failures)) {
-      out.failures = failure.failures.slice(0, 8).map((item) => ({
-        ref: item.ref,
-        reason: item.reason || item.detail,
-        detail: item.detail,
-        candidates: Array.isArray(item.candidates)
-          ? item.candidates.slice(0, 6).map((candidate) => ({
-              file: candidate.file,
-              line: candidate.line,
-              kind: candidate.kind,
-              reason: candidate.reason,
-            }))
-          : undefined,
-      }));
-    }
-    if (failure.checks) out.checks = failure.checks;
-    return out;
-  }).slice(0, 20);
-}
-
-function buildRepairBatch(batch, repair) {
-  return {
-    ...batch,
-    repair,
-  };
-}
-
-function normalizeProjectSourcePath(cwd, file, opts = {}) {
-  if (!file || typeof file !== 'string') return null;
-  const absolute = path.isAbsolute(file) ? file : path.resolve(cwd, file);
-  const relative = path.relative(cwd, absolute);
-  if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) return null;
-  if (opts.requireExists && !fs.existsSync(absolute)) return null;
-  if (isGeneratedFile(absolute, { cwd })) return null;
-  return relative;
-}
-
-function normalizeRelativeFile(cwd, file) {
-  return normalizeProjectSourcePath(cwd, file, { requireExists: true });
-}
-
-function sourceHintWindowFailure(cwd, op) {
-  const hint = op?.sourceHint;
-  if (!hint?.file || !hint.line) return null;
-  const relative = normalizeRelativeFile(cwd, hint.file);
-  if (!relative) return null;
-  const absolute = path.resolve(cwd, relative);
-  let content;
-  try { content = fs.readFileSync(absolute, 'utf-8'); } catch { return null; }
-  const lines = content.split('\n');
-  const line = Math.max(1, Number(hint.line) || 1);
-  const lineText = lines[line - 1] || '';
-  const start = Math.max(0, line - 5);
-  const end = Math.min(lines.length, line + 4);
-  if (
-    typeof op.originalText === 'string'
-    && op.originalText
-    && lineText.includes(op.originalText)
-    && !lineShowsAppliedOp(lineText, op)
-  ) {
-    return {
-      file: relative,
-      line,
-      reason: 'source_hint_still_contains_original_text',
-    };
-  }
-  if (lines.slice(start, end).some((candidateLine) => lineShowsAppliedOp(candidateLine, op))) return null;
-  return null;
-}
-
-function verificationTargetsForOp(batch, op, reportedFiles, cwd) {
-  const candidate = (batch.candidates || []).find((item) => item.entryId === op.entryId && item.ref === op.ref);
-  const out = [];
-  const reportedFileSet = new Set(reportedFiles || []);
-  const add = (file, line, kind) => {
-    const relativeFile = normalizeRelativeFile(cwd, file);
-    const lineNumber = Number(line);
-    if (!relativeFile || !Number.isFinite(lineNumber) || lineNumber < 1) return;
-    out.push({ file: relativeFile, line: lineNumber, kind, reported: reportedFileSet.has(relativeFile) });
-  };
-
-  add(op.sourceHint?.file, op.sourceHint?.line, 'source_hint');
-  add(candidate?.sourceHint?.relativeFile || candidate?.sourceHint?.file, candidate?.sourceHint?.line, 'candidate_source_hint');
-  for (const item of candidate?.textMatches || []) add(item.file, item.line, 'text_match');
-  for (const item of candidate?.objectKeyMatches || []) add(item.file, item.line, 'object_key_match');
-  for (const item of candidate?.locatorMatches || []) add(item.file, item.line, 'locator_match');
-  for (const item of candidate?.contextTextMatches || []) add(item.file, item.line, 'context_text_match');
-
-  // Manual copy edits often stage coupled leaves from the same UI object, e.g.
-  // a card label plus its count. Dynamic source stores both on the label/key
-  // line, so the count op may need the sibling label's data candidates.
-  for (const siblingCandidate of siblingCandidatesForEntry(batch, op)) {
-    add(siblingCandidate.sourceHint?.relativeFile || siblingCandidate.sourceHint?.file, siblingCandidate.sourceHint?.line, 'entry_source_hint');
-    for (const item of siblingCandidate.textMatches || []) add(item.file, item.line, 'entry_text_match');
-    for (const item of siblingCandidate.objectKeyMatches || []) add(item.file, item.line, 'entry_object_key_match');
-    for (const item of siblingCandidate.contextTextMatches || []) add(item.file, item.line, 'entry_context_text_match');
-  }
-
-  for (const relativeFile of reportedFiles || []) {
-    for (const target of locatorTargetsInFile(cwd, relativeFile, op)) {
-      out.push(target);
-    }
-  }
-
-  const seen = new Set();
-  return out.filter((target) => {
-    const key = target.file + ':' + target.line + ':' + target.kind;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-}
-
-function objectKeyCandidatesForOp(batch, op) {
-  const candidates = (batch.candidates || [])
-    .filter((item) => item.entryId === op.entryId && item.ref === op.ref);
-  return candidates.flatMap((candidate) => candidate.objectKeyMatches || []);
-}
-
-function lineHasObjectKey(line, text) {
-  if (typeof text !== 'string' || text.length === 0) return false;
-  const quotedKey = new RegExp('(^|[\\s,{])([\'"`])' + escapeRegExp(text) + '\\2\\s*:');
-  if (quotedKey.test(line)) return true;
-  const identifierSafe = /^[A-Za-z_$][\w$]*$/.test(text);
-  if (!identifierSafe) return false;
-  const bareKey = new RegExp('(^|[\\s,{])' + escapeRegExp(text) + '\\s*:');
-  return bareKey.test(line);
-}
-
-function objectKeyMatchStillUsesOriginal(cwd, match, op) {
-  const relative = normalizeRelativeFile(cwd, match?.file);
-  const lineNumber = Number(match?.line);
-  if (!relative || !Number.isFinite(lineNumber) || lineNumber < 1) return false;
-  let lines;
-  try { lines = fs.readFileSync(path.resolve(cwd, relative), 'utf-8').split('\n'); } catch { return false; }
-  const start = Math.max(0, lineNumber - 4);
-  const end = Math.min(lines.length, lineNumber + 3);
-  const windowLines = lines.slice(start, end);
-  if (windowLines.some((line) => lineHasObjectKey(line, op.newText))) return false;
-  return windowLines.some((line) => lineHasObjectKey(line, op.originalText));
-}
-
-function coupledObjectKeyFailuresForOp(batch, op, cwd) {
-  if (
-    typeof op?.originalText !== 'string'
-    || typeof op?.newText !== 'string'
-    || op.originalText === op.newText
-  ) return [];
-  return objectKeyCandidatesForOp(batch, op)
-    .filter((match) => objectKeyMatchStillUsesOriginal(cwd, match, op))
-    .map((match) => ({
-      ref: op.ref,
-      reason: 'source_verification_failed',
-      detail: 'edited_text_source_key_dependency_not_updated',
-      candidates: [{
-        file: normalizeRelativeFile(cwd, match.file) || match.file,
-        line: match.line,
-        kind: 'object_key_match',
-        reason: 'edited text is also a source key; update the coupled key to newText or fail the entry',
-      }],
-    }));
-}
-
-function siblingCandidatesForEntry(batch, op) {
-  if (!op?.entryId) return [];
-  return (batch.candidates || []).filter((item) => item.entryId === op.entryId && item.ref !== op.ref);
-}
-
-function locatorTargetsInFile(cwd, relativeFile, op) {
-  if (!opHasLocator(op)) return [];
-  const absolute = path.resolve(cwd, relativeFile);
-  let lines;
-  try { lines = fs.readFileSync(absolute, 'utf-8').split('\n'); } catch { return []; }
-  const out = [];
-  for (let index = 0; index < lines.length; index += 1) {
-    if (!lineMatchesManualEditLocator(lines[index], op)) continue;
-    out.push({ file: relativeFile, line: index + 1, kind: 'reported_locator_match' });
-    if (out.length >= 20) break;
-  }
-  return out;
-}
-
-function verificationTargetPasses(cwd, target, op) {
-  let lines;
-  try { lines = fs.readFileSync(path.resolve(cwd, target.file), 'utf-8').split('\n'); } catch { return false; }
-  return verificationTargetPassesLines(lines, target, op);
-}
-
-function verificationTargetPassesLines(lines, target, op) {
-  const line = lines[target.line - 1] || '';
-  if (lineShowsAppliedOp(line, op)) return true;
-  const originalText = typeof op?.originalText === 'string' ? op.originalText : '';
-  if (originalText && line.includes(originalText)) return false;
-  const kind = String(target.kind || '');
-  const canSearchWindow = target.reported
-    || kind.includes('context_text_match')
-    || kind.includes('object_key_match')
-    || kind.includes('text_match');
-  if (!canSearchWindow) return false;
-  const radius = kind.includes('context_text_match') ? 20 : 4;
-  const start = Math.max(0, target.line - radius - 1);
-  const end = Math.min(lines.length, target.line + radius);
-  const windowLines = lines.slice(start, end);
-  if (windowLines.some((candidateLine) => lineShowsAppliedOp(candidateLine, op))) return true;
-  if (windowShowsAppliedOp(windowLines, op)) return true;
-  return false;
-}
-
-function windowShowsAppliedOp(lines, op) {
-  const newText = typeof op?.newText === 'string' ? op.newText : '';
-  if (!newText) return false;
-  const originalText = typeof op?.originalText === 'string' ? op.originalText : '';
-  const normalizedNew = normalizeVerificationText(newText);
-  const normalizedOriginal = normalizeVerificationText(originalText);
-  const normalizedWindow = normalizeVerificationText(lines.join('\n'));
-  if (!normalizedNew || !normalizedWindow.includes(normalizedNew)) return false;
-  if (normalizedOriginal && !normalizedNew.includes(normalizedOriginal) && normalizedWindow.includes(normalizedOriginal)) return false;
-  return true;
-}
-
-function normalizeVerificationText(text) {
-  return String(text || '').replace(/\s+/g, ' ').trim();
-}
-
-function lineShowsAppliedOp(line, op) {
-  const originalText = typeof op?.originalText === 'string' ? op.originalText : '';
-  const newText = typeof op?.newText === 'string' ? op.newText : '';
-  const deletion = op?.deleted === true || newText.length === 0;
-  if (deletion) return !!originalText && !line.includes(originalText);
-  if (!line.includes(newText)) return false;
-  if (originalText && !newText.includes(originalText) && line.includes(originalText)) return false;
-  return true;
-}
-
-function opHasLocator(op) {
-  return !!(
-    op?.tag
-    || op?.elementId
-    || (Array.isArray(op?.classes) && op.classes.filter(Boolean).length > 0)
-  );
-}
-
-function lineMatchesManualEditLocator(line, op) {
-  if (op.tag) {
-    const tagRe = new RegExp('<\\s*' + escapeRegExp(op.tag) + '(?=[\\s>/]|$)', 'i');
-    if (!tagRe.test(line)) return false;
-  }
-
-  if (op.elementId) {
-    const idRe = new RegExp('\\bid\\s*=\\s*["\']' + escapeRegExp(op.elementId) + '["\']');
-    if (!idRe.test(line)) return false;
-  }
-
-  const classes = Array.isArray(op.classes) ? op.classes.filter(Boolean) : [];
-  for (const className of classes) {
-    if (!line.includes(className)) return false;
-  }
-
-  return true;
-}
-
-function verifyAppliedEntry({ batch, entry, reportedFiles, cwd }) {
-  const failures = [];
-  for (const rawOp of entry.ops || []) {
-    const op = { ...rawOp, entryId: entry.id };
-    if (op.deleted === true && typeof op.newText !== 'string') op.newText = '';
-    if (typeof op.newText !== 'string') {
-      failures.push({
-        ref: op.ref,
-        reason: 'source_verification_failed',
-        detail: 'missing_newText',
-        candidates: candidatesForEntry(batch, entry.id).slice(0, 12),
-      });
-      continue;
-    }
-    const targets = verificationTargetsForOp(batch, op, reportedFiles, cwd);
-    const coupledObjectKeyFailures = coupledObjectKeyFailuresForOp(batch, op, cwd);
-    if (
-      coupledObjectKeyFailures.length === 0
-      && targets.some((target) => verificationTargetPasses(cwd, target, op))
-    ) continue;
-
-    if (coupledObjectKeyFailures.length > 0) {
-      failures.push(...coupledObjectKeyFailures.map((failure) => ({
-        ...failure,
-        candidates: [
-          ...(failure.candidates || []),
-          ...targets.map((target) => ({ file: target.file, line: target.line, kind: target.kind })),
-          ...candidatesForEntry(batch, entry.id),
-        ].slice(0, 12),
-      })));
-      continue;
-    }
-
-    const hintedOldText = sourceHintWindowFailure(cwd, op);
-    if (hintedOldText) {
-      failures.push({
-        ref: op.ref,
-        reason: 'source_verification_failed',
-        detail: hintedOldText.reason,
-        candidates: [hintedOldText, ...targets.map((target) => ({ file: target.file, line: target.line, kind: target.kind })), ...candidatesForEntry(batch, entry.id)].slice(0, 12),
-      });
-      continue;
-    }
-
-    failures.push({
-      ref: op.ref,
-      reason: 'source_verification_failed',
-      detail: op.newText.length === 0 ? 'originalText_still_present_in_plausible_source_location' : 'newText_not_found_in_plausible_source_location',
-      candidates: targets.map((target) => ({ file: target.file, line: target.line, kind: target.kind })).concat(candidatesForEntry(batch, entry.id)).slice(0, 12),
-    });
-  }
-  return failures;
-}
-
-function snapshotTargetPasses(snapshot, target, op) {
-  const before = snapshot.get(target.file)?.content;
-  if (typeof before !== 'string') return false;
-  return verificationTargetPassesLines(before.split('\n'), target, op);
-}
-
-function findUnappliedEntrySourceChanges({ batch, entries, reportedFiles, cwd, rollbackSnapshot }) {
-  const failures = [];
-  for (const entry of entries || []) {
-    for (const rawOp of entry.ops || []) {
-      const op = { ...rawOp, entryId: entry.id };
-      if (typeof op.newText !== 'string' || op.newText.length === 0) continue;
-      const targets = verificationTargetsForOp(batch, op, reportedFiles, cwd);
-      const leakedTargets = targets.filter((target) =>
-        verificationTargetPasses(cwd, target, op)
-        && !snapshotTargetPasses(rollbackSnapshot, target, op)
-      );
-      if (leakedTargets.length === 0) continue;
-      failures.push({
-        id: entry.id,
-        reason: 'failed_entry_source_changed',
-        ref: op.ref,
-        newText: op.newText,
-        candidates: leakedTargets
-          .map((target) => ({ file: target.file, line: target.line, kind: target.kind }))
-          .concat(candidatesForEntry(batch, entry.id))
-          .slice(0, 12),
-      });
-      break;
-    }
-  }
-  return failures;
-}
-
-function verificationFailuresForEntries(batch, entries, reason, extra = {}) {
-  return entries.map((entry) => ({
-    id: entry.id,
-    reason,
-    candidates: candidatesForEntry(batch, entry.id),
-    ...extra,
-  }));
-}
-
-function clearAppliedEntries(cwd, appliedEntryIds) {
-  const ids = new Set(appliedEntryIds);
-  if (ids.size === 0) return 0;
-  const buffer = readBuffer(cwd);
-  let cleared = 0;
-  const kept = [];
-  for (const entry of buffer.entries || []) {
-    if (ids.has(entry.id)) {
-      cleared += Array.isArray(entry.ops) ? entry.ops.length : 0;
-    } else {
-      kept.push(entry);
-    }
-  }
-  writeBuffer(cwd, { version: buffer.version || 1, entries: kept });
-  return cleared;
-}
-
-function snapshotRollbackFiles(cwd, files = null) {
-  const snapshot = new Map();
-  const rollbackFiles = Array.isArray(files) && files.length > 0
-    ? uniqueStrings(files).map((file) => normalizeRollbackPath(cwd, file)).filter(Boolean)
-    : collectRollbackFiles(cwd);
-  for (const relativeFile of rollbackFiles) {
-    const absolute = path.resolve(cwd, relativeFile);
-    try {
-      snapshot.set(relativeFile, {
-        existed: true,
-        content: fs.readFileSync(absolute, 'utf-8'),
-      });
-    } catch (err) {
-      if (err?.code === 'ENOENT') {
-        snapshot.set(relativeFile, { existed: false });
-      }
-      // Other read failures are not safe to roll back.
-    }
-  }
-  return snapshot;
-}
-
-function collectRollbackFiles(cwd) {
-  const out = [];
-  const seenDirs = new Set();
-  const seenFiles = new Set();
-  scanRollbackDir(cwd, cwd, out, seenDirs, seenFiles, 0);
-  return out;
-}
-
-function scanRollbackDir(dir, cwd, out, seenDirs, seenFiles, depth) {
-  if (depth > 10) return;
-  let realDir;
-  try { realDir = fs.realpathSync(dir); } catch { return; }
-  if (seenDirs.has(realDir)) return;
-  seenDirs.add(realDir);
-
-  let entries;
-  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      if (ROLLBACK_SKIP_DIRS.has(entry.name)) continue;
-      scanRollbackDir(path.join(dir, entry.name), cwd, out, seenDirs, seenFiles, depth + 1);
-      continue;
-    }
-    if (!entry.isFile()) continue;
-    if (!ROLLBACK_EXTENSIONS.has(path.extname(entry.name).toLowerCase())) continue;
-    const absolute = path.join(dir, entry.name);
-    if (isGeneratedFile(absolute, { cwd })) continue;
-    let realFile;
-    try { realFile = fs.realpathSync(absolute); } catch { continue; }
-    if (seenFiles.has(realFile)) continue;
-    seenFiles.add(realFile);
-    const relative = path.relative(cwd, absolute);
-    if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) continue;
-    out.push(relative);
-  }
-}
-
-function changedFilesSinceSnapshot(cwd, snapshot, scopeFiles = null) {
-  const changed = new Map();
-  const scopedFiles = Array.isArray(scopeFiles) && scopeFiles.length > 0
-    ? scopeFiles.map((file) => normalizeRollbackPath(cwd, file)).filter(Boolean)
-    : null;
-  const currentFiles = new Set(scopedFiles || collectRollbackFiles(cwd));
-  for (const [relativeFile, before] of snapshot.entries()) {
-    if (scopedFiles && !currentFiles.has(relativeFile)) continue;
-    const absolute = path.resolve(cwd, relativeFile);
-    if (before?.existed === false) {
-      if (fs.existsSync(absolute)) changed.set(relativeFile, { file: relativeFile, kind: 'added' });
-      continue;
-    }
-    if (!fs.existsSync(absolute)) {
-      changed.set(relativeFile, { file: relativeFile, kind: 'deleted' });
-      continue;
-    }
-    let content;
-    try { content = fs.readFileSync(absolute, 'utf-8'); } catch { continue; }
-    if (content !== before.content) {
-      changed.set(relativeFile, { file: relativeFile, kind: 'modified' });
-    }
-  }
-  for (const relativeFile of currentFiles) {
-    if (!snapshot.has(relativeFile)) {
-      changed.set(relativeFile, { file: relativeFile, kind: 'unknown' });
-    }
-  }
-  return [...changed.values()];
-}
-
-function rollbackChangedFiles(cwd, snapshot, extraFiles = [], scopeFiles = []) {
-  const scope = new Set(
-    [...(scopeFiles || []), ...(extraFiles || [])]
-      .map((file) => normalizeRollbackPath(cwd, file))
-      .filter(Boolean),
-  );
-  const changed = changedFilesSinceSnapshot(cwd, snapshot, [...scope]);
-  const byFile = new Map(changed.map((item) => [item.file, item]));
-  for (const file of extraFiles || []) {
-    const relative = normalizeRollbackPath(cwd, file);
-    if (relative && !byFile.has(relative)) {
-      byFile.set(relative, { file: relative, kind: snapshot.has(relative) ? 'reported' : 'unknown' });
-    }
-  }
-
-  const rolledBackFiles = [];
-  const rollbackFailures = [];
-  for (const item of byFile.values()) {
-    if (!scope.has(item.file)) continue;
-    const absolute = path.resolve(cwd, item.file);
-    const before = snapshot.get(item.file);
-    try {
-      if (before?.existed !== false && typeof before?.content === 'string') {
-        fs.mkdirSync(path.dirname(absolute), { recursive: true });
-        fs.writeFileSync(absolute, before.content, 'utf-8');
-      } else if (before?.existed === false && item.kind === 'added' && fs.existsSync(absolute)) {
-        fs.rmSync(absolute);
-      } else {
-        rollbackFailures.push({ file: item.file, reason: 'no_snapshot' });
-        continue;
-      }
-      rolledBackFiles.push(item.file);
-    } catch (err) {
-      rollbackFailures.push({ file: item.file, reason: 'restore_failed', message: err.message || String(err) });
-    }
-  }
-  return { rolledBackFiles, rollbackFailures };
-}
-
-function collectApplyOwnedFiles(batch, cwd, extraFiles = []) {
-  const files = [];
-  for (const entry of batch?.entries || []) {
-    for (const op of entry.ops || []) files.push(op.sourceHint?.file);
-  }
-  for (const candidate of batch?.candidates || []) {
-    files.push(candidate.sourceHint?.relativeFile, candidate.sourceHint?.file);
-    for (const item of candidate.textMatches || []) files.push(item.file);
-    for (const item of candidate.objectKeyMatches || []) files.push(item.file);
-    for (const item of candidate.locatorMatches || []) files.push(item.file);
-    for (const item of candidate.contextTextMatches || []) files.push(item.file);
-  }
-  files.push(...(extraFiles || []));
-  return uniqueStrings(files)
-    .map((file) => normalizeRollbackPath(cwd, file))
-    .filter(Boolean);
-}
-
-function unreportedChangedFiles(cwd, snapshot, reportedFiles, scopeFiles = []) {
-  const reported = new Set(
-    (reportedFiles || [])
-      .map((file) => normalizeRollbackPath(cwd, file))
-      .filter(Boolean),
-  );
-  const scope = new Set(
-    (scopeFiles || [])
-      .map((file) => normalizeRollbackPath(cwd, file))
-      .filter(Boolean),
-  );
-  return changedFilesSinceSnapshot(cwd, snapshot, [...scope])
-    .map((item) => item.file)
-    .filter((file) => scope.has(file))
-    .filter((file) => !reported.has(file));
-}
-
-function normalizeRollbackPath(cwd, file) {
-  return normalizeProjectSourcePath(cwd, file);
-}
-
-function verifyEntriesAfterRepair({ batch, appliedEntryIds, files, cwd }) {
-  const reportedFiles = uniqueStrings(files || [])
-    .map((file) => normalizeRelativeFile(cwd, file))
-    .filter(Boolean);
-  const entries = (batch.entries || []).filter((entry) => appliedEntryIds.includes(entry.id));
-  const verifiedIds = [];
-  const failed = [];
-  for (const entry of entries) {
-    const failures = verifyAppliedEntry({ batch, entry, reportedFiles, cwd });
-    if (failures.length === 0) {
-      verifiedIds.push(entry.id);
-    } else {
-      failed.push({
-        id: entry.id,
-        reason: 'source_verification_failed',
-        failures,
-        candidates: candidatesForEntry(batch, entry.id),
-      });
-    }
-  }
-  return { verifiedIds, failed, reportedFiles };
-}
-
-async function repairPostApplyValidation({
-  batch,
-  cwd,
-  pageUrl,
-  count,
-  provider,
-  env,
-  timeoutMs,
-  applyBatchToSource,
-  chatAvailable,
-  transactionId,
-  appliedEntryIds,
-  files,
-  failed,
-  notes,
-  warnings,
-  postChecks,
-  repairReason = 'post_apply_validation_failed',
-  repairFailures = null,
-}) {
-  const maxAttempts = repairAttemptLimit(env);
-  let currentFiles = mergeUniqueStrings(files || []);
-  let currentAppliedIds = mergeUniqueStrings(appliedEntryIds || []);
-  let currentFailed = Array.isArray(failed) ? failed : [];
-  let currentNotes = Array.isArray(notes) ? notes : [];
-  let currentWarnings = Array.isArray(warnings) ? warnings : [];
-  let currentFailures = Array.isArray(repairFailures) ? repairFailures : (postChecks?.failures || []);
-
-  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-    const repair = {
-      attempt,
-      maxAttempts,
-      transactionId: transactionId || null,
-      reason: repairReason,
-      failures: summarizeRepairFailures(currentFailures),
-      files: currentFiles,
-      pageUrl,
-    };
-    let repairResult;
-    try {
-      repairResult = await runCopyEditBatchAgent(buildRepairBatch(batch, repair), {
-        cwd,
-        provider,
-        env,
-        timeoutMs,
-        applyBatchToSource,
-        chatAvailable,
-      });
-    } catch (err) {
-      currentFailures = [{
-        reason: 'repair_agent_failed',
-        message: err.message || String(err),
-      }];
-      continue;
-    }
-
-    currentFiles = mergeUniqueStrings(currentFiles, repairResult.files || []);
-    currentNotes = [...currentNotes, ...(repairResult.notes || [])];
-    currentWarnings = [...currentWarnings, ...(repairResult.warnings || [])];
-    currentAppliedIds = mergeUniqueStrings(currentAppliedIds, repairResult.appliedEntryIds || []);
-    currentFailed = mergeFailedEntries(
-      currentFailed,
-      normalizeFailedEntries(batch, repairResult, 'repair_failed'),
-    );
-
-    const verified = verifyEntriesAfterRepair({
-      batch,
-      appliedEntryIds: currentAppliedIds,
-      files: currentFiles,
-      cwd,
-    });
-    if (verified.failed.length > 0) {
-      currentFailures = verified.failed;
-      continue;
-    }
-
-    const repairedChecks = runCopyEditPostApplyChecks({ cwd, files: currentFiles });
-    currentWarnings = [...currentWarnings, ...(repairedChecks.warnings || [])];
-    if (!repairedChecks.ok) {
-      currentFailures = repairedChecks.failures || [];
-      continue;
-    }
-
-    const cleared = clearAppliedEntries(cwd, verified.verifiedIds);
-    const counts = countByPage(cwd);
-    const verifiedIdSet = new Set(verified.verifiedIds);
-    return {
-      applied: summarizeAppliedEntries(batch.entries, verified.verifiedIds),
-      failed: mergeFailedEntries(currentFailed).filter((item) => !verifiedIdSet.has(item.id)),
-      files: currentFiles,
-      cleared,
-      count,
-      pageUrl,
-      warnings: currentWarnings,
-      notes: currentNotes,
-      repair: {
-        status: 'repaired',
-        attempts: attempt,
-        maxAttempts,
-        transactionId: transactionId || null,
-      },
-      ...counts,
-    };
-  }
-
-  const decisionFailedEntries = currentAppliedIds.length > 0
-    ? (batch.entries || [])
-        .filter((entry) => currentAppliedIds.includes(entry.id))
-        .map((entry) => ({
-          id: entry.id,
-          reason: repairReason,
-          checks: currentFailures,
-          candidates: candidatesForEntry(batch, entry.id),
-        }))
-    : verificationFailuresForEntries(batch, batch.entries || [], repairReason, { checks: currentFailures });
-  return {
-    applied: [],
-    failed: mergeFailedEntries(decisionFailedEntries, currentFailed),
-    files: currentFiles,
-    cleared: 0,
-    count,
-    pageUrl,
-    warnings: currentWarnings,
-    notes: currentNotes,
-    reason: 'manual_edit_repair_needs_decision',
-    needsManualDecision: true,
-    repair: {
-      status: 'needs_decision',
-      attempts: maxAttempts,
-      maxAttempts,
-      transactionId: transactionId || null,
-      failures: summarizeRepairFailures(currentFailures),
-      files: currentFiles,
-    },
-    ...countByPage(cwd),
-  };
-}
-
-export async function commitManualEdits({
-  cwd = process.cwd(),
-  pageUrl = null,
-  provider = undefined,
-  env = process.env,
-  timeoutMs = undefined,
-  applyBatchToSource = undefined,
-  chatAvailable = undefined,
-  repairOnly = false,
-  transactionId = null,
-  batch: providedBatch = null,
-} = {}) {
-  try {
-    readBufferStrict(cwd);
-  } catch (err) {
-    return {
-      applied: [],
-      failed: [],
-      files: [],
-      cleared: 0,
-      count: 0,
-      pageUrl,
-      reason: 'manual_edit_buffer_invalid',
-      message: err.message || String(err),
-      ...countByPage(cwd),
-    };
-  }
-
-  const batch = providedBatch || buildManualEditEvidence({ cwd, pageUrl });
-  const count = countOps(batch.entries);
-  if (count === 0) {
-    return {
-      applied: [],
-      failed: [],
-      files: [],
-      cleared: 0,
-      count: 0,
-      pageUrl,
-      reason: 'no_pending_edits',
-      ...countByPage(cwd),
-    };
-  }
-
-  const repairContext = {
-    batch,
-    cwd,
-    pageUrl,
-    count,
-    provider,
-    env,
-    timeoutMs,
-    applyBatchToSource,
-    chatAvailable,
-    transactionId,
-  };
-
-  const baseRollbackScope = collectApplyOwnedFiles(batch, cwd);
-  const rollbackSnapshot = snapshotRollbackFiles(cwd, baseRollbackScope);
-  const failWithRollback = ({
-    scope = baseRollbackScope,
-    extraFiles = [],
-    failed,
-    files = [],
-    details = {},
-  }) => {
-    const rollback = rollbackChangedFiles(cwd, rollbackSnapshot, extraFiles, scope);
-    return {
-      applied: [],
-      failed,
-      files,
-      cleared: 0,
-      count,
-      pageUrl,
-      ...details,
-      rolledBackFiles: rollback.rolledBackFiles,
-      rollbackFailures: rollback.rollbackFailures,
-      ...countByPage(cwd),
-    };
-  };
-  let result;
-  try {
-    result = repairOnly
-      ? {
-          status: 'done',
-          appliedEntryIds: allEntryIds(batch),
-          failed: [],
-          files: collectApplyOwnedFiles(batch, cwd),
-          notes: ['repair-only validation pass'],
-        }
-      : await runCopyEditBatchAgent(batch, {
-          cwd,
-          provider,
-          env,
-          timeoutMs,
-          applyBatchToSource,
-          chatAvailable,
-        });
-  } catch (err) {
-    return failWithRollback({
-      failed: batch.entries.map((entry) => ({
-        id: entry.id,
-        reason: err.message || String(err),
-        candidates: candidatesForEntry(batch, entry.id),
-      })),
-    });
-  }
-
-  if (result.status === 'error') {
-    const rollbackScope = collectApplyOwnedFiles(batch, cwd, result.files || []);
-    const failed = normalizeFailedEntries(batch, result, result.message || 'AI copy edit failed');
-    return failWithRollback({
-      scope: rollbackScope,
-      extraFiles: result.files || [],
-      failed: failed.length > 0
-        ? failed
-        : verificationFailuresForEntries(batch, batch.entries, result.message || 'AI copy edit failed'),
-      files: result.files || [],
-      details: { notes: result.notes || [] },
-    });
-  }
-
-  const reportedAppliedIds = uniqueStrings(result.appliedEntryIds || []);
-  const reportedFiles = uniqueStrings(result.files || [])
-    .map((file) => normalizeRelativeFile(cwd, file))
-    .filter(Boolean);
-  const aiFailed = normalizeFailedEntries(batch, result, 'AI copy edit failed');
-  const rollbackScope = collectApplyOwnedFiles(batch, cwd, result.files || []);
-  const failedIds = new Set(aiFailed.map((item) => item.id).filter(Boolean));
-  const conflictingAppliedIds = reportedAppliedIds.filter((id) => failedIds.has(id));
-
-  if (conflictingAppliedIds.length > 0) {
-    const conflictingEntries = batch.entries.filter((entry) => conflictingAppliedIds.includes(entry.id));
-    return failWithRollback({
-      scope: rollbackScope,
-      extraFiles: result.files || [],
-      failed: [
-        ...verificationFailuresForEntries(batch, conflictingEntries, 'conflicting_apply_result'),
-        ...aiFailed.filter((item) => !conflictingAppliedIds.includes(item.id)),
-      ],
-      files: result.files || [],
-      details: { notes: result.notes || [] },
-    });
-  }
-
-  const unreportedFiles = unreportedChangedFiles(cwd, rollbackSnapshot, result.files || [], rollbackScope);
-  if (unreportedFiles.length > 0) {
-    return failWithRollback({
-      scope: [...rollbackScope, ...unreportedFiles],
-      extraFiles: result.files || [],
-      failed: verificationFailuresForEntries(batch, batch.entries, 'unreported_source_changes', { files: unreportedFiles }),
-      files: result.files || [],
-      details: { unreportedFiles, notes: result.notes || [] },
-    });
-  }
-
-  if (result.status === 'done' && reportedAppliedIds.length === 0) {
-    return failWithRollback({
-      scope: rollbackScope,
-      extraFiles: result.files || [],
-      failed: verificationFailuresForEntries(batch, batch.entries, 'missing_applied_entry_ids'),
-      files: result.files || [],
-      details: { notes: result.notes || [] },
-    });
-  }
-
-  const reportedAppliedEntries = batch.entries.filter((entry) => reportedAppliedIds.includes(entry.id));
-  if (reportedAppliedIds.length > 0 && reportedFiles.length === 0) {
-    return repairPostApplyValidation({
-      ...repairContext,
-      appliedEntryIds: reportedAppliedIds,
-      files: result.files || [],
-      failed: aiFailed,
-      notes: result.notes || [],
-      warnings: result.warnings || [],
-      repairReason: 'missing_touched_files',
-      repairFailures: verificationFailuresForEntries(batch, reportedAppliedEntries, 'missing_touched_files'),
-    });
-  }
-
-  const {
-    verifiedIds: verifiedAppliedIds,
-    failed: verificationFailed,
-  } = verifyEntriesAfterRepair({ batch, appliedEntryIds: reportedAppliedIds, files: reportedFiles, cwd });
-  const unreportedEntries = result.status === 'done' || result.status === 'partial'
-    ? batch.entries.filter((entry) => !reportedAppliedIds.includes(entry.id) && !aiFailed.some((item) => item.id === entry.id))
-    : [];
-  const nonRepairFailed = [
-    ...verificationFailuresForEntries(batch, unreportedEntries, 'not_reported_applied'),
-    ...aiFailed,
-  ];
-  const failed = [
-    ...verificationFailed,
-    ...nonRepairFailed,
-  ];
-
-  const unappliedEntries = batch.entries.filter((entry) => !reportedAppliedIds.includes(entry.id));
-  const leakedUnapplied = findUnappliedEntrySourceChanges({
-    batch,
-    entries: unappliedEntries,
-    reportedFiles,
-    cwd,
-    rollbackSnapshot,
-  });
-  if (leakedUnapplied.length > 0) {
-    const leakedIds = new Set(leakedUnapplied.map((item) => item.id).filter(Boolean));
-    const rolledBackVerified = reportedAppliedEntries
-      .filter((entry) => verifiedAppliedIds.includes(entry.id))
-      .map((entry) => ({
-        id: entry.id,
-        reason: 'rolled_back_due_to_failed_entry_source_changed',
-        candidates: candidatesForEntry(batch, entry.id),
-      }));
-    return failWithRollback({
-      scope: rollbackScope,
-      extraFiles: result.files || [],
-      failed: [
-        ...leakedUnapplied,
-        ...failed.filter((item) => !leakedIds.has(item.id)),
-        ...rolledBackVerified,
-      ],
-      files: result.files || [],
-      details: { notes: result.notes || [] },
-    });
-  }
-
-  if (verificationFailed.length > 0) {
-    return repairPostApplyValidation({
-      ...repairContext,
-      appliedEntryIds: reportedAppliedIds,
-      files: result.files || [],
-      failed: nonRepairFailed,
-      notes: result.notes || [],
-      warnings: result.warnings || [],
-      repairReason: 'source_verification_failed',
-      repairFailures: verificationFailed,
-    });
-  }
-
-  const postChecks = runCopyEditPostApplyChecks({ cwd, files: result.files || [] });
-  if (!postChecks.ok) {
-    const postCheckEntries = verifiedAppliedIds.length > 0
-      ? reportedAppliedEntries.filter((entry) => verifiedAppliedIds.includes(entry.id))
-      : batch.entries;
-    return repairPostApplyValidation({
-      ...repairContext,
-      appliedEntryIds: verifiedAppliedIds.length > 0
-        ? verifiedAppliedIds
-        : postCheckEntries.map((entry) => entry.id).filter(Boolean),
-      files: result.files || [],
-      failed,
-      notes: result.notes || [],
-      warnings: [...(result.warnings || []), ...(postChecks.warnings || [])],
-      postChecks,
-    });
-  }
-
-  const cleared = clearAppliedEntries(cwd, verifiedAppliedIds);
-  const counts = countByPage(cwd);
-  return {
-    applied: summarizeAppliedEntries(batch.entries, verifiedAppliedIds),
-    failed,
-    files: result.files || [],
-    cleared,
-    count,
-    pageUrl,
-    warnings: [...(result.warnings || []), ...(postChecks.warnings || [])],
-    notes: result.notes || [],
-    ...counts,
-  };
-}
-
-async function main() {
-  const args = process.argv.slice(2);
-  if (args.includes('--help') || args.includes('-h')) {
-    console.log('Usage: node live-commit-manual-edits.mjs [--page-url=<url>] [--provider=auto|codex|claude|mock]');
-    process.exit(0);
-  }
-
-  const result = await commitManualEdits({
-    cwd: process.cwd(),
-    pageUrl: argVal(args, '--page-url'),
-    provider: argVal(args, '--provider') || undefined,
-    timeoutMs: Number(process.env.IMPECCABLE_LIVE_COPY_AGENT_TIMEOUT_MS || 120000),
-  });
-  console.log(JSON.stringify(result));
-}
-
-if (process.argv[1]?.endsWith('live-commit-manual-edits.mjs')) {
-  main().catch((err) => {
-    console.error(JSON.stringify({ error: 'commit_failed', message: err.message || String(err) }));
-    process.exit(1);
-  });
-}
-
-function escapeRegExp(value) {
-  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}