@openchambery/web 2.0.0-beta.9 → 2.0.1

package/server/lib/opencode/upgrade-screen.js

@@ -1,5 +1,5 @@
 /**
- * Startup upgrade screen for OpenCode below 2.0.15.
+ * Startup upgrade screen for OpenCode below the runtime contract minimum.
  *
  * This module does not own process lifecycle. It classifies the version the
  * existing startup path already detected, and installs through the owned-cache
@@ -9,6 +9,7 @@
 
 import {
   PINNED_OPENCODE2_VERSION,
+  MINIMUM_OPENCODE2_VERSION,
   isAcceptableOpenCode2HealthVersion,
   isOpenCode1xVersion,
   isOpenCode2VersionAtLeast,
@@ -16,7 +17,7 @@ import {
 } from './opencode2-pin.js';
 
 /** Oldest OpenCode this OpenChamber build will enter a session against. */
-export const REQUIRED_OPENCODE_VERSION = '2.0.15';
+export const REQUIRED_OPENCODE_VERSION = MINIMUM_OPENCODE2_VERSION;
 
 const normalizeVersion = (value) => {
   if (typeof value !== 'string') return null;
@@ -68,14 +69,6 @@ export function platformSupportsUpgradeScreenInstall(platform = process.platform
   }
 }
 
-const pickDetectedVersion = (serveVersion, cliVersion) => {
-  const serve = normalizeVersion(serveVersion);
-  const cli = normalizeVersion(cliVersion);
-  if (serve && !isUpgradeScreenSatisfied(serve)) return serve;
-  if (serve) return serve;
-  return cli;
-};
-
 /**
  * @param {{
  *   version?: string | null,
@@ -156,7 +149,7 @@ async function readUpgradeScreenStatus(deps) {
     ? await Promise.resolve(deps.readCliVersion()).catch(() => null)
     : null;
   return describeUpgradeScreen({
-    version: pickDetectedVersion(serveVersion, cliVersion),
+    version: serveVersion || (typeof deps.readServeVersion === 'function' ? null : cliVersion),
     installation,
     platformCanInstall: typeof deps.platformCanInstall === 'boolean'
       ? deps.platformCanInstall

package/server/lib/opencode/upgrade-screen.test.js

@@ -11,26 +11,26 @@ import {
 } from './upgrade-screen.js';
 
 describe('upgrade screen version gate', () => {
-  it('uses 2.0.15 even when the runtime pin is older', () => {
-    expect(REQUIRED_OPENCODE_VERSION).toBe('2.0.15');
-    expect(resolveUpgradeScreenTarget('2.0.12')).toBe('2.0.15');
-    expect(resolveUpgradeScreenTarget('2.0.16')).toBe('2.0.16');
+  it('uses the floor even when the runtime pin is older', () => {
+    expect(REQUIRED_OPENCODE_VERSION).toBe('2.0.20');
+    expect(resolveUpgradeScreenTarget('2.0.12')).toBe('2.0.20');
+    expect(resolveUpgradeScreenTarget('2.0.23')).toBe('2.0.23');
   });
 
-  it('does not open the gate at or above 2.0.15', () => {
+  it('does not open the gate at or above 2.0.20', () => {
     expect(describeUpgradeScreen({
-      version: '2.0.15',
+      version: '2.0.20',
       installation: 'managed',
       platformCanInstall: true,
-    })).toMatchObject({ state: 'compatible', canInstall: false, minimumVersion: '2.0.15' });
+    })).toMatchObject({ state: 'compatible', canInstall: false, minimumVersion: '2.0.20' });
     expect(describeUpgradeScreen({
-      version: 'v2.0.16',
+      version: 'v2.0.23',
       installation: 'managed',
       platformCanInstall: true,
     }).state).toBe('compatible');
   });
 
-  it('opens the gate below 2.0.15 and offers install only when this runtime can switch', () => {
+  it('opens the gate below 2.0.20 and offers install only when this runtime can switch', () => {
     expect(describeUpgradeScreen({
       version: '2.0.14',
       installation: 'managed',
@@ -68,17 +68,17 @@ describe('upgrade screen version gate', () => {
 
   it('does not report an unverified install as upgraded', () => {
     expect(evaluateUpgradeScreenInstallResult({
-      targetVersion: '2.0.15',
+      targetVersion: '2.0.23',
       serveVersion: '2.0.14',
     })).toMatchObject({ ok: false, upgraded: false, version: '2.0.14' });
     expect(evaluateUpgradeScreenInstallResult({
-      targetVersion: '2.0.15',
+      targetVersion: '2.0.23',
       serveVersion: null,
     }).upgraded).toBe(false);
     expect(evaluateUpgradeScreenInstallResult({
-      targetVersion: '2.0.15',
-      serveVersion: '2.0.15',
-    })).toMatchObject({ ok: true, upgraded: true, version: '2.0.15' });
+      targetVersion: '2.0.23',
+      serveVersion: '2.0.23',
+    })).toMatchObject({ ok: true, upgraded: true, version: '2.0.23' });
   });
 });
 
@@ -94,7 +94,7 @@ describe('installRequiredOpenCode', () => {
         calls.push('install');
         return '/cache/opencode';
       }),
-      readBinaryVersion: vi.fn(() => '2.0.15'),
+      readBinaryVersion: vi.fn(() => '2.0.23'),
       persistBinary: vi.fn(async () => {
         calls.push('persist');
       }),
@@ -114,20 +114,20 @@ describe('installRequiredOpenCode', () => {
     return { deps, calls };
   };
 
-  it('installs 2.0.15 and only succeeds after the running serve is verified', async () => {
+  it('installs 2.0.23 and only succeeds after the running serve is verified', async () => {
     const { deps, calls } = createDeps({
       readServeVersion: vi.fn()
         .mockResolvedValueOnce('2.0.14')
-        .mockResolvedValueOnce('2.0.15'),
+        .mockResolvedValueOnce('2.0.23'),
     });
 
     await expect(installRequiredOpenCode(deps)).resolves.toMatchObject({
       ok: true,
       upgraded: true,
-      version: '2.0.15',
-      targetVersion: '2.0.15',
+      version: '2.0.23',
+      targetVersion: '2.0.23',
     });
-    expect(deps.install).toHaveBeenCalledWith({ version: '2.0.15' });
+    expect(deps.install).toHaveBeenCalledWith({ version: '2.0.23' });
     expect(calls).toEqual(['install', 'persist', 'force', 'restart', 'ready']);
   });
 
@@ -137,7 +137,7 @@ describe('installRequiredOpenCode', () => {
         .mockResolvedValueOnce('1.18.30')
         .mockResolvedValueOnce('1.18.30'),
       readCliVersion: () => '1.18.30',
-      readBinaryVersion: () => '2.0.15',
+      readBinaryVersion: () => '2.0.23',
     });
 
     await expect(installRequiredOpenCode(deps)).rejects.toThrow(/still 1\.18\.30/);
@@ -161,11 +161,11 @@ describe('installRequiredOpenCode', () => {
 });
 
 describe('upgrade screen routes', () => {
-  it('hides the gate for 2.0.15 and reports install failure without upgraded:true', async () => {
+  it('hides the gate for 2.0.20 and reports install failure without upgraded:true', async () => {
     const app = express();
     app.use(express.json());
     const readServeVersion = vi.fn()
-      .mockResolvedValueOnce('2.0.15')
+      .mockResolvedValueOnce('2.0.20')
       .mockResolvedValueOnce('2.0.12')
       .mockResolvedValueOnce('2.0.12');
     registerUpgradeScreenRoutes(app, {
@@ -176,14 +176,14 @@ describe('upgrade screen routes', () => {
       install: vi.fn(async () => {
         throw new Error('registry unreachable');
       }),
-      readBinaryVersion: () => '2.0.15',
+      readBinaryVersion: () => '2.0.23',
       persistBinary: vi.fn(),
       forceBinary: vi.fn(),
       restart: vi.fn(),
     });
 
     const compatible = await request(app).get('/api/opencode/compatibility').expect(200);
-    expect(compatible.body).toMatchObject({ state: 'compatible', version: '2.0.15', minimumVersion: '2.0.15' });
+    expect(compatible.body).toMatchObject({ state: 'compatible', version: '2.0.20', minimumVersion: '2.0.20' });
 
     const failed = await request(app).post('/api/opencode/install-required').expect(500);
     expect(failed.body).toMatchObject({

package/server/lib/opencode/version-alignment.test.js

@@ -0,0 +1,40 @@
+import { describe, expect, it, vi } from 'vitest';
+import { MINIMUM_OPENCODE2_VERSION, PINNED_OPENCODE2_VERSION } from './opencode2-pin.js';
+import { evaluateRuntimeContract } from './runtime-contract.js';
+import { describeUpgradeScreen, installRequiredOpenCode, resolveUpgradeScreenTarget } from './upgrade-screen.js';
+import { ensurePinnedOpenCode2Cli } from './ensure-cli.js';
+
+describe('v2 version alignment', () => {
+  it.each(['1.18.30', '2.0.19', null, 'unknown'])('blocks execution and startup for %s', (version) => {
+    expect(evaluateRuntimeContract({ serveVersion: version, cliVersion: '2.0.23', reachable: true, authenticated: true }).executionAllowed).toBe(false);
+    expect(describeUpgradeScreen({ version }).state).not.toBe('compatible');
+  });
+  it.each(['2.0.20', '2.0.23', '2.1.0'])('admits running %s independently of CLI pin', (version) => {
+    expect(evaluateRuntimeContract({ serveVersion: version, cliVersion: '2.0.15', reachable: true, authenticated: true })).toMatchObject({ executionAllowed: true, versionMismatch: true, minVerifiedVersion: '2.0.20' });
+    expect(describeUpgradeScreen({ version }).state).toBe('compatible');
+  });
+  it('installs the audited pin on first install and preserves newer discovered CLIs', async () => {
+    expect(MINIMUM_OPENCODE2_VERSION).toBe('2.0.20');
+    expect(PINNED_OPENCODE2_VERSION).toBe('2.0.23');
+    expect(resolveUpgradeScreenTarget()).toBe('2.0.23');
+    const install = vi.fn(async () => '/owned/opencode');
+    await expect(ensurePinnedOpenCode2Cli({ readVersion: (path) => path === '/owned/opencode' ? '2.0.23' : '', install })).resolves.toMatchObject({ version: '2.0.23', installed: true });
+    expect(install).toHaveBeenCalledWith(expect.objectContaining({ version: '2.0.23' }));
+    install.mockClear();
+    await expect(ensurePinnedOpenCode2Cli({ discoveredPath: '/global/opencode', readVersion: () => '2.1.0', install })).resolves.toMatchObject({ version: '2.1.0', installed: false });
+    expect(install).not.toHaveBeenCalled();
+  });
+  it('does not infer a successful installation from an unreadable binary', async () => {
+    await expect(ensurePinnedOpenCode2Cli({ readVersion: () => '', install: async () => '/owned/opencode' })).rejects.toThrow('got unknown');
+  });
+  it('verifies the live service after explicit install, and rolls selection back on failure', async () => {
+    const persistBinary = vi.fn();
+    const restart = vi.fn();
+    const deps = { resolveOwnership: async () => ({ ownership: 'shared-service' }), readServeVersion: vi.fn().mockResolvedValueOnce('2.0.19').mockResolvedValueOnce('2.0.23'), readCliVersion: () => '2.0.23', platformCanInstall: true, install: async () => '/owned/opencode', readBinaryVersion: () => '2.0.23', persistBinary, restart, isSharedService: () => true };
+    await expect(installRequiredOpenCode(deps)).resolves.toMatchObject({ upgraded: true, version: '2.0.23' });
+    expect(restart).toHaveBeenCalledWith({ binaryPath: '/owned/opencode' });
+    deps.readServeVersion.mockResolvedValue('2.0.19');
+    await expect(installRequiredOpenCode(deps)).rejects.toMatchObject({ code: 'UPGRADE_SCREEN_NOT_VERIFIED' });
+    expect(persistBinary).toHaveBeenLastCalledWith('');
+  });
+});

package/server/lib/question-auto-delegate/DOCUMENTATION.md

@@ -2,12 +2,15 @@
 
 ## Purpose
 
-Server-owned automatic handling of OpenCode `question.asked` prompts. When
+Server-owned automatic handling of OpenCode 2 question-tool forms (`form.created`,
+`data.form.metadata.kind === "question"`). When
 enabled (default), pending questions are answered after 30 seconds with a fixed
 continuation text so agents (including background/subagent sessions) can proceed
 without a connected UI. Manual reply/reject still use the official OpenCode
-SDK shape; the Host only adds a single-flight claim so timer, manual, and
-delegate paths cannot double-POST upstream.
+form schema. The Host adds a single-flight claim for timer, delegate, and
+compatibility question routes. Native manual form replies settle via
+`form.replied` / `form.cancelled`; upstream form settlement arbitrates any race
+with a native reply already in flight.
 
 Permission auto-accept is intentionally out of scope — this module never
 replies to permission requests.
@@ -42,6 +45,7 @@ Auto-submit requires **settings ready + enabled + authoritative directory**.
 |---|---|
 | `core.js` / `core.d.ts` | Platform-agnostic state machine (IO/timer injected). Shared contract for VS Code. |
 | `runtime.js` | Web adapter: OpenCode upstream fetch, global event hub, settings, SSE tips, project + session-index directories. |
+| `form-io.js` / `form-io.d.ts` | Shared Web/VS Code native form list, schema lookup, answer mapping and cancellation. |
 | `routes.js` | OpenChamber routes + precise `/api/question/:id/reply\|reject` intercepts. |
 
 ## Snapshot
@@ -62,21 +66,31 @@ Tip event (not a data payload):
 | `POST` | `.../requests/:id/pause` | `{ sessionID, directory, reason: 'interaction'\|'user' }` — bound identity conflicts → 409. Directory may be empty; pause still cancels the auto timer. |
 | `POST` | `.../requests/:id/delegate` | recovers identity via scoped list; allowed when toggle off |
 | `POST` | `/api/question/:id/reply` | manual: `answers` must be an array (incl. `[]`); never auto text |
-| `POST` | `/api/question/:id/reject` | SDK body preserved |
+| `POST` | `/api/question/:id/reject` | Compatibility route mapped to native form cancellation |
 
 Concurrent claim losers: HTTP **409** + `code: "question_submission_claimed"`.
 
 ## Claim / upstream rules
 
+OpenCode 2.0.15 upstream uses `GET /api/form?location[directory]=...` for
+pending forms and `GET /api/session/:sessionID/form/:formID` before submitting
+`POST .../reply` with `{ answer }`. Only question-tool forms are eligible.
+The fresh schema owns field keys, option values and string/multiselect shape.
+Failed schema reads are `notSent` and pause for retry. Cancellation uses
+`POST .../cancel`. Session directory recovery reads `info.location.directory`;
+live events read `payload.location.directory` and `payload.data`.
+Web, Electron and mobile hosts use the Web adapter; VS Code imports the same
+form IO and core, restoring `/api` for origin-only upstream URLs.
+
 1. One authority owns at most one upstream POST per `requestID` (sync claim).
 2. **Definitive reject** (400/409/422) or pre-send throw → **release claim**, pause for human retry. **No immediate auto retry.**
 3. **Unclear post-dispatch result** (timeout/5xx/`uncertain`) → `uncertain` tombstone; no retry; still **blocks** goal.
 4. **Settled** must not be downgraded by a late POST failure.
 5. Successful **scoped** empty list may converge `uncertain`/pending → `external` settled **only for that directory**.
-6. Manual reply forwards `answers` as-is (including `[]`). Fixed text is auto/delegate only.
+6. Compatibility manual reply passes `answers` (including `[]`) to the form adapter, which maps them by authoritative fields. Fixed text is auto/delegate only.
 7. Client `sessionID`/`directory` hints never override a bound identity (conflict → 409).
 8. Auto-submit requires an authoritative directory binding (from event, session cache, or `getSession` write-back). Missing directory → no timer.
-9. Unknown pause/delegate recovers via scoped `question.list` — never invents `questionCount=1`.
+9. Unknown pause/delegate recovers via scoped `form.list`, filtered to question-tool forms — never invents `questionCount=1`.
 
 ## Reconcile
 
@@ -119,6 +133,7 @@ Concurrent claim losers: HTTP **409** + `code: "question_submission_claimed"`.
 ```sh
 bunx vitest run --project @openchamber/web \
   packages/web/server/lib/question-auto-delegate/core.test.js \
+  packages/web/server/lib/question-auto-delegate/runtime.test.js \
   packages/web/server/lib/question-auto-delegate/routes.test.js \
   packages/web/server/lib/session-goal/runtime.test.js
 ```

package/server/lib/question-auto-delegate/core.d.ts

@@ -114,6 +114,8 @@ export interface QuestionAutoDelegatePendingQuestion {
   sessionID: string;
   directory?: string | null;
   questions?: unknown[] | null;
+  fields?: unknown[];
+  metadata?: { kind?: unknown };
 }
 
 export interface QuestionAutoDelegateSessionInfo {
@@ -167,11 +169,13 @@ export interface QuestionAutoDelegateIO {
     requestID: string,
     directory: string | undefined,
     answers: string[][],
+    sessionID: string,
   ): Promise<QuestionAutoDelegateUpstreamResult>;
   postReject(
     requestID: string,
     directory: string | undefined,
-    body?: unknown,
+    body: unknown,
+    sessionID: string,
   ): Promise<QuestionAutoDelegateUpstreamResult>;
   /** Project directories used for reconnect/start reconcile. */
   listDirectories(): Promise<string[]>;

package/server/lib/question-auto-delegate/core.js

@@ -25,7 +25,8 @@ const normalizeQuestion = (raw, directoryHint = '') => {
   const sessionID = asTrimmedString(raw.sessionID);
   if (!requestID || !sessionID) return null;
   const directory = asTrimmedString(raw.directory) || asTrimmedString(directoryHint);
-  const questions = Array.isArray(raw.questions) ? raw.questions : [];
+  if (Array.isArray(raw.fields) && raw.metadata?.kind !== 'question') return null;
+  const questions = Array.isArray(raw.fields) ? raw.fields : Array.isArray(raw.questions) ? raw.questions : [];
   return {
     requestID,
     sessionID,
@@ -608,18 +609,18 @@ export function createQuestionAutoDelegateCore({
     try {
       if (kind === 'reject') {
         entry.upstreamDispatched = true;
-        upstream = await io.postReject(requestID, directory, input.body);
+        upstream = await io.postReject(requestID, directory, input.body, entry.sessionID);
       } else if (authority === 'manual') {
         entry.upstreamDispatched = true;
         // Forward the caller payload exactly (answers may be empty).
-        upstream = await io.postReply(requestID, directory, input.answers);
+        upstream = await io.postReply(requestID, directory, input.answers, entry.sessionID);
       } else {
         const count = entry.questionCount > 0 ? entry.questionCount : 1;
         const answers = Array.isArray(input.answers) && input.answers.length > 0
           ? input.answers
           : buildAutoDelegateAnswers(count, autoAnswer);
         entry.upstreamDispatched = true;
-        upstream = await io.postReply(requestID, directory, answers);
+        upstream = await io.postReply(requestID, directory, answers, entry.sessionID);
       }
     } catch (error) {
       // Throw before a classified upstream result: treat as pre-send failure → release for retry.
@@ -1157,12 +1158,18 @@ export function createQuestionAutoDelegateCore({
   const processEvent = (payload, directoryHint = '') => {
     if (disposed || !payload || typeof payload !== 'object') return;
     const type = typeof payload.type === 'string' ? payload.type : '';
-    const properties = payload.properties && typeof payload.properties === 'object' ? payload.properties : {};
-    const hint = asTrimmedString(directoryHint);
+    const properties = payload.data && typeof payload.data === 'object'
+      ? payload.data
+      : payload.properties && typeof payload.properties === 'object' ? payload.properties : {};
+    const hint = asTrimmedString(payload.location?.directory) || asTrimmedString(directoryHint);
 
     if (type === 'session.created' || type === 'session.updated') {
-      rememberSession(properties.info, hint);
-      const info = properties.info;
+      const info = properties.info ?? {
+        id: properties.sessionID,
+        parentID: properties.parentID,
+        directory: properties.location?.directory,
+      };
+      rememberSession(info, hint);
       const sessionId = asTrimmedString(info?.id);
       const directory = asTrimmedString(info?.directory) || hint;
       if (sessionId && directory) {
@@ -1176,8 +1183,9 @@ export function createQuestionAutoDelegateCore({
       return;
     }
 
-    if (type === 'question.asked') {
-      const normalized = normalizeQuestion(properties, hint);
+    if (type === 'question.asked' || type === 'form.created') {
+      if (type === 'form.created' && properties.form?.metadata?.kind !== 'question') return;
+      const normalized = normalizeQuestion(type === 'form.created' ? properties.form : properties, hint);
       if (!normalized) return;
       rememberSession({ id: normalized.sessionID, directory: normalized.directory }, normalized.directory || hint);
       if (!normalized.directory) {
@@ -1191,13 +1199,13 @@ export function createQuestionAutoDelegateCore({
       return;
     }
 
-    if (type === 'question.replied' || type === 'question.rejected') {
-      const requestID = asTrimmedString(properties.id) || asTrimmedString(properties.requestID);
+    if (type === 'question.replied' || type === 'question.rejected' || type === 'form.replied' || type === 'form.cancelled') {
+      const requestID = asTrimmedString(properties.formID) || asTrimmedString(properties.id) || asTrimmedString(properties.requestID);
       if (!requestID) return;
       const entry = requests.get(requestID);
       if (!entry) return;
       if (entry.state === TERMINAL_SETTLED) return;
-      const resolution = type === 'question.rejected' ? 'rejected' : 'replied';
+      const resolution = type === 'question.rejected' || type === 'form.cancelled' ? 'rejected' : 'replied';
       if (entry.state === 'uncertain' || entry.state === 'submitting') {
         markSettled(entry, resolution, entry.submittedBy ?? null);
         bump();

package/server/lib/question-auto-delegate/form-io.d.ts

@@ -0,0 +1,6 @@
+import type { QuestionAutoDelegateIO, QuestionAutoDelegateUpstreamResult } from './core.js';
+
+export function createQuestionFormIO(upstream: (
+  path: string,
+  options?: { directory?: string | null; method?: string; body?: unknown },
+) => Promise<QuestionAutoDelegateUpstreamResult>): Pick<QuestionAutoDelegateIO, 'listQuestions' | 'postReply' | 'postReject'>;

package/server/lib/question-auto-delegate/form-io.js

@@ -0,0 +1,39 @@
+/** Native OpenCode form IO shared by Web and the VS Code host. */
+export function createQuestionFormIO(upstream) {
+  const formPath = (sessionID, requestID) => {
+    if (!sessionID) throw new Error('Question form requires a sessionID');
+    return `/session/${encodeURIComponent(sessionID)}/form/${encodeURIComponent(requestID)}`;
+  };
+  return {
+    async listQuestions(directory) {
+      const result = await upstream('/form', { directory });
+      if (!result.ok) return null;
+      const rows = result.body?.data;
+      if (!Array.isArray(rows)) return null;
+      return rows.filter((form) => form?.metadata?.kind === 'question');
+    },
+    async postReply(requestID, directory, answers, sessionID) {
+      const path = formPath(sessionID, requestID);
+      const result = await upstream(path, { directory });
+      // A failed schema read never means the answer POST was dispatched.
+      if (!result.ok) return { ...result, notSent: true, uncertain: false };
+      const form = result.body?.data;
+      if (form?.id !== requestID || form?.sessionID !== sessionID
+        || form.metadata?.kind !== 'question' || !Array.isArray(form.fields) || !form.fields.length) {
+        throw new Error('Invalid question form schema');
+      }
+      const answer = Object.fromEntries(form.fields.map((field, index) => {
+        if (!field.key || (field.type !== 'string' && field.type !== 'multiselect')) {
+          throw new Error('Unsupported question form field');
+        }
+        const values = (answers[index] ?? []).map((value) =>
+          field.options?.find((option) => (option.label || option.value) === value)?.value ?? value);
+        return [field.key, field.type === 'multiselect' ? values : values[0] ?? ''];
+      }));
+      return upstream(`${path}/reply`, { directory, method: 'POST', body: { answer } });
+    },
+    async postReject(requestID, directory, _body, sessionID) {
+      return upstream(`${formPath(sessionID, requestID)}/cancel`, { directory, method: 'POST' });
+    },
+  };
+}

package/server/lib/question-auto-delegate/runtime.js

@@ -2,6 +2,7 @@ import {
   createQuestionAutoDelegateCore,
   QUESTION_AUTO_DELEGATE_DELAY_MS,
 } from './core.js';
+import { createQuestionFormIO } from './form-io.js';
 
 const REQUEST_TIMEOUT_MS = 15_000;
 
@@ -44,7 +45,7 @@ export function createQuestionAutoDelegateRuntime({
 } = {}) {
   const upstream = async (path, { directory, method = 'GET', body } = {}) => {
     const url = new URL(buildOpenCodeUrl(path, ''));
-    if (directory) url.searchParams.set('directory', directory);
+    if (directory) url.searchParams.set('location[directory]', directory);
     let response;
     try {
       response = await fetchImpl(url, {
@@ -149,14 +150,7 @@ export function createQuestionAutoDelegateRuntime({
         }
         return Array.from(dirs);
       },
-      async listQuestions(directory) {
-        const result = await upstream('/question', { directory });
-        if (!result.ok) return null;
-        const payload = result.body;
-        if (Array.isArray(payload)) return payload;
-        if (Array.isArray(payload?.data)) return payload.data;
-        return null;
-      },
+      ...createQuestionFormIO(upstream),
       async getSession(sessionID, directory) {
         const result = await upstream(`/session/${encodeURIComponent(sessionID)}`, { directory });
         if (!result.ok) return null;
@@ -167,23 +161,9 @@ export function createQuestionAutoDelegateRuntime({
         return {
           id: asTrimmedString(info.id) || sessionID,
           parentID: asTrimmedString(info.parentID) || null,
-          directory: asTrimmedString(info.directory) || asTrimmedString(directory) || null,
+          directory: asTrimmedString(info.location?.directory) || asTrimmedString(info.directory) || asTrimmedString(directory) || null,
         };
       },
-      async postReply(requestID, directory, answers) {
-        return upstream(`/question/${encodeURIComponent(requestID)}/reply`, {
-          directory,
-          method: 'POST',
-          body: { answers },
-        });
-      },
-      async postReject(requestID, directory, body) {
-        return upstream(`/question/${encodeURIComponent(requestID)}/reject`, {
-          directory,
-          method: 'POST',
-          body: body && typeof body === 'object' ? body : {},
-        });
-      },
     },
   });
 

package/server/lib/question-auto-delegate/runtime.test.js

@@ -0,0 +1,138 @@
+import { afterEach, expect, it, vi } from 'vitest';
+import { createQuestionAutoDelegateRuntime } from './runtime.js';
+import { QUESTION_AUTO_DELEGATE_ANSWER } from './core.js';
+
+const form = {
+  id: 'frm_question', sessionID: 'ses_test', title: 'Choose',
+  metadata: { kind: 'question' },
+  fields: [{ key: 'approach', type: 'string', custom: true, options: [{ label: 'A', value: 'a' }] }],
+};
+const runtimes = [];
+afterEach(() => {
+  runtimes.splice(0).forEach((runtime) => runtime.dispose());
+  vi.useRealTimers();
+});
+
+const setup = async (pending = []) => {
+  vi.useFakeTimers();
+  let onEvent;
+  const fetchImpl = vi.fn(async (url, options) => {
+    const path = url.pathname;
+    if (path === '/api/form') return Response.json({ data: pending });
+    if (path === '/api/session/ses_test') return Response.json({ data: { id: 'ses_test', location: { directory: '/project' } } });
+    if (path === '/api/session/ses_test/form/frm_question') return Response.json({ data: form });
+    if (path === '/api/session/ses_test/form/frm_question/reply' && options.method === 'POST') return new Response(null, { status: 204 });
+    return Response.json({ error: 'Not found' }, { status: 404 });
+  });
+  const runtime = createQuestionAutoDelegateRuntime({
+    globalEventHub: { subscribeEvent: (fn) => { onEvent = fn; return () => {}; } },
+    buildOpenCodeUrl: (path) => `http://opencode.test/api${path}`,
+    getOpenCodeAuthHeaders: () => ({}),
+    readSettingsFromDiskMigrated: async () => ({ projects: [{ path: '/project' }] }),
+    fetchImpl,
+  });
+  runtimes.push(runtime);
+  runtime.start();
+  await vi.advanceTimersByTimeAsync(0);
+  return {
+    runtime, fetchImpl,
+    emit: (type, data, directory = '/project') => onEvent({ directory: 'global', payload: {
+      type, data, ...(directory ? { location: { directory } } : {}),
+    } }),
+    posts: () => fetchImpl.mock.calls.filter(([, options]) => options.method === 'POST'),
+  };
+};
+
+it('auto-delegates a native question form after exactly 30 seconds without a UI', async () => {
+  const { emit, posts, runtime } = await setup();
+  emit('form.created', { sessionID: form.sessionID, form });
+  await vi.advanceTimersByTimeAsync(29_999);
+  expect(posts()).toHaveLength(0);
+  await vi.advanceTimersByTimeAsync(1);
+  expect(posts()).toHaveLength(1);
+  expect(posts()[0][0].pathname).toBe('/api/session/ses_test/form/frm_question/reply');
+  expect(JSON.parse(posts()[0][1].body)).toEqual({ answer: { approach: QUESTION_AUTO_DELEGATE_ANSWER } });
+  expect(runtime.snapshot().requests[0].state).toBe('settled');
+});
+
+it('recovers pending native question forms on startup', async () => {
+  const { posts } = await setup([form]);
+  await vi.advanceTimersByTimeAsync(30_000);
+  expect(posts()).toHaveLength(1);
+});
+
+it.each(['form.replied', 'form.cancelled'])('cancels the timer on %s', async (type) => {
+  const { emit, posts, runtime } = await setup();
+  emit('form.created', { sessionID: form.sessionID, form });
+  expect(runtime.snapshot().requests).toHaveLength(1);
+  emit(type, { sessionID: form.sessionID, id: form.id });
+  await vi.advanceTimersByTimeAsync(30_000);
+  expect(posts()).toHaveLength(0);
+  expect(runtime.snapshot().requests[0].state).toBe('settled');
+});
+
+it('does not auto-answer non-question forms', async () => {
+  const other = { ...form, metadata: { kind: 'configuration' } };
+  const { emit, posts, runtime } = await setup([other]);
+  emit('form.created', { sessionID: other.sessionID, form: other });
+  await vi.advanceTimersByTimeAsync(30_000);
+  expect(posts()).toHaveLength(0);
+  expect(runtime.snapshot().requests).toEqual([]);
+});
+
+it('resolves a directory-less event through the native session location', async () => {
+  const { emit, posts } = await setup();
+  emit('form.created', { form }, '');
+  await vi.advanceTimersByTimeAsync(30_000);
+  expect(posts()).toHaveLength(1);
+});
+
+it('preserves pending questions when native list reconciliation fails', async () => {
+  const { emit, runtime, fetchImpl, posts } = await setup();
+  emit('form.created', { form });
+  const original = fetchImpl.getMockImplementation();
+  fetchImpl.mockImplementation((url, options) => url.pathname === '/api/form'
+    ? Promise.resolve(new Response(null, { status: 503 })) : original(url, options));
+  await runtime.reconcile();
+  expect(runtime.snapshot().coverage.state).toBe('partial');
+  expect(runtime.snapshot().requests[0].state).toBe('counting');
+  await vi.advanceTimersByTimeAsync(30_000);
+  expect(posts()).toHaveLength(1);
+});
+
+it('pauses for retry when schema lookup fails, without sending an answer', async () => {
+  const { emit, runtime, fetchImpl, posts } = await setup();
+  emit('form.created', { form });
+  const original = fetchImpl.getMockImplementation();
+  fetchImpl.mockImplementation((url, options) => url.pathname.endsWith('/form/frm_question')
+    ? Promise.resolve(new Response(null, { status: 503 })) : original(url, options));
+  await vi.advanceTimersByTimeAsync(30_000);
+  expect(posts()).toHaveLength(0);
+  expect(runtime.snapshot().requests[0].state).toBe('paused');
+});
+
+it('honors user takeover and explicit delegation of native forms', async () => {
+  const { emit, runtime, posts } = await setup();
+  emit('form.created', { form });
+  const identity = { requestID: form.id, sessionID: form.sessionID, directory: '/project' };
+  await runtime.pause({ ...identity, reason: 'interaction' });
+  await vi.advanceTimersByTimeAsync(30_000);
+  expect(posts()).toHaveLength(0);
+  await runtime.delegate(identity);
+  expect(posts()).toHaveLength(1);
+});
+
+it('uses the freshly read schema for multiple fields and array answers', async () => {
+  const { emit, fetchImpl, posts } = await setup();
+  const original = fetchImpl.getMockImplementation();
+  fetchImpl.mockImplementation((url, options) => url.pathname.endsWith('/form/frm_question')
+    ? Promise.resolve(Response.json({ data: { ...form, fields: [
+      { key: 'actual_key', type: 'string', custom: true },
+      { key: 'targets', type: 'multiselect', custom: true, options: [] },
+    ] } })) : original(url, options));
+  emit('form.created', { form: { ...form, fields: [...form.fields, { key: 'old', type: 'multiselect' }] } });
+  await vi.advanceTimersByTimeAsync(30_000);
+  expect(JSON.parse(posts()[0][1].body)).toEqual({ answer: {
+    actual_key: QUESTION_AUTO_DELEGATE_ANSWER, targets: [QUESTION_AUTO_DELEGATE_ANSWER],
+  } });
+});