@agjs/tsforge 0.2.2 → 0.2.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agjs/tsforge",
   "type": "module",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "license": "MIT",
   "description": "TypeScript coding harness with a deterministic gate, stack-aware guardrails, and stream-level correction.",
   "repository": {

package/src/eval/failure-class.ts

@@ -12,7 +12,8 @@ export const FAILURE_CLASS = {
   none: "none",
   /** Model emitted tool calls the parser couldn't read (repair L3 / salvage). */
   toolMalformed: "tool-malformed",
-  /** Edits kept missing their target (missing-file / not-found / ambiguous). */
+  /** Edits/tool calls were rejected — missing target (missing-file / not-found /
+   *  ambiguous) or out-of-scope (the dispatcher's tool_rejected). */
   editReject: "edit-reject",
   /** Hit the turn cap or the gate stalled with no decisive error class. */
   noProgress: "no-progress",
@@ -44,6 +45,8 @@ export interface IFailureSignals {
   salvages: number;
   editRejects: number;
   degenerated: boolean;
+  timedOut: boolean;
+  toolUseFailed: boolean;
   tsErrors: number;
   lintErrors: number;
   missingModule: number;
@@ -60,10 +63,25 @@ export interface IFailureSummary {
 
 const TS_CODE = /^TS\d+$/;
 const MISSING_MODULE = /cannot find module/i;
-const DEGENERATE = /degenerat/i;
+// The terminal degeneration stops say "repetition loop" (run.ts, session.ts) —
+// NOT "degenerate". Match both the user-facing phrase and the internal term.
+const DEGENERATE = /repetition loop|degenerat/i;
+// Salvage telemetry on the tool channel ("recovered N malformed tool call(s)").
 const TOOL_MALFORMED = /salvage|recovered|malformed|re-ask/i;
+// Terminal stops where the model never produced usable tool calls: the leaked
+// malformed-tool-call stop and the narrate-instead-of-build stop (session.ts).
+const TOOL_USE_FAILED =
+  /malformed tool-call|writing files as chat|instead of creating them/i;
+// Edit/scope rejections surface on TWO channels: model-agent emits a `kind:"edit"`
+// "<file> — rejected (<reason>)"; the tool dispatcher emits `kind:"tool"`
+// "tool_rejected:" / "tool_input_rejected:". Both contain "reject".
 const REJECTED = /reject/i;
-const BROWSER = /blank|did not render|did not mount|page error|uncaught/i;
+// The TERMINAL timeout stop ("timed out repeatedly … stopped"), NOT the transient
+// per-turn re-steer ("timed out … re-steering (1/3)") — only the former ends a run.
+const TIMED_OUT = /timed out repeatedly/i;
+// The actual browser-oracle failure strings (oracle.ts): "rendered blank",
+// "app did not mount", "console error:", "uncaught:", "route X failed to load".
+const BROWSER = /blank|did not mount|console error|uncaught|failed to load/i;
 const ROUTE = /route|phantom|stub/i;
 const BUILD = /vite|esbuild|build failed|bundl/i;
 
@@ -146,10 +164,15 @@ function gatherSignals(
     salvages: events.filter(
       (e) => e.kind === "tool" && TOOL_MALFORMED.test(e.message)
     ).length,
+    // Rejections come on both the "edit" channel (model-agent) and the "tool"
+    // channel (dispatcher: tool_rejected / tool_input_rejected).
     editRejects: events.filter(
-      (e) => e.kind === "edit" && REJECTED.test(e.message)
+      (e) =>
+        (e.kind === "edit" || e.kind === "tool") && REJECTED.test(e.message)
     ).length,
     degenerated: events.some((e) => DEGENERATE.test(e.message)),
+    timedOut: events.some((e) => TIMED_OUT.test(e.message)),
+    toolUseFailed: events.some((e) => TOOL_USE_FAILED.test(e.message)),
     tsErrors: rules.filter((r) => TS_CODE.test(r) && r !== "TS2307").length,
     lintErrors: rules.filter((r) => !TS_CODE.test(r)).length,
     missingModule,
@@ -203,11 +226,7 @@ function classifyGateErrors(
 
 /** Behavioral fallback when no gate-error class dominates. */
 function classifyBehavior(signals: IFailureSignals): FailureClass {
-  if (signals.degenerated) {
-    return FAILURE_CLASS.degeneration;
-  }
-
-  if (signals.salvages > 0 || signals.repairs > 0) {
+  if (signals.toolUseFailed || signals.salvages > 0 || signals.repairs > 0) {
     return FAILURE_CLASS.toolMalformed;
   }
 
@@ -234,6 +253,18 @@ export function classifyRun(
     return { failureClass: FAILURE_CLASS.none, signals };
   }
 
+  // A repeated request timeout is the terminal cause — the model couldn't even
+  // respond — so it outranks any stale gate error from an earlier turn.
+  if (signals.timedOut) {
+    return { failureClass: FAILURE_CLASS.timeout, signals };
+  }
+
+  // Likewise a repetition-loop stop: the run died because generation degenerated,
+  // not because of whatever the gate last reported.
+  if (signals.degenerated) {
+    return { failureClass: FAILURE_CLASS.degeneration, signals };
+  }
+
   if (signals.missingModule > 0) {
     return { failureClass: FAILURE_CLASS.hallucinatedImport, signals };
   }

package/src/files/hashline-format.ts

@@ -108,3 +108,22 @@ export function isValidHash(hash: string): boolean {
 export function normalizeHash(hash: string): string {
   return hash.toUpperCase();
 }
+
+/**
+ * Extract the 4-hex hash from a raw value that may be a full `¶path#HASH` tag,
+ * a `path#HASH`, a `#HASH`, or a bare `HASH`. The model frequently pastes the
+ * whole header tag (what it saw on read) into the `hash` arg, which then fails
+ * the staleness compare against a real 4-hex hash. Returns undefined when no
+ * valid hash is present.
+ */
+export function extractHash(raw: string | undefined): string | undefined {
+  if (raw === undefined) {
+    return undefined;
+  }
+
+  const candidate = raw.includes(HL_HASH_SEP)
+    ? raw.slice(raw.lastIndexOf(HL_HASH_SEP) + 1).trim()
+    : raw.trim();
+
+  return isValidHash(candidate) ? candidate : undefined;
+}

package/src/files/hashline.ts

@@ -10,6 +10,7 @@ import {
   computeFileHash,
   parseHashHeader,
   normalizeHash,
+  HL_HEADER_SIGIL,
 } from "./hashline-format";
 
 /**
@@ -318,26 +319,35 @@ export function parseHashlineEdit(input: string): {
 
   let i = 0;
 
-  // Parse file header
-  if (i < lines.length) {
-    const headerLine = lines[i] ?? "";
-    const parsed = parseHeaderLine(headerLine, errors);
+  // The `¶path#HASH` header is OPTIONAL. The model frequently sends bare ops
+  // (`delete 79..164`) — the path is already in the tool args and the hash
+  // comes from the `hash` arg — so only treat the first line as a header when
+  // it actually looks like one (a malformed sigil header is still an error).
+  const headerLine = lines[0] ?? "";
 
-    filePath = parsed.filePath;
-    fileHash = parsed.fileHash;
+  if (headerLine.startsWith(HL_HEADER_SIGIL)) {
+    const parsed = parseHeaderLine(headerLine, errors);
 
-    if (filePath.length > 0) {
-      i++;
-    } else if (errors.length > 0) {
+    if (errors.length > 0) {
       return { filePath: "", fileHash: undefined, ops: [], errors };
-    } else if (headerLine.trim() === "") {
-      i++;
     }
+
+    filePath = parsed.filePath;
+    fileHash = parsed.fileHash;
+    i = 1;
+  } else if (headerLine.trim() === "") {
+    i = 1;
   }
 
   // Parse operations
   const ops = parseOperations(lines, i, errors);
 
+  if (ops.length === 0 && errors.length === 0) {
+    errors.push(
+      "No edit operations found. Provide replace/delete/insert ops (optionally after a ¶path#HASH header)."
+    );
+  }
+
   return { filePath, fileHash, ops, errors };
 }
 

package/src/loop/tools/edit-hashline.ts

@@ -3,6 +3,7 @@ import {
   parseHashlineEdit,
   SessionSnapshotStore,
 } from "../../files/hashline";
+import { extractHash } from "../../files/hashline-format";
 import { parseOrRepair, reject, type IToolContext } from "./tool-context";
 import { toHashlineEdit } from "../../agent";
 
@@ -50,11 +51,17 @@ export async function doHashlineEdit(
   // Ensure the store exists on the context
   ctx.snapshotStore ??= new SessionSnapshotStore();
 
+  // Hash source priority: the `¶path#HASH` header the model wrote in `input`
+  // (the format it saw on read), else the `hash` arg — tolerantly extracted so
+  // a pasted full tag (`¶path#HASH`) still yields the bare hash. Using the raw
+  // arg directly caused false stale-anchor rejections on unchanged files.
+  const fileHash = parsed.fileHash ?? extractHash(edit.hash);
+
   const result = await applyHashlineEdit(
     ctx.snapshotStore,
     ctx.cwd,
     edit.file,
-    edit.hash,
+    fileHash,
     parsed.ops
   );