npm - @openchambery/web - Versions diffs - 1.19.11 → 1.19.12 - Mend

@openchambery/web 1.19.11 → 1.19.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (50) hide show

package/dist/mini-chat.html CHANGED Viewed

@@ -74,7 +74,7 @@
       }
     </style>
-    <script type="module" crossorigin src="/assets/miniChat-BJ9AclZX.js"></script>
+    <script type="module" crossorigin src="/assets/miniChat-C9QMj8T8.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-C0FnF6B9.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-base-ui-CnHfUmDN.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-zustand-B4dlGEM2.js">
@@ -91,7 +91,7 @@
     <link rel="modulepreload" crossorigin href="/assets/terminalApi-947l7Ra3.js">
     <link rel="modulepreload" crossorigin href="/assets/types-BuiqMmh_.js">
     <link rel="modulepreload" crossorigin href="/assets/capgoAdapter-DCowZ2ab.js">
-    <link rel="modulepreload" crossorigin href="/assets/runtimeConfig-P8nVMYzE.js">
+    <link rel="modulepreload" crossorigin href="/assets/runtimeConfig-C6matIEB.js">
     <link rel="stylesheet" crossorigin href="/assets/src-B-P5qIBc.css">
   </head>
   <body class="h-full bg-background text-foreground">

package/dist/mobile.html CHANGED Viewed

@@ -63,7 +63,7 @@
       })();
     </script>
-    <script type="module" crossorigin src="/assets/mobile-OcCu_0mG.js"></script>
+    <script type="module" crossorigin src="/assets/mobile-Z_X7CbzB.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-C0FnF6B9.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-base-ui-CnHfUmDN.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-zustand-B4dlGEM2.js">
@@ -80,7 +80,7 @@
     <link rel="modulepreload" crossorigin href="/assets/terminalApi-947l7Ra3.js">
     <link rel="modulepreload" crossorigin href="/assets/types-BuiqMmh_.js">
     <link rel="modulepreload" crossorigin href="/assets/capgoAdapter-DCowZ2ab.js">
-    <link rel="modulepreload" crossorigin href="/assets/runtimeConfig-P8nVMYzE.js">
+    <link rel="modulepreload" crossorigin href="/assets/runtimeConfig-C6matIEB.js">
     <link rel="stylesheet" crossorigin href="/assets/src-B-P5qIBc.css">
   </head>
   <body class="h-full bg-background text-foreground">

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@openchambery/web",
-  "version": "1.19.11",
+  "version": "1.19.12",
   "private": false,
   "type": "module",
   "main": "./server/index.js",

package/server/lib/assistants/DOCUMENTATION.md CHANGED Viewed

@@ -2,7 +2,7 @@
 ## Acceptance criteria
-The in-app Assistant is an OpenChamber-owned **contact**. OpenCode is only the LLM gateway (`POST /api/openchamber/llm/chat/completions`) using already-connected `{providerID, modelID}`. Composer send runs `@earendil-works/pi-agent-core` with `thinkingLevel: 'off'`. When the assistant has an effective workspace, the harness attaches pi's four coding tools (`read`, `write`, `edit`, `bash`) via `NodeExecutionEnv` in that directory, applies `defaultPrompt`, and merges skills from `~/.claude/skills`, `~/.agents/skills`, plus the project's `.claude/skills` and `.agents/skills` (project wins on name). OpenChamber API tools remain (`new_conversation`, `clear_chat_history`, `list_projects`, `list_sessions`, `create_assistant`, `schedule_task`, `message_assistant`, `assign_session`). It does not use `SessionPrompt` / `promptAsync` as the conversation engine. The LLM gateway throwaway session still denies OpenCode tools; file and shell work runs in-process through pi.
+The in-app Assistant is an OpenChamber-owned **contact**. OpenCode is only the LLM gateway (`POST /api/openchamber/llm/chat/completions`) using already-connected `{providerID, modelID}`. Composer send runs `@earendil-works/pi-agent-core` with `thinkingLevel: 'off'`. When the assistant has an effective workspace, the harness attaches pi's four coding tools (`read`, `write`, `edit`, `bash`) via `NodeExecutionEnv` in that directory, applies `defaultPrompt`, and merges skills from `~/.claude/skills`, `~/.agents/skills`, plus the project's `.claude/skills` and `.agents/skills` (project wins on name). OpenChamber API tools remain (`new_conversation`, `clear_chat_history`, `list_projects`, `list_sessions`, `create_assistant`, `schedule_task`, `message_assistant`, `assign_session`). It does not use `SessionPrompt` / `promptAsync` as the conversation engine. The LLM gateway throwaway session still denies OpenCode tools (`session.create` PermissionRuleset deny-all + `promptAsync` tools map + hidden `openchamber-llm` agent `permission: { "*": deny }`); file and shell work runs in-process through pi. The contact system prompt includes **full argument schemas** for both pi coding tools and OpenChamber contact tools. Skill directory entries are instructions loaded via `read`, not native/MCP tool names.
 Contact turns retain all eight OpenChamber operation tools alongside the four
 pi tools. Skill discovery contributes instructions to this combined tool set.
@@ -22,7 +22,9 @@ and keep their existing error result handling.
 - `assign_session` is an OpenChamber AgentTool on the contact harness. It creates or reuses a visible OpenCode/OpenChamber session on a **registered project path** (Settings projects / `getAllowedRoots()`), optionally an **existing** Chat worktree/branch via `getWorktrees`, then kicks the coding prompt into that session with `session.create` + `session.promptAsync` (same worker path as `POST /api/openchamber/conversations`).
 - That worker session is the coder. The contact does not code. Assign sessions are **not** archived Assistant bindings and must not use `assistant-workspaces`.
-- After a successful assign, the service persists the existing session card into the contact transcript (user bubbles first, then the card) and watches that worker session in `assistant_contact_watch`.
+- Successful `assign_session` returns `terminate: true` so the pi agent loop does **not** auto-follow-up the LLM (prevents a looping model from re-assigning dozens of times in one turn). Prerequisite tools (`list_projects` / `list_sessions`) may still run before assign in the same turn; multi-operation user intents remain ordered **across turns** after a successful assign.
+- Same contact-turn assign gate (tools instance lifetime only, not cross-turn): identical args after success replay the cached success result (no second worker); different args after success, or parallel mismatched args, fail closed with a validation error. Failure clears the gate so a corrected retry may run. Parallel identical args share one in-flight promise.
+- After a successful assign, the service persists the existing session card into the contact transcript (user bubbles first, then the card) and watches that worker session in `assistant_contact_watch`. The user-facing outcome is the session card plus a short confirm bubble.
 - Existing OpenCode SSE on the same `globalEventHub` as notifications (`session.idle`, `session.error`, `session.status`, `question.asked`, `permission.asked`) updates **the same card** (`busy` → `complete` / `error` / `question`) and appends one idempotent settle bubble (`oc.settle.*`). Session-goal settle (`emitGoalNotification`) is wired into that same reporter — not a second scheduler. Idle after `session.error` must not rewrite 失败 as 完成.
 - Restart or a missed `session.idle` cannot leave the watch stuck: boot and the existing 60s reconcile timer `listInFlightWatches` and poll OpenCode `session.get` / `session.messages`. Idle, `time.completed`, or a missing session settles the same card (`busy` → 完成) and appends the existing `oc.settle.complete` bubble. `session.error` or last-assistant `info.error` settles 失败. Transport / non-404 get errors leave the watch in flight (failure is not empty success). One failed watch does not block unrelated watches. Reconcile reuses `reportAssignedSession`, so an error watch is never rewritten as complete.
 - Worker sessions stamp `metadata.openchamber.assigned` (`from: 'contact'`, `assistantID`, `name`). They must **not** use `openchamber.assistant.assistantID` — that marker hides archived Assistant bindings from Chat.
@@ -42,7 +44,7 @@ and keep their existing error result handling.
 - `create_assistant` calls the same in-process `createAssistant` (`name`, connected OpenCode `providerID`/`modelID`, `mode: 'continuous'`). It emits an `assistant` card that opens that contact.
 - `schedule_task` calls in-process `projectConfigRuntime.upsertScheduledTask` with the same payload as `PUT /api/projects/:id/scheduled-tasks` (`name`, `schedule.kind/time/timezone`, `execution.prompt` + provider/model) on a registered project, then best-effort `scheduledTasksRuntime.syncProject`. It emits a `schedule` card.
 - Successful `schedule_task` also writes an assistants-owned mapping row in `assistants.sqlite` (`assistant_scheduled_task`: assistantID + projectID + taskID). Project-config execution strips unknown fields, so ownership stays out of the task payload. `GET /api/openchamber/assistants/:id/scheduled-tasks` returns those mappings joined with live `listScheduledTasks` records when possible; failed project lookups keep the mapping with `task: null`.
-- `CONTACT_SYSTEM_PROMPT` + `formatContactToolsPrompt` tell the model to call these from natural language (开新对话 / 找项目 / 现有对话 / 建助理 / 建会话 / 排定时任务 / 给 X 说一声). A reply without the tool call does nothing; never say 已创建 / 已发送 unless the tool returned. Completions are messages-only (no native tools), so `parseContactToolCalls` accepts a fence, a whole-message JSON object, or a bare `{name, arguments}` object anywhere in the reply.
+- `CONTACT_SYSTEM_PROMPT` + `formatContactToolsPrompt` + `formatPiCodingPrompt` tell the model to call these from natural language (开新对话 / 找项目 / 现有对话 / 建助理 / 建会话 / 排定时任务 / 给 X 说一声). Catalog lines include each tool's JSON argument schema (pi `write`/`edit` require `path`+`content` / `path`+`edits[{oldText,newText}]`). A reply without the tool call does nothing; never say 已创建 / 已发送 unless the tool returned. Completions are messages-only (no native tools), so `parseContactToolCalls` accepts a fence, a whole-message JSON object, or a bare `{name, arguments}` object anywhere in the reply. Tool results are re-injected as user turns labeled `OpenChamber tool result name=<tool> call=<id>` so multi-step turns keep call/result association.
 - If the user asked for `new_conversation` / `clear_chat_history` / `list_projects` / `list_sessions` / `create_assistant` / `schedule_task` / `message_assistant` / `assign_session` and the first completion has no tool call, the harness runs **one** follow-up completion whose user content is only `emit the fence now, do not claim success.` If still no tool, the turn replies that it could not complete and does not fake a card. No slash commands. No second store.
 **Clear memory vs clear chat history (this PR)**

package/server/lib/assistants/contact-tools.js CHANGED Viewed

@@ -1,4 +1,4 @@
-import { AssignError, PROJECT_REQUIRED_MESSAGE } from './assign.js';
+import { AssignError, ASSIGN_CODES, PROJECT_REQUIRED_MESSAGE } from './assign.js';
 import { createAssistantCardPart, createScheduleCardPart, createSessionCardPart } from './cards.js';
 import { isPiCodingToolName } from './pi-tools.js';
@@ -32,6 +32,8 @@ export const LIST_PROJECTS_TOOL_NAME = 'list_projects';
 export const LIST_SESSIONS_TOOL_NAME = 'list_sessions';
 const CONTACT_TOOL_FENCE = 'openchamber-tool';
 export const ASSIGNED_SESSION_FALLBACK_BUBBLE = 'Opened a coding session.';
+/** Same-turn duplicate assign (different args after a success, or parallel mismatch). */
+export const ASSIGN_DUPLICATE_TURN_MESSAGE = 'This contact turn already opened a coding session. Do not assign again.';
 /** Clear-memory confirm: transcript rows stay; only the LLM window resets. */
 export const NEW_CONVERSATION_CONFIRM_BUBBLE = 'Memory cleared. Previous messages stay in the chat; I will not use them as context.';
 /** Explicit transcript wipe confirm (clear_chat_history / POST contact/reset). */
@@ -39,6 +41,23 @@ export const CLEAR_CHAT_HISTORY_CONFIRM_BUBBLE = 'Chat history cleared.';
 const LIST_SESSIONS_LIMIT_DEFAULT = 20;
 const LIST_SESSIONS_LIMIT_MAX = 50;
+/** Stable key for same-turn assign dedup (not cross-turn). */
+export function normalizeAssignRequestKey(params = {}) {
+  const pick = (value) => {
+    if (typeof value === 'string') return value.trim();
+    if (value == null) return '';
+    return String(value).trim();
+  };
+  return JSON.stringify({
+    prompt: pick(params?.prompt),
+    projectPath: pick(params?.projectPath),
+    directory: pick(params?.directory),
+    branch: pick(params?.branch),
+    sessionID: pick(params?.sessionID),
+    title: pick(params?.title),
+  });
+}
 const DENIED_CODING_TOOLS = new Set(['glob', 'grep', 'shell', 'find', 'ls', 'powershell']);
 const FENCE = new RegExp(`\`\`\`${CONTACT_TOOL_FENCE}\\s*([\\s\\S]*?)\`\`\``, 'u');
@@ -414,6 +433,35 @@ export function resolvePeerAssistant(params = {}, assistants = [], currentAssist
   return matches[0];
 }
+/**
+ * Serialize a tool parameter schema for the contact system prompt.
+ * Accepts plain JSON-schema-like objects and TypeBox schemas (JSON.stringify).
+ * Strips non-enumerable TypeBox markers (~kind / ~optional).
+ */
+export function serializeToolParametersForPrompt(parameters) {
+  if (parameters == null) return '{"type":"object","properties":{}}';
+  try {
+    const text = JSON.stringify(parameters, (_key, value) => {
+      if (typeof value === 'function' || typeof value === 'symbol') return undefined;
+      return value;
+    });
+    if (typeof text === 'string' && text.trim() && text !== 'undefined') return text;
+  } catch {
+    // Fall through to empty object schema.
+  }
+  return '{"type":"object","properties":{}}';
+}
+/** One catalog line: name, description, and full arguments schema. */
+export function formatApplicationToolCatalogEntry(tool) {
+  if (!tool || typeof tool.name !== 'string' || !tool.name.trim()) return '';
+  const name = tool.name.trim();
+  const description = typeof tool.description === 'string' && tool.description.trim()
+    ? tool.description.trim()
+    : (typeof tool.label === 'string' && tool.label.trim() ? tool.label.trim() : name);
+  return `- ${name}: ${description}\n  arguments schema: ${serializeToolParametersForPrompt(tool.parameters)}`;
+}
 export function formatContactToolsPrompt(tools) {
   const list = Array.isArray(tools)
     ? tools.filter((tool) => tool?.name && !DENIED_CODING_TOOLS.has(tool.name) && !isPiCodingToolName(tool.name))
@@ -455,11 +503,12 @@ export function formatContactToolsPrompt(tools) {
     `{"name":"${ASSIGN_SESSION_TOOL_NAME}","arguments":{"prompt":"...","projectPath":"..."}}`,
     '```',
     'If the user asked for more than one of these, do them in that order across turns: new_conversation or clear_chat_history, then list_projects, then list_sessions, then create_assistant, then schedule_task, then message_assistant, then assign_session.',
+    'Prerequisite lookups (list_projects / list_sessions) may run before assign_session in the same turn. After a successful assign_session the turn ends — never call assign_session again, and do not keep looping tools.',
     'new_conversation advances this contact\'s LLM context boundary only. Stored messages and watches remain. It never calls session/new or createNew.',
     'clear_chat_history deletes this contact\'s stored messages, parts, and watches. Use only for explicit wipe intent.',
     'You already receive the registered project catalog each turn. Prefer matching label/path yourself; list_projects refreshes or filters. Never claim you cannot see projects; never ask for a raw path when a name matches.',
     'list_sessions searches the OpenChamber session index for existing chats in a project. A failure is not an empty list — surface the error.',
-    'assign_session opens a real OpenChamber/OpenCode session on a registered project (or reuses sessionID). You are not the worker.',
+    'assign_session opens a real OpenChamber/OpenCode session on a registered project (or reuses sessionID). You are not the worker. One successful assign ends this turn.',
     'create_assistant reuses already-connected OpenCode providers (providerID/modelID). Mode is continuous.',
     'schedule_task writes the same payload as PUT /api/projects/:id/scheduled-tasks onto a registered project.',
     'message_assistant is read-only: it inserts into the other contact transcript. It never runs promptAsync or mutates sessions or files. Never assign through a peer message.',
@@ -467,9 +516,10 @@ export function formatContactToolsPrompt(tools) {
     'When calling a tool that takes a beat (找项目 / 开会话), you may say one short spoken line first (≤40 characters, e.g. 我去找一下), then only the fence. No planning, no tool names, no "let me think".',
     'Never say 已创建, 已发送, created, scheduled, opened, or sent unless the tool already returned success.',
     'If no registered project exists, tell the user to add one in Settings — do not use assistant-workspaces.',
-    'After a successful tool, confirm in one short bubble. The user sees a contact card, not tool traces.',
+    'After a successful tool, confirm in one short bubble. The user sees a contact card, not tool traces. After successful assign_session the session card plus that short confirm is enough — stop.',
+    'These are application-owned OpenChamber contact tools (not OpenCode native tools, not MCP, not skill directory entries). Use only the names and argument schemas below:',
     'Available OpenChamber tools:',
-    ...list.map((tool) => `- ${tool.name}: ${tool.description || tool.label || tool.name}`),
+    ...list.map((tool) => formatApplicationToolCatalogEntry(tool)).filter(Boolean),
   ].join('\n');
 }
@@ -553,6 +603,64 @@ export function createContactTools({
     if (typeof onCard === 'function') onCard(card);
   };
+  /**
+   * Same contact-turn assign gate only (tools instance = one harness turn).
+   * - Same args after success → cached success (no second worker).
+   * - Different args after success / parallel mismatch → reject.
+   * - Failure clears the gate so a corrected retry may run.
+   * Not cross-turn.
+   */
+  let assignTurnGate = null;
+  const executeAssignOnce = async (params) => {
+    const key = normalizeAssignRequestKey(params);
+    if (assignTurnGate?.status === 'done') {
+      if (assignTurnGate.key === key) return assignTurnGate.result;
+      throw new AssignError(ASSIGN_CODES.VALIDATION, ASSIGN_DUPLICATE_TURN_MESSAGE);
+    }
+    if (assignTurnGate?.status === 'pending') {
+      if (assignTurnGate.key === key) return assignTurnGate.promise;
+      throw new AssignError(ASSIGN_CODES.VALIDATION, ASSIGN_DUPLICATE_TURN_MESSAGE);
+    }
+    let settle;
+    const promise = new Promise((resolve, reject) => {
+      settle = { resolve, reject };
+    });
+    assignTurnGate = { status: 'pending', key, promise };
+    void (async () => {
+      try {
+        if (typeof assignWork !== 'function') {
+          throw new AssignError('upstream_error', 'Assign is unavailable.');
+        }
+        const assigned = await assignWork(params || {});
+        const card = createSessionCardPart({
+          sessionID: assigned.sessionID,
+          directory: assigned.directory,
+          title: assigned.title,
+          status: assigned.status || 'busy',
+          branch: assigned.branch,
+        });
+        emitCard(card);
+        const result = {
+          // Short confirm for the transcript; session id lives on the card details.
+          content: [{ type: 'text', text: ASSIGNED_SESSION_FALLBACK_BUBBLE }],
+          details: { card, assigned },
+          // End the pi agent loop so a looping model cannot re-assign 37 times.
+          terminate: true,
+        };
+        assignTurnGate = { status: 'done', key, result };
+        settle.resolve(result);
+      } catch (error) {
+        assignTurnGate = null;
+        settle.reject(error);
+      }
+    })();
+    return promise;
+  };
   return [
     {
       name: NEW_CONVERSATION_TOOL_NAME,
@@ -816,28 +924,12 @@ export function createContactTools({
       description: [
         'Open or reuse a real OpenChamber coding session on a registered project path',
         'and kick the prompt into that session. Optional existing worktree branch or sessionID.',
-        'Never codes here. Never uses assistant-workspaces.',
+        'Successful assign ends this contact turn (terminate). Never codes here. Never uses assistant-workspaces.',
       ].join(' '),
       parameters: assignParameters,
       execute: async (_toolCallId, params) => {
         try {
-          if (typeof assignWork !== 'function') {
-            throw new AssignError('upstream_error', 'Assign is unavailable.');
-          }
-          const assigned = await assignWork(params || {});
-          const card = createSessionCardPart({
-            sessionID: assigned.sessionID,
-            directory: assigned.directory,
-            title: assigned.title,
-            status: assigned.status || 'busy',
-            branch: assigned.branch,
-          });
-          emitCard(card);
-          return {
-            content: [{ type: 'text', text: `Opened coding session ${assigned.sessionID}. The user will see a session card.` }],
-            details: { card, assigned },
-            terminate: false,
-          };
+          return await executeAssignOnce(params || {});
         } catch (error) {
           return toolFailure(error, 'assign_failed', 'Could not assign a coding session.');
         }

package/server/lib/assistants/contact-tools.test.js CHANGED Viewed

@@ -1,6 +1,7 @@
 import { describe, expect, it, vi } from 'vitest';
 import { AssignError, ASSIGN_CODES, PROJECT_REQUIRED_MESSAGE } from './assign.js';
 import {
+  ASSIGN_DUPLICATE_TURN_MESSAGE,
   ASSIGN_SESSION_TOOL_NAME,
   CLEAR_CHAT_HISTORY_CONFIRM_BUBBLE,
   CLEAR_CHAT_HISTORY_TOOL_NAME,
@@ -18,6 +19,7 @@ import {
   formatContactToolsPrompt,
   formatRegisteredProjectsPrompt,
   matchesProjectQuery,
+  normalizeAssignRequestKey,
   parseContactToolCalls,
   resolveContactProviderModel,
   resolvePeerAssistant,
@@ -160,6 +162,13 @@ describe('contact tool protocol', () => {
     expect(prompt).toContain('A reply without the tool call does nothing');
     expect(prompt).toContain('已创建');
     expect(prompt).toContain('Never claim you cannot see projects');
+    expect(prompt).toContain('One successful assign ends this turn');
+    expect(prompt).toContain('application-owned OpenChamber contact tools');
+    expect(prompt).toContain('arguments schema:');
+    expect(prompt).toContain('"prompt"');
+    expect(prompt).toContain('"projectPath"');
+    expect(prompt).toContain('"to"');
+    expect(prompt).toContain('"text"');
   });
   it('fuzzy-matches project labels like openchamber yee / openchamer yee', () => {
@@ -292,9 +301,56 @@ describe('createContactTools', () => {
       sessionID: 'ses_1',
       title: 'Login',
     });
+    expect(assigned.terminate).toBe(true);
     expect(onCard).toHaveBeenCalledTimes(3);
   });
+  it('same-turn assign gate caches identical success and rejects a different second assign', async () => {
+    const assignWork = vi.fn(async () => ({
+      sessionID: 'ses_once',
+      directory: '/repo',
+      title: 'Once',
+      status: 'busy',
+    }));
+    const tools = createContactTools({ assignWork });
+    const assign = tools.find((tool) => tool.name === ASSIGN_SESSION_TOOL_NAME);
+    const args = { prompt: 'Fix login', projectPath: '/repo' };
+    const first = await assign.execute('call_a', args);
+    const secondSame = await assign.execute('call_b', { ...args });
+    expect(assignWork).toHaveBeenCalledTimes(1);
+    expect(secondSame.details.assigned.sessionID).toBe('ses_once');
+    expect(secondSame.terminate).toBe(true);
+    expect(normalizeAssignRequestKey(args)).toBe(normalizeAssignRequestKey({ ...args, title: '  ' }));
+    const different = await assign.execute('call_c', { prompt: 'Other work', projectPath: '/repo' });
+    expect(different.details.error).toBe('validation_error');
+    expect(different.content[0].text).toContain(ASSIGN_DUPLICATE_TURN_MESSAGE);
+    expect(different.terminate).toBe(true);
+    expect(assignWork).toHaveBeenCalledTimes(1);
+  });
+  it('same-turn parallel identical assigns share one worker create', async () => {
+    let release;
+    const barrier = new Promise((resolve) => { release = resolve; });
+    const assignWork = vi.fn(async () => {
+      await barrier;
+      return { sessionID: 'ses_parallel', directory: '/repo', title: 'P', status: 'busy' };
+    });
+    const tools = createContactTools({ assignWork });
+    const assign = tools.find((tool) => tool.name === ASSIGN_SESSION_TOOL_NAME);
+    const args = { prompt: 'Fix', projectPath: '/repo' };
+    const pending = Promise.all([
+      assign.execute('call_1', args),
+      assign.execute('call_2', args),
+    ]);
+    release();
+    const [a, b] = await pending;
+    expect(assignWork).toHaveBeenCalledTimes(1);
+    expect(a.details.assigned.sessionID).toBe('ses_parallel');
+    expect(b.details.assigned.sessionID).toBe('ses_parallel');
+    expect(a.terminate).toBe(true);
+    expect(b.terminate).toBe(true);
+  });
   it('resolves a peer by name and rejects a missing recipient', () => {
     const listed = [{ id: 'asst_peer', name: 'PeerQA' }, { id: 'asst_host', name: 'DeepSeekQA' }];
     expect(resolvePeerAssistant({ to: 'PeerQA' }, listed, { id: 'asst_host' })).toEqual(listed[0]);

package/server/lib/assistants/harness.js CHANGED Viewed

@@ -79,7 +79,7 @@ export const CONTACT_SYSTEM_PROMPT = [
   'You have bash, read, write, and edit in the working directory. Use them for pwd, files, and shell. Never say you have no terminal or cannot read files. Ignore any temporary generator workspace in the environment.',
   'Understand natural language in any language, including Chinese: 开新对话 / 清除记忆 means new_conversation (LLM memory only, chat history stays), 清空聊天记录 means clear_chat_history (delete transcript), 找项目 means list_projects, 现有对话 means list_sessions, 建助理 means create_assistant, 建会话 / 开个新会话 means assign_session, 排定时任务 means schedule_task, 给 X 说一声 means message_assistant, 发卡片 means emit a card via those tools — never ask the user to type /card or /dm.',
   'You receive the registered project catalog every turn. You CAN see those projects. Look them up yourself (fuzzy match label/name/path). Never say you cannot see the registered project list. Never ask for a raw filesystem path when a name matches. If the catalog is empty, tell the user to add a project in Settings.',
-  'File and shell work in this working directory uses read, write, edit, and bash. To open a separate Chat coding session: match the project, optionally list_sessions for existing chats, then assign_session with projectPath or sessionID.',
+  'File and shell work in this working directory uses read, write, edit, and bash. To open a separate Chat coding session: match the project, optionally list_sessions for existing chats, then assign_session with projectPath or sessionID. One successful assign_session ends the turn — do not call it again.',
   'A reply without the tool call does nothing. Never say 已创建, created, scheduled, or opened unless the tool already returned success.',
 ].join(' ');
@@ -259,7 +259,17 @@ export function createContactStreamFn(createChatCompletion, {
                 .filter((part) => part?.type === 'text')
                 .map((part) => part.text)
                 .join('');
-              return content ? [{ role: 'user', content: `OpenChamber tool ${message.toolName || 'result'}: ${content}` }] : [];
+              if (!content) return [];
+              const toolName = typeof message.toolName === 'string' && message.toolName.trim()
+                ? message.toolName.trim()
+                : 'result';
+              const callId = typeof message.toolCallId === 'string' && message.toolCallId.trim()
+                ? message.toolCallId.trim()
+                : (typeof message.id === 'string' && message.id.trim() ? message.id.trim() : '');
+              const label = callId
+                ? `OpenChamber tool result name=${toolName} call=${callId}`
+                : `OpenChamber tool result name=${toolName}`;
+              return [{ role: 'user', content: `${label}: ${content}` }];
             }
             return [];
         });
@@ -473,7 +483,11 @@ export async function runContactTurn({
     const codingTools = Array.isArray(runtime?.tools) ? runtime.tools : [];
     const systemPrompt = [
       CONTACT_SYSTEM_PROMPT,
-      formatPiCodingPrompt({ cwd: runtime?.cwd, skillsPrompt: runtime?.skillsPrompt }),
+      formatPiCodingPrompt({
+        cwd: runtime?.cwd,
+        skillsPrompt: runtime?.skillsPrompt,
+        tools: codingTools,
+      }),
       formatRegisteredProjectsPrompt(projects),
       formatContactToolsPrompt(contactTools),
       assistant.defaultPrompt,

package/server/lib/assistants/harness.test.js CHANGED Viewed

@@ -229,6 +229,10 @@ describe('runContactTurn', () => {
     const createChatCompletion = vi.fn(async ({ body }) => {
       expect(body.messages[0].content).toContain('assign_session')
       expect(body.messages[0].content).toContain('docs')
+      expect(body.messages[0].content).toContain('arguments schema:')
+      expect(body.messages[0].content).toContain('"edits"')
+      expect(body.messages[0].content).toContain('"content"')
+      expect(body.messages[0].content).toContain('not OpenCode native tools and not MCP')
       const content = replies[call++]
       if (!content) throw new Error('Unexpected completion')
       return { completion: { choices: [{ message: { content } }] } }
@@ -242,11 +246,126 @@ describe('runContactTurn', () => {
       expect(result.tools.map((tool) => tool.name)).toEqual([...PI_CODING_TOOL_NAMES, ...tools.map((tool) => tool.name)])
       expect(assignWork).toHaveBeenCalledTimes(1)
       expect(result.cards).toEqual([expect.objectContaining({ sessionID: 'ses_mixed' })])
-      expect(createChatCompletion).toHaveBeenCalledTimes(4)
+      // read → text (miss) → missed-fence retry assign; assign terminates (no post-assign LLM).
+      expect(createChatCompletion).toHaveBeenCalledTimes(3)
+      // Tool call/result association: after read, the next completion sees a named tool result.
+      const secondMessages = createChatCompletion.mock.calls[1][0].body.messages
+      const toolResultTurn = secondMessages.find((message) => (
+        message.role === 'user' && typeof message.content === 'string' && message.content.includes('tool result name=read')
+      ))
+      expect(toolResultTurn).toBeTruthy()
+      expect(toolResultTurn.content).toMatch(/Read project docs|documentation/i)
     } finally {
       fs.rmSync(workspace, { recursive: true, force: true })
     }
   })
+  it('real Agent loop: looping assign fences create only one worker + one card (terminate)', async () => {
+    const assignWork = vi.fn(async () => ({
+      sessionID: 'ses_once',
+      directory: '/repo',
+      title: 'Once',
+      status: 'busy',
+    }))
+    const tools = createContactTools({ assignWork })
+    let completions = 0
+    const createChatCompletion = vi.fn(async () => {
+      completions += 1
+      // Safety: a non-terminating loop must not mint 37 sessions in tests.
+      if (completions > 8) {
+        throw new Error('harness safety stop: too many completions without terminate')
+      }
+      return {
+        completion: {
+          choices: [{
+            message: {
+              content: '```openchamber-tool\n{"name":"assign_session","arguments":{"prompt":"Fix login","projectPath":"/repo"}}\n```',
+            },
+          }],
+        },
+      }
+    })
+    const result = await runContactTurn({
+      assistant: { providerID: 'p', modelID: 'm', defaultPrompt: '' },
+      history: [],
+      userText: '建会话修 login',
+      tools,
+      projects: [{ id: 'p1', path: '/repo', label: 'Repo' }],
+      createChatCompletion,
+    })
+    expect(assignWork).toHaveBeenCalledTimes(1)
+    expect(result.cards).toEqual([expect.objectContaining({ sessionID: 'ses_once', cardType: 'session' })])
+    expect(result.cards).toHaveLength(1)
+    expect(result.bubbles).toContain('Opened a coding session.')
+    // First completion issues assign; terminate skips the auto follow-up LLM.
+    expect(createChatCompletion).toHaveBeenCalledTimes(1)
+    expect(completions).toBe(1)
+  })
+  it('real Agent loop: list_projects then assign keeps prereq + one session (terminate after assign)', async () => {
+    const listProjects = vi.fn(async () => [{ id: 'p1', path: '/repo', label: 'Repo' }])
+    const assignWork = vi.fn(async () => ({
+      sessionID: 'ses_prereq',
+      directory: '/repo',
+      title: 'Prereq',
+      status: 'busy',
+    }))
+    const tools = createContactTools({ listProjects, assignWork })
+    let completions = 0
+    const createChatCompletion = vi.fn(async ({ body }) => {
+      completions += 1
+      if (completions > 6) {
+        throw new Error('harness safety stop: too many completions')
+      }
+      const last = body.messages.at(-1)
+      const lastText = typeof last?.content === 'string' ? last.content : ''
+      if (lastText.includes('tool result name=list_projects') || lastText.includes('Registered projects')) {
+        return {
+          completion: {
+            choices: [{
+              message: {
+                content: '```openchamber-tool\n{"name":"assign_session","arguments":{"prompt":"Fix","projectPath":"/repo"}}\n```',
+              },
+            }],
+          },
+        }
+      }
+      if (completions === 1) {
+        return {
+          completion: {
+            choices: [{
+              message: {
+                content: '```openchamber-tool\n{"name":"list_projects","arguments":{"query":"repo"}}\n```',
+              },
+            }],
+          },
+        }
+      }
+      // If assign did not terminate, a looping model would keep assigning — fail closed.
+      return {
+        completion: {
+          choices: [{
+            message: {
+              content: '```openchamber-tool\n{"name":"assign_session","arguments":{"prompt":"Fix again","projectPath":"/repo"}}\n```',
+            },
+          }],
+        },
+      }
+    })
+    const result = await runContactTurn({
+      assistant: { providerID: 'p', modelID: 'm', defaultPrompt: '' },
+      history: [],
+      userText: '找项目 repo 然后建会话修问题',
+      tools,
+      projects: [{ id: 'p1', path: '/repo', label: 'Repo' }],
+      createChatCompletion,
+    })
+    expect(listProjects).toHaveBeenCalledTimes(1)
+    expect(assignWork).toHaveBeenCalledTimes(1)
+    expect(result.cards).toEqual([expect.objectContaining({ sessionID: 'ses_prereq' })])
+    expect(result.cards).toHaveLength(1)
+    expect(createChatCompletion.mock.calls.length).toBeLessThanOrEqual(3)
+  })
   it('retries assignment after an unrelated read result', async () => {
     const prompts = []
     function AgentImpl(options) {

package/server/lib/assistants/pi-tools.js CHANGED Viewed

@@ -70,21 +70,68 @@ const bindHarnessTool = (tool, context) => ({
   ),
 });
-export function formatPiCodingPrompt({ cwd, skillsPrompt = '' } = {}) {
+/**
+ * Serialize a tool parameter schema for the contact system prompt.
+ * Mirrors contact-tools.serializeToolParametersForPrompt without a circular import.
+ */
+const serializeParameters = (parameters) => {
+  if (parameters == null) return '{"type":"object","properties":{}}';
+  try {
+    const text = JSON.stringify(parameters, (_key, value) => {
+      if (typeof value === 'function' || typeof value === 'symbol') return undefined;
+      return value;
+    });
+    if (typeof text === 'string' && text.trim() && text !== 'undefined') return text;
+  } catch {
+    // Fall through.
+  }
+  return '{"type":"object","properties":{}}';
+};
+const formatCodingToolEntry = (tool) => {
+  if (!tool || typeof tool.name !== 'string' || !tool.name.trim()) return '';
+  const name = tool.name.trim();
+  const description = typeof tool.description === 'string' && tool.description.trim()
+    ? tool.description.trim()
+    : name;
+  return `- ${name}: ${description}\n  arguments schema: ${serializeParameters(tool.parameters)}`;
+};
+export function formatPiCodingPrompt({ cwd, skillsPrompt = '', tools = [] } = {}) {
   if (typeof cwd !== 'string' || !cwd.trim()) return '';
+  const codingTools = Array.isArray(tools)
+    ? tools.filter((tool) => isPiCodingToolName(tool?.name))
+    : [];
+  const catalog = codingTools.length > 0
+    ? codingTools.map(formatCodingToolEntry).filter(Boolean)
+    : [
+      '- bash: Execute a bash command in the working directory.\n  arguments schema: {"type":"object","required":["command"],"properties":{"command":{"type":"string"},"timeout":{"type":"number"}}}',
+      '- read: Read a file (path required; optional offset/limit).\n  arguments schema: {"type":"object","required":["path"],"properties":{"path":{"type":"string"},"offset":{"type":"number"},"limit":{"type":"number"}}}',
+      '- write: Write/create a file (path + content required).\n  arguments schema: {"type":"object","required":["path","content"],"properties":{"path":{"type":"string"},"content":{"type":"string"}}}',
+      '- edit: Exact text replacement (path + edits[{oldText,newText}] required).\n  arguments schema: {"type":"object","required":["path","edits"],"properties":{"path":{"type":"string"},"edits":{"type":"array","items":{"type":"object","required":["oldText","newText"],"properties":{"oldText":{"type":"string"},"newText":{"type":"string"}}}}}}',
+    ];
   return [
     `Working directory: ${cwd}`,
-    'You have pi coding tools in this directory: read, write, edit, bash.',
+    'You have application-owned pi coding tools in this directory: read, write, edit, bash.',
+    'These are not OpenCode native tools and not MCP. Skill directory entries below are instructions only — load a matching skill by calling read on its path; never invent skill or MCP tool names (no context7, gh_grep, webfetch, etc.).',
     'This is your working directory. Ignore any other cwd from the environment, including temporary generator workspaces under /var/folders or os.tmpdir.',
     'When the user asks pwd, the current directory, or to look at files, call bash/read yourself. Never say you have no terminal or cannot read or write files.',
     'Skills are merged from ~/.claude/skills, ~/.agents/skills, and this project\'s .claude/skills plus .agents/skills (project wins on name). Read a skill file when the task matches its description.',
-    'Call these tools with the same fenced JSON as other tools:',
+    'Call these tools with the same fenced JSON as other tools. Match the argument schemas exactly:',
     '```openchamber-tool',
     '{"name":"bash","arguments":{"command":"pwd"}}',
     '```',
     '```openchamber-tool',
     '{"name":"read","arguments":{"path":".agents/skills/example/SKILL.md"}}',
     '```',
+    '```openchamber-tool',
+    '{"name":"write","arguments":{"path":"notes.txt","content":"hello"}}',
+    '```',
+    '```openchamber-tool',
+    '{"name":"edit","arguments":{"path":"notes.txt","edits":[{"oldText":"hello","newText":"hello world"}]}}',
+    '```',
+    'Available pi coding tools (full argument schemas):',
+    ...catalog,
     typeof skillsPrompt === 'string' && skillsPrompt.trim() ? skillsPrompt.trim() : '',
   ].filter(Boolean).join('\n');
 }