aicodeman 1.24.7 → 1.26.0

package/dist/web/routes/session-routes.js

@@ -19,7 +19,8 @@ import { ownerLayoutKey } from '../../tab-layout-persistence.js';
 import { TabLayoutValidationError } from '../../tab-layout.js';
 import { sessionWaits, resolveWaitSignals, sessionHookOptions, signalForStatus, WaitCapacityError, } from '../session-wait-registry.js';
 import { clampWaitMs, MAX_BUFFER_SCAN_BYTES } from '../../config/agent-wait.js';
-import { autoConfigureRalph, canAccessOwned, CASES_DIR, findPersistedSessionOrFail, findSessionOrFail, getAuthUser, isAdmin, isWorkingDirAllowed, ownerFor, parseBody, persistAndBroadcastSession, resolveCasesDir, resolveParentSessionId, sessionCapacityMessage, SETTINGS_PATH, validatePathWithinBase, } from '../route-helpers.js';
+import { autoConfigureRalph, canAccessOwned, CASES_DIR, findPersistedSessionOrFail, findSessionOrFail, getAuthUser, isAdmin, isWorkingDirAllowed, ownerFor, parseBody, persistAndBroadcastSession, resolveAgentCaseOrigin, resolveCasesDir, resolveParentSessionId, sessionCapacityMessage, SETTINGS_PATH, validatePathWithinBase, } from '../route-helpers.js';
+import { buildAgentCaseMarker, writeAgentCaseMarker } from '../../agent-case-marker.js';
 import { canUsernameRunPrivilegedCommands, resolveClaudeModeForUsername } from '../../user-store.js';
 import { enabledClis, getCli } from '../../config/cli-registry/registry.js';
 import { resolveCliLaunchError } from '../../utils/cli-launcher.js';
@@ -38,7 +39,7 @@ import { MAX_INPUT_LENGTH, MAX_SESSION_NAME_LENGTH } from '../../config/terminal
 import { MAX_PASTE_IMAGE_BYTES } from '../../config/buffer-limits.js';
 import { dataPath, getDataDir } from '../../config/instance.js';
 import { checkRemoteTmuxAvailable, readRemoteCases, readRemoteHosts, toAttachedSessionRemote, toSessionRemote, } from '../../remote-hosts.js';
-import { checkDockerAvailable, checkDockerConfigDrift, checkDockerTmuxAvailable, ensureAgentBaseImage, DEFAULT_AGENT_IMAGE, persistDockerCaseClaudeSessionId, readDockerCases, readDockerHosts, toSessionDocker, } from '../../docker-hosts.js';
+import { checkDockerAvailable, checkDockerConfigDrift, probeAdoptableContainer, checkDockerTmuxAvailable, ensureAgentBaseImage, DEFAULT_AGENT_IMAGE, persistDockerCaseClaudeSessionId, readDockerCases, readDockerHosts, toSessionDocker, } from '../../docker-hosts.js';
 import { LRUMap } from '../../utils/lru-map.js';
 import { findLatestOmpSessionId } from '../../utils/omp-session-resolver.js';
 import { scanOmpSessionsHistory } from '../../omp-transcript.js';
@@ -1552,9 +1553,18 @@ export function registerSessionRoutes(app, ctx) {
     // turn behind beats a viewer showing someone else's conversation.
     const claudeHistoryPinCache = new LRUMap({ maxSize: 1024 });
     async function resolveActiveClaudeSessionIdFromHistory(session, projectsDir) {
+        // A pane whose conversation id came from its OWN hook needs no correlation:
+        // $CODEMAN_SESSION_ID (the pane's env) -> data.session_id (the CLI's own
+        // stdin JSON) is a first-hand binding that never looks at cwd, so it cannot
+        // be stolen by a sibling pane, a closed tab, or a bare `claude` in a
+        // terminal. Guessing can only be worse than the fact. This is also what
+        // closes the hole below for a pane driven straight from tmux: it never
+        // reaches `if (!submitAt)`.
+        if (session.claudeSessionIdIsFirstHand)
+            return null;
         const submitAt = session.lastSubmitAt;
         if (!submitAt)
-            return null; // never typed through Codeman — nothing to credit
+            return null; // no anchor at all — nothing to credit
         const cached = claudeHistoryPinCache.get(session.id);
         if (cached && cached.submitAt === submitAt)
             return cached.claudeSessionId;
@@ -1652,17 +1662,40 @@ export function registerSessionRoutes(app, ctx) {
         return /^(?:<local-command|<command-name>|<task-notification>|<system-reminder>|<teammate-message\b|Another Claude session sent a message:|Base directory for this skill:)/i.test(text);
     }
     /**
-     * Claude writes one logical turn as many JSONL rows: text, thinking and tool
-     * blocks share message ids, while tool results are represented as user rows.
-     * Build viewer cards from real user boundaries instead of treating every row
-     * as a separate chat message.
+     * Claude writes an append-only event log: tool results arrive as user rows,
+     * thinking/tool_use rows carry no text, and a prompt typed while the agent is
+     * working is only ever recorded as an `attachment/queued_command` row. But one
+     * assistant row IS one whole model message: measured across ~/.claude/projects
+     * (CLI 2.1.220-2.1.251) no assistant row carries more than one content block
+     * and no message id carries more than one text block, so there is nothing to
+     * reassemble. Emit one card per row and group them with `turn` instead of
+     * concatenating a human turn's replies into a single card (#169), which fused
+     * up to 74 distinct model messages into one card. Splitting is safe for
+     * markdown: no adjacent pair of assistant text rows in the corpus continues a
+     * table, a list, or an open code fence.
      */
     function parseClaudeResponseTranscript(content, full) {
         let lastText = '';
         let lastTimestamp = '';
         const messages = [];
-        let currentUserFragments = new Set();
-        let currentAssistantFragments = new Set();
+        // #169's replay guards, kept: they now SKIP a duplicated row instead of
+        // concatenating it into the previous card.
+        const currentUserFragments = new Set();
+        const currentAssistantFragments = new Set();
+        // Turn 0 is reserved for anything emitted before the first human prompt.
+        let turn = 0;
+        const pushUserMessage = (text, timestamp, queued) => {
+            // A run of consecutive human inputs (a mid-turn queued burst) is ONE turn,
+            // so the viewer renders it under one badge instead of one badge per line.
+            if (messages.at(-1)?.role !== 'user')
+                turn += 1;
+            const message = { kind: 'prompt', label: 'Prompt', role: 'user', text, timestamp, turn };
+            if (queued)
+                message.queued = true;
+            messages.push(message);
+            currentUserFragments.add(text);
+            currentAssistantFragments.clear();
+        };
         for (const line of content.split('\n')) {
             if (!line)
                 continue;
@@ -1677,6 +1710,30 @@ export function registerSessionRoutes(app, ctx) {
             // rows include repeated image dimensions and other UI-generated context.
             if (entry.isSidechain)
                 continue;
+            // A prompt typed while Claude is working is absorbed mid-turn and lives
+            // ONLY in an attachment row, so it was lost outright. `origin.kind` and
+            // `commandMode` separate the human's queue entries from the CLI's own:
+            // measured over 57 real transcripts on 2026-09-01, 322 queued_command rows
+            // split 163 `prompt`/`human` and 159 `task-notification`, and not one of
+            // those 159 carries an `origin` key. The 163 human rows become 162 user
+            // cards here — one is a verbatim repeat inside a still-unanswered user run
+            // and is collapsed by the dedup guard below — out of 353 user cards total.
+            if (entry.type === 'attachment') {
+                if (!full)
+                    continue;
+                const queued = entry.attachment;
+                if (!queued || queued.type !== 'queued_command')
+                    continue;
+                if (queued.origin?.kind !== 'human' || queued.commandMode !== 'prompt')
+                    continue;
+                const text = typeof queued.prompt === 'string' ? queued.prompt.trim() : '';
+                if (!text || isClaudeSyntheticUserMessage(entry, text))
+                    continue;
+                if (currentUserFragments.has(text))
+                    continue;
+                pushUserMessage(text, queued.timestamp || entry.timestamp, true);
+                continue;
+            }
             if (entry.type === 'user') {
                 const text = extractClaudeText(entry.message?.content, '\n').trim();
                 // A tool_result block has no text block and naturally drops out here.
@@ -1684,21 +1741,13 @@ export function registerSessionRoutes(app, ctx) {
                     continue;
                 if (!full)
                     continue;
-                const previous = messages.at(-1);
-                if (previous?.role === 'user') {
-                    // Claude can replay the initial user row while restoring a transcript.
-                    // Only collapse duplicates within the same unanswered user turn; the
-                    // same prompt after an assistant response remains a legitimate turn.
-                    if (currentUserFragments.has(text))
-                        continue;
-                    previous.text += `\n\n${text}`;
-                    currentUserFragments.add(text);
-                }
-                else {
-                    messages.push({ role: 'user', text, timestamp: entry.timestamp });
-                    currentUserFragments = new Set([text]);
-                }
-                currentAssistantFragments.clear();
+                // Claude replays the initial user row while restoring a transcript, and
+                // a CLI that also wrote an absorbed prompt as a user row would double it.
+                // Both collapse here. The same prompt sent again AFTER a reply is a
+                // legitimate second turn, because that reply cleared the set.
+                if (currentUserFragments.has(text))
+                    continue;
+                pushUserMessage(text, entry.timestamp, false);
                 continue;
             }
             if (entry.type !== 'assistant')
@@ -1710,20 +1759,11 @@ export function registerSessionRoutes(app, ctx) {
             lastTimestamp = entry.timestamp || '';
             if (!full)
                 continue;
-            const previous = messages.at(-1);
-            if (previous?.role === 'assistant') {
-                // Replayed snapshots sometimes repeat an identical text block. Distinct
-                // progress/final blocks are kept, but remain inside one Claude card.
-                if (currentAssistantFragments.has(text))
-                    continue;
-                previous.text += `\n\n${text}`;
-                previous.timestamp = entry.timestamp || previous.timestamp;
-                currentAssistantFragments.add(text);
-            }
-            else {
-                messages.push({ role: 'assistant', text, timestamp: entry.timestamp });
-                currentAssistantFragments = new Set([text]);
-            }
+            // Replayed snapshots repeat an identical text block inside one turn.
+            if (currentAssistantFragments.has(text))
+                continue;
+            messages.push({ kind: 'response', label: 'Response', role: 'assistant', text, timestamp: entry.timestamp, turn });
+            currentAssistantFragments.add(text);
             currentUserFragments.clear();
         }
         return full ? { text: lastText, timestamp: lastTimestamp, messages } : { text: lastText, timestamp: lastTimestamp };
@@ -2527,7 +2567,10 @@ export function registerSessionRoutes(app, ctx) {
         const capMsg = sessionCapacityMessage(ctx.sessions, owner);
         if (capMsg)
             return createErrorResponse(ApiErrorCode.SESSION_BUSY, capMsg);
-        const { caseName = 'testcase', sessionName, mode = 'claude', modelOverride, openCodeConfig, codexConfig, geminiConfig, antigravityConfig, piConfig, grokConfig, deepSeekConfig, ompConfig, envOverrides, effort, parentSessionId, } = parseBody(QuickStartSchema, req.body);
+        const { caseName = 'testcase', sessionName, mode = 'claude', modelOverride, openCodeConfig, codexConfig, geminiConfig, antigravityConfig, piConfig, grokConfig, deepSeekConfig, ompConfig, envOverrides, effort, parentSessionId, agentOrigin, } = parseBody(QuickStartSchema, req.body);
+        // Resolved ONCE here: the same value labels a case directory this request creates
+        // (agent-case-marker.ts) and draws the tab lineage line on the session below.
+        const qsParentSessionId = resolveParentSessionId(ctx, req, parentSessionId, owner);
         // Multi-user: shell mode is arbitrary host-account execution, gated by the grant.
         // Resolve the owner's grant from the store so a GRANTED regular user is not wrongly denied.
         if (getCli(mode)?.capabilities.privilegedCommandGate && !(await canUsernameRunPrivilegedCommands(owner))) {
@@ -2606,25 +2649,46 @@ export function registerSessionRoutes(app, ctx) {
                 return createErrorResponse(ApiErrorCode.OPERATION_FAILED, availability.error || 'docker daemon is not available');
             }
             const sessionDocker = toSessionDocker(host, dockerCase);
-            // Ensure the base image exists, auto-building the default image on first use so
-            // it is never a blocker. Dedup'd with any build kicked off at case-create, so
-            // this awaits the SAME in-flight build rather than starting a second one.
-            const ensured = await ensureAgentBaseImage(sessionDocker, sessionDocker.image, {
-                onProgress: (line) => ctx.broadcast(SseEvent.DockerImageBuildProgress, { name: dockerCase.name, line }),
-            });
-            if (!ensured.ok) {
-                return createErrorResponse(ApiErrorCode.OPERATION_FAILED, ensured.error || 'base image not available');
-            }
-            if (ensured.built) {
-                ctx.broadcast(SseEvent.DockerImageBuildComplete, { name: dockerCase.name, image: sessionDocker.image });
-            }
-            // tmux is a hard prerequisite (the in-container tmux makes reconnect durable).
-            // Skip the extra container-run probe for our OWN default image (the baked
-            // Dockerfile always contains tmux); still verify a custom image.
-            if (sessionDocker.image !== DEFAULT_AGENT_IMAGE) {
-                const tmuxCheck = await checkDockerTmuxAvailable(sessionDocker);
-                if (!tmuxCheck.ok) {
-                    return createErrorResponse(ApiErrorCode.OPERATION_FAILED, tmuxCheck.error || 'base image is missing tmux');
+            // An ADOPTED container skips every image-side gate: we never run `docker
+            // create`, so the image is the user's business, and `ensureAgentBaseImage`
+            // would build/require an image that has nothing to do with their container.
+            // The prerequisite that DOES still hold is tmux inside it, so probe the live
+            // container (not the image) and refuse before launch rather than dead-paning.
+            if (sessionDocker.owned === false) {
+                const probe = await probeAdoptableContainer(sessionDocker, [mode]);
+                if (!probe.ok) {
+                    return createErrorResponse(ApiErrorCode.OPERATION_FAILED, probe.error || 'container is not usable');
+                }
+                // The probe already exec'd into the container; carry its facts onto the
+                // live session so the launch chain does not have to re-ask.
+                sessionDocker.runsAsRoot = probe.runsAsRoot;
+                // No `mode !== 'shell'` arm: a mode with no binary of its own is reported
+                // available by the probe unconditionally, so this reads the same answer for it.
+                if (!probe.availableModes?.includes(mode)) {
+                    return createErrorResponse(ApiErrorCode.OPERATION_FAILED, `"${mode}" is not installed in container "${sessionDocker.containerName}". Adoption never modifies the container — install it inside, or pick another mode.`);
+                }
+            }
+            else {
+                // Ensure the base image exists, auto-building the default image on first use so
+                // it is never a blocker. Dedup'd with any build kicked off at case-create, so
+                // this awaits the SAME in-flight build rather than starting a second one.
+                const ensured = await ensureAgentBaseImage(sessionDocker, sessionDocker.image, {
+                    onProgress: (line) => ctx.broadcast(SseEvent.DockerImageBuildProgress, { name: dockerCase.name, line }),
+                });
+                if (!ensured.ok) {
+                    return createErrorResponse(ApiErrorCode.OPERATION_FAILED, ensured.error || 'base image not available');
+                }
+                if (ensured.built) {
+                    ctx.broadcast(SseEvent.DockerImageBuildComplete, { name: dockerCase.name, image: sessionDocker.image });
+                }
+                // tmux is a hard prerequisite (the in-container tmux makes reconnect durable).
+                // Skip the extra container-run probe for our OWN default image (the baked
+                // Dockerfile always contains tmux); still verify a custom image.
+                if (sessionDocker.image !== DEFAULT_AGENT_IMAGE) {
+                    const tmuxCheck = await checkDockerTmuxAvailable(sessionDocker);
+                    if (!tmuxCheck.ok) {
+                        return createErrorResponse(ApiErrorCode.OPERATION_FAILED, tmuxCheck.error || 'base image is missing tmux');
+                    }
                 }
             }
             // Config drift (docs/docker-cases-plan.md §4): the desired create-config no
@@ -2716,6 +2780,22 @@ export function registerSessionRoutes(app, ctx) {
                     mode !== 'omp') {
                     await writeHooksConfig(resolvedCasePath);
                 }
+                // Label a directory an AGENT asked us to create, so the scratch workspaces a
+                // long orchestration leaves behind can be told apart from the user's real
+                // projects later (see agent-case-marker.ts). This is the only branch that may
+                // write it: it is the only one that creates the directory, and a pre-existing
+                // case must never be labelled. Best-effort — a failed marker must not fail the
+                // spawn it decorates.
+                const qsAgentOrigin = resolveAgentCaseOrigin(req, agentOrigin, qsParentSessionId);
+                if (qsAgentOrigin) {
+                    await writeAgentCaseMarker(resolvedCasePath, buildAgentCaseMarker({
+                        createdBy: qsAgentOrigin,
+                        parentSessionId: qsParentSessionId,
+                        parentSessionName: qsParentSessionId ? ctx.sessions.get(qsParentSessionId)?.name : undefined,
+                        mode,
+                        owner,
+                    }));
+                }
                 ctx.broadcast(SseEvent.CaseCreated, { name: caseName, path: resolvedCasePath });
             }
             catch (err) {
@@ -2833,7 +2913,7 @@ export function registerSessionRoutes(app, ctx) {
             docker,
             resumeSessionId: dockerResumeId,
             tmuxHistoryLimit: qsTerminalHistoryConfig.tmuxHistoryLimit,
-            parentSessionId: resolveParentSessionId(ctx, req, parentSessionId, owner),
+            parentSessionId: qsParentSessionId,
         });
         // Auto-detect completion phrase from CLAUDE.md BEFORE broadcasting
         // so the initial state already has the phrase configured (only if globally enabled)