@sema-agent/core 1.436.2 → 1.437.0

package/dist/core/auto-compaction.d.ts

@@ -66,11 +66,14 @@ export interface MaybeCompactOptions {
         maxFiles?: number;
         maxCharsPerFile?: number;
         recentlyReadFiles?: () => string[];
+        instructionSourcePaths?: ReadonlyArray<string>;
+        normalizePath?: (raw: string) => Promise<string>;
+        isDedupStubResult?: (resultText: string) => boolean;
     };
     onApplied?: (attachedComplete: ReadonlyArray<{
         path: string;
         content: string;
-    }>) => void;
+    }>, preserveReadState?: ReadonlyArray<string>) => void;
     overheadTokens?: number;
     summaryProvider?: (input: {
         messagesToSummarize: AgentMessage[];

package/dist/core/auto-compaction.js

@@ -1,4 +1,5 @@
 import { DEFAULT_CHARS_PER_TOKEN, DEFAULT_CLAMP_TOLERANCE, DEFAULT_COMPACTION_SETTINGS, CompactionError, compact, computeFileLists, dryRunSummarizationClamp, estimateContextTokens, estimateTokens, prepareCompaction, shouldCompact, } from "../internal/harness.js";
+import { fileArgPath } from "../tools/fs/safety.js";
 import { contextEditFrontier } from "./context-edit.js";
 import { selectCompactionEpoch } from "../prompt-assembly/epoch.js";
 import { SEMA_DEFAULT_PACK } from "../prompt-assembly/packs/sema-default.js";
@@ -318,9 +319,95 @@ export async function maybeCompact(opts) {
     const attachedComplete = [];
     const att = opts.workingFileAttachments;
     const recentlyRead = att?.recentlyReadFiles?.() ?? [];
-    const candidateFiles = recentlyRead.length > 0 ? recentlyRead : (details?.modifiedFilesByRecency ?? details?.modifiedFiles);
+    const rawCandidateFiles = recentlyRead.length > 0 ? recentlyRead : (details?.modifiedFilesByRecency ?? details?.modifiedFiles);
+    const maxFilesForSelection = Math.max(1, att?.maxFiles ?? 3);
+    const excludedReadStatePreserveKeys = [];
+    const candidateFiles = Array.isArray(rawCandidateFiles) && rawCandidateFiles.length > 0
+        ? await (async () => {
+            const keptTailReadPathsRaw = new Set();
+            const firstKeptIdx = branch.findIndex((e) => e.id === firstKeptEntryId);
+            if (firstKeptIdx >= 0) {
+                const dedupStub = att?.isDedupStubResult;
+                for (let i = firstKeptIdx; i < branch.length; i++) {
+                    const entry = branch[i];
+                    if (entry.type !== "message" || entry.message.role !== "assistant")
+                        continue;
+                    const msg = entry.message;
+                    if (!("content" in msg) || !Array.isArray(msg.content))
+                        continue;
+                    const pendingReads = new Map();
+                    for (const block of msg.content) {
+                        if (typeof block !== "object" || block === null)
+                            continue;
+                        if (!("type" in block) || block.type !== "toolCall")
+                            continue;
+                        const tc = block;
+                        if (typeof tc.name !== "string" || typeof tc.id !== "string" || !tc.arguments)
+                            continue;
+                        if (tc.name !== "read" && tc.name !== "Read" && tc.name !== "read_file")
+                            continue;
+                        const path = fileArgPath(tc.arguments);
+                        if (path)
+                            pendingReads.set(tc.id, path);
+                    }
+                    if (pendingReads.size === 0)
+                        continue;
+                    for (let j = i + 1; j < branch.length && pendingReads.size > 0; j++) {
+                        const next = branch[j];
+                        if (next.type !== "message")
+                            continue;
+                        if (next.message.role === "assistant")
+                            break;
+                        if (next.message.role !== "toolResult")
+                            continue;
+                        const tr = next.message;
+                        const path = pendingReads.get(tr.toolCallId);
+                        if (path === undefined)
+                            continue;
+                        pendingReads.delete(tr.toolCallId);
+                        if (tr.isError)
+                            continue;
+                        if (dedupStub) {
+                            const text = tr.content.map((c) => ("text" in c ? c.text : "")).join("");
+                            if (dedupStub(text))
+                                continue;
+                        }
+                        keptTailReadPathsRaw.add(path);
+                    }
+                }
+            }
+            const instructionPathsRaw = new Set(att?.instructionSourcePaths ?? []);
+            if (keptTailReadPathsRaw.size === 0 && instructionPathsRaw.size === 0)
+                return rawCandidateFiles;
+            const normalize = att?.normalizePath;
+            if (!normalize) {
+                excludedReadStatePreserveKeys.push(...keptTailReadPathsRaw, ...instructionPathsRaw);
+                return rawCandidateFiles.filter((p) => !keptTailReadPathsRaw.has(p) && !instructionPathsRaw.has(p));
+            }
+            const normalizeSafe = async (p) => {
+                try {
+                    return await normalize(p);
+                }
+                catch {
+                    return p;
+                }
+            };
+            const normalizeCap = Math.max(maxFilesForSelection * 4, 12);
+            const boundedCandidates = rawCandidateFiles.slice(0, normalizeCap);
+            const overflowCandidates = rawCandidateFiles.slice(normalizeCap);
+            const [normBounded, normKeptTail, normInstruction] = await Promise.all([
+                Promise.all(boundedCandidates.map(normalizeSafe)),
+                Promise.all([...keptTailReadPathsRaw].map(normalizeSafe)),
+                Promise.all([...instructionPathsRaw].map(normalizeSafe)),
+            ]);
+            excludedReadStatePreserveKeys.push(...normKeptTail, ...normInstruction);
+            const excluded = new Set([...normKeptTail, ...normInstruction]);
+            const filteredBounded = boundedCandidates.filter((_, i) => !excluded.has(normBounded[i]));
+            return [...filteredBounded, ...overflowCandidates];
+        })()
+        : rawCandidateFiles;
     if (att && Array.isArray(candidateFiles) && candidateFiles.length > 0) {
-        const maxFiles = Math.max(1, att.maxFiles ?? 3);
+        const maxFiles = maxFilesForSelection;
         const perFileCap = Math.max(200, att.maxCharsPerFile ?? 16_000);
         let remaining = Math.min(maxFiles * perFileCap, Math.floor(window * 0.15) * cpt);
         const blocks = [];
@@ -369,7 +456,7 @@ export async function maybeCompact(opts) {
         ...(restatedListings !== undefined ? { announcedListings: restatedListings } : {}),
     }, false);
     try {
-        opts.onApplied?.(attachedComplete);
+        opts.onApplied?.(attachedComplete, excludedReadStatePreserveKeys);
     }
     catch {
     }

package/dist/core/runner/prepare-task.d.ts

@@ -194,10 +194,12 @@ export interface Prepared {
     promptOverheadTokens: number;
     readTaskFile?: (path: string) => Promise<string | null>;
     recentlyReadFiles?: () => string[];
+    normalizeAttachmentPath?: (raw: string) => Promise<string>;
+    isDedupStubResult?: (resultText: string) => boolean;
     onCompactionApplied?: (attachedComplete: ReadonlyArray<{
         path: string;
         content: string;
-    }>) => void;
+    }>, preserveReadState?: ReadonlyArray<string>) => void;
     lspDiagnostics?: {
         registry: import("../lsp-diagnostics.js").LspDiagnosticsRegistry;
         nudge: (rawPath: string) => void;

package/dist/core/runner/prepare-task.js

@@ -55,7 +55,7 @@ import { hasBackgroundShell, sweepBackgroundShells } from "../background-shell.j
 import { createTaskOutputTool, createTaskStopTool, defaultTaskRegistry } from "../task-registry.js";
 import { createMonitorTool } from "../../tools/monitor.js";
 import { createWorktreeTools } from "../../tools/worktree.js";
-import { applyCompactionToReadFileState, bashReversibilityProbe, createHandsToolkit, seedReadFileStateFromContext, HAND_TOOL_EFFECTS, pdfModelCapabilitiesOf } from "../../tools/fs/index.js";
+import { applyCompactionToReadFileState, bashReversibilityProbe, createHandsToolkit, isReadDedupStubResult, seedReadFileStateFromContext, HAND_TOOL_EFFECTS, pdfModelCapabilitiesOf } from "../../tools/fs/index.js";
 import { decodeTextBytes } from "../../tools/fs/encoding.js";
 import { ASK_USER_QUESTION_TOOL_NAME, createAskUserQuestionTool } from "../ask-question.js";
 import { createSchedulerTools } from "../../tools/scheduler-tools.js";
@@ -3291,6 +3291,20 @@ export async function prepareTask(spec, deps, sessions, resume, _memorySelector,
                 }
             }
             : undefined;
+        const normalizeAttachmentPath = handsEnabled
+            ? async (path) => {
+                if (attachmentRootCanonical === undefined)
+                    return path;
+                try {
+                    const rk = await resolveKey(executionEnv, attachmentRootCanonical, path, undefined, handsCwdRef?.current, additionalRootsCanonical);
+                    return rk.ok ? rk.key : path;
+                }
+                catch {
+                    return path;
+                }
+            }
+            : undefined;
+        const isDedupStubResult = handsEnabled ? isReadDedupStubResult : undefined;
         const recentlyReadFiles = handsEnabled && readFileStateForCheckpoint
             ? () => [...readFileStateForCheckpoint.entries()]
                 .filter(([, v]) => v.seededFromContext !== true)
@@ -3298,7 +3312,7 @@ export async function prepareTask(spec, deps, sessions, resume, _memorySelector,
                 .map(([path]) => path)
             : undefined;
         const onCompactionApplied = handsEnabled && readFileStateForCheckpoint
-            ? (attachedComplete) => applyCompactionToReadFileState(readFileStateForCheckpoint, attachedComplete)
+            ? (attachedComplete, preserveReadState) => applyCompactionToReadFileState(readFileStateForCheckpoint, attachedComplete, preserveReadState)
             : undefined;
         const detectExternalChanges = handsEnabled && readFileStateForCheckpoint
             ? async (maxFiles) => {
@@ -3382,7 +3396,7 @@ export async function prepareTask(spec, deps, sessions, resume, _memorySelector,
             : undefined;
         overheadState.promptChars = systemPrompt.length;
         const preparedHolder = {};
-        const buildPrepared = () => ({ harness, session, sessionId, taskRootPath, model, thinking, compModel, mcp: mcp, blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, nestedStats, cwdRef: handsCwdRef, ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), denyNarrowingPolicy, ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), releaseSignal, cacheBreakDetector, cacheFingerprint, promptManifest, epochDeclaredSections, activeTools, ownedEnv, suspendRef, reviewRef, reviewRequestRef, suspendLoopRef, suspendForResource, ...(callCapRef ? { callCapRef } : {}), ...(cutKills ? { cutKills } : {}), ...(callCapRef ? { callIssuedAtRef } : {}), suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolEffects, promptOverheadTokens, readTaskFile, recentlyReadFiles, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit } } : {}), planModeRef, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, listBackgroundTasks, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}) });
+        const buildPrepared = () => ({ harness, session, sessionId, taskRootPath, model, thinking, compModel, mcp: mcp, blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, nestedStats, cwdRef: handsCwdRef, ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), denyNarrowingPolicy, ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), releaseSignal, cacheBreakDetector, cacheFingerprint, promptManifest, epochDeclaredSections, activeTools, ownedEnv, suspendRef, reviewRef, reviewRequestRef, suspendLoopRef, suspendForResource, ...(callCapRef ? { callCapRef } : {}), ...(cutKills ? { cutKills } : {}), ...(callCapRef ? { callIssuedAtRef } : {}), suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolEffects, promptOverheadTokens, readTaskFile, recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit } } : {}), planModeRef, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, listBackgroundTasks, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}) });
         const prepared = buildPrepared();
         preparedHolder.current = prepared;
         return prepared;

package/dist/core/runner/runtask.js

@@ -1823,6 +1823,11 @@ export class Runner {
                                 ? {
                                     readFile: prepared.readTaskFile,
                                     ...(prepared.recentlyReadFiles ? { recentlyReadFiles: prepared.recentlyReadFiles } : {}),
+                                    ...(prepared.normalizeAttachmentPath ? { normalizePath: prepared.normalizeAttachmentPath } : {}),
+                                    ...(prepared.isDedupStubResult ? { isDedupStubResult: prepared.isDedupStubResult } : {}),
+                                    ...(prepared.instructionSources
+                                        ? { instructionSourcePaths: prepared.instructionSources.filter((s) => s.contentHash !== null).map((s) => s.path) }
+                                        : {}),
                                     ...(typeof spec.compaction?.attachWorkingFiles === "object" ? spec.compaction.attachWorkingFiles : undefined),
                                 }
                                 : undefined,
@@ -2257,6 +2262,11 @@ export class Runner {
                         ? {
                             readFile: prepared.readTaskFile,
                             ...(prepared.recentlyReadFiles ? { recentlyReadFiles: prepared.recentlyReadFiles } : {}),
+                            ...(prepared.normalizeAttachmentPath ? { normalizePath: prepared.normalizeAttachmentPath } : {}),
+                            ...(prepared.isDedupStubResult ? { isDedupStubResult: prepared.isDedupStubResult } : {}),
+                            ...(prepared.instructionSources
+                                ? { instructionSourcePaths: prepared.instructionSources.filter((s) => s.contentHash !== null).map((s) => s.path) }
+                                : {}),
                             ...(typeof spec.compaction?.attachWorkingFiles === "object" ? spec.compaction.attachWorkingFiles : undefined),
                         }
                         : undefined,
@@ -3539,6 +3549,11 @@ export class Runner {
                         ? {
                             readFile: prepared.readTaskFile,
                             ...(prepared.recentlyReadFiles ? { recentlyReadFiles: prepared.recentlyReadFiles } : {}),
+                            ...(prepared.normalizeAttachmentPath ? { normalizePath: prepared.normalizeAttachmentPath } : {}),
+                            ...(prepared.isDedupStubResult ? { isDedupStubResult: prepared.isDedupStubResult } : {}),
+                            ...(prepared.instructionSources
+                                ? { instructionSourcePaths: prepared.instructionSources.filter((s) => s.contentHash !== null).map((s) => s.path) }
+                                : {}),
                             ...(typeof spec.compaction?.attachWorkingFiles === "object" ? spec.compaction.attachWorkingFiles : undefined),
                         }
                         : undefined,

package/dist/tools/fs/index.d.ts

@@ -10,11 +10,12 @@ export declare const MAX_EDIT_BYTES: number;
 export type ReadImageDownsamplerOption = ImageDownsampler | false | undefined;
 export declare function msTimeoutToSec(timeoutMs: number | undefined): number;
 export declare function seededFileUnchangedReminder(filePath: string): string;
+export declare function isReadDedupStubResult(resultText: string): boolean;
 export declare function seedReadFileStateFromContext(state: ReadFileState, key: string, content: string): void;
 export declare function applyCompactionToReadFileState(state: ReadFileState, attachedComplete: ReadonlyArray<{
     path: string;
     content: string;
-}>): void;
+}>, preserveKeys?: ReadonlyArray<string>): void;
 export interface CwdRef {
     current: string;
 }

package/dist/tools/fs/index.js

@@ -102,12 +102,17 @@ function countLines(s) {
 export function seededFileUnchangedReminder(filePath) {
     return `<system-reminder>This file is already in your context (see "Contents of ${filePath}" above) and has not changed on disk. Use that content instead of re-reading.</system-reminder>`;
 }
+export function isReadDedupStubResult(resultText) {
+    return (resultText.includes("unchanged since you last read it") ||
+        resultText.includes("has not changed on disk. Use that content instead of re-reading"));
+}
 export function seedReadFileStateFromContext(state, key, content) {
     state.set(key, { hash: sha256(content), totalLines: countLines(content), truncated: false, lastReadAt: Date.now(), seededFromContext: true });
 }
-export function applyCompactionToReadFileState(state, attachedComplete) {
+export function applyCompactionToReadFileState(state, attachedComplete, preserveKeys = []) {
+    const preserve = new Set(preserveKeys);
     for (const [k, v] of [...state]) {
-        if (v.seededFromContext !== true)
+        if (v.seededFromContext !== true && !preserve.has(k))
             state.delete(k);
     }
     for (const f of attachedComplete) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "1.436.2",
+  "version": "1.437.0",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",