gsd-pi 2.3.6 → 2.3.7

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.7",
   "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

@@ -247,6 +247,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 +766,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;
@@ -1086,7 +1099,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 +1199,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

@@ -102,7 +102,7 @@ export default function (pi: ExtensionAPI) {
   };
   pi.registerTool(dynamicBash as any);
 
-  // ── session_start: render branded GSD header ───────────────────────────
+  // ── 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 +112,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,
   };
 }
 

package/src/resources/extensions/gsd/tests/remote-questions.test.ts

@@ -0,0 +1,155 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { parseSlackReply, parseDiscordResponse } from "../../remote-questions/format.ts";
+import { resolveRemoteConfig, isValidChannelId } from "../../remote-questions/config.ts";
+import { sanitizeError } from "../../remote-questions/manager.ts";
+
+test("parseSlackReply handles single-number single-question answers", () => {
+  const result = parseSlackReply("2", [{
+    id: "choice",
+    header: "Choice",
+    question: "Pick one",
+    allowMultiple: false,
+    options: [
+      { label: "Alpha", description: "A" },
+      { label: "Beta", description: "B" },
+    ],
+  }]);
+
+  assert.deepEqual(result, { answers: { choice: { answers: ["Beta"] } } });
+});
+
+test("parseSlackReply handles multiline multi-question answers", () => {
+  const result = parseSlackReply("1\ncustom note", [
+    {
+      id: "first",
+      header: "First",
+      question: "Pick one",
+      allowMultiple: false,
+      options: [
+        { label: "Alpha", description: "A" },
+        { label: "Beta", description: "B" },
+      ],
+    },
+    {
+      id: "second",
+      header: "Second",
+      question: "Explain",
+      allowMultiple: false,
+      options: [
+        { label: "Gamma", description: "G" },
+        { label: "Delta", description: "D" },
+      ],
+    },
+  ]);
+
+  assert.deepEqual(result, {
+    answers: {
+      first: { answers: ["Alpha"] },
+      second: { answers: [], user_note: "custom note" },
+    },
+  });
+});
+
+test("parseDiscordResponse handles single-question reactions", () => {
+  const result = parseDiscordResponse([{ emoji: "2️⃣", count: 1 }], null, [{
+    id: "choice",
+    header: "Choice",
+    question: "Pick one",
+    allowMultiple: false,
+    options: [
+      { label: "Alpha", description: "A" },
+      { label: "Beta", description: "B" },
+    ],
+  }]);
+
+  assert.deepEqual(result, { answers: { choice: { answers: ["Beta"] } } });
+});
+
+test("parseDiscordResponse rejects multi-question reaction parsing", () => {
+  const result = parseDiscordResponse([{ emoji: "1️⃣", count: 1 }], null, [
+    {
+      id: "first",
+      header: "First",
+      question: "Pick one",
+      allowMultiple: false,
+      options: [{ label: "Alpha", description: "A" }],
+    },
+    {
+      id: "second",
+      header: "Second",
+      question: "Pick one",
+      allowMultiple: false,
+      options: [{ label: "Beta", description: "B" }],
+    },
+  ]);
+
+  assert.match(String(result.answers.first.user_note), /single-question prompts/i);
+  assert.match(String(result.answers.second.user_note), /single-question prompts/i);
+});
+
+test("parseSlackReply truncates user_note longer than 500 chars", () => {
+  const longText = "x".repeat(600);
+  const result = parseSlackReply(longText, [{
+    id: "q1",
+    header: "Q1",
+    question: "Pick",
+    allowMultiple: false,
+    options: [{ label: "A", description: "a" }],
+  }]);
+
+  const note = result.answers.q1.user_note!;
+  assert.ok(note.length <= 502, `note should be truncated, got ${note.length} chars`);
+  assert.ok(note.endsWith("…"), "truncated note should end with ellipsis");
+});
+
+test("isValidChannelId rejects invalid Slack channel IDs", () => {
+  // Too short
+  assert.equal(isValidChannelId("slack", "C123"), false);
+  // Contains invalid chars (URL injection)
+  assert.equal(isValidChannelId("slack", "https://evil.com"), false);
+  // Lowercase
+  assert.equal(isValidChannelId("slack", "c12345678"), false);
+  // Too long
+  assert.equal(isValidChannelId("slack", "C1234567890AB"), false);
+  // Valid: 9-12 uppercase alphanumeric
+  assert.equal(isValidChannelId("slack", "C12345678"), true);
+  assert.equal(isValidChannelId("slack", "C12345678AB"), true);
+  assert.equal(isValidChannelId("slack", "C1234567890A"), true);
+});
+
+test("isValidChannelId rejects invalid Discord channel IDs", () => {
+  // Too short
+  assert.equal(isValidChannelId("discord", "12345"), false);
+  // Contains letters (not a snowflake)
+  assert.equal(isValidChannelId("discord", "abc12345678901234"), false);
+  // URL injection
+  assert.equal(isValidChannelId("discord", "https://evil.com"), false);
+  // Too long (21 digits)
+  assert.equal(isValidChannelId("discord", "123456789012345678901"), false);
+  // Valid: 17-20 digit snowflake
+  assert.equal(isValidChannelId("discord", "12345678901234567"), true);
+  assert.equal(isValidChannelId("discord", "11234567890123456789"), true);
+});
+
+test("sanitizeError strips Slack token patterns from error messages", () => {
+  assert.equal(
+    sanitizeError("Auth failed: xoxb-1234-5678-abcdef"),
+    "Auth failed: [REDACTED]",
+  );
+  assert.equal(
+    sanitizeError("Bad token xoxp-abc-def-ghi in request"),
+    "Bad token [REDACTED] in request",
+  );
+});
+
+test("sanitizeError strips long opaque secrets", () => {
+  const fakeDiscordToken = "MTIzNDU2Nzg5MDEyMzQ1Njc4OQ.G1x2y3.abcdefghijklmnop";
+  assert.ok(!sanitizeError(`Token: ${fakeDiscordToken}`).includes(fakeDiscordToken));
+});
+
+test("sanitizeError preserves short safe messages", () => {
+  assert.equal(sanitizeError("HTTP 401: Unauthorized"), "HTTP 401: Unauthorized");
+  assert.equal(sanitizeError("Connection refused"), "Connection refused");
+});
+

package/src/resources/extensions/gsd/tests/remote-status.test.ts

@@ -0,0 +1,99 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { createPromptRecord, writePromptRecord } from "../../remote-questions/store.ts";
+import { getLatestPromptSummary } from "../../remote-questions/status.ts";
+
+function withTempHome(fn: (tempHome: string) => void | Promise<void>) {
+  return async () => {
+    const savedHome = process.env.HOME;
+    const savedUserProfile = process.env.USERPROFILE;
+    const tempHome = join(tmpdir(), `gsd-remote-status-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(join(tempHome, ".gsd", "runtime", "remote-questions"), { recursive: true });
+    process.env.HOME = tempHome;
+    process.env.USERPROFILE = tempHome;
+    try {
+      await fn(tempHome);
+    } finally {
+      process.env.HOME = savedHome;
+      process.env.USERPROFILE = savedUserProfile;
+      rmSync(tempHome, { recursive: true, force: true });
+    }
+  };
+}
+
+test("getLatestPromptSummary returns latest stored prompt", withTempHome(() => {
+  const recordA = createPromptRecord({
+    id: "a-prompt",
+    channel: "slack",
+    createdAt: 1,
+    timeoutAt: 10,
+    pollIntervalMs: 5000,
+    questions: [],
+  });
+  recordA.updatedAt = 1;
+  writePromptRecord(recordA);
+
+  const recordB = createPromptRecord({
+    id: "z-prompt",
+    channel: "discord",
+    createdAt: 2,
+    timeoutAt: 10,
+    pollIntervalMs: 5000,
+    questions: [],
+  });
+  recordB.updatedAt = 2;
+  recordB.status = "answered";
+  writePromptRecord(recordB);
+
+  const latest = getLatestPromptSummary();
+  assert.equal(latest?.id, "z-prompt");
+  assert.equal(latest?.status, "answered");
+}));
+
+test("getLatestPromptSummary sorts by updatedAt, not filename", withTempHome(() => {
+  // Record with alphabetically-LAST id but OLDEST timestamp
+  const old = createPromptRecord({
+    id: "zzz-oldest",
+    channel: "slack",
+    createdAt: 1000,
+    timeoutAt: 9999,
+    pollIntervalMs: 5000,
+    questions: [],
+  });
+  old.updatedAt = 1000;
+  writePromptRecord(old);
+
+  // Record with alphabetically-FIRST id but NEWEST timestamp
+  const newest = createPromptRecord({
+    id: "aaa-newest",
+    channel: "discord",
+    createdAt: 3000,
+    timeoutAt: 9999,
+    pollIntervalMs: 5000,
+    questions: [],
+  });
+  newest.updatedAt = 3000;
+  newest.status = "answered";
+  writePromptRecord(newest);
+
+  // Record in between
+  const middle = createPromptRecord({
+    id: "mmm-middle",
+    channel: "slack",
+    createdAt: 2000,
+    timeoutAt: 9999,
+    pollIntervalMs: 5000,
+    questions: [],
+  });
+  middle.updatedAt = 2000;
+  writePromptRecord(middle);
+
+  const latest = getLatestPromptSummary();
+  // Should return "aaa-newest" (updatedAt=3000), NOT "zzz-oldest" (alphabetically last)
+  assert.equal(latest?.id, "aaa-newest", "should pick the most recently updated prompt, not the alphabetically last filename");
+  assert.equal(latest?.status, "answered");
+  assert.equal(latest?.updatedAt, 3000);
+}));