@kuralle-agents/core 0.12.0 → 0.14.0

package/dist/flow/extraction.js

@@ -6,6 +6,10 @@ function collectDataKey(nodeId) {
 function collectTurnsKey(nodeId) {
     return `__collectTurns_${nodeId}`;
 }
+export function resetCollect(state, nodeId) {
+    delete state[collectDataKey(nodeId)];
+    delete state[collectTurnsKey(nodeId)];
+}
 export function getCollectData(state, nodeId) {
     const raw = state[collectDataKey(nodeId)];
     if (typeof raw === 'object' && raw !== null && !Array.isArray(raw)) {
@@ -125,16 +129,22 @@ export function emitExtractionTelemetry(node, state, incoming, emit) {
         }
     }
     emit({
+        channel: 'internal',
         type: 'custom',
-        name: 'flow.extraction.submission',
-        data: { node: node.id, fieldsAccepted, fieldsRejected },
+        payload: {
+            name: 'flow.extraction.submission',
+            data: { node: node.id, fieldsAccepted, fieldsRejected },
+        },
     });
     const collected = getCollectData(state, node.id);
     const missing = computeMissingFields(node, collected);
     emit({
+        channel: 'internal',
         type: 'custom',
-        name: 'flow.extraction.update',
-        data: { nodeId: node.id, collected, missing },
+        payload: {
+            name: 'flow.extraction.update',
+            data: { nodeId: node.id, collected, missing },
+        },
     });
 }
 function fieldPopulated(value) {

package/dist/flow/reduceTransition.d.ts

@@ -1,7 +1,7 @@
 import type { LanguageModel } from 'ai';
 import type { Flow, FlowNode } from '../types/flow.js';
 import type { RunState } from '../runtime/durable/types.js';
-import type { HarnessStreamPart } from '../types/stream.js';
+import type { StreamPart } from '../types/stream.js';
 export interface ReduceTransitionInput {
     fromNodeId: string;
     toNode: FlowNode;
@@ -9,7 +9,7 @@ export interface ReduceTransitionInput {
     flow: Flow;
     model: LanguageModel;
     data?: Record<string, unknown>;
-    emit: (part: HarnessStreamPart) => void;
+    emit: (part: StreamPart) => void;
     abortSignal?: AbortSignal;
 }
 export declare function reduceTransition(input: ReduceTransitionInput): Promise<void>;

package/dist/flow/reduceTransition.js

@@ -8,9 +8,13 @@ function resolveNodeContext(toNode, flow) {
 }
 export async function reduceTransition(input) {
     const { fromNodeId, toNode, run, flow, model, data, emit, abortSignal } = input;
-    emit({ type: 'node-exit', nodeName: fromNodeId });
-    emit({ type: 'flow-transition', from: fromNodeId, to: toNode.id });
-    emit({ type: 'node-enter', nodeName: toNode.id });
+    emit({ channel: 'internal', type: 'node-exit', payload: { nodeName: fromNodeId } });
+    emit({
+        channel: 'internal',
+        type: 'flow-transition',
+        payload: { from: fromNodeId, to: toNode.id },
+    });
+    emit({ channel: 'internal', type: 'node-enter', payload: { nodeName: toNode.id } });
     emitInteractiveOnNodeEnter(toNode, run.state, emit);
     await applyContextStrategy({
         strategy: resolveNodeContext(toNode, flow),

package/dist/flow/runFlow.js

@@ -1,6 +1,6 @@
-import { getFlowPark } from './collectDigression.js';
+import { popFlowPark, runCollectDigression } from './collectDigression.js';
 import { parseConfirmation } from './confirmParse.js';
-import { hasPendingUserInput } from '../runtime/channels/inputBuffer.js';
+import { hasPendingUserInput, setPendingUserInput } from '../runtime/channels/inputBuffer.js';
 import { userInputToText } from '../runtime/userInput.js';
 import { collectUntilComplete } from './collectUntilComplete.js';
 import { isActionNode, isCollectNode, isDecideNode, isReplyNode, } from './nodeKinds.js';
@@ -10,8 +10,8 @@ import { resolveReplyNode } from './nodeBuilders.js';
 import { evaluateReplyControl } from './controlEvaluator.js';
 import { runNodeVerify, VerifyBlockedError } from './verify.js';
 import { loadRecordedSteps } from '../runtime/durable/replay.js';
-import { SuspendError } from '../runtime/durable/RunStore.js';
-import { ToolApprovalDeniedError } from '../tools/effect/errors.js';
+import { persistTurnUsageFromTurn } from '../runtime/turnTokenUsage.js';
+import { isApprovalDenial, isControlFlowSignal } from '../runtime/controlFlowSignal.js';
 import { emitInteractiveOnNodeEnter } from './emitInteractive.js';
 import { appendConversationAudit } from '../audit/record.js';
 import { appendSafeAssistantMessage, degradeFlowError, findEscalateNode, } from './degrade.js';
@@ -68,16 +68,24 @@ async function dispatchConfirmGate(node, run, driver, ctx) {
         return { kind: 'stay' };
     }
     let input = '';
+    let rawInput = '';
     if (hasPendingUserInput(ctx.session)) {
         const signal = await driver.awaitUser(ctx);
+        rawInput = signal.input;
         input = userInputToText(signal.input);
         appendUserMessage(run, signal.input);
     }
     else {
         input = latestUserText(run);
+        rawInput = input;
     }
-    ctx.turnInputConsumed = true;
     const verdict = parseConfirmation(input);
+    if (verdict === 'decline') {
+        setPendingUserInput(ctx.session, rawInput);
+    }
+    else {
+        ctx.turnInputConsumed = true;
+    }
     const branch = verdict === 'affirm'
         ? gate.onConfirm
         : verdict === 'decline'
@@ -136,7 +144,40 @@ async function dispatchNode(node, run, driver, ctx, agent, flow) {
         return normalizeTransition(await node.decide(structured, run.state));
     }
     if (isReplyNode(node)) {
+        // Consume input here ONLY to feed the out-of-band digression check below, and
+        // only for input this turn genuinely fresh to THIS reply — gated on both:
+        //   !turnInputConsumed: a prior node (e.g. a collect) already took the turn's
+        //     input, so a terminal reply like `done` (next→end) must not re-digress on
+        //     the leftover — otherwise it returns `stay`, the main loop's stay+pending
+        //     branch re-dispatches, and completion hangs on a driver clearing the buffer.
+        //   outOfBandControl: with OOB off there is no digression, so the reply must not
+        //     swallow input here — it returns its transition (`next: () => 'stay'`) and the
+        //     main loop's stay-branch owns awaitUser.
+        let freshUserInput = false;
+        if (hasPendingUserInput(ctx.session) && !ctx.turnInputConsumed && ctx.outOfBandControl) {
+            const signal = await driver.awaitUser(ctx);
+            appendUserMessage(run, signal.input);
+            ctx.turnInputConsumed = true;
+            freshUserInput = true;
+        }
+        if (freshUserInput && agent) {
+            const digression = await runCollectDigression({
+                agent,
+                node,
+                activeFlowName: flow.name,
+                run,
+                driver,
+                ctx,
+            });
+            if (digression.kind === 'transition') {
+                return digression.transition;
+            }
+            if (digression.kind === 'answeredThenResume') {
+                return { kind: 'stay' };
+            }
+        }
         const turn = await driver.runAgentTurn(resolveReplyNode(node, run.state), ctx);
+        await persistTurnUsageFromTurn(ctx, turn);
         if (ctx.outOfBandControl) {
             const decision = await evaluateReplyControl({
                 node,
@@ -147,6 +188,23 @@ async function dispatchNode(node, run, driver, ctx, agent, flow) {
             if (decision.kind === 'redispatch') {
                 const signal = await driver.awaitUser(ctx);
                 appendUserMessage(run, signal.input);
+                ctx.turnInputConsumed = true;
+                if (agent) {
+                    const digression = await runCollectDigression({
+                        agent,
+                        node,
+                        activeFlowName: flow.name,
+                        run,
+                        driver,
+                        ctx,
+                    });
+                    if (digression.kind === 'transition') {
+                        return digression.transition;
+                    }
+                    if (digression.kind === 'answeredThenResume') {
+                        return { kind: 'stay' };
+                    }
+                }
                 return dispatchNode(node, run, driver, ctx, agent, flow);
             }
             appendAssistantMessage(run, turn.text);
@@ -206,8 +264,8 @@ export async function runFlow(flow, run, driver, ctx, agent) {
     if (!run.activeNode) {
         run.activeNode = node.id;
         run.activeFlow = flow.name;
-        ctx.emit({ type: 'flow-enter', flow: flow.name });
-        ctx.emit({ type: 'node-enter', nodeName: node.id });
+        ctx.emit({ channel: 'internal', type: 'flow-enter', payload: { flow: flow.name } });
+        ctx.emit({ channel: 'internal', type: 'node-enter', payload: { nodeName: node.id } });
         emitInteractiveOnNodeEnter(node, run.state, ctx.emit);
     }
     const edgeCounts = new Map();
@@ -218,11 +276,14 @@ export async function runFlow(flow, run, driver, ctx, agent) {
             transition = await dispatchNode(node, run, driver, ctx, agent, flow);
         }
         catch (error) {
-            if (error instanceof SuspendError || error instanceof ToolApprovalDeniedError) {
+            // Neither is a malfunction, so neither may reach degradeFlowError and be reported to
+            // the user as "something went wrong on my side". A suspend resumes later; a denial is
+            // the action node author's to handle, since they chose to call the tool.
+            if (isControlFlowSignal(error) || isApprovalDenial(error)) {
                 throw error;
             }
             const message = error instanceof Error ? error.message : String(error);
-            ctx.emit({ type: 'error', error: message });
+            ctx.emit({ channel: 'client', type: 'error', payload: { error: message } });
             return degradeFlowError(flow, registry, run, driver, ctx, (n, r, d, c) => dispatchNode(n, r, d, c, agent, flow));
         }
         if (transition.kind === 'switchFlow') {
@@ -232,23 +293,34 @@ export async function runFlow(flow, run, driver, ctx, agent) {
             return runFlow(transition.flow, run, driver, ctx, agent);
         }
         if (transition.kind === 'end') {
-            const park = getFlowPark(run.state);
+            const park = popFlowPark(run.state);
             if (park && agent) {
-                delete run.state.__flowPark;
                 const parkedFlow = agent.flows?.find((candidate) => candidate.name === park.flow);
                 if (parkedFlow) {
                     run.activeFlow = park.flow;
                     run.activeNode = park.node;
                     await ctx.runStore.putRunState(run);
-                    ctx.emit({ type: 'flow-end', flow: flow.name, reason: transition.reason });
+                    ctx.emit({
+                        channel: 'internal',
+                        type: 'flow-end',
+                        payload: { flow: flow.name, reason: transition.reason },
+                    });
                     return runFlow(parkedFlow, run, driver, ctx, agent);
                 }
             }
-            ctx.emit({ type: 'flow-end', flow: flow.name, reason: transition.reason });
+            ctx.emit({
+                channel: 'internal',
+                type: 'flow-end',
+                payload: { flow: flow.name, reason: transition.reason },
+            });
             return { kind: 'ended', reason: transition.reason };
         }
         if (transition.kind === 'handoff') {
-            ctx.emit({ type: 'handoff', targetAgent: transition.to, reason: transition.reason });
+            ctx.emit({
+                channel: 'internal',
+                type: 'handoff',
+                payload: { targetAgent: transition.to, reason: transition.reason },
+            });
             return { kind: 'handoff', to: transition.to, reason: transition.reason };
         }
         if (transition.kind === 'escalate') {
@@ -279,14 +351,18 @@ export async function runFlow(flow, run, driver, ctx, agent) {
         }
         catch (error) {
             if (error instanceof VerifyBlockedError) {
-                ctx.emit({ type: 'error', error: error.message });
+                ctx.emit({ channel: 'client', type: 'error', payload: { error: error.message } });
                 return { kind: 'awaitingUser' };
             }
             throw error;
         }
         const oscillation = bumpOscillation(edgeCounts, node.id, target.id);
         if (oscillation > maxOscillations) {
-            ctx.emit({ type: 'error', error: `Flow oscillation blocked: ${node.id} -> ${target.id}` });
+            ctx.emit({
+                channel: 'client',
+                type: 'error',
+                payload: { error: `Flow oscillation blocked: ${node.id} -> ${target.id}` },
+            });
             const escalateNode = findEscalateNode(registry);
             if (escalateNode) {
                 appendSafeAssistantMessage(run, ctx);
@@ -305,7 +381,11 @@ export async function runFlow(flow, run, driver, ctx, agent) {
                 continue;
             }
             appendSafeAssistantMessage(run, ctx);
-            ctx.emit({ type: 'flow-end', flow: flow.name, reason: 'error_degraded' });
+            ctx.emit({
+                channel: 'internal',
+                type: 'flow-end',
+                payload: { flow: flow.name, reason: 'error_degraded' },
+            });
             return { kind: 'ended', reason: 'error_degraded' };
         }
         await reduceTransition({

package/dist/foundation/AgentStateController.d.ts

@@ -1,7 +1,7 @@
 import type { Session } from '../types/index.js';
 /**
  * Manages active agent resolution, handoff recording, and agent state.
- * Shared by Runtime and VoiceEngine.
+ * Used by Runtime.
  */
 export interface AgentStateController {
     /** Resolve the active agent ID, falling back to the provided default. */

package/dist/foundation/ToolExecutor.d.ts

@@ -1,7 +1,7 @@
 import type { Session, ToolCallRecord } from '../types/index.js';
 /**
  * Minimal tool shape required by the executor.
- * Compatible with AI SDK `Tool`, VoiceToolDef, and plain `{ execute }` objects.
+ * Compatible with AI SDK `Tool` and plain `{ execute }` objects.
  */
 export interface ExecutableTool {
     execute: (args: unknown, options?: unknown) => Promise<unknown>;
@@ -9,7 +9,7 @@ export interface ExecutableTool {
 }
 /**
  * Encapsulates tool execution with enforcement, idempotency, and context enrichment.
- * Shared by Runtime (text path) and VoiceEngine (audio path).
+ * Used by Runtime.
  */
 export interface ToolExecutor {
     /**

package/dist/foundation/index.d.ts

@@ -1,14 +1,3 @@
-export type { AgentDefinition } from './AgentDefinition.js';
 export type { ToolExecutor, ExecutableTool } from './ToolExecutor.js';
-export type { ConversationState } from './ConversationState.js';
-export type { ConversationEventLog, ConversationEvent } from './ConversationEventLog.js';
 export type { AgentStateController } from './AgentStateController.js';
-export { DefaultToolExecutor, ToolTimeoutError } from './DefaultToolExecutor.js';
-export type { DefaultToolExecutorConfig } from './DefaultToolExecutor.js';
-export { DefaultConversationState } from './DefaultConversationState.js';
-export type { DefaultConversationStateConfig } from './DefaultConversationState.js';
-export { DefaultConversationEventLog } from './DefaultConversationEventLog.js';
-export type { DefaultConversationEventLogConfig } from './DefaultConversationEventLog.js';
 export { DefaultAgentStateController } from './DefaultAgentStateController.js';
-export { createFoundation } from './createFoundation.js';
-export type { Foundation, FoundationConfig } from './createFoundation.js';

package/dist/foundation/index.js

@@ -1,7 +1,2 @@
 // Default implementations
-export { DefaultToolExecutor, ToolTimeoutError } from './DefaultToolExecutor.js';
-export { DefaultConversationState } from './DefaultConversationState.js';
-export { DefaultConversationEventLog } from './DefaultConversationEventLog.js';
 export { DefaultAgentStateController } from './DefaultAgentStateController.js';
-// Factory
-export { createFoundation } from './createFoundation.js';

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { createFlowTransition, createFlowTransitionWithNode, isFlowTransition, createFlowUpdate, isFlowUpdate, } from './flows/index.js';
 export { SessionManager } from './session/SessionManager.js';
 export type { SessionStore } from './session/SessionStore.js';
+export { StaleWriteError } from './session/SessionStore.js';
 export { MemoryStore } from './session/stores/MemoryStore.js';
 export { reviveSession } from './session/utils.js';
 export { DEFAULT_CHANNEL_POLICIES, applyChannelPolicy, getDefaultChannelPolicy, resolveChannelPolicy, } from './channels/index.js';
@@ -29,12 +30,6 @@ export type { PromptSection, PromptTemplate, ToolGuideline } from './prompts/ind
 export { BuiltinPersonas, composePersonaPrompt } from './persona/index.js';
 export { resolvePersonaExperiment } from './persona/index.js';
 export type { PersonaConfig, PersonaExperimentCohort, PersonaExperimentConfig, PersonaExperimentMetadata, PersonaExperimentResolution, PersonaLanguagePolicy, PersonaRegister, PersonaVoice, } from './persona/index.js';
-export { HookRunner, createHookRunner } from './hooks/HookRunner.js';
-export { loggingHooks, createLoggingHooks } from './hooks/builtin/logging.js';
-export { createMetricsHooks, InMemoryMetrics } from './hooks/builtin/metrics.js';
-export type { Metrics } from './hooks/builtin/metrics.js';
-export { createObservabilityHooks } from './hooks/builtin/observability.js';
-export type { ObservabilityConfig } from './hooks/builtin/observability.js';
 export type { SessionTrace, TraceStreamEvent } from './types/telemetry.js';
 export { createPromptInjectionGuard } from './processors/builtin/promptInjectionGuard.js';
 export type { PromptInjectionGuardOptions } from './processors/builtin/promptInjectionGuard.js';
@@ -75,8 +70,8 @@ export { applyPromptCache, applyAnthropicCacheControl, buildOpenAIResponsesProvi
 export type { AnthropicCacheTtl, OpenAIResponsesCompactOptions } from './runtime/promptCache.js';
 export { handoffFilters, removeToolHistory, keepRecentMessages, removeKeys, composeFilters, } from './runtime/handoffFilters.js';
 export type { HandoffInputFilter, HandoffInputData, HandoffInputResult, } from './runtime/handoffFilters.js';
-export { DefaultToolExecutor, DefaultConversationState, DefaultConversationEventLog, DefaultAgentStateController, createFoundation, } from './foundation/index.js';
-export type { ToolExecutor, ConversationState, ConversationEventLog, ConversationEvent, AgentStateController, Foundation, FoundationConfig, } from './foundation/index.js';
+export { DefaultAgentStateController } from './foundation/index.js';
+export type { ToolExecutor, AgentStateController, } from './foundation/index.js';
 export type * from './types/index.js';
 export { CapabilityHost, ExtractionCapability, GuardrailCapability, AutoRetrieveCapability, PassThroughRefinement, PassThroughValidation, toGeminiDeclarations, toAISDKTools, } from './capabilities/index.js';
 export type { Capability, CapabilityAction, ExtractionToolResponseEnvelope, FlowReconfigureTransition, ToolDeclaration, PromptSection as CapabilityPromptSection, GeminiFunctionDeclaration, ExtractionCapabilityConfig, RetrieveProvider, AutoRetrieveCapabilityConfig, RefinementCapability, RefineInput, RefineDecision, ValidationCapability, ValidateInput, ValidateDecision, SourceRef, } from './capabilities/index.js';
@@ -86,9 +81,7 @@ export { createInProcessScheduler, createWakeJobRunner, createScheduleFollowupTo
 export type { Scheduler, ScheduledJob, InjectableTimer, WakeOptions, WakeJobPayload, WakeDelivery, WakeRunnable, } from './scheduler/index.js';
 export { filterAuditEntries } from './audit/index.js';
 export type { AuditConfig, AuditEntryBase, AuditEntryType, AuditListOptions, AuditReplayOptions, ConversationAuditEntry, ConversationAuditLog, } from './audit/types.js';
-export type { RealtimeAudioClient, RealtimeSessionConfig, RealtimeAudioConfig, RealtimeToolResponse, RealtimeEventMap, RealtimeSessionHandle, } from './realtime/index.js';
 export type { Hooks } from './types/hooks.js';
-export type { HarnessHooks } from './types/runtime.js';
 export { defineAgent, defineFlow, reply, collect, action, decide, confirmGate, } from './authoring/index.js';
 export { defineTool } from './types/effectTool.js';
 export { fsErrorCode } from './types/filesystem.js';
@@ -97,8 +90,8 @@ export type { CreateFsToolOptions, GrepHit } from './tools/fs/createFsTool.js';
 export { createShellTool } from './tools/fs/createShellTool.js';
 export type { CreateShellToolOptions } from './tools/fs/createShellTool.js';
 export type { Shell, ShellResult, ShellExecOptions } from './types/shell.js';
-export { SkillsCapability, wireAgentSkills, collectRegisteredNames, validateSkillAllowedTools, prepareSkillStore, isSkillStore, InlineSkillStore, } from './skills/index.js';
-export type { WiredAgentSkills, SkillWireAgent } from './skills/index.js';
+export { SkillsCapability, wireAgentSkills, collectRegisteredNames, validateSkillAllowedTools, prepareSkillStore, isSkillStore, InlineSkillStore, CompositeSkillStore, fsSkillStore, defineSkill, parseSkillFrontmatter, } from './skills/index.js';
+export type { WiredAgentSkills, SkillWireAgent, DefineSkillConfig, ParsedSkill, } from './skills/index.js';
 export { buildToolSet, toolToAiSdk, wrapAiSdkTool, ToolApprovalDeniedError, ToolTimeoutError, } from './tools/effect/index.js';
 export type { Tool as EffectTool } from './types/effectTool.js';
 export type { AgentRoute } from './types/processors.js';
@@ -107,8 +100,15 @@ export type { Flow, FlowNode, Transition, CollectNode, DecideNode, ConfirmGate,
 export { parseConfirmation } from './flow/confirmParse.js';
 export type { ConfirmVerdict } from './flow/confirmParse.js';
 export type { Route } from './types/route.js';
-export type { TurnHandle } from './types/stream.js';
-export type { HarnessStreamPart } from './types/stream.js';
+export { PART_CHANNEL } from './types/stream.js';
+export type { StreamChannel, StreamPartBase, TextStartPayload, TextDeltaPayload, TextEndPayload, TextCancelPayload, ToolCallPayload, ToolResultPayload, FlowEnterPayload, FlowEndPayload, NodeEnterPayload, NodeExitPayload, FlowTransitionPayload, HandoffPayload, InterruptedPayload, PausedPayload, ConversationOutcomePayload, InteractivePayload, TurnEndPayload, PipelineValidationBlockPayload, SafetyBlockedPayload, WakePayload, EscalationPayload, ContextCompactedPayload, CompactionSkippedPayload, ContextOverflowRecoveredPayload, ErrorPayload, CustomPayload, DonePayload, KnowledgeCacheHitPayload, KnowledgeCacheMissPayload, KnowledgeSearchPayload, KnowledgeQualityCheckPayload, KnowledgeReformulationPayload, StreamPart, TurnHandle, } from './types/stream.js';
+export type { AgentSpan, AgentTrace, SpanKind } from './types/trace.js';
+export { MemoryTraceStore, isTraceStore, type MemoryTraceStoreOptions, type TraceListWindow, type TraceSink, type TraceStore, } from './tracing/index.js';
+export { OtelTraceSink, langfuseSink, otelSink, toOtlpPayload, type LangfuseSinkOptions, type OtelTraceSinkOptions, } from './tracing/index.js';
+export { TraceRecorder, runOnce, type TraceRecorderOptions } from './runtime/TraceRecorder.js';
+export { TracingService } from './services/TracingService.js';
+export { InMemoryMetricsService } from './services/MetricsService.js';
+export type { MetricsService } from './services/MetricsService.js';
 export { harnessToUIMessageStream } from './ai-sdk/uiMessageStream.js';
 export type { KuralleMetadata, KuralleDataParts, KuralleUIMessage, } from './ai-sdk/uiMessageStream.js';
 export type { ChoiceOption, ResolvedSelection } from './types/selection.js';
@@ -119,7 +119,7 @@ export type { ChannelDriver, TextDriver } from './runtime/channels/index.js';
 export type { TurnResult } from './types/channel.js';
 export type { RunContext, ToolContext, ActionContext } from './types/run-context.js';
 export type { AnyTool } from './types/effectTool.js';
-export { createRuntime, Runtime, type HarnessConfig, type RunOptions, } from './runtime/Runtime.js';
+export { createRuntime, Runtime, type HarnessConfig, type RunOptions, type TracingConfig, } from './runtime/Runtime.js';
 export type { RuntimeLike } from './runtime/RuntimeLike.js';
 export { userInputToText, mergeUserInputContents, hasMediaParts, transcribeAudioParts, type UserInputContent, } from './runtime/userInput.js';
 export { setPendingUserInput, consumePendingUserInput, consumeAllPendingUserInput, peekPendingUserInput, hasPendingUserInput, } from './runtime/channels/inputBuffer.js';

package/dist/index.js

@@ -1,5 +1,6 @@
 export { createFlowTransition, createFlowTransitionWithNode, isFlowTransition, createFlowUpdate, isFlowUpdate, } from './flows/index.js';
 export { SessionManager } from './session/SessionManager.js';
+export { StaleWriteError } from './session/SessionStore.js';
 export { MemoryStore } from './session/stores/MemoryStore.js';
 export { reviveSession } from './session/utils.js';
 export { DEFAULT_CHANNEL_POLICIES, applyChannelPolicy, getDefaultChannelPolicy, resolveChannelPolicy, } from './channels/index.js';
@@ -17,10 +18,6 @@ export { createLoadMemoryTool } from './tools/memory.js';
 export { PromptTemplateBuilder, PromptBuilder, createPromptTemplate, SUPPORT_AGENT_TEMPLATE, SALES_AGENT_TEMPLATE, TRIAGE_AGENT_TEMPLATE, createSupportAgentTemplate, DEFAULT_HANDOFF_INSTRUCTION, } from './prompts/index.js';
 export { BuiltinPersonas, composePersonaPrompt } from './persona/index.js';
 export { resolvePersonaExperiment } from './persona/index.js';
-export { HookRunner, createHookRunner } from './hooks/HookRunner.js';
-export { loggingHooks, createLoggingHooks } from './hooks/builtin/logging.js';
-export { createMetricsHooks, InMemoryMetrics } from './hooks/builtin/metrics.js';
-export { createObservabilityHooks } from './hooks/builtin/observability.js';
 export { createPromptInjectionGuard } from './processors/builtin/promptInjectionGuard.js';
 export { createPiiInputGuard, createPiiOutputGuard, redactPii, } from './processors/builtin/piiGuard.js';
 export { createModerationGuard, createModerationOutputGuard, } from './processors/builtin/moderationGuard.js';
@@ -44,7 +41,7 @@ export { compactMessages, estimateMessagesTokens, DEFAULT_COMPACTION_TRIGGER_TOK
 export { isContextOverflowError, recoverFromContextOverflow, } from './runtime/contextOverflow.js';
 export { applyPromptCache, applyAnthropicCacheControl, buildOpenAIResponsesProviderOptions, isAnthropicLanguageModel, isOpenAIResponsesModel, } from './runtime/promptCache.js';
 export { handoffFilters, removeToolHistory, keepRecentMessages, removeKeys, composeFilters, } from './runtime/handoffFilters.js';
-export { DefaultToolExecutor, DefaultConversationState, DefaultConversationEventLog, DefaultAgentStateController, createFoundation, } from './foundation/index.js';
+export { DefaultAgentStateController } from './foundation/index.js';
 export { CapabilityHost, ExtractionCapability, GuardrailCapability, AutoRetrieveCapability, PassThroughRefinement, PassThroughValidation, toGeminiDeclarations, toAISDKTools, } from './capabilities/index.js';
 export { buildEscalationRequest, ensureSessionMetadata } from './escalation/escalation.js';
 export { createInProcessScheduler, createWakeJobRunner, createScheduleFollowupTool, wakeJob, isWakeJob, WAKE_JOB_KIND, } from './scheduler/index.js';
@@ -54,9 +51,15 @@ export { defineTool } from './types/effectTool.js';
 export { fsErrorCode } from './types/filesystem.js';
 export { createFsTool } from './tools/fs/createFsTool.js';
 export { createShellTool } from './tools/fs/createShellTool.js';
-export { SkillsCapability, wireAgentSkills, collectRegisteredNames, validateSkillAllowedTools, prepareSkillStore, isSkillStore, InlineSkillStore, } from './skills/index.js';
+export { SkillsCapability, wireAgentSkills, collectRegisteredNames, validateSkillAllowedTools, prepareSkillStore, isSkillStore, InlineSkillStore, CompositeSkillStore, fsSkillStore, defineSkill, parseSkillFrontmatter, } from './skills/index.js';
 export { buildToolSet, toolToAiSdk, wrapAiSdkTool, ToolApprovalDeniedError, ToolTimeoutError, } from './tools/effect/index.js';
 export { parseConfirmation } from './flow/confirmParse.js';
+export { PART_CHANNEL } from './types/stream.js';
+export { MemoryTraceStore, isTraceStore, } from './tracing/index.js';
+export { OtelTraceSink, langfuseSink, otelSink, toOtlpPayload, } from './tracing/index.js';
+export { TraceRecorder, runOnce } from './runtime/TraceRecorder.js';
+export { TracingService } from './services/TracingService.js';
+export { InMemoryMetricsService } from './services/MetricsService.js';
 export { harnessToUIMessageStream } from './ai-sdk/uiMessageStream.js';
 export { DURABLE_RUNS_KEY } from './runtime/durable/types.js';
 export { createRuntime, Runtime, } from './runtime/Runtime.js';

package/dist/outcomes/streamPart.d.ts

@@ -1,3 +1,3 @@
-import type { HarnessStreamPart } from '../types/voice.js';
+import type { StreamPart } from '../types/stream.js';
 import type { ConversationOutcomeRecord } from './types.js';
-export declare function toConversationOutcomeStreamPart(record: ConversationOutcomeRecord): HarnessStreamPart;
+export declare function toConversationOutcomeStreamPart(record: ConversationOutcomeRecord): StreamPart;

package/dist/outcomes/streamPart.js

@@ -1,8 +1,7 @@
 export function toConversationOutcomeStreamPart(record) {
     return {
+        channel: 'client',
         type: 'conversation-outcome',
-        outcome: record.outcome,
-        ...(record.reason ? { reason: record.reason } : {}),
-        markedBy: record.markedBy,
+        payload: { outcome: record.outcome },
     };
 }

package/dist/prompts/PromptBuilder.d.ts

@@ -1,5 +1,5 @@
 import type { ToolSet } from '../tools/Tool.js';
-import type { PromptTemplate, PromptBuilderConfig, BrandVoiceConfig, KnowledgeContext, SessionMemory, AgentDefinition, PolicyProfile } from './types.js';
+import type { PromptTemplate, PromptBuilderConfig, BrandVoiceConfig, KnowledgeContext, SessionMemory, AgentIdentity, PolicyProfile } from './types.js';
 import { type PersonaConfig } from '../persona/index.js';
 export declare class PromptBuilder {
     private config;
@@ -10,7 +10,7 @@ export declare class PromptBuilder {
      */
     constructor(config?: PromptBuilderConfig | PromptTemplate);
     withTemplate(template: PromptTemplate): this;
-    withAgentDefinition(definition: AgentDefinition): this;
+    withAgentIdentity(identity: AgentIdentity): this;
     withBrandVoice(brandVoice: BrandVoiceConfig): this;
     withPersona(persona: PersonaConfig): this;
     addPersona(persona: PersonaConfig): this;
@@ -19,7 +19,7 @@ export declare class PromptBuilder {
     withKnowledgeContext(context: KnowledgeContext): this;
     withPolicyProfile(profile: PolicyProfile): this;
     build(): string;
-    private buildAgentDefinitionSections;
+    private buildAgentIdentitySections;
     private buildPersonaSections;
     private buildBrandVoiceSections;
     private buildKnowledgeSections;

package/dist/prompts/PromptBuilder.js

@@ -22,8 +22,8 @@ export class PromptBuilder {
         this.config.template = template;
         return this;
     }
-    withAgentDefinition(definition) {
-        this.config.agentDefinition = definition;
+    withAgentIdentity(identity) {
+        this.config.agentIdentity = identity;
         return this;
     }
     withBrandVoice(brandVoice) {
@@ -63,8 +63,8 @@ export class PromptBuilder {
             immutable: true,
         });
         // Layer 1: Agent Definition
-        if (this.config.agentDefinition) {
-            sections.push(...this.buildAgentDefinitionSections());
+        if (this.config.agentIdentity) {
+            sections.push(...this.buildAgentIdentitySections());
         }
         if (this.config.persona) {
             sections.push(...this.buildPersonaSections());
@@ -100,8 +100,8 @@ export class PromptBuilder {
         const sorted = sections.sort((a, b) => (a.priority ?? 100) - (b.priority ?? 100));
         return sorted.map(s => this.formatSection(s)).join('\n\n');
     }
-    buildAgentDefinitionSections() {
-        const def = this.config.agentDefinition;
+    buildAgentIdentitySections() {
+        const def = this.config.agentIdentity;
         const sections = [];
         sections.push({
             type: 'identity',
@@ -235,6 +235,13 @@ export class PromptBuilder {
                 priority: LAYER_PRIORITIES.CONVERSATION_SUMMARY,
             });
         }
+        if (memory.openGoalsPrompt) {
+            sections.push({
+                type: 'conversation_summary',
+                content: memory.openGoalsPrompt,
+                priority: LAYER_PRIORITIES.CONVERSATION_SUMMARY,
+            });
+        }
         return sections;
     }
     formatSection(section) {

package/dist/prompts/index.d.ts

@@ -1,4 +1,4 @@
-export type { PromptSection, PromptTemplate, ToolGuideline, PromptTemplateBuilderOptions, PromptSectionType, VoiceRulesConfig, VoiceRules, GlossaryTerm, GlossaryConfig, BrandVoiceConfig, KnowledgeContext, SessionMemory, AgentDefinition, PolicyProfile, PromptBuilderConfig, } from './types.js';
+export type { PromptSection, PromptTemplate, ToolGuideline, PromptTemplateBuilderOptions, PromptSectionType, VoiceRulesConfig, VoiceRules, GlossaryTerm, GlossaryConfig, BrandVoiceConfig, KnowledgeContext, SessionMemory, AgentIdentity, PolicyProfile, PromptBuilderConfig, } from './types.js';
 export { PromptTemplateBuilder, createPromptTemplate, LAYER_PRIORITIES } from './types.js';
 export { PromptBuilder, createPrompt } from './PromptBuilder.js';
 export { SUPPORT_AGENT_TEMPLATE, SALES_AGENT_TEMPLATE, TRIAGE_AGENT_TEMPLATE, createSupportAgentTemplate, BUILTIN_TEMPLATES, DEFAULT_HANDOFF_INSTRUCTION, } from './templates.js';

package/dist/prompts/types.d.ts

@@ -49,15 +49,22 @@ export interface SessionMemory {
         label: string;
         content: string;
     }>;
+    /** Compact open-thread note projected from session.workingMemory.__goals (G5). */
+    openGoalsPrompt?: string;
 }
-export interface AgentDefinition {
+/**
+ * Who the agent is, rendered into the `identity` / `role` / `capabilities` prompt
+ * sections by `PromptBuilder`. A prompt fragment — not the agent itself, which is
+ * `AgentConfig` from `defineAgent`.
+ */
+export interface AgentIdentity {
     identity: string;
     role: string;
     capabilities?: string[];
 }
 export interface PromptBuilderConfig {
     template?: PromptTemplate;
-    agentDefinition?: AgentDefinition;
+    agentIdentity?: AgentIdentity;
     persona?: PersonaConfig;
     brandVoice?: BrandVoiceConfig;
     knowledgeContext?: KnowledgeContext;

package/dist/runtime/InMemoryRetrievalCache.d.ts

@@ -0,0 +1,25 @@
+import type { KnowledgeRetrievalResult, RetrievalCacheAdapter } from '../types/knowledge.js';
+/**
+ * Zero-config, in-process session retrieval cache (G6). Keyed by the query
+ * embedding: a lookup returns the cached results of the most-similar recent
+ * query (cosine ≥ threshold, within TTL). LRU-bounded. Needs only the embedder
+ * the KnowledgeProvider already requires — no external dependency. Apps that
+ * want a shared/vector-backed cache can inject their own `RetrievalCacheAdapter`
+ * via the KnowledgeProvider's `cacheFactory` instead.
+ */
+export interface InMemoryRetrievalCacheOptions {
+    maxEntries?: number;
+    ttlMs?: number;
+    similarityThreshold?: number;
+}
+export declare class InMemoryRetrievalCache implements RetrievalCacheAdapter {
+    /** Ordered oldest → newest (LRU front, MRU back). */
+    private entries;
+    private readonly maxEntries;
+    private readonly ttlMs;
+    private readonly threshold;
+    constructor(options?: InMemoryRetrievalCacheOptions);
+    get size(): number;
+    lookup(queryEmbedding: readonly number[], topK?: number): KnowledgeRetrievalResult[];
+    populate(results: KnowledgeRetrievalResult[], queryEmbedding?: readonly number[]): void;
+}