@agjs/tsforge 0.2.1 → 0.2.3

package/package.json

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

package/scripts/sweep.ts

@@ -6,7 +6,7 @@
 import { mkdir, readdir, rm, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { parseSpec } from "../src/spec";
-import { buildGate, prettierWriteCommand } from "../src/detect-gate";
+import { buildGate, buildCoreFix } from "../src/detect-gate";
 import { runSpec, qualityRepair } from "../src/loop";
 import { modelAgent } from "../src/agent";
 import { OpenAICompatibleProvider } from "../src/inference";
@@ -258,17 +258,22 @@ async function runOne(
     // (an unguarded index access, an `as any`) slipped through as GREEN. Now
     // every task and the whole-spec verify must clear the strict floor BEFORE
     // its functional tests count.
-    // prettier --write FIRST (auto-format), then tsc-strict + eslint. The model
-    // never hand-formats, but the gate still enforces type-safety + idioms.
-    const strictGate = `${prettierWriteCommand()} && ${(await buildGate(runDir)).command}`;
+    // buildCoreFix (eslint --fix + prettier) runs as task.fix before each gate
+    // check — same janitor as the interactive CLI — so padding-line, prefer-const,
+    // etc. are squashed without model turns.
+    const gateCommand = (await buildGate(runDir)).command;
+    const fixCommand = buildCoreFix();
     const gatedSpec = {
       ...spec,
       tasks: spec.tasks.map((t) => ({
         ...t,
-        accept: `${strictGate} && ${t.accept}`,
+        fix: fixCommand,
+        accept: `${gateCommand} && ${t.accept}`,
       })),
       verify:
-        spec.verify.length > 0 ? `${strictGate} && ${spec.verify}` : strictGate,
+        spec.verify.length > 0
+          ? `${gateCommand} && ${spec.verify}`
+          : gateCommand,
     };
 
     // Every run gets a full transcript at <runDir>/run.log; stream to the

package/src/cli.ts

@@ -38,6 +38,7 @@ import {
   buildGate,
   buildWebGate,
   buildWebFix,
+  buildCoreFix,
   buildWebTypeGate,
   buildWebTscCheck,
   scaffoldWeb,
@@ -903,7 +904,7 @@ async function repl(args: ICliArgs): Promise<number> {
           fix: buildWebFix("react"),
           incrementalCheck: buildWebTscCheck(),
         }
-      : { scaffoldWeb: true }),
+      : { scaffoldWeb: true, fix: buildCoreFix() }),
     ...(thinkingTokenBudget === undefined ? {} : { thinkingTokenBudget }),
     ...(autoCompactAt === undefined ? {} : { autoCompactAt }),
     // Thinking OFF for interactive replies so they STREAM immediately instead of

package/src/detect-gate.ts

@@ -462,6 +462,22 @@ export function buildWebFix(framework: WebFramework): string {
   return `${lintFix} ; ${format}`;
 }
 
+/**
+ * The core (non-web) auto-fix command — same janitor as buildWebFix but uses the
+ * bundled strict.eslint.config.mjs. Run BEFORE the gate each cycle so padding-line,
+ * prefer-const, curly, etc. are squashed without model turns.
+ */
+export function buildCoreFix(): string {
+  const lintFix =
+    `"${ESLINT_BIN}" --no-config-lookup -c "${STRICT_CONFIG}" --fix .`.replace(
+      /\s+/g,
+      " "
+    );
+  const format = `"${PRETTIER_BIN}" --write .`;
+
+  return `${lintFix} ; ${format}`;
+}
+
 async function ensureFile(
   cwd: string,
   name: string,

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/strict.eslint.config.mjs

@@ -12,6 +12,7 @@
 // Rule overrides are loaded via TSFORGE_RULE_OVERRIDES env var (JSON-encoded
 // map of bare rule names to "error" | "warn" | "off").
 import tseslint from "typescript-eslint";
+import stylistic from "@stylistic/eslint-plugin";
 
 // Load stack-aware packs if TSFORGE_PACKS env var is set
 let packConfig = [];
@@ -52,7 +53,10 @@ export default tseslint.config(
   {
     files: ["**/*.ts", "**/*.tsx"],
     languageOptions: { parser: tseslint.parser },
-    plugins: { "@typescript-eslint": tseslint.plugin },
+    plugins: {
+      "@typescript-eslint": tseslint.plugin,
+      "@stylistic": stylistic,
+    },
     rules: {
       // The idioms the model habitually violates — all caught WITHOUT type info.
       "@typescript-eslint/consistent-type-assertions": [
@@ -69,6 +73,25 @@ export default tseslint.config(
       "prefer-const": "error",
       "prefer-template": "error",
       "no-var": "error",
+      // Blank-line discipline — the model rarely gets spacing right, so
+      // eslint --fix + prettier make it free. Uses @stylistic (the rule's
+      // maintained home; the core rule is deprecated and spams usedDeprecatedRules
+      // into eslint's --format json gate output).
+      "@stylistic/padding-line-between-statements": [
+        "error",
+        { blankLine: "always", prev: "import", next: "*" },
+        { blankLine: "any", prev: "import", next: "import" },
+        { blankLine: "always", prev: "*", next: "return" },
+        { blankLine: "always", prev: "*", next: "throw" },
+        { blankLine: "always", prev: ["const", "let", "var"], next: "*" },
+        {
+          blankLine: "any",
+          prev: ["const", "let", "var"],
+          next: ["const", "let", "var"],
+        },
+        { blankLine: "always", prev: "block-like", next: "*" },
+        { blankLine: "always", prev: "*", next: "block-like" },
+      ],
       eqeqeq: ["error", "always"],
       curly: ["error", "all"],
       "no-restricted-syntax": [