@wrongstack/core 0.309.1 → 0.310.0

package/dist/coordination/kanban-dispatch-port.d.ts

@@ -0,0 +1,30 @@
+/**
+ * kanban-dispatch-port — composition seam for the Director's kanban
+ * dispatch and assignment operations (Roadmap #11).
+ *
+ * The coordination layer must not import `@wrongstack/kanban` at runtime;
+ * it resolves the concrete operations through this port, wired at the
+ * CLI composition root (see `setKanbanDispatch`). Type imports from
+ * `@wrongstack/kanban` are erased at compile time and do not create a
+ * runtime edge.
+ */
+import type { CompleteDispatchInput, CompleteDispatchResult, FailDispatchInput, HeartbeatKanbanTaskAssignmentInput, KanbanAgentAssignment, KanbanAgentRunStatus, KanbanBoard, KanbanEventContext, KanbanSearchInput, KanbanSearchResult, ReserveDispatchInput, ReserveDispatchResult, StartDispatchInput, StartDispatchResult } from '@wrongstack/kanban';
+export interface KanbanDispatchPort {
+    getBoard(projectRoot: string, boardId: string): Promise<KanbanBoard | null>;
+    listReadyTasks(projectRoot: string, input?: KanbanSearchInput & {
+        limit?: number | undefined;
+    }): Promise<KanbanSearchResult[]>;
+    reserveKanbanDispatch(projectRoot: string, input: ReserveDispatchInput): Promise<ReserveDispatchResult | null>;
+    startKanbanDispatch(projectRoot: string, input: StartDispatchInput): Promise<StartDispatchResult | null>;
+    completeKanbanDispatch(projectRoot: string, input: CompleteDispatchInput): Promise<CompleteDispatchResult | null>;
+    failKanbanDispatch(projectRoot: string, input: FailDispatchInput): Promise<KanbanBoard | null>;
+    updateTaskAssignment(projectRoot: string, boardId: string, taskId: string, patch: Partial<KanbanAgentAssignment> & {
+        status?: KanbanAgentRunStatus | undefined;
+    }, eventContext?: KanbanEventContext): Promise<KanbanBoard | null>;
+    heartbeatTaskAssignment(projectRoot: string, boardId: string, taskId: string, input?: HeartbeatKanbanTaskAssignmentInput): Promise<KanbanBoard | null>;
+}
+/** Composition-root hook: register the real kanban-backed implementation. */
+export declare function setKanbanDispatch(impl: KanbanDispatchPort): void;
+/** Runtime accessor used by director-tools; throws loudly when unwired. */
+export declare function kanbanDispatch(): KanbanDispatchPort;
+//# sourceMappingURL=kanban-dispatch-port.d.ts.map

package/dist/coordination/kanban-ops-port.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Kanban operations port for the coordination area (director queue tools).
+ *
+ * The director queue helpers previously imported `describeKanbanBoundary`
+ * (a pure formatter) directly from `@wrongstack/kanban`, keeping a
+ * core → kanban runtime edge (roadmap #11 / report §2.1). This port is
+ * the leaf contract; the CLI composition root registers the real
+ * implementation at boot alongside the storage BoardStorePort.
+ *
+ * Type-only imports of kanban's data shapes remain permitted — they erase
+ * at compile time and do not create a runtime edge.
+ */
+import type { KanbanBoundaryPolicy } from '@wrongstack/kanban';
+export interface KanbanBoundaryOpsPort {
+    describeKanbanBoundary(policy: KanbanBoundaryPolicy | undefined): string;
+}
+/** Composition-root hook: register the real kanban-backed implementation. */
+export declare function setKanbanBoundaryOps(impl: KanbanBoundaryOpsPort): void;
+/** Resolve the boundary-ops port (throws when not wired, mirroring BoardStorePort). */
+export declare function kanbanBoundaryOps(): KanbanBoundaryOpsPort;
+//# sourceMappingURL=kanban-ops-port.d.ts.map

package/dist/coordination/mailbox-hooks.d.ts

@@ -11,7 +11,7 @@
  *
  * @module mailbox-hooks
  */
-import type { Mailbox } from '../coordination/mailbox-types.js';
+import type { Mailbox } from './mailbox-types.js';
 export interface MailboxHooksOptions {
     /** The mailbox instance. */
     mailbox: Mailbox;

package/dist/coordination/mailbox-project-server.js

@@ -384,7 +384,10 @@ var withFileLock = primitives.withFileLock;
 import * as fs from "node:fs";
 import * as fsp2 from "node:fs/promises";
 import * as path3 from "node:path";
-import { PerformanceObserver, constants as performanceConstants } from "node:perf_hooks";
+import {
+  PerformanceObserver,
+  constants as performanceConstants
+} from "node:perf_hooks";
 import * as v8 from "node:v8";
 
 // src/utils/memory-flight-recorder.ts
@@ -690,7 +693,8 @@ function createMemoryFlightRecorder(options = {}) {
   const now = options.now ?? Date.now;
   const startedAt2 = now();
   const root = options.diagnosticsRoot ?? path2.join(wstackGlobalRoot(), "diagnostics", "memory");
-  const enabled = options.enabled ?? (process.env["WRONGSTACK_MEMORY_FLIGHT_RECORDER"] !== "0" && process.env["NODE_ENV"] !== "test");
+  const isBunRuntime = typeof globalThis.Bun !== "undefined";
+  const enabled = options.enabled ?? (!isBunRuntime && process.env["WRONGSTACK_MEMORY_FLIGHT_RECORDER"] !== "0" && process.env["NODE_ENV"] !== "test");
   const writer = options.captureWriter ?? (enabled ? new ContinuousMemoryCaptureWriter(root) : disabledWriter(path2.join(root, `${timestampSlug()}-pid-${process.pid}`)));
   const observations = [];
   const windowMs = options.windowMs ?? DEFAULT_WINDOW_MS;
@@ -800,7 +804,11 @@ function defaultHeapLogPath() {
 function takeHeapSample() {
   const m = process.memoryUsage();
   const heap = v8.getHeapStatistics();
-  const spaces = v8.getHeapSpaceStatistics();
+  let spaces = [];
+  try {
+    spaces = v8.getHeapSpaceStatistics();
+  } catch {
+  }
   const spaceUsed = (name) => spaces.find((space) => space.space_name === name)?.space_used_size ?? 0;
   const limit = heap.heap_size_limit || 0;
   let activeResources = 0;
@@ -2230,8 +2238,8 @@ function previousCredentialTtlMs(credential) {
 
 // src/coordination/sqlite-mailbox-schema.ts
 import * as fs2 from "node:fs";
-import { createRequire } from "node:module";
 import * as path5 from "node:path";
+import { loadRuntimeDatabaseSync } from "@wrongstack/persistence";
 
 // src/utils/sqlite-warning.ts
 var SQLITE_EXPERIMENTAL_WARNING_RE = /sqlite is an experimental feature/i;
@@ -2379,8 +2387,7 @@ var DatabaseSyncCtor;
 function loadDatabaseSync() {
   if (DatabaseSyncCtor) return DatabaseSyncCtor;
   return withSqliteExperimentalWarningSuppressed(() => {
-    const require2 = createRequire(import.meta.url);
-    DatabaseSyncCtor = require2("node:sqlite").DatabaseSync;
+    DatabaseSyncCtor = loadRuntimeDatabaseSync();
     return DatabaseSyncCtor;
   });
 }
@@ -2536,9 +2543,7 @@ function migrateLegacyFiles(ctx) {
 }
 function readLegacyMessages(projectDir2) {
   try {
-    return parseMailboxFile(
-      fs2.readFileSync(path5.join(projectDir2, GLOBAL_MAILBOX_FILE), "utf8")
-    );
+    return parseMailboxFile(fs2.readFileSync(path5.join(projectDir2, GLOBAL_MAILBOX_FILE), "utf8"));
   } catch (error) {
     if (error.code === "ENOENT") return [];
     throw error;

package/dist/core/context.d.ts

@@ -3,36 +3,14 @@ import type { ContextEvidenceState } from '../types/context-evidence.js';
 import type { FileEventRecord } from '../types/file-event-record.js';
 import type { Message } from '../types/messages.js';
 import type { Provider, Usage } from '../types/provider.js';
-import type { SessionWriter } from '../types/session.js';
+import type { SessionEvent, SessionWriter } from '../types/session.js';
 import type { TokenCounter } from '../types/token-counter.js';
 import type { Tool } from '../types/tool.js';
+import type { AgentContext, ContextMessageLimits } from '../types/context.js';
+import type { RunEnv } from '../types/run-env.js';
 import { ConversationState } from './conversation-state.js';
-import type { RunEnv } from './run-env.js';
-export interface TodoItem {
-    id: string;
-    content: string;
-    status: 'pending' | 'in_progress' | 'completed';
-    activeForm?: string | undefined;
-    /** When promoted from a plan item, stores the plan item's id. */
-    promotedFromPlan?: string | undefined;
-    /** When promoted from a task, stores the task's id. */
-    promotedFromTask?: string | undefined;
-    /** Durable Kanban owner when the todo row is a UI projection of a real card. */
-    kanbanBoardId?: string | undefined;
-    /** Durable Kanban card represented by this todo row. */
-    kanbanTaskId?: string | undefined;
-    /**
-     * Titles of the unfinished work this row waits on, derived from the Kanban
-     * card's dependencies. Always board-derived, never model-supplied.
-     *
-     * A blocked item is genuinely `pending` — it has not started — so this is an
-     * extra field rather than a fourth status. What was missing was never the
-     * state but the *reason*: the board computes readiness on every mutation,
-     * then the projection dropped it, leaving blocked work indistinguishable
-     * from ready work on screen and in the model's context.
-     */
-    blockedBy?: string[] | undefined;
-}
+import type { TodoItem } from '../types/context.js';
+export type { TodoItem };
 export interface RunOptions {
     signal?: AbortSignal | undefined;
     model?: string | undefined;
@@ -103,7 +81,7 @@ export interface ProviderMemoryEvidence {
  * the agent and user to navigate within the project without spawning a new
  * process. All changes must stay inside `projectRoot`.
  */
-export declare class Context implements RunEnv {
+export declare class Context implements RunEnv, AgentContext {
     messages: Message[];
     /**
      * Maximum number of messages retained in the conversation history.
@@ -243,6 +221,10 @@ export declare class Context implements RunEnv {
      * so storage operations can include it in `storage.*` events.
      */
     traceId: string | undefined;
+    /** Logical provider request whose response produced the current tool calls. */
+    activeLogicalRequestId: string | undefined;
+    /** Content-addressed prompt composition for {@link activeLogicalRequestId}. */
+    activePromptManifestId: string | undefined;
     /**
      * Session id pinned to the currently-executing run. Set by `Agent.run()`
      * at run start and cleared when the run ends. Event-emission sites must
@@ -266,13 +248,14 @@ export declare class Context implements RunEnv {
      */
     eventSessionId(): string;
     /** Callbacks fired when `setWorkingDir()` changes the working directory. */
-    private _onWorkingDirChanged;
+    /** WorkingDir-change callbacks; public for structural typing (Roadmap 10A). */
+    readonly _onWorkingDirChanged: Array<(newDir: string, oldDir: string) => void>;
     /**
      * Serializes externally requested provider/model changes. Request creation
      * waits on this barrier so an automatic continuation cannot capture the old
      * model while a user-triggered switch is still building its provider.
      */
-    private _modelTransition;
+    _modelTransition: Promise<void>;
     runModelTransition<T>(transition: () => T | Promise<T>): Promise<T>;
     waitForModelTransition(): Promise<void>;
     /**
@@ -333,23 +316,27 @@ export declare class Context implements RunEnv {
      * mutations that go through `state.appendMessage()` etc. fire
      * `onChange`. New code should prefer the wrapper API.
      */
-    private _state;
-    private readonly _conversationJournalQueue;
-    private _conversationJournalBytes;
-    private _conversationJournalDrain;
+    _state: ConversationState | null;
+    readonly _conversationJournalQueue: Array<{
+        event: SessionEvent;
+        bytes: number;
+        writer: SessionWriter;
+    }>;
+    _conversationJournalBytes: number;
+    _conversationJournalDrain: Promise<void> | null;
     private static readonly CONVERSATION_JOURNAL_MAX_EVENTS;
     private static readonly CONVERSATION_JOURNAL_MAX_BYTES;
     private static readonly MAX_FILE_EVENTS;
     private static readonly MAX_SIDE_EFFECTS;
     /** Wait until every exact conversation-state event queued so far is in the writer buffer. */
     flushConversationJournal(): Promise<void>;
-    private conversationJournalBytes;
-    private _journalDropCount;
-    private _journalDropWarnAt;
+    conversationJournalBytes(event: SessionEvent): number;
+    _journalDropCount: number;
+    _journalDropWarnAt: number;
     /** Throttled notice that a conversation event never reached the journal. */
-    private warnConversationJournalDrop;
-    private enqueueConversationJournal;
-    private startConversationJournalDrain;
+    warnConversationJournalDrop(eventType: SessionEvent['type']): void;
+    enqueueConversationJournal(event: SessionEvent, writer: SessionWriter): void;
+    startConversationJournalDrain(): void;
     get state(): ConversationState;
     /**
      * Register a teardown hook tied to the current run's abort signal.
@@ -364,7 +351,10 @@ export declare class Context implements RunEnv {
      * For hooks that must survive across run boundaries (mailbox heartbeat,
      * awareness polling, HQ publisher), prefer `registerAgentHook` instead.
      */
-    private abortHooks;
+    /** Run-scoped abort hooks (drained by drainAbortHooks). Public for structural typing (Roadmap 10A). */
+    readonly abortHooks: Set<() => void | Promise<void>>;
+    /** Retention limits honoring runtime subclass overrides of the statics. */
+    get messageLimits(): ContextMessageLimits;
     registerAbortHook(fn: () => void | Promise<void>): () => void;
     drainAbortHooks(): Promise<void>;
     /**
@@ -377,7 +367,8 @@ export declare class Context implements RunEnv {
      * awareness polling interval, HQ publisher connection, and auto-compaction
      * timer — resources that must survive from the first run to the last.
      */
-    private agentHooks;
+    /** Session-lifetime teardown hooks (drained by drainAgentHooks). Public for structural typing (Roadmap 10A). */
+    readonly agentHooks: Set<() => void | Promise<void>>;
     registerAgentHook(fn: () => void | Promise<void>): () => void;
     drainAgentHooks(): Promise<void>;
     /**
@@ -421,7 +412,7 @@ export declare class Context implements RunEnv {
      * the tool will re-stat the file and re-populate the entry. The agent
      * never fails or misbehaves; it just pays one extra stat call.
      */
-    private trimTrackedFiles;
+    trimTrackedFiles(): void;
     private static trimSet;
     private static trimMap;
     /** Clear accumulated file-read metadata after compaction or at boundaries
@@ -508,5 +499,5 @@ export declare class Context implements RunEnv {
  * tests and lightweight embedders stub Context with partial objects whose
  * `session` may be missing despite the non-optional type.
  */
-export declare function resolveEventSessionId(ctx: Context): string;
+export declare function resolveEventSessionId(ctx: AgentContext): string;
 //# sourceMappingURL=context.d.ts.map

package/dist/core/conversation-state.d.ts

@@ -1,6 +1,9 @@
 import type { ContentBlock } from '../types/blocks.js';
 import type { Message } from '../types/messages.js';
-import type { Context, TodoItem } from './context.js';
+import type { AgentContext, TodoItem } from '../types/context.js';
+import type { ConversationStateApi, ReadonlyConversationState, StateChange } from '../types/conversation-state.js';
+export type { ConversationStateApi, ReadonlyConversationState, StateChange };
+export type StateChangeHandler = (change: StateChange, state: ConversationStateApi) => void;
 /**
  * Observable wrapper for mutable conversation state. Production code should
  * mutate messages, todos, and meta through this API so subscribers see a
@@ -13,51 +16,13 @@ import type { Context, TodoItem } from './context.js';
  * that reads `ctx.messages` directly still works — they are NOT safe for
  * external writes.
  */
-export type StateChange = {
-    kind: 'message_appended';
-    message: Message;
-} | {
-    kind: 'messages_replaced';
-    messages: readonly Message[];
-}
-/** The oldest `count` messages were evicted; see the `messages_dropped` SessionEvent. */
- | {
-    kind: 'messages_dropped';
-    count: number;
-} | {
-    kind: 'message_updated';
-    index: number;
-    message: Message;
-} | {
-    kind: 'todos_replaced';
-    todos: readonly TodoItem[];
-    /**
-     * Final all-completed snapshot when the tactical list auto-clears.
-     * Observational mirrors use this to move cards to Done instead of
-     * interpreting the empty active list as "the work vanished".
-     */
-    completedSnapshot?: readonly TodoItem[] | undefined;
-} | {
-    kind: 'meta_set';
-    key: string;
-    value: unknown;
-} | {
-    kind: 'meta_deleted';
-    key: string;
-} | {
-    kind: 'meta_cleared';
-};
-export type StateChangeHandler = (change: StateChange, state: ConversationState) => void;
-export interface ReadonlyConversationState {
-    readonly messages: readonly Message[];
-    readonly todos: readonly TodoItem[];
-    readonly meta: Readonly<Record<string, unknown>>;
-}
 export declare class ConversationState {
-    private readonly ctx;
-    private readonly listeners;
-    private _revision;
-    constructor(ctx: Context);
+    /** Owning context; public for structural typing (Roadmap 10A). */
+    readonly ctx: AgentContext;
+    /** Subscribers; public for structural typing (Roadmap 10A). */
+    readonly listeners: Set<StateChangeHandler>;
+    _revision: number;
+    constructor(ctx: AgentContext);
     get messages(): readonly Message[];
     get todos(): readonly TodoItem[];
     get meta(): Readonly<Record<string, unknown>>;
@@ -77,16 +42,15 @@ export declare class ConversationState {
     appendMessage(message: Message): void;
     /**
      * How many of the oldest messages must be dropped to satisfy both retention
-     * caps — count ({@link Context.MAX_MESSAGES}) and size
-     * ({@link Context.MAX_MESSAGE_TOKENS}). Returns 0 when the history already
-     * fits, which is the overwhelmingly common case.
+     * caps — count and size (see {@link AgentContext.messageLimits}). Returns 0
+     * when the history already fits, which is the overwhelmingly common case.
      *
      * The size pass reads the per-message `_estTokens` cache populated at
      * mutation time, so it is a sum over numbers rather than a re-walk of
      * content blocks.  It runs whenever the token cap is enabled; the count
      * cap determines the starting index for the sum but does not gate it.
      */
-    private overflowCount;
+    overflowCount(arr: readonly Message[]): number;
     /**
      * Front eviction must not retain a `tool_result` after evicting the
      * immediately preceding assistant `tool_use`. Long tool-heavy sessions sit
@@ -100,7 +64,7 @@ export declare class ConversationState {
      * the minimum lossless representation; once enough newer messages exist, the
      * next eviction boundary naturally moves past both halves together.
      */
-    private protocolSafeDropCount;
+    protocolSafeDropCount(arr: readonly Message[], drop: number): number;
     /**
      * Append a content block to the trailing user message's content array.
      * Mutates only that one message (a single indexed assignment) — avoids
@@ -124,10 +88,10 @@ export declare class ConversationState {
      * the compatibility arrays are intentionally not observed.
      */
     onChange(listener: StateChangeHandler): () => void;
-    private emit;
+    emit(change: StateChange): void;
 }
 /**
  * Convenience constructor. The wrapper holds a reference, not a copy.
  */
-export declare function wrapAsState(ctx: Context): ConversationState;
+export declare function wrapAsState(ctx: AgentContext): ConversationState;
 //# sourceMappingURL=conversation-state.d.ts.map

package/dist/core/index.js

@@ -4762,7 +4762,9 @@ function hasToolUseBlock(message) {
   return message?.role === "assistant" && Array.isArray(message.content) && message.content.some((block) => block.type === "tool_use");
 }
 var ConversationState = class {
+  /** Owning context; public for structural typing (Roadmap 10A). */
   ctx;
+  /** Subscribers; public for structural typing (Roadmap 10A). */
   listeners = /* @__PURE__ */ new Set();
   _revision = 0;
   constructor(ctx) {
@@ -4817,9 +4819,8 @@ var ConversationState = class {
   }
   /**
    * How many of the oldest messages must be dropped to satisfy both retention
-   * caps — count ({@link Context.MAX_MESSAGES}) and size
-   * ({@link Context.MAX_MESSAGE_TOKENS}). Returns 0 when the history already
-   * fits, which is the overwhelmingly common case.
+   * caps — count and size (see {@link AgentContext.messageLimits}). Returns 0
+   * when the history already fits, which is the overwhelmingly common case.
    *
    * The size pass reads the per-message `_estTokens` cache populated at
    * mutation time, so it is a sum over numbers rather than a re-walk of
@@ -4827,9 +4828,7 @@ var ConversationState = class {
    * cap determines the starting index for the sum but does not gate it.
    */
   overflowCount(arr) {
-    const contextClass = this.ctx.constructor;
-    const maxMessages = contextClass.MAX_MESSAGES;
-    const maxMessageTokens = contextClass.MAX_MESSAGE_TOKENS;
+    const { maxMessages, maxMessageTokens } = this.ctx.messageLimits;
     let drop = maxMessages > 0 ? Math.max(0, arr.length - maxMessages) : 0;
     if (maxMessageTokens <= 0) return this.protocolSafeDropCount(arr, drop);
     let total = 0;
@@ -5103,6 +5102,10 @@ var Context = class _Context {
    * so storage operations can include it in `storage.*` events.
    */
   traceId;
+  /** Logical provider request whose response produced the current tool calls. */
+  activeLogicalRequestId = void 0;
+  /** Content-addressed prompt composition for {@link activeLogicalRequestId}. */
+  activePromptManifestId = void 0;
   /**
    * Session id pinned to the currently-executing run. Set by `Agent.run()`
    * at run start and cleared when the run ends. Event-emission sites must
@@ -5128,6 +5131,7 @@ var Context = class _Context {
     return resolveEventSessionId(this);
   }
   /** Callbacks fired when `setWorkingDir()` changes the working directory. */
+  /** WorkingDir-change callbacks; public for structural typing (Roadmap 10A). */
   _onWorkingDirChanged = [];
   /**
    * Serializes externally requested provider/model changes. Request creation
@@ -5383,7 +5387,16 @@ var Context = class _Context {
    * For hooks that must survive across run boundaries (mailbox heartbeat,
    * awareness polling, HQ publisher), prefer `registerAgentHook` instead.
    */
+  /** Run-scoped abort hooks (drained by drainAbortHooks). Public for structural typing (Roadmap 10A). */
   abortHooks = /* @__PURE__ */ new Set();
+  /** Retention limits honoring runtime subclass overrides of the statics. */
+  get messageLimits() {
+    const cls = this.constructor;
+    return Object.freeze({
+      maxMessages: cls.MAX_MESSAGES,
+      maxMessageTokens: cls.MAX_MESSAGE_TOKENS
+    });
+  }
   registerAbortHook(fn) {
     this.abortHooks.add(fn);
     return () => this.abortHooks.delete(fn);
@@ -5408,6 +5421,7 @@ var Context = class _Context {
    * awareness polling interval, HQ publisher connection, and auto-compaction
    * timer — resources that must survive from the first run to the last.
    */
+  /** Session-lifetime teardown hooks (drained by drainAgentHooks). Public for structural typing (Roadmap 10A). */
   agentHooks = /* @__PURE__ */ new Set();
   registerAgentHook(fn) {
     this.agentHooks.add(fn);
@@ -5588,6 +5602,9 @@ var Context = class _Context {
       agentName: this.agentName,
       provider: typeof this.provider === "object" ? this.provider.id : String(this.provider),
       model: this.model,
+      ...this.activeLogicalRequestId ? { logicalRequestId: this.activeLogicalRequestId } : {},
+      ...this.activePromptManifestId ? { promptManifestId: this.activePromptManifestId } : {},
+      provenanceConfidence: this.activeLogicalRequestId && this.activePromptManifestId ? "explicit" : "unknown",
       toolName: input.toolName,
       toolUseId: input.toolUseId,
       scope,
@@ -5615,6 +5632,9 @@ var Context = class _Context {
       agentName: this.agentName,
       provider: record.provider,
       model: record.model,
+      ...record.logicalRequestId ? { logicalRequestId: record.logicalRequestId } : {},
+      ...record.promptManifestId ? { promptManifestId: record.promptManifestId } : {},
+      provenanceConfidence: record.provenanceConfidence,
       toolName: input.toolName,
       toolUseId: input.toolUseId,
       scope,
@@ -6772,7 +6792,12 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
             const idVal = ev.id;
             const nameVal = ev.name;
             handleToolUseStart(state, { id: idVal, name: nameVal });
-            const emittedPayload = { sessionId, ctx, id: idVal ?? "unknown", name: nameVal ?? "unknown" };
+            const emittedPayload = {
+              sessionId,
+              ctx,
+              id: idVal ?? "unknown",
+              name: nameVal ?? "unknown"
+            };
             events.emit("provider.tool_use_start", emittedPayload);
             break;
           }
@@ -7075,6 +7100,8 @@ async function runProviderWithRetry(opts) {
   const { provider, request, signal, ctx, events, retry, logger, tracer } = opts;
   const logicalRequestId = randomUUID5();
   const promptManifest = createChroniclePromptManifest(request);
+  ctx.activeLogicalRequestId = logicalRequestId;
+  ctx.activePromptManifestId = promptManifest.manifestId;
   let attempt = 0;
   for (; ; ) {
     const attemptId = randomUUID5();
@@ -7085,6 +7112,7 @@ async function runProviderWithRetry(opts) {
       ...ctx.traceId ? { traceId: ctx.traceId } : {},
       ...ctx.agentId ? { agentId: ctx.agentId } : {},
       logicalRequestId,
+      promptManifestId: promptManifest.manifestId,
       attemptId,
       attempt,
       providerId: provider.id,
@@ -7108,15 +7136,18 @@ async function runProviderWithRetry(opts) {
     });
     logger.debug(`Provider attempt ${attempt + 1} starting`, providerLogCtx(provider, request));
     try {
-      const res = await runWithNetworkTelemetry({
-        events,
-        sessionId: resolveEventSessionId(ctx),
-        ...ctx.traceId ? { traceId: ctx.traceId } : {},
-        ...ctx.agentId ? { agentId: ctx.agentId } : {},
-        attemptId,
-        initiator: "provider",
-        operationName: `${provider.id}.complete`
-      }, () => provider.capabilities.streaming ? streamProviderToResponse(provider, request, signal, ctx, events, logger) : provider.complete(request, { signal }));
+      const res = await runWithNetworkTelemetry(
+        {
+          events,
+          sessionId: resolveEventSessionId(ctx),
+          ...ctx.traceId ? { traceId: ctx.traceId } : {},
+          ...ctx.agentId ? { agentId: ctx.agentId } : {},
+          attemptId,
+          initiator: "provider",
+          operationName: `${provider.id}.complete`
+        },
+        () => provider.capabilities.streaming ? streamProviderToResponse(provider, request, signal, ctx, events, logger) : provider.complete(request, { signal })
+      );
       span?.setAttribute("provider.stopReason", res.stopReason);
       span?.setAttribute("provider.usage_in", res.usage.input);
       span?.setAttribute("provider.usage_out", res.usage.output);
@@ -8857,6 +8888,8 @@ function createAgentToolHandler(a) {
     a.events.emit("tool.executed", {
       sessionId: resolveEventSessionId(a.ctx),
       ...a.ctx.traceId ? { traceId: a.ctx.traceId } : {},
+      ...a.ctx.activeLogicalRequestId ? { logicalRequestId: a.ctx.activeLogicalRequestId } : {},
+      ...a.ctx.activePromptManifestId ? { promptManifestId: a.ctx.activePromptManifestId } : {},
       agentId: a.ctx.agentId,
       agentName: a.ctx.agentName,
       id: toolUseId,
@@ -9368,6 +9401,8 @@ var Agent = class {
     const sessionId = sessionWriter.id;
     this.ctx.activeRunSessionWriter = sessionWriter;
     this.ctx.activeRunSessionId = sessionId;
+    this.ctx.activeLogicalRequestId = void 0;
+    this.ctx.activePromptManifestId = void 0;
     controller.onAbort(() => this.ctx.drainAbortHooks());
     controller.onAbort(async () => {
       await sessionWriter.flush().catch(() => {
@@ -9471,6 +9506,8 @@ var Agent = class {
       } finally {
         this.ctx.activeRunSessionId = void 0;
         this.ctx.activeRunSessionWriter = void 0;
+        this.ctx.activeLogicalRequestId = void 0;
+        this.ctx.activePromptManifestId = void 0;
         this._runInProgress = false;
       }
     }

package/dist/core/provider-runner.d.ts

@@ -3,12 +3,12 @@ import type { Logger } from '../types/logger.js';
 import type { Tracer } from '../types/observability.js';
 import type { Provider, Request, Response } from '../types/provider.js';
 import type { RetryPolicy } from '../types/retry-policy.js';
-import { type Context } from './context.js';
+import type { AgentContext } from '../types/context.js';
 export interface RunProviderOptions {
     provider: Provider;
     request: Request;
     signal: AbortSignal;
-    ctx: Context;
+    ctx: AgentContext;
     events: EventBus;
     retry: RetryPolicy;
     logger: Logger;

package/dist/core/run-env.d.ts

@@ -1,9 +1,5 @@
-import type { TextBlock } from '../types/blocks.js';
-import type { Provider } from '../types/provider.js';
-import type { SessionWriter } from '../types/session.js';
-import type { TokenCounter } from '../types/token-counter.js';
-import type { Tool } from '../types/tool.js';
 import type { Context } from './context.js';
+import type { RunEnv } from '../types/run-env.js';
 /**
  * Immutable run environment — the set-once dependencies for an agent run.
  *
@@ -18,32 +14,15 @@ import type { Context } from './context.js';
  * references. The opposite direction (set things on Context) still works,
  * and `extractRunEnv` rebuilds the view if you need a snapshot.
  *
+ * Roadmap 10A: the interface itself now lives in `types/run-env.ts` (a
+ * dependency leaf that never imports `core/`), so the type module graph
+ * stays acyclic; this module keeps `extractRunEnv` and re-exports the
+ * interface for existing import paths.
+ *
  * Migration path: new APIs accept `RunEnv` instead of `Context` when they
  * only need read access. Existing APIs continue to accept `Context` until
  * a full split is scheduled.
  */
-export interface RunEnv {
-    readonly provider: Provider;
-    readonly session: SessionWriter;
-    readonly signal: AbortSignal;
-    readonly tokenCounter: TokenCounter;
-    readonly cwd: string;
-    readonly projectRoot: string;
-    /** Mutable working directory — starts as `cwd`. */
-    readonly workingDir: string;
-    readonly model: string;
-    readonly systemPrompt: readonly TextBlock[];
-    readonly tools: readonly Tool[];
-    readonly agentId: string;
-    readonly agentName: string;
-}
-/**
- * Build a `RunEnv` view from a Context. The returned object is a shallow
- * frozen view — mutations to `Context` are visible (it's the same
- * references), but the view itself can't be mutated.
- *
- * Use this in subsystems that want to declare "I only need read access to
- * the env" without rewriting their signature to accept the full Context.
- */
+export type { RunEnv } from '../types/run-env.js';
 export declare function extractRunEnv(ctx: Context): RunEnv;
 //# sourceMappingURL=run-env.d.ts.map

package/dist/core/streaming-response-builder.d.ts

@@ -1,7 +1,7 @@
 import type { EventBus } from '../kernel/events.js';
 import type { Logger } from '../types/logger.js';
 import type { Provider, Request, Response } from '../types/provider.js';
-import { type Context } from './context.js';
+import type { AgentContext } from '../types/context.js';
 interface ThinkingEntry {
     textBuf: string;
     signature?: string | undefined;
@@ -73,6 +73,6 @@ export declare function handleMessageStop(state: StreamingState, ev: {
     stopReason?: Response['stopReason'] | undefined;
     usage?: Response['usage'] | undefined;
 }): void;
-export declare function streamProviderToResponse(provider: Provider, req: Request, signal: AbortSignal, ctx: Context, events: EventBus, logger: Logger): Promise<Response>;
+export declare function streamProviderToResponse(provider: Provider, req: Request, signal: AbortSignal, ctx: AgentContext, events: EventBus, logger: Logger): Promise<Response>;
 export {};
 //# sourceMappingURL=streaming-response-builder.d.ts.map