@deepstrike/sdk 0.2.70 → 0.2.72

package/dist/runtime/replay-provider.d.ts

@@ -17,14 +17,14 @@
  *     from the original run). That's the point of replay-for-benchmarking: prompt may differ across
  *     variants, response is pinned, so a cost Δ purely reflects the prompt change.
  *   - `outputTokens` is estimated from `message.content.length / 4`; provider usage belongs to
- *     the session measurement plane, never to the public ProviderMessage mirror.
+ *     the session measurement plane, never to the public ModelMessage mirror.
  *   - `cacheReadInputTokens` / `cacheCreationInputTokens` are emitted as 0 — replay has no real
  *     cache state. Mechanisms whose Δ depends on cache behavior must validate with a live A/B too.
  *
  * Tokenizer: by default a `chars/4` estimator (±20% for English; worse for code/JSON). For tighter
  * numbers plug `opts.tokenizer = tiktokenEncoder` or similar.
  */
-import type { LLMProvider, ProviderMessage, ProviderDescriptor, ProviderRunState, RenderedContext, StreamEvent, ToolSchema } from "../types.js";
+import type { LLMProvider, ModelMessage, ProviderDescriptor, ProviderRunState, RenderedContext, StreamEvent, ToolSchema } from "../types.js";
 export interface ReplayProviderOpts {
     /**
      * Maps a rendered-context text payload to a token count. Defaults to `chars / 4`.
@@ -54,7 +54,7 @@ export declare class ReplayProvider implements LLMProvider {
      * @param messages Ordered list of assistant messages to replay (one per LLM call).
      * @param opts Optional tokenizer / descriptor / wrap-around behavior.
      */
-    constructor(messages: ReadonlyArray<ProviderMessage>, opts?: ReplayProviderOpts);
+    constructor(messages: ReadonlyArray<ModelMessage>, opts?: ReplayProviderOpts);
     descriptor(): ProviderDescriptor;
     /** Number of messages consumed so far. */
     consumed(): number;
@@ -62,7 +62,7 @@ export declare class ReplayProvider implements LLMProvider {
     remaining(): number;
     /** Reset the cursor — useful for re-running the same fixture in a fresh session. */
     reset(): void;
-    complete(_context: RenderedContext, _tools: ToolSchema[]): Promise<ProviderMessage>;
+    complete(_context: RenderedContext, _tools: ToolSchema[]): Promise<ModelMessage>;
     stream(context: RenderedContext, tools: ToolSchema[], _extensions?: Record<string, unknown>, _state?: ProviderRunState, _signal?: AbortSignal): AsyncIterable<StreamEvent>;
     private pull;
     private estimateInputTokens;

package/dist/runtime/replay-provider.js

@@ -17,7 +17,7 @@
  *     from the original run). That's the point of replay-for-benchmarking: prompt may differ across
  *     variants, response is pinned, so a cost Δ purely reflects the prompt change.
  *   - `outputTokens` is estimated from `message.content.length / 4`; provider usage belongs to
- *     the session measurement plane, never to the public ProviderMessage mirror.
+ *     the session measurement plane, never to the public ModelMessage mirror.
  *   - `cacheReadInputTokens` / `cacheCreationInputTokens` are emitted as 0 — replay has no real
  *     cache state. Mechanisms whose Δ depends on cache behavior must validate with a live A/B too.
  *

package/dist/runtime/runner.d.ts

@@ -1,6 +1,8 @@
-import type { LLMProvider, ProviderMessage, ContentPart, ToolSchema, StreamEvent, ToolSuspendEvent, PermissionRequestEvent, PermissionResponse, AsyncSummarizer, MemorySummarizer, EntropySample, EntropyWatchOptions } from "../types.js";
+import type { LLMProvider, ModelMessage, ContentPart, ToolSchema, StreamEvent, ToolSuspendEvent, PermissionRequestEvent, PermissionResponse, AsyncSummarizer, MemorySummarizer, EntropySample, EntropyWatchOptions } from "../types.js";
 import type { MemoryStore, MemoryRecord, MemoryRecall, MemoryScope, MemoryQuery } from "../memory/protocols.js";
 import type { KnowledgeSource } from "../knowledge/source.js";
+import type { Skill } from "../skill.js";
+import type { ContextManager } from "./context-manager.js";
 import type { RuntimeSignalUrgency, SignalSource } from "../signals/types.js";
 import type { SessionLog, SessionEvent } from "./session-log.js";
 import type { KernelJournal } from "./kernel-journal.js";
@@ -9,6 +11,7 @@ import type { ExecutionPlane } from "./execution-plane.js";
 import type { RunGroup } from "./run-group.js";
 import { type MemoryPolicy, type ResourceQuota } from "../kernel.js";
 import type { AgentRunSpec, MilestoneCheckResult, MilestoneContract, MilestonePolicy, WorkflowSpec, WorkflowOutcome } from "../types/agent.js";
+import type { AgentCapabilityFilter } from "../types/agent.js";
 export declare function stableSemanticArchiveName(effectId: string): string;
 import { type SubAgentOrchestrator } from "./sub-agent-orchestrator.js";
 import { type ReducerRegistry } from "./reducers.js";
@@ -95,6 +98,8 @@ export interface KernelReliabilityOptions {
 export type OperationCancellationReason = "user" | "deadline" | "lease_lost" | "host_shutdown";
 export interface RuntimeOptions {
     provider: LLMProvider;
+    /** Host-owned capability ceiling applied to the root run before skills or run profiles narrow it further. */
+    capabilityFilter?: AgentCapabilityFilter;
     /** Host-owned artifact set identity captured in operation genesis. */
     artifactSetDigest?: string;
     /** M4/G5: cumulative token cap for this run (the kernel's `max_total_tokens`). A workflow node's
@@ -150,7 +155,11 @@ export interface RuntimeOptions {
      *  behavior difference. */
     nudges?: NudgeRule[];
     initialMemory?: string[];
+    /** Optional host ledger that admits dynamic context before kernel insertion. */
+    contextManager?: ContextManager;
     skillDir?: string;
+    /** Inline skill catalog. Metadata is exposed at run start; content is loaded only on activation. */
+    skillCatalog?: Skill[];
     /** Host-layer allowlist over the `skillDir` catalog by skill NAME. When set, only scanned skills
      *  whose name is listed are fed to the kernel via `set_available_skills` (the manifest layer
      *  intersects onto this host baseline in `applyManifest`). Absent ⇒ zero behavior difference (all
@@ -398,6 +407,8 @@ export declare 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). */
     private knowledgePushedSkills;
+    /** Host mirror of kernel skill lease expiry, used only to clear ContextManager overlays. */
+    private skillLeaseExpirations;
     private nextArchiveStart;
     private pendingPageOutArchives;
     private activePageOutArchive;
@@ -488,7 +499,7 @@ export declare class RuntimeRunner {
      *  K1: `opts.key` gives the entry identity — a same-key push upserts (applied at the next
      *  compaction/renewal boundary, where the cached system[1] block is rewritten anyway) instead
      *  of appending a duplicate. `opts.pinned` exempts the entry from the knowledge-budget sweep. */
-    pushKnowledge(message: ProviderMessage, tokens?: number, opts?: {
+    pushKnowledge(message: ModelMessage, tokens?: number, opts?: {
         key?: string;
         pinned?: boolean;
     }): Promise<void>;
@@ -500,6 +511,7 @@ export declare 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. */
     deactivateSkill(name: string): Promise<void>;
+    private expireSkillContext;
     /**
      * G3: run one workflow node, enforcing its `output_schema` (if any). Without a schema this is a
      * plain `orchestrator.run`. With one, the node's agent is instructed to emit conforming JSON, its
@@ -603,14 +615,14 @@ export declare class RuntimeRunner {
  *  message exists. A tail assistant tool_call with nothing after it is a genuinely PENDING tool the
  *  run stopped in front of (the wake/recovery case), which must stay unpaired so wake executes it.
  *  Pure. */
-export declare function pairOrphanToolCalls(messages: ProviderMessage[]): ProviderMessage[];
+export declare function pairOrphanToolCalls(messages: ModelMessage[]): ModelMessage[];
 export declare function replayMessages(events: Array<{
     seq: number;
     event: SessionEvent;
-}>, maxBytes?: number): ProviderMessage[];
+}>, maxBytes?: number): ModelMessage[];
 export declare function replayMessagesAsync(events: Array<{
     seq: number;
     event: SessionEvent;
-}>, maxBytes?: number, loadArchive?: (archiveRef: string) => Promise<ProviderMessage[]>): Promise<ProviderMessage[]>;
+}>, maxBytes?: number, loadArchive?: (archiveRef: string) => Promise<ModelMessage[]>): Promise<ModelMessage[]>;
 /** Collect all text_delta events from a run into a single string. */
 export declare function collectText(stream: AsyncIterable<StreamEvent>): Promise<string>;

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(", ")}. ` +