@openchambery/web 1.19.13-beta.3 → 1.19.13-beta.5

package/server/lib/assistants/assign.js

@@ -24,6 +24,7 @@ export const ASSIGN_CODES = Object.freeze({
   IMAGE_NOT_SUPPORTED: 'image_not_supported',
   NO_PROVIDER: 'no_provider',
   PROMPT_AMBIGUOUS: 'prompt_ambiguous',
+  NOT_FOUND: 'not_found',
 });
 
 export const PROJECT_REQUIRED_MESSAGE = 'No registered project is configured. Add a project in Settings before assigning work. Do not use assistant-workspaces.';
@@ -136,7 +137,13 @@ function normalizeProjectRoots(allowedRoots = []) {
   const roots = [];
   for (const root of allowedRoots) {
     if (typeof root !== 'string' || !root.trim()) continue;
-    const resolved = path.resolve(root.trim());
+    // realpath so /var vs /private/var (and prior resolveAssignDirectory results) still match.
+    let resolved = path.resolve(root.trim());
+    try {
+      resolved = fs.realpathSync(resolved);
+    } catch {
+      // Keep path.resolve when the root is not yet on disk.
+    }
     if (seen.has(resolved)) continue;
     seen.add(resolved);
     roots.push(resolved);
@@ -146,7 +153,15 @@ function normalizeProjectRoots(allowedRoots = []) {
 
 export function isManagedAssistantWorkspace(candidate, managedWorkspaceRoot) {
   if (!candidate || !managedWorkspaceRoot) return false;
-  return contained(path.resolve(candidate), path.resolve(managedWorkspaceRoot));
+  const realpathOrResolve = (value) => {
+    const resolved = path.resolve(value);
+    try {
+      return fs.realpathSync(resolved);
+    } catch {
+      return resolved;
+    }
+  };
+  return contained(realpathOrResolve(candidate), realpathOrResolve(managedWorkspaceRoot));
 }
 
 export function resolveAssignDirectory({
@@ -177,22 +192,24 @@ export function resolveAssignDirectory({
   const resolveExisting = (candidate) => {
     const raw = trim(candidate, 4096);
     if (!raw) return null;
-    const resolved = path.resolve(raw);
-    rejectManaged(resolved);
-    if (!underRoots(resolved)) {
-      throw new AssignError(
-        ASSIGN_CODES.WORKSPACE_FORBIDDEN,
-        'That path is not a registered project. Add it in Settings, then assign again.',
-      );
-    }
+    let resolved = path.resolve(raw);
     if (!fs.existsSync(resolved) || !fs.statSync(resolved).isDirectory()) {
       throw new AssignError(ASSIGN_CODES.VALIDATION, 'The project directory does not exist.');
     }
     try {
-      return fs.realpathSync(resolved);
+      resolved = fs.realpathSync(resolved);
     } catch {
       throw new AssignError(ASSIGN_CODES.VALIDATION, 'The project directory does not exist.');
     }
+    // Compare realpaths so a prior authoritative resolve cannot fail against non-real roots.
+    rejectManaged(resolved);
+    if (!underRoots(resolved)) {
+      throw new AssignError(
+        ASSIGN_CODES.WORKSPACE_FORBIDDEN,
+        'That path is not a registered project. Add it in Settings, then assign again.',
+      );
+    }
+    return resolved;
   };
 
   let target = resolveExisting(directory) || resolveExisting(projectPath) || resolveExisting(defaultProjectPath);
@@ -262,17 +279,126 @@ export function hasAssignImageParts(parts = []) {
   return sanitizeAssignFileParts(parts).some((part) => String(part.mime).toLowerCase().startsWith('image/'));
 }
 
+/**
+ * Directory from authoritative OpenCode session payload.
+ * Prefer session.directory / path / project.worktree — never invent paths.
+ */
+export function extractSessionDirectory(session) {
+  const payload = session?.data && typeof session.data === 'object' && !Array.isArray(session.data)
+    ? session.data
+    : session;
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return null;
+  return trim(payload.directory, 4096)
+    || trim(payload.path, 4096)
+    || trim(payload.project?.worktree, 4096)
+    || trim(payload.project?.directory, 4096)
+    || trim(payload.project?.path, 4096)
+    || null;
+}
+
+/** Title from session payload or index row. */
+export function extractSessionTitle(session) {
+  const payload = session?.data && typeof session.data === 'object' && !Array.isArray(session.data)
+    ? session.data
+    : session;
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return null;
+  return trim(payload.title, 256) || null;
+}
+
+/**
+ * Map OpenCode session + messages into contact watch/card status.
+ * Used as the baseline when watching an existing session so an already-terminal
+ * idle is not treated as a fresh complete transition.
+ * - busy/retry → busy (in-flight)
+ * - session.error / last assistant error → error
+ * - idle / time.completed / missing session → complete
+ * - otherwise busy (keep watching; never invent complete from silence)
+ */
+export function mapSessionToWatchStatus({
+  session = null,
+  messages = null,
+  missing = false,
+} = {}) {
+  if (missing) return 'complete';
+  const payload = session?.data && typeof session.data === 'object' && !Array.isArray(session.data)
+    ? session.data
+    : session;
+  if (payload?.error) return 'error';
+
+  const statusType = typeof payload?.status?.type === 'string'
+    ? payload.status.type
+    : (typeof payload?.status === 'string'
+      ? payload.status
+      : (typeof payload?.type === 'string' ? payload.type : ''));
+  if (statusType === 'busy' || statusType === 'retry') return 'busy';
+  if (statusType === 'question') return 'question';
+
+  const rows = Array.isArray(messages)
+    ? messages
+    : (Array.isArray(messages?.data) ? messages.data : []);
+  for (let index = rows.length - 1; index >= 0; index -= 1) {
+    const info = rows[index]?.info ?? rows[index];
+    if (info?.role !== 'assistant') continue;
+    if (info?.error) return 'error';
+    if (info?.time?.completed) return 'complete';
+    break;
+  }
+
+  if (statusType === 'idle' || payload?.time?.completed) return 'complete';
+  // No terminal signal — keep in-flight so later idle can settle once.
+  return 'busy';
+}
+
+/**
+ * Normalize a session/message model object to { providerID, modelID }.
+ * Accepts `{ providerID, id }` or `{ providerID, modelID }`. Lookup failures stay null.
+ */
+export function normalizeAssignSessionModel(model) {
+  if (!model || typeof model !== 'object' || Array.isArray(model)) return null;
+  const providerID = trim(model.providerID, 256);
+  const modelID = trim(model.modelID, 256) || trim(model.id, 256);
+  if (!providerID || !modelID) return null;
+  return { providerID, modelID };
+}
+
+/**
+ * Extract the last worker model from a session.get payload and optional messages list.
+ * Priority: session.model → newest user/assistant info.model. Never throws.
+ */
+export function extractAssignSessionModel({ session = null, messages = null } = {}) {
+  const payload = session?.data && typeof session.data === 'object' && !Array.isArray(session.data)
+    ? session.data
+    : session;
+  const fromSession = normalizeAssignSessionModel(payload?.model);
+  if (fromSession) return fromSession;
+
+  const rows = Array.isArray(messages)
+    ? messages
+    : (Array.isArray(messages?.data) ? messages.data : []);
+  for (let index = rows.length - 1; index >= 0; index -= 1) {
+    const row = rows[index];
+    const info = row?.info && typeof row.info === 'object' ? row.info : row;
+    const role = info?.role || row?.role;
+    if (role !== 'user' && role !== 'assistant') continue;
+    const hit = normalizeAssignSessionModel(info?.model || row?.model);
+    if (hit) return hit;
+  }
+  return null;
+}
+
 /**
  * Resolve worker model for assign.
- * - No explicit selection → assistant default (no catalog required).
+ * - No explicit selection → reused session model (catalog match, source session) else assistant default.
  * - Explicit selection → must resolve uniquely against the connected catalog; never silent fallback.
  * - Provided but illegal/blank/overlong/conflicting fields fail closed (validation_error).
+ * - Session model missing/not-in-catalog degrades to assistant default (never fails assign).
  */
 export function resolveAssignWorkerModel({
   providerID,
   modelID,
   model,
   fallback = {},
+  sessionModel = null,
   catalog = null,
 } = {}) {
   const explicitProvider = requireProvidedString(providerID, { field: 'providerID', max: 256 });
@@ -284,6 +410,21 @@ export function resolveAssignWorkerModel({
   const fallbackModel = trim(fallback.modelID, 256);
 
   if (!hasExplicit) {
+    const session = normalizeAssignSessionModel(sessionModel);
+    if (session && catalog && Array.isArray(catalog.models)) {
+      const hit = catalog.models.find((item) => (
+        item?.providerID === session.providerID && item?.modelID === session.modelID
+      ));
+      if (hit) {
+        return {
+          providerID: session.providerID,
+          modelID: session.modelID,
+          source: 'session',
+          name: typeof hit.name === 'string' ? hit.name : null,
+          acceptsImages: hit.acceptsImages === true ? true : hit.acceptsImages === false ? false : null,
+        };
+      }
+    }
     if (!fallbackProvider || !fallbackModel) {
       throw new AssignError(ASSIGN_CODES.VALIDATION, 'Assistant is missing a connected provider/model.');
     }
@@ -354,7 +495,7 @@ export function resolveAssignWorkerModel({
   }
 
   const models = catalog.models.filter((entry) => entry && typeof entry === 'object');
-  const matches = models.filter((entry) => {
+  let matches = models.filter((entry) => {
     const entryProvider = trim(entry.providerID, 256);
     const entryModel = trim(entry.modelID, 256);
     const entryName = trim(entry.name, 512);
@@ -366,6 +507,7 @@ export function resolveAssignWorkerModel({
       return entryProvider === wantedProvider;
     }
     if (!wantedProvider && wantedModel) {
+      if (explicitModel) return entryModel === wantedModel;
       const needle = wantedModel.toLowerCase();
       return entryModel.toLowerCase() === needle
         || (entryName && entryName.toLowerCase() === needle)
@@ -374,6 +516,19 @@ export function resolveAssignWorkerModel({
     return false;
   });
 
+  // Only the informal `model` alias gets fuzzy matching. Explicit IDs remain exact.
+  if (matches.length === 0 && combined && !combined.includes('/') && !explicitModel) {
+    const normalize = (value) => trim(value, 512).toLowerCase().replace(/[^\p{L}\p{N}]/gu, '');
+    const needle = normalize(combined);
+    const eligible = models.filter((entry) => !wantedProvider || entry.providerID === wantedProvider);
+    if (needle.length >= 2) {
+      const exact = eligible.filter((entry) => normalize(entry.modelID) === needle || normalize(entry.name) === needle);
+      matches = exact.length > 0 ? exact : eligible.filter((entry) => (
+        normalize(entry.modelID).includes(needle) || normalize(entry.name).includes(needle)
+      ));
+    }
+  }
+
   if (matches.length === 0) {
     const label = wantedProvider && wantedModel
       ? `${wantedProvider}/${wantedModel}`
@@ -534,6 +689,7 @@ export async function assignSession(input = {}) {
         providerID: assistant.providerID,
         modelID: assistant.modelID,
       },
+      sessionModel: input.sessionModel,
       catalog: input.catalog,
     });
   }
@@ -583,6 +739,7 @@ export async function assignSession(input = {}) {
     throw new AssignError(ASSIGN_CODES.UPSTREAM, 'Worker session APIs are unavailable.');
   }
 
+  input.signal?.throwIfAborted();
   let targetSessionID = sessionID;
   if (!targetSessionID) {
     let created;
@@ -603,6 +760,9 @@ export async function assignSession(input = {}) {
     }
   }
 
+  // A cancelled contact must not submit work after a late create response.
+  // Retain that session: creation succeeded, and cancellation is not deletion.
+  input.signal?.throwIfAborted();
   let prompted;
   let promptError;
   try {

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

@@ -8,9 +8,13 @@ import {
   assignSession,
   attachmentScopeKey,
   buildAssignParts,
+  extractAssignSessionModel,
+  extractSessionDirectory,
   hasAssignImageParts,
   isAmbiguousPromptFailure,
   isManagedAssistantWorkspace,
+  mapSessionToWatchStatus,
+  normalizeAssignSessionModel,
   requireProvidedString,
   resolveAssignDirectory,
   resolveAssignWorkerModel,
@@ -63,6 +67,22 @@ describe('resolveAssignDirectory', () => {
 });
 
 describe('requireProvidedString / resolveAssignWorkerModel', () => {
+  it('resolves a unique informal alias while keeping explicit ids exact and ambiguity closed', () => {
+    const catalog = { models: [
+      { providerID: 'a', modelID: 'claude-sonnet-4-6', name: 'Claude Sonnet 4.6' },
+      { providerID: 'a', modelID: 'gpt-5.4', name: 'GPT 5.4' },
+      { providerID: 'b', modelID: 'gpt-5.4-mini', name: 'GPT 5.4 Mini' },
+    ] }
+    expect(resolveAssignWorkerModel({ model: 'sonnet 4.6', catalog }).modelID).toBe('claude-sonnet-4-6')
+    expect(resolveAssignWorkerModel({ model: 'gpt54', catalog }).modelID).toBe('gpt-5.4')
+    expect(() => resolveAssignWorkerModel({ model: 'gpt', catalog })).toThrow(/Several connected models/)
+    expect(() => resolveAssignWorkerModel({ providerID: 'a', modelID: 'sonnet 4.6', catalog })).toThrow(/No connected/)
+    expect(() => resolveAssignWorkerModel({ model: 'made-up-model', catalog })).toThrow(/No connected/)
+    expect(() => resolveAssignWorkerModel({ modelID: 'GPT 5.4', catalog })).toThrow(/No connected/)
+    expect(resolveAssignWorkerModel({ providerID: 'a', model: 'gpt', catalog }).modelID).toBe('gpt-5.4')
+    expect(() => resolveAssignWorkerModel({ model: 'sonnet', catalog: { models: [catalog.models[0], { ...catalog.models[0], providerID: 'b' }] } })).toThrow(/Several connected models/)
+  })
+
   const catalog = {
     models: [
       { providerID: 'openai', modelID: 'gpt-4o', name: 'GPT-4o', acceptsImages: true },
@@ -84,6 +104,64 @@ describe('requireProvidedString / resolveAssignWorkerModel', () => {
     });
   });
 
+  it('prefers a catalog-matched session model over the assistant default', () => {
+    expect(normalizeAssignSessionModel({ providerID: 'xai', id: 'grok-4.6' })).toEqual({
+      providerID: 'xai',
+      modelID: 'grok-4.6',
+    });
+    expect(extractAssignSessionModel({
+      session: { model: { providerID: 'xai', id: 'grok-4.6' } },
+    })).toEqual({ providerID: 'xai', modelID: 'grok-4.6' });
+    expect(extractAssignSessionModel({
+      messages: [
+        { info: { role: 'user', model: { providerID: 'openai', modelID: 'gpt-4o' } } },
+        { info: { role: 'assistant', model: { providerID: 'xai', id: 'grok-4.6' } } },
+      ],
+    })).toEqual({ providerID: 'xai', modelID: 'grok-4.6' });
+    expect(resolveAssignWorkerModel({
+      sessionModel: { providerID: 'xai', modelID: 'grok-4.6' },
+      fallback: { providerID: 'p', modelID: 'm' },
+      catalog,
+    })).toMatchObject({
+      providerID: 'xai',
+      modelID: 'grok-4.6',
+      source: 'session',
+      acceptsImages: true,
+    });
+  });
+
+  it('degrades to the assistant model when the session model is missing from catalog', () => {
+    expect(resolveAssignWorkerModel({
+      sessionModel: { providerID: 'missing', modelID: 'gone' },
+      fallback: { providerID: 'p', modelID: 'm' },
+      catalog,
+    })).toEqual({
+      providerID: 'p',
+      modelID: 'm',
+      source: 'assistant',
+      name: null,
+      acceptsImages: null,
+    });
+    expect(resolveAssignWorkerModel({
+      sessionModel: { providerID: 'xai', modelID: 'grok-4.6' },
+      fallback: { providerID: 'p', modelID: 'm' },
+      catalog: null,
+    }).source).toBe('assistant');
+  });
+
+  it('keeps explicit model fail-closed over a session model', () => {
+    expect(resolveAssignWorkerModel({
+      model: 'openai/gpt-4o',
+      sessionModel: { providerID: 'xai', modelID: 'grok-4.6' },
+      fallback: { providerID: 'p', modelID: 'm' },
+      catalog,
+    })).toMatchObject({
+      providerID: 'openai',
+      modelID: 'gpt-4o',
+      source: 'explicit',
+    });
+  });
+
   it('resolves explicit provider/model against the connected catalog', () => {
     expect(resolveAssignWorkerModel({
       model: 'xai/grok-4.6',
@@ -149,6 +227,25 @@ describe('requireProvidedString / resolveAssignWorkerModel', () => {
 });
 
 describe('resolveAssignWorkerVariant', () => {
+  it('does not submit or delete a session whose create completes after cancellation', async () => {
+    const directory = root();
+    const controller = new AbortController();
+    const promptExisting = vi.fn();
+    const deleteSession = vi.fn();
+    const createSession = vi.fn(async () => {
+      controller.abort();
+      return { data: { id: 'ses_created' } };
+    });
+    await expect(assignSession({
+      prompt: 'Fix', directory, assistant: { providerID: 'p', modelID: 'm' },
+      allowedRoots: [directory], managedWorkspaceRoot: path.join(directory, 'assistant-workspaces'),
+      createSession, promptExisting, deleteSession, signal: controller.signal,
+    })).rejects.toMatchObject({ name: 'AbortError' });
+    expect(createSession).toHaveBeenCalledTimes(1);
+    expect(promptExisting).not.toHaveBeenCalled();
+    expect(deleteSession).not.toHaveBeenCalled();
+  });
+
   it('reuses assistant variant only for same/default model; drops it cross-model', () => {
     expect(resolveAssignWorkerVariant({
       source: 'assistant',
@@ -466,4 +563,46 @@ describe('assignSession', () => {
     expect(deleteSession).not.toHaveBeenCalled();
     expect(promptExisting).toHaveBeenCalledWith(expect.objectContaining({ sessionID: 'ses_existing' }));
   });
+
+  it('mapSessionToWatchStatus baselines terminal idle without inventing busy', () => {
+    expect(mapSessionToWatchStatus({
+      session: { id: 'ses_1', status: { type: 'idle' }, time: { completed: 1 } },
+      messages: [{ info: { role: 'assistant', time: { completed: 1 } } }],
+    })).toBe('complete');
+    expect(mapSessionToWatchStatus({
+      session: { id: 'ses_2', status: { type: 'busy' } },
+    })).toBe('busy');
+    expect(mapSessionToWatchStatus({
+      session: { id: 'ses_3', error: { message: 'boom' } },
+    })).toBe('error');
+    expect(mapSessionToWatchStatus({ missing: true })).toBe('complete');
+    expect(extractSessionDirectory({
+      directory: '/repo/app',
+      project: { worktree: '/other' },
+    })).toBe('/repo/app');
+    expect(extractSessionDirectory({
+      project: { worktree: '/repo/wt' },
+    })).toBe('/repo/wt');
+  });
+
+  it('resolveAssignDirectory accepts a realpath candidate against non-realpath allowed roots', () => {
+    const directory = root();
+    const project = path.join(directory, 'app');
+    fs.mkdirSync(project, { recursive: true });
+    const realProject = fs.realpathSync(project);
+    // First resolve returns realpath; second call with the same realpath must still pass.
+    const first = resolveAssignDirectory({
+      directory: project,
+      allowedRoots: [directory],
+      managedWorkspaceRoot: path.join(directory, 'assistant-workspaces'),
+    });
+    expect(first).toBe(realProject);
+    const second = resolveAssignDirectory({
+      directory: realProject,
+      projectPath: realProject,
+      allowedRoots: [directory],
+      managedWorkspaceRoot: path.join(directory, 'assistant-workspaces'),
+    });
+    expect(second).toBe(realProject);
+  });
 });

package/server/lib/assistants/bubbles.js

@@ -1,5 +1,5 @@
 const SENTENCE = /(?<=[.!?])\s+(?=[A-Z“"‘])/u;
-const CONTACT_PLANNING = /\b(let me think|i should|i need to|i'll call|i will call|the user (said|wants|asked)|actually,?|hmm\.?|assign_session|list_projects|list_sessions|create_assistant|schedule_task|tool call|projectPath)\b/i;
+const CONTACT_PLANNING = /\b(let me think|i should|i need to|i'll call|i will call|the user (said|wants|asked)|actually,?|hmm\.?|assign_session|watch_session|stop_session|list_projects|list_sessions|create_assistant|schedule_task|tool call|projectPath)\b/i;
 
 /**
  * A short spoken contact line (not chain-of-thought). Shown before a tool and kept.