@sema-agent/core 1.435.0 → 1.437.0

package/dist/agents/subagent.d.ts

@@ -5,6 +5,7 @@ import { type ExecutionEnv } from "../internal/harness.js";
 import type { RunInternals } from "../core/runner/prepare-task.js";
 import type { TaskNotificationPayload } from "../core/task-notification.js";
 export type { SubagentStep, SubagentEditedFile } from "./subagent-steps.js";
+export declare function notifyResultField(result: string | undefined): string | undefined;
 export declare function inheritedManifestScopeFor(snapshot: readonly unknown[] | undefined): RunInternals["inheritedManifestScope"];
 export declare const DEFAULT_SUBAGENT_TOOL_NAME = "Agent";
 export declare const LEGACY_SUBAGENT_TOOL_NAME = "Task";

package/dist/agents/subagent.js

@@ -12,6 +12,7 @@ import { SUBAGENT_PROMPT } from "../prompts/default.js";
 import { hasSessionFork } from "../core/session.js";
 import { isDurablePause } from "./suspend-guard.js";
 import { delimitUntrusted, inlineUntrusted } from "../core/untrusted-text.js";
+import { boundedRedactedSummary } from "../core/untrusted-egress.js";
 import { uuidv7 } from "../internal/harness.js";
 import { addWorktree } from "../core/git-worktree-env.js";
 import { BG_AGENT_REAP_STOP_ERROR, DURABLE_AGENT_HANDLE_RE, DURABLE_AGENT_HEARTBEAT_MS, normalizeAgentName } from "../core/task-registry.js";
@@ -19,6 +20,23 @@ import { canAccessAgentRecord } from "../core/background-agent-store.js";
 import { extractErrorCode } from "../brain/errors.js";
 import { ObserverDigestTap, ObserverPairing, createObserverReportToolSpec, markObserverTaskId, unmarkObserverTaskId, isObserverTaskId, observerFramingPrompt, observerSlug, resolveObserverDeclaration, OBSERVER_SENDMESSAGE_SENDER_REFUSAL, OBSERVER_SENDMESSAGE_TARGET_REFUSAL, } from "./observer.js";
 import { SubagentStepRecorder, stepsFromMessages } from "./subagent-steps.js";
+const BG_AGENT_RESULT_MAX = 4_000;
+const BG_AGENT_RESULT_FULL_MAX = 200_000;
+function resultSettleFields(result) {
+    if (!result)
+        return {};
+    const full = boundedRedactedSummary(result, BG_AGENT_RESULT_FULL_MAX);
+    const display = full.length > BG_AGENT_RESULT_MAX ? boundedRedactedSummary(result, BG_AGENT_RESULT_MAX) : full;
+    return display === full ? { result: display } : { result: display, resultFull: full };
+}
+const BG_AGENT_NOTIFY_RESULT_MAX = 2_000;
+export function notifyResultField(result) {
+    if (!result)
+        return undefined;
+    return result.length > BG_AGENT_NOTIFY_RESULT_MAX
+        ? `${result.slice(0, BG_AGENT_NOTIFY_RESULT_MAX)}\n[result truncated: ${result.length} chars total — call TaskOutput for the full text]`
+        : result;
+}
 export function inheritedManifestScopeFor(snapshot) {
     if (!snapshot || snapshot.length === 0)
         return undefined;
@@ -610,7 +628,7 @@ function makeSubagentResume(deps) {
                     try {
                         const winner = deps.registry.settleRevivedAgent(deps.taskId, reviveCycle, {
                             status,
-                            ...(child.result ? { result: child.result.slice(0, 2_000) } : {}),
+                            ...resultSettleFields(child.result),
                             ...(status !== "completed" ? { error: (child.errorMessage ?? `resumed run ${status}`).slice(0, 500) } : {}),
                         });
                         if (winner !== undefined)
@@ -644,7 +662,7 @@ function makeSubagentResume(deps) {
                     ...(stoppedByRevive !== undefined ? { stoppedBy: stoppedByRevive } : {}),
                     seq: entry.cycleSeq,
                     summary: `Agent "${reviveName}" (resumed) ${status === "killed" ? "stopped" : child.status === "completed" ? "finished" : String(child.status)}${ccElapsedTag(Date.now() - reviveStartedAt)}`,
-                    ...(child.result ? { result: child.result.slice(0, 2_000) } : {}),
+                    ...(child.result ? { result: notifyResultField(child.result) } : {}),
                     ...(status === "killed" && child.result ? { partial: true } : {}),
                     ...resumeResidual(),
                     resumable: status !== "killed",
@@ -1771,7 +1789,7 @@ function makeSubagentTool(opts, depth, excluded, extraToolsBudget) {
                         const reapedBg = !okBg && abort.signal.aborted;
                         const settledBg = bg.registry.settleBackgroundAgent(taskId, {
                             status: okBg ? "completed" : reapedBg ? "killed" : "failed",
-                            ...(child.result ? { result: child.result.slice(0, 4_000) } : {}),
+                            ...resultSettleFields(child.result),
                             ...(!okBg ? { error: reapedBg ? BG_AGENT_REAP_STOP_ERROR : child.errorMessage ?? String(child.status) } : {}),
                         }) ?? (abort.signal.aborted ? "killed" : okBg ? "completed" : "failed");
                         const stoppedByBg = settledBg === "killed" ? bg.registry.getStopAttribution(taskId) ?? "system" : undefined;
@@ -1809,7 +1827,7 @@ function makeSubagentTool(opts, depth, excluded, extraToolsBudget) {
                                 ...(stoppedByBg !== undefined ? { stoppedBy: stoppedByBg } : {}),
                                 summary: `${ccCompletionText(shortDesc, settledBg, String(child.status), Date.now() - forkBgStartedAt)}`,
                                 ...(child.sessionId ? { sessionId: child.sessionId } : {}),
-                                ...(child.result ? { result: child.result.slice(0, 2_000) } : {}),
+                                ...(child.result ? { result: notifyResultField(child.result) } : {}),
                                 ...(settledBg === "killed" && child.result ? { partial: true } : {}),
                                 ...residualFork,
                                 resumable: resumableFork,
@@ -2347,7 +2365,7 @@ task_id: ${taskId}
                     const settled = bg.registry.settleBackgroundAgent(taskId, {
                         status: ok ? "completed" : reaped ? "killed" : "failed",
                         seq: seqAtSettle ?? 1,
-                        ...(child.result ? { result: child.result.slice(0, 4_000) } : {}),
+                        ...resultSettleFields(child.result),
                         ...(!ok ? { error: reaped ? BG_AGENT_REAP_STOP_ERROR : child.errorMessage ?? String(child.status) } : {}),
                     }) ??
                         (abort.signal.aborted ? "killed" : ok ? "completed" : "failed");
@@ -2386,7 +2404,7 @@ task_id: ${taskId}
                         ...(stoppedBy !== undefined ? { stoppedBy } : {}),
                         summary: `${ccCompletionText(shortDesc, settled, String(child.status), Date.now() - bgStartedAt)}${observerNote}`,
                         ...(child.sessionId ? { sessionId: child.sessionId } : {}),
-                        ...(child.result ? { result: child.result.slice(0, 2_000) } : {}),
+                        ...(child.result ? { result: notifyResultField(child.result) } : {}),
                         ...(settled === "killed" && child.result ? { partial: true } : {}),
                         ...residual,
                         resumable: resumableBg,

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/background-agent-store.d.ts

@@ -34,6 +34,7 @@ export interface BackgroundAgentRecord {
     parkClaimId?: string;
     summary?: string;
     finalOutput?: string;
+    finalOutputFull?: string;
     error?: string;
     resultIsPartial?: boolean;
     recentSteps?: SubagentStep[];

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/core/task-registry.d.ts

@@ -97,6 +97,7 @@ interface BackgroundAgentTaskHandle extends SemaTaskHandle {
     name?: string;
     sessionScoped?: true;
     result?: string;
+    resultFull?: string;
     error?: string;
     resultIsPartial?: boolean;
     stopSource?: StopSource;
@@ -291,6 +292,7 @@ export declare class TaskRegistry {
     settleBackgroundAgent(id: string, outcome: {
         status: "completed" | "failed" | "killed";
         result?: string;
+        resultFull?: string;
         error?: string;
         stoppedBy?: StopSource;
         seq?: number;
@@ -353,6 +355,7 @@ export declare class TaskRegistry {
     settleRevivedAgent(id: string, cycle: number, outcome: {
         status: "completed" | "failed" | "killed";
         result?: string;
+        resultFull?: string;
         error?: string;
     }): "completed" | "failed" | "killed" | undefined;
     unmarkRetainedContinuation(id: string): void;

package/dist/core/task-registry.js

@@ -1074,6 +1074,8 @@ export class TaskRegistry {
                     handle.result = outcome.result;
                     handle.resultIsPartial = true;
                     backfilled = true;
+                    if (outcome.resultFull !== undefined)
+                        handle.resultFull = outcome.resultFull;
                 }
                 if (handle.error === undefined && outcome.error !== undefined && outcome.error !== BG_AGENT_REAP_STOP_ERROR) {
                     handle.error = outcome.error;
@@ -1083,6 +1085,7 @@ export class TaskRegistry {
                     handle.updatedAt = Date.now();
                     this.durableAgentWrite(handle, {
                         ...(handle.result !== undefined ? { finalOutput: handle.result } : {}),
+                        ...(handle.resultFull !== undefined ? { finalOutputFull: handle.resultFull } : {}),
                         ...(handle.resultIsPartial ? { resultIsPartial: true } : {}),
                         ...(handle.error !== undefined ? { error: handle.error } : {}),
                     });
@@ -1103,6 +1106,8 @@ export class TaskRegistry {
         }
         if (outcome.result !== undefined)
             handle.result = outcome.result;
+        if (outcome.resultFull !== undefined)
+            handle.resultFull = outcome.resultFull;
         if (outcome.status === "killed" && outcome.result !== undefined && outcome.result !== "") {
             handle.resultIsPartial = true;
         }
@@ -1119,6 +1124,7 @@ export class TaskRegistry {
             settledAt: Date.now(),
             ...(handle.stoppedBy !== undefined ? { stoppedBy: handle.stoppedBy } : {}),
             ...(handle.result !== undefined ? { finalOutput: handle.result } : {}),
+            ...(handle.resultFull !== undefined ? { finalOutputFull: handle.resultFull } : {}),
             ...(handle.resultIsPartial ? { resultIsPartial: true } : {}),
             ...(handle.error !== undefined ? { error: handle.error } : {}),
         }, ["parkedCheckpointToken", "parkClaimId", "parkedAt"]);
@@ -1841,7 +1847,7 @@ The agent is durably suspended, waiting for an approval decision. It resumes whe
         const body = `status: ${row.status}
 ${row.error ? `error: ${row.error}
 ` : ""}${row.finalOutput ? `--- result${row.resultIsPartial ? " (partial — produced before the task was stopped)" : ""} ---
-${clipTaskOutput(row.finalOutput)}` : "(no result text)"}`;
+${clipTaskOutput(row.finalOutputFull ?? row.finalOutput)}` : "(no result text)"}`;
         return {
             content: delimitUntrusted(`TaskOutput ${row.handle}`, body),
             details: {
@@ -2019,13 +2025,14 @@ ${clipTaskOutput(row.finalOutput)}` : "(no result text)"}`;
         if (abort !== undefined)
             handle.abort = abort;
         handle.result = undefined;
+        handle.resultFull = undefined;
         handle.error = undefined;
         handle.resultIsPartial = undefined;
         handle.stopSource = undefined;
         handle.reviveCycle = (handle.reviveCycle ?? 0) + 1;
         handle.cycleSeq = (handle.cycleSeq ?? 1) + 1;
         handle.updatedAt = Date.now();
-        this.durableAgentWrite(handle, { status: "running" }, ["settledAt", "stoppedBy", "finalOutput", "error", "resultIsPartial", "summary", "recentSteps", "editedFiles", "usage"]);
+        this.durableAgentWrite(handle, { status: "running" }, ["settledAt", "stoppedBy", "finalOutput", "finalOutputFull", "error", "resultIsPartial", "summary", "recentSteps", "editedFiles", "usage"]);
         return { ok: true, cycle: handle.reviveCycle };
     }
     settleRevivedAgent(id, cycle, outcome) {
@@ -2579,7 +2586,7 @@ The agent is still working — you will be notified when it completes.`
             : `status: ${handle.status}
 ${handle.error ? `error: ${handle.error}
 ` : ""}${handle.result ? `--- result${handle.resultIsPartial ? " (partial — produced before the task was stopped)" : ""} ---
-${clipTaskOutput(handle.result, handle.outputFile)}` : "(no result text)"}`;
+${clipTaskOutput(handle.resultFull ?? handle.result, handle.outputFile)}` : "(no result text)"}`;
         return {
             content: delimitUntrusted(`TaskOutput ${handle.id}`, body),
             details: {

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.435.0",
+  "version": "1.437.0",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",