@mjasnikovs/pi-task 0.40.8 → 0.40.11

package/dist/shared/child-output.d.ts

@@ -41,17 +41,33 @@ export interface ExcerptVerification {
     contentLength: number;
     /** The whitespace-normalised excerpt that was searched for. */
     normalisedExcerpt: string;
+    /**
+     * How many verbatim spans of the source the excerpt is made of — 1 when it
+     * verified, more when the child stitched it. Over every unverified excerpt in
+     * five live runs it ran 2 to 11, with nothing missing.
+     */
+    verbatimSpans: number;
+    /** Words in no span of the source at all. This, not `verified`, is what a
+     *  fabrication looks like. */
+    absent: string[];
 }
 export declare function verifyExcerpt(excerpt: string, content: string): ExcerptVerification;
 /**
  * Format the child's parsed output with a header and optional excerpt block.
  *
- * The warning is prepended only on the excerpt path, and only for an explicit
- * `false`. With no excerpt the function returns before the warning is built, and
- * an `undefined` verdict — nothing was checked — prints no warning either. So the
- * warning means "checked and not found", never "not checked".
+ * The note is prepended only on the excerpt path, and only when something was
+ * actually checked. With no excerpt the function returns before it is built, and
+ * an undefined verification — nothing was checked — prints nothing either. So a
+ * note means "checked", never "not checked".
+ *
+ * Two different findings, because they mean different things to the worker that
+ * reads this. An excerpt the source does not contain a word of is a possible
+ * fabrication. An excerpt assembled from several real spans is a stitched quote,
+ * which is what the extraction prompt produces — and calling that a possible
+ * hallucination was wrong on 21 of 21 measured cases, on a fifth of every run's
+ * answers. See "Defect 18" in DOC_REGRESSINONS.md.
  */
 export declare function formatResultText(header: string, parsed: {
     answer: string;
     excerpt?: string;
-}, verified: boolean | undefined): string;
+}, check: ExcerptVerification | undefined): string;

package/dist/shared/child-output.js

@@ -44,6 +44,40 @@ export function isExcerptInContent(excerpt, content) {
         return false;
     return normaliseWhitespace(content).includes(ne);
 }
+/** The child writes these to mark its own join, so they are not source text and
+ *  not evidence of invention either. */
+const ELISION = /^(?:\.{3}|\u2026|\/\/\s*\.{3})$/;
+/**
+ * Cover the excerpt with the longest runs the source actually contains, greedily.
+ *
+ * `verified` asks whether the excerpt is ONE such run. This asks what it is made
+ * of, which is the difference between a quote assembled from four real places and
+ * a quote with a word nobody wrote. The warning needs the second question; it had
+ * only ever asked the first.
+ */
+function coverBySource(normalisedExcerpt, normalisedContent) {
+    const words = normalisedExcerpt.length === 0 ? [] : normalisedExcerpt.split(' ');
+    const absent = [];
+    let verbatimSpans = 0;
+    let i = 0;
+    while (i < words.length) {
+        let run = 0;
+        while (i + run < words.length
+            && normalisedContent.includes(words.slice(i, i + run + 1).join(' '))) {
+            run++;
+        }
+        if (run === 0) {
+            if (!ELISION.test(words[i]))
+                absent.push(words[i]);
+            i++;
+        }
+        else {
+            verbatimSpans++;
+            i += run;
+        }
+    }
+    return { verbatimSpans, absent };
+}
 export function verifyExcerpt(excerpt, content) {
     const nc = normaliseWhitespace(content);
     const ne = normaliseWhitespace(excerpt);
@@ -52,24 +86,36 @@ export function verifyExcerpt(excerpt, content) {
         verified: isExcerptInContent(excerpt, content),
         contentSha256: createHash('sha256').update(nc).digest('hex'),
         contentLength: nc.length,
-        normalisedExcerpt: ne
+        normalisedExcerpt: ne,
+        ...coverBySource(ne, nc)
     };
 }
 /**
  * Format the child's parsed output with a header and optional excerpt block.
  *
- * The warning is prepended only on the excerpt path, and only for an explicit
- * `false`. With no excerpt the function returns before the warning is built, and
- * an `undefined` verdict — nothing was checked — prints no warning either. So the
- * warning means "checked and not found", never "not checked".
+ * The note is prepended only on the excerpt path, and only when something was
+ * actually checked. With no excerpt the function returns before it is built, and
+ * an undefined verification — nothing was checked — prints nothing either. So a
+ * note means "checked", never "not checked".
+ *
+ * Two different findings, because they mean different things to the worker that
+ * reads this. An excerpt the source does not contain a word of is a possible
+ * fabrication. An excerpt assembled from several real spans is a stitched quote,
+ * which is what the extraction prompt produces — and calling that a possible
+ * hallucination was wrong on 21 of 21 measured cases, on a fifth of every run's
+ * answers. See "Defect 18" in DOC_REGRESSINONS.md.
  */
-export function formatResultText(header, parsed, verified) {
+export function formatResultText(header, parsed, check) {
     if (!parsed.excerpt) {
         return header ? `${header}\n\n${parsed.answer}` : parsed.answer;
     }
     const quote = parsed.excerpt.replace(/\n/g, '\n> ');
-    const warning = verified === false ?
-        'WARNING: cited excerpt not found verbatim in source content — the child pi may have paraphrased or hallucinated.\n\n'
-        : '';
-    return `${warning}${header}\n\n${parsed.answer}\n\nSource excerpt:\n> ${quote}`;
+    let note = '';
+    if (check && !check.verified) {
+        note =
+            check.absent.length > 0 ?
+                'WARNING: cited excerpt not found verbatim in source content — the child pi may have paraphrased or hallucinated.\n\n'
+                : `NOTE: cited excerpt is stitched from ${check.verbatimSpans} separate spans of the source; every span is verbatim.\n\n`;
+    }
+    return `${note}${header}\n\n${parsed.answer}\n\nSource excerpt:\n> ${quote}`;
 }

package/dist/task/deprecated-constraint.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Sibling of refuted-constraint.ts, for the other half of the same failure.
+ *
+ * That pass deletes a refine-invented DEPENDENCY the research says is not needed.
+ * This one deletes a refine-invented API or package the research says is
+ * DEPRECATED. Defect 14: refine writes an API example into CONSTRAINTS from
+ * memory before research runs, research then names that exact form as superseded,
+ * and compose prefers the constraint — so the run ships the deprecated call with
+ * the correct answer sitting one section above it in the same file.
+ *
+ * Everything about the sibling's discipline carries over unchanged: the
+ * correction is SUBTRACTIVE (an appended one loses to the text it contradicts),
+ * the match is lexical, and an owned-requirement line is never touched.
+ *
+ * Two things are deliberately NOT shared with the sibling, which is why this is a
+ * second pass and not a widening of the first:
+ *
+ *  - it reads research APIS as well as CONTEXT, and two of the three recorded
+ *    fires are in APIS;
+ *  - its token class admits an UN-BACKTICKED API expression (`z.string().email()`),
+ *    which `isPackageToken` refuses on purpose to keep the dependency channel
+ *    narrow. Widening that channel to reach this one would loosen it for every
+ *    dependency drop.
+ */
+export type Deprecation = {
+    /** The deprecated token, as it must be matched inside the constraint. */
+    token: string;
+    /** Index into the refined prompt's lines. */
+    line: number;
+    /** The refine CONSTRAINTS line, verbatim, before the drop. */
+    constraint: string;
+    /** The research line that deprecates it, verbatim. */
+    research: string;
+    /** `apis-symbol` or `marker-adjacent` — which rule fired. */
+    rule: string;
+};
+/** The tokens one research line deprecates, or an empty list. */
+export declare function deprecatedTokens(line: string): string[];
+/**
+ * Find every (constraint line, research line, deprecated token) triple. `refined`
+ * is the refined prompt and `research` the research output — the exact strings
+ * compose is handed.
+ */
+export declare function detectDeprecations(refined: string, research: string): Deprecation[];
+/**
+ * Delete one token from a constraint line, backticked or bare, plus one adjacent
+ * list separator. Then collapse the wreckage the deletion left: an emptied
+ * `(e.g. )`, doubled spaces, a space stranded before punctuation.
+ *
+ * Every step removes characters and adds none, so the result stays a character
+ * subsequence of the input — the invariant the whole approach rests on.
+ *
+ * The example-parenthetical collapse requires a literal `e.g.`/`i.e.` rather than
+ * matching any emptied `()`. A bare `\(\s*\)` also matches the call parens inside
+ * `z.string()` elsewhere on the same line, which would silently corrupt a
+ * constraint this pass is not even firing on.
+ *
+ * Returns null when nothing but boilerplate is left, which the caller turns into
+ * a whole-line drop.
+ */
+export declare function dropExpression(line: string, token: string): string | null;
+export type DeprecationResult = {
+    refined: string;
+    trail: string[];
+    deprecations: Deprecation[];
+};
+/** Apply every detected deprecation to the refined prompt. Purely subtractive. */
+export declare function applyDeprecations(refined: string, research: string): DeprecationResult;

package/dist/task/deprecated-constraint.js

@@ -0,0 +1,262 @@
+/**
+ * Sibling of refuted-constraint.ts, for the other half of the same failure.
+ *
+ * That pass deletes a refine-invented DEPENDENCY the research says is not needed.
+ * This one deletes a refine-invented API or package the research says is
+ * DEPRECATED. Defect 14: refine writes an API example into CONSTRAINTS from
+ * memory before research runs, research then names that exact form as superseded,
+ * and compose prefers the constraint — so the run ships the deprecated call with
+ * the correct answer sitting one section above it in the same file.
+ *
+ * Everything about the sibling's discipline carries over unchanged: the
+ * correction is SUBTRACTIVE (an appended one loses to the text it contradicts),
+ * the match is lexical, and an owned-requirement line is never touched.
+ *
+ * Two things are deliberately NOT shared with the sibling, which is why this is a
+ * second pass and not a widening of the first:
+ *
+ *  - it reads research APIS as well as CONTEXT, and two of the three recorded
+ *    fires are in APIS;
+ *  - its token class admits an UN-BACKTICKED API expression (`z.string().email()`),
+ *    which `isPackageToken` refuses on purpose to keep the dependency channel
+ *    narrow. Widening that channel to reach this one would loosen it for every
+ *    dependency drop.
+ */
+/** Bare ALL-CAPS section header — same boundary convention as the sibling. */
+const HEADER = /^[A-Z][A-Z -]*$/;
+/**
+ * The closed deprecation set, exactly as the base-rate measurement left it.
+ *
+ * `\breplaced by\b` was in the first pattern set and the measurement REMOVED it:
+ * it fired on "`src/shared/index.ts`  Empty file to be replaced by schema.ts
+ * exports", a claim about a FILE, and it was the only false positive in 14,171
+ * task files. Dropping it loses none of the three true fires.
+ */
+const DEPRECATION = /@?\bdeprecated\b|\bsupersed(?:e|es|ed)\b|\bmerged\s+into\b|\bno\s+longer\s+(?:recommended|supported|maintained)\b/i;
+/**
+ * Where the token's own clause ends. A deprecation marker past one of these is a
+ * claim about something else — on "z.email()  … for adminEmail (z.string().email()
+ * … is @deprecated)" the opening paren is what stops the leading symbol from
+ * inheriting the verdict on the expression inside it.
+ *
+ * A character window was measured first and rejected: it is flat from 41 to 4,000
+ * over 12,568 task files, so the corpus cannot choose one and any value would be
+ * a guess. The clause boundary reproduces the same 3 fires with no constant.
+ */
+const CLAUSE_END = /[;()\u2014\u2013]|\.\s/;
+/** The owned-requirement stamp requirements.ts writes. Never refutable. */
+const OWNED_MARKER = 'owned requirement from the source design';
+const IDENT = '[A-Za-z_$][A-Za-z0-9_$]*';
+const CALL = '\\([^()]*\\)';
+/**
+ * A call expression: identifiers and calls chained with `.`, requiring at least
+ * one of each. `Network.Wai.Test` is a module path and does not qualify;
+ * `z.string().email()` does. This is the class the sibling refuses.
+ */
+const EXPRESSION = new RegExp(`${IDENT}(?:\\.${IDENT}|${CALL})+`, 'g');
+/**
+ * A package name, narrowed to the compound forms. A bare word (`aeson`, `text`)
+ * is excluded: on the leading-symbol rule below it would let any one-word noun in
+ * a deprecation sentence reach CONSTRAINTS, and no recorded fire needs it.
+ */
+const PACKAGE = /^@?[a-z][a-z0-9.]*(?:[-/][a-z0-9.]+)+$/;
+/** Section body between a bare ALL-CAPS header and the next one (or EOF). */
+function capsSection(text, heading) {
+    const lines = text.split('\n');
+    const start = lines.findIndex(l => l.trim() === heading);
+    if (start === -1)
+        return null;
+    const rest = lines.slice(start + 1);
+    const end = rest.findIndex(l => HEADER.test(l.trim()) && l.trim().length > 1);
+    return (end === -1 ? rest : rest.slice(0, end)).join('\n');
+}
+/** One entry per bullet or per `symbol  description` row; continuations joined. */
+function entries(section) {
+    const out = [];
+    for (const raw of section.split('\n')) {
+        const line = raw.trimEnd();
+        if (!line.trim())
+            continue;
+        if (/^\s*[-*]\s+/.test(line) || !/^\s/.test(line))
+            out.push(line.trim());
+        else if (out.length > 0)
+            out[out.length - 1] += ` ${line.trim()}`;
+        else
+            out.push(line.trim());
+    }
+    return out;
+}
+function stripTicks(s) {
+    return s.replace(/`/g, '');
+}
+/**
+ * Every expression on the line whose deprecation marker sits in the same clause,
+ * ahead of it. Forward-only: "X is deprecated, use Y" must not indict Y, and Y is
+ * always on the far side of the marker.
+ */
+function markerAdjacent(line) {
+    const flat = stripTicks(line);
+    const out = [];
+    for (const m of flat.matchAll(EXPRESSION)) {
+        const tok = m[0];
+        if (!tok.includes('.') || !tok.includes('('))
+            continue;
+        const rest = flat.slice(m.index + tok.length);
+        const stop = CLAUSE_END.exec(rest);
+        const tail = stop ? rest.slice(0, stop.index) : rest;
+        if (DEPRECATION.test(tail) && !out.includes(tok))
+            out.push(tok);
+    }
+    return out;
+}
+/**
+ * An APIS row is `symbol  description`, so the row's leading symbol is what the
+ * row is ABOUT. Used only when no expression sits next to the marker: on
+ * "z.email()  … (z.string().email() … is @deprecated)" the leading symbol is the
+ * replacement, not the casualty, and the adjacent expression is the truth.
+ */
+function apisSymbol(line) {
+    const m = /^(\S+)\s\s+\S/.exec(stripTicks(line));
+    if (!m)
+        return null;
+    const tok = m[1];
+    if (PACKAGE.test(tok))
+        return tok;
+    if (tok.includes('.') && tok.includes('('))
+        return tok;
+    return null;
+}
+/** The tokens one research line deprecates, or an empty list. */
+export function deprecatedTokens(line) {
+    if (!DEPRECATION.test(stripTicks(line)))
+        return [];
+    const adjacent = markerAdjacent(line);
+    if (adjacent.length > 0)
+        return adjacent;
+    const symbol = apisSymbol(line);
+    return symbol === null ? [] : [symbol];
+}
+/**
+ * Find every (constraint line, research line, deprecated token) triple. `refined`
+ * is the refined prompt and `research` the research output — the exact strings
+ * compose is handed.
+ */
+export function detectDeprecations(refined, research) {
+    const constraintsBody = capsSection(refined, 'CONSTRAINTS');
+    if (constraintsBody === null)
+        return [];
+    const deprecated = new Map();
+    for (const heading of ['APIS', 'CONTEXT']) {
+        const body = capsSection(research, heading);
+        if (body === null)
+            continue;
+        for (const line of entries(body)) {
+            const adjacent = markerAdjacent(line);
+            const rule = adjacent.length > 0 ? 'marker-adjacent' : 'apis-symbol';
+            for (const tok of deprecatedTokens(line)) {
+                if (!deprecated.has(tok))
+                    deprecated.set(tok, { research: line, rule });
+            }
+        }
+    }
+    if (deprecated.size === 0)
+        return [];
+    const lines = refined.split('\n');
+    const start = lines.findIndex(l => l.trim() === 'CONSTRAINTS');
+    const out = [];
+    for (let i = start + 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (HEADER.test(line.trim()) && line.trim().length > 1)
+            break;
+        if (line.includes(OWNED_MARKER))
+            continue;
+        for (const [tok, src] of deprecated) {
+            if (!stripTicks(line).includes(tok))
+                continue;
+            out.push({
+                token: tok,
+                line: i,
+                constraint: line,
+                research: src.research,
+                rule: src.rule
+            });
+        }
+    }
+    return out;
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Delete one token from a constraint line, backticked or bare, plus one adjacent
+ * list separator. Then collapse the wreckage the deletion left: an emptied
+ * `(e.g. )`, doubled spaces, a space stranded before punctuation.
+ *
+ * Every step removes characters and adds none, so the result stays a character
+ * subsequence of the input — the invariant the whole approach rests on.
+ *
+ * The example-parenthetical collapse requires a literal `e.g.`/`i.e.` rather than
+ * matching any emptied `()`. A bare `\(\s*\)` also matches the call parens inside
+ * `z.string()` elsewhere on the same line, which would silently corrupt a
+ * constraint this pass is not even firing on.
+ *
+ * Returns null when nothing but boilerplate is left, which the caller turns into
+ * a whole-line drop.
+ */
+export function dropExpression(line, token) {
+    const tokRe = new RegExp('`?' + escapeRe(token) + '`?', 'g');
+    let next = line;
+    for (;;) {
+        const m = tokRe.exec(next);
+        if (!m)
+            break;
+        const start = m.index;
+        const end = start + m[0].length;
+        const before = next.slice(0, start);
+        const sepBefore = /(?:,\s*|\s+or\s+|\s+and\s+)$/.exec(before);
+        if (sepBefore) {
+            next = next.slice(0, start - sepBefore[0].length) + next.slice(end);
+        }
+        else {
+            const sepAfter = /^(?:\s*,\s*|\s+or\s+|\s+and\s+)/.exec(next.slice(end));
+            next = before + next.slice(end + (sepAfter ? sepAfter[0].length : 0));
+        }
+        tokRe.lastIndex = 0;
+    }
+    if (next === line)
+        return line;
+    // Leading whitespace is held out of the collapse: it is a nested bullet's
+    // markdown level, not a gap this deletion opened.
+    const indent = /^\s*/.exec(next)?.[0] ?? '';
+    next =
+        indent
+            + next
+                .slice(indent.length)
+                .replace(/\s*\((?:\s*e\.g\.,?|\s*i\.e\.,?)\s*\)/gi, '')
+                .replace(/ {2,}/g, ' ')
+                .replace(/ +([.,;:)])/g, '$1');
+    const carcass = next.replace(/^\s*[-*]\s*/, '').replace(/[\s,.;:()]/g, '');
+    return carcass.length === 0 ? null : next;
+}
+/** Apply every detected deprecation to the refined prompt. Purely subtractive. */
+export function applyDeprecations(refined, research) {
+    const deprecations = detectDeprecations(refined, research);
+    if (deprecations.length === 0)
+        return { refined, trail: [], deprecations };
+    const lines = refined.split('\n');
+    const dropped = new Set();
+    const trail = [];
+    for (const d of deprecations) {
+        const next = dropExpression(lines[d.line], d.token);
+        const what = next === null ?
+            `dropped the whole CONSTRAINTS line for '${d.token}'`
+            : `dropped '${d.token}' from CONSTRAINTS`;
+        if (next === null)
+            dropped.add(d.line);
+        else
+            lines[d.line] = next;
+        trail.push(`constraint deprecated by research — ${what}`
+            + ` | constraint: "${d.constraint.trim()}" | research: "${d.research.trim()}"`);
+    }
+    return { refined: lines.filter((_l, i) => !dropped.has(i)).join('\n'), trail, deprecations };
+}

package/dist/task/phases.d.ts

@@ -174,10 +174,12 @@ export declare function phaseResearch(deps: PhaseDeps, refined: string): Promise
 export declare function phaseAutoAnswer(deps: PhaseDeps, refined: string, research: string, question: string): Promise<AutoAnswer>;
 export declare function phaseGrill(deps: PhaseDeps, ctx: ExtensionCommandContext, widgetState: WidgetState, refined: string, research: string): Promise<string>;
 /**
- * A refutation is a DELETION. Where the run's own research explicitly says a
- * dependency refine invented is not needed, drop that token from CONSTRAINTS —
- * compose cannot forbid the design's own API "because the refined task
- * explicitly requires `argon2`" if the refined task no longer requires it.
+ * A correction is a DELETION. Where the run's own research explicitly says a
+ * dependency refine invented is not needed, or names the API refine wrote as
+ * deprecated, drop that token from CONSTRAINTS — compose cannot forbid the
+ * design's own API "because the refined task explicitly requires `argon2`" if the
+ * refined task no longer requires it, and cannot ship `z.string().email()` under
+ * a constraint that no longer names it.
  *
  * Applied to the REFINED TASK ITSELF, not to compose's copy of it, and that is
  * load-bearing: critique receives the refined task as GROUND TRUTH and is told
@@ -185,7 +187,8 @@ export declare function phaseGrill(deps: PhaseDeps, ctx: ExtensionCommandContext
  * them", so a deletion visible only to compose is restored one phase later. Both
  * spec-producing phases have to see the same text.
  *
- * Purely subtractive and never touches an owned line (task/refuted-constraint.ts).
+ * Purely subtractive and never touches an owned line (task/refuted-constraint.ts,
+ * task/deprecated-constraint.ts).
  * Idempotent, so a resumed run re-deriving `refined` from the task file lands in
  * the same place. The task file's `## refined prompt` is deliberately left as
  * refine wrote it; the drop is recorded on the `## gates` trail with both source
@@ -193,7 +196,7 @@ export declare function phaseGrill(deps: PhaseDeps, ctx: ExtensionCommandContext
  */
 export declare function dropRefutedConstraints(deps: PhaseDeps, refined: string, research: string): Promise<string>;
 /**
- * COMPOSE's carry: the refutation drop, as a `PhaseConfig.carry`.
+ * COMPOSE's carry: both subtractive drops, as a `PhaseConfig.carry`.
  *
  * Same transform as `dropRefutedConstraints` over the same pure core, minus the
  * recording — the caller decides whether this application is the live one or a

package/dist/task/phases.js

@@ -22,6 +22,7 @@ import { resolve } from 'node:path';
 import { buildExternalContext, gatherExternalContext } from './external-context.js';
 import { REFINE_PROMPT, RESEARCH_FILES_PROMPT, RESEARCH_APIS_PROMPT, RESEARCH_CONTEXT_PROMPT, RESEARCH_TOOLING_PROMPT, GRILL_GEN_PROMPT, GRILL_AUTO_ANSWER_PROMPT, GRILL_AUTO_FORMAT_HINT, COMPOSE_PROMPT, CRITIQUE_PROMPT, CRITIQUE_TRIAGE_PROMPT, VERIFY_TOOLING_PROMPT, MAX_GRILL_QUESTIONS } from './prompts.js';
 import { appendGateRecord, readSection, removeTaskSection, setTaskSection, updateTaskFrontMatter } from './task-io.js';
+import { applyDeprecations } from './deprecated-constraint.js';
 import { applyRefutations } from './refuted-constraint.js';
 import { spawnSync } from 'node:child_process';
 import {} from './task-types.js';
@@ -906,10 +907,12 @@ export async function phaseGrill(deps, ctx, widgetState, refined, research) {
     return transcript.forRecord();
 }
 /**
- * A refutation is a DELETION. Where the run's own research explicitly says a
- * dependency refine invented is not needed, drop that token from CONSTRAINTS —
- * compose cannot forbid the design's own API "because the refined task
- * explicitly requires `argon2`" if the refined task no longer requires it.
+ * A correction is a DELETION. Where the run's own research explicitly says a
+ * dependency refine invented is not needed, or names the API refine wrote as
+ * deprecated, drop that token from CONSTRAINTS — compose cannot forbid the
+ * design's own API "because the refined task explicitly requires `argon2`" if the
+ * refined task no longer requires it, and cannot ship `z.string().email()` under
+ * a constraint that no longer names it.
  *
  * Applied to the REFINED TASK ITSELF, not to compose's copy of it, and that is
  * load-bearing: critique receives the refined task as GROUND TRUTH and is told
@@ -917,21 +920,22 @@ export async function phaseGrill(deps, ctx, widgetState, refined, research) {
  * them", so a deletion visible only to compose is restored one phase later. Both
  * spec-producing phases have to see the same text.
  *
- * Purely subtractive and never touches an owned line (task/refuted-constraint.ts).
+ * Purely subtractive and never touches an owned line (task/refuted-constraint.ts,
+ * task/deprecated-constraint.ts).
  * Idempotent, so a resumed run re-deriving `refined` from the task file lands in
  * the same place. The task file's `## refined prompt` is deliberately left as
  * refine wrote it; the drop is recorded on the `## gates` trail with both source
  * lines quoted, so the decision stays auditable after the fact.
  */
 export async function dropRefutedConstraints(deps, refined, research) {
-    const refuted = applyRefutations(refined, research);
-    if (refuted.trail.length === 0)
+    const dropped = dropRefutedAndDeprecated(refined, research);
+    if (dropped.trail.length === 0)
         return refined;
-    await recordPhaseTrail(deps, 'compose', refuted.trail);
-    return refuted.refined;
+    await recordPhaseTrail(deps, 'compose', dropped.trail);
+    return dropped.refined;
 }
 /**
- * COMPOSE's carry: the refutation drop, as a `PhaseConfig.carry`.
+ * COMPOSE's carry: both subtractive drops, as a `PhaseConfig.carry`.
  *
  * Same transform as `dropRefutedConstraints` over the same pure core, minus the
  * recording — the caller decides whether this application is the live one or a
@@ -941,11 +945,21 @@ export async function dropRefutedConstraints(deps, refined, research) {
 export function composeCarry(_deps, pc) {
     // Not `async`, and that is the shape rather than an oversight: this carry
     // performs no I/O at all, which is what lets the resume path replay it.
-    const refuted = applyRefutations(pc.refined, pc.research);
-    if (refuted.trail.length === 0)
+    const dropped = dropRefutedAndDeprecated(pc.refined, pc.research);
+    if (dropped.trail.length === 0)
         return Promise.resolve([]);
-    pc.refined = refuted.refined;
-    return Promise.resolve(refuted.trail);
+    pc.refined = dropped.refined;
+    return Promise.resolve(dropped.trail);
+}
+/**
+ * The two subtractive passes, in one place so the live path and the resume replay
+ * cannot drift apart. Chained rather than run side by side: the second reads the
+ * first's output, so a line the first deleted outright is never scanned again.
+ */
+function dropRefutedAndDeprecated(refined, research) {
+    const refuted = applyRefutations(refined, research);
+    const deprecated = applyDeprecations(refuted.refined, research);
+    return { refined: deprecated.refined, trail: [...refuted.trail, ...deprecated.trail] };
 }
 /** Write a carry's trail to the debug log and the task file's `## gates` section. */
 export async function recordPhaseTrail(deps, phaseName, trail) {

package/dist/workers/docs-ecosystems.d.ts

@@ -17,6 +17,7 @@ import { type AutoInstallPin } from './docs-core.js';
 import { resolvePackage, type ResolvedPackage } from './docs-resolve.js';
 import { npmVersionLookup, type NpmVersionInfo } from './npm-version.js';
 import { type SpawnFn } from '../shared/child-process.js';
+import type { ExportGap } from './export-gap.js';
 export type EcosystemId = 'npm' | 'cargo' | 'hackage';
 /**
  * Every filesystem, process and network reach a row is allowed. Rows read no
@@ -75,10 +76,26 @@ export interface EcosystemProfile {
     }>;
     /**
      * Packages whose declarations belong in THIS package's index, because this
-     * package exports names it does not declare. Only hackage has facades of the
-     * `hspec`/`hspec-core` shape; see DEFECT-12-STOPPING-RULE.md.
+     * package exports names it does not declare — `hspec`/`hspec-core`,
+     * `axum`/`axum-core`; see DEFECT-12-STOPPING-RULE.md.
      */
     supplements?: (pkg: ResolvedPackage, cwd: string, io: EcosystemIo) => Promise<ResolvedPackage[]>;
+    /**
+     * What this package publishes and declares nowhere, in this ecosystem's own
+     * syntax. Read only when `supplements` returned something, and it decides
+     * which of a supplement's chunks are kept.
+     */
+    exportGap?: (root: string) => ExportGap;
+    /**
+     * Source of everything this row contributes to a chunk's CONTENT — `surface`,
+     * `exportGap`, and every function and regex they delegate to.
+     *
+     * Required, and not derived from `String(surface)`, because that has hidden a
+     * real fix three times: `surface` here is the wrapper
+     * `content => rustSurface(content)`, which shows none of `rustSurface`, and
+     * neither gap rule's helpers appear in its entry point either.
+     */
+    contentFingerprint: () => string;
     /** The registry's own newest version, for grounding an answer in the present. */
     latest: (name: string, io: EcosystemIo) => Promise<NpmVersionInfo | null>;
     /** True for a file that carries the package's public API surface. */
@@ -131,13 +148,6 @@ export interface NpmProfileHooks {
     resolvePackage?: typeof resolvePackage;
     npmVersionLookup?: typeof npmVersionLookup;
 }
-/**
- * The npm row, with the pieces a caller may have replaced left as parameters.
- *
- * `docsRaw` already takes `resolvePackage` and `npmVersionLookup` as injection
- * hooks, and those hooks must keep reaching the resolution they are injected
- * for. A per-call row carries them; {@link ECOSYSTEMS} holds the plain one.
- */
 export declare function npmProfile(hooks?: NpmProfileHooks): EcosystemProfile;
 /**
  * The package.json manifest, not the lockfile: a lockfile is rewritten by

package/dist/workers/docs-ecosystems.js

@@ -21,8 +21,8 @@ import { runAutoInstall, findDeclaredRange, extractParentPackage, resolveTypeSou
 import { resolvePackage, isDtsFile, isValidModuleName } from './docs-resolve.js';
 import { DECL_SPLIT_RE } from './docs-chunk.js';
 import { npmVersionLookup } from './npm-version.js';
-import { resolveCrate, cratesLatest, crateTarballUrl, crateOf, isValidCrateName, isRustFile, lockedVersion, rustSurface, cargoProjectName, childDirs, lockedDeps, manifestCrates, CARGO_DECL_SPLIT_RE } from './eco-cargo.js';
-import { resolveHackage, hackageLatest, hackageVersion, hackageTarballUrl, hackageExtractDir, hackageProjectName, supplementCandidates, findCabalTarball, cachedVersions, resolvedVersions, manifestPackages, isValidHackageName, isHaskellFile, haskellSurface, HACKAGE_DECL_SPLIT_RE, HACKAGE_SKIP_DIRS } from './eco-hackage.js';
+import { resolveCrate, cratesLatest, crateTarballUrl, crateOf, isValidCrateName, isRustFile, lockedVersion, rustSurface, cargoProjectName, childDirs, lockedDeps, manifestCrates, cargoExportGap, cargoContentFingerprint, cargoSupplementCandidates, CARGO_DECL_SPLIT_RE } from './eco-cargo.js';
+import { resolveHackage, hackageLatest, hackageVersion, hackageTarballUrl, hackageExtractDir, hackageProjectName, supplementCandidates, hackageExportGap, hackageContentFingerprint, findCabalTarball, cachedVersions, resolvedVersions, manifestPackages, isValidHackageName, isHaskellFile, haskellSurface, HACKAGE_DECL_SPLIT_RE, HACKAGE_SKIP_DIRS } from './eco-hackage.js';
 import { runChild } from '../shared/child-process.js';
 /**
  * Is any of `names` present at `cwd` or above it?
@@ -101,6 +101,9 @@ function defaultCabalPackageDirs() {
  * hooks, and those hooks must keep reaching the resolution they are injected
  * for. A per-call row carries them; {@link ECOSYSTEMS} holds the plain one.
  */
+/** A `.d.ts` is already declarations only, so npm's extractor is the identity.
+ *  Named rather than inline so `contentFingerprint` can point at it. */
+const npmSurface = (content) => content;
 export function npmProfile(hooks = {}) {
     const resolve = hooks.resolvePackage ?? resolvePackage;
     const versionLookup = hooks.npmVersionLookup ?? npmVersionLookup;
@@ -126,7 +129,10 @@ export function npmProfile(hooks = {}) {
         afterResolve: (pkg, requested, cwd, io) => resolveTypeSourceForDocs(pkg, requested, cwd, io.spawn, resolve, io.signal),
         latest: (name, io) => versionLookup(name, io.signal === undefined ? {} : { signal: io.signal }),
         isSurfaceFile: isDtsFile,
-        surface: content => content,
+        surface: npmSurface,
+        // No gap rule, and a `.d.ts` IS the surface, so there is nothing below the
+        // identity for a fingerprint to miss.
+        contentFingerprint: () => String(npmSurface),
         declSplitRe: DECL_SPLIT_RE,
         typeKeywords: ['interface', 'type', 'class', 'enum'],
         commentPrefix: '//',
@@ -267,8 +273,44 @@ const cargoProfile = {
         }
         return acquireCrate(info?.pkg ?? name, version, io);
     },
+    supplements: async (pkg, cwd, io) => {
+        const deps = manifestCrates(pkg.root);
+        if (!deps)
+            return [];
+        // The PROJECT's lock, never the crate's own root. `findLock` walks upward,
+        // and a crate unpacked under `~/.cargo/registry` sits below whatever lock
+        // happens to be above it — which resolved a version this project never
+        // pinned, making the index a function of the machine.
+        const candidates = cargoSupplementCandidates(pkg.name, deps, lockedDeps(cwd) ?? {});
+        const out = [];
+        for (const c of candidates) {
+            try {
+                out.push(resolveCrate(c.name, cwd, { cargoHome: io.cargoHome, modulesDir: io.modulesDir }));
+                continue;
+            }
+            catch {
+                // Not unpacked here. `acquire` reads crates.io for the published
+                // spelling, so `tokio-util` and `tokio_util` both land.
+            }
+            const got = await cargoProfile.acquire(c.name, c.version, io);
+            if (!got.success)
+                continue;
+            try {
+                out.push(resolveCrate(c.name, cwd, { cargoHome: io.cargoHome, modulesDir: io.modulesDir }));
+            }
+            catch {
+                // A supplement that will not resolve leaves the facade as it was.
+            }
+        }
+        return out;
+    },
+    exportGap: cargoExportGap,
+    contentFingerprint: cargoContentFingerprint,
     latest: (name, io) => cratesLatest(name, io.fetch, io.signal),
     isSurfaceFile: isRustFile,
+    // Wrapped, not passed by reference: `rustSurface` takes two more optional
+    // arguments, and a bare reference would let a `.map(profile.surface)` pass an
+    // index as `insideTrait`. `contentFingerprint` is what covers its source.
     surface: content => rustSurface(content),
     declSplitRe: CARGO_DECL_SPLIT_RE,
     typeKeywords: ['struct', 'trait', 'enum', 'type', 'union'],
@@ -381,6 +423,8 @@ const hackageProfile = {
         }
         return out;
     },
+    exportGap: hackageExportGap,
+    contentFingerprint: hackageContentFingerprint,
     latest: (name, io) => hackageLatest(name, io.fetch, io.signal),
     isSurfaceFile: isHaskellFile,
     surface: haskellSurface,

package/dist/workers/docs-index.js

@@ -4,7 +4,6 @@ import * as path from 'node:path';
 import {} from './docs-resolve.js';
 import { chunkDeclarations, chunkReadme, splitAtMatches } from './docs-chunk.js';
 import { ECOSYSTEMS } from './docs-ecosystems.js';
-import { hackageExportGap, declaredInSurface } from './eco-hackage.js';
 const ZERO_SEP = Buffer.from([0]);
 /**
  * The gate that decides whether a package needs re-indexing.
@@ -53,11 +52,16 @@ function computeContentHash(pkg, profile, supplements = []) {
     // leaves a package cached whenever a fix moves some OTHER module — the
     // wrapped `instance` head is in aeson's `Types/FromJSON.hs`, never its entry
     // — and nothing surfaced the duplicate drop in `ingestBody` at all.
-    hash.update(Buffer.from(`${String(profile.surface)}\u0000${String(ingestBody)}`, 'utf8'));
+    hash.update(Buffer.from(`${String(profile.surface)}\u0000${profile.contentFingerprint()}`
+        + `\u0000${String(ingestBody)}`, 'utf8'));
     hash.update(ZERO_SEP);
-    // Which packages were folded in, so gaining or losing one re-indexes.
+    // Which packages were folded in, so gaining or losing one re-indexes — and the
+    // rule that decides WHICH of their chunks are kept, by source. Hashing the set
+    // alone left a fix to `cargoExportGap` invisible, so every cached facade held
+    // the chunks the old rule chose.
     hash.update(Buffer.from(supplements.map(s => `${s.name}@${s.version}`).join('\u0000'), 'utf8'));
     hash.update(ZERO_SEP);
+    hash.update(ZERO_SEP);
     if (pkg.entry && fs.existsSync(pkg.entry)) {
         try {
             hash.update(Buffer.from(profile.surface(fs.readFileSync(pkg.entry, 'utf8')), 'utf8'));
@@ -216,10 +220,9 @@ function ingestBody(cache, pkg, profile, contentHash, supplements = []) {
     // A facade package indexes to a table of contents: `hspec` is 14 chunks of
     // export lists and every signature is in `hspec-core`. Fill only the holes —
     // see DEFECT-12-STOPPING-RULE.md for the boundary and why it stops here.
-    const gap = supplements.length > 0 ? hackageExportGap(pkg.root) : null;
-    for (const sup of gap && (gap.unresolved.size > 0 || gap.reexportedModules.size > 0) ?
-        supplements
-        : []) {
+    const found = supplements.length > 0 ? (profile.exportGap?.(pkg.root) ?? null) : null;
+    const gap = found !== null && !found.empty ? found : null;
+    for (const sup of gap === null ? [] : supplements) {
         for (const abs of collectFiles(sup, profile).surface) {
             let raw;
             try {
@@ -228,15 +231,13 @@ function ingestBody(cache, pkg, profile, contentHash, supplements = []) {
             catch {
                 continue;
             }
-            const module = /^module\s+([\w.']+)/m.exec(raw)?.[1];
-            const whole = module !== undefined && gap.reexportedModules.has(module);
             // The path names the package the declaration really came from: the
             // chunk header is model-facing, and a signature attributed to the
             // wrong package is the bug this whole table exists for.
             const rel = `${sup.name}-${sup.version}/` + path.relative(sup.root, abs).replace(/\\/g, '/');
+            const whole = gap.wholesale(rel, raw);
             for (const c of chunkDeclarations(profile.surface(raw), rel, profile.declSplitRe, profile.commentPrefix)) {
-                const declares = declaredInSurface(c.replace(/^\S.*\n/, ''));
-                if (!whole && ![...declares].some(n => gap.unresolved.has(n)))
+                if (!whole && !gap.fillsHole(c.replace(/^\S.*\n/, '')))
                     continue;
                 if (seen.has(c))
                     continue;

package/dist/workers/docs-lookup.js

@@ -36,7 +36,7 @@ export async function docsLookup(input) {
     const excerptVerified = extraction.excerptVerified;
     return {
         kind: 'answer',
-        body: formatResultText(input.corpus.header, extraction, excerptVerified),
+        body: formatResultText(input.corpus.header, extraction, extraction.excerptCheck),
         content,
         extraction,
         excerptVerified

package/dist/workers/eco-cargo.d.ts

@@ -12,6 +12,7 @@
  */
 import { type ResolvedPackage } from './docs-resolve.js';
 import type { NpmVersionInfo } from './npm-version.js';
+import type { ExportGap } from './export-gap.js';
 export declare function isValidCrateName(name: string): boolean;
 /** `serde_json::Value` is a path into `serde_json`; the crate is what installs. */
 export declare function crateOf(name: string): string;
@@ -98,16 +99,6 @@ interface Item {
  * finds the end of the item it is in.
  */
 export declare function splitRustItems(src: string): Item[];
-/**
- * Reduce Rust source to its public API surface.
- *
- * Function bodies go — they are the bulk of the file and answer no question the
- * docs tool is asked. Everything a caller can name stays: the item head, its doc
- * comment, its attributes, and for a struct or enum its fields and variants.
- *
- * Inside a `trait` every member is public by definition, so the `pub` test is
- * suspended there; anywhere else a bare or `pub(crate)` item is dropped.
- */
 export declare function rustSurface(src: string, insideTrait?: boolean, topLevel?: boolean): string;
 export declare function isRustFile(name: string): boolean;
 /** The `[package] name` of a cargo project, for labelling its own source. */
@@ -123,4 +114,40 @@ export declare function cargoProjectName(cwd: string): string | null;
  * Undefined when there is no readable manifest, which is not "declares nothing".
  */
 export declare function manifestCrates(cwd: string): Set<string> | undefined;
+/**
+ * The names this crate publishes through a dependency and declares nowhere.
+ *
+ * The trigger is the hole, with no threshold — measured, and for the same reason
+ * as hackage: across twenty-two crates the unresolved fraction reads 100% on a
+ * crate with one re-export and 0% on a crate with none, so a ratio separates
+ * nothing. See "Defect 16" in DOC_REGRESSINONS.md for the sweep.
+ */
+export declare function cargoExportGap(root: string): ExportGap;
+/**
+ * Source of everything this row contributes to a chunk's CONTENT — the surface
+ * extractor, the gap rule, and every function and regex they delegate to.
+ *
+ * `String(fn)` covers only a top level, and three separate bugs have now hidden
+ * one level below it: the chunker (which `chunkerFingerprint` closes), the gap
+ * rule's helpers, and `surface` itself, declared as the wrapper
+ * `content => rustSurface(content)` which shows none of `rustSurface`. A fix that
+ * does not move this leaves every cached crate holding the chunks the old rule
+ * chose.
+ */
+export declare function cargoContentFingerprint(): string;
+/**
+ * Which declared dependencies may be opened to fill the gap.
+ *
+ * Cargo splits a facade from its implementation by name the way hackage does —
+ * `axum`/`axum-core`, `futures`/`futures-util`, `tracing`/`tracing-core` — and
+ * writes that name with either separator, so both spellings are one candidate.
+ *
+ * The bound's cost is stated rather than hidden: `hyper` re-exports twelve names
+ * from `http`, `bytes` and `http-body`, and axum's own `Bytes` comes from `bytes`.
+ * No prefix rule can see any of them.
+ */
+export declare function cargoSupplementCandidates(pkgName: string, declaredDeps: ReadonlySet<string>, resolved: Readonly<Record<string, string>>): Array<{
+    name: string;
+    version: string;
+}>;
 export {};

package/dist/workers/eco-cargo.js

@@ -631,6 +631,37 @@ const LIST_KINDS = new Set(['use']);
  * Inside a `trait` every member is public by definition, so the `pub` test is
  * suspended there; anywhere else a bare or `pub(crate)` item is dropped.
  */
+/** A `#name` interpolation. Rust item syntax has none; a `quote!` template is
+ *  nothing but. Comments come out first — a doctest hides lines with `# use …`. */
+const INTERPOLATION = /#[A-Za-z_(]/;
+function withoutComments(body) {
+    return body
+        .split('\n')
+        .map(l => (/^\s*(?:\/\/|\*)/.test(l) ? '' : l.replace(/\/\/.*$/, '')))
+        .join('\n');
+}
+/**
+ * The body of a `name! { … }` block that WRAPS items, or null.
+ *
+ * tokio declares `pub struct TcpListener` inside `cfg_net! { … }`, and every
+ * async crate does the same: 818 public items across twenty-two crates sit inside
+ * such a block, 441 of them tokio's. Treating the invocation as one opaque item
+ * dropped all of them, `TcpListener` — a ground-truth symbol of the live test —
+ * included.
+ *
+ * The guard is what the body IS, never which macro it is. A `quote!` body is a
+ * token template, and the same measurement found zero public items inside an
+ * interpolating body, so the two populations do not overlap.
+ */
+function macroWrappedItems(item) {
+    if (item.body === null)
+        return null;
+    if (!/^[a-z_][a-z0-9_]*!$/.test(item.head.trim()))
+        return null;
+    if (INTERPOLATION.test(withoutComments(item.body)))
+        return null;
+    return item.body;
+}
 export function rustSurface(src, insideTrait = false, topLevel = true) {
     const out = [];
     const items = splitRustItems(src);
@@ -645,8 +676,12 @@ export function rustSurface(src, insideTrait = false, topLevel = true) {
         out.push(moduleDoc);
     for (const item of items) {
         const headMatch = ITEM_HEAD_RE.exec(item.head);
-        if (!headMatch)
+        if (!headMatch) {
+            const wrapped = macroWrappedItems(item);
+            if (wrapped !== null)
+                out.push(rustSurface(wrapped, insideTrait, false));
             continue;
+        }
         const kind = headMatch[1];
         // A `#[macro_export]` macro IS the crate's API — `anyhow::bail!`,
         // `serde_json::json!`. Dropping every macro answered "no such thing"
@@ -832,3 +867,242 @@ export function manifestCrates(cwd) {
     }
     return out;
 }
+// ── the facade gap (DEFECT-12-STOPPING-RULE.md, cargo half) ─────────────────
+/** A `pub use …;` statement, attributes and line breaks included. */
+const PUB_USE_RE = /\bpub\s+use\s+([^;]+);/g;
+/** Every item head that introduces a name, visibility ignored — a facade may
+ *  re-export something its own private module declares. */
+const RUST_DECL_RE = /\b(?:fn|struct|enum|union|trait|type|const|static|mod)\s+([A-Za-z_][A-Za-z0-9_]*)|macro_rules!\s*([A-Za-z_][A-Za-z0-9_]*)/g;
+/** Path roots that name this crate, never a dependency. */
+const OWN_PATH_ROOTS = new Set(['crate', 'self', 'super']);
+/** Read `[dependencies]` only. Dev- and build-dependencies were measured and
+ *  fetch `tokio-test`, `regex-test` and `tower-test` for zero extra names. */
+function runtimeDeps(root) {
+    const text = safeRead(path.join(root, 'Cargo.toml'));
+    const out = new Set();
+    if (text === null)
+        return out;
+    let inDeps = false;
+    for (const raw of text.split('\n')) {
+        const line = raw.trim();
+        const header = /^\[([^\]]+)\]$/.exec(line);
+        if (header) {
+            const table = /^(?:target\.[^.]*\.)?dependencies(?:\.(.+))?$/.exec(header[1]);
+            inDeps = table !== null && table[1] === undefined;
+            if (table?.[1])
+                out.add(canonical(table[1]));
+            continue;
+        }
+        if (!inDeps)
+            continue;
+        const key = /^([A-Za-z0-9_-]+)\s*=/.exec(line);
+        if (key)
+            out.add(canonical(key[1]));
+    }
+    return out;
+}
+/** Every leaf name a use-path brings in, and every module it globs. */
+function useTargets(body) {
+    // Whitespace is normalised, never removed: `Inner as Outer` collapsed to
+    // `InnerasOuter` is unrecoverable, and splitting a leaf on a bare "as" turns
+    // `Hasher` into `H`.
+    const flat = body
+        .replace(/#\[[^\]]*\]/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+    const names = [];
+    const globs = [];
+    const expand = (prefix, rest) => {
+        const brace = rest.indexOf('{');
+        if (brace === -1) {
+            const full = prefix + rest;
+            if (full.endsWith('*'))
+                globs.push(full.replace(/::\*$/, ''));
+            else {
+                // The SOURCE name of a rename is the hole: the supplier declares
+                // `Inner`, whatever the facade calls it.
+                const leaf = full
+                    .split('::')
+                    .pop()
+                    ?.split(/\s+as\s+/)[0]
+                    .trim();
+                if (leaf)
+                    names.push(leaf);
+            }
+            return;
+        }
+        const head = prefix + rest.slice(0, brace);
+        let depth = 0;
+        let start = brace + 1;
+        for (let i = brace; i < rest.length; i++) {
+            const c = rest[i];
+            if (c === '{')
+                depth++;
+            else if (c === '}') {
+                depth--;
+                if (depth === 0)
+                    return expand(head, rest.slice(start, i));
+            }
+            else if (c === ',' && depth === 1) {
+                expand(head, rest.slice(start, i));
+                start = i + 1;
+            }
+        }
+    };
+    expand('', flat);
+    return { names, globs };
+}
+function rustSources(root) {
+    const out = [];
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (e.isDirectory()) {
+                if (!CARGO_SKIP_DIRS.includes(e.name))
+                    walk(path.join(dir, e.name));
+            }
+            else if (isRustFile(e.name))
+                out.push(path.join(dir, e.name));
+        }
+    };
+    walk(root);
+    return out;
+}
+const CARGO_SKIP_DIRS = ['tests', 'benches', 'examples', 'target', '.git'];
+/** `axum-core-0.5.6/src/response/mod.rs` -> `response`, the module path a
+ *  `pub use axum_core::response::*` names. `lib.rs` and `mod.rs` are the module
+ *  they sit in, not a module of their own. */
+function moduleOfPath(relPath) {
+    const parts = relPath.replace(/\\/g, '/').split('/');
+    const src = parts.indexOf('src');
+    const tail = (src === -1 ? parts : parts.slice(src + 1)).join('/').replace(/\.rs$/, '');
+    return tail
+        .split('/')
+        .filter(seg => seg !== 'mod' && seg !== 'lib')
+        .join('::');
+}
+/**
+ * The names this crate publishes through a dependency and declares nowhere.
+ *
+ * The trigger is the hole, with no threshold — measured, and for the same reason
+ * as hackage: across twenty-two crates the unresolved fraction reads 100% on a
+ * crate with one re-export and 0% on a crate with none, so a ratio separates
+ * nothing. See "Defect 16" in DOC_REGRESSINONS.md for the sweep.
+ */
+export function cargoExportGap(root) {
+    const deps = runtimeDeps(root);
+    const declared = new Set();
+    const reexported = new Set();
+    const globModules = new Set();
+    for (const file of rustSources(root)) {
+        const src = safeRead(file);
+        if (src === null)
+            continue;
+        for (const m of src.matchAll(RUST_DECL_RE))
+            declared.add((m[1] ?? m[2]));
+        for (const m of src.matchAll(PUB_USE_RE)) {
+            const rootSeg = m[1]
+                .replace(/#\[[^\]]*\]/g, '')
+                .trim()
+                .split(/::|\{/)[0]
+                .trim();
+            if (rootSeg === '' || OWN_PATH_ROOTS.has(rootSeg) || !deps.has(canonical(rootSeg)))
+                continue;
+            const { names, globs } = useTargets(m[1]);
+            for (const n of names)
+                if (/^[A-Za-z_]/.test(n))
+                    reexported.add(n);
+            // Drop the leading crate segment: the supplier's own paths start below it.
+            for (const g of globs)
+                globModules.add(g.split('::').slice(1).join('::'));
+        }
+    }
+    const unresolved = new Set([...reexported].filter(n => !declared.has(n)));
+    return {
+        empty: unresolved.size === 0 && globModules.size === 0,
+        wholesale: relPath => globModules.has(moduleOfPath(relPath)),
+        fillsHole: chunk => {
+            for (const m of chunk.matchAll(RUST_DECL_RE)) {
+                if (unresolved.has((m[1] ?? m[2])))
+                    return true;
+            }
+            return false;
+        }
+    };
+}
+/**
+ * Source of everything this row contributes to a chunk's CONTENT — the surface
+ * extractor, the gap rule, and every function and regex they delegate to.
+ *
+ * `String(fn)` covers only a top level, and three separate bugs have now hidden
+ * one level below it: the chunker (which `chunkerFingerprint` closes), the gap
+ * rule's helpers, and `surface` itself, declared as the wrapper
+ * `content => rustSurface(content)` which shows none of `rustSurface`. A fix that
+ * does not move this leaves every cached crate holding the chunks the old rule
+ * chose.
+ */
+export function cargoContentFingerprint() {
+    return [
+        rustSurface,
+        splitRustItems,
+        macroWrappedItems,
+        withoutComments,
+        keptPreamble,
+        privateTypeNames,
+        implTarget,
+        fieldsOf,
+        cargoExportGap,
+        runtimeDeps,
+        useTargets,
+        rustSources,
+        moduleOfPath
+    ]
+        .map(String)
+        .concat([
+        PUB_USE_RE.source,
+        RUST_DECL_RE.source,
+        ITEM_HEAD_RE.source,
+        INTERPOLATION.source,
+        CARGO_SKIP_DIRS.join(','),
+        [...OWN_PATH_ROOTS].join(',')
+    ])
+        .join('\u0000');
+}
+/**
+ * Which declared dependencies may be opened to fill the gap.
+ *
+ * Cargo splits a facade from its implementation by name the way hackage does —
+ * `axum`/`axum-core`, `futures`/`futures-util`, `tracing`/`tracing-core` — and
+ * writes that name with either separator, so both spellings are one candidate.
+ *
+ * The bound's cost is stated rather than hidden: `hyper` re-exports twelve names
+ * from `http`, `bytes` and `http-body`, and axum's own `Bytes` comes from `bytes`.
+ * No prefix rule can see any of them.
+ */
+export function cargoSupplementCandidates(pkgName, declaredDeps, resolved) {
+    const out = [];
+    const seen = new Set();
+    for (const dep of declaredDeps) {
+        if (canonical(dep) === canonical(pkgName))
+            continue;
+        if (!canonical(dep).startsWith(`${canonical(pkgName)}_`))
+            continue;
+        const version = resolved[dep];
+        if (!version || seen.has(canonical(dep)))
+            continue;
+        seen.add(canonical(dep));
+        out.push({ name: dep, version });
+    }
+    // Code-unit order, not `localeCompare`: the sort decides the order supplement
+    // chunks enter the index, and a locale-aware compare puts `-` and `_` in
+    // different places under a different LANG.
+    return out.sort((a, b) => a.name < b.name ? -1
+        : a.name > b.name ? 1
+            : 0);
+}

package/dist/workers/eco-hackage.d.ts

@@ -17,6 +17,7 @@
  */
 import { type ResolvedPackage } from './docs-resolve.js';
 import type { NpmVersionInfo } from './npm-version.js';
+import type { ExportGap } from './export-gap.js';
 export declare function isValidHackageName(name: string): boolean;
 /** True for a dotted Haskell MODULE name, which is never a package name. */
 export declare function looksLikeModuleName(name: string): boolean;
@@ -100,29 +101,12 @@ export declare function hackageProjectName(cwd: string): string | null;
  * Undefined when there is no readable `.cabal` file.
  */
 export declare function manifestPackages(cwd: string): Set<string> | undefined;
-/**
- * What a package exports but does not declare.
- *
- * `hspec` indexes to 14 chunks of export lists: `it`, `describe` and `shouldBe`
- * are in the corpus as bare names with no signature attached, because every
- * signature is in `hspec-core`. The whole index is a table of contents.
- *
- * Both shapes are here because either alone misses half of it. A name-level
- * re-export puts the name in the export list; a `module X` re-export puts
- * nothing there at all, which is why `shouldBe` is invisible to the first.
- *
- * See DEFECT-12-STOPPING-RULE.md for why this triggers on the hole itself
- * rather than on a fraction of the export list.
- */
-export interface HackageExportGap {
-    /** Exported names with no declaration anywhere in the package. */
-    unresolved: Set<string>;
-    /** `module X` re-exports of modules this package does not own. */
-    reexportedModules: Set<string>;
-}
 /** Every name the extracted surface declares: signatures, heads, constructors, fields. */
 export declare function declaredInSurface(surface: string): Set<string>;
-export declare function hackageExportGap(root: string): HackageExportGap;
+/** Source of everything this row contributes to a chunk's content — see
+ *  `cargoContentFingerprint` for why a top-level `String(fn)` is not enough. */
+export declare function hackageContentFingerprint(): string;
+export declare function hackageExportGap(root: string): ExportGap;
 /**
  * Which declared dependencies may be opened to fill the gap.
  *

package/dist/workers/eco-hackage.js

@@ -586,6 +586,21 @@ export function manifestPackages(cwd) {
     }
     return out;
 }
+// ── re-export resolution ────────────────────────────────────────────────────
+/**
+ * What a package exports but does not declare.
+ *
+ * `hspec` indexes to 14 chunks of export lists: `it`, `describe` and `shouldBe`
+ * are in the corpus as bare names with no signature attached, because every
+ * signature is in `hspec-core`. The whole index is a table of contents.
+ *
+ * Both shapes are here because either alone misses half of it. A name-level
+ * re-export puts the name in the export list; a `module X` re-export puts
+ * nothing there at all, which is why `shouldBe` is invisible to the first.
+ *
+ * See DEFECT-12-STOPPING-RULE.md for why this triggers on the hole itself
+ * rather than on a fraction of the export list.
+ */
 const EXPORT_NAME_RE = /^[A-Za-z_][\w']*$/;
 /** `module X` inside an export list is a re-export; `Prelude` is base, and base is not fetched. */
 const REEXPORT_RE = /\bmodule\s+([\w.']+)/g;
@@ -655,6 +670,14 @@ function haskellSources(root) {
     walk(root);
     return out;
 }
+/** Source of everything this row contributes to a chunk's content — see
+ *  `cargoContentFingerprint` for why a top-level `String(fn)` is not enough. */
+export function hackageContentFingerprint() {
+    return [hackageExportGap, haskellSources, exportListText, declaredInSurface, haskellSurface]
+        .map(String)
+        .concat([REEXPORT_RE.source, EXPORT_NAME_RE.source])
+        .join('\u0000');
+}
 export function hackageExportGap(root) {
     const declared = new Set();
     const exported = new Set();
@@ -687,9 +710,14 @@ export function hackageExportGap(root) {
     for (const m of ownModules)
         reexportedModules.delete(m);
     reexportedModules.delete('Prelude');
+    const unresolved = new Set([...exported].filter(n => !declared.has(n)));
     return {
-        unresolved: new Set([...exported].filter(n => !declared.has(n))),
-        reexportedModules
+        empty: unresolved.size === 0 && reexportedModules.size === 0,
+        wholesale: (_relPath, raw) => {
+            const module = /^module\s+([\w.']+)/m.exec(raw)?.[1];
+            return module !== undefined && reexportedModules.has(module);
+        },
+        fillsHole: chunk => [...declaredInSurface(chunk)].some(n => unresolved.has(n))
     };
 }
 /**
@@ -713,5 +741,9 @@ export function supplementCandidates(pkgName, declaredDeps, resolved) {
         if (version)
             out.push({ name: dep, version });
     }
-    return out.sort((a, b) => a.name.localeCompare(b.name));
+    // Code-unit order, not `localeCompare`: this sort decides index order and a
+    // locale-aware compare is a machine-dependent index.
+    return out.sort((a, b) => a.name < b.name ? -1
+        : a.name > b.name ? 1
+            : 0);
 }

package/dist/workers/export-gap.d.ts

@@ -0,0 +1,26 @@
+/**
+ * What a facade package publishes and does not declare.
+ *
+ * `hspec` indexes to a table of contents and every signature is in `hspec-core`;
+ * `axum` re-exports `IntoResponse` and the trait lives in `axum-core`. Both are
+ * the same failure — a query retrieves the package's own chunks and not one of
+ * them defines the thing asked about — and DEFECT-12-STOPPING-RULE.md fixes the
+ * boundary for following the re-export.
+ *
+ * The boundary is shared; the parsing is not. Haskell states the gap in an export
+ * list, Rust in `pub use`, so each ecosystem answers the same three questions in
+ * its own syntax and the indexer never learns either language.
+ */
+export type ExportGap = {
+    /** No hole at all, so no supplement is opened. */
+    empty: boolean;
+    /**
+     * Does this whole supplement file belong in the index? True for the target of
+     * a wholesale re-export — Haskell's `module X`, Rust's `pub use x::y::*`.
+     * Given both the path and the source because Haskell names its module in the
+     * source and Rust names it by file location.
+     */
+    wholesale: (relPath: string, rawSource: string) => boolean;
+    /** Does this chunk declare a name the facade publishes and lacks? */
+    fillsHole: (chunkBody: string) => boolean;
+};

package/dist/workers/export-gap.js

@@ -0,0 +1 @@
+export {};

package/dist/workers/pi-worker-fetch.js

@@ -56,7 +56,7 @@ export function registerPiWorkerFetch(pi, internals = {}) {
                     }));
                 }
                 const body = formatResultText('', // a fetched page answer carries no package header
-                { answer: result.answer, excerpt: result.excerpt }, result.excerptVerified) || '(no output)';
+                { answer: result.answer, excerpt: result.excerpt }, result.excerptCheck) || '(no output)';
                 // The coverage miss is the one outcome that carries an instruction. It goes
                 // in the TEXT, not only in details: details are for the harness, and the
                 // worker acts on what it reads.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.40.8",
+    "version": "0.40.11",
     "description": "Deterministic task planning and spec-orchestration for local models — crash-safe /task pipelines with verify/enforce gates, a real-time remote web view, and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",