gsd-pi 2.24.0 → 2.25.0

package/packages/pi-coding-agent/src/modes/interactive/components/tool-execution.ts

@@ -903,6 +903,24 @@ export class ToolExecutionComponent extends Container {
 					text += `\n${theme.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
 				}
 			}
+		} else if (this.toolName === "web_search") {
+			// Server-side Anthropic web search
+			text = theme.fg("toolTitle", theme.bold("web search"));
+
+			if (this.result) {
+				const output = this.getTextOutput().trim();
+				if (output) {
+					const lines = output.split("\n");
+					const maxLines = this.expanded ? lines.length : 10;
+					const displayLines = lines.slice(0, maxLines);
+					const remaining = lines.length - maxLines;
+
+					text += `\n\n${displayLines.map((line: string) => theme.fg("toolOutput", line)).join("\n")}`;
+					if (remaining > 0) {
+						text += `${theme.fg("muted", `\n... (${remaining} more lines,`)} ${keyHint("expandTools", "to expand")})`;
+					}
+				}
+			}
 		} else {
 			// Generic tool (shouldn't reach here for custom tools)
 			text = theme.fg("toolTitle", theme.bold(this.toolName));

package/packages/pi-coding-agent/src/modes/interactive/interactive-mode.ts

@@ -1165,6 +1165,34 @@ export class InteractiveMode {
 		return registeredTool?.definition;
 	}
 
+	/**
+	 * Format web search result content for display in the TUI.
+	 */
+	private formatWebSearchResult(content: unknown): string {
+		if (!content) return "Web search completed";
+
+		// Error result
+		if (typeof content === "object" && "type" in (content as any) && (content as any).type === "web_search_tool_result_error") {
+			const error = content as any;
+			return `Search error: ${error.error_code || "unknown"}`;
+		}
+
+		// Array of search results
+		if (Array.isArray(content)) {
+			const results = content.filter((r: any) => r.type === "web_search_result");
+			if (results.length === 0) return "No results found";
+			return results
+				.map((r: any) => {
+					const title = r.title || "Untitled";
+					const url = r.url || "";
+					return `${title}\n  ${url}`;
+				})
+				.join("\n");
+		}
+
+		return "Web search completed";
+	}
+
 	/**
 	 * Set up keyboard shortcuts registered by extensions.
 	 */
@@ -2201,6 +2229,35 @@ export class InteractiveMode {
 									component.updateArgs(content.arguments);
 								}
 							}
+						} else if (content.type === "serverToolUse") {
+							// Server-side tool (e.g., native web search) — show as pending tool execution
+							if (!this.pendingTools.has(content.id)) {
+								const component = new ToolExecutionComponent(
+									content.name,
+									content.input ?? {},
+									{
+										showImages: this.settingsManager.getShowImages(),
+									},
+									undefined,
+									this.ui,
+								);
+								component.setExpanded(this.toolOutputExpanded);
+								this.chatContainer.addChild(component);
+								this.pendingTools.set(content.id, component);
+							}
+						} else if (content.type === "webSearchResult") {
+							// Server-side tool result — resolve the pending server tool execution
+							const component = this.pendingTools.get(content.toolUseId);
+							if (component) {
+								const searchContent = content.content;
+								const isError = searchContent && typeof searchContent === "object" && "type" in (searchContent as any) && (searchContent as any).type === "web_search_tool_result_error";
+								const resultText = this.formatWebSearchResult(searchContent);
+								component.updateResult({
+									content: [{ type: "text", text: resultText }],
+									isError: !!isError,
+								});
+								this.pendingTools.delete(content.toolUseId);
+							}
 						}
 					}
 					this.ui.requestRender();
@@ -2594,6 +2651,33 @@ export class InteractiveMode {
 						} else {
 							this.pendingTools.set(content.id, component);
 						}
+					} else if (content.type === "serverToolUse") {
+						// Server-side tool (e.g., native web search)
+						const component = new ToolExecutionComponent(
+							content.name,
+							content.input ?? {},
+							{ showImages: this.settingsManager.getShowImages() },
+							undefined,
+							this.ui,
+						);
+						component.setExpanded(this.toolOutputExpanded);
+						this.chatContainer.addChild(component);
+						// Find matching webSearchResult in this message's content
+						const resultBlock = message.content.find(
+							(c) => c.type === "webSearchResult" && c.toolUseId === content.id,
+						);
+						if (resultBlock && resultBlock.type === "webSearchResult") {
+							const searchContent = resultBlock.content;
+							const isError = searchContent && typeof searchContent === "object" && "type" in (searchContent as any) && (searchContent as any).type === "web_search_tool_result_error";
+							const resultText = this.formatWebSearchResult(searchContent);
+							component.updateResult({
+								content: [{ type: "text", text: resultText }],
+								isError: !!isError,
+							});
+						} else {
+							// No result yet (aborted stream?) — show as pending
+							this.pendingTools.set(content.id, component);
+						}
 					}
 				}
 			} else if (message.role === "toolResult") {

package/src/resources/GSD-WORKFLOW.md

@@ -565,25 +565,28 @@ One commit per slice. Individually revertable. Reads like a changelog.
 
 ```
 gsd/M001/S01:
-  test(S01): round-trip tests passing
+  test(S01/T03): round-trip tests passing
   feat(S01/T03): file writer with round-trip fidelity
-  chore(S01/T03): auto-commit after task
   feat(S01/T02): markdown parser for plan files
-  chore(S01/T02): auto-commit after task
   feat(S01/T01): core types and interfaces
-  chore(S01/T01): auto-commit after task
+  docs(S01): add slice plan
 ```
 
 ### Commit Conventions
 
 | When | Format | Example |
 |------|--------|---------|
-| Auto-commit (dirty state) | `chore(S01/T02): auto-commit after task` | Automatic save of work in progress |
-| After task verified | `feat(S01/T02): <what was built>` | The real work |
-| Plan/docs committed | `docs(S01): add slice plan` | Bundled with first task |
-| Slice squash to main | `type(M001/S01): <slice title>` | Type inferred from title (`feat`, `fix`, `docs`, etc.) |
+| Task completed | `{type}(S01/T02): <one-liner from summary>` | Type inferred from title (`feat`, `fix`, `test`, etc.) |
+| Plan/docs committed | `docs(S01): add slice plan` | Planning artifacts |
+| Slice squash to main | `type(M001/S01): <slice title>` | Type inferred from title |
+| State rebuild | `chore(S01/T02): auto-commit after state-rebuild` | Bookkeeping only |
 
-Commit types: `feat`, `fix`, `test`, `refactor`, `docs`, `chore`
+The system reads the task summary after execution and builds a meaningful commit message:
+- **Subject**: `{type}({sliceId}/{taskId}): {one-liner}` — the one-liner from the summary frontmatter
+- **Type**: Inferred from the task title and one-liner (`feat`, `fix`, `test`, `refactor`, `docs`, `perf`, `chore`)
+- **Body**: Key files from the summary frontmatter (up to 8 files listed)
+
+Commit types: `feat`, `fix`, `test`, `refactor`, `docs`, `perf`, `chore`
 
 ### Squash Merge Message
 

package/src/resources/extensions/bg-shell/overlay.ts

@@ -328,12 +328,9 @@ export class BgManagerOverlay {
 		return this.box(inner, width);
 	}
 
-	private renderOutput(width: number): string[] {
+	private processStatusHeader(p: typeof this.viewingProcess, activeTab: "output" | "events"): { statusIcon: string; headerLine: string } {
 		const th = this.theme;
-		const p = this.viewingProcess;
-		if (!p) return [""];
-		const inner: string[] = [];
-
+		if (!p) return { statusIcon: "", headerLine: "" };
 		const statusIcon = p.alive
 			? (p.status === "ready" ? th.fg("success", "●")
 				: p.status === "error" ? th.fg("error", "●")
@@ -343,9 +340,21 @@ export class BgManagerOverlay {
 		const uptime = th.fg("dim", formatUptime(Date.now() - p.startedAt));
 		const typeTag = th.fg("dim", `[${p.processType}]`);
 		const portInfo = p.ports.length > 0 ? th.fg("dim", ` :${p.ports.join(",")}`) : "";
-		const tabIndicator = th.fg("accent", "[Output]") + " " + th.fg("dim", "Events");
+		const tabIndicator = activeTab === "output"
+			? th.fg("accent", "[Output]") + " " + th.fg("dim", "Events")
+			: th.fg("dim", "Output") + " " + th.fg("accent", "[Events]");
+		const headerLine = `${statusIcon} ${name} ${typeTag} ${uptime}${portInfo}  ${tabIndicator}`;
+		return { statusIcon, headerLine };
+	}
+
+	private renderOutput(width: number): string[] {
+		const th = this.theme;
+		const p = this.viewingProcess;
+		if (!p) return [""];
+		const inner: string[] = [];
 
-		inner.push(`${statusIcon} ${name} ${typeTag} ${uptime}${portInfo}  ${tabIndicator}`);
+		const { headerLine } = this.processStatusHeader(p, "output");
+		inner.push(headerLine);
 		inner.push("");
 
 		// Unified buffer is already chronologically interleaved
@@ -384,16 +393,8 @@ export class BgManagerOverlay {
 		if (!p) return [""];
 		const inner: string[] = [];
 
-		const statusIcon = p.alive
-			? (p.status === "ready" ? th.fg("success", "●")
-				: p.status === "error" ? th.fg("error", "●")
-				: th.fg("warning", "●"))
-			: th.fg("dim", "○");
-		const name = th.fg("muted", p.label);
-		const uptime = th.fg("dim", formatUptime(Date.now() - p.startedAt));
-		const tabIndicator = th.fg("dim", "Output") + " " + th.fg("accent", "[Events]");
-
-		inner.push(`${statusIcon} ${name} ${uptime}  ${tabIndicator}`);
+		const { headerLine } = this.processStatusHeader(p, "events");
+		inner.push(headerLine);
 		inner.push("");
 
 		if (p.events.length === 0) {

package/src/resources/extensions/get-secrets-from-user.ts

@@ -369,32 +369,14 @@ async function applySecrets(
 		}
 	}
 
-	if (destination === "vercel" && opts.exec) {
+	if ((destination === "vercel" || destination === "convex") && opts.exec) {
 		const env = opts.environment ?? "development";
 		for (const { key, value } of provided) {
+			const cmd = destination === "vercel"
+				? `printf %s ${shellEscapeSingle(value)} | vercel env add ${key} ${env}`
+				: `npx convex env set ${key} ${shellEscapeSingle(value)}`;
 			try {
-				const result = await opts.exec("sh", [
-					"-c",
-					`printf %s ${shellEscapeSingle(value)} | vercel env add ${key} ${env}`,
-				]);
-				if (result.code !== 0) {
-					errors.push(`${key}: ${result.stderr.slice(0, 200)}`);
-				} else {
-					applied.push(key);
-				}
-			} catch (err: any) {
-				errors.push(`${key}: ${err.message}`);
-			}
-		}
-	}
-
-	if (destination === "convex" && opts.exec) {
-		for (const { key, value } of provided) {
-			try {
-				const result = await opts.exec("sh", [
-					"-c",
-					`npx convex env set ${key} ${shellEscapeSingle(value)}`,
-				]);
+				const result = await opts.exec("sh", ["-c", cmd]);
 				if (result.code !== 0) {
 					errors.push(`${key}: ${result.stderr.slice(0, 200)}`);
 				} else {

package/src/resources/extensions/gsd/activity-log.ts

@@ -103,10 +103,10 @@ export function saveActivityLog(
   basePath: string,
   unitType: string,
   unitId: string,
-): void {
+): string | null {
   try {
     const entries = ctx.sessionManager.getEntries();
-    if (!entries || entries.length === 0) return;
+    if (!entries || entries.length === 0) return null;
 
     const activityDir = join(gsdRoot(basePath), "activity");
     mkdirSync(activityDir, { recursive: true });
@@ -116,7 +116,7 @@ export function saveActivityLog(
     const unitKey = `${unitType}\0${safeUnitId}`;
     // Use lightweight fingerprint instead of serializing all entries (#611)
     const key = snapshotKey(unitType, safeUnitId, entries);
-    if (state.lastSnapshotKeyByUnit.get(unitKey) === key) return;
+    if (state.lastSnapshotKeyByUnit.get(unitKey) === key) return null;
 
     const filePath = nextActivityFilePath(activityDir, state, unitType, safeUnitId);
     // Stream entries to disk line-by-line instead of building one massive string (#611).
@@ -131,9 +131,11 @@ export function saveActivityLog(
     }
     state.nextSeq += 1;
     state.lastSnapshotKeyByUnit.set(unitKey, key);
+    return filePath;
   } catch (e) {
     // Don't let logging failures break auto-mode
     void e;
+    return null;
   }
 }
 

package/src/resources/extensions/gsd/auto-prompts.ts

@@ -637,6 +637,12 @@ export async function buildPlanSlicePrompt(
   const executorContextConstraints = formatExecutorConstraints();
 
   const outputRelPath = relSliceFile(base, mid, sid, "PLAN");
+  const prefs = loadEffectiveGSDPreferences();
+  const commitDocsEnabled = prefs?.preferences?.git?.commit_docs !== false;
+  const commitInstruction = commitDocsEnabled
+    ? `Commit: \`docs(${sid}): add slice plan\``
+    : "Do not commit — planning docs are not tracked in git for this project.";
+
   return loadPrompt("plan-slice", {
     workingDirectory: base,
     milestoneId: mid, sliceId: sid, sliceTitle: sTitle,
@@ -647,6 +653,7 @@ export async function buildPlanSlicePrompt(
     inlinedContext,
     dependencySummaries: depContent,
     executorContextConstraints,
+    commitInstruction,
   });
 }
 
@@ -1071,6 +1078,12 @@ export async function buildReassessRoadmapPrompt(
     // Non-fatal — captures module may not be available
   }
 
+  const reassessPrefs = loadEffectiveGSDPreferences();
+  const reassessCommitDocsEnabled = reassessPrefs?.preferences?.git?.commit_docs !== false;
+  const reassessCommitInstruction = reassessCommitDocsEnabled
+    ? `Commit: \`docs(${mid}): reassess roadmap after ${completedSliceId}\``
+    : "Do not commit — planning docs are not tracked in git for this project.";
+
   return loadPrompt("reassess-roadmap", {
     workingDirectory: base,
     milestoneId: mid,
@@ -1081,6 +1094,7 @@ export async function buildReassessRoadmapPrompt(
     assessmentPath,
     inlinedContext,
     deferredCaptures,
+    commitInstruction: reassessCommitInstruction,
   });
 }
 

package/src/resources/extensions/gsd/auto-worktree.ts

@@ -6,7 +6,7 @@
  * manages create, enter, detect, and teardown for auto-mode worktrees.
  */
 
-import { existsSync, cpSync, readFileSync, realpathSync, utimesSync } from "node:fs";
+import { existsSync, cpSync, readFileSync, writeFileSync, readdirSync, mkdirSync, realpathSync, utimesSync } from "node:fs";
 import { isAbsolute, join, resolve } from "node:path";
 import { copyWorktreeDb, reconcileWorktreeDb, isDbAvailable } from "./gsd-db.js";
 import { execSync, execFileSync } from "node:child_process";
@@ -134,6 +134,112 @@ export function autoWorktreeBranch(milestoneId: string): string {
  * Atomic: chdir + originalBase update happen in the same try block
  * to prevent split-brain.
  */
+
+/**
+ * Forward-merge plan checkbox state from the project root into a freshly
+ * re-attached worktree (#778).
+ *
+ * When auto-mode stops via crash (not graceful stop), the milestone branch
+ * HEAD may be behind the filesystem state at the project root because
+ * syncStateToProjectRoot() runs after every task completion but the final
+ * git commit may not have happened before the crash. On restart the worktree
+ * is re-attached to the branch HEAD, which has [ ] for the crashed task,
+ * causing verifyExpectedArtifact() to fail and triggering an infinite
+ * dispatch/skip loop.
+ *
+ * Fix: after re-attaching, read every *.md plan file in the milestone
+ * directory at the project root and apply any [x] checkbox states that are
+ * ahead of the worktree version (forward-only: never downgrade [x] → [ ]).
+ *
+ * This is safe because syncStateToProjectRoot() is the authoritative source
+ * of post-task state at the project root — it writes the same [x] the LLM
+ * produced, then the auto-commit follows. If the commit never happened, the
+ * filesystem copy is still valid and correct.
+ */
+function reconcilePlanCheckboxes(projectRoot: string, wtPath: string, milestoneId: string): void {
+  const srcMilestone = join(projectRoot, ".gsd", "milestones", milestoneId);
+  const dstMilestone = join(wtPath, ".gsd", "milestones", milestoneId);
+  if (!existsSync(srcMilestone) || !existsSync(dstMilestone)) return;
+
+  // Walk all markdown files in the milestone directory (plans, summaries, etc.)
+  function walkMd(dir: string): string[] {
+    const results: string[] = [];
+    try {
+      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          results.push(...walkMd(full));
+        } else if (entry.isFile() && entry.name.endsWith(".md")) {
+          results.push(full);
+        }
+      }
+    } catch { /* non-fatal */ }
+    return results;
+  }
+
+  for (const srcFile of walkMd(srcMilestone)) {
+    const rel = srcFile.slice(srcMilestone.length);
+    const dstFile = dstMilestone + rel;
+    if (!existsSync(dstFile)) continue; // only reconcile existing files
+
+    let srcContent: string;
+    let dstContent: string;
+    try {
+      srcContent = readFileSync(srcFile, "utf-8");
+      dstContent = readFileSync(dstFile, "utf-8");
+    } catch { continue; }
+
+    if (srcContent === dstContent) continue;
+
+    // Extract all checked task IDs from the source (project root)
+    // Pattern: - [x] **T<id>: or - [x] **S<id>: (case-insensitive x)
+    const checkedRe = /^- \[[xX]\] \*\*([TS]\d+):/gm;
+    const srcChecked = new Set<string>();
+    for (const m of srcContent.matchAll(checkedRe)) srcChecked.add(m[1]);
+
+    if (srcChecked.size === 0) continue;
+
+    // Forward-apply: replace [ ] → [x] for any IDs that are checked in src
+    let updated = dstContent;
+    let changed = false;
+    for (const id of srcChecked) {
+      const escapedId = id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const uncheckedRe = new RegExp(`^(- )\\[ \\]( \\*\\*${escapedId}:)`, "gm");
+      if (uncheckedRe.test(updated)) {
+        updated = updated.replace(
+          new RegExp(`^(- )\\[ \\]( \\*\\*${escapedId}:)`, "gm"),
+          "$1[x]$2",
+        );
+        changed = true;
+      }
+    }
+
+    if (changed) {
+      try {
+        writeFileSync(dstFile, updated, "utf-8");
+      } catch { /* non-fatal */ }
+    }
+  }
+
+  // Also forward-merge completed-units.json (set-union)
+  const srcKeys = join(projectRoot, ".gsd", "completed-units.json");
+  const dstKeys = join(wtPath, ".gsd", "completed-units.json");
+  if (existsSync(srcKeys)) {
+    try {
+      const src: string[] = JSON.parse(readFileSync(srcKeys, "utf-8"));
+      let dst: string[] = [];
+      if (existsSync(dstKeys)) {
+        try { dst = JSON.parse(readFileSync(dstKeys, "utf-8")); } catch { /* ignore corrupt */ }
+      }
+      const merged = [...new Set([...dst, ...src])];
+      if (merged.length > dst.length) {
+        mkdirSync(join(wtPath, ".gsd"), { recursive: true });
+        writeFileSync(dstKeys, JSON.stringify(merged), "utf-8");
+      }
+    } catch { /* non-fatal */ }
+  }
+}
+
 export function createAutoWorktree(basePath: string, milestoneId: string): string {
   const branch = autoWorktreeBranch(milestoneId);
 
@@ -166,6 +272,18 @@ export function createAutoWorktree(basePath: string, milestoneId: string): strin
   // not always fully synced.
   if (!branchExists) {
     copyPlanningArtifacts(basePath, info.path);
+  } else {
+    // Re-attaching to an existing branch: forward-merge any plan checkpoint
+    // state from the project root into the worktree (#778).
+    //
+    // If auto-mode stopped via crash, the milestone branch HEAD may lag behind
+    // the project root filesystem because syncStateToProjectRoot() ran after
+    // task completion but the auto-commit never fired. On restart the worktree
+    // is re-created from the branch HEAD (which has [ ] for the crashed task),
+    // causing verifyExpectedArtifact() to return false → stale-key eviction →
+    // infinite dispatch/skip loop. Reconciling here ensures the worktree sees
+    // the same [x] state that syncStateToProjectRoot() wrote to the root.
+    reconcilePlanCheckboxes(basePath, info.path, milestoneId);
   }
 
   // Run user-configured post-create hook (#597) — e.g. copy .env, symlink assets