clearotron 0.3.3 → 0.4.0-beta.1

package/driver/pipeline-knockout.mjs

@@ -54,6 +54,7 @@ import { capabilitiesFor } from "./register-capabilities.mjs";
 // — the ONE binding of the office split to this box's env, shared with the plan lane.
 import { registerUnavailableOffices } from "./register-unreachable.mjs";
 import { runRecordLogPath } from "../providers/_shared/ledger-path.mjs";   // — this run's record log
+import { beginAnswerMemory, endAnswerMemory } from "../providers/_shared/answer-memory.mjs";
 import { validators as koValidators, validateMergedFindings, worstBand, registerSurfacedFilings, raterCaveats, SURVIVOR_BOUNDARY_RE } from "./verify-knockout.mjs";
 import { reviewAbout, reviewEvidence, reviewEvidenceLines, applyKnockoutReview, knockoutReviewFile } from "./knockout-review-record.mjs";
 import { stripNextStepSections } from "./knockout-next-step.mjs";
@@ -646,6 +647,12 @@ export async function knockoutInner(ctx, job, opts = {}) {
       ...(ctx.stateReset ? { __stateReset: true } : {}),
     });
     rollupStatus(run.studioRoot);
+    // THE SIGNA RUN MEMORY'S ATTEMPT (providers/_shared/answer-memory.mjs): whatever an earlier attempt
+    // held is dropped, so a re-run asks the register again, and the mode is fixed for this attempt.
+    ctx.answerMemory = beginAnswerMemory(run.runDir, REGISTER_PROVIDER);
+    if (ctx.answerMemory.applies)
+      runLog(run.runDir, { event: "answer-memory", mode: ctx.answerMemory.mode, ...(ctx.answerMemory.unknown ? { unrecognised: ctx.answerMemory.unknown } : {}) });
+    if (ctx.answerMemory.unknown) note(`answer memory: ${ctx.answerMemory.switch}="${ctx.answerMemory.unknown}" is not off, watch or on, so this register's default applies (${ctx.answerMemory.mode})`);
     note(`=== KNOCKOUT batch (${policy.stageLabel}) — ${markNames.length} mark(s), framework ${ctx.framework.framework_key} ===`);
 
     // 1 — frame
@@ -661,6 +668,125 @@ export async function knockoutInner(ctx, job, opts = {}) {
     if (probeWanted) {
       koStep(ctx, KO_STEP_REGISTER_COUNT);
       ensureDriverDir(run.runDir);
+      // The listing lane, as a step the count lane can run before or after. It returns the listing it
+      // wrote, or null when it was refused or failed; either way it has already recorded why.
+      const listFilings = async () => {
+        let listedDoc = null;
+        // ── 1.6 — THE FILINGS BEHIND THE NARROW COUNTS ( part 5) ─────────────────────────────────
+        //
+        // NEVER TERMINAL, and that is the difference between this lane and the count lane. The counts
+        // ARE the product — none of them means no product, so the run dies. The listing EXPLAINS the
+        // counts: a batch that got its numbers and could not fetch the faces behind them is a smaller
+        // deliverable, not a wrong one, and killing the run would throw away the part that was paid for.
+        // Every failure lands as a recorded reason on the surfaces instead.
+        const recExec = resolveRecordExecutor({
+          lister: opts?.recordLister ?? null, adapter: activeProvider(),
+          agentId: agent, sessionKey: `clearance-${run.slug}-${run.codename}`,
+          // — this run's record log, not the box's. The knockout lane never reads the record bodies
+          // its batch-screen hydration writes; before this they were pure growth on a global file.
+          recordLog: runRecordLogPath(run.runDir),
+          // The $0 guarantee, threaded rather than re-derived: if the COUNTS ran on fixtures, this lane
+          // may not reach a live register. resolveRecordExecutor refuses instead of falling through.
+          offline: countExec.source.startsWith("fixtures:"),
+          fixtureDir: job?.registerFixtures?.records ?? null,
+        });
+        const recRefusal = countExec.source.startsWith("fixtures:") && recExec.source === "none"
+          // NAMES WHAT THE READER CAN ACT ON. This said `CLEAROTRON_KNOCKOUT_RECORD_FIXTURES` — a variable that
+          // no longer exists — so the sentence now names the job field that does.
+          ? "this run counted from fixtures and its job declares no `registerFixtures.records` directory, so the "
+            + "filings behind the counts were not listed — a fixture run never reaches a live register."
+          : recordsPreflight({ capabilities: ctx.registerCaps, hasAdapter: recExec.source !== "none" });
+        if (recRefusal) {
+          // A structural refusal is RECORDED, not swallowed. Without a sidecar the surfaces cannot tell
+          // "this provider does not list filings" from "nobody asked", and the second reads as an
+          // omission — the same silence part 2 closed one section up.
+          atomicWrite(K.registerRecords, JSON.stringify({
+            schema: 1, provider: REGISTER_PROVIDER, providerLabel: ctx.registerCaps?.label ?? REGISTER_PROVIDER,
+            takenAt: new Date().toISOString(), unavailable: recRefusal, marks: [],
+          }, null, 2) + "\n");
+          note(`register filings not listed: ${recRefusal}`);
+          runLog(run.runDir, { event: "knockout-register-records-refused", provider: REGISTER_PROVIDER, reason: recRefusal });
+        } else {
+          try {
+            const recDoc = await listRegisterRecords({
+              marks: markRows.map((m) => ({ name: String(m.name), classes: Array.isArray(m.classes) ? m.classes : null })),
+              classes: job.classes ?? null, jurisdictions: job.jurisdictions ?? null,
+              provider: REGISTER_PROVIDER, capabilities: ctx.registerCaps,
+              lister: recExec.list, ledgerPath: K.countLedger,
+              // — the SAME split the counts used. Re-deriving it here would let the two halves of one
+              // report narrow to different scopes; `recExec` can also be a fixture lister while the counts
+              // ran live, and the offices a fixture holds are not this box's.
+              unreachable: recExec.source === "provider" ? (ctx.registerUnreachable ?? []) : [],
+              concurrency: 3,   // step 3 — the same constant as the sibling call above
+              ...(process.env.CLEAROTRON_KNOCKOUT_RECORD_CAP ? { cap: Number(process.env.CLEAROTRON_KNOCKOUT_RECORD_CAP) } : {}),
+              ...(process.env.CLEAROTRON_KNOCKOUT_VARIANT_CAP ? { variantCap: Number(process.env.CLEAROTRON_KNOCKOUT_VARIANT_CAP) } : {}),
+            });
+            atomicWrite(K.registerRecords, JSON.stringify(recDoc, null, 2) + "\n");
+            listedDoc = recDoc;
+            runLog(run.runDir, { event: "knockout-register-records", provider: REGISTER_PROVIDER, executor: recExec.source,
+              marks: recDoc.marks.length, listed: listedMarks(recDoc), records: recDoc.marks.reduce((n, m) => n + m.records.length, 0) });
+          } catch (e) {
+            // The lane does not throw per mark, so reaching here means something structural broke. It
+            // still must not take the counts down with it — but it must not vanish either.
+            note(`register filings listing failed (non-fatal): ${e.message}`);
+            runLog(run.runDir, { event: "knockout-register-records-failed", provider: REGISTER_PROVIDER, cause: String(e?.message ?? e).slice(0, 300) });
+          }
+        }
+        return listedDoc;
+      };
+
+      // ── THE OWNER LOOKUP, ONCE THE LISTING HAS NAMED THE OWNER AND A COUNT HAS LANDED ──────────────
+      //
+      // Run after the count gate below, whichever lane went first. A batch where not one mark got a
+      // number stops at that gate; on a register that lists first the lookups used to run before it,
+      // research calls the batch paid for and then threw away.
+      const checkOwners = async (recDoc) => {
+        if (!recDoc) return;
+        // On the run that produced the issue, the owner's name was on disk 48 seconds before the sweep
+        // started and no pass ever searched it: every sweep keys on the TERM, and nothing re-swept on an
+        // OWNER once the register named one. The assessment then inferred what the owner sold from the
+        // owner's name, and deferred the real answer to a document the run did not hold.
+        //
+        // Bounded to promoted filings and deduplicated per owner — on the issue's own run that is ONE
+        // extra query. Never throws: a failure produces rows saying the lookup did not answer, and the
+        // run publishes (ruling A, 2026-09-07).
+        try {
+          const owed = ownersOwedACheck(recDoc);
+          if (owed.length) {
+            const checks = await runOwnerChecks({
+              owners: owed, exec: sweep.exec, runDir: run.runDir, ledgerPath: K.ownerCheckLedger,
+              preset: process.env.CLEAROTRON_KNOCKOUT_PRESET || "pro-search",
+            });
+            atomicWrite(K.ownerChecks, JSON.stringify({ schema: 1, checks }, null, 2) + "\n");
+            runLog(run.runDir, {
+              event: "knockout-owner-checks", owners: owed.length,
+              answered: checks.filter((c) => c.ok).length,
+              // The count is logged because the ruling is about COST: one promoted filing on the
+              // issue's run means one query. A number climbing here is the bound having widened.
+              unanswered: checks.filter((c) => !c.ok).length,
+            });
+          } else {
+            runLog(run.runDir, { event: "knockout-owner-checks", owners: 0, answered: 0, unanswered: 0,
+              detail: "no promoted filing names a proprietor to search" });
+          }
+        } catch (e) {
+          // Structural only — runOwnerChecks itself never throws. Non-fatal by the same rule as the
+          // listing above: a report is never withheld for a check that could not run.
+          note(`owner use-check failed (non-fatal): ${e.message}`);
+          runLog(run.runDir, { event: "knockout-owner-checks-failed", cause: String(e?.message ?? e).slice(0, 300) });
+        }
+      };
+
+      // ── THE LISTING FIRST, ON A REGISTER WHOSE LISTING HOLDS THE COUNT ──────────────────────────────
+      //
+      // The identical and close columns are the exact predicate over a term, and the listing asks exactly
+      // that. On a register that declares its listing carries the register's own total for that question
+      // (`listingAnswersCount`), the listing runs first and the count lane takes those two columns from it
+      // (register-count.mjs listingAnswers) instead of paying for them again. It still asks what the
+      // listing never asks — `containing` — and any term the listing did not answer. Every other register
+      // counts first and lists second, as it always has.
+      const listFirst = ctx.registerCaps?.listingAnswersCount === true;
+      const listedFirst = listFirst ? await listFilings() : null;
       // resume: a settled prior sidecar is reused cell by cell, so a re-run never re-bills a count that
       // already landed — including across a build that ADDED a predicate, where only the new column is
       // bought (register-count.mjs cellSettled).
@@ -683,6 +809,7 @@ export async function knockoutInner(ctx, job, opts = {}) {
         // to VARIANT_CAP, so this knob can only ever narrow. Unset ⇒ the code cap, which is the answer
         // for every deployment that has not thought about it.
         ...(process.env.CLEAROTRON_KNOCKOUT_VARIANT_CAP ? { variantCap: Number(process.env.CLEAROTRON_KNOCKOUT_VARIANT_CAP) } : {}),
+        ...(listedFirst ? { listed: listedFirst } : {}),
       });
       const counted = countedMarks(doc);
       // Not one mark got a number. The count IS this product — a batch published now would be a plain
@@ -698,101 +825,7 @@ export async function knockoutInner(ctx, job, opts = {}) {
       runLog(run.runDir, { event: "knockout-register-counts", provider: REGISTER_PROVIDER, executor: countExec.source, marks: doc.marks.length, counted, regions: doc.scope.regions ?? "worldwide" });
       if (counted < doc.marks.length) note(`register counts: ${doc.marks.length - counted}/${doc.marks.length} mark(s) unavailable — the batch continues (they publish as "not available", never as zero)`);
 
-      // ── 1.6 — THE FILINGS BEHIND THE NARROW COUNTS ( part 5) ─────────────────────────────────
-      //
-      // NEVER TERMINAL, and that is the difference between this lane and the one above it. The counts
-      // ARE the product — none of them means no product, so the run dies. The listing EXPLAINS the
-      // counts: a batch that got its numbers and could not fetch the faces behind them is a smaller
-      // deliverable, not a wrong one, and killing the run would throw away the part that was paid for.
-      // Every failure lands as a recorded reason on the surfaces instead.
-      const recExec = resolveRecordExecutor({
-        lister: opts?.recordLister ?? null, adapter: activeProvider(),
-        agentId: agent, sessionKey: `clearance-${run.slug}-${run.codename}`,
-        // — this run's record log, not the box's. The knockout lane never reads the record bodies
-        // its batch-screen hydration writes; before this they were pure growth on a global file.
-        recordLog: runRecordLogPath(run.runDir),
-        // The $0 guarantee, threaded rather than re-derived: if the COUNTS ran on fixtures, this lane
-        // may not reach a live register. resolveRecordExecutor refuses instead of falling through.
-        offline: countExec.source.startsWith("fixtures:"),
-        fixtureDir: job?.registerFixtures?.records ?? null,
-      });
-      const recRefusal = countExec.source.startsWith("fixtures:") && recExec.source === "none"
-        // NAMES WHAT THE READER CAN ACT ON. This said `CLEAROTRON_KNOCKOUT_RECORD_FIXTURES` — a variable that
-        // no longer exists — so the sentence now names the job field that does.
-        ? "this run counted from fixtures and its job declares no `registerFixtures.records` directory, so the "
-          + "filings behind the counts were not listed — a fixture run never reaches a live register."
-        : recordsPreflight({ capabilities: ctx.registerCaps, hasAdapter: recExec.source !== "none" });
-      if (recRefusal) {
-        // A structural refusal is RECORDED, not swallowed. Without a sidecar the surfaces cannot tell
-        // "this provider does not list filings" from "nobody asked", and the second reads as an
-        // omission — the same silence part 2 closed one section up.
-        atomicWrite(K.registerRecords, JSON.stringify({
-          schema: 1, provider: REGISTER_PROVIDER, providerLabel: ctx.registerCaps?.label ?? REGISTER_PROVIDER,
-          takenAt: new Date().toISOString(), unavailable: recRefusal, marks: [],
-        }, null, 2) + "\n");
-        note(`register filings not listed: ${recRefusal}`);
-        runLog(run.runDir, { event: "knockout-register-records-refused", provider: REGISTER_PROVIDER, reason: recRefusal });
-      } else {
-        try {
-          const recDoc = await listRegisterRecords({
-            marks: markRows.map((m) => ({ name: String(m.name), classes: Array.isArray(m.classes) ? m.classes : null })),
-            classes: job.classes ?? null, jurisdictions: job.jurisdictions ?? null,
-            provider: REGISTER_PROVIDER, capabilities: ctx.registerCaps,
-            lister: recExec.list, ledgerPath: K.countLedger,
-            // — the SAME split the counts used. Re-deriving it here would let the two halves of one
-            // report narrow to different scopes; `recExec` can also be a fixture lister while the counts
-            // ran live, and the offices a fixture holds are not this box's.
-            unreachable: recExec.source === "provider" ? (ctx.registerUnreachable ?? []) : [],
-            concurrency: 3,   // step 3 — the same constant as the sibling call above
-            ...(process.env.CLEAROTRON_KNOCKOUT_RECORD_CAP ? { cap: Number(process.env.CLEAROTRON_KNOCKOUT_RECORD_CAP) } : {}),
-            ...(process.env.CLEAROTRON_KNOCKOUT_VARIANT_CAP ? { variantCap: Number(process.env.CLEAROTRON_KNOCKOUT_VARIANT_CAP) } : {}),
-          });
-          atomicWrite(K.registerRecords, JSON.stringify(recDoc, null, 2) + "\n");
-          runLog(run.runDir, { event: "knockout-register-records", provider: REGISTER_PROVIDER, executor: recExec.source,
-            marks: recDoc.marks.length, listed: listedMarks(recDoc), records: recDoc.marks.reduce((n, m) => n + m.records.length, 0) });
-
-          // ── THE OWNER LOOKUP, HERE BECAUSE HERE IS WHERE THE OWNER BECOMES KNOWN ──────────────────────
-          //
-          // On the run that produced the issue, the owner's name was on disk 48 seconds before the sweep
-          // started and no pass ever searched it: every sweep keys on the TERM, and nothing re-swept on an
-          // OWNER once the register named one. The assessment then inferred what the owner sold from the
-          // owner's name, and deferred the real answer to a document the run did not hold.
-          //
-          // Bounded to promoted filings and deduplicated per owner — on the issue's own run that is ONE
-          // extra query. Never throws: a failure produces rows saying the lookup did not answer, and the
-          // run publishes (ruling A, 2026-09-07).
-          try {
-            const owed = ownersOwedACheck(recDoc);
-            if (owed.length) {
-              const checks = await runOwnerChecks({
-                owners: owed, exec: sweep.exec, runDir: run.runDir, ledgerPath: K.ownerCheckLedger,
-                preset: process.env.CLEAROTRON_KNOCKOUT_PRESET || "pro-search",
-              });
-              atomicWrite(K.ownerChecks, JSON.stringify({ schema: 1, checks }, null, 2) + "\n");
-              runLog(run.runDir, {
-                event: "knockout-owner-checks", owners: owed.length,
-                answered: checks.filter((c) => c.ok).length,
-                // The count is logged because the ruling is about COST: one promoted filing on the
-                // issue's run means one query. A number climbing here is the bound having widened.
-                unanswered: checks.filter((c) => !c.ok).length,
-              });
-            } else {
-              runLog(run.runDir, { event: "knockout-owner-checks", owners: 0, answered: 0, unanswered: 0,
-                detail: "no promoted filing names a proprietor to search" });
-            }
-          } catch (e) {
-            // Structural only — runOwnerChecks itself never throws. Non-fatal by the same rule as the
-            // listing above: a report is never withheld for a check that could not run.
-            note(`owner use-check failed (non-fatal): ${e.message}`);
-            runLog(run.runDir, { event: "knockout-owner-checks-failed", cause: String(e?.message ?? e).slice(0, 300) });
-          }
-        } catch (e) {
-          // The lane does not throw per mark, so reaching here means something structural broke. It
-          // still must not take the counts down with it — but it must not vanish either.
-          note(`register filings listing failed (non-fatal): ${e.message}`);
-          runLog(run.runDir, { event: "knockout-register-records-failed", provider: REGISTER_PROVIDER, cause: String(e?.message ?? e).slice(0, 300) });
-        }
-      }
+      await checkOwners(listFirst ? listedFirst : await listFilings());
     }
 
     // 2 — the sweep: ONE broad code-side research call per mark, receipted, per-mark degrade
@@ -1098,6 +1131,7 @@ export async function knockoutInner(ctx, job, opts = {}) {
     // returns. Same seam, same best-effort contract, no lane-specific exception to write down.
     const stamp = writeSettleStamp(published.poolRunDir, { state: "delivered", tier: overall, deliveredAt, runId: published.runId ?? run.runId, lane: "knockout" });
     if (!stamp.written) note(`delivery: settle stamp not written (${stamp.reason})`);
+    endAnswerMemory(run.runDir);   // the held answers do not travel into the archive
     const archived = archive(run);
     rollupStatus(run.studioRoot);
     sentinel(archived ?? run.runDir, ".delivered", { verdict: overall, url: published.url, reports: published.reports.map((r) => ({ mark: r.mark, url: r.url })), notified: "pending", sendPending: true, archived, lane: "knockout" });

package/driver/pipeline.mjs

@@ -76,7 +76,7 @@ import { armCoverageForm, coverageFormInput, coverageFormPaths, coverageFormStam
 import { unionPlacementForm } from "./placement-union.mjs";
 import { readPlacementForm, readPlacementFormInput, writePlacementForm } from "./placement-form-io.mjs";
 import { dictatedPaths, findStrayArtifacts, treeSnapshot, findStrayInTree, matterSiblings, findStrayMatterSiblings } from "./stray-artifacts.mjs";   // — a run dir holds no document no stage dictated; — nor does the doctrine tree
-import { resolveProfile, resolveEffectiveProfile, derivedFloor, derivedBatchSize, applicantMatchesProfile, NEUTRAL_DELIVERY, deliveryForRun, recipeProseGuard, withRunPlatforms, profileStoreResolution } from "./profiles.mjs";   // adds profileStoreResolution — the CONFIG store's identity, beside the doctrine tree's
+import { resolveProfile, resolveEffectiveProfile, derivedFloor, derivedBatchSize, gridBatchFor, applicantMatchesProfile, NEUTRAL_DELIVERY, deliveryForRun, recipeProseGuard, withRunPlatforms, profileStoreResolution } from "./profiles.mjs";   // adds profileStoreResolution — the CONFIG store's identity, beside the doctrine tree's
 import { resolveSearchPolicy, gateResolvedPolicy, loadRecipes, policyFor, isRegisterOnly, reportIdentityFor, depthFor } from "./search-policy.mjs";
 import { profileOrdinals } from "./profile-selection.mjs";   // lever 3 — driver selection
 // THE OFFERING'S own sentence about where the native-language investigation can be bought. It reaches a
@@ -138,6 +138,7 @@ import { tallyRegisterCalls, DEFAULT_LEDGER_PATH, fetchedRecordUris, countLaneCa
 // this path, because this process runs several runs' pipelines at once and a global address would file
 // one run's evidence under another.
 import { runRecordLogPath } from "../providers/_shared/ledger-path.mjs";
+import { beginAnswerMemory, endAnswerMemory } from "../providers/_shared/answer-memory.mjs";
 import { findScreenGateViolations, findScreenGateParseGaps, screenGateZeroCause } from "./screen-gate.mjs";
 import { emptyQueue, coerceQueue, mintItem, pendingItems, markFlushed, receiptKeyFor,
   buildFlushFollowup, runPostFlushGateRepair } from "./digest-queue.mjs";   // (t1cd) — the digest-trigger funnel
@@ -149,7 +150,7 @@ import { stampTokenRollup } from "./tokens.mjs";
 import { recordRunConsumption } from "./consumption-ledger.mjs";
 import { quoteForJob, reconcileTurnaround } from "./run-quote.mjs";
 import { assembleRunRecords, readRecordArtifacts, findRegistryArithmeticIssues, findRegistryViolations, applyRegistryCorrections, extractEnforcerSignals, collectOppositionDeadlines, normalizeRecordUri } from "./registry-fidelity.mjs";
-import { readKnownConflictsFor, writeKnownConflictsFor, markKey, acceptedConflicts } from "./known-conflicts.mjs";   // spec 64 — the workspace-level per-mark recall store
+import { readKnownConflictsFor, writeKnownConflictsFor, markKey, acceptedConflicts, recallReceiptForOwnCompany } from "./known-conflicts.mjs";   // spec 64 — the workspace-level per-mark recall store
 import { runLint, flagLines, properNameCandidates } from "./predelivery-lint.mjs";
 import { parsePlacementsJson } from "./placement-model.mjs";   // B2 — the structured tier mirror; the lint reads it only to flag an EMPTY one
 import { readAnchors } from "./anchor-reader.mjs";
@@ -979,7 +980,12 @@ function deriveGridSpec(ctx) {
     terms: null,
     spec_inputs: { registerOnly: Boolean(ctx.registerOnly), gridVariants: ctx.gridVariants?.length ?? 0, profilePlatforms: ctx.profile?.platforms?.length ?? 0 },
   };
-  if (!ctx.registerOnly && ctx.gridVariants?.length && ctx.profile?.platforms?.length) {
+  // AN EMPTY MARKETPLACE LIST STILL WRITES A GRID. A company may pick no marketplaces (the owner's ruling of
+  // 2026-09-23), and the general-web cell and the meaning sweep ride in this spec: gating it on a non-empty
+  // list switched both off with the stores, and the downgrade clamp then read the missing spec as a failed
+  // sweep. The spec below is then the web cell plus whatever channels the matter frame names. Only a profile
+  // with no list at all (legacy) takes the spec-less path.
+  if (!ctx.registerOnly && ctx.gridVariants?.length && Array.isArray(ctx.profile?.platforms)) {
     const gridSpecPath = P.gridSpec;
     // #5 — required channels: a NAMED profile's curated platforms are authoritative. The GENERIC fallback
     // derives the channels from the MATTER FRAME's industry/goods reasoning (its "Search channels:" line) so
@@ -1041,7 +1047,8 @@ function deriveGridSpec(ctx) {
       terms: ctx.gridVariants,
       platforms: [...channels, "web"], // the dictated channels + the general-web cell
       output_path: P.commonLawGrid,
-      batch: ctx.profile?.batchSize ?? 14,
+      // SIZED BY THE CELLS THIS GRID RUNS, never larger than the profile's own figure (gridBatchFor).
+      batch: gridBatchFor(ctx.profile, channels.length + 1),
       // disposition_required (P2-C §8b leg 2): the receipt-presence stamp arming the commonLaw validator's
       // receipts-disposition arm (the D1 ledger_required pattern — every fresh spec carries it; pre-P2-C
       // archived specs lack it, so replay verdicts never flip). splitGridSpec spreads the connotation
@@ -2179,7 +2186,7 @@ function deriveScopeLedgerJson(ctx) {
 // 2026-08-03 — the SEED SET is the union of every distinctive element the manifest names, and falls
 // back to the job's own mark when it names none, so the floor stops moving with the model's choice of anchor
 // and can no longer be empty. See the VARIANT FLOOR section of form-neighbourhood.mjs.
-function deriveFormNeighbourhood(ctx) {
+export function deriveFormNeighbourhood(ctx) {   // @internal — exported for its call-site test
   const P = ctx.paths;
   // — an ABSENT prose manifest no longer returns without an artifact. It used to, and that was the
   // zero-semantics hole at its widest: no manifest ⇒ no form-neighbourhood.json ⇒ compileRegisterPlan's
@@ -2207,14 +2214,19 @@ function deriveFormNeighbourhood(ctx) {
     // The MARK is the floor's fallback seed and the only input to it that is not model output —
     // resolved exactly as every other job-mark consumer resolves it (stages.mjs blind-frame).
     const mark = ctx.job.marks ?? ctx.job.markName ?? ctx.job.name ?? "";
-    const ow = loadOrdinaryWords("en"), json = renderFormNeighbourhoodJson(manifestMd, { markets, droppedAxes, model, mark, ordinaryWords: ow.words });   // an unloadable word list removes nothing
+    // The active register's own declaration: `false` leaves the mixed-alphabet look-alike spellings out of
+    // the band and lists them as not searched, with the reason its index gives. Undeclared changes nothing.
+    const caps = registerCapabilities();
+    const mixedScriptQuery = caps?.mixedScriptQuery ?? null;
+    const ow = loadOrdinaryWords("en"), json = renderFormNeighbourhoodJson(manifestMd, { markets, droppedAxes, model, mark, ordinaryWords: ow.words, mixedScriptQuery, nativeScriptIndex: caps?.nativeScriptIndex ?? null });   // an unloadable word list removes nothing
     const tmp = P.formNeighbourhood + ".tmp";
     writeFileSync(tmp, json);
     renameSync(tmp, P.formNeighbourhood);
-    let exact = 0, floor = 0, added = 0, seededFrom = "", seeds = [], notSearched = 0;
+    let exact = 0, floor = 0, added = 0, seededFrom = "", seeds = [], notSearched = 0, mixedNotSearched = 0;
     try {
       const o = JSON.parse(json);
       exact = o.elements.reduce((a, e) => a + (e.band?.exactQueries?.length ?? 0), 0); notSearched = o.elements.reduce((a, e) => a + (e.band?.ordinaryWordDifferentSound?.length ?? 0), 0);
+      mixedNotSearched = o.elements.reduce((a, e) => a + (e.band?.mixedScriptNotSearched?.length ?? 0), 0);
       floor = o.variant_floor?.counts?.floor ?? 0;
       added = o.variant_floor?.counts?.model_added ?? 0;
       seededFrom = String(o.seeded_from ?? "");
@@ -2222,7 +2234,7 @@ function deriveFormNeighbourhood(ctx) {
     } catch { /* counts are telemetry only */ }
     // The SEED SET is logged by name, because it is the input that decides whether two runs of the same
     // matter can produce the same floor — a floor count alone cannot tell a stable run from a re-anchored one.
-    runLog(P.runDir, { event: "form-neighbourhood-derived", exact, floor, modelAdded: added, droppedAxes, seeds, seededFrom, ordinaryWordNotSearched: notSearched, ...(ow.error ? { ordinaryWordListError: ow.error } : {}) });
+    runLog(P.runDir, { event: "form-neighbourhood-derived", exact, floor, modelAdded: added, droppedAxes, seeds, seededFrom, ordinaryWordNotSearched: notSearched, ...(mixedScriptQuery === false ? { mixedScriptNotSearched: mixedNotSearched } : {}), ...(ow.error ? { ordinaryWordListError: ow.error } : {}) });
     // The fallback is not a quiet degrade: it means this run's variant floor rests on the mark alone
     // because the stage named no usable element. Loud, so the absence is a finding and not a shrug.
     if (seededFrom.startsWith("job mark"))
@@ -3134,7 +3146,7 @@ function recordSynthesisSeam(ctx, r, trigger = null) {
     evidence: r?.fail ? String(r.fail).slice(0, 80) : "",
     reasonFor: (rec, uri) => {
       // — THE 102. This callback used to be zero-arity and constant: every record this pass
-      // discarded got the same sentence and `step-silent`, whatever it was. One of them was DELPHIC,
+      // discarded got the same sentence and `step-silent`, whatever it was. One of them was KORPHIC,
       // a lawyer-named gold mark placed on sheet-2 and stamped `carry: "carried"`, and the trace could
       // say only that synthesis had not delivered it. The sibling seam one stage earlier
       // (`recordDigestSeam`) has read its stage's own output per record since it was written; this one
@@ -3324,7 +3336,7 @@ export function deriveRecordCarry(ctx, trigger, { findings = null } = {}) {   //
 // DIFFERENT Play Store apps. That collision concentrates in the non-Latin population this exists for,
 // because a Han-script marketplace query returns `?q=…` search URLs.
 //
-// This is the path that lost TIKI TWIST and TIKI TROPICS on R3 — both sat in the run's own records and
+// This is the path that lost WAVO TWIST and WAVO TROPICS on R3 — both sat in the run's own records and
 // reached no findings list. It has already cost a round.
 //
 // Derived at publish, like the register trace and for the same reason: everything it joins is final by
@@ -9070,6 +9082,12 @@ async function pipelineInner(job, opts = {}) {
   ctx.forceFrom = opts.fromStage != null ? stageOrdinal(opts.fromStage) : null;
   if (opts.fromStage != null && ctx.forceFrom < 0) throw new Error(`--from: unknown stage "${opts.fromStage}"`);
   runLog(run.runDir, { event: "start", agent, resume: isResume, fromStage: opts.fromStage ?? null, job: { id: job.id, slug: run.slug, codename: run.codename, customer: run.customer, forwarder: job.forwarder } });
+  // THE SIGNA RUN MEMORY'S ATTEMPT (providers/_shared/answer-memory.mjs): whatever an earlier attempt held
+  // is dropped, so a resume asks the register again, and the mode is fixed for this attempt.
+  ctx.answerMemory = beginAnswerMemory(run.runDir, REGISTER_PROVIDER);
+  if (ctx.answerMemory.applies)
+    runLog(run.runDir, { event: "answer-memory", mode: ctx.answerMemory.mode, ...(ctx.answerMemory.unknown ? { unrecognised: ctx.answerMemory.unknown } : {}) });
+  if (ctx.answerMemory.unknown) note(`answer memory: ${ctx.answerMemory.switch}="${ctx.answerMemory.unknown}" is not off, watch or on, so this register's default applies (${ctx.answerMemory.mode})`);
   // item 11 — WHICH ARM DID THIS RUN RUN UNDER? Unconditional and three-valued in the AD-4 sense: the row
   // is always written, `seed: null` meaning the ordinary production ordering. A probe arm that is not on
   // the record is an arm whose result cannot be attributed later, and the probe exists to attribute.
@@ -9161,6 +9179,9 @@ async function pipelineInner(job, opts = {}) {
         const candidates = [], candDirectives = [], overflow = [];
         const seen = new Set();
         const mintedQids = new Set();   // qid uniqueness inside the lane — the fold below dedupes on it
+        // term → every company whose delivery remembered it. The searches read every company's rows; the
+        // receipt names whose they were, so an audit lists only its own (recallReceiptForOwnCompany).
+        const companiesOf = new Map();
         for (const r of ranked) {
           const mark = String(r.mark_text).trim();
           if (searchedKeys.has(markKey(mark))) continue;   // the primary sweep already owns the searched mark itself
@@ -9176,13 +9197,17 @@ async function pipelineInner(job, opts = {}) {
             // characters", and it answered both with a silent `continue`. The first is a genuine repeat
             // and is still skipped; the second is a distinct mark and now gets a distinct qid.
             const termKey = `${predicate}:${term.toLowerCase()}`;
+            if (!companiesOf.has(termKey)) companiesOf.set(termKey, new Set());
+            companiesOf.get(termKey).add(r.customer || null);
             if (seen.has(termKey)) continue;
             seen.add(termKey);
             const qid = mintSupplementalQid({ prefix, term, used: mintedQids });
             candidates.push({ qid, axis: "primary-sweep", predicate, term, nice_classes: inScope, regions: [], expected_kind: "enumerate" });
-            candDirectives.push({ qid, uri: r.uri ?? null, mark_text: mark, owner: r.owner ?? null });
+            candDirectives.push({ qid, uri: r.uri ?? null, mark_text: mark, owner: r.owner ?? null, customers: companiesOf.get(termKey) });
           }
         }
+        for (const d of candDirectives) d.customers = [...d.customers];
+        const customersOfQid = new Map(candDirectives.map((d) => [d.qid, d.customers]));
         // ── — THE SAME DEFECT, AND THE OWNER BUDGET IS WHERE IT BITES ───────────
         //
         // The cross-check lane's fix, applied here because this lane has the identical shape: the caps
@@ -9201,7 +9226,7 @@ async function pipelineInner(job, opts = {}) {
         for (const e of screened.entries) {
           const isOwner = e.predicate === "owner";
           if (isOwner ? ownerUsed >= RECALL_CAP_OWNER : markUsed >= RECALL_CAP_MARK) {
-            overflow.push({ qid: e.qid, term: String(e.term).slice(0, 60) }); continue;
+            overflow.push({ qid: e.qid, term: String(e.term).slice(0, 60), customers: customersOfQid.get(e.qid) ?? [] }); continue;
           }
           if (isOwner) ownerUsed++; else markUsed++;
           entries.push(e);
@@ -9234,7 +9259,7 @@ async function pipelineInner(job, opts = {}) {
           note(`recall probes: ${refusedDirectives.length} probe(s) REFUSED as un-searchable terms — recorded in _driver/register-recall.json refused[], never dispatched`);
         }
         if (kept.length || overflow.length || refusedDirectives.length) {
-          writeFileSync(`${receiptPath}.tmp`, JSON.stringify({ schema_version: 2, ts: new Date().toISOString(), cap: { mark: RECALL_CAP_MARK, owner: RECALL_CAP_OWNER }, directives: kept, overflow, ...(refusedDirectives.length ? { refused: refusedDirectives } : {}) }, null, 2) + "\n");
+          writeFileSync(`${receiptPath}.tmp`, JSON.stringify({ schema_version: 2, ts: new Date().toISOString(), customer: ctx.profile?.profileKey || null, cap: { mark: RECALL_CAP_MARK, owner: RECALL_CAP_OWNER }, directives: kept, overflow, ...(refusedDirectives.length ? { refused: refusedDirectives } : {}) }, null, 2) + "\n");
           renameSync(`${receiptPath}.tmp`, receiptPath);
         }
         // The RECEIPT partitions; what the seat is TOLD does not. This feeds the primary-sweep prompt's
@@ -10410,7 +10435,7 @@ async function pipelineInner(job, opts = {}) {
             // plan-unexecuted StageFailure below still holds the line for a genuine hole.
             runLog(run.runDir, { event: "plan-qids-missing", axis: a, qids: entries.map((e) => e.qid), action: "fresh-execute-plan" });
             note(`register-unit ${a}: ${entries.length} dictated plan entr${entries.length === 1 ? "y" : "ies"} unexecuted on a resumed-past axis — one fresh execute_plan-only call`);
-            const freshMsg = repairFollowup("register-unit:plan-join-fresh", { axis: a, registerPlan: P.registerPlan, bandPath: P.registerBand(a) });
+            const freshMsg = repairFollowup("register-unit:plan-join-fresh", { axis: a, registerPlan: P.registerPlan, bandPath: P.registerBand(a), entries });
             const rf = await stage("register-unit", { ...ctx, axis: a }, { force: true, freshMessage: freshMsg, sessionKey: `clearance-${ctx.run.slug}-${ctx.run.codename}-register-unit-${a}-plan-join-fresh`, trigger: "plan-join-fresh" });
             if (!rf.ok) note(`register-unit ${a}: fresh execute_plan call failed (${rf.fail}) — the plan-unexecuted StageFailure below holds the line`);
             continue;
@@ -10591,10 +10616,13 @@ async function pipelineInner(job, opts = {}) {
         // back-compat: a pre-doc-35 receipt keyed only on the cell set (no source channels)
         (priorReceipt.sig == null && !sourceChannels.length &&
           JSON.stringify((priorReceipt.requested ?? []).map(cellKey).sort()) === JSON.stringify(closable.map(cellKey).sort())));
+      // SIZED BY THE CELLS A CLOSURE GRID RUNS, as the main grid is (gridBatchFor): its spec carries only the
+      // platforms of the cells it closes.
+      const closureBatch = (cells) => gridBatchFor(ctx.profile, new Set(cells.map((c) => c.platform)).size);
       if ((closable.length || sourceChannels.length) && !alreadyAttempted) {
         const requested = closable;
         const variants = [...new Set(closable.map((c) => c.variant))];
-        const batchSize = ctx.profile?.batchSize ?? 14;   // WS-B: derived from the profile's platform count
+        const batchSize = closureBatch(closable);
         const batches = Math.max(1, Math.ceil(variants.length / batchSize));
         const gridCalls = batches + (sourceChannels.length ? 1 : 0);   // grid call(s) + a channel-sweep call (tokens-only: no $ estimate)
         note(`coverage closure: ${closable.length} machine-closable cell(s)${sourceChannels.length ? ` + ${sourceChannels.length} un-swept in-scope channel(s) [${sourceChannels.join(", ")}]` : ""} — one supplementary grid pass (${gridCalls} grid call(s))`);
@@ -10707,7 +10735,7 @@ async function pipelineInner(job, opts = {}) {
       }
       if (closable.length || exempt.length) {
         // Tokens-only (owner directive 2026-07-11): the offer names the work (grid calls), never a $ figure.
-        const batchesLeft = Math.max(1, Math.ceil([...new Set(closable.map((c) => c.variant))].length / (ctx.profile?.batchSize ?? 14)));
+        const batchesLeft = Math.max(1, Math.ceil([...new Set(closable.map((c) => c.variant))].length / closureBatch(closable)));
         const offer = ` — closable on instruction (${batchesLeft} supplementary grid call(s))`;
         ctx.coverageNote = `marketplace cells not executed: ${[...closable, ...exempt].map(cellKey).join("; ")}` +
           (closable.length ? ` — attempted in-loop and still unreachable${offer}` : "") +
@@ -11060,7 +11088,7 @@ async function pipelineInner(job, opts = {}) {
                 directiveQids.set(key, []);
                 // Per-case wording (A2): the variant fallback now also DISCLOSES a label-shaped item
                 // (term-shape lint) — dispatching the display label verbatim was the 2026-07-28
-                // nil-search class ("Reverse-order TIKI composites (…)" searched as exact → 0 → read
+                // nil-search class ("Reverse-order WAVO composites (…)" searched as exact → 0 → read
                 // as clean). The remedy contract (SKILL.md) is the fix the wording points at.
                 regDeferReason.set(key, String(d.layer ?? "").toLowerCase() === "field"
                   ? "no-code-remedy: a field class-gap with no searchable term×class pair (closing it in the matter's own classes only re-runs the primary sweep — disclosed)"
@@ -11152,8 +11180,8 @@ async function pipelineInner(job, opts = {}) {
               }
               // Dispatch → derive band → VERIFY per directive (qid-landed + non-collapse + class-scope).
               // A byte-changed band with only a wrong-scope/empty/error block closes NOTHING.
-              const dispatchAndVerify = async () => {
-                const outcome = await dispatchPlanQids(a, added, "frame-reopen-sweep", 2);
+              const dispatchAndVerify = async (qids) => {
+                const outcome = await dispatchPlanQids(a, qids, "frame-reopen-sweep", 2);
                 refreshSupplementalExecution(ctx);
                 try { deriveNamedBand(ctx); } catch (e) { regMechFail = `named-band:${String(e.message).slice(0, 80)}`; }
                 const bands = readRegisterBands(P, axes);
@@ -11166,7 +11194,7 @@ async function pipelineInner(job, opts = {}) {
                 executedQids: ev.executedQids, blocksByQid: ev.blocksByQid,
               });
               const mintedDirectives = regDirectives.filter((d) => (directiveQids.get(reopenKey(d)) ?? []).length);
-              let ev = await dispatchAndVerify();
+              let ev = await dispatchAndVerify(added);
               regLastJoin = ev;
               let outcome = ev.outcome;
               const retryTargets = [];
@@ -11179,16 +11207,24 @@ async function pipelineInner(job, opts = {}) {
               // correct scope from attempt 1, so this recovers a transient (an error / collapsed / unlanded
               // slice), never re-runs a wrong query. dispatchPlanQids' own repair ledger (max 2) refuses a
               // third — so this cannot loop or thrash the paid pass.
+              //
+              // ONLY THE FAILING DIRECTIVES' OWN ENTRIES GO AGAIN. A directive that verified closed on the first
+              // attempt is not asked twice: re-sending its qids re-fetches records the run already holds, and
+              // on a register that bills per request it pays for them again.
               if (retryTargets.length) {
-                note(`frame-reopen: ${retryTargets.length} directive(s) not verified-closed — ONE re-attempt with the same structured remedy`);
-                runLog(run.runDir, { event: "frame-reopen-reattempt", directives: retryTargets.map(reopenKey) });
-                ev = await dispatchAndVerify();
-                regLastJoin = ev;
-                outcome = ev.outcome ?? outcome;
-                for (const d of retryTargets) {
-                  const v = verifyOne(d, ev);
-                  if (v.closed) { regSwept.add(reopenKey(d)); regDeferReason.delete(reopenKey(d)); }
-                  else regDeferReason.set(reopenKey(d), v.reason);
+                const retryQids = [...new Set(retryTargets.flatMap((d) => directiveQids.get(reopenKey(d)) ?? []))]
+                  .filter((q) => added.includes(q));
+                note(`frame-reopen: ${retryTargets.length} directive(s) not verified-closed — ONE re-attempt of their own ${retryQids.length} entr${retryQids.length === 1 ? "y" : "ies"} with the same structured remedy`);
+                runLog(run.runDir, { event: "frame-reopen-reattempt", directives: retryTargets.map(reopenKey), qids: retryQids });
+                if (retryQids.length) {
+                  ev = await dispatchAndVerify(retryQids);
+                  regLastJoin = ev;
+                  outcome = ev.outcome ?? outcome;
+                  for (const d of retryTargets) {
+                    const v = verifyOne(d, ev);
+                    if (v.closed) { regSwept.add(reopenKey(d)); regDeferReason.delete(reopenKey(d)); }
+                    else regDeferReason.set(reopenKey(d), v.reason);
+                  }
                 }
               }
               const afterBand = existsSync(P.registerBand(a)) ? readFileSync(P.registerBand(a), "utf8") : null;
@@ -12557,7 +12593,7 @@ async function pipelineInner(job, opts = {}) {
       jurisdictions: (() => { try { return JSON.parse(readFileSync(P.instructedScope, "utf8"))?.jurisdictions ?? null; } catch { return null; } })(),
     });
     if (caseLaw.declined)
-      note(`[case-law] the draft narrative turns on "${caseLaw.trigger}", and a ${caseLaw.product ?? "run with no resolved product"} does not carry the case-law reading — recorded, not run (#519)`);
+      note(`[case-law] the draft narrative turns on "${caseLaw.trigger}", and a ${caseLaw.product ?? "run with no resolved product"} does not carry the case-law reading — recorded, not run`);
     if (needCaseLaw) runLog(run.runDir, { event: "case-law-trigger", requested: caseLaw.requested, detected: caseLaw.detected });
     // T7 (E5): feed the finding index so the case-law stage stamps "- ord:" on each grounded
     // profile — the render + report-card joins become deterministic (copper-spire's prompt-fished join
@@ -13500,7 +13536,7 @@ async function pipelineInner(job, opts = {}) {
       // by construction, which is the intended shape: a BLOCKING with an empty reasons array is
       // structurally impossible, and any future path that reintroduces one dies here instead of shipping.
       if (verdict === "BLOCKING" && !reasonsOut.length)
-        throw new Error("verdict BLOCKING with no reasons — a blocking decision without its grounds; verdict.json is the artifact whose whole purpose is carrying them (#1065)");
+        throw new Error("verdict BLOCKING with no reasons — a blocking decision without its grounds; verdict.json is the artifact whose whole purpose is carrying them");
       // doc 50 — a v4 record derives off the run's FROZEN framework (band words); deriveDisplayVerdict
       // fail-louds if banded findings arrive with no manifest (never silently badge a rated matter LOW).
       const derived = deriveDisplayVerdict({ verdict, reasons: reasonsOut, kinds: kindsOut, findings: findingsArr,
@@ -14096,7 +14132,7 @@ async function pipelineInner(job, opts = {}) {
           screenGateUnresolved: readJson(driverDir(run.runDir, "screen-gate-unresolved.json"))?.unresolved ?? null,
           supplementalPlans,
           xcheck: readJson(driverDir(run.runDir, "register-xcheck.json")),
-          recall: readJson(driverDir(run.runDir, "register-recall.json")),
+          recall: recallReceiptForOwnCompany(readJson(driverDir(run.runDir, "register-recall.json"))),   // never another company's recall line
           planExecution: ctx.planExecution ?? readJson(P.planExecution),
         }, { ts: askTs });
       } catch (e) {
@@ -15476,6 +15512,7 @@ async function pipelineInner(job, opts = {}) {
     // and the run is already settled, so a failure to stamp is logged and the delivery proceeds.
     const stamp = writeSettleStamp(published.poolRunDir, { state: "delivered", signoff: verdict, deliveredAt, runId: published.runId ?? run.runId, lane: "clearance" });
     if (!stamp.written) note(`delivery: settle stamp not written (${stamp.reason})`);
+    endAnswerMemory(run.runDir);   // the held answers do not travel into the archive
     const archived = archive(run);
     rollupStatus(run.studioRoot);
     // `notified: "pending"` and `sendPending: true` unconditionally, which is what the KNOCKOUT lane has

package/driver/placement-carry.mjs

@@ -71,7 +71,7 @@ const isSepRow = (t) => /^\|[\s:|-]+\|$/.test(t);
  * BOTH reach every line of the section, prose included, and that is deliberate. The first cut held
  * the text path to pipe-TABLE rows only, on the theory that digest.md puts carried candidates in
  * tables. Run against the real 2026-07-29 findings it manufactured a loss: the watchlist annex there
- * is written as `- **W-1 · TIKI Brand outdoor-living portfolio — …**` bullets, so a candidate the
+ * is written as `- **W-1 · WAVO Brand outdoor-living portfolio — …**` bullets, so a candidate the
  * digest had plainly carried came back `uncarried`. A join that invents losses is worth nothing, and
  * the section shape is the digest's to choose. So the reach is the same as parseFindingsEndings
  * (recall-reconciliation.mjs), which has always counted a prose mention as an ending — one
@@ -216,7 +216,7 @@ export function adjudicationOf(entry, surfaces) {
   // Measured on `placement-carry-2026-07-29`, whose delivered digest discharges its one borderline
   // entry in as many words —
   //
-  //     | R-8 (my override) — placement-inquiry placed `TIKI LOVERS` at sheet-2 (S2-C) while flagging
+  //     | R-8 (my override) — placement-inquiry placed `WAVO LOVERS` at sheet-2 (S2-C) while flagging
   //       it as a borderline headline call | OVERRODE — promoted to headline. …
   //
   // — and names no URI anywhere in that row. A URI-only branch reports that discharged obligation as

package/driver/placement-form.mjs

@@ -103,7 +103,7 @@ export const SELECT_ROW_CONTRACT = Object.freeze({
   unresolved: "A `select` the band does not hold is reported back to you by id, never silently dropped.",
 });
 
-const PROVENANCE = "driver-written form (#562). You SELECT and you JUDGE; the driver COPIES. For each "
+const PROVENANCE = "driver-written form. You SELECT and you JUDGE; the driver COPIES. For each "
   + "register candidate you are placing, add a row naming one of its record ids in `select` plus your "
   + "`tier` and `reason` (and `borderline` if the call is close) — the driver resolves the id against the "
   + "register's own exact-identity fold and fills mark, owner, records, territories and classes from it, "

package/driver/portal-mcp-client.mjs

@@ -83,7 +83,7 @@ function post(urlStr, { headers = {}, body = "", wantId = null, timeoutMs = 3000
     });
     // — a timeout got no status and therefore no answer; it is marked at the throw rather than
     // recognised later by its message, so nothing has to keep a regex in step with a sentence.
-    req.setTimeout(timeoutMs, () => { req.destroy(transportError(`MCP request timed out after ${timeoutMs}ms`, null)); });
+    req.setTimeout(timeoutMs, () => { req.destroy(Object.assign(transportError(`MCP request timed out after ${timeoutMs}ms`, null), { timedOut: true })); });
     req.on("error", (e) => reject(isSocketFailure(e) ? transportError(e.message, null) : e));
     req.end(body);
   });