@openchambery/web 1.19.11 → 1.19.12

package/server/lib/assistants/pi-tools.test.js

@@ -5,6 +5,7 @@ import { afterEach, describe, expect, it } from 'vitest';
 import {
   collectAssistantSkillDirectories,
   createPiCodingRuntime,
+  formatPiCodingPrompt,
   mergeSkillsByName,
   PI_CODING_TOOL_NAMES,
   resolveAssistantCwd,
@@ -78,6 +79,30 @@ describe('mergeSkillsByName', () => {
   });
 });
 
+describe('formatPiCodingPrompt', () => {
+  it('includes full pi tool argument schemas and distinguishes skills from tools', async () => {
+    const cwd = temp();
+    const home = temp();
+    const runtime = await createPiCodingRuntime(cwd, { homeDir: home });
+    const prompt = formatPiCodingPrompt({
+      cwd: runtime.cwd,
+      skillsPrompt: runtime.skillsPrompt,
+      tools: runtime.tools,
+    });
+    expect(prompt).toContain('arguments schema:');
+    expect(prompt).toContain('"path"');
+    expect(prompt).toContain('"content"');
+    expect(prompt).toContain('"edits"');
+    expect(prompt).toContain('"oldText"');
+    expect(prompt).toContain('"newText"');
+    expect(prompt).toContain('"command"');
+    expect(prompt).toContain('not OpenCode native tools and not MCP');
+    expect(prompt).toContain('never invent skill or MCP tool names');
+    expect(prompt).toContain('context7');
+    await runtime.close();
+  });
+});
+
 describe('createPiCodingRuntime', () => {
   it('installs read/write/edit/bash and merges global plus project skills', async () => {
     const home = temp();

package/server/lib/assistants/service.test.js

@@ -1160,6 +1160,49 @@ describe('assistants service', () => {
     service.close();
   });
 
+  it('same contact-turn assign gate: model re-send creates one worker and one card', async () => {
+    const directory = root();
+    const project = path.join(directory, 'app');
+    fs.mkdirSync(project, { recursive: true });
+    const creates = [];
+    const service = setup(directory, {
+      create: async (input) => {
+        creates.push(input);
+        return { data: { id: `ses_${creates.length}` } };
+      },
+      promptAsync: async () => ({ response: { status: 204 } }),
+    }, {
+      runContactTurn: async ({ tools, userText }) => {
+        const assign = tools.find((tool) => tool.name === 'assign_session');
+        const args = { prompt: userText, projectPath: project, title: 'Once' };
+        const first = await assign.execute('call_1', args);
+        const second = await assign.execute('call_2', args);
+        const thirdDifferent = await assign.execute('call_3', { ...args, prompt: `${userText} again` });
+        expect(first.terminate).toBe(true);
+        expect(second.terminate).toBe(true);
+        expect(second.details.assigned.sessionID).toBe(first.details.assigned.sessionID);
+        expect(thirdDifferent.details.error).toBe('validation_error');
+        return {
+          text: first.content[0].text,
+          bubbles: [first.content[0].text],
+          cards: first.details.card ? [first.details.card, second.details.card].filter(Boolean) : [],
+          tools,
+        };
+      },
+    });
+    const assistant = service.createAssistant(assistantInput);
+    await settleSend(service, assistant.id, {
+      messageID: 'client_assign_once',
+      parts: [{ type: 'text', text: 'Fix once' }],
+    });
+    expect(creates).toHaveLength(1);
+    const page = service.contactMessages(assistant.id);
+    const cards = page.messages.flatMap((message) => (message.parts || []).filter((part) => part.type === 'card'));
+    expect(cards).toHaveLength(1);
+    expect(cards[0]).toMatchObject({ cardType: 'session', sessionID: 'ses_1' });
+    service.close();
+  });
+
   it('creates another assistant from create_assistant and persists the assistant card', async () => {
     const directory = root();
     const service = setup(directory, {}, {

package/server/lib/llm/DOCUMENTATION.md

@@ -29,27 +29,40 @@ The 1.18.4 client exposes `GET /provider`, `GET /config/providers`, and
    the response is JSON (`Content-Type` or a JSON object body). SPA / OpenCode
    HTML `200 <!doctype` is not generate — fall through to the throwaway path.
    Bundled 1.18.4 has no sessionless generate.
-2. Otherwise create a throwaway archived OpenCode session, deny every tool
-   (`client.tool.ids()` → `{ [id]: false }`), send our messages as
-   `system` + user text via `session.promptAsync` (v2 `session.prompt` only
-   forwards `{ id, prompt, delivery, resume }` and drops `model`/`parts` —
-   that produced empty assistant text and a 502). Contact file parts reuse the
-   existing OpenCode `{ type: 'file', mime, url, filename? }` delivery shape
-   (data URLs in the contact SQLite store — not a second attachment store) and
-   are forwarded on `promptAsync` only when the connected catalog marks that
-   model as image-capable (`modalities.input`, `input`, or `attachment`).
-   Non-vision models (for example deepseek-v4-flash) keep the `[image: …]`
-   description and any text-file bytes, and skip image data URLs so generate
-   cannot stall on unsupported vision parts. Non-image
-    text files are also inlined into the flattened prompt. Wait for idle via
-    `session.status` + `session.messages`, then delete the session. Throwaway
-    sessions are created with
-    `metadata.openchamber.llm.purpose = 'chat-completions'` (and archived
-    immediately) so sidebar visibility, session-index, session-title, and
-    notification/push fanout treat them as system-owned — same contract as
+2. Otherwise create a throwaway archived OpenCode session under a hidden
+   `openchamber-llm` agent whose frontmatter uses OpenCode 1.18
+   `permission: { "*": deny }` (not legacy `action`/`resource`/`effect` lists —
+   those load without a terminal `*` deny). `session.create` also sets
+   `permission: [{ permission: '*', pattern: '*', action: 'deny' }]` (SDK
+   PermissionRuleset; verified to round-trip on the session object). Deny every
+   catalog tool via `client.tool.ids()` → `{ [id]: false }` on `promptAsync`;
+   a `tool.ids` SDK/transport error fails generate (never silent empty deny).
+   Send messages as `system` + user text via `session.promptAsync` (v2
+   `session.prompt` only forwards `{ id, prompt, delivery, resume }` and drops
+   `model`/`parts` — that produced empty assistant text and a 502). Contact
+   file parts reuse the existing OpenCode `{ type: 'file', mime, url, filename? }`
+   delivery shape (data URLs in the contact SQLite store — not a second
+   attachment store) and are forwarded on `promptAsync` only when the connected
+   catalog marks that model as image-capable (`modalities.input`, `input`, or
+   `attachment`). Non-vision models (for example deepseek-v4-flash) keep the
+   `[image: …]` description and any text-file bytes, and skip image data URLs so
+   generate cannot stall on unsupported vision parts. Non-image text files are
+   also inlined into the flattened prompt. Wait for idle via `session.status` +
+   `session.messages`; a deterministic `session.messages` SDK error (for example
+   HTTP 400) fails generate immediately. Then delete the session and surface
+   delete SDK errors in diagnostics without erasing a successful text result.
+    Throwaway sessions use `metadata.openchamber.llm.purpose = 'chat-completions'`
+    (and archived immediately) so sidebar visibility, session-index, session-title,
+    and notification/push fanout treat them as system-owned — same contract as
     non-empty `smallModel.purpose`. This is a text generator only — never the
     contact transcript and never a coding SessionPrompt loop. Upstream
     `info.error.message` is forwarded on 502.
+    `ensureLlmTempDirectory` keeps one process-wide throwaway root (`openchamber-llm-…`).
+    Concurrent first callers share a single `mkdtemp` inflight; every caller still
+    writes/refreshes `.opencode/agent/<name>.md` after settle so a mid-flight ensure
+    cannot skip a newer agent body. Concurrent warm refreshes serialize through one
+    write chain (last committed body wins; no interleaved partial writes).
+    `stopLlmTempDirectory` clears the singleton for shutdown/tests.
 
 ### Internal token callback (in-process only)
 

package/server/lib/llm/generate.js

@@ -6,19 +6,34 @@ const SETTLE_POLL_MS = 250;
 const INCOMPLETE_ASSISTANT_SETTLE_PROBES = 2;
 const EMPTY_IDLE_PROBES = 5;
 
+/**
+ * Session-level deny-all. OpenCode 1.18 session.create serializes this
+ * PermissionRuleset shape (permission/pattern/action). Confirmed on local
+ * 1.18.23/1.18.29: create returns the same rule on the session object.
+ */
+export const LLM_SESSION_DENY_PERMISSION = Object.freeze([
+  Object.freeze({ permission: '*', pattern: '*', action: 'deny' }),
+]);
+
+/**
+ * Agent frontmatter for OpenCode 1.18. Runtime /agent metadata uses
+ * permission:[{permission,pattern,action}]. Markdown config accepts the
+ * PermissionActionConfig map (`"*": deny`) / scalar `deny` / tools:"*":false —
+ * not the legacy action/resource/effect list (that loads but does not add
+ * a terminal * deny, so build-like allows and skill guidance stay visible).
+ */
 const AGENT_MARKDOWN = `---
 mode: primary
 hidden: true
-permissions:
-  - action: "*"
-    resource: "*"
-    effect: deny
+permission:
+  "*": deny
 ---
 
 You generate responses for an application-owned assistant. Follow the supplied system instructions and response format.
 The application executes its registered tools, including openchamber-tool JSON fences in your response, and supplies their results on the next request.
 Emit the requested application tool call when an action requires one. Your native tool permissions describe this generator process; the application's supplied tool catalog describes the assistant's capabilities.
 Report execution and failures from supplied tool results only.
+Do not call native OpenCode tools, MCP tools, or skill tools. Native permissions are denied for this generator session.
 `;
 
 const isMissing = (result) =>
@@ -152,7 +167,11 @@ const waitForIdleAssistant = async ({ client, sessionID, directory, signal }) =>
         directory,
         limit: 20,
       }, { signal });
-      if (!messagesResult?.error && Array.isArray(messagesResult?.data)) {
+      if (messagesResult?.error) {
+        // Deterministic upstream failures (e.g. 400) must not look like "still settling".
+        failGenerate(`OpenCode LLM session.messages failed: ${sdkErrorMessage(messagesResult, 'messages failed')}`);
+      }
+      if (Array.isArray(messagesResult?.data)) {
         const lastInfo = readMessageInfo(messagesResult.data.at(-1));
         if (lastInfo?.role === 'assistant') {
           emptyIdleProbes = 0;
@@ -469,13 +488,23 @@ export async function generateOpenCodeText({
       ? clientFactory()
       : createOpencodeClient({ baseUrl, directory: workingDirectory, headers });
 
-    const toolIds = await client.tool.ids({ directory: workingDirectory }).catch(() => ({ data: [] }));
+    let toolIds;
+    try {
+      toolIds = await client.tool.ids({ directory: workingDirectory });
+    } catch (error) {
+      failGenerate(`OpenCode tool.ids failed: ${error?.message || 'tool.ids failed'}`);
+    }
+    if (toolIds?.error) {
+      failGenerate(`OpenCode tool.ids failed: ${sdkErrorMessage(toolIds, 'tool.ids failed')}`);
+    }
     const tools = deniedTools(Array.isArray(toolIds?.data) ? toolIds.data : []);
 
     const created = await client.session.create({
       directory: workingDirectory,
       title: '[openchamber-llm] generate',
       agent: LLM_AGENT_NAME,
+      // Session fence: deny every native OpenCode/MCP/skill tool for this throwaway.
+      permission: LLM_SESSION_DENY_PERMISSION,
       metadata: { openchamber: { llm: { purpose: 'chat-completions' } } },
     }, { signal: controller.signal });
     const sessionID = created?.data?.id;
@@ -548,7 +577,13 @@ export async function generateOpenCodeText({
       }
       unsubscribeDeltas = null;
       try {
-        await client.session.delete({ sessionID, directory: workingDirectory });
+        const deleted = await client.session.delete({ sessionID, directory: workingDirectory });
+        if (deleted?.error) {
+          console.warn(
+            '[llm] failed to delete throwaway OpenCode session:',
+            sdkErrorMessage(deleted, 'delete failed'),
+          );
+        }
       } catch (error) {
         console.warn('[llm] failed to delete throwaway OpenCode session:', error?.message || error);
       }
@@ -570,4 +605,5 @@ export const _test = {
   subscribeThrowawayTextDeltas,
   LLM_AGENT_NAME,
   AGENT_MARKDOWN,
+  LLM_SESSION_DENY_PERMISSION,
 };

package/server/lib/llm/generate.test.js

@@ -74,8 +74,11 @@ describe('generateOpenCodeText', () => {
       clientFactory: createOpencodeClient,
       ensureTempDirectory: async ({ agentMarkdown }) => {
         expect(agentMarkdown).toContain('openchamber-tool JSON fences')
-        expect(agentMarkdown).toContain('effect: deny')
+        expect(agentMarkdown).toMatch(/"\*"\s*:\s*deny/)
+        expect(agentMarkdown).toContain('permission:')
+        expect(agentMarkdown).not.toContain('effect: deny')
         expect(agentMarkdown).toContain('Report execution and failures from supplied tool results only.')
+        expect(agentMarkdown).toContain('Native permissions are denied')
         return '/tmp/openchamber-llm'
       },
       detect: async () => ({ available: false, mode: 'throwaway-session' }),
@@ -83,6 +86,8 @@ describe('generateOpenCodeText', () => {
 
     expect(create).toHaveBeenCalledWith(expect.objectContaining({
       title: expect.stringContaining('[openchamber-llm]'),
+      agent: 'openchamber-llm',
+      permission: [{ permission: '*', pattern: '*', action: 'deny' }],
       metadata: { openchamber: { llm: { purpose: 'chat-completions' } } },
     }), expect.anything())
     expect(update).toHaveBeenCalled()
@@ -417,6 +422,98 @@ describe('generateOpenCodeText', () => {
     expect(subscribers.size).toBe(0)
   })
 
+  it('throws when tool.ids returns an SDK error instead of denying nothing', async () => {
+    const remove = vi.fn(async () => ({ data: true }))
+    await expect(generateOpenCodeText({
+      buildOpenCodeUrl: () => 'http://127.0.0.1:4096',
+      getOpenCodeAuthHeaders: () => ({}),
+      providerID: 'opencode',
+      modelID: 'gpt-5-nano',
+      messages: [{ role: 'user', content: 'hi' }],
+      clientFactory: () => ({
+        session: {
+          create: vi.fn(async () => ({ data: { id: 'ses_tmp' } })),
+          update: vi.fn(),
+          prompt: vi.fn(),
+          promptAsync: vi.fn(),
+          status: vi.fn(),
+          messages: vi.fn(),
+          delete: remove,
+        },
+        tool: { ids: async () => ({ error: { status: 500, message: 'tool catalog unavailable' } }) },
+      }),
+      ensureTempDirectory: async () => '/tmp/openchamber-llm',
+      detect: async () => ({ available: false, mode: 'throwaway-session' }),
+    })).rejects.toMatchObject({
+      code: 'upstream_error',
+      message: expect.stringContaining('tool.ids failed'),
+    })
+    expect(remove).not.toHaveBeenCalled()
+  })
+
+  it('throws when session.messages returns a deterministic 400', async () => {
+    const remove = vi.fn(async () => ({ data: true }))
+    await expect(generateOpenCodeText({
+      buildOpenCodeUrl: () => 'http://127.0.0.1:4096',
+      getOpenCodeAuthHeaders: () => ({}),
+      providerID: 'opencode',
+      modelID: 'gpt-5-nano',
+      messages: [{ role: 'user', content: 'hi' }],
+      clientFactory: () => ({
+        session: {
+          create: async () => ({ data: { id: 'ses_tmp' } }),
+          update: async () => ({ data: { id: 'ses_tmp' } }),
+          prompt: vi.fn(),
+          promptAsync: async () => ({ response: { status: 204 } }),
+          status: async () => ({ data: { ses_tmp: { type: 'idle' } } }),
+          messages: async () => ({ error: { status: 400, message: 'OutputFormatJsonSchema' } }),
+          delete: remove,
+        },
+        tool: { ids: async () => ({ data: ['bash'] }) },
+      }),
+      ensureTempDirectory: async () => '/tmp/openchamber-llm',
+      detect: async () => ({ available: false, mode: 'throwaway-session' }),
+    })).rejects.toMatchObject({
+      code: 'upstream_error',
+      message: expect.stringMatching(/session\.messages failed.*400|OutputFormatJsonSchema/),
+    })
+    expect(remove).toHaveBeenCalled()
+  })
+
+  it('logs SDK delete errors without erasing a successful generate result', async () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      const result = await generateOpenCodeText({
+        buildOpenCodeUrl: () => 'http://127.0.0.1:4096',
+        getOpenCodeAuthHeaders: () => ({}),
+        providerID: 'opencode',
+        modelID: 'gpt-5-nano',
+        messages: [{ role: 'user', content: 'hi' }],
+        clientFactory: () => ({
+          session: {
+            create: async () => ({ data: { id: 'ses_tmp' } }),
+            update: async () => ({ data: { id: 'ses_tmp' } }),
+            prompt: vi.fn(),
+            promptAsync: async () => ({ response: { status: 204 } }),
+            status: async () => ({ data: { ses_tmp: { type: 'idle' } } }),
+            messages: async () => ({ data: [completedAssistant('ok')] }),
+            delete: async () => ({ error: { status: 500, message: 'delete denied' } }),
+          },
+          tool: { ids: async () => ({ data: [] }) },
+        }),
+        ensureTempDirectory: async () => '/tmp/openchamber-llm',
+        detect: async () => ({ available: false, mode: 'throwaway-session' }),
+      })
+      expect(result).toEqual({ text: 'ok', source: 'throwaway-session' })
+      expect(warn).toHaveBeenCalledWith(
+        expect.stringContaining('[llm] failed to delete throwaway OpenCode session:'),
+        expect.stringContaining('delete denied'),
+      )
+    } finally {
+      warn.mockRestore()
+    }
+  })
+
   it('does not invent deltas on the sessionless /generate JSON path', async () => {
     const onTextDelta = vi.fn()
     const subscribers = new Set()

package/server/lib/llm/temp-directory.js

@@ -6,28 +6,49 @@ import path from 'node:path';
 let tempDirectory = null;
 /** @type {Promise<string> | null} */
 let inflight = null;
+/** Serialize markdown refreshes so concurrent ensure cannot interleave one file. */
+let writeChain = Promise.resolve();
+
+const writeAgentMarkdown = async (root, agentName, agentMarkdown) => {
+  const agentDir = path.join(root, '.opencode', 'agent');
+  await fs.mkdir(agentDir, { recursive: true });
+  await fs.writeFile(path.join(agentDir, `${agentName}.md`), agentMarkdown, 'utf8');
+};
+
+const enqueueWrite = (work) => {
+  const run = writeChain.catch(() => {}).then(work);
+  writeChain = run.catch(() => {});
+  return run;
+};
 
 export async function ensureLlmTempDirectory({ agentName, agentMarkdown }) {
-  if (tempDirectory) return tempDirectory;
-  if (!inflight) {
-    inflight = (async () => {
-      const root = await fs.mkdtemp(path.join(os.tmpdir(), 'openchamber-llm-'));
-      const agentDir = path.join(root, '.opencode', 'agent');
-      await fs.mkdir(agentDir, { recursive: true });
-      await fs.writeFile(path.join(agentDir, `${agentName}.md`), agentMarkdown, 'utf8');
-      tempDirectory = root;
-      return root;
-    })().finally(() => {
-      inflight = null;
-    });
+  // Long-lived servers / HMR must refresh the hidden agent markdown so a
+  // permission-format fix is not stuck behind a stale temp directory.
+  // Concurrent first callers share one mkdtemp; every caller still writes its
+  // markdown after settle so a mid-flight ensure cannot skip a newer body.
+  // Concurrent warm writes are serialized (last committed body wins).
+  if (!tempDirectory) {
+    if (!inflight) {
+      inflight = (async () => {
+        const root = await fs.mkdtemp(path.join(os.tmpdir(), 'openchamber-llm-'));
+        tempDirectory = root;
+        return root;
+      })().finally(() => {
+        inflight = null;
+      });
+    }
+    await inflight;
   }
-  return inflight;
+  const root = tempDirectory;
+  await enqueueWrite(() => writeAgentMarkdown(root, agentName, agentMarkdown));
+  return root;
 }
 
 export async function stopLlmTempDirectory() {
   const dir = tempDirectory;
   tempDirectory = null;
   inflight = null;
+  writeChain = Promise.resolve();
   if (!dir) return;
   try {
     await fs.rm(dir, { recursive: true, force: true });

package/server/lib/llm/temp-directory.test.js

@@ -0,0 +1,57 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { ensureLlmTempDirectory, stopLlmTempDirectory } from './temp-directory.js';
+
+const readAgent = async (root, agentName) =>
+  fs.readFile(path.join(root, '.opencode', 'agent', `${agentName}.md`), 'utf8');
+
+afterEach(async () => {
+  await stopLlmTempDirectory();
+});
+
+describe('ensureLlmTempDirectory', () => {
+  it('shares one directory across concurrent first ensures and applies each markdown body', async () => {
+    const firstBody = '---\nname: a\n---\nFIRST\n';
+    const secondBody = '---\nname: a\n---\nSECOND\n';
+    const [first, second] = await Promise.all([
+      ensureLlmTempDirectory({ agentName: 'openchamber-llm', agentMarkdown: firstBody }),
+      ensureLlmTempDirectory({ agentName: 'openchamber-llm', agentMarkdown: secondBody }),
+    ]);
+    expect(first).toBe(second);
+    const written = await readAgent(first, 'openchamber-llm');
+    // Last writer wins; both callers must have completed a full write after settle.
+    expect(written === firstBody || written === secondBody).toBe(true);
+    expect(written).toMatch(/FIRST|SECOND/);
+  });
+
+  it('refreshes markdown on a warm directory under concurrent ensure', async () => {
+    const root = await ensureLlmTempDirectory({
+      agentName: 'openchamber-llm',
+      agentMarkdown: '---\nname: a\n---\nSEED\n',
+    });
+    const bodies = Array.from({ length: 8 }, (_, index) => `---\nname: a\n---\nREFRESH-${index}\n`);
+    const roots = await Promise.all(
+      bodies.map((agentMarkdown) => ensureLlmTempDirectory({ agentName: 'openchamber-llm', agentMarkdown })),
+    );
+    expect(new Set(roots)).toEqual(new Set([root]));
+    const written = await readAgent(root, 'openchamber-llm');
+    expect(bodies).toContain(written);
+    expect(written).toMatch(/REFRESH-\d+/);
+  });
+
+  it('stop clears the singleton so the next ensure creates a fresh directory', async () => {
+    const first = await ensureLlmTempDirectory({
+      agentName: 'openchamber-llm',
+      agentMarkdown: '---\nname: a\n---\nA\n',
+    });
+    await stopLlmTempDirectory();
+    const second = await ensureLlmTempDirectory({
+      agentName: 'openchamber-llm',
+      agentMarkdown: '---\nname: a\n---\nB\n',
+    });
+    expect(second).not.toBe(first);
+    await expect(fs.access(first)).rejects.toThrow();
+    expect(await readAgent(second, 'openchamber-llm')).toContain('B');
+  });
+});