gsd-pi 2.10.12 → 2.12.0

package/dist/resources/extensions/remote-questions/remote-command.ts

@@ -0,0 +1,361 @@
+/**
+ * Remote Questions — /gsd remote command
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
+import { AuthStorage } from "@gsd/pi-coding-agent";
+import { CURSOR_MARKER, Editor, type EditorTheme, Key, matchesKey, truncateToWidth } from "@gsd/pi-tui";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getGlobalGSDPreferencesPath, loadEffectiveGSDPreferences } from "../gsd/preferences.js";
+import { getRemoteConfigStatus, isValidChannelId, resolveRemoteConfig } from "./config.js";
+import { sanitizeError } from "./manager.js";
+import { getLatestPromptSummary } from "./status.js";
+
+export async function handleRemote(
+  subcommand: string,
+  ctx: ExtensionCommandContext,
+  _pi: ExtensionAPI,
+): Promise<void> {
+  const trimmed = subcommand.trim();
+
+  if (trimmed === "slack") return handleSetupSlack(ctx);
+  if (trimmed === "discord") return handleSetupDiscord(ctx);
+  if (trimmed === "status") return handleRemoteStatus(ctx);
+  if (trimmed === "disconnect") return handleDisconnect(ctx);
+
+  return handleRemoteMenu(ctx);
+}
+
+async function handleSetupSlack(ctx: ExtensionCommandContext): Promise<void> {
+  const token = await promptMaskedInput(ctx, "Slack Bot Token", "Paste your xoxb-... token");
+  if (!token) return void ctx.ui.notify("Slack setup cancelled.", "info");
+  if (!token.startsWith("xoxb-")) return void ctx.ui.notify("Invalid token format — Slack bot tokens start with xoxb-.", "warning");
+
+  ctx.ui.notify("Validating token...", "info");
+  const auth = await fetchJson("https://slack.com/api/auth.test", { headers: { Authorization: `Bearer ${token}` } });
+  if (!auth?.ok) return void ctx.ui.notify("Token validation failed — check the token and app install.", "error");
+
+  const channelId = await promptInput(ctx, "Channel ID", "Paste the Slack channel ID (e.g. C0123456789)");
+  if (!channelId) return void ctx.ui.notify("Slack setup cancelled.", "info");
+  if (!isValidChannelId("slack", channelId)) return void ctx.ui.notify("Invalid Slack channel ID format — expected 9-12 uppercase alphanumeric characters.", "error");
+
+  const send = await fetchJson("https://slack.com/api/chat.postMessage", {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json; charset=utf-8" },
+    body: JSON.stringify({ channel: channelId, text: "GSD remote questions connected." }),
+  });
+  if (!send?.ok) return void ctx.ui.notify(`Could not send to channel: ${send?.error ?? "unknown error"}`, "error");
+
+  saveProviderToken("slack_bot", token);
+  process.env.SLACK_BOT_TOKEN = token;
+  saveRemoteQuestionsConfig("slack", channelId);
+  ctx.ui.notify(`Slack connected — remote questions enabled for channel ${channelId}.`, "info");
+}
+
+async function handleSetupDiscord(ctx: ExtensionCommandContext): Promise<void> {
+  const token = await promptMaskedInput(ctx, "Discord Bot Token", "Paste your bot token");
+  if (!token) return void ctx.ui.notify("Discord setup cancelled.", "info");
+
+  ctx.ui.notify("Validating token...", "info");
+  const headers = { Authorization: `Bot ${token}` };
+  const auth = await fetchJson("https://discord.com/api/v10/users/@me", { headers });
+  if (!auth?.id) return void ctx.ui.notify("Token validation failed — check the bot token.", "error");
+
+  // Fetch guilds the bot is a member of
+  const guilds: Array<{ id: string; name: string }> | null = await fetchJson("https://discord.com/api/v10/users/@me/guilds", { headers });
+  if (!Array.isArray(guilds) || guilds.length === 0) {
+    return void ctx.ui.notify("Bot is not in any Discord servers.", "error");
+  }
+
+  let guildId: string;
+  let guildName: string;
+  if (guilds.length === 1) {
+    guildId = guilds[0].id;
+    guildName = guilds[0].name;
+  } else {
+    const guildOptions = guilds.map((g) => g.name);
+    const selectedGuild = await ctx.ui.select("Select a Discord server", guildOptions);
+    if (!selectedGuild) return void ctx.ui.notify("Discord setup cancelled.", "info");
+    const chosen = guilds.find((g) => g.name === selectedGuild);
+    if (!chosen) return void ctx.ui.notify("Discord setup cancelled.", "info");
+    guildId = chosen.id;
+    guildName = chosen.name;
+  }
+
+  // Fetch text and announcement channels in the selected guild
+  ctx.ui.notify(`Fetching channels for ${guildName}...`, "info");
+  const allChannels: Array<{ id: string; name: string; type: number }> | null = await fetchJson(
+    `https://discord.com/api/v10/guilds/${guildId}/channels`,
+    { headers },
+  );
+  const textChannels = Array.isArray(allChannels)
+    ? allChannels.filter((ch) => ch.type === 0 || ch.type === 5)
+    : [];
+
+  const MANUAL_OPTION = "Enter channel ID manually";
+  let channelId: string;
+
+  if (textChannels.length === 0) {
+    ctx.ui.notify("No text channels found — falling back to manual entry.", "warning");
+    const manualId = await promptInput(ctx, "Channel ID", "Paste the Discord channel ID (e.g. 1234567890123456789)");
+    if (!manualId) return void ctx.ui.notify("Discord setup cancelled.", "info");
+    if (!isValidChannelId("discord", manualId)) return void ctx.ui.notify("Invalid Discord channel ID format — expected 17-20 digit numeric ID.", "error");
+    channelId = manualId;
+  } else {
+    const channelOptions = [...textChannels.map((ch) => `#${ch.name}`), MANUAL_OPTION];
+    const selectedChannel = await ctx.ui.select("Select a channel", channelOptions);
+    if (!selectedChannel) return void ctx.ui.notify("Discord setup cancelled.", "info");
+
+    if (selectedChannel === MANUAL_OPTION) {
+      const manualId = await promptInput(ctx, "Channel ID", "Paste the Discord channel ID (e.g. 1234567890123456789)");
+      if (!manualId) return void ctx.ui.notify("Discord setup cancelled.", "info");
+      if (!isValidChannelId("discord", manualId)) return void ctx.ui.notify("Invalid Discord channel ID format — expected 17-20 digit numeric ID.", "error");
+      channelId = manualId;
+    } else {
+      const chosenChannel = textChannels.find((ch) => `#${ch.name}` === selectedChannel);
+      if (!chosenChannel) return void ctx.ui.notify("Discord setup cancelled.", "info");
+      channelId = chosenChannel.id;
+    }
+  }
+
+  const sendResponse = await fetch(`https://discord.com/api/v10/channels/${channelId}/messages`, {
+    method: "POST",
+    headers: { ...headers, "Content-Type": "application/json" },
+    body: JSON.stringify({ content: "GSD remote questions connected." }),
+    signal: AbortSignal.timeout(15_000),
+  });
+  if (!sendResponse.ok) {
+    const body = await sendResponse.text().catch(() => "");
+    return void ctx.ui.notify(`Could not send to channel (HTTP ${sendResponse.status}): ${sanitizeError(body).slice(0, 200)}`, "error");
+  }
+
+  saveProviderToken("discord_bot", token);
+  process.env.DISCORD_BOT_TOKEN = token;
+  saveRemoteQuestionsConfig("discord", channelId);
+  ctx.ui.notify(`Discord connected — remote questions enabled for channel ${channelId}.`, "info");
+}
+
+async function handleRemoteStatus(ctx: ExtensionCommandContext): Promise<void> {
+  const status = getRemoteConfigStatus();
+  const config = resolveRemoteConfig();
+  if (!config) {
+    ctx.ui.notify(status, status.includes("disabled") ? "warning" : "info");
+    return;
+  }
+
+  const latestPrompt = getLatestPromptSummary();
+  const lines = [status];
+  if (latestPrompt) {
+    lines.push(`Last prompt: ${latestPrompt.id}`);
+    lines.push(`  status: ${latestPrompt.status}`);
+    if (latestPrompt.updatedAt) lines.push(`  updated: ${new Date(latestPrompt.updatedAt).toLocaleString()}`);
+  }
+
+  ctx.ui.notify(lines.join("\n"), "info");
+}
+
+async function handleDisconnect(ctx: ExtensionCommandContext): Promise<void> {
+  const prefs = loadEffectiveGSDPreferences();
+  const channel = prefs?.preferences.remote_questions?.channel;
+  if (!channel) return void ctx.ui.notify("No remote channel configured — nothing to disconnect.", "info");
+
+  removeRemoteQuestionsConfig();
+  removeProviderToken(channel === "slack" ? "slack_bot" : "discord_bot");
+  if (channel === "slack") delete process.env.SLACK_BOT_TOKEN;
+  if (channel === "discord") delete process.env.DISCORD_BOT_TOKEN;
+  ctx.ui.notify(`Remote questions disconnected (${channel}).`, "info");
+}
+
+async function handleRemoteMenu(ctx: ExtensionCommandContext): Promise<void> {
+  const config = resolveRemoteConfig();
+  const latestPrompt = getLatestPromptSummary();
+  const lines = config
+    ? [
+        `Remote questions: ${config.channel} configured`,
+        `  Timeout: ${config.timeoutMs / 60000}m, poll: ${config.pollIntervalMs / 1000}s`,
+        latestPrompt ? `  Last prompt: ${latestPrompt.id} (${latestPrompt.status})` : "  No remote prompts recorded yet",
+        "",
+        "Commands:",
+        "  /gsd remote status",
+        "  /gsd remote disconnect",
+        "  /gsd remote slack",
+        "  /gsd remote discord",
+      ]
+    : [
+        "No remote question channel configured.",
+        "",
+        "Commands:",
+        "  /gsd remote slack",
+        "  /gsd remote discord",
+        "  /gsd remote status",
+      ];
+
+  ctx.ui.notify(lines.join("\n"), "info");
+}
+
+async function fetchJson(url: string, init?: RequestInit): Promise<any> {
+  try {
+    const response = await fetch(url, { ...init, signal: AbortSignal.timeout(15_000) });
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+
+function getAuthStorage(): AuthStorage {
+  const authPath = join(process.env.HOME ?? "", ".gsd", "agent", "auth.json");
+  mkdirSync(dirname(authPath), { recursive: true });
+  return AuthStorage.create(authPath);
+}
+
+function saveProviderToken(provider: string, token: string): void {
+  const auth = getAuthStorage();
+  auth.set(provider, { type: "api_key", key: token });
+}
+
+function removeProviderToken(provider: string): void {
+  const auth = getAuthStorage();
+  auth.set(provider, { type: "api_key", key: "" });
+}
+
+export function saveRemoteQuestionsConfig(channel: "slack" | "discord", channelId: string): void {
+  const prefsPath = getGlobalGSDPreferencesPath();
+  const block = [
+    "remote_questions:",
+    `  channel: ${channel}`,
+    `  channel_id: \"${channelId}\"`,
+    "  timeout_minutes: 5",
+    "  poll_interval_seconds: 5",
+  ].join("\n");
+
+  const content = existsSync(prefsPath) ? readFileSync(prefsPath, "utf-8") : "";
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  let next = content;
+
+  if (fmMatch) {
+    let frontmatter = fmMatch[1];
+    const regex = /remote_questions:[\s\S]*?(?=\n[a-zA-Z_]|\n---|$)/;
+    frontmatter = regex.test(frontmatter) ? frontmatter.replace(regex, block) : `${frontmatter.trimEnd()}\n${block}`;
+    next = `---\n${frontmatter}\n---${content.slice(fmMatch[0].length)}`;
+  } else {
+    next = `---\n${block}\n---\n\n${content}`;
+  }
+
+  mkdirSync(dirname(prefsPath), { recursive: true });
+  writeFileSync(prefsPath, next, "utf-8");
+}
+
+function removeRemoteQuestionsConfig(): void {
+  const prefsPath = getGlobalGSDPreferencesPath();
+  if (!existsSync(prefsPath)) return;
+  const content = readFileSync(prefsPath, "utf-8");
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch) return;
+  const frontmatter = fmMatch[1].replace(/remote_questions:[\s\S]*?(?=\n[a-zA-Z_]|\n---|$)/, "").trim();
+  const next = frontmatter ? `---\n${frontmatter}\n---${content.slice(fmMatch[0].length)}` : content.slice(fmMatch[0].length).replace(/^\n+/, "");
+  writeFileSync(prefsPath, next, "utf-8");
+}
+
+function maskEditorLine(line: string): string {
+  let output = "";
+  let i = 0;
+  while (i < line.length) {
+    if (line.startsWith(CURSOR_MARKER, i)) {
+      output += CURSOR_MARKER;
+      i += CURSOR_MARKER.length;
+      continue;
+    }
+    const ansiMatch = /^\x1b\[[0-9;]*m/.exec(line.slice(i));
+    if (ansiMatch) {
+      output += ansiMatch[0];
+      i += ansiMatch[0].length;
+      continue;
+    }
+    output += line[i] === " " ? " " : "*";
+    i += 1;
+  }
+  return output;
+}
+
+async function promptMaskedInput(ctx: ExtensionCommandContext, label: string, hint: string): Promise<string | null> {
+  if (!ctx.hasUI) return null;
+  return ctx.ui.custom<string | null>((tui: any, theme: any, _kb: any, done: (r: string | null) => void) => {
+    let cachedLines: string[] | undefined;
+    const editorTheme: EditorTheme = {
+      borderColor: (s: string) => theme.fg("accent", s),
+      selectList: {
+        selectedPrefix: (t: string) => theme.fg("accent", t),
+        selectedText: (t: string) => theme.fg("accent", t),
+        description: (t: string) => theme.fg("muted", t),
+        scrollInfo: (t: string) => theme.fg("dim", t),
+        noMatch: (t: string) => theme.fg("warning", t),
+      },
+    };
+    const editor = new Editor(tui, editorTheme, { paddingX: 1 });
+    const refresh = () => { cachedLines = undefined; tui.requestRender(); };
+    const handleInput = (data: string) => {
+      if (matchesKey(data, Key.enter)) return done(editor.getText().trim() || null);
+      if (matchesKey(data, Key.escape)) return done(null);
+      editor.handleInput(data); refresh();
+    };
+    const render = (width: number) => {
+      if (cachedLines) return cachedLines;
+      const lines: string[] = [];
+      const add = (s: string) => lines.push(truncateToWidth(s, width));
+      add(theme.fg("accent", "─".repeat(width)));
+      add(theme.fg("accent", theme.bold(` ${label}`)));
+      add(theme.fg("muted", `  ${hint}`));
+      lines.push("");
+      add(theme.fg("muted", " Enter value:"));
+      for (const line of editor.render(width - 2)) add(theme.fg("text", maskEditorLine(line)));
+      lines.push("");
+      add(theme.fg("dim", " enter to confirm  |  esc to cancel"));
+      add(theme.fg("accent", "─".repeat(width)));
+      cachedLines = lines;
+      return lines;
+    };
+    return { render, handleInput, invalidate: () => { cachedLines = undefined; } };
+  });
+}
+
+async function promptInput(ctx: ExtensionCommandContext, label: string, hint: string): Promise<string | null> {
+  if (!ctx.hasUI) return null;
+  return ctx.ui.custom<string | null>((tui: any, theme: any, _kb: any, done: (r: string | null) => void) => {
+    let cachedLines: string[] | undefined;
+    const editorTheme: EditorTheme = {
+      borderColor: (s: string) => theme.fg("accent", s),
+      selectList: {
+        selectedPrefix: (t: string) => theme.fg("accent", t),
+        selectedText: (t: string) => theme.fg("accent", t),
+        description: (t: string) => theme.fg("muted", t),
+        scrollInfo: (t: string) => theme.fg("dim", t),
+        noMatch: (t: string) => theme.fg("warning", t),
+      },
+    };
+    const editor = new Editor(tui, editorTheme, { paddingX: 1 });
+    const refresh = () => { cachedLines = undefined; tui.requestRender(); };
+    const handleInput = (data: string) => {
+      if (matchesKey(data, Key.enter)) return done(editor.getText().trim() || null);
+      if (matchesKey(data, Key.escape)) return done(null);
+      editor.handleInput(data); refresh();
+    };
+    const render = (width: number) => {
+      if (cachedLines) return cachedLines;
+      const lines: string[] = [];
+      const add = (s: string) => lines.push(truncateToWidth(s, width));
+      add(theme.fg("accent", "─".repeat(width)));
+      add(theme.fg("accent", theme.bold(` ${label}`)));
+      add(theme.fg("muted", `  ${hint}`));
+      lines.push("");
+      add(theme.fg("muted", " Enter value:"));
+      for (const line of editor.render(width - 2)) add(theme.fg("text", line));
+      lines.push("");
+      add(theme.fg("dim", " enter to confirm  |  esc to cancel"));
+      add(theme.fg("accent", "─".repeat(width)));
+      cachedLines = lines;
+      return lines;
+    };
+    return { render, handleInput, invalidate: () => { cachedLines = undefined; } };
+  });
+}

package/dist/resources/extensions/remote-questions/slack-adapter.ts

@@ -0,0 +1,92 @@
+/**
+ * Remote Questions — Slack adapter
+ */
+
+import type { ChannelAdapter, RemotePrompt, RemoteDispatchResult, RemoteAnswer, RemotePromptRef } from "./types.js";
+import { formatForSlack, parseSlackReply } from "./format.js";
+
+const SLACK_API = "https://slack.com/api";
+const PER_REQUEST_TIMEOUT_MS = 15_000;
+
+export class SlackAdapter implements ChannelAdapter {
+  readonly name = "slack" as const;
+  private botUserId: string | null = null;
+  private readonly token: string;
+  private readonly channelId: string;
+
+  constructor(token: string, channelId: string) {
+    this.token = token;
+    this.channelId = channelId;
+  }
+
+  async validate(): Promise<void> {
+    const res = await this.slackApi("auth.test", {});
+    if (!res.ok) throw new Error(`Slack auth failed: ${res.error ?? "invalid token"}`);
+    this.botUserId = String(res.user_id ?? "");
+  }
+
+  async sendPrompt(prompt: RemotePrompt): Promise<RemoteDispatchResult> {
+    const res = await this.slackApi("chat.postMessage", {
+      channel: this.channelId,
+      text: "GSD needs your input",
+      blocks: formatForSlack(prompt),
+    });
+
+    if (!res.ok) throw new Error(`Slack postMessage failed: ${res.error ?? "unknown"}`);
+
+    const ts = String(res.ts);
+    const channel = String(res.channel);
+    return {
+      ref: {
+        id: prompt.id,
+        channel: "slack",
+        messageId: ts,
+        threadTs: ts,
+        channelId: channel,
+        threadUrl: `https://slack.com/archives/${channel}/p${ts.replace(".", "")}`,
+      },
+    };
+  }
+
+  async pollAnswer(prompt: RemotePrompt, ref: RemotePromptRef): Promise<RemoteAnswer | null> {
+    if (!this.botUserId) await this.validate();
+
+    const res = await this.slackApi("conversations.replies", {
+      channel: ref.channelId,
+      ts: ref.threadTs!,
+      limit: "20",
+    });
+
+    if (!res.ok) return null;
+
+    const messages = (res.messages ?? []) as Array<{ user?: string; text?: string; ts: string }>;
+    const userReplies = messages.filter((m) => m.ts !== ref.threadTs && m.user && m.user !== this.botUserId && m.text);
+    if (userReplies.length === 0) return null;
+
+    return parseSlackReply(String(userReplies[0].text), prompt.questions);
+  }
+
+  private async slackApi(method: string, params: Record<string, unknown>): Promise<Record<string, unknown>> {
+    const url = `${SLACK_API}/${method}`;
+    const isGet = method === "conversations.replies" || method === "auth.test";
+
+    let response: Response;
+    if (isGet) {
+      const qs = new URLSearchParams(Object.fromEntries(Object.entries(params).map(([k, v]) => [k, String(v)]))).toString();
+      response = await fetch(`${url}?${qs}`, { method: "GET", headers: { Authorization: `Bearer ${this.token}` }, signal: AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS) });
+    } else {
+      response = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          "Content-Type": "application/json; charset=utf-8",
+        },
+        body: JSON.stringify(params),
+        signal: AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS),
+      });
+    }
+
+    if (!response.ok) throw new Error(`Slack API HTTP ${response.status}: ${response.statusText}`);
+    return (await response.json()) as Record<string, unknown>;
+  }
+}

package/dist/resources/extensions/remote-questions/status.ts

@@ -0,0 +1,31 @@
+/**
+ * Remote Questions — status helpers
+ */
+
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { readPromptRecord } from "./store.js";
+
+export interface LatestPromptSummary {
+  id: string;
+  status: string;
+  updatedAt: number;
+}
+
+export function getLatestPromptSummary(): LatestPromptSummary | null {
+  const runtimeDir = join(homedir(), ".gsd", "runtime", "remote-questions");
+  if (!existsSync(runtimeDir)) return null;
+  const files = readdirSync(runtimeDir).filter((f) => f.endsWith(".json"));
+  if (files.length === 0) return null;
+
+  let latest: LatestPromptSummary | null = null;
+  for (const file of files) {
+    const record = readPromptRecord(file.replace(/\.json$/, ""));
+    if (!record) continue;
+    if (!latest || record.updatedAt > latest.updatedAt) {
+      latest = { id: record.id, status: record.status, updatedAt: record.updatedAt };
+    }
+  }
+  return latest;
+}

package/dist/resources/extensions/remote-questions/store.ts

@@ -0,0 +1,77 @@
+/**
+ * Remote Questions — durable prompt store
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import type { RemotePrompt, RemotePromptRecord, RemotePromptRef, RemoteAnswer, RemotePromptStatus } from "./types.js";
+
+function runtimeDir(): string {
+  return join(homedir(), ".gsd", "runtime", "remote-questions");
+}
+
+function recordPath(id: string): string {
+  return join(runtimeDir(), `${id}.json`);
+}
+
+export function createPromptRecord(prompt: RemotePrompt): RemotePromptRecord {
+  return {
+    version: 1,
+    id: prompt.id,
+    createdAt: prompt.createdAt,
+    updatedAt: Date.now(),
+    status: "pending",
+    channel: prompt.channel,
+    timeoutAt: prompt.timeoutAt,
+    pollIntervalMs: prompt.pollIntervalMs,
+    questions: prompt.questions,
+    context: prompt.context,
+  };
+}
+
+export function writePromptRecord(record: RemotePromptRecord): void {
+  mkdirSync(runtimeDir(), { recursive: true });
+  writeFileSync(recordPath(record.id), JSON.stringify(record, null, 2) + "\n", "utf-8");
+}
+
+export function readPromptRecord(id: string): RemotePromptRecord | null {
+  const path = recordPath(id);
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8")) as RemotePromptRecord;
+  } catch {
+    return null;
+  }
+}
+
+export function updatePromptRecord(
+  id: string,
+  updates: Partial<RemotePromptRecord>,
+): RemotePromptRecord | null {
+  const current = readPromptRecord(id);
+  if (!current) return null;
+  const next: RemotePromptRecord = {
+    ...current,
+    ...updates,
+    updatedAt: Date.now(),
+  };
+  writePromptRecord(next);
+  return next;
+}
+
+export function markPromptDispatched(id: string, ref: RemotePromptRef): RemotePromptRecord | null {
+  return updatePromptRecord(id, { ref, status: "pending" });
+}
+
+export function markPromptAnswered(id: string, response: RemoteAnswer): RemotePromptRecord | null {
+  return updatePromptRecord(id, { response, status: "answered", lastPollAt: Date.now() });
+}
+
+export function markPromptStatus(id: string, status: RemotePromptStatus, lastError?: string): RemotePromptRecord | null {
+  return updatePromptRecord(id, {
+    status,
+    lastPollAt: Date.now(),
+    ...(lastError ? { lastError } : {}),
+  });
+}

package/dist/resources/extensions/remote-questions/types.ts

@@ -0,0 +1,75 @@
+/**
+ * Remote Questions — shared types
+ */
+
+export type RemoteChannel = "slack" | "discord";
+
+export interface RemoteQuestionOption {
+  label: string;
+  description: string;
+}
+
+export interface RemoteQuestion {
+  id: string;
+  header: string;
+  question: string;
+  options: RemoteQuestionOption[];
+  allowMultiple: boolean;
+}
+
+export interface RemotePrompt {
+  id: string;
+  channel: RemoteChannel;
+  createdAt: number;
+  timeoutAt: number;
+  pollIntervalMs: number;
+  questions: RemoteQuestion[];
+  context?: {
+    source: string;
+  };
+}
+
+export interface RemotePromptRef {
+  id: string;
+  channel: RemoteChannel;
+  messageId: string;
+  channelId: string;
+  threadTs?: string;
+  threadUrl?: string;
+}
+
+export interface RemoteAnswer {
+  answers: Record<string, { answers: string[]; user_note?: string }>;
+}
+
+export type RemotePromptStatus = "pending" | "answered" | "timed_out" | "failed" | "cancelled";
+
+export interface RemotePromptRecord {
+  version: 1;
+  id: string;
+  createdAt: number;
+  updatedAt: number;
+  status: RemotePromptStatus;
+  channel: RemoteChannel;
+  timeoutAt: number;
+  pollIntervalMs: number;
+  questions: RemoteQuestion[];
+  ref?: RemotePromptRef;
+  response?: RemoteAnswer;
+  lastPollAt?: number;
+  lastError?: string;
+  context?: {
+    source: string;
+  };
+}
+
+export interface RemoteDispatchResult {
+  ref: RemotePromptRef;
+}
+
+export interface ChannelAdapter {
+  readonly name: RemoteChannel;
+  validate(): Promise<void>;
+  sendPrompt(prompt: RemotePrompt): Promise<RemoteDispatchResult>;
+  pollAnswer(prompt: RemotePrompt, ref: RemotePromptRef): Promise<RemoteAnswer | null>;
+}