@openchambery/web 1.19.11 → 1.19.13-beta.1

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

@@ -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,30 @@ 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). Includes worker model + attachment scope. */
+export function normalizeAssignRequestKey(params = {}) {
+  const pick = (value) => {
+    if (typeof value === 'string') return value.trim();
+    if (value == null) return '';
+    return String(value).trim();
+  };
+  const attachments = Array.isArray(params?.attachmentScope)
+    ? params.attachmentScope
+    : (Array.isArray(params?.attachments) ? params.attachments : []);
+  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),
+    providerID: pick(params?.providerID),
+    modelID: pick(params?.modelID),
+    model: pick(params?.model),
+    attachments,
+  });
+}
+
 const DENIED_CODING_TOOLS = new Set(['glob', 'grep', 'shell', 'find', 'ls', 'powershell']);
 
 const FENCE = new RegExp(`\`\`\`${CONTACT_TOOL_FENCE}\\s*([\\s\\S]*?)\`\`\``, 'u');
@@ -61,12 +87,16 @@ const newConversationParameters = typeboxObject({});
 const clearChatHistoryParameters = typeboxObject({});
 
 const assignParameters = typeboxObject({
-  prompt: typeboxString('Coding prompt to kick into the worker OpenCode session.'),
+  prompt: typeboxString('Coding prompt to kick into the worker OpenCode session. Current-turn user attachments (images/files) are forwarded by the server automatically — do not base64-encode or invent local paths.'),
   projectPath: typeboxOptional(typeboxString('Registered project path. Required when more than one project exists.')),
   directory: typeboxOptional(typeboxString('Existing project or worktree directory to reuse.')),
   branch: typeboxOptional(typeboxString('Existing Chat worktree branch to reuse. Do not create a new worktree.')),
   sessionID: typeboxOptional(typeboxString('Existing OpenCode session to reuse instead of creating one.')),
   title: typeboxOptional(typeboxString('Optional title for the worker session and contact card.')),
+  providerID: typeboxOptional(typeboxString('Optional worker OpenCode provider ID from the connected catalog. Does not change this contact\'s model. Illegal/blank values fail closed.')),
+  modelID: typeboxOptional(typeboxString('Optional worker OpenCode model ID from the connected catalog. Does not change this contact\'s model. Illegal/blank values fail closed.')),
+  model: typeboxOptional(typeboxString('Optional worker provider/model string such as provider/model-id from the connected catalog. Must not conflict with providerID/modelID. Does not change this contact\'s model.')),
+  variant: typeboxOptional(typeboxString('Optional worker variant for this assign only. Cross-model assign never reuses this contact\'s variant.')),
 });
 
 const createAssistantParameters = typeboxObject({
@@ -181,6 +211,47 @@ export function formatRegisteredProjectsPrompt(projects) {
   ].join('\n');
 }
 
+/** Sanitize connected catalog rows for prompt/tool consumption (no secrets). */
+function sanitizeConnectedModel(entry) {
+  if (!entry || typeof entry !== 'object') return null;
+  const providerID = typeof entry.providerID === 'string' ? entry.providerID.trim() : '';
+  const modelID = typeof entry.modelID === 'string' ? entry.modelID.trim() : '';
+  if (!providerID || !modelID) return null;
+  const name = typeof entry.name === 'string' && entry.name.trim() ? entry.name.trim() : modelID;
+  return {
+    providerID,
+    modelID,
+    name,
+    acceptsImages: entry.acceptsImages === true,
+  };
+}
+
+export function normalizeConnectedModels(models) {
+  return (Array.isArray(models) ? models : [])
+    .map(sanitizeConnectedModel)
+    .filter(Boolean);
+}
+
+/** Injected each turn so assign_session can pick an explicit worker model from the live catalog. */
+export function formatConnectedModelsPrompt(models) {
+  const list = normalizeConnectedModels(models);
+  if (list.length === 0) {
+    return [
+      'Connected OpenCode models: none discoverable this turn.',
+      'assign_session without providerID/modelID/model still uses this contact\'s default model.',
+      'If the user names a specific worker model, only use ids from a successful catalog load — never invent provider/model strings.',
+    ].join(' ');
+  }
+  return [
+    'Connected OpenCode models (worker targets for assign_session only — choosing one does NOT change this contact\'s own model):',
+    ...list.map((entry) => (
+      `- providerID=${JSON.stringify(entry.providerID)} modelID=${JSON.stringify(entry.modelID)} name=${JSON.stringify(entry.name)} acceptsImages=${entry.acceptsImages ? 'true' : 'false'}`
+    )),
+    'When the user names a worker model, pass providerID+modelID or model="provider/modelID" on assign_session. Ambiguous or unknown names must fail — never silent-fallback.',
+    'Current-turn user images/files are forwarded by the server on assign_session. Prefer a acceptsImages=true model when the user attached images.',
+  ].join('\n');
+}
+
 export function boundSessionListLimit(value) {
   if (value == null || value === '') return LIST_SESSIONS_LIMIT_DEFAULT;
   const parsed = typeof value === 'number' ? value : Number(String(value).trim());
@@ -414,6 +485,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))
@@ -452,14 +552,15 @@ export function formatContactToolsPrompt(tools) {
     `{"name":"${MESSAGE_ASSISTANT_TOOL_NAME}","arguments":{"to":"PeerQA","text":"hello-from-assistant 写好了"}}`,
     '```',
     `\`\`\`${CONTACT_TOOL_FENCE}`,
-    `{"name":"${ASSIGN_SESSION_TOOL_NAME}","arguments":{"prompt":"...","projectPath":"..."}}`,
+    `{"name":"${ASSIGN_SESSION_TOOL_NAME}","arguments":{"prompt":"...","projectPath":"...","model":"provider/model-id"}}`,
     '```',
     '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. Optional providerID/modelID/model select the worker only from the connected catalog and never change this contact. Current-turn user attachments are server-forwarded — do not embed base64 or local paths. 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 +568,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');
 }
 
@@ -529,9 +631,17 @@ const toolFailure = (error, fallbackCode, fallbackMessage) => {
   const message = typeof error?.message === 'string' && error.message.trim()
     ? error.message.trim()
     : fallbackMessage;
+  const details = { error: code };
+  // Recoverable prompt admission identity — model must reuse sessionID/messageID,
+  // never blind-create another worker on the same contact turn.
+  if (error instanceof AssignError || (error && typeof error === 'object')) {
+    if (error.ambiguous === true) details.ambiguous = true;
+    if (typeof error.sessionID === 'string' && error.sessionID) details.sessionID = error.sessionID;
+    if (typeof error.messageID === 'string' && error.messageID) details.messageID = error.messageID;
+  }
   return {
     content: [{ type: 'text', text: message }],
-    details: { error: code },
+    details,
     terminate: true,
   };
 };
@@ -548,11 +658,106 @@ export function createContactTools({
   listSessions,
   currentAssistant,
   onCard,
+  /** Authoritative current-turn user file parts (server-owned). Forwarded on assign by default. */
+  turnFileParts = [],
+  /** Precomputed attachment fingerprint for same-turn assign dedup. */
+  turnAttachmentScope = [],
 } = {}) {
   const emitCard = (card) => {
     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.
+   * - Definitive failure clears the gate so a corrected retry may run.
+   * - prompt_ambiguous keeps the gate with sessionID/messageID so a retry must
+   *   reuse that worker — never blind-create a second session this turn.
+   * Not cross-turn.
+   */
+  let assignTurnGate = null;
+
+  const executeAssignOnce = async (params) => {
+    let request = { ...(params || {}) };
+    const key = normalizeAssignRequestKey({
+      ...request,
+      attachmentScope: turnAttachmentScope,
+    });
+    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);
+    }
+    if (assignTurnGate?.status === 'ambiguous') {
+      if (assignTurnGate.key !== key) {
+        throw new AssignError(ASSIGN_CODES.VALIDATION, ASSIGN_DUPLICATE_TURN_MESSAGE);
+      }
+      // Same request after ambiguous admission: reuse worker identity only.
+      if (assignTurnGate.sessionID) request = { ...request, sessionID: assignTurnGate.sessionID };
+      if (assignTurnGate.messageID) request = { ...request, messageID: assignTurnGate.messageID };
+    }
+
+    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.');
+        }
+        // Server owns current-turn attachments — model never supplies base64/paths.
+        const assigned = await assignWork({
+          ...request,
+          fileParts: turnFileParts,
+          attachmentScope: turnAttachmentScope,
+        });
+        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) {
+        if (
+          error instanceof AssignError
+          && error.code === ASSIGN_CODES.PROMPT_AMBIGUOUS
+          && typeof error.sessionID === 'string'
+          && error.sessionID
+        ) {
+          assignTurnGate = {
+            status: 'ambiguous',
+            key,
+            sessionID: error.sessionID,
+            messageID: typeof error.messageID === 'string' ? error.messageID : null,
+          };
+        } else {
+          assignTurnGate = null;
+        }
+        settle.reject(error);
+      }
+    })();
+
+    return promise;
+  };
+
   return [
     {
       name: NEW_CONVERSATION_TOOL_NAME,
@@ -816,28 +1021,14 @@ 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.',
+        'Optional providerID/modelID/model select the worker from the connected catalog only (does not change this contact).',
+        'Current-turn user attachments are forwarded by the server automatically.',
+        '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

@@ -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,
@@ -15,15 +16,18 @@ import {
   createContactTools,
   detectRequestedContactTools,
   filterRegisteredProjects,
+  formatConnectedModelsPrompt,
   formatContactToolsPrompt,
   formatRegisteredProjectsPrompt,
   matchesProjectQuery,
+  normalizeAssignRequestKey,
   parseContactToolCalls,
   resolveContactProviderModel,
   resolvePeerAssistant,
   stripContactToolFences,
   userTextAuthorizesClearChatHistory,
 } from './contact-tools.js';
+import { attachmentScopeKey } from './assign.js';
 
 describe('contact tool protocol', () => {
   it('parses an assign_session fence and strips it from chat text', () => {
@@ -160,6 +164,43 @@ 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('"providerID"');
+    expect(prompt).toContain('"modelID"');
+    expect(prompt).toContain('"model"');
+    expect(prompt).toContain('connected catalog');
+    expect(prompt).toContain('"to"');
+    expect(prompt).toContain('"text"');
+  });
+
+  it('exposes connected models for assign worker selection without inventing ids', () => {
+    const prompt = formatConnectedModelsPrompt([
+      { providerID: 'xai', modelID: 'grok-4.6', name: 'Grok 4.6', acceptsImages: true },
+      { providerID: 'opencode-go', modelID: 'deepseek-v4-flash', acceptsImages: false },
+    ]);
+    expect(prompt).toContain('xai');
+    expect(prompt).toContain('grok-4.6');
+    expect(prompt).toContain('acceptsImages=true');
+    expect(prompt).toContain('does NOT change this contact');
+    expect(formatConnectedModelsPrompt([])).toContain('none discoverable');
+  });
+
+  it('includes worker model and attachment scope in same-turn assign keys', () => {
+    const scope = attachmentScopeKey([
+      { type: 'file', mime: 'image/png', url: 'data:image/png;base64,aa', filename: 'a.png' },
+    ]);
+    const base = { prompt: 'Fix', projectPath: '/repo' };
+    expect(normalizeAssignRequestKey(base)).not.toBe(normalizeAssignRequestKey({
+      ...base,
+      model: 'xai/grok-4.6',
+    }));
+    expect(normalizeAssignRequestKey({ ...base, attachmentScope: scope })).not.toBe(
+      normalizeAssignRequestKey({ ...base, attachmentScope: [] }),
+    );
   });
 
   it('fuzzy-matches project labels like openchamber yee / openchamer yee', () => {
@@ -292,9 +333,135 @@ describe('createContactTools', () => {
       sessionID: 'ses_1',
       title: 'Login',
     });
+    expect(assigned.terminate).toBe(true);
     expect(onCard).toHaveBeenCalledTimes(3);
   });
 
+  it('forwards server turn file parts on assign and keeps model selection in the tool args', async () => {
+    const image = { type: 'file', mime: 'image/png', url: 'data:image/png;base64,aa', filename: 'shot.png' };
+    const assignWork = vi.fn(async (params) => ({
+      sessionID: 'ses_img',
+      directory: '/repo',
+      title: 'Shot',
+      status: 'busy',
+      model: { providerID: params.providerID, modelID: params.modelID },
+    }));
+    const tools = createContactTools({
+      assignWork,
+      turnFileParts: [image],
+      turnAttachmentScope: attachmentScopeKey([image]),
+    });
+    const result = await tools.find((tool) => tool.name === ASSIGN_SESSION_TOOL_NAME).execute('call_img', {
+      prompt: 'Fix card width',
+      projectPath: '/repo',
+      providerID: 'xai',
+      modelID: 'grok-4.6',
+    });
+    expect(assignWork).toHaveBeenCalledWith(expect.objectContaining({
+      prompt: 'Fix card width',
+      providerID: 'xai',
+      modelID: 'grok-4.6',
+      fileParts: [image],
+    }));
+    expect(result.terminate).toBe(true);
+  });
+
+  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 assign gate treats different worker models as distinct requests after success', async () => {
+    const assignWork = vi.fn(async () => ({
+      sessionID: 'ses_model',
+      directory: '/repo',
+      title: 'M',
+      status: 'busy',
+    }));
+    const tools = createContactTools({ assignWork });
+    const assign = tools.find((tool) => tool.name === ASSIGN_SESSION_TOOL_NAME);
+    await assign.execute('call_1', { prompt: 'Fix', projectPath: '/repo', model: 'xai/grok-4.6' });
+    const second = await assign.execute('call_2', { prompt: 'Fix', projectPath: '/repo', model: 'openai/gpt-4o' });
+    expect(second.details.error).toBe('validation_error');
+    expect(assignWork).toHaveBeenCalledTimes(1);
+  });
+
+  it('prompt_ambiguous keeps recoverable sessionID/messageID and blocks a different create this turn', async () => {
+    let calls = 0;
+    const assignWork = vi.fn(async (params) => {
+      calls += 1;
+      if (calls === 1) {
+        throw new AssignError(
+          ASSIGN_CODES.PROMPT_AMBIGUOUS,
+          'admission unknown',
+          { ambiguous: true, sessionID: 'ses_amb', messageID: 'msg_amb' },
+        );
+      }
+      expect(params.sessionID).toBe('ses_amb');
+      expect(params.messageID).toBe('msg_amb');
+      return { sessionID: 'ses_amb', directory: '/repo', title: 'A', status: 'busy', messageID: 'msg_amb' };
+    });
+    const tools = createContactTools({ assignWork });
+    const assign = tools.find((tool) => tool.name === ASSIGN_SESSION_TOOL_NAME);
+    const args = { prompt: 'Fix', projectPath: '/repo' };
+    const failed = await assign.execute('call_a', args);
+    expect(failed.details).toMatchObject({
+      error: 'prompt_ambiguous',
+      ambiguous: true,
+      sessionID: 'ses_amb',
+      messageID: 'msg_amb',
+    });
+    expect(failed.terminate).toBe(true);
+    const other = await assign.execute('call_b', { prompt: 'Other', projectPath: '/repo' });
+    expect(other.details.error).toBe('validation_error');
+    expect(assignWork).toHaveBeenCalledTimes(1);
+    const recovered = await assign.execute('call_c', args);
+    expect(assignWork).toHaveBeenCalledTimes(2);
+    expect(recovered.details.assigned.sessionID).toBe('ses_amb');
+    expect(recovered.terminate).toBe(true);
+  });
+
+  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/contracts.js

@@ -1,8 +1,8 @@
 export const assistantContractFixtures = Object.freeze({
-  assistant: Object.freeze({ id: 'assistant_fixture', revision: 4, enabled: true, name: 'Fixture', defaultPrompt: '', workspacePath: null, managedWorkspacePath: '/data/assistant-workspaces/assistant_fixture', effectiveWorkspacePath: '/workspace', providerID: 'provider_fixture', modelID: 'model_fixture', agent: null, variant: null, mode: 'continuous', sessionID: 'ses_fixture', sessionGeneration: 4, historySessionIDs: Object.freeze([]), historySessionCount: 0, assignedSessionIDs: Object.freeze([]), working: false, createdAt: 1234, updatedAt: 1234, tombstoneAt: null }),
+  assistant: Object.freeze({ id: 'assistant_fixture', revision: 4, enabled: true, name: 'Fixture', defaultPrompt: '', workspacePath: null, managedWorkspacePath: '/data/assistant-workspaces/assistant_fixture', effectiveWorkspacePath: '/workspace', providerID: 'provider_fixture', modelID: 'model_fixture', agent: null, variant: null, mode: 'continuous', sessionID: 'ses_fixture', sessionGeneration: 4, historySessionIDs: Object.freeze([]), historySessionCount: 0, assignedSessionIDs: Object.freeze([]), working: false, activeContactTurn: null, createdAt: 1234, updatedAt: 1234, tombstoneAt: null }),
   sessionBinding: Object.freeze({ sessionID: 'ses_fixture', directory: '/workspace', sessionGeneration: 4 }),
   compactResponse: Object.freeze({ binding: Object.freeze({ sessionID: 'ses_fixture', directory: '/workspace', sessionGeneration: 4 }), summarized: true }),
-  messageAdmission: Object.freeze({ binding: Object.freeze({ sessionID: 'ses_fixture', directory: '/workspace', sessionGeneration: 4 }), messageID: 'msg_fixture', admitted: true }),
+  messageAdmission: Object.freeze({ binding: Object.freeze({ sessionID: 'ses_fixture', directory: '/workspace', sessionGeneration: 4 }), messageID: 'msg_fixture', admitted: true, revision: 4 }),
   abortResponse: Object.freeze({ binding: Object.freeze({ sessionID: 'ses_fixture', directory: '/workspace', sessionGeneration: 4 }), aborted: true }),
   shareOperation: Object.freeze({ operationID: 'share_fixture', assistantID: 'assistant_fixture', sessionID: 'ses_fixture', messageID: 'msg_fixture', state: 'running', phase: 'submitted', attempt: 1, leaseExpiresAt: 1234, errorCode: null }),
   historicalMessages: Object.freeze({ entries: Object.freeze([Object.freeze({ sessionID: 'ses_fixture', directory: null, info: Object.freeze({ id: 'msg_fixture', sessionID: 'ses_fixture', role: 'assistant', time: Object.freeze({ created: 1234 }) }), parts: Object.freeze([]) })]), nextCursor: null, complete: true }),

package/server/lib/assistants/harness.js

@@ -9,6 +9,7 @@ import {
   detectRequestedContactTools,
   extractContactCardsFromMessages,
   formatContactToolsPrompt,
+  formatConnectedModelsPrompt,
   formatRegisteredProjectsPrompt,
   MISSED_FENCE_RETRY_USER_TEXT,
   MISSED_TOOL_FAILURE_BUBBLE,
@@ -79,7 +80,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. Optional worker model via providerID/modelID/model from the connected catalog — that does not change this contact. Current-turn user attachments are server-forwarded on assign. 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 +260,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 [];
         });
@@ -455,6 +466,7 @@ export async function runContactTurn({
   createChatCompletion,
   tools = [],
   projects = [],
+  connectedModels = [],
   onTextDelta = null,
   onBubbleDelta = null,
   globalEventHub = null,
@@ -473,8 +485,13 @@ 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),
+      formatConnectedModelsPrompt(connectedModels),
       formatContactToolsPrompt(contactTools),
       assistant.defaultPrompt,
     ].filter((value) => typeof value === 'string' && value.trim()).join('\n\n');