clearotron 0.5.0-beta.2 → 0.5.0-beta.4

package/driver/parts-not-completed.mjs

@@ -17,35 +17,40 @@
 //
 // ONCE PER PART. The catch never writes a part whose record already exists: a failure on the pass that delivers
 // without it ends the run as it always did, with the stop notice, and the record is removed then, so a later resume
-// tries the part again.
+// tries the part again. The searches are the one part whose record grows: each failure names the slices it could not
+// prove ran, and a failure that names a slice the record does not hold yet adds it; one that names none new ends the
+// run, so the run still ends.
 //
-// A pure leaf: node:fs, node:path and shared/driver-dir.mjs only.
+// A pure leaf: node:fs, node:path, shared/driver-dir.mjs and shared/slices-taken-out.mjs (node:fs and the same) only.
 import { readFileSync, writeFileSync, renameSync, rmSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { driverDir, ensureDriverDir } from "../shared/driver-dir.mjs";
+// Where the record sits is stated with the band readers outside the driver, which read the searches' record too.
+import { NOT_COMPLETED_DIR, notCompletedPath } from "../shared/slices-taken-out.mjs";
 
-export const NOT_COMPLETED_DIR = "not-completed";
+export { NOT_COMPLETED_DIR, notCompletedPath };
 
 // The covered parts. `assessment` is the run's overall assessment: placement, the register write-up and synthesis, and
 // everything built from them. `review` is the first review of the assessment, whose verdict the sign-off is. `overview`
 // is the report overview, the conclusion under the rating. `delivery` is the
 // changed-material check before publishing: it never delivers past staleness, and its record buys the report one more
-// assembly from the current material instead of the stop notice.
-export const NOT_COMPLETED_PARTS = Object.freeze(["assessment", "review", "overview", "delivery"]);
-
-/** The record's path for `part`. */
-export function notCompletedPath(runDir, part) {
-  return driverDir(runDir, NOT_COMPLETED_DIR, `${part}.json`);
-}
+// assembly from the current material instead of the stop notice. `searches` is the register's searches: the slices a
+// check could not prove ran, each with its axis, its qid and the reason it is open, taken out of the band and
+// delivered as open rows; the axes whose pass was killed at its time limit, read as the last pass left them and
+// disclosed, their clean claims open (`disclosed_axes`); and the units that wrote no result once their attempts were
+// spent, delivered as their bands stand and not sent again (`unfinished_units`).
+export const NOT_COMPLETED_PARTS = Object.freeze(["assessment", "review", "overview", "delivery", "searches"]);
 
 /**
  * Record that `part` could not be completed. `stage` is the stage that failed, `reason` its cause for the run's record
  * (never a reader's cell), `sig` and `terminalKind` what the recovery decision said. Written through a temporary file
  * and a rename, so a reader never sees half a record. Returns the record.
  */
-export function writePartNotCompleted(runDir, part, { stage = null, reason = null, sig = null, terminalKind = null } = {}) {
+export function writePartNotCompleted(runDir, part, { stage = null, reason = null, sig = null, terminalKind = null, slices = null, disclosedAxes = null, unfinishedUnits = null } = {}) {
   if (!NOT_COMPLETED_PARTS.includes(part)) throw new Error(`parts-not-completed: "${part}" is not a covered part`);
   const record = { part, stage, reason: reason == null ? null : String(reason).slice(0, 600), sig, terminalKind,
+    ...(Array.isArray(slices) ? { slices } : {}), ...(Array.isArray(disclosedAxes) && disclosedAxes.length ? { disclosed_axes: disclosedAxes } : {}),
+    ...(Array.isArray(unfinishedUnits) && unfinishedUnits.length ? { unfinished_units: unfinishedUnits } : {}),
     ts: new Date().toISOString() };
   const path = notCompletedPath(runDir, part);
   ensureDriverDir(runDir, NOT_COMPLETED_DIR);
@@ -76,6 +81,42 @@ export function partsNotCompleted(runDir) {
   return NOT_COMPLETED_PARTS.filter((p) => names.includes(`${p}.json`)).map((p) => readPartNotCompleted(runDir, p));
 }
 
+/**
+ * The slices of `failed` that `record` does not hold yet, each `{axis, qid, reason}`, or `{axis, query, reason}` for a
+ * slice with no qid, which its query names: what a failure of the searches adds to their record. [] when it adds
+ * none. PURE.
+ */
+export function slicesNotYetRecorded(record, failed) {
+  const keyOf = (s) => `${s?.axis}\u0000${s?.qid ? `qid:${s.qid}` : `query:${s?.query}`}`;
+  const held = new Set((Array.isArray(record?.slices) ? record.slices : []).map(keyOf));
+  const out = [];
+  for (const s of Array.isArray(failed) ? failed : []) {
+    if (!s?.axis || (!s?.qid && !s?.query) || held.has(keyOf(s))) continue;
+    held.add(keyOf(s));
+    out.push(s.qid ? { axis: String(s.axis), qid: String(s.qid), reason: String(s.reason ?? "") }
+      : { axis: String(s.axis), query: String(s.query), reason: String(s.reason ?? "") });
+  }
+  return out;
+}
+
+/**
+ * The axes of `failed` that `record` does not list as disclosed yet: a pass on each was killed at its time limit and its
+ * recovery is spent, so the delivering pass reads its band as it stands and discloses it. [] when it adds none. PURE.
+ */
+export function axesNotYetDisclosed(record, failed) {
+  const held = new Set(Array.isArray(record?.disclosed_axes) ? record.disclosed_axes : []);
+  return [...new Set((Array.isArray(failed) ? failed : []).map((a) => String(a ?? "").trim()).filter((a) => a && !held.has(a)))];
+}
+
+/**
+ * The units of `failed` that `record` does not list as unfinished yet: each wrote no result once its attempts were spent,
+ * so the delivering pass takes it as its band stands instead of sending it again. [] when it adds none. PURE.
+ */
+export function unitsNotYetRecorded(record, failed) {
+  const held = new Set(Array.isArray(record?.unfinished_units) ? record.unfinished_units : []);
+  return [...new Set((Array.isArray(failed) ? failed : []).map((a) => String(a ?? "").trim()).filter((a) => a && !held.has(a)))];
+}
+
 /** Remove one part's record, once that part has completed after all. */
 export function clearPartNotCompleted(runDir, part) {
   try { rmSync(notCompletedPath(runDir, part), { force: true }); } catch { /* none */ }

package/driver/pipeline-knockout.mjs

@@ -64,7 +64,7 @@ import { writeRunStatus, readRunStatus, rollupStatus, atomicWrite, identitySeed
 import { batchMarkName } from "./mark-name.mjs";
 import { runLog, note, outputMeta } from "./log.mjs";
 import { defaultTerritoryState } from "./effective-scope.mjs";   // the stored-defaults reading — one producer, shared with the clearance lane
-import { AGENT_WHATSAPP, whatsappRouting } from "./stages.mjs";
+import { whatsappRouting } from "./stages.mjs";
 import { writeOutboxPacket } from "./outbox.mjs";
 import { rollupTokens, stampTokenRollup } from "./tokens.mjs";
 import { recordRunConsumption } from "./consumption-ledger.mjs";
@@ -1205,8 +1205,9 @@ export async function knockoutInner(ctx, job, opts = {}) {
       // two existing. Where no number is held the packet now SAYS so in `whatsappToReason` rather than
       // substituting the operator silently.
       //
-      // The failure notice below deliberately keeps `AGENT_WHATSAPP[agent]`: 289 ruled on the COMPLETION
-      // notice, and a stage failure is an operational page rather than an answer the requester ordered.
+      // The failure notice below routes the same way (buildFailurePacket). It used to keep `AGENT_WHATSAPP[agent]` as an
+      // operational page, but the courier relays it to the requester, who is owed it as they are owed a report, and the
+      // operator keeps the page as the copy beside it.
       ...whatsappRouting(job, agent),
       // ONE LINE, N LINKS. This said "Report: <one url>" and on a batch that url is now null, which would
       // have read "Report: null" — the fail-visible shape doing its job, and still not a line to send. A
@@ -1350,7 +1351,7 @@ export async function knockoutInner(ctx, job, opts = {}) {
     try {
       const rich = buildFailurePacket({
         runId, agent, job, failedStage, shortReason, terminalKind,
-        reasonVerbatim: String(reason).slice(0, 1000), whatsappTo: AGENT_WHATSAPP[agent] ?? null,
+        reasonVerbatim: String(reason).slice(0, 1000),
       });
       const packet = {
         kind: "run-failed", ...rich,