@mjasnikovs/pi-task 0.16.5 → 0.17.0

package/dist/task/auto-orchestrator.js

@@ -11,7 +11,6 @@ import { runSingleTask } from './orchestrator.js';
 import { parseClarifyList, deriveTitle } from './parsers.js';
 import { renderInlineMarkdown, stripInlineMarkdown } from './inline-markdown.js';
 import { AUTO_CLARIFY_PROMPT, AUTO_DECOMPOSE_PROMPT } from './auto-prompts.js';
-import { getProjectSnapshot } from './file-inventory.js';
 import { isDuplicateQuestion, MAX_DUP_STRIKES, DUP_REPROMPT_HINT } from './question-dedup.js';
 import { allocateAutoId, buildAutoBody, parseDecomposeList, parseTaskList, checkOffTask, stampTaskInProgress, findResumableAuto } from './auto-io.js';
 import { writeTaskFile, readTaskFile, updateTaskFrontMatter, taskFilePath, tasksDir } from './task-io.js';
@@ -213,13 +212,6 @@ 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(', ')}`);
     }
-    // Factual snapshot of the target directory (root files + top-level dirs).
-    // Clarify only "may" read the repo; a model that skips the read assumes a
-    // greenfield project and recommends bootstrapping config/manifest files that
-    // already exist (or invents a path like /workspace). Handing it the facts
-    // up front removes the guess. '' for a non-git/empty tree ⇒ prompt omits the
-    // block and the model correctly treats the target as greenfield.
-    const projectState = await getProjectSnapshot(cwd);
     const answers = [];
     // Plain text of every question already shown, for the duplicate backstop.
     const askedQuestions = [];
@@ -232,7 +224,7 @@ export async function planAuto(ctx, cwd, feature, deps) {
     // Open-ended: keep asking until the model emits NONE or the user dismisses —
     // but never past MAX_CLARIFY_QUESTIONS distinct questions.
     while (askedQuestions.length < MAX_CLARIFY_QUESTIONS) {
-        const qRaw = await deps.runChild('auto-clarify', 'read', prependHint(dupHint, AUTO_CLARIFY_PROMPT(featureForModel, answers.join('\n'), projectState)));
+        const qRaw = await deps.runChild('auto-clarify', 'read', prependHint(dupHint, AUTO_CLARIFY_PROMPT(featureForModel, answers.join('\n'))));
         const parsed = parseClarifyList(qRaw);
         if (parsed.length === 0)
             break; // NONE / nothing left to ask

package/dist/task/auto-prompts.d.ts

@@ -9,7 +9,7 @@
  * when no clarification remains. priorQA carries the questions already answered so
  * each next question adapts to them.
  */
-export declare const AUTO_CLARIFY_PROMPT: (feature: string, priorQA: string, projectState?: string) => string;
+export declare const AUTO_CLARIFY_PROMPT: (feature: string, priorQA: string) => string;
 /**
  * Decompose: output a markdown checkbox list of task titles (one line each).
  */

package/dist/task/auto-prompts.js

@@ -9,19 +9,16 @@
  * when no clarification remains. priorQA carries the questions already answered so
  * each next question adapts to them.
  */
-export const AUTO_CLARIFY_PROMPT = (feature, priorQA, projectState = '') => `You are planning how to split a feature into separate implementation tasks, one clarifying question at a time.
+export const AUTO_CLARIFY_PROMPT = (feature, priorQA) => `You are planning how to split a feature into separate implementation tasks, one clarifying question at a time.
 
 FEATURE REQUEST:
 ${feature.trim()}
 
 ANSWERS SO FAR:
 ${priorQA.trim() || '(none yet)'}
-${projectState.trim() ? `\n${projectState.trim()}\n` : ''}
+
 You may use the read tool to inspect the repo and any referenced docs so your
-question and recommendation are grounded in what already exists. When a PROJECT
-STATE snapshot is given above, trust it: never assume an empty or greenfield
-project, never invent directory paths, and never recommend creating files it
-already lists — at most propose updating them.
+question and recommendation are grounded in what already exists.
 
 Output the SINGLE most important clarifying question that REMAINS — the one whose
 answer would most change HOW this feature is split into tasks (scope boundaries,

package/dist/task/file-inventory.d.ts

@@ -17,19 +17,3 @@ export declare function stripTasksDir(raw: string): string;
 /** Cap output to maxLines real (non-blank) paths; tag truncation when cut. */
 export declare function capInventory(raw: string, maxLines?: number): string;
 export declare function getFileInventory(cwd: string, signal?: AbortSignal, maxLines?: number): Promise<string>;
-/**
- * Derive a compact PROJECT STATE block (root-level files + top-level directories)
- * from a raw `git ls-files` listing. Pure/testable; `getProjectSnapshot` wires it
- * to the live repo. Returns '' when there is nothing tracked so the caller omits
- * the block entirely (and the model is then correctly free to treat the target as
- * an empty/greenfield project).
- */
-export declare function formatProjectSnapshot(raw: string): string;
-/**
- * Live PROJECT STATE snapshot for the planning phase. Clarify otherwise only
- * "may" read the repo; a weak model that skips the read then assumes a greenfield
- * project and recommends creating package.json/tsconfig from scratch — or invents
- * a path like /workspace — even when those configs already exist on disk. Handing
- * it the facts up front removes the guess. Empty (non-git / nothing tracked) ⇒ ''.
- */
-export declare function getProjectSnapshot(cwd: string, signal?: AbortSignal): Promise<string>;

package/dist/task/file-inventory.js

@@ -59,40 +59,3 @@ export async function getFileInventory(cwd, signal, maxLines = DEFAULT_MAX_LINES
         return '';
     return capInventory(stripTasksDir(raw), maxLines);
 }
-/**
- * Derive a compact PROJECT STATE block (root-level files + top-level directories)
- * from a raw `git ls-files` listing. Pure/testable; `getProjectSnapshot` wires it
- * to the live repo. Returns '' when there is nothing tracked so the caller omits
- * the block entirely (and the model is then correctly free to treat the target as
- * an empty/greenfield project).
- */
-export function formatProjectSnapshot(raw) {
-    const lines = stripTasksDir(raw)
-        .split('\n')
-        .map(l => l.trim())
-        .filter(l => l.length > 0);
-    const rootFiles = [...new Set(lines.filter(l => !l.includes('/')))].sort();
-    const dirs = [...new Set(lines.filter(l => l.includes('/')).map(l => l.split('/')[0]))].sort();
-    if (rootFiles.length === 0 && dirs.length === 0)
-        return '';
-    return ('EXISTING PROJECT STATE (a factual snapshot of the target directory — trust it over '
-        + 'assumptions: do NOT assume an empty or greenfield project, do NOT invent directory '
-        + 'paths, and do NOT propose creating files that already exist. Treat the config/manifest '
-        + "files listed here as the project's established setup unless the request explicitly says "
-        + 'to replace them):\n'
-        + `Root files: ${rootFiles.join(', ') || '(none)'}\n`
-        + `Top-level directories: ${dirs.join(', ') || '(none)'}`);
-}
-/**
- * Live PROJECT STATE snapshot for the planning phase. Clarify otherwise only
- * "may" read the repo; a weak model that skips the read then assumes a greenfield
- * project and recommends creating package.json/tsconfig from scratch — or invents
- * a path like /workspace — even when those configs already exist on disk. Handing
- * it the facts up front removes the guess. Empty (non-git / nothing tracked) ⇒ ''.
- */
-export async function getProjectSnapshot(cwd, signal) {
-    const raw = await runGitLsFiles(cwd, signal);
-    if (!raw)
-        return '';
-    return formatProjectSnapshot(raw);
-}

package/dist/task/phases.d.ts

@@ -42,6 +42,14 @@ export interface PhaseConfig {
 export declare function extractToolingCommands(research: string): string[] | null;
 /** Replace the TOOLING section in a research string with a VERIFIED-TOOLING section. */
 export declare function replaceToolingWithVerified(research: string, verifiedCommands: string[]): string;
+/**
+ * Manifest + config content (orientation tiers 0–1) for refine, with the preserve
+ * directive. Reuses the SAME orientation machinery research feeds its workers — not
+ * a parallel reader — scoped to the "accumulative" files a from-scratch rewrite
+ * silently destroys. '' (non-git/empty/orientation-off) leaves refine unchanged, so
+ * a genuinely greenfield task is still free to create.
+ */
+export declare function refineExistingFilesBlock(deps: PhaseDeps): Promise<string>;
 export declare const phaseRefine: (deps: PhaseDeps, raw: string, planContext?: string) => Promise<string>;
 export declare function phaseVerifyTooling(deps: PhaseDeps, research: string): Promise<string>;
 export interface PhaseResearchDeps extends ExternalContextDeps {

package/dist/task/phases.js

@@ -11,7 +11,7 @@ import { search as defaultSearch } from '../workers/search-core.js';
 import { extractEnrichTargets } from './enrichment.js';
 import { isIntegrationUnknown } from './unknown-routing.js';
 import { getFileInventory } from './file-inventory.js';
-import { buildOrientation } from './orientation.js';
+import { buildOrientation, orientationTier } from './orientation.js';
 import { getConfig } from '../config/config.js';
 import { readFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
@@ -63,15 +63,67 @@ export function replaceToolingWithVerified(research, verifiedCommands) {
     return replaced;
 }
 // ─── Phase functions ─────────────────────────────────────────────────────────
-export const phaseRefine = (deps, raw, planContext) => runPhaseWithLoopGuard(deps, 'refine', 'read', hint => prependHint(hint, appendNoThink(REFINE_PROMPT(raw, planContext))), 
-// refine's deliverable is a 4-section text rewrite that never strictly
-// needs a successful read — on a test-writing task against a large
-// existing codebase the model over-explores (re-reads source hunting for
-// the impl) and burns the loop budget. Degrade to a no-tools final
-// attempt instead of hard-failing the whole run. See TASK_0016 (mx5):
-// refine looped 3×/resume forever; the deliverable was always producible
-// from the title + design doc alone.
-{ degradeOnExhaustion: true });
+// Authoritative directive that travels with the refine orientation block. Refine
+// runs BEFORE research, so on a "Scaffold project with package.json…" title it has
+// no signal the file already exists and authors greenfield strip-constraints
+// ("bun-plugin-tailwind the only dependency", "exactly N scripts") that compose
+// then obeys over the research facts — the implementer executes a wholesale
+// rewrite that drops every existing dependency and script (mx5 TASK_0001 emptied
+// package.json; the REAL pipeline reproduced it 3/3 even with research surfacing
+// the deps). Handing refine the manifest/config CONTENT up front, with this
+// reframe, fixes it at the origin (A/B: 1/5 → 5/5 preserve, 5/5 end-to-end).
+const REFINE_PRESERVE_DIRECTIVE = 'EXISTING FILES ON DISK — AUTHORITATIVE (overrides any "scaffold / create / set '
+    + 'up / initialize / from scratch / only / exactly / minimal" wording in the task '
+    + 'below): the files shown in the PROJECT ORIENTATION block ALREADY EXIST. When '
+    + 'the task says to scaffold, create, set up, initialize, or configure a file that '
+    + 'already exists, your GOAL and CONSTRAINTS MUST frame it as an in-place UPDATE '
+    + 'that PRESERVES every existing dependency, devDependency, script, field, and '
+    + "compiler option — adding or changing only the task's explicit delta. Do NOT "
+    + 'author any constraint that empties, reduces to a fixed/minimal set, renames, '
+    + 'recreates, or drops existing entries (no "X is the only dependency", no '
+    + '"exactly N scripts", no "produce exactly N files from scratch"). An existing '
+    + 'entry is NEVER scope drift and is never removed because it "belongs to a later step".';
+/**
+ * Manifest + config content (orientation tiers 0–1) for refine, with the preserve
+ * directive. Reuses the SAME orientation machinery research feeds its workers — not
+ * a parallel reader — scoped to the "accumulative" files a from-scratch rewrite
+ * silently destroys. '' (non-git/empty/orientation-off) leaves refine unchanged, so
+ * a genuinely greenfield task is still free to create.
+ */
+export async function refineExistingFilesBlock(deps) {
+    if (!getConfig().orientation)
+        return '';
+    const inventoryRaw = await getFileInventory(deps.cwd, deps.signal).catch(() => '');
+    if (inventoryRaw.length === 0)
+        return '';
+    const paths = inventoryRaw
+        .split('\n')
+        .map(l => l.trim())
+        .filter(l => l.length > 0 && (orientationTier(l) === 0 || orientationTier(l) === 1));
+    if (paths.length === 0)
+        return '';
+    const { block } = await buildOrientation(paths, async (p) => {
+        try {
+            return await readFile(resolve(deps.cwd, p), 'utf8');
+        }
+        catch {
+            return null;
+        }
+    });
+    return block.trim().length === 0 ? '' : `${REFINE_PRESERVE_DIRECTIVE}\n\n${block.trim()}`;
+}
+export const phaseRefine = async (deps, raw, planContext) => {
+    const existingFiles = await refineExistingFilesBlock(deps).catch(() => '');
+    return runPhaseWithLoopGuard(deps, 'refine', 'read', hint => prependHint(hint, appendNoThink(REFINE_PROMPT(raw, planContext, existingFiles))), 
+    // refine's deliverable is a 4-section text rewrite that never strictly
+    // needs a successful read — on a test-writing task against a large
+    // existing codebase the model over-explores (re-reads source hunting for
+    // the impl) and burns the loop budget. Degrade to a no-tools final
+    // attempt instead of hard-failing the whole run. See TASK_0016 (mx5):
+    // refine looped 3×/resume forever; the deliverable was always producible
+    // from the title + design doc alone.
+    { degradeOnExhaustion: true });
+};
 export async function phaseVerifyTooling(deps, research) {
     const commands = extractToolingCommands(research);
     if (!commands || commands.length === 0) {

package/dist/task/prompts.d.ts

@@ -47,7 +47,7 @@ export declare const COMPRESS_LABEL_PROMPT: (title: string, maxChars: number) =>
  * "Scaffold …" title re-expands the entire design into one task (validated: a real
  * /task-auto run implemented all 24 steps under step 1).
  */
-declare const REFINE_PROMPT: (raw: string, planContext?: string) => string;
+declare const REFINE_PROMPT: (raw: string, planContext?: string, existingFiles?: string) => string;
 declare const RESEARCH_READ_ONLY_CONSTRAINT = "IMPORTANT: You are ONLY allowed to READ. Do NOT create, modify, or delete any files. Use the read, grep, find, and ls tools to inspect the repo.";
 declare const RESEARCH_FILES_PROMPT: (refined: string) => string;
 declare const RESEARCH_APIS_PROMPT: (refined: string) => string;

package/dist/task/prompts.js

@@ -61,7 +61,7 @@ ${title}`;
  * "Scaffold …" title re-expands the entire design into one task (validated: a real
  * /task-auto run implemented all 24 steps under step 1).
  */
-const REFINE_PROMPT = (raw, planContext) => `${planContext ? planContext + '\n\n---\n\n' : ''}You receive a user's task description for an AI coding agent. Rewrite it to be unambiguous and actionable.
+const REFINE_PROMPT = (raw, planContext, existingFiles) => `${planContext ? planContext + '\n\n---\n\n' : ''}You receive a user's task description for an AI coding agent. Rewrite it to be unambiguous and actionable.
 
 Output structure (four sections, exact headings, in this order):
 
@@ -87,7 +87,7 @@ Rules:
 - Do not invent requirements not implied by the input.
 - If the task references a design/spec document (an @-path or a named spec file), READ it and treat it as authoritative. Carry its concrete schema verbatim into GOAL/CONSTRAINTS — table and column names, types, endpoint methods and paths, enum values. The task title is only a pointer into that spec: where the title and the spec disagree, follow the spec, and never introduce a table, column, endpoint, or dependency the spec does not define.
 - Do not output any preamble, commentary, or markdown headings beyond the four sections above.
-
+${existingFiles && existingFiles.trim() ? `\n${existingFiles.trim()}\n` : ''}
 Task: ${raw}`;
 // ─── Research fan-out prompts ─────────────────────────────────────────────────
 const RESEARCH_READ_ONLY_CONSTRAINT = `IMPORTANT: You are ONLY allowed to READ. Do NOT create, modify, or delete any files. Use the read, grep, find, and ls tools to inspect the repo.`;

package/package.json

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