gsd-pi 2.3.6 → 2.3.8

package/dist/wizard.js

@@ -81,6 +81,8 @@ export function loadStoredEnvKeys(authStorage) {
         ['brave_answers', 'BRAVE_ANSWERS_KEY'],
         ['context7', 'CONTEXT7_API_KEY'],
         ['jina', 'JINA_API_KEY'],
+        ['slack_bot', 'SLACK_BOT_TOKEN'],
+        ['discord_bot', 'DISCORD_BOT_TOKEN'],
     ];
     for (const [provider, envVar] of providers) {
         if (!process.env[envVar]) {
@@ -120,6 +122,20 @@ const API_KEYS = [
         hint: '(clean page extraction)',
         description: 'High-quality web page content extraction',
     },
+    {
+        provider: 'slack_bot',
+        envVar: 'SLACK_BOT_TOKEN',
+        label: 'Slack Bot',
+        hint: '(remote questions in auto-mode)',
+        description: 'Bot token for remote questions via Slack',
+    },
+    {
+        provider: 'discord_bot',
+        envVar: 'DISCORD_BOT_TOKEN',
+        label: 'Discord Bot',
+        hint: '(remote questions in auto-mode)',
+        description: 'Bot token for remote questions via Discord',
+    },
 ];
 /**
  * Check for missing optional tool API keys and prompt for them if on a TTY.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "2.3.6",
+  "version": "2.3.8",
   "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {

package/patches/@mariozechner+pi-coding-agent+0.57.1.patch

@@ -1,3 +1,63 @@
+diff --git a/node_modules/@mariozechner/pi-coding-agent/dist/core/agent-session.js b/node_modules/@mariozechner/pi-coding-agent/dist/core/agent-session.js
+index 90622c2..cff094b 100644
+--- a/node_modules/@mariozechner/pi-coding-agent/dist/core/agent-session.js
++++ b/node_modules/@mariozechner/pi-coding-agent/dist/core/agent-session.js
+@@ -1007,7 +1007,7 @@ export class AgentSession {
+      * Validates API key, saves to session and settings.
+      * @throws Error if no API key available for the model
+      */
+-    async setModel(model) {
++    async setModel(model, options) {
+         const apiKey = await this._modelRegistry.getApiKey(model);
+         if (!apiKey) {
+             throw new Error(`No API key for ${model.provider}/${model.id}`);
+@@ -1016,7 +1016,9 @@ export class AgentSession {
+         const thinkingLevel = this._getThinkingLevelForModelSwitch();
+         this.agent.setModel(model);
+         this.sessionManager.appendModelChange(model.provider, model.id);
+-        this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
++        if (options?.persist !== false) {
++            this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
++        }
+         // Re-clamp thinking level for new model's capabilities
+         this.setThinkingLevel(thinkingLevel);
+         await this._emitModelSelect(model, previousModel, "set");
+@@ -1067,7 +1069,9 @@ export class AgentSession {
+         // Apply model
+         this.agent.setModel(next.model);
+         this.sessionManager.appendModelChange(next.model.provider, next.model.id);
+-        this.settingsManager.setDefaultModelAndProvider(next.model.provider, next.model.id);
++        if (options?.persist !== false) {
++            this.settingsManager.setDefaultModelAndProvider(next.model.provider, next.model.id);
++        }
+         // Apply thinking level.
+         // - Explicit scoped model thinking level overrides current session level
+         // - Undefined scoped model thinking level inherits the current session preference
+@@ -1094,7 +1098,9 @@ export class AgentSession {
+         const thinkingLevel = this._getThinkingLevelForModelSwitch();
+         this.agent.setModel(nextModel);
+         this.sessionManager.appendModelChange(nextModel.provider, nextModel.id);
+-        this.settingsManager.setDefaultModelAndProvider(nextModel.provider, nextModel.id);
++        if (options?.persist !== false) {
++            this.settingsManager.setDefaultModelAndProvider(nextModel.provider, nextModel.id);
++        }
+         // Re-clamp thinking level for new model's capabilities
+         this.setThinkingLevel(thinkingLevel);
+         await this._emitModelSelect(nextModel, currentModel, "cycle");
+@@ -1659,11 +1665,11 @@ export class AgentSession {
+             setActiveTools: (toolNames) => this.setActiveToolsByName(toolNames),
+             refreshTools: () => this._refreshToolRegistry(),
+             getCommands,
+-            setModel: async (model) => {
++            setModel: async (model, options) => {
+                 const key = await this.modelRegistry.getApiKey(model);
+                 if (!key)
+                     return false;
+-                await this.setModel(model);
++                await this.setModel(model, options);
+                 return true;
+             },
+             getThinkingLevel: () => this.thinkingLevel,
 diff --git a/node_modules/@mariozechner/pi-coding-agent/dist/core/tools/bash.js b/node_modules/@mariozechner/pi-coding-agent/dist/core/tools/bash.js
 index 27fe820..68f277f 100644
 --- a/node_modules/@mariozechner/pi-coding-agent/dist/core/tools/bash.js

package/src/resources/extensions/ask-user-questions.ts

@@ -21,12 +21,27 @@ import {
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 
-interface AskUserQuestionsDetails {
+interface LocalResultDetails {
+	remote?: false;
 	questions: Question[];
 	response: RoundResult | null;
 	cancelled: boolean;
 }
 
+interface RemoteResultDetails {
+	remote: true;
+	channel: string;
+	timed_out: boolean;
+	promptId?: string;
+	threadUrl?: string;
+	status?: string;
+	questions?: Question[];
+	response?: import("./remote-questions/types.js").RemoteAnswer;
+	error?: boolean;
+}
+
+type AskUserQuestionsDetails = LocalResultDetails | RemoteResultDetails;
+
 // ─── Schema ───────────────────────────────────────────────────────────────────
 
 const OptionSchema = Type.Object({
@@ -104,7 +119,7 @@ export default function AskUserQuestions(pi: ExtensionAPI) {
 		],
 		parameters: AskUserQuestionsParams,
 
-		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
 			// Validation
 			if (params.questions.length === 0 || params.questions.length > 3) {
 				return errorResult("Error: questions must contain 1-3 items", params.questions);
@@ -120,6 +135,9 @@ export default function AskUserQuestions(pi: ExtensionAPI) {
 			}
 
 			if (!ctx.hasUI) {
+				const { tryRemoteQuestions } = await import("./remote-questions/manager.js");
+				const remoteResult = await tryRemoteQuestions(params.questions, signal);
+				if (remoteResult) return remoteResult;
 				return errorResult("Error: UI not available (non-interactive mode)", params.questions);
 			}
 
@@ -131,13 +149,13 @@ export default function AskUserQuestions(pi: ExtensionAPI) {
 			if (!hasAnswers) {
 				return {
 					content: [{ type: "text", text: "ask_user_questions was cancelled before receiving a response" }],
-					details: { questions: params.questions, response: null, cancelled: true } as AskUserQuestionsDetails,
+					details: { questions: params.questions, response: null, cancelled: true } satisfies LocalResultDetails,
 				};
 			}
 
 			return {
 				content: [{ type: "text", text: formatForLLM(result) }],
-				details: { questions: params.questions, response: result, cancelled: false } as AskUserQuestionsDetails,
+				details: { questions: params.questions, response: result, cancelled: false } satisfies LocalResultDetails,
 			};
 		},
 
@@ -171,13 +189,44 @@ export default function AskUserQuestions(pi: ExtensionAPI) {
 				return new Text(text?.type === "text" ? text.text : "", 0, 0);
 			}
 
+			// Remote channel result (discriminated on details.remote === true)
+			if (details.remote) {
+				if (details.timed_out) {
+					return new Text(
+						`${theme.fg("warning", `${details.channel} — timed out`)}${details.threadUrl ? theme.fg("dim", ` ${details.threadUrl}`) : ""}`,
+						0,
+						0,
+					);
+				}
+
+				const questions = (details.questions ?? []) as Question[];
+				const lines: string[] = [];
+				lines.push(theme.fg("dim", details.channel));
+				if (details.response) {
+					for (const q of questions) {
+						const answer = details.response.answers[q.id];
+						if (!answer) {
+							lines.push(`${theme.fg("accent", q.header)}: ${theme.fg("dim", "(no answer)")}`);
+							continue;
+						}
+						const answerText = answer.answers.length > 0 ? answer.answers.join(", ") : "(custom)";
+						let line = `${theme.fg("success", "✓ ")}${theme.fg("accent", q.header)}: ${answerText}`;
+						if (answer.user_note) {
+							line += ` ${theme.fg("muted", `[note: ${answer.user_note}]`)}`;
+						}
+						lines.push(line);
+					}
+				}
+				return new Text(lines.join("\n"), 0, 0);
+			}
+
 			if (details.cancelled || !details.response) {
 				return new Text(theme.fg("warning", "Cancelled"), 0, 0);
 			}
 
 			const lines: string[] = [];
 			for (const q of details.questions) {
-				const answer = details.response.answers[q.id];
+				const answer = (details.response as RoundResult).answers[q.id];
 				if (!answer) {
 					lines.push(`${theme.fg("accent", q.header)}: ${theme.fg("dim", "(no answer)")}`);
 					continue;

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

@@ -60,6 +60,8 @@ import { execSync } from "node:child_process";
 import {
   autoCommitCurrentBranch,
   ensureSliceBranch,
+  getCurrentBranch,
+  getSliceBranchName,
   switchToMain,
   mergeSliceToMain,
 } from "./worktree.ts";
@@ -247,6 +249,14 @@ export async function startAuto(
     if (!getLedger()) initMetrics(base);
     ctx.ui.setStatus("gsd-auto", stepMode ? "next" : "auto");
     ctx.ui.notify(stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "info");
+    // Rebuild disk state before resuming — user interaction during pause may have changed files
+    try { await rebuildState(base); } catch { /* non-fatal */ }
+    try {
+      const report = await runGSDDoctor(base, { fix: true });
+      if (report.fixesApplied.length > 0) {
+        ctx.ui.notify(`Resume: applied ${report.fixesApplied.length} fix(es) to state.`, "info");
+      }
+    } catch { /* non-fatal */ }
     await dispatchNextUnit(ctx, pi);
     return;
   }
@@ -758,7 +768,12 @@ async function dispatchNextUnit(
   ctx: ExtensionContext,
   pi: ExtensionAPI,
 ): Promise<void> {
-  if (!active || !cmdCtx) return;
+  if (!active || !cmdCtx) {
+    if (active && !cmdCtx) {
+      ctx.ui.notify("Auto-mode dispatch failed: no command context. Run /gsd auto to restart.", "error");
+    }
+    return;
+  }
 
   let state = await deriveState(basePath);
   let mid = state.activeMilestone?.id;
@@ -787,39 +802,53 @@ async function dispatchNextUnit(
     return;
   }
 
-  // ── Post-completion merge: merge the slice branch after complete-slice finishes ──
-  // The complete-slice unit writes the summary, UAT, marks roadmap [x], and commits.
-  // Now we switch to main and squash-merge the slice branch.
-  if (currentUnit?.type === "complete-slice") {
-    try {
-      const [completedMid, completedSid] = currentUnit.id.split("/");
-      // Look up actual slice title from roadmap (on current branch, before switching)
-      const roadmapFile = resolveMilestoneFile(basePath, completedMid!, "ROADMAP");
+  // ── General merge guard: merge completed slice branches before advancing ──
+  // If we're on a gsd/MID/SID branch and that slice is done (roadmap [x]),
+  // merge to main before dispatching the next unit. This handles:
+  //   - Normal complete-slice → merge → reassess flow
+  //   - LLM writes summary during task execution, skipping complete-slice
+  //   - Doctor post-hook marks everything done, skipping complete-slice
+  //   - complete-milestone runs on a slice branch (last slice bypass)
+  {
+    const currentBranch = getCurrentBranch(basePath);
+    const branchMatch = currentBranch.match(/^gsd\/(M\d+)\/(S\d+)$/);
+    if (branchMatch) {
+      const branchMid = branchMatch[1]!;
+      const branchSid = branchMatch[2]!;
+      // Check if this slice is marked done in the roadmap
+      const roadmapFile = resolveMilestoneFile(basePath, branchMid, "ROADMAP");
       const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-      let sliceTitleForMerge = completedSid!;
       if (roadmapContent) {
         const roadmap = parseRoadmap(roadmapContent);
-        const sliceEntry = roadmap.slices.find(s => s.id === completedSid);
-        if (sliceEntry) sliceTitleForMerge = sliceEntry.title;
+        const sliceEntry = roadmap.slices.find(s => s.id === branchSid);
+        if (sliceEntry?.done) {
+          try {
+            const sliceTitleForMerge = sliceEntry.title || branchSid;
+            switchToMain(basePath);
+            const mergeResult = mergeSliceToMain(
+              basePath, branchMid, branchSid, sliceTitleForMerge,
+            );
+            ctx.ui.notify(
+              `Merged ${mergeResult.branch} → main.`,
+              "info",
+            );
+            // Re-derive state from main so downstream logic sees merged state
+            state = await deriveState(basePath);
+            mid = state.activeMilestone?.id;
+            midTitle = state.activeMilestone?.title;
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            ctx.ui.notify(
+              `Slice merge failed: ${message}`,
+              "error",
+            );
+            // Re-derive state so dispatch can figure out what to do
+            state = await deriveState(basePath);
+            mid = state.activeMilestone?.id;
+            midTitle = state.activeMilestone?.title;
+          }
+        }
       }
-      switchToMain(basePath);
-      const mergeResult = mergeSliceToMain(
-        basePath, completedMid!, completedSid!, sliceTitleForMerge,
-      );
-      ctx.ui.notify(
-        `Merged ${mergeResult.branch} → main.`,
-        "info",
-      );
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      ctx.ui.notify(
-        `Slice merge failed: ${message}`,
-        "error",
-      );
-      // Re-derive state so dispatch can figure out what to do
-      state = await deriveState(basePath);
-      mid = state.activeMilestone?.id;
-      midTitle = state.activeMilestone?.title;
     }
   }
 
@@ -1086,7 +1115,7 @@ async function dispatchNextUnit(
     const allModels = ctx.modelRegistry.getAll();
     const model = allModels.find(m => m.id === preferredModelId);
     if (model) {
-      const ok = await pi.setModel(model);
+      const ok = await pi.setModel(model, { persist: false });
       if (ok) {
         ctx.ui.notify(`Model: ${preferredModelId}`, "info");
       }
@@ -1186,7 +1215,8 @@ async function dispatchNextUnit(
     await pauseAuto(ctx, pi);
   }, hardTimeoutMs);
 
-  // Inject prompt
+  // Inject prompt — verify auto-mode still active (guards against race with timeout/pause)
+  if (!active) return;
   pi.sendMessage(
     { customType: "gsd-auto", content: finalPrompt, display: verbose },
     { triggerTurn: true },

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

@@ -31,6 +31,7 @@ import {
 } from "./doctor.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { handleMigrate } from "./migrate/command.js";
+import { handleRemote } from "../remote-questions/remote-command.js";
 
 function dispatchDoctorHeal(pi: ExtensionAPI, scope: string | undefined, reportText: string, structuredIssues: string): void {
   const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".pi", "GSD-WORKFLOW.md");
@@ -52,10 +53,10 @@ function dispatchDoctorHeal(pi: ExtensionAPI, scope: string | undefined, reportT
 
 export function registerGSDCommand(pi: ExtensionAPI): void {
   pi.registerCommand("gsd", {
-    description: "GSD — Get Shit Done: /gsd next|auto|stop|status|queue|prefs|doctor|migrate",
+    description: "GSD — Get Shit Done: /gsd next|auto|stop|status|queue|prefs|doctor|migrate|remote",
 
     getArgumentCompletions: (prefix: string) => {
-      const subcommands = ["next", "auto", "stop", "status", "queue", "discuss", "prefs", "doctor", "migrate"];
+      const subcommands = ["next", "auto", "stop", "status", "queue", "discuss", "prefs", "doctor", "migrate", "remote"];
       const parts = prefix.trim().split(/\s+/);
 
       if (parts.length <= 1) {
@@ -78,6 +79,13 @@ export function registerGSDCommand(pi: ExtensionAPI): void {
           .map((cmd) => ({ value: `prefs ${cmd}`, label: cmd }));
       }
 
+      if (parts[0] === "remote" && parts.length <= 2) {
+        const subPrefix = parts[1] ?? "";
+        return ["slack", "discord", "status", "disconnect"]
+          .filter((cmd) => cmd.startsWith(subPrefix))
+          .map((cmd) => ({ value: `remote ${cmd}`, label: cmd }));
+      }
+
       if (parts[0] === "doctor") {
         const modePrefix = parts[1] ?? "";
         const modes = ["fix", "heal", "audit"];
@@ -148,6 +156,11 @@ export function registerGSDCommand(pi: ExtensionAPI): void {
         return;
       }
 
+      if (trimmed === "remote" || trimmed.startsWith("remote ")) {
+        await handleRemote(trimmed.replace(/^remote\s*/, "").trim(), ctx, pi);
+        return;
+      }
+
       if (trimmed === "") {
         // Bare /gsd defaults to step mode
         await startAuto(ctx, pi, process.cwd(), false, { step: true });
@@ -155,7 +168,7 @@ export function registerGSDCommand(pi: ExtensionAPI): void {
       }
 
       ctx.ui.notify(
-        `Unknown: /gsd ${trimmed}. Use /gsd, /gsd next, /gsd auto, /gsd stop, /gsd status, /gsd queue, /gsd discuss, /gsd prefs [global|project|status], /gsd doctor [audit|fix|heal] [M###/S##], or /gsd migrate <path>.`,
+        `Unknown: /gsd ${trimmed}. Use /gsd, /gsd next, /gsd auto, /gsd stop, /gsd status, /gsd queue, /gsd discuss, /gsd prefs [global|project|status], /gsd doctor [audit|fix|heal] [M###/S##], /gsd migrate <path>, or /gsd remote [slack|discord|status|disconnect].`,
         "warning",
       );
     },

package/src/resources/extensions/gsd/index.ts

@@ -22,7 +22,7 @@ import type {
   ExtensionAPI,
   ExtensionContext,
 } from "@mariozechner/pi-coding-agent";
-import { createBashTool } from "@mariozechner/pi-coding-agent";
+import { createBashTool, createWriteTool, createReadTool, createEditTool } from "@mariozechner/pi-coding-agent";
 
 import { registerGSDCommand } from "./commands.js";
 import { registerWorktreeCommand, getWorktreeOriginalCwd, getActiveWorktreeName } from "./worktree-command.js";
@@ -102,7 +102,60 @@ export default function (pi: ExtensionAPI) {
   };
   pi.registerTool(dynamicBash as any);
 
-  // ── session_start: render branded GSD header ───────────────────────────
+  // ── Dynamic-cwd file tools (write, read, edit) ────────────────────────
+  // The built-in file tools capture cwd at startup. When process.chdir()
+  // moves us into a worktree, relative paths still resolve against the
+  // original launch directory. These replacements delegate to freshly-
+  // created tools on each call so that process.cwd() is read dynamically.
+  const baseWrite = createWriteTool(process.cwd());
+  const dynamicWrite = {
+    ...baseWrite,
+    execute: async (
+      toolCallId: string,
+      params: { path: string; content: string },
+      signal?: AbortSignal,
+      onUpdate?: any,
+      ctx?: any,
+    ) => {
+      const fresh = createWriteTool(process.cwd());
+      return fresh.execute(toolCallId, params, signal, onUpdate, ctx);
+    },
+  };
+  pi.registerTool(dynamicWrite as any);
+
+  const baseRead = createReadTool(process.cwd());
+  const dynamicRead = {
+    ...baseRead,
+    execute: async (
+      toolCallId: string,
+      params: { path: string; offset?: number; limit?: number },
+      signal?: AbortSignal,
+      onUpdate?: any,
+      ctx?: any,
+    ) => {
+      const fresh = createReadTool(process.cwd());
+      return fresh.execute(toolCallId, params, signal, onUpdate, ctx);
+    },
+  };
+  pi.registerTool(dynamicRead as any);
+
+  const baseEdit = createEditTool(process.cwd());
+  const dynamicEdit = {
+    ...baseEdit,
+    execute: async (
+      toolCallId: string,
+      params: { path: string; oldText: string; newText: string },
+      signal?: AbortSignal,
+      onUpdate?: any,
+      ctx?: any,
+    ) => {
+      const fresh = createEditTool(process.cwd());
+      return fresh.execute(toolCallId, params, signal, onUpdate, ctx);
+    },
+  };
+  pi.registerTool(dynamicEdit as any);
+
+  // ── session_start: render branded GSD header + remote channel status ──
   pi.on("session_start", async (_event, ctx) => {
     const theme = ctx.ui.theme;
     const version = process.env.GSD_VERSION || "0.0.0";
@@ -112,6 +165,22 @@ export default function (pi: ExtensionAPI) {
 
     const headerContent = `${logoText}\n${titleLine}`;
     ctx.ui.setHeader((_ui, _theme) => new Text(headerContent, 1, 0));
+
+    // Notify remote questions status if configured
+    try {
+      const [{ getRemoteConfigStatus }, { getLatestPromptSummary }] = await Promise.all([
+        import("../remote-questions/config.js"),
+        import("../remote-questions/status.js"),
+      ]);
+      const status = getRemoteConfigStatus();
+      const latest = getLatestPromptSummary();
+      if (!status.includes("not configured")) {
+        const suffix = latest ? `\nLast remote prompt: ${latest.id} (${latest.status})` : "";
+        ctx.ui.notify(`${status}${suffix}`, status.includes("disabled") ? "warning" : "info");
+      }
+    } catch {
+      // Remote questions module not available — ignore
+    }
   });
 
   // ── Ctrl+Alt+G shortcut — GSD dashboard overlay ────────────────────────

package/src/resources/extensions/gsd/preferences.ts

@@ -31,6 +31,13 @@ export interface AutoSupervisorConfig {
   hard_timeout_minutes?: number;
 }
 
+export interface RemoteQuestionsConfig {
+  channel: "slack" | "discord";
+  channel_id: string | number;
+  timeout_minutes?: number;        // clamped to 1-30
+  poll_interval_seconds?: number;  // clamped to 2-30
+}
+
 export interface GSDPreferences {
   version?: number;
   always_use_skills?: string[];
@@ -43,6 +50,7 @@ export interface GSDPreferences {
   auto_supervisor?: AutoSupervisorConfig;
   uat_dispatch?: boolean;
   budget_ceiling?: number;
+  remote_questions?: RemoteQuestionsConfig;
 }
 
 export interface LoadedGSDPreferences {
@@ -430,7 +438,12 @@ function parseFrontmatterBlock(frontmatter: string): GSDPreferences {
 function parseScalar(value: string): string | number | boolean {
   if (value === "true") return true;
   if (value === "false") return false;
-  if (/^-?\d+$/.test(value)) return Number(value);
+  if (/^-?\d+$/.test(value)) {
+    const n = Number(value);
+    // Keep large integers (e.g. Discord channel IDs) as strings to avoid precision loss
+    if (Number.isSafeInteger(n)) return n;
+    return value;
+  }
   return value.replace(/^['\"]|['\"]$/g, "");
 }
 
@@ -495,6 +508,9 @@ function mergePreferences(base: GSDPreferences, override: GSDPreferences): GSDPr
     auto_supervisor: { ...(base.auto_supervisor ?? {}), ...(override.auto_supervisor ?? {}) },
     uat_dispatch: override.uat_dispatch ?? base.uat_dispatch,
     budget_ceiling: override.budget_ceiling ?? base.budget_ceiling,
+    remote_questions: override.remote_questions
+      ? { ...(base.remote_questions ?? {}), ...override.remote_questions }
+      : base.remote_questions,
   };
 }