@sema-agent/core 7.23.5 → 7.24.0

package/dist/brain/stream-engine.js

@@ -1,13 +1,13 @@
 import { createAssistantMessageEventStream, } from "../internal/llm.js";
 import { STREAM_TORN_WARNING } from "./stream-shared.js";
 import { FLOOR_OUTPUT_TOKENS, parseContextOverflow, planOutputCapAdjustment } from "./context-overflow.js";
-import { abortLikeName, BrainError, classifyConnectFailure, classifyFetchThrow, classifyHttp, describeNetworkError, namesTheFailure, readProviderRequestId } from "./errors.js";
+import { abortLikeName, BrainError, brainErrorCodeOf, classifyConnectFailure, classifyFetchThrow, classifyHttp, describeNetworkError, namesTheFailure, readProviderRequestId } from "./errors.js";
 import { stripUrlCredentials } from "./route-adjudicator.js";
 import { classifyInputTooLong } from "./input-too-long.js";
 import { FAST_MAX_BACKOFF_MS, providerWaitHint, retryBackoffMs } from "./retry.js";
 import { bindBrainStatusEmitter, emitBrainStatus, emitBrainTelemetry } from "./status-sink.js";
 import { createConnectController, resolveStallTimeoutMs } from "./timeout.js";
-import { thrownText } from "../core/thrown-value.js";
+import { readMember, thrownText } from "../core/thrown-value.js";
 import { redactSecrets } from "../core/untrusted-egress.js";
 const DEFAULT_MAX_RETRIES = 10;
 const MAX_RETRIES_ENV_CEILING = 15;
@@ -274,15 +274,17 @@ export function runStreamingBrain(args) {
         const errorMsg = emptyAssistant(model);
         errorMsg.stopReason = aborted ? "aborted" : "error";
         errorMsg.errorMessage = thrownText(err);
-        if (!aborted && err instanceof BrainError) {
-            if (err.inputTooLong === true)
+        if (!aborted && brainErrorCodeOf(err) !== undefined) {
+            if (readMember(err, "inputTooLong") === true)
                 errorMsg.errorKind = "input_too_long";
-            else if (err.inputTooLongRuledOut === true)
+            else if (readMember(err, "inputTooLongRuledOut") === true)
                 errorMsg.inputTooLongRuledOut = true;
-            if (err.apiError === true) {
+            if (readMember(err, "apiError") === true) {
                 errorMsg.isApiErrorMessage = true;
-                if (namesTheFailure(err.status))
-                    errorMsg.apiErrorStatus = err.status;
+                const status = readMember(err, "status");
+                const statusNum = typeof status === "number" ? status : undefined;
+                if (namesTheFailure(statusNum))
+                    errorMsg.apiErrorStatus = statusNum;
                 if (requestIdSeen !== undefined)
                     errorMsg.requestId = requestIdSeen;
             }
@@ -581,7 +583,7 @@ export function runStreamingBrain(args) {
                     return false;
                 }
                 catch (e) {
-                    if (!(e instanceof BrainError) || e.code !== "server" || !parser.snapshot().hasSubstantiveText)
+                    if (brainErrorCodeOf(e) !== "server" || !parser.snapshot().hasSubstantiveText)
                         throw e;
                     return true;
                 }

package/dist/core/arg-summary.js

@@ -196,14 +196,15 @@ export function runRedactionPasses(input, passes, report) {
     return result;
 }
 export const SECRET_PASSES = [
-    { kind: "prefixed-token", confidence: "high", marker: "[redacted]", source: "arg-summary", re: /(?<![A-Za-z0-9])(?:sk|pk|rk|gh[opsur])[-_][A-Za-z0-9_-]{8,}/g, replace: "[redacted]" },
+    { kind: "prefixed-token", confidence: "high", marker: "[redacted]", source: "arg-summary", re: /(?<![A-Za-z0-9])(?:sk|pk|rk|gh[opsur]|github_pat)[-_][A-Za-z0-9_-]{8,}/g, replace: "[redacted]" },
     { kind: "prefixed-token", confidence: "high", marker: "[redacted]", source: "arg-summary", re: /(?<![A-Za-z0-9])AIza[A-Za-z0-9_-]{20,}/g, replace: "[redacted]" },
     { kind: "prefixed-token", confidence: "high", marker: "[redacted]", source: "arg-summary", re: /(?<![A-Za-z0-9])xox[baprs]-[A-Za-z0-9-]{10,}/g, replace: "[redacted]" },
     { kind: "prefixed-token", confidence: "high", marker: "[redacted]", source: "arg-summary", re: /(?<![A-Za-z0-9])AKIA[0-9A-Z]{12,}/g, replace: "[redacted]" },
     { kind: "prefixed-token", confidence: "high", marker: "[redacted]", source: "arg-summary", re: /(?<![A-Za-z0-9])hf_[A-Za-z0-9]{20,}/g, replace: "[redacted]" },
     { kind: "jwt", confidence: "high", marker: "[redacted]", source: "arg-summary", re: /(?<![A-Za-z0-9])eyJ[A-Za-z0-9._-]{20,}/g, replace: "[redacted]" },
-    { kind: "private-key-block", confidence: "high", marker: "[redacted]", source: "arg-summary", re: /-----BEGIN[ A-Z]*PRIVATE KEY-----[\s\S]*?(?:-----END[ A-Z]*PRIVATE KEY-----|$)/g, replace: "[redacted]" },
+    { kind: "private-key-block", confidence: "high", marker: "[redacted]", source: "arg-summary", re: /-----BEGIN[ A-Z0-9]*PRIVATE KEY(?: BLOCK)?-----[\s\S]*?(?:-----END[ A-Z0-9]*PRIVATE KEY(?: BLOCK)?-----|$)/g, replace: "[redacted]" },
     { kind: "bearer-token", confidence: "high", marker: "[redacted]", source: "arg-summary", re: /(?<![A-Za-z0-9])Bearer\s+[A-Za-z0-9._~+/-]{8,}=*/gi, replace: "[redacted]" },
+    { kind: "prefixed-token", confidence: "high", marker: "[redacted]", source: "arg-summary", re: /(AccountKey=)[A-Za-z0-9+/]{40,}={0,2}/g, replace: "$1[redacted]" },
     {
         kind: "keyword-value",
         confidence: "medium",
@@ -247,12 +248,22 @@ export function primaryActivityArg(args) {
         val = basename(path);
     }
     else if (url !== undefined) {
-        try {
-            const u = new URL(url);
-            val = `${u.origin}${u.pathname}`;
+        const parsed = (() => { try {
+            return new URL(url);
         }
         catch {
-            val = url.split(/[?#]/)[0].replace(/^([a-z][a-z0-9+.-]*:\/\/)[^/@]*@/i, "$1");
+            return undefined;
+        } })();
+        if (parsed !== undefined && parsed.host !== "") {
+            val = `${parsed.origin}${parsed.pathname}`;
+        }
+        else {
+            const head = url.split(/[?#]/, 1)[0] ?? url;
+            const sep = head.indexOf("://");
+            const scheme = sep > 0 && /^[a-z][a-z0-9+.-]*$/i.test(head.slice(0, sep)) ? head.slice(0, sep + 3) : "";
+            const rest = head.slice(scheme.length);
+            const at = rest.lastIndexOf("@");
+            val = scheme + (at === -1 ? rest : rest.slice(at + 1));
         }
     }
     else {

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

@@ -3,6 +3,7 @@ import type { Message, Model, Tool } from "../internal/llm.js";
 import type { Hooks } from "./hooks.js";
 import type { TraceEvent } from "./trace.js";
 import type { Brain } from "./types.js";
+import type { TaskEvent, TaskEventIdentity } from "./task-event.js";
 /**
  * Default summarization focus, applied when a task does not provide `compaction.instructions`.
  * Addresses the common fidelity failure where summaries drop specific facts.
@@ -431,10 +432,13 @@ export interface MaybeCompactOptions {
      * return). Does NOT alter control flow. `reused` distinguishes a provider-supplied summary from a real
      * LLM `generateSummary`. `freedTokens` is the §25.2 structural delta (may be ~0 when a reused summary
      * frees little — see reuse guard (b): such a compaction does NOT raise the caller's anti-thrash floor).
+     * ABSENT when the post measurement failed — never a stand-in ("fully effective" is not true of a
+     * landing that leaves a summary behind). Every consumer reads absence as "no evidence": the floor
+     * stays where it is and the backoff does not flip.
      */
     onCompaction?: (info: {
         messagesCompacted: number;
-        freedTokens: number;
+        freedTokens?: number;
         tokensBefore: number;
         reused: boolean;
     }) => void;
@@ -517,6 +521,8 @@ export declare function maybeCompact(opts: MaybeCompactOptions): Promise<{
      *  (`compaction_outcome{outcome:"noop"}`) reads this flag. */
     noop?: true;
     tokensBefore?: number;
+    /** The §25.2 STRUCTURAL pre/post delta in ONE coordinate — the only subtractable quantity here.
+     *  Absent ⇒ the post measurement failed and no delta was taken. */
     freedTokens?: number;
     triggerTokens?: number;
     /** P-13: post-compaction context size in the SAME coordinate as `triggerTokens` (estimate + anchor-less
@@ -627,6 +633,41 @@ export declare function maybeCompact(opts: MaybeCompactOptions): Promise<{
      *  ordinary truncation (disclosed, not silent). */
     clampReason?: "budget" | "tolerance";
 }>;
+/** What a landed compaction hands the wire frame. Structural, so both the full `maybeCompact` result
+ *  and the settle lane's narrower `EndOfTaskCompaction` satisfy it without either importing the other. */
+export interface CompactedFrameSource {
+    tokensBefore?: number;
+    freedTokens?: number;
+    postTriggerTokens?: number;
+    triggerTokens?: number;
+    durationMs?: number;
+    phaseDurations?: CompactionPhaseDurations;
+    firstKeptEntryId?: string;
+    attachedFiles?: Array<{
+        path: string;
+        chars: number;
+        truncated: boolean;
+    }>;
+    modelFallback?: true;
+    fallbackReason?: "window";
+    clampedRatio?: number;
+    clampReason?: "budget" | "tolerance";
+}
+/**
+ * THE mint of the `compacted` wire frame — one function, three lanes (the turn boundary, the
+ * prompt-too-long recovery, the end-of-task settle). The three used to carry a verbatim copy of the
+ * same fourteen-line literal, which is how a field reaches the wire on two lanes out of three: a key
+ * added to one copy is invisible in the others' diffs, and the only guard against it was a test that
+ * grepped the SOURCE TEXT of all three for a matching line. A behavior can be pinned; a copy can only
+ * be spelled.
+ *
+ * What differs per lane is exactly `trigger` and the identity envelope, so those are the parameters;
+ * everything else is derived here, once. Absence semantics live on the event type
+ * ({@link import("./task-event.js").TaskEvent}) and are the same whichever lane fires.
+ */
+export declare function mintCompactedEvent(comp: CompactedFrameSource, trigger: "auto" | "manual" | "forced", identity: TaskEventIdentity): Extract<TaskEvent, {
+    type: "compacted";
+}>;
 /**
  * design/123 D4 (r5) — trim-force BACKOFF transition (pure; the run-scoped bit lives in the caller).
  * Spiral protection replacing the §25.2 floor's role on the trim-force path: trim pressure re-arms

package/dist/core/auto-compaction.js

@@ -478,7 +478,7 @@ export async function maybeCompact(opts) {
         catch {
         }
     }
-    let freedTokens = preChars;
+    let freedTokens;
     let postTriggerTokens;
     try {
         const post = (await opts.session.buildContext()).messages;
@@ -502,6 +502,7 @@ export async function maybeCompact(opts) {
             trigger,
             summary,
             tokensBefore: summaryTokensBefore,
+            ...(freedTokens !== undefined ? { freedTokens } : {}),
             ...(postTriggerTokens !== undefined ? { tokensAfter: postTriggerTokens } : {}),
         }), "compaction.postCompact");
     }
@@ -534,6 +535,25 @@ export async function maybeCompact(opts) {
         ...(clampReason !== undefined ? { clampReason } : {}),
     };
 }
+export function mintCompactedEvent(comp, trigger, identity) {
+    return {
+        type: "compacted",
+        trigger,
+        tokensBefore: comp.tokensBefore ?? 0,
+        ...(comp.freedTokens !== undefined ? { freedTokens: comp.freedTokens } : {}),
+        ...(comp.postTriggerTokens !== undefined ? { tokensAfter: comp.postTriggerTokens } : {}),
+        ...(comp.triggerTokens !== undefined ? { triggerTokensBefore: comp.triggerTokens } : {}),
+        ...(comp.durationMs !== undefined ? { durationMs: comp.durationMs } : {}),
+        ...(comp.phaseDurations !== undefined ? { phaseDurations: comp.phaseDurations } : {}),
+        ...(comp.firstKeptEntryId !== undefined ? { preserved_segment: { firstKeptEntryId: comp.firstKeptEntryId } } : {}),
+        ...(comp.attachedFiles !== undefined ? { attachedFiles: comp.attachedFiles } : {}),
+        ...(comp.modelFallback ? { modelFallback: true } : {}),
+        ...(comp.fallbackReason !== undefined ? { fallbackReason: comp.fallbackReason } : {}),
+        ...(comp.clampedRatio !== undefined ? { clampedRatio: comp.clampedRatio } : {}),
+        ...(comp.clampReason !== undefined ? { clampReason: comp.clampReason } : {}),
+        ...identity,
+    };
+}
 export function nextTrimForceBackoff(prev, comp, trimForced = false) {
     if (trimForced && comp.naturalTrigger !== true && comp.compacted && comp.freedTokens !== undefined && comp.freedTokens <= 0) {
         return true;

package/dist/core/auto-mode.js

@@ -1,4 +1,5 @@
 import { AUTO_MODE_DEFAULT_TIMEOUT_MS, AUTO_MODE_DENIAL_AUTO_DENY_DEFAULT_MS, AUTO_MODE_DENIAL_LIMIT_DEFAULTS } from "./auto-mode-defaults.js";
+import { thrownIs } from "./thrown-value.js";
 import { describeRejectedValue } from "./tool-search-setting.js";
 export const AUTO_MODE_UNAVAILABLE_CAUSES = ["error", "timeout"];
 const AUTO_MODE_UNAVAILABLE_CAUSE_SET = new Set(AUTO_MODE_UNAVAILABLE_CAUSES);
@@ -286,14 +287,7 @@ class AutoModeTimeout extends Error {
         super("auto-mode classify timeout");
     }
 }
-function isAutoModeTimeout(e) {
-    try {
-        return e instanceof AutoModeTimeout;
-    }
-    catch {
-        return false;
-    }
-}
+const isAutoModeTimeout = (e) => thrownIs(e, AutoModeTimeout);
 export function readDenialLimitFallback(v) {
     if (typeof v !== "object" || v === null)
         return undefined;

package/dist/core/exec-gate.js

@@ -1,4 +1,5 @@
 import { isRemoteExecutionEnv, RemoteExecutionError } from "./remote-env.js";
+import { readMember, thrownIs } from "./thrown-value.js";
 const DEFAULT_MAX_OUTPUT_BYTES = 64 * 1024;
 function clampBytes(s, maxBytes) {
     const total = Buffer.byteLength(s, "utf8");
@@ -47,11 +48,8 @@ async function runStreamStep(env, step, options, maxOutputBytes) {
         }
     }
     catch (e) {
-        const code = e instanceof RemoteExecutionError
-            ? e.code
-            : e?.name === "AbortError"
-                ? "aborted"
-                : "unknown";
+        const remoteCode = thrownIs(e, RemoteExecutionError) ? readMember(e, "code") : undefined;
+        const code = typeof remoteCode === "string" ? remoteCode : readMember(e, "name") === "AbortError" ? "aborted" : "unknown";
         return { label, command: step.command, exitCode: null, stdout: out.join(""), stderr: errOut.join(""), ok: false, errorCode: code, truncated };
     }
     return { label, command: step.command, exitCode, stdout: out.join(""), stderr: errOut.join(""), ok: exitCode === 0, truncated };

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

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { thrownText } from "./thrown-value.js";
 import { isAbsoluteForFamily, isAbsolutePathForm, isWinFormPath, pathFamilyOf } from "../tools/fs/safety.js";
 import { fileHistoryBoundariesToKeep, resolveFileHistoryRetention } from "./file-history-retention.js";
 const normSlash = (p) => p.replace(/\\/g, "/");
@@ -489,7 +490,7 @@ export class InMemoryFileHistoryStore {
             return { ok: true, minted: true };
         }
         catch (err) {
-            return { ok: false, error: { code: "track_failed", message: `first-touch record for ${absPath} could not be persisted: ${err.message}` } };
+            return { ok: false, error: { code: "track_failed", message: `first-touch record for ${absPath} could not be persisted: ${thrownText(err)}` } };
         }
     }
     async annulTrack(scope, absPath, root, verify) {
@@ -530,7 +531,7 @@ export class InMemoryFileHistoryStore {
             return { ok: true };
         }
         catch (err) {
-            return { ok: false, error: { code: "track_failed", message: `annulling the first-touch record for ${absPath} failed: ${err.message}` } };
+            return { ok: false, error: { code: "track_failed", message: `annulling the first-touch record for ${absPath} failed: ${thrownText(err)}` } };
         }
     }
     async snapshot(scope, entryId, env, root, signal) {
@@ -599,14 +600,14 @@ export class InMemoryFileHistoryStore {
             }
             catch (err) {
                 sc.spentAttempts.add(entryId);
-                return { ok: false, error: { code: "snapshot_failed", message: `boundary for entry "${entryId}" could not be committed: ${err.message}` } };
+                return { ok: false, error: { code: "snapshot_failed", message: `boundary for entry "${entryId}" could not be committed: ${thrownText(err)}` } };
             }
             this.applyBoundaryRetention(scope, entryId);
             return { ok: true };
         }
         catch (err) {
             sc.spentAttempts.add(entryId);
-            return { ok: false, error: { code: "snapshot_failed", message: err.message } };
+            return { ok: false, error: { code: "snapshot_failed", message: thrownText(err) } };
         }
         finally {
             sc.activeAttempts.delete(entryId);
@@ -669,7 +670,7 @@ export class InMemoryFileHistoryStore {
                     });
                 }
                 catch (err) {
-                    applied = { outcome: "failed", reason: err.message };
+                    applied = { outcome: "failed", reason: thrownText(err) };
                 }
                 if (applied.outcome === "applied")
                     ledger.filesChanged.push(key);
@@ -686,7 +687,7 @@ export class InMemoryFileHistoryStore {
         }
         catch (err) {
             const touched = empty.filesChanged.length > 0 || empty.identicalSkipped.length > 0 || empty.refused.length > 0 || empty.failed.length > 0;
-            return { outcome: touched ? "partial" : "failed", ...empty, error: { code: "restore_failed", message: err.message } };
+            return { outcome: touched ? "partial" : "failed", ...empty, error: { code: "restore_failed", message: thrownText(err) } };
         }
     }
     async canRestore(scope, entryId) {
@@ -793,7 +794,7 @@ export class InMemoryFileHistoryStore {
             return { ok: true };
         }
         catch (err) {
-            return { ok: false, error: { code: "adopt_failed", message: `adoptScope failed: ${err.message}` } };
+            return { ok: false, error: { code: "adopt_failed", message: `adoptScope failed: ${thrownText(err)}` } };
         }
     }
     async exportHistory(scope) {
@@ -846,7 +847,7 @@ export class InMemoryFileHistoryStore {
             }
         }
         catch (err) {
-            return { ok: false, error: { code: "unsupported_format", message: `importHistory failed: ${err.message}` } };
+            return { ok: false, error: { code: "unsupported_format", message: `importHistory failed: ${thrownText(err)}` } };
         }
     }
     async importStaged(scope, data, srcGetBlob, needed) {
@@ -860,7 +861,7 @@ export class InMemoryFileHistoryStore {
                     bytes = await srcGetBlob(hash);
                 }
                 catch (err) {
-                    return { ok: false, error: { code: "unsupported_format", message: `source blob ${hash} fetch failed: ${err.message}` } };
+                    return { ok: false, error: { code: "unsupported_format", message: `source blob ${hash} fetch failed: ${thrownText(err)}` } };
                 }
                 if (bytes === undefined)
                     return { ok: false, error: { code: "not_found", message: `source blob ${hash} is missing — the envelope's graph cannot be completed, so nothing is published` } };
@@ -892,7 +893,7 @@ export class InMemoryFileHistoryStore {
             return { ok: true };
         }
         catch (err) {
-            return { ok: false, error: { code: "unsupported_format", message: `importHistory failed: ${err.message}` } };
+            return { ok: false, error: { code: "unsupported_format", message: `importHistory failed: ${thrownText(err)}` } };
         }
     }
 }

package/dist/core/hooks.d.ts

@@ -515,8 +515,15 @@ export interface PostCompactContext {
     trigger: "auto" | "manual" | "forced";
     /** The conversation summary the compaction produced (CC `compact_summary` parity). */
     summary: string;
+    /** DIAGNOSTIC, NOT subtractable: prepareCompaction's coordinate, LACKING the overhead term
+     *  {@link tokensAfter} carries. Use {@link freedTokens}. */
     tokensBefore?: number;
+    /** DIAGNOSTIC, NOT subtractable: always structural + prompt overhead, a different coordinate from
+     *  {@link tokensBefore}, so the difference can go negative. Absent when the post measurement failed. */
     tokensAfter?: number;
+    /** The engine's measured delta (clamped ≥ 0) — the ONE subtractable number here, and the same value
+     *  this pass's `compacted` frame carries. Absent ⇒ the post measurement failed. */
+    freedTokens?: number;
     /** {@link HookSeatSignal} — this invocation's own abort signal. */
     signal?: AbortSignal;
 }

package/dist/core/mcp.js

@@ -21,7 +21,7 @@ import { withContentOrigin } from "./memory-engine/content-origin.js";
 import { snapshotMcpEntries } from "./locked-config.js";
 import { validateJsonSchemaShape } from "./runner/strict-output-schema.js";
 import { schemaKeyBoundProblem } from "./tool-roster.js";
-import { thrownText } from "./thrown-value.js";
+import { readMember, thrownIs, thrownName, thrownText } from "./thrown-value.js";
 export const MCP_PREFIX = MCP_NAMESPACE.prefix;
 const MCP_OUTPUT_TOKENS_DEFAULT = 25_000;
 const MCP_CHARS_PER_TOKEN = 4;
@@ -187,7 +187,7 @@ function sanitizeMcpErrorTextInPlace(err) {
 }
 function namedMcpFailureText(err) {
     const detail = remoteErrorText(err, { collapse: true });
-    const condition = err instanceof McpError ? describeMcpSpecErrorCode(err.code) : undefined;
+    const condition = thrownIs(err, McpError) ? describeMcpSpecErrorCode(readMember(err, "code")) : undefined;
     return condition !== undefined ? `${condition}: ${detail}` : detail;
 }
 function remoteErrorText(err, opts) {
@@ -1769,9 +1769,11 @@ function asServerWarning(spec, err) {
 }
 function sanitizedCause(err) {
     const copy = new Error(namedMcpFailureText(err));
-    if (err instanceof Error) {
-        copy.name = err.name;
-        const code = err.code;
+    const name = thrownName(err);
+    if (name !== undefined) {
+        if (name !== "")
+            copy.name = name;
+        const code = readMember(err, "code");
         if (typeof code === "string" || typeof code === "number")
             copy.code = code;
     }

package/dist/core/memory-engine/distiller.d.ts

@@ -131,10 +131,13 @@ export type DistillerChatFn = (req: DistillerChatRequest) => Promise<DistillerCh
 export declare function isAliasModelId(model: string): boolean;
 /**
  * An OpenAI-compatible chat seat over an explicit endpoint. Screened at CONSTRUCTION (the
- * bad-value loudness law): a missing key or an alias model id refuses with a code before any call
- * is made — an alias can be re-pointed upstream and would move the driven model with no trace in
- * the archived plan.
- */
+ * bad-value loudness law): a missing key, an alias model id or an unservable request root refuses
+ * with a code before any call is made — an alias can be re-pointed upstream and would move the
+ * driven model with no trace in the archived plan.
+ *
+ * The root is judged by {@link assertServableRequestRoot} — the SAME law the brains apply, because
+ * emptiness alone let userinfo, a non-http(s) scheme and a non-URL spelling reach `fetch` as a
+ * TRANSPORT error. Only the ENVELOPE is this seat's; the driver routes config throws apart. */
 export declare function openAiCompatChatSeat(seat: {
     baseUrl: string;
     apiKey: string;

package/dist/core/memory-engine/distiller.js

@@ -1,4 +1,5 @@
 import { readMember, thrownText } from "../thrown-value.js";
+import { assertServableRequestRoot } from "../../brain/route-adjudicator.js";
 export const DISTILLER_DEFAULT_MAX_INPUTS_PER_PRODUCT = 32;
 const SIZE_CLAUSE = {
     "dl-2": "- the index should be as small as it can be made without losing either of the above.",
@@ -132,8 +133,8 @@ function renderCandidate(n, c) {
     return `[${n}] ${head}\n${String(c.entry?.body ?? "").trim()}`;
 }
 const fill = (tpl, vars) => Object.entries(vars).reduce((s, [k, v]) => s.split(`{{${k}}}`).join(String(v)), tpl);
-function distillerConfigRefusal(message) {
-    const e = new Error(message);
+function distillerConfigRefusal(message, cause) {
+    const e = (cause === undefined ? new Error(message) : new Error(message, { cause }));
     e.code = "config.memory_consolidation_driver";
     return e;
 }
@@ -143,13 +144,20 @@ export function isAliasModelId(model) {
 export function openAiCompatChatSeat(seat) {
     if (typeof seat.baseUrl !== "string" || seat.baseUrl.trim() === "")
         throw distillerConfigRefusal("memory consolidation driver chat seat needs a non-empty baseUrl.");
+    let requestRoot;
+    try {
+        requestRoot = (assertServableRequestRoot(seat.baseUrl, "memory consolidation driver chat seat baseUrl") ?? "").replace(/\/+$/, "");
+    }
+    catch (e) {
+        throw distillerConfigRefusal(thrownText(e), e);
+    }
     if (typeof seat.apiKey !== "string" || seat.apiKey === "")
         throw distillerConfigRefusal("memory consolidation driver chat seat needs an api key — a driver that silently skips would publish an empty plan as a model's answer.");
     if (typeof seat.model !== "string" || seat.model.trim() === "" || isAliasModelId(seat.model)) {
         throw distillerConfigRefusal(`memory consolidation driver chat seat needs an EXPLICIT model id, got ${JSON.stringify(seat.model)} — an alias can be re-pointed upstream and would move the driver with no trace in the plan.`);
     }
     return async (req) => {
-        const res = await fetch(`${String(seat.baseUrl).replace(/\/+$/, "")}/chat/completions`, {
+        const res = await fetch(`${requestRoot}/chat/completions`, {
             method: "POST",
             headers: { "content-type": "application/json", authorization: `Bearer ${seat.apiKey}` },
             body: JSON.stringify({

package/dist/core/memory.js

@@ -46,6 +46,7 @@ const SECRET_PATTERNS = [
     { label: "stripe_secret_key", re: /\b[sr]k_(?:live|test)_[A-Za-z0-9]{24,}\b/ },
     { label: "slack_token", re: /\bxox[baprs]-(?:[A-Za-z0-9]+-){1,3}[A-Za-z0-9]{16,}\b/ },
     { label: "google_api_key", re: /\bAIza[0-9A-Za-z_-]{35}\b/ },
+    { label: "huggingface_token", re: /\bhf_(?=[A-Za-z0-9]*[0-9])[A-Za-z0-9]{20,}\b/ },
     { label: "private_key", re: /-----BEGIN (?:[A-Z0-9]+ )*PRIVATE KEY(?: BLOCK)?-----/ },
     { label: "jwt", re: /\beyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]{16,}\b/ },
     { label: "azure_storage_account_key", re: /AccountKey=[A-Za-z0-9+/]{40,}={0,2}/ },

package/dist/core/runner/assemble-result.js

@@ -2,6 +2,7 @@ import { isDegenerateCutMessage } from "../../brain/terminal-cause.js";
 import { extractErrorCode, stripErrorCodePrefix } from "../../brain/errors.js";
 import { terminalProjection } from "./terminal-projection.js";
 import { haltConsumed } from "./halt-attribution.js";
+import { isErrorLike, readMember } from "../thrown-value.js";
 import { describeRejectedValue } from "../tool-search-setting.js";
 const SALVAGE_ELIGIBLE_TERMINALS = new Set([
     "output.degenerate",
@@ -13,33 +14,25 @@ const SALVAGE_ELIGIBLE_TERMINALS = new Set([
     "usage.window_exhausted",
 ]);
 function thrownMessage(threw) {
-    try {
-        if (threw instanceof Error) {
-            const m = threw.message;
-            if (typeof m === "string")
-                return m;
-        }
-    }
-    catch {
+    if (isErrorLike(threw)) {
+        const m = readMember(threw, "message");
+        if (typeof m === "string")
+            return m;
     }
     return describeRejectedValue(threw);
 }
 export function errorCodeOf(err) {
     let cur = err;
     let fallback;
-    try {
-        for (let depth = 0; cur && typeof cur === "object" && depth < 8; depth++) {
-            const code = cur.code;
-            if (typeof code === "string" && code) {
-                if (code !== "unknown") {
-                    return code;
-                }
-                fallback ??= code;
+    for (let depth = 0; cur !== null && cur !== undefined && typeof cur === "object" && depth < 8; depth++) {
+        const code = readMember(cur, "code");
+        if (typeof code === "string" && code) {
+            if (code !== "unknown") {
+                return code;
             }
-            cur = cur.cause;
+            fallback ??= code;
         }
-    }
-    catch {
+        cur = readMember(cur, "cause");
     }
     return fallback;
 }

package/dist/core/runner/contracts.d.ts

@@ -2620,6 +2620,7 @@ export interface ManualCompactRef {
 export type EndOfTaskCompaction = {
     compacted: boolean;
     tokensBefore?: number;
+    freedTokens?: number;
     triggerTokens?: number;
     postTriggerTokens?: number;
     durationMs?: number;

package/dist/core/runner/prepare-file-history.js

@@ -43,6 +43,16 @@ export async function prepareFileHistory(input) {
         });
     }
     const fileHistoryEnabled = fileHistoryStore !== undefined && handsEnabled;
+    if (!fileHistoryEnabled && (handsEnabled || fileHistoryStore !== undefined) && deps.onError !== undefined && !toldAlready(deps.onError, fileHistoryStore === undefined ? "no-store" : "no-env")) {
+        const reason = fileHistoryStore === undefined
+            ? `this deployment wired no RunnerDeps.fileHistoryStore, so NOTHING is recorded: no first-touch snapshot before an edit, no turn boundary, and a later restoreFiles / rewindFilesTo has nothing to restore from and will refuse (rewind.store_unconfigured). Supply a store, or accept an unrecoverable working tree knowingly`
+            : `RunnerDeps.fileHistoryStore is wired but this run mounts no filesystem-capable ExecutionEnv, so the store is INERT: there is no working tree to snapshot and nothing will ever be written to it. Wire RunnerDeps.executionEnv, or drop the store from this deployment shape`;
+        try {
+            deps.onError(new Error(`file history is not live for this run — ${reason}.`), { phase: "config", sessionId });
+        }
+        catch {
+        }
+    }
     const { historyRoot, historyScope, historyFs } = await resolveFileHistoryCoordinates(fileHistoryEnabled, executionEnv, taskRootFinal, internals?.fileHistoryLineage, sessionId);
     if (fileHistoryStore !== undefined && internals?.fileHistoryLineage === undefined)
         await adoptForkedFileHistory(fileHistoryStore, session, sessionId, deps.onError);
@@ -197,6 +207,15 @@ function rewindRefusalTail(form) {
         : `Either the boundary does not exist (its turns ran without a RunnerDeps.fileHistoryStore, or it was reaped), or it was produced in the retired whole-tree snapshot era, which this engine's per-edited-file seat does not restore.`;
 }
 const FILE_HISTORY_BOUNDARY_TIMEOUT_MS = 30_000;
+const FILE_HISTORY_LIVENESS_MEMO = new WeakMap();
+function toldAlready(sink, arm) {
+    const heard = FILE_HISTORY_LIVENESS_MEMO.get(sink) ?? new Set();
+    FILE_HISTORY_LIVENESS_MEMO.set(sink, heard);
+    if (heard.has(arm))
+        return true;
+    heard.add(arm);
+    return false;
+}
 const FILE_HISTORY_CARRY_MEMO = new WeakMap();
 async function adoptForkedFileHistory(store, session, sessionId, onError) {
     const memo = FILE_HISTORY_CARRY_MEMO.get(store) ?? { settled: new Set(), disclosed: new Set(), inFlight: new Map() };

package/dist/core/runner/run-recovery-lanes.js

@@ -1,7 +1,7 @@
 import { DEFAULT_COMPACTION_SETTINGS } from "../../internal/harness.js";
 import { planRejectionClears } from "../context-edit.js";
 import { landStaleResultClears } from "./prepare-context-lane.js";
-import { DEFAULT_COMPACTION_INSTRUCTIONS, maybeCompact } from "../auto-compaction.js";
+import { DEFAULT_COMPACTION_INSTRUCTIONS, maybeCompact, mintCompactedEvent } from "../auto-compaction.js";
 import { emitTrace } from "../trace.js";
 import { isDegenerateCutMessage } from "../../brain/terminal-cause.js";
 import { rebaseCadenceWindows } from "./turn-attachments.js";
@@ -48,26 +48,10 @@ export function runRecoveryLanes(input) {
             if (comp.compacted) {
                 compactionBreaker.failures = 0;
                 recordCompactionReuse(runner, prepared, comp);
-                if ((comp.freedTokens ?? 0) >= COMPACTION_FREED_EPSILON) {
-                    const postSize = comp.postTriggerTokens ?? Math.max(0, (comp.triggerTokens ?? comp.tokensBefore ?? 0) - (comp.freedTokens ?? 0));
-                    rs.counters.compactionFloor = Math.ceil(postSize * COMPACTION_REGROWTH_FACTOR);
+                if ((comp.freedTokens ?? 0) >= COMPACTION_FREED_EPSILON && comp.postTriggerTokens !== undefined) {
+                    rs.counters.compactionFloor = Math.ceil(comp.postTriggerTokens * COMPACTION_REGROWTH_FACTOR);
                 }
-                queue.push({
-                    type: "compacted",
-                    trigger: "forced",
-                    tokensBefore: comp.tokensBefore ?? 0,
-                    ...(comp.postTriggerTokens !== undefined ? { tokensAfter: comp.postTriggerTokens } : {}),
-                    ...(comp.triggerTokens !== undefined ? { triggerTokensBefore: comp.triggerTokens } : {}),
-                    ...(comp.durationMs !== undefined ? { durationMs: comp.durationMs } : {}),
-                    ...(comp.phaseDurations !== undefined ? { phaseDurations: comp.phaseDurations } : {}),
-                    ...(comp.firstKeptEntryId !== undefined ? { preserved_segment: { firstKeptEntryId: comp.firstKeptEntryId } } : {}),
-                    ...(comp.attachedFiles !== undefined ? { attachedFiles: comp.attachedFiles } : {}),
-                    ...(comp.modelFallback ? { modelFallback: true } : {}),
-                    ...(comp.fallbackReason !== undefined ? { fallbackReason: comp.fallbackReason } : {}),
-                    ...(comp.clampedRatio !== undefined ? { clampedRatio: comp.clampedRatio } : {}),
-                    ...(comp.clampReason !== undefined ? { clampReason: comp.clampReason } : {}),
-                    ...ident(),
-                });
+                queue.push(mintCompactedEvent(comp, "forced", ident()));
                 if (comp.phaseDurations !== undefined && comp.durationMs !== undefined) {
                     const pd = comp.phaseDurations;
                     const pdDur = comp.durationMs;

package/dist/core/runner/run-settle-and-teardown.js

@@ -20,27 +20,13 @@ import { generatePromptSuggestions } from "./prompt-suggestions.js";
 import { settleTeardownLeg } from "./teardown-bounded.js";
 import { autoRunConsolidationFromRecommendation, autoRunOnRecommendationEffective, scopeHasUnconsumedRecommendation } from "./memory-consolidation-driver.js";
 import { amendTerminal, terminalProjection } from "./terminal-projection.js";
+import { mintCompactedEvent } from "../auto-compaction.js";
 import { asThrownError } from "../thrown-value.js";
 export async function runSettleAndTeardown(input) {
     const { spec, queue, prepared, resume, internals, rs, stats, ident, parentToolCallId, subagentName, loopLatch, timeout, ownCommittedTailRef, emitDelegationLifecycle, taskIdRef, manualCompactRef, drainManualCompact, final, threw, abortedLive, userInterruptedLive, answerSettled, strandedHumanAnswers, reasoningResolution, comp, owedUserInput, setResult, onSuggestions, onSuspend, runner, sessions } = input;
     try {
         if (comp?.compacted) {
-            queue.push({
-                type: "compacted",
-                trigger: "auto",
-                tokensBefore: comp.tokensBefore ?? 0,
-                ...(comp.postTriggerTokens !== undefined ? { tokensAfter: comp.postTriggerTokens } : {}),
-                ...(comp.triggerTokens !== undefined ? { triggerTokensBefore: comp.triggerTokens } : {}),
-                ...(comp.durationMs !== undefined ? { durationMs: comp.durationMs } : {}),
-                ...(comp.phaseDurations !== undefined ? { phaseDurations: comp.phaseDurations } : {}),
-                ...(comp.firstKeptEntryId !== undefined ? { preserved_segment: { firstKeptEntryId: comp.firstKeptEntryId } } : {}),
-                ...(comp.attachedFiles !== undefined ? { attachedFiles: comp.attachedFiles } : {}),
-                ...(comp.modelFallback ? { modelFallback: true } : {}),
-                ...(comp.fallbackReason !== undefined ? { fallbackReason: comp.fallbackReason } : {}),
-                ...(comp.clampedRatio !== undefined ? { clampedRatio: comp.clampedRatio } : {}),
-                ...(comp.clampReason !== undefined ? { clampReason: comp.clampReason } : {}),
-                ...ident(),
-            });
+            queue.push(mintCompactedEvent(comp, "auto", ident()));
             if (comp.phaseDurations !== undefined && comp.durationMs !== undefined) {
                 const pd = comp.phaseDurations;
                 const pdDur = comp.durationMs;