@vantran-se/openchamber-web 1.23.0 → 1.24.3

package/server/lib/opencode/theme-catalog.test.js

@@ -0,0 +1,125 @@
+import { describe, expect, test } from 'bun:test';
+import { createHash } from 'node:crypto';
+import { deflateRawSync } from 'node:zlib';
+import { createThemeCatalog, registerThemeCatalogRoutes } from './theme-catalog.js';
+import { registerCommonRequestMiddleware } from './core-routes.js';
+import express from 'express';
+import request from 'supertest';
+import { openThemeArchive } from './theme-archive.js';
+
+function archive(files) {
+  const locals = [];
+  const directory = [];
+  let offset = 0;
+  for (const [filename, content] of Object.entries(files)) {
+    const name = Buffer.from(filename);
+    const data = Buffer.from(content);
+    const compressed = deflateRawSync(data);
+    const header = Buffer.alloc(30);
+    header.writeUInt32LE(0x04034b50);
+    header.writeUInt16LE(8, 8);
+    header.writeUInt32LE(compressed.length, 18);
+    header.writeUInt32LE(data.length, 22);
+    header.writeUInt16LE(name.length, 26);
+    locals.push(header, name, compressed);
+    const central = Buffer.alloc(46);
+    central.writeUInt32LE(0x02014b50);
+    central.writeUInt16LE(8, 10);
+    central.writeUInt32LE(compressed.length, 20);
+    central.writeUInt32LE(data.length, 24);
+    central.writeUInt16LE(name.length, 28);
+    central.writeUInt32LE(offset, 42);
+    directory.push(central, name);
+    offset += header.length + name.length + compressed.length;
+  }
+  const end = Buffer.alloc(22);
+  end.writeUInt32LE(0x06054b50);
+  end.writeUInt16LE(directory.length / 2, 8);
+  end.writeUInt16LE(directory.length / 2, 10);
+  end.writeUInt32LE(Buffer.concat(directory).length, 12);
+  end.writeUInt32LE(offset, 16);
+  return Buffer.concat([...locals, ...directory, end]);
+}
+
+const identity = { namespace: 'Author', name: 'fixture', version: '1.0.0' };
+const manifest = { publisher: 'Author', name: 'fixture', version: '1.0.0', contributes: { themes: [
+  { label: 'Readable Night', path: './themes/night.json', uiTheme: 'vs-dark' },
+  { label: 'Broken sibling', path: '../../outside.json', uiTheme: 'vs' },
+] } };
+const packageFiles = {
+  'extension/package.json': JSON.stringify(manifest),
+  'extension/base.json': '{"colors":{"editor.background":"#111111","editor.foreground":"#eeeeee"},"tokenColors":[{"scope":"string","settings":{"foreground":"#aaaaaa"}}]}',
+  'extension/themes/night.json': '{ // JSONC\n"include":"../base.json", "colors":{"editor.foreground":"#ffffff"},"tokenColors":"./tokens.json",}',
+  'extension/themes/tokens.json': '[{"scope":"keyword","settings":{"foreground":"#aabbcc"}}]',
+};
+
+function transport(bytes, overrides = {}) {
+  const responses = new Map([
+    ['https://open-vsx.org/api/Author/fixture/1.0.0', JSON.stringify({ ...identity, files: { download: 'https://open-vsx.org/package.vsix', sha256: 'https://open-vsx.org/package.sha256' } })],
+    ['https://open-vsx.org/package.vsix', bytes],
+    ['https://open-vsx.org/package.sha256', createHash('sha256').update(bytes).digest('hex')],
+    ...Object.entries(overrides),
+  ]);
+  return async (url) => {
+    const body = responses.get(url.href);
+    if (body === undefined) throw new Error(`Unexpected request ${url}`);
+    return new Response(body);
+  };
+}
+
+describe('Open VSX theme catalog', () => {
+  test('catalog requests retain their bodies through the production middleware', async () => {
+    const app = express();
+    registerCommonRequestMiddleware(app, { express });
+    const catalog = createThemeCatalog({ fetchImpl: transport(archive(packageFiles)) });
+    registerThemeCatalogRoutes(app, {
+      search: async (input) => { expect(input).toEqual({ query: 'nord' }); return []; },
+      readPackage: catalog.readPackage,
+    });
+    await request(app).post('/api/config/themes/catalog/search').send({ query: 'nord' }).expect(200);
+    const response = await request(app).post('/api/config/themes/catalog/package').send(identity).expect(200);
+    expect(response.body.items[0].name).toBe('Readable Night');
+  });
+  test('resolves JSONC includes and external token files, preserving healthy siblings and manifest labels', async () => {
+    const catalog = createThemeCatalog({ fetchImpl: transport(archive(packageFiles)) });
+    const result = await catalog.readPackage(identity);
+    expect(result[0].error).toBe(false);
+    const source = JSON.parse(result[0].text);
+    expect(source.name).toBe('Readable Night');
+    expect(source.type).toBe('dark');
+    expect(source.colors).toEqual({ 'editor.background': '#111111', 'editor.foreground': '#ffffff' });
+    expect(source.tokenColors.map((rule) => rule.scope)).toEqual(['string', 'keyword']);
+    expect(source.include).toBeUndefined();
+    expect(result[1].error).toBe(true);
+  });
+
+  test('rejects checksum and package identity mismatches', async () => {
+    const bytes = archive(packageFiles);
+    await expect(createThemeCatalog({ fetchImpl: transport(bytes, { 'https://open-vsx.org/package.sha256': '0'.repeat(64) }) }).readPackage(identity)).rejects.toThrow('checksum');
+    const wrong = archive({ ...packageFiles, 'extension/package.json': JSON.stringify({ ...manifest, publisher: 'Impostor' }) });
+    await expect(createThemeCatalog({ fetchImpl: transport(wrong) }).readPackage(identity)).rejects.toThrow('identity');
+  });
+
+  test('limits decompression and rejects traversal and cyclic includes', async () => {
+    expect(() => openThemeArchive(archive({ '../outside.json': '{}' }))).toThrow('Unsafe');
+    const read = openThemeArchive(archive({ 'extension/huge.json': ' '.repeat(512 * 1024 + 1) }));
+    await expect(read('extension/huge.json')).rejects.toThrow('large');
+    const cyclic = archive({ ...packageFiles, 'extension/base.json': '{"include":"./themes/night.json"}' });
+    expect((await createThemeCatalog({ fetchImpl: transport(cyclic) }).readPackage(identity))[0].error).toBe(true);
+  });
+
+  test('searches only the theme category and rejects redirects outside the catalog', async () => {
+    const catalog = createThemeCatalog({ fetchImpl: async (url, options) => {
+      expect(url.searchParams.get('category')).toBe('Themes');
+      expect(url.searchParams.get('query')).toBe('Dune');
+      expect(options.redirect).toBe('manual');
+      return Response.json({ extensions: [{ ...identity, displayName: 'Dune', files: {} }] });
+    } });
+    expect((await catalog.search({ query: 'Dune' }))[0].label).toBe('Dune');
+    let calls = 0;
+    const hostile = createThemeCatalog({ fetchImpl: async () => { calls++; return new Response(null, { status: 302, headers: { location: 'http://127.0.0.1/private' } }); } });
+    await expect(hostile.search({ query: 'Dune' })).rejects.toThrow('host');
+    expect(calls).toBe(1);
+    await expect(catalog.readPackage({ ...identity, name: '../secret' })).rejects.toThrow();
+  });
+});

package/server/lib/opencode/theme-import.test.js

@@ -0,0 +1,144 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import express from 'express';
+import request from 'supertest';
+import { createThemeRuntime } from './theme-runtime.js';
+import { registerSettingsUtilityRoutes, registerCommonRequestMiddleware } from './core-routes.js';
+
+const directories = [];
+afterEach(async () => {
+  await Promise.all(directories.splice(0).map((directory) => fs.rm(directory, { recursive: true, force: true })));
+});
+
+const definition = {
+  metadata: { id: '../../escape', name: 'Imported fixture', variant: 'dark' },
+  colors: {
+    primary: { base: '#ffcc66' },
+    surface: { background: '#111111', foreground: '#eeeeee', muted: '#181818', mutedForeground: '#999999', elevated: '#222222' },
+    interactive: { border: '#333333' },
+    status: { error: '#ff6666', warning: '#ffcc66', success: '#66cc66', info: '#66aaff' },
+    syntax: { base: { comment: '#888888', keyword: '#aa88ff', string: '#88cc66', number: '#ffcc66', function: '#66aaff', variable: '#eeeeee', type: '#66dddd', operator: '#ff6677' } },
+  },
+};
+
+async function setup(overrides = {}) {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'oc-theme-import-'));
+  directories.push(root);
+  const themesDir = path.join(root, 'themes');
+  const runtime = createThemeRuntime({ fsPromises: { ...fs, ...overrides }, path, themesDir, maxThemeJsonBytes: 512 * 1024, logger: console });
+  const app = express();
+  registerCommonRequestMiddleware(app, { express });
+  registerSettingsUtilityRoutes(app, runtime);
+  return { root, themesDir, runtime, app };
+}
+
+describe('theme import persistence', () => {
+  it('deletes only imported files, leaves siblings intact and allows an identical reimport', async () => {
+    const { app, runtime, themesDir } = await setup();
+    const theme = await runtime.saveImportedTheme(definition);
+    await fs.writeFile(path.join(themesDir, 'custom.json'), JSON.stringify(definition));
+    await request(app).delete('/api/config/themes/openchamber-dark').expect(200);
+    await request(app).delete(`/api/config/themes/${theme.metadata.id}`).expect(200);
+    expect(await fs.readdir(themesDir)).toEqual(['custom.json']);
+    await request(app).delete(`/api/config/themes/${theme.metadata.id}`).expect(200);
+    expect(await runtime.saveImportedTheme(definition)).toEqual(theme);
+  });
+
+  it('does not follow a symlink during deletion or report deletion failure as success', async () => {
+    const { app, root, themesDir } = await setup();
+    await fs.mkdir(themesDir);
+    const outside = path.join(root, 'outside.json');
+    await fs.writeFile(outside, 'keep');
+    const id = `imported-vscode-${'a'.repeat(24)}`;
+    await fs.symlink(outside, path.join(themesDir, `${id}.json`));
+    await request(app).delete(`/api/config/themes/${id}`).expect(200);
+    expect(await fs.readFile(outside, 'utf8')).toBe('keep');
+    const denied = await setup({ unlink: async () => { throw Object.assign(new Error('denied'), { code: 'EACCES' }); } });
+    await fs.mkdir(denied.themesDir);
+    await fs.writeFile(path.join(denied.themesDir, `${id}.json`), JSON.stringify({ ...definition, metadata: { ...definition.metadata, id } }));
+    await request(denied.app).delete(`/api/config/themes/${id}`).expect(500);
+    expect(await fs.readdir(denied.themesDir)).toEqual([`${id}.json`]);
+  });
+  it('deletes a hand-added theme by its metadata ID, not by an assumed filename', async () => {
+    const { app, themesDir } = await setup();
+    await fs.mkdir(themesDir);
+    const custom = { ...definition, metadata: { ...definition.metadata, id: 't3-code-dark', name: 'T3 Code' } };
+    await fs.writeFile(path.join(themesDir, 'my-custom-palette.json'), JSON.stringify(custom));
+    const loaded = await request(app).get('/api/config/themes').expect(200);
+    expect(loaded.body.themes[0].metadata.id).toBe('t3-code-dark');
+    await request(app).delete('/api/config/themes/t3-code-dark').expect(200);
+    expect(await fs.readdir(themesDir)).toEqual([]);
+  });
+
+  it('refuses ambiguous duplicate IDs and does not turn an ID into a filesystem path', async () => {
+    const { app, themesDir, root } = await setup();
+    await fs.mkdir(themesDir);
+    const custom = { ...definition, metadata: { ...definition.metadata, id: 'duplicate' } };
+    for (const name of ['one.json', 'two.json']) await fs.writeFile(path.join(themesDir, name), JSON.stringify(custom));
+    await request(app).delete('/api/config/themes/duplicate').expect(409);
+    expect((await fs.readdir(themesDir)).sort()).toEqual(['one.json', 'two.json']);
+    await fs.writeFile(path.join(root, 'outside.json'), JSON.stringify(custom));
+    await request(app).delete('/api/config/themes/..%2Foutside').expect(200);
+    expect(await fs.readFile(path.join(root, 'outside.json'), 'utf8')).toBe(JSON.stringify(custom));
+  });
+
+  it('allows deleting a readable theme beside an unreadable sibling, but does not treat failed reads as absence', async () => {
+    const { runtime, themesDir } = await setup({ readFile: async (file, ...args) => {
+      if (path.basename(file) === 'unreadable.json') throw Object.assign(new Error('denied'), { code: 'EACCES' });
+      return fs.readFile(file, ...args);
+    } });
+    const theme = await runtime.saveImportedTheme(definition);
+    await fs.writeFile(path.join(themesDir, 'unreadable.json'), JSON.stringify(definition));
+    await runtime.deleteImportedTheme(theme.metadata.id);
+    expect(await fs.readdir(themesDir)).toEqual(['unreadable.json']);
+    await expect(runtime.deleteImportedTheme('possibly-unreadable')).rejects.toMatchObject({ code: 'EACCES' });
+  });
+  it('saves through the API under a server-owned ID and returns it through reload', async () => {
+    const { app, themesDir, root } = await setup();
+    const response = await request(app).post('/api/config/themes').send({ theme: definition }).expect(201);
+    expect(response.body.theme.metadata.id).toMatch(/^imported-vscode-[a-f0-9]{24}$/);
+    expect(await fs.readdir(root)).toEqual(['themes']);
+    expect(await fs.readdir(themesDir)).toEqual([`${response.body.theme.metadata.id}.json`]);
+    const loaded = await request(app).get('/api/config/themes').expect(200);
+    expect(loaded.body.themes).toEqual([response.body.theme]);
+  });
+
+  it('deduplicates simultaneous imports and never overwrites a subsequently edited theme', async () => {
+    const { runtime, themesDir } = await setup();
+    const [first, second] = await Promise.all([runtime.saveImportedTheme(definition), runtime.saveImportedTheme(definition)]);
+    expect(first).toEqual(second);
+    expect((await fs.readdir(themesDir)).length).toBe(1);
+    const filename = path.join(themesDir, `${first.metadata.id}.json`);
+    await fs.writeFile(filename, 'manually edited');
+    await expect(runtime.saveImportedTheme(definition)).rejects.toMatchObject({ code: 'conflict', status: 409 });
+    expect(await fs.readFile(filename, 'utf8')).toBe('manually edited');
+    expect(await fs.readdir(themesDir)).toEqual([`${first.metadata.id}.json`]);
+  });
+
+  it('rejects malformed definitions and unsafe token names without creating files', async () => {
+    const { app, root } = await setup();
+    await request(app).post('/api/config/themes').send({ theme: { ...definition, colors: {} } }).expect(400);
+    await request(app).post('/api/config/themes').send({ theme: { ...definition, colors: { ...definition.colors, syntax: { ...definition.colors.syntax, tokens: { 'x;body': '#000000' } } } } }).expect(400);
+    expect(await fs.readdir(root)).toEqual([]);
+  });
+
+  it('cleans temporary files after a publication failure', async () => {
+    const { runtime, themesDir } = await setup({ link: async () => { throw Object.assign(new Error('denied'), { code: 'EACCES' }); } });
+    await expect(runtime.saveImportedTheme(definition)).rejects.toMatchObject({ code: 'EACCES' });
+    expect(await fs.readdir(themesDir)).toEqual([]);
+  });
+
+  it('does not report a directory read failure as an empty theme library', async () => {
+    const { runtime } = await setup({ readdir: async () => { throw Object.assign(new Error('denied'), { code: 'EACCES' }); } });
+    await expect(runtime.readCustomThemesFromDisk()).rejects.toMatchObject({ code: 'EACCES' });
+  });
+
+  it('rejects oversized imports without touching the themes directory', async () => {
+    const { runtime, root } = await setup();
+    const tokens = Object.fromEntries(Array.from({ length: 30000 }, (_, index) => [`token${index}`, '#123456']));
+    await expect(runtime.saveImportedTheme({ ...definition, colors: { ...definition.colors, syntax: { ...definition.colors.syntax, tokens } } })).rejects.toMatchObject({ code: 'size', status: 413 });
+    expect(await fs.readdir(root)).toEqual([]);
+  });
+});

package/server/lib/opencode/theme-runtime.js

@@ -1,3 +1,29 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { z } from 'zod';
+
+const color = z.string().regex(/^#(?:[\da-f]{3}|[\da-f]{4}|[\da-f]{6}|[\da-f]{8})$/i);
+const role = z.string().regex(/^[a-zA-Z][a-zA-Z0-9]*$/).max(64);
+const importedThemeSchema = z.object({
+  metadata: z.object({
+    name: z.string().trim().min(1).max(160),
+    author: z.string().max(160).optional(),
+    variant: z.enum(['light', 'dark']),
+    description: z.string().max(1024).default(''),
+    version: z.string().max(40).default('1.0.0'),
+    tags: z.array(z.string().max(40)).max(16).default([]),
+  }),
+  colors: z.record(role, z.record(role, z.union([color, z.record(role, color)]))),
+});
+const fileErrorSchema = z.object({ code: z.string() });
+
+export class ThemeImportStorageError extends Error {
+  constructor(code, status) {
+    super(code);
+    this.code = code;
+    this.status = status;
+  }
+}
+
 export const createThemeRuntime = (dependencies) => {
   const {
     fsPromises,
@@ -34,46 +60,24 @@ export const createThemeRuntime = (dependencies) => {
     const status = colors.status;
     const syntax = colors.syntax;
     const syntaxBase = syntax && typeof syntax === 'object' ? syntax.base : null;
-    const syntaxHighlights = syntax && typeof syntax === 'object' ? syntax.highlights : null;
 
-    if (!primary || !surface || !interactive || !status || !syntaxBase || !syntaxHighlights) {
+    if (!primary || !surface || !interactive || !status || !syntaxBase) {
       return null;
     }
 
-    // Minimal fields required by CSSVariableGenerator and diff/syntax rendering.
+    // Authored inputs only. The UI resolves optional roles before rendering.
     const required = [
       primary.base,
-      primary.foreground,
       surface.background,
       surface.foreground,
       surface.muted,
       surface.mutedForeground,
       surface.elevated,
-      surface.elevatedForeground,
-      surface.subtle,
       interactive.border,
-      interactive.selection,
-      interactive.selectionForeground,
-      interactive.focusRing,
-      interactive.hover,
       status.error,
-      status.errorForeground,
-      status.errorBackground,
-      status.errorBorder,
       status.warning,
-      status.warningForeground,
-      status.warningBackground,
-      status.warningBorder,
       status.success,
-      status.successForeground,
-      status.successBackground,
-      status.successBorder,
       status.info,
-      status.infoForeground,
-      status.infoBackground,
-      status.infoBorder,
-      syntaxBase.background,
-      syntaxBase.foreground,
       syntaxBase.keyword,
       syntaxBase.string,
       syntaxBase.number,
@@ -82,9 +86,6 @@ export const createThemeRuntime = (dependencies) => {
       syntaxBase.type,
       syntaxBase.comment,
       syntaxBase.operator,
-      syntaxHighlights.diffAdded,
-      syntaxHighlights.diffRemoved,
-      syntaxHighlights.lineNumber,
     ];
 
     if (!required.every(isValidThemeColor)) {
@@ -156,12 +157,83 @@ export const createThemeRuntime = (dependencies) => {
         return [];
       }
       logger.warn('[themes] Failed to list custom themes dir:', error);
-      return [];
+      throw error;
+    }
+  };
+
+  const saveImportedTheme = async (raw) => {
+    const parsed = importedThemeSchema.safeParse(raw);
+    if (!parsed.success) throw new ThemeImportStorageError('invalid', 400);
+    const normalized = normalizeThemeJson({ ...parsed.data, metadata: { ...parsed.data.metadata, id: 'import' } });
+    if (!normalized) throw new ThemeImportStorageError('invalid', 400);
+    // The client supplies colors, never a filename or an overwrite target.
+    // Identical imports have the same ID, including retries after a lost reply.
+    const digest = createHash('sha256').update(JSON.stringify(parsed.data)).digest('hex').slice(0, 24);
+    const theme = { ...normalized, metadata: { ...normalized.metadata, id: `imported-vscode-${digest}` } };
+    const contents = `${JSON.stringify(theme, null, 2)}\n`;
+    if (Buffer.byteLength(contents, 'utf8') > maxThemeJsonBytes) throw new ThemeImportStorageError('size', 413);
+    await fsPromises.mkdir(themesDir, { recursive: true });
+    const target = path.join(themesDir, `${theme.metadata.id}.json`);
+    const temporary = path.join(themesDir, `${randomUUID()}.tmp`);
+    try {
+      await fsPromises.writeFile(temporary, contents, { flag: 'wx', mode: 0o600 });
+      try {
+        // Link publishes the complete file atomically and cannot overwrite an
+        // existing theme, even if another import finishes at the same time.
+        await fsPromises.link(temporary, target);
+      } catch (error) {
+        const parsedError = fileErrorSchema.safeParse(error);
+        if (!parsedError.success || parsedError.data.code !== 'EEXIST') throw error;
+        if (await fsPromises.readFile(target, 'utf8') !== contents) throw new ThemeImportStorageError('conflict', 409);
+      }
+      return theme;
+    } finally {
+      await fsPromises.unlink(temporary).catch((error) => {
+        const parsedError = fileErrorSchema.safeParse(error);
+        if (!parsedError.success || parsedError.data.code !== 'ENOENT') logger.warn('[themes] Failed to clean import temporary file');
+      });
     }
   };
 
   return {
     normalizeThemeJson,
     readCustomThemesFromDisk,
+    saveImportedTheme,
+    async deleteImportedTheme(id) {
+      if (!z.string().trim().min(1).max(256).safeParse(id).success) throw new ThemeImportStorageError('invalid', 400);
+      const matches = [];
+      let readFailure;
+      let entries;
+      try { entries = await fsPromises.readdir(themesDir, { withFileTypes: true }); }
+      catch (error) {
+        if (fileErrorSchema.safeParse(error).data?.code === 'ENOENT') return;
+        throw error;
+      }
+      for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith('.json')) continue;
+        const target = path.join(themesDir, entry.name);
+        let text;
+        try {
+          const stat = await fsPromises.lstat(target);
+          if (!stat.isFile() || stat.isSymbolicLink() || stat.size > maxThemeJsonBytes) continue;
+          text = await fsPromises.readFile(target, 'utf8');
+        } catch (error) {
+          if (fileErrorSchema.safeParse(error).data?.code !== 'ENOENT') readFailure = error;
+          continue;
+        }
+        let theme;
+        try { theme = normalizeThemeJson(JSON.parse(text)); }
+        catch { continue; }
+        if (theme?.metadata.id === id) matches.push(target);
+      }
+      // IDs identify themes, not filenames. Refuse ambiguous matches rather
+      // than deleting an arbitrary sibling or constructing a path from the ID.
+      if (matches.length > 1) throw new ThemeImportStorageError('conflict', 409);
+      if (!matches.length) {
+        if (readFailure) throw readFailure;
+        return;
+      }
+      await fsPromises.unlink(matches[0]);
+    },
   };
 };

package/server/lib/opencode/theme-runtime.test.js

@@ -90,6 +90,21 @@ const createTestRuntime = ({ entries, files, stats }) => createThemeRuntime({
 
 describe('theme runtime', () => {
   describe('readCustomThemesFromDisk', () => {
+    it('loads compact authored roles without requiring derived colors', async () => {
+      const theme = validTheme('compact');
+      theme.colors.primary = { base: '#ffffff' };
+      theme.colors.interactive = { border: '#444444' };
+      theme.colors.status = { error: '#ff0000', warning: '#ffaa00', success: '#00ff00', info: '#0000ff' };
+      delete theme.colors.syntax.highlights;
+      delete theme.colors.syntax.base.background;
+      delete theme.colors.syntax.base.foreground;
+      const runtime = createTestRuntime({
+        entries: [fileEntry('compact.json'), fileEntry('bad.json')],
+        files: { '/themes/compact.json': JSON.stringify(theme), '/themes/bad.json': '{broken' },
+        stats: { '/themes/compact.json': { isFile: () => true, size: 1024 }, '/themes/bad.json': { isFile: () => true, size: 10 } },
+      });
+      expect((await runtime.readCustomThemesFromDisk()).map((item) => item.metadata.id)).toEqual(['compact']);
+    });
     it('loads valid theme files', async () => {
       const runtime = createTestRuntime({
         entries: [fileEntry('direct.json')],

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

@@ -16,6 +16,14 @@ Policy inheritance uses the nearest explicit session value. A child `false` ther
 
 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.
 
+## Safety net
+
+`evaluatePermission` (the routing runtime, `../routing/DOCUMENTATION.md`) is
+consulted after the policy check and before the reply. `hold` counts the
+request as handled without replying, so it stays on screen; `accept` replies as
+before. A `permission.replied` event is passed to `onPermissionReplied` so the
+routing runtime forgets its cached decision.
+
 ## Routes
 
 - `GET /api/permission-auto-accept`

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

@@ -25,6 +25,10 @@ export function createPermissionAutoAcceptRuntime({
   readSettingsFromDiskMigrated,
   persistSettings,
   broadcastGlobalUiEvent,
+  // The routing safety net: asked once per request before the automatic reply.
+  // `hold` leaves the request for the user; absent means every request is replied to.
+  evaluatePermission = null,
+  onPermissionReplied = null,
   fetchImpl = fetch,
   retryDelaysMs = RETRY_DELAYS_MS,
   requestTimeoutMs = REQUEST_TIMEOUT_MS,
@@ -148,6 +152,10 @@ export function createPermissionAutoAcceptRuntime({
     if (!permission?.id || !permission?.sessionID) return false;
     await load();
     if (!(await isSessionAutoAccepting(permission.sessionID, directory))) return false;
+    if (evaluatePermission) {
+      const verdict = await evaluatePermission(permission, directory);
+      if (verdict?.action === 'hold') return true;
+    }
     await request(`/permission/${encodeURIComponent(permission.id)}/reply`, {
       directory,
       method: 'POST',
@@ -218,6 +226,11 @@ export function createPermissionAutoAcceptRuntime({
     }
     if (payload?.type === 'permission.asked') {
       void processPermission(payload.properties, directory);
+      return;
+    }
+    if (payload?.type === 'permission.replied') {
+      const permissionId = payload.properties?.requestID;
+      if (typeof permissionId === 'string') onPermissionReplied?.(permissionId);
     }
   };
 

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

@@ -1,7 +1,7 @@
 import { describe, expect, it, vi } from 'vitest';
 import { createPermissionAutoAcceptRuntime } from './runtime.js';
 
-const createRuntime = ({ stored, fetchImpl, retryDelaysMs = [0] } = {}) => {
+const createRuntime = ({ stored, fetchImpl, retryDelaysMs = [0], evaluatePermission, onPermissionReplied } = {}) => {
   let settings = stored ?? { permissionAutoAccept: { sessions: {} } };
   let eventHandler;
   let statusHandler;
@@ -16,6 +16,8 @@ const createRuntime = ({ stored, fetchImpl, retryDelaysMs = [0] } = {}) => {
     persistSettings: async (changes) => { settings = { ...settings, ...changes }; },
     fetchImpl: fetchImpl ?? vi.fn(async () => new Response('[]')),
     retryDelaysMs,
+    evaluatePermission,
+    onPermissionReplied,
   });
   runtime.start();
   return {
@@ -143,4 +145,38 @@ describe('permission auto-accept runtime', () => {
     expect(fetchImpl.mock.calls.some(([url]) => new URL(url).searchParams.get('directory') === '/project')).toBe(true);
     expect(await runtime.load()).toEqual({ sessions: { root: true }, revision: 1 });
   });
+
+  it('leaves a request held by the safety net unanswered and forgets it once replied', async () => {
+    const fetchImpl = vi.fn(async () => new Response('[]'));
+    const verdicts = { held: { action: 'hold', score: 0.9, kind: 'git_history' }, safe: { action: 'accept', score: 0.1 } };
+    const evaluatePermission = vi.fn(async (permission) => verdicts[permission.id]);
+    const onPermissionReplied = vi.fn();
+    const { runtime, emit } = createRuntime({
+      stored: { permissionAutoAccept: { sessions: { root: true } } },
+      fetchImpl,
+      evaluatePermission,
+      onPermissionReplied,
+    });
+    await runtime.load();
+
+    emit({ type: 'permission.asked', properties: { id: 'held', sessionID: 'root', permission: 'bash', metadata: {} } });
+    emit({ type: 'permission.asked', properties: { id: 'safe', sessionID: 'root', permission: 'bash', metadata: {} } });
+    await flush();
+
+    const replies = fetchImpl.mock.calls.map(([url]) => String(url)).filter((url) => url.includes('/reply'));
+    expect(replies).toEqual(['http://opencode.test/permission/safe/reply?directory=%2Fproject']);
+    expect(evaluatePermission).toHaveBeenCalledTimes(2);
+
+    emit({ type: 'permission.replied', properties: { sessionID: 'root', requestID: 'held', reply: 'once' } });
+    expect(onPermissionReplied).toHaveBeenCalledWith('held');
+  });
+
+  it('does not consult the safety net for sessions that are not auto-accepting', async () => {
+    const evaluatePermission = vi.fn(async () => ({ action: 'hold' }));
+    const { runtime, emit } = createRuntime({ evaluatePermission });
+    await runtime.load();
+    emit({ type: 'permission.asked', properties: { id: 'p', sessionID: 'manual', permission: 'bash', metadata: {} } });
+    await flush();
+    expect(evaluatePermission).not.toHaveBeenCalled();
+  });
 });

package/server/lib/project-context/DOCUMENTATION.md

@@ -12,8 +12,18 @@ The managed Chats root (`~/.config/openchamber/chats`) is also one context owner
 | `<projectsDir>/<projectId>.json` | `packages/web/server/lib/projects` (`project-setup.js` for the client-owned keys behind `/api/projects/:projectId/config`; `project-config.js` for `version` / `scheduledTasks`), one write lock for both | worktree setup, draft starters, project actions, scheduled tasks |
 | `<projectsDir>/<projectId>/context.json` | **this module, exclusively** | notes, todos, plan manifest |
 | `<projectsDir>/<projectId>/plans/*.md` | **this module, exclusively** | plan bodies |
+| `<projectsDir>/<projectId>/memory.json` | `packages/web/server/lib/agent-memory` | what the agent chose to remember about the project |
 | `<repo>/<plansDir>/*.md` | this module (read, edit, delete, move) when the team config names a `plansDir`; the folder is the team's, any tool may write there | shared plan bodies |
 
+`<projectId>` in these paths is the bounded stem `projectConfigFileStemOf`
+(`packages/web/server/lib/projects/project-id.js`) gives the id: the id itself
+up to 200 characters, `path_sha256_<digest>` beyond that, so a deeply nested
+checkout gets a folder the filesystem accepts. The folder, the config file,
+and the memory file all share that one stem; nothing here composes a path from
+the raw id. The legacy-migration read below looks at the bounded config file
+for the same reason: a read of `<raw id>.json` would fail with ENAMETOOLONG
+and turn an empty project into an error.
+
 The split is the point. Both files were previously one, written by the client
 with a whole-file read-modify-write. Adding a server writer to that file would
 have made unrelated features (project actions, draft starters) clobber notes
@@ -147,9 +157,9 @@ and I/O failures are `500`.
 ## Legacy migration
 
 `projectNotes`, `projectTodos`, and `projectPlanFiles` originally lived in
-`<projectId>.json`. On the first read with no `context.json`, those three keys
-are moved out and deleted from the client-owned file; every other key is
-preserved untouched.
+`<projectId>.json` (the bounded name, see Ownership). On the first read with
+no `context.json`, those three keys are moved out and deleted from the
+client-owned file; every other key is preserved untouched.
 
 Plan links carried absolute paths. Migration converts each to a base name. A
 file already in the plans directory is used in place; one referenced from

package/server/lib/project-context/runtime.js

@@ -12,6 +12,8 @@
  * directory never invalidates a reference.
  */
 
+import { projectConfigFileStemOf } from '../projects/project-id.js';
+
 const PROJECT_CONTEXT_VERSION = 2;
 const PROJECT_NOTE_BODY_MAX_LENGTH = 3000;
 const PROJECT_NOTE_MAX_ITEMS = 200;
@@ -221,10 +223,14 @@ export const createProjectContextRuntime = (deps) => {
     return value;
   };
 
-  const storageDirFor = (projectId) => path.join(projectsDirPath, sanitizeProjectId(projectId));
+  // The folder and the client-owned config file share one bounded stem
+  // (`projectConfigFileStemOf`): an id too long for a file name would
+  // otherwise fail every read with ENAMETOOLONG instead of reading as empty.
+  const storageStemFor = (projectId) => projectConfigFileStemOf(sanitizeProjectId(projectId));
+  const storageDirFor = (projectId) => path.join(projectsDirPath, storageStemFor(projectId));
   const contextPathFor = (projectId) => path.join(storageDirFor(projectId), 'context.json');
   const plansDirFor = (projectId) => path.join(storageDirFor(projectId), 'plans');
-  const legacyConfigPathFor = (projectId) => path.join(projectsDirPath, `${sanitizeProjectId(projectId)}.json`);
+  const legacyConfigPathFor = (projectId) => path.join(projectsDirPath, `${storageStemFor(projectId)}.json`);
 
   const readJson = async (filePath) => {
     let raw;