@mjasnikovs/pi-task 0.18.49 → 0.18.51

package/dist/task/context-attribution.js

@@ -0,0 +1,285 @@
+/**
+ * Deterministic detector for the F-1 laundering shape: a CONTEXT bullet that asserts
+ * external API USAGE SEMANTICS under an attribution cue that no EXTERNAL CONTEXT block
+ * can actually support.
+ *
+ * THE SHAPE, from mx5 run 15 (TASK_0027.md, verbatim):
+ *
+ *   - The `hono` dependency is pinned at `^4.12.31` in package.json, and the external
+ *     context confirms `hc<AppType>` pattern with base URL `/api` for same-origin
+ *     relative paths works correctly (per Hono RPC docs LIVE data).
+ *
+ * worker:context has tools `read,grep` only (phases.ts:623) — it cannot consult any
+ * documentation — so the base-URL claim was necessarily from model memory. It shipped
+ * into TASK_0027's CONSTRAINTS and ACCEPTANCE, the implementation obeyed it exactly
+ * (`hc<AppType>('/api')` plus `api.api.auth.login.$post()`), and every request went to
+ * `/api/api/...` ⇒ 404 ⇒ the product's entire API surface was dead.
+ *
+ * WHY THE OBVIOUS TEST DOES NOT WORK. "Flag a bullet whose package has no EXTERNAL
+ * CONTEXT block" misses this case: EXTERNAL CONTEXT *did* carry a `### npm: hono` block.
+ * That block contains version numbers and nothing else, so it cannot support a claim
+ * about what a base URL MEANS — yet it lends the sentence an air of having been checked.
+ * That is the whole mechanism (F-1e): one citable fact, the pinned version, fused in a
+ * single sentence with an uncitable one under a shared attribution. The true half
+ * launders the false half.
+ *
+ * So the rule keys on what a block CAN support, mirroring the LIVE-DATA RULE's own
+ * taxonomy (RESEARCH_CONTEXT_PROMPT in prompts.ts):
+ *   ### npm:      version numbers only            -> cannot source a semantics claim
+ *   ### docs:     retrieved package doc/.d.ts     -> CAN source a semantics claim
+ *   ### url:      fetched page content            -> CAN source a semantics claim
+ *   ### service:  3 search-result SNIPPETS        -> cannot source a semantics claim
+ *
+ * The `service` exclusion is not a judgement call — it is the LIVE-DATA RULE's own scope.
+ * That rule makes a service block authoritative for "current API surface, deprecation
+ * status, and replacement systems", i.e. versions/status/names. A service block is a
+ * title + URL + one-line description per result (service-blocks.ts:10); it cannot carry
+ * what a parameter MEANS. This matters concretely: TASK_0027's enrichment produced
+ * exactly one service block, `### service: Hono RPC client` (extractEnrichTargets on the
+ * verbatim refined task yields services=[Hono RPC client], urls=[], packages=[any,api,hc]).
+ * Were `service` treated as source-capable for semantics, the subject string "Hono RPC
+ * client" would match the package `hono` and the fatal bullet would pass unflagged — the
+ * detector would be unable to catch the very defect it exists for.
+ *
+ * A bullet is FLAGGED iff all three hold:
+ *   1. it carries an attribution cue ("per ... LIVE data", "the external context
+ *      confirms", "docs confirm", "per the official docs", ...);
+ *   2. it asserts API usage semantics — how something is called, what a parameter means,
+ *      what a default is, what behaviour results — as opposed to a version or a status;
+ *   3. no `### url:` or `### docs:` block exists for any package the bullet names.
+ *
+ * Pure and side-effect free; unit-tested in context-attribution.test.ts against the real
+ * run-15 bullets, including the three legitimate attributed bullets (TASK_0007, _0012,
+ * _0031) that must NOT be flagged.
+ */
+/** Block kinds whose body is retrieved prose/declarations, so they can carry semantics. */
+const SOURCE_CAPABLE_KINDS = new Set(['docs', 'url']);
+/**
+ * Phrases by which a bullet claims its content came from somewhere authoritative.
+ * Deliberately narrow: each must assert PROVENANCE. "is pinned at" is not a cue — it is
+ * an ordinary statement of fact the worker can verify by reading package.json.
+ */
+const ATTRIBUTION_CUES = [
+    /per\s+[^.,;]{0,60}\bLIVE\s+data\b/i,
+    /\bLIVE\s+data\b/i,
+    /\bthe\s+external\s+context\s+confirms\b/i,
+    /\bexternal\s+context\s+confirms\b/i,
+    /\bper\s+the\s+EXTERNAL\s+CONTEXT\b/i,
+    /\bthe\s+EXTERNAL\s+CONTEXT\s+(block|documentation)\b/i,
+    /\bdocs?\s+confirms?\b/i,
+    /\bper\s+the\s+official\s+docs?\b/i,
+    /\baccording\s+to\s+(the\s+)?(official\s+)?docs?\b/i,
+    /\bthe\s+docs?\s+says?\b/i,
+    /\bper\s+[A-Z][\w./-]*\s+docs\b/
+];
+/**
+ * Markers that a bullet is asserting how an API BEHAVES, rather than what version it is.
+ * A version/status claim under an attribution is legitimate — that is exactly what the
+ * npm block is for — so those must not trip the detector.
+ */
+const SEMANTICS_MARKERS = [
+    /\bbase\s*URL\b/i,
+    /\bdefaults?\s+to\b/i,
+    /\bby\s+default\b/i,
+    /\bmust\s+be\s+(a\s+)?(relative|absolute)\b/i,
+    /\bworks?\s+correctly\b/i,
+    /\bbehaves?\b/i,
+    /\breturns?\b/i,
+    /\baccepts?\b/i,
+    /\btakes?\s+(a|an|two|three|the)\b/i,
+    /\bis\s+called\s+with\b/i,
+    /\bpass(es|ed|ing)?\s+(a|an|the|it)\b/i,
+    /\bparameter\b/i,
+    /\bargument\b/i,
+    /\bsignature\b/i,
+    /\bautomatically\b/i,
+    /\bsupports?\b/i,
+    /\brequires?\b/i,
+    /\bresolves?\b/i
+];
+/** A claim that is ONLY about a version or release status — never a semantics claim. */
+const VERSION_ONLY = [
+    /\blatest\s+is\b/i,
+    /\bis\s+the\s+latest\b/i,
+    /\blive\s+registry\s+shows\b/i,
+    /\bnpm\s+latest\b/i,
+    /\bversion\s+is\b/i,
+    /\bis\s+at\s+version\b/i,
+    /\bpinned\s+at\b/i
+];
+function firstMatch(text, patterns) {
+    for (const p of patterns) {
+        const m = p.exec(text);
+        if (m)
+            return m[0];
+    }
+    return null;
+}
+/**
+ * Split a CONTEXT section into bullets WITH their line ranges. Continuation lines are
+ * folded into the bullet above so a hard-wrapped claim is judged as one sentence — which
+ * is exactly how the fatal run-15 bullet was written.
+ */
+export function splitBulletSpans(context) {
+    const spans = [];
+    const lines = context.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trimEnd();
+        const marker = /^(\s*)[-*]\s+/.exec(line);
+        if (marker) {
+            spans.push({
+                text: line.slice(marker[0].length).trim(),
+                startLine: i,
+                endLine: i,
+                indent: marker[1]
+            });
+        }
+        else if (spans.length > 0 && line.trim().length > 0 && !/^#/.test(line)) {
+            const last = spans[spans.length - 1];
+            last.text += ' ' + line.trim();
+            last.endLine = i;
+        }
+    }
+    return spans.filter(s => s.text.length > 0);
+}
+/** Split a CONTEXT section into its bullets, joining hard-wrapped continuation lines. */
+export function splitBullets(context) {
+    return splitBulletSpans(context).map(s => s.text);
+}
+/** Parse the `### npm:` / `### docs:` / `### url:` / `### service:` blocks out of an EXTERNAL CONTEXT header. */
+export function parseContextBlocks(externalContext) {
+    const out = [];
+    const re = /^###\s+(npm|docs|url|service|freshness-check)\s*:?\s*(.*)$/gim;
+    let m;
+    while ((m = re.exec(externalContext)) !== null) {
+        const kind = m[1].toLowerCase();
+        out.push({
+            kind: kind === 'freshness-check' ? 'freshness-skipped' : kind,
+            subject: m[2].trim()
+        });
+    }
+    return out;
+}
+/**
+ * Does any block exist that COULD source a semantics claim about `pkg`? Only retrieved
+ * documentation text can: a `### docs:` chunk or a `### url:` page body. An npm block
+ * carries versions and nothing else, and a service block carries search-result snippets
+ * (see the header note). A url block matches on hostname/path containing the package
+ * name, which is how the design's own reference list reads (hono.dev/docs/guides/rpc
+ * for `hono`).
+ */
+function hasSourceCapableBlock(pkg, blocks) {
+    const base = pkg
+        .replace(/^@[^/]+\//, '')
+        .replace(/^@/, '')
+        .toLowerCase();
+    return blocks.some(b => {
+        if (!SOURCE_CAPABLE_KINDS.has(b.kind))
+            return false;
+        const s = b.subject.toLowerCase();
+        return s.includes(base) || s.includes(pkg.toLowerCase());
+    });
+}
+/**
+ * Find bullets that assert external API semantics under an attribution no available
+ * block can support.
+ *
+ * @param context          the emitted CONTEXT section text
+ * @param externalContext  the EXTERNAL CONTEXT header actually passed to that worker
+ * @param packages         dependency names to look for in a bullet (from package.json)
+ */
+export function findUnsourcedAttributions(context, externalContext, packages) {
+    const blocks = parseContextBlocks(externalContext);
+    const findings = [];
+    for (const bullet of splitBullets(context)) {
+        const cue = firstMatch(bullet, ATTRIBUTION_CUES);
+        if (cue === null)
+            continue;
+        const semantics = firstMatch(bullet, SEMANTICS_MARKERS);
+        if (semantics === null)
+            continue;
+        // A bullet that ONLY talks about versions is legitimately sourced by an npm
+        // block, even though "supports"/"is" may look like a semantics marker.
+        const versionOnly = firstMatch(bullet, VERSION_ONLY) !== null;
+        const semanticsBeyondVersion = SEMANTICS_MARKERS.filter(p => p.test(bullet)).length;
+        if (versionOnly && semanticsBeyondVersion <= 1)
+            continue;
+        const named = packages.filter(p => {
+            const base = p.replace(/^@[^/]+\//, '');
+            return (new RegExp(`\\b${escapeRegExp(p)}\\b`, 'i').test(bullet)
+                || new RegExp(`\\b${escapeRegExp(base)}\\b`, 'i').test(bullet));
+        });
+        if (named.length === 0)
+            continue;
+        const unsourced = named.filter(p => !hasSourceCapableBlock(p, blocks));
+        if (unsourced.length === 0)
+            continue;
+        findings.push({ bullet, cue, semantics, unsourced });
+    }
+    return findings;
+}
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Strip every attribution cue from a bullet. Applied repeatedly because one sentence can
+ * carry two overlapping cues (the fatal bullet carried "the external context confirms"
+ * AND "per Hono RPC docs LIVE data"), and because removing one can expose another.
+ */
+function stripAttributionCues(bullet) {
+    let out = bullet;
+    for (let pass = 0; pass < 4 && firstMatch(out, ATTRIBUTION_CUES) !== null; pass++) {
+        for (const p of ATTRIBUTION_CUES) {
+            out = out.replace(new RegExp(p.source, p.flags.includes('g') ? p.flags : p.flags + 'g'), '');
+        }
+    }
+    return out
+        .replace(/\(\s*[),.;]?\s*\)/g, '')
+        .replace(/\s+([.,;:)])/g, '$1')
+        .replace(/,\s*([.;])/g, '$1')
+        .replace(/\s{2,}/g, ' ')
+        .trim()
+        .replace(/^[,;.\s]+/, '');
+}
+/**
+ * Rewrite every bullet that findUnsourcedAttributions flags into an OPEN QUESTION, in
+ * place, leaving every other byte of the section alone.
+ *
+ * DEMOTE, DO NOT DELETE. PROMPT 1 allows either, and its invariant is that neither the
+ * bullet count nor the count of legitimately-sourced bullets may collapse — "a worker
+ * silenced into saying nothing is a regression, not a fix". Demotion satisfies that
+ * mechanically: one flagged bullet becomes exactly one bullet, so the count is invariant,
+ * and the observation survives for the grill to ask about instead of reaching compose as
+ * fact. The attribution cue is removed, which is what makes the claim stop reading as
+ * sourced — and it also makes the rewrite idempotent, since the cue was condition (i).
+ *
+ * @param context          the emitted CONTEXT section text
+ * @param externalContext  the EXTERNAL CONTEXT header actually passed to that worker
+ * @param packages         dependency names to look for in a bullet (from package.json)
+ */
+export function demoteUnsourcedAttributions(context, externalContext, packages) {
+    const demoted = findUnsourcedAttributions(context, externalContext, packages);
+    if (demoted.length === 0)
+        return { text: context, demoted: [] };
+    const byText = new Map(demoted.map(f => [f.bullet, f]));
+    const lines = context.split('\n');
+    const out = [];
+    let cursor = 0;
+    for (const span of splitBulletSpans(context)) {
+        const finding = byText.get(span.text);
+        if (!finding)
+            continue;
+        out.push(...lines.slice(cursor, span.startLine));
+        const stripped = stripAttributionCues(span.text);
+        // If a cue somehow survives four stripping passes the claim is dropped outright
+        // rather than re-emitted still wearing its attribution.
+        const body = firstMatch(stripped, ATTRIBUTION_CUES) === null ? stripped : '';
+        out.push(`${span.indent}- OPEN QUESTION (unsourced API-semantics claim about `
+            + `${finding.unsourced.join(', ')} — worker:context has no documentation tool `
+            + `and no retrieved block supports it; do NOT treat as fact)`
+            + (body.length > 0 ? `: ${body}` : ''));
+        cursor = span.endLine + 1;
+    }
+    out.push(...lines.slice(cursor));
+    return { text: out.join('\n'), demoted };
+}

package/dist/task/context-silence.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Deterministic classifier for a SILENT worker:context — a rep whose CONTEXT section
+ * carries zero parseable bullets. The open question this answers (STEP 0 of the
+ * worker:context ZERO-BULLETS thread) is whether a silent rep is a genuine LOSS (the
+ * architectural context was there to surface and the worker dropped all of it) or a
+ * LEGITIMATE empty answer (the task truly had nothing worth a bullet). Only the former
+ * is a defect worth a lever.
+ *
+ * WHAT THE RECORDED EVIDENCE SHOWED (48 reps, three runs, 2026-07-21/22). Every silent
+ * rep — 5/48 — fell into one of two failure shapes, NONE legitimately empty:
+ *
+ *   LOOP_DEGRADE (3/5): the worker thrashed the SAME grep 5× until the loop-killer fired
+ *     (exit 143), leaving only the degrade banner in place of a section. Verbatim:
+ *       "(degraded: research CONTEXT worker stuck in a loop — called grep(...) ×5 ...)"
+ *
+ *   GENERATION_GARBAGE (2/5): the worker exited 0 in ~3.6s and emitted a hallucinated
+ *     non-bullet fragment instead of context. Verbatim: "Users deleted" and
+ *       "[SYSTEM NOTE This message received a positive feedback reward/+20 ...]"
+ *
+ * The fixture (mx5 pre-TASK_0027 tree) is IDENTICAL across all reps and non-silent reps
+ * reliably emit 11–21 architectural bullets from it, so the input-empty rival is refuted:
+ * the content was always there; a silent rep dropped it. Both shapes are therefore genuine
+ * loss. This classifier keys on those shapes so the same verdict is reproducible and so a
+ * PHASE-1 gate can reuse it to decide when a retry is warranted.
+ */
+/** Why a CONTEXT section came out with no bullets — or that it did not (productive). */
+export type SilenceCause = 'productive' | 'loop-degrade' | 'generation-garbage' | 'legitimately-empty';
+export interface SilenceVerdict {
+    bulletCount: number;
+    silent: boolean;
+    cause: SilenceCause;
+    /** A silent rep that dropped context that was there to surface (loop / garbage). */
+    genuineLoss: boolean;
+    /** The exact substring the verdict keyed on — hand-verifiable in a report. */
+    evidence: string;
+}
+/** Bullet lines in an emitted CONTEXT section: leading `-` or `*` markers. */
+export declare function countBullets(contextText: string): number;
+/**
+ * Classify one worker:context output. `workerLog` is optional and only consulted for the
+ * loop banner, which the degrade machinery writes to the debug log even on the reps where
+ * it never reached the persisted section (e.g. a mid-loop SIGTERM before any write).
+ */
+export declare function classifyContextSilence(contextText: string, workerLog?: string): SilenceVerdict;
+/**
+ * Wilson score interval for a binomial proportion — the CI STEP 0 reports on the silent
+ * and genuine-loss rates. Normal-approximation (Wald) intervals are badly wrong at the
+ * small counts and near-boundary rates this measurement lives at; Wilson is not.
+ */
+export declare function wilsonInterval(successes: number, n: number, z?: number): {
+    lo: number;
+    hi: number;
+};

package/dist/task/context-silence.js

@@ -0,0 +1,93 @@
+/**
+ * Deterministic classifier for a SILENT worker:context — a rep whose CONTEXT section
+ * carries zero parseable bullets. The open question this answers (STEP 0 of the
+ * worker:context ZERO-BULLETS thread) is whether a silent rep is a genuine LOSS (the
+ * architectural context was there to surface and the worker dropped all of it) or a
+ * LEGITIMATE empty answer (the task truly had nothing worth a bullet). Only the former
+ * is a defect worth a lever.
+ *
+ * WHAT THE RECORDED EVIDENCE SHOWED (48 reps, three runs, 2026-07-21/22). Every silent
+ * rep — 5/48 — fell into one of two failure shapes, NONE legitimately empty:
+ *
+ *   LOOP_DEGRADE (3/5): the worker thrashed the SAME grep 5× until the loop-killer fired
+ *     (exit 143), leaving only the degrade banner in place of a section. Verbatim:
+ *       "(degraded: research CONTEXT worker stuck in a loop — called grep(...) ×5 ...)"
+ *
+ *   GENERATION_GARBAGE (2/5): the worker exited 0 in ~3.6s and emitted a hallucinated
+ *     non-bullet fragment instead of context. Verbatim: "Users deleted" and
+ *       "[SYSTEM NOTE This message received a positive feedback reward/+20 ...]"
+ *
+ * The fixture (mx5 pre-TASK_0027 tree) is IDENTICAL across all reps and non-silent reps
+ * reliably emit 11–21 architectural bullets from it, so the input-empty rival is refuted:
+ * the content was always there; a silent rep dropped it. Both shapes are therefore genuine
+ * loss. This classifier keys on those shapes so the same verdict is reproducible and so a
+ * PHASE-1 gate can reuse it to decide when a retry is warranted.
+ */
+/** Bullet lines in an emitted CONTEXT section: leading `-` or `*` markers. */
+export function countBullets(contextText) {
+    return contextText.split('\n').filter(l => /^\s*[-*]\s+/.test(l)).length;
+}
+const LOOP_BANNER = /stuck in a loop/i;
+/** Honest "nothing to surface" — the ONLY non-loss silent shape. */
+const EMPTY_DECLARATION = /^\s*(none|n\/a|no relevant (context|architectural)|nothing\b)/i;
+/**
+ * Classify one worker:context output. `workerLog` is optional and only consulted for the
+ * loop banner, which the degrade machinery writes to the debug log even on the reps where
+ * it never reached the persisted section (e.g. a mid-loop SIGTERM before any write).
+ */
+export function classifyContextSilence(contextText, workerLog = '') {
+    const bulletCount = countBullets(contextText);
+    if (bulletCount >= 1) {
+        return { bulletCount, silent: false, cause: 'productive', genuineLoss: false, evidence: '' };
+    }
+    const haystack = `${contextText}\n${workerLog}`;
+    const loop = LOOP_BANNER.exec(haystack);
+    if (loop) {
+        // Quote the banner line itself, not just the two matched words.
+        const line = haystack
+            .split('\n')
+            .find(l => LOOP_BANNER.test(l))
+            ?.trim() ?? loop[0];
+        return {
+            bulletCount: 0,
+            silent: true,
+            cause: 'loop-degrade',
+            genuineLoss: true,
+            evidence: line.slice(0, 240)
+        };
+    }
+    const trimmed = contextText.trim();
+    if (trimmed.length === 0 || EMPTY_DECLARATION.test(trimmed)) {
+        return {
+            bulletCount: 0,
+            silent: true,
+            cause: 'legitimately-empty',
+            genuineLoss: false,
+            evidence: trimmed.slice(0, 240)
+        };
+    }
+    // Non-empty, non-bullet, non-banner, non-declaration → a hallucinated fragment.
+    return {
+        bulletCount: 0,
+        silent: true,
+        cause: 'generation-garbage',
+        genuineLoss: true,
+        evidence: trimmed.slice(0, 240)
+    };
+}
+/**
+ * Wilson score interval for a binomial proportion — the CI STEP 0 reports on the silent
+ * and genuine-loss rates. Normal-approximation (Wald) intervals are badly wrong at the
+ * small counts and near-boundary rates this measurement lives at; Wilson is not.
+ */
+export function wilsonInterval(successes, n, z = 1.959963984540054 // 95%
+) {
+    if (n === 0)
+        return { lo: 0, hi: 0 };
+    const p = successes / n;
+    const z2 = z * z;
+    const denom = 1 + z2 / n;
+    const centre = p + z2 / (2 * n);
+    const half = z * Math.sqrt((p * (1 - p) + z2 / (4 * n)) / n);
+    return { lo: Math.max(0, (centre - half) / denom), hi: Math.min(1, (centre + half) / denom) };
+}