@aiworker/web 1.22.0 → 1.23.0

package/server/lib/agent-memory/feature-flag.js

@@ -14,6 +14,6 @@
 const TRUTHY = new Set(['1', 'true', 'yes', 'on']);
 
 export const isAgentMemoryFeatureAvailable = () => {
-  const raw = process.env.OPENCHAMBER_MEMORY_ENABLE;
+  const raw = process.env.AIWORKER_MEMORY_ENABLE;
   return typeof raw === 'string' && TRUTHY.has(raw.trim().toLowerCase());
 };

package/server/lib/agent-memory/feature-flag.test.js

@@ -2,37 +2,37 @@ import { afterEach, describe, expect, test } from 'bun:test';
 
 import { isAgentMemoryFeatureAvailable } from './feature-flag.js';
 
-const original = process.env.OPENCHAMBER_MEMORY_ENABLE;
+const original = process.env.AIWORKER_MEMORY_ENABLE;
 
 afterEach(() => {
-  if (original === undefined) delete process.env.OPENCHAMBER_MEMORY_ENABLE;
-  else process.env.OPENCHAMBER_MEMORY_ENABLE = original;
+  if (original === undefined) delete process.env.AIWORKER_MEMORY_ENABLE;
+  else process.env.AIWORKER_MEMORY_ENABLE = original;
 });
 
 describe('the unreleased feature gate', () => {
   test('is closed when the variable is unset', () => {
-    delete process.env.OPENCHAMBER_MEMORY_ENABLE;
+    delete process.env.AIWORKER_MEMORY_ENABLE;
     expect(isAgentMemoryFeatureAvailable()).toBe(false);
   });
 
   test('opens for the usual truthy spellings', () => {
     for (const value of ['1', 'true', 'TRUE', 'yes', 'on', ' true ']) {
-      process.env.OPENCHAMBER_MEMORY_ENABLE = value;
+      process.env.AIWORKER_MEMORY_ENABLE = value;
       expect(isAgentMemoryFeatureAvailable()).toBe(true);
     }
   });
 
   test('stays closed for anything else, including "false"', () => {
     for (const value of ['', '0', 'false', 'no', 'off', 'maybe']) {
-      process.env.OPENCHAMBER_MEMORY_ENABLE = value;
+      process.env.AIWORKER_MEMORY_ENABLE = value;
       expect(isAgentMemoryFeatureAvailable()).toBe(false);
     }
   });
 
   test('is read per call, so a process started with it set is what decides', () => {
-    delete process.env.OPENCHAMBER_MEMORY_ENABLE;
+    delete process.env.AIWORKER_MEMORY_ENABLE;
     expect(isAgentMemoryFeatureAvailable()).toBe(false);
-    process.env.OPENCHAMBER_MEMORY_ENABLE = '1';
+    process.env.AIWORKER_MEMORY_ENABLE = '1';
     expect(isAgentMemoryFeatureAvailable()).toBe(true);
   });
 });

package/server/lib/agent-memory/routes.js

@@ -1,5 +1,5 @@
 /**
- * OpenChamber agent memory routes.
+ * AiWorker agent memory routes.
  *
  * The scope is a query parameter rather than part of the path, because global
  * and project memory are the same resource with two homes: one set of handlers
@@ -7,7 +7,7 @@
  * scope wrong must fail loudly, never silently write the user's global memory
  * from a project-scoped call.
  *
- * Memory is created by the agent through the `openchamber_memory` tool, so
+ * Memory is created by the agent through the `aiworker_memory` tool, so
  * there is no create route here; the panel reads, corrects, and deletes.
  *
  * The body parser is attached per route rather than globally: the generic

package/server/lib/agent-tool/runtime.js

@@ -1,24 +1,24 @@
-import { parse as parseJsonc } from 'jsonc-parser';
 import { pathToFileURL } from 'node:url';
+import { appendManagedPlugin } from '../opencode/managed-plugin-config.js';
 import {
-  OPENCHAMBER_AGENT_TOOL_ACTION_DEFINITIONS,
-  OPENCHAMBER_AGENT_TOOL_ACTIONS,
-  OPENCHAMBER_MEMORY_ACTION_DEFINITIONS,
-  OPENCHAMBER_MEMORY_ACTIONS,
+  AIWORKER_AGENT_TOOL_ACTION_DEFINITIONS,
+  AIWORKER_AGENT_TOOL_ACTIONS,
+  AIWORKER_MEMORY_ACTION_DEFINITIONS,
+  AIWORKER_MEMORY_ACTIONS,
   resolveAgentToolAction,
-  OPENCHAMBER_WEB_ACTION_DEFINITIONS,
-  OPENCHAMBER_WEB_ACTIONS,
+  AIWORKER_WEB_ACTION_DEFINITIONS,
+  AIWORKER_WEB_ACTIONS,
 } from '../openchamber-control/actions.js';
 
 const TOOL_SCHEMA_VERSION = 1;
 // Everything either managed tool may ask for; the agent allowlist stays
 // narrower than the full control surface.
-const ACTIONS = new Set([...OPENCHAMBER_AGENT_TOOL_ACTIONS, ...OPENCHAMBER_WEB_ACTIONS, ...OPENCHAMBER_MEMORY_ACTIONS]);
+const ACTIONS = new Set([...AIWORKER_AGENT_TOOL_ACTIONS, ...AIWORKER_WEB_ACTIONS, ...AIWORKER_MEMORY_ACTIONS]);
 const AGENT_TOOL_ACTION_TITLES = Object.fromEntries(
   [
-    ...OPENCHAMBER_AGENT_TOOL_ACTION_DEFINITIONS,
-    ...OPENCHAMBER_WEB_ACTION_DEFINITIONS,
-    ...OPENCHAMBER_MEMORY_ACTION_DEFINITIONS,
+    ...AIWORKER_AGENT_TOOL_ACTION_DEFINITIONS,
+    ...AIWORKER_WEB_ACTION_DEFINITIONS,
+    ...AIWORKER_MEMORY_ACTION_DEFINITIONS,
   ].map(({ action, title }) => [action, title]),
 );
 
@@ -108,9 +108,9 @@ const MEMORY_PARAMETER_PROPERTIES = {
   ...MEMORY_PARAMETER_OVERRIDES,
 };
 
-const CONTROL_TOOL_DESCRIPTION = "Control OpenChamber projects, sessions, and scheduled tasks on the user's behalf. Sessions and scheduled tasks you create are for the user to follow and interact with; never use this tool to delegate parts of your own current task. Use one action per call. Scope with projectId or directory; omit both to use the current session directory. Session dispatches return immediately by default and you receive no notification when a dispatched session finishes, so never promise to report back on it; the user follows it in OpenChamber; a dispatched session needs no follow-up from you. If the user later asks how it went, use session.messages (add wait to block until it is idle, lastAssistant for just the final answer) — session.send always sends a NEW prompt and never just waits. Set wait only when the user asks or the next step requires the completed result. Session and worktree deletion are unavailable.";
+const CONTROL_TOOL_DESCRIPTION = "Control AiWorker projects, sessions, and scheduled tasks on the user's behalf. Sessions and scheduled tasks you create are for the user to follow and interact with; never use this tool to delegate parts of your own current task. Use one action per call. Scope with projectId or directory; omit both to use the current session directory. Session dispatches return immediately by default and you receive no notification when a dispatched session finishes, so never promise to report back on it; the user follows it in AiWorker; a dispatched session needs no follow-up from you. If the user later asks how it went, use session.messages (add wait to block until it is idle, lastAssistant for just the final answer) — session.send always sends a NEW prompt and never just waits. Set wait only when the user asks or the next step requires the completed result. Session and worktree deletion are unavailable.";
 
-const WEB_TOOL_DESCRIPTION = "Look at and interact with a web page in OpenChamber's browser panel, so you can check your own work rather than describing what you expect. Use one action per call. Open a page, snapshot it to read its text and its interactive elements, then click, type or scroll using the selectors the snapshot returned; snapshots also report any errors the page logged. Pass a selector to browser.snapshot to read one part of a long page. browser.inspect returns computed styles when the question is how something renders. Set viewport to check a layout at mobile, tablet or desktop size. The page runs with the user's real logins, so treat what you see as their live session.";
+const WEB_TOOL_DESCRIPTION = "Look at and interact with a web page in AiWorker's browser panel, so you can check your own work rather than describing what you expect. Use one action per call. Open a page, snapshot it to read its text and its interactive elements, then click, type or scroll using the selectors the snapshot returned; snapshots also report any errors the page logged. Pass a selector to browser.snapshot to read one part of a long page. browser.inspect returns computed styles when the question is how something renders. Set viewport to check a layout at mobile, tablet or desktop size. The page runs with the user's real logins, so treat what you see as their live session.";
 
 const MEMORY_TOOL_DESCRIPTION = "Keep what you learn across sessions, so the user does not have to explain the same thing twice. Use one action per call. The session already lists the titles of what is stored. A title is an abbreviation, not the memory: read the entry with memory.read before acting on it, because titles leave out the conditions and exceptions that decide how the memory applies, and the ones that look self-explanatory hide them most often. Save something only when it will still be true in a later session — a stable preference, a project convention, a decision and its reason, or a hard-won pointer. Do not save one-off task state, anything you can read from the code, secrets or credentials, or anything the user asked you not to keep. Choose the scope deliberately: global is about the user and reaches every project, so put a project's conventions in project scope. What you save is shown to the user as unreviewed until they confirm it, so save plainly and say what you saved when it matters.";
 
@@ -147,7 +147,7 @@ const isLoopbackAddress = (value) => {
 const createToolEntry = ({ name, description, actions, definitions, parameters }) => String.raw`    ${name}: {
       description: ${JSON.stringify(description)},
       args: {
-        action: { type: "string", enum: ${JSON.stringify(actions)}, oneOf: ${JSON.stringify(definitions.map((entry) => ({ const: entry.action, description: entry.description })))}, description: "OpenChamber action to perform" },
+        action: { type: "string", enum: ${JSON.stringify(actions)}, oneOf: ${JSON.stringify(definitions.map((entry) => ({ const: entry.action, description: entry.description })))}, description: "AiWorker action to perform" },
         parameters: { type: "object", properties: ${JSON.stringify(parameters)}, additionalProperties: false, description: "Inputs for the action; use an empty object when none are needed" },
       },
       async execute(input, context) {
@@ -169,15 +169,15 @@ const createToolEntry = ({ name, description, actions, definitions, parameters }
             },
           },
         })
-        const endpoint = process.env.OPENCHAMBER_AGENT_TOOL_URL
-        const token = process.env.OPENCHAMBER_AGENT_TOOL_TOKEN
+        const endpoint = process.env.AIWORKER_AGENT_TOOL_URL
+        const token = process.env.AIWORKER_AGENT_TOOL_TOKEN
         const failure = (payload) => ({
           title,
           output: JSON.stringify(payload),
-          metadata: { openchamber: { schemaVersion: ${TOOL_SCHEMA_VERSION}, action: args.action, description: title, ok: false } },
+          metadata: { aiworker: { schemaVersion: ${TOOL_SCHEMA_VERSION}, action: args.action, description: title, ok: false } },
         })
         if (!endpoint || !token) {
-          return failure({ schemaVersion: ${TOOL_SCHEMA_VERSION}, ok: false, action: args.action, error: { message: "OpenChamber managed tool connection is unavailable" } })
+          return failure({ schemaVersion: ${TOOL_SCHEMA_VERSION}, ok: false, action: args.action, error: { message: "AiWorker managed tool connection is unavailable" } })
         }
 
         try {
@@ -205,8 +205,8 @@ const createToolEntry = ({ name, description, actions, definitions, parameters }
               },
             },
           })
-          if (valid) return { title, output, metadata: { openchamber: { schemaVersion: ${TOOL_SCHEMA_VERSION}, action: args.action, description: title, ok: result.ok === true } } }
-          return failure({ schemaVersion: ${TOOL_SCHEMA_VERSION}, ok: false, action: args.action, error: { message: "OpenChamber returned an invalid response", kind: "runtime", status: response.status } })
+          if (valid) return { title, output, metadata: { aiworker: { schemaVersion: ${TOOL_SCHEMA_VERSION}, action: args.action, description: title, ok: result.ok === true } } }
+          return failure({ schemaVersion: ${TOOL_SCHEMA_VERSION}, ok: false, action: args.action, error: { message: "AiWorker returned an invalid response", kind: "runtime", status: response.status } })
         } catch (error) {
           if (context.abort.aborted) throw error
           return failure({ schemaVersion: ${TOOL_SCHEMA_VERSION}, ok: false, action: args.action, error: { message: error instanceof Error ? error.message : String(error), kind: "runtime" } })
@@ -219,56 +219,39 @@ const createPluginSource = ({ includeControl, includeWeb, includeMemory }) => {
   const entries = [];
   if (includeControl) {
     entries.push(createToolEntry({
-      name: 'openchamber',
+      name: 'aiworker',
       description: CONTROL_TOOL_DESCRIPTION,
-      actions: OPENCHAMBER_AGENT_TOOL_ACTIONS,
-      definitions: OPENCHAMBER_AGENT_TOOL_ACTION_DEFINITIONS,
+      actions: AIWORKER_AGENT_TOOL_ACTIONS,
+      definitions: AIWORKER_AGENT_TOOL_ACTION_DEFINITIONS,
       parameters: CONTROL_PARAMETER_PROPERTIES,
     }));
   }
   if (includeWeb) {
     entries.push(createToolEntry({
-      name: 'openchamber_web',
+      name: 'aiworker_web',
       description: WEB_TOOL_DESCRIPTION,
-      actions: OPENCHAMBER_WEB_ACTIONS,
-      definitions: OPENCHAMBER_WEB_ACTION_DEFINITIONS,
+      actions: AIWORKER_WEB_ACTIONS,
+      definitions: AIWORKER_WEB_ACTION_DEFINITIONS,
       parameters: WEB_PARAMETER_PROPERTIES,
     }));
   }
   if (includeMemory) {
     entries.push(createToolEntry({
-      name: 'openchamber_memory',
+      name: 'aiworker_memory',
       description: MEMORY_TOOL_DESCRIPTION,
-      actions: OPENCHAMBER_MEMORY_ACTIONS,
-      definitions: OPENCHAMBER_MEMORY_ACTION_DEFINITIONS,
+      actions: AIWORKER_MEMORY_ACTIONS,
+      definitions: AIWORKER_MEMORY_ACTION_DEFINITIONS,
       parameters: MEMORY_PARAMETER_PROPERTIES,
     }));
   }
 
-  return `export const OpenChamberPlugin = async () => ({
+  return `export const AiWorkerPlugin = async () => ({
   tool: {
 ${entries.join('')}  },
 })
 `;
 };
 
-const mergePluginConfig = (rawConfig, pluginUrl) => {
-  const errors = [];
-  const parsed = asNonEmptyString(rawConfig) ? parseJsonc(rawConfig, errors, { allowTrailingComma: true }) : {};
-  if (errors.length > 0 || !parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-    throw new Error('OPENCODE_CONFIG_CONTENT must contain a valid JSON object before OpenChamber can inject its managed tool');
-  }
-  if (parsed.plugin !== undefined && !Array.isArray(parsed.plugin)) {
-    throw new Error('OPENCODE_CONFIG_CONTENT plugin must be an array before OpenChamber can inject its managed tool');
-  }
-  const configured = Array.isArray(parsed.plugin) ? parsed.plugin : [];
-  parsed.plugin = [
-    ...configured.filter((value) => value !== pluginUrl && (!Array.isArray(value) || value[0] !== pluginUrl)),
-    pluginUrl,
-  ];
-  return JSON.stringify(parsed);
-};
-
 export const createAgentToolRuntime = (dependencies) => {
   const {
     crypto,
@@ -286,19 +269,19 @@ export const createAgentToolRuntime = (dependencies) => {
   const prepareManagedOpenCodeEnv = async ({ includeControl = true, includeWeb = true, includeMemory = true } = {}) => {
     const port = getActivePort();
     if (!Number.isInteger(port) || port <= 0) {
-      throw new Error('OpenChamber listener port is unavailable for managed tool injection');
+      throw new Error('AiWorker listener port is unavailable for managed tool injection');
     }
     if (!includeControl && !includeWeb && !includeMemory) {
-      throw new Error('At least one OpenChamber managed tool must be enabled to inject the plugin');
+      throw new Error('At least one AiWorker managed tool must be enabled to inject the plugin');
     }
     await fsPromises.mkdir(pluginDirectory, { recursive: true });
     await fsPromises.writeFile(pluginPath, createPluginSource({ includeControl, includeWeb, includeMemory }), { mode: 0o600 });
     activeToken = crypto.randomBytes(32).toString('base64url');
     const pluginUrl = pathToFileURL(pluginPath).href;
     return {
-      OPENCODE_CONFIG_CONTENT: mergePluginConfig(env.OPENCODE_CONFIG_CONTENT, pluginUrl),
-      OPENCHAMBER_AGENT_TOOL_URL: `http://127.0.0.1:${port}/api/openchamber/agent-tool`,
-      OPENCHAMBER_AGENT_TOOL_TOKEN: activeToken,
+      OPENCODE_CONFIG_CONTENT: appendManagedPlugin(env.OPENCODE_CONFIG_CONTENT, pluginUrl, 'managed tool'),
+      AIWORKER_AGENT_TOOL_URL: `http://127.0.0.1:${port}/api/openchamber/agent-tool`,
+      AIWORKER_AGENT_TOOL_TOKEN: activeToken,
     };
   };
 
@@ -322,10 +305,10 @@ export const createAgentToolRuntime = (dependencies) => {
     }
     const action = resolution.action;
     if (!ACTIONS.has(action)) {
-      return createResult({ ok: false, action, error: { message: `Unsupported OpenChamber action: ${action}`, kind: 'usage' } });
+      return createResult({ ok: false, action, error: { message: `Unsupported AiWorker action: ${action}`, kind: 'usage' } });
     }
     if (typeof executeAction !== 'function') {
-      return createResult({ ok: false, action, error: { message: 'OpenChamber control service is unavailable', kind: 'runtime' } });
+      return createResult({ ok: false, action, error: { message: 'AiWorker control service is unavailable', kind: 'runtime' } });
     }
     try {
       const data = await executeAction(action, { ...payload.input, action }, payload.contextDirectory, options);

package/server/lib/agent-tool/runtime.test.js

@@ -8,7 +8,7 @@ import request from 'supertest';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
 import { createAgentToolRuntime } from './runtime.js';
-import { OPENCHAMBER_AGENT_TOOL_ACTION_DEFINITIONS, OPENCHAMBER_CONTROL_ACTION_DEFINITIONS } from '../openchamber-control/actions.js';
+import { AIWORKER_AGENT_TOOL_ACTION_DEFINITIONS, AIWORKER_CONTROL_ACTION_DEFINITIONS } from '../openchamber-control/actions.js';
 
 const temporaryDirectories = [];
 
@@ -36,7 +36,7 @@ const createRuntime = async (overrides = {}) => {
 
 describe('agent tool action allowlist', () => {
   it('defines a short title and agent description for every action', () => {
-    expect(OPENCHAMBER_CONTROL_ACTION_DEFINITIONS.every(({ action, title, description }) => action && title && description)).toBe(true);
+    expect(AIWORKER_CONTROL_ACTION_DEFINITIONS.every(({ action, title, description }) => action && title && description)).toBe(true);
   });
 
   it.each([
@@ -90,28 +90,28 @@ describe('managed agent tool runtime', () => {
       ['example-plugin', { flag: true }],
       expect.stringContaining('/agent-tool/openchamber-plugin.js'),
     ]);
-    expect(preparedEnv.OPENCHAMBER_AGENT_TOOL_URL).toBe('http://127.0.0.1:3901/api/openchamber/agent-tool');
-    expect(preparedEnv.OPENCHAMBER_AGENT_TOOL_TOKEN).toMatch(/^[A-Za-z0-9_-]+$/);
-    expect(source).toContain('openchamber: {');
-    for (const { action, description } of OPENCHAMBER_AGENT_TOOL_ACTION_DEFINITIONS) {
+    expect(preparedEnv.AIWORKER_AGENT_TOOL_URL).toBe('http://127.0.0.1:3901/api/openchamber/agent-tool');
+    expect(preparedEnv.AIWORKER_AGENT_TOOL_TOKEN).toMatch(/^[A-Za-z0-9_-]+$/);
+    expect(source).toContain('aiworker: {');
+    for (const { action, description } of AIWORKER_AGENT_TOOL_ACTION_DEFINITIONS) {
       expect(source).toContain(JSON.stringify({ const: action, description }));
     }
     expect(source).not.toContain('"schedule.status"');
     const pluginModule = await import(`${pathToFileURL(pluginPath).href}?schema=${Date.now()}`);
-    const hooks = await pluginModule.OpenChamberPlugin();
-    expect(hooks.tool.openchamber.description).toContain('Session dispatches return immediately by default');
-    expect(hooks.tool.openchamber.description).toContain('Set wait only when the user asks or the next step requires the completed result');
-    expect(hooks.tool.openchamber.args.action.oneOf).toContainEqual({
+    const hooks = await pluginModule.AiWorkerPlugin();
+    expect(hooks.tool.aiworker.description).toContain('Session dispatches return immediately by default');
+    expect(hooks.tool.aiworker.description).toContain('Set wait only when the user asks or the next step requires the completed result');
+    expect(hooks.tool.aiworker.args.action.oneOf).toContainEqual({
       const: 'session.messages',
       description: 'Read text-only messages and current sessionStatus for sessionId; directory and limit 10 are defaults',
     });
-    expect(hooks.tool.openchamber.args.parameters.properties.wait.description).toBe(
+    expect(hooks.tool.aiworker.args.parameters.properties.wait.description).toBe(
       'Wait for current session activity to become idle. Omit by default; use only when the user asks or the next step requires the completed result',
     );
-    expect(hooks.tool.openchamber.args.parameters.properties.sessionId).toEqual({ type: 'string' });
-    expect(source).not.toContain('title: "OpenChamber"');
+    expect(hooks.tool.aiworker.args.parameters.properties.sessionId).toEqual({ type: 'string' });
+    expect(source).not.toContain('title: "AiWorker"');
     expect(source).not.toContain('@opencode-ai/plugin');
-    expect(source).not.toContain(preparedEnv.OPENCHAMBER_AGENT_TOOL_TOKEN);
+    expect(source).not.toContain(preparedEnv.AIWORKER_AGENT_TOOL_TOKEN);
   });
 
   it('emits both tools, each carrying only its own actions and inputs', async () => {
@@ -119,18 +119,18 @@ describe('managed agent tool runtime', () => {
     await runtime.prepareManagedOpenCodeEnv();
     const pluginPath = path.join(dataDir, 'agent-tool', 'openchamber-plugin.js');
     const pluginModule = await import(`${pathToFileURL(pluginPath).href}?both=${Date.now()}`);
-    const { tool } = await pluginModule.OpenChamberPlugin();
+    const { tool } = await pluginModule.AiWorkerPlugin();
 
-    const controlActions = tool.openchamber.args.action.enum;
-    const webActions = tool.openchamber_web.args.action.enum;
+    const controlActions = tool.aiworker.args.action.enum;
+    const webActions = tool.aiworker_web.args.action.enum;
     expect(webActions).toContain('browser.open');
     expect(controlActions).not.toContain('browser.open');
     expect(webActions).not.toContain('session.create');
 
     // Turning one tool off has to remove its inputs too, not just its actions.
-    expect(Object.keys(tool.openchamber_web.args.parameters.properties)).toContain('url');
-    expect(Object.keys(tool.openchamber.args.parameters.properties)).not.toContain('url');
-    expect(Object.keys(tool.openchamber.args.parameters.properties)).toContain('sessionId');
+    expect(Object.keys(tool.aiworker_web.args.parameters.properties)).toContain('url');
+    expect(Object.keys(tool.aiworker.args.parameters.properties)).not.toContain('url');
+    expect(Object.keys(tool.aiworker.args.parameters.properties)).toContain('sessionId');
   });
 
   it('accepts inputs passed beside the action, not only inside parameters', async () => {
@@ -138,14 +138,14 @@ describe('managed agent tool runtime', () => {
     const prepared = await runtime.prepareManagedOpenCodeEnv();
     const pluginPath = path.join(dataDir, 'agent-tool', 'openchamber-plugin.js');
     const pluginModule = await import(`${pathToFileURL(pluginPath).href}?flat=${Date.now()}`);
-    const { tool } = await pluginModule.OpenChamberPlugin();
+    const { tool } = await pluginModule.AiWorkerPlugin();
 
     const sent = [];
     const originalFetch = globalThis.fetch;
-    const originalUrl = process.env.OPENCHAMBER_AGENT_TOOL_URL;
-    const originalToken = process.env.OPENCHAMBER_AGENT_TOOL_TOKEN;
-    process.env.OPENCHAMBER_AGENT_TOOL_URL = prepared.OPENCHAMBER_AGENT_TOOL_URL;
-    process.env.OPENCHAMBER_AGENT_TOOL_TOKEN = prepared.OPENCHAMBER_AGENT_TOOL_TOKEN;
+    const originalUrl = process.env.AIWORKER_AGENT_TOOL_URL;
+    const originalToken = process.env.AIWORKER_AGENT_TOOL_TOKEN;
+    process.env.AIWORKER_AGENT_TOOL_URL = prepared.AIWORKER_AGENT_TOOL_URL;
+    process.env.AIWORKER_AGENT_TOOL_TOKEN = prepared.AIWORKER_AGENT_TOOL_TOKEN;
     globalThis.fetch = async (_endpoint, init) => {
       sent.push(JSON.parse(init.body));
       return new Response(JSON.stringify({ schemaVersion: 1, ok: true, action: 'browser.open', data: {} }));
@@ -154,24 +154,24 @@ describe('managed agent tool runtime', () => {
 
     try {
       // The shape a model actually produced: url and viewport next to action.
-      await tool.openchamber_web.execute(
+      await tool.aiworker_web.execute(
         { action: 'browser.open', url: 'https://example.test', viewport: 'mobile' },
         context,
       );
       // The documented shape must keep working, and win when both are present.
-      await tool.openchamber_web.execute(
+      await tool.aiworker_web.execute(
         { action: 'browser.open', url: 'https://ignored.test', parameters: { url: 'https://example.test/nested' } },
         context,
       );
       // Both tools come from one template, so session control accepts it too.
-      await tool.openchamber.execute(
+      await tool.aiworker.execute(
         { action: 'session.messages', sessionId: 'ses_1', limit: 3 },
         context,
       );
     } finally {
       globalThis.fetch = originalFetch;
-      process.env.OPENCHAMBER_AGENT_TOOL_URL = originalUrl;
-      process.env.OPENCHAMBER_AGENT_TOOL_TOKEN = originalToken;
+      process.env.AIWORKER_AGENT_TOOL_URL = originalUrl;
+      process.env.AIWORKER_AGENT_TOOL_TOKEN = originalToken;
     }
 
     expect(sent[0].input).toEqual({ action: 'browser.open', url: 'https://example.test', viewport: 'mobile' });
@@ -184,9 +184,9 @@ describe('managed agent tool runtime', () => {
     await runtime.prepareManagedOpenCodeEnv({ includeControl: false, includeWeb: true, includeMemory: false });
     const pluginPath = path.join(dataDir, 'agent-tool', 'openchamber-plugin.js');
     const pluginModule = await import(`${pathToFileURL(pluginPath).href}?web=${Date.now()}`);
-    const { tool } = await pluginModule.OpenChamberPlugin();
+    const { tool } = await pluginModule.AiWorkerPlugin();
 
-    expect(Object.keys(tool)).toEqual(['openchamber_web']);
+    expect(Object.keys(tool)).toEqual(['aiworker_web']);
   });
 
   it('exposes memory as its own tool carrying only its own inputs', async () => {
@@ -194,14 +194,14 @@ describe('managed agent tool runtime', () => {
     await runtime.prepareManagedOpenCodeEnv({ includeControl: true, includeWeb: false, includeMemory: true });
     const pluginPath = path.join(dataDir, 'agent-tool', 'openchamber-plugin.js');
     const pluginModule = await import(`${pathToFileURL(pluginPath).href}?memory=${Date.now()}`);
-    const { tool } = await pluginModule.OpenChamberPlugin();
+    const { tool } = await pluginModule.AiWorkerPlugin();
 
-    expect(Object.keys(tool)).toEqual(['openchamber', 'openchamber_memory']);
-    expect(Object.keys(tool.openchamber_memory.args.parameters.properties).sort())
+    expect(Object.keys(tool)).toEqual(['aiworker', 'aiworker_memory']);
+    expect(Object.keys(tool.aiworker_memory.args.parameters.properties).sort())
       .toEqual(['body', 'memoryId', 'scope', 'title', 'type']);
     // Memory inputs must not leak into the control tool's schema, which the
     // model pays for on every unrelated call.
-    expect(Object.keys(tool.openchamber.args.parameters.properties)).not.toContain('memoryId');
+    expect(Object.keys(tool.aiworker.args.parameters.properties)).not.toContain('memoryId');
   });
 
   it('omits memory entirely when the user turns it off', async () => {
@@ -209,9 +209,9 @@ describe('managed agent tool runtime', () => {
     await runtime.prepareManagedOpenCodeEnv({ includeControl: true, includeWeb: false, includeMemory: false });
     const pluginPath = path.join(dataDir, 'agent-tool', 'openchamber-plugin.js');
     const pluginModule = await import(`${pathToFileURL(pluginPath).href}?nomemory=${Date.now()}`);
-    const { tool } = await pluginModule.OpenChamberPlugin();
+    const { tool } = await pluginModule.AiWorkerPlugin();
 
-    expect(Object.keys(tool)).toEqual(['openchamber']);
+    expect(Object.keys(tool)).toEqual(['aiworker']);
   });
 
   it('injects the plugin when memory is the only tool left on', async () => {
@@ -219,9 +219,9 @@ describe('managed agent tool runtime', () => {
     await runtime.prepareManagedOpenCodeEnv({ includeControl: false, includeWeb: false, includeMemory: true });
     const pluginPath = path.join(dataDir, 'agent-tool', 'openchamber-plugin.js');
     const pluginModule = await import(`${pathToFileURL(pluginPath).href}?onlymemory=${Date.now()}`);
-    const { tool } = await pluginModule.OpenChamberPlugin();
+    const { tool } = await pluginModule.AiWorkerPlugin();
 
-    expect(Object.keys(tool)).toEqual(['openchamber_memory']);
+    expect(Object.keys(tool)).toEqual(['aiworker_memory']);
   });
 
   it('refuses to inject a plugin with no tools in it', async () => {
@@ -236,7 +236,7 @@ describe('managed agent tool runtime', () => {
   });
 
   it('accepts the bare action a tool name already qualifies', async () => {
-    // Observed: the model called `read` on openchamber_memory, having taken the
+    // Observed: the model called `read` on aiworker_memory, having taken the
     // tool's own name for the namespace.
     const executeAction = vi.fn(async () => ({ memory: {} }));
     const { runtime } = await createRuntime({ executeAction });
@@ -244,7 +244,7 @@ describe('managed agent tool runtime', () => {
     const result = await runtime.execute({
       input: { action: 'read', title: 'Uses bun' },
       contextDirectory: '/work/project',
-      tool: 'openchamber_memory',
+      tool: 'aiworker_memory',
     });
 
     expect(result.ok).toBe(true);
@@ -262,7 +262,7 @@ describe('managed agent tool runtime', () => {
 
     const result = await runtime.execute({
       input: { action: 'get' },
-      tool: 'openchamber_memory',
+      tool: 'aiworker_memory',
     });
 
     expect(result.ok).toBe(false);
@@ -276,7 +276,7 @@ describe('managed agent tool runtime', () => {
 
     const result = await runtime.execute({
       input: { action: 'open', url: 'https://example.test' },
-      tool: 'openchamber_memory',
+      tool: 'aiworker_memory',
     });
 
     expect(result.ok).toBe(false);
@@ -318,7 +318,7 @@ describe('managed agent tool runtime', () => {
   it('forwards cancellation to the shared control service', async () => {
     const executeAction = vi.fn(async (_action, _input, _directory, options) => {
       await new Promise((resolve, reject) => {
-        options.signal.addEventListener('abort', () => reject(Object.assign(new Error('OpenChamber action was cancelled'), { statusCode: 499 })), { once: true });
+        options.signal.addEventListener('abort', () => reject(Object.assign(new Error('AiWorker action was cancelled'), { statusCode: 499 })), { once: true });
       });
     });
     const { runtime } = await createRuntime({ executeAction });
@@ -330,7 +330,7 @@ describe('managed agent tool runtime', () => {
     await expect(pending).resolves.toEqual(expect.objectContaining({
       ok: false,
       action: 'projects.list',
-      error: { message: 'OpenChamber action was cancelled', kind: 'runtime' },
+      error: { message: 'AiWorker action was cancelled', kind: 'runtime' },
     }));
     expect(executeAction).toHaveBeenCalledWith('projects.list', { action: 'projects.list' }, undefined, { signal: controller.signal });
   });
@@ -348,7 +348,7 @@ describe('managed agent tool runtime', () => {
 
     const response = await request(app)
       .post('/api/openchamber/agent-tool')
-      .set('authorization', `Bearer ${env.OPENCHAMBER_AGENT_TOOL_TOKEN}`)
+      .set('authorization', `Bearer ${env.AIWORKER_AGENT_TOOL_TOKEN}`)
       .send({ input: { action: 'projects.list' } })
       .expect(200);
     expect(response.body).toEqual(expect.objectContaining({ ok: true, action: 'projects.list' }));
@@ -364,18 +364,18 @@ describe('managed agent tool runtime', () => {
     });
     activePort = server.address().port;
 
-    const previousUrl = process.env.OPENCHAMBER_AGENT_TOOL_URL;
-    const previousToken = process.env.OPENCHAMBER_AGENT_TOOL_TOKEN;
+    const previousUrl = process.env.AIWORKER_AGENT_TOOL_URL;
+    const previousToken = process.env.AIWORKER_AGENT_TOOL_TOKEN;
     try {
       const env = await runtime.prepareManagedOpenCodeEnv();
-      process.env.OPENCHAMBER_AGENT_TOOL_URL = env.OPENCHAMBER_AGENT_TOOL_URL;
-      process.env.OPENCHAMBER_AGENT_TOOL_TOKEN = env.OPENCHAMBER_AGENT_TOOL_TOKEN;
+      process.env.AIWORKER_AGENT_TOOL_URL = env.AIWORKER_AGENT_TOOL_URL;
+      process.env.AIWORKER_AGENT_TOOL_TOKEN = env.AIWORKER_AGENT_TOOL_TOKEN;
       const pluginPath = path.join(dataDir, 'agent-tool', 'openchamber-plugin.js');
       const pluginModule = await import(`${pathToFileURL(pluginPath).href}?test=${Date.now()}`);
-      const hooks = await pluginModule.OpenChamberPlugin();
+      const hooks = await pluginModule.AiWorkerPlugin();
       const metadata = vi.fn();
 
-      const result = await hooks.tool.openchamber.execute(
+      const result = await hooks.tool.aiworker.execute(
         { action: 'projects.list', parameters: {} },
         { directory: '/work/project', abort: new AbortController().signal, metadata },
       );
@@ -387,18 +387,18 @@ describe('managed agent tool runtime', () => {
         data: { projects: [] },
       });
       expect(result.title).toBe('List configured projects');
-      expect(result.metadata.openchamber.description).toBe('List configured projects');
+      expect(result.metadata.aiworker.description).toBe('List configured projects');
       expect(metadata).toHaveBeenCalledWith(expect.objectContaining({
         title: 'List configured projects',
         metadata: expect.objectContaining({
-          openchamber: expect.objectContaining({ description: 'List configured projects' }),
+          aiworker: expect.objectContaining({ description: 'List configured projects' }),
         }),
       }));
     } finally {
-      if (previousUrl === undefined) delete process.env.OPENCHAMBER_AGENT_TOOL_URL;
-      else process.env.OPENCHAMBER_AGENT_TOOL_URL = previousUrl;
-      if (previousToken === undefined) delete process.env.OPENCHAMBER_AGENT_TOOL_TOKEN;
-      else process.env.OPENCHAMBER_AGENT_TOOL_TOKEN = previousToken;
+      if (previousUrl === undefined) delete process.env.AIWORKER_AGENT_TOOL_URL;
+      else process.env.AIWORKER_AGENT_TOOL_URL = previousUrl;
+      if (previousToken === undefined) delete process.env.AIWORKER_AGENT_TOOL_TOKEN;
+      else process.env.AIWORKER_AGENT_TOOL_TOKEN = previousToken;
       await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
     }
   });

package/server/lib/browser-control/broker.js

@@ -2,7 +2,7 @@
  * Request/response broker between the agent tool and the in-app browser.
  *
  * The browser lives in the renderer, not the server, so the server cannot act
- * on a page directly. It publishes a request over the existing OpenChamber
+ * on a page directly. It publishes a request over the existing AiWorker
  * event stream and waits for the client that owns the browser view to post the
  * result back.
  *
@@ -73,8 +73,8 @@ export const createBrowserControlBroker = ({
         // environment can do, and leave deciding whether it matters to the
         // caller rather than handing it an instruction it cannot carry out.
         return Promise.reject(new BrowserControlError(
-          'No OpenChamber client connected here can control a page. Reading and '
-          + 'interacting with a page works when OpenChamber runs as its desktop '
+          'No AiWorker client connected here can control a page. Reading and '
+          + 'interacting with a page works when AiWorker runs as its desktop '
           + 'application; a web browser tab can display a page but cannot be '
           + 'driven. Nothing was changed. Mention this to the user only if it '
           + 'affects what they asked for.',

package/server/lib/browser-control/broker.test.js

@@ -102,7 +102,7 @@ describe('browser control broker', () => {
   test('fails everything in flight when the owning client disconnects', async () => {
     const { broker } = createBroker();
     const inflight = broker.request('browser.snapshot', {});
-    broker.rejectAll('The OpenChamber client disconnected');
+    broker.rejectAll('The AiWorker client disconnected');
     await expect(inflight).rejects.toThrow('disconnected');
     expect(broker.pendingCount).toBe(0);
   });