gsd-pi 2.78.1-dev.e9d88a536 → 2.78.1-dev.eccf86e27

package/packages/mcp-server/src/mcp-server.test.ts

@@ -948,6 +948,232 @@ describe('createMcpServer tool registration', () => {
     assert.equal(result.content[0]?.text, 'remote response');
   });
 
+  it('ask_user_questions surfaces remote success answers as structuredContent (regression #5267)', async () => {
+    const questions = [
+      {
+        id: 'depth_verification_M001',
+        header: 'Depth Check',
+        question: 'Did I capture the depth right?',
+        options: [
+          { label: 'Yes, you got it (Recommended)', description: 'Continue.' },
+          { label: 'Not quite', description: 'Clarify.' },
+        ],
+      },
+    ];
+
+    const result = await askUserQuestionsHandler(questions, undefined, {
+      async elicitInput() {
+        throw new Error('MCP host does not support elicitation');
+      },
+      isRemoteConfigured() {
+        return true;
+      },
+      async tryRemoteQuestions() {
+        return {
+          content: [{ type: 'text', text: '{"answers":{"depth_verification_M001":{"answers":["Yes, you got it (Recommended)"]}}}' }],
+          details: {
+            remote: true,
+            channel: 'discord',
+            timed_out: false,
+            promptId: 'p1',
+            threadUrl: null,
+            questions,
+            response: {
+              endInterview: false,
+              answers: {
+                depth_verification_M001: { selected: 'Yes, you got it (Recommended)', notes: '' },
+              },
+            },
+            status: 'answered',
+          },
+        };
+      },
+    });
+
+    assert.deepEqual(
+      (result as { structuredContent?: unknown }).structuredContent,
+      {
+        questions,
+        response: {
+          // endInterview mirrors the local RoundResult shape so register-hooks
+          // sees identical payloads on both code paths.
+          endInterview: false,
+          answers: {
+            depth_verification_M001: { selected: 'Yes, you got it (Recommended)', notes: '' },
+          },
+        },
+        cancelled: false,
+      },
+    );
+  });
+
+  it('ask_user_questions surfaces remote timeout as cancelled structuredContent (regression #5267)', async () => {
+    const questions = [
+      {
+        id: 'depth_verification_M001',
+        header: 'Depth Check',
+        question: 'Did I capture the depth right?',
+        options: [
+          { label: 'Yes, you got it (Recommended)', description: 'Continue.' },
+          { label: 'Not quite', description: 'Clarify.' },
+        ],
+      },
+    ];
+
+    const result = await askUserQuestionsHandler(questions, undefined, {
+      async elicitInput() {
+        throw new Error('MCP host does not support elicitation');
+      },
+      isRemoteConfigured() {
+        return true;
+      },
+      async tryRemoteQuestions() {
+        return {
+          content: [{ type: 'text', text: '{"timed_out":true,"channel":"discord","message":"User did not respond within 5 minutes."}' }],
+          details: { remote: true, channel: 'discord', timed_out: true, status: 'timed_out' },
+        };
+      },
+    });
+
+    assert.deepEqual(
+      (result as { structuredContent?: unknown }).structuredContent,
+      { questions, response: null, cancelled: true },
+    );
+  });
+
+  it('ask_user_questions reports a malformed remote response as cancelled, not silent success (regression #5267)', async () => {
+    const questions = [
+      {
+        id: 'depth_verification_M001',
+        header: 'Depth Check',
+        question: 'Did I capture the depth right?',
+        options: [
+          { label: 'Yes, you got it (Recommended)', description: 'Continue.' },
+          { label: 'Not quite', description: 'Clarify.' },
+        ],
+      },
+    ];
+
+    const result = await askUserQuestionsHandler(questions, undefined, {
+      async elicitInput() {
+        throw new Error('MCP host does not support elicitation');
+      },
+      isRemoteConfigured() {
+        return true;
+      },
+      async tryRemoteQuestions() {
+        // Simulates a remote module returning a non-conforming `details.response`
+        // (e.g. a stale build, a wire mismatch). The handler must not surface
+        // this as `cancelled: false, response: null` — that would lie to any
+        // consumer reading `structuredContent.cancelled`.
+        return {
+          content: [{ type: 'text', text: '{}' }],
+          details: { remote: true, channel: 'discord', timed_out: false, response: 'not-an-object' },
+        };
+      },
+    });
+
+    assert.deepEqual(
+      (result as { structuredContent?: unknown }).structuredContent,
+      { questions, response: null, cancelled: true },
+    );
+  });
+
+  it('ask_user_questions returns cancelled structuredContent when remote is unconfigured and local declines (regression #5267)', async () => {
+    const questions = [
+      {
+        id: 'depth_verification_M001',
+        header: 'Depth Check',
+        question: 'Did I capture the depth right?',
+        options: [
+          { label: 'Yes, you got it (Recommended)', description: 'Continue.' },
+          { label: 'Not quite', description: 'Clarify.' },
+        ],
+      },
+    ];
+
+    const result = await askUserQuestionsHandler(questions, undefined, {
+      async elicitInput() {
+        return { action: 'decline' };
+      },
+      isRemoteConfigured() {
+        return false;
+      },
+      async tryRemoteQuestions() {
+        throw new Error('should not be called when remote is unconfigured');
+      },
+    });
+
+    assert.deepEqual(
+      (result as { structuredContent?: unknown }).structuredContent,
+      { questions, response: null, cancelled: true },
+    );
+    assert.equal(result.content[0]?.text, 'ask_user_questions was cancelled before receiving a response');
+  });
+
+  it('ask_user_questions returns cancelled structuredContent when configured remote returns null (regression #5267)', async () => {
+    const questions = [
+      {
+        id: 'depth_verification_M001',
+        header: 'Depth Check',
+        question: 'Did I capture the depth right?',
+        options: [
+          { label: 'Yes, you got it (Recommended)', description: 'Continue.' },
+          { label: 'Not quite', description: 'Clarify.' },
+        ],
+      },
+    ];
+
+    const result = await askUserQuestionsHandler(questions, undefined, {
+      async elicitInput() {
+        return { action: 'cancel' };
+      },
+      isRemoteConfigured() {
+        return true;
+      },
+      async tryRemoteQuestions() {
+        return null;
+      },
+    });
+
+    assert.deepEqual(
+      (result as { structuredContent?: unknown }).structuredContent,
+      { questions, response: null, cancelled: true },
+    );
+  });
+
+  it('ask_user_questions re-throws non-fallback local errors (regression #5267)', async () => {
+    const questions = [
+      {
+        id: 'depth_verification_M001',
+        header: 'Depth Check',
+        question: 'Did I capture the depth right?',
+        options: [
+          { label: 'Yes, you got it (Recommended)', description: 'Continue.' },
+          { label: 'Not quite', description: 'Clarify.' },
+        ],
+      },
+    ];
+
+    const result = await askUserQuestionsHandler(questions, undefined, {
+      async elicitInput() {
+        throw new TypeError('schema validation blew up');
+      },
+      isRemoteConfigured() {
+        return false;
+      },
+      async tryRemoteQuestions() {
+        throw new Error('should not be called');
+      },
+    });
+
+    // Non-fallback errors propagate to the outer try/catch and surface as an
+    // MCP `isError` result — no `structuredContent` is attached because the
+    // error path predates the structured success/cancel branches.
+    assert.equal('isError' in result && result.isError, true);
+    assert.match(result.content[0]?.text ?? '', /schema validation blew up/);
+  });
+
   it('ask_user_questions reports both local and remote errors when both paths fail', async () => {
     const questions = [
       {

package/packages/mcp-server/src/remote-questions.test.ts

@@ -23,6 +23,7 @@ import { join } from 'node:path';
 // ask_user_questions handler integration test further below.
 import {
   isRemoteConfigured,
+  toRoundResultResponse,
   tryRemoteQuestions,
   type RemoteQuestion,
 } from './remote-questions.js';
@@ -47,6 +48,108 @@ function makePrefsFile(dir: string, content: string): void {
   writeFileSync(join(dir, 'PREFERENCES.md'), content, 'utf-8');
 }
 
+// ---------------------------------------------------------------------------
+// toRoundResultResponse — regression #5267
+// ---------------------------------------------------------------------------
+
+describe('toRoundResultResponse', () => {
+  const singleSelectQuestion: RemoteQuestion = {
+    id: 'approach',
+    header: 'Approach',
+    question: 'Pick one',
+    options: [
+      { label: 'Option A (Recommended)', description: '' },
+      { label: 'Option B', description: '' },
+    ],
+  };
+
+  const multiSelectQuestion: RemoteQuestion = {
+    id: 'focus',
+    header: 'Focus',
+    question: 'Pick all',
+    options: [
+      { label: 'Frontend', description: '' },
+      { label: 'Backend', description: '' },
+    ],
+    allowMultiple: true,
+  };
+
+  const noteQuestion: RemoteQuestion = {
+    id: 'confirm',
+    header: 'Confirm',
+    question: 'Proceed?',
+    options: [
+      { label: 'Yes', description: '' },
+      { label: 'No', description: '' },
+    ],
+  };
+
+  it('normalizes a single-answer RemoteAnswer into RoundResult shape', () => {
+    const result = toRoundResultResponse(
+      { answers: { approach: { answers: ['Option A (Recommended)'] } } },
+      [singleSelectQuestion],
+    );
+    assert.deepEqual(result, {
+      endInterview: false,
+      answers: {
+        approach: { selected: 'Option A (Recommended)', notes: '' },
+      },
+    });
+  });
+
+  it('keeps multi-answer arrays intact for multi-select questions', () => {
+    const result = toRoundResultResponse(
+      { answers: { focus: { answers: ['Frontend', 'Backend'] } } },
+      [multiSelectQuestion],
+    );
+    assert.deepEqual(result.answers.focus, { selected: ['Frontend', 'Backend'], notes: '' });
+  });
+
+  it('preserves the array shape for a multi-select question with a single selection (regression #5267)', () => {
+    // Without consulting `allowMultiple`, the previous length-based inference
+    // collapsed `['Frontend']` into the string `'Frontend'`, breaking any
+    // consumer that does `selected.includes(...)` on a multi-select answer.
+    const result = toRoundResultResponse(
+      { answers: { focus: { answers: ['Frontend'] } } },
+      [multiSelectQuestion],
+    );
+    assert.deepEqual(result.answers.focus, { selected: ['Frontend'], notes: '' });
+  });
+
+  it('lifts user_note into the notes field', () => {
+    const result = toRoundResultResponse(
+      { answers: { confirm: { answers: ['None of the above'], user_note: 'Need a hybrid path.' } } },
+      [noteQuestion],
+    );
+    assert.deepEqual(result.answers.confirm, { selected: 'None of the above', notes: 'Need a hybrid path.' });
+  });
+
+  it('returns an empty selected string when the channel produced no answer for a single-select', () => {
+    const result = toRoundResultResponse(
+      { answers: { approach: { answers: [] } } },
+      [singleSelectQuestion],
+    );
+    assert.deepEqual(result.answers.approach, { selected: '', notes: '' });
+  });
+
+  it('returns an empty array when the channel produced no answer for a multi-select', () => {
+    const result = toRoundResultResponse(
+      { answers: { focus: { answers: [] } } },
+      [multiSelectQuestion],
+    );
+    assert.deepEqual(result.answers.focus, { selected: [], notes: '' });
+  });
+
+  it('falls back to single-select shape when the answer id is not in the questions list', () => {
+    // Defensive: an unknown id (channel desync) should not wedge the helper.
+    const result = toRoundResultResponse(
+      { answers: { ghost: { answers: ['anything'] } } },
+      [singleSelectQuestion],
+    );
+    assert.deepEqual(result.answers.ghost, { selected: 'anything', notes: '' });
+  });
+});
+
 // ---------------------------------------------------------------------------
 // isRemoteConfigured — unit tests
 // ---------------------------------------------------------------------------

package/packages/mcp-server/src/remote-questions.ts

@@ -832,6 +832,40 @@ function formatForTool(answer: RemoteAnswer): Record<string, { answers: string[]
   return out;
 }
 
+/**
+ * Normalize a `RemoteAnswer` into the `RoundResult` shape the GSD
+ * discussion-gate hook reads from `tool_result` `details.response`. Mirrors
+ * `src/resources/extensions/remote-questions/manager.ts:toRoundResultResponse`
+ * and the local-path helper `buildAskUserQuestionsRoundResult` in server.ts.
+ * Without this, the remote channel (Discord / Slack / Telegram) would have
+ * the same gate-stuck problem as the local elicitation path. See #5267.
+ *
+ * `questions` is required so the multi-select contract is preserved: a
+ * `allowMultiple` question with a single selection must still surface
+ * `selected: [label]` so consumers reading `selected.includes(...)` keep
+ * working. Falling back to length-based inference (the previous behavior)
+ * silently demoted single-pick multi-select answers to strings.
+ */
+export function toRoundResultResponse(
+  answer: RemoteAnswer,
+  questions: RemoteQuestion[],
+): {
+  endInterview: false;
+  answers: Record<string, { selected: string | string[]; notes: string }>;
+} {
+  const allowMultipleById = new Map<string, boolean>();
+  for (const q of questions) allowMultipleById.set(q.id, q.allowMultiple ?? false);
+
+  const normalized: Record<string, { selected: string | string[]; notes: string }> = {};
+  for (const [id, data] of Object.entries(answer.answers)) {
+    const list = data.answers ?? [];
+    const allowMultiple = allowMultipleById.get(id) ?? false;
+    const selected: string | string[] = allowMultiple ? list : (list[0] ?? '');
+    normalized[id] = { selected, notes: data.user_note ?? '' };
+  }
+  return { endInterview: false, answers: normalized };
+}
+
 /**
  * Dispatch questions to the configured remote channel and wait for a response.
  *
@@ -926,6 +960,7 @@ export async function tryRemoteQuestions(
       promptId: prompt.id,
       threadUrl: ref.threadUrl ?? null,
       questions,
+      response: toRoundResultResponse(answer, questions),
       status: 'answered',
     },
   };

package/packages/mcp-server/src/server.ts

@@ -329,6 +329,32 @@ interface AskUserQuestionsElicitRequest {
   };
 }
 
+/**
+ * Structured payload mirrored to the MCP `structuredContent` field on
+ * `ask_user_questions` results. Mirrors the `LocalResultDetails` shape that
+ * src/resources/extensions/ask-user-questions.ts already produces, so the
+ * GSD discussion-gate hook in register-hooks.ts can treat the MCP path
+ * identically to the in-process extension path. Without this, the bridge
+ * surfaces `details = undefined` and the gate hook's
+ * `if (details?.cancelled || !details?.response)` branch HARD-BLOCKs every
+ * user answer, including successful confirmations. See #5267.
+ */
+interface AskUserQuestionsRoundResultAnswer {
+  selected: string | string[];
+  notes: string;
+}
+
+interface AskUserQuestionsRoundResult {
+  endInterview: false;
+  answers: Record<string, AskUserQuestionsRoundResultAnswer>;
+}
+
+interface AskUserQuestionsStructuredContent {
+  questions: AskUserQuestion[];
+  response: AskUserQuestionsRoundResult | null;
+  cancelled: boolean;
+}
+
 const OTHER_OPTION_LABEL = 'None of the above';
 
 function normalizeAskUserQuestionsNote(value: AskUserQuestionsContentValue | undefined): string {
@@ -434,6 +460,41 @@ export function formatAskUserQuestionsElicitResult(
   return JSON.stringify({ answers });
 }
 
+/**
+ * Normalize an MCP elicitation form result into the `RoundResult` shape the
+ * GSD discussion-gate hook reads from `tool_result` `details.response`. The
+ * elicitation `content` map carries `{ [id]: label, [id]__note?: string }`;
+ * the hook expects `{ answers: { [id]: { selected, notes } } }`. Mirrored into
+ * `structuredContent` by `askUserQuestionsHandler`. See #5267.
+ */
+export function buildAskUserQuestionsRoundResult(
+  questions: AskUserQuestion[],
+  result: AskUserQuestionsElicitResult,
+): AskUserQuestionsRoundResult {
+  const answers: Record<string, AskUserQuestionsRoundResultAnswer> = {};
+  const content = result.content ?? {};
+
+  for (const question of questions) {
+    if (question.allowMultiple) {
+      const list = normalizeAskUserQuestionsAnswers(content[question.id], true);
+      answers[question.id] = { selected: list, notes: '' };
+      continue;
+    }
+
+    const list = normalizeAskUserQuestionsAnswers(content[question.id], false);
+    const selected = list[0] ?? '';
+    const notes = selected === OTHER_OPTION_LABEL
+      ? normalizeAskUserQuestionsNote(content[`${question.id}__note`])
+      : '';
+    answers[question.id] = { selected, notes };
+  }
+
+  // `endInterview: false` mirrors the local extension's `RoundResult` shape and
+  // matches the remote path's `toRoundResultResponse` so register-hooks reads
+  // identical payloads regardless of channel. See peer review #5267-Q2.
+  return { endInterview: false, answers };
+}
+
 interface AskUserQuestionsHandlerDeps {
   elicitInput(params: AskUserQuestionsElicitRequest): Promise<AskUserQuestionsElicitResult>;
   isRemoteConfigured(): boolean;
@@ -458,6 +519,18 @@ function formatErrorMessage(err: unknown): string {
   return err instanceof Error ? err.message : String(err);
 }
 
+/**
+ * Defensive guard for the `details.response` payload from `tryRemoteQuestions`.
+ * Accepts only an object with a plain `answers` map; anything else (null,
+ * stringified JSON, missing) falls back to `null` so the gate hook routes
+ * the cancel branch instead of crashing on `details.response.answers[id]`.
+ */
+function isRoundResultLike(value: unknown): boolean {
+  if (!value || typeof value !== 'object') return false;
+  const answers = (value as Record<string, unknown>)['answers'];
+  return !!answers && typeof answers === 'object' && !Array.isArray(answers);
+}
+
 export async function askUserQuestionsHandler(
   questions: AskUserQuestion[],
   extra: McpToolExtra | undefined,
@@ -478,7 +551,15 @@ export async function askUserQuestionsHandler(
         'ask_user_questions',
       );
       if (elicitation.action === 'accept' && elicitation.content) {
-        return textContent(formatAskUserQuestionsElicitResult(questions, elicitation));
+        const structured: AskUserQuestionsStructuredContent = {
+          questions,
+          response: buildAskUserQuestionsRoundResult(questions, elicitation),
+          cancelled: false,
+        };
+        return {
+          content: [{ type: 'text' as const, text: formatAskUserQuestionsElicitResult(questions, elicitation) }],
+          structuredContent: structured as unknown as Record<string, unknown>,
+        };
       }
     } catch (err) {
       if (!isLocalElicitFallbackError(err)) throw err;
@@ -503,15 +584,57 @@ export async function askUserQuestionsHandler(
       if (remoteResult) {
         const details = remoteResult.details as Record<string, unknown> | undefined;
         if (details?.['timed_out'] || details?.['error']) {
-          return textContent(remoteResult.content[0]?.text ?? 'Remote questions timed out or failed');
+          // Mirror the timeout/error into structuredContent so the gate hook's
+          // `details?.cancelled || !details?.response` branch fires correctly
+          // (gate stays pending, model re-asks) instead of silently dropping
+          // because no `details` made it across the MCP wire. See #5267.
+          const failedStructured: AskUserQuestionsStructuredContent = {
+            questions,
+            response: null,
+            cancelled: true,
+          };
+          return {
+            content: [{ type: 'text' as const, text: remoteResult.content[0]?.text ?? 'Remote questions timed out or failed' }],
+            structuredContent: failedStructured as unknown as Record<string, unknown>,
+          };
         }
-        return textContent(remoteResult.content[0]?.text ?? '');
+        // Successful remote answer — surface the normalized RoundResult that
+        // remote-questions.ts attached to `details.response` so the gate hook
+        // sees `details.response.answers[id].selected` on this path too.
+        // A malformed `response` (failing isRoundResultLike) is reported as
+        // an explicit cancellation rather than a silent `cancelled: false`
+        // with `response: null` — the latter would lie to any consumer that
+        // reads `structuredContent.cancelled` independently of `.response`.
+        const hasValidResponse = isRoundResultLike(details?.['response']);
+        const acceptedStructured: AskUserQuestionsStructuredContent = hasValidResponse
+          ? {
+              questions,
+              response: details!['response'] as AskUserQuestionsRoundResult,
+              cancelled: false,
+            }
+          : {
+              questions,
+              response: null,
+              cancelled: true,
+            };
+        return {
+          content: [{ type: 'text' as const, text: remoteResult.content[0]?.text ?? '' }],
+          structuredContent: acceptedStructured as unknown as Record<string, unknown>,
+        };
       }
     }
 
     if (localElicitError) throw localElicitError;
 
-    return textContent('ask_user_questions was cancelled before receiving a response');
+    const cancelledStructured: AskUserQuestionsStructuredContent = {
+      questions,
+      response: null,
+      cancelled: true,
+    };
+    return {
+      content: [{ type: 'text' as const, text: 'ask_user_questions was cancelled before receiving a response' }],
+      structuredContent: cancelledStructured as unknown as Record<string, unknown>,
+    };
   } catch (err) {
     return errorContent(err instanceof Error ? err.message : String(err));
   }
@@ -527,8 +650,8 @@ export type ElicitInputFn = (params: {
 }) => Promise<{ action: 'accept' | 'cancel' | 'decline'; content?: Record<string, unknown> }>;
 
 type ToolContent =
-  | { content: Array<{ type: 'text'; text: string }> }
-  | { isError: true; content: Array<{ type: 'text'; text: string }> };
+  | { content: Array<{ type: 'text'; text: string }>; structuredContent?: Record<string, unknown> }
+  | { isError: true; content: Array<{ type: 'text'; text: string }>; structuredContent?: Record<string, unknown> };
 
 export async function secureEnvCollectHandler(
   args: Record<string, unknown>,

package/packages/mcp-server/src/workflow-tools.ts

@@ -230,7 +230,7 @@ type WorkflowToolExecutors = {
 };
 
 type WorkflowWriteGateModule = {
-  loadWriteGateSnapshot: (basePath?: string) => {
+  loadWriteGateSnapshot: (basePath: string) => {
     verifiedDepthMilestones: string[];
     activeQueuePhase: boolean;
     pendingGateId: string | null;