@aiworker/web 1.22.0 → 1.22.2

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);
   });

package/server/lib/changelog/update-notes.js

@@ -0,0 +1,82 @@
+// Release notes for the update dialog.
+//
+// The repo publishes `changelog/index.json` on `main`: one object per release,
+// newest first, with the app notes grouped as New / Improvements / Fixes /
+// Misc. This module fetches it and renders the releases between the installed
+// version (exclusive) and the offered one (inclusive) as the Markdown the
+// dialog already understands: a `## [x.y.z] - YYYY-MM-DD` header per release,
+// the release title in bold, the intro, then the groups.
+//
+// Any failure (network, 404, unexpected shape) yields null: the update is
+// still offered, only without notes.
+
+export const CHANGELOG_INDEX_URL = 'https://raw.githubusercontent.com/openchamber/openchamber/main/changelog/index.json';
+
+const GROUPS = [
+  ['new', 'New'],
+  ['improvements', 'Improvements'],
+  ['fixes', 'Fixes'],
+  ['misc', 'Misc'],
+];
+
+const VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
+const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+
+// The file crosses a network boundary with no schema library on this side, so
+// each field is coerced into its domain shape here; a release without a valid
+// version and date is dropped.
+const text = (value) => (value === null || value === undefined ? null : String(value).trim() || null);
+const bulletList = (value) => (Array.isArray(value) ? value.map((item) => String(item)) : []);
+
+const parseRelease = (entry) => {
+  if (entry === null || entry === undefined) return null;
+  const version = text(entry.version);
+  const date = text(entry.date);
+  if (!version || !VERSION_PATTERN.test(version) || !date || !DATE_PATTERN.test(date)) return null;
+  const app = entry.app ?? {};
+  return {
+    version,
+    date,
+    title: text(entry.title),
+    intro: text(entry.intro),
+    groups: GROUPS.map(([key, heading]) => ({ heading, bullets: bulletList(app[key]) })),
+  };
+};
+
+const renderRelease = (release) => {
+  const lines = [`## [${release.version}] - ${release.date}`, ''];
+  if (release.title) lines.push(`**${release.title}**`, '');
+  if (release.intro) lines.push(release.intro, '');
+  for (const { heading, bullets } of release.groups) {
+    if (bullets.length === 0) continue;
+    lines.push(`### ${heading}`, '', ...bullets.map((bullet) => `- ${bullet}`), '');
+  }
+  return lines.join('\n').trim();
+};
+
+/**
+ * Markdown for the releases in (fromVersion, toVersion], newest first, or
+ * null when the index holds none of them.
+ */
+export function renderUpdateNotes(index, fromVersion, toVersion, compareVersions) {
+  if (!Array.isArray(index)) return null;
+  const relevant = index
+    .map(parseRelease)
+    .filter((release) => release !== null)
+    .filter((release) => compareVersions(release.version, fromVersion) > 0 && compareVersions(release.version, toVersion) <= 0)
+    .sort((a, b) => compareVersions(b.version, a.version));
+  if (relevant.length === 0) return null;
+  return relevant.map(renderRelease).join('\n\n');
+}
+
+/** Fetch the index and render the notes for one update; null on any failure. */
+export async function fetchUpdateNotes(fromVersion, toVersion, compareVersions, options = {}) {
+  const fetchImpl = options.fetch ?? fetch;
+  try {
+    const response = await fetchImpl(CHANGELOG_INDEX_URL, { signal: AbortSignal.timeout(options.timeoutMs ?? 10_000) });
+    if (!response.ok) return null;
+    return renderUpdateNotes(await response.json(), fromVersion, toVersion, compareVersions);
+  } catch {
+    return null;
+  }
+}