@mjasnikovs/pi-task 0.14.8 → 0.14.10

package/dist/task/auto-orchestrator.js

@@ -17,6 +17,7 @@ import { writeTaskFile, readTaskFile, updateTaskFrontMatter, taskFilePath, tasks
 import { gitCommitAll } from './auto-commit.js';
 import { runGuidelineEnforcement, classifyEnforceChildFailure } from './enforce-guidelines.js';
 import { runWorker } from '../workers/pi-worker-core.js';
+import { findPhantomImports, rewritePhantomSpecifiers } from '../workers/phantom-imports.js';
 import { runPhaseChild, prependHint, formatLoopHint, USER_CANCELLED } from './child-runner.js';
 import { SessionUI, registerBridgeCommand } from '../remote/bridge.js';
 import { pushNotify } from '../remote/push.js';
@@ -42,6 +43,19 @@ const MENTION_TRAILING_PUNCT = /[.,;:!?)\]}>"']+$/;
 function mentionPath(token) {
     return token.replace(MENTION_TRAILING_PUNCT, '');
 }
+/**
+ * Fire-and-forget debug line for the PLAN phase (clarify/decompose), which runs
+ * before any task file — hence any per-task `TASK_XXXX-debug.log` — exists. Writes
+ * to `.pi-tasks/plan-debug.log`; the `*-debug.log` suffix keeps it grep-compatible
+ * with the per-task logs. Never throws (mkdir + append are best-effort).
+ */
+function logPlanDebug(cwd, msg) {
+    const line = `${new Date().toISOString()} ${msg}\n`;
+    const dir = tasksDir(cwd);
+    fsp.mkdir(dir, { recursive: true })
+        .then(() => fsp.appendFile(path.join(dir, 'plan-debug.log'), line))
+        .catch(() => { });
+}
 /**
  * Expand any @file references in the feature text by appending each referenced
  * file's contents, so the planning children (clarify, decompose) always see the
@@ -180,7 +194,22 @@ export async function planAuto(ctx, cwd, feature, deps) {
     const ui = new SessionUI(ctx);
     // Inline any @file spec the user referenced so clarify/decompose reason over
     // the real content, not a one-line "Implement @file" that reads as trivial.
-    const featureForModel = await expandFeatureMentions(cwd, feature);
+    const rawFeatureForModel = await expandFeatureMentions(cwd, feature);
+    // Strike phantom runtime specifiers (`bun:sql`) out of the inlined spec BEFORE
+    // clarify/decompose ever see it. Layer A only rewrites the per-task `refined`
+    // text — which is DOWNSTREAM of here: clarify is the first phase and runs on
+    // this raw inline, so the doc's affirmative `bun:sql` is parroted straight into
+    // the very first clarifying question ("instantly bun:sql is back"). Apply the
+    // same deterministic, no-LLM strike at the single point that feeds both planning
+    // children. Silent + no-op when nothing is flagged or the runtime's types aren't
+    // installed.
+    const planPhantoms = findPhantomImports(rawFeatureForModel, cwd);
+    const featureForModel = planPhantoms.length === 0 ?
+        rawFeatureForModel
+        : rewritePhantomSpecifiers(rawFeatureForModel, planPhantoms);
+    if (planPhantoms.length > 0) {
+        logPlanDebug(cwd, `phantom specifiers rewritten in plan spec: ${planPhantoms.map(x => x.spec).join(', ')}`);
+    }
     const answers = [];
     // Plain text of every question already shown, for the duplicate backstop.
     const askedQuestions = [];

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.10",
     "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",