@mjasnikovs/pi-task 0.14.8 → 0.14.9

package/dist/task/phases.js

@@ -6,7 +6,7 @@ import { docsFocused } from '../workers/docs-core.js';
 import { fetchFocused } from '../workers/fetch-core.js';
 import { formatNpmVersionSection } from '../workers/npm-version.js';
 import { runWorker } from '../workers/pi-worker-core.js';
-import { findPhantomImports, formatApiCorrections } from '../workers/phantom-imports.js';
+import { findPhantomImports, formatApiCorrections, rewritePhantomSpecifiers } from '../workers/phantom-imports.js';
 import { search as defaultSearch } from '../workers/search-core.js';
 import { extractEnrichTargets } from './enrichment.js';
 import { getFileInventory } from './file-inventory.js';
@@ -651,7 +651,21 @@ export const PHASES = [
         name: 'refine',
         section: 'refined prompt',
         field: 'refined',
-        run: (d, p) => phaseRefine(d, p.rawPrompt, p.planContext)
+        run: async (d, p) => {
+            const refined = await phaseRefine(d, p.rawPrompt, p.planContext);
+            // Subtractively strike any phantom runtime specifier (`bun:sql`) the
+            // refine carried up verbatim from the spec doc, BEFORE it flows to
+            // research/grill/compose. An appended correction alone loses: the
+            // affirmative survives into the composed GOAL and on to the implementer
+            // (proven: compose re-leaks it 4/4). Rewriting the source so compose has
+            // nothing to contradict is the fix. Silent + no-op when nothing is wrong
+            // or the runtime's types aren't installed.
+            const phantoms = findPhantomImports(refined, d.cwd);
+            if (phantoms.length === 0)
+                return refined;
+            d.logDebug?.(`phantom specifiers rewritten in refined: ${phantoms.map(x => x.spec).join(', ')}`);
+            return rewritePhantomSpecifiers(refined, phantoms);
+        }
     },
     {
         name: 'research',

package/dist/workers/phantom-imports.d.ts

@@ -5,6 +5,9 @@ export interface PhantomImport {
     realModules: string[];
     /** Corrective guidance to inject into the spec. */
     suggestion: string;
+    /** Base-module symbol the submodule leaf maps to (`bun:sql` → `SQL`), or null
+     *  when the types declare no matching symbol. Drives the canonical-import rewrite. */
+    baseSymbol: string | null;
 }
 /** Every distinct runtime-namespace specifier mentioned in the text, in first-seen order. */
 export declare function extractRuntimeSpecifiers(text: string): string[];
@@ -33,3 +36,19 @@ export declare function loadRuntimeTypeText(runtime: string, cwd: string): strin
 export declare function findPhantomImports(text: string, cwd: string, loadText?: (runtime: string, cwd: string) => string | null): PhantomImport[];
 /** Render flagged phantoms as an authoritative research section, or '' if none. */
 export declare function formatApiCorrections(phantoms: PhantomImport[]): string;
+/**
+ * Subtractively rewrite every flagged phantom specifier in `text` to the canonical
+ * import the installed types prove, so NO affirmative occurrence of the non-existent
+ * specifier survives downstream. This is the half an appended correction can't do:
+ * REFINE preserves identifiers verbatim, so `bun:sql` otherwise rides into the
+ * composed GOAL (proven: compose re-leaks it 4/4) and on to the implementer. Strike
+ * it at the source and compose has nothing to contradict.
+ *
+ * Deterministic, no LLM. Idempotent on healthy input: once a specifier is replaced
+ * the literal is gone, so a second pass is a no-op (the only residue is a `declare
+ * module` comment that quotes the spec inside a slash-star, which the bare-word rule
+ * skips via its lookbehind). Handles the four forms a phantom takes: an import/require
+ * `from "<spec>"`, a fabricated `declare module "<spec>"`, a backticked prose mention
+ * `` `<spec>` ``, and a bare word `<spec>`.
+ */
+export declare function rewritePhantomSpecifiers(text: string, phantoms: PhantomImport[]): string;

package/dist/workers/phantom-imports.js

@@ -173,7 +173,8 @@ export function findPhantomImports(text, cwd, loadText = loadRuntimeTypeText) {
         out.push({
             spec,
             realModules: verdict.realModules,
-            suggestion: suggestionFor(verdict, ns.runtime)
+            suggestion: suggestionFor(verdict, ns.runtime),
+            baseSymbol: verdict.baseSymbol
         });
     }
     return out;
@@ -185,3 +186,43 @@ export function formatApiCorrections(phantoms) {
     const lines = phantoms.map(p => `  - ${p.suggestion}`);
     return `API CORRECTIONS\n${lines.join('\n')}`;
 }
+/**
+ * Subtractively rewrite every flagged phantom specifier in `text` to the canonical
+ * import the installed types prove, so NO affirmative occurrence of the non-existent
+ * specifier survives downstream. This is the half an appended correction can't do:
+ * REFINE preserves identifiers verbatim, so `bun:sql` otherwise rides into the
+ * composed GOAL (proven: compose re-leaks it 4/4) and on to the implementer. Strike
+ * it at the source and compose has nothing to contradict.
+ *
+ * Deterministic, no LLM. Idempotent on healthy input: once a specifier is replaced
+ * the literal is gone, so a second pass is a no-op (the only residue is a `declare
+ * module` comment that quotes the spec inside a slash-star, which the bare-word rule
+ * skips via its lookbehind). Handles the four forms a phantom takes: an import/require
+ * `from "<spec>"`, a fabricated `declare module "<spec>"`, a backticked prose mention
+ * `` `<spec>` ``, and a bare word `<spec>`.
+ */
+export function rewritePhantomSpecifiers(text, phantoms) {
+    let out = text;
+    for (const p of phantoms) {
+        const ns = splitRuntimeNamespace(p.spec);
+        if (!ns)
+            continue;
+        const runtime = ns.runtime;
+        const canonical = p.baseSymbol ?
+            `import { ${p.baseSymbol} } from "${runtime}"`
+            : `the "${runtime}" module`;
+        const spec = escapeRe(p.spec);
+        out = out
+            // `from "bun:sql"` / `require("bun:sql")` → point at the base runtime module
+            .replace(new RegExp(`((?:from\\s+|require\\(\\s*)["'])${spec}(["'])`, 'g'), `$1${runtime}$2`)
+            // a fabricated `declare module "bun:sql"` → a comment naming the real import.
+            // Deliberately does NOT echo the spec literal, so the bare-word pass below
+            // can't re-corrupt this comment (keeps the rewrite idempotent).
+            .replace(new RegExp(`declare\\s+module\\s+["']${spec}["']`, 'g'), `/* not a module — use ${canonical} */`)
+            // backticked prose mention → the canonical import
+            .replace(new RegExp('`' + spec + '`', 'g'), '`' + canonical + '`')
+            // bare word, not already inside quotes/backticks/a path or our own comment
+            .replace(new RegExp(`(?<![\`"'/])\\b${spec}\\b(?![\`"'])`, 'g'), canonical);
+    }
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.14.8",
+    "version": "0.14.9",
     "description": "Deterministic spec-orchestration for local models, with a bundled real-time remote web view and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",