@openchambery/web 1.19.13 → 1.19.15-beta.1

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,6 +279,76 @@ 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.
@@ -408,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);
@@ -420,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)
@@ -428,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}`
@@ -638,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;
@@ -658,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

@@ -9,9 +9,11 @@ import {
   attachmentScopeKey,
   buildAssignParts,
   extractAssignSessionModel,
+  extractSessionDirectory,
   hasAssignImageParts,
   isAmbiguousPromptFailure,
   isManagedAssistantWorkspace,
+  mapSessionToWatchStatus,
   normalizeAssignSessionModel,
   requireProvidedString,
   resolveAssignDirectory,
@@ -65,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 },
@@ -209,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',
@@ -526,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.