oh-my-knowledge 0.52.1 → 0.52.3-oidc.0

package/dist/observability/codex-conversation-index.d.ts

@@ -15,7 +15,7 @@ export interface CodexIndexedTask {
     endLine: number;
 }
 export interface CodexRolloutIndex {
-    schemaVersion: 11;
+    schemaVersion: 12;
     sourcePath: string;
     /** File size observed when the index was produced. */
     sourceSize: number;
@@ -51,6 +51,10 @@ export interface CodexJsonlLine {
     startOffset: number;
     endOffset: number;
 }
+export interface CodexTaskRecordReadOptions {
+    /** Include only the next task prefix through its first human user message. */
+    includeNextHumanMessage?: boolean;
+}
 /**
  * Build a compact byte-range index without retaining the rollout. Only records
  * needed for turn boundaries and list metrics are parsed.
@@ -80,7 +84,7 @@ export declare function isCurrentCodexRolloutIndex(value: unknown, sourcePath: s
  * index remains internally consistent even after newer records are appended.
  */
 export declare function isReusableCodexRolloutIndex(value: unknown, sourcePath: string): value is CodexRolloutIndex;
-export declare function readCodexTaskRecords(index: CodexRolloutIndex, task: CodexIndexedTask): {
+export declare function readCodexTaskRecords(index: CodexRolloutIndex, task: CodexIndexedTask, options?: CodexTaskRecordReadOptions): {
     records: Array<unknown | undefined>;
     lines: CodexJsonlLine[];
     malformedRecordCount: number;

package/dist/observability/codex-conversation-index.js

@@ -3,7 +3,7 @@ import { codexUserDisplayText, codexUserMessageOrigin } from './codex-protocol.j
 import { codexRuntimeToolOutcomeFromPayload, codexToolOutputOutcome, } from './codex-tool-status.js';
 const READ_CHUNK_BYTES = 256 * 1024;
 const MAX_RECORD_BYTES = 32 * 1024 * 1024;
-const INDEX_SCHEMA_VERSION = 11;
+const INDEX_SCHEMA_VERSION = 12;
 const MAX_CURRENT_INDEX_ATTEMPTS = 4;
 /**
  * Build a compact byte-range index without retaining the rollout. Only records
@@ -327,7 +327,7 @@ export function isReusableCodexRolloutIndex(value, sourcePath) {
         return false;
     }
 }
-export function readCodexTaskRecords(index, task) {
+export function readCodexTaskRecords(index, task, options = {}) {
     const records = [];
     if (index.sessionMeta !== undefined && index.sessionMetaLine !== undefined) {
         records[index.sessionMetaLine] = index.sessionMeta;
@@ -345,8 +345,40 @@ export function readCodexTaskRecords(index, task) {
             malformedRecordCount += 1;
         }
     }, task.startOffset, task.endOffset, task.startLine);
+    if (options.includeNextHumanMessage) {
+        const taskIndex = index.tasks.findIndex((candidate) => candidate.turnId === task.turnId);
+        const nextTask = taskIndex >= 0 ? index.tasks[taskIndex + 1] : undefined;
+        if (nextTask) {
+            forEachJsonlLine(index.sourcePath, (record) => {
+                lines.push(record);
+                try {
+                    const parsed = JSON.parse(record.text);
+                    records[record.line] = parsed;
+                    return isHumanUserPrompt(parsed) ? false : undefined;
+                }
+                catch {
+                    malformedRecordCount += 1;
+                    return undefined;
+                }
+            }, nextTask.startOffset, nextTask.endOffset, nextTask.startLine);
+        }
+    }
     return { records, lines, malformedRecordCount };
 }
+function isHumanUserPrompt(value) {
+    const raw = objectValue(value);
+    if (!raw)
+        return false;
+    const recordType = stringValue(raw.type);
+    const payload = objectValue(raw.payload) ?? {};
+    const payloadType = stringValue(payload.type);
+    if (!isUserPromptRecord(recordType, payloadType, payload))
+        return false;
+    const message = userPromptText(payload)?.trim();
+    return Boolean(message
+        && codexUserMessageOrigin(message) === 'human'
+        && codexUserDisplayText(message)?.trim());
+}
 function finalizeSupersededTask(task, endOffset, endLine, endTimestamp) {
     return stripMutable({
         ...task,
@@ -501,7 +533,7 @@ function forEachJsonlLine(filePath, visit, startOffset = 0, endOffset = Number.P
     let indexedEndsWithNewline = true;
     let fragments = [];
     try {
-        while (absoluteOffset < endOffset) {
+        readLoop: while (absoluteOffset < endOffset) {
             const requestBytes = Math.min(buffer.length, endOffset - absoluteOffset);
             const bytesRead = readSync(fd, buffer, 0, requestBytes, absoluteOffset);
             if (bytesRead === 0)
@@ -515,7 +547,7 @@ function forEachJsonlLine(filePath, visit, startOffset = 0, endOffset = Number.P
                     ? Buffer.concat([...fragments, tail])
                     : tail;
                 const nextOffset = absoluteOffset + index + 1;
-                emitLine(lineBuffer, lineNumber, lineStartOffset, nextOffset, visit);
+                const shouldContinue = emitLine(lineBuffer, lineNumber, lineStartOffset, nextOffset, visit);
                 indexedSize = nextOffset;
                 indexedLineCount = lineNumber + 1;
                 indexedEndsWithNewline = true;
@@ -523,6 +555,8 @@ function forEachJsonlLine(filePath, visit, startOffset = 0, endOffset = Number.P
                 cursor = index + 1;
                 lineStartOffset = nextOffset;
                 lineNumber += 1;
+                if (!shouldContinue)
+                    break readLoop;
             }
             if (cursor < bytesRead)
                 fragments.push(Buffer.from(buffer.subarray(cursor, bytesRead)));
@@ -561,6 +595,6 @@ function isCompleteJsonRecord(buffer) {
 function emitLine(buffer, line, startOffset, endOffset, visit) {
     const text = buffer.toString('utf8').trim();
     if (!text)
-        return;
-    visit({ text, line, startOffset, endOffset });
+        return true;
+    return visit({ text, line, startOffset, endOffset }) !== false;
 }

package/dist/observability/codex-protocol.d.ts

@@ -1,8 +1,14 @@
 /** Stable inventory of Codex rollout record shapes understood by OMK. */
+export interface CodexUserAttachment {
+    attachmentKind: 'image' | 'file';
+    name: string;
+}
 export declare function isCodexResponseItemType(value: string | undefined): boolean;
 export declare function isCodexEventMessageType(value: string | undefined): boolean;
 /** Preserve source text separately while removing Codex UI transport envelopes from semantic display. */
 export declare function codexUserDisplayText(text: string): string | undefined;
+/** Extract privacy-safe attachment metadata without projecting local paths into Trace IR. */
+export declare function codexUserAttachments(text: string): CodexUserAttachment[];
 export declare function codexUserMessageOrigin(text: string): 'human' | 'runtime';
 /**
  * Records consumed by correlation or retained only as source provenance do not

package/dist/observability/codex-protocol.js

@@ -32,6 +32,9 @@ const EVENT_MESSAGE_TYPES = new Set([
 ]);
 const IN_APP_BROWSER_CONTEXT_RE = /<in-app-browser-context\b[^>]*>[\s\S]*?<\/in-app-browser-context>/gi;
 const CODEX_RUNTIME_MESSAGE_RE = /^# AGENTS\.md instructions\b|^<(?:app-context|environment_context|permissions instructions|collaboration_mode|apps_instructions|plugins_instructions|skills_instructions|recommended_plugins)>/i;
+const CODEX_USER_REQUEST_HEADING_RE = /^## My request(?: for Codex)?:\s*$/im;
+const CODEX_USER_FILES_HEADING_RE = /^# Files mentioned by the user:\s*$/im;
+const IMAGE_ATTACHMENT_RE = /\.(?:avif|bmp|gif|heic|heif|jpe?g|png|webp)$/i;
 export function isCodexResponseItemType(value) {
     return value !== undefined && RESPONSE_ITEM_TYPES.has(value);
 }
@@ -40,8 +43,7 @@ export function isCodexEventMessageType(value) {
 }
 /** Preserve source text separately while removing Codex UI transport envelopes from semantic display. */
 export function codexUserDisplayText(text) {
-    const requestHeading = /^## My request for Codex:\s*$/im;
-    const requestMatch = requestHeading.exec(text);
+    const requestMatch = CODEX_USER_REQUEST_HEADING_RE.exec(text);
     const request = requestMatch
         ? text.slice(requestMatch.index + requestMatch[0].length)
         : text;
@@ -53,6 +55,39 @@ export function codexUserDisplayText(text) {
         .trim();
     return visible || undefined;
 }
+/** Extract privacy-safe attachment metadata without projecting local paths into Trace IR. */
+export function codexUserAttachments(text) {
+    const attachments = new Map();
+    const requestMatch = CODEX_USER_REQUEST_HEADING_RE.exec(text);
+    const filesMatch = CODEX_USER_FILES_HEADING_RE.exec(text);
+    if (filesMatch && (!requestMatch || filesMatch.index < requestMatch.index)) {
+        const sectionEnd = requestMatch?.index ?? text.length;
+        const section = text.slice(filesMatch.index + filesMatch[0].length, sectionEnd);
+        for (const match of section.matchAll(/^##\s+(.+?):\s+(.+)\s*$/gm)) {
+            addCodexUserAttachment(attachments, match[1], match[2]);
+        }
+    }
+    for (const match of text.matchAll(/<image\b[^>]*\bpath="([^"]+)"[^>]*>/gi)) {
+        addCodexUserAttachment(attachments, undefined, match[1]);
+    }
+    return [...attachments.values()];
+}
+function addCodexUserAttachment(attachments, declaredName, sourcePath) {
+    const normalizedPath = sourcePath?.trim();
+    const inferredName = normalizedPath?.split(/[\\/]/).at(-1);
+    const name = declaredName?.trim() || inferredName?.trim();
+    if (!name)
+        return;
+    const key = name.toLocaleLowerCase('en-US');
+    if (attachments.has(key))
+        return;
+    attachments.set(key, {
+        attachmentKind: IMAGE_ATTACHMENT_RE.test(name) || IMAGE_ATTACHMENT_RE.test(normalizedPath ?? '')
+            ? 'image'
+            : 'file',
+        name,
+    });
+}
 export function codexUserMessageOrigin(text) {
     const trimmed = text.trimStart();
     if (CODEX_RUNTIME_MESSAGE_RE.test(trimmed))

package/dist/observability/codex-trace-adapter.js

@@ -4,7 +4,7 @@ import { correlateTraceToolEvents, createTraceId, normalizeTraceTimestamp, trace
 import { nonNegativeMetric, optionalTokenCount, splitInclusiveInputTokens, tokenCount, } from '../shared/token-usage.js';
 import { normalizeToolIdentity } from '../shared/tool-identity.js';
 import { extractCodexExecCommands } from './codex-exec-command.js';
-import { codexUserDisplayText, codexUserMessageOrigin, isCodexEventMessageType, isCodexRecordConsumedWithoutDirectEvent, isCodexResponseItemType, } from './codex-protocol.js';
+import { codexUserAttachments, codexUserDisplayText, codexUserMessageOrigin, isCodexEventMessageType, isCodexRecordConsumedWithoutDirectEvent, isCodexResponseItemType, } from './codex-protocol.js';
 import { codexRuntimeToolOutcome, codexToolOutputOutcome, codexToolStatusFromValue, } from './codex-tool-status.js';
 export function isCodexJsonl(records) {
     return records.some((record) => {
@@ -231,6 +231,7 @@ function convertCodexRecords(rawRecords, runId) {
                         : normalizedRole === 'system' ? 'runtime' : 'synthetic',
                     text,
                     displayText: normalizedRole === 'user' ? codexUserDisplayText(text) : undefined,
+                    attachments: normalizedRole === 'user' ? codexUserAttachments(text) : undefined,
                     model: normalizedRole === 'assistant' ? activeModel : undefined,
                 });
             }
@@ -444,6 +445,7 @@ function convertCodexRecords(rawRecords, runId) {
                     origin: codexUserMessageOrigin(text),
                     text,
                     displayText: codexUserDisplayText(text),
+                    attachments: codexUserAttachments(text),
                 });
             }
             return;
@@ -995,6 +997,7 @@ function indexDuplicateEventMessages(records) {
         const text = stringValue(payload.message);
         if (!role || !text)
             return;
+        const mirrorText = role === 'user' ? codexUserDisplayText(text) : text;
         const nearbyRecords = [-1, 1].flatMap((direction) => {
             let candidateIndex = sourceIndex + direction;
             while (candidateIndex >= 0 && candidateIndex < records.length) {
@@ -1010,9 +1013,14 @@ function indexDuplicateEventMessages(records) {
             if (adjacent?.type !== 'response_item')
                 return false;
             const adjacentPayload = isObject(adjacent.payload) ? adjacent.payload : {};
-            return adjacentPayload.type === 'message'
-                && adjacentPayload.role === role
-                && codexContentText(adjacentPayload.content) === text;
+            if (adjacentPayload.type !== 'message' || adjacentPayload.role !== role)
+                return false;
+            const adjacentText = codexContentText(adjacentPayload.content);
+            if (!adjacentText)
+                return false;
+            return role === 'user'
+                ? Boolean(mirrorText) && codexUserDisplayText(adjacentText) === mirrorText
+                : adjacentText === text;
         });
         if (mirrored)
             duplicateIndexes.add(sourceIndex);

package/dist/observability/conversation-catalog.js

@@ -106,7 +106,9 @@ class CodexConversationCatalog {
     trajectoryFromIndex(row, index, indexedTask) {
         const threadId = row.id;
         const turnId = indexedTask.turnId;
-        const selected = readCodexTaskRecords(index, indexedTask);
+        const selected = readCodexTaskRecords(index, indexedTask, {
+            includeNextHumanMessage: true,
+        });
         const traceSession = parseCodexSessionFile(row.rolloutPath, selected.records);
         const fullSessionTimeline = projectTraceSessionTimeline(traceSession);
         const turns = reconstructExperienceTurns(fullSessionTimeline);

package/dist/observability/experience.js

@@ -983,13 +983,20 @@ function isTimelineEvent(value) {
     ];
     if (!optionalStrings.every((field) => field === undefined || typeof field === 'string')
         || !isOptionalTimestamp(value.timestamp)
-        || (value.isError !== undefined && typeof value.isError !== 'boolean'))
+        || (value.isError !== undefined && typeof value.isError !== 'boolean')
+        || (value.attachments !== undefined && !isTimelineAttachmentArray(value.attachments)))
         return false;
     return value.kind !== 'tool_result'
         || value.toolStatus === undefined
         || value.isError === undefined
         || value.isError === (value.toolStatus === 'failure');
 }
+function isTimelineAttachmentArray(value) {
+    return Array.isArray(value) && value.every((attachment) => (isObjectRecord(attachment)
+        && (attachment.attachmentKind === 'image' || attachment.attachmentKind === 'file')
+        && typeof attachment.name === 'string'
+        && attachment.name.length > 0));
+}
 function isTimelineEventArray(value) {
     return Array.isArray(value) && value.every(isTimelineEvent);
 }
@@ -2746,6 +2753,7 @@ function userTimelineEvents(event, base, order) {
         order: order + (commandEnvelope ? 1 : 0),
         snippet: snippet(semanticText, 700),
         fullText: fullText(semanticText),
+        attachments: event.attachments,
         label: userTextEventLabel(kind),
     }));
     return events;

package/dist/observability/feedback-matchers.d.ts

@@ -28,6 +28,11 @@ export interface TextMatchRange {
 }
 export declare function findUserCorrectionMatches(value: string): TextMatchRange[];
 export declare function hasUserCorrectionSignal(value: string): boolean;
+/**
+ * 用严格纠正信号把下一轮用户消息关联回上一任务。统计反馈匹配仍保持更宽，
+ * 因为「改成」等表达可用于指标统计，但不足以单独证明任务连续性。
+ */
+export declare function hasExplicitFollowUpCorrectionSignal(value: string): boolean;
 export declare function findUserGoalShiftMatches(value: string): TextMatchRange[];
 export declare function hasUserGoalShiftSignal(value: string): boolean;
 export declare function findNegativeFeedbackMatches(value: string): TextMatchRange[];

package/dist/observability/feedback-matchers.js

@@ -40,6 +40,14 @@ const PHRASE_USER_CORRECTION_TERMS = [
     '改成',
     '重来',
 ];
+const EXPLICIT_FOLLOW_UP_CORRECTION_PATTERNS = [
+    /(?:^|[\s,，;；.。!！?？:：])(?:不对|错了)(?:啊|呀|吧|呢)?(?=$|[\s,，;；.。!！?？:：])/iu,
+    /(?:这|这个|这样|你的|你.{0,8})(?:不对|错了)/iu,
+    /不是这个|不是我要的|不要这样|理解错|看错|你没懂|重来|重新来|重做|重新做/iu,
+    /\b(?:that(?:'s| is)|this is|you(?:'re| are)) wrong\b/iu,
+    /\b(?:this|that) is (?:incorrect|not right)\b/iu,
+    /\byou (?:misunderstood|misread)\b|\b(?:start|do)(?: it)? over\b/iu,
+];
 const USER_GOAL_SHIFT_TERMS = [
     '换个方向',
     '重新来',
@@ -165,6 +173,13 @@ export function findUserCorrectionMatches(value) {
 export function hasUserCorrectionSignal(value) {
     return findUserCorrectionMatches(value).length > 0;
 }
+/**
+ * 用严格纠正信号把下一轮用户消息关联回上一任务。统计反馈匹配仍保持更宽，
+ * 因为「改成」等表达可用于指标统计，但不足以单独证明任务连续性。
+ */
+export function hasExplicitFollowUpCorrectionSignal(value) {
+    return EXPLICIT_FOLLOW_UP_CORRECTION_PATTERNS.some((pattern) => pattern.test(value));
+}
 export function findUserGoalShiftMatches(value) {
     const ranges = [];
     for (const term of USER_GOAL_SHIFT_TERMS) {

package/dist/observability/knowledge-debugger.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { hasUserCorrectionSignal } from './feedback-matchers.js';
 import { resolveTaskWindow } from './task-window.js';
 const AGENTS_CONTEXT_RE = /^# AGENTS\.md instructions for ([^\n]+)\n/gim;
 const SKILL_PATH_RE = /((?:~|\.{0,2}|\/)?[^\s"'`]*\/skills\/(?:\.system\/)?([^/\s"'`]+)\/SKILL\.md)\b/i;
@@ -16,13 +17,16 @@ export function buildKnowledgeDebuggerViewModel(session, targetTurnId, ingestion
 }) {
     const taskWindow = resolveTaskWindow(session, targetTurnId);
     const normalizedEvents = taskWindow.events;
+    const normalizedTimeline = normalizedEvents.filter((event) => event.runtimeKind !== 'usage');
     const timeline = taskWindow.semanticEvents.filter((event) => event.runtimeKind !== 'usage');
+    const replayTimeline = [...timeline, ...taskWindow.relatedEvents]
+        .sort((left, right) => left.order - right.order);
     const knowledgeEvidence = projectKnowledgeEvidence(timeline);
-    const steps = buildTaskReplaySteps(session, timeline, knowledgeEvidence);
-    const notices = buildIntegrityNotices(taskWindow.scope, timeline, steps, ingestion);
-    const userEvents = timeline.filter((event) => event.kind === 'user_message');
-    const assistantEvents = timeline.filter((event) => event.kind === 'assistant_message');
-    const observedModels = timeline.reduce((models, event) => {
+    const steps = buildTaskReplaySteps(session, replayTimeline, knowledgeEvidence);
+    const notices = buildIntegrityNotices(taskWindow.scope, normalizedEvents, ingestion);
+    const userEvents = normalizedTimeline.filter((event) => event.kind === 'user_message');
+    const assistantEvents = normalizedTimeline.filter((event) => event.kind === 'assistant_message');
+    const observedModels = normalizedTimeline.reduce((models, event) => {
         const eventModel = event.model?.trim();
         if (eventModel && !models.includes(eventModel))
             models.push(eventModel);
@@ -34,11 +38,11 @@ export function buildKnowledgeDebuggerViewModel(session, targetTurnId, ingestion
         summary: {
             userGoal: eventText(userEvents[0]),
             finalResponse: eventText(assistantEvents.at(-1)),
-            observedStartTimestamp: timeline.find((event) => (event.timestamp && event.runtimeKind !== 'session_context'))?.timestamp
-                ?? timeline.find((event) => event.timestamp)?.timestamp,
-            observedEndTimestamp: [...timeline].reverse().find((event) => event.timestamp)?.timestamp,
-            toolCallCount: steps.filter((step) => step.stepKind === 'tool_exchange').length,
-            toolFailureCount: steps.filter((step) => step.stepKind === 'tool_exchange' && step.toolStatus === 'failure').length,
+            observedStartTimestamp: normalizedTimeline.find((event) => (event.timestamp && event.runtimeKind !== 'session_context'))?.timestamp
+                ?? normalizedTimeline.find((event) => event.timestamp)?.timestamp,
+            observedEndTimestamp: [...normalizedTimeline].reverse().find((event) => event.timestamp)?.timestamp,
+            toolCallCount: normalizedEvents.filter((event) => event.kind === 'tool_use').length,
+            toolFailureCount: normalizedEvents.filter((event) => (event.kind === 'tool_result' && (event.toolStatus === 'failure' || event.isError))).length,
             hasUserCorrection: steps.some((step) => step.stepKind === 'user_correction'),
             observedModels,
         },
@@ -199,7 +203,7 @@ function isKnowledgeReturningCall(toolName, callText) {
     const command = sourceLocator(callText);
     return command ? READ_ONLY_SHELL_RE.test(command) : false;
 }
-function buildIntegrityNotices(taskScope, timeline, steps, ingestion) {
+function buildIntegrityNotices(taskScope, normalizedEvents, ingestion) {
     const notices = [];
     if (taskScope.basis === 'unresolved') {
         notices.push({ code: 'task_boundary_unavailable', count: 1 });
@@ -214,17 +218,40 @@ function buildIntegrityNotices(taskScope, timeline, steps, ingestion) {
         notices.push({ code: 'ignored_values', count: ingestion.ignoredValueCount });
     if (ingestion?.unknownEventCount)
         notices.push({ code: 'unknown_events', count: ingestion.unknownEventCount });
-    const unmatchedCalls = steps.filter((step) => step.stepKind === 'tool_exchange' && step.events.length === 1).length;
-    if (unmatchedCalls > 0)
-        notices.push({ code: 'unmatched_tool_calls', count: unmatchedCalls });
-    const unmatchedResults = steps.filter((step) => step.stepKind === 'unmatched_tool_result').length;
-    if (unmatchedResults > 0)
-        notices.push({ code: 'unmatched_tool_results', count: unmatchedResults });
-    const missingTimestamps = timeline.filter((event) => !event.timestamp).length;
+    const unmatched = unmatchedToolEventCounts(normalizedEvents);
+    if (unmatched.calls > 0)
+        notices.push({ code: 'unmatched_tool_calls', count: unmatched.calls });
+    if (unmatched.results > 0)
+        notices.push({ code: 'unmatched_tool_results', count: unmatched.results });
+    const missingTimestamps = normalizedEvents.filter((event) => !event.timestamp).length;
     if (missingTimestamps > 0)
         notices.push({ code: 'missing_timestamps', count: missingTimestamps });
     return notices;
 }
+function unmatchedToolEventCounts(events) {
+    const availableResults = new Map();
+    for (const event of events) {
+        if (event.kind !== 'tool_result')
+            continue;
+        const key = toolCorrelationKey(event);
+        availableResults.set(key, (availableResults.get(key) ?? 0) + 1);
+    }
+    let unmatchedCalls = 0;
+    for (const event of events) {
+        if (event.kind !== 'tool_use')
+            continue;
+        const key = toolCorrelationKey(event);
+        const remaining = availableResults.get(key) ?? 0;
+        if (remaining === 0) {
+            unmatchedCalls += 1;
+        }
+        else {
+            availableResults.set(key, remaining - 1);
+        }
+    }
+    const unmatchedResults = [...availableResults.values()].reduce((sum, count) => sum + count, 0);
+    return { calls: unmatchedCalls, results: unmatchedResults };
+}
 function correctionEventIds(session, timeline) {
     const ids = new Set();
     for (const episode of session.sessionStory?.episodes ?? []) {
@@ -235,9 +262,15 @@ function correctionEventIds(session, timeline) {
         }
     }
     const userCorrectionCount = session.indicators?.userCorrectionCount ?? 0;
+    const lastAssistantOrder = Math.max(-1, ...timeline.filter((event) => event.kind === 'assistant_message').map((event) => event.order));
+    const explicitCandidates = timeline
+        .filter((event) => (event.kind === 'user_message'
+        && event.order > lastAssistantOrder
+        && hasUserCorrectionSignal(event.fullText ?? event.snippet ?? '')));
+    for (const event of explicitCandidates)
+        ids.add(event.id);
     if (ids.size > 0 || userCorrectionCount === 0)
         return ids;
-    const lastAssistantOrder = Math.max(-1, ...timeline.filter((event) => event.kind === 'assistant_message').map((event) => event.order));
     const correctionCandidates = timeline
         .filter((event) => event.kind === 'user_message' && event.order > lastAssistantOrder)
         .slice(-userCorrectionCount);

package/dist/observability/task-semantic-projection.d.ts

@@ -0,0 +1,11 @@
+import type { ExperienceTimelineEvent } from '../types/index.js';
+export interface TaskSemanticProjectionOptions {
+    preservePendingToolCalls?: boolean;
+}
+/**
+ * Bound one task's semantic projection without separating tool exchanges or
+ * blindly discarding the middle of a long task. Failures, task boundaries and
+ * the user/assistant endpoints are retained first; remaining capacity is
+ * distributed across the task so the preview still explains its progression.
+ */
+export declare function projectTaskSemanticEvents(events: ExperienceTimelineEvent[], limit: number, options?: TaskSemanticProjectionOptions): ExperienceTimelineEvent[];

package/dist/observability/task-semantic-projection.js

@@ -0,0 +1,172 @@
+const PRIORITY_BANDS = [100, 90, 80, 70, 60, 40, 20, 0];
+/**
+ * Bound one task's semantic projection without separating tool exchanges or
+ * blindly discarding the middle of a long task. Failures, task boundaries and
+ * the user/assistant endpoints are retained first; remaining capacity is
+ * distributed across the task so the preview still explains its progression.
+ */
+export function projectTaskSemanticEvents(events, limit, options = {}) {
+    if (limit <= 0 || events.length === 0)
+        return [];
+    if (events.length <= limit)
+        return events;
+    const units = semanticUnits(events, options);
+    const selected = new Map();
+    let remaining = limit;
+    const required = units
+        .filter((unit) => unit.required)
+        .sort((left, right) => right.priority - left.priority || left.retentionOrder - right.retentionOrder);
+    for (const unit of required) {
+        if (unit.events.length > remaining)
+            continue;
+        selected.set(unit.id, unit);
+        remaining -= unit.events.length;
+    }
+    for (const priority of PRIORITY_BANDS) {
+        if (remaining <= 0)
+            break;
+        const candidates = units.filter((unit) => (!selected.has(unit.id) && unit.priority === priority));
+        if (candidates.length === 0)
+            continue;
+        const totalSize = candidates.reduce((sum, unit) => sum + unit.events.length, 0);
+        if (totalSize <= remaining) {
+            for (const unit of candidates)
+                selected.set(unit.id, unit);
+            remaining -= totalSize;
+            continue;
+        }
+        remaining = selectSpreadCandidates(candidates, selected, units, remaining);
+    }
+    return [...selected.values()]
+        .flatMap((unit) => unit.events)
+        .sort((left, right) => left.order - right.order);
+}
+function semanticUnits(events, options) {
+    const resultByCall = new Map();
+    for (const event of events) {
+        if (event.kind !== 'tool_result')
+            continue;
+        const key = toolCorrelationKey(event);
+        resultByCall.set(key, [...(resultByCall.get(key) ?? []), event]);
+    }
+    const firstUserId = events.find((event) => event.kind === 'user_message')?.id;
+    const finalAssistantId = [...events].reverse()
+        .find((event) => event.kind === 'assistant_message')?.id;
+    const consumedResults = new Set();
+    const units = [];
+    for (const event of events) {
+        if (event.kind === 'tool_result' && consumedResults.has(event.id))
+            continue;
+        if (event.kind === 'tool_use') {
+            const result = resultByCall.get(toolCorrelationKey(event))
+                ?.find((candidate) => !consumedResults.has(candidate.id));
+            if (result)
+                consumedResults.add(result.id);
+            const exchange = result ? [event, result] : [event];
+            const failed = exchange.some((candidate) => candidate.isError || candidate.toolStatus === 'failure');
+            const pending = !result && options.preservePendingToolCalls === true;
+            units.push({
+                id: `tool:${event.id}`,
+                events: exchange,
+                order: event.order,
+                priority: failed ? 135 : pending ? 140 : 70,
+                required: failed || pending,
+                retentionOrder: pending ? -event.order : event.order,
+            });
+            continue;
+        }
+        const isFirstUser = event.id === firstUserId;
+        const isFinalAssistant = event.id === finalAssistantId;
+        const isBoundary = event.kind === 'lifecycle' && isBoundaryLifecycle(event);
+        const isFailedResult = event.kind === 'tool_result'
+            && (event.isError || event.toolStatus === 'failure');
+        const required = isFirstUser
+            || event.id === finalAssistantId
+            || isFailedResult
+            || isBoundary;
+        units.push({
+            id: `event:${event.id}`,
+            events: [event],
+            order: event.order,
+            priority: requiredPriority(event, {
+                isFirstUser,
+                isFinalAssistant,
+                isBoundary,
+                isFailedResult,
+            }),
+            required,
+            retentionOrder: event.order,
+        });
+    }
+    return units;
+}
+function requiredPriority(event, flags) {
+    if (flags.isFirstUser)
+        return 160;
+    if (flags.isFinalAssistant)
+        return 150;
+    if (flags.isBoundary && event.label === 'turn_started')
+        return 145;
+    if (flags.isFailedResult)
+        return 135;
+    if (flags.isBoundary)
+        return 130;
+    return semanticPriority(event);
+}
+function semanticPriority(event) {
+    if (event.kind === 'user_message' || event.kind === 'assistant_message')
+        return 90;
+    if (event.kind === 'skill_context')
+        return 80;
+    if (event.kind === 'runtime_context')
+        return event.runtimeKind === 'usage' ? 0 : 80;
+    if (event.kind === 'lifecycle')
+        return 70;
+    if (event.kind === 'tool_result')
+        return event.isError || event.toolStatus === 'failure' ? 100 : 70;
+    if (event.kind === 'observation' || event.kind === 'agent_activity')
+        return 60;
+    if (event.kind === 'model_activity')
+        return event.contentVisibility === 'plaintext' ? 40 : 20;
+    return 0;
+}
+function isBoundaryLifecycle(event) {
+    const label = `${event.label ?? ''} ${event.sourceType ?? ''}`.toLowerCase();
+    return /(?:turn|task)[_-]?(?:start|complete|abort|interrupt|end)/.test(label);
+}
+function selectSpreadCandidates(candidates, selected, allUnits, capacity) {
+    const selectedOrders = [...selected.values()].map((unit) => unit.order);
+    const firstOrder = allUnits[0]?.order ?? 0;
+    const lastOrder = allUnits.at(-1)?.order ?? firstOrder;
+    const distances = new Map(candidates.map((candidate) => [
+        candidate.id,
+        selectedOrders.length > 0
+            ? Math.min(...selectedOrders.map((order) => Math.abs(candidate.order - order)))
+            : Math.min(Math.abs(candidate.order - firstOrder), Math.abs(lastOrder - candidate.order)),
+    ]));
+    let remaining = capacity;
+    while (remaining > 0) {
+        const fitting = candidates.filter((unit) => (!selected.has(unit.id) && unit.events.length <= remaining));
+        if (fitting.length === 0)
+            break;
+        const next = fitting.reduce((best, candidate) => {
+            const candidateDistance = distances.get(candidate.id) ?? 0;
+            const bestDistance = distances.get(best.id) ?? 0;
+            return candidateDistance > bestDistance
+                || (candidateDistance === bestDistance && candidate.order < best.order)
+                ? candidate
+                : best;
+        });
+        selected.set(next.id, next);
+        remaining -= next.events.length;
+        for (const candidate of candidates) {
+            if (selected.has(candidate.id))
+                continue;
+            distances.set(candidate.id, Math.min(distances.get(candidate.id) ?? Number.POSITIVE_INFINITY, Math.abs(candidate.order - next.order)));
+        }
+    }
+    return remaining;
+}
+function toolCorrelationKey(event) {
+    return event.callInstanceId ?? event.toolUseId ?? event.id;
+}

package/dist/observability/task-window.d.ts

@@ -3,6 +3,7 @@ export declare const TASK_SEMANTIC_EVENT_LIMIT = 240;
 export interface ResolvedTaskWindow {
     events: ExperienceTimelineEvent[];
     semanticEvents: ExperienceTimelineEvent[];
+    relatedEvents: ExperienceTimelineEvent[];
     scope: TaskWindowScope;
 }
 export declare function resolveTaskWindow(session: TaskTrajectorySession, targetTurnId: string, semanticLimit?: number): ResolvedTaskWindow;