gsd-pi 2.22.0 → 2.23.0

package/dist/resources/extensions/gsd/commands.ts

@@ -14,7 +14,7 @@ import { deriveState } from "./state.js";
 import { GSDDashboardOverlay } from "./dashboard-overlay.js";
 import { GSDVisualizerOverlay } from "./visualizer-overlay.js";
 import { showQueue, showDiscuss } from "./guided-flow.js";
-import { startAuto, stopAuto, pauseAuto, isAutoActive, isAutoPaused, isStepMode, stopAutoRemote } from "./auto.js";
+import { startAuto, stopAuto, pauseAuto, isAutoActive, isAutoPaused, isStepMode, stopAutoRemote, dispatchDirectPhase } from "./auto.js";
 import { resolveProjectRoot } from "./worktree.js";
 import { appendCapture, hasPendingCaptures, loadPendingCaptures } from "./captures.js";
 import {
@@ -69,11 +69,11 @@ function projectRoot(): string {
 
 export function registerGSDCommand(pi: ExtensionAPI): void {
   pi.registerCommand("gsd", {
-    description: "GSD — Get Shit Done: /gsd help|next|auto|stop|pause|status|visualize|queue|quick|capture|triage|history|undo|skip|export|cleanup|mode|prefs|config|hooks|run-hook|skill-health|doctor|forensics|migrate|remote|steer|knowledge",
+    description: "GSD — Get Shit Done: /gsd help|next|auto|stop|pause|status|visualize|queue|quick|capture|triage|dispatch|history|undo|skip|export|cleanup|mode|prefs|config|hooks|run-hook|skill-health|doctor|forensics|migrate|remote|steer|knowledge",
     getArgumentCompletions: (prefix: string) => {
       const subcommands = [
         "help", "next", "auto", "stop", "pause", "status", "visualize", "queue", "quick", "discuss",
-        "capture", "triage",
+        "capture", "triage", "dispatch",
         "history", "undo", "skip", "export", "cleanup", "mode", "prefs",
         "config", "hooks", "run-hook", "skill-health", "doctor", "forensics", "migrate", "remote", "steer", "inspect", "knowledge",
       ];
@@ -165,6 +165,13 @@ export function registerGSDCommand(pi: ExtensionAPI): void {
         return [];
       }
 
+      if (parts[0] === "dispatch" && parts.length <= 2) {
+        const phasePrefix = parts[1] ?? "";
+        return ["research", "plan", "execute", "complete", "reassess", "uat", "replan"]
+          .filter((cmd) => cmd.startsWith(phasePrefix))
+          .map((cmd) => ({ value: `dispatch ${cmd}`, label: cmd }));
+      }
+
       return [];
     },
 
@@ -388,6 +395,16 @@ Examples:
         return;
       }
 
+      if (trimmed === "dispatch" || trimmed.startsWith("dispatch ")) {
+        const phase = trimmed.replace(/^dispatch\s*/, "").trim();
+        if (!phase) {
+          ctx.ui.notify("Usage: /gsd dispatch <phase>  (research|plan|execute|complete|reassess|uat|replan)", "warning");
+          return;
+        }
+        await dispatchDirectPhase(ctx, pi, phase, projectRoot());
+        return;
+      }
+
       if (trimmed === "inspect") {
         await handleInspect(ctx);
         return;

package/dist/resources/extensions/gsd/dashboard-overlay.ts

@@ -319,16 +319,23 @@ export class GSDDashboardOverlay {
     const centered = (content: string) => row(centerLine(content, contentWidth));
 
     const title = th.fg("accent", th.bold("GSD Dashboard"));
+    const isRemote = !!this.dashData.remoteSession;
     const status = this.dashData.active
       ? `${Date.now() % 2000 < 1000 ? th.fg("success", "●") : th.fg("dim", "○")} ${th.fg("success", "AUTO")}`
       : this.dashData.paused
         ? th.fg("warning", "⏸ PAUSED")
-        : th.fg("dim", "idle");
+        : isRemote
+          ? `${Date.now() % 2000 < 1000 ? th.fg("success", "●") : th.fg("dim", "○")} ${th.fg("success", "AUTO")} ${th.fg("dim", `(PID ${this.dashData.remoteSession!.pid})`)}`
+          : th.fg("dim", "idle");
     const worktreeName = getActiveWorktreeName();
     const worktreeTag = worktreeName
       ? `  ${th.fg("warning", `⎇ ${worktreeName}`)}`
       : "";
-    const elapsed = th.fg("dim", formatDuration(this.dashData.elapsed));
+    const elapsed = this.dashData.active || this.dashData.paused
+      ? th.fg("dim", formatDuration(this.dashData.elapsed))
+      : isRemote
+        ? th.fg("dim", `since ${this.dashData.remoteSession!.startedAt.replace("T", " ").slice(0, 19)}`)
+        : "";
     lines.push(row(joinColumns(`${title}  ${status}${worktreeTag}`, elapsed, contentWidth)));
     lines.push(blank());
 
@@ -344,6 +351,13 @@ export class GSDDashboardOverlay {
     } else if (this.dashData.paused) {
       lines.push(row(th.fg("dim", "/gsd auto to resume")));
       lines.push(blank());
+    } else if (isRemote) {
+      const rs = this.dashData.remoteSession!;
+      const unitDisplay = rs.unitType === "starting" || rs.unitType === "resuming"
+        ? rs.unitType
+        : `${unitLabel(rs.unitType)} ${rs.unitId}`;
+      lines.push(row(th.fg("text", `Remote session: ${unitDisplay}`)));
+      lines.push(blank());
     } else {
       lines.push(row(th.fg("dim", "No unit running · /gsd auto to start")));
       lines.push(blank());

package/dist/resources/extensions/gsd/diff-context.ts

@@ -6,7 +6,7 @@
  * Standalone module: only imports node:child_process and node:path.
  */
 
-import { execFileSync } from "node:child_process";
+import { execFileSync, execFile } from "node:child_process";
 import { resolve } from "node:path";
 
 // ─── Types ──────────────────────────────────────────────────────────────────
@@ -32,10 +32,23 @@ const EXEC_OPTS = {
   stdio: ["pipe", "pipe", "pipe"] as ["pipe", "pipe", "pipe"],
 };
 
-function git(args: string[], cwd: string): string {
+/** Synchronous git — used where sequential control flow is required (fallback paths). */
+function gitSync(args: string[], cwd: string): string {
   return execFileSync("git", args, { ...EXEC_OPTS, cwd }).trim();
 }
 
+/** Async git — returns stdout on success, empty string on any error. */
+function gitAsync(args: string[], cwd: string): Promise<string> {
+  return new Promise((resolve) => {
+    execFile(
+      "git",
+      args,
+      { encoding: "utf-8", timeout: 5000, cwd },
+      (err, stdout) => resolve(err ? "" : stdout.trim()),
+    );
+  });
+}
+
 function splitLines(output: string): string[] {
   return output
     .split("\n")
@@ -49,6 +62,8 @@ function splitLines(output: string): string[] {
  * Returns recently-changed file paths, deduplicated and sorted by recency
  * (most recent first). Combines committed diffs, staged changes, and
  * unstaged/untracked files from `git status`.
+ *
+ * The three git queries (log, diff --cached, status) run concurrently.
  */
 export async function getRecentlyChangedFiles(
   cwd: string,
@@ -59,40 +74,23 @@ export async function getRecentlyChangedFiles(
   const dir = resolve(cwd);
 
   try {
-    // 1. Committed changes in the last N commits (or since sinceDays)
-    let committedFiles: string[] = [];
-    try {
-      const days = Math.max(1, Math.floor(Number(sinceDays)));
-      if (!Number.isFinite(days)) throw new Error("invalid sinceDays");
-      const raw = git(["log", "--diff-filter=ACMR", "--name-only", "--pretty=format:", `--since=${days} days ago`], dir);
-      committedFiles = splitLines(raw);
-    } catch {
-      // Fallback: use HEAD~10
-      try {
-        const raw = git(["diff", "--name-only", "HEAD~10"], dir);
-        committedFiles = splitLines(raw);
-      } catch {
-        // Shallow clone or <10 commits — ignore
-      }
-    }
-
-    // 2. Staged changes
-    let stagedFiles: string[] = [];
-    try {
-      const raw = git(["diff", "--cached", "--name-only"], dir);
-      stagedFiles = splitLines(raw);
-    } catch {
-      // ignore
-    }
-
-    // 3. Unstaged / untracked via porcelain status
-    let statusFiles: string[] = [];
-    try {
-      const raw = git(["status", "--porcelain"], dir);
-      statusFiles = splitLines(raw).map((line) => line.slice(3)); // strip XY + space
-    } catch {
-      // ignore
-    }
+    const days = Math.max(1, Math.floor(Number(sinceDays)));
+    if (!Number.isFinite(days)) throw new Error("invalid sinceDays");
+
+    // Run all three queries concurrently — they read independent git state
+    const [logRaw, stagedRaw, statusRaw] = await Promise.all([
+      // 1. Committed changes since N days ago (fallback to HEAD~10 on error)
+      gitAsync(["log", "--diff-filter=ACMR", "--name-only", "--pretty=format:", `--since=${days} days ago`], dir)
+        .then((out) => out || gitAsync(["diff", "--name-only", "HEAD~10"], dir)),
+      // 2. Staged changes
+      gitAsync(["diff", "--cached", "--name-only"], dir),
+      // 3. Unstaged / untracked
+      gitAsync(["status", "--porcelain"], dir),
+    ]);
+
+    const committedFiles = splitLines(logRaw);
+    const stagedFiles = splitLines(stagedRaw);
+    const statusFiles = splitLines(statusRaw).map((line) => line.slice(3)); // strip XY + space
 
     // Deduplicate, preserving insertion order (most-recent-first: status → staged → committed)
     const seen = new Set<string>();
@@ -113,6 +111,9 @@ export async function getRecentlyChangedFiles(
 
 /**
  * Returns richer change metadata: change type and approximate line counts.
+ *
+ * The three git queries (diff --cached --numstat, diff --numstat, status --porcelain)
+ * run concurrently — they read independent git state.
  */
 export async function getChangedFilesWithContext(
   cwd: string,
@@ -120,6 +121,13 @@ export async function getChangedFilesWithContext(
   const dir = resolve(cwd);
 
   try {
+    // Run all three queries concurrently
+    const [cachedNumstat, unstagedNumstat, statusRaw] = await Promise.all([
+      gitAsync(["diff", "--cached", "--numstat"], dir),
+      gitAsync(["diff", "--numstat"], dir),
+      gitAsync(["status", "--porcelain"], dir),
+    ]);
+
     const result: ChangedFileInfo[] = [];
     const seen = new Set<string>();
 
@@ -131,57 +139,42 @@ export async function getChangedFilesWithContext(
     };
 
     // 1. Staged files with numstat
-    try {
-      const numstat = git(["diff", "--cached", "--numstat"], dir);
-      for (const line of splitLines(numstat)) {
-        const [added, deleted, filePath] = line.split("\t");
-        if (!filePath) continue;
-        const lines =
-          added === "-" || deleted === "-"
-            ? undefined
-            : Number(added) + Number(deleted);
-        add({ path: filePath, changeType: "staged", linesChanged: lines });
-      }
-    } catch {
-      // ignore
+    for (const line of splitLines(cachedNumstat)) {
+      const [added, deleted, filePath] = line.split("\t");
+      if (!filePath) continue;
+      const lines =
+        added === "-" || deleted === "-"
+          ? undefined
+          : Number(added) + Number(deleted);
+      add({ path: filePath, changeType: "staged", linesChanged: lines });
     }
 
     // 2. Unstaged modifications with numstat
-    try {
-      const numstat = git(["diff", "--numstat"], dir);
-      for (const line of splitLines(numstat)) {
-        const [added, deleted, filePath] = line.split("\t");
-        if (!filePath) continue;
-        const lines =
-          added === "-" || deleted === "-"
-            ? undefined
-            : Number(added) + Number(deleted);
-        add({ path: filePath, changeType: "modified", linesChanged: lines });
-      }
-    } catch {
-      // ignore
+    for (const line of splitLines(unstagedNumstat)) {
+      const [added, deleted, filePath] = line.split("\t");
+      if (!filePath) continue;
+      const lines =
+        added === "-" || deleted === "-"
+          ? undefined
+          : Number(added) + Number(deleted);
+      add({ path: filePath, changeType: "modified", linesChanged: lines });
     }
 
     // 3. Untracked / deleted from porcelain status
-    try {
-      const raw = git(["status", "--porcelain"], dir);
-      for (const line of splitLines(raw)) {
-        const code = line.slice(0, 2);
-        const filePath = line.slice(3);
-        if (seen.has(filePath)) continue;
-
-        if (code.includes("?")) {
-          add({ path: filePath, changeType: "added" });
-        } else if (code.includes("D")) {
-          add({ path: filePath, changeType: "deleted" });
-        } else if (code.includes("A")) {
-          add({ path: filePath, changeType: "added" });
-        } else {
-          add({ path: filePath, changeType: "modified" });
-        }
+    for (const line of splitLines(statusRaw)) {
+      const code = line.slice(0, 2);
+      const filePath = line.slice(3);
+      if (seen.has(filePath)) continue;
+
+      if (code.includes("?")) {
+        add({ path: filePath, changeType: "added" });
+      } else if (code.includes("D")) {
+        add({ path: filePath, changeType: "deleted" });
+      } else if (code.includes("A")) {
+        add({ path: filePath, changeType: "added" });
+      } else {
+        add({ path: filePath, changeType: "modified" });
       }
-    } catch {
-      // ignore
     }
 
     return result;

package/dist/resources/extensions/gsd/doctor.ts

@@ -41,7 +41,8 @@ export type DoctorIssueCode =
   | "activity_log_bloat"
   | "state_file_stale"
   | "state_file_missing"
-  | "gitignore_missing_patterns";
+  | "gitignore_missing_patterns"
+  | "unresolvable_dependency";
 
 export interface DoctorIssue {
   severity: DoctorSeverity;
@@ -1041,6 +1042,24 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
         });
       }
 
+      // Check for unresolvable dependency IDs — catches range syntax like "S01-S04"
+      // that the parser expanded but that don't match any actual slice in the roadmap.
+      // Also catches plain typos or IDs referencing slices not yet defined.
+      const knownSliceIds = new Set(roadmap.slices.map(s => s.id));
+      for (const dep of slice.depends) {
+        if (!knownSliceIds.has(dep)) {
+          issues.push({
+            severity: "warning",
+            code: "unresolvable_dependency",
+            scope: "slice",
+            unitId,
+            message: `Slice ${unitId} depends on "${dep}" which is not a slice ID in this roadmap. This permanently blocks the slice. Use comma-separated IDs: \`depends:[S01,S02]\``,
+            file: relMilestoneFile(basePath, milestoneId, "ROADMAP"),
+            fixable: false,
+          });
+        }
+      }
+
       const slicePath = resolveSlicePath(basePath, milestoneId, slice.id);
       if (!slicePath) continue;
 

package/dist/resources/extensions/gsd/forensics.ts

@@ -27,6 +27,7 @@ import { isAutoActive } from "./auto.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { gsdRoot } from "./paths.js";
 import { formatDuration } from "./history.js";
+import { getAutoWorktreePath } from "./auto-worktree.js";
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 
@@ -54,6 +55,7 @@ interface ForensicReport {
   basePath: string;
   activeMilestone: string | null;
   activeSlice: string | null;
+  activeWorktree: string | null;
   unitTraces: UnitTrace[];
   metrics: MetricsLedger | null;
   completedKeys: string[];
@@ -143,8 +145,11 @@ async function buildForensicReport(basePath: string): Promise<ForensicReport> {
     activeSlice = state.activeSlice?.id ?? null;
   } catch { /* state derivation failure is non-fatal */ }
 
-  // 2. Scan activity logs (last 5)
-  const unitTraces = scanActivityLogs(basePath);
+  // 1b. Check for active auto-worktree
+  const activeWorktree = activeMilestone ? getAutoWorktreePath(basePath, activeMilestone) : null;
+
+  // 2. Scan activity logs (last 5) — worktree-aware
+  const unitTraces = scanActivityLogs(basePath, activeMilestone);
 
   // 3. Load metrics
   const metrics = loadLedgerFromDisk(basePath);
@@ -178,20 +183,16 @@ async function buildForensicReport(basePath: string): Promise<ForensicReport> {
     }
   }
 
-  // 8. GSD version
-  let gsdVersion = "unknown";
-  try {
-    const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "../../../../package.json");
-    if (existsSync(pkgPath)) {
-      gsdVersion = JSON.parse(readFileSync(pkgPath, "utf-8")).version ?? "unknown";
-    }
-  } catch { /* non-fatal */ }
+  // 8. GSD version — use GSD_VERSION env var set by the loader at startup.
+  // Extensions run from ~/.gsd/agent/extensions/gsd/ at runtime, so path-traversal
+  // from import.meta.url would resolve to ~/package.json (wrong on every system).
+  const gsdVersion = process.env.GSD_VERSION || "unknown";
 
   // 9. Run anomaly detectors
   if (metrics?.units) detectStuckLoops(metrics.units, anomalies);
   if (metrics?.units) detectCostSpikes(metrics.units, anomalies);
   detectTimeouts(unitTraces, anomalies);
-  detectMissingArtifacts(completedKeys, basePath, anomalies);
+  detectMissingArtifacts(completedKeys, basePath, activeMilestone, anomalies);
   detectCrash(crashLock, anomalies);
   detectDoctorIssues(doctorIssues, anomalies);
   detectErrorTraces(unitTraces, anomalies);
@@ -202,6 +203,7 @@ async function buildForensicReport(basePath: string): Promise<ForensicReport> {
     basePath,
     activeMilestone,
     activeSlice,
+    activeWorktree: activeWorktree ? relative(basePath, activeWorktree) : null,
     unitTraces,
     metrics,
     completedKeys,
@@ -216,48 +218,78 @@ async function buildForensicReport(basePath: string): Promise<ForensicReport> {
 
 const ACTIVITY_FILENAME_RE = /^(\d+)-(.+?)-(.+)\.jsonl$/;
 
-function scanActivityLogs(basePath: string): UnitTrace[] {
-  const activityDir = join(gsdRoot(basePath), "activity");
-  if (!existsSync(activityDir)) return [];
-
-  const files = readdirSync(activityDir).filter(f => f.endsWith(".jsonl")).sort();
-  const lastFiles = files.slice(-5);
-  const traces: UnitTrace[] = [];
-
-  for (const file of lastFiles) {
-    const match = ACTIVITY_FILENAME_RE.exec(file);
-    if (!match) continue;
-
-    const seq = parseInt(match[1]!, 10);
-    const unitType = match[2]!;
-    const unitId = match[3]!;
-    const filePath = join(activityDir, file);
-
-    let entries: unknown[] = [];
-    const nativeResult = nativeParseJsonlTail(filePath, MAX_JSONL_BYTES);
-    if (nativeResult) {
-      entries = nativeResult.entries;
-    } else {
-      try {
-        const raw = readFileSync(filePath, "utf-8");
-        entries = parseJSONL(raw);
-      } catch { continue; }
+function scanActivityLogs(basePath: string, activeMilestone?: string | null): UnitTrace[] {
+  const activityDirs = resolveActivityDirs(basePath, activeMilestone);
+  const allTraces: UnitTrace[] = [];
+
+  for (const activityDir of activityDirs) {
+    if (!existsSync(activityDir)) continue;
+
+    const files = readdirSync(activityDir).filter(f => f.endsWith(".jsonl")).sort();
+    const lastFiles = files.slice(-5);
+
+    for (const file of lastFiles) {
+      const match = ACTIVITY_FILENAME_RE.exec(file);
+      if (!match) continue;
+
+      const seq = parseInt(match[1]!, 10);
+      const unitType = match[2]!;
+      const unitId = match[3]!;
+      const filePath = join(activityDir, file);
+
+      let entries: unknown[] = [];
+      const nativeResult = nativeParseJsonlTail(filePath, MAX_JSONL_BYTES);
+      if (nativeResult) {
+        entries = nativeResult.entries;
+      } else {
+        try {
+          const raw = readFileSync(filePath, "utf-8");
+          entries = parseJSONL(raw);
+        } catch { continue; }
+      }
+
+      const trace = extractTrace(entries);
+      const stat = statSync(filePath, { throwIfNoEntry: false });
+
+      allTraces.push({
+        file: activityDirs.length > 1 ? `[${relative(basePath, activityDir)}] ${file}` : file,
+        unitType,
+        unitId,
+        seq,
+        trace,
+        mtime: stat?.mtimeMs ?? 0,
+      });
     }
+  }
 
-    const trace = extractTrace(entries);
-    const stat = statSync(filePath, { throwIfNoEntry: false });
-
-    traces.push({
-      file,
-      unitType,
-      unitId,
-      seq,
-      trace,
-      mtime: stat?.mtimeMs ?? 0,
-    });
+  // Sort by mtime descending so the most recent traces (regardless of source) come first
+  return allTraces.sort((a, b) => b.mtime - a.mtime).slice(0, 5);
+}
+
+/**
+ * Resolve activity directories to scan for forensics.
+ * If an active auto-worktree exists for the milestone, its activity dir
+ * is included first (preferred) so stale root logs don't mask worktree progress.
+ */
+function resolveActivityDirs(basePath: string, activeMilestone?: string | null): string[] {
+  const dirs: string[] = [];
+
+  // Check for active auto-worktree activity logs
+  if (activeMilestone) {
+    const wtPath = getAutoWorktreePath(basePath, activeMilestone);
+    if (wtPath) {
+      const wtActivityDir = join(wtPath, ".gsd", "activity");
+      if (existsSync(wtActivityDir)) {
+        dirs.push(wtActivityDir);
+      }
+    }
   }
 
-  return traces.sort((a, b) => b.seq - a.seq);
+  // Always include root activity logs
+  const rootActivityDir = join(gsdRoot(basePath), "activity");
+  dirs.push(rootActivityDir);
+
+  return dirs;
 }
 
 // ─── Completed Keys Loader ────────────────────────────────────────────────────
@@ -336,21 +368,27 @@ function detectTimeouts(traces: UnitTrace[], anomalies: ForensicAnomaly[]): void
   }
 }
 
-function detectMissingArtifacts(completedKeys: string[], basePath: string, anomalies: ForensicAnomaly[]): void {
+function detectMissingArtifacts(completedKeys: string[], basePath: string, activeMilestone: string | null, anomalies: ForensicAnomaly[]): void {
+  // Also check the worktree path for artifacts — they may exist there but not at root
+  const wtBasePath = activeMilestone ? getAutoWorktreePath(basePath, activeMilestone) : null;
+
   for (const key of completedKeys) {
     const slashIdx = key.indexOf("/");
     if (slashIdx === -1) continue;
     const unitType = key.slice(0, slashIdx);
     const unitId = key.slice(slashIdx + 1);
 
-    if (!verifyExpectedArtifact(unitType, unitId, basePath)) {
+    const rootHasArtifact = verifyExpectedArtifact(unitType, unitId, basePath);
+    const wtHasArtifact = wtBasePath ? verifyExpectedArtifact(unitType, unitId, wtBasePath) : false;
+
+    if (!rootHasArtifact && !wtHasArtifact) {
       anomalies.push({
         type: "missing-artifact",
         severity: "error",
         unitType,
         unitId,
         summary: `Completed key ${key} but artifact missing or invalid`,
-        details: `The unit is recorded as completed but verifyExpectedArtifact() returns false. The completion state is stale.`,
+        details: `The unit is recorded as completed but verifyExpectedArtifact() returns false at both project root and worktree. The completion state is stale.`,
       });
     }
   }
@@ -416,6 +454,7 @@ function saveForensicReport(basePath: string, report: ForensicReport, problemDes
     `**GSD Version:** ${report.gsdVersion}`,
     `**Active Milestone:** ${report.activeMilestone ?? "none"}`,
     `**Active Slice:** ${report.activeSlice ?? "none"}`,
+    `**Active Worktree:** ${report.activeWorktree ?? "none"}`,
     ``,
     `## Problem Description`,
     ``,
@@ -559,6 +598,10 @@ function formatReportForPrompt(report: ForensicReport): string {
   sections.push(`### GSD Version: ${report.gsdVersion}`);
   sections.push(`### Active Milestone: ${report.activeMilestone ?? "none"}`);
   sections.push(`### Active Slice: ${report.activeSlice ?? "none"}`);
+  if (report.activeWorktree) {
+    sections.push(`### Active Worktree: ${report.activeWorktree}`);
+    sections.push(`Note: Activity logs were scanned from both the worktree and the project root. Worktree logs take priority.`);
+  }
 
   let result = sections.join("\n");
   if (result.length > MAX_BYTES) {

package/dist/resources/extensions/gsd/guided-flow.ts

@@ -821,8 +821,9 @@ export async function showDiscuss(
 
     if (choice === "discuss_draft") {
       const discussMilestoneTemplates = inlineTemplate("context", "Context");
+      const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
       const basePrompt = loadPrompt("guided-discuss-milestone", {
-        milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates,
+        milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
       });
       const seed = draftContent
         ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
@@ -831,9 +832,10 @@ export async function showDiscuss(
       dispatchWorkflow(pi, seed, "gsd-discuss");
     } else if (choice === "discuss_fresh") {
       const discussMilestoneTemplates = inlineTemplate("context", "Context");
+      const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
       pendingAutoStart = { ctx, pi, basePath, milestoneId: mid, step: false };
       dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
-        milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates,
+        milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
       }), "gsd-discuss");
     } else if (choice === "skip_milestone") {
       const milestoneIds = findMilestoneIds(basePath);
@@ -1136,8 +1138,9 @@ export async function showSmartEntry(
 
     if (choice === "discuss_draft") {
       const discussMilestoneTemplates = inlineTemplate("context", "Context");
+      const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
       const basePrompt = loadPrompt("guided-discuss-milestone", {
-        milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates,
+        milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
       });
       const seed = draftContent
         ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
@@ -1146,9 +1149,10 @@ export async function showSmartEntry(
       dispatchWorkflow(pi, seed, "gsd-discuss");
     } else if (choice === "discuss_fresh") {
       const discussMilestoneTemplates = inlineTemplate("context", "Context");
+      const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
       pendingAutoStart = { ctx, pi, basePath, milestoneId, step: stepMode };
       dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
-        milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates,
+        milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
       }), "gsd-discuss");
     } else if (choice === "skip_milestone") {
       const milestoneIds = findMilestoneIds(basePath);
@@ -1220,8 +1224,9 @@ export async function showSmartEntry(
         }));
       } else if (choice === "discuss") {
         const discussMilestoneTemplates = inlineTemplate("context", "Context");
+        const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
         dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
-          milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates,
+          milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
         }));
       } else if (choice === "skip_milestone") {
         const milestoneIds = findMilestoneIds(basePath);