@deepstrike/sdk 0.2.71 → 0.2.72

package/dist/runtime/runner.js

@@ -11,6 +11,23 @@ import { buildLlmCompletedEvent, buildRunTerminalEvent, buildWorkflowNodeComplet
 import { KernelPrimitivesDashboard } from "./kernel-primitives-dashboard.js";
 import { capabilityMarker, capabilitySkill, capabilityTool, capabilityCommandMount, capabilityCommandUnmount, archivePresentationFromObservations, entropySampleFromObservation, messageToKernelMessage, skillMetadataToKernel, taskUpdateToKernel, toolResultToKernel, toolSchemaToKernel, } from "./kernel-step.js";
 import { CanonicalKernelRejectedError, CanonicalRunnerRuntime, canonicalKernelAction, canonicalKernelApply, canonicalKernelMaybeAction, canonicalStartAgent, canonicalStartWorkflow, } from "./canonical-kernel-step.js";
+function intersectCapabilityFilters(a, b) {
+    if (!a && !b)
+        return undefined;
+    const intersect = (left, right) => {
+        if (!left?.length)
+            return right?.length ? [...right] : undefined;
+        if (!right?.length)
+            return [...left];
+        return left.filter(value => right.includes(value));
+    };
+    const allowedKinds = intersect(a?.allowedKinds, b?.allowedKinds);
+    const allowedIds = intersect(a?.allowedIds, b?.allowedIds);
+    return {
+        ...(allowedKinds?.length ? { allowedKinds } : allowedKinds ? { allowedKinds: [] } : {}),
+        ...(allowedIds?.length ? { allowedIds } : allowedIds ? { allowedIds: [] } : {}),
+    };
+}
 export function stableSemanticArchiveName(effectId) {
     const stableEffectId = effectId.replace(/[^a-zA-Z0-9._:-]/g, "_");
     return `page-out-${stableEffectId || "unknown"}`;
@@ -153,6 +170,8 @@ export class RuntimeRunner {
      *  run — guards against re-pushing a duplicate entry if the model calls `skill(name)` again for
      *  an already-active skill (loading is idempotent; the knowledge push should be too). */
     knowledgePushedSkills = new Set();
+    /** Host mirror of kernel skill lease expiry, used only to clear ContextManager overlays. */
+    skillLeaseExpirations = new Map();
     nextArchiveStart = 0;
     pendingPageOutArchives = [];
     activePageOutArchive;
@@ -273,7 +292,7 @@ export class RuntimeRunner {
      * agent syscall: the host selects records from its store, then the kernel owns the write
      * of live semantic context. `seenRecordIds` is the prefetch's dedupe horizon.
      */
-    async prefetchMemoryIntoKnowledge(runtime, query, agentId, sessionId, seenRecordIds, leftovers) {
+    async prefetchMemoryIntoKnowledge(runtime, query, agentId, sessionId, seenRecordIds) {
         let hits = [];
         try {
             hits = await this.retrieveMemoryFromStore(query, query.top_k, agentId);
@@ -287,12 +306,10 @@ export class RuntimeRunner {
                 });
             }
             for (const hit of hits) {
-                await this.commitKernelApply(runtime, leftovers ?? [], {
-                    kind: "add_knowledge_message",
-                    key: `memory:${hit.record.record_id}`,
-                    content: hit.record.content,
-                    tokens: Math.max(1, Math.ceil(hit.record.content.length / 4)),
-                }, sessionId);
+                // Route renewal recalls through the same host context admission path as every other
+                // dynamic knowledge entry. This keeps ContextManager budgets and ledger events in sync
+                // while preserving the canonical kernel knowledge command underneath.
+                await this.pushKnowledge({ role: "system", content: hit.record.content, toolCalls: [] }, Math.max(1, Math.ceil(hit.record.content.length / 4)), { key: `memory:${hit.record.record_id}` });
             }
             await this.applyHostMemoryRecallLifecycle(hits, agentId);
             await this.logMemoryRetrievalResult(sessionId, hits);
@@ -598,10 +615,27 @@ export class RuntimeRunner {
     async pushKnowledge(message, tokens, opts) {
         if (!this.activeKernel)
             return;
+        const content = message.content ?? "";
+        const itemId = opts?.key ?? `context:${createHash("sha256").update(content).digest("hex").slice(0, 16)}`;
+        if (this.opts.contextManager) {
+            this.opts.contextManager.upsert({
+                id: itemId,
+                kind: opts?.key?.startsWith("skill:") ? "skill" : opts?.key?.startsWith("memory:") ? "memory" : "knowledge",
+                content,
+                scope: opts?.key?.startsWith("skill:") ? "session" : "turn",
+                priority: opts?.pinned ? 100 : 50,
+                pinned: opts?.pinned,
+                source: { type: opts?.key?.split(":", 1)[0] ?? "context", ...(opts?.key ? { id: opts.key } : {}) },
+            });
+            if (!this.opts.contextManager.select().some(item => item.id === itemId)) {
+                this.opts.contextManager.remove(itemId);
+                return;
+            }
+        }
         await this.commitKernelApply(this.activeKernel, this.pendingObservations, {
             kind: "add_knowledge_message",
-            content: message.content ?? "",
-            tokens: tokens ?? Math.max(1, Math.ceil((message.content?.length ?? 0) / 4)),
+            content,
+            tokens: tokens ?? Math.max(1, Math.ceil(content.length / 4)),
             ...(opts?.key !== undefined ? { key: opts.key } : {}),
             ...(opts?.pinned ? { pinned: true } : {}),
         });
@@ -609,6 +643,7 @@ export class RuntimeRunner {
     /** K1: mark a keyed knowledge entry for removal at the next compaction/renewal boundary.
      *  Errs-open: an unknown key is a kernel-side no-op. */
     async removeKnowledge(key) {
+        this.opts.contextManager?.remove(key);
         if (!this.activeKernel)
             return;
         await this.commitKernelApply(this.activeKernel, this.pendingObservations, { kind: "remove_knowledge", key });
@@ -618,11 +653,24 @@ export class RuntimeRunner {
      *  drops at the next compaction/renewal boundary. A later `skill(name)` call re-activates and
      *  re-pins fresh content. Errs-open: not-active is a kernel-side no-op. */
     async deactivateSkill(name) {
-        if (!this.activeKernel)
-            return;
-        await this.commitKernelApply(this.activeKernel, this.pendingObservations, { kind: "skill_deactivated", name });
+        if (this.activeKernel) {
+            await this.commitKernelApply(this.activeKernel, this.pendingObservations, { kind: "skill_deactivated", name });
+        }
         // Re-arm the SDK-side push guard so a re-activation re-pins the content.
         this.knowledgePushedSkills.delete(name);
+        this.skillLeaseExpirations.delete(name);
+        this.opts.contextManager?.remove(`skill:${name}`);
+    }
+    expireSkillContext(currentTurn) {
+        if (this.opts.skillLeaseTurns === undefined)
+            return;
+        for (const [name, expiresAtTurn] of this.skillLeaseExpirations) {
+            if (currentTurn < expiresAtTurn)
+                continue;
+            this.skillLeaseExpirations.delete(name);
+            this.knowledgePushedSkills.delete(name);
+            this.opts.contextManager?.remove(`skill:${name}`);
+        }
     }
     /**
      * G3: run one workflow node, enforcing its `output_schema` (if any). Without a schema this is a
@@ -632,7 +680,7 @@ export class RuntimeRunner {
      * validation reason — a node that cannot meet its declared output contract starves its dependents,
      * exactly as a denied spawn does.
      */
-    async runWorkflowNode(node, parentSessionId, orchestrator, budget, outputs, abortSignal) {
+    async runWorkflowNode(node, parentSessionId, orchestrator, budget, outputs, abortSignal, contextPolicies) {
         // G2: a reduce node runs no LLM — execute the registered pure function over its dependency
         // outputs and feed the result back as an ordinary completion. Deterministic; no agent burned.
         if (node.reducer) {
@@ -645,7 +693,11 @@ export class RuntimeRunner {
         const budgetNote = workflowBudgetNote(budget);
         // W-N2: a DAG edge carries data — every dependent node sees its dependencies' outputs (the
         // kernel sends `input_agent_ids` for all dependents; judges/reduce keep their special paths).
-        const depsNote = dependencyOutputsNote(node.input_agent_ids, outputs);
+        const policy = contextPolicies?.get(node.agent_id) ?? contextPolicies?.get(node.agent_id.replace(/-i\d+$/, ""));
+        const include = policy?.include ?? ["dependency_outputs"];
+        const depsNote = include.includes("dependency_outputs")
+            ? dependencyOutputsNote(node.input_agent_ids, outputs, policy?.maxTokens !== undefined ? Math.max(256, policy.maxTokens * 4) : 8_000, policy?.dependencyMode ?? "full")
+            : "";
         const withBudget = (goal) => [goal, depsNote, budgetNote].filter(Boolean).join("\n\n");
         const mkCtx = (goal) => ({
             parentOpts: this.opts,
@@ -806,7 +858,7 @@ export class RuntimeRunner {
                 };
             }
             const observations = this.pendingObservations.slice(observationStart);
-            const outcome = await this.driveWorkflow(initialAction, observations, parentSessionId, runtime, new Map());
+            const outcome = await this.driveWorkflow(initialAction, observations, parentSessionId, runtime, new Map(), new Map(spec.nodes.flatMap((node, index) => node.context ? [[`wf-node${index}`, node.context]] : [])));
             if (bootstrapped) {
                 let terminal = runtime.resumeAction();
                 if (!terminal)
@@ -861,6 +913,8 @@ export class RuntimeRunner {
         this.pendingObservations = [];
         this.pendingPageOutArchives = [];
         this.activePageOutArchive = undefined;
+        this.knowledgePushedSkills.clear();
+        this.skillLeaseExpirations.clear();
         this.currentSessionId = sessionId;
         const runtime = this.createCanonicalRuntime(runId, sessionId);
         this.activeKernel = runtime;
@@ -965,7 +1019,7 @@ export class RuntimeRunner {
      * Drive a canonical root or provider-authored workflow from kernel effects only: run each
      * emitted batch, resolve its launch/completion/preemption effects, and stop at the kernel terminal.
      */
-    async driveWorkflow(initialAction, initial, parentSessionId, runtime, seedOutputs) {
+    async driveWorkflow(initialAction, initial, parentSessionId, runtime, seedOutputs, contextPolicies) {
         let observations = initial;
         const orchestrator = this.opts.subAgentOrchestrator ?? defaultSubAgentOrchestrator;
         const findDone = (obs) => obs.find(o => o.kind === "workflow_completed");
@@ -1027,7 +1081,7 @@ export class RuntimeRunner {
             const controllers = new Map(nodes.map(n => [n.agent_id, new AbortController()]));
             const batchState = { settled: false };
             const monitor = this.monitorWorkflowPreemption(runtime, controllers, batchState);
-            const results = await Promise.all(nodes.map(node => this.runWorkflowNode(node, parentSessionId, orchestrator, roundBudget, outputs, controllers.get(node.agent_id)?.signal)));
+            const results = await Promise.all(nodes.map(node => this.runWorkflowNode(node, parentSessionId, orchestrator, roundBudget, outputs, controllers.get(node.agent_id)?.signal, contextPolicies)));
             batchState.settled = true;
             const preempted = await monitor;
             if (preempted !== null) {
@@ -1352,6 +1406,8 @@ export class RuntimeRunner {
         this.pendingObservations = [];
         this.pendingPageOutArchives = [];
         this.activePageOutArchive = undefined;
+        this.knowledgePushedSkills.clear();
+        this.skillLeaseExpirations.clear();
         this.currentSessionId = sessionId;
         this.activeProviderInvocationId = undefined;
         this.providerRetryPending = false;
@@ -1413,17 +1469,23 @@ export class RuntimeRunner {
                     });
                 }
                 if (this.opts.initialMemory) {
-                    for (const mem of this.opts.initialMemory) {
-                        await this.commitKernelApply(runtime, this.pendingObservations, {
-                            kind: "add_knowledge_message",
-                            content: mem,
-                            tokens: Math.max(1, Math.ceil(mem.length / 4)),
-                        });
+                    for (const [index, mem] of this.opts.initialMemory.entries()) {
+                        await this.pushKnowledge({ role: "system", content: mem, toolCalls: [] }, undefined, { key: `initial:${index}`, pinned: true });
                     }
                 }
-                if (this.opts.skillDir) {
+                if (this.opts.skillDir || this.opts.skillCatalog?.length) {
                     const { scanSkillDir } = await import("../skills/loader.js");
-                    const metas = await scanSkillDir(this.opts.skillDir);
+                    const metas = [
+                        ...(this.opts.skillDir ? await scanSkillDir(this.opts.skillDir) : []),
+                        ...(this.opts.skillCatalog ?? []).map(skill => ({
+                            name: skill.name,
+                            description: skill.description ?? "",
+                            ...(skill.metadata?.whenToUse ? { whenToUse: String(skill.metadata.whenToUse) } : {}),
+                            ...(skill.metadata?.effort !== undefined ? { effort: Number(skill.metadata.effort) } : {}),
+                            ...(skill.metadata?.estimatedTokens !== undefined ? { estimatedTokens: Number(skill.metadata.estimatedTokens) } : {}),
+                            ...(skill.tools?.length ? { allowedTools: skill.tools.map(tool => typeof tool === "string" ? tool : tool.name) } : {}),
+                        })),
+                    ];
                     // S2 host-layer skill allowlist: keep only scanned skills named in `skillFilter` before feeding
                     // the catalog. Absent ⇒ feed all (identical to the pre-feature message); empty ⇒ feed none. The
                     // `set_available_skills` message is ALWAYS sent when a skillDir exists (shape preserved) — only
@@ -1505,9 +1567,16 @@ export class RuntimeRunner {
                     role: "custom",
                     goal,
                 };
-                let spec = hasProfile
-                    ? { ...baseSpec, capabilityFilter: { ...baseSpec.capabilityFilter, allowedIds: allowedToolIds } }
+                const filtered = intersectCapabilityFilters(baseSpec.capabilityFilter, this.opts.capabilityFilter);
+                let spec = filtered
+                    ? { ...baseSpec, capabilityFilter: filtered }
                     : baseSpec;
+                if (hasProfile) {
+                    spec = {
+                        ...spec,
+                        capabilityFilter: intersectCapabilityFilters(spec.capabilityFilter, { allowedIds: allowedToolIds }),
+                    };
+                }
                 spec = { ...spec, exposureBaseline: baselineToolIds };
                 if (hasMilestoneContract && !spec.verificationContractId) {
                     spec = { ...spec, verificationContractId: "node-default" };
@@ -1569,6 +1638,7 @@ export class RuntimeRunner {
                 while (!runtime.isTerminal()) {
                     nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart, taskScope);
                     this.nextArchiveStart = nextCompressedArchiveStart;
+                    this.expireSkillContext(runtime.turn());
                     if (this.interrupted) {
                         action = await this.commitKernelAction(runtime, this.pendingObservations, {
                             kind: "cancel_operation",
@@ -1921,7 +1991,7 @@ export class RuntimeRunner {
                             ...(turnOutputTokens > 0 ? { observed_output_tokens: settlement?.observed_output_tokens ?? turnOutputTokens } : {}),
                             ...(turnStopReason ? { stop_reason: turnStopReason } : {}),
                         };
-                        if (this.opts.skillDir) {
+                        if (this.opts.skillDir || this.opts.skillCatalog?.length) {
                             const skillCalls = finalToolCalls.filter(call => call.name === "skill");
                             if (skillCalls.length > 0) {
                                 const { readSkillFile } = await import("../skills/loader.js");
@@ -1932,16 +2002,16 @@ export class RuntimeRunner {
                                             continue;
                                         if (this.opts.skillFilter && !this.opts.skillFilter.includes(name))
                                             continue;
-                                        const content = await readSkillFile(this.opts.skillDir, name);
+                                        const inline = this.opts.skillCatalog?.find(skill => skill.name === name);
+                                        const content = inline?.instructions
+                                            ?? (this.opts.skillDir ? await readSkillFile(this.opts.skillDir, name) : null);
                                         if (!content)
                                             continue;
-                                        await this.commitKernelApply(runtime, this.pendingObservations, {
-                                            kind: "add_knowledge_message",
-                                            key: `skill:${name}`,
-                                            content,
-                                            tokens: Math.max(1, Math.ceil(content.length / 4)),
-                                            pinned: true,
-                                        });
+                                        const knowledge = inline?.knowledge
+                                            ?.map(entry => typeof entry === "string" ? entry : entry.content)
+                                            .filter((entry) => Boolean(entry)) ?? [];
+                                        const fullContent = [content, ...knowledge].join("\n\n");
+                                        await this.pushKnowledge({ role: "system", content: fullContent, toolCalls: [] }, Math.max(1, Math.ceil(fullContent.length / 4)), { key: `skill:${name}`, pinned: true });
                                     }
                                     catch {
                                         // A missing or malformed skill stays a model-visible syscall rejection.
@@ -2372,6 +2442,9 @@ export class RuntimeRunner {
                                 if (this.opts.skillLeaseTurns !== undefined || !this.knowledgePushedSkills.has(name)) {
                                     this.knowledgePushedSkills.add(name);
                                     await this.pushKnowledge({ role: "system", content: res.output, toolCalls: [] }, undefined, { key: `skill:${name}` });
+                                    if (this.opts.skillLeaseTurns !== undefined) {
+                                        this.skillLeaseExpirations.set(name, runtime.turn() + this.opts.skillLeaseTurns);
+                                    }
                                 }
                             }
                             catch { /* malformed skill args — skip the knowledge pin */ }
@@ -2614,7 +2687,7 @@ export class RuntimeRunner {
             for (const q of queries ?? []) {
                 if (!q.query.trim())
                     continue;
-                const { action } = await this.prefetchMemoryIntoKnowledge(runtime, q, this.opts.agentId, this.durableSessionId(this.currentSessionId), seenRecordIds, this.pendingObservations);
+                const { action } = await this.prefetchMemoryIntoKnowledge(runtime, q, this.opts.agentId, this.durableSessionId(this.currentSessionId), seenRecordIds);
                 resumed = action ?? resumed;
             }
             // Every seed command leaves the pending provider action authoritative; use the last view.

package/dist/runtime/session-log.d.ts

@@ -279,7 +279,7 @@ export type SessionEvent = {
     classify_branch?: string;
     tournament_winner?: string;
     loop_continue?: boolean;
-    output?: import("../types.js").ProviderMessage;
+    output?: import("../types.js").ModelMessage;
 } | {
     kind: "workflow_nodes_submitted";
     turn: number;

package/dist/runtime/session-repair.d.ts

@@ -1,4 +1,4 @@
-import type { ProviderMessage, ProviderWireEvidence, ToolCall } from "../types.js";
+import type { ModelMessage, ProviderWireEvidence, ToolCall } from "../types.js";
 import type { SessionEvent } from "./session-log.js";
 import type { WorkflowNodeStatus } from "../types/agent.js";
 export { REPLAY_CONTENT_MAX_BYTES as RECOVERY_CONTENT_MAX_BYTES } from "./replay-sanitize.js";
@@ -57,7 +57,7 @@ export declare function buildWorkflowNodeCompletedEvent(input: {
     classifyBranch?: string;
     tournamentWinner?: string;
     loopContinue?: boolean;
-    output?: ProviderMessage;
+    output?: ModelMessage;
 }): Extract<SessionEvent, {
     kind: "workflow_node_completed";
 }>;

package/dist/runtime/workflow-control-flow.d.ts

@@ -7,7 +7,7 @@ export declare function loopInstruction(maxIters: number, iteration?: number): s
  *  just ordering (fan-out→synthesize was an uninformed synthesis without this). Each dependency's
  *  output is clipped so a chain of large nodes can't blow the child's context; empty/unknown
  *  outputs are skipped. Returns "" when the node has no dependencies. */
-export declare function dependencyOutputsNote(inputAgentIds: string[] | undefined, outputs: Map<string, string> | undefined, maxPerDep?: number): string;
+export declare function dependencyOutputsNote(inputAgentIds: string[] | undefined, outputs: Map<string, string> | undefined, maxPerDep?: number, mode?: "full" | "summary" | "reference"): string;
 /** Instruction appended to a classify node's goal: pick exactly one of the kernel's branch labels. */
 export declare function classifyInstruction(labels: string[]): string;
 /** Build a tournament judge's goal: the controller's criterion + the two candidates to compare. */

package/dist/runtime/workflow-control-flow.js

@@ -20,20 +20,34 @@ export function loopInstruction(maxIters, iteration = 0) {
  *  just ordering (fan-out→synthesize was an uninformed synthesis without this). Each dependency's
  *  output is clipped so a chain of large nodes can't blow the child's context; empty/unknown
  *  outputs are skipped. Returns "" when the node has no dependencies. */
-export function dependencyOutputsNote(inputAgentIds, outputs, maxPerDep = 8_000) {
+export function dependencyOutputsNote(inputAgentIds, outputs, maxPerDep = 8_000, mode = "full") {
     if (!inputAgentIds?.length || !outputs)
         return "";
+    if (mode === "reference") {
+        return inputAgentIds.some(id => outputs.has(id))
+            ? `[dependency references]\n${inputAgentIds.filter(id => outputs.has(id)).join(", ")}`
+            : "";
+    }
     const blocks = inputAgentIds
         .map(id => {
         const out = outputs.get(id) ?? "";
         if (!out)
             return "";
-        const clipped = out.length > maxPerDep ? `${out.slice(0, maxPerDep)}\n…[truncated]` : out;
+        const clipped = mode === "summary"
+            ? summarizeDependency(out, maxPerDep)
+            : out.length > maxPerDep ? `${out.slice(0, maxPerDep)}\n…[truncated]` : out;
         return `[dependency ${id} output]\n${clipped}`;
     })
         .filter(Boolean);
     return blocks.join("\n\n");
 }
+function summarizeDependency(value, maxChars) {
+    if (value.length <= maxChars)
+        return value;
+    const head = Math.max(1, Math.floor(maxChars * 0.7));
+    const tail = Math.max(1, maxChars - head);
+    return `${value.slice(0, head)}\n…[summary truncated]…\n${value.slice(-tail)}`;
+}
 /** Instruction appended to a classify node's goal: pick exactly one of the kernel's branch labels. */
 export function classifyInstruction(labels) {
     return (`Classify the input and choose EXACTLY ONE label from: ${labels.map(l => JSON.stringify(l)).join(", ")}. ` +

package/dist/runtime-classification.d.ts

@@ -0,0 +1,161 @@
+/** SPC-028-02: cross-layer object classification registry. */
+export type RuntimeDomain = "public" | "host" | "kernel" | "provider";
+export type RuntimeAuthority = "public-agent" | "host-runtime" | "kernel" | "none";
+export type RuntimeRepresentation = "semantic" | "projection" | "measurement" | "evidence" | "wire" | "state-truth" | "snapshot";
+export type RuntimeDurability = "durable" | "ephemeral" | "rebuildable" | "append-only";
+export interface RuntimeObjectClassification {
+    domain: RuntimeDomain;
+    authority: RuntimeAuthority;
+    representation: RuntimeRepresentation;
+    durability: RuntimeDurability;
+    identity: string;
+    causation: string;
+    replay: string;
+}
+export declare const RUNTIME_OBJECT_CLASSIFICATIONS: {
+    readonly AgentDefinition: {
+        readonly domain: "public";
+        readonly authority: "public-agent";
+        readonly representation: "semantic";
+        readonly durability: "rebuildable";
+        readonly identity: "agent name or host-assigned agent identity";
+        readonly causation: "agent declaration";
+        readonly replay: "input to AgentSpec projection";
+    };
+    readonly AgentSpec: {
+        readonly domain: "host";
+        readonly authority: "host-runtime";
+        readonly representation: "semantic";
+        readonly durability: "rebuildable";
+        readonly identity: "agent identity";
+        readonly causation: "AgentDefinition plus host bindings";
+        readonly replay: "re-derived from public definition and runtime bindings";
+    };
+    readonly StoredMessageState: {
+        readonly domain: "host";
+        readonly authority: "host-runtime";
+        readonly representation: "state-truth";
+        readonly durability: "durable";
+        readonly identity: "message identity";
+        readonly causation: "accepted session or run input";
+        readonly replay: "replayed from durable message history";
+    };
+    readonly ModelMessage: {
+        readonly domain: "host";
+        readonly authority: "host-runtime";
+        readonly representation: "semantic";
+        readonly durability: "rebuildable";
+        readonly identity: "message identity";
+        readonly causation: "stored or runtime message projection";
+        readonly replay: "re-rendered from message state";
+    };
+    readonly ProviderRequestPlan: {
+        readonly domain: "host";
+        readonly authority: "none";
+        readonly representation: "projection";
+        readonly durability: "rebuildable";
+        readonly identity: "request fingerprint";
+        readonly causation: "ContextCandidate plus ResolvedProviderRoute";
+        readonly replay: "re-rendered and re-encoded from inputs";
+    };
+    readonly PromptMeasurement: {
+        readonly domain: "host";
+        readonly authority: "host-runtime";
+        readonly representation: "measurement";
+        readonly durability: "durable";
+        readonly identity: "request fingerprint";
+        readonly causation: "prepared provider request";
+        readonly replay: "reused only on exact fingerprint match";
+    };
+    readonly ProviderUsage: {
+        readonly domain: "provider";
+        readonly authority: "host-runtime";
+        readonly representation: "measurement";
+        readonly durability: "durable";
+        readonly identity: "provider attempt identity";
+        readonly causation: "decoded provider response";
+        readonly replay: "retained as response evidence";
+    };
+    readonly ResolvedProviderRoute: {
+        readonly domain: "provider";
+        readonly authority: "host-runtime";
+        readonly representation: "projection";
+        readonly durability: "durable";
+        readonly identity: "route identity";
+        readonly causation: "model resolution";
+        readonly replay: "frozen on ProviderAttempt";
+    };
+    readonly ProviderAttempt: {
+        readonly domain: "host";
+        readonly authority: "host-runtime";
+        readonly representation: "evidence";
+        readonly durability: "append-only";
+        readonly identity: "effect identity plus attempt sequence";
+        readonly causation: "CallProvider effect";
+        readonly replay: "evidence for one physical execution";
+    };
+    readonly KernelInput: {
+        readonly domain: "kernel";
+        readonly authority: "kernel";
+        readonly representation: "wire";
+        readonly durability: "append-only";
+        readonly identity: "input identity";
+        readonly causation: "host submission";
+        readonly replay: "durable input sequence";
+    };
+    readonly KernelEffect: {
+        readonly domain: "kernel";
+        readonly authority: "kernel";
+        readonly representation: "wire";
+        readonly durability: "append-only";
+        readonly identity: "effect identity";
+        readonly causation: "kernel decision";
+        readonly replay: "journal decision chain";
+    };
+    readonly BudgetLedger: {
+        readonly domain: "kernel";
+        readonly authority: "kernel";
+        readonly representation: "state-truth";
+        readonly durability: "durable";
+        readonly identity: "operation or group budget identity";
+        readonly causation: "accepted kernel facts";
+        readonly replay: "folded from journal facts";
+    };
+    readonly Journal: {
+        readonly domain: "kernel";
+        readonly authority: "kernel";
+        readonly representation: "state-truth";
+        readonly durability: "append-only";
+        readonly identity: "journal sequence and digest";
+        readonly causation: "kernel inputs and facts";
+        readonly replay: "source of durable state truth";
+    };
+    readonly Checkpoint: {
+        readonly domain: "kernel";
+        readonly authority: "kernel";
+        readonly representation: "snapshot";
+        readonly durability: "durable";
+        readonly identity: "checkpoint identity and journal head";
+        readonly causation: "checkpoint boundary";
+        readonly replay: "restore seed verified against journal";
+    };
+    readonly SessionLog: {
+        readonly domain: "host";
+        readonly authority: "none";
+        readonly representation: "evidence";
+        readonly durability: "append-only";
+        readonly identity: "session identity and event sequence";
+        readonly causation: "host observations";
+        readonly replay: "evidence only; never recovery authority";
+    };
+    readonly EvaluationRun: {
+        readonly domain: "host";
+        readonly authority: "host-runtime";
+        readonly representation: "semantic";
+        readonly durability: "durable";
+        readonly identity: "evaluation run identity";
+        readonly causation: "public Eval request";
+        readonly replay: "replayed from dataset and captured evidence";
+    };
+};
+export type RuntimeObjectName = keyof typeof RUNTIME_OBJECT_CLASSIFICATIONS;

package/dist/runtime-classification.js

@@ -0,0 +1,66 @@
+export const RUNTIME_OBJECT_CLASSIFICATIONS = {
+    AgentDefinition: {
+        domain: "public", authority: "public-agent", representation: "semantic", durability: "rebuildable",
+        identity: "agent name or host-assigned agent identity", causation: "agent declaration", replay: "input to AgentSpec projection",
+    },
+    AgentSpec: {
+        domain: "host", authority: "host-runtime", representation: "semantic", durability: "rebuildable",
+        identity: "agent identity", causation: "AgentDefinition plus host bindings", replay: "re-derived from public definition and runtime bindings",
+    },
+    StoredMessageState: {
+        domain: "host", authority: "host-runtime", representation: "state-truth", durability: "durable",
+        identity: "message identity", causation: "accepted session or run input", replay: "replayed from durable message history",
+    },
+    ModelMessage: {
+        domain: "host", authority: "host-runtime", representation: "semantic", durability: "rebuildable",
+        identity: "message identity", causation: "stored or runtime message projection", replay: "re-rendered from message state",
+    },
+    ProviderRequestPlan: {
+        domain: "host", authority: "none", representation: "projection", durability: "rebuildable",
+        identity: "request fingerprint", causation: "ContextCandidate plus ResolvedProviderRoute", replay: "re-rendered and re-encoded from inputs",
+    },
+    PromptMeasurement: {
+        domain: "host", authority: "host-runtime", representation: "measurement", durability: "durable",
+        identity: "request fingerprint", causation: "prepared provider request", replay: "reused only on exact fingerprint match",
+    },
+    ProviderUsage: {
+        domain: "provider", authority: "host-runtime", representation: "measurement", durability: "durable",
+        identity: "provider attempt identity", causation: "decoded provider response", replay: "retained as response evidence",
+    },
+    ResolvedProviderRoute: {
+        domain: "provider", authority: "host-runtime", representation: "projection", durability: "durable",
+        identity: "route identity", causation: "model resolution", replay: "frozen on ProviderAttempt",
+    },
+    ProviderAttempt: {
+        domain: "host", authority: "host-runtime", representation: "evidence", durability: "append-only",
+        identity: "effect identity plus attempt sequence", causation: "CallProvider effect", replay: "evidence for one physical execution",
+    },
+    KernelInput: {
+        domain: "kernel", authority: "kernel", representation: "wire", durability: "append-only",
+        identity: "input identity", causation: "host submission", replay: "durable input sequence",
+    },
+    KernelEffect: {
+        domain: "kernel", authority: "kernel", representation: "wire", durability: "append-only",
+        identity: "effect identity", causation: "kernel decision", replay: "journal decision chain",
+    },
+    BudgetLedger: {
+        domain: "kernel", authority: "kernel", representation: "state-truth", durability: "durable",
+        identity: "operation or group budget identity", causation: "accepted kernel facts", replay: "folded from journal facts",
+    },
+    Journal: {
+        domain: "kernel", authority: "kernel", representation: "state-truth", durability: "append-only",
+        identity: "journal sequence and digest", causation: "kernel inputs and facts", replay: "source of durable state truth",
+    },
+    Checkpoint: {
+        domain: "kernel", authority: "kernel", representation: "snapshot", durability: "durable",
+        identity: "checkpoint identity and journal head", causation: "checkpoint boundary", replay: "restore seed verified against journal",
+    },
+    SessionLog: {
+        domain: "host", authority: "none", representation: "evidence", durability: "append-only",
+        identity: "session identity and event sequence", causation: "host observations", replay: "evidence only; never recovery authority",
+    },
+    EvaluationRun: {
+        domain: "host", authority: "host-runtime", representation: "semantic", durability: "durable",
+        identity: "evaluation run identity", causation: "public Eval request", replay: "replayed from dataset and captured evidence",
+    },
+};

package/dist/runtime-language.d.ts

@@ -0,0 +1,32 @@
+/**
+ * SPC-028-01: the normative vocabulary for the four runtime language layers.
+ *
+ * Terms are names, not a second semantic authority. The registry is consumed by
+ * conformance tests and documentation tooling so each term has one primary layer.
+ */
+export declare const RUNTIME_VOCABULARY: {
+    readonly version: "0.2.72";
+    readonly public: readonly ["Agent", "Model", "Run", "Session", "Tool", "Skill", "Memory", "Knowledge", "MCPServer", "Handoff", "Workflow", "Guardrail", "Eval", "Dataset", "Evaluator", "Output", "Usage"];
+    readonly host: readonly ["AgentSpec", "Context", "ContextPlan", "Capability", "ModelRoute", "Invocation", "ProviderAttempt", "Measurement", "Evidence", "Artifact", "Evaluation", "Promotion", "ExecutionPlane"];
+    readonly kernel: readonly ["Operation", "Intent", "Decision", "Effect", "Fact", "Settlement", "Task", "Capability", "Budget", "Journal", "Checkpoint", "StateTransition"];
+    readonly provider: readonly ["Model", "Provider", "Endpoint", "Protocol", "Route", "Adapter", "Request", "Response", "Usage", "ReplayEvidence"];
+    readonly primaryDomain: {
+        readonly Model: "public";
+        readonly Usage: "public";
+        readonly Capability: "host";
+        readonly Route: "host";
+    };
+    readonly verbs: {
+        readonly resolve: "select or answer a runtime object at a boundary";
+        readonly render: "project semantic state into model-facing input";
+        readonly encode: "map semantic input into a wire request";
+        readonly execute: "perform one physical provider or external call";
+        readonly decode: "extract semantic output and retained wire evidence";
+        readonly normalize: "map vendor data into the controlled runtime vocabulary";
+        readonly settle: "apply accounting policy to an observed measurement";
+    };
+};
+export type RuntimeLanguage = typeof RUNTIME_VOCABULARY;
+export type RuntimeLanguageDomain = "public" | "host" | "kernel" | "provider";
+/** Returns all layer terms while preserving the registry's primary-domain order. */
+export declare function runtimeVocabularyTerms(): readonly string[];