@deepstrike/wasm 0.2.77 → 0.2.78

package/dist/agent.d.ts

@@ -145,7 +145,6 @@ export interface AgentRunResult {
     evidence?: {
         route?: unknown;
         measurement?: unknown;
-        contextBinding?: unknown;
     };
 }
 export interface MemoryInput {
@@ -226,8 +225,13 @@ export declare class Agent {
     workflow(spec: WorkflowSpec, options?: {
         sessionId?: string;
     }): Promise<WorkflowOutcome>;
+    /** M4 · the runner a facade memory call goes through, so `remember`/`recall` take the same
+     *  kernel admission, memory runtime policy, candidate routing, recall lifecycle and session
+     *  audit as every other memory path. A `DurableMemory` is routed on its own store; any other
+     *  `Memory` facade is adapted to one. */
+    private memoryRunner;
     remember(input: MemoryInput, sessionId?: string): Promise<MemoryRecord>;
-    recall(query: string, options?: RecallOptions, _sessionId?: string): Promise<MemoryRecall[]>;
+    recall(query: string, options?: RecallOptions, sessionId?: string): Promise<MemoryRecall[]>;
     delegate(request: {
         target: AgentRef;
         goal: string;

package/dist/agent.js

@@ -2,7 +2,7 @@ import { RuntimeRunner } from "./runtime/runner.js";
 import { LocalExecutionPlane } from "./runtime/execution-plane.js";
 import { InMemorySessionLog } from "./runtime/session-log.js";
 import { extractJsonValue, validateAgainstSchema } from "./runtime/output-schema.js";
-import { checkMemoryWrite } from "./memory/authority.js";
+import { DurableMemory } from "./memory/durable.js";
 function statusOf(reason) {
     if (["completed", "success", "done"].includes(reason))
         return "completed";
@@ -158,31 +158,54 @@ export class Agent {
     resume(sessionId, options = {}) { return this.session(sessionId).resume(options); }
     interrupt(reason = "user", sessionId) { sessionId ? this.session(sessionId).interrupt(reason) : [...this.sessions.values()].forEach(s => s.interrupt(reason)); }
     workflow(spec, options = {}) { return this.session(options.sessionId).workflow(spec); }
-    async remember(input, sessionId) {
-        if (!this.memory || typeof this.memory.put !== "function")
+    /** M4 · the runner a facade memory call goes through, so `remember`/`recall` take the same
+     *  kernel admission, memory runtime policy, candidate routing, recall lifecycle and session
+     *  audit as every other memory path. A `DurableMemory` is routed on its own store; any other
+     *  `Memory` facade is adapted to one. */
+    memoryRunner() {
+        const memory = this.memory;
+        if (!memory || typeof memory.put !== "function" || typeof memory.search !== "function") {
             throw new Error(`agent "${this.name}" memory is not runtime-bound`);
+        }
+        const facade = memory;
+        const scope = facade.scope ?? { tenant_id: "default", namespace: facade.namespace ?? this.name };
+        const durable = memory instanceof DurableMemory ? memory : undefined;
+        const binding = this.runtimeBinding;
+        const provider = binding?.provider ?? (typeof this.model === "string" ? binding?.providerFor?.(this.model) : undefined);
+        const runner = new RuntimeRunner({
+            ...(binding?.runtimeOptions ?? {}),
+            provider: provider ?? memoryOnlyProvider(this.name),
+            executionPlane: new LocalExecutionPlane(),
+            sessionLog: this.sessionLog,
+            maxTokens: 32_000,
+            agentId: durable?.agentId ?? this.name,
+            memoryScope: scope,
+            memoryStore: durable?.store ?? facadeStore(facade),
+        });
+        return { runner, scope };
+    }
+    async remember(input, sessionId) {
+        const { runner, scope } = this.memoryRunner();
         const now = Date.now();
+        const session = sessionId ?? `memory-${crypto.randomUUID()}`;
         const record = {
-            record_id: crypto.randomUUID(), scope: this.memory.scope
-                ?? { tenant_id: "default", namespace: this.memory.namespace ?? this.name },
+            record_id: crypto.randomUUID(), scope,
             name: input.name, kind: input.kind ?? "reference", content: input.content,
             description: input.description ?? input.name,
-            provenance: { author: "host", trust: "user_asserted", evidence_refs: [], session_id: sessionId ?? `memory-${crypto.randomUUID()}` },
+            provenance: { author: "host", trust: "user_asserted", evidence_refs: [], session_id: session },
             created_at: now, updated_at: now, recall_count: 0, confidence: input.confidence ?? 1,
             links: [], pinned: input.pinned ?? false, ...(input.ttlDays === undefined ? {} : { ttl_days: input.ttlDays }),
         };
-        // §22.13 · the kernel's write rule, not a copy of it, decides whether this record may be stored.
-        const refusal = await checkMemoryWrite(undefined, record.name, record.content);
-        if (refusal)
-            throw new Error(`agent "${this.name}" memory write denied: ${refusal}`);
-        await this.memory.put(record);
+        if (!await runner.writeMemory(record, session))
+            throw new Error(`agent "${this.name}" memory write denied`);
         return record;
     }
-    async recall(query, options = {}, _sessionId) {
-        if (!this.memory || typeof this.memory.search !== "function")
-            throw new Error(`agent "${this.name}" memory is not runtime-bound`);
-        const records = await this.memory.search(query, { topK: options.topK ?? 8, kinds: options.kinds, minScore: options.minScore });
-        return records.map(record => ({ record, score: 1, why: "memory facade search" }));
+    async recall(query, options = {}, sessionId) {
+        const { runner, scope } = this.memoryRunner();
+        return runner.queryMemory({
+            scope, query, top_k: options.topK ?? 8, kinds: options.kinds ?? [],
+            ...(options.minScore === undefined ? {} : { min_score: options.minScore }),
+        }, sessionId ?? `memory-${crypto.randomUUID()}`);
     }
     async delegate(request) {
         const targetName = typeof request.target === "string" ? request.target : request.target.name;
@@ -231,12 +254,10 @@ export class Agent {
             result.usage = { inputTokens: attempt.usage.inputTokens, outputTokens: attempt.usage.outputTokens, totalTokens: attempt.usage.inputTokens + attempt.usage.outputTokens };
         }
         const measured = [...entries].reverse().find(e => e.event.kind === "prompt_measured")?.event;
-        const prepared = [...entries].reverse().find(e => e.event.kind === "context_prepared")?.event;
-        if ((started?.kind === "run_started" && started.route) || (attempt?.kind === "provider_attempt" && attempt.route) || measured || prepared) {
+        if ((started?.kind === "run_started" && started.route) || (attempt?.kind === "provider_attempt" && attempt.route) || measured) {
             result.evidence = {
                 ...((attempt?.kind === "provider_attempt" ? attempt.route : started?.kind === "run_started" ? started.route : undefined) ? { route: attempt?.kind === "provider_attempt" ? attempt.route : started.route } : {}),
                 ...(measured?.kind === "prompt_measured" ? { measurement: measured.measurement } : {}),
-                ...(prepared?.kind === "context_prepared" ? { contextBinding: prepared.preparation.binding } : {}),
             };
         }
         if (this.outputSchema) {
@@ -247,3 +268,22 @@ export class Agent {
         return result;
     }
 }
+/** The provider a memory-only runner carries: `remember`/`recall` never call the model. */
+function memoryOnlyProvider(agent) {
+    const refuse = () => { throw new Error(`agent "${agent}" has no runtime provider binding`); };
+    return { complete: async () => refuse(), stream: () => refuse() };
+}
+/** A `Memory` facade as the store the runner writes through. The facade reports records only,
+ *  so a recall from it carries no retrieval score. */
+function facadeStore(memory) {
+    return {
+        put: (_agentId, record) => memory.put(record),
+        get: (_agentId, recordId) => memory.get(recordId),
+        delete: (_agentId, recordId) => memory.delete(recordId),
+        search: async (_agentId, query) => (await memory.search(query.query, {
+            topK: query.top_k, kinds: query.kinds,
+            ...(query.min_score === undefined ? {} : { minScore: query.min_score }),
+        })).map(record => ({ record, score: 1, why: "memory facade search" })),
+        saveSession: async () => { },
+    };
+}

package/dist/index.d.ts

@@ -5,19 +5,17 @@ export { CANONICAL_CONTENT_PARTS_PREFIX, encodeCanonicalContentParts, decodeCano
 export type { ReplayProviderOpts, Criterion, Verdict, VerdictDetail, JudgeArgs, } from "./runtime/index.js";
 export type { NativeOsProfile, OsProfileId, MemoryPolicy, MemoryWriteRateLimit, ResourceQuota, RuntimeOptions, PromptBudget, SchedulerPolicy, SignalPolicy, SessionEvent, SessionEventKind, SessionLog, RunContext, ExecutionPlane, KernelEventCategory, KernelPrimitive, } from "./runtime/index.js";
 export { primitiveForCategory, primitiveForKind } from "./runtime/index.js";
-export { VERIFIABLE_REPORT_SCHEMA, VERIFIABLE_FORK_SCHEMA, assertVerifiableReportSchema, createVerifiableRuntimeAdapter, createNativeVerifiableRuntimeAdapter, VerifiableOperation, } from "./runtime/verifiable-report.js";
-export type { VerifiableCommand, CheckVerdict, VerifiableForkManifest, ForkPlan, VerifiableEvidence, VerifyOptions, ReplayOptions, VerifiableRuntimeAdapter, VerifiableReport, VerifiableOperationJson, } from "./runtime/verifiable-report.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
 export type { SubAgentRunContext } from "./runtime/sub-agent-orchestrator.js";
 export type { AgentCapabilityFilter, AgentIdentity, AgentIsolation, AgentRunSpec, AgentProcessChangedObservation, ContextInheritance, KernelAgentRole, LoopResult, MilestoneCheckResult, MilestoneContract, MilestonePhase, MilestonePolicy, SubAgentResult, TerminationReason, WorkflowSpec, WorkflowNodeSpec, SchedulingFactors, WorkflowDependencyPolicy, WorkflowNodeStatus, WorkflowNodeOutcome, WorkflowOutcome, WorkflowTaskSpec, WorkflowSpawnInfo, } from "./runtime/types/agent.js";
 export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, genEval, verifyRules } from "./runtime/types/agent.js";
-export { loopInstruction, classifyInstruction, judgeGoal, extractClassifyBranch, extractJudgeWinner, } from "./runtime/workflow-control-flow.js";
 export { Agent } from "./agent.js";
 export { McpExecutionPlane } from "./runtime/mcp-transport.js";
 export type { McpConnection, McpConnectionFactory, McpCredentialVault, McpServerConfig } from "./runtime/mcp-transport.js";
 export type { AgentMemory, AgentOptions, AgentRunResult, AgentRunOptions, AgentToolDefinition, AgentRef, Guardrail, Handoff, Knowledge, KnowledgeSourceRef, MCPServer, McpTransport, MemoryReference, ModelRef, ModelRequirement, Skill, MemoryInput, RecallOptions, DelegationResult, AgentRuntimeBinding, AgentSession, } from "./agent.js";
 export { AnthropicProvider } from "./providers/anthropic.js";
+export type { AnthropicCompaction, AnthropicContextEditing, AnthropicOnDemandCompaction, AnthropicProviderOptions, AnthropicThresholdCompaction, } from "./providers/anthropic.js";
 export { OpenAIProvider, qwen, deepseek, minimax, kimi } from "./providers/openai.js";
 export type { OpenAIProviderOptions, BackendProviderOptions } from "./providers/openai.js";
 export { ProviderError, classifyProviderError } from "./providers/provider-error.js";
@@ -35,11 +33,8 @@ export type { InMemoryMemoryStoreOptions } from "./memory/in-memory-store.js";
 export { memoryRetentionScore } from "./memory/retention.js";
 export { rankMemories } from "./memory/ranking.js";
 export type { RankableMemory, RankedMemory, RankOptions } from "./memory/ranking.js";
-export { extractSessionMemories, parseExtractedMemories } from "./memory/extraction.js";
 export type { MemoryStore, Memory, MemorySearchOptions, SessionStore, SessionData, SessionMessage, MemoryRecord, MemoryRecall, MemoryRecallLifecycle, MemoryQuery, MemoryScope, MemoryProvenance, MemoryKind, MemoryAuthor, MemoryTrustLevel, } from "./memory/index.js";
 export type { KnowledgeSource } from "./knowledge/index.js";
-export { createEvolutionRuntimeAdapter, createNativeEvolutionRuntimeAdapter, EvolutionRuntime } from "./runtime/evolution.js";
-export type { ActivationBinding, ArtifactKind, ArtifactManifest, ArtifactRef, ArtifactSet, ArtifactVersion, ContextEntryRef, ContextEntrySource, ContextExecutionInput, ContextPlan, ContextPlanAction, ContextPreparationRequest, ContextSelection, ContextState, EvaluationContextBinding, EvaluationFact, EvaluationGate, EvaluationMetric, EvaluationRun, EvolutionBundle, EvolutionProposal, EvolutionReport, EvolutionVerdict, PromotionDecision, PromotionOutcome, EvolutionStore, } from "./runtime/evolution.js";
 export { AttemptLoop, RuntimeAttemptBody, VerdictFnJudge, LlmEvalJudge, HybridJudge, continueSession, freshWithFeedback, freshWithDigest, } from "./harness/index.js";
 export type { AttemptBody, AttemptBodyContext, AttemptBodyEvent, AttemptBodyTerminal, AttemptJudge, AttemptLoopEvent, AttemptLoopOptions, AttemptOutcome, AttemptOutcomeKind, AttemptProgressEvent, AttemptRequest, CarryPolicy, JudgeContext, JudgeResult, PreparedAttempt, StopPolicy, VerdictFn, } from "./harness/index.js";
 export { ScheduledPrompt } from "./signals/index.js";
@@ -57,6 +52,9 @@ export type { PermissionDecision } from "./safety/index.js";
 export type { ModelMessage, ToolCall, ToolExecutionResult, ToolSchema, RenderedContext, ProviderRunState, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, ToolAuditFailedEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, PermissionResolvedEvent, PermissionResponse, EntropySample, EntropySampleEvent, EntropyAlertEvent, EntropyWatchOptions, LLMProvider, CacheBreakpointStrategy, ProviderWireEvidence, ProviderTransportTelemetry, } from "./types.js";
 export { DurableContentError, decodeDurableContent, decodeDurableToolResult, encodeDurableContent, encodeDurableToolResult, toolOutputBlocksToDurable, durableBlocksToToolOutput } from "./runtime/durable-content.js";
 export type { DurableContent, DurableContentBlock, DurableSource, DurableToolResult } from "./runtime/durable-content.js";
-export { createContextPreparationAdapter, createNativeContextPreparationAdapter } from "./runtime/context.js";
-export type { ContextPrepareJson, ContextVerifyJson, ContextPrepared, ContextProviderPreparationRequest } from "./runtime/context.js";
-export type { PreparedProviderRequest } from "./types.js";
+export type { NativeContextTiers, PreparedProviderRequest } from "./types.js";
+export { InMemoryMemoryCandidateSink, memoryCandidateDuplicateReason, memoryCandidateId, memoryCandidatePayloadDigest } from "./memory/candidate-sink.js";
+export { memoryFetchRecall } from "./memory/recall-projection.js";
+export type { MemoryCandidate, MemoryCandidateReceipt, MemoryCandidateSink, MemoryCandidateSource } from "./memory/candidate-sink.js";
+export { resolveMemoryRuntimePolicy } from "./memory/runtime-policy.js";
+export type { MemoryRuntimePolicy, MemoryRetrievalPolicy, MemoryWritePolicy, ResolvedMemoryRuntimePolicy } from "./memory/runtime-policy.js";

package/dist/index.js

@@ -4,11 +4,9 @@ export { DriverKernelJournal, InMemoryJournalDriver, InMemoryKernelJournal, Jour
 // ── content-parts-v1 registered encoding (F14/B5; byte-pinned by sdk-conformance) ──
 export { CANONICAL_CONTENT_PARTS_PREFIX, encodeCanonicalContentParts, decodeCanonicalContentParts, } from "./runtime/kernel-step.js";
 export { primitiveForCategory, primitiveForKind } from "./runtime/index.js";
-export { VERIFIABLE_REPORT_SCHEMA, VERIFIABLE_FORK_SCHEMA, assertVerifiableReportSchema, createVerifiableRuntimeAdapter, createNativeVerifiableRuntimeAdapter, VerifiableOperation, } from "./runtime/verifiable-report.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
 export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, genEval, verifyRules } from "./runtime/types/agent.js";
-export { loopInstruction, classifyInstruction, judgeGoal, extractClassifyBranch, extractJudgeWinner, } from "./runtime/workflow-control-flow.js";
 export { Agent } from "./agent.js";
 export { McpExecutionPlane } from "./runtime/mcp-transport.js";
 export { AnthropicProvider } from "./providers/anthropic.js";
@@ -22,8 +20,6 @@ export { DurableMemory } from "./memory/durable.js";
 export { InMemoryMemoryStore } from "./memory/in-memory-store.js";
 export { memoryRetentionScore } from "./memory/retention.js";
 export { rankMemories } from "./memory/ranking.js";
-export { extractSessionMemories, parseExtractedMemories } from "./memory/extraction.js";
-export { createEvolutionRuntimeAdapter, createNativeEvolutionRuntimeAdapter, EvolutionRuntime } from "./runtime/evolution.js";
 export { AttemptLoop, RuntimeAttemptBody, VerdictFnJudge, LlmEvalJudge, HybridJudge, continueSession, freshWithFeedback, freshWithDigest, } from "./harness/index.js";
 export { ScheduledPrompt } from "./signals/index.js";
 export { PermissionManager, PermissionMode } from "./safety/index.js";
@@ -32,4 +28,6 @@ export { FULL_FOOTPRINT_USAGE_ACCOUNTING_POLICY, providerAttemptToRecord, tryNor
 export { decodeCanonicalStopReason, normalizeProviderStopReason } from "./providers/stop-reason.js";
 export { ContentPolicyError, contentDispositionFor, requireContentDisposition } from "./providers/content-policy.js";
 export { DurableContentError, decodeDurableContent, decodeDurableToolResult, encodeDurableContent, encodeDurableToolResult, toolOutputBlocksToDurable, durableBlocksToToolOutput } from "./runtime/durable-content.js";
-export { createContextPreparationAdapter, createNativeContextPreparationAdapter } from "./runtime/context.js";
+export { InMemoryMemoryCandidateSink, memoryCandidateDuplicateReason, memoryCandidateId, memoryCandidatePayloadDigest } from "./memory/candidate-sink.js";
+export { memoryFetchRecall } from "./memory/recall-projection.js";
+export { resolveMemoryRuntimePolicy } from "./memory/runtime-policy.js";

package/dist/memory/attestation.d.ts

@@ -0,0 +1,38 @@
+import { type MemoryCandidate, type MemoryCandidateSource } from "./candidate-sink.js";
+export interface MemoryCandidateAttestation {
+    issuer: string;
+    key_id: string;
+    agent_id: string;
+    tenant_id: string;
+    namespace: string;
+    candidate_id: string;
+    source: MemoryCandidateSource;
+    payload_digest: string;
+    issued_at: number;
+    expires_at: number;
+    policy_version: string;
+    signature: string;
+}
+export type MemoryCandidateVerification = {
+    valid: true;
+    verified_at?: number;
+} | {
+    valid: false;
+    reason_code: string;
+};
+export interface MemoryCandidateSourceVerifier {
+    verify(agentId: string, candidate: MemoryCandidate): MemoryCandidateVerification | Promise<MemoryCandidateVerification>;
+}
+/** Browser-safe verifier seam. Signature verification stays host-injected in WASM. */
+export declare class HostMemoryCandidateSourceVerifier implements MemoryCandidateSourceVerifier {
+    private readonly verifyFn;
+    constructor(verifyFn: (agentId: string, candidate: MemoryCandidate) => MemoryCandidateVerification | Promise<MemoryCandidateVerification>);
+    verify(agentId: string, candidate: MemoryCandidate): MemoryCandidateVerification | Promise<MemoryCandidateVerification>;
+}
+/** The kernel's provenance rule, then the host's verifier: only the host may claim
+ *  `host_verified`, that claim must carry an attestation, and any attestation supplied is verified. */
+export declare function verifyMemoryCandidateSource(agentId: string, candidate: MemoryCandidate, verifier?: MemoryCandidateSourceVerifier): Promise<MemoryCandidateVerification>;
+export declare function admitMemoryCandidate(agentId: string, candidate: MemoryCandidate, verifier?: MemoryCandidateSourceVerifier): Promise<MemoryCandidateVerification>;
+export declare function memoryCandidateAttestationCanonicalPayload(attestation: Omit<MemoryCandidateAttestation, "signature">): Promise<string>;
+export declare function memoryCandidateAttestationDigest(attestation: MemoryCandidateAttestation): Promise<string>;
+export declare function memoryCandidateAttestationMatches(candidate: MemoryCandidate, attestation: MemoryCandidateAttestation): Promise<boolean>;

package/dist/memory/attestation.js

@@ -0,0 +1,43 @@
+import { askMemoryAuthority } from "./authority.js";
+import { memoryCandidatePayloadDigest } from "./candidate-sink.js";
+/** Browser-safe verifier seam. Signature verification stays host-injected in WASM. */
+export class HostMemoryCandidateSourceVerifier {
+    verifyFn;
+    constructor(verifyFn) {
+        this.verifyFn = verifyFn;
+    }
+    verify(agentId, candidate) { return this.verifyFn(agentId, candidate); }
+}
+/** Timestamps the kernel can read: non-negative safe integers. */
+function wireTimestamps(attestation) {
+    return [attestation.issued_at, attestation.expires_at].every(value => Number.isSafeInteger(value) && value >= 0);
+}
+/** The kernel's provenance rule, then the host's verifier: only the host may claim
+ *  `host_verified`, that claim must carry an attestation, and any attestation supplied is verified. */
+export async function verifyMemoryCandidateSource(agentId, candidate, verifier) {
+    // Asked with no verifier, the kernel admits a candidate that needs none, refuses a bad claim, and
+    // answers `attestation_verifier_unconfigured` for one whose attestation the host must judge.
+    if (candidate.attestation && !wireTimestamps(candidate.attestation)) {
+        return verifier ? verifier.verify(agentId, candidate) : { valid: false, reason_code: "attestation_verifier_unconfigured" };
+    }
+    const answer = await askMemoryAuthority({ op: "verify_source", agent_id: agentId, candidate });
+    if (answer.valid === true)
+        return { valid: true };
+    if (answer.reason_code === "attestation_verifier_unconfigured" && verifier)
+        return verifier.verify(agentId, candidate);
+    return { valid: false, reason_code: String(answer.reason_code) };
+}
+export async function admitMemoryCandidate(agentId, candidate, verifier) {
+    return verifyMemoryCandidateSource(agentId, candidate, verifier);
+}
+export async function memoryCandidateAttestationCanonicalPayload(attestation) {
+    return String((await askMemoryAuthority({ op: "attestation", attestation })).canonical_payload);
+}
+export async function memoryCandidateAttestationDigest(attestation) {
+    return String((await askMemoryAuthority({ op: "attestation", attestation })).digest);
+}
+export async function memoryCandidateAttestationMatches(candidate, attestation) {
+    return attestation.candidate_id === candidate.candidate_id &&
+        attestation.source === candidate.source &&
+        attestation.payload_digest === await memoryCandidatePayloadDigest(candidate.record);
+}

package/dist/memory/authority.d.ts

@@ -21,6 +21,8 @@ export interface MemoryPromotion {
     record_id: string;
     recall_count: number;
 }
+/** One stateless question to the kernel's memory authority. */
+export declare function askMemoryAuthority(request: Record<string, unknown>): Promise<Record<string, unknown>>;
 /** Would the kernel admit this write? Resolves to the refusal reason, or `undefined` when admitted. */
 export declare function checkMemoryWrite(policy: KernelMemoryPolicyWire | undefined, name: string, content: string): Promise<string | undefined>;
 /** Derive one recall's lifecycle from the counts the store reported it held. */

package/dist/memory/authority.js

@@ -1,8 +1,10 @@
 import { getKernel } from "../runtime/kernel.js";
-async function ask(request) {
+/** One stateless question to the kernel's memory authority. */
+export async function askMemoryAuthority(request) {
     const kernel = await getKernel();
     return JSON.parse(kernel.memoryAuthorityJson(JSON.stringify(request)));
 }
+const ask = askMemoryAuthority;
 /** Would the kernel admit this write? Resolves to the refusal reason, or `undefined` when admitted. */
 export async function checkMemoryWrite(policy, name, content) {
     const answer = await ask({

package/dist/memory/candidate-sink.d.ts

@@ -0,0 +1,66 @@
+import type { MemoryRecord } from "./index.js";
+import { type MemoryCandidateAttestation, type MemoryCandidateSourceVerifier } from "./attestation.js";
+/** Which write path produced the candidate. `child_request` is the kernel's PersistMemory effect;
+ *  `model_proposal` is the model's own `propose_memory` call. */
+export type MemoryCandidateSource = "child_request" | "model_proposal";
+export interface MemoryCandidate {
+    /** Deterministic for the write that produced it (see {@link memoryCandidateId}): a retry of the
+     *  same write carries the same id, so the sink can answer it from what it already holds. */
+    candidate_id: string;
+    source: MemoryCandidateSource;
+    record: MemoryRecord;
+    attestation?: MemoryCandidateAttestation;
+}
+export type MemoryCandidateReceipt = {
+    status: "pending";
+    candidate_id: string;
+    receipt_id: string;
+} | {
+    status: "accepted";
+    candidate_id: string;
+    receipt_id: string;
+    record_ref: string;
+    digest: string;
+} | {
+    status: "rejected";
+    candidate_id: string;
+    receipt_id: string;
+    reason_code: string;
+};
+/**
+ * The host's candidate store. Contract (spec §2.3):
+ *
+ * - The sink mints `receipt_id`; it is the stable name of its answer.
+ * - Identity is scoped by agentId; source and review metadata are part of conflict detection.
+ * - The same `candidate_id` with the same payload returns the original receipt and stores nothing
+ *   new, so a write whose acknowledgement was lost can be redelivered safely.
+ * - The same `candidate_id` with a different payload is rejected with
+ *   `reason_code = "candidate_conflict"` and does not overwrite what is held.
+ * - Throwing means no answer was obtained; the caller may redeliver the same candidate.
+ */
+export interface MemoryCandidateSink {
+    submit(agentId: string, candidate: MemoryCandidate): Promise<MemoryCandidateReceipt>;
+}
+/** A candidate id from the write's canonical identity — never random, so a retry repeats it.
+ *  The kernel mints it, so every SDK hands the same write the same id. */
+export declare function memoryCandidateId(parts: readonly string[]): Promise<string>;
+/** The kernel's digest of the part of a record a candidate is judged by. Store ids, timestamps and
+ *  recall counters are excluded: a retry of the same write may mint them afresh without changing
+ *  what is being proposed. */
+export declare function memoryCandidatePayloadDigest(record: MemoryRecord): Promise<string>;
+/** Why a sink refuses a candidate whose payload it already holds for the agent under another id:
+ *  the proposal is still in review, or already remembered. A rejected one does not count, so a
+ *  proposal the host turned down may be made again. Each write path mints its own ids, so this is
+ *  what keeps a model proposal and a child request for the same fact from both reaching review. */
+export declare function memoryCandidateDuplicateReason(held: MemoryCandidateReceipt["status"] | undefined): string | undefined;
+/** In-process sink: every candidate is held as `pending`. For tests and local development. */
+export declare class InMemoryMemoryCandidateSink implements MemoryCandidateSink {
+    private readonly sourceVerifier?;
+    private readonly held;
+    private nextReceipt;
+    constructor(sourceVerifier?: MemoryCandidateSourceVerifier | undefined);
+    submit(agentId: string, candidate: MemoryCandidate): Promise<MemoryCandidateReceipt>;
+    /** Candidates held for `agentId`, in submission order. */
+    candidates(agentId?: string): MemoryCandidate[];
+    private mintReceiptId;
+}

package/dist/memory/candidate-sink.js

@@ -0,0 +1,82 @@
+// Memory candidate hand-off (contract M2). A write path whose `memoryRuntimePolicy` value is
+// `"candidate_sink"` does not put the record in the memory store: it hands the record to the
+// host's sink as a candidate, and the sink answers whether it is pending review, accepted, or
+// rejected. Only an accepted candidate is a remembered record.
+import { askMemoryAuthority } from "./authority.js";
+import { admitMemoryCandidate } from "./attestation.js";
+/** A candidate id from the write's canonical identity — never random, so a retry repeats it.
+ *  The kernel mints it, so every SDK hands the same write the same id. */
+export async function memoryCandidateId(parts) {
+    return String((await askMemoryAuthority({ op: "candidate_id", parts })).candidate_id);
+}
+/** The kernel's digest of the part of a record a candidate is judged by. Store ids, timestamps and
+ *  recall counters are excluded: a retry of the same write may mint them afresh without changing
+ *  what is being proposed. */
+export async function memoryCandidatePayloadDigest(record) {
+    return String((await askMemoryAuthority({ op: "candidate_payload_digest", record })).payload_digest);
+}
+/** Why a sink refuses a candidate whose payload it already holds for the agent under another id:
+ *  the proposal is still in review, or already remembered. A rejected one does not count, so a
+ *  proposal the host turned down may be made again. Each write path mints its own ids, so this is
+ *  what keeps a model proposal and a child request for the same fact from both reaching review. */
+export function memoryCandidateDuplicateReason(held) {
+    if (held === "pending")
+        return "already_pending_review";
+    if (held === "accepted")
+        return "already_remembered";
+    return undefined;
+}
+/** In-process sink: every candidate is held as `pending`. For tests and local development. */
+export class InMemoryMemoryCandidateSink {
+    sourceVerifier;
+    held = new Map();
+    nextReceipt = 1;
+    constructor(sourceVerifier) {
+        this.sourceVerifier = sourceVerifier;
+    }
+    async submit(agentId, candidate) {
+        const payloadDigest = await memoryCandidatePayloadDigest(candidate.record);
+        const key = JSON.stringify([agentId, candidate.candidate_id]);
+        const existing = this.held.get(key);
+        if (existing) {
+            if (existing.payloadDigest === payloadDigest && existing.candidate.source === candidate.source)
+                return structuredClone(existing.receipt);
+            return {
+                status: "rejected",
+                candidate_id: candidate.candidate_id,
+                receipt_id: this.mintReceiptId(),
+                reason_code: "candidate_conflict",
+            };
+        }
+        const verification = await admitMemoryCandidate(agentId, candidate, this.sourceVerifier);
+        if (!verification.valid) {
+            return {
+                status: "rejected",
+                candidate_id: candidate.candidate_id,
+                receipt_id: this.mintReceiptId(),
+                reason_code: verification.reason_code,
+            };
+        }
+        const duplicate = memoryCandidateDuplicateReason([...this.held.values()]
+            .find(held => held.agentId === agentId && held.payloadDigest === payloadDigest)?.receipt.status);
+        if (duplicate) {
+            return { status: "rejected", candidate_id: candidate.candidate_id, receipt_id: this.mintReceiptId(), reason_code: duplicate };
+        }
+        const receipt = {
+            status: "pending",
+            candidate_id: candidate.candidate_id,
+            receipt_id: this.mintReceiptId(),
+        };
+        this.held.set(key, { agentId, candidate: structuredClone(candidate), payloadDigest, receipt });
+        return structuredClone(receipt);
+    }
+    /** Candidates held for `agentId`, in submission order. */
+    candidates(agentId) {
+        return [...this.held.values()]
+            .filter(held => agentId === undefined || held.agentId === agentId)
+            .map(held => structuredClone(held.candidate));
+    }
+    mintReceiptId() {
+        return `receipt:${this.nextReceipt++}`;
+    }
+}

package/dist/memory/durable.d.ts

@@ -1,10 +1,12 @@
 import type { Memory, MemoryRecord, MemoryScope, MemorySearchOptions, MemoryStore } from "./index.js";
 /** Binds host storage to the public durable Memory contract for one agent and namespace. */
 export declare class DurableMemory implements Memory {
-    private readonly store;
-    private readonly agentId;
+    readonly store: MemoryStore;
+    readonly agentId: string;
     readonly namespace: string;
     readonly scope: MemoryScope;
+    /** `store` and `agentId` are the binding a runner uses to route this memory's writes and
+     *  recalls through the kernel funnel (M4). */
     constructor(store: MemoryStore, agentId: string, scope: MemoryScope);
     search(query: string, options?: MemorySearchOptions): Promise<MemoryRecord[]>;
     get(recordId: string): Promise<MemoryRecord | null>;

package/dist/memory/durable.js

@@ -4,6 +4,8 @@ export class DurableMemory {
     agentId;
     namespace;
     scope;
+    /** `store` and `agentId` are the binding a runner uses to route this memory's writes and
+     *  recalls through the kernel funnel (M4). */
     constructor(store, agentId, scope) {
         this.store = store;
         this.agentId = agentId;

package/dist/memory/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./lifecycle.js";
 export declare class WorkingMemory {
     private store;
     set(key: string, value: unknown): void;
@@ -90,7 +91,7 @@ export interface MemoryStore {
     get(agentId: string, recordId: string): Promise<MemoryRecord | null>;
     delete(agentId: string, recordId: string): Promise<void>;
     search(agentId: string, query: MemoryQuery): Promise<MemoryRecall[]>;
-    /** Persist a completed session before the runner's one extraction pass. */
+    /** Persist a completed session's transcript. */
     saveSession(data: SessionData): Promise<void>;
     /** M3: mirror the kernel's journaled recall lifecycle into the durable store. Optional. */
     recordRecall?(agentId: string, recalls: MemoryRecallLifecycle[]): Promise<void>;
@@ -101,3 +102,10 @@ export interface SessionStore {
     loadSession(sessionId: string): Promise<SessionData | undefined>;
     saveSession(data: SessionData): Promise<void>;
 }
+export { InMemoryMemoryCandidateSink, memoryCandidateDuplicateReason, memoryCandidateId, memoryCandidatePayloadDigest } from "./candidate-sink.js";
+export { HostMemoryCandidateSourceVerifier, admitMemoryCandidate, verifyMemoryCandidateSource, memoryCandidateAttestationCanonicalPayload, memoryCandidateAttestationDigest, memoryCandidateAttestationMatches } from "./attestation.js";
+export type { MemoryCandidateAttestation, MemoryCandidateSourceVerifier, MemoryCandidateVerification } from "./attestation.js";
+export { memoryFetchRecall } from "./recall-projection.js";
+export type { MemoryCandidate, MemoryCandidateReceipt, MemoryCandidateSink, MemoryCandidateSource } from "./candidate-sink.js";
+export { resolveMemoryRuntimePolicy } from "./runtime-policy.js";
+export type { MemoryRuntimePolicy, MemoryRetrievalPolicy, MemoryWritePolicy, ResolvedMemoryRuntimePolicy } from "./runtime-policy.js";

package/dist/memory/index.js

@@ -1,3 +1,4 @@
+export * from "./lifecycle.js";
 export class WorkingMemory {
     store = new Map();
     set(key, value) { this.store.set(key, value); }
@@ -6,3 +7,7 @@ export class WorkingMemory {
     clear() { this.store.clear(); }
     has(key) { return this.store.has(key); }
 }
+export { InMemoryMemoryCandidateSink, memoryCandidateDuplicateReason, memoryCandidateId, memoryCandidatePayloadDigest } from "./candidate-sink.js";
+export { HostMemoryCandidateSourceVerifier, admitMemoryCandidate, verifyMemoryCandidateSource, memoryCandidateAttestationCanonicalPayload, memoryCandidateAttestationDigest, memoryCandidateAttestationMatches } from "./attestation.js";
+export { memoryFetchRecall } from "./recall-projection.js";
+export { resolveMemoryRuntimePolicy } from "./runtime-policy.js";

package/dist/memory/lifecycle.d.ts

@@ -0,0 +1,82 @@
+import type { MemoryRecord, MemoryScope } from "./index.js";
+export interface MemoryLease {
+    lease_id: string;
+    agent_id: string;
+    scope: MemoryScope;
+    issued_at: number;
+    expires_at: number;
+    max_writes: number;
+    writes_used: number;
+    revoked_at?: number;
+}
+export type MemoryLeaseRejection = "lease_missing" | "lease_scope_mismatch" | "lease_expired" | "lease_revoked" | "memory_write_budget_exhausted";
+export interface MemoryWriteBudget {
+    max_writes: number;
+    writes_used?: number;
+}
+export type MemoryLifecycleEventType = "lease_issued" | "lease_renewed" | "lease_write_consumed" | "lease_revoked" | "deletion_requested" | "deletion_applied" | "deletion_noop";
+export interface MemoryLifecycleEvent {
+    event_id: string;
+    sequence: number;
+    type: MemoryLifecycleEventType;
+    agent_id: string;
+    lease_id: string;
+    scope: MemoryScope;
+    operation_id?: string;
+    occurred_at: number;
+    payload: Record<string, unknown>;
+}
+export interface MemoryDeletionReceipt {
+    deletion_id: string;
+    agent_id: string;
+    scope: MemoryScope;
+    record_id: string;
+    prior_digest?: string;
+    status: "applied" | "noop";
+    event_sequence: number;
+}
+export type MemoryLifecycleWriteResult = {
+    valid: true;
+    lease: MemoryLease;
+    event_id: string;
+} | {
+    valid: false;
+    reason_code: MemoryLeaseRejection;
+};
+export interface MemoryLifecycleController {
+    issueLease(lease: MemoryLease): MemoryLease;
+    getLease(agentId: string, scope: MemoryScope): MemoryLease | undefined;
+    renewLease(agentId: string, leaseId: string, expiresAt: number, renewedAt: number): MemoryLease;
+    consumeWrite(agentId: string, scope: MemoryScope, operationId: string, nowMs: number): MemoryLifecycleWriteResult;
+    revokeLease(agentId: string, leaseId: string, revokedAt: number): MemoryLease;
+    deleteRecord(agentId: string, scope: MemoryScope, recordId: string, deletionId: string, priorDigest?: string): MemoryDeletionReceipt;
+    events(): MemoryLifecycleEvent[];
+}
+export declare function memoryRecordExpired(record: Pick<MemoryRecord, "updated_at" | "ttl_days">, nowMs: number): boolean;
+export declare function verifyMemoryLease(lease: MemoryLease | undefined, agentId: string, scope: MemoryScope, nowMs: number, budget?: MemoryWriteBudget): {
+    valid: true;
+} | {
+    valid: false;
+    reason_code: MemoryLeaseRejection;
+};
+export declare function consumeMemoryLeaseWrite(lease: MemoryLease): MemoryLease;
+export declare function revokeMemoryLease(lease: MemoryLease, revokedAt: number): MemoryLease;
+export declare function scopeMatchesMemoryDeletion(record: MemoryRecord, scope: {
+    tenant_id?: string;
+    namespace?: string;
+}): boolean;
+export declare class InMemoryMemoryLifecycleController implements MemoryLifecycleController {
+    private leases;
+    private consumed;
+    private deletedRecords;
+    private journal;
+    issueLease(lease: MemoryLease): MemoryLease;
+    getLease(agentId: string, scope: MemoryScope): MemoryLease | undefined;
+    renewLease(agentId: string, leaseId: string, expiresAt: number, renewedAt: number): MemoryLease;
+    consumeWrite(agentId: string, scope: MemoryScope, operationId: string, nowMs: number): MemoryLifecycleWriteResult;
+    revokeLease(agentId: string, leaseId: string, revokedAt: number): MemoryLease;
+    deleteRecord(agentId: string, scope: MemoryScope, recordId: string, deletionId: string, priorDigest?: string): MemoryDeletionReceipt;
+    events(): MemoryLifecycleEvent[];
+    private require;
+    private append;
+}