@adeu/core 1.18.0 → 1.18.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adeu/core",
-  "version": "1.18.0",
+  "version": "1.18.1",
   "description": "",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/engine.feedback.test.ts

@@ -31,7 +31,11 @@ describe("Feedback Layer & Dry Run Verification", () => {
     expect(stats.version).toBeDefined();
   });
 
-  it("punctuation anchor triggers warning", async () => {
+  it("punctuation anchor: no warning on clean apply", async () => {
+    // A punctuated anchor that matches and applies cleanly must NOT raise the
+    // tokenization-splitting warning. The redline preview already reports the
+    // change; a warning here is a false positive that pushes agents into
+    // needless "cleaner anchor" retries.
     const doc = await createTestDocument();
     addParagraph(doc, "Refer to sample_term_name in Section 4.");
     const engine = new RedlineEngine(doc, "Reviewer TS");
@@ -41,9 +45,37 @@ describe("Feedback Layer & Dry Run Verification", () => {
     ]);
 
     const report = stats.edits[0];
+    expect(report.status).toBe("applied");
+    expect(report.warning).toBeNull();
+
+    // Same expectation under dry_run.
+    const doc2 = await createTestDocument();
+    addParagraph(doc2, "Refer to sample_term_name in Section 4.");
+    const engine2 = new RedlineEngine(doc2, "Reviewer TS");
+    const dryStats = (engine2 as any).process_batch([
+      { type: "modify", target_text: "sample_term_name", new_text: "validated_term_name" }
+    ], true);
+    const dryReport = dryStats.edits[0];
+    expect(dryReport.status).toBe("applied");
+    expect(dryReport.warning).toBeNull();
+  });
+
+  it("punctuation anchor: warns only when match fails", async () => {
+    // When a punctuated anchor fails to match, the warning IS surfaced as
+    // recovery context (the punctuation may be why the match missed).
+    const doc = await createTestDocument();
+    addParagraph(doc, "Refer to sample_term_name in Section 4.");
+    const engine = new RedlineEngine(doc, "Reviewer TS");
+
+    const stats = (engine as any).process_batch([
+      { type: "modify", target_text: "phantom_term-x", new_text: "anything" }
+    ], true);
+
+    const report = stats.edits[0];
+    expect(report.status).toBe("failed");
     expect(report.warning).not.toBeNull();
     expect(report.warning.toLowerCase()).toContain("punctuation");
-    expect(report.warning).toContain("sample_term_name");
+    expect(report.warning).toContain("phantom_term-x");
   });
 
   it("dry_run does not mutate and reports safely", async () => {

package/src/engine.ts

@@ -322,8 +322,19 @@ export class RedlineEngine {
     this.comments_manager = new CommentsManager(this.doc);
   }
 
+  /**
+   * Return a hint when a short, single-token anchor contains punctuation that
+   * can split awkwardly, else null.
+   *
+   * Surface this ONLY for edits that actually failed to match/apply. On a
+   * successful edit the batch report already carries the redline preview, so
+   * emitting this would be a false positive: the punctuation (dates,
+   * `[_name_]` placeholders, `____` blanks) is frequently the literal target
+   * and the edit succeeds despite it. Mirrors the Python engine.
+   */
   private _check_punctuation_warning(target_text: string): string | null {
     if (!target_text) return null;
+    if (target_text.length > 20 || target_text.includes(" ")) return null;
     if (target_text.includes("_") || target_text.includes("-")) {
       return `Warning: target_text '${target_text}' contains tokenization-splitting punctuation ('_' or '-'). This can trigger mid-word splits in the diff engine. Consider using a longer plain-prose anchor.`;
     }
@@ -1894,11 +1905,16 @@ export class RedlineEngine {
         for (let i = 0; i < edits.length; i++) {
           const edit = edits[i];
           const single_errors = this.validate_edits([edit], i);
-          const warning = this._check_punctuation_warning(
-            (edit as any).target_text || "",
-          );
           if (single_errors.length > 0) {
             skipped_edits++;
+            // Only surface the punctuation-anchor warning when the edit actually
+            // failed. A clean apply already returns the redline preview, so the
+            // warning is pure noise on success — and it misleads agents into
+            // hunting for a "cleaner" anchor that was never needed (e.g. on
+            // placeholders/dates where the punctuation IS the literal target).
+            const warning = this._check_punctuation_warning(
+              (edit as any).target_text || "",
+            );
             edits_reports.push({
               status: "failed",
               target_text: (edit as any).target_text || "",
@@ -1918,7 +1934,7 @@ export class RedlineEngine {
               status: "applied",
               target_text: (edit as any).target_text || "",
               new_text: (edit as any).new_text || "",
-              warning: warning,
+              warning: null,
               error: null,
               critic_markup: previews[0],
               clean_text: previews[1],
@@ -1935,6 +1951,9 @@ export class RedlineEngine {
               this.skipped_details.length > 0
                 ? this.skipped_details[this.skipped_details.length - 1]
                 : "Failed to apply edit";
+            const warning = this._check_punctuation_warning(
+              (edit as any).target_text || "",
+            );
             edits_reports.push({
               status: "failed",
               target_text: (edit as any).target_text || "",
@@ -1983,15 +2002,19 @@ export class RedlineEngine {
         for (const edit of edits) {
           const success = (edit as any)._applied_status || false;
           const error_msg = (edit as any)._error_msg || null;
-          const warning = this._check_punctuation_warning(
-            (edit as any).target_text || "",
-          );
           let critic_markup = null;
           let clean_text = null;
+          // Punctuation-anchor warning is failure-context only: on success the
+          // redline preview below already reports the change cleanly.
+          let warning: string | null = null;
           if (success) {
             const previews = this._build_edit_context_previews(edit);
             critic_markup = previews[0];
             clean_text = previews[1];
+          } else {
+            warning = this._check_punctuation_warning(
+              (edit as any).target_text || "",
+            );
           }
           edits_reports.push({
             status: success ? "applied" : "failed",