omp-conductor 0.5.1 → 0.5.2

package/README.md

@@ -167,7 +167,8 @@ Also required on the host:
   account is invisible to the service. A unit running `User=fleet` cannot see
   `root`'s login, and workers then die at turn 0 with `No model selected`. Such a
   run is classified `env-start-failure` and charges **neither** the failure budget
-  nor a continuation — an environment fault is not a failed implementation — but
+  nor a continuation — an environment fault is not a failed implementation, and a
+  run that recorded no turn, no commit and no error did not attempt anything — but
   nothing dispatches successfully until the credential is reachable.
 - `gh`, already authenticated: every tracker operation shells out to it, so the
   daemon never handles a GitHub token itself.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omp-conductor",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "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

@@ -65,10 +65,11 @@ function normalise(state: string): string {
 /**
  * Harness start failures, matched on the text it prints.
  *
- * Deliberately a small closed list rather than "anything at turn 0": a run that
- * ended at turn 0 for a reason nobody has named is exactly what `unknown` is for,
- * and quietly declaring it an environment fault would waive an attempt that may
- * have been genuinely spent.
+ * A small closed list rather than "any error at turn 0": a run that ended at
+ * turn 0 with an error nobody has named is exactly what `unknown` is for, and
+ * declaring that an environment fault would waive an attempt that may have been
+ * genuinely spent. A mirror fetch that failed is not a session that never
+ * started.
  */
 const START_FAILURE_SIGNATURES = [
   "no model selected",
@@ -90,6 +91,42 @@ export function startFailure(lastError: string | undefined): string | undefined
   return hit === undefined ? undefined : lastError.split("\n")[0]?.trim();
 }
 
+/**
+ * Evidence that this run never started, or `undefined` when something did happen.
+ *
+ * Two shapes, and the second is the one the reference fleet actually produced.
+ *
+ * 1. Turn zero with a recognised harness start error — the session said why.
+ * 2. Turn zero, **no artifacts and no error text at all**. The row records
+ *    nothing: no turn, no head, no salvage, not even a message. On the reference
+ *    fleet every worker died at turn 0 with `No model selected`, and that string
+ *    went into the tier-1 escalation rather than into `lastError` — so the rows
+ *    for issues 373, 359, 343 and 319 carry no error whatsoever and were logged
+ *    `unknown`, each charging an implementation attempt (#152).
+ *
+ * Shape 2 is a deliberate judgement, not a loosening. There is no evidence an
+ * attempt was spent, so charging one is charging for a run whose only trace is
+ * that it existed; and the two ways of being wrong are not symmetric — being
+ * generous grants an issue one more attempt a human will see, while being strict
+ * leaves it permanently undispatchable for a fault that was never in its code.
+ * A turn-0 run carrying an *unrecognised* error still reads `unknown`, because
+ * there the row does say something happened.
+ *
+ * Shared with the store's one-time repair so history and future agree.
+ */
+export function neverStarted(
+  run: Pick<RunRecord, "turns" | "lastError" | "prUrl" | "headSha" | "salvageSha">,
+): string | undefined {
+  if (run.turns !== 0) return undefined;
+  const detail = startFailure(run.lastError);
+  if (detail !== undefined) return `the session never started: ${detail}`;
+  const produced = run.prUrl !== undefined || run.headSha !== undefined || run.salvageSha !== undefined;
+  if (!produced && run.lastError === undefined) {
+    return "the session never started: no turns, no commit and no error were recorded";
+  }
+  return undefined;
+}
+
 export function classifyRun(run: RunRecord, facts: ClassifyFacts): Classification {
   const hasArtifacts = run.prUrl !== undefined || run.headSha !== undefined || run.salvageSha !== undefined;
 
@@ -113,19 +150,14 @@ export function classifyRun(run: RunRecord, facts: ClassifyFacts): Classificatio
     };
   }
 
-  // Turn zero with an explicit harness start error is the most classifiable
-  // failure there is, and the least deserving of an implementation attempt: the
-  // session never got as far as reading the issue. 27 recoveries on the reference
-  // fleet were this, logged as `unknown` while the session's own output carried
-  // the literal string `No model selected` (#152).
-  if ((run.state === "failed" || run.state === "killed") && run.turns === 0) {
-    const detail = startFailure(run.lastError);
-    if (detail !== undefined) {
-      return {
-        cls: "env-start-failure",
-        recovery: "escalate",
-        evidence: `the session never started: ${detail}`,
-      };
+  // A run that never started is the most classifiable failure there is, and the
+  // least deserving of an implementation attempt: the session did not get as far
+  // as reading the issue. See {@link neverStarted} for the two shapes and why the
+  // second one counts.
+  if (run.state === "failed" || run.state === "killed") {
+    const evidence = neverStarted(run);
+    if (evidence !== undefined) {
+      return { cls: "env-start-failure", recovery: "escalate", evidence };
     }
   }
 

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 { startFailure } from "./failure-class.ts";
+import { neverStarted } from "./failure-class.ts";
 import type {
   DecisionDraft,
   FailureClass,
@@ -693,18 +693,32 @@ export function openStore(dbPath: string): Store {
   // charged, and an issue sitting at its cap for a fault that was never in its
   // code stays undispatchable forever.
   //
-  // Narrow by construction: `turns = 0` (the session never took a turn), an
-  // error the classifier itself recognises as a start failure, and a class of
+  // Narrow by construction, and narrow through the CLASSIFIER's own predicate
+  // rather than a second copy of the rule: {@link neverStarted}. A class of
   // exactly `unknown` — a row a human or a later release classified as anything
-  // else is left alone. Idempotent for free: afterwards those rows read
-  // `env-start-failure`, which the WHERE no longer matches.
+  // else is left alone — plus zero turns and either a recognised start error or
+  // nothing recorded at all. A turn-0 row carrying an unrecognised error (a
+  // failed mirror fetch, say) is untouched. Idempotent for free: afterwards these
+  // rows read `env-start-failure`, which the WHERE no longer matches.
   const misread = db
     .query<
-      { id: string; lastError: string | null },
+      { id: string; lastError: string | null; prUrl: string | null; headSha: string | null; salvageSha: string | null },
       []
-    >(`SELECT id, lastError FROM runs WHERE failureClass = 'unknown' AND turns = 0 AND lastError IS NOT NULL`)
+    >(
+      `SELECT id, lastError, prUrl, headSha, salvageSha FROM runs
+        WHERE failureClass = 'unknown' AND turns = 0`,
+    )
     .all()
-    .filter((row) => startFailure(row.lastError ?? undefined) !== undefined);
+    .filter(
+      (row) =>
+        neverStarted({
+          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 (misread.length > 0) {
     const reclassify = db.query<unknown, [string]>(
       `UPDATE runs SET failureClass = 'env-start-failure' WHERE id = ?`,