@sema-agent/core 3.0.0 → 4.0.0

package/dist/brain/openai.js

@@ -1,7 +1,8 @@
 import {} from "../internal/llm.js";
 import { repairTextToolCalls } from "./tool-call-repair.js";
 import { DEGENERATE_MESSAGE, trimDegenerateTail } from "./repetition.js";
-import { createRepetitionPoll, createWalltimeGate } from "./stream-shared.js";
+import { createRepetitionPoll, createWalltimeGate, parseStreamedToolArgs } from "./stream-shared.js";
+import { mintFallbackToolCallId } from "./tool-call-id.js";
 import { WALLTIME_CUTOFF_MESSAGE } from "./walltime.js";
 import { emitBrainTelemetry } from "./status-sink.js";
 import { OPENAI_RESERVED, applyExtraBody, stripAuthHeaders } from "./request-params.js";
@@ -12,23 +13,11 @@ function closeToolCallAccum(acc) {
         return acc.closedTc;
     if (!acc.name)
         return undefined;
-    let args;
-    if (acc.args) {
-        try {
-            const parsed = JSON.parse(acc.args);
-            if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
-                return undefined;
-            args = parsed;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    else {
-        args = {};
-    }
+    const args = parseStreamedToolArgs(acc.args);
+    if (args === undefined)
+        return undefined;
     if (!acc.id)
-        acc.id = `call_${Math.random().toString(36).slice(2)}`;
+        acc.id = mintFallbackToolCallId("call_");
     acc.closedTc = { type: "toolCall", id: acc.id, name: acc.name, arguments: args };
     return acc.closedTc;
 }
@@ -356,6 +345,8 @@ export function createOpenAIBrain(config = {}) {
                 const toolAccum = new Map();
                 let finishReason = null;
                 let usageRaw;
+                let malformedFrames = 0;
+                let malformedSample;
                 const thinkingBlock = { type: "thinking", thinking: "" };
                 const textBlock = { type: "text", text: "" };
                 const pushReasoningDelta = (delta) => {
@@ -438,6 +429,8 @@ export function createOpenAIBrain(config = {}) {
                             chunk = JSON.parse(data);
                         }
                         catch {
+                            malformedFrames++;
+                            malformedSample ??= data.slice(0, 160);
                             return;
                         }
                         if (chunk.usage)
@@ -535,6 +528,12 @@ export function createOpenAIBrain(config = {}) {
                                 text: `\n[note: ${malformed.length} tool call(s) were truncated (finish_reason="${finishReason ?? "?"}") and dropped — re-issue them next turn: ${malformed.join("; ")}]`,
                             });
                         }
+                        if (malformedFrames > 0) {
+                            finalContent.push({
+                                type: "text",
+                                text: `\n[note: ${malformedFrames} provider stream frame(s) were not valid JSON and were dropped — the streamed output may be missing content (first sample: ${JSON.stringify(malformedSample)})]`,
+                            });
+                        }
                         const truncatedEmpty = finishReason === "length" && noUsableContent && !toolError;
                         const dynamicCut = truncatedEmpty && options?.maxTokensDynamic === true;
                         const safetyCut = finishReason === "content_filter";
@@ -557,7 +556,7 @@ export function createOpenAIBrain(config = {}) {
                                                     ? `[length_empty] response truncated at max_tokens (finish_reason="length", ${maxTokensNote}) with no answer text — the model spent the whole budget on reasoning (${accumReasoning.length} reasoning chars). Raise max_tokens, or disable thinking for this task.`
                                                     : `[length_empty] response truncated at max_tokens (finish_reason="length", ${maxTokensNote}) with no answer text — raise max_tokens`
                                                 : emptyNoFinish
-                                                    ? `[stream_torn] model stream ended with no content and no finish_reason — the response was lost (a torn stream or an in-band provider error frame)`
+                                                    ? `[stream_torn] model stream ended with no content and no finish_reason — the response was lost (a torn stream or an in-band provider error frame)${malformedFrames > 0 ? ` — ${malformedFrames} unparseable data frame(s) were dropped on this stream (first sample: ${JSON.stringify(malformedSample)})` : ""}`
                                                     : undefined));
                         const errored = walltime.cut ||
                             degenerate ||
@@ -566,9 +565,13 @@ export function createOpenAIBrain(config = {}) {
                             emptyNoFinish ||
                             (toolError !== undefined && noUsableContent) ||
                             (truncatedEmpty && !dynamicCut);
-                        const errorKind = !walltime.cut && !degenerate && !safetyCut && !refused && toolError === undefined && truncatedEmpty && !dynamicCut
-                            ? "length_empty"
-                            : undefined;
+                        const errorKind = walltime.cut
+                            ? "walltime_cutoff"
+                            : degenerate
+                                ? "degenerate"
+                                : !safetyCut && !refused && toolError === undefined && truncatedEmpty && !dynamicCut
+                                    ? "length_empty"
+                                    : undefined;
                         const finalMessage = {
                             ...partial,
                             content: finalContent.length > 0 ? finalContent : [{ type: "text", text: "" }],

package/dist/brain/stream-engine.js

@@ -8,7 +8,7 @@ const DEFAULT_MAX_RETRIES = 10;
 const MAX_RETRIES_ENV_CEILING = 15;
 const MAX_RETRIES_ENV = "SEMA_MAX_RETRIES";
 export function resolveMaxRetries(configured) {
-    if (configured !== undefined)
+    if (configured !== undefined && Number.isFinite(configured))
         return configured;
     const raw = process.env[MAX_RETRIES_ENV];
     if (raw !== undefined && raw.trim() !== "") {
@@ -88,10 +88,13 @@ export function runStreamingBrain(args) {
         .catch((err) => {
         const aborted = signal?.aborted === true || isAbortError(err);
         terminalRetryPhase = "gave_up";
-        terminalRetryDetail = aborted ? "cancelled while retrying" : isWalltimeCutoff(err) ? "wall-clock deadline reached while retrying" : "retries exhausted";
+        const walltimeCut = isWalltimeCutoff(err);
+        terminalRetryDetail = aborted ? "cancelled while retrying" : walltimeCut ? "wall-clock deadline reached while retrying" : "retries exhausted";
         const errorMsg = emptyAssistant(model);
         errorMsg.stopReason = aborted ? "aborted" : "error";
         errorMsg.errorMessage = err instanceof Error ? err.message : String(err);
+        if (walltimeCut)
+            errorMsg.errorKind = "walltime_cutoff";
         errorMsg.usageMissing = true;
         out.push({ type: "error", reason: aborted ? "aborted" : "error", error: errorMsg });
     })

package/dist/brain/stream-shared.d.ts

@@ -1,4 +1,5 @@
 import { type RepetitionEvent } from "./repetition.js";
+export declare function parseStreamedToolArgs(json: string): Record<string, unknown> | undefined;
 export interface RepetitionPoll {
     poll(text: string): boolean;
     readonly cut: RepetitionEvent | undefined;

package/dist/brain/stream-shared.js

@@ -1,4 +1,18 @@
 import { inspectDegenerate } from "./repetition.js";
+export function parseStreamedToolArgs(json) {
+    if (!json)
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+        return undefined;
+    return parsed;
+}
 export function createRepetitionPoll() {
     let repCut;
     const repSpared = new Map();

package/dist/brain/terminal-cause.d.ts

@@ -0,0 +1,4 @@
+import type { AssistantMessage } from "../internal/llm.js";
+export type TerminalCauseCarrier = Pick<AssistantMessage, "errorKind" | "errorMessage">;
+export declare function isDegenerateCutMessage(message: TerminalCauseCarrier): boolean;
+export declare function isWalltimeCutMessage(message: TerminalCauseCarrier): boolean;

package/dist/brain/terminal-cause.js

@@ -0,0 +1,12 @@
+import { DEGENERATE_MESSAGE } from "./repetition.js";
+import { WALLTIME_CUTOFF_MESSAGE } from "./walltime.js";
+export function isDegenerateCutMessage(message) {
+    if (message.errorKind === "degenerate")
+        return true;
+    return message.errorMessage === DEGENERATE_MESSAGE;
+}
+export function isWalltimeCutMessage(message) {
+    if (message.errorKind === "walltime_cutoff")
+        return true;
+    return message.errorMessage === WALLTIME_CUTOFF_MESSAGE;
+}

package/dist/brain/tool-call-id.d.ts

@@ -0,0 +1 @@
+export declare function mintFallbackToolCallId(prefix: string): string;

package/dist/brain/tool-call-id.js

@@ -0,0 +1,3 @@
+export function mintFallbackToolCallId(prefix) {
+    return `${prefix}${Math.random().toString(36).slice(2)}`;
+}

package/dist/brain/tool-call-repair.js

@@ -1,3 +1,4 @@
+import { mintFallbackToolCallId } from "./tool-call-id.js";
 const TAG_RE = /<(tool_call|function_call|tool_calls|function_calls)>\s*([\s\S]*?)\s*<\/\1>/gi;
 const FENCE_RE = /```(?:json|tool_call|tool|function)?\s*([\s\S]*?)```/gi;
 function asRecord(v) {
@@ -41,7 +42,7 @@ function extractCall(obj, toolNames, framed) {
     }
     return {
         type: "toolCall",
-        id: `repair_${name}_${Math.random().toString(36).slice(2, 8)}`,
+        id: mintFallbackToolCallId(`repair_${name}_`),
         name,
         arguments: args,
     };

package/dist/core/auto-compaction.js

@@ -5,6 +5,7 @@ import { selectCompactionEpoch } from "../prompt-assembly/epoch.js";
 import { SEMA_DEFAULT_PACK } from "../prompt-assembly/packs/sema-default.js";
 import { brainToRuntime } from "./runtime.js";
 import { defuseFenceMarkers, sanitizeUntrustedText } from "./untrusted-text.js";
+import { createSafeNotifier } from "./safe-notify.js";
 export const DEFAULT_COMPACTION_INSTRUCTIONS = "Preserve verbatim every code, identifier, name, number, file path, error message, credential " +
     "reference, and explicit user instruction or decision mentioned anywhere in the conversation. " +
     "When in doubt, keep the specific detail rather than generalizing it.";
@@ -96,6 +97,7 @@ export async function maybeCompact(opts) {
         return { contextUsage, compacted: false, noop: true };
     }
     const trigger = opts.trigger ?? "auto";
+    const notifier = createSafeNotifier();
     let hookInstructions;
     if (opts.preCompact) {
         let pre;
@@ -183,11 +185,7 @@ export async function maybeCompact(opts) {
         }
         const contentTokens = dry !== undefined ? Math.ceil((dry.conversationChars + (prep.value.previousSummary?.length ?? 0)) / cpt) : 0;
         const observeWindowSafety = (info) => {
-            try {
-                opts.onWindowSafety?.(info);
-            }
-            catch {
-            }
+            notifier.notify(() => opts.onWindowSafety?.(info), "compaction.onWindowSafety");
         };
         if (wantsWindowSafety && dry !== undefined) {
             const tolerance = settings.clampTolerance ?? DEFAULT_CLAMP_TOLERANCE;
@@ -498,27 +496,20 @@ export async function maybeCompact(opts) {
     }
     catch {
     }
-    try {
-        opts.onCompaction?.({
-            messagesCompacted: prep.value.messagesToSummarize.length,
-            freedTokens,
-            tokensBefore: summaryTokensBefore,
-            reused,
-        });
-    }
-    catch {
-    }
+    const messagesCompacted = prep.value.messagesToSummarize.length;
+    notifier.notify(() => opts.onCompaction?.({
+        messagesCompacted,
+        freedTokens,
+        tokensBefore: summaryTokensBefore,
+        reused,
+    }), "compaction.onCompaction");
     if (opts.postCompact) {
-        try {
-            await opts.postCompact({
-                trigger,
-                summary,
-                tokensBefore: summaryTokensBefore,
-                ...(postTriggerTokens !== undefined ? { tokensAfter: postTriggerTokens } : {}),
-            });
-        }
-        catch {
-        }
+        await notifier.notifyAsync(() => opts.postCompact?.({
+            trigger,
+            summary,
+            tokensBefore: summaryTokensBefore,
+            ...(postTriggerTokens !== undefined ? { tokensAfter: postTriggerTokens } : {}),
+        }), "compaction.postCompact");
     }
     const endAt = Date.now();
     return {

package/dist/core/background-agent-store.d.ts

@@ -73,18 +73,24 @@ export declare function canAccessAgentRecord(record: Pick<BackgroundAgentRecord,
     sessionId?: string;
 }): boolean;
 export declare const STALE_RUNNING_REAP_ATTRIBUTION = "the host process was interrupted while this agent was running \u2014 its in-process state was lost. Check its worktree / output file for partial work before assuming the task landed (stale running row reaped).";
+export interface BackgroundAgentUpdateIfExpect {
+    rev: number;
+    status?: BackgroundAgentRecord["status"];
+    parkedCheckpointToken?: string | null;
+    parkClaimId?: string | null;
+}
+export interface BackgroundAgentReapOptions {
+    maxAgeMs?: number;
+    keep?: number;
+    staleRunningMaxAgeMs?: number;
+}
 export interface BackgroundAgentStore {
     put(record: BackgroundAgentRecord): Promise<void>;
     get(handle: string, scope: string): Promise<BackgroundAgentRecord | null>;
     update(handle: string, scope: string, record: BackgroundAgentRecord, expect: {
         rev: number;
     }): Promise<boolean>;
-    updateIf(handle: string, scope: string, record: BackgroundAgentRecord, expect: {
-        rev: number;
-        status?: BackgroundAgentRecord["status"];
-        parkedCheckpointToken?: string | null;
-        parkClaimId?: string | null;
-    }): Promise<boolean>;
+    updateIf(handle: string, scope: string, record: BackgroundAgentRecord, expect: BackgroundAgentUpdateIfExpect): Promise<boolean>;
     listBySession(scope: string, sessionId: string, opts?: {
         status?: BackgroundAgentRecord["status"];
         limit?: number;
@@ -97,11 +103,7 @@ export interface BackgroundAgentStore {
         rev: number;
     }): Promise<boolean>;
     listScopes?(): Promise<string[]>;
-    reap(scope: string, now: number, opts?: {
-        maxAgeMs?: number;
-        keep?: number;
-        staleRunningMaxAgeMs?: number;
-    }): Promise<number>;
+    reap(scope: string, now: number, opts?: BackgroundAgentReapOptions): Promise<number>;
 }
 export declare function reconcileParkedAgents(stores: {
     agentStore: BackgroundAgentStore;
@@ -114,6 +116,13 @@ export declare function reconcileParkedAgents(stores: {
     failed: number;
     rolledBack: number;
 }>;
+export interface BackgroundAgentQuery {
+    scope: string;
+    sessionId?: string;
+    status?: BackgroundAgentRecord["status"];
+    limit?: number;
+}
+export declare function queryBackgroundAgents(rows: Iterable<BackgroundAgentRecord>, query: BackgroundAgentQuery): BackgroundAgentRowSummary[];
 export declare class InMemoryBackgroundAgentStore implements BackgroundAgentStore {
     private rows;
     private key;
@@ -122,12 +131,7 @@ export declare class InMemoryBackgroundAgentStore implements BackgroundAgentStor
     update(handle: string, scope: string, record: BackgroundAgentRecord, expect: {
         rev: number;
     }): Promise<boolean>;
-    updateIf(handle: string, scope: string, record: BackgroundAgentRecord, expect: {
-        rev: number;
-        status?: BackgroundAgentRecord["status"];
-        parkedCheckpointToken?: string | null;
-        parkClaimId?: string | null;
-    }): Promise<boolean>;
+    updateIf(handle: string, scope: string, record: BackgroundAgentRecord, expect: BackgroundAgentUpdateIfExpect): Promise<boolean>;
     listBySession(scope: string, sessionId: string, opts?: {
         status?: BackgroundAgentRecord["status"];
         limit?: number;
@@ -140,9 +144,5 @@ export declare class InMemoryBackgroundAgentStore implements BackgroundAgentStor
         rev: number;
     }): Promise<boolean>;
     listScopes(): Promise<string[]>;
-    reap(scope: string, now: number, opts?: {
-        maxAgeMs?: number;
-        keep?: number;
-        staleRunningMaxAgeMs?: number;
-    }): Promise<number>;
+    reap(scope: string, now: number, opts?: BackgroundAgentReapOptions): Promise<number>;
 }

package/dist/core/background-agent-store.js

@@ -173,6 +173,23 @@ function toSummary(r) {
         ...(r.usage !== undefined ? { usage: structuredClone(r.usage) } : {}),
     };
 }
+export function queryBackgroundAgents(rows, query) {
+    const out = [];
+    for (const r of rows) {
+        if (r.scope !== query.scope)
+            continue;
+        if (query.sessionId !== undefined) {
+            const anchor = r.sessionScoped ? r.owner : r.parentSessionId;
+            if (anchor !== query.sessionId && r.rootSessionId !== query.sessionId)
+                continue;
+        }
+        if (query.status !== undefined && r.status !== query.status)
+            continue;
+        out.push(toSummary(r));
+    }
+    out.sort((a, b) => b.spawnedAt - a.spawnedAt);
+    return query.limit !== undefined ? out.slice(0, Math.max(0, query.limit)) : out;
+}
 export class InMemoryBackgroundAgentStore {
     rows = new Map();
     key(handle, scope) {
@@ -220,31 +237,10 @@ export class InMemoryBackgroundAgentStore {
         return this.update(handle, scope, record, { rev: expect.rev });
     }
     async listBySession(scope, sessionId, opts) {
-        const out = [];
-        for (const r of this.rows.values()) {
-            if (r.scope !== scope)
-                continue;
-            const anchor = r.sessionScoped ? r.owner : r.parentSessionId;
-            if (anchor !== sessionId && r.rootSessionId !== sessionId)
-                continue;
-            if (opts?.status !== undefined && r.status !== opts.status)
-                continue;
-            out.push(toSummary(r));
-        }
-        out.sort((a, b) => b.spawnedAt - a.spawnedAt);
-        return opts?.limit !== undefined ? out.slice(0, Math.max(0, opts.limit)) : out;
+        return queryBackgroundAgents(this.rows.values(), { scope, sessionId, status: opts?.status, limit: opts?.limit });
     }
     async listByScope(scope, opts) {
-        const out = [];
-        for (const r of this.rows.values()) {
-            if (r.scope !== scope)
-                continue;
-            if (opts?.status !== undefined && r.status !== opts.status)
-                continue;
-            out.push(toSummary(r));
-        }
-        out.sort((a, b) => b.spawnedAt - a.spawnedAt);
-        return opts?.limit !== undefined ? out.slice(0, Math.max(0, opts.limit)) : out;
+        return queryBackgroundAgents(this.rows.values(), { scope, status: opts?.status, limit: opts?.limit });
     }
     async delete(handle, scope, expect) {
         const k = this.key(handle, scope);

package/dist/core/checkpoint-store.d.ts

@@ -3,7 +3,8 @@ import type { RepairBundle } from "../agents/repair-loop.js";
 import type { WorkspaceHandle } from "./remote-env.js";
 import type { ConsolidationNote } from "./runner/memory-consolidation.js";
 import type { SessionPermissionRules } from "./session-policy-store.js";
-import type { TaskResult } from "./types.js";
+import type { NestedUsageAccum, TaskResult } from "./types.js";
+import type { ActiveWorktreeSession } from "../internal/harness-types.js";
 export type CheckpointToken = string & {
     readonly __brand: "CheckpointToken";
 };
@@ -112,12 +113,7 @@ export interface CheckpointState {
         value?: unknown;
         set?: boolean;
     };
-    nestedStats: {
-        tokens: number;
-        turns: number;
-        tasks: number;
-        costMicroUsd: number;
-    };
+    nestedStats: NestedUsageAccum;
     consolidationNotes?: ConsolidationNote[];
     readFileState?: Array<[string, ReadEntry]>;
     repairBundle?: RepairBundle;
@@ -131,12 +127,7 @@ export interface CheckpointState {
         description?: string;
     }>;
     handsCwd?: string;
-    activeWorktree?: {
-        worktreeDir: string;
-        originalCwd: string;
-        baseSha: string;
-        entered?: boolean;
-    };
+    activeWorktree?: ActiveWorktreeSession;
     inheritedGate?: {
         ancestorRules?: ReadonlyArray<{
             sessionId: string;
@@ -273,6 +264,8 @@ export declare function validatePendingSteer(steer: {
     text: string;
     trusted: boolean;
 };
+export declare function checkpointRowMatches(cp: Checkpoint | undefined, scope: string, status: Checkpoint["status"]): cp is Checkpoint;
+export declare function checkpointOccMatches(cp: Checkpoint, expect?: ResolveExpectation): boolean;
 export type CheckpointFaultMode = "resolve-after-commit" | "resolve-before-commit";
 export declare class InMemoryCheckpointStore implements CheckpointStore {
     private cps;

package/dist/core/checkpoint-store.js

@@ -237,6 +237,12 @@ export function validatePendingSteer(steer) {
     }
     return { text: steer.text, trusted: steer.trusted };
 }
+export function checkpointRowMatches(cp, scope, status) {
+    return cp !== undefined && cp.scope === scope && cp.status === status;
+}
+export function checkpointOccMatches(cp, expect) {
+    return expect === undefined || (cp.rev ?? 0) === expect.rev;
+}
 export class InMemoryCheckpointStore {
     cps = new Map();
     fault = null;
@@ -256,10 +262,10 @@ export class InMemoryCheckpointStore {
             throw new Error("injected fault: resolve before commit");
         }
         const cp = this.cps.get(token);
-        if (!cp || cp.scope !== scope || cp.status !== "pending") {
+        if (!checkpointRowMatches(cp, scope, "pending")) {
             return false;
         }
-        if (expect !== undefined && (cp.rev ?? 0) !== expect.rev) {
+        if (!checkpointOccMatches(cp, expect)) {
             return false;
         }
         cp.status = "resolved";
@@ -276,7 +282,7 @@ export class InMemoryCheckpointStore {
     }
     async reopen(token, scope, reason) {
         const cp = this.cps.get(token);
-        if (!cp || cp.scope !== scope || cp.status !== "resolved") {
+        if (!checkpointRowMatches(cp, scope, "resolved")) {
             return false;
         }
         cp.status = "pending";
@@ -287,7 +293,7 @@ export class InMemoryCheckpointStore {
     async setPendingSteer(token, scope, steer) {
         const clean = validatePendingSteer(steer);
         const cp = this.cps.get(token);
-        if (!cp || cp.scope !== scope || cp.status !== "pending") {
+        if (!checkpointRowMatches(cp, scope, "pending")) {
             return false;
         }
         cp.state.pendingSteer = clean;
@@ -295,7 +301,7 @@ export class InMemoryCheckpointStore {
     }
     async expire(token, scope) {
         const cp = this.cps.get(token);
-        if (!cp || cp.scope !== scope || cp.status !== "pending") {
+        if (!checkpointRowMatches(cp, scope, "pending")) {
             return false;
         }
         cp.status = "expired";

package/dist/core/file-snapshot-store.d.ts

@@ -1,3 +1,5 @@
+declare function relUnder(root: string, child: string): string | null;
+declare function joinUnder(root: string, rel: string): string;
 import type { ExecutionEnv } from "../internal/harness-types.js";
 export interface FileSnapshotError {
     code: "too_large" | "enumerate_failed" | "read_failed" | "restore_failed" | "not_found" | "aborted";
@@ -51,3 +53,9 @@ export declare class InMemoryFileSnapshotStore implements FileSnapshotStore {
     importManifest(scope: string, key: string, manifest: Map<string, string>, srcGetBlob: (hash: string) => Promise<Uint8Array | undefined>): Promise<FileSnapshotResult>;
     reap(scope: string, keepKeys: string[]): Promise<number>;
 }
+export declare const __testables: {
+    joinUnder: typeof joinUnder;
+    relUnder: typeof relUnder;
+    stripTrailSep: (p: string) => string;
+};
+export {};

package/dist/core/file-snapshot-store.js

@@ -1,8 +1,8 @@
 import { createHash } from "node:crypto";
+import { isAbsolutePathForm, isWinFormPath } from "../tools/fs/safety.js";
 const normSlash = (p) => p.replace(/\\/g, "/");
-const stripTrailSep = (p) => p.replace(/[\\/]+$/, "");
+const stripTrailSep = (p) => (isWinFormPath(p) ? p.replace(/[\\/]+$/, "") : p.replace(/\/+$/, ""));
 const foldDrive = (p) => (/^[A-Za-z]:(\/|$)/.test(p) ? p[0].toLowerCase() + p.slice(1) : p);
-const isWinFormPath = (p) => /^[A-Za-z]:[\\/]/.test(p) || p.startsWith("\\\\") || (!p.startsWith("/") && p.includes("\\"));
 function relUnder(root, child) {
     const fold = isWinFormPath(root) ? normSlash : (p) => p;
     const r = foldDrive(fold(stripTrailSep(root)));
@@ -18,7 +18,7 @@ function joinUnder(root, rel) {
     return stripTrailSep(root) + (win ? "\\" : "/") + (win ? rel.replace(/\//g, "\\") : rel);
 }
 function isUnsafeRelPath(relN) {
-    return relN.startsWith("/") || /^[A-Za-z]:/.test(relN) || relN.split("/").includes("..");
+    return isAbsolutePathForm(relN) || /^[A-Za-z]:/.test(relN) || relN.split("/").includes("..");
 }
 export const DEFAULT_SNAPSHOT_BOUNDS = {
     maxFiles: 10000,
@@ -256,3 +256,4 @@ export class InMemoryFileSnapshotStore {
         return removed;
     }
 }
+export const __testables = { joinUnder, relUnder, stripTrailSep };

package/dist/core/hooks.d.ts

@@ -7,7 +7,9 @@ export interface Hooks {
     userPromptSubmit?(prompt: string): UserPromptSubmitResult | undefined | Promise<UserPromptSubmitResult | undefined>;
     stop?(ctx: StopHookContext): StopHookResult | undefined | Promise<StopHookResult | undefined>;
     postToolUseFailure?(toolName: string, input: unknown, failure: HookToolFailure, ctx: HookToolContext): PostToolUseFailureResult | undefined | Promise<PostToolUseFailureResult | undefined>;
-    postToolBatch?(batch: PostToolBatchCall[]): PostToolBatchResult | undefined | Promise<PostToolBatchResult | undefined>;
+    postToolBatch?(batch: PostToolBatchCall[], meta?: {
+        injectedThisTurn: "final_verification" | "finalize";
+    }): PostToolBatchResult | undefined | Promise<PostToolBatchResult | undefined>;
     preCompact?(ctx: PreCompactContext): PreCompactResult | undefined | Promise<PreCompactResult | undefined>;
     postCompact?(ctx: PostCompactContext): void | Promise<void>;
     stopFailure?(ctx: StopFailureContext): void | Promise<void>;

package/dist/core/hooks.js

@@ -1,6 +1,7 @@
 import { decisionText } from "./tool-policy.js";
 import { inlineUntrusted } from "./untrusted-text.js";
 import { ASK_USER_QUESTION_TOOL_NAME } from "./ask-question.js";
+import { createSafeNotifier } from "./safe-notify.js";
 export function cloneObserverInput(input) {
     try {
         return structuredClone(input);
@@ -23,12 +24,8 @@ function preToolUseCrashReason(subject, err) {
         `This is a failure of the deployment's hook, NOT of the tool itself — an identical retry reaches the ` +
         `same hook and fails the same way. Hook error: ${cause || "(no message)"}`);
 }
-function traceHookCrash(input, err) {
-    try {
-        input.onHookError?.(err);
-    }
-    catch {
-    }
+function traceHookCrash(input, err, notifier) {
+    notifier.notify(() => input.onHookError?.(err), "toolGate.onHookError");
 }
 function withProbeTimeout(p, ms, signal) {
     if (ms === undefined && signal === undefined)
@@ -62,6 +59,7 @@ export async function runToolGate(input) {
     let currentInput = event.input;
     const preToolContext = [];
     let hookAsk;
+    const notifier = createSafeNotifier();
     if (preToolUse) {
         let r;
         try {
@@ -69,13 +67,9 @@ export async function runToolGate(input) {
         }
         catch (err) {
             const reason = preToolUseCrashReason(`this call to "${toolName}"`, err);
-            traceHookCrash(input, err);
+            traceHookCrash(input, err, notifier);
             if (input.permissionDenied) {
-                try {
-                    await input.permissionDenied({ toolName, input: cloneObserverInput(currentInput), toolCallId, reason, source: "hook" });
-                }
-                catch {
-                }
+                await notifier.notifyAsync(() => input.permissionDenied?.({ toolName, input: cloneObserverInput(currentInput), toolCallId, reason, source: "hook" }), "toolGate.permissionDenied");
             }
             return { block: true, reason: formatHookFeedback(reason), preToolContext };
         }
@@ -216,7 +210,7 @@ export async function runToolGate(input) {
                             hr = await preToolUse(toolName, editArgs, { toolCallId, toolName });
                         }
                         catch (err) {
-                            traceHookCrash(input, err);
+                            traceHookCrash(input, err, notifier);
                             editDenied = { action: "deny", reason: preToolUseCrashReason(`the approved edit for "${toolName}"`, err) };
                             denySource = "hook";
                             break;
@@ -288,11 +282,7 @@ export async function runToolGate(input) {
             currentInput = decision.updatedInput;
         }
         if (input.permissionDenied) {
-            try {
-                await input.permissionDenied({ toolName, input: cloneObserverInput(currentInput), toolCallId, reason: denyReason, source: denySource });
-            }
-            catch {
-            }
+            await notifier.notifyAsync(() => input.permissionDenied?.({ toolName, input: cloneObserverInput(currentInput), toolCallId, reason: denyReason, source: denySource }), "toolGate.permissionDenied");
         }
         return {
             block: true,

package/dist/core/lsp.js

@@ -1,4 +1,5 @@
 import { uriToPath } from "./lsp-protocol.js";
+import { foldRedundantPathSegments, isAbsolutePathForm } from "../tools/fs/safety.js";
 import { Type } from "typebox";
 import { defineTool, errorResult } from "./tools.js";
 export const LSP_OPERATIONS = [
@@ -67,10 +68,10 @@ export function settleOnAbort(job, signal, onAbort) {
     });
 }
 export function resolveLspPath(filePath, cwd) {
-    const isAbsForm = filePath.startsWith("/") || /^[A-Za-z]:[\\/]/.test(filePath) || filePath.startsWith("\\\\");
+    const isAbsForm = isAbsolutePathForm(filePath);
     if (isAbsForm || !cwd)
-        return filePath;
-    return cwd.replace(/[\\/]+$/, "") + (cwd.includes("\\") ? "\\" : "/") + filePath;
+        return foldRedundantPathSegments(filePath);
+    return foldRedundantPathSegments(cwd.replace(/[\\/]+$/, "") + (cwd.includes("\\") ? "\\" : "/") + filePath);
 }
 export const MAX_LSP_FILE_BYTES = 10 * 1000 * 1000;
 function fmt(result, ctx) {