@myagentroam/node 0.11.1 → 0.11.3

package/dist/runner/codex/managed-run-controller.js

@@ -6,7 +6,7 @@ import { safeErrorCode } from '../../util/safe-error.js';
 import { runnerErrorProjection } from '../../util/runner-error.js';
 import { ResponseLatencyTracker } from '../../service/response-latency-tracker.js';
 import { GenerationTimingTracker } from '../../service/generation-timing-tracker.js';
-import { boundedConversationItemId, codexImageAttachments, codexLiveConversationItem, CodexUsageNormalizer, codexUserInputQuestions, compactRunnerText, isPlainRecord } from './conversation-parser.js';
+import { boundedConversationItemId, codexImageAttachments, codexLiveConversationItem, codexSourceItemId, CodexUsageNormalizer, codexUserInputQuestions, compactRunnerText, isPlainRecord } from './conversation-parser.js';
 export function resolveCodexNotificationRun(runs, input) {
     const entries = [...runs.entries()];
     if (input.turnId !== undefined) {
@@ -35,6 +35,15 @@ export class CodexManagedRunController {
         this.runner = runner;
         this.host = host;
     }
+    emitItem(runId, item) {
+        const nativeTurnId = this.runner.execution.runs.get(runId)?.turnId;
+        this.host.emitItem(runId, nativeTurnId === undefined
+            ? item
+            : {
+                ...item,
+                sourceItemId: codexSourceItemId(nativeTurnId, item.itemId)
+            });
+    }
     async executeCommand(session, command, input, context) {
         if (command.id === 'plan') {
             const environmentLeaseId = crypto.randomUUID();
@@ -222,6 +231,9 @@ export class CodexManagedRunController {
                 : undefined;
             this.host.emit(runId, 'text.delta', {
                 text: params.delta,
+                ...(itemId === undefined || turnId === undefined
+                    ? {}
+                    : { sourceItemId: codexSourceItemId(turnId, itemId) }),
                 ...(itemId === undefined ? {} : { itemId })
             });
             if (params.delta.length > 0)
@@ -245,11 +257,14 @@ export class CodexManagedRunController {
             const index = typeof params.summaryIndex === 'number' && Number.isInteger(params.summaryIndex)
                 ? params.summaryIndex
                 : 0;
-            this.host.emitItem(runId, {
+            this.emitItem(runId, {
                 itemId: boundedConversationItemId('codex', params.itemId),
-                kind: 'reasoning_summary',
+                kind: 'reasoning',
                 status: 'IN_PROGRESS',
-                payload: { sections: [{ index, text: compactRunnerText(params.delta, 10_000) }] },
+                payload: {
+                    representation: 'summary',
+                    sections: [{ index, text: compactRunnerText(params.delta, 10_000) }]
+                },
                 merge: true,
                 append: 'sections'
             });
@@ -262,7 +277,7 @@ export class CodexManagedRunController {
         if (notification.method === 'item/commandExecution/outputDelta' &&
             typeof params.itemId === 'string' &&
             typeof params.delta === 'string') {
-            this.host.emitItem(runId, {
+            this.emitItem(runId, {
                 itemId: boundedConversationItemId('codex', params.itemId),
                 kind: 'command_execution',
                 status: 'IN_PROGRESS',
@@ -275,7 +290,7 @@ export class CodexManagedRunController {
         if (notification.method === 'item/mcpToolCall/progress' &&
             typeof params.itemId === 'string' &&
             typeof params.message === 'string') {
-            this.host.emitItem(runId, {
+            this.emitItem(runId, {
                 itemId: boundedConversationItemId('codex', params.itemId),
                 kind: 'tool_call',
                 status: 'IN_PROGRESS',
@@ -289,7 +304,7 @@ export class CodexManagedRunController {
             const attachments = this.host.appendImages(runId, codexImageAttachments(params.item));
             const item = codexLiveConversationItem(params.item, notification.method === 'item/completed', attachments);
             if (item !== undefined) {
-                this.host.emitItem(runId, item);
+                this.emitItem(runId, item);
                 if (item.kind === 'context_compaction') {
                     activeRun.generationCompacting = notification.method === 'item/started';
                     if (activeRun.generationCompacting) {
@@ -317,7 +332,7 @@ export class CodexManagedRunController {
                             this.host.emit(runId, 'run.performance', { latencyMs });
                     }
                 }
-                else if (['assistant_message', 'reasoning_summary', 'plan'].includes(item.kind)) {
+                else if (['assistant_message', 'reasoning', 'plan'].includes(item.kind)) {
                     // A started reasoning item is itself a semantic response, even before its summary.
                     if (notification.method === 'item/started')
                         this.beginGeneration(runId, receiptAt);
@@ -527,7 +542,7 @@ export class CodexManagedRunController {
                 allowOther: question.allowOther
             }))
         });
-        this.host.emitItem(runId, {
+        this.emitItem(runId, {
             itemId: boundedConversationItemId('codex-input', requestId),
             kind: 'user_input_request',
             status: 'PENDING',
@@ -722,7 +737,7 @@ export class CodexManagedRunController {
     }
     emitError(runId, error, fallbackCode) {
         const projected = runnerErrorProjection(error, fallbackCode);
-        this.host.emitItem(runId, {
+        this.emitItem(runId, {
             itemId: boundedConversationItemId('runner-error', runId),
             kind: 'error',
             status: 'FAILED',

package/dist/runner/mar-agent/conversation-normalizer.js

@@ -52,11 +52,11 @@ export class MarAgentConversationNormalizer {
                 }
             ];
         }
-        if (event.type === 'message.completed') {
+        if (event.type === 'message.started' || event.type === 'message.completed') {
             const modelName = record(event)?.modelName;
             const itemId = this.messageItemId(event.itemId);
             const payload = {
-                text: event.text,
+                text: event.type === 'message.completed' ? event.text : '',
                 format: 'markdown',
                 model: typeof modelName === 'string' ? modelName : null
             };
@@ -64,7 +64,7 @@ export class MarAgentConversationNormalizer {
                 {
                     itemId,
                     kind: 'assistant_message',
-                    status: 'COMPLETED',
+                    status: event.type === 'message.completed' ? 'COMPLETED' : 'IN_PROGRESS',
                     payload
                 }
             ];
@@ -78,20 +78,24 @@ export class MarAgentConversationNormalizer {
                     payload: { explanation: event.text, steps: [] }
                 }
             ];
-        if (event.type === 'reasoning.summary')
+        if (event.type === 'reasoning.completed')
             return [
                 {
-                    itemId: itemId('reasoning', event.eventId),
-                    kind: 'reasoning_summary',
+                    itemId: itemId('reasoning', event.itemId),
+                    kind: 'reasoning',
                     status: 'COMPLETED',
-                    payload: { sections: [{ index: 0, text: compactRunnerText(event.text, 10_000) }] }
+                    payload: {
+                        representation: event.representation,
+                        sections: [{ index: 0, text: compactRunnerText(event.text, 10_000) }]
+                    }
                 }
             ];
         if (event.type === 'tool.started' ||
             event.type === 'tool.completed' ||
             event.type === 'tool.failed') {
-            // Native web calls and generated artifacts stay visible independently of cell observations.
+            // Read/web calls and generated artifacts stay visible independently of cell observations.
             if (event.parentCallId !== undefined &&
+                event.toolName !== 'read' &&
                 event.toolName !== 'web_search' &&
                 event.toolName !== 'web_fetch' &&
                 !isImageGenerationTool(event.toolName))
@@ -352,7 +356,7 @@ export class MarAgentConversationNormalizer {
             if (observation.id !== undefined)
                 this.#codeModeObservationIds.add(observation.id);
             this.#codeModeSourceCallIds.add(observation.source.callId);
-            items.push(...projected);
+            items.push(...projected.map((item) => 'callId' in event ? { ...item, parentItemId: itemId('tool', event.callId) } : item));
         }
         return items;
     }
@@ -665,6 +669,16 @@ function genericToolItem(id, toolName, status, input, outputSummary = null, erro
     };
 }
 function projectToolPresentation(toolName, input, output, startedAt) {
+    if (toolName === 'read') {
+        const reads = record(input)?.reads;
+        const paths = (Array.isArray(reads) ? reads : [])
+            .flatMap((entry) => {
+            const path = record(entry)?.path;
+            return typeof path === 'string' && path.length > 0 ? [compactRunnerText(path, 4096)] : [];
+        })
+            .slice(0, 16);
+        return { kind: 'READ', paths };
+    }
     const category = toolName === 'web_search'
         ? 'WEB_SEARCH'
         : toolName === 'web_fetch'

package/dist/runner/mar-agent/history-projection.js

@@ -102,7 +102,7 @@ export function projectMarAgentHistory(session, entries, options = {}) {
             const attachments = projected.generatedImages === undefined
                 ? []
                 : (options.registerGeneratedImages?.(event.sessionId, projected.generatedImages) ?? []);
-            replace(projectionTurn, historyItem(session, projectionTurn, projected.itemId, projected.kind, projected.status, attachments.length === 0 ? projected.payload : { ...projected.payload, attachments }, at, projected.permissionStop));
+            replace(projectionTurn, historyItem(session, projectionTurn, projected.itemId, projected.kind, projected.status, attachments.length === 0 ? projected.payload : { ...projected.payload, attachments }, at, projected.permissionStop, projected.parentItemId));
         }
     }
     return [...turns.values()];
@@ -129,13 +129,13 @@ function record(value) {
         ? value
         : undefined;
 }
-function historyItem(session, turn, id, kind, status, payload, at, permissionStop) {
+function historyItem(session, turn, id, kind, status, payload, at, permissionStop, parentItemId) {
     return {
         id,
         sessionId: session.id,
         turnId: turn.id,
         runId: turn.runId,
-        parentItemId: null,
+        parentItemId: parentItemId ?? null,
         sourceSequence: null,
         revision: 0,
         kind,

package/dist/runner/mar-agent/managed-run-controller.js

@@ -709,6 +709,7 @@ export class MarAgentManagedRunController {
                         []);
                 this.host.emitItem(runId, {
                     itemId: item.itemId,
+                    ...(item.parentItemId === undefined ? {} : { parentItemId: item.parentItemId }),
                     kind: item.kind,
                     status: item.status,
                     payload: attachments.length === 0 ? item.payload : { ...item.payload, attachments },

package/dist/runner/opencode/conversation-parser.js

@@ -139,7 +139,12 @@ function openCodeTurn(session, user, userParts, assistants, sequence, managed) {
         for (const part of assistant.parts) {
             const projected = partItem(session, nativeTurnId, part, assistant.info.mode === 'plan', startedAt, completedAt, sequence);
             if (projected !== undefined)
-                items.push(projected);
+                items.push({
+                    ...projected,
+                    ...(typeof assistant.info.id === 'string' && typeof record(part)?.id === 'string'
+                        ? { sourceItemId: openCodeSourceItemId(assistant.info.id, record(part).id) }
+                        : {})
+                });
         }
     }
     if (items.length === 0)
@@ -173,12 +178,17 @@ function partItem(session, turnId, raw, planMode, startedAt, completedAt, sequen
     const part = record(raw);
     if (typeof part?.id !== 'string' || typeof part.type !== 'string')
         return undefined;
+    if (part.type === 'reasoning' && (typeof part.text !== 'string' || !part.text.trim()))
+        return undefined;
     if ((part.type === 'text' || part.type === 'reasoning') && typeof part.text === 'string')
-        return item(session, turnId, part.id, part.type === 'text' ? (planMode ? 'plan' : 'assistant_message') : 'reasoning_summary', completedAt === null ? 'IN_PROGRESS' : 'COMPLETED', part.type === 'text'
+        return item(session, turnId, part.id, part.type === 'text' ? (planMode ? 'plan' : 'assistant_message') : 'reasoning', completedAt === null ? 'IN_PROGRESS' : 'COMPLETED', part.type === 'text'
             ? planMode
                 ? { explanation: compactRunnerText(part.text, 20_000), steps: [] }
                 : { text: compactRunnerText(part.text, 20_000), format: 'markdown', model: null }
-            : { sections: [{ index: 0, text: compactRunnerText(part.text, 10_000) }] }, startedAt, completedAt, sequence);
+            : {
+                representation: 'unspecified',
+                sections: [{ index: 0, text: compactRunnerText(part.text, 10_000) }]
+            }, startedAt, completedAt, sequence);
     if (part.type === 'tool' && typeof part.tool === 'string') {
         const state = record(part.state);
         if (part.tool === 'question' && typeof part.callID === 'string') {
@@ -258,6 +268,9 @@ export function openCodePatchToolPayload() {
         truncated: false
     };
 }
+export function openCodeSourceItemId(messageId, partId) {
+    return JSON.stringify(['opencode', messageId, partId]);
+}
 function item(session, turnId, nativeId, kind, status, payload, startedAt, completedAt, sequence) {
     return {
         id: boundedConversationItemId(`${session.id}:official:${turnId}`, nativeId),

package/dist/runner/opencode/managed-run-controller.js

@@ -1,4 +1,4 @@
-import { OpenCodeUsageNormalizer } from './conversation-parser.js';
+import { OpenCodeUsageNormalizer, openCodeSourceItemId } from './conversation-parser.js';
 import { parseComposerTags } from '@myagentroam/protocol';
 import { nodeExecutionEnvironment } from '../../node-execution-environment.js';
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
@@ -440,7 +440,10 @@ export class OpenCodeManagedRunController {
             }
             const item = openCodePart(part, this.runner.execution.get(runId)?.agent === 'plan');
             if (item !== undefined)
-                this.host.emitItem(runId, item);
+                this.host.emitItem(runId, {
+                    ...item,
+                    sourceItemId: openCodeSourceItemId(part.messageID, part.id)
+                });
             if (typeof part.id === 'string') {
                 const itemId = boundedConversationItemId('opencode', part.id);
                 const responseLatency = this.currentResponseMessage(runId, part.messageID)
@@ -688,6 +691,8 @@ function openCodePart(part, planMode = false) {
     const id = typeof part?.id === 'string' ? part.id : undefined;
     if (id === undefined || typeof part?.type !== 'string')
         return undefined;
+    if (part.type === 'reasoning' && (typeof part.text !== 'string' || !part.text.trim()))
+        return undefined;
     const itemId = boundedConversationItemId('opencode', id);
     if (part.type === 'text' && typeof part.text === 'string')
         return {
@@ -702,9 +707,9 @@ function openCodePart(part, planMode = false) {
     if (part.type === 'reasoning' && typeof part.text === 'string')
         return {
             itemId,
-            kind: 'reasoning_summary',
+            kind: 'reasoning',
             status: record(part.time)?.end === undefined ? 'IN_PROGRESS' : 'COMPLETED',
-            payload: { sections: [{ index: 0, text: part.text }] },
+            payload: { representation: 'unspecified', sections: [{ index: 0, text: part.text }] },
             merge: true
         };
     if (part.type === 'tool' && typeof part.tool === 'string') {

package/dist/runner/opencode/tool-normalizer.js

@@ -38,6 +38,16 @@ export function normalizeOpenCodeTool(toolName, state) {
             progressLabel: null,
             errorCode: status === 'FAILED' ? 'OPENCODE_TOOL_FAILED' : null,
             truncated: false,
+            ...(normalizedName === 'read'
+                ? {
+                    toolPresentation: {
+                        kind: 'READ',
+                        paths: typeof input?.filePath === 'string' && input.filePath.length > 0
+                            ? [compactRunnerText(input.filePath, 4096)]
+                            : []
+                    }
+                }
+                : {}),
             ...subagent
         }
     };

package/dist/runtime-state.js

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import { projectConversationWorkProcesses } from './service/conversation-work-process.js';
 import { nodeLog } from './operational.js';
 import { safeErrorCode } from './util/safe-error.js';
 import { permissionStopSchema } from '@myagentroam/protocol';
@@ -1383,6 +1384,7 @@ export class NodeRuntimeState {
             this.currentTurnForRun(event.runId) === undefined &&
             conversationItemFromEvent(event) !== undefined)
             this.createItemOnlyTurn(run, event.createdAt);
+        let needsProcessProjection = false;
         const update = (turn) => {
             if (event.eventType === 'text.delta' &&
                 isRecord(event.payload) &&
@@ -1398,8 +1400,14 @@ export class NodeRuntimeState {
                         : undefined
                     : turn.items.find((item) => item.id === stableItemId && item.kind === 'assistant_message');
                 const text = `${existing === undefined ? '' : readableText(existing.payload)}${event.payload.text}`;
+                const sourceItemId = conversationSourceItemId(event.payload) ?? existing?.sourceItemId;
+                needsProcessProjection =
+                    existing === undefined ||
+                        existing.sourceItemId !== sourceItemId ||
+                        (!readableText(existing.payload).trim() && !!text.trim());
                 const item = {
                     id: existing?.id ?? stableItemId ?? `${event.runId}:assistant:${event.sequence}`,
+                    ...(sourceItemId === undefined ? {} : { sourceItemId }),
                     sessionId: run.sessionId,
                     turnId: turn.id,
                     runId: event.runId,
@@ -1407,6 +1415,7 @@ export class NodeRuntimeState {
                     sourceSequence: existing?.sourceSequence ?? event.sequence,
                     revision: event.sequence,
                     kind: 'assistant_message',
+                    ...(existing?.processGroup === undefined ? {} : { processGroup: existing.processGroup }),
                     updatedAt: event.createdAt,
                     status: 'IN_PROGRESS',
                     payload: { text, format: 'markdown', model: null },
@@ -1447,15 +1456,30 @@ export class NodeRuntimeState {
                         ? trailingItem
                         : undefined);
                 const status = projected.status;
+                const sourceItemId = projected.sourceItemId ?? existing?.sourceItemId;
+                const parentItemId = projected.parentItemId === undefined
+                    ? (existing?.parentItemId ?? null)
+                    : runConversationItemId(event.runId, projected.parentItemId);
+                needsProcessProjection =
+                    existing === undefined ||
+                        existing.kind !== projected.kind ||
+                        projected.kind === 'context_compaction' ||
+                        existing.parentItemId !== parentItemId ||
+                        existing.sourceItemId !== sourceItemId ||
+                        (projected.kind === 'assistant_message' &&
+                            !!readableText(existing.payload).trim() !== !!readableText(projected.payload).trim()) ||
+                        (projected.kind === 'reasoning' && existing.processGroup === undefined);
                 const item = {
                     id: itemId,
                     sessionId: run.sessionId,
                     turnId: turn.id,
                     runId: event.runId,
-                    parentItemId: null,
+                    parentItemId,
+                    ...(sourceItemId === undefined ? {} : { sourceItemId }),
                     sourceSequence: existing?.sourceSequence ?? event.sequence,
                     revision: (existing?.revision ?? -1) + 1,
                     kind: projected.kind,
+                    ...(existing?.processGroup === undefined ? {} : { processGroup: existing.processGroup }),
                     updatedAt: event.createdAt,
                     status,
                     payload: mergeConversationItemPayload(existing?.payload, projected),
@@ -1495,11 +1519,16 @@ export class NodeRuntimeState {
             }
             return turn;
         };
+        const project = (turn) => {
+            const next = update(turn);
+            // Ordinary token/output updates retain membership; only structural input needs a scan.
+            return needsProcessProjection ? projectConversationWorkProcesses(next) : next;
+        };
         if (turnId === undefined)
-            this.updateCurrentTurnForRun(event.runId, update);
+            this.updateCurrentTurnForRun(event.runId, project);
         else {
             const current = this.turns.get(run.sessionId) ?? [];
-            this.turns.set(run.sessionId, current.map((turn) => (turn.id === turnId ? update(turn) : turn)));
+            this.turns.set(run.sessionId, current.map((turn) => (turn.id === turnId ? project(turn) : turn)));
         }
     }
 }
@@ -1575,12 +1604,19 @@ function conversationItemFromEvent(event) {
         !isRecord(payload))
         return undefined;
     const append = event.payload.append;
+    const sourceItemId = conversationSourceItemId(event.payload);
     const permissionStop = permissionStopSchema.safeParse(event.payload.permissionStop);
     return {
         itemId,
         kind,
         status,
         payload,
+        ...(sourceItemId === undefined ? {} : { sourceItemId }),
+        ...(typeof event.payload.parentItemId === 'string' &&
+            event.payload.parentItemId.length > 0 &&
+            event.payload.parentItemId.length <= 88
+            ? { parentItemId: event.payload.parentItemId }
+            : {}),
         ...(permissionStop.success ? { permissionStop: permissionStop.data } : {}),
         merge: event.payload.merge === true,
         ...(append === 'sections' || append === 'outputPreview' || append === 'outputSummary'
@@ -1588,10 +1624,17 @@ function conversationItemFromEvent(event) {
             : {})
     };
 }
+function conversationSourceItemId(payload) {
+    return typeof payload.sourceItemId === 'string' &&
+        payload.sourceItemId.length > 0 &&
+        payload.sourceItemId.length <= 1024
+        ? payload.sourceItemId
+        : undefined;
+}
 function projectableConversationKind(value) {
     return (value === 'user_message' ||
         value === 'assistant_message' ||
-        value === 'reasoning_summary' ||
+        value === 'reasoning' ||
         value === 'tool_call' ||
         value === 'command_execution' ||
         value === 'approval_request' ||

package/dist/service/conversation-history-service.js

@@ -1,3 +1,4 @@
+import { projectConversationWorkProcesses } from './conversation-work-process.js';
 import { discoverNativeSessions, readNativeSession } from '../native-session-history.js';
 import { nativeConversationPage } from '../util/runner-native-session-parsers.js';
 import { isPlainRecord } from '../util/node-operation-parsers.js';
@@ -552,7 +553,7 @@ export class ConversationHistoryService {
     page(nextCursor, turns, metadata) {
         return {
             ...metadata,
-            turns,
+            turns: turns.map(projectConversationWorkProcesses),
             nextCursor,
             latestVisibleAt: Math.max(0, ...turns.map((turn) => Math.max(turn.startedAt ?? 0, turn.completedAt ?? 0)))
         };

package/dist/service/conversation-segment-service.js

@@ -1,3 +1,4 @@
+import { projectConversationWorkProcesses } from './conversation-work-process.js';
 const MAX_INITIAL_TURN_PAGE_SIZE = 30;
 function conversationSegmentPrefix(turn) {
     const user = turn.items.find((item) => item.kind === 'user_message');
@@ -10,6 +11,7 @@ function conversationSegmentPrefix(turn) {
         : turn.id;
 }
 export function conversationSegments(turn) {
+    turn = projectConversationWorkProcesses(turn);
     const prefix = conversationSegmentPrefix(turn);
     const groups = [];
     let current = [];
@@ -25,7 +27,7 @@ export function conversationSegments(turn) {
     return groups.map((items, index) => {
         const id = `${prefix}:segment:${index}`;
         const latest = index === groups.length - 1;
-        const projectedItems = items.map((item) => ({
+        const projectedItems = items.map(({ sourceItemId: _sourceItemId, ...item }) => ({
             ...item,
             runId: turn.runId,
             segmentId: id,

package/dist/service/conversation-work-process.js

@@ -0,0 +1,102 @@
+import { createHash } from 'node:crypto';
+const members = new Set([
+    'reasoning',
+    'tool_call',
+    'command_execution',
+    'file_change',
+    'todo_list'
+]);
+const boundaries = new Set([
+    'user_message',
+    'assistant_message',
+    'approval_request',
+    'user_input_request',
+    'plan',
+    'turn_summary'
+]);
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function visible(item) {
+    const payload = record(item.payload);
+    if (item.kind === 'assistant_message')
+        return typeof payload.text === 'string' && !!payload.text.trim();
+    if (item.kind === 'reasoning')
+        return (Array.isArray(payload.sections) &&
+            payload.sections.some((part) => {
+                const text = record(part).text;
+                return typeof text === 'string' && !!text.trim();
+            }));
+    return true;
+}
+/** Runtime owns this exact prefix; native history already carries the unprefixed identity. */
+function sourceIdentity(item) {
+    if (item.sourceItemId !== undefined)
+        return item.sourceItemId;
+    const prefix = item.runId === null ? undefined : `${item.runId}:`;
+    return prefix !== undefined && item.id.startsWith(prefix)
+        ? item.id.slice(prefix.length)
+        : item.id;
+}
+/** Project complete public input before transport segmentation, without clocks or stored groups. */
+export function projectConversationWorkProcesses(turn) {
+    const positions = new Map(turn.items.map((item, index) => [item.id, index]));
+    const anchored = new Map();
+    const relocated = new Set();
+    for (const item of turn.items) {
+        const payload = record(item.payload);
+        if (item.kind !== 'context_compaction' ||
+            !['BACKGROUND', 'BLOCKING'].includes(String(payload.mode)) ||
+            typeof payload.anchorItemId !== 'string' ||
+            !positions.has(payload.anchorItemId) ||
+            payload.anchorItemId === item.id ||
+            turn.items[positions.get(payload.anchorItemId)]?.kind === 'context_compaction')
+            continue;
+        const list = anchored.get(payload.anchorItemId) ?? [];
+        list.push(item);
+        anchored.set(payload.anchorItemId, list);
+        relocated.add(item.id);
+    }
+    const ordered = turn.items.flatMap((item) => relocated.has(item.id) ? [] : [item, ...(anchored.get(item.id) ?? [])]);
+    let knownBoundary = turn.runId !== null || turn.items.some((item) => item.id === turn.userItemId);
+    let current;
+    const assigned = new Map();
+    const items = ordered.map((item) => {
+        const payload = record(item.payload);
+        let group;
+        let isStart = false;
+        const independent = boundaries.has(item.kind) ||
+            (item.kind === 'context_compaction' && payload.mode !== 'BACKGROUND') ||
+            (item.kind === 'error' && item.parentItemId === null);
+        if (visible(item)) {
+            if (independent) {
+                current = undefined;
+                knownBoundary = true;
+            }
+            else if (members.has(item.kind) || ['warning', 'error', 'unknown'].includes(item.kind)) {
+                group = item.parentItemId === null ? undefined : assigned.get(item.parentItemId);
+                if (group === undefined) {
+                    group = current;
+                    if (group === undefined && knownBoundary && members.has(item.kind)) {
+                        group = `process:${createHash('sha256')
+                            .update(`${turn.sessionId}\0${sourceIdentity(item)}`)
+                            .digest('hex')}`;
+                        current = group;
+                        isStart = true;
+                    }
+                }
+                if (group !== undefined)
+                    assigned.set(item.id, group);
+            }
+        }
+        if (item.processGroup?.id === group && (item.processGroup?.isStart === true) === isStart)
+            return item;
+        const { processGroup: _previous, ...rest } = item;
+        return group === undefined
+            ? rest
+            : { ...rest, processGroup: { id: group, ...(isStart ? { isStart: true } : {}) } };
+    });
+    return items.every((item, index) => item === turn.items[index]) ? turn : { ...turn, items };
+}

package/dist/service/node-workspace-coordinator.js

@@ -1,3 +1,5 @@
+import { realpath } from 'node:fs/promises';
+import { nodeLog } from '../operational.js';
 import { inspectWorkspace, normalizeWorkspacePath } from '../workspace.js';
 import { ensureWorkspaceGitExclude } from './workspace-git-exclude-service.js';
 /** Coordinates Workspace invalidation, inspection and persisted Terminal summaries. */
@@ -18,7 +20,7 @@ export class NodeWorkspaceCoordinator {
         const config = this.options.config();
         if (config === undefined)
             throw new Error('NODE_CONFIG_UNAVAILABLE');
-        const inspection = await inspectWorkspace(workspace.path, config.allowedRoots);
+        const inspection = await inspectWorkspace(workspace.path, config.allowedRoots, workspace.includeParentRepository ?? true);
         if (normalizeWorkspacePath(inspection.path) !== normalizeWorkspacePath(workspace.path))
             throw new Error('WORKSPACE_NOT_ALLOWED');
         return inspection;
@@ -29,8 +31,14 @@ export class NodeWorkspaceCoordinator {
             throw new Error('NODE_DATABASE_UNAVAILABLE');
         if (normalizeWorkspacePath(inspection.path) !== normalizeWorkspacePath(workspace.path))
             throw new Error('WORKSPACE_NOT_ALLOWED');
+        const current = this.require(workspace.id);
+        if ((current.includeParentRepository ?? true) !== (workspace.includeParentRepository ?? true))
+            return current;
         if (workspace.kind !== 'GIT_WORKSPACE' && inspection.kind === 'GIT_WORKSPACE')
-            await ensureWorkspaceGitExclude(workspace.path);
+            await ensureWorkspaceGitExclude(workspace.path, workspace.includeParentRepository ?? true);
+        if ((this.require(workspace.id).includeParentRepository ?? true) !==
+            (workspace.includeParentRepository ?? true))
+            return this.require(workspace.id);
         const saved = database.saveWorkspace({
             id: workspace.id,
             path: workspace.path,
@@ -57,6 +65,14 @@ export class NodeWorkspaceCoordinator {
     invalidateChanges(workspaceId) {
         this.options.changes.invalidate(workspaceId);
     }
+    gitPolicyChanged(workspaceId) {
+        this.invalidate(workspaceId);
+        const workspace = this.require(workspaceId);
+        void this.inspectMetadata(workspace)
+            .then((inspection) => this.commitMetadata(workspace, inspection))
+            .then(() => this.invalidate(workspaceId))
+            .catch(() => nodeLog('workspace.git-policy.refresh-failed', { workspaceId }));
+    }
     persistTerminal(summary) {
         const database = this.options.database();
         if (database === undefined)
@@ -87,7 +103,9 @@ export class NodeWorkspaceCoordinator {
             return;
         }
         try {
-            const inspection = await inspectWorkspace(requestedPath, config.allowedRoots);
+            const path = await realpath(requestedPath);
+            const current = this.options.database()?.getWorkspaceByPath(path);
+            const inspection = await inspectWorkspace(path, config.allowedRoots, current?.includeParentRepository ?? true);
             this.options.send('workspace.inspect.result', inspection, envelope.id);
         }
         catch {