@zergai/ztc 0.4.0-beta.1 → 0.5.0-beta.1

package/dist/simulation/llm.d.ts

@@ -4,8 +4,10 @@
  * configured with, so it works with any provider (OpenAI, Anthropic,
  * Gemini, proxy, etc.).
  */
+import type { BufferedRecoveryPolicy, BufferedRecoveryRequest } from '../agent/backends/types.js';
 import { simSwarmExtractFirstJson as extractFirstJson } from '@ztc/sim-swarm';
 import type { ZodType } from 'zod';
+import { type ResolvedSimulationInference } from './inference.js';
 import { type SimulationLlmCallContext } from './telemetry.js';
 export declare function setActiveSimulationSignalGetter(getter: (() => AbortSignal | undefined) | null): void;
 /** Marker class so callers can distinguish abort-induced failures from real errors. */
@@ -101,4 +103,4 @@ export declare function llmCompleteStructured<T>(system: string, userMessage: st
  * Rejects with a timeout error after `timeoutMs` milliseconds so the caller
  * is never blocked permanently by a stalled provider.
  */
-export declare function llmComplete(system: string, userMessage: string, maxTokens?: number, timeoutMs?: number, callContext?: SimulationLlmCallContext, signal?: AbortSignal): Promise<string>;
+export declare function llmComplete(system: string, userMessage: string, maxTokens?: number, timeoutMs?: number, callContext?: SimulationLlmCallContext, signal?: AbortSignal, inferenceOverride?: Pick<ResolvedSimulationInference, 'provider' | 'model' | 'codexEffort' | 'codexFastMode'>, responseValidator?: (responseText: string) => void, outputSchema?: Record<string, unknown>, outputSchemaStrict?: boolean, bufferedRecovery?: BufferedRecoveryPolicy & Pick<BufferedRecoveryRequest, 'onAttempt'>): Promise<string>;

package/dist/simulation/llm.js

@@ -6,6 +6,7 @@
  */
 import { configStore } from '../config.js';
 import { createBackendForProvider } from '../agent/backends/index.js';
+import { CodexBufferedDeadlineError } from '../agent/backends/codex_buffered_recovery.js';
 import { jsonrepair } from 'jsonrepair';
 import { simSwarmExtractFirstJson as extractFirstJson } from '@ztc/sim-swarm';
 import { resolveSimulationInference, } from './inference.js';
@@ -101,6 +102,7 @@ export function circuitOnFailure(now) {
 let cachedBackend = null;
 let cachedBackendKey = null;
 const DEFAULT_SIM_MAX_TOKENS = 2048;
+const SIM_CODEX_MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
 /**
  * Get (or create) a backend instance matching the current config.
  * Cached until provider or API key changes.
@@ -110,12 +112,19 @@ function getBackend(resolved) {
     const apiKey = resolved.apiKey ?? configStore.getApiKey(provider);
     if (!apiKey)
         throw new Error('No API key configured for LLM fill');
-    const cacheKey = `${provider}:${apiKey}:${resolved.baseUrl ?? ''}:${resolved.model}`;
+    const cacheKey = [
+        provider,
+        apiKey,
+        resolved.baseUrl ?? '',
+        resolved.model,
+        resolved.codexAuthFilePath ?? '',
+    ].join(':');
     if (cachedBackend && cachedBackendKey === cacheKey)
         return cachedBackend;
     cachedBackend = createBackendForProvider(provider, {
         apiKey,
         baseUrl: resolved.baseUrl ?? (configStore.getOpenAICompatibleBaseUrl() || undefined),
+        codexAuthFilePath: resolved.codexAuthFilePath,
     });
     cachedBackendKey = cacheKey;
     return cachedBackend;
@@ -263,8 +272,13 @@ export const LLM_TIMEOUT_MS = 90_000;
  */
 export async function llmCompleteStructured(system, userMessage, schema, context, maxTokens = DEFAULT_SIM_MAX_TOKENS, timeoutMs = LLM_TIMEOUT_MS, callContext, signal) {
     const jsonHint = '\n\nReturn ONLY a single valid JSON value. No markdown fences, no prose.';
-    const raw = await llmComplete(system, userMessage + jsonHint, maxTokens, timeoutMs, callContext, signal);
-    return safeParseJsonWithSchema(raw, schema, context);
+    let parsed;
+    await llmComplete(system, userMessage + jsonHint, maxTokens, timeoutMs, callContext, signal, undefined, (raw) => {
+        parsed = { value: safeParseJsonWithSchema(raw, schema, context) };
+    });
+    if (parsed === undefined)
+        throw new Error(`${context} returned no validated value`);
+    return parsed.value;
 }
 /**
  * One-shot LLM completion. Returns the text response.
@@ -273,22 +287,17 @@ export async function llmCompleteStructured(system, userMessage, schema, context
  * Rejects with a timeout error after `timeoutMs` milliseconds so the caller
  * is never blocked permanently by a stalled provider.
  */
-export async function llmComplete(system, userMessage, maxTokens = DEFAULT_SIM_MAX_TOKENS, timeoutMs = LLM_TIMEOUT_MS, callContext, signal) {
+export async function llmComplete(system, userMessage, maxTokens = DEFAULT_SIM_MAX_TOKENS, timeoutMs = LLM_TIMEOUT_MS, callContext, signal, inferenceOverride, responseValidator, outputSchema, outputSchemaStrict, bufferedRecovery) {
     const startedAt = new Date();
-    const inference = resolveSimulationInference();
+    const inference = resolveSimulationInference(inferenceOverride);
     const backend = getBackend(inference);
-    const { codexEffort, model, provider } = inference;
+    const { codexEffort, codexFastMode, model, provider } = inference;
+    if (bufferedRecovery && provider !== 'codex_legacy')
+        throw new Error('Buffered Codex recovery requires the Codex subscription provider');
     const context = callContext ?? { stage: 'world.evolve', component: 'simulation.llm.default' };
     // When called inside a running sim, default the abort signal to the run's
     // controller so stop() / cancelGame() cancels in-flight provider HTTP calls.
     const effectiveSignal = signal ?? getActiveSimAbortSignal();
-    // Fail fast if the sim was already stopped before the call started.
-    if (effectiveSignal?.aborted) {
-        throw new SimulationAbortedError();
-    }
-    // Circuit breaker: fail fast (degraded) when consecutive provider failures
-    // have tripped the breaker, instead of hammering a failing provider.
-    circuitPreflight(Date.now());
     let timerId;
     let abortListener;
     const requestController = new AbortController();
@@ -296,7 +305,18 @@ export async function llmComplete(system, userMessage, maxTokens = DEFAULT_SIM_M
     let stopReason;
     let usage;
     let caughtError;
+    let outcome = 'success';
+    let timedOut = false;
+    let invalidOutput = false;
+    let providerSucceeded = false;
     try {
+        // Fail fast if the simulation stopped before the call started.
+        if (effectiveSignal?.aborted) {
+            throw new SimulationAbortedError();
+        }
+        // Circuit breaker: fail fast when earlier provider failures opened it.
+        circuitPreflight(Date.now());
+        const deadlineAtMs = Date.now() + timeoutMs;
         const response = await Promise.race([
             backend.generate({
                 model,
@@ -305,14 +325,20 @@ export async function llmComplete(system, userMessage, maxTokens = DEFAULT_SIM_M
                 messages: [{ role: 'user', content: userMessage }],
                 tools: [],
                 codexEffort,
+                codexFastMode,
+                maxResponseBytes: SIM_CODEX_MAX_RESPONSE_BYTES,
+                outputTokenGuidance: true,
                 signal: requestController.signal,
+                ...(bufferedRecovery === undefined ? {} : { bufferedRecovery: { ...bufferedRecovery, deadlineAtMs } }),
+                ...(outputSchema === undefined ? {} : { outputSchema, outputSchemaStrict }),
             }).finally(() => clearTimeout(timerId)),
             new Promise((_, reject) => {
                 timerId = setTimeout(() => {
+                    timedOut = true;
                     const timeoutError = new Error(`LLM request timed out after ${timeoutMs}ms`);
                     requestController.abort(timeoutError);
                     reject(timeoutError);
-                }, timeoutMs);
+                }, bufferedRecovery === undefined ? timeoutMs : Math.max(0, deadlineAtMs - Date.now()));
                 // Reject the race immediately on abort so the timeout setTimeout doesn't
                 // keep the event loop alive after the caller has bailed.
                 if (effectiveSignal) {
@@ -332,12 +358,30 @@ export async function llmComplete(system, userMessage, maxTokens = DEFAULT_SIM_M
         usage = response.usage;
         const textBlocks = response.content.filter(b => b.type === 'text');
         if (textBlocks.length === 0) {
+            invalidOutput = true;
             throw new Error(`LLM returned no text content (stopReason: ${response.stopReason})`);
         }
         responseText = textBlocks.map(b => b.text).join('\n');
+        // The provider answered. Output that fails validation is a model fault,
+        // not a provider fault, so it must not count toward the breaker.
         circuitOnSuccess();
+        providerSucceeded = true;
+        if (responseValidator) {
+            try {
+                responseValidator(responseText);
+            }
+            catch (error) {
+                invalidOutput = true;
+                throw error;
+            }
+        }
     }
     catch (err) {
+        if (err instanceof CodexBufferedDeadlineError) {
+            timedOut = true;
+            err = new Error(`LLM request timed out after ${timeoutMs}ms`);
+            requestController.abort(err);
+        }
         // Wrap raw AbortError from the provider SDK into our marker class so
         // callers can treat it as "stopped" instead of "failed".
         if (effectiveSignal?.aborted && !(err instanceof SimulationAbortedError)) {
@@ -348,29 +392,45 @@ export async function llmComplete(system, userMessage, maxTokens = DEFAULT_SIM_M
         }
         // Abort is an intentional cancellation, not a provider fault — never trip
         // the breaker on it. Real provider/transport failures count toward it.
-        if (!(caughtError instanceof SimulationAbortedError)) {
+        if (!providerSucceeded
+            && !(caughtError instanceof SimulationAbortedError)
+            && !(caughtError instanceof SimulationDegradedError)) {
             circuitOnFailure(Date.now());
         }
+        outcome = caughtError instanceof SimulationAbortedError
+            ? 'aborted'
+            : caughtError instanceof SimulationDegradedError
+                ? 'circuit-open'
+                : timedOut
+                    ? 'timeout'
+                    : invalidOutput
+                        ? 'invalid-output'
+                        : 'provider-error';
     }
     finally {
         if (effectiveSignal && abortListener) {
             effectiveSignal.removeEventListener('abort', abortListener);
         }
-        recordSimulationLlmCall({
-            context,
-            provider,
-            model,
-            reasoningEffort: codexEffort,
-            maxTokensRequested: maxTokens,
-            system,
-            userMessage,
-            responseText,
-            stopReason,
-            usage,
-            startedAt,
-            endedAt: new Date(),
-            error: caughtError,
-        });
+        try {
+            recordSimulationLlmCall({
+                context,
+                provider,
+                model,
+                reasoningEffort: codexEffort,
+                maxTokensRequested: maxTokens,
+                systemBytes: Buffer.byteLength(system, 'utf8'),
+                userBytes: Buffer.byteLength(userMessage, 'utf8'),
+                responseBytes: Buffer.byteLength(responseText, 'utf8'),
+                outcome,
+                stopReason,
+                usage,
+                startedAt,
+                endedAt: new Date(),
+            });
+        }
+        catch {
+            // Telemetry is observational. It cannot replace a gameplay result.
+        }
     }
     if (caughtError)
         throw caughtError;

package/dist/simulation/memory/embedding.d.ts

@@ -50,4 +50,4 @@ export declare class ZeroEmbeddingProvider implements EmbeddingProvider {
  * For Anthropic/Gemini/other providers, fall back to OPENAI_API_KEY env var.
  * No TF-IDF fallback — real embeddings are required.
  */
-export declare function createEmbeddingProvider(cache: Map<string, number[]>): EmbeddingProvider;
+export declare function createEmbeddingProvider(cache: Map<string, number[]>, sessionProvider?: string): EmbeddingProvider;

package/dist/simulation/memory/embedding.js

@@ -145,13 +145,19 @@ export class ZeroEmbeddingProvider {
  * For Anthropic/Gemini/other providers, fall back to OPENAI_API_KEY env var.
  * No TF-IDF fallback — real embeddings are required.
  */
-export function createEmbeddingProvider(cache) {
-    if (process.env.ZTC_SIM_DISABLE_EMBEDDINGS === '1') {
+export function createEmbeddingProvider(cache, sessionProvider) {
+    // Session construction and checkpoint restore happen before ambient state is attached.
+    if (sessionProvider === 'zergrouter') {
+        return new CachedEmbeddingProvider(new ZeroEmbeddingProvider(), cache);
+    }
+    const inference = resolveSimulationInference();
+    // A ZergRouter simulation runs only its one DeepSeek chat model. It has no
+    // embedding model, so retrieval stays lexical and no other provider is called.
+    if (process.env.ZTC_SIM_DISABLE_EMBEDDINGS === '1' || inference.provider === 'zergrouter') {
         return new CachedEmbeddingProvider(new ZeroEmbeddingProvider(), cache);
     }
     const provider = configStore.getProvider();
     const cfg = configStore.get();
-    const inference = resolveSimulationInference();
     let apiKey;
     let baseUrl;
     let model = inference.embeddingModel ?? EMBEDDING_MODEL;

package/dist/simulation/memory/filesystem.d.ts

@@ -61,6 +61,7 @@ export declare class FileSystemMemory implements CuratableMemoryStore {
     private recordCuratorStrictnessProbe;
     logRetrieval(context: MemoryRetrievalLogContext, results: RetrievalResult[]): void;
     verifyInvariants(): InvariantViolation[];
+    hasSourceFile(relativePath: string): boolean;
     getIdToNodeMap(): ReadonlyMap<string, ConceptNode>;
     getStreams(): {
         seqEvent: readonly ConceptNode[];
@@ -73,6 +74,7 @@ export declare class FileSystemMemory implements CuratableMemoryStore {
     static fromSnapshot(snapshot: FileSystemMemorySnapshot, clock: SimClock, opts: {
         outputDir: string;
         invariantMode?: InvariantMode;
+        detached?: boolean;
     }): FileSystemMemory;
     private addConceptNode;
     private autoSupersedeStaleUpdates;

package/dist/simulation/memory/filesystem.js

@@ -70,7 +70,7 @@ export class FileSystemMemory {
         this.outputDir = resolve(opts.outputDir);
         assertFileSystemMemoryOutputDirAllowed(this.outputDir);
         this.root = resolve(this.outputDir, 'memory', this.agentId);
-        this.files = new FileSystemMemoryFileTree(this.outputDir, this.root, this.agentId);
+        this.files = new FileSystemMemoryFileTree(this.outputDir, this.root, this.agentId, opts.detached);
         this.curator = new FileSystemMemoryCuratorPatchExecutor({
             agentId: this.agentId,
             now: () => this.auditTimestamp(),
@@ -338,6 +338,9 @@ export class FileSystemMemory {
     verifyInvariants() {
         return reportFileSystemMemoryInvariants(this);
     }
+    hasSourceFile(relativePath) {
+        return this.files.hasRelativeFile(relativePath);
+    }
     getIdToNodeMap() {
         return new Map([...this.idToNode.entries()].map(([id, node]) => [id, cloneConceptNode(node)]));
     }
@@ -373,6 +376,7 @@ export class FileSystemMemory {
     static fromSnapshot(snapshot, clock, opts) {
         const memory = new FileSystemMemory(snapshot.agentId, clock, {
             outputDir: opts.outputDir,
+            detached: opts.detached,
             invariantMode: opts.invariantMode,
         });
         memory.seqEvent = snapshot.seqEvent.map(node => ({ ...node }));

package/dist/simulation/memory/filesystem_file_tree.d.ts

@@ -6,13 +6,16 @@ export declare class FileSystemMemoryFileTree {
     readonly outputDir: string;
     readonly root: string;
     private readonly agentId;
-    constructor(outputDir: string, root: string, agentId: string);
+    private readonly detached;
+    private readonly detachedFiles;
+    constructor(outputDir: string, root: string, agentId: string, detached?: boolean);
     initializeLayout(personaSeed: string | undefined, episodeDate: string): void;
     appendNodeBlock(node: ConceptNode, episodeDate: string): ConceptNode['memorySource'];
     writeCurrentFacts(nodes: ConceptNode[]): void;
     clear(): void;
     writeRelative(relativePath: string, content: string): void;
     readRelative(relativePath: string): string;
+    hasRelativeFile(relativePath: string): boolean;
     writeIfAbsent(relativePath: string, content: string): void;
     appendText(relativePath: string, content: string): void;
     makeDirectory(relativePath: string): void;

package/dist/simulation/memory/filesystem_file_tree.js

@@ -43,10 +43,14 @@ export class FileSystemMemoryFileTree {
     outputDir;
     root;
     agentId;
-    constructor(outputDir, root, agentId) {
+    detached;
+    // Detached candidates rebuild the same file contents without publishing them.
+    detachedFiles = new Map();
+    constructor(outputDir, root, agentId, detached = false) {
         this.outputDir = outputDir;
         this.root = root;
         this.agentId = agentId;
+        this.detached = detached;
         const outputRoot = resolve(outputDir);
         const memoryRoot = resolve(outputRoot, 'memory');
         this.ensureInside(memoryRoot, root);
@@ -54,7 +58,8 @@ export class FileSystemMemoryFileTree {
         this.ensureInside(realPathForPolicy(memoryRoot), realPathForPolicy(root));
     }
     initializeLayout(personaSeed, episodeDate) {
-        mkdirSync(this.root, { recursive: true });
+        if (!this.detached)
+            mkdirSync(this.root, { recursive: true });
         for (const dir of [
             'episodes',
             'facts',
@@ -65,7 +70,8 @@ export class FileSystemMemoryFileTree {
             'records',
             'events',
         ]) {
-            mkdirSync(this.absolute(dir), { recursive: true });
+            if (!this.detached)
+                mkdirSync(this.absolute(dir), { recursive: true });
         }
         this.writeIfAbsent('profile.md', `# Profile\n\n${personaSeed ? personaSeed.trim() : ''}\n`);
         this.writeIfAbsent('anchors.md', '# Durable Anchors\n\n');
@@ -86,13 +92,13 @@ export class FileSystemMemoryFileTree {
         if (category === 'episodes') {
             this.writeIfAbsent(relativePath, `# Episode ${episodeDate}\n\n`);
         }
-        const abs = this.absolute(relativePath);
-        this.ensureWritablePath(abs);
-        const text = existsSync(abs) ? readFileSync(abs, 'utf8') : '';
+        if (!this.detached)
+            this.ensureWritablePath(this.absolute(relativePath));
+        const text = this.readRelative(relativePath);
         const lineStart = lineCount(text) + 1;
         const block = renderMarkdownBlock(node);
         const lineEnd = lineStart + lineCount(block) - 1;
-        writeFileNoFollow(abs, block, true);
+        this.appendText(relativePath, block);
         return {
             backend: 'filesystem',
             relativePath,
@@ -125,40 +131,65 @@ export class FileSystemMemoryFileTree {
         this.writeRelative('facts/current.md', content);
     }
     clear() {
+        if (this.detached) {
+            this.detachedFiles.clear();
+            return;
+        }
         rmSync(this.root, { recursive: true, force: true });
         mkdirSync(this.root, { recursive: true });
     }
     writeRelative(relativePath, content) {
         const abs = this.absolute(relativePath);
+        if (this.detached) {
+            this.detachedFiles.set(abs, content);
+            return;
+        }
         this.ensureWritablePath(abs);
         writeFileNoFollow(abs, content, false);
     }
     readRelative(relativePath) {
         const abs = this.absolute(relativePath);
+        if (this.detached)
+            return this.detachedFiles.get(abs) ?? '';
         return existsSync(abs) ? readFileSync(abs, 'utf8') : '';
     }
+    hasRelativeFile(relativePath) {
+        const abs = this.absolute(relativePath);
+        return this.detached ? this.detachedFiles.has(abs) : existsSync(abs);
+    }
     writeIfAbsent(relativePath, content) {
         const abs = this.absolute(relativePath);
+        if (this.detached) {
+            if (!this.detachedFiles.has(abs))
+                this.detachedFiles.set(abs, content);
+            return;
+        }
         this.ensureWritablePath(abs);
         if (!existsSync(abs))
             writeFileNoFollow(abs, content, false);
     }
     appendText(relativePath, content) {
         const abs = this.absolute(relativePath);
+        if (this.detached) {
+            this.detachedFiles.set(abs, (this.detachedFiles.get(abs) ?? '') + content);
+            return;
+        }
         this.ensureWritablePath(abs);
         writeFileNoFollow(abs, content, true);
     }
     makeDirectory(relativePath) {
         const abs = this.absolute(relativePath);
+        if (this.detached)
+            return;
         this.ensureWritablePath(abs);
         mkdirSync(abs, { recursive: true });
     }
     appendJsonl(relativePath, entry) {
-        const abs = this.absolute(relativePath);
-        this.ensureWritablePath(abs);
-        writeFileNoFollow(abs, `${JSON.stringify(entry)}\n`, true);
+        this.appendText(relativePath, `${JSON.stringify(entry)}\n`);
     }
     appendTelemetryJsonl(fileName, entry) {
+        if (this.detached)
+            return;
         const telemetryDir = resolve(this.outputDir, 'telemetry');
         this.ensureInside(this.outputDir, telemetryDir);
         ensureWritableContainedPath(this.outputDir, telemetryDir);

package/dist/simulation/memory/filesystem_invariants.js

@@ -1,4 +1,3 @@
-import { existsSync } from 'node:fs';
 import { resolve, sep } from 'node:path';
 import { memoryPrivacyLabel } from './backend.js';
 export function reportFileSystemMemoryInvariants(mem) {
@@ -120,7 +119,7 @@ export function reportFileSystemMemoryInvariants(mem) {
                 severity: 'hard',
             });
         }
-        if (!existsSync(abs)) {
+        if (!mem.hasSourceFile(source.relativePath)) {
             violations.push({
                 kind: 'missing-source-file',
                 message: `node ${node.nodeId} source file missing: ${source.relativePath}`,

package/dist/simulation/memory/filesystem_types.d.ts

@@ -37,6 +37,7 @@ export interface FileSystemMemoryCuratorFileWriteEntry {
 }
 export interface FileSystemMemoryOptions {
     outputDir: string;
+    detached?: boolean;
     personaSeed?: string;
     invariantMode?: InvariantMode;
 }

package/dist/simulation/memory/memory.d.ts

@@ -36,6 +36,7 @@ export interface AssociativeMemoryOptions {
     getEmbeddings?: () => Map<string, number[]>;
     invariantMode?: InvariantMode;
     outputDir?: string;
+    detached?: boolean;
 }
 export declare class AssociativeMemory implements AgentMemoryStore {
     readonly kind: "associative";
@@ -64,6 +65,7 @@ export declare class AssociativeMemory implements AgentMemoryStore {
     private getEmbeddings?;
     private agentId?;
     private outputDir?;
+    private readonly detached;
     constructor(clock: SimClock, opts?: AssociativeMemoryOptions);
     /** Set/replace the clock (used during checkpoint restore). */
     setClock(clock: SimClock): void;

package/dist/simulation/memory/memory.js

@@ -47,12 +47,14 @@ export class AssociativeMemory {
     getEmbeddings;
     agentId;
     outputDir;
+    detached;
     constructor(clock, opts) {
         this.clock = clock;
         this.invariantMode = opts?.invariantMode ?? resolveInvariantMode();
         this.getEmbeddings = opts?.getEmbeddings;
         this.agentId = opts?.agentId;
         this.outputDir = opts?.outputDir ? resolve(opts.outputDir) : undefined;
+        this.detached = opts?.detached ?? false;
         if (this.outputDir) {
             this.touchTelemetryFile('memory_retrieval.jsonl');
             this.touchTelemetryFile('memory_curator.jsonl');
@@ -571,12 +573,14 @@ export class AssociativeMemory {
         return memory;
     }
     touchTelemetryFile(fileName) {
-        if (!this.outputDir)
+        if (this.detached || !this.outputDir)
             return;
         const path = this.telemetryPath(fileName);
         closeSync(openSync(path, 'a'));
     }
     appendTelemetryJsonl(fileName, entry) {
+        if (this.detached)
+            return;
         appendFileSync(this.telemetryPath(fileName), `${JSON.stringify(entry)}\n`);
     }
     telemetryPath(fileName) {

package/dist/simulation/orchestration/intent.js

@@ -85,7 +85,6 @@ async function generateSessionArc(agent, state, maxPeriods, prompts) {
             stage: 'intent.session_arc',
             component: 'orchestration.intent',
             agentId: agent.id,
-            agentName: agent.identity.fullName,
         });
         const trimmed = parsed.session_arc.trim().slice(0, MAX_SESSION_ARC_CHARS);
         return trimmed.length > 0 ? trimmed : null;
@@ -125,7 +124,6 @@ export async function generateAgentIntent(agent, state, periodCount, maxPeriods,
             component: 'orchestration.intent',
             periodNumber: periodCount,
             agentId: agent.id,
-            agentName: agent.identity.fullName,
         });
         const trimmed = parsed.intent.trim().slice(0, MAX_INTENT_CHARS);
         return trimmed.length > 0 ? trimmed : null;

package/dist/simulation/orchestration/lifecycle.js

@@ -43,7 +43,6 @@ export async function processLifecycleRequests(state, onProgress) {
                     stage: 'lifecycle.hire_review',
                     component: 'orchestration.lifecycle',
                     agentId: req.requesterId,
-                    agentName: requesterName,
                     requestId: req.id,
                 });
                 const approved = parseApprovalDecision(raw);
@@ -77,7 +76,6 @@ export async function processLifecycleRequests(state, onProgress) {
                     stage: 'lifecycle.termination_review',
                     component: 'orchestration.lifecycle',
                     agentId: req.requesterId,
-                    agentName: requesterName,
                     requestId: req.id,
                 });
                 const approved = parseApprovalDecision(raw);

package/dist/simulation/plugin_host.d.ts

@@ -1,12 +1,36 @@
 /** Private adapter from the public simulation plugin contract to the ZTC kernel. */
-import type { SimulationCompatibilityV1, SimulationDriverRegistrationV1, SimulationHostV1, SimulationJsonObjectV1, SimulationTransitionBatchV1, SimulationTransitionResultV1 } from '../plugin/simulation_contract.js';
+import type { SimulationCompatibilityV1, SimulationDriverRegistrationV1, SimulationDynamicStateV1, SimulationHostV1, SimulationJsonObjectV1, SimulationPlayerCommandV1, SimulationSessionRefV1, SimulationSessionSnapshotV1, SimulationSessionStatusV1, SimulationTransitionBatchV1, SimulationTransitionResultV1 } from '../plugin/simulation_contract.js';
 import { SimState } from './world/state.js';
+import type { SimulationInputJournalV1 } from '../plugin/simulation_interventions.js';
+export interface SessionRecord {
+    inputJournal: SimulationInputJournalV1 | undefined;
+    lastTransition: SimulationTransitionBatchV1 | null;
+    readonly state: SimState;
+    readonly driverKind: string;
+    readonly appliedTransitions: Set<string>;
+    readonly actorMetadata: Map<string, SimulationJsonObjectV1>;
+    readonly submittedPlayerCommandIds: Set<string>;
+    pendingPlayerCommand: SimulationPlayerCommandV1 | null;
+    dynamicState: SimulationDynamicStateV1 | null;
+    pluginData: Record<string, SimulationJsonObjectV1>;
+    status: SimulationSessionStatusV1;
+    revision: number;
+}
+type StateValidators = Pick<SimulationDriverRegistrationV1, 'validateDynamicState' | 'validateDocuments'>;
+/** Register canonical checkpoint validators without loading a driver or claiming its inference boundary. */
+export declare function registerSimulationCheckpointValidators(kind: string, validators: StateValidators): void;
 export declare function getKernelSimulationTransitionState(state: SimState): {
     revision: number;
     pluginData: SimulationJsonObjectV1;
 };
 export declare function applyKernelSimulationTransition(state: SimState, batch: SimulationTransitionBatchV1): Promise<SimulationTransitionResultV1>;
+export declare function detachedSessionRecord(checkpoint: SimulationJsonObjectV1): Promise<SessionRecord>;
+export declare function detachedSessionSnapshot(record: SessionRecord): SimulationSessionSnapshotV1;
+export declare function detachedSessionCheckpoint(record: SessionRecord, source: SimulationJsonObjectV1): SimulationJsonObjectV1;
+export declare function applyDetachedSessionTransition(record: SessionRecord, batch: SimulationTransitionBatchV1): Promise<void>;
+export declare function getOriginalSessionTransition(ref: SimulationSessionRefV1): SimulationTransitionBatchV1 | null;
 export declare function saveSimulationSessionCheckpoint(state: SimState, outputPath?: string): string;
 export declare function validateSimulationDriverRegistration(registration: SimulationDriverRegistrationV1): void;
 export declare function registerSimulationDriver(registration: SimulationDriverRegistrationV1): void;
 export declare function requireSimulationHost(compatibility: SimulationCompatibilityV1): SimulationHostV1;
+export {};