gsd-pi 2.10.12 → 2.12.0

package/dist/resources/extensions/gsd/worktree.d.ts

@@ -1,106 +0,0 @@
-/**
- * GSD Slice Branch Management — Thin Facade
- *
- * Simple branch-per-slice workflow. No worktrees, no registry.
- * Runtime state (metrics, activity, lock, STATE.md) is gitignored
- * so branch switches are clean.
- *
- * All git-mutation functions delegate to GitServiceImpl from git-service.ts.
- * Pure utility functions (detectWorktreeName, getSliceBranchName, parseSliceBranch,
- * SLICE_BRANCH_RE) remain standalone.
- *
- * Flow:
- *   1. ensureSliceBranch() — create + checkout slice branch
- *   2. agent does work, commits
- *   3. mergeSliceToMain() — checkout integration branch, squash-merge, delete slice branch
- */
-export type { MergeSliceResult } from "./git-service.js";
-export { MergeConflictError } from "./git-service.js";
-/**
- * Set the active milestone ID on the cached GitServiceImpl.
- * This enables integration branch resolution in getMainBranch().
- */
-export declare function setActiveMilestoneId(basePath: string, milestoneId: string | null): void;
-/**
- * Record the current branch as the integration branch for a milestone.
- * Called once when auto-mode starts — captures where slice branches should
- * merge back to. No-op if the same branch is already recorded. Updates the
- * record when the user starts from a different branch (#300). Always a no-op
- * if on a GSD slice branch.
- */
-export declare function captureIntegrationBranch(basePath: string, milestoneId: string): void;
-/**
- * Detect the active worktree name from the current working directory.
- * Returns null if not inside a GSD worktree (.gsd/worktrees/<name>/).
- */
-export declare function detectWorktreeName(basePath: string): string | null;
-/**
- * Get the slice branch name, namespaced by worktree when inside one.
- *
- * In the main tree:     gsd/<milestoneId>/<sliceId>
- * In a worktree:        gsd/<worktreeName>/<milestoneId>/<sliceId>
- *
- * This prevents branch conflicts when multiple worktrees work on the
- * same milestone/slice IDs — git doesn't allow a branch to be checked
- * out in more than one worktree simultaneously.
- */
-export declare function getSliceBranchName(milestoneId: string, sliceId: string, worktreeName?: string | null): string;
-/** Regex that matches both plain and worktree-namespaced slice branches. */
-export declare const SLICE_BRANCH_RE: RegExp;
-/**
- * Parse a slice branch name into its components.
- * Handles both `gsd/M001/S01` and `gsd/myworktree/M001/S01`.
- */
-export declare function parseSliceBranch(branchName: string): {
-    worktreeName: string | null;
-    milestoneId: string;
-    sliceId: string;
-} | null;
-/**
- * Get the "main" branch for GSD slice operations.
- *
- * In the main working tree: returns main/master (the repo's default branch).
- * In a worktree: returns worktree/<name> — the worktree's own base branch.
- *
- * This is critical because git doesn't allow a branch to be checked out
- * in more than one worktree. Slice branches merge into the worktree's base
- * branch, and the worktree branch later merges into the real main via
- * /worktree merge.
- */
-export declare function getMainBranch(basePath: string): string;
-export declare function getCurrentBranch(basePath: string): string;
-/**
- * Ensure the slice branch exists and is checked out.
- * Creates the branch from the current branch if it's not a slice branch,
- * otherwise from main. This preserves planning artifacts (CONTEXT, ROADMAP,
- * etc.) that were committed on the working branch — which may differ from
- * the repo's default branch (e.g. `developer` vs `main`).
- * When inside a worktree, the branch is namespaced to avoid conflicts.
- * Returns true if the branch was newly created.
- */
-export declare function ensureSliceBranch(basePath: string, milestoneId: string, sliceId: string): boolean;
-/**
- * Auto-commit any dirty files in the current working tree.
- * Returns the commit message used, or null if already clean.
- */
-export declare function autoCommitCurrentBranch(basePath: string, unitType: string, unitId: string): string | null;
-/**
- * Switch to the integration branch, auto-committing any dirty files on the current branch first.
- */
-export declare function switchToMain(basePath: string): void;
-/**
- * Squash-merge a completed slice branch into the integration branch.
- * Expects to already be on the integration branch (call switchToMain first).
- * Deletes the slice branch after merge.
- */
-export declare function mergeSliceToMain(basePath: string, milestoneId: string, sliceId: string, sliceTitle: string): import("./git-service.ts").MergeSliceResult;
-/**
- * Check if we're currently on a slice branch (not main).
- * Handles both plain (gsd/M001/S01) and worktree-namespaced (gsd/wt/M001/S01) branches.
- */
-export declare function isOnSliceBranch(basePath: string): boolean;
-/**
- * Get the active slice branch name, or null if on main.
- * Handles both plain and worktree-namespaced branch patterns.
- */
-export declare function getActiveSliceBranch(basePath: string): string | null;

package/dist/resources/extensions/remote-questions/config.d.ts

@@ -1,14 +0,0 @@
-/**
- * Remote Questions — configuration resolution and validation
- */
-import type { RemoteChannel } from "./types.js";
-export interface ResolvedConfig {
-    channel: RemoteChannel;
-    channelId: string;
-    timeoutMs: number;
-    pollIntervalMs: number;
-    token: string;
-}
-export declare function resolveRemoteConfig(): ResolvedConfig | null;
-export declare function getRemoteConfigStatus(): string;
-export declare function isValidChannelId(channel: RemoteChannel, id: string): boolean;

package/dist/resources/extensions/remote-questions/config.js

@@ -1,68 +0,0 @@
-/**
- * Remote Questions — configuration resolution and validation
- */
-import { loadEffectiveGSDPreferences } from "../gsd/preferences.js";
-const ENV_KEYS = {
-    slack: "SLACK_BOT_TOKEN",
-    discord: "DISCORD_BOT_TOKEN",
-};
-// Channel ID format validation — prevents SSRF if preferences are attacker-controlled
-const CHANNEL_ID_PATTERNS = {
-    slack: /^[A-Z0-9]{9,12}$/,
-    discord: /^\d{17,20}$/,
-};
-const DEFAULT_TIMEOUT_MINUTES = 5;
-const DEFAULT_POLL_INTERVAL_SECONDS = 5;
-const MIN_TIMEOUT_MINUTES = 1;
-const MAX_TIMEOUT_MINUTES = 30;
-const MIN_POLL_INTERVAL_SECONDS = 2;
-const MAX_POLL_INTERVAL_SECONDS = 30;
-export function resolveRemoteConfig() {
-    const prefs = loadEffectiveGSDPreferences();
-    const rq = prefs?.preferences.remote_questions;
-    if (!rq || !rq.channel || !rq.channel_id)
-        return null;
-    if (rq.channel !== "slack" && rq.channel !== "discord")
-        return null;
-    const channelId = String(rq.channel_id);
-    if (!CHANNEL_ID_PATTERNS[rq.channel].test(channelId))
-        return null;
-    const token = process.env[ENV_KEYS[rq.channel]];
-    if (!token)
-        return null;
-    const timeoutMinutes = clampNumber(rq.timeout_minutes, DEFAULT_TIMEOUT_MINUTES, MIN_TIMEOUT_MINUTES, MAX_TIMEOUT_MINUTES);
-    const pollIntervalSeconds = clampNumber(rq.poll_interval_seconds, DEFAULT_POLL_INTERVAL_SECONDS, MIN_POLL_INTERVAL_SECONDS, MAX_POLL_INTERVAL_SECONDS);
-    return {
-        channel: rq.channel,
-        channelId,
-        timeoutMs: timeoutMinutes * 60 * 1000,
-        pollIntervalMs: pollIntervalSeconds * 1000,
-        token,
-    };
-}
-export function getRemoteConfigStatus() {
-    const prefs = loadEffectiveGSDPreferences();
-    const rq = prefs?.preferences.remote_questions;
-    if (!rq || !rq.channel || !rq.channel_id)
-        return "Remote questions: not configured";
-    if (rq.channel !== "slack" && rq.channel !== "discord")
-        return `Remote questions: unknown channel type \"${rq.channel}\"`;
-    const channelId = String(rq.channel_id);
-    if (!CHANNEL_ID_PATTERNS[rq.channel].test(channelId))
-        return `Remote questions: invalid ${rq.channel} channel ID format`;
-    const envVar = ENV_KEYS[rq.channel];
-    if (!process.env[envVar])
-        return `Remote questions: ${envVar} not set — remote questions disabled`;
-    const timeoutMinutes = clampNumber(rq.timeout_minutes, DEFAULT_TIMEOUT_MINUTES, MIN_TIMEOUT_MINUTES, MAX_TIMEOUT_MINUTES);
-    const pollIntervalSeconds = clampNumber(rq.poll_interval_seconds, DEFAULT_POLL_INTERVAL_SECONDS, MIN_POLL_INTERVAL_SECONDS, MAX_POLL_INTERVAL_SECONDS);
-    return `Remote questions: ${rq.channel} configured (timeout ${timeoutMinutes}m, poll ${pollIntervalSeconds}s)`;
-}
-export function isValidChannelId(channel, id) {
-    return CHANNEL_ID_PATTERNS[channel].test(id);
-}
-function clampNumber(value, fallback, min, max) {
-    const n = typeof value === "number" ? value : Number(value);
-    if (!Number.isFinite(n))
-        return fallback;
-    return Math.max(min, Math.min(max, n));
-}

package/dist/resources/extensions/remote-questions/discord-adapter.d.ts

@@ -1,17 +0,0 @@
-/**
- * Remote Questions — Discord adapter
- */
-import type { ChannelAdapter, RemotePrompt, RemoteDispatchResult, RemoteAnswer, RemotePromptRef } from "./types.js";
-export declare class DiscordAdapter implements ChannelAdapter {
-    readonly name: "discord";
-    private botUserId;
-    private readonly token;
-    private readonly channelId;
-    constructor(token: string, channelId: string);
-    validate(): Promise<void>;
-    sendPrompt(prompt: RemotePrompt): Promise<RemoteDispatchResult>;
-    pollAnswer(prompt: RemotePrompt, ref: RemotePromptRef): Promise<RemoteAnswer | null>;
-    private checkReactions;
-    private checkReplies;
-    private discordApi;
-}

package/dist/resources/extensions/remote-questions/discord-adapter.js

@@ -1,118 +0,0 @@
-/**
- * Remote Questions — Discord adapter
- */
-import { formatForDiscord, parseDiscordResponse } from "./format.js";
-const DISCORD_API = "https://discord.com/api/v10";
-const PER_REQUEST_TIMEOUT_MS = 15_000;
-const NUMBER_EMOJIS = ["1️⃣", "2️⃣", "3️⃣", "4️⃣", "5️⃣"];
-export class DiscordAdapter {
-    name = "discord";
-    botUserId = null;
-    token;
-    channelId;
-    constructor(token, channelId) {
-        this.token = token;
-        this.channelId = channelId;
-    }
-    async validate() {
-        const res = await this.discordApi("GET", "/users/@me");
-        if (!res.id)
-            throw new Error("Discord auth failed: invalid token");
-        this.botUserId = String(res.id);
-    }
-    async sendPrompt(prompt) {
-        const { embeds, reactionEmojis } = formatForDiscord(prompt);
-        const res = await this.discordApi("POST", `/channels/${this.channelId}/messages`, {
-            content: "**GSD needs your input** — reply to this message with your answer",
-            embeds,
-        });
-        if (!res.id)
-            throw new Error(`Discord send failed: ${JSON.stringify(res)}`);
-        const messageId = String(res.id);
-        if (prompt.questions.length === 1) {
-            for (const emoji of reactionEmojis) {
-                try {
-                    await this.discordApi("PUT", `/channels/${this.channelId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}/@me`);
-                }
-                catch {
-                    // Best-effort only
-                }
-            }
-        }
-        return {
-            ref: {
-                id: prompt.id,
-                channel: "discord",
-                messageId,
-                channelId: this.channelId,
-            },
-        };
-    }
-    async pollAnswer(prompt, ref) {
-        if (!this.botUserId)
-            await this.validate();
-        if (prompt.questions.length === 1) {
-            const reactionAnswer = await this.checkReactions(prompt, ref);
-            if (reactionAnswer)
-                return reactionAnswer;
-        }
-        return this.checkReplies(prompt, ref);
-    }
-    async checkReactions(prompt, ref) {
-        const reactions = [];
-        for (const emoji of NUMBER_EMOJIS) {
-            try {
-                const users = await this.discordApi("GET", `/channels/${ref.channelId}/messages/${ref.messageId}/reactions/${encodeURIComponent(emoji)}`);
-                if (Array.isArray(users)) {
-                    const humanUsers = users.filter((u) => u.id !== this.botUserId);
-                    if (humanUsers.length > 0)
-                        reactions.push({ emoji, count: humanUsers.length });
-                }
-            }
-            catch (err) {
-                const msg = String(err.message ?? "");
-                // 404 = no reactions for this emoji — expected, continue
-                if (msg.includes("HTTP 404"))
-                    continue;
-                // 401/403 = auth failure — surface to caller so it can fail the poll
-                if (msg.includes("HTTP 401") || msg.includes("HTTP 403"))
-                    throw err;
-                // Other errors (rate limit, network) — skip this emoji, best-effort
-            }
-        }
-        if (reactions.length === 0)
-            return null;
-        return parseDiscordResponse(reactions, null, prompt.questions);
-    }
-    async checkReplies(prompt, ref) {
-        const messages = await this.discordApi("GET", `/channels/${ref.channelId}/messages?after=${ref.messageId}&limit=10`);
-        if (!Array.isArray(messages))
-            return null;
-        const replies = messages.filter((m) => m.author?.id &&
-            m.author.id !== this.botUserId &&
-            m.message_reference?.message_id === ref.messageId &&
-            m.content);
-        if (replies.length === 0)
-            return null;
-        return parseDiscordResponse([], String(replies[0].content), prompt.questions);
-    }
-    async discordApi(method, path, body) {
-        const headers = { Authorization: `Bot ${this.token}` };
-        const init = { method, headers };
-        if (body) {
-            headers["Content-Type"] = "application/json";
-            init.body = JSON.stringify(body);
-        }
-        init.signal = AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS);
-        const response = await fetch(`${DISCORD_API}${path}`, init);
-        if (response.status === 204)
-            return {};
-        if (!response.ok) {
-            const text = await response.text().catch(() => "");
-            // Limit error body length to avoid leaking verbose Discord error responses
-            const safeText = text.length > 200 ? text.slice(0, 200) + "…" : text;
-            throw new Error(`Discord API HTTP ${response.status}: ${safeText}`);
-        }
-        return response.json();
-    }
-}

package/dist/resources/extensions/remote-questions/format.d.ts

@@ -1,38 +0,0 @@
-/**
- * Remote Questions — payload formatting and parsing helpers
- */
-import type { RemotePrompt, RemoteQuestion, RemoteAnswer } from "./types.js";
-export interface SlackBlock {
-    type: string;
-    text?: {
-        type: string;
-        text: string;
-    };
-    elements?: Array<{
-        type: string;
-        text: string;
-    }>;
-}
-export interface DiscordEmbed {
-    title: string;
-    description: string;
-    color: number;
-    fields: Array<{
-        name: string;
-        value: string;
-        inline?: boolean;
-    }>;
-    footer?: {
-        text: string;
-    };
-}
-export declare function formatForSlack(prompt: RemotePrompt): SlackBlock[];
-export declare function formatForDiscord(prompt: RemotePrompt): {
-    embeds: DiscordEmbed[];
-    reactionEmojis: string[];
-};
-export declare function parseSlackReply(text: string, questions: RemoteQuestion[]): RemoteAnswer;
-export declare function parseDiscordResponse(reactions: Array<{
-    emoji: string;
-    count: number;
-}>, replyText: string | null, questions: RemoteQuestion[]): RemoteAnswer;

package/dist/resources/extensions/remote-questions/format.js

@@ -1,119 +0,0 @@
-/**
- * Remote Questions — payload formatting and parsing helpers
- */
-const NUMBER_EMOJIS = ["1️⃣", "2️⃣", "3️⃣", "4️⃣", "5️⃣"];
-const MAX_USER_NOTE_LENGTH = 500;
-export function formatForSlack(prompt) {
-    const blocks = [
-        {
-            type: "header",
-            text: { type: "plain_text", text: "GSD needs your input" },
-        },
-    ];
-    for (const q of prompt.questions) {
-        blocks.push({
-            type: "section",
-            text: { type: "mrkdwn", text: `*${q.header}*\n${q.question}` },
-        });
-        blocks.push({
-            type: "section",
-            text: {
-                type: "mrkdwn",
-                text: q.options.map((opt, i) => `${i + 1}. *${opt.label}* — ${opt.description}`).join("\n"),
-            },
-        });
-        blocks.push({
-            type: "context",
-            elements: [{
-                    type: "mrkdwn",
-                    text: q.allowMultiple
-                        ? "Reply in thread with comma-separated numbers (`1,3`) or free text."
-                        : "Reply in thread with a number (`1`) or free text.",
-                }],
-        });
-        blocks.push({ type: "divider" });
-    }
-    return blocks;
-}
-export function formatForDiscord(prompt) {
-    const reactionEmojis = [];
-    const embeds = prompt.questions.map((q, questionIndex) => {
-        const supportsReactions = prompt.questions.length === 1;
-        const optionLines = q.options.map((opt, i) => {
-            const emoji = NUMBER_EMOJIS[i] ?? `${i + 1}.`;
-            if (supportsReactions && NUMBER_EMOJIS[i])
-                reactionEmojis.push(NUMBER_EMOJIS[i]);
-            return `${emoji} **${opt.label}** — ${opt.description}`;
-        });
-        const footerText = supportsReactions
-            ? (q.allowMultiple
-                ? "Reply with comma-separated choices (`1,3`) or react with matching numbers"
-                : "Reply with a number or react with the matching number")
-            : `Question ${questionIndex + 1}/${prompt.questions.length} — reply with one line per question or use semicolons`;
-        return {
-            title: q.header,
-            description: q.question,
-            color: 0x7c3aed,
-            fields: [{ name: "Options", value: optionLines.join("\n") }],
-            footer: { text: footerText },
-        };
-    });
-    return { embeds, reactionEmojis };
-}
-export function parseSlackReply(text, questions) {
-    const answers = {};
-    const trimmed = text.trim();
-    if (questions.length === 1) {
-        answers[questions[0].id] = parseAnswerForQuestion(trimmed, questions[0]);
-        return { answers };
-    }
-    const parts = trimmed.includes(";")
-        ? trimmed.split(";").map((s) => s.trim()).filter(Boolean)
-        : trimmed.split("\n").map((s) => s.trim()).filter(Boolean);
-    for (let i = 0; i < questions.length; i++) {
-        answers[questions[i].id] = parseAnswerForQuestion(parts[i] ?? "", questions[i]);
-    }
-    return { answers };
-}
-export function parseDiscordResponse(reactions, replyText, questions) {
-    if (replyText)
-        return parseSlackReply(replyText, questions);
-    const answers = {};
-    if (questions.length !== 1) {
-        for (const q of questions) {
-            answers[q.id] = { answers: [], user_note: "Discord reactions are only supported for single-question prompts" };
-        }
-        return { answers };
-    }
-    const q = questions[0];
-    const picked = reactions
-        .filter((r) => NUMBER_EMOJIS.includes(r.emoji) && r.count > 0)
-        .map((r) => q.options[NUMBER_EMOJIS.indexOf(r.emoji)]?.label)
-        .filter(Boolean);
-    answers[q.id] = picked.length > 0
-        ? { answers: q.allowMultiple ? picked : [picked[0]] }
-        : { answers: [], user_note: "No clear response via reactions" };
-    return { answers };
-}
-function parseAnswerForQuestion(text, q) {
-    if (!text)
-        return { answers: [], user_note: "No response provided" };
-    if (/^[\d,\s]+$/.test(text)) {
-        const nums = text
-            .split(",")
-            .map((s) => parseInt(s.trim(), 10))
-            .filter((n) => !Number.isNaN(n) && n >= 1 && n <= q.options.length);
-        if (nums.length > 0) {
-            const selected = nums.map((n) => q.options[n - 1].label);
-            return { answers: q.allowMultiple ? selected : [selected[0]] };
-        }
-    }
-    const single = parseInt(text, 10);
-    if (!Number.isNaN(single) && single >= 1 && single <= q.options.length) {
-        return { answers: [q.options[single - 1].label] };
-    }
-    return { answers: [], user_note: truncateNote(text) };
-}
-function truncateNote(text) {
-    return text.length > MAX_USER_NOTE_LENGTH ? text.slice(0, MAX_USER_NOTE_LENGTH) + "…" : text;
-}

package/dist/resources/extensions/remote-questions/manager.d.ts

@@ -1,23 +0,0 @@
-/**
- * Remote Questions — orchestration manager
- */
-interface ToolResult {
-    content: Array<{
-        type: "text";
-        text: string;
-    }>;
-    details?: Record<string, unknown>;
-}
-interface QuestionInput {
-    id: string;
-    header: string;
-    question: string;
-    options: Array<{
-        label: string;
-        description: string;
-    }>;
-    allowMultiple?: boolean;
-}
-export declare function tryRemoteQuestions(questions: QuestionInput[], signal?: AbortSignal): Promise<ToolResult | null>;
-export declare function sanitizeError(msg: string): string;
-export {};

package/dist/resources/extensions/remote-questions/manager.js

@@ -1,161 +0,0 @@
-/**
- * Remote Questions — orchestration manager
- */
-import { randomUUID } from "node:crypto";
-import { resolveRemoteConfig } from "./config.js";
-import { SlackAdapter } from "./slack-adapter.js";
-import { DiscordAdapter } from "./discord-adapter.js";
-import { createPromptRecord, writePromptRecord, markPromptAnswered, markPromptDispatched, markPromptStatus, updatePromptRecord } from "./store.js";
-export async function tryRemoteQuestions(questions, signal) {
-    const config = resolveRemoteConfig();
-    if (!config)
-        return null;
-    const prompt = createPrompt(questions, config);
-    writePromptRecord(createPromptRecord(prompt));
-    const adapter = createAdapter(config);
-    try {
-        await adapter.validate();
-    }
-    catch (err) {
-        markPromptStatus(prompt.id, "failed", sanitizeError(String(err.message)));
-        return errorResult(`Remote auth failed (${config.channel}): ${err.message}`, config.channel);
-    }
-    let dispatch;
-    try {
-        dispatch = await adapter.sendPrompt(prompt);
-        markPromptDispatched(prompt.id, dispatch.ref);
-    }
-    catch (err) {
-        markPromptStatus(prompt.id, "failed", sanitizeError(String(err.message)));
-        return errorResult(`Failed to send questions via ${config.channel}: ${err.message}`, config.channel);
-    }
-    const answer = await pollUntilDone(adapter, prompt, dispatch.ref, signal);
-    if (!answer) {
-        markPromptStatus(prompt.id, signal?.aborted ? "cancelled" : "timed_out");
-        return {
-            content: [{
-                    type: "text",
-                    text: JSON.stringify({
-                        timed_out: true,
-                        channel: config.channel,
-                        prompt_id: prompt.id,
-                        timeout_minutes: config.timeoutMs / 60000,
-                        thread_url: dispatch.ref.threadUrl ?? null,
-                        message: `User did not respond within ${config.timeoutMs / 60000} minutes.`,
-                    }),
-                }],
-            details: {
-                remote: true,
-                channel: config.channel,
-                timed_out: true,
-                promptId: prompt.id,
-                threadUrl: dispatch.ref.threadUrl,
-                status: signal?.aborted ? "cancelled" : "timed_out",
-            },
-        };
-    }
-    markPromptAnswered(prompt.id, answer);
-    return {
-        content: [{ type: "text", text: JSON.stringify({ answers: formatForTool(answer) }) }],
-        details: {
-            remote: true,
-            channel: config.channel,
-            timed_out: false,
-            promptId: prompt.id,
-            threadUrl: dispatch.ref.threadUrl,
-            questions,
-            response: answer,
-            status: "answered",
-        },
-    };
-}
-function createPrompt(questions, config) {
-    const createdAt = Date.now();
-    return {
-        id: randomUUID(),
-        channel: config.channel,
-        createdAt,
-        timeoutAt: createdAt + config.timeoutMs,
-        pollIntervalMs: config.pollIntervalMs,
-        context: { source: "ask_user_questions" },
-        questions: questions.map((q) => ({
-            id: q.id,
-            header: q.header,
-            question: q.question,
-            options: q.options,
-            allowMultiple: q.allowMultiple ?? false,
-        })),
-    };
-}
-function createAdapter(config) {
-    return config.channel === "slack"
-        ? new SlackAdapter(config.token, config.channelId)
-        : new DiscordAdapter(config.token, config.channelId);
-}
-async function pollUntilDone(adapter, prompt, ref, signal) {
-    let retryCount = 0;
-    while (Date.now() < prompt.timeoutAt && !signal?.aborted) {
-        try {
-            const answer = await adapter.pollAnswer(prompt, ref);
-            updatePromptRecord(prompt.id, { lastPollAt: Date.now() });
-            retryCount = 0;
-            if (answer)
-                return answer;
-        }
-        catch (err) {
-            retryCount++;
-            if (retryCount > 1) {
-                markPromptStatus(prompt.id, "failed", sanitizeError(String(err.message)));
-                return null;
-            }
-        }
-        await sleep(prompt.pollIntervalMs, signal);
-    }
-    return null;
-}
-function sleep(ms, signal) {
-    return new Promise((resolve) => {
-        if (signal?.aborted)
-            return resolve();
-        const timer = setTimeout(() => {
-            if (signal)
-                signal.removeEventListener("abort", onAbort);
-            resolve();
-        }, ms);
-        const onAbort = () => {
-            clearTimeout(timer);
-            resolve();
-        };
-        signal?.addEventListener("abort", onAbort, { once: true });
-    });
-}
-function formatForTool(answer) {
-    const out = {};
-    for (const [id, data] of Object.entries(answer.answers)) {
-        const list = [...data.answers];
-        if (data.user_note)
-            list.push(`user_note: ${data.user_note}`);
-        out[id] = { answers: list };
-    }
-    return out;
-}
-// Strip token-like strings from error messages before surfacing
-const TOKEN_PATTERNS = [
-    /xoxb-[A-Za-z0-9\-]+/g, // Slack bot tokens
-    /xoxp-[A-Za-z0-9\-]+/g, // Slack user tokens
-    /xoxa-[A-Za-z0-9\-]+/g, // Slack app tokens
-    /[A-Za-z0-9_\-.]{20,}/g, // Long opaque secrets (Discord tokens, etc.)
-];
-export function sanitizeError(msg) {
-    let sanitized = msg;
-    for (const pattern of TOKEN_PATTERNS) {
-        sanitized = sanitized.replace(pattern, "[REDACTED]");
-    }
-    return sanitized;
-}
-function errorResult(message, channel) {
-    return {
-        content: [{ type: "text", text: sanitizeError(message) }],
-        details: { remote: true, channel, error: true, status: "failed" },
-    };
-}

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

@@ -1,6 +0,0 @@
-/**
- * Remote Questions — /gsd remote command
- */
-import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
-export declare function handleRemote(subcommand: string, ctx: ExtensionCommandContext, _pi: ExtensionAPI): Promise<void>;
-export declare function saveRemoteQuestionsConfig(channel: "slack" | "discord", channelId: string): void;