omp-conductor 0.7.0 → 0.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omp-conductor",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "type": "module",
   "license": "MIT",
   "description": "A 24/7 dispatcher that takes ready GitHub issues to green, mergeable PRs using omp coding sessions, with tiered escalation first to an orchestrator session and then to a human.",

package/src/failure-class.ts

@@ -149,6 +149,35 @@ export function neverStarted(
   return undefined;
 }
 
+/**
+ * Evidence that the conductor's own git path failed before the worker's first
+ * turn, or `undefined` when this row is something else.
+ *
+ * A mirror ref-lock (#168), a dead mirror, a transiently unreachable host: the
+ * worker never touched the issue, so none of this should charge an
+ * implementation attempt. `lastError` of this shape is written only by the
+ * dispatch catch (`errText(err)` = the stack, which prefixes the thrown
+ * "git … exited N: …" message with "Error: ") and by state messages — never by
+ * a worker — so it is proof of the daemon's own git rather than a worker's
+ * failed push.
+ *
+ * Exported for the same reason {@link neverStarted} is: the store's one-time
+ * repair has to recognise exactly what the classifier does, or history and
+ * future disagree about which rows were the daemon's fault.
+ */
+export function dispatchInfra(
+  run: Pick<RunRecord, "turns" | "lastError" | "prUrl" | "headSha" | "salvageSha">,
+): string | undefined {
+  if (run.turns !== 0) return undefined;
+  if (run.prUrl !== undefined || run.headSha !== undefined || run.salvageSha !== undefined) return undefined;
+  if (run.lastError === undefined || !DISPATCH_GIT_ERROR.test(run.lastError)) return undefined;
+  return `dispatch failed in the conductor's own git path before turn 1: ${run.lastError.split("\n")[0]}`;
+}
+
+// See {@link dispatchInfra}: the "Error: " prefix is what `errText` puts in
+// front of the thrown message, so a bare /^git / would never match a real row.
+const DISPATCH_GIT_ERROR = /^(?:Error: )?git .+ exited \d+/s;
+
 export function classifyRun(run: RunRecord, facts: ClassifyFacts): Classification {
   const hasArtifacts = run.prUrl !== undefined || run.headSha !== undefined || run.salvageSha !== undefined;
 
@@ -184,25 +213,13 @@ export function classifyRun(run: RunRecord, facts: ClassifyFacts): Classificatio
   }
 
   // Dispatch infra: the conductor's own git path failed before the worker's
-  // first turn — a mirror ref-lock (#168), a dead mirror, a transiently
-  // unreachable host. The worker never touched the issue, so this should not
-  // charge an implementation attempt. `lastError` here is written only by the
-  // dispatch catch (`errText(err)` = the stack, which prefixes the thrown
-  // "git … exited N: …" message with "Error: ") and by state messages — never
-  // by a worker — so that shape is proof of the daemon's own git, not a
-  // worker's failed push.
-  if (
-    run.state === "failed" &&
-    run.turns === 0 &&
-    !hasArtifacts &&
-    run.lastError !== undefined &&
-    /^(?:Error: )?git .+ exited \d+/s.test(run.lastError)
-  ) {
-    return {
-      cls: "dispatch-infra",
-      recovery: "requeue",
-      evidence: `dispatch failed in the conductor's own git path before turn 1: ${run.lastError.split("\n")[0]}`,
-    };
+  // first turn. See {@link dispatchInfra} — the worker never touched the issue,
+  // so this must not charge an implementation attempt.
+  if (run.state === "failed") {
+    const evidence = dispatchInfra(run);
+    if (evidence !== undefined) {
+      return { cls: "dispatch-infra", recovery: "requeue", evidence };
+    }
   }
 
   if (run.state === "blocked") {

package/src/store.ts

@@ -15,7 +15,7 @@ import { dirname, join } from "node:path";
 
 import { stateDir } from "./config.ts";
 import { DECISION_TTL_MS, DEFAULT_CAPS } from "./types.ts";
-import { neverStarted } from "./failure-class.ts";
+import { dispatchInfra, neverStarted } from "./failure-class.ts";
 import type {
   DecisionDraft,
   FailureClass,
@@ -726,6 +726,48 @@ export function openStore(dbPath: string): Store {
     for (const row of misread) reclassify.run(row.id);
   }
 
+  // The same repair, for the case the one above deliberately leaves alone: its
+  // comment names it exactly ("a turn-0 row carrying an unrecognised error (a
+  // failed mirror fetch, say) is untouched"). #177 gave that fault a name, but
+  // only for rows written after it existed. Every earlier one was logged
+  // `unknown`, whose recovery is `escalate` — so `runsNeedingClassification`
+  // never revisits it and `countFailures` counts it forever. With
+  // `maxAttemptsPerIssue` defaulting to 2, a single mirror ref-lock is half an
+  // issue's entire budget spent on a fault that was never in its code.
+  //
+  // Narrow the same way: exactly `unknown`, state `failed`, and the
+  // CLASSIFIER's own predicate rather than a second copy of the rule.
+  // Deliberately only `failureClass` — not `recoveryAction`/`recoveredAt`.
+  // Relieving the budget is the point; re-animating a months-old run into the
+  // requeue sweep is not, and clearing the recovery columns would do exactly
+  // that. Idempotent for free: these rows then read `dispatch-infra`, which the
+  // WHERE no longer matches.
+  const mirrorBroke = db
+    .query<
+      { id: string; lastError: string | null; prUrl: string | null; headSha: string | null; salvageSha: string | null },
+      []
+    >(
+      `SELECT id, lastError, prUrl, headSha, salvageSha FROM runs
+        WHERE failureClass = 'unknown' AND turns = 0 AND state = 'failed'`,
+    )
+    .all()
+    .filter(
+      (row) =>
+        dispatchInfra({
+          turns: 0,
+          ...(row.lastError === null ? {} : { lastError: row.lastError }),
+          ...(row.prUrl === null ? {} : { prUrl: row.prUrl }),
+          ...(row.headSha === null ? {} : { headSha: row.headSha }),
+          ...(row.salvageSha === null ? {} : { salvageSha: row.salvageSha }),
+        }) !== undefined,
+    );
+  if (mirrorBroke.length > 0) {
+    const reclassify = db.query<unknown, [string]>(
+      `UPDATE runs SET failureClass = 'dispatch-infra' WHERE id = ?`,
+    );
+    for (const row of mirrorBroke) reclassify.run(row.id);
+  }
+
   const insertRun = db.query<unknown, SqlValue[]>(
     `INSERT INTO runs (
        id, project, issue, repo, branch, worktree, state, attempt, turns,