@mjasnikovs/pi-task 0.40.50 → 0.41.0

package/dist/task/orientation.js

@@ -1,32 +1,48 @@
 /**
  * Project orientation core — a bounded snapshot of the few files a research worker
- * re-reads cold to learn "what is this project" (manifest, config, domain types,
- * schema, entrypoints, API surface). The four research workers are separate child
- * processes with no shared memory, so without this each one reads the same hot
- * files for itself.
+ * re-reads cold to learn "what is this project" (the doc the task cites, manifest,
+ * config, project rules, domain types, schema, entrypoints, API surface). The four
+ * research workers are separate child processes with no shared memory, so without
+ * this each one reads the same hot files for itself.
  *
  * This module picks that core from the file inventory (repo-agnostic, by path
  * convention) and reads it ONCE in the parent. The caller folds the block into a
- * prompt: refine gets a tier-0/1 subset, and phases.ts prepends the full block to
- * the two READ-HEAVY research workers (`worker:files`, `worker:apis`) — not to all
- * four. It is purely additive: nothing is blocked, so a worker can still read
- * anything it wants; orientation only removes the need to.
+ * prompt: refine gets the manifest/config tiers, and phases.ts prepends the full
+ * block to the three EXPLORING research workers — not to TOOLING. It is purely
+ * additive: nothing is blocked, so a worker can still read anything it wants;
+ * orientation only removes the need to.
+ *
+ * ELIGIBILITY IS A REGISTRY, not a ladder of regexes: {@link ORIENTATION_RULES} is
+ * an ordered list of `{id, tier, match}` rows over an {@link OrientationCandidate},
+ * so "does this file orient" and "how fundamental is it" are one row each, and the
+ * two facts a path cannot carry on its own — whether the task CITES it, and whether
+ * it is VENDORED — are fields on the candidate rather than more pattern-matching.
  *
  * Bounded by design — the snapshot can never overflow the prompt regardless of
- * repo size: a hard total byte budget, a per-file cap (one huge file can't eat
- * the budget), and a candidate cap. Files that don't fit are simply not
- * pre-supplied; the worker reads them as before. Selection is the pure, tested
- * core; reading takes an injectable reader so it can be exercised without a repo.
+ * repo size: a hard total byte budget, a per-file cap so one huge file can't eat
+ * it, a candidate cap, and a second budget of the same size that only cited
+ * documents may draw on. Files that don't fit are simply not pre-supplied; the worker reads
+ * them as before. Selection is the pure, tested core; reading takes an injectable
+ * reader so it can be exercised without a repo.
  */
 /**
  * Total bytes the emitted orientation block may occupy. This is the real overflow
  * guard: it bounds the block regardless of repo size, and because the snapshot is
- * prepended to each read-heavy worker it also caps the prefill those workers pay.
+ * prepended to each exploring worker it also caps the prefill those workers pay.
  * Selection stops as soon as adding a file would exceed it.
  */
 export const ORIENTATION_BYTE_BUDGET = 40 * 1024;
 /** A single file larger than this is skipped (read by the worker as before). */
 export const ORIENTATION_PER_FILE_MAX = 12 * 1024;
+/**
+ * A SECOND purse, spent only on cited documents.
+ *
+ * A design doc is routinely most of the core budget on its own — the recorded mx5
+ * run's is 29 KB of 40 KB — so charging it to the shared purse buys the one file
+ * the task cites by dropping five files every task needs. Equal to the core
+ * budget, so the block can at most double and the bound stays a stated one.
+ */
+export const ORIENTATION_CITED_BYTE_BUDGET = ORIENTATION_BYTE_BUDGET;
 /**
  * Backstop file-count cap — a guard against a pathological repo with hundreds of
  * tiny core files packing the byte budget into noise, NOT a normal-case limit. Set
@@ -34,6 +50,28 @@ export const ORIENTATION_PER_FILE_MAX = 12 * 1024;
  * selection, budget is left unspent and core files are dropped for no reason.
  */
 export const ORIENTATION_MAX_FILES = 40;
+/**
+ * The priority ladder, lowest first. The tiers mirror the questions a worker
+ * re-derives on every task: what am I being asked about (the cited doc) → what is
+ * this project (manifest) → how is it built (config) → what rules does it set for
+ * itself (guidelines) → what is its domain model (types/schema) → where does it
+ * start (entrypoints) → what is its surface (api) → what does it say about itself
+ * (docs).
+ *
+ * Named rather than numbered at the call sites: refine asks for "manifest and
+ * config", not for "0 and 1", and a tier inserted in the middle must not silently
+ * change what refine gets.
+ */
+export const ORIENTATION_TIERS = {
+    cited: 0,
+    manifest: 1,
+    config: 2,
+    guidelines: 3,
+    domain: 4,
+    entrypoint: 5,
+    api: 6,
+    docs: 7
+};
 /** Code/config/doc extensions worth pre-reading; everything else is ignored. */
 const ORIENTATION_EXTENSIONS = new Set([
     'ts',
@@ -69,6 +107,28 @@ const MANIFEST_BASENAMES = new Set([
     'composer.json',
     'deno.json'
 ]);
+/** The files a project states its own rules in. */
+const GUIDELINE_BASENAMES = new Set(['agents.md', 'claude.md']);
+/**
+ * Directories whose contents are never this project's own source: vendored
+ * dependencies, build output, and the agent's own scaffolding. A dependency's
+ * `package.json` is a manifest by basename and `.pi/skills/**` is a wall of
+ * markdown — either would outrank the project's real files and eat the budget.
+ *
+ * A registry rather than one regex so a project can be given more through
+ * `.gitignore` and `orientationExclude` (config.ts) without editing a pattern.
+ */
+export const VENDORED_DIRS = [
+    '.git',
+    'node_modules',
+    'dist',
+    'build',
+    'out',
+    'vendor',
+    'coverage',
+    '.pi',
+    '.pi-tasks'
+];
 function basename(p) {
     const i = p.lastIndexOf('/');
     return i === -1 ? p : p.slice(i + 1);
@@ -86,51 +146,162 @@ function depth(p) {
     return n;
 }
 /**
- * Priority tier for an orientation candidate — lower is more fundamental. The
- * tiers mirror the questions a worker re-derives on every task: what is this
- * project (manifest) → how is it built (config) → what is its domain model
- * (types/schema) → where does it start (entrypoints) → what is its surface (api)
- * → what does it say about itself (docs). Returns null for paths that aren't
- * orientation material, so they're dropped entirely.
+ * Eligibility, in priority order — FIRST MATCH WINS, and a candidate no row
+ * matches is not orientation material and is dropped entirely.
+ *
+ * The three rejecting rows come first and carry no tier of their own: a vendored
+ * file, a test and an absolute path are excluded whatever else they look like.
+ * They are rows rather than early returns so the whole policy is one list.
+ */
+export const ORIENTATION_RULES = [
+    {
+        // The task's own spec document. Highest tier because it is the one file
+        // the worker is guaranteed to need and the one it cannot guess the path
+        // of — the mx5 run read it 50 times because orientation could not select
+        // a `DESIGN/*.md` by convention.
+        id: 'cited-spec-doc',
+        tier: ORIENTATION_TIERS.cited,
+        match: c => c.cited,
+        byName: true
+    },
+    {
+        id: 'manifest',
+        tier: ORIENTATION_TIERS.manifest,
+        match: c => MANIFEST_BASENAMES.has(basename(c.path).toLowerCase()),
+        byName: true
+    },
+    {
+        id: 'config',
+        tier: ORIENTATION_TIERS.config,
+        match: c => {
+            const base = basename(c.path).toLowerCase();
+            return (base === 'tsconfig.json'
+                || /\.config\.(ts|js|mjs|cjs|json)$/.test(base)
+                || extension(c.path) === 'toml');
+        }
+    },
+    {
+        id: 'guidelines',
+        tier: ORIENTATION_TIERS.guidelines,
+        match: c => GUIDELINE_BASENAMES.has(basename(c.path).toLowerCase()),
+        byName: true
+    },
+    {
+        id: 'domain',
+        tier: ORIENTATION_TIERS.domain,
+        match: c => {
+            const lower = c.path.toLowerCase();
+            const ext = extension(lower);
+            const base = basename(lower);
+            return (ext === 'sql'
+                || ext === 'prisma'
+                || ext === 'graphql'
+                || ext === 'gql'
+                || base.endsWith('.d.ts')
+                || lower.split('/').includes('types')
+                || base.replace(/\.[^.]+$/, '') === 'types'
+                || /schema|zod/.test(lower));
+        }
+    },
+    {
+        id: 'entrypoint',
+        tier: ORIENTATION_TIERS.entrypoint,
+        match: c => ['index', 'main', 'app', 'server', 'mod'].includes(basename(c.path)
+            .toLowerCase()
+            .replace(/\.[^.]+$/, ''))
+    },
+    {
+        id: 'api',
+        tier: ORIENTATION_TIERS.api,
+        match: c => {
+            const lower = c.path.toLowerCase();
+            return /(^|\/)api(\/|s?\.|$)/.test(lower) || lower.split('/').includes('api');
+        }
+    },
+    {
+        id: 'readme',
+        tier: ORIENTATION_TIERS.docs,
+        match: c => basename(c.path)
+            .toLowerCase()
+            .replace(/\.[^.]+$/, '') === 'readme'
+    }
+];
+/** A path that no rule may promote, whatever it looks like. */
+function excluded(c) {
+    if (c.vendored)
+        return true;
+    if (c.path.startsWith('/'))
+        return true; // absolute path escaped the repo root
+    const lower = c.path.toLowerCase();
+    return /\.(test|spec)\.[a-z]+$/.test(lower) || /(^|\/)(__tests__|e2e)\//.test(lower);
+}
+/**
+ * Priority tier for an orientation candidate — lower is more fundamental, null
+ * for a path that is not orientation material.
  */
-export function orientationTier(path) {
-    const lower = path.toLowerCase();
-    // Never orient on vendored/build output or tests: a dependency's package.json
-    // is tier 0 by basename and a `*.test.ts` under `src/types/` is tier 2, so
-    // either would outrank the project's own files and eat the budget. A
-    // git-ls-files inventory won't list these anyway; this is belt-and-braces.
-    if (/(^|\/)(node_modules|dist|build|out|vendor|\.git|coverage)\//.test(lower))
+export function orientationTier(path, opts = {}) {
+    const candidate = {
+        path,
+        cited: opts.cited ?? false,
+        vendored: opts.vendored ?? isVendored(path)
+    };
+    if (excluded(candidate))
         return null;
-    if (/\.(test|spec)\.[a-z]+$/.test(lower) || /(^|\/)(__tests__|e2e)\//.test(lower))
+    const rule = ORIENTATION_RULES.find(r => r.match(candidate));
+    if (!rule)
         return null;
-    if (path.startsWith('/'))
-        return null; // absolute path escaped the repo root
-    const base = basename(lower);
-    const ext = extension(lower);
-    if (MANIFEST_BASENAMES.has(base))
-        return 0;
-    if (!ORIENTATION_EXTENSIONS.has(ext))
+    if (!rule.byName && !ORIENTATION_EXTENSIONS.has(extension(path)))
         return null;
-    if (base === 'tsconfig.json' || /\.config\.(ts|js|mjs|cjs|json)$/.test(base))
-        return 1;
-    const segs = lower.split('/');
-    const stem = base.replace(/\.[^.]+$/, '');
-    if (ext === 'sql'
-        || ext === 'prisma'
-        || ext === 'graphql'
-        || ext === 'gql'
-        || base.endsWith('.d.ts')
-        || segs.includes('types')
-        || stem === 'types'
-        || /schema|zod/.test(lower))
-        return 2;
-    if (['index', 'main', 'app', 'server', 'mod'].includes(stem))
-        return 3;
-    if (/(^|\/)api(\/|s?\.|$)/.test(lower) || segs.includes('api'))
-        return 4;
-    if (stem === 'readme')
-        return 5;
-    return null;
+    return rule.tier;
+}
+/**
+ * Is this path outside the project's own source? `VENDORED_DIRS` plus whatever
+ * `.gitignore` and `orientationExclude` add (see {@link parseIgnorePatterns}).
+ */
+export function isVendored(path, patterns = []) {
+    const segments = path.split('/');
+    if (VENDORED_DIRS.some(d => segments.includes(d)))
+        return true;
+    return patterns.some(p => ignoreMatcher(p)(path));
+}
+/**
+ * The usable patterns in a `.gitignore`.
+ *
+ * Negations (`!kept.md`) are DROPPED rather than honoured: un-ignoring is a
+ * whole-file-order semantics this does not implement, and the inventory a real
+ * run orients over is `git ls-files`, which has already applied the real rules.
+ * What is left here only has to keep bulk out.
+ */
+export function parseIgnorePatterns(gitignore) {
+    return gitignore
+        .split('\n')
+        .map(l => l.trim())
+        .filter(l => l.length > 0 && !l.startsWith('#') && !l.startsWith('!'));
+}
+const matchers = new Map();
+/** A `.gitignore`-style pattern as a predicate, compiled once per pattern. */
+function ignoreMatcher(pattern) {
+    const cached = matchers.get(pattern);
+    if (cached)
+        return cached;
+    const anchored = pattern.startsWith('/');
+    const body = pattern.replace(/^\//, '').replace(/\/$/, '');
+    const source = body
+        .split('/')
+        .map(seg => seg
+        .split('*')
+        .map(part => part.replace(/[.+^${}()|[\]\\?]/g, '\\$&'))
+        .join('[^/]*')
+        // `**` survives the split above as two `[^/]*` around an empty
+        // part; a directory wildcard has to cross separators.
+        .replace(/\[\^\/\]\*\[\^\/\]\*/g, '.*'))
+        .join('/');
+    // A pattern matches the path itself or anything under it, and — unless it is
+    // anchored to the repo root — at any depth, which is gitignore's own rule.
+    const re = new RegExp(`^${anchored ? '' : '(?:.*/)?'}${source}(?:/.*)?$`);
+    const fn = (path) => re.test(path);
+    matchers.set(pattern, fn);
+    return fn;
 }
 /**
  * Rank inventory paths into orientation priority order: by tier, then shallower
@@ -138,26 +309,39 @@ export function orientationTier(path) {
  * for a fully deterministic order. Non-orientation paths are dropped. The result
  * is the *candidate* order; the byte budget is applied later when reading.
  */
-export function selectOrientationFiles(inventoryPaths) {
+export function selectOrientationFiles(inventoryPaths, opts = {}) {
+    const cited = new Set(opts.cited ?? []);
     return inventoryPaths
-        .map(p => ({ p, tier: orientationTier(p) }))
+        .map(p => ({
+        path: p,
+        tier: orientationTier(p, {
+            cited: cited.has(p),
+            vendored: isVendored(p, opts.excludePatterns ?? [])
+        })
+    }))
         .filter((x) => x.tier !== null)
-        .sort((a, b) => a.tier - b.tier || depth(a.p) - depth(b.p) || (a.p < b.p ? -1 : 1))
-        .map(x => x.p);
+        .sort((a, b) => a.tier - b.tier || depth(a.path) - depth(b.path) || (a.path < b.path ? -1 : 1));
 }
 /**
  * Read the orientation core within the byte budget and format it as a header
  * block. `readFile` returns a file's text or null (missing/unreadable/binary) —
  * a null or over-cap file is skipped, not fatal. Greedy in priority order: take
- * each file whose content fits the per-file cap and the remaining total budget;
- * skip the rest. Returns an empty block (and empty set) when nothing qualifies,
- * so the caller falls back to today's behavior.
+ * each file whose content fits its tier's per-file cap and the remaining total
+ * budget; skip the rest. Returns an empty block (and empty set) when nothing
+ * qualifies, so the caller falls back to today's behavior.
  */
 export async function buildOrientation(inventoryPaths, readFile, opts = {}) {
     const byteBudget = opts.byteBudget ?? ORIENTATION_BYTE_BUDGET;
+    const citedBudget = opts.citedByteBudget ?? ORIENTATION_CITED_BYTE_BUDGET;
     const perFileMax = opts.perFileMax ?? ORIENTATION_PER_FILE_MAX;
     const maxFiles = opts.maxFiles ?? ORIENTATION_MAX_FILES;
-    const candidates = selectOrientationFiles(inventoryPaths).slice(0, maxFiles * 4);
+    // The cited doc is the file the task is ABOUT, and a design document is
+    // routinely larger than the cap that keeps one incidental file from eating
+    // the budget. Skipping it is the failure this tier exists to fix, so it is
+    // bounded by its own purse instead.
+    const cited = (tier) => tier === ORIENTATION_TIERS.cited;
+    const perFileMaxFor = (tier) => (cited(tier) ? citedBudget : perFileMax);
+    const candidates = selectOrientationFiles(inventoryPaths, opts).slice(0, maxFiles * 4);
     const supplied = new Set();
     const parts = [];
     // Budget the *emitted* block, not just the raw content: the per-file fence
@@ -168,20 +352,28 @@ export async function buildOrientation(inventoryPaths, readFile, opts = {}) {
         + `already provided, do not re-read these)\n`;
     const TRAILER = '\n\n';
     let used = Buffer.byteLength(HEADER + TRAILER, 'utf8');
-    for (const path of candidates) {
+    let usedCited = 0;
+    for (const { path, tier } of candidates) {
         if (supplied.size >= maxFiles)
             break;
         const text = await readFile(path);
         if (text === null)
             continue;
-        if (Buffer.byteLength(text, 'utf8') > perFileMax)
+        if (Buffer.byteLength(text, 'utf8') > perFileMaxFor(tier))
             continue;
         const piece = `--- ${path} ---\n${text.replace(/\n+$/, '')}`;
         // Each piece after the first is preceded by the `\n\n` join separator.
         const pieceBytes = Buffer.byteLength(piece, 'utf8') + (parts.length > 0 ? 2 : 0);
-        if (used + pieceBytes > byteBudget)
-            continue;
-        used += pieceBytes;
+        if (cited(tier)) {
+            if (usedCited + pieceBytes > citedBudget)
+                continue;
+            usedCited += pieceBytes;
+        }
+        else {
+            if (used + pieceBytes > byteBudget)
+                continue;
+            used += pieceBytes;
+        }
         supplied.add(path);
         parts.push(piece);
     }

package/dist/task/owned-freeze-reassign.d.ts

@@ -15,7 +15,7 @@
  *           `appendOwnedConstraints` stamps the bullet, which is the first moment
  *           the pair exists): the entry is marked `pending: [frozen paths]` in the
  *           ledger and its stamped bullet is dropped from this spec. It is now
- *           owned by nobody; `ownedForTitle` skips it; the quote is still there,
+ *           owned by nobody; `ownedForTask` skips it; the quote is still there,
  *           byte for byte.
  *   CLAIM   at every LATER task's compose, before the belt block is built: if that
  *           task's REFINED PROMPT shows a write intent on one of the pending
@@ -89,7 +89,9 @@ export declare function writeIntent(text: string, p: string): boolean;
  */
 export declare function detachUnsatisfiableRequirements(args: {
     spec: string;
-    /** The executing task's plan title — the ledger's join key. */
+    /** The executing task's plan key — the ledger's join. */
+    key?: string;
+    /** The executing task's plan title — display, and the legacy join. */
     title: string;
     ledger: OwnedRequirement[];
     isSource?: OwnedFreezeOptions['isSource'];
@@ -110,7 +112,9 @@ export interface ClaimResult {
 export declare function claimPendingRequirements(args: {
     /** The claiming task's refined prompt — the text that says what it will write. */
     intent: string;
-    /** The claiming task's plan title (the ledger's join key). */
+    /** The claiming task's plan key — what the ledger joins on afterwards. */
+    key?: string;
+    /** The claiming task's plan title. */
     title: string;
     ledger: OwnedRequirement[];
 }): ClaimResult;

package/dist/task/owned-freeze-reassign.js

@@ -15,7 +15,7 @@
  *           `appendOwnedConstraints` stamps the bullet, which is the first moment
  *           the pair exists): the entry is marked `pending: [frozen paths]` in the
  *           ledger and its stamped bullet is dropped from this spec. It is now
- *           owned by nobody; `ownedForTitle` skips it; the quote is still there,
+ *           owned by nobody; `ownedForTask` skips it; the quote is still there,
  *           byte for byte.
  *   CLAIM   at every LATER task's compose, before the belt block is built: if that
  *           task's REFINED PROMPT shows a write intent on one of the pending
@@ -46,7 +46,7 @@
  * see rather than an obligation that quietly evaporated.
  */
 import { findOwnedFreezeConflicts } from './owned-freeze-conflict.js';
-import { ownedForTitle } from './requirements.js';
+import { ownedForTask } from './requirements.js';
 import { PROHIBITION_RE } from './prohibition-probe.js';
 /**
  * Does this text CLAIM a write on `p` — a create/modify verb reaching a mention
@@ -101,7 +101,7 @@ function dropLine(spec, line) {
  * no quote leaves the ledger, no prose is touched.
  */
 export function detachUnsatisfiableRequirements(args) {
-    const mine = ownedForTitle(args.ledger, args.title);
+    const mine = ownedForTask(args.ledger, args);
     const conflicts = findOwnedFreezeConflicts(args.spec, {
         owned: mine,
         isSource: args.isSource
@@ -111,10 +111,13 @@ export function detachUnsatisfiableRequirements(args) {
         spec: args.spec,
         actions: []
     };
+    // `mine` holds the pre-copy entries, so the copy is re-found by quote — the
+    // ledger's own key.
+    const ownedQuotes = new Set(mine.map(o => o.quote));
     for (const c of conflicts) {
         const entry = out.ledger.find(o => !(o.pending && o.pending.length > 0)
             && c.requirement.includes(o.quote)
-            && normalise(o.title) === normalise(args.title));
+            && ownedQuotes.has(o.quote));
         if (!entry) {
             // The conflicting line is not one of THIS task's ledger quotes (a
             // stamp from an earlier plan round, or a quote the ledger no longer
@@ -166,6 +169,12 @@ export function claimPendingRequirements(args) {
         if (claimed.length === 0)
             continue;
         delete entry.pending;
+        // Both halves of the join move together — a claim that retitled without
+        // rekeying would leave the entry owned by the task that gave it up.
+        if (args.key === undefined)
+            delete entry.key;
+        else
+            entry.key = args.key;
         entry.title = args.title;
         out.actions.push({ kind: 'claim', quote: entry.quote, by: args.title, paths: claimed });
     }
@@ -177,7 +186,6 @@ export function claimPendingRequirements(args) {
 export function unclaimedPendingRequirements(ledger) {
     return ledger.filter(o => (o.pending ?? []).length > 0);
 }
-const normalise = (s) => s.trim().toLowerCase().replace(/\s+/g, ' ');
 /** One line per action, for the run's debug log. */
 export function formatReassignActions(actions) {
     return actions

package/dist/task/parsers.d.ts

@@ -3,6 +3,7 @@
  *
  * Pure functions that parse raw model output into structured data.
  */
+import type { ToolingClass } from './run-context.js';
 /**
  * WHY an auto-answer came back `unknown` — the producers are otherwise
  * indistinguishable at the call site, and they are NOT equivalent: only
@@ -48,7 +49,11 @@ export declare function parseClarifyList(raw: string): ClarifyQuestion[];
 export declare function autoAnswerHasTag(raw: string): boolean;
 export declare function parseAutoAnswer(raw: string): AutoAnswer;
 export declare function parseVerifyToolingOutput(output: string): {
-    verified: string[];
+    verified: Array<{
+        cmd: string;
+        class: ToolingClass;
+        evidence: string;
+    }>;
     rejected: Array<{
         cmd: string;
         reason: string;

package/dist/task/parsers.js

@@ -164,6 +164,12 @@ export function parseAutoAnswer(raw) {
     return { kind: 'unknown', raw, reason: 'model-unknown' };
 }
 // ─── Verify tooling output parser ────────────────────────────────────────────
+const TOOLING_CLASSES = ['check', 'build', 'serve'];
+/** The class column of a VERIFIED line, or null when the child wrote something else. */
+function toolingClass(field) {
+    const t = field.trim().toLowerCase();
+    return TOOLING_CLASSES.find(c => c === t) ?? null;
+}
 export function parseVerifyToolingOutput(output) {
     const verified = [];
     const rejected = [];
@@ -180,15 +186,26 @@ export function parseVerifyToolingOutput(output) {
         }
         if (!line)
             continue;
-        // Lines look like: "  <cmd>  <evidence/reason>"
+        // Lines look like: "  <cmd>  <class>  <evidence>" (REJECTED has no class).
         const match = line.match(/^(\S.*?)\s{2,}(.+)$/);
         if (!match)
             continue;
         const [, cmd, detail] = match;
-        if (section === 'verified')
-            verified.push(cmd.trim());
-        else if (section === 'rejected')
+        if (section === 'rejected') {
             rejected.push({ cmd: cmd.trim(), reason: detail.trim() });
+            continue;
+        }
+        if (section !== 'verified')
+            continue;
+        const columns = detail.match(/^(\S+)\s{2,}(.+)$/);
+        const cls = columns ? toolingClass(columns[1]) : null;
+        // A line with no class column is a check: the TOOLING list is verification
+        // commands, and the prompt requires a long-running one to say `serve`.
+        verified.push({
+            cmd: cmd.trim(),
+            class: cls ?? 'check',
+            evidence: (cls && columns ? columns[2] : detail).trim()
+        });
     }
     return { verified, rejected };
 }

package/dist/task/phases.d.ts

@@ -170,7 +170,7 @@ export declare const SINGLE_READ_EXTENSION_PATH: string;
  * …) or end of text.
  */
 export declare function scopedToolingGoal(refined: string): string;
-export declare function phaseResearch(deps: PhaseDeps, refined: string): Promise<string>;
+export declare function phaseResearch(deps: PhaseDeps, refined: string, rawPrompt?: string): Promise<string>;
 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>;
 /**