@sema-agent/core 2.13.0 → 4.0.0

package/dist/core/tool-errors.js

@@ -1,14 +1,15 @@
 import { Value } from "typebox/value";
 const MAX_ERROR_CHARS = 10_000;
 const HALF = MAX_ERROR_CHARS / 2;
+import { isHighSurrogate, isLowSurrogate, sliceHeadSafe, sliceTailSafe } from "./surrogate-safe-slice.js";
 export function truncateError(s) {
     if (s.length <= MAX_ERROR_CHARS)
         return s;
-    const removed = s.length - MAX_ERROR_CHARS;
-    return `${s.slice(0, HALF)}\n\n... [${removed} characters truncated] ...\n\n${s.slice(s.length - HALF)}`;
+    const head = sliceHeadSafe(s, HALF);
+    const tail = sliceTailSafe(s, HALF);
+    const removed = s.length - head.length - tail.length;
+    return `${head}\n\n... [${removed} characters truncated] ...\n\n${tail}`;
 }
-const isHighSurrogate = (c) => c >= 0xd800 && c <= 0xdbff;
-const isLowSurrogate = (c) => c >= 0xdc00 && c <= 0xdfff;
 export function clipWithFilePointer(s, limit, fullOutputPath) {
     if (s.length <= limit)
         return s;

package/dist/core/tool-name-aliases.js

@@ -52,7 +52,8 @@ export const TOMBSTONED_TOOLS = {
 const MCP_PREFIX = "mcp__";
 const MCP_NAME_SEP = "__";
 export function canonicalToolName(name) {
-    const renamed = OLD_TO_NEW[name] ?? name;
+    const mapped = Object.hasOwn(OLD_TO_NEW, name) ? OLD_TO_NEW[name] : undefined;
+    const renamed = typeof mapped === "string" ? mapped : name;
     if (renamed.includes(MCP_NAME_SEP) && !renamed.startsWith(MCP_PREFIX))
         return MCP_PREFIX + renamed;
     return renamed;

package/dist/core/tool-policy.js

@@ -1,13 +1,14 @@
 import { homedir } from "node:os";
-import { isAbsolute, join, sep } from "node:path";
+import { isAbsolute, join, normalize as normalizePath, sep } from "node:path";
 import { BASH_READONLY_DEFAULT_ALLOW, parseLeadingCommandName } from "../tools/fs/index.js";
+import { writeTargetPath } from "../tools/fs/safety.js";
 import { canonicalToolName } from "./tool-name-aliases.js";
 export function decisionText(d) {
     return d.message ?? d.reason;
 }
 const ALLOW = { action: "allow" };
 function withTimeout(p, ms, onTimeout) {
-    if (!ms || ms <= 0) {
+    if (ms === undefined) {
         return p;
     }
     return new Promise((resolve, reject) => {
@@ -24,7 +25,6 @@ function withTimeout(p, ms, onTimeout) {
                 return;
             settle(resolve, onTimeout());
         }, ms);
-        timer.unref?.();
         p.then((v) => settle(resolve, v), (e) => settle(reject, e));
     });
 }
@@ -50,6 +50,9 @@ export function createAllowDenyPolicy(opts) {
     };
 }
 export function createApprovalPolicy(opts) {
+    if (opts.approvalTimeoutMs !== undefined && !Number.isFinite(opts.approvalTimeoutMs)) {
+        throw new Error(`createApprovalPolicy: approvalTimeoutMs must be a finite number of ms (got ${opts.approvalTimeoutMs}) — omit it to wait indefinitely`);
+    }
     const need = new Set(opts.requireApproval.map(canonicalToolName));
     const deny = new Set((opts.deny ?? []).map(canonicalToolName));
     const auto = new Set((opts.autoAllow ?? []).map(canonicalToolName));
@@ -106,7 +109,7 @@ export function combinePolicies(...policies) {
                     current = { ...current, args: d.updatedInput };
                     rewrite = d;
                 }
-                if (d.action === "ask" && !asked) {
+                if (d.action === "ask" && (asked === undefined || (d.requiresRealApproval === true && asked.requiresRealApproval !== true))) {
                     asked = d;
                 }
             }
@@ -119,10 +122,13 @@ export function combinePolicies(...policies) {
     };
 }
 export const COARSE_SHELL_TOOLS = ["Bash", "Monitor"];
+function canonicalToolNameSet(tools) {
+    return new Set((tools ?? COARSE_SHELL_TOOLS).map(canonicalToolName));
+}
 export function createCoarseCommandNamePolicy(opts) {
     const allow = opts.allow ? new Set(opts.allow) : undefined;
     const deny = new Set(opts.deny ?? []);
-    const shellTools = new Set(opts.tools ?? COARSE_SHELL_TOOLS);
+    const shellTools = canonicalToolNameSet(opts.tools);
     const defaultAction = opts.defaultAction ?? "ask";
     const fallback = (reason) => defaultAction === "deny"
         ? { action: "deny", reason, decisionReason: "rule" }
@@ -154,6 +160,7 @@ const DELETE_HEADS = new Set(["rm", "xargs", "Remove-Item"]);
 const DELETE_WRAPPERS = new Set([
     "sudo", "command", "nohup", "time", "do", "then", "else",
     "env", "nice", "ionice", "exec", "doas", "setsid", "stdbuf", "chroot", "eval",
+    "sh", "bash", "zsh", "dash", "ksh", "ash", "timeout", "case",
 ]);
 const STATEMENT_SPLIT = /[;&|\n]+/;
 const stripTokenEdges = (t) => t.replace(/^[("'{]+|[)"'}]+$/g, "");
@@ -209,7 +216,7 @@ export function findUnverifiableRecursiveDelete(command, safeVars = new Set(UNVE
         }
         return false;
     };
-    const statements = command.split(STATEMENT_SPLIT);
+    const statements = command.replace(/\\\r?\n/g, " ").split(STATEMENT_SPLIT);
     for (const stmt of statements) {
         const tokens = stmt.trim().split(/\s+/).filter(Boolean);
         let i = 0;
@@ -230,6 +237,10 @@ export function findUnverifiableRecursiveDelete(command, safeVars = new Set(UNVE
         let sawWrapper = false;
         while (i < tokens.length) {
             const t = stripTokenEdges(tokens[i]).replace(/^\\/, "");
+            if (t === "") {
+                i++;
+                continue;
+            }
             if (DELETE_WRAPPERS.has(t)) {
                 sawWrapper = true;
                 i++;
@@ -237,8 +248,9 @@ export function findUnverifiableRecursiveDelete(command, safeVars = new Set(UNVE
                     i++;
                 continue;
             }
-            if (t === "timeout" && i + 1 < tokens.length) {
-                i += 2;
+            if (/\)$/.test(tokens[i]) && !DELETE_HEADS.has(t)) {
+                sawWrapper = true;
+                i++;
                 continue;
             }
             break;
@@ -368,7 +380,7 @@ function hasRecursiveForce(argvTail) {
 }
 export function createUnverifiableDeletePolicy(opts) {
     const safeVars = new Set([...UNVERIFIABLE_DELETE_SAFE_VARS, ...(opts?.safeVars ?? [])]);
-    const shellTools = new Set(opts?.tools ?? COARSE_SHELL_TOOLS);
+    const shellTools = canonicalToolNameSet(opts?.tools);
     return {
         check(req) {
             if (!shellTools.has(canonicalToolName(req.toolName)))
@@ -390,10 +402,30 @@ export function createUnverifiableDeletePolicy(opts) {
         },
     };
 }
+function pathSegments(p) {
+    return p.split(/[\\/]/).filter(Boolean);
+}
+const CASE_INSENSITIVE_FS = process.platform === "darwin" || process.platform === "win32";
+const foldPathCase = (s) => (CASE_INSENSITIVE_FS ? s.toLowerCase() : s);
+function lexicalPath(p, home) {
+    const norm = p.normalize("NFC");
+    const expanded = norm === "~" ? home : /^~[\\/]/.test(norm) ? join(home, norm.slice(2)) : norm;
+    return normalizePath(expanded);
+}
+const RELATIVE_TAIL_MIN_SEGMENTS = 2;
+function relativeContinuesDirTail(segs, dirSegs) {
+    const from = Math.min(RELATIVE_TAIL_MIN_SEGMENTS, dirSegs.length);
+    for (let k = from; k <= Math.min(segs.length, dirSegs.length); k++) {
+        const tail = dirSegs.slice(dirSegs.length - k);
+        if (tail.every((s, i) => s === segs[i]))
+            return true;
+    }
+    return false;
+}
 export function createTranscriptIntegrityPolicy(opts) {
     const home = homedir();
     const defaultRoot = (process.env.AGENT_DATA_DIR ?? join(home, ".ai-agent")).normalize("NFC");
-    const dirs = (opts?.sessionsDirs ?? [join(defaultRoot, "sessions")]).map((d) => d.normalize("NFC").replace(/[\\/]+$/, ""));
+    const dirs = (opts?.sessionsDirs ?? [join(defaultRoot, "sessions")]).map((d) => lexicalPath(d, home).replace(/(?<=.)[\\/]+$/, ""));
     const textualForms = dirs.flatMap((d) => {
         const forms = [d];
         if (d.startsWith(home + sep)) {
@@ -403,13 +435,35 @@ export function createTranscriptIntegrityPolicy(opts) {
         return forms;
     });
     const readAllow = new Set(opts?.readAllow ?? BASH_READONLY_DEFAULT_ALLOW);
-    const shellTools = new Set(opts?.tools ?? COARSE_SHELL_TOOLS);
+    const shellTools = canonicalToolNameSet(opts?.tools);
+    const dirSegs = dirs.map((d) => pathSegments(d).map(foldPathCase));
     const inProtectedDir = (p) => {
-        const norm = p.normalize("NFC");
-        const abs = norm.startsWith("~" + sep) || norm === "~" ? join(home, norm.slice(1)) : norm;
-        if (!isAbsolute(abs))
-            return false;
-        return dirs.some((d) => abs === d || abs.startsWith(d + sep));
+        const abs = lexicalPath(p, home);
+        const segs = pathSegments(abs).map(foldPathCase);
+        if (isAbsolute(abs)) {
+            return dirSegs.some((d) => d.length <= segs.length && d.every((s, i) => s === segs[i]));
+        }
+        return dirSegs.some((d) => relativeContinuesDirTail(segs, d));
+    };
+    const referencesProtectedDir = (cmd) => {
+        const hay = foldPathCase(cmd);
+        if (textualForms.some((f) => hay.includes(foldPathCase(f))))
+            return true;
+        for (const raw of cmd.split(/[\s;&|<>()]+/)) {
+            if (raw === "")
+                continue;
+            const unquoted = raw.replace(/["'`]/g, "");
+            if (unquoted === "")
+                continue;
+            const expanded = unquoted.startsWith("${HOME}")
+                ? home + unquoted.slice("${HOME}".length)
+                : unquoted.startsWith("$HOME")
+                    ? home + unquoted.slice("$HOME".length)
+                    : unquoted;
+            if (inProtectedDir(expanded))
+                return true;
+        }
+        return false;
     };
     const askReason = (what) => ({
         action: "ask",
@@ -428,7 +482,7 @@ export function createTranscriptIntegrityPolicy(opts) {
                 if (typeof command !== "string")
                     return ALLOW;
                 const cmd = command.normalize("NFC");
-                if (!textualForms.some((f) => cmd.includes(f)))
+                if (!referencesProtectedDir(cmd))
                     return ALLOW;
                 const parsed = parseLeadingCommandName(command);
                 if ("name" in parsed && readAllow.has(parsed.name))
@@ -438,8 +492,7 @@ export function createTranscriptIntegrityPolicy(opts) {
                     : "the command references the transcript directory and is not a single read-only command (fail-closed)");
             }
             if (toolName === "Write" || toolName === "Edit" || toolName === "NotebookEdit") {
-                const a = req.args;
-                const p = a?.file_path ?? a?.notebook_path;
+                const p = writeTargetPath(toolName, req.args);
                 if (typeof p === "string" && inProtectedDir(p)) {
                     return askReason(`"${p}" is inside the session-transcript directory`);
                 }

package/dist/core/tool-result-store.d.ts

@@ -45,6 +45,7 @@ export declare class ScopedToolResultStore implements ToolResultStore {
 }
 export declare function isVolatileOffloadStore(store: ToolResultStore): boolean;
 export declare const OFFLOAD_TOOL_NAME = "ReadToolResult";
+export declare function createOffloadPersist(store: ToolResultStore, sessionId: string): (toolCallId: string, fullText: string) => string;
 export declare function offloadPagebackHint(ref: string, form: "preview" | "cleared", reachableTools?: ReadonlySet<string>): string;
 export declare const PERSISTED_OUTPUT_PREFIX = "<persisted-output ref=";
 export declare const DEFAULT_TOOL_RESULT_THRESHOLD_CHARS = 20000;

package/dist/core/tool-result-store.js

@@ -29,6 +29,10 @@ export class InMemoryToolResultStore {
     totalChars = 0;
     constructor(opts) {
         this.opts = opts;
+        const cap = opts?.maxTotalChars;
+        if (cap !== undefined && Number.isNaN(cap)) {
+            throw new Error("InMemoryToolResultStore: maxTotalChars must be a number (got NaN) — omit it for an unbounded store");
+        }
     }
     put(ref, content) {
         assertSafeToolResultRef(ref);
@@ -37,7 +41,7 @@ export class InMemoryToolResultStore {
         this.map.set(ref, content);
         this.totalChars += content.length;
         const cap = this.opts?.maxTotalChars;
-        if (cap !== undefined && cap > 0) {
+        if (cap !== undefined && Number.isFinite(cap)) {
             for (const [oldRef, oldContent] of this.map) {
                 if (this.totalChars <= cap || oldRef === ref)
                     break;
@@ -93,6 +97,16 @@ export function isVolatileOffloadStore(store) {
     return store instanceof InMemoryToolResultStore;
 }
 export const OFFLOAD_TOOL_NAME = "ReadToolResult";
+export function createOffloadPersist(store, sessionId) {
+    return (toolCallId, fullText) => {
+        const ref = buildToolResultRef(sessionId, toolCallId);
+        void Promise.resolve(store.put(ref, fullText)).catch((err) => {
+            const cause = err instanceof Error ? err.message : String(err);
+            void Promise.resolve(store.put(ref, `[offload LOST at write time: ${cause} — the inline preview is all that survived]`)).catch(() => undefined);
+        });
+        return ref;
+    };
+}
 export function offloadPagebackHint(ref, form, reachableTools) {
     const activate = reachableTools !== undefined && !reachableTools.has(OFFLOAD_TOOL_NAME)
         ? `${OFFLOAD_TOOL_NAME} is not active yet — call ${TOOL_SEARCH_NAME} with {"query":"select:${OFFLOAD_TOOL_NAME}"} to activate it, then `
@@ -144,6 +158,8 @@ export function buildPreview(full, ref, sizes, reachableTools) {
         `</persisted-output>`);
 }
 export function withToolResultOffload(tool, store, thresholdChars, sessionId, reachableTools) {
+    if (!(Number.isFinite(thresholdChars) && thresholdChars > 0))
+        return tool;
     const wrappedExecute = async (toolCallId, params, signal, onUpdate) => {
         const res = await tool.execute(toolCallId, params, signal, onUpdate);
         if (totalTextChars(res.content) <= thresholdChars)

package/dist/core/trace.d.ts

@@ -1,5 +1,6 @@
 import type { TaskStatus, ToolEffect } from "./types.js";
 import type { ThinkingLevel } from "../internal/harness-types.js";
+import type { ToolManifestRow } from "../prompt-assembly/tool-catalog.js";
 export interface TraceMechanismsSummary {
     finalizeInjected?: true;
     nudgesSent?: number;
@@ -42,15 +43,7 @@ export type TraceEvent = {
         hash: string;
         contentHash?: string;
     }>;
-    tools?: Array<{
-        wireName: string;
-        aliases: string[];
-        contractId: string;
-        implementationRevision: string;
-        cardId: string;
-        shapeDigest: string;
-        wireSchemaDigest: string;
-    }>;
+    tools?: ToolManifestRow[];
     totalChars: number;
     snapshot?: {
         cacheIdentity: string;
@@ -140,6 +133,7 @@ export type TraceEvent = {
     provider?: string;
     turn?: number;
     promptTokens: number;
+    totalInputTokens: number;
     completionTokens: number;
     cacheRead: number;
     cacheWrite: number;

package/dist/core/types.d.ts

@@ -57,6 +57,19 @@ export type ToolReturn = string | {
     terminate?: boolean;
     isError?: boolean;
 };
+export interface NestedUsage {
+    tokens: number;
+    turns: number;
+    tasks: number;
+    costMicroUsd?: number;
+}
+export interface NestedUsageAccum {
+    tokens: number;
+    turns: number;
+    tasks: number;
+    costMicroUsd: number;
+    anyUnpriced: boolean;
+}
 export interface ToolExecuteContext {
     toolCallId: string;
     signal?: AbortSignal;
@@ -81,12 +94,7 @@ export interface ToolExecuteContext {
         release: () => Promise<void>;
     } | null>;
     parentCwd?: string;
-    reportUsage?: (usage: {
-        tokens: number;
-        turns: number;
-        tasks: number;
-        costMicroUsd?: number;
-    }) => void;
+    reportUsage?: (usage: NestedUsage) => void;
     model?: Model;
     thinkingLevel?: ThinkingLevel;
     principal?: string;
@@ -412,12 +420,7 @@ export interface TaskResult {
         outputTokens?: number;
         cacheWriteTokensLong?: number;
         costMicroUsd?: number;
-        nested?: {
-            tokens: number;
-            turns: number;
-            tasks: number;
-            costMicroUsd?: number;
-        };
+        nested?: NestedUsage;
         memory?: {
             tokens: number;
             costMicroUsd: number;
@@ -524,6 +527,7 @@ export type TaskEvent = ({
     type: "turn_end";
     usage?: {
         inputTokens: number;
+        totalInputTokens: number;
         outputTokens: number;
         cacheReadTokens: number;
         cacheWriteTokens: number;

package/dist/core/untrusted-egress.js

@@ -1,5 +1,6 @@
 import { delimitUntrusted } from "./untrusted-text.js";
 import { scrubSecrets } from "./arg-summary.js";
+import { sliceHeadSafe } from "./surrogate-safe-slice.js";
 const URI_SCHEME = String.raw `[A-Za-z][A-Za-z0-9+.\-_]{0,63}`;
 const CREDENTIALS_IN_AUTHORITY = new RegExp(String.raw `(${URI_SCHEME}:\/\/)((?:[^/\s"'@]*@)+)`, "gi");
 const URL_OF_ANY_PROTOCOL = new RegExp(String.raw `${URI_SCHEME}:\/\/[^\s"'\`]+`, "gi");
@@ -52,16 +53,17 @@ function boundedString(value, max, redact) {
     if (s.length <= max)
         return s;
     const totalMarkers = countRedactionMarkers(s);
-    const plainSuffix = (keepN) => `…[+${s.length - keepN} chars]`;
-    const enrichedSuffix = (keepN) => {
-        const lost = totalMarkers - countRedactionMarkers(s.slice(0, keepN));
-        return lost > 0 ? `…[+${s.length - keepN} chars, ${lost} redaction marker(s) among them]` : plainSuffix(keepN);
+    const plainSuffix = (kept) => `…[+${s.length - kept.length} chars]`;
+    const enrichedSuffix = (kept) => {
+        const lost = totalMarkers - countRedactionMarkers(kept);
+        return lost > 0 ? `…[+${s.length - kept.length} chars, ${lost} redaction marker(s) among them]` : plainSuffix(kept);
     };
     const converge = (suffixFor) => {
         let keep = max;
         let out = "";
         for (let i = 0; i < 4; i++) {
-            out = `${s.slice(0, keep)}${suffixFor(keep)}`;
+            const kept = sliceHeadSafe(s, keep);
+            out = `${kept}${suffixFor(kept)}`;
             if (out.length <= max)
                 return out;
             if (keep === 0)

package/dist/core/workflow-journal-store.d.ts

@@ -3,23 +3,20 @@ export interface WorkflowJournalEntry {
     callKey: string;
     result: TaskResult;
 }
+export interface ResumeClaimArgs {
+    sourceRunId: string;
+    newRunId: string;
+    scope: string;
+}
 export interface WorkflowJournalStore {
     load(runId: string, scope: string): Promise<WorkflowJournalEntry[]>;
     append(runId: string, scope: string, entry: WorkflowJournalEntry): Promise<void>;
     locator?(runId: string, scope: string): string | undefined;
-    resumeClaim?(input: {
-        sourceRunId: string;
-        newRunId: string;
-        scope: string;
-    }): Promise<{
+    resumeClaim?(input: ResumeClaimArgs): Promise<{
         granted: boolean;
         holder?: string;
     }>;
-    releaseResumeClaim?(input: {
-        sourceRunId: string;
-        newRunId: string;
-        scope: string;
-    }): Promise<void>;
+    releaseResumeClaim?(input: ResumeClaimArgs): Promise<void>;
 }
 export declare const MAX_JOURNAL_RESULT_BYTES: number;
 export declare function oversizeJournalResult(serialized: string): boolean;
@@ -31,19 +28,11 @@ export declare class InMemoryWorkflowJournalStore implements WorkflowJournalStor
     private readonly runs;
     private readonly resumeClaims;
     private claimsForScope;
-    resumeClaim(input: {
-        sourceRunId: string;
-        newRunId: string;
-        scope: string;
-    }): Promise<{
+    resumeClaim(input: ResumeClaimArgs): Promise<{
         granted: boolean;
         holder?: string;
     }>;
-    releaseResumeClaim(input: {
-        sourceRunId: string;
-        newRunId: string;
-        scope: string;
-    }): Promise<void>;
+    releaseResumeClaim(input: ResumeClaimArgs): Promise<void>;
     load(runId: string, scope: string): Promise<WorkflowJournalEntry[]>;
     append(runId: string, scope: string, entry: WorkflowJournalEntry): Promise<void>;
 }

package/dist/core/workflow-run-store.d.ts

@@ -21,22 +21,27 @@ export declare class WorkflowRunStoreError extends Error {
     readonly code: "workflow_run.already_exists";
     constructor(code: "workflow_run.already_exists", message: string);
 }
+export interface WorkflowRunListByScopeOptions {
+    status?: WorkflowRunStatus;
+    limit?: number;
+    session?: string;
+}
 export interface WorkflowRunStore {
     put(id: string, run: WorkflowRun): Promise<void>;
     get(id: string): Promise<WorkflowRun | null>;
     update(id: string, scope: string, run: WorkflowRun, expect?: {
         rev: number;
     }): Promise<boolean>;
-    listByScope(scope: string, opts?: {
-        status?: WorkflowRunStatus;
-        limit?: number;
-        session?: string;
-    }): Promise<WorkflowRunSummary[]>;
+    listByScope(scope: string, opts?: WorkflowRunListByScopeOptions): Promise<WorkflowRunSummary[]>;
     reap(scope: string, now: number, opts?: {
         maxAgeMs?: number;
         keep?: number;
     }): Promise<number>;
 }
+export declare function nextWorkflowRunOnUpdate(cur: WorkflowRun | undefined, id: string, scope: string, run: WorkflowRun, expect?: {
+    rev: number;
+}): WorkflowRun | null;
+export declare function queryWorkflowRuns(runs: Iterable<WorkflowRun>, scope: string, opts?: WorkflowRunListByScopeOptions): WorkflowRunSummary[];
 export declare class InMemoryWorkflowRunStore implements WorkflowRunStore {
     private runs;
     put(id: string, run: WorkflowRun): Promise<void>;
@@ -44,11 +49,7 @@ export declare class InMemoryWorkflowRunStore implements WorkflowRunStore {
     update(id: string, scope: string, run: WorkflowRun, expect?: {
         rev: number;
     }): Promise<boolean>;
-    listByScope(scope: string, opts?: {
-        status?: WorkflowRunStatus;
-        limit?: number;
-        session?: string;
-    }): Promise<WorkflowRunSummary[]>;
+    listByScope(scope: string, opts?: WorkflowRunListByScopeOptions): Promise<WorkflowRunSummary[]>;
     reap(scope: string, now: number, opts?: {
         maxAgeMs?: number;
         keep?: number;

package/dist/core/workflow-run-store.js

@@ -28,6 +28,25 @@ export class WorkflowRunStoreError extends Error {
         this.name = "WorkflowRunStoreError";
     }
 }
+export function nextWorkflowRunOnUpdate(cur, id, scope, run, expect) {
+    if (!cur || cur.scope !== scope)
+        return null;
+    if (expect !== undefined && (cur.rev ?? 0) !== expect.rev)
+        return null;
+    const next = structuredClone(run);
+    next.id = id;
+    next.scope = scope;
+    next.rev = (cur.rev ?? 0) + 1;
+    return next;
+}
+export function queryWorkflowRuns(runs, scope, opts) {
+    const rows = [...runs].filter((r) => r.scope === scope &&
+        (opts?.status === undefined || r.status === opts.status) &&
+        (opts?.session === undefined || r.originatingSessionId === opts.session));
+    rows.sort((a, b) => b.createdAt - a.createdAt);
+    const limited = opts?.limit !== undefined ? rows.slice(0, Math.max(0, opts.limit)) : rows;
+    return limited.map(summarizeWorkflowRun);
+}
 export class InMemoryWorkflowRunStore {
     runs = new Map();
     async put(id, run) {
@@ -44,27 +63,14 @@ export class InMemoryWorkflowRunStore {
         return run ? structuredClone(run) : null;
     }
     async update(id, scope, run, expect) {
-        const cur = this.runs.get(id);
-        if (!cur || cur.scope !== scope) {
+        const next = nextWorkflowRunOnUpdate(this.runs.get(id), id, scope, run, expect);
+        if (!next)
             return false;
-        }
-        if (expect !== undefined && (cur.rev ?? 0) !== expect.rev) {
-            return false;
-        }
-        const next = structuredClone(run);
-        next.id = id;
-        next.scope = scope;
-        next.rev = (cur.rev ?? 0) + 1;
         this.runs.set(id, next);
         return true;
     }
     async listByScope(scope, opts) {
-        const rows = [...this.runs.values()].filter((r) => r.scope === scope &&
-            (opts?.status === undefined || r.status === opts.status) &&
-            (opts?.session === undefined || r.originatingSessionId === opts.session));
-        rows.sort((a, b) => b.createdAt - a.createdAt);
-        const limited = opts?.limit !== undefined ? rows.slice(0, Math.max(0, opts.limit)) : rows;
-        return limited.map(summarizeWorkflowRun);
+        return queryWorkflowRuns(this.runs.values(), scope, opts);
     }
     async reap(scope, now, opts) {
         if (opts?.maxAgeMs === undefined && opts?.keep === undefined)

package/dist/engine/compaction/compaction.d.ts

@@ -78,3 +78,4 @@ export interface CompactionPreparation {
 export declare function prepareCompaction(pathEntries: SessionTreeEntry[], settings: CompactionSettings, charsPerToken?: number, windowTokens?: number): Result<CompactionPreparation | undefined, CompactionError>;
 export { computeFileLists, serializeConversation } from "./utils.js";
 export declare function compact(preparation: CompactionPreparation, model: Model, apiKey: string | undefined, headers?: Record<string, string>, customInstructions?: string, signal?: AbortSignal, thinkingLevel?: ThinkingLevel, streamFn?: StreamFn, runtime?: AgentCoreCompletionRuntimeDeps, charsPerToken?: number, onInputTruncated?: (info: SummarizationInputTruncation) => void, onPtlRetry?: () => void): Promise<Result<CompactionResult, CompactionError>>;
+export declare function turnPrefixSummarizationPrompt(customInstructions?: string): string;

package/dist/engine/compaction/compaction.js

@@ -132,6 +132,9 @@ export function shouldCompact(contextTokens, contextWindow, settings) {
     if (!settings.enabled) {
         return false;
     }
+    if (!Number.isFinite(contextWindow) || contextWindow <= 0) {
+        return false;
+    }
     return contextTokens > contextWindow - settings.reserveTokens;
 }
 export function estimateTokens(message, charsPerToken = DEFAULT_CHARS_PER_TOKEN) {
@@ -539,7 +542,7 @@ export function dryRunSummarizationClamp(preparation, model, customInstructions,
     if (isSplitTurn && turnPrefixMessages.length > 0) {
         const text = serializeConversation(convertToLlm(turnPrefixMessages));
         conversationChars += text.length;
-        const clamped = clampSummarizationConversation(text, model, cpt, SUMMARIZATION_SYSTEM_PROMPT.length + TURN_PREFIX_SUMMARIZATION_PROMPT.length + 128, Math.floor(0.5 * summaryBudget));
+        const clamped = clampSummarizationConversation(text, model, cpt, SUMMARIZATION_SYSTEM_PROMPT.length + turnPrefixSummarizationPrompt(customInstructions).length + 128, Math.floor(0.5 * summaryBudget));
         dropped += Math.max(0, clamped.droppedChars);
         kept += clamped.keptChars;
     }
@@ -879,7 +882,7 @@ export async function compact(preparation, model, apiKey, headers, customInstruc
                 ? generateSummary(messagesToSummarize, model, summaryBudget, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, runtime, charsPerToken, onInputTruncated, onPtlRetry)
                 :
                     Promise.resolve(ok(previousSummary ? stripFileOperationsFooter(previousSummary) : "No prior history.")),
-            generateTurnPrefixSummary(turnPrefixMessages, model, summaryBudget, apiKey, headers, signal, thinkingLevel, streamFn, runtime, charsPerToken, onInputTruncated, onPtlRetry),
+            generateTurnPrefixSummary(turnPrefixMessages, model, summaryBudget, apiKey, headers, signal, customInstructions, thinkingLevel, streamFn, runtime, charsPerToken, onInputTruncated, onPtlRetry),
         ]);
         if (!historyResult.ok) {
             return err(historyResult.error);
@@ -913,16 +916,22 @@ export async function compact(preparation, model, apiKey, headers, customInstruc
         },
     });
 }
-async function generateTurnPrefixSummary(messages, model, summaryBudgetTokens, apiKey, headers, signal, thinkingLevel, streamFn, runtime, charsPerToken, onInputTruncated, onPtlRetry) {
+export function turnPrefixSummarizationPrompt(customInstructions) {
+    return customInstructions
+        ? `${TURN_PREFIX_SUMMARIZATION_PROMPT}\n\nAdditional Instructions:\n${customInstructions}`
+        : TURN_PREFIX_SUMMARIZATION_PROMPT;
+}
+async function generateTurnPrefixSummary(messages, model, summaryBudgetTokens, apiKey, headers, signal, customInstructions, thinkingLevel, streamFn, runtime, charsPerToken, onInputTruncated, onPtlRetry) {
     const llmMessages = convertToLlm(messages);
+    const basePrompt = turnPrefixSummarizationPrompt(customInstructions);
     return summarizeWithPtlRetry({
         label: "Turn prefix summarization",
         truncationLabel: "turn_prefix",
         llmMessages,
-        buildPromptText: (conversationText) => `<conversation>\n${conversationText}\n</conversation>\n\n${TURN_PREFIX_SUMMARIZATION_PROMPT}`,
+        buildPromptText: (conversationText) => `<conversation>\n${conversationText}\n</conversation>\n\n${basePrompt}`,
         model,
         cpt: charsPerToken ?? model.charsPerToken ?? DEFAULT_CHARS_PER_TOKEN,
-        fixedPromptChars: SUMMARIZATION_SYSTEM_PROMPT.length + TURN_PREFIX_SUMMARIZATION_PROMPT.length + 128,
+        fixedPromptChars: SUMMARIZATION_SYSTEM_PROMPT.length + basePrompt.length + 128,
         baseMaxTokens: Math.floor(0.5 * summaryBudgetTokens),
         apiKey,
         headers,

package/dist/engine/compaction/utils.js

@@ -1,4 +1,5 @@
 import { normalizeLlmMessageContent } from "../harness/messages.js";
+import { sliceHeadSafe } from "../../core/surrogate-safe-slice.js";
 import { cutEnginePrefix, cutEngineSegments, flattenableUserText } from "../../core/untrusted-text.js";
 import { fileArgPath } from "../../tools/fs/safety.js";
 export function createFileOps() {
@@ -287,11 +288,12 @@ function truncateForSummary(text, maxChars) {
     let keep = maxChars;
     let out = "";
     for (let i = 0; i < 4; i++) {
-        out = `${text.slice(0, keep)}\n\n[... ${text.length - keep} more characters truncated]`;
+        const kept = sliceHeadSafe(text, keep);
+        out = `${kept}\n\n[... ${text.length - kept.length} more characters truncated]`;
         if (out.length <= maxChars)
             break;
         if (keep === 0)
-            return maxChars >= 1 ? `${text.slice(0, maxChars - 1)}…` : "";
+            return maxChars >= 1 ? `${sliceHeadSafe(text, maxChars - 1)}…` : "";
         keep = Math.max(0, keep - (out.length - maxChars));
     }
     return out.length < text.length ? out : text;