@sema-agent/core 3.0.0 → 5.0.0

package/dist/core/memory-engine/file-backend.js

@@ -1,11 +1,11 @@
-import { lstatSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, openSync, writeSync, fsyncSync, closeSync } from "node:fs";
+import { lstatSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, openSync, fsyncSync, closeSync } from "node:fs";
 import { randomUUID } from "node:crypto";
-import { basename, dirname, join, relative } from "node:path";
+import { dirname, join, relative } from "node:path";
 import { jaccardDistance, termSet } from "../memory-vector.js";
 import { MAX_MEMORY_BYTES } from "../memory.js";
 import { inlineUntrusted } from "../untrusted-text.js";
 import { computeEntryRev, entryFromFile, isValidEntryId, parseEntryFile, serializeEntryFile } from "./frontmatter.js";
-import { ControlPlaneCorruptError, CURSORS_FILE, atomicWriteFileSync, claimRootScope, deriveControlPlaneDir, ensureDirExists, enqueueMemoryAnnouncement, registerScope, registeredScopes, resolveMemoryEngineRoot, scopeDirName, } from "./layout.js";
+import { ControlPlaneCorruptError, CURSORS_FILE, QUARANTINE_DIR, atomicWriteFileSync, quarantineAndTombstone, claimRootScope, deriveControlPlaneDir, ensureDirExists, enqueueMemoryAnnouncement, registerScope, registeredScopes, resolveMemoryEngineRoot, scopeDirName, writeAllSync, } from "./layout.js";
 import { scanMemoryFileName, scanMemoryWrite } from "./scan.js";
 export const MEMORY_INDEX_FILENAME = "MEMORY.md";
 export const DEFAULT_MAX_ENTRY_DEPTH = 3;
@@ -18,6 +18,8 @@ export function scanEntryFiles(dir, opts = {}) {
             names = readdirSync(d);
         }
         catch {
+            if (d !== dir)
+                opts.onSkip?.(d, "unreadable");
             return;
         }
         for (const name of names.sort()) {
@@ -32,6 +34,7 @@ export function scanEntryFiles(dir, opts = {}) {
                 st = lstatSync(p);
             }
             catch {
+                opts.onSkip?.(p, "unreadable");
                 continue;
             }
             if (st.isSymbolicLink()) {
@@ -65,7 +68,6 @@ const TXN_LOCK_STALE_MS = 30_000;
 const TXN_LOCK_WAIT_MS = 15_000;
 const TXN_LOCK_STEAL_GRACE_MS = 250;
 const SHADOW_DIR = "shadow";
-const QUARANTINE_DIR = "quarantine";
 export class FileMemoryEngineBackend {
     directoryRoot;
     controlPlaneRoot;
@@ -98,35 +100,6 @@ export class FileMemoryEngineBackend {
     shadowPath(id) {
         return join(this.controlPlaneRoot, SHADOW_DIR, `${id}.md`);
     }
-    quarantineFile(path, content) {
-        const dest = join(this.controlPlaneRoot, QUARANTINE_DIR, `${Date.now()}-${basename(path)}`);
-        let captured;
-        let detail;
-        try {
-            ensureDirExists(dirname(dest));
-            writeFileSync(dest, content, "utf8");
-            captured = dest;
-        }
-        catch (err) {
-            detail = `quarantine copy failed: ${err instanceof Error ? err.message : String(err)}`;
-        }
-        let removed = false;
-        try {
-            rmSync(path, { force: true });
-            removed = true;
-        }
-        catch (rmErr) {
-            try {
-                writeFileSync(path, "---\ndeleted: true\n---\n", "utf8");
-                removed = true;
-                detail = `${detail !== undefined ? `${detail}; ` : ""}delete failed (${rmErr instanceof Error ? rmErr.message : String(rmErr)}) — tombstoned in place`;
-            }
-            catch (clearErr) {
-                detail = `${detail !== undefined ? `${detail}; ` : ""}suspect file could not be deleted or cleared: ${clearErr instanceof Error ? clearErr.message : String(clearErr)}`;
-            }
-        }
-        return { ...(captured !== undefined ? { dest: captured } : {}), removed, ...(detail !== undefined ? { detail } : {}) };
-    }
     loadLedger() {
         if (this.ledger)
             return this.ledger;
@@ -278,12 +251,14 @@ export class FileMemoryEngineBackend {
         const ledger = sync ? this.loadLedger() : undefined;
         let ledgerChanged = false;
         const adoptedExternal = [];
+        const skippedUnreadable = [];
         for (const f of files) {
             let text;
             try {
                 text = readFileSync(f.path, "utf8");
             }
             catch {
+                skippedUnreadable.push(relative(this.directoryRoot, f.path));
                 continue;
             }
             const parsed = parseEntryFile(text);
@@ -312,7 +287,7 @@ export class FileMemoryEngineBackend {
                     }
                     if (finding) {
                         this.inboundFindings.push(finding);
-                        const q = this.quarantineFile(f.path, text);
+                        const q = quarantineAndTombstone(f.path, text, join(this.controlPlaneRoot, QUARANTINE_DIR), this.now);
                         const shadowText = committed !== undefined ? this.readCommittedShadow(entry.id) : undefined;
                         let restoredShadow = false;
                         if (shadowText !== undefined) {
@@ -378,6 +353,20 @@ export class FileMemoryEngineBackend {
             catch {
             }
         }
+        if (skippedUnreadable.length > 0) {
+            try {
+                enqueueMemoryAnnouncement(this.controlPlaneRoot, {
+                    kind: "external",
+                    at: this.now(),
+                    items: skippedUnreadable
+                        .slice(0, 12)
+                        .map((rel) => `committed memory entry could not be read and is MISSING from this session's memory: ${JSON.stringify(inlineUntrusted(rel))} — check the file (permissions/fs)`)
+                        .concat(skippedUnreadable.length > 12 ? [`…and ${skippedUnreadable.length - 12} more unreadable entr(ies)`] : []),
+                });
+            }
+            catch {
+            }
+        }
         if (!sync && this.batchScan !== undefined)
             this.batchScan.set(scope, entries);
         return entries;
@@ -458,7 +447,7 @@ export class FileMemoryEngineBackend {
                 try {
                     const fd = openSync(ownerPath, "w", 0o600);
                     try {
-                        writeSync(fd, token);
+                        writeAllSync(fd, token);
                         fsyncSync(fd);
                     }
                     finally {
@@ -584,7 +573,7 @@ export class FileMemoryEngineBackend {
             mkdirSync(dirname(op.target), { recursive: true });
             const fd = openSync(staged, "w", 0o600);
             try {
-                writeSync(fd, op.content);
+                writeAllSync(fd, op.content);
                 fsyncSync(fd);
             }
             finally {

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

@@ -23,6 +23,13 @@ export declare function scopeDirFor(memoryDir: string, controlDir: string, scope
 export declare function canonicalize(p: string): string;
 export declare function isContainedIn(root: string, child: string): boolean;
 export declare function ensureDirExists(dir: string): void;
+export declare const QUARANTINE_DIR = "quarantine";
+export interface QuarantineOutcome {
+    dest?: string;
+    removed: boolean;
+    detail?: string;
+}
+export declare function quarantineAndTombstone(path: string, content: string, quarantineDir: string, now: () => number): QuarantineOutcome;
 export declare const ANNOUNCEMENTS_FILE = "announcements.json";
 export declare const MEMORY_ANNOUNCEMENTS_MAX = 20;
 export declare const SCAN_FUSE_FILE = "scan-fuse.json";
@@ -39,5 +46,6 @@ export declare function readIndexRevs(controlDir: string): Record<string, string
 export declare function writeIndexRevs(controlDir: string, revs: Record<string, string>): void;
 export declare function scanFuseCount(controlDir: string, key: string): number;
 export declare function clearScanFuse(controlDir: string, keys: Iterable<string>): void;
+export declare function writeAllSync(fd: number, data: string): void;
 export declare function atomicWriteFileSync(path: string, data: string): void;
 export {};

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

@@ -1,7 +1,7 @@
-import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeSync } from "node:fs";
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
 import { homedir } from "node:os";
 import { createHash } from "node:crypto";
-import { dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
 const SCOPES_FILE = "scopes.json";
 export const CURSORS_FILE = "cursors.json";
 export class ControlPlaneCorruptError extends Error {
@@ -190,6 +190,52 @@ export function ensureDirExists(dir) {
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true, mode: 0o700 });
 }
+export const QUARANTINE_DIR = "quarantine";
+const DELETED_TOMBSTONE = "---\ndeleted: true\n---\n";
+let quarantineSeq = 0;
+export function quarantineAndTombstone(path, content, quarantineDir, now) {
+    let captured;
+    let detail;
+    try {
+        ensureDirExists(quarantineDir);
+        const base = `${now()}-${basename(path)}`;
+        for (let attempt = 0; captured === undefined && attempt < 10; attempt++) {
+            const candidate = join(quarantineDir, attempt === 0 ? base : `${base}.${attempt}`);
+            try {
+                writeFileSync(candidate, content, { encoding: "utf8", flag: "wx" });
+                captured = candidate;
+            }
+            catch (err) {
+                if (!(err instanceof Error && "code" in err && err.code === "EEXIST"))
+                    throw err;
+            }
+        }
+        if (captured === undefined) {
+            const last = join(quarantineDir, `${base}.${process.pid}.${quarantineSeq++}`);
+            writeFileSync(last, content, { encoding: "utf8", flag: "wx" });
+            captured = last;
+        }
+    }
+    catch (err) {
+        detail = `quarantine copy failed: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    let removed = false;
+    try {
+        rmSync(path, { force: true });
+        removed = true;
+    }
+    catch (rmErr) {
+        try {
+            writeFileSync(path, DELETED_TOMBSTONE, "utf8");
+            removed = true;
+            detail = `${detail !== undefined ? `${detail}; ` : ""}delete failed (${rmErr instanceof Error ? rmErr.message : String(rmErr)}) — tombstoned in place`;
+        }
+        catch (clearErr) {
+            detail = `${detail !== undefined ? `${detail}; ` : ""}suspect file could not be deleted or cleared: ${clearErr instanceof Error ? clearErr.message : String(clearErr)}`;
+        }
+    }
+    return { ...(captured !== undefined ? { dest: captured } : {}), removed, ...(detail !== undefined ? { detail } : {}) };
+}
 export const ANNOUNCEMENTS_FILE = "announcements.json";
 export const MEMORY_ANNOUNCEMENTS_MAX = 20;
 export const SCAN_FUSE_FILE = "scan-fuse.json";
@@ -219,7 +265,7 @@ function acquireSidecarLock(lockDir, opts = {}) {
             let fd;
             try {
                 fd = openSync(join(lockDir, "owner"), "w");
-                writeSync(fd, token);
+                writeAllSync(fd, token);
             }
             catch {
             }
@@ -444,12 +490,22 @@ export function clearScanFuse(controlDir, keys) {
         return changed ? counts : undefined;
     });
 }
+export function writeAllSync(fd, data) {
+    const buf = Buffer.from(data, "utf8");
+    let written = 0;
+    while (written < buf.length) {
+        const n = writeSync(fd, buf, written, buf.length - written);
+        if (n <= 0)
+            throw new Error(`writeAllSync: write made no progress (${written}/${buf.length} bytes) — refusing to leave a truncated file`);
+        written += n;
+    }
+}
 export function atomicWriteFileSync(path, data) {
     ensureDirExists(dirname(path));
     const tmp = join(dirname(path), `.tmp-${process.pid}-${Math.random().toString(36).slice(2, 10)}`);
     const fd = openSync(tmp, "w", 0o600);
     try {
-        writeSync(fd, data);
+        writeAllSync(fd, data);
         fsyncSync(fd);
     }
     finally {

package/dist/core/memory-engine/scope-contract.js

@@ -1,5 +1,11 @@
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
+import { canonicalize } from "./layout.js";
+function pathSegmentsDualFamily(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);
 export const SCOPE_SEGMENT_MAX_ENCODED = 64;
 const SEGMENT_SAFE = /^[A-Za-z0-9._-]$/;
 export function encodeScopeSegment(raw) {
@@ -117,9 +123,9 @@ export function assertScopeContractPlacement(args) {
     const personal = args.parsedScopes.filter(isCentralAuthorityScope);
     if (personal.length === 0)
         return;
-    const root = resolve(args.repoRoot);
-    const dir = resolve(args.memoryDir);
-    if (dir === root || dir.startsWith(root + "/")) {
+    const rootSegs = pathSegmentsDualFamily(canonicalize(resolve(args.repoRoot))).map(foldPathCase);
+    const dirSegs = pathSegmentsDualFamily(canonicalize(resolve(args.memoryDir))).map(foldPathCase);
+    if (rootSegs.length <= dirSegs.length && rootSegs.every((s, i) => s === dirSegs[i])) {
         const e = new Error(`memory scope contract v2: central-authority scope(s) ${personal
             .map((p) => `"${p.kind}"`)
             .join(", ")} cannot materialize into an IN-REPO memory dir (${args.memoryDir}) — ` +

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

@@ -88,7 +88,7 @@ export interface MemorySessionHandle {
     indexBaselineLines: number;
     indexText: string;
 }
-export type HarvestRejectionCode = "outside_root" | "symlink" | "secret" | "injection" | "filename" | "too_large" | "file_cap" | "readonly_layer" | "stub_modified" | "nested_too_deep" | "quarantine_failed" | "invalid";
+export type HarvestRejectionCode = "outside_root" | "symlink" | "secret" | "injection" | "filename" | "too_large" | "file_cap" | "readonly_layer" | "stub_modified" | "nested_too_deep" | "quarantine_failed" | "unreadable" | "invalid";
 export interface HarvestRejection {
     path: string;
     code: HarvestRejectionCode;

package/dist/core/permission-rules.js

@@ -1,4 +1,3 @@
-import { canonicalToolName } from "./tool-name-aliases.js";
 export const BASH_GENERIC_PARAMS = new Set(["command", "timeout", "description", "run_in_background"]);
 const DEFAULT_CAPS = {
     maxRules: 256,
@@ -142,7 +141,7 @@ function compile(rules, caps, primaryFieldGeneric) {
                 continue;
             }
         }
-        const toolName = canonicalToolName(parsed.toolName);
+        const toolName = parsed.toolName;
         if (toolName.startsWith("mcp__") && (parsed.ruleContent !== undefined || indexOfUnescaped(text, "(") !== -1)) {
             bad(text, "unsupported.mcp_paren", "MCP rules do not support patterns in parentheses (CC parity); use the toolAxes system");
             continue;
@@ -262,7 +261,7 @@ export function createPermissionRulePolicy(rules, opts) {
     const defaultAction = opts?.defaultAction ?? "allow";
     return {
         check(req) {
-            const entry = byTool.get(canonicalToolName(req.toolName));
+            const entry = byTool.get(req.toolName);
             if (entry) {
                 if (entry.bare.deny) {
                     return { action: "deny", reason: ruleMessage("denied", entry.bare.deny.ruleText, entry.bare.deny.source) };

package/dist/core/runner/active-skill-scope.d.ts

@@ -16,7 +16,6 @@ export declare class ActiveSkillScope {
     active(): readonly ActiveSkillFrame[];
     get size(): number;
 }
-export declare function isWithin(root: string, p: string): boolean;
 export declare function createActiveSkillScopePolicy(opts: {
     scope: ActiveSkillScope;
     env: ExecutionEnv;

package/dist/core/runner/active-skill-scope.js

@@ -1,5 +1,5 @@
 import { canonicalizeTarget, fileArgPath } from "../../tools/fs/safety.js";
-import { canonicalToolName } from "../tool-name-aliases.js";
+import { PATH_WRITE_TOOLS, isWithin } from "./session-rule-policy.js";
 import { parseSkillToolEntry, skillSpecifierRejection } from "../skill-tool-specifier.js";
 export class ActiveSkillScope {
     frames = [];
@@ -16,26 +16,11 @@ export class ActiveSkillScope {
         return this.frames.length;
     }
 }
-const PATH_WRITE_TOOLS = new Set(["Write", "Edit", "MultiEdit"]);
-export function isWithin(root, p) {
-    const norm = (x) => {
-        let n = x.replace(/\\/g, "/");
-        if (/^[A-Za-z]:(\/|$)/.test(n))
-            n = n[0].toLowerCase() + n.slice(1);
-        return n;
-    };
-    const r = norm(root);
-    const c = norm(p);
-    if (c === r)
-        return true;
-    const base = r.endsWith("/") ? r : r + "/";
-    return c.startsWith(base);
-}
 export function createActiveSkillScopePolicy(opts) {
     const { scope, env, rootPath, toolEffects } = opts;
     return {
         async check(req, signal) {
-            const toolName = canonicalToolName(req.toolName);
+            const toolName = req.toolName;
             const frames = scope.active();
             if (frames.length === 0)
                 return { action: "allow" };

package/dist/core/runner/assemble-result.d.ts

@@ -1,5 +1,5 @@
 import type { AssistantMessage } from "../../internal/llm.js";
-import type { TaskResult, TaskSpec } from "../types.js";
+import type { NestedUsage, TaskResult, TaskSpec } from "../types.js";
 export interface Stats {
     turns: number;
     tokens: number;
@@ -12,12 +12,7 @@ export interface Stats {
     cacheHitRate?: number;
     totalInputTokens: number;
     costMicroUsd: number;
-    nested?: {
-        tokens: number;
-        turns: number;
-        tasks: number;
-        costMicroUsd?: number;
-    };
+    nested?: NestedUsage;
     memory?: {
         tokens: number;
         costMicroUsd: number;

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

@@ -1,5 +1,4 @@
-import { DEGENERATE_MESSAGE } from "../../brain/repetition.js";
-import { WALLTIME_CUTOFF_MESSAGE } from "../../brain/walltime.js";
+import { isDegenerateCutMessage, isWalltimeCutMessage } from "../../brain/terminal-cause.js";
 import { extractErrorCode, stripErrorCodePrefix } from "../../brain/errors.js";
 export function errorCodeOf(err) {
     let cur = err;
@@ -54,8 +53,8 @@ export function assembleResult(spec, sessionId, final, stats, flags) {
     let checkpointToken;
     let checkpointGate;
     let workspaceRestoreMode;
-    const isDegenerate = final?.stopReason === "error" && final.errorMessage === DEGENERATE_MESSAGE;
-    const isWalltimeCutoff = final?.stopReason === "error" && final.errorMessage === WALLTIME_CUTOFF_MESSAGE;
+    const isDegenerate = final?.stopReason === "error" && isDegenerateCutMessage(final);
+    const isWalltimeCutoff = final?.stopReason === "error" && isWalltimeCutMessage(final);
     if (flags.outputInvalid) {
         status = "failed";
         errorCode = "output.invalid";

package/dist/core/runner/compaction-call-options.d.ts

@@ -0,0 +1,7 @@
+import { type TracerHook } from "../trace.js";
+import type { MaybeCompactOptions } from "../auto-compaction.js";
+import type { TaskSpec } from "../types.js";
+import type { Prepared } from "./prepare-task.js";
+export declare function buildWorkingFileAttachments(spec: TaskSpec, prepared: Prepared): MaybeCompactOptions["workingFileAttachments"];
+export declare function centerAdoptionOption(prepared: Prepared): Partial<Pick<MaybeCompactOptions, "centerAdoption">>;
+export declare function emitInputTruncated(tracer: TracerHook | undefined, taskId: string): NonNullable<MaybeCompactOptions["onInputTruncated"]>;

package/dist/core/runner/compaction-call-options.js

@@ -0,0 +1,30 @@
+import { emitTrace } from "../trace.js";
+export function buildWorkingFileAttachments(spec, prepared) {
+    if (spec.compaction?.attachWorkingFiles === false || !prepared.readTaskFile)
+        return undefined;
+    return {
+        readFile: prepared.readTaskFile,
+        ...(prepared.recentlyReadFiles ? { recentlyReadFiles: prepared.recentlyReadFiles } : {}),
+        ...(prepared.normalizeAttachmentPath ? { normalizePath: prepared.normalizeAttachmentPath } : {}),
+        ...(prepared.isDedupStubResult ? { isDedupStubResult: prepared.isDedupStubResult } : {}),
+        ...(prepared.instructionSources
+            ? { instructionSourcePaths: prepared.instructionSources.filter((s) => s.contentHash !== null).map((s) => s.path) }
+            : {}),
+        ...(typeof spec.compaction?.attachWorkingFiles === "object" ? spec.compaction.attachWorkingFiles : undefined),
+    };
+}
+export function centerAdoptionOption(prepared) {
+    const ca = prepared.centerCompactionCandidate?.();
+    return ca !== undefined ? { centerAdoption: ca } : {};
+}
+export function emitInputTruncated(tracer, taskId) {
+    return (info) => emitTrace(tracer, () => ({
+        kind: "compaction.input_truncated",
+        version: 1,
+        taskId,
+        label: info.label,
+        droppedChars: info.droppedChars,
+        keptChars: info.keptChars,
+        ts: Date.now(),
+    }));
+}

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

@@ -12,12 +12,13 @@ import type { SessionPermissionRules } from "../session-policy-store.js";
 import { CacheBreakDetector, type ToolFingerprintInput } from "../cache-break-detector.js";
 import { type OutputRef, type BlockedRef, type SkillListingEntry } from "./synthetic-tools.js";
 import type { MemoryEngine } from "../memory-engine/engine.js";
+import { type ToolManifestRow } from "../../prompt-assembly/tool-catalog.js";
 import type { TaskNotificationPayload } from "../task-notification.js";
 import { type CwdRef } from "../../tools/fs/index.js";
 import type { Runner } from "./runtask.js";
 import { type CheckpointGate, type CheckpointState, type CheckpointToken, type ResourceLedger, type ResourceLimitReason } from "../checkpoint-store.js";
-import type { AgentMessage, AgentTool, ExecutionEnv } from "../../internal/harness.js";
-import type { RunnerDeps, TaskEvent, TaskResult, TaskSpec, ToolActivity, ToolEffect } from "../types.js";
+import type { ActiveWorktreeSession, AgentMessage, AgentTool, ExecutionEnv } from "../../internal/harness.js";
+import type { NestedUsageAccum, RunnerDeps, TaskEvent, TaskResult, TaskSpec, ToolActivity, ToolEffect } from "../types.js";
 import type { RepairBundle } from "../../agents/repair-loop.js";
 export declare const DEFAULT_IRREVERSIBLE_SCOPE = "irreversible";
 export declare function checkpointScopeOf(spec: {
@@ -42,21 +43,11 @@ export interface Prepared {
         hit: boolean;
     };
     blockedToolCalls: Set<string>;
-    nestedStats: {
-        tokens: number;
-        turns: number;
-        tasks: number;
-        costMicroUsd: number;
-    };
+    nestedStats: NestedUsageAccum;
     rewindNotes?: NonNullable<TaskResult["rewindNotes"]>;
     cwdRef?: CwdRef;
     worktreeSessionRef?: {
-        current?: {
-            worktreeDir: string;
-            originalCwd: string;
-            baseSha: string;
-            entered?: boolean;
-        };
+        current?: ActiveWorktreeSession;
     };
     workspaceStateSettle?: {
         rootCanonical: string;
@@ -89,15 +80,7 @@ export interface Prepared {
             hash: string;
             contentHash?: string;
         }>;
-        tools?: Array<{
-            wireName: string;
-            aliases: string[];
-            contractId: string;
-            implementationRevision: string;
-            cardId: string;
-            shapeDigest: string;
-            wireSchemaDigest: string;
-        }>;
+        tools?: ToolManifestRow[];
         snapshot?: {
             cacheIdentity: string;
             elements: import("../../prompt-assembly/turn-snapshot.js").CacheIdentityElements;