@mjasnikovs/pi-task 0.17.5 → 0.17.7

package/dist/task/auto-orchestrator.js

@@ -17,6 +17,7 @@ import { allocateAutoId, buildAutoBody, parseDecomposeList, parseTaskList, check
 import { writeTaskFile, readTaskFile, updateTaskFrontMatter, taskFilePath, tasksDir } from './task-io.js';
 import { findPhantomImports, rewritePhantomSpecifiers } from '../workers/phantom-imports.js';
 import { runPhaseChild, prependHint, USER_CANCELLED } from './child-runner.js';
+import { refineExistingFilesBlock } from './phases.js';
 import { SessionUI, registerBridgeCommand, publishLifecycleNotice } from '../remote/bridge.js';
 import { pushNotify } from '../remote/push.js';
 import { startAutoLoader } from './widget.js';
@@ -80,9 +81,19 @@ function logPlanDebug(cwd, msg) {
  * throw or an untagged reply falls back to surfacing the question (the prior
  * behavior), never dropping it silently.
  */
-async function triageClarifyQuestion(deps, cwd, featureForModel, question) {
+async function triageClarifyQuestion(deps, cwd, featureForModel, existingFilesBlock, question) {
     try {
-        const basePrompt = GRILL_AUTO_ANSWER_PROMPT(featureForModel, '(none — clarify runs before decomposition; each task researches itself later)', question);
+        // Prepend the existing-files block (refine's REFINE_PRESERVE_DIRECTIVE +
+        // manifest/config content) so a "scaffold/create/from scratch" question is
+        // auto-resolved as an in-place UPDATE that PRESERVES what is on disk —
+        // instead of "greenfield, from scratch", which the spec-only triage emitted
+        // 13/15 of the time and would mint a destructive decompose decision that can
+        // outrank refine's preserve directive (A/B live: 2/15 → 14/15 preserve).
+        // Empty (greenfield repo / orientation off) → byte-identical to before.
+        const source = existingFilesBlock.length > 0 ?
+            `${existingFilesBlock}\n\n${featureForModel}`
+            : featureForModel;
+        const basePrompt = GRILL_AUTO_ANSWER_PROMPT(source, '(none — clarify runs before decomposition; each task researches itself later)', question);
         let text = await deps.runChild('clarify-triage', 'read', basePrompt);
         if (!autoAnswerHasTag(text)) {
             // No ANSWER/UNKNOWN/ALT tag — the model wrote prose. Reprompt once for
@@ -261,6 +272,15 @@ export async function planAuto(ctx, cwd, feature, deps) {
     if (planPhantoms.length > 0) {
         logPlanDebug(cwd, `phantom specifiers rewritten in plan spec: ${planPhantoms.map(x => x.spec).join(', ')}`);
     }
+    // Existing manifest/config on disk (REFINE_PRESERVE_DIRECTIVE + tier 0–1
+    // content), computed ONCE and fed to every triage call so a "scaffold X"
+    // question resolves to an in-place update instead of "greenfield". '' for a
+    // greenfield/non-git repo or orientation off → triage stays spec-only.
+    const existingFilesBlock = await refineExistingFilesBlock({
+        cwd,
+        taskId: '',
+        signal: new AbortController().signal
+    }).catch(() => '');
     const answers = [];
     // Plain text of every question already shown, for the duplicate backstop.
     const askedQuestions = [];
@@ -299,7 +319,7 @@ export async function planAuto(ctx, cwd, feature, deps) {
         // this question, auto-resolve it and never show it. The resolved value is
         // recorded so decompose sees the decision and the next gen call's priorQA
         // won't re-ask it.
-        const autoResolved = await triageClarifyQuestion(deps, cwd, featureForModel, plainQ);
+        const autoResolved = await triageClarifyQuestion(deps, cwd, featureForModel, existingFilesBlock, plainQ);
         if (autoResolved !== null) {
             answers.push(`Q${answers.length + 1}: ${plainQ}\n`
                 + `A${answers.length + 1}: ${autoResolved} (auto-resolved — already settled by the spec)`);

package/dist/task/enrichment.d.ts

@@ -3,7 +3,14 @@
  * orchestrator can fan out docs/URL lookups before the research phase.
  */
 export declare function extractEnrichTargets(text: string): {
+    /** Packages that get a (heavy) docs fetch — capped at ENRICH_CAP. */
     packages: string[];
+    /**
+     * Every named package, up to ENRICH_VERSION_CAP, for a cheap live npm version
+     * lookup. A superset of `packages`; the extras get a version block only (no
+     * docs body). Order-preserving and deduped, same as `packages`.
+     */
+    versionPackages: string[];
     urls: string[];
     services: Array<{
         name: string;

package/dist/task/enrichment.js

@@ -21,6 +21,13 @@ const ENRICH_DENYLIST = new Set([
     'rm'
 ]);
 const ENRICH_CAP = 3;
+// Heavy docs/url fetches stay capped at ENRICH_CAP (each is a worker spawn +
+// page fetch). A live npm VERSION lookup is just one cheap registry GET, so it
+// can cover far more packages — every dependency a task explicitly names should
+// get a grounded latest-version block, not just the first ENRICH_CAP of them. A
+// task that named 6 runtime deps used to leave the 4th–6th (e.g. tailwindcss)
+// with NO live version, so a version question fell back to stale training data.
+const ENRICH_VERSION_CAP = 12;
 const ENRICH_SERVICE_HEADER = 'EXTERNAL-DEPENDENCIES';
 const ENRICH_HEADER_LINE_RE = /^[A-Z][A-Z0-9 -]+$/;
 const ENRICH_SERVICE_BULLET_RE = /^\s*-\s+(.+?)\s{2,}(.+?)\s*$/;
@@ -61,13 +68,15 @@ function parseServices(text) {
     return out;
 }
 export function extractEnrichTargets(text) {
-    const pkgs = new Set();
+    const pkgs = [];
+    const seen = new Set();
     for (const m of text.matchAll(ENRICH_PKG_RE)) {
         const t = m[1];
-        if (ENRICH_DENYLIST.has(t))
+        if (ENRICH_DENYLIST.has(t) || seen.has(t))
             continue;
-        pkgs.add(t);
-        if (pkgs.size >= ENRICH_CAP)
+        seen.add(t);
+        pkgs.push(t);
+        if (pkgs.length >= ENRICH_VERSION_CAP)
             break;
     }
     const urls = new Set();
@@ -78,5 +87,5 @@ export function extractEnrichTargets(text) {
             break;
     }
     const services = parseServices(text);
-    return { packages: [...pkgs], urls: [...urls], services };
+    return { packages: pkgs.slice(0, ENRICH_CAP), versionPackages: pkgs, urls: [...urls], services };
 }

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

@@ -10,6 +10,7 @@
  */
 import { docsRaw } from '../workers/docs-core.js';
 import { fetchRaw } from '../workers/fetch-core.js';
+import { npmVersionLookup } from '../workers/npm-version.js';
 import type { SearchCoreInput, SearchCoreResult } from '../workers/search-core.js';
 import type { PhaseDeps } from './child-runner.js';
 /** Injectable workers so enrichment is testable without spawning real lookups. */
@@ -17,6 +18,7 @@ export interface ExternalContextDeps {
     docsRaw?: typeof docsRaw;
     fetchRaw?: typeof fetchRaw;
     searchFn?: (input: SearchCoreInput) => Promise<SearchCoreResult>;
+    npmVersionLookup?: typeof npmVersionLookup;
 }
 type GatherDeps = Pick<PhaseDeps, 'cwd' | 'signal' | 'recordSubStep'>;
 /**

package/dist/task/external-context.js

@@ -10,7 +10,7 @@
  */
 import { docsRaw } from '../workers/docs-core.js';
 import { fetchRaw } from '../workers/fetch-core.js';
-import { formatNpmVersionSection } from '../workers/npm-version.js';
+import { formatNpmVersionSection, npmVersionLookup } from '../workers/npm-version.js';
 import { search as defaultSearch } from '../workers/search-core.js';
 import { extractEnrichTargets } from './enrichment.js';
 import { formatServiceBlock, formatFreshnessSkippedBlock } from './service-blocks.js';
@@ -22,7 +22,15 @@ export async function gatherExternalContext(refined, deps, researchDeps = {}) {
     const docsRawFn = researchDeps.docsRaw ?? docsRaw;
     const fetchRawFn = researchDeps.fetchRaw ?? fetchRaw;
     const searchFn = researchDeps.searchFn ?? defaultSearch;
+    const npmVersionFn = researchDeps.npmVersionLookup ?? npmVersionLookup;
     const enrichTargets = extractEnrichTargets(refined);
+    // Every named dep past the heavy-docs cap still gets a cheap live version
+    // lookup, so a version block exists for ALL of them (the docs-fetched ones
+    // emit their version below from the bundled lookup). Without this, deps 4..N
+    // had no live version and a "which version?" question fell back to the model's
+    // stale training data — how tailwindcss got pinned to an old major.
+    const docsPkgs = new Set(enrichTargets.packages);
+    const extraVersionPkgs = enrichTargets.versionPackages.filter(p => !docsPkgs.has(p));
     if (enrichTargets.packages.length === 0
         && enrichTargets.urls.length === 0
         && enrichTargets.services.length === 0) {
@@ -30,7 +38,7 @@ export async function gatherExternalContext(refined, deps, researchDeps = {}) {
     }
     const enrichSections = [];
     const tEnrichStart = Date.now();
-    const [docsResults, fetchResults, serviceResults] = await Promise.all([
+    const [docsResults, fetchResults, serviceResults, extraVersionResults] = await Promise.all([
         Promise.all(enrichTargets.packages.map(pkg => docsRawFn({
             pkg,
             query: refined.split('\n').find(l => l.trim()) ?? refined,
@@ -42,16 +50,22 @@ export async function gatherExternalContext(refined, deps, researchDeps = {}) {
             query: `${s.name} ${s.query}`,
             count: 3,
             signal: deps.signal
-        }).catch(() => null)))
+        }).catch(() => null))),
+        Promise.all(extraVersionPkgs.map(pkg => npmVersionFn(pkg, { signal: deps.signal }).catch(() => null)))
     ]);
-    // npm version blocks come from docsRaw's bundled lookup and lead the
-    // section so the model anchors on live version data before reading
-    // the docs body.
+    // npm version blocks lead the section so the model anchors on live version
+    // data before reading any docs body. The docs-fetched packages carry their
+    // version in docsRaw's bundled lookup; the remaining named deps get theirs
+    // from the cheap standalone lookup above. Together they cover EVERY named dep.
     for (let i = 0; i < enrichTargets.packages.length; i++) {
         const v = docsResults[i]?.npmVersion;
         if (v)
             enrichSections.push(formatNpmVersionSection(v));
     }
+    for (const v of extraVersionResults) {
+        if (v)
+            enrichSections.push(formatNpmVersionSection(v));
+    }
     for (let i = 0; i < enrichTargets.packages.length; i++) {
         const r = docsResults[i];
         if (r?.kind === 'ok' && r.chunks.length > 0) {

package/dist/task/prompts.js

@@ -221,6 +221,7 @@ LIVE-DATA RULE:
 - "### service: <name>" blocks are LIVE web data; authoritative over training data for that service.
 - "### freshness-check skipped" → tag UNKNOWN and say current state needs verification.
 - No npm block + question is about latest/current version → tag UNKNOWN (training data goes stale).
+- VERSION-PIN questions ("pin to X.y vs latest", "which major version") are costly-to-reverse build-shaping choices: unless the spec or an "### npm:" block already settles it (then ANSWER that value), tag UNKNOWN and surface it. NEVER auto-answer a downgrade to an OLDER major "to avoid breaking changes" from memory — that reasoning is exactly the stale-training-data trap. If an "### npm:" block shows a newer major than your instinct, that block is the live latest; do not silently pin an older major the live data and spec never asked for.
 
 TRIAGE — run these checks IN ORDER first. The REVERSIBILITY TEST below applies ONLY to a question that survives all checks as a genuine preference.
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.17.5",
+    "version": "0.17.7",
     "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",