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

package/server/lib/opencode/v2-plugin-host-shim/index.mjs

@@ -0,0 +1,155 @@
+import { readdirSync, readFileSync, statSync } from "node:fs"
+import { homedir } from "node:os"
+import path from "node:path"
+import { pathToFileURL } from "node:url"
+
+const stripJsonc = (text) => text
+  .replace(/\/\*[\s\S]*?\*\//g, "")
+  .replace(/(^|[^:\\])\/\/.*$/gm, "$1")
+
+const readConfigPlugins = () => {
+  const specs = []
+  const files = []
+  if (process.env.OPENCODE_CONFIG) files.push(process.env.OPENCODE_CONFIG)
+  const dirs = [process.env.OPENCODE_CONFIG_DIR, path.join(homedir(), ".config", "opencode")].filter(Boolean)
+  for (const dir of dirs) {
+    files.push(path.join(dir, "opencode.jsonc"), path.join(dir, "opencode.json"), path.join(dir, "config.json"))
+  }
+  for (const file of files) {
+    try {
+      const parsed = JSON.parse(stripJsonc(readFileSync(file, "utf8")))
+      const plugin = parsed?.plugin
+      const list = Array.isArray(plugin) ? plugin : plugin ? [plugin] : []
+      for (const entry of list) {
+        if (typeof entry === "string") specs.push(entry)
+        else if (Array.isArray(entry) && typeof entry[0] === "string") specs.push(entry[0])
+      }
+    } catch {
+      // Missing or invalid config files are skipped; OpenCode still loads the ones it can parse.
+    }
+  }
+  return [...new Set(specs)]
+}
+
+const packageName = (spec) => {
+  const slash = spec.startsWith("@") ? spec.indexOf("/", 1) : -1
+  const versionAt = spec.lastIndexOf("@")
+  if (versionAt > 0 && versionAt > slash) return spec.slice(0, versionAt)
+  return spec
+}
+
+const resolvePackageEntry = (spec) => {
+  const name = packageName(spec)
+  const roots = [
+    path.join(homedir(), ".cache", "opencode", "npm"),
+    path.join(homedir(), ".cache", "opencode", "packages"),
+  ]
+  const candidates = []
+  for (const root of roots) {
+    let entries = []
+    try {
+      entries = readdirSync(root)
+    } catch {
+      continue
+    }
+    for (const entry of entries) {
+      if (entry !== name && !entry.startsWith(`${name}@`)) continue
+      const base = path.join(root, entry)
+      const packageDirs = [path.join(base, "node_modules", name)]
+      try {
+        for (const child of readdirSync(base)) {
+          if (/^\d+$/.test(child)) packageDirs.push(path.join(base, child, "node_modules", name))
+        }
+      } catch {
+        // The cache entry may be the package directory itself.
+      }
+      for (const pkgDir of packageDirs) {
+        try {
+          const pkg = JSON.parse(readFileSync(path.join(pkgDir, "package.json"), "utf8"))
+          if (pkg.name !== name) continue
+          const exported = pkg.exports?.["."]
+          const rel = typeof exported === "string" ? exported : pkg.module || pkg.main || "index.mjs"
+          candidates.push({
+            dir: pkgDir,
+            entry: path.resolve(pkgDir, rel),
+            mtime: statSync(path.join(pkgDir, "package.json")).mtimeMs,
+          })
+        } catch {
+          // Not a readable package directory.
+        }
+      }
+    }
+  }
+  candidates.sort((left, right) => right.mtime - left.mtime)
+  return candidates[0] || null
+}
+
+const usesCatalog = (dir) => {
+  const stack = [dir]
+  let seen = 0
+  while (stack.length > 0 && seen < 80) {
+    const current = stack.pop()
+    let names = []
+    try {
+      names = readdirSync(current)
+    } catch {
+      continue
+    }
+    for (const name of names) {
+      if (name === "node_modules" || name === ".git") continue
+      const full = path.join(current, name)
+      let info
+      try {
+        info = statSync(full)
+      } catch {
+        continue
+      }
+      if (info.isDirectory()) {
+        stack.push(full)
+        continue
+      }
+      if (!/\.(?:mjs|cjs|js)$/.test(name) || info.size > 2_000_000) continue
+      seen += 1
+      try {
+        if (readFileSync(full, "utf8").includes(".catalog")) return true
+      } catch {
+        // Unreadable files are not catalog callers.
+      }
+    }
+  }
+  return false
+}
+
+const catalogFor = (ctx) => ({
+  // OpenCode 2.0.12 removed ctx.catalog. Model plugins still call
+  // draft.provider.update / draft.model.update inside catalog.transform.
+  transform: (fn) => ctx.provider?.transform?.((draft) => fn({
+    provider: {
+      update: (id, updater) => draft.update(id, updater),
+      add: (...args) => draft.add?.(...args),
+    },
+    model: {
+      update: (providerID, modelID, updater) => draft.models?.update?.(providerID, modelID, updater),
+      set: (providerID, modelID, value) => draft.models?.set?.(providerID, modelID, value),
+    },
+  })),
+  reload: () => ctx.provider?.reload?.() ?? ctx.model?.reload?.(),
+})
+
+export default {
+  id: "openchamber-v2-plugin-host-shim",
+  setup: async (ctx) => {
+    if (typeof ctx?.catalog?.transform === "function") return
+    const patched = { ...ctx, catalog: catalogFor(ctx) }
+    for (const spec of readConfigPlugins()) {
+      const resolved = resolvePackageEntry(spec)
+      if (!resolved || !usesCatalog(resolved.dir)) continue
+      try {
+        const mod = await import(pathToFileURL(resolved.entry).href)
+        if (typeof mod.default?.setup === "function") await mod.default.setup(patched)
+      } catch (error) {
+        console.error(`[openchamber] v2 plugin host shim skipped ${spec}: ${error instanceof Error ? error.message : String(error)}`)
+      }
+    }
+  },
+}

package/server/lib/opencode/v2-plugin-host-shim/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "module",
+  "name": "openchamber-v2-plugin-host-shim"
+}

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) {