@renzrollon/interlock 1.4.2 → 1.5.0

package/lib/graph/graph/link-csharp.mjs

@@ -0,0 +1,210 @@
+// C# is linked in a pass after the per-file loop: a `using` names a namespace, and a
+// namespace is declared across many files, so it cannot be resolved against a set of
+// paths. This module is pure (no `node:` import) -- it takes every `extractCsharp`
+// record and returns `{ nodes, edges }`, the shape the OpenSpec and memory overlays
+// already return.
+
+const INFERRED_REFERENCE_WEIGHT = 0.5;
+
+function nameOf(entry) {
+  return typeof entry === 'string' ? entry : entry?.name;
+}
+
+function lineOf(entry, fallback = 1) {
+  const line = entry && typeof entry === 'object' ? entry.line : undefined;
+  return Number.isInteger(line) && line > 0 ? line : fallback;
+}
+
+function ascending(lines) {
+  if (!Array.isArray(lines)) return [];
+  return lines.filter((n) => Number.isInteger(n)).sort((a, b) => a - b);
+}
+
+/** `A.B.C` -> ['A.B.C', 'A.B', 'A'] */
+function dotPrefixes(name) {
+  const parts = name.split('.');
+  const out = [];
+  for (let i = parts.length; i > 0; i -= 1) out.push(parts.slice(0, i).join('.'));
+  return out;
+}
+
+function compare(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+/**
+ * Link C# records into namespace nodes, test nodes and their edges.
+ *
+ * @param {Array<{filePath: string, csharp?: object}>} records `extractCsharp` results
+ * @returns {{ nodes: object[], edges: object[] }}
+ */
+export function linkCsharp(records) {
+  const files = (Array.isArray(records) ? records : [])
+    .filter((r) => r && typeof r.filePath === 'string' && r.csharp)
+    .sort((a, b) => compare(a.filePath, b.filePath));
+
+  const nodes = [];
+  const edges = [];
+  const nodeIds = new Set();
+  const edgeKeys = new Set();
+
+  function addNode(node) {
+    if (nodeIds.has(node.id)) return;
+    nodeIds.add(node.id);
+    nodes.push(node);
+  }
+
+  function addEdge(edge) {
+    const key = `${edge.source}\u0000${edge.target}\u0000${edge.relation}\u0000${edge.source_location}`;
+    if (edgeKeys.has(key)) return;
+    edgeKeys.add(key);
+    edges.push(edge);
+  }
+
+  // Pass 1: every namespace the repository declares, and the types each one holds.
+  const declared = new Set();
+  const typesByNamespace = new Map(); // namespace -> Map(typeName -> [declFile])
+  for (const rec of files) {
+    for (const ns of rec.csharp.namespaces || []) {
+      const name = nameOf(ns);
+      if (!name) continue;
+      declared.add(name);
+      const id = `namespace:${name}`;
+      if (!nodeIds.has(id)) {
+        // First declaring file in path order, its first declaration.
+        const first = (rec.csharp.namespaces || [])
+          .filter((n) => nameOf(n) === name)
+          .reduce((best, n) => Math.min(best, lineOf(n)), Infinity);
+        addNode({
+          id,
+          type: 'namespace',
+          label: name,
+          source_file: rec.filePath,
+          source_location: `L${first}`,
+        });
+      }
+    }
+    for (const type of rec.csharp.types || []) {
+      const name = nameOf(type);
+      if (!name) continue;
+      const ns = type && typeof type === 'object' && typeof type.namespace === 'string' ? type.namespace : '';
+      if (!typesByNamespace.has(ns)) typesByNamespace.set(ns, new Map());
+      const byName = typesByNamespace.get(ns);
+      if (!byName.has(name)) byName.set(name, []);
+      if (!byName.get(name).includes(rec.filePath)) byName.get(name).push(rec.filePath);
+    }
+  }
+
+  const declaredByLength = [...declared].sort((a, b) => b.length - a.length || compare(a, b));
+  function resolveNamespace(name) {
+    return declaredByLength.find((d) => name === d || name.startsWith(`${d}.`)) || null;
+  }
+
+  // Pass 2: edges, per file in path order.
+  for (const rec of files) {
+    const fileId = `file:${rec.filePath}`;
+    const cs = rec.csharp;
+    const visible = new Set();
+
+    for (const ns of cs.namespaces || []) {
+      const name = nameOf(ns);
+      if (!name) continue;
+      addEdge({
+        source: fileId,
+        target: `namespace:${name}`,
+        relation: 'declares',
+        confidence: 'EXTRACTED',
+        source_file: rec.filePath,
+        source_location: `L${lineOf(ns)}`,
+        weight: 1,
+      });
+      for (const p of dotPrefixes(name)) visible.add(p);
+    }
+
+    for (const using of cs.usings || []) {
+      const name = nameOf(using);
+      if (!name) continue;
+      const hit = resolveNamespace(name);
+      if (hit) visible.add(hit);
+      addEdge({
+        source: fileId,
+        target: hit ? `namespace:${hit}` : `external:${name}`,
+        relation: 'imports',
+        confidence: 'EXTRACTED',
+        source_file: rec.filePath,
+        source_location: `L${lineOf(using)}`,
+        weight: 1,
+      });
+    }
+
+    const tests = [];
+    for (const t of cs.tests || []) {
+      if (!t || !t.name) continue;
+      const label = `${t.type}.${t.name}`;
+      const id = `test:${rec.filePath}#${label}`;
+      addNode({
+        id,
+        type: 'test',
+        label,
+        source_file: rec.filePath,
+        source_location: `L${lineOf(t)}`,
+      });
+      addEdge({
+        source: fileId,
+        target: id,
+        relation: 'exports',
+        confidence: 'EXTRACTED',
+        source_file: rec.filePath,
+        source_location: `L${lineOf(t)}`,
+        weight: 1,
+      });
+      tests.push({
+        id,
+        start: Number.isInteger(t.start) ? t.start : lineOf(t),
+        end: Number.isInteger(t.end) ? t.end : Infinity,
+      });
+    }
+
+    const ownTypes = new Set((cs.types || []).map(nameOf).filter(Boolean));
+    const identifiers = cs.identifiers || {};
+    for (const ident of Object.keys(identifiers).sort()) {
+      if (ownTypes.has(ident)) continue;
+      const lines = ascending(identifiers[ident]);
+      if (lines.length === 0) continue;
+      const targets = new Set();
+      for (const ns of visible) {
+        for (const declFile of typesByNamespace.get(ns)?.get(ident) || []) {
+          targets.add(`symbol:${declFile}#${ident}`);
+        }
+      }
+      for (const target of [...targets].sort()) {
+        addEdge({
+          source: fileId,
+          target,
+          relation: 'references',
+          confidence: 'INFERRED',
+          source_file: rec.filePath,
+          source_location: `L${lines[0]}`,
+          weight: INFERRED_REFERENCE_WEIGHT,
+          name: ident,
+        });
+        for (const test of tests) {
+          const at = lines.find((n) => n >= test.start && n <= test.end);
+          if (at === undefined) continue;
+          addEdge({
+            source: test.id,
+            target,
+            relation: 'references',
+            confidence: 'INFERRED',
+            source_file: rec.filePath,
+            source_location: `L${at}`,
+            weight: INFERRED_REFERENCE_WEIGHT,
+            name: ident,
+          });
+        }
+      }
+    }
+  }
+
+  return { nodes, edges };
+}

package/lib/graph/graph/query.mjs

@@ -134,6 +134,8 @@ export function consumers(graph, target) {
         );
         if (src?.type === 'file') {
           lines.push(`    consumer_file: ${src.source_file}`);
+        } else if (src?.type === 'test') {
+          lines.push(`    consumer_test: ${src.source_file}:${src.source_location} ${src.label}`);
         }
       }
     }

package/lib/graph/graph/report.mjs

@@ -1,7 +1,11 @@
 /**
  * Generate GRAPH_REPORT.md content from a graph.
+ *
+ * `skipped` is the build's list of paths it could not read (`[{ path, code }]`).
+ * They are in no node, so the report names them in a section of their own; with
+ * none, the report is what it was before the section existed.
  */
-export function writeReport(_root, graph, stats) {
+export function writeReport(_root, graph, stats, skipped = []) {
   const degree = new Map();
   for (const n of graph.nodes) degree.set(n.id, { in: 0, out: 0, node: n });
   for (const e of graph.links) {
@@ -60,6 +64,12 @@ export function writeReport(_root, graph, stats) {
   lines.push(`- Symbols: ${stats.symbols}`);
   lines.push(`- Modules: ${stats.modules}`);
   lines.push('');
+  if (Array.isArray(skipped) && skipped.length > 0) {
+    lines.push('## Not indexed (unreadable)');
+    lines.push('');
+    for (const entry of skipped) lines.push(`- ${entry.path} (${entry.code})`);
+    lines.push('');
+  }
   lines.push('## God nodes (highest degree)');
   lines.push('');
   if (hubs.length === 0) {

package/lib/graph/graph/update.mjs

@@ -1,6 +1,7 @@
-import fs from 'node:fs';
+import { extractMemory } from '../extract/memory.mjs';
+import { extractOpenspec } from '../extract/openspec.mjs';
 import { walkSourceFiles } from '../extract/walk.mjs';
-import { loadJson, manifestPath, rel, sha256File } from '../paths.mjs';
+import { createSkips, loadJson, manifestPath, readIndexed, rel } from '../paths.mjs';
 import { buildGraph, writeGraphArtifacts } from './build.mjs';
 
 /**
@@ -8,40 +9,79 @@ import { buildGraph, writeGraphArtifacts } from './build.mjs';
  * (v1 keeps it simple — detect staleness, then full rebuild of affected set + dependents
  * is complex; we do full rebuild when any hash differs, which is still fast for mid-size repos).
  *
- * Returns { updated: boolean, stats, reason }.
+ * Readability is compared as well as content. A path that was skipped by the
+ * recorded build and is still unreadable is not a change: it can never be
+ * hashed, so without the manifest's record it would look changed on every run.
+ * A path that was indexed and can no longer be read, and one that was skipped
+ * and can now be read, each rebuild.
+ *
+ * `skips` is the command's collector (`createSkips`). It holds the currently
+ * unreadable paths when this returns, whether or not the graph was rebuilt.
+ *
+ * Returns { updated: boolean, stats, reason, skipped }.
  */
-export function updateGraph(root) {
+export function updateGraph(root, { skips = createSkips(root) } = {}) {
   const manifest = loadJson(manifestPath(root), null);
   if (!manifest?.files) {
-    const result = buildGraph(root);
+    const result = buildGraph(root, { skips });
     writeGraphArtifacts(root, result);
-    return { updated: true, stats: result.stats, reason: 'no-manifest' };
+    return { updated: true, stats: result.stats, reason: 'no-manifest', skipped: result.skipped };
   }
 
-  const currentFiles = walkSourceFiles(root).map((f) => rel(root, f));
   const prevFiles = new Set(Object.keys(manifest.files));
   const changed = [];
 
-  for (const f of currentFiles) {
-    const abs = `${root}/${f}`;
-    if (!fs.existsSync(abs)) continue;
-    const hash = sha256File(abs);
-    if (manifest.files[f] !== hash) changed.push(f);
+  for (const abs of walkSourceFiles(root, { skips })) {
+    const f = rel(root, abs);
+    const got = readIndexed(abs);
+    if (!got.ok) {
+      // Unreadable now, not removed. Whether that is news is decided below,
+      // against the recorded skips.
+      skips.add(abs, got.code);
+      prevFiles.delete(f);
+      continue;
+    }
+    if (manifest.files[f] !== got.sha256) changed.push(f);
     prevFiles.delete(f);
   }
   const removed = [...prevFiles];
 
-  if (changed.length === 0 && removed.length === 0) {
-    return { updated: false, stats: manifest.stats, reason: 'up-to-date' };
+  // The overlays read prose the hashes above do not cover, and a build records
+  // what they could not read. Run the same readers so the two sets are compared
+  // like for like; what they extract is not used here.
+  extractOpenspec(root, new Set(), new Set(), { skips });
+  extractMemory(root, new Set(), { skips });
+
+  // A manifest written before skips were recorded reads as one with none.
+  const recorded = new Set(
+    (Array.isArray(manifest.skipped) ? manifest.skipped : []).map((entry) => entry?.path).filter(Boolean),
+  );
+  const current = skips.list();
+  const unreadableNow = current.filter((entry) => !recorded.has(entry.path)).map((entry) => entry.path);
+  const currentPaths = new Set(current.map((entry) => entry.path));
+  const readableNow = [...recorded].filter((p) => !currentPaths.has(p));
+
+  if (
+    changed.length === 0 &&
+    removed.length === 0 &&
+    unreadableNow.length === 0 &&
+    readableNow.length === 0
+  ) {
+    return { updated: false, stats: manifest.stats, reason: 'up-to-date', skipped: current };
   }
 
-  const result = buildGraph(root);
+  const result = buildGraph(root, { skips });
   writeGraphArtifacts(root, result);
+  const readability =
+    unreadableNow.length || readableNow.length
+      ? ` unreadable=${unreadableNow.length} readable=${readableNow.length}`
+      : '';
   return {
     updated: true,
     stats: result.stats,
-    reason: `changed=${changed.length} removed=${removed.length}`,
+    reason: `changed=${changed.length} removed=${removed.length}${readability}`,
     changed,
     removed,
+    skipped: result.skipped,
   };
 }

package/lib/graph/paths.mjs

@@ -49,10 +49,62 @@ export function abs(root, relPath) {
   return path.join(root, ...relPath.split('/'));
 }
 
-export function sha256File(filePath) {
-  const hash = createHash('sha256');
-  hash.update(fs.readFileSync(filePath));
-  return hash.digest('hex');
+/** Marker on every stderr line naming a path an indexing command could not read. */
+export const SKIP_MARKER = 'GRAPH SKIPPED UNREADABLE';
+
+/** Marker on the one stderr line a query prints when its graph was built past skipped paths. */
+export const PARTIAL_MARKER = 'GRAPH PARTIAL';
+
+function codeOf(errorOrCode) {
+  if (typeof errorOrCode === 'string' && errorOrCode) return errorOrCode;
+  const code = errorOrCode && typeof errorOrCode === 'object' ? errorOrCode.code : undefined;
+  return typeof code === 'string' && code ? code : 'UNKNOWN';
+}
+
+/**
+ * Read a file once. Returns its text and the sha256 of the same bytes, or the
+ * error code the read failed with. Never throws and never prints: the caller
+ * decides what a failed read means (usually: `skips.add`).
+ */
+export function readIndexed(absPath) {
+  let bytes;
+  try {
+    bytes = fs.readFileSync(absPath);
+  } catch (error) {
+    return { ok: false, code: codeOf(error) };
+  }
+  return {
+    ok: true,
+    text: bytes.toString('utf8'),
+    sha256: createHash('sha256').update(bytes).digest('hex'),
+  };
+}
+
+/**
+ * Collector for paths that could not be read. One entry per path, root-relative
+ * with forward slashes, listed sorted by path.
+ */
+export function createSkips(root) {
+  const byPath = new Map();
+  return {
+    add(absPath, errorOrCode, note) {
+      const p = rel(root, absPath);
+      const entry = { path: p, code: codeOf(errorOrCode) };
+      if (note) entry.note = note;
+      const prior = byPath.get(p);
+      if (prior && (prior.note || !entry.note)) return;
+      byPath.set(p, entry);
+    },
+    list() {
+      return [...byPath.values()].sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+    },
+  };
+}
+
+/** `GRAPH SKIPPED UNREADABLE: <path> (<code>)`, plus ` — <note>` when there is one. */
+export function formatSkip(entry) {
+  const note = entry.note ? ` \u2014 ${entry.note}` : '';
+  return `${SKIP_MARKER}: ${entry.path} (${entry.code})${note}`;
 }
 
 export function loadJson(filePath, fallback = null) {

package/lib/graph/retrieve/context.mjs

@@ -21,6 +21,7 @@ export function retrieveContext(root, {
   graphBudget = null,
   docsBudget = null,
   docsDirs = null,
+  skips,
 } = {}) {
   const terms = deriveTerms({ query, changedFiles, commitSubject });
   const searchQuery = query || terms.slice(0, 8).join(' ');
@@ -64,6 +65,7 @@ export function retrieveContext(root, {
     changedFiles,
     dirs: docsDirs ?? undefined,
     budget: docsShare,
+    skips,
   });
 
   parts.push(docsResult.text.trimEnd());

package/lib/graph/retrieve/docs-index.mjs

@@ -1,10 +1,9 @@
-import fs from 'node:fs';
 import {
   docsDigestPath,
   docsIndexPath,
   ensureGraphDir,
+  readIndexed,
   rel,
-  sha256File,
   writeJson,
 } from '../paths.mjs';
 import { walkMarkdown, resolveDocsDirs } from '../extract/walk.mjs';
@@ -41,21 +40,21 @@ export function extractBlurb(content, blurbTokens = DEFAULT_BLURB_TOKENS) {
 export function buildDocsIndex(root, {
   dirs: requestedDirs,
   blurbTokens = DEFAULT_BLURB_TOKENS,
+  skips,
 } = {}) {
   const dirs = resolveDocsDirs(root, requestedDirs);
   const files = [];
   let totalSections = 0;
   let totalTokens = 0;
 
-  for (const absPath of walkMarkdown(root, dirs)) {
+  for (const absPath of walkMarkdown(root, dirs, { skips })) {
     const filePath = rel(root, absPath);
-    let text;
-    try {
-      text = fs.readFileSync(absPath, 'utf8');
-    } catch {
+    const read = readIndexed(absPath);
+    if (!read.ok) {
+      if (skips) skips.add(absPath, read.code);
       continue;
     }
-    const sha256 = sha256File(absPath);
+    const { text, sha256 } = read;
     const sections = parseMarkdownSections(filePath, text).map((s) => {
       const tokens_est = estimateTokens(s.content);
       return {
@@ -97,8 +96,8 @@ export function buildDocsIndex(root, {
  * Returns { index, path, written }.
  */
 export function writeDocsIndex(root, options = {}) {
-  const { write = true, dirs, blurbTokens } = options;
-  const index = buildDocsIndex(root, { dirs, blurbTokens });
+  const { write = true, dirs, blurbTokens, skips } = options;
+  const index = buildDocsIndex(root, { dirs, blurbTokens, skips });
   const outPath = docsIndexPath(root);
   if (write) {
     ensureGraphDir(root);

package/lib/graph/retrieve/markdown.mjs

@@ -1,6 +1,5 @@
-import fs from 'node:fs';
 import path from 'node:path';
-import { rel } from '../paths.mjs';
+import { readIndexed, rel } from '../paths.mjs';
 import { walkMarkdown, resolveDocsDirs } from '../extract/walk.mjs';
 import { estimateTokens } from '../format.mjs';
 
@@ -150,6 +149,7 @@ export function retrieveMarkdownSections(root, {
   perSectionLines = DEFAULT_PER_SECTION_LINES,
   perSectionTokens = DEFAULT_PER_SECTION_TOKENS,
   minScore = 1,
+  skips,
 } = {}) {
   const terms = explicitTerms ?? deriveTerms({ query, changedFiles });
   const changedPaths = changedFiles.map((f) => String(f).replace(/\\/g, '/'));
@@ -157,19 +157,19 @@ export function retrieveMarkdownSections(root, {
   // Fall back to probing only when the caller did not name dirs AND the
   // preferred roots are empty on this repo.
   let dirs = requestedDirs ?? DEFAULT_DIRS;
-  if (!requestedDirs && walkMarkdown(root, DEFAULT_DIRS).length === 0) {
+  if (!requestedDirs && walkMarkdown(root, DEFAULT_DIRS, { skips }).length === 0) {
     dirs = resolveDocsDirs(root, null);
   }
 
   const allSections = [];
-  for (const absPath of walkMarkdown(root, dirs)) {
+  for (const absPath of walkMarkdown(root, dirs, { skips })) {
     const filePath = rel(root, absPath);
-    let text;
-    try {
-      text = fs.readFileSync(absPath, 'utf8');
-    } catch {
+    const read = readIndexed(absPath);
+    if (!read.ok) {
+      if (skips) skips.add(absPath, read.code);
       continue;
     }
+    const text = read.text;
     for (const section of parseMarkdownSections(filePath, text)) {
       const s = scoreSection(section, terms, changedPaths);
       if (s >= minScore) {

package/lib/limits.mjs

@@ -87,6 +87,12 @@ export const LIMITS = {
   /**
    * Soft budget for inter-wave verification. Past this, drop to typecheck only
    * rather than letting the checks outweigh the work they guard.
+   *
+   * This is a floor, not the budget every run gets: a test profile whose
+   * `unit.timeout_ms` is a positive integer raises it to `interWaveVerifications`
+   * times that allowance (`interWaveVerifyBudget` in `lib/verify.mjs`), and
+   * nothing a profile says can lower it. A caller's explicit `--budget-ms` still
+   * overrides both.
    */
   interWaveVerifyBudgetMs: 60_000,
 
@@ -115,9 +121,11 @@ export const LIMITS = {
   /**
    * Character budget for one task's wave handoff — `summary`, `next`,
    * `blocker` and the joined `evidence` locators added together. A packet over
-   * this fails its task rather than being truncated: silent truncation is the
+   * this is rejected whole rather than truncated: silent truncation is the
    * degradation the schema exists to forbid, and a next wave reading half a
-   * sentence is worse off than one told the report was rejected.
+   * sentence is worse off than one told the report was rejected. The task that
+   * filed it stays done; the paths a rejected report hands on are held to this
+   * same cap.
    * See add-wave-handoff-and-prompt-snapshots design.md §2.
    */
   maxHandoffChars: 2000,
@@ -559,7 +567,7 @@ export function formatLimits({ runtimeObserved } = {}) {
     ['root-cause iterations (per run)', LIMITS.rootCauseIterations],
     ['task failures tolerated', LIMITS.taskFailureHalt],
     ['run steps (per run)', LIMITS.maxRunSteps],
-    ['inter-wave verify budget', `${LIMITS.interWaveVerifyBudgetMs / 1000}s`],
+    ['inter-wave verify budget (floor)', `${LIMITS.interWaveVerifyBudgetMs / 1000}s`],
     ['inter-wave verifications (per run)', LIMITS.interWaveVerifications],
     ['verify spill threshold (bytes)', LIMITS.verifySpillBytes],
     ['verify preview budget (chars)', LIMITS.verifyPreviewChars],

package/lib/outcomes.mjs

@@ -177,7 +177,14 @@ function waveTallies(value) {
       wave: nullableCount(w.wave),
       ok: nullableCount(w.ok),
       failed: nullableCount(w.failed),
-      notAttempted: nullableStringArray(w.notAttempted, MAX_NAME) || []
+      notAttempted: nullableStringArray(w.notAttempted, MAX_NAME) || [],
+      // Task ids whose handoff packet was rejected though the task reported success.
+      // Carried only when the row holds the key: a row from before the field
+      // existed keeps the shape it had, and an absent key reads as unobserved --
+      // never `[]`, which would say the run looked and found none.
+      ...(w.reportRejected !== undefined
+        ? { reportRejected: nullableStringArray(w.reportRejected, MAX_NAME) }
+        : {})
     }
   })
 }

package/lib/prompts/implementer.mjs

@@ -11,7 +11,17 @@
 // assembled text has to be a deliberate act that updates a file, not a side
 // effect of editing nearby control flow.
 
-export function assembleImplementerPrompt({ change, lane, task, previousHandoffs, isolateWaves, solo }) {
+import { renderRejectedReport } from './rejected.mjs'
+
+export function assembleImplementerPrompt({
+  change,
+  lane,
+  task,
+  previousHandoffs,
+  previousRejectedReports,
+  isolateWaves,
+  solo
+}) {
   // A lane is the unit now; a bare `task` is still accepted and means a lane of
   // one. That is not politeness to old callers — a one-task lane MUST assemble
   // byte-identically to the pre-lane prompt, and sharing one code path is the
@@ -54,6 +64,19 @@ export function assembleImplementerPrompt({ change, lane, task, previousHandoffs
       `\n`
     : ''
 
+  // A previous-wave task that said it succeeded but whose packet did not validate.
+  // It is not a failure and has no packet to quote, so it gets its own block: the
+  // reason the packet was rejected and the paths it claimed, to be read, not trusted.
+  // Empty or absent renders nothing, so every existing prompt stays byte-identical.
+  const rejectedEntries = (Array.isArray(previousRejectedReports) ? previousRejectedReports : []).filter(
+    r => r && typeof r === 'object'
+  )
+  const rejected = rejectedEntries.length
+    ? `\nNO VALIDATED REPORT (the packet was rejected; read the paths, assume nothing):\n` +
+      rejectedEntries.map(renderRejectedReport).join('\n') +
+      `\n`
+    : ''
+
   // A lane of one renders exactly the text it rendered before lanes existed —
   // the single-task fixtures are the pin that keeps that honest.
   const single = tasks.length === 1
@@ -137,12 +160,14 @@ export function assembleImplementerPrompt({ change, lane, task, previousHandoffs
       ? `- If your tier is 1 or 2: after typecheck/lint pass, stop. Do not refactor or polish.\n`
       : '') +
     previous +
+    rejected +
     isolation +
     handoff +
     `- status "ok" means blocker is null; "blocked" and "partial" need a non-empty blocker.\n` +
     `- evidence is at most 8 locators (path, path:line, path:start-end) — never file bodies.\n` +
-    `- Keep it terse. A packet over the character cap \`interlock limits\` publishes fails the ` +
-    `task, and it is never truncated for you.\n\n` +
+    `- Keep it terse. A packet over the character cap \`interlock limits\` publishes is rejected ` +
+    `whole — it is never truncated for you, and your task is recorded as having filed no usable ` +
+    `report.\n\n` +
     (single
       ? `Report ok:false if you could not complete the task, with what blocked you.`
       : `Report outcome "failed" for the task that blocked you, with what blocked you.`)