@openchambery/web 1.19.17-beta.2 → 1.19.17-beta.3

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

@@ -0,0 +1,223 @@
+import { QUESTION_SUBMISSION_CLAIMED_CODE } from './core.js';
+
+const asTrimmedString = (value) => (typeof value === 'string' && value.trim() ? value.trim() : '');
+
+const readDirectory = (req) => {
+  const fromQuery = asTrimmedString(
+    Array.isArray(req.query?.directory) ? req.query.directory[0] : req.query?.directory,
+  );
+  if (fromQuery) return fromQuery;
+  const fromBody = asTrimmedString(req.body?.directory);
+  if (fromBody) return fromBody;
+  const header = req.headers?.['x-opencode-directory'];
+  if (typeof header === 'string' && header.trim()) {
+    if (req.headers?.['x-opencode-directory-encoding'] === 'uri') {
+      try {
+        return decodeURIComponent(header.trim());
+      } catch {
+        return header.trim();
+      }
+    }
+    return header.trim();
+  }
+  return '';
+};
+
+const sendMutation = (res, result) => {
+  if (result.outcome === 'claimed') {
+    return res.status(409).json({
+      error: result.error || 'Question submission already claimed',
+      code: result.code || QUESTION_SUBMISSION_CLAIMED_CODE,
+      outcome: result.outcome,
+      snapshot: result.snapshot,
+    });
+  }
+  if (result.outcome === 'not_found') {
+    return res.status(404).json({
+      error: result.error || 'Not found',
+      outcome: result.outcome,
+      snapshot: result.snapshot,
+    });
+  }
+  if (result.outcome === 'error') {
+    return res.status(result.status || 500).json({
+      error: result.error || 'Question auto-delegate error',
+      outcome: result.outcome,
+      snapshot: result.snapshot,
+    });
+  }
+  if (result.outcome === 'disabled') {
+    return res.status(409).json({
+      error: result.error || 'Question auto-delegate is disabled',
+      outcome: result.outcome,
+      snapshot: result.snapshot,
+    });
+  }
+  if (result.outcome === 'paused') {
+    return res.json({
+      outcome: result.outcome,
+      snapshot: result.snapshot,
+    });
+  }
+  return res.json({
+    outcome: result.outcome,
+    snapshot: result.snapshot,
+    ...(result.upstreamStatus != null ? { upstreamStatus: result.upstreamStatus } : {}),
+  });
+};
+
+/**
+ * OpenChamber-owned question auto-delegate routes + precise intercepts for
+ * `/api/question/:id/reply|reject` (must register before the generic OpenCode proxy).
+ * Manual reply/reject keep the upstream SDK response shape/body on success.
+ */
+export function registerQuestionAutoDelegateRoutes(app, runtime) {
+  app.get('/api/question-auto-delegate', (_req, res) => {
+    try {
+      res.json(runtime.snapshot());
+    } catch (error) {
+      res.status(500).json({ error: error?.message ?? 'Failed to read question auto-delegate snapshot' });
+    }
+  });
+
+  app.post('/api/question-auto-delegate/requests/:requestID/pause', async (req, res) => {
+    try {
+      const result = await runtime.pause({
+        requestID: req.params.requestID,
+        sessionID: req.body?.sessionID,
+        directory: req.body?.directory,
+        reason: req.body?.reason,
+      });
+      return sendMutation(res, result);
+    } catch (error) {
+      return res.status(500).json({ error: error?.message ?? 'Failed to pause question auto-delegate' });
+    }
+  });
+
+  app.post('/api/question-auto-delegate/requests/:requestID/delegate', async (req, res) => {
+    try {
+      const result = await runtime.delegate({
+        requestID: req.params.requestID,
+        sessionID: req.body?.sessionID,
+        directory: req.body?.directory,
+      });
+      return sendMutation(res, result);
+    } catch (error) {
+      return res.status(500).json({ error: error?.message ?? 'Failed to delegate question' });
+    }
+  });
+
+  // Precise intercepts — claim then forward to upstream via runtime IO.
+  app.post('/api/question/:requestID/reply', async (req, res) => {
+    try {
+      const requestID = asTrimmedString(req.params.requestID);
+      const directory = readDirectory(req);
+      const sessionID = asTrimmedString(req.body?.sessionID);
+      // Manual path: answers must be present as an array (including []). Never
+      // substitute the auto-delegate fixed text.
+      if (!req.body || !Object.prototype.hasOwnProperty.call(req.body, 'answers')) {
+        return res.status(400).json({ error: 'answers is required' });
+      }
+      if (!Array.isArray(req.body.answers)) {
+        return res.status(400).json({ error: 'answers must be an array' });
+      }
+
+      const result = await runtime.submit({
+        requestID,
+        sessionID: sessionID || undefined,
+        directory: directory || undefined,
+        kind: 'reply',
+        authority: 'manual',
+        answers: req.body.answers,
+        body: req.body,
+      });
+
+      if (result.outcome === 'claimed') {
+        return res.status(409).json({
+          error: result.error || 'Question submission already claimed',
+          code: result.code || QUESTION_SUBMISSION_CLAIMED_CODE,
+        });
+      }
+      if (result.outcome === 'uncertain') {
+        return res.status(result.upstreamStatus && result.upstreamStatus >= 400 ? result.upstreamStatus : 502).json(
+          result.upstreamBody ?? { error: result.error || 'Question reply uncertain' },
+        );
+      }
+      if (result.outcome === 'not_found' || result.upstreamStatus === 404) {
+        // Preserve upstream 404 body shape when present.
+        if (result.upstreamBody != null) {
+          return res.status(404).json(result.upstreamBody);
+        }
+        return res.status(404).json({ error: 'Question not found' });
+      }
+      if (result.outcome === 'submitted' || result.outcome === 'settled') {
+        const status = result.upstreamStatus && result.upstreamStatus >= 200 ? result.upstreamStatus : 200;
+        if (result.upstreamBody === null || result.upstreamBody === undefined) {
+          // SDK optional unwrap expects boolean true on success for reply.
+          return res.status(status).json(true);
+        }
+        return res.status(status).json(result.upstreamBody);
+      }
+      if (result.outcome === 'error') {
+        // Definitive upstream reject (400/409/422) — preserve body when present.
+        if (result.upstreamBody != null && result.upstreamStatus) {
+          return res.status(result.upstreamStatus).json(result.upstreamBody);
+        }
+        return res.status(result.status || result.upstreamStatus || 500).json({
+          error: result.error || 'Question reply failed',
+        });
+      }
+      return res.status(result.upstreamStatus || 500).json(result.upstreamBody ?? { error: 'Question reply failed' });
+    } catch (error) {
+      return res.status(500).json({ error: error?.message ?? 'Question reply failed' });
+    }
+  });
+
+  app.post('/api/question/:requestID/reject', async (req, res) => {
+    try {
+      const requestID = asTrimmedString(req.params.requestID);
+      const directory = readDirectory(req);
+      const sessionID = asTrimmedString(req.body?.sessionID);
+
+      const result = await runtime.submit({
+        requestID,
+        sessionID: sessionID || undefined,
+        directory: directory || undefined,
+        kind: 'reject',
+        authority: 'manual',
+        body: req.body && typeof req.body === 'object' ? req.body : {},
+      });
+
+      if (result.outcome === 'claimed') {
+        return res.status(409).json({
+          error: result.error || 'Question submission already claimed',
+          code: result.code || QUESTION_SUBMISSION_CLAIMED_CODE,
+        });
+      }
+      if (result.outcome === 'uncertain') {
+        return res.status(result.upstreamStatus && result.upstreamStatus >= 400 ? result.upstreamStatus : 502).json(
+          result.upstreamBody ?? { error: result.error || 'Question reject uncertain' },
+        );
+      }
+      if (result.outcome === 'not_found' || result.upstreamStatus === 404) {
+        if (result.upstreamBody != null) {
+          return res.status(404).json(result.upstreamBody);
+        }
+        return res.status(404).json({ error: 'Question not found' });
+      }
+      if (result.outcome === 'submitted' || result.outcome === 'settled') {
+        const status = result.upstreamStatus && result.upstreamStatus >= 200 ? result.upstreamStatus : 200;
+        if (result.upstreamBody === null || result.upstreamBody === undefined) {
+          return res.status(status).json(true);
+        }
+        return res.status(status).json(result.upstreamBody);
+      }
+      if (result.outcome === 'error') {
+        return res.status(result.status || 500).json({ error: result.error || 'Question reject failed' });
+      }
+      return res.status(result.upstreamStatus || 500).json(result.upstreamBody ?? { error: 'Question reject failed' });
+    } catch (error) {
+      return res.status(500).json({ error: error?.message ?? 'Question reject failed' });
+    }
+  });
+}

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

@@ -0,0 +1,180 @@
+import express from 'express';
+import { describe, expect, it, vi } from 'vitest';
+import {
+  QUESTION_AUTO_DELEGATE_ANSWER,
+  QUESTION_SUBMISSION_CLAIMED_CODE,
+  createQuestionAutoDelegateCore,
+} from './core.js';
+import { registerQuestionAutoDelegateRoutes } from './routes.js';
+
+const listen = (app) => new Promise((resolve) => {
+  const server = app.listen(0, '127.0.0.1', () => {
+    const { port } = server.address();
+    resolve({
+      server,
+      base: `http://127.0.0.1:${port}`,
+      close: () => new Promise((r) => server.close(() => r())),
+    });
+  });
+});
+
+const createFakeTimers = () => {
+  const timers = [];
+  let now = 1_000_000;
+  let nextId = 1;
+  return {
+    now: () => now,
+    advance: async (ms) => {
+      now += ms;
+      const due = timers.filter((t) => !t.cleared && t.fireAt <= now);
+      for (const timer of due) {
+        timer.cleared = true;
+        timer.callback();
+        await Promise.resolve();
+        await Promise.resolve();
+      }
+    },
+    createTimer: (callback, delayMs) => {
+      const timer = { id: nextId++, fireAt: now + delayMs, callback, cleared: false };
+      timers.push(timer);
+      return { clear: () => { timer.cleared = true; } };
+    },
+  };
+};
+
+describe('question auto-delegate HTTP routes — claim arbitration', () => {
+  it('timer and manual POST share one upstream mutation (409 loser)', async () => {
+    const clock = createFakeTimers();
+    let release;
+    const gate = new Promise((resolve) => { release = resolve; });
+    let upstreamPosts = 0;
+    const posts = [];
+
+    const core = createQuestionAutoDelegateCore({
+      delayMs: 30_000,
+      io: {
+        now: clock.now,
+        createTimer: clock.createTimer,
+        createEpoch: () => 'epoch-http',
+        readEnabled: async () => true,
+        listDirectories: async () => ['/repo'],
+        listQuestions: async () => [],
+        getSession: async (id, directory) => ({ id, parentID: null, directory: directory || '/repo' }),
+        postReply: async (requestID, directory, answers) => {
+          upstreamPosts += 1;
+          posts.push({ requestID, directory, answers });
+          await gate;
+          return { ok: true, uncertain: false, status: 200, body: true };
+        },
+        postReject: async () => ({ ok: true, uncertain: false, status: 200, body: true }),
+      },
+    });
+    core.applyEnabled(true);
+    core.processEvent({
+      type: 'question.asked',
+      properties: {
+        id: 'q-race',
+        sessionID: 'ses-1',
+        directory: '/repo',
+        questions: [{ question: '?', header: 'h', options: [{ label: 'a', description: '' }] }],
+      },
+    });
+
+    const runtime = {
+      snapshot: () => core.snapshot(),
+      pause: (input) => core.pause(input),
+      delegate: (input) => core.delegate(input),
+      submit: (input) => core.submit(input),
+    };
+
+    const app = express();
+    app.use(express.json());
+    registerQuestionAutoDelegateRoutes(app, runtime);
+    const { base, close } = await listen(app);
+
+    try {
+      // Arm timer fire (auto claim starts and waits on gate).
+      const timerPromise = (async () => {
+        await clock.advance(30_000);
+      })();
+
+      // Give auto claim a tick to start.
+      await Promise.resolve();
+      await Promise.resolve();
+
+      const manualResponse = await fetch(`${base}/api/question/q-race/reply?directory=${encodeURIComponent('/repo')}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ answers: [['human']] }),
+      });
+      expect(manualResponse.status).toBe(409);
+      const manualBody = await manualResponse.json();
+      expect(manualBody.code).toBe(QUESTION_SUBMISSION_CLAIMED_CODE);
+
+      release();
+      await timerPromise;
+      // Drain auto submit.
+      for (let i = 0; i < 20; i += 1) await Promise.resolve();
+
+      expect(upstreamPosts).toBe(1);
+      expect(posts[0].answers).toEqual([[QUESTION_AUTO_DELEGATE_ANSWER]]);
+      expect(core.snapshot().requests[0].state).toBe('settled');
+      expect(core.snapshot().requests[0].submittedBy).toBe('auto');
+    } finally {
+      core.dispose();
+      await close();
+    }
+  });
+
+  it('manual answers:[] are accepted and forwarded without auto text', async () => {
+    const posts = [];
+    const core = createQuestionAutoDelegateCore({
+      io: {
+        now: () => 1,
+        createTimer: () => ({ clear() {} }),
+        createEpoch: () => 'e',
+        readEnabled: async () => true,
+        listDirectories: async () => ['/repo'],
+        listQuestions: async () => [],
+        getSession: async (id) => ({ id, parentID: null, directory: '/repo' }),
+        postReply: async (requestID, directory, answers) => {
+          posts.push(answers);
+          return { ok: true, uncertain: false, status: 200, body: true };
+        },
+        postReject: async () => ({ ok: true, uncertain: false, status: 200, body: true }),
+      },
+    });
+    core.applyEnabled(true);
+    core.processEvent({
+      type: 'question.asked',
+      properties: {
+        id: 'q-empty',
+        sessionID: 'ses-1',
+        directory: '/repo',
+        questions: [{ question: '?', header: 'h', options: [] }],
+      },
+    });
+
+    const app = express();
+    app.use(express.json());
+    registerQuestionAutoDelegateRoutes(app, {
+      snapshot: () => core.snapshot(),
+      pause: (i) => core.pause(i),
+      delegate: (i) => core.delegate(i),
+      submit: (i) => core.submit(i),
+    });
+    const { base, close } = await listen(app);
+    try {
+      const response = await fetch(`${base}/api/question/q-empty/reply`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ answers: [], directory: '/repo' }),
+      });
+      expect(response.status).toBe(200);
+      expect(posts).toEqual([[]]);
+    } finally {
+      core.dispose();
+      await close();
+    }
+  });
+});

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

@@ -0,0 +1,243 @@
+import {
+  createQuestionAutoDelegateCore,
+  QUESTION_AUTO_DELEGATE_DELAY_MS,
+} from './core.js';
+
+const REQUEST_TIMEOUT_MS = 15_000;
+
+const asTrimmedString = (value) => (typeof value === 'string' && value.trim() ? value.trim() : '');
+
+const parseJsonSafe = async (response) => {
+  const text = await response.text().catch(() => '');
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+};
+
+/**
+ * Web Host adapter: injects OpenCode upstream IO + event hub into the shared core.
+ * Does not loop through Host `/api/question/*` routes (avoids claim re-entry).
+ */
+export function createQuestionAutoDelegateRuntime({
+  globalEventHub,
+  buildOpenCodeUrl,
+  getOpenCodeAuthHeaders,
+  readSettingsFromDiskMigrated,
+  sanitizeProjects,
+  /** Optional: session-index / worktree inventory directories. */
+  listIndexedDirectories,
+  broadcastGlobalUiEvent,
+  broadcastOpenChamberEvent,
+  fetchImpl = fetch,
+  requestTimeoutMs = REQUEST_TIMEOUT_MS,
+  delayMs = QUESTION_AUTO_DELEGATE_DELAY_MS,
+  now = () => Date.now(),
+  createTimer = (callback, ms) => {
+    const handle = setTimeout(callback, ms);
+    return { clear: () => clearTimeout(handle) };
+  },
+  createEpoch = () => `qad-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`,
+  onUserTakeover,
+} = {}) {
+  const upstream = async (path, { directory, method = 'GET', body } = {}) => {
+    const url = new URL(buildOpenCodeUrl(path, ''));
+    if (directory) url.searchParams.set('directory', directory);
+    let response;
+    try {
+      response = await fetchImpl(url, {
+        method,
+        headers: {
+          Accept: 'application/json',
+          ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+          ...getOpenCodeAuthHeaders(),
+        },
+        ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+        signal: AbortSignal.timeout(requestTimeoutMs),
+      });
+    } catch (error) {
+      return {
+        ok: false,
+        uncertain: true,
+        status: 0,
+        body: { error: error?.message ?? 'Upstream request failed' },
+      };
+    }
+
+    const parsed = await parseJsonSafe(response);
+    if (response.ok) {
+      return { ok: true, uncertain: false, status: response.status, body: parsed };
+    }
+    // Definitive client/conflict rejects — core releases claim for manual retry.
+    if (response.status === 404 || response.status === 400 || response.status === 409 || response.status === 422) {
+      return { ok: false, uncertain: false, status: response.status, body: parsed };
+    }
+    if (response.status >= 500 || response.status === 0) {
+      return { ok: false, uncertain: true, status: response.status, body: parsed };
+    }
+    return { ok: false, uncertain: true, status: response.status, body: parsed };
+  };
+
+  const emitChanged = (tip) => {
+    const event = {
+      type: 'openchamber:question-auto-delegate-changed',
+      properties: {
+        epoch: tip.epoch,
+        revision: tip.revision,
+      },
+    };
+    try {
+      broadcastOpenChamberEvent?.(event);
+    } catch {
+      // ignore
+    }
+    try {
+      broadcastGlobalUiEvent?.(event);
+    } catch {
+      // ignore
+    }
+  };
+
+  const core = createQuestionAutoDelegateCore({
+    delayMs,
+    io: {
+      now,
+      createTimer,
+      createEpoch,
+      onChanged: emitChanged,
+      onUserTakeover,
+      /**
+       * @returns {Promise<boolean|null>} true/false when known; null when settings unreadable.
+       */
+      async readEnabled() {
+        try {
+          const settings = await readSettingsFromDiskMigrated();
+          if (settings?.questionAutoDelegateEnabled === false) return false;
+          return true;
+        } catch {
+          return null;
+        }
+      },
+      async listDirectories() {
+        const dirs = new Set();
+        try {
+          const settings = await readSettingsFromDiskMigrated();
+          const projects = typeof sanitizeProjects === 'function'
+            ? (sanitizeProjects(settings?.projects ?? []) || [])
+            : (Array.isArray(settings?.projects) ? settings.projects : []);
+          for (const project of projects) {
+            const path = asTrimmedString(project?.path);
+            if (path) dirs.add(path);
+          }
+        } catch {
+          // Project list failure is not fatal when index inventory exists.
+        }
+        if (typeof listIndexedDirectories === 'function') {
+          try {
+            const indexed = await listIndexedDirectories();
+            if (Array.isArray(indexed)) {
+              for (const directory of indexed) {
+                const path = asTrimmedString(directory);
+                if (path) dirs.add(path);
+              }
+            }
+          } catch {
+            // ignore index failures — core marks partial when inventory empty+failed
+          }
+        }
+        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;
+      },
+      async getSession(sessionID, directory) {
+        const result = await upstream(`/session/${encodeURIComponent(sessionID)}`, { directory });
+        if (!result.ok) return null;
+        const info = result.body?.data && typeof result.body.data === 'object'
+          ? result.body.data
+          : result.body;
+        if (!info || typeof info !== 'object') return null;
+        return {
+          id: asTrimmedString(info.id) || sessionID,
+          parentID: asTrimmedString(info.parentID) || null,
+          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 : {},
+        });
+      },
+    },
+  });
+
+  const processHubEvent = (event) => {
+    const raw = event?.payload;
+    const payload = raw?.payload && typeof raw.payload === 'object' ? raw.payload : raw;
+    const directory = typeof event?.directory === 'string' && event.directory && event.directory !== 'global'
+      ? event.directory
+      : '';
+    if (!payload || typeof payload !== 'object') return;
+    core.processEvent(payload, directory);
+  };
+
+  const start = () => {
+    const unsubscribers = [];
+    if (globalEventHub?.subscribeEvent) {
+      unsubscribers.push(globalEventHub.subscribeEvent(processHubEvent));
+    }
+    if (globalEventHub?.subscribeStatus) {
+      unsubscribers.push(globalEventHub.subscribeStatus((status) => {
+        if (status?.type === 'connect') {
+          void core.reconcile();
+        }
+      }));
+    }
+    const stopCore = core.start();
+    const stop = () => {
+      for (const unsubscribe of unsubscribers) {
+        try {
+          unsubscribe?.();
+        } catch {
+          // ignore
+        }
+      }
+      stopCore?.();
+      core.dispose();
+    };
+    core._attachStop?.(stop);
+    return stop;
+  };
+
+  return {
+    start,
+    dispose: () => core.dispose(),
+    snapshot: () => core.snapshot(),
+    applyEnabled: (enabled) => core.applyEnabled(enabled),
+    pause: (input) => core.pause(input),
+    delegate: (input) => core.delegate(input),
+    submit: (input) => core.submit(input),
+    reconcile: (options) => core.reconcile(options),
+    processEvent: (payload, directory) => core.processEvent(payload, directory),
+    isBlockingSession: (sessionID) => core.isBlockingSession(sessionID),
+    isAutoHandling: (sessionID, requestID) => core.isAutoHandling(sessionID, requestID),
+    pauseForSessionTree: (sessionID, directory) => core.pauseForSessionTree(sessionID, directory),
+    resolveRootSession: (sessionID) => core.resolveRootSession(sessionID),
+  };
+}

package/server/lib/session-goal/DOCUMENTATION.md

@@ -104,11 +104,21 @@ before touching the filesystem). Rationale: metadata rides every
       stop), with a tick-side safety net. Messages sent while paused leave
       the goal alone; Resume re-arms the loop, and resuming over an aborted
       tail skips the audit and goes straight to a continuation nudge;
-    - `question.asked` also pauses an active goal (including when a child /
+    - `question.asked` pauses an active goal (including when a child /
       sub-agent session asks — the parent session's goal is the one paused)
       but does NOT abort the current turn: aborting would kill the pending
       question. After the user answers, they Resume manually to re-arm
-      the loop;
+      the loop. **Exception:** when question auto-delegate is handling the
+      ask (`shouldKeepGoalActiveForQuestion`), the goal stays `active` and
+      only the idle timer is cleared; `tick` also bails while
+      `isQuestionBlockingGoal` reports a pending auto-delegated question on
+      the session or a known descendant. User pause / disable of auto-delegate
+      still calls `pauseForQuestion`. See `lib/question-auto-delegate/`.
+      Explicit `session.updated` with `status: paused` notifies `onGoalPaused`
+      (cancels related question timers) **except** when `statusReason` is
+      `paused for question` (auto-delegate must keep counting). Abort after
+      metadata already paused still notifies for non-question pause reasons
+      (UI concurrent abort + metadata race).
    - terminal checks, cheapest first: assistant turn error → `blocked`;
      `tokensUsed >= tokenBudget` → `budgetLimited`;
      `turnsUsed >= MAX_AUTO_TURNS` (20) → `blocked`;