petari 0.6.0 → 0.8.0

package/README.md

@@ -59,7 +59,8 @@ slnmix の出力) が実ファイルとずれている**可能性が高いです
 長い添付を要約・検索処理で部分的にしか読まないことがあり、AI が見えなかった箇所を
 もっともらしく補って出力することがあります。SEARCH の空白調整や言い換えを繰り返す
 より、スナップショットを取り直して渡し直すのが確実です (petari 側は空白・インデント・
-文字コードの差を吸収して照合するため、それらが原因で失敗することはありません)。
+空行の位置や数・文字コードの差を吸収して照合するため、それらが原因で失敗することは
+ありません)。
 
 ### コマンド
 

package/dist/commands/apply.js

@@ -9,7 +9,7 @@ import { parseArgs } from "node:util";
 import { invalidPathReason, planChangeSet, } from "../core/applier.js";
 import { PRESENCE_STAGE_LABEL } from "../core/matcher.js";
 import { parseChangesRecovering } from "../core/parser.js";
-import { buildFailureReport, buildParseErrorReport } from "../core/report.js";
+import { buildBlankInsensitiveNote, buildFailureReport, buildParseErrorReport, } from "../core/report.js";
 import { readClipboard, writeClipboard } from "../infra/clipboard.js";
 import { loadConfig } from "../infra/config.js";
 import { findRecentChangesFiles, resolveDownloadsDir, } from "../infra/downloads.js";
@@ -224,6 +224,9 @@ export async function applyCommand(argv) {
         out(`dry-run: 適用予定 ${applicable.length} ファイル (書き込みなし)`);
         printPreview(applicable);
         printAlreadyApplied(plan.outcomes);
+        const dryRunNote = buildBlankInsensitiveNote(plan.outcomes);
+        if (dryRunNote !== null)
+            out(dryRunNote);
         if (plan.failures.length > 0) {
             out("");
             await emitReport(buildFailureReport(plan.failures, { outcomes: plan.outcomes, nothingWritten: true }));
@@ -312,6 +315,9 @@ export async function applyCommand(argv) {
     for (const o of applicable)
         out(`  ${opLabel(o)}`);
     printAlreadyApplied(plan.outcomes);
+    const appliedNote = buildBlankInsensitiveNote(plan.outcomes);
+    if (appliedNote !== null)
+        out(appliedNote);
     if (plan.failures.length > 0) {
         out(`スキップした失敗 ${plan.failures.length} 件のレポート:`);
         out("");

package/dist/commands/init.js

@@ -63,15 +63,32 @@ export async function initCommand(argv) {
         }
         catch {
             err(`3. ${repomixPath} を JSON として読めないためスキップします`);
-            parsed = { output: { instructionFilePath: "(parse error)" } };
+            parsed = null;
         }
-        if (parsed.output?.instructionFilePath !== undefined) {
-            out(`3. repomix.config.json は instructionFilePath 設定済みです (変更しません)`);
-        }
-        else if (await ask('3. repomix.config.json に output.instructionFilePath: "protocol.md" を追記しますか?')) {
-            parsed.output = { ...(parsed.output ?? {}), instructionFilePath: "protocol.md" };
-            writeFileSync(repomixPath, JSON.stringify(parsed, null, 2) + "\n", "utf8");
-            out(`   追記しました: ${repomixPath}`);
+        if (parsed !== null) {
+            let changed = false;
+            if (parsed.output?.instructionFilePath !== undefined) {
+                out(`3. repomix.config.json は instructionFilePath 設定済みです (変更しません)`);
+            }
+            else if (await ask('3. repomix.config.json に output.instructionFilePath: "protocol.md" を追記しますか?')) {
+                parsed.output = { ...(parsed.output ?? {}), instructionFilePath: "protocol.md" };
+                changed = true;
+            }
+            // 空行を落としたスナップショットは SEARCH 不一致 (空行欠落) の定番原因 (2026-08-25 実運用事例)
+            const output = parsed.output;
+            if (output !== undefined && output.removeEmptyLines === true) {
+                if (await ask("3. repomix.config.json の output.removeEmptyLines: true は、スナップショットと実ファイルの空行がずれて SEARCH 不一致の原因になります。false に変更しますか?")) {
+                    output.removeEmptyLines = false;
+                    changed = true;
+                }
+                else {
+                    err("   removeEmptyLines: true のままでは AI の SEARCH から空行が欠けやすくなります (petari は失敗レポートの + 印で検出します)");
+                }
+            }
+            if (changed) {
+                writeFileSync(repomixPath, JSON.stringify(parsed, null, 2) + "\n", "utf8");
+                out(`   更新しました: ${repomixPath}`);
+            }
         }
     }
     else if (await ask("3. repomix 連携用の repomix.config.json (最小構成) を作成しますか?")) {

package/dist/core/applier.js

@@ -90,12 +90,23 @@ function planReplace(change, state, fallbackEol) {
                 (checkedReplace
                     ? " (REPLACE の内容も見つからないため、changes.md の基準スナップショットが現在のコードベースとずれている可能性があります)"
                     : "");
+            const nearest = analyzeNearest(textLines, block.search, applied.length > 0);
+            // SEARCH が全滅のときのみ REPLACE 側で近傍を推定する (本来当てたかった箇所のヒント)。
+            // fold 段のみの偶然一致をノイズとして弾くため matchCount >= 1 を要求する
+            let nearestReplace;
+            if (nearest.window === null && checkedReplace) {
+                const byReplace = analyzeNearest(textLines, block.replace, applied.length > 0, "REPLACE");
+                if (byReplace.window !== null && byReplace.window.matchCount >= 1) {
+                    nearestReplace = byReplace;
+                }
+            }
             failures.push({
                 path: change.path,
                 kind: "block-not-found",
                 message,
                 block,
-                nearest: analyzeNearest(textLines, block.search, applied.length > 0),
+                nearest,
+                ...(nearestReplace !== undefined ? { nearestReplace } : {}),
             });
             continue;
         }

package/dist/core/matcher.js

@@ -2,6 +2,7 @@ export const STAGE_LABEL = {
     "exact": "完全一致",
     "trim-end": "行末空白無視",
     "trim-all": "インデント無視",
+    "blank-insensitive": "空行差無視",
 };
 const STAGES = [
     { stage: "exact", eq: (a, b) => a === b },
@@ -89,7 +90,47 @@ export function reindent(replaceLines, searchBase, fileBase) {
         return fileBase + line.trimStart();
     });
 }
-/** 1 ブロックを 2 段フォールバックでマッチさせ、適用後の置換行も算出する */
+/**
+ * 4 段目 blank-insensitive (§6): SEARCH と実ファイルの双方から空行を除いた行列を
+ * trim-all 比較 (a.trim() === b.trim()) で連続一致探索する。マッチ範囲は最初と最後の
+ * 非空行で囲まれた元ファイル範囲 (内部の空行は含む、外側の空行は含まない)。
+ * SEARCH の先頭・末尾の空行は照合範囲に含めず、実ファイル側の外側の空行はそのまま残る。
+ * REPLACE 側の空行はそのまま挿入する (意図的な空行挿入を潰さないため、勝手に削らない)。
+ * 見つからないときは null (呼び出し元が not-found にする)。
+ */
+function matchBlankInsensitive(lines, block) {
+    const searchNonBlank = block.search.filter((l) => l.trim() !== "");
+    // SEARCH が空行のみなら試行しない (どこにでも一致し得るため)
+    if (searchNonBlank.length === 0)
+        return null;
+    const fileNonBlank = [];
+    const origIdx = [];
+    lines.forEach((line, i) => {
+        if (line.trim() !== "") {
+            fileNonBlank.push(line);
+            origIdx.push(i);
+        }
+    });
+    const found = findMatches(fileNonBlank, searchNonBlank, (a, b) => a.trim() === b.trim());
+    if (found.length === 0)
+        return null;
+    if (found.length > 1) {
+        return {
+            ok: false,
+            block,
+            reason: "ambiguous",
+            stage: "blank-insensitive",
+            count: found.length,
+            positions: found.map((h) => origIdx[h]),
+        };
+    }
+    const hit = found[0];
+    const start = origIdx[hit];
+    const end = origIdx[hit + searchNonBlank.length - 1] + 1;
+    const replacement = reindent(block.replace, baseIndent(block.search), baseIndent(lines.slice(start, end)));
+    return { ok: true, block, stage: "blank-insensitive", start, end, replacement };
+}
+/** 1 ブロックを段階フォールバック (STAGES → blank-insensitive) でマッチさせ、適用後の置換行も算出する */
 export function matchBlock(lines, block) {
     for (const { stage, eq } of STAGES) {
         const found = findMatches(lines, block.search, eq);
@@ -105,6 +146,9 @@ export function matchBlock(lines, block) {
             return { ok: false, block, reason: "ambiguous", stage, count: found.length, positions: found };
         }
     }
+    const blankInsensitive = matchBlankInsensitive(lines, block);
+    if (blankInsensitive !== null)
+        return blankInsensitive;
     return { ok: false, block, reason: "not-found" };
 }
 /**

package/dist/core/nearest.js

@@ -6,13 +6,34 @@
  * 2026-08-25 の実運用事例 (AI が失敗原因を空白/エンコーディングと誤診し 4 往復) を受けて追加。
  * 抜粋行は verbatim で保持する — AI がそのまま次の SEARCH へコピーする前提のため、
  * 制御文字の可視化などの加工は行わない (差分の説明は note 側に分離する)。
+ *
+ * 2026-08-25 追記 (空行欠落事例): スナップショット生成ツール側で空行が落ち、SEARCH に
+ * 空行が不足するだけで不一致になる事例が確認された。固定幅ウィンドウのスライド照合では
+ * 1 行の過不足で位置合わせ全体がずれ、別の類似箇所 (End Sub 等) を抜粋してしまうため、
+ * ギャップ (行の挿入・欠落) を許容するアラインメント (fit alignment) へ変更した。
+ * 実ファイル側にだけある行は "+" として抜粋に含め、空行なら専用の注記と修正ヒントを出す。
+ *
+ * 2026-08-30 追記: matcher に 4 段目 blank-insensitive が入り、空行の差だけなら SEARCH
+ * マッチングの段階で自動吸収されるようになった。この診断に空行差が現れるのは「空行以外にも
+ * 差がある」ケースだけなので、注記は空行が原因と読めない文言にする (誤誘導防止)。
  */
 /** 前後のコンテキストとして抜粋に含める行数 */
-const CONTEXT_LINES = 2;
+const CONTEXT_LINES = 4;
 /** レポートに載せるウィンドウの最大行数 (巨大 SEARCH の暴走防止) */
 const MAX_RENDER_LINES = 40;
 /** 「存在しない行」一覧の最大表示数 */
 const MAX_MISSING_LINES = 8;
+/** アラインメント DP のセル数上限 (巨大ファイル × 巨大 SEARCH のメモリ暴走防止) */
+const MAX_DP_CELLS = 20_000_000;
+/**
+ * アラインメントのスコア。置換 (SUB) は gap 2 個 (削除+挿入) より高くする —
+ * 内容の異なる行同士でも位置が対応するなら「!」として同じ行に並べて見せたいため。
+ */
+const SCORE_MATCH = 6; // 前後空白無視で一致
+const SCORE_WS = 4; // 行内空白の圧縮まで許すと一致
+const SCORE_FOLD = 2; // 不可視文字の畳み込みまで許すと一致
+const SCORE_SUB = -2; // 内容の異なる行同士の対応付け
+const GAP = -3; // 片側にしかない行 1 行あたり
 const collapseWs = (s) => s.replace(/[ \t]+/g, " ");
 /**
  * 目視で区別しづらい文字を通常の文字へ畳み込む。畳み込み後に一致するなら、
@@ -46,26 +67,113 @@ function describeFirstDiff(fileLine, searchLine) {
     };
     return `${i + 1} 文字目から異なります (実ファイル側: ${cp(a, i)} / SEARCH 側: ${cp(b, i)})`;
 }
-function noteFor(fileLine, searchLine, verdict) {
+function noteFor(fileLine, searchLine, verdict, subject) {
     if (verdict === "ws-only") {
         return "行内の連続空白の個数のみが異なります (実ファイル側の行をそのままコピーしてください)";
     }
     if (verdict === "differ") {
         const ft = fileLine.trim();
         const st = searchLine.trim();
+        if (ft === "" && st !== "") {
+            return `実ファイル側のこの行は空行です (空行の位置・数の差は自動で吸収されるため、失敗の原因は空行ではなく他の行の差にあります)`;
+        }
+        if (st === "" && ft !== "") {
+            return `${subject} 側の対応行は空行ですが、実ファイルのこの行は空行ではありません (実ファイル側の行をそのままコピーしてください。空行の差は自動で吸収されます)`;
+        }
         if (collapseWs(foldConfusable(ft)) === collapseWs(foldConfusable(st))) {
             return `見た目で区別しづらい文字の差です。${describeFirstDiff(fileLine, searchLine)}`;
         }
     }
     return undefined;
 }
+/**
+ * fit alignment: SEARCH 全行を実ファイルのどこかの連続領域に、行の挿入・欠落 (gap) を
+ * 許容しつつ最良スコアで対応付ける。局所アラインメントと違い SEARCH 側は必ず全行を
+ * 消費する (先頭・末尾の不一致行も「!」として抜粋に残すため)。
+ * 実ファイル側の開始位置は自由 (H[i][0] = 0)、同点なら最初 (最も上) の領域を採用。
+ */
+function alignSearch(fTrim, sTrimAll, fColl, sCollAll, fFold, sFoldAll) {
+    const n = fTrim.length;
+    if (n === 0 || sTrimAll.length === 0)
+        return null;
+    // セル数上限を超える場合は SEARCH 側を先頭から切り詰める (残りは unmatched 扱い)
+    const m = Math.min(sTrimAll.length, Math.max(1, Math.floor(MAX_DP_CELLS / n)));
+    const pairScore = (fi, sj) => {
+        if (fTrim[fi] === sTrimAll[sj])
+            return SCORE_MATCH;
+        if (fColl[fi] === sCollAll[sj])
+            return SCORE_WS;
+        if (fFold[fi] === sFoldAll[sj])
+            return SCORE_FOLD;
+        return SCORE_SUB;
+    };
+    // 1 = diag (pair), 2 = up (実ファイル側の挿入行), 3 = left (SEARCH 側の欠落行)
+    const dirs = new Uint8Array(n * m);
+    let prev = new Int32Array(m + 1);
+    let curr = new Int32Array(m + 1);
+    for (let j = 1; j <= m; j++)
+        prev[j] = j * GAP;
+    let bestScore = Number.NEGATIVE_INFINITY;
+    let bestI = -1;
+    for (let i = 1; i <= n; i++) {
+        curr[0] = 0;
+        for (let j = 1; j <= m; j++) {
+            const diag = prev[j - 1] + pairScore(i - 1, j - 1);
+            const up = prev[j] + GAP;
+            const left = curr[j - 1] + GAP;
+            let v = diag;
+            let d = 1;
+            if (up > v) {
+                v = up;
+                d = 2;
+            }
+            if (left > v) {
+                v = left;
+                d = 3;
+            }
+            curr[j] = v;
+            dirs[(i - 1) * m + (j - 1)] = d;
+        }
+        if (curr[m] > bestScore) {
+            bestScore = curr[m];
+            bestI = i;
+        }
+        [prev, curr] = [curr, prev];
+    }
+    if (bestI < 0)
+        return null;
+    const rev = [];
+    let i = bestI;
+    let j = m;
+    while (j > 0) {
+        if (i === 0) {
+            rev.push({ kind: "missing", searchIdx: j - 1 });
+            j--;
+            continue;
+        }
+        const d = dirs[(i - 1) * m + (j - 1)];
+        if (d === 1) {
+            rev.push({ kind: "pair", fileIdx: i - 1, searchIdx: j - 1 });
+            i--;
+            j--;
+        }
+        else if (d === 2) {
+            rev.push({ kind: "extra", fileIdx: i - 1 });
+            i--;
+        }
+        else {
+            rev.push({ kind: "missing", searchIdx: j - 1 });
+            j--;
+        }
+    }
+    return { steps: rev.reverse(), clippedSearchFrom: m };
+}
 /**
  * SEARCH に最も近い実ファイル領域を探す。
- * スコア: 前後空白無視の一致 = 3 点、空白圧縮一致 = 2 点、不可視文字の畳み込みまで
- * かけて一致 = 1 点。最高得点の最初の位置を採用する (全比較段が 0 のときのみ null)。
- * 走査が O(ファイル行数 × SEARCH 行数) になるため、正規化はすべて事前計算する。
+ * 行の対応付けはギャップ許容アラインメント (alignSearch)。1 行も (空白圧縮・不可視文字の
+ * 畳み込みでも) 一致しないときのみ window は null。
  */
-export function analyzeNearest(fileLines, search, afterPriorBlocks = false) {
+export function analyzeNearest(fileLines, search, afterPriorBlocks = false, subject = "SEARCH") {
     const fTrim = fileLines.map((l) => l.trim());
     const sTrim = search.map((l) => l.trim());
     const fColl = fTrim.map(collapseWs);
@@ -83,59 +191,132 @@ export function analyzeNearest(fileLines, search, afterPriorBlocks = false) {
                 count++;
         lineHits.push({ index: i + 1, text, count });
     });
-    const size = Math.min(search.length, fileLines.length);
-    let bestStart = -1;
-    let bestScore = 0;
-    let bestMatch = 0;
-    for (let i = 0; size > 0 && i + size <= fileLines.length; i++) {
-        let score = 0;
-        let matches = 0;
-        for (let j = 0; j < size; j++) {
-            if (fTrim[i + j] === sTrim[j]) {
-                score += 3;
-                matches++;
-            }
-            else if (fColl[i + j] === sColl[j]) {
-                score += 2;
-            }
-            else if (fFold[i + j] === sFold[j]) {
-                score += 1;
-            }
-        }
-        if (score > bestScore) {
-            bestScore = score;
-            bestStart = i;
-            bestMatch = matches;
-        }
-    }
-    if (bestStart < 0)
-        return { lineHits, window: null, afterPriorBlocks };
+    const aligned = alignSearch(fTrim, sTrim, fColl, sColl, fFold, sFold);
+    if (aligned === null)
+        return { lineHits, window: null, afterPriorBlocks, subject };
+    const { steps, clippedSearchFrom } = aligned;
+    // どの段の一致も 1 行も無いアラインメントは領域として無意味 (従来の null 条件を維持)
+    const anyHit = steps.some((s) => s.kind === "pair" &&
+        (fTrim[s.fileIdx] === sTrim[s.searchIdx] ||
+            fColl[s.fileIdx] === sColl[s.searchIdx] ||
+            fFold[s.fileIdx] === sFold[s.searchIdx]));
+    if (!anyHit)
+        return { lineHits, window: null, afterPriorBlocks, subject };
+    const fileIdxs = steps.flatMap((s) => (s.kind === "missing" ? [] : [s.fileIdx]));
+    const startFile = Math.min(...fileIdxs);
+    const endFile = Math.max(...fileIdxs) + 1;
     const lines = [];
-    const from = Math.max(0, bestStart - CONTEXT_LINES);
-    const to = Math.min(fileLines.length, bestStart + size + CONTEXT_LINES);
-    for (let i = from; i < to; i++) {
-        const inWindow = i >= bestStart && i < bestStart + size;
-        if (!inWindow) {
+    const unmatchedSearch = [];
+    let matchCount = 0;
+    let extraCount = 0;
+    let extraBlankCount = 0;
+    const pushContext = (from, to) => {
+        for (let i = from; i < to; i++) {
             lines.push({ lineNo: i + 1, text: fileLines[i], verdict: null });
+        }
+    };
+    pushContext(Math.max(0, startFile - CONTEXT_LINES), startFile);
+    for (const step of steps) {
+        if (step.kind === "missing") {
+            unmatchedSearch.push({
+                index: step.searchIdx + 1,
+                text: search[step.searchIdx],
+                blank: sTrim[step.searchIdx] === "",
+            });
+            continue;
+        }
+        if (step.kind === "extra") {
+            extraCount++;
+            const blank = fTrim[step.fileIdx] === "";
+            if (blank)
+                extraBlankCount++;
+            const note = blank
+                ? `実ファイル側にある空行です (空行の位置・数の差は自動で吸収されるため、この空行自体は失敗の原因ではありません)`
+                : `${subject} に含まれていない行です。この行も含めてコピーしてください`;
+            lines.push({
+                lineNo: step.fileIdx + 1,
+                text: fileLines[step.fileIdx],
+                verdict: "extra",
+                note,
+            });
             continue;
         }
-        const j = i - bestStart;
-        const verdict = verdictOf(fTrim[i], sTrim[j]);
-        const note = noteFor(fileLines[i], search[j], verdict);
+        const verdict = verdictOf(fTrim[step.fileIdx], sTrim[step.searchIdx]);
+        if (verdict === "match")
+            matchCount++;
+        const note = noteFor(fileLines[step.fileIdx], search[step.searchIdx], verdict, subject);
         lines.push({
-            lineNo: i + 1,
-            text: fileLines[i],
+            lineNo: step.fileIdx + 1,
+            text: fileLines[step.fileIdx],
             verdict,
             ...(note !== undefined ? { note } : {}),
         });
     }
+    pushContext(endFile, Math.min(fileLines.length, endFile + CONTEXT_LINES));
+    // DP セル数上限で切り詰めた SEARCH 末尾は対応なし扱い
+    for (let k = clippedSearchFrom; k < search.length; k++) {
+        unmatchedSearch.push({ index: k + 1, text: search[k], blank: sTrim[k] === "" });
+    }
     return {
         lineHits,
-        window: { total: search.length, matchCount: bestMatch, lines },
+        window: {
+            total: search.length,
+            matchCount,
+            lines,
+            extraCount,
+            extraBlankCount,
+            unmatchedSearch,
+        },
         afterPriorBlocks,
+        subject,
     };
 }
-const MARK = { match: "=", "ws-only": "~", differ: "!" };
+const MARK = { match: "=", "ws-only": "~", differ: "!", extra: "+" };
+/** 抜粋 (コードブロック + 凡例 + 行ごとの注記)。SEARCH / REPLACE 両方の診断で共用 */
+function renderWindowBody(w, subject) {
+    const out = ["```"];
+    for (const line of w.lines.slice(0, MAX_RENDER_LINES)) {
+        const mark = line.verdict === null ? " " : MARK[line.verdict];
+        out.push(`${mark} ${String(line.lineNo).padStart(5)}│${line.text}`);
+    }
+    if (w.lines.length > MAX_RENDER_LINES) {
+        out.push(`… (以下 ${w.lines.length - MAX_RENDER_LINES} 行省略)`);
+    }
+    out.push("```", `凡例: ! = ${subject} と内容が異なる行 / ~ = 空白の個数のみ異なる行 / + = 実ファイルにあるが ${subject} にない行 / = = 一致した行 / 無印 = 前後の文脈`);
+    for (const line of w.lines) {
+        if (line.note !== undefined)
+            out.push(`- ${line.lineNo} 行目: ${line.note}`);
+    }
+    for (const u of w.unmatchedSearch) {
+        out.push(u.blank
+            ? `- ${subject} ${u.index} 行目の空行に対応する行がこの領域にありません (${subject} 側だけの空行は自動で吸収されるため、失敗の原因は他の行にあります)`
+            : `- ${subject} ${u.index} 行目 (${u.text.trim()}) に対応する行がこの領域にありません`);
+    }
+    return out;
+}
+/**
+ * 修正のヒント (near-miss 自動サジェスト)。SEARCH の全行が順序どおり実ファイルに存在し、
+ * 間に SEARCH 側に無い行が挟まっているだけなら「抜粋のコピーで一致する」と機械的に言える。
+ * 空行だけの過不足は blank-insensitive 段階で自動吸収されるため、このヒントが空行のみを
+ * 指すのは行内空白差 (~) が併発しているときだけ — 原因を空行と誤読させない文言にする。
+ */
+function buildHint(w) {
+    if (w.extraCount === 0 || w.unmatchedSearch.length > 0)
+        return [];
+    if (w.lines.some((l) => l.verdict === "differ"))
+        return [];
+    const hasWsOnly = w.lines.some((l) => l.verdict === "ws-only");
+    const head = w.extraBlankCount === w.extraCount
+        ? hasWsOnly
+            ? `▶ 修正のヒント: 間に挟まる空行 ${w.extraCount} 行の差は自動で吸収されます。この失敗の原因は空行ではなく、空白の個数のみ異なる行 (~) です。`
+            : `▶ 修正のヒント: SEARCH の全行はこの順で実ファイルに存在しますが、間に空行 ${w.extraCount} 行が挟まっています。`
+        : `▶ 修正のヒント: SEARCH の全行はこの順で実ファイルに存在しますが、間に SEARCH にない行が ${w.extraCount} 行 (うち空行 ${w.extraBlankCount} 行) 挟まっています。空行の差は自動で吸収されますが、内容のある行の欠落は吸収されません。`;
+    return [
+        "",
+        head,
+        "上の抜粋の「│」より右側を、+ の行も含めてそのままコピーした SEARCH に置き換えれば一致します。",
+    ];
+}
 /** 失敗レポートに埋め込む診断テキスト。抜粋行は「│」の右側が実ファイルの verbatim */
 export function renderNearest(a) {
     const out = ["#### 参考: 実ファイルの該当箇所 (petari が現在のファイル内容から自動抽出)"];
@@ -161,18 +342,26 @@ export function renderNearest(a) {
         return out;
     }
     const w = a.window;
-    out.push("", `最も近い領域 (SEARCH ${w.total} 行中 ${w.matchCount} 行が一致):`, "```");
-    for (const line of w.lines.slice(0, MAX_RENDER_LINES)) {
-        const mark = line.verdict === null ? " " : MARK[line.verdict];
-        out.push(`${mark} ${String(line.lineNo).padStart(5)}│${line.text}`);
-    }
-    if (w.lines.length > MAX_RENDER_LINES) {
-        out.push(`… (以下 ${w.lines.length - MAX_RENDER_LINES} 行省略)`);
-    }
-    out.push("```", "凡例: ! = SEARCH と内容が異なる行 / ~ = 空白の個数のみ異なる行 / = = 一致した行 / 無印 = 前後の文脈");
-    for (const line of w.lines) {
-        if (line.note !== undefined)
-            out.push(`- ${line.lineNo} 行目: ${line.note}`);
-    }
+    out.push("", `最も近い領域 (SEARCH ${w.total} 行中 ${w.matchCount} 行が一致):`);
+    out.push(...renderWindowBody(w, a.subject));
+    out.push(...buildHint(w));
     return out;
 }
+/**
+ * SEARCH がどの行も見つからなかったときの補助診断: REPLACE 側の内容に近い実ファイル領域。
+ * 「本来変更を当てたかった箇所」の推定と、変更が既に別の形で入っている可能性の提示に使う。
+ */
+export function renderNearestReplace(a) {
+    if (a.window === null)
+        return [];
+    const w = a.window;
+    return [
+        "#### 参考: REPLACE 側の内容に近い実ファイル領域",
+        "(SEARCH はどの行も見つかりませんでしたが、REPLACE の内容に近い箇所が実ファイルにあります。",
+        "この変更が既に別の形で適用されているか、SEARCH の基準にしたスナップショットが古い可能性が",
+        "あります。変更がまだ必要な場合は、以下の抜粋を現在の内容として SEARCH を作り直してください)",
+        "",
+        `最も近い領域 (REPLACE ${w.total} 行中 ${w.matchCount} 行が一致):`,
+        ...renderWindowBody(w, a.subject),
+    ];
+}

package/dist/core/report.js

@@ -1,13 +1,16 @@
 import { STAGE_LABEL } from "./matcher.js";
-import { renderNearest } from "./nearest.js";
+import { renderNearest, renderNearestReplace } from "./nearest.js";
 const MATCH_SPEC_NOTE = [
     "## petari の照合仕様 (SEARCH を修正する前に必ず読んでください)",
     "",
-    "- petari は行末空白・インデントの深さ (タブ/スペース混在含む)・改行コード・文字コード",
-    "  (UTF-8 / Shift_JIS) の違いを自動で吸収して照合しています",
-    "- したがって「SEARCH が見つかりません」は空白・インデント・エンコーディングの問題では",
-    "  ありません。行の文字内容そのものが現在のファイルと異なっています",
-    "- 空白の調整・ASCII 行だけへの縮小・別アンカーへの乗り換えでは解決しません。各失敗に",
+    "- petari は行末空白・インデントの深さ (タブ/スペース混在含む)・空行の位置と数・改行コード・",
+    "  文字コード (UTF-8 / Shift_JIS) の違いを自動で吸収して照合しています",
+    "- 空行の差は双方から空行を除いた照合で吸収されます。ただし空行を除くと複数箇所に一致して",
+    "  しまう場合は曖昧エラーになります (前後の行を追加して一意に特定できる範囲にしてください)",
+    "- したがって「SEARCH が見つかりません」は空白・空行・インデント・エンコーディングの問題では",
+    "  ありません。内容のある行の文字内容か、その過不足が現在のファイルと異なっています",
+    "  (抜粋では実ファイル側にだけある行を + で示します)",
+    "- 行内空白や空行の調整・ASCII 行だけへの縮小・別アンカーへの乗り換えでは解決しません。各失敗に",
     "  添付した「実ファイルの該当箇所」の抜粋から、行をそのままコピーしてください",
 ];
 const RE_REQUEST = `## 依頼
@@ -15,7 +18,8 @@ const RE_REQUEST = `## 依頼
 上記の失敗した各ブロックについて、SEARCH 部分を現在のファイル内容と完全に一致するよう修正し、
 changes.md 全体を元の規約フォーマット (## CHANGES から始まる形式) で再出力してください。
 - SEARCH の修正には「実ファイルの該当箇所」の抜粋を使い、「│」より右側を一字一句そのまま
-  コピーしてください (行頭の「! ~ =」の記号と行番号は含めません)
+  コピーしてください (行頭の「! ~ = +」の記号と行番号は含めません。+ の行 (空行含む) も
+  SEARCH に含めます)
 - SEARCH ブロックにはファイル内で一意に特定できる範囲を含めてください
 - 失敗していないファイル・ブロックも含めた完全な changes.md を出力してください
 - 抜粋にも SEARCH に相当する行が見当たらない場合は、推測で書き換えず、その旨を報告して
@@ -62,8 +66,56 @@ function outcomeSummary(outcomes) {
             lines.push(`    - ブロック ${index}: ${status}`);
         }
     }
+    lines.push(...remainingSummary(outcomes));
     return lines;
 }
+/**
+ * 「残り何ブロックを直せば全適用できるか」の構造化サマリ (§7)。
+ * all-or-nothing の設計上、あと 1 ブロックで全通しの状態を明示すると再出力の
+ * 修正ポイントが絞れる (2026-08-25 実運用フィードバック)。
+ */
+function remainingSummary(outcomes) {
+    let totalUnits = 0;
+    let failedUnits = 0;
+    for (const o of outcomes) {
+        if (o.change.op === "replace" && o.totalBlocks > 0) {
+            totalUnits += o.totalBlocks;
+            const fileLevel = o.failures.some((f) => f.block === undefined);
+            failedUnits += fileLevel ? o.totalBlocks : o.failures.length;
+        }
+        else {
+            totalUnits += 1;
+            if (o.failures.length > 0)
+                failedUnits += 1;
+        }
+    }
+    if (failedUnits === 0 || failedUnits >= totalUnits)
+        return [];
+    const passed = totalUnits - failedUnits;
+    return [
+        "",
+        failedUnits === 1
+            ? `→ 失敗は全 ${totalUnits} ブロック中この 1 ブロックだけです。この 1 ブロックの SEARCH を修正すれば全体が適用可能になります。`
+            : `→ 全 ${totalUnits} ブロック中 ${passed} ブロックは検証を通過しています。残る ${failedUnits} ブロックの SEARCH を修正すれば全体が適用可能になります。`,
+    ];
+}
+/**
+ * blank-insensitive (空行差無視) で一致したブロックがあるときの注記 (§6)。
+ * 空行の並びが SEARCH の指定どおりにならない可能性を dry-run と適用サマリの末尾で知らせる。
+ * 該当ブロックが無ければ null。
+ */
+export function buildBlankInsensitiveNote(outcomes) {
+    let count = 0;
+    for (const o of outcomes) {
+        for (const b of o.appliedBlocks) {
+            if (b.stage === "blank-insensitive")
+                count++;
+        }
+    }
+    if (count === 0)
+        return null;
+    return `注: ${count} 件のブロックは空行の差を吸収して適用しました (git diff で空行の並びを確認してください)`;
+}
 /** 検証失敗 (マッチング・パス・エンコーディング) のレポート */
 export function buildFailureReport(failures, ctx = {}) {
     const parts = ["以下の変更ブロックが現在のコードベースに適用できませんでした。"];
@@ -83,6 +135,9 @@ export function buildFailureReport(failures, ctx = {}) {
         if (f.nearest !== undefined) {
             parts.push("", ...renderNearest(f.nearest));
         }
+        if (f.nearestReplace !== undefined) {
+            parts.push("", ...renderNearestReplace(f.nearestReplace));
+        }
     }
     parts.push("", RE_REQUEST, "");
     return parts.join("\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "petari",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "petari — paste AI chat patches onto your codebase",
   "keywords": [
     "cli",