@openchambery/web 2.0.0-beta.1 → 2.0.0-beta.11

package/server/lib/permission-auto-accept/DOCUMENTATION.md

@@ -8,13 +8,13 @@ This module owns the authoritative permission auto-accept policy for web, deskto
 
 `permissionAutoAccept.sessions` contains explicit per-session boolean policies.
 
-Policy inheritance uses the nearest explicit session value. A child `false` therefore overrides a parent `true`; descendants without an explicit value inherit from their nearest configured ancestor.
+Policy inheritance uses the nearest explicit session value. A child `false` therefore overrides a parent `true`. Sessions with no explicit value, including a missing ancestor lookup, default to allow. A failed settings load still fails closed and does not approve.
 
 ## Runtime
 
-`createPermissionAutoAcceptRuntime` loads and serializes policy writes, subscribes to the global OpenCode event hub, caches session lineage, retries transient replies, and reconciles pending permissions after startup, reconnect, and policy enablement. Enabling Auto-Accept for a session immediately accepts matching pending requests and keeps handling future requests without requiring a connected UI.
+`createPermissionAutoAcceptRuntime` loads and serializes policy writes, subscribes to the global OpenCode event hub, caches session lineage, retries transient replies, and reconciles pending permissions after startup, reconnect, and policy enablement. Pending requests are listed at `GET /permission/request` and approved with `POST /session/:sessionID/permission/:requestID/reply` body `{ decision: "always" }`. OpenCode 2.0.12 rejects the legacy `{ reply }` body and the unscoped `/permission/:id/reply` path.
 
-Unknown lineage and failed policy loads fail closed. A failed pending-permission fetch is distinct from an empty successful response and never clears policy state.
+A failed settings load fails closed and does not approve. A failed pending-permission fetch is distinct from an empty successful response and never clears policy state.
 
 ## Routes
 
@@ -27,9 +27,9 @@ These are normal authenticated OpenChamber runtime routes. They must not be adde
 
 `packages/ui/src/stores/permissionStore.ts` is a projection of server policy and does not persist an independent policy. The server is the sole responder and the UI renders pending requests until the authoritative `permission.replied` event arrives.
 
-`ChatInput` derives control visibility from the persisted, directory-scoped `useConfigStore` agent snapshot. A selected agent with a final global `allow` or `deny` rule has no remaining prompt path and hides the control. Unknown snapshots, missing selected agents, and rules that can ask keep the control visible. This path issues no additional request.
+`ChatInput` derives control visibility from the persisted, directory-scoped `useConfigStore` agent snapshot via `shouldShowPermissionAutoAcceptControl`. It reads the V2 wire `permissions` field when present (OpenCode `AgentInfo.permissions`), otherwise the legacy singular `permission` document. Rule normalization reuses `toPermissionRuleset` so both V2 `{ action, resource, effect }` and V1 `{ permission, pattern, action }` / tool-map shapes are recognized. A selected agent with a final global `allow` or `deny` rule has no remaining prompt path and hides the control. Unknown snapshots, missing selected agents, unparseable rules, and rules that can still ask keep the control visible. This path issues no additional request and does not change server auto-accept policy.
 
-VS Code retains its foreground-only implementation because it does not run the web server runtime.
+VS Code retains its foreground-only implementation because it does not run the web server runtime (`isVSCodeRuntime()` always shows the control).
 
 ## Tests
 

package/server/lib/permission-auto-accept/runtime.js

@@ -123,6 +123,7 @@ export function createPermissionAutoAcceptRuntime({
 
   const isSessionAutoAccepting = async (sessionId, directory) => {
     await load();
+    if (!sessionId) return false;
     const seen = new Set();
     let current = sessionId;
     let currentDirectory = directory;
@@ -133,22 +134,23 @@ export function createPermissionAutoAcceptRuntime({
       try {
         info = await getSession(current, currentDirectory);
       } catch {
-        return false;
+        // Lineage lookup failed. No explicit deny was found, so keep the default allow.
+        return true;
       }
       current = info?.parentID ?? null;
       currentDirectory = info?.directory ?? currentDirectory;
     }
-    return false;
+    return true;
   };
 
   const replyOnce = async (permission, directory) => {
     if (!permission?.id || !permission?.sessionID) return false;
     await load();
     if (!(await isSessionAutoAccepting(permission.sessionID, directory))) return false;
-    await request(`/permission/${encodeURIComponent(permission.id)}/reply`, {
+    await request(`/session/${encodeURIComponent(permission.sessionID)}/permission/${encodeURIComponent(permission.id)}/reply`, {
       directory,
       method: 'POST',
-      body: { reply: 'once' },
+      body: { decision: 'always' },
     });
     return true;
   };
@@ -187,7 +189,7 @@ export function createPermissionAutoAcceptRuntime({
       for (const directory of scopes) {
         let payload;
         try {
-          payload = await request('/permission', { directory });
+          payload = await request('/permission/request', { directory });
         } catch {
           continue;
         }
@@ -209,12 +211,17 @@ export function createPermissionAutoAcceptRuntime({
     const raw = event?.payload;
     const payload = raw?.payload && typeof raw.payload === 'object' ? raw.payload : raw;
     const directory = typeof event?.directory === 'string' && event.directory !== 'global' ? event.directory : undefined;
+    const body = payload?.properties && typeof payload.properties === 'object'
+      ? payload.properties
+      : payload?.data && typeof payload.data === 'object'
+        ? payload.data
+        : payload;
     if (payload?.type === 'session.created' || payload?.type === 'session.updated') {
-      rememberSession(payload.properties?.info, directory);
+      rememberSession(body?.info ?? payload.properties?.info, directory);
       return;
     }
     if (payload?.type === 'permission.asked') {
-      void processPermission(payload.properties, directory);
+      void processPermission(body, directory);
     }
   };
 

package/server/lib/permission-auto-accept/runtime.test.js

@@ -31,6 +31,18 @@ const flush = async () => {
 };
 
 describe('permission auto-accept runtime', () => {
+  it('approves a session with no explicit policy', async () => {
+    const fetchImpl = vi.fn(async (url, init = {}) => {
+      const path = new URL(url).pathname;
+      if (path === '/session/root') return Response.json({ id: 'root' });
+      if (init.method === 'POST') return Response.json({});
+      return new Response('', { status: 404 });
+    });
+    const { runtime } = createRuntime({ fetchImpl });
+    await expect(runtime.processPermission({ id: 'perm', sessionID: 'root' }, '/project')).resolves.toBe(true);
+    expect(fetchImpl.mock.calls.some(([url, init]) => new URL(url).pathname === '/session/root/permission/perm/reply' && JSON.parse(init.body).decision === 'always')).toBe(true);
+  });
+
   it('persists explicit session policies across runtime restarts', async () => {
     const first = createRuntime();
     await first.runtime.setSessionPolicy('root', true);
@@ -55,7 +67,7 @@ describe('permission auto-accept runtime', () => {
   it('fetches missing subagent lineage before replying', async () => {
     const fetchImpl = vi.fn(async (url, init = {}) => {
       const path = new URL(url).pathname;
-      if (path === '/permission') return new Response('[]');
+      if (path === '/permission/request') return new Response('[]');
       if (path === '/session/child') return Response.json({ id: 'child', parentID: 'root', directory: '/project' });
       if (init.method === 'POST') return Response.json({});
       return new Response('', { status: 404 });
@@ -65,15 +77,15 @@ describe('permission auto-accept runtime', () => {
       fetchImpl,
     });
     await expect(runtime.processPermission({ id: 'perm', sessionID: 'child' }, '/project')).resolves.toBe(true);
-    expect(fetchImpl.mock.calls.some(([url, init]) => new URL(url).pathname === '/permission/perm/reply' && init.method === 'POST')).toBe(true);
+    expect(fetchImpl.mock.calls.some(([url, init]) => new URL(url).pathname === '/session/child/permission/perm/reply' && init.method === 'POST' && JSON.parse(init.body).decision === 'always')).toBe(true);
   });
 
   it('retries a transient reply failure and deduplicates concurrent events', async () => {
     let replyAttempts = 0;
     const fetchImpl = vi.fn(async (url, init = {}) => {
       const path = new URL(url).pathname;
-      if (path === '/permission') return new Response('[]');
-      if (path === '/permission/perm/reply' && init.method === 'POST') {
+      if (path === '/permission/request') return new Response('[]');
+      if (path === '/session/root/permission/perm/reply' && init.method === 'POST') {
         replyAttempts += 1;
         return replyAttempts === 1 ? new Response('', { status: 503 }) : Response.json({});
       }
@@ -94,8 +106,8 @@ describe('permission auto-accept runtime', () => {
   it('reconciles pending permissions after reconnect', async () => {
     const fetchImpl = vi.fn(async (url, init = {}) => {
       const path = new URL(url).pathname;
-      if (path === '/permission') return Response.json([{ id: 'pending', sessionID: 'root' }]);
-      if (path === '/permission/pending/reply' && init.method === 'POST') return Response.json({});
+      if (path === '/permission/request') return Response.json([{ id: 'pending', sessionID: 'root' }]);
+      if (path === '/session/root/permission/pending/reply' && init.method === 'POST') return Response.json({});
       return Response.json({ id: 'root' });
     });
     const { connect } = createRuntime({
@@ -104,14 +116,14 @@ describe('permission auto-accept runtime', () => {
     });
     connect();
     await flush();
-    expect(fetchImpl.mock.calls.some(([url]) => new URL(url).pathname === '/permission/pending/reply')).toBe(true);
+    expect(fetchImpl.mock.calls.some(([url]) => new URL(url).pathname === '/session/root/permission/pending/reply')).toBe(true);
   });
 
   it('accepts existing pending permissions when a session policy is enabled', async () => {
     const fetchImpl = vi.fn(async (url, init = {}) => {
       const parsed = new URL(url);
       const path = parsed.pathname;
-      if (path === '/permission') {
+      if (path === '/permission/request') {
         return parsed.searchParams.get('directory') === '/project'
           ? Response.json([
             { id: 'root-pending', sessionID: 'root' },
@@ -119,19 +131,22 @@ describe('permission auto-accept runtime', () => {
           ])
           : Response.json([]);
       }
-      if (path === '/permission/root-pending/reply' && init.method === 'POST') return Response.json({});
+      if (init.method === 'POST' && path.endsWith('/reply')) return Response.json({});
       if (path === '/session/other') return Response.json({ id: 'other' });
       return new Response('', { status: 404 });
     });
-    const { runtime } = createRuntime({ fetchImpl });
+    const { runtime } = createRuntime({
+      stored: { permissionAutoAccept: { sessions: { other: false } } },
+      fetchImpl,
+    });
 
     await runtime.setSessionPolicy('root', true, '/project');
 
     const replyPaths = fetchImpl.mock.calls
       .filter(([, init]) => init?.method === 'POST')
       .map(([url]) => new URL(url).pathname);
-    expect(replyPaths).toEqual(['/permission/root-pending/reply']);
+    expect(replyPaths).toEqual(['/session/root/permission/root-pending/reply']);
     expect(fetchImpl.mock.calls.some(([url]) => new URL(url).searchParams.get('directory') === '/project')).toBe(true);
-    expect(await runtime.load()).toEqual({ sessions: { root: true } });
+    expect(await runtime.load()).toEqual({ sessions: { other: false, root: true } });
   });
 });

package/server/lib/relay/reasoning-projection.e2e.test.ts

@@ -147,7 +147,11 @@ const startFakeOpenCode = async (): Promise<{
     next();
   });
 
-  app.get('/global/event', (req, res) => {
+  // Production proxy forwards official v2 paths with `/api` restored
+  // (`toUpstreamOpenCodeApiPath`). Host mounts both `/api/global/event` and
+  // `/api/event`; fake upstream must match those upstream targets — not the
+  // pre-v2 bare `/global/event` or `/event`.
+  const writeSseFixture = (res: express.Response) => {
     res.writeHead(200, {
       'content-type': 'text/event-stream; charset=utf-8',
       'cache-control': 'no-cache',
@@ -243,9 +247,16 @@ const startFakeOpenCode = async (): Promise<{
     );
 
     res.end();
+  };
+
+  app.get('/api/global/event', (_req, res) => {
+    writeSseFixture(res);
+  });
+  app.get('/api/event', (_req, res) => {
+    writeSseFixture(res);
   });
 
-  app.get('/session/:sessionID/message', (req, res) => {
+  app.get('/api/session/:sessionID/message', (_req, res) => {
     res.json([
       {
         info: {
@@ -513,11 +524,15 @@ describe('relay reasoning projection e2e (Host filter over private relay)', () =
       for (const url of upstream.observation.urls) {
         expect(url).not.toContain('includeReasoning');
       }
-      // Sanity: upstream still saw the event + message routes.
-      expect(upstream.observation.urls.some((u) => u.includes('/global/event'))).toBe(true);
-      expect(upstream.observation.urls.some((u) => u.includes('/session/ses_1/message'))).toBe(
-        true,
-      );
+      // Sanity: upstream still saw official v2 event + message routes.
+      expect(
+        upstream.observation.urls.some(
+          (u) => u.includes('/api/global/event') || u.includes('/api/event'),
+        ),
+      ).toBe(true);
+      expect(
+        upstream.observation.urls.some((u) => u.includes('/api/session/ses_1/message')),
+      ).toBe(true);
 
       // Unauthenticated tunnel request still hits real auth gate (not open).
       const denied = await client.fetch('/api/global/event?includeReasoning=false', {

package/server/lib/scheduled-tasks/DOCUMENTATION.md

@@ -69,6 +69,14 @@ Server-owned scheduled task runtime and routes for OpenChamber-only automation.
   - `runNow(projectId, taskId)`
   - `observeSessionEvent(event)`
 
+Isolation dependencies (required for sidebar hide):
+
+- `persistSessionMetadata(sessionID, patch)` — Host store write. Missing
+  persist refuses the run **before** `session.create`. Persist failure after
+  create fails the run before prompt.
+- `onSystemSessionPersisted({ sessionID, directory, metadata })` — drop the
+  session from the sidebar index immediately after Host commit.
+
 Dependencies include optional `runHistoryStore` with:
 
 - `startRun(record)`

package/server/lib/scheduled-tasks/runtime.js

@@ -8,6 +8,7 @@ import {
   isSessionGoalSupported,
   sessionGoalUnavailableMessage,
 } from '../session-goal/capability.js';
+import { buildScheduledTaskMetadata } from '../session-metadata/system-session.js';
 import { SCHEDULED_SLOT_CLAIMED_CODE } from './run-history-store.js';
 
 const DEFAULT_GLOBAL_CONCURRENCY = 4;
@@ -481,12 +482,26 @@ const snapshotSessionOutcome = async ({
 
 const parseSessionEventPhase = (event) => {
   const payload = event?.payload?.payload ?? event?.payload;
-  const properties = payload?.properties;
+  // Accept bridge `{ properties }` and native v2 `{ data }` envelopes.
+  const properties = (payload?.properties && typeof payload.properties === 'object')
+    ? payload.properties
+    : ((payload?.data && typeof payload.data === 'object') ? payload.data : null);
   const sessionID = typeof properties?.sessionID === 'string' ? properties.sessionID : '';
   if (!sessionID) {
     return { phase: '', sessionID: '' };
   }
-  if (payload?.type === 'session.idle') {
+  // Ticket 07: shutdown interrupt is not an idle terminal — keep run open.
+  if (payload?.type === 'session.execution.interrupted' && properties?.reason === 'shutdown') {
+    return { phase: 'busy', sessionID };
+  }
+  if (payload?.type === 'session.idle' || payload?.type === 'session.execution.succeeded') {
+    return { phase: 'idle', sessionID };
+  }
+  if (payload?.type === 'session.execution.failed') {
+    return { phase: 'error', sessionID };
+  }
+  if (payload?.type === 'session.execution.interrupted') {
+    // user / superseded / inactivity — claim released; treat as idle for settlement.
     return { phase: 'idle', sessionID };
   }
   if (payload?.type === 'session.status') {
@@ -518,6 +533,14 @@ export const createScheduledTasksRuntime = (deps) => {
     maxRunDurationMs = DEFAULT_MAX_RUN_MS,
     /** Host store write: (sessionId, directory, goal) => Promise */
     persistSessionGoal = null,
+    /** Host store write: (sessionId, patch) => Promise — required for sidebar isolation */
+    persistSessionMetadata = null,
+    /**
+     * After Host isolation metadata is committed. Used to drop the session
+     * from the sidebar index immediately (do not wait for the next list sync).
+     * @type {null | ((event: { sessionID: string, directory?: string, metadata: object }) => void)}
+     */
+    onSystemSessionPersisted = null,
     /** Host store read: (sessionId) => Promise<metadata|null> */
     readSessionMetadata = null,
     /**
@@ -801,9 +824,10 @@ export const createScheduledTasksRuntime = (deps) => {
       + '\n</system-reminder>';
   };
 
-  const buildSessionCreateInput = (task, projectPath, title) => ({
+  const buildSessionCreateInput = (task, projectPath, title, metadata) => ({
     title,
     location: { directory: projectPath },
+    metadata,
     ...(task.execution.agent ? { agent: task.execution.agent } : {}),
     model: {
       id: task.execution.modelID,
@@ -812,6 +836,18 @@ export const createScheduledTasksRuntime = (deps) => {
     },
   });
 
+  const persistScheduledTaskIsolation = async (sessionID, directory, metadata) => {
+    if (typeof persistSessionMetadata !== 'function') {
+      throw new Error('scheduled-task session metadata persist is not configured');
+    }
+    await persistSessionMetadata(sessionID, metadata);
+    try {
+      onSystemSessionPersisted?.({ sessionID, directory, metadata });
+    } catch {
+      // Index/live hide is compensatory; Host persist is the authority.
+    }
+  };
+
   const buildPromptText = (task, projectPath) => {
     const promptText = expandSnippets(task.execution.prompt, projectPath);
     if (!task.execution.goalEnabled) {
@@ -915,6 +951,7 @@ export const createScheduledTasksRuntime = (deps) => {
       note: '',
       statusReason: '',
       lastAccountedMessageID: '',
+      executionGeneration: 0,
       createdAt: now,
       updatedAt: now,
     };
@@ -1107,6 +1144,10 @@ export const createScheduledTasksRuntime = (deps) => {
       }
     }
 
+    if (typeof persistSessionMetadata !== 'function') {
+      throw new Error('scheduled-task session metadata persist is not configured');
+    }
+
     if (typeof waitForOpenCodeReady === 'function') {
       await waitForOpenCodeReady(10_000, 250);
       signal?.throwIfAborted?.();
@@ -1141,14 +1182,21 @@ export const createScheduledTasksRuntime = (deps) => {
     };
 
     try {
+      const isolationMetadata = buildScheduledTaskMetadata({
+        projectID,
+        taskID: task.id,
+        runID,
+        name: task.name,
+      });
       const session = await client.session.create(
-        buildSessionCreateInput(task, projectPath, title),
+        buildSessionCreateInput(task, projectPath, title, isolationMetadata),
         requestOptions,
       );
       sessionID = session?.id;
       if (!sessionID) {
         throw new Error('failed to create session');
       }
+      await persistScheduledTaskIsolation(sessionID, projectPath, isolationMetadata);
 
       if (signal) {
         if (signal.aborted) {

package/server/lib/scheduled-tasks/runtime.test.js

@@ -45,6 +45,7 @@ const createRuntime = (updateScheduledTaskState, overrides = {}) => createSchedu
   waitForOpenCodeReady: vi.fn(async () => {
     throw new Error('OpenCode unavailable');
   }),
+  persistSessionMetadata: vi.fn(async () => ({})),
   logger: { info: vi.fn(), warn: vi.fn() },
   ...overrides,
 });
@@ -443,12 +444,16 @@ describe('scheduled-tasks run history and session lifecycle', () => {
   it('creates session with Scheduled title and location, attaches history, then prompts via session.prompt', async () => {
     const history = createHistoryStore();
     const client = createSuccessfulClient();
+    const persistSessionMetadata = vi.fn(async () => ({}));
+    const onSystemSessionPersisted = vi.fn();
 
     const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
       task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
     }));
     const runtime = createRuntime(updateScheduledTaskState, {
       runHistoryStore: history,
+      persistSessionMetadata,
+      onSystemSessionPersisted,
       waitForOpenCodeReady: vi.fn(async () => {}),
     });
     await runtime.syncProject('project-1');
@@ -474,9 +479,37 @@ describe('scheduled-tasks run history and session lifecycle', () => {
       location: { directory: '/tmp/project-1' },
       title: expect.stringMatching(/^\[Scheduled\] Task /),
       model: { id: 'gpt-4.1', providerID: 'openai' },
+      metadata: {
+        openchamber: {
+          scheduledTask: expect.objectContaining({
+            projectID: 'project-1',
+            taskID: 'task-1',
+            runID: started.id,
+            name: 'Task',
+          }),
+        },
+      },
     }), expect.objectContaining({ signal: expect.any(AbortSignal) }));
-    expect(client.create.mock.calls[0][0].metadata).toBeUndefined();
     expect(client.create.mock.calls[0][0].directory).toBeUndefined();
+    expect(persistSessionMetadata).toHaveBeenCalledWith('ses_1', {
+      openchamber: {
+        scheduledTask: expect.objectContaining({
+          projectID: 'project-1',
+          taskID: 'task-1',
+          runID: started.id,
+          name: 'Task',
+        }),
+      },
+    });
+    expect(onSystemSessionPersisted).toHaveBeenCalledWith({
+      sessionID: 'ses_1',
+      directory: '/tmp/project-1',
+      metadata: expect.objectContaining({
+        openchamber: expect.objectContaining({
+          scheduledTask: expect.objectContaining({ taskID: 'task-1' }),
+        }),
+      }),
+    });
     expect(history.attachSession).toHaveBeenCalledWith(started.id, 'ses_1');
     expect(client.prompt).toHaveBeenCalledWith({
       sessionID: 'ses_1',
@@ -492,6 +525,48 @@ describe('scheduled-tasks run history and session lifecycle', () => {
     expect(client.active.mock.invocationCallOrder[0]).toBeGreaterThan(client.prompt.mock.invocationCallOrder[0]);
   });
 
+  it('refuses before session create when Host metadata persist is not configured', async () => {
+    const history = createHistoryStore();
+    const client = createSuccessfulClient();
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState, {
+      runHistoryStore: history,
+      persistSessionMetadata: null,
+      waitForOpenCodeReady: vi.fn(async () => {}),
+    });
+    await runtime.syncProject('project-1');
+    const result = await runtime.runNow('project-1', 'task-1');
+
+    expect(result.ok).toBe(false);
+    expect(result.error).toMatch(/session metadata persist is not configured/);
+    expect(client.create).not.toHaveBeenCalled();
+    expect(client.prompt).not.toHaveBeenCalled();
+  });
+
+  it('fails the run before prompt when Host metadata persist throws', async () => {
+    const history = createHistoryStore();
+    const client = createSuccessfulClient();
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState, {
+      runHistoryStore: history,
+      persistSessionMetadata: vi.fn(async () => {
+        throw new Error('store unavailable');
+      }),
+      waitForOpenCodeReady: vi.fn(async () => {}),
+    });
+    await runtime.syncProject('project-1');
+    const result = await runtime.runNow('project-1', 'task-1');
+
+    expect(result.ok).toBe(false);
+    expect(result.error).toMatch(/store unavailable/);
+    expect(client.create).toHaveBeenCalled();
+    expect(client.prompt).not.toHaveBeenCalled();
+  });
+
   it('records error outcome and real duration when the assistant turn fails after admission', async () => {
     const history = createHistoryStore();
     const client = createSuccessfulClient({ settlement: 'assistant-error' });
@@ -763,6 +838,7 @@ describe('scheduled-tasks run history and session lifecycle', () => {
       buildOpenCodeUrl: vi.fn(() => 'http://127.0.0.1:4096'),
       getOpenCodeAuthHeaders: vi.fn(() => ({})),
       waitForOpenCodeReady: vi.fn(async () => {}),
+      persistSessionMetadata: vi.fn(async () => ({})),
       logger: { info: vi.fn(), warn: vi.fn() },
       runHistoryStore: history,
       maxRunDurationMs: 500,
@@ -948,6 +1024,7 @@ describe('scheduled-tasks run history and session lifecycle', () => {
       buildOpenCodeUrl: vi.fn(() => 'http://127.0.0.1:4096'),
       getOpenCodeAuthHeaders: vi.fn(() => ({})),
       waitForOpenCodeReady: vi.fn(async () => {}),
+      persistSessionMetadata: vi.fn(async () => ({})),
       logger: { info: vi.fn(), warn: vi.fn() },
       runHistoryStore: history,
       persistSessionGoal,
@@ -1016,6 +1093,7 @@ describe('scheduled-tasks run history and session lifecycle', () => {
       buildOpenCodeUrl: vi.fn(() => 'http://127.0.0.1:4096'),
       getOpenCodeAuthHeaders: vi.fn(() => ({})),
       waitForOpenCodeReady: vi.fn(async () => {}),
+      persistSessionMetadata: vi.fn(async () => ({})),
       logger: { info: vi.fn(), warn: vi.fn() },
       runHistoryStore: history,
       persistSessionGoal,
@@ -1581,6 +1659,7 @@ describe('scheduled-tasks cross-process slot occupancy', () => {
         waitForOpenCodeReady: vi.fn(async () => {
           throw new Error('OpenCode unavailable');
         }),
+        persistSessionMetadata: vi.fn(async () => ({})),
         logger: { info: vi.fn(), warn: vi.fn() },
         runHistoryStore: store,
         notifyTaskRun,