@mjasnikovs/pi-task 0.16.4 → 0.16.5

package/dist/task/auto-orchestrator.js

@@ -11,6 +11,7 @@ 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';
@@ -212,6 +213,13 @@ 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 = [];
@@ -224,7 +232,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'))));
+        const qRaw = await deps.runChild('auto-clarify', 'read', prependHint(dupHint, AUTO_CLARIFY_PROMPT(featureForModel, answers.join('\n'), projectState)));
         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) => string;
+export declare const AUTO_CLARIFY_PROMPT: (feature: string, priorQA: string, projectState?: string) => string;
 /**
  * Decompose: output a markdown checkbox list of task titles (one line each).
  */

package/dist/task/auto-prompts.js

@@ -9,16 +9,19 @@
  * when no clarification remains. priorQA carries the questions already answered so
  * each next question adapts to them.
  */
-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.
+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.
 
 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.
+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.
 
 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,3 +17,19 @@ 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,3 +59,40 @@ 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/package.json

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