gsd-pi 2.80.0-dev.cf9433f56 → 2.80.0-dev.d4fc28e6b

package/dist/resources/extensions/gsd/parallel-orchestrator.js

@@ -12,7 +12,7 @@ import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { gsdRoot } from "./paths.js";
 import { createWorktree, worktreePath } from "./worktree-manager.js";
-import { autoWorktreeBranch, runWorktreePostCreateHook, syncGsdStateToWorktree } from "./auto-worktree.js";
+import { autoWorktreeBranch, fastForwardReusedMilestoneBranchIfSafe, runWorktreePostCreateHook, syncGsdStateToWorktree } from "./auto-worktree.js";
 import { nativeBranchExists } from "./native-git-bridge.js";
 import { readIntegrationBranch } from "./git-service.js";
 import { resolveParallelConfig } from "./preferences.js";
@@ -368,7 +368,7 @@ export async function startParallel(basePath, milestoneIds, prefs) {
             // Create the worktree (without chdir — coordinator stays in project root)
             let wtPath;
             try {
-                wtPath = createMilestoneWorktree(basePath, mid);
+                wtPath = _createMilestoneWorktree(basePath, mid);
             }
             catch (e) {
                 logWarning("parallel", `createMilestoneWorktree fallback for ${mid}: ${e.message}`);
@@ -421,12 +421,22 @@ export async function startParallel(basePath, milestoneIds, prefs) {
 /**
  * Create a git worktree for a milestone without changing the coordinator's cwd.
  * Uses milestone/<MID> branch naming (same as auto-worktree.ts).
+ *
+ * Exported with the `_` prefix purely for tests — production callers stay on
+ * the closure-private name `createMilestoneWorktree` below.
  */
-function createMilestoneWorktree(basePath, milestoneId) {
+export function _createMilestoneWorktree(basePath, milestoneId) {
     const branch = autoWorktreeBranch(milestoneId);
     const branchExists = nativeBranchExists(basePath, branch);
     let info;
     if (branchExists) {
+        // #5549 post-merge audit (R3): match the fast-forward behavior added to
+        // `createAutoWorktree` in commit 8996cb68e. When a worker reuses an
+        // existing milestone branch, fast-forward it onto the integration branch
+        // when safe so per-worker worktrees don't fork from a stale base after a
+        // sibling milestone has merged. Same `nativeIsAncestor` + worktree-list
+        // safety guards apply.
+        fastForwardReusedMilestoneBranchIfSafe(basePath, milestoneId, branch);
         info = createWorktree(basePath, milestoneId, { branch, reuseExistingBranch: true });
     }
     else {

package/dist/resources/extensions/gsd/pre-execution-checks.js

@@ -391,6 +391,15 @@ function getExpectedOutputsUpTo(tasks, taskIndex) {
  */
 export function checkFilePathConsistency(tasks, basePath) {
     const results = [];
+    // Build a set of all files created by any task at any position (normalized).
+    // Used to suppress consistency errors for files that will be caught with a
+    // more precise message by checkTaskOrdering (sequence violation).
+    const allTaskOutputs = new Set();
+    for (const t of tasks) {
+        for (const f of t.expected_output) {
+            allTaskOutputs.add(normalizeFilePath(f));
+        }
+    }
     for (let i = 0; i < tasks.length; i++) {
         const task = tasks[i];
         const priorOutputs = getExpectedOutputsUpTo(tasks, i);
@@ -421,6 +430,12 @@ export function checkFilePathConsistency(tasks, basePath) {
                         anyOutputUnderDirectory(normalizedFile, ownOutputs);
             }
             if (!existsOnDisk && !inPriorOutputs && !inOwnOutputs && !directorySatisfied) {
+                // If a later task claims to create this file, the ordering check will
+                // fire a more precise "sequence violation" error for the same file.
+                // Suppress the consistency error here to avoid duplicate noise.
+                if (allTaskOutputs.has(normalizedFile) && !ownOutputs.has(normalizedFile)) {
+                    continue;
+                }
                 results.push({
                     category: "file",
                     target: file,

package/dist/resources/extensions/gsd/prompts/complete-milestone.md

@@ -6,6 +6,8 @@ You are executing GSD auto-mode.
 
 Your working directory is `{{workingDirectory}}`. All file reads, writes, and shell commands MUST operate relative to this directory. Do NOT `cd` to any other directory.
 
+If any inlined plan, summary, verification command, or prior artifact names an absolute path outside `{{workingDirectory}}`, treat that path as stale context. Convert it to the equivalent relative path under `{{workingDirectory}}` before reading, writing, or executing. If no equivalent path exists under `{{workingDirectory}}`, record a verification failure and stop; do not edit or run commands in another checkout.
+
 ## Mission
 
 All slices are complete. Verify the integrated work, persist milestone completion, refresh project state, and write the final record future milestones will rely on.

package/dist/resources/extensions/gsd/prompts/complete-slice.md

@@ -29,7 +29,7 @@ Use `subagent` only for fresh-context review when useful: reviewer for cross-cut
 7. If requirement status changed, call `gsd_requirement_update`; do not write `.gsd/REQUIREMENTS.md` directly.
 8. Prepare `gsd_slice_complete` content with camelCase fields `milestoneId`, `sliceId`, `sliceTitle`, `oneLiner`, `narrative`, `verification`, and `uatContent`.
 9. Draft concrete UAT with preconditions, numbered steps, expected outcomes, edge cases, UAT Type, and Not Proven By This UAT.
-10. Review task summaries for DECISIONS.md and KNOWLEDGE.md-worthy decisions, patterns, and gotchas. Capture significant items with `capture_thought`; do not append knowledge files directly.
+10. Review the inlined task-summary excerpts for DECISIONS.md and KNOWLEDGE.md-worthy decisions, patterns, and gotchas. Read full `*-SUMMARY.md` files only when an excerpt is absent, truncated, or lacks the specific evidence needed for the slice narrative. Capture significant items with `capture_thought`; do not append knowledge files directly.
 11. Call `gsd_slice_complete`. The DB-backed tool is the canonical write path. Do **not** manually write `{{sliceSummaryPath}}`. Do **not** manually write `{{sliceUatPath}}`. Do not edit roadmap checkboxes; the tool renders files and updates projections.
 12. Do not run git commands.
 13. Update `.gsd/PROJECT.md` with a full `write` only if the current project state needs refresh.

package/dist/resources/extensions/gsd/prompts/execute-task.md

@@ -33,7 +33,7 @@ You execute. The inlined task plan is authoritative. Verify referenced files and
 ## Execution Rules
 
 1. Tersely narrate transitions, decisions, and verification outcomes between tool-call clusters.
-2. Call `memory_query` with 2-4 keywords from the task title and touched files unless this is purely mechanical.
+2. Use the injected memory/context blocks first. Call `memory_query` with 2-4 keywords from the task title and touched files only when no injected memory block exists or the inlined memory/context is insufficient for this task.
 3. {{skillActivation}} Follow activated skills before code edits.
 4. Execute the task plan. Before any `Write` that creates an artifact or output file, check whether that path already exists. If it does, read it first and decide whether the work is already done, should be extended, or truly needs replacement.
 5. Build real behavior through the intended surface; stubs/mocks belong in tests only.
@@ -59,11 +59,13 @@ Keep about **{{verificationBudget}}** for verification and summary. If context i
 - If the plan is fundamentally invalid, set `blocker_discovered: true` in the summary and explain.
 - For downstream-impacting ambiguity that cannot be resolved from code, plans, or decisions, include an `escalation` object with question, options, recommendation, rationale, and `continueWithDefault`.
 - Capture meaningful architecture/pattern/observability decisions with `capture_thought`; capture non-obvious gotchas or conventions only when they save future investigation.
-- Read the template at `{{taskSummaryTemplatePath}}`.
+- Use the inlined Task Summary template below. Read `{{taskSummaryTemplatePath}}` only if the inlined template is absent or visibly truncated.
 - Call `gsd_task_complete` with camelCase fields `milestoneId`, `sliceId`, `taskId`, `oneLiner`, `narrative`, `verification`, and `verificationEvidence`.
 - The DB-backed tool is the canonical write path. Do **not** manually write `{{taskSummaryPath}}` or edit PLAN.md checkboxes; the tool renders the summary and updates state.
 - Do not run git commands; the system commits from your summary.
 
+{{inlinedTemplates}}
+
 **Autonomous execution:** no human is available. Do not call `ask_user_questions` or `secure_env_collect`; make reasonable assumptions and document them.
 
 **You MUST call `gsd_task_complete` before finishing.**

package/dist/resources/extensions/gsd/prompts/plan-slice.md

@@ -39,7 +39,7 @@ If slice research is inlined, trust it. Explore enough code to confirm paths, bo
 5. Define slice verification before tasks. Non-trivial slices need real tests or executable assertions; boundary contracts need contract-exercising checks. Tests must not read .gitignore/gitignored paths such as `.gsd/`, `.planning/`, or `.audits/`.
 6. Include Threat Surface (Q3), Requirement Impact (Q4), proof level, observability, integration closure, Failure Modes (Q5), Load Profile (Q6), and Negative Tests (Q7) only where applicable.
 7. Right-size tasks. Simple slices can be one task; split only when context, ownership, or verification boundaries justify it.
-8. Each task needs a concrete title, Why / Files / Do / Verify / Done when, plus task-plan description, steps, must-haves, verification, inputs, and expected output. Inputs and Expected Output must include concrete backtick-wrapped paths; each task needs at least one output path. Use paths relative to `{{workingDirectory}}`; do not put absolute paths to the original checkout or any directory outside `{{workingDirectory}}` in `files`, `inputs`, `expectedOutput`, or verification commands.
+8. Each task needs a concrete title, Why / Files / Do / Verify / Done when, plus task-plan description, steps, must-haves, verification, inputs, and expected output. Inputs and Expected Output must include concrete backtick-wrapped paths. Use paths relative to `{{workingDirectory}}`; do not put absolute paths to the original checkout or any directory outside `{{workingDirectory}}` in `files`, `inputs`, `expectedOutput`, or verification commands. **`expected_output` must only list files the task actually creates or overwrites on disk.** Do NOT include files the task merely reads, verifies, or tests — those belong only in `inputs`. If a task is a pure verification or test task that produces no new files, its `expected_output` may be empty or limited to test-result artifacts (e.g. a log or assertion output). A file that does not yet exist on disk and is needed as an `input` must be produced by an earlier task's `expected_output` — if no prior task creates it, add a task before this one that does.
 9. Persist with `gsd_plan_slice` using goal, successCriteria, optional proofLevel/integrationClosure/observabilityImpact, and tasks. `gsd_plan_slice` handles task persistence transactionally and renders `{{outputPath}}` plus task plans; do not call `gsd_plan_task`. The DB-backed tool is the canonical write path. Do **not** rely on direct `PLAN.md` writes as the source of truth.
 10. Self-audit before finishing: goal/demo closure, requirement coverage, locked decisions, concrete paths, dependency order, wiring, scope size, proof truthfulness, feature completeness, and quality gates. Quality gates: non-trivial slices/tasks include specific Q3-Q7 coverage where applicable.
 11. If planning creates structural decisions, append them to `.gsd/DECISIONS.md`.

package/dist/resources/extensions/gsd/prompts/replan-slice.md

@@ -8,7 +8,7 @@ Your working directory is `{{workingDirectory}}`. All file reads, writes, and sh
 
 A completed task reported `blocker_discovered: true`, meaning the current slice plan cannot be executed as-is. Your job is to rewrite the remaining tasks in the slice plan to address the blocker while preserving all completed work.
 
-All relevant context has been preloaded below — the roadmap, current slice plan, the blocker task summary, and decisions are inlined. Start working immediately without re-reading these files.
+All relevant context has been preloaded below — the roadmap, current slice plan, blocker task summary excerpt, and decisions are inlined. Start working immediately without re-reading these files.
 
 {{inlinedContext}}
 
@@ -30,7 +30,7 @@ Consider these captures when rewriting the remaining tasks — they represent th
 
 ## Instructions
 
-1. Read the blocker task summary carefully. Understand exactly what was discovered and why it blocks the current plan.
+1. Use the inlined blocker summary excerpt first. Read the full blocker task summary only if the excerpt is absent, marked truncated, or lacks the specific blocker evidence needed to replan.
 2. Analyze the remaining `[ ]` tasks in the slice plan. Determine which are still valid, which need modification, and which should be replaced.
 3. **Persist replan state through `gsd_replan_slice`.** Call it with: `milestoneId`, `sliceId`, `blockerTaskId`, `blockerDescription`, `whatChanged`, `updatedTasks` (array of task objects with taskId, title, description, estimate, files, verify, inputs, expectedOutput), `removedTaskIds` (array of task ID strings). The tool structurally enforces preservation of completed tasks, writes replan history to the DB, re-renders `{{planPath}}`, and renders `{{replanPath}}`. Preserve or update the Threat Surface and Requirement Impact sections if the replan changes the slice's security posture or requirement coverage.
 4. If any incomplete task had a `T0x-PLAN.md`, remove or rewrite it to match the new task description.

package/dist/resources/extensions/gsd/workflow-protocol.js

@@ -0,0 +1,131 @@
+// Project/App: GSD-2
+// File Purpose: Shared capped workflow protocol and doctor-heal prompt payload helpers.
+const DEFAULT_WORKFLOW_PROTOCOL_EXCERPT_CHARS = 4_000;
+const MIN_WORKFLOW_PROTOCOL_EXCERPT_CHARS = 1_000;
+const DEFAULT_DOCTOR_SUMMARY_CHARS = 2_400;
+const DEFAULT_DOCTOR_ISSUE_CHARS = 300;
+const DEFAULT_DOCTOR_MAX_ISSUES = 12;
+const DEFAULT_DOCTOR_ISSUES_CHARS = 4_000;
+export function buildWorkflowProtocolExcerpt(workflow, workflowPath, opts = {}) {
+    const limit = opts.maxChars ?? getWorkflowProtocolExcerptLimit();
+    const trimmed = workflow.trim();
+    const excerpt = buildPrioritizedWorkflowExcerpt(trimmed, limit);
+    const truncated = trimmed.length > limit;
+    const lines = [
+        "## GSD Workflow Protocol Excerpt",
+        `Source: \`${workflowPath}\``,
+        "",
+        excerpt,
+    ];
+    if (truncated) {
+        lines.push("", "[Workflow Protocol Truncated]", "The full workflow protocol remains available at the source path above. Read it only if this excerpt lacks a rule required for the dispatched task.");
+    }
+    return lines.join("\n");
+}
+export function buildWorkflowDispatchContent(opts) {
+    return [
+        "Read the following GSD workflow protocol excerpt and execute exactly. Use the source path for a full protocol read only if the excerpt lacks a required rule.",
+        "",
+        buildWorkflowProtocolExcerpt(opts.workflow, opts.workflowPath, { maxChars: opts.maxProtocolChars }),
+        "",
+        "## Your Task",
+        "",
+        opts.task.trim(),
+    ].join("\n");
+}
+export function buildDoctorHealSummary(reportText, opts = {}) {
+    const limit = opts.maxChars ?? DEFAULT_DOCTOR_SUMMARY_CHARS;
+    const lines = reportText.split(/\r?\n/).map((line) => line.trimEnd());
+    const summaryLines = lines.filter((line) => line.length > 0 && (/^#/.test(line) ||
+        /^(scope|status|summary|checks?|errors?|warnings?|fixes?|issues?)\b/i.test(line) ||
+        /doctor/i.test(line)));
+    const selected = summaryLines.length > 0 ? summaryLines : lines.filter((line) => line.trim()).slice(0, 24);
+    return capText(selected.join("\n"), limit, "Full doctor report is available in the command output; use the structured issue list below for repairs.");
+}
+export function buildDoctorHealIssuePayload(structuredIssues, opts = {}) {
+    const maxIssues = opts.maxIssues ?? DEFAULT_DOCTOR_MAX_ISSUES;
+    const maxIssueChars = opts.maxIssueChars ?? DEFAULT_DOCTOR_ISSUE_CHARS;
+    const maxChars = opts.maxChars ?? DEFAULT_DOCTOR_ISSUES_CHARS;
+    const blocks = splitIssueBlocks(structuredIssues);
+    const topBlocks = blocks.slice(0, maxIssues).map((block) => capText(block, maxIssueChars, "Issue details truncated; inspect the relevant artifact before editing."));
+    if (blocks.length > maxIssues) {
+        topBlocks.push(`[${blocks.length - maxIssues} additional actionable issue(s) omitted from prompt. Re-run /gsd doctor heal after this repair pass.]`);
+    }
+    return capText(topBlocks.join("\n\n"), maxChars, "Structured issue list truncated; repair top actionable issues first and re-run doctor heal.");
+}
+function getWorkflowProtocolExcerptLimit() {
+    const raw = process.env.PI_GSD_WORKFLOW_PROTOCOL_MAX_CHARS;
+    if (!raw)
+        return DEFAULT_WORKFLOW_PROTOCOL_EXCERPT_CHARS;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed < MIN_WORKFLOW_PROTOCOL_EXCERPT_CHARS) {
+        return DEFAULT_WORKFLOW_PROTOCOL_EXCERPT_CHARS;
+    }
+    return Math.floor(parsed);
+}
+function buildPrioritizedWorkflowExcerpt(workflow, limit) {
+    if (workflow.length <= limit)
+        return workflow;
+    const sections = splitMarkdownSections(workflow);
+    const wanted = [
+        /^# /,
+        /^## Quick Start\b/i,
+        /^## The Hierarchy\b/i,
+        /^## The Phases\b/i,
+        /^### Phase 4: Execute\b/i,
+        /^### Phase 5: Verify\b/i,
+        /^### Observable Truths\b/i,
+        /^### Artifacts\b/i,
+        /^### Key Links\b/i,
+        /^### Phase 6: Summarize\b/i,
+        /^### Phase 7: Advance\b/i,
+    ];
+    const selected = [];
+    const used = new Set();
+    for (const pattern of wanted) {
+        const index = sections.findIndex((section, sectionIndex) => !used.has(sectionIndex) && pattern.test(section.heading));
+        if (index >= 0) {
+            used.add(index);
+            selected.push(sections[index].text);
+        }
+    }
+    const body = selected.length > 0 ? selected.join("\n\n") : workflow;
+    return capText(body, limit, "Workflow protocol excerpt capped; read the source path for omitted details.");
+}
+function splitMarkdownSections(markdown) {
+    const lines = markdown.split(/\r?\n/);
+    const sections = [];
+    let currentHeading = lines[0]?.startsWith("#") ? lines[0] : "# Preamble";
+    let current = [];
+    for (const line of lines) {
+        if (/^#{1,3}\s+/.test(line) && current.length > 0) {
+            sections.push({ heading: currentHeading, text: current.join("\n").trim() });
+            currentHeading = line;
+            current = [line];
+            continue;
+        }
+        if (/^#{1,3}\s+/.test(line))
+            currentHeading = line;
+        current.push(line);
+    }
+    if (current.length > 0) {
+        sections.push({ heading: currentHeading, text: current.join("\n").trim() });
+    }
+    return sections.filter((section) => section.text.length > 0);
+}
+function splitIssueBlocks(structuredIssues) {
+    const trimmed = structuredIssues.trim();
+    if (!trimmed)
+        return ["No structured issue details were provided."];
+    const split = trimmed.split(/\n(?=(?:#{2,6}\s+|\d+\.\s+|- \*\*|- \[[ x]\]))/i)
+        .map((block) => block.trim())
+        .filter(Boolean);
+    return split.length > 0 ? split : [trimmed];
+}
+function capText(text, limit, notice) {
+    if (text.length <= limit)
+        return text;
+    const suffix = `\n\n[Truncated]\n${notice}`;
+    const headBudget = Math.max(0, limit - suffix.length);
+    return `${text.slice(0, headBudget).trimEnd()}${suffix}`;
+}

package/dist/resources/extensions/gsd/worktree-resolver.js

@@ -35,6 +35,14 @@ import { claimMilestoneLease, refreshMilestoneLease, releaseMilestoneLease } fro
 function isSamePath(a, b) {
     return normalizeWorktreePathForCompare(a) === normalizeWorktreePathForCompare(b);
 }
+class UserNotifiedError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.name = "UserNotifiedError";
+        this.cause = cause;
+    }
+}
 // ─── Path Helpers ──────────────────────────────────────────────────────────
 /**
  * Resolve the project root from session path state.
@@ -663,16 +671,35 @@ export class WorktreeResolver {
             const currentBranch = this.deps.getCurrentBranch(this.s.basePath);
             const milestoneBranch = this.deps.autoWorktreeBranch(milestoneId);
             if (currentBranch !== milestoneBranch) {
+                // #5538-followup: previous behavior was to silently `return false`
+                // when HEAD wasn't on the milestone branch — that let the loop
+                // advance with the milestone's commits stranded on the branch (the
+                // exact failure mode reported in the test12345 repro). Attempt
+                // recovery by force-checking-out the milestone branch; if the
+                // checkout fails, throw so the caller pauses auto-mode and the user
+                // sees the failure instead of a silent merge skip.
                 debugLog("WorktreeResolver", {
                     action: "mergeAndExit",
                     milestoneId,
                     mode: "branch",
-                    skipped: true,
-                    reason: "not-on-milestone-branch",
+                    recovery: "checkout-milestone-branch",
                     currentBranch,
                     milestoneBranch,
                 });
-                return false;
+                try {
+                    this.deps.checkoutBranch(this.s.basePath, milestoneBranch);
+                }
+                catch (checkoutErr) {
+                    const checkoutMsg = checkoutErr instanceof Error ? checkoutErr.message : String(checkoutErr);
+                    ctx.notify(`Cannot merge milestone ${milestoneId}: working tree is on ${currentBranch} and checkout to ${milestoneBranch} failed (${checkoutMsg}). Resolve manually and run /gsd auto to resume.`, "error");
+                    throw new UserNotifiedError(checkoutMsg, checkoutErr);
+                }
+                const reverify = this.deps.getCurrentBranch(this.s.basePath);
+                if (reverify !== milestoneBranch) {
+                    const reverifyMsg = `branch checkout to ${milestoneBranch} reported success but current branch is ${reverify}`;
+                    ctx.notify(`Cannot merge milestone ${milestoneId}: ${reverifyMsg}. Resolve manually and run /gsd auto to resume.`, "error");
+                    throw new UserNotifiedError(reverifyMsg);
+                }
             }
             const roadmapPath = this.deps.resolveMilestoneFile(this.s.basePath, milestoneId, "ROADMAP");
             if (!roadmapPath) {
@@ -713,7 +740,9 @@ export class WorktreeResolver {
                 result: "error",
                 error: msg,
             });
-            ctx.notify(`Milestone merge failed (branch mode): ${msg}`, "warning");
+            if (!(err instanceof UserNotifiedError)) {
+                ctx.notify(`Milestone merge failed (branch mode): ${msg}`, "warning");
+            }
             // Re-throw all errors so callers can apply their own recovery logic (#4380).
             throw err;
         }
@@ -736,6 +765,8 @@ export class WorktreeResolver {
             this.mergeAndExit(currentMilestoneId, ctx);
         }
         catch (err) {
+            if (err instanceof UserNotifiedError)
+                throw err;
             // mergeAndExit emits a warning and restores state when it fails during
             // merge/cleanup. But if it throws before recovery runs (e.g., in
             // validateMilestoneId or emitJournalEvent), basePath won't be restored