@aiworker/web 1.22.0 → 1.23.0

package/server/lib/openchamber-control/service.js

@@ -1,14 +1,14 @@
 import path from 'node:path';
 import { createOpencodeClient } from '@opencode-ai/sdk/v2';
-import { OpenChamberControlError, asControlError } from './error.js';
-import { OPENCHAMBER_ALL_ACTIONS } from './actions.js';
+import { AiWorkerControlError, asControlError } from './error.js';
+import { AIWORKER_ALL_ACTIONS } from './actions.js';
 import { writeScreenshot } from './screenshots.js';
 
 const DEFAULT_WAIT_TIMEOUT_SECONDS = 600;
 const MAX_WAIT_TIMEOUT_SECONDS = 86_400;
 const WAIT_POLL_INTERVAL_MS = 500;
 // One service, both capabilities: which tool asked is the caller's concern.
-const CONTROL_ACTIONS = new Set(OPENCHAMBER_ALL_ACTIONS);
+const CONTROL_ACTIONS = new Set(AIWORKER_ALL_ACTIONS);
 const SCHEDULE_TASK_ID_ACTIONS = new Set([
   'schedule.run',
   'schedule.delete',
@@ -25,7 +25,7 @@ const positiveInteger = (value, fallback, field) => {
   if (value === undefined || value === null) return fallback;
   const number = Number(value);
   if (!Number.isSafeInteger(number) || number < 1) {
-    throw new OpenChamberControlError(`${field} must be a positive integer`, 400);
+    throw new AiWorkerControlError(`${field} must be a positive integer`, 400);
   }
   return number;
 };
@@ -33,7 +33,7 @@ const positiveInteger = (value, fallback, field) => {
 const normalizeWaitTimeoutMs = (value) => {
   const seconds = value === undefined || value === null ? DEFAULT_WAIT_TIMEOUT_SECONDS : Number(value);
   if (!Number.isSafeInteger(seconds) || seconds < 1 || seconds > MAX_WAIT_TIMEOUT_SECONDS) {
-    throw new OpenChamberControlError(`timeout must be from 1 to ${MAX_WAIT_TIMEOUT_SECONDS} seconds`, 400);
+    throw new AiWorkerControlError(`timeout must be from 1 to ${MAX_WAIT_TIMEOUT_SECONDS} seconds`, 400);
   }
   return seconds * 1000;
 };
@@ -64,20 +64,20 @@ const extractTextMessages = (messages, role = 'all') => {
 
 const parseModel = (value) => {
   const model = asNonEmptyString(value);
-  if (!model) throw new OpenChamberControlError('model is required', 400);
+  if (!model) throw new AiWorkerControlError('model is required', 400);
   const slashIndex = model.indexOf('/');
   if (slashIndex <= 0 || slashIndex === model.length - 1) {
-    throw new OpenChamberControlError('model must be in provider/model format', 400);
+    throw new AiWorkerControlError('model must be in provider/model format', 400);
   }
   return { providerID: model.slice(0, slashIndex), modelID: model.slice(slashIndex + 1) };
 };
 
 const parseWeekdays = (value) => {
   const raw = asNonEmptyString(value);
-  if (!raw) throw new OpenChamberControlError('weekly is required', 400);
+  if (!raw) throw new AiWorkerControlError('weekly is required', 400);
   const weekdays = raw.split(',').map((entry) => Number.parseInt(entry.trim(), 10));
   if (weekdays.some((entry) => !Number.isInteger(entry) || entry < 0 || entry > 6)) {
-    throw new OpenChamberControlError('weekly must contain weekdays from 0 to 6', 400);
+    throw new AiWorkerControlError('weekly must contain weekdays from 0 to 6', 400);
   }
   return Array.from(new Set(weekdays)).sort((a, b) => a - b);
 };
@@ -89,18 +89,18 @@ const buildSchedule = (input) => {
   const cron = asNonEmptyString(input.cron);
   const selectors = [daily, weekly, once, cron].filter(Boolean);
   if (selectors.length !== 1) {
-    throw new OpenChamberControlError('Provide exactly one of daily, weekly, once, or cron', 400);
+    throw new AiWorkerControlError('Provide exactly one of daily, weekly, once, or cron', 400);
   }
   const timezone = asNonEmptyString(input.timezone);
   if (daily) return { kind: 'daily', times: [daily], ...(timezone ? { timezone } : {}) };
   if (weekly) {
     const time = asNonEmptyString(input.time);
-    if (!time) throw new OpenChamberControlError('time is required with weekly', 400);
+    if (!time) throw new AiWorkerControlError('time is required with weekly', 400);
     return { kind: 'weekly', weekdays: parseWeekdays(weekly), times: [time], ...(timezone ? { timezone } : {}) };
   }
   if (once) {
     const time = asNonEmptyString(input.time);
-    if (!time) throw new OpenChamberControlError('time is required with once', 400);
+    if (!time) throw new AiWorkerControlError('time is required with once', 400);
     return { kind: 'once', date: once, time, ...(timezone ? { timezone } : {}) };
   }
   return { kind: 'cron', cron, ...(timezone ? { timezone } : {}) };
@@ -109,15 +109,15 @@ const buildSchedule = (input) => {
 const buildScheduledTask = (input) => {
   const name = asNonEmptyString(input.name);
   const prompt = asNonEmptyString(input.prompt);
-  if (!name) throw new OpenChamberControlError('name is required', 400);
-  if (!prompt) throw new OpenChamberControlError('prompt is required', 400);
+  if (!name) throw new AiWorkerControlError('name is required', 400);
+  if (!prompt) throw new AiWorkerControlError('prompt is required', 400);
   const model = parseModel(input.model);
   const goalTokenBudget = input.goalTokenBudget;
   if (goalTokenBudget !== undefined && input.goal !== true) {
-    throw new OpenChamberControlError('goalTokenBudget requires goal', 400);
+    throw new AiWorkerControlError('goalTokenBudget requires goal', 400);
   }
   if (goalTokenBudget !== undefined && (!Number.isSafeInteger(goalTokenBudget) || goalTokenBudget < 1000 || goalTokenBudget > 100_000_000)) {
-    throw new OpenChamberControlError('goalTokenBudget must be from 1000 to 100000000', 400);
+    throw new AiWorkerControlError('goalTokenBudget must be from 1000 to 100000000', 400);
   }
   return {
     name,
@@ -134,7 +134,7 @@ const buildScheduledTask = (input) => {
   };
 };
 
-export const createOpenChamberControlService = (dependencies) => {
+export const createAiWorkerControlService = (dependencies) => {
   const {
     readSettingsFromDiskMigrated,
     sanitizeProjects,
@@ -152,11 +152,11 @@ export const createOpenChamberControlService = (dependencies) => {
 
   const wait = (duration, signal) => {
     if (!signal) return sleep(duration);
-    if (signal.aborted) return Promise.reject(new OpenChamberControlError('OpenChamber action was cancelled', 499));
+    if (signal.aborted) return Promise.reject(new AiWorkerControlError('AiWorker action was cancelled', 499));
     return new Promise((resolve, reject) => {
       const onAbort = () => {
         signal.removeEventListener('abort', onAbort);
-        reject(new OpenChamberControlError('OpenChamber action was cancelled', 499));
+        reject(new AiWorkerControlError('AiWorker action was cancelled', 499));
       };
       signal.addEventListener('abort', onAbort, { once: true });
       sleep(duration).then(() => {
@@ -201,7 +201,7 @@ export const createOpenChamberControlService = (dependencies) => {
     const response = await client.session.status({ directory });
     const statuses = response?.data;
     if (!statuses || typeof statuses !== 'object' || Array.isArray(statuses)) {
-      throw new OpenChamberControlError('Invalid session status response', 500);
+      throw new AiWorkerControlError('Invalid session status response', 500);
     }
     return statuses[sessionID] || { type: 'idle' };
   };
@@ -223,7 +223,7 @@ export const createOpenChamberControlService = (dependencies) => {
     const deadline = now() + timeoutMs;
     let observedActivity = false;
     while (true) {
-      if (signal?.aborted) throw new OpenChamberControlError('OpenChamber action was cancelled', 499);
+      if (signal?.aborted) throw new AiWorkerControlError('AiWorker action was cancelled', 499);
       const status = await sessionStatus(client, sessionID, directory);
       if (status.type === 'busy' || status.type === 'retry') {
         observedActivity = true;
@@ -238,7 +238,7 @@ export const createOpenChamberControlService = (dependencies) => {
       }
       const remaining = deadline - now();
       if (remaining <= 0) {
-        throw new OpenChamberControlError(`Session did not become idle within ${Math.ceil(timeoutMs / 1000)} seconds`, 500);
+        throw new AiWorkerControlError(`Session did not become idle within ${Math.ceil(timeoutMs / 1000)} seconds`, 500);
       }
       await wait(Math.min(WAIT_POLL_INTERVAL_MS, remaining), signal);
     }
@@ -262,8 +262,8 @@ export const createOpenChamberControlService = (dependencies) => {
   };
 
   const executeSessionAction = async (action, input, contextDirectory, signal) => {
-    if (input.timeout !== undefined && input.wait !== true) throw new OpenChamberControlError('timeout requires wait', 400);
-    if (input.lastAssistant === true && input.wait !== true) throw new OpenChamberControlError('lastAssistant requires wait', 400);
+    if (input.timeout !== undefined && input.wait !== true) throw new AiWorkerControlError('timeout requires wait', 400);
+    if (input.lastAssistant === true && input.wait !== true) throw new AiWorkerControlError('lastAssistant requires wait', 400);
     const sessionID = asNonEmptyString(input.sessionId);
     let directory = asNonEmptyString(input.directory) || (!input.projectId ? asNonEmptyString(contextDirectory) : null);
     if (sessionID && action !== 'session.create' && !asNonEmptyString(input.directory) && !input.projectId) {
@@ -293,7 +293,7 @@ export const createOpenChamberControlService = (dependencies) => {
     if (action === 'session.create') {
       result = await sessionService.create(payload);
     } else {
-      if (!sessionID) throw new OpenChamberControlError('sessionId is required', 400);
+      if (!sessionID) throw new AiWorkerControlError('sessionId is required', 400);
       if (action === 'session.send') {
         result = await sessionService.send(sessionID, payload);
       } else {
@@ -335,11 +335,11 @@ export const createOpenChamberControlService = (dependencies) => {
     const readViewport = (required) => {
       const viewport = asNonEmptyString(input.viewport);
       if (!viewport) {
-        if (required) throw new OpenChamberControlError('viewport is required for browser.resize', 400);
+        if (required) throw new AiWorkerControlError('viewport is required for browser.resize', 400);
         return;
       }
       if (!['mobile', 'tablet', 'desktop', 'fill'].includes(viewport)) {
-        throw new OpenChamberControlError('viewport must be mobile, tablet, desktop, or fill', 400);
+        throw new AiWorkerControlError('viewport must be mobile, tablet, desktop, or fill', 400);
       }
       parameters.viewport = viewport;
     };
@@ -354,15 +354,15 @@ export const createOpenChamberControlService = (dependencies) => {
     if (action === 'browser.open') {
       readViewport(false);
       const url = asNonEmptyString(input.url);
-      if (!url) throw new OpenChamberControlError('url is required for browser.open', 400);
+      if (!url) throw new AiWorkerControlError('url is required for browser.open', 400);
       let parsed;
       try {
         parsed = new URL(url);
       } catch {
-        throw new OpenChamberControlError('url must be an absolute http(s) URL', 400);
+        throw new AiWorkerControlError('url must be an absolute http(s) URL', 400);
       }
       if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
-        throw new OpenChamberControlError('url must use http or https', 400);
+        throw new AiWorkerControlError('url must use http or https', 400);
       }
       parameters.url = parsed.toString();
     }
@@ -372,7 +372,7 @@ export const createOpenChamberControlService = (dependencies) => {
       const selector = asNonEmptyString(input.selector);
       const text = asNonEmptyString(input.text);
       if (!selector && !text) {
-        throw new OpenChamberControlError('browser.click requires selector or text', 400);
+        throw new AiWorkerControlError('browser.click requires selector or text', 400);
       }
       if (selector) parameters.selector = selector;
       if (text) parameters.text = text;
@@ -385,15 +385,15 @@ export const createOpenChamberControlService = (dependencies) => {
 
     if (action === 'browser.inspect') {
       const selector = asNonEmptyString(input.selector);
-      if (!selector) throw new OpenChamberControlError('selector is required for browser.inspect', 400);
+      if (!selector) throw new AiWorkerControlError('selector is required for browser.inspect', 400);
       parameters.selector = selector;
     }
 
     if (action === 'browser.type') {
       const selector = asNonEmptyString(input.selector);
-      if (!selector) throw new OpenChamberControlError('selector is required for browser.type', 400);
+      if (!selector) throw new AiWorkerControlError('selector is required for browser.type', 400);
       if (typeof input.value !== 'string') {
-        throw new OpenChamberControlError('value is required for browser.type', 400);
+        throw new AiWorkerControlError('value is required for browser.type', 400);
       }
       parameters.selector = selector;
       parameters.value = input.value;
@@ -404,10 +404,10 @@ export const createOpenChamberControlService = (dependencies) => {
       const selector = asNonEmptyString(input.selector);
       const direction = asNonEmptyString(input.direction);
       if (!selector && !direction) {
-        throw new OpenChamberControlError('browser.scroll requires direction or selector', 400);
+        throw new AiWorkerControlError('browser.scroll requires direction or selector', 400);
       }
       if (direction && !['up', 'down', 'top', 'bottom'].includes(direction)) {
-        throw new OpenChamberControlError('direction must be up, down, top, or bottom', 400);
+        throw new AiWorkerControlError('direction must be up, down, top, or bottom', 400);
       }
       if (selector) parameters.selector = selector;
       if (direction) parameters.direction = direction;
@@ -425,7 +425,7 @@ export const createOpenChamberControlService = (dependencies) => {
     if (action === 'browser.capture') {
       const directory = asNonEmptyString(input.directory) || asNonEmptyString(contextDirectory);
       if (!directory) {
-        throw new OpenChamberControlError('directory is required to save a screenshot', 400);
+        throw new AiWorkerControlError('directory is required to save a screenshot', 400);
       }
       const capture = result && typeof result === 'object' ? result : {};
       const saved = await writeScreenshot({
@@ -457,17 +457,17 @@ export const createOpenChamberControlService = (dependencies) => {
   const execute = async (action, input = {}, contextDirectory, options = {}) => {
     try {
       if (!CONTROL_ACTIONS.has(action)) {
-        throw new OpenChamberControlError(`Unsupported OpenChamber action: ${action || 'missing'}`, 400);
+        throw new AiWorkerControlError(`Unsupported AiWorker action: ${action || 'missing'}`, 400);
       }
       if (action.startsWith('memory.')) {
         if (!agentMemoryActions) {
-          throw new OpenChamberControlError('Agent memory is not available on this server', 503);
+          throw new AiWorkerControlError('Agent memory is not available on this server', 503);
         }
         return agentMemoryActions.execute(action, input, contextDirectory);
       }
       if (action.startsWith('browser.')) {
         if (!browserControl) {
-          throw new OpenChamberControlError('The in-app browser is not available on this server', 503);
+          throw new AiWorkerControlError('The in-app browser is not available on this server', 503);
         }
         return browserAction(action, input, options.signal, contextDirectory);
       }
@@ -477,7 +477,7 @@ export const createOpenChamberControlService = (dependencies) => {
       if (action.startsWith('schedule.')) {
         const taskID = asNonEmptyString(input.taskId);
         if (SCHEDULE_TASK_ID_ACTIONS.has(action) && !taskID) {
-          throw new OpenChamberControlError('taskId is required', 400);
+          throw new AiWorkerControlError('taskId is required', 400);
         }
         const explicitProjectID = asNonEmptyString(input.projectId);
         const explicitDirectory = asNonEmptyString(input.directory);
@@ -501,7 +501,7 @@ export const createOpenChamberControlService = (dependencies) => {
             return { deleted: true, tasks: await scheduledTaskService.remove(projectID, taskID) };
           case 'schedule.toggle': {
             if (typeof input.disabled !== 'boolean') {
-              throw new OpenChamberControlError('disabled is required for schedule.toggle', 400);
+              throw new AiWorkerControlError('disabled is required for schedule.toggle', 400);
             }
             const enabled = input.disabled === false;
             return { task: await scheduledTaskService.setEnabled(projectID, taskID, enabled), enabled };
@@ -536,18 +536,18 @@ export const createOpenChamberControlService = (dependencies) => {
           }
           return { sessions, limit, directory, archived: input.all === true ? 'included' : 'excluded' };
         }
-        if (!sessionID) throw new OpenChamberControlError('sessionId is required', 400);
-        if (!directory) throw new OpenChamberControlError('directory is required', 400);
+        if (!sessionID) throw new AiWorkerControlError('sessionId is required', 400);
+        if (!directory) throw new AiWorkerControlError('directory is required', 400);
         if (action === 'session.status') {
           return { sessionId: sessionID, directory, sessionStatus: await sessionStatus(client, sessionID, directory) };
         }
         if (action === 'session.messages') {
-          if (input.timeout !== undefined && input.wait !== true) throw new OpenChamberControlError('timeout requires wait', 400);
+          if (input.timeout !== undefined && input.wait !== true) throw new AiWorkerControlError('timeout requires wait', 400);
           const role = input.lastAssistant === true ? 'assistant' : (asNonEmptyString(input.role) || 'all');
-          if (!['all', 'user', 'assistant'].includes(role)) throw new OpenChamberControlError('role must be all, user, or assistant', 400);
+          if (!['all', 'user', 'assistant'].includes(role)) throw new AiWorkerControlError('role must be all, user, or assistant', 400);
           const last = input.last === true || input.lastAssistant === true;
-          if (input.all === true && (last || input.limit !== undefined)) throw new OpenChamberControlError('all cannot be combined with last or limit', 400);
-          if (last && input.limit !== undefined) throw new OpenChamberControlError('last cannot be combined with limit', 400);
+          if (input.all === true && (last || input.limit !== undefined)) throw new AiWorkerControlError('all cannot be combined with last or limit', 400);
+          if (last && input.limit !== undefined) throw new AiWorkerControlError('last cannot be combined with limit', 400);
           const currentStatus = input.wait === true
             ? await waitForIdle({ client, sessionID, directory, timeoutMs: normalizeWaitTimeoutMs(input.timeout), requireActivity: false, startedAt: now(), signal: options.signal })
             : await sessionStatus(client, sessionID, directory);
@@ -555,9 +555,9 @@ export const createOpenChamberControlService = (dependencies) => {
           return { sessionId: sessionID, directory, role, sessionStatus: currentStatus, messages: await sessionMessages(client, sessionID, directory, role, limit) };
         }
       }
-      throw new OpenChamberControlError(`Unsupported OpenChamber action: ${action || 'missing'}`, 400);
+      throw new AiWorkerControlError(`Unsupported AiWorker action: ${action || 'missing'}`, 400);
     } catch (error) {
-      throw asControlError(error, `Failed to execute ${action || 'OpenChamber action'}`);
+      throw asControlError(error, `Failed to execute ${action || 'AiWorker action'}`);
     }
   };
 

package/server/lib/openchamber-control/service.test.js

@@ -4,7 +4,7 @@ import os from 'node:os';
 import path from 'node:path';
 import fs from 'node:fs/promises';
 
-import { createOpenChamberControlService } from './service.js';
+import { createAiWorkerControlService } from './service.js';
 
 const createService = (overrides = {}) => {
   const client = {
@@ -28,7 +28,7 @@ const createService = (overrides = {}) => {
     remove: vi.fn(),
     setEnabled: vi.fn(),
   };
-  const service = createOpenChamberControlService({
+  const service = createAiWorkerControlService({
     readSettingsFromDiskMigrated: vi.fn(async () => ({
       projects: [{ id: 'project-1', path: '/repo', label: 'Repo' }],
       defaultModel: 'provider/model',
@@ -47,7 +47,7 @@ const createService = (overrides = {}) => {
   return { service, client, sessionService, scheduledTaskService };
 };
 
-describe('OpenChamber control service', () => {
+describe('AiWorker control service', () => {
   it('serves project and model projections without an HTTP or CLI round trip', async () => {
     const { service } = createService();
     await expect(service.execute('projects.list')).resolves.toEqual({
@@ -262,7 +262,7 @@ describe('OpenChamber control service', () => {
 
   it('rejects actions outside the fixed contract', async () => {
     const { service } = createService();
-    await expect(service.execute('session.delete')).rejects.toThrow('Unsupported OpenChamber action');
+    await expect(service.execute('session.delete')).rejects.toThrow('Unsupported AiWorker action');
   });
 });
 
@@ -289,7 +289,7 @@ describe('browser capture', () => {
 
     const result = await service.execute('browser.capture', { label: 'After fix' }, directory);
 
-    expect(result.path.startsWith('.openchamber/screenshots/after-fix-')).toBe(true);
+    expect(result.path.startsWith('.aiworker/screenshots/after-fix-')).toBe(true);
     expect(result.path.endsWith('.png')).toBe(true);
     expect(result.url).toBe('http://localhost:3000/');
     expect(result.viewport).toEqual({ mode: 'mobile', width: 390, height: 844 });

package/server/lib/openchamber-sessions/routes.js

@@ -4,7 +4,7 @@ import { createWorktree, getWorktreeBootstrapStatus } from '../git/index.js';
 import { expandSnippets } from '../opencode/snippets.js';
 import { expandCommandGoalObjective, parseScheduledCommandPrompt } from '../scheduled-tasks/runtime.js';
 import { buildGoalIntroText, createSessionGoal } from '../session-goal/create.js';
-import { OpenChamberControlError, asControlError } from '../openchamber-control/error.js';
+import { AiWorkerControlError, asControlError } from '../openchamber-control/error.js';
 
 const asNonEmptyString = (value) => {
   if (typeof value !== 'string') return null;
@@ -253,6 +253,40 @@ const latestCompletedAssistantMessageID = async ({ client, sessionID, directory
   return asNonEmptyString(latest?.id);
 };
 
+/**
+ * Upper bound on one archive batch.
+ *
+ * The batch is applied one session at a time against OpenCode, so an unbounded
+ * list would hold a request open for as long as the list is large. Callers with
+ * more sessions than this send several batches and keep their own partial
+ * results.
+ */
+const MAX_ARCHIVE_BATCH = 500;
+
+const parseArchiveRequest = (payload) => {
+  const rawIds = payload?.ids;
+  if (!Array.isArray(rawIds) || rawIds.length === 0) {
+    return { ok: false, error: 'ids must be a non-empty array of session ids' };
+  }
+  if (rawIds.length > MAX_ARCHIVE_BATCH) {
+    return { ok: false, error: `ids must contain at most ${MAX_ARCHIVE_BATCH} session ids` };
+  }
+
+  const ids = [];
+  for (const value of rawIds) {
+    const id = asNonEmptyString(value);
+    if (!id) return { ok: false, error: 'ids must contain non-empty session ids' };
+    ids.push(id);
+  }
+
+  const archivedAt = payload?.archivedAt;
+  if (archivedAt !== undefined && (!Number.isSafeInteger(archivedAt) || archivedAt <= 0)) {
+    return { ok: false, error: 'archivedAt must be a positive integer timestamp' };
+  }
+
+  return { ok: true, ids, archivedAt: archivedAt ?? Date.now() };
+};
+
 const resolveRequestedDirectory = async ({ payload, readSettingsFromDiskMigrated, sanitizeProjects, validateDirectoryPath }) => {
   const projectID = asNonEmptyString(payload?.projectId) || asNonEmptyString(payload?.projectID);
   if (projectID) {
@@ -292,12 +326,12 @@ const waitForWorktreeBootstrapReady = async ({ directory }) => {
   for (;;) {
     const status = await getWorktreeBootstrapStatus(directory);
     if (status?.status === 'failed') {
-      throw new OpenChamberControlError(`Worktree bootstrap failed: ${status.error || 'unknown error'}`, 500);
+      throw new AiWorkerControlError(`Worktree bootstrap failed: ${status.error || 'unknown error'}`, 500);
     }
     const phase = status?.phase;
     if (status?.status === 'ready' || phase === 'git-ready' || phase === 'setup-ready') return;
     if (Date.now() >= deadline) {
-      throw new OpenChamberControlError('Timed out waiting for the worktree bootstrap', 500);
+      throw new AiWorkerControlError('Timed out waiting for the worktree bootstrap', 500);
     }
     await new Promise((resolve) => setTimeout(resolve, WORKTREE_BOOTSTRAP_POLL_MS));
   }
@@ -350,7 +384,7 @@ const resolveWorktreeInput = (payload) => {
   };
 };
 
-export const createOpenChamberSessionService = (dependencies) => {
+export const createAiWorkerSessionService = (dependencies) => {
   const {
     readSettingsFromDiskMigrated,
     sanitizeProjects,
@@ -404,23 +438,23 @@ export const createOpenChamberSessionService = (dependencies) => {
     if (requestedAgent && agents.length > 0) {
       const agent = agents.find((entry) => entry?.name === requestedAgent) || null;
       if (!agent) {
-        throw new OpenChamberControlError(`Unknown agent '${requestedAgent}' for ${directory}`, 400);
+        throw new AiWorkerControlError(`Unknown agent '${requestedAgent}' for ${directory}`, 400);
       }
       if (!isPrimaryAgentMode(agent.mode)) {
-        throw new OpenChamberControlError(`Agent '${requestedAgent}' is a subagent and cannot receive a prompt directly`, 400);
+        throw new AiWorkerControlError(`Agent '${requestedAgent}' is a subagent and cannot receive a prompt directly`, 400);
       }
     }
 
     if (requestedModel && providers.length > 0) {
       if (!hasProviderModel(providers, requestedModel.providerID, requestedModel.modelID)) {
-        throw new OpenChamberControlError(
+        throw new AiWorkerControlError(
           `Unknown model '${requestedModel.providerID}/${requestedModel.modelID}' for ${directory}`,
           400,
         );
       }
       if (requestedVariant
         && !resolveVariant(providers, requestedModel.providerID, requestedModel.modelID, requestedVariant)) {
-        throw new OpenChamberControlError(
+        throw new AiWorkerControlError(
           `Unknown variant '${requestedVariant}' for model '${requestedModel.providerID}/${requestedModel.modelID}'`,
           400,
         );
@@ -499,7 +533,7 @@ export const createOpenChamberSessionService = (dependencies) => {
         tokenBudget: goalInput.tokenBudget,
         providerID: model.providerID,
         modelID: model.modelID,
-        onWarning: (message, error) => console.warn(`[OpenChamberSessions] ${message}:`, error?.message || error),
+        onWarning: (message, error) => console.warn(`[AiWorkerSessions] ${message}:`, error?.message || error),
       });
     }
 
@@ -579,12 +613,70 @@ export const createOpenChamberSessionService = (dependencies) => {
     return { model, agent, variant, promptDispatched: true, dispatchedAsCommand: Boolean(resolvedCommand) };
   };
 
+  /**
+   * Archive a batch of sessions in one request.
+   *
+   * The UI archives every session linked to a worktree before removing it.
+   * Doing that from the browser costs one request per session plus a store
+   * reconciliation between each of them, which is what made deleting a
+   * worktree with many sessions take tens of seconds. Here the batch stays on
+   * the server, next to OpenCode, and the client reconciles once.
+   *
+   * Sessions are updated one at a time on purpose: they are archived against a
+   * single OpenCode instance, and a fan-out of concurrent writes would trade a
+   * UI stall for server event-loop starvation. One failed session never stops
+   * the batch — it is reported in `failedIds` while the rest still archive, so
+   * callers keep the partial-failure behaviour they already show.
+   */
+  const archive = async (payload = {}) => {
+    const parsed = parseArchiveRequest(payload);
+    if (!parsed.ok) {
+      throw new AiWorkerControlError(parsed.error, 400);
+    }
+
+    const resolvedDirectory = await resolveRequestedDirectory({
+      payload,
+      readSettingsFromDiskMigrated,
+      sanitizeProjects,
+      validateDirectoryPath,
+    });
+    if (!resolvedDirectory.ok) {
+      throw new AiWorkerControlError(resolvedDirectory.error, resolvedDirectory.status || 400);
+    }
+
+    if (typeof waitForOpenCodeReady === 'function') await waitForOpenCodeReady(10_000, 250);
+
+    const directory = resolvedDirectory.directory;
+    const baseUrl = buildOpenCodeUrl('/', '').replace(/\/$/, '');
+    const client = createOpencodeClient({ baseUrl, headers: getOpenCodeAuthHeaders() });
+
+    const archived = [];
+    const failedIds = [];
+    for (const sessionID of parsed.ids) {
+      try {
+        const response = await client.session.update({
+          sessionID,
+          directory,
+          time: { archived: parsed.archivedAt },
+        });
+        const session = response?.data;
+        if (session?.id) archived.push(session);
+        else failedIds.push(sessionID);
+      } catch (error) {
+        console.warn('[AiWorkerSessions] failed to archive session', sessionID, error);
+        failedIds.push(sessionID);
+      }
+    }
+
+    return { directory, archived, failedIds };
+  };
+
   const create = async (payload = {}) => {
     const title = asNonEmptyString(payload.title);
     const prompt = asNonEmptyString(payload.prompt);
     const goalInput = resolveGoalInput(payload, prompt);
     if (!goalInput.ok) {
-      throw new OpenChamberControlError(goalInput.error, 400);
+      throw new AiWorkerControlError(goalInput.error, 400);
     }
     const model = resolveRequestedModel(payload);
     const agent = asNonEmptyString(payload.agent);
@@ -597,14 +689,14 @@ export const createOpenChamberSessionService = (dependencies) => {
       validateDirectoryPath,
     });
     if (!resolvedDirectory.ok) {
-      throw new OpenChamberControlError(resolvedDirectory.error, resolvedDirectory.status || 400);
+      throw new AiWorkerControlError(resolvedDirectory.error, resolvedDirectory.status || 400);
     }
 
     const worktreeInput = resolveWorktreeInput(payload);
     let worktree = null;
     let sessionDirectory = resolvedDirectory.directory;
     if (payload?.worktree && !worktreeInput) {
-      throw new OpenChamberControlError('worktree.name is required when worktree is provided', 400);
+      throw new AiWorkerControlError('worktree.name is required when worktree is provided', 400);
     }
 
     if (typeof waitForOpenCodeReady === 'function') await waitForOpenCodeReady(10_000, 250);
@@ -692,10 +784,10 @@ export const createOpenChamberSessionService = (dependencies) => {
   const runExisting = async (action, sourceSessionId, payload = {}) => {
     const sourceSessionID = asNonEmptyString(sourceSessionId);
     const prompt = asNonEmptyString(payload.prompt);
-    if (!sourceSessionID) throw new OpenChamberControlError('sessionId is required', 400);
-    if (!prompt) throw new OpenChamberControlError('prompt is required', 400);
+    if (!sourceSessionID) throw new AiWorkerControlError('sessionId is required', 400);
+    if (!prompt) throw new AiWorkerControlError('prompt is required', 400);
     const goalInput = resolveGoalInput(payload, prompt);
-    if (!goalInput.ok) throw new OpenChamberControlError(goalInput.error, 400);
+    if (!goalInput.ok) throw new AiWorkerControlError(goalInput.error, 400);
     const requestedModel = resolveRequestedModel(payload);
 
     let targetSessionID = sourceSessionID;
@@ -709,7 +801,7 @@ export const createOpenChamberSessionService = (dependencies) => {
         validateDirectoryPath,
       });
       if (!resolvedDirectory.ok) {
-        throw new OpenChamberControlError(resolvedDirectory.error, resolvedDirectory.status || 400);
+        throw new AiWorkerControlError(resolvedDirectory.error, resolvedDirectory.status || 400);
       }
       directory = resolvedDirectory.directory;
       if (typeof waitForOpenCodeReady === 'function') await waitForOpenCodeReady(10_000, 250);
@@ -794,7 +886,7 @@ export const createOpenChamberSessionService = (dependencies) => {
       const statusCode = Number(error?.statusCode) || 500;
       const forkCreated = action === 'fork' && targetSessionID !== sourceSessionID;
       const goalConfigured = error?.goalConfigured === true;
-      throw new OpenChamberControlError(
+      throw new AiWorkerControlError(
         error instanceof Error ? error.message : `Failed to ${action} session`,
         statusCode,
         {
@@ -813,6 +905,7 @@ export const createOpenChamberSessionService = (dependencies) => {
 
   return {
     create,
+    archive,
     send: (sessionID, payload) => runExisting('send', sessionID, payload),
     fork: (sessionID, payload) => runExisting('fork', sessionID, payload),
   };
@@ -831,18 +924,27 @@ const sendServiceError = (res, error, fallback) => {
   });
 };
 
-export const registerOpenChamberSessionRoutes = (app, dependencies) => {
-  const service = dependencies.sessionService || createOpenChamberSessionService(dependencies);
+export const registerAiWorkerSessionRoutes = (app, dependencies) => {
+  const service = dependencies.sessionService || createAiWorkerSessionService(dependencies);
 
   app.post('/api/openchamber/sessions', express.json({ limit: '1mb' }), async (req, res) => {
     try {
       return res.json(await service.create(req.body && typeof req.body === 'object' ? req.body : {}));
     } catch (error) {
-      console.error('[OpenChamberSessions] failed to create session:', error);
+      console.error('[AiWorkerSessions] failed to create session:', error);
       return sendServiceError(res, error, 'Failed to create session');
     }
   });
 
+  app.post('/api/openchamber/sessions/archive', express.json({ limit: '1mb' }), async (req, res) => {
+    try {
+      return res.json(await service.archive(req.body && typeof req.body === 'object' ? req.body : {}));
+    } catch (error) {
+      console.error('[AiWorkerSessions] failed to archive sessions:', error);
+      return sendServiceError(res, error, 'Failed to archive sessions');
+    }
+  });
+
   app.post(
     '/api/openchamber/sessions/:sessionId/send',
     express.json({ limit: '1mb' }),
@@ -850,7 +952,7 @@ export const registerOpenChamberSessionRoutes = (app, dependencies) => {
       try {
         return res.json(await service.send(req.params.sessionId, req.body));
       } catch (error) {
-        console.error('[OpenChamberSessions] failed to send session:', error);
+        console.error('[AiWorkerSessions] failed to send session:', error);
         return sendServiceError(res, error, 'Failed to send session');
       }
     },
@@ -862,7 +964,7 @@ export const registerOpenChamberSessionRoutes = (app, dependencies) => {
       try {
         return res.json(await service.fork(req.params.sessionId, req.body));
       } catch (error) {
-        console.error('[OpenChamberSessions] failed to fork session:', error);
+        console.error('[AiWorkerSessions] failed to fork session:', error);
         return sendServiceError(res, error, 'Failed to fork session');
       }
     },