@theokit/sdk 4.63.4 → 5.0.0-next.2

package/dist/chunk-N2U4AZGB.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/internal/session/agent-session-store.ts"],"names":[],"mappings":"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","file":"chunk-N2U4AZGB.js","sourcesContent":["/**\n * SE40 — native session store over the Claude-shaped `.jsonl` transcript.\n *\n * The theokit session format IS the Claude Code record shape (see\n * `../../persistence/session-transcript.ts`). This module owns the FS lifecycle:\n * read existing records, seed a {@link SessionTranscript}'s parent chain, append\n * the new turn (user + assistant/tool blocks), and write append-only. Compaction\n * appends a `compact_boundary` record (a new root) — it NEVER shrinks the line\n * set (that would break the DAG). Reads reconstruct `LlmMessage[]` via\n * {@link reconstructMessages}, narrowed to the in-memory {@link SessionMessage}.\n *\n * @internal\n */\n\nimport type { ToolResultContentBlock } from \"../../types/content-blocks.js\";\nimport type { ConversationStep, ConversationTurn } from \"../../types/conversation.js\";\nimport type { SessionStore } from \"../../types/session-store.js\";\nimport {\n  type AssistantTurn,\n  reconstructMessages,\n  type SessionRecord,\n  SessionTranscript,\n} from \"../persistence/session-transcript.js\";\nimport type { SessionMessage, SessionMessagePart } from \"./session-types.js\";\n\n/**\n * Seed a {@link SessionTranscript} from the already-on-disk records so a new\n * append parents correctly on the existing DAG leaf. The transcript re-emits the\n * seeded records verbatim before the new turn, so the whole file rewrites atomically\n * as one append-only line set. Returns the transcript primed with the prior records.\n */\nfunction seedTranscript(\n  prior: readonly SessionRecord[],\n  opts: { cwd: string; sessionId: string; model: string },\n): SessionTranscript {\n  return SessionTranscript.fromRecords(prior, opts);\n}\n\n/** The turn to persist: the user's text plus the rich per-turn conversation view. */\nexport interface PersistTurnInput {\n  userText: string;\n  conversation: readonly ConversationTurn[];\n  /**\n   * M50 — when supplied, size-driven auto-compaction runs in the SAME write chain after the turn\n   * persists (usage real vs the model's context window; summarizer injected by the caller).\n   */\n  autoCompact?: {\n    usageTotal?: number | undefined;\n    contextWindow?: number | undefined;\n    summarize: (\n      messages: readonly import(\"../../compaction.js\").CompressibleMessage[],\n    ) => Promise<string>;\n  };\n}\n\ninterface MappedTurn {\n  assistant: AssistantTurn;\n  toolResults: Array<{ toolUseId: string; content: string; isError?: boolean }>;\n}\n\n/**\n * theokit#122 — record the turn's thinking block, signature included.\n *\n * The signature is what makes the block replayable: without it the resumed turn is rejected by\n * Anthropic with `400 \"thinking blocks cannot be modified\"`.\n */\nfunction applyThinkingStep(\n  assistant: AssistantTurn,\n  message: { text: string; signature?: string },\n): void {\n  assistant.thinking = message.text;\n  if (message.signature !== undefined) assistant.thinkingSignature = message.signature;\n}\n\n/** Fold one agent turn's steps into an assistant record + paired tool results. */\nfunction mapAgentTurn(steps: readonly ConversationStep[]): MappedTurn {\n  const assistant: AssistantTurn = {};\n  const toolResults: MappedTurn[\"toolResults\"] = [];\n  const toolCalls: NonNullable<AssistantTurn[\"toolCalls\"]> = [];\n  for (const step of steps) {\n    if (step.type === \"thinkingMessage\") applyThinkingStep(assistant, step.message);\n    else if (step.type === \"assistantMessage\") assistant.text = step.message.text;\n    else if (step.type === \"toolCall\")\n      toolCalls.push({\n        id: step.message.callId,\n        name: step.message.name,\n        input: (step.message.args as Record<string, unknown> | undefined) ?? {},\n      });\n    else\n      toolResults.push({\n        toolUseId: step.message.callId,\n        content: step.message.result,\n        isError: step.message.isError,\n      });\n  }\n  if (toolCalls.length > 0) assistant.toolCalls = toolCalls;\n  return { assistant, toolResults };\n}\n\n/** True when the assistant record carries any content worth emitting. */\nfunction hasAssistantContent(a: AssistantTurn): boolean {\n  return a.text !== undefined || a.thinking !== undefined || (a.toolCalls?.length ?? 0) > 0;\n}\n\n/**\n * Map the rich `ConversationTurn[]` (from `run.conversation()`) into the native\n * assistant/tool records. One transcript turn is: an `assistant` record carrying\n * thinking + text + tool_use blocks, then (when present) a `user` record carrying\n * the paired tool_result blocks. Tool results pair with tool_use by `callId`.\n */\nfunction appendConversation(\n  transcript: SessionTranscript,\n  conversation: readonly ConversationTurn[],\n): void {\n  for (const ct of conversation) {\n    if (ct.type !== \"agentConversationTurn\") continue;\n    const { assistant, toolResults } = mapAgentTurn(ct.turn.steps);\n    if (hasAssistantContent(assistant)) transcript.appendAssistantTurn(assistant);\n    if (toolResults.length > 0) transcript.appendToolResults(toolResults);\n  }\n}\n\n/**\n * The per-agent transcript metadata used to seed a {@link SessionTranscript}. The\n * actual record I/O goes through the injected {@link SessionStore} (SE41), so this\n * no longer carries a `baseDir` — the store is already bound to its location.\n */\nexport interface TranscriptLocation {\n  cwd: string;\n  agentId: string;\n  model: string;\n}\n\n/**\n * Read the session's records via the {@link SessionStore} and reconstruct the\n * resumable history, narrowed to the in-memory {@link SessionMessage} shape\n * (user/assistant text). Tool turns fold into assistant-role context so resume\n * keeps tool history. Works identically for the FS default and an external store.\n */\nexport async function readSessionMessages(\n  store: SessionStore,\n  agentId: string,\n): Promise<SessionMessage[]> {\n  const records = await store.readRecords(agentId);\n  return reconstructMessages(records).map(narrowToSessionMessage);\n}\n\ntype NarrowPart = {\n  type: string;\n  text?: string;\n  content?: unknown;\n  name?: string;\n  id?: string;\n  toolUseId?: string;\n  input?: unknown;\n  isError?: boolean;\n};\n\n/** Render one reconstructed content part as folded session text. */\nfunction partToText(p: NarrowPart): string {\n  if (p.type === \"text\") return p.text ?? \"\";\n  if (p.type === \"tool_use\") return `[tool call] ${p.name ?? \"\"}`;\n  if (p.type === \"tool_result\") {\n    const body = typeof p.content === \"string\" ? p.content : JSON.stringify(p.content);\n    return `[tool result] ${body}`;\n  }\n  return \"\";\n}\n\n/**\n * theokit#146 — the same part, kept as STRUCTURE.\n *\n * `partToText` above is what the model replay wants; a host rendering tool cards needs the call id,\n * the tool name and the arguments, none of which survive `[tool call] NAME`. Both projections are\n * produced from the one reconstructed part, so they cannot drift apart.\n *\n * Returns `undefined` for a part with no display meaning (e.g. an image placeholder the session\n * projection does not model), which the caller filters out.\n */\nfunction partToStructured(p: NarrowPart): SessionMessagePart | undefined {\n  if (p.type === \"text\") return { type: \"text\", text: p.text ?? \"\" };\n  if (p.type === \"tool_use\") {\n    return {\n      type: \"tool_use\",\n      id: p.id ?? \"\",\n      name: p.name ?? \"\",\n      input: (p.input ?? {}) as Record<string, unknown>,\n    };\n  }\n  if (p.type === \"tool_result\") {\n    return {\n      type: \"tool_result\",\n      toolUseId: p.toolUseId ?? \"\",\n      // Reconstructed tool results carry either a string or the SE7 content blocks; both are\n      // already the session shape, so this narrows `unknown` rather than converting anything.\n      content: p.content as string | ReadonlyArray<ToolResultContentBlock>,\n      ...(p.isError === true ? { isError: true } : {}),\n    };\n  }\n  return undefined;\n}\n\n/** Flatten a reconstructed `LlmMessage` to the narrowed in-memory `SessionMessage`. */\nfunction narrowToSessionMessage(m: {\n  role: \"system\" | \"user\" | \"assistant\";\n  content: NarrowPart[];\n}): SessionMessage {\n  const role = m.role === \"user\" ? \"user\" : \"assistant\";\n  const text = m.content\n    .map(partToText)\n    .filter((s) => s.length > 0)\n    .join(\"\\n\");\n  const parts = m.content\n    .map(partToStructured)\n    .filter((p): p is SessionMessagePart => p !== undefined);\n  return { role, text, parts };\n}\n\n/** The records appended by the last turn (the delta beyond the seeded prior). */\nfunction deltaRecords(\n  transcript: SessionTranscript,\n  priorLength: number,\n): readonly SessionRecord[] {\n  return transcript.records().slice(priorLength);\n}\n\n/**\n * Persist one conversation turn (user + assistant/tool records) to the session\n * store, append-only. Reads the prior records to seed the parent chain, folds the\n * new turn, and appends ONLY the delta via {@link SessionStore.appendRecords}\n * (the store owns the append atomicity — the FS default serializes under a file\n * lock). Within one process, turns for an agent are already chained upstream, so\n * the read→append is ordered; cross-host ordering is the external store's contract.\n */\nexport async function persistTurn(\n  store: SessionStore,\n  loc: TranscriptLocation,\n  sessionId: string,\n  turn: PersistTurnInput,\n): Promise<void> {\n  const prior = await store.readRecords(loc.agentId);\n  const transcript = seedTranscript(prior, { cwd: loc.cwd, sessionId, model: loc.model });\n  transcript.appendUserTurn(turn.userText);\n  appendConversation(transcript, turn.conversation);\n  await store.appendRecords(loc.agentId, deltaRecords(transcript, prior.length));\n}\n\n/**\n * Append-only compaction: add a `compact_boundary` system record (a new root) so\n * resume replays only the post-boundary continuation. Appends only the boundary\n * record via the store — NEVER rewrites or shrinks the prior records.\n */\nexport async function appendCompactBoundaryRecord(\n  store: SessionStore,\n  loc: TranscriptLocation,\n  sessionId: string,\n  meta: { preTokens: number; trigger: string },\n): Promise<void> {\n  const prior = await store.readRecords(loc.agentId);\n  const transcript = seedTranscript(prior, { cwd: loc.cwd, sessionId, model: loc.model });\n  transcript.appendCompactBoundary(meta);\n  await store.appendRecords(loc.agentId, deltaRecords(transcript, prior.length));\n}\n"]}

package/dist/chunk-NDGGJQTZ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/internal/runtime/hooks/hooks-source.ts","../src/internal/personality/context.ts"],"names":[],"mappings":"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","file":"chunk-NDGGJQTZ.js","sourcesContent":["/**\n * Single source of truth for loading the hooks config (ADR 0016 — reverses\n * D74/D77 for hooks: JSON is canonical again, in the Claude Code shape).\n *\n * `.theokit/hooks.json` (Claude-Code-shaped JSON) is the only supported form.\n * A stray legacy `.theokit/hooks/*.md` dir (no hooks.json) is NOT loaded — it\n * warns to migrate and yields no hooks. Absent both → empty config.\n *\n * Consumed by `hooks-executor.ts` (runtime dispatch).\n *\n * Config shape (identical to Claude Code's `settings.json` hooks):\n *   { \"hooks\": { \"PreToolUse\": [ { \"matcher\": \"shell\",\n *       \"hooks\": [ { \"type\": \"command\", \"command\": \"…\", \"timeout\": 30 } ] } ] } }\n *\n * @internal\n */\n\nimport { existsSync } from \"node:fs\";\nimport { readFile } from \"node:fs/promises\";\nimport { join } from \"node:path\";\nimport { ConfigurationError } from \"../../../errors.js\";\nimport { diag } from \"../../diagnostics.js\";\nimport { projectConfigRoots } from \"../../persistence/paths.js\";\n\n/** The five lifecycle events the SDK runtime actually fires. */\nexport type HookEvent = \"preRun\" | \"postRun\" | \"preToolUse\" | \"postToolUse\" | \"stop\";\n\n/**\n * Claude Code event name → the SDK firing event. Only events the runtime\n * genuinely emits are mapped; a Claude Code event with no SDK firing point\n * (SessionStart / SubagentStop / PreCompact / Notification / SessionEnd) is\n * skipped with a warn rather than silently accepted (it would never run).\n */\nconst CLAUDE_CODE_EVENT_MAP: Readonly<Record<string, HookEvent>> = {\n  PreToolUse: \"preToolUse\",\n  PostToolUse: \"postToolUse\",\n  UserPromptSubmit: \"preRun\",\n  Stop: \"stop\",\n};\n\nexport interface HookCommand {\n  command: string;\n  matcher?: string;\n  timeoutMs?: number;\n  /**\n   * The config file this command was declared in.\n   *\n   * Carried so the executor can supply the runtime contract the declaring DIALECT presumes — a\n   * command from `.claude/settings.json` is written against Claude Code's runtime and expects\n   * `$CLAUDE_PROJECT_DIR` to exist (#522). Absent for a command built in memory, which is native by\n   * construction.\n   */\n  sourcePath?: string;\n}\n\nexport interface HookConfig {\n  hooks?: Partial<Record<HookEvent, HookCommand[]>>;\n}\n\nconst warned = new Set<string>();\n\n/**\n * Emit a stderr warn once per process per unique key. Helps surface the\n * deprecation path without spamming when the loader is called many times\n * during a session (cron + send + skills all hit this).\n *\n * Note: spawned workers (cron, subagent) start fresh processes — warn\n * re-emits there, by design (1 per process boot, not per call).\n *\n * @internal\n */\nexport function warnOnce(key: string, message: string): void {\n  if (warned.has(key)) return;\n  warned.add(key);\n  diag(`${message}\\n`);\n}\n\n/** Reset for tests; not exported via barrel. @internal */\nexport function _resetWarnOnceForTests(): void {\n  warned.clear();\n}\n\n/**\n * Load hooks from `.theokit/hooks.json` (Claude-Code-shaped — the only supported\n * form). A stray legacy `.theokit/hooks/*.md` markdown dir (no `hooks.json`) is\n * NOT loaded — it emits a one-time migration warn and yields no hooks.\n *\n * @internal\n */\nexport async function loadHookConfig(cwd: string): Promise<HookConfig> {\n  const merged: HookConfig = {};\n  let sawAny = false;\n  for (const path of hookConfigCandidates(cwd)) {\n    if (!existsSync(path)) continue;\n    sawAny = true;\n    // Stamped at merge, where the file is still known. One line later the commands are pooled per\n    // event and every trace of which dialect declared them is gone — which is how a Claude Code\n    // command came to be run without Claude Code's runtime (#522).\n    mergeInto(merged, stampSource(await readHookFile(path), path));\n  }\n  if (!sawAny && existsSync(join(cwd, \".theokit\", \"hooks\"))) {\n    warnOnce(\n      \"hooks-md-unsupported\",\n      \"[theokit-sdk] .theokit/hooks/*.md hooks are no longer supported (ADR 0016) — migrate to a Claude-Code-shaped .theokit/hooks.json\",\n    );\n  }\n  return merged;\n}\n\n/**\n * Every file that may declare hooks, in precedence order.\n *\n * `hooks.json` under each project config root, then the Claude Code CLI's own settings files — which\n * is where the CLI actually keeps hooks, so a repository set up for it presents its hooks here\n * without being converted. `settings.local.json` is the CLI's personal-override file and sits beside\n * the shared one rather than replacing it.\n *\n * The shape never needed translating: `parseClaudeCodeConfig` reads the `hooks` key off whatever\n * object it is given, and a settings file is that same object with other keys alongside.\n */\nfunction hookConfigCandidates(cwd: string): string[] {\n  const roots = projectConfigRoots(cwd);\n  return [\n    ...roots.map((root) => join(root, \"hooks.json\")),\n    ...roots.map((root) => join(root, \"settings.json\")),\n    ...roots.map((root) => join(root, \"settings.local.json\")),\n  ];\n}\n\n/**\n * Record which file each command came from.\n *\n * A command already carrying a `sourcePath` keeps it: nothing produces that today, and a nested\n * config that declared its own origin would be describing something this function cannot see.\n */\nfunction stampSource(config: HookConfig, sourcePath: string): HookConfig {\n  if (config.hooks === undefined) return config;\n  const hooks: NonNullable<HookConfig[\"hooks\"]> = {};\n  for (const [event, commands] of Object.entries(config.hooks) as [\n    HookEvent,\n    HookCommand[] | undefined,\n  ][]) {\n    if (commands === undefined) continue;\n    hooks[event] = commands.map((c) => ({ sourcePath, ...c }));\n  }\n  return { hooks };\n}\n\n/**\n * Append one source's commands onto the accumulator, per event.\n *\n * MERGED, not first-wins, and the distinction is deliberate. An agent or a skill is a NAMED\n * declaration: two files claiming one name collide, and the explicit namespace should win. Hooks are\n * unnamed lists — two files declaring `PreToolUse` are two sets of commands an operator wrote, and\n * keeping only one drops the other in silence, which is the failure class this package guards\n * against everywhere else.\n */\nfunction mergeInto(target: HookConfig, source: HookConfig): void {\n  for (const [event, commands] of Object.entries(source.hooks ?? {}) as [\n    HookEvent,\n    HookCommand[] | undefined,\n  ][]) {\n    if (commands === undefined || commands.length === 0) continue;\n    target.hooks ??= {};\n    target.hooks[event] = [...(target.hooks[event] ?? []), ...commands];\n  }\n}\n\nasync function readHookFile(jsonPath: string): Promise<HookConfig> {\n  let raw: string;\n  try {\n    raw = await readFile(jsonPath, \"utf8\");\n  } catch (cause) {\n    throw new ConfigurationError(`Failed to read hooks config: ${jsonPath}`, {\n      code: \"hooks_read_error\",\n      cause,\n    });\n  }\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(raw);\n  } catch (cause) {\n    throw new ConfigurationError(`Invalid JSON in hooks config: ${jsonPath}`, {\n      code: \"hooks_json_invalid\",\n      cause,\n    });\n  }\n  return parseClaudeCodeConfig(parsed, jsonPath);\n}\n\n/** Narrow an unknown to a record, or throw a typed config error. */\nfunction asRecord(value: unknown, path: string, where: string): Record<string, unknown> {\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) {\n    throw new ConfigurationError(`hooks: expected an object at ${where} in ${path}`, {\n      code: \"hooks_json_invalid\",\n    });\n  }\n  return value as Record<string, unknown>;\n}\n\n/** Narrow an unknown to an array, or throw a typed config error. */\nfunction asArray(value: unknown, path: string, where: string): unknown[] {\n  if (!Array.isArray(value)) {\n    throw new ConfigurationError(`hooks: expected an array at ${where} in ${path}`, {\n      code: \"hooks_json_invalid\",\n    });\n  }\n  return value;\n}\n\n/**\n * Parse Claude Code's nested hooks config into the SDK's flat internal shape:\n * `{ hooks: { PreToolUse: [{ matcher?, hooks: [{ type:\"command\", command, timeout? }] }] } }`\n * → `{ hooks: { preToolUse: [{ command, matcher?, timeoutMs? }] } }`. Each group's\n * `matcher` applies to every command it wraps; `timeout` (seconds) → `timeoutMs`.\n */\nfunction parseClaudeCodeConfig(raw: unknown, path: string): HookConfig {\n  const root = asRecord(raw, path, \"the root\");\n  if (root.hooks === undefined) return {};\n  const hooksRec = asRecord(root.hooks, path, `\"hooks\"`);\n  const grouped: Partial<Record<HookEvent, HookCommand[]>> = {};\n\n  for (const [ccEvent, groups] of Object.entries(hooksRec)) {\n    const event = CLAUDE_CODE_EVENT_MAP[ccEvent];\n    if (event === undefined) {\n      warnOnce(\n        `hooks-event-${ccEvent}`,\n        `[theokit-sdk] hooks: event \"${ccEvent}\" is not fired by the SDK runtime (supported: ${Object.keys(CLAUDE_CODE_EVENT_MAP).join(\", \")}) — skipping`,\n      );\n      continue;\n    }\n    grouped[event] = [...(grouped[event] ?? []), ...flattenEventGroups(groups, path, ccEvent)];\n  }\n  return { hooks: grouped };\n}\n\n/** Flatten one Claude Code event's matcher-groups into internal HookCommands. */\nfunction flattenEventGroups(groups: unknown, path: string, ccEvent: string): HookCommand[] {\n  const commands: HookCommand[] = [];\n  for (const rawGroup of asArray(groups, path, `hooks.${ccEvent}`)) {\n    const group = asRecord(rawGroup, path, `hooks.${ccEvent}[]`);\n    const matcher = group.matcher === undefined ? undefined : String(group.matcher);\n    for (const rawCmd of asArray(group.hooks, path, `hooks.${ccEvent}[].hooks`)) {\n      commands.push(parseClaudeCodeCommand(rawCmd, matcher, path, ccEvent));\n    }\n  }\n  return commands;\n}\n\n/** One `{ type:\"command\", command, timeout? }` entry → an internal HookCommand. */\nfunction parseClaudeCodeCommand(\n  raw: unknown,\n  matcher: string | undefined,\n  path: string,\n  ccEvent: string,\n): HookCommand {\n  const cmd = asRecord(raw, path, `hooks.${ccEvent}[].hooks[]`);\n  if (cmd.type !== \"command\") {\n    throw new ConfigurationError(\n      `hooks: only { \"type\": \"command\" } is supported (got ${JSON.stringify(cmd.type)}) in ${path}`,\n      { code: \"hooks_unsupported_type\" },\n    );\n  }\n  if (typeof cmd.command !== \"string\" || cmd.command.length === 0) {\n    throw new ConfigurationError(`hooks: \"command\" must be a non-empty string in ${path}`, {\n      code: \"hooks_invalid_command\",\n    });\n  }\n  const hc: HookCommand = { command: cmd.command };\n  if (matcher !== undefined) hc.matcher = matcher;\n  if (typeof cmd.timeout === \"number\" && cmd.timeout > 0) {\n    hc.timeoutMs = Math.round(cmd.timeout * 1000);\n  }\n  return hc;\n}\n","/**\n * Personality fork-context (ADR D168 + EC-A snapshot semantic).\n *\n * Uses Node's `AsyncLocalStorage` so a fork's execution chain can know\n * that it is running inside a fork AND can see the slug that was active\n * on the parent **at fork-construction time**.\n *\n * **EC-A:** The slug stored here is captured ONCE at the wrap site\n * (`localAgentFork`) — passing `parentStore.active(parentAgentId)`\n * returns a primitive `string | undefined`, which is then frozen\n * inside the ALS context object. Subsequent `usePersonality` calls on\n * the parent do NOT mutate the fork's view, because the fork reads from\n * its own ALS frame, not from the parent's store.\n *\n * @internal\n */\n\nimport { AsyncLocalStorage } from \"node:async_hooks\";\n\nimport { warnOnce } from \"../runtime/hooks/hooks-source.js\";\n\n/**\n * Snapshot data carried into a fork's async context.\n *\n * @internal\n */\nexport interface PersonalityForkContext {\n  /** Parent's active personality slug at fork-construction time. */\n  readonly slug: string | undefined;\n  /** Always `true` inside this scope (used by guards). */\n  readonly isFork: true;\n}\n\nconst storage = new AsyncLocalStorage<PersonalityForkContext>();\n\n/**\n * Run `fn` with `ctx` bound as the active fork context. Nested calls\n * shadow the outer context (EC-22).\n *\n * @internal\n */\nexport function withPersonalityContext<T>(\n  ctx: PersonalityForkContext,\n  fn: () => Promise<T>,\n): Promise<T> {\n  return storage.run(ctx, fn);\n}\n\n/**\n * Return the active fork context, or `undefined` when called outside a\n * fork scope.\n *\n * @internal\n */\nexport function currentPersonalityContext(): PersonalityForkContext | undefined {\n  return storage.getStore();\n}\n\n/**\n * Emit one warning per agentId stating that personality switches inside\n * a fork are no-ops. The fork inherits the parent snapshot — runtime\n * mutation is intentionally rejected to keep fork voice deterministic.\n *\n * @internal\n */\nexport function warnPersonalitySwitchInsideFork(agentId: string): void {\n  warnOnce(\n    `personality-switch-in-fork-${agentId}`,\n    `[theokit-sdk] usePersonality is a no-op inside a fork (D168). Subagents inherit the parent's active personality at fork-construction time.`,\n  );\n}\n"]}

package/dist/chunk-O7DK5PBJ.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/internal/llm/credential-pool-types.ts","../src/internal/llm/retry.ts","../src/internal/llm/credential-pool.ts","../src/internal/llm/credential-pool-context.ts"],"names":["ConfigurationError","withCwdMutex","picked","AsyncLocalStorage"],"mappings":"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","file":"chunk-O7DK5PBJ.cjs","sourcesContent":["/**\n * Types for the credential pool subsystem (ADRs D123-D133).\n *\n * Pool a developer's multiple API keys for the SAME provider so the SDK\n * can rotate transparently on HTTP 429/402/401 instead of jumping\n * straight to a different provider via `FallbackLlmClient`.\n *\n * @internal\n */\n\n/**\n * Rotation strategy when picking the next credential from a pool.\n *\n * - `fill_first` (default): use entries[0] until exhausted, then [1]…\n * - `round_robin`: rotate after each `select()`\n * - `least_used`: pick the entry with the lowest `requestCount`\n * - `random`: random pick among healthy entries\n *\n * Closed enum per ADR D124 — adding a strategy is an explicit semver\n * minor that updates `selectByStrategy` exhaustively.\n *\n * @internal\n */\nexport type CredentialPoolStrategy = \"fill_first\" | \"round_robin\" | \"least_used\" | \"random\";\n\n/** Health flag tracked per credential. */\nexport type CredentialStatus = \"ok\" | \"exhausted\";\n\n/**\n * Provenance of a credential — where it came from when seeded.\n * Free-form string; conventional prefixes:\n *\n * - `env:<VAR_NAME>` — auto-discovered from environment variable\n * - `manual` — added via explicit `apiKeys` config\n * - `explicit-apikey` — wrapped from `AgentOptions.apiKey` single-key path (D132)\n */\nexport type CredentialSource = string;\n\n/**\n * Single credential entry inside a {@link CredentialPool}.\n *\n * `accessToken` is the sensitive field — must never be logged unredacted.\n * The lint gate `tests/lint/no-unredacted-pool-token.test.ts` enforces this.\n *\n * @internal\n */\nexport interface PooledCredential {\n  /** Stable identifier (uuid v4) for log lines + telemetry. */\n  id: string;\n  /** Human-readable label for `Theokit.credentialPool.list()`. */\n  label: string;\n  /** Provider name (matches `ProviderProfile.name`). */\n  provider: string;\n  /** Sort key; lower = earlier in fill_first. Unique within a pool. */\n  priority: number;\n  /** Provenance string. */\n  source: CredentialSource;\n  /** Sensitive API key. NEVER LOG UNREDACTED. */\n  accessToken: string;\n  /** Current health. */\n  lastStatus: CredentialStatus;\n  /** Epoch ms of the last status change. */\n  lastStatusAt: number | undefined;\n  /** HTTP code that caused exhaustion (401/402/429). */\n  lastErrorCode: number | undefined;\n  /** Provider-supplied \"retry after this epoch ms\" hint. Overrides cooldown defaults. */\n  lastErrorResetAt: number | undefined;\n  /** Bumped per successful `select()` for `least_used` strategy. Lazy-persisted. */\n  requestCount: number;\n}\n\n/**\n * Serializable snapshot of a single provider's pool. Used by the\n * persistence layer (T2.1) to read/write `~/.theokit/credential-pool.json`.\n *\n * @internal\n */\nexport interface CredentialPoolSnapshot {\n  provider: string;\n  strategy: CredentialPoolStrategy;\n  entries: PooledCredential[];\n}\n\n/**\n * Cooldown ladder by HTTP error code (ADR D125). Provider-supplied\n * `lastErrorResetAt` overrides these defaults when present.\n *\n * @internal\n */\nexport const COOLDOWN_MS: Readonly<Record<number, number>> = {\n  401: 5 * 60 * 1000, // 5 minutes — OAuth refresh can recover quickly\n  402: 60 * 60 * 1000, // 1 hour — billing quota typically hourly+\n  429: 60 * 60 * 1000, // 1 hour — daily-rate-limit windows\n};\n\n/** Default cooldown when no specific code matches. */\nexport const DEFAULT_COOLDOWN_MS = 60 * 60 * 1000;\n","/**\n * T3.4 — exponential backoff with full jitter for credential-pool retry.\n *\n * Why we need this: pre-T3.4 `pool-aware-client.ts:79-83` retried the\n * SAME credential immediately on the first 429 without any wait. When\n * every credential in the pool returned 429 (thundering herd against a\n * shared quota), the client burned through all 5 retry attempts in <1ms,\n * tripped `CredentialPoolExhaustedError`, and surfaced to the agent loop\n * as a hard failure. The user-visible symptom was \"all my keys are\n * exhausted!\" when in reality a 1-2s wait would have cleared the rate\n * limit.\n *\n * AWS Architecture Blog \"Exponential Backoff And Jitter\" (Marc Brooker,\n * 2015) demonstrates full jitter as the canonical pattern: `sleep =\n * random_between(0, base * 2^attempt)`. We extend it with a hard cap\n * (so a 32s sleep never blocks an interactive agent) and honor the\n * provider's `Retry-After` hint when present — the hint always wins over\n * the computed value when it falls within `[base, cap]`.\n *\n * @internal\n */\n\nexport interface BackoffOptions {\n  /** 0-indexed retry attempt number. */\n  attempt: number;\n  /** Base delay in ms (multiplier for 2^attempt). Default 500. */\n  baseMs?: number;\n  /** Hard cap in ms — backoff never sleeps longer than this. Default 32_000. */\n  capMs?: number;\n  /** Provider's Retry-After hint in ms (from header). Takes precedence when in-range. */\n  retryAfterMs?: number;\n  /** Random source — pass a deterministic mock from tests. Default `Math.random`. */\n  rng?: () => number;\n}\n\nconst DEFAULT_BASE_MS = 500;\nconst DEFAULT_CAP_MS = 32_000;\n\n/**\n * Compute the next sleep duration (ms) before retrying a failed request.\n *\n * Algorithm:\n * 1. If `retryAfterMs` is set, prefer it — clamped to `[baseMs, capMs]`.\n *    The provider's hint is the most accurate available signal.\n * 2. Otherwise: `sleep = random(0, min(cap, base * 2^attempt))` — full\n *    jitter per Brooker 2015 ensures coordinated clients (each with\n *    different RNG seeds) spread the retry storm.\n *\n * @internal\n */\nexport function computeBackoffMs(opts: BackoffOptions): number {\n  const base = opts.baseMs ?? DEFAULT_BASE_MS;\n  const cap = opts.capMs ?? DEFAULT_CAP_MS;\n  const rng = opts.rng ?? Math.random;\n  if (opts.retryAfterMs !== undefined && opts.retryAfterMs >= 0) {\n    return Math.max(base, Math.min(cap, opts.retryAfterMs));\n  }\n  const ceiling = Math.min(cap, base * 2 ** opts.attempt);\n  return Math.floor(rng() * ceiling);\n}\n\n/**\n * `setTimeout`-based sleep that resolves early when the abort signal fires.\n * Resolves cleanly (does not throw on abort) so callers decide how to\n * react to the abort downstream.\n *\n * @internal\n */\nexport function sleepWithAbort(ms: number, signal: AbortSignal): Promise<void> {\n  if (ms <= 0 || signal.aborted) return Promise.resolve();\n  return new Promise<void>((resolve) => {\n    const timer = setTimeout(() => {\n      signal.removeEventListener(\"abort\", onAbort);\n      resolve();\n    }, ms);\n    const onAbort = (): void => {\n      clearTimeout(timer);\n      resolve();\n    };\n    signal.addEventListener(\"abort\", onAbort, { once: true });\n  });\n}\n","/**\n * In-memory credential pool with strategy-based rotation (ADRs D123-D133).\n *\n * Pure logic. No I/O — persistence lives in `internal/persistence/\n * credential-pool-store.ts`. The pool is the single source of truth for\n * rotation state within a process; if it diverges from disk (e.g.,\n * process killed mid-rotation per EC-I), the next save heals the\n * inconsistency — at the cost of one extra HTTP 429 per crash.\n *\n * Thread safety: the pool uses an in-process async-aware mutex\n * (`cwd-mutex` D9 keyed by `credential-pool:${provider}`). Cross-process\n * safety happens at the persistence layer via `withFileLock` (D61).\n * Two Node processes sharing the same file may double-pick momentarily\n * (worst case = 1 extra 429 per race) — acceptable per ADR D128.\n *\n * @internal\n */\n\nimport { ConfigurationError } from \"../../errors.js\";\nimport { withCwdMutex } from \"../persistence/cwd-mutex.js\";\nimport {\n  COOLDOWN_MS,\n  type CredentialPoolSnapshot,\n  type CredentialPoolStrategy,\n  DEFAULT_COOLDOWN_MS,\n  type PooledCredential,\n} from \"./credential-pool-types.js\";\nimport { sleepWithAbort } from \"./retry.js\";\n\n/**\n * Construct a `PooledCredential` with sane defaults.\n *\n * @internal\n */\nexport function newPooledCredential(args: {\n  provider: string;\n  accessToken: string;\n  priority: number;\n  source: string;\n  label?: string;\n}): PooledCredential {\n  return {\n    id: globalThis.crypto.randomUUID(),\n    label: args.label ?? labelFromSource(args.source, args.accessToken),\n    provider: args.provider,\n    priority: args.priority,\n    source: args.source,\n    accessToken: args.accessToken,\n    lastStatus: \"ok\",\n    lastStatusAt: undefined,\n    lastErrorCode: undefined,\n    lastErrorResetAt: undefined,\n    requestCount: 0,\n  };\n}\n\n/**\n * Build a human-readable label from the credential source. Used for\n * `Theokit.credentialPool.list()` UX. NEVER includes the raw token.\n *\n * @internal\n */\nfunction labelFromSource(source: string, accessToken: string): string {\n  if (source.startsWith(\"env:\")) return source.slice(4);\n  const masked =\n    accessToken.length > 8 ? `${accessToken.slice(0, 4)}…${accessToken.slice(-4)}` : \"***\";\n  return `${source}:${masked}`;\n}\n\n/**\n * Per-provider credential pool. Construct with one or more entries\n * sorted by priority. Throws `ConfigurationError` on empty input.\n *\n * EC-C: identical `accessToken`s are deduplicated during construction\n * (3 copies of \"k1\" → 1 entry). Otherwise an exhaustion event would\n * mark \"k1\" exhausted 3× wastefully.\n *\n * @internal\n */\nexport class CredentialPool {\n  readonly provider: string;\n  private readonly strategy: CredentialPoolStrategy;\n  private entries: PooledCredential[];\n\n  constructor(\n    provider: string,\n    entries: PooledCredential[],\n    strategy: CredentialPoolStrategy = \"fill_first\",\n  ) {\n    if (entries.length === 0) {\n      throw new ConfigurationError(\n        `credential-pool: cannot construct empty pool for provider \"${provider}\"`,\n        { code: \"credential_pool_empty\" },\n      );\n    }\n    this.provider = provider;\n    this.strategy = strategy;\n    // EC-C: dedupe by accessToken before sort.\n    this.entries = dedupeByToken(entries).sort((a, b) => a.priority - b.priority);\n  }\n\n  /** True if the pool was seeded with at least one entry. */\n  hasCredentials(): boolean {\n    return this.entries.length > 0;\n  }\n\n  /** True iff at least one entry is healthy (auto-healed if cooldown expired). */\n  hasAvailable(): boolean {\n    return this.availableEntries().length > 0;\n  }\n\n  /**\n   * Earliest `lastErrorResetAt` across all entries, or `undefined` if no\n   * entry is in cooldown. Used by `waitForAvailable` to compute the\n   * upper bound of each jittered sleep window.\n   *\n   * @internal\n   */\n  earliestResetAt(): number | undefined {\n    let earliest: number | undefined;\n    for (const entry of this.entries) {\n      if (entry.lastStatus === \"ok\") continue;\n      if (entry.lastErrorResetAt === undefined) continue;\n      if (earliest === undefined || entry.lastErrorResetAt < earliest) {\n        earliest = entry.lastErrorResetAt;\n      }\n    }\n    return earliest;\n  }\n\n  /**\n   * Wait until at least one entry becomes healthy OR `maxWaitMs` elapses\n   * OR `signal` aborts. Returns `true` if a healthy entry is available\n   * when the call returns, `false` otherwise.\n   *\n   * T3.9 — Reconnect storm prevention. Concurrent callers each sleep a\n   * random fraction of the window to the earliest cooldown reset (full\n   * jitter — AWS Brooker 2015) so they do not all wake at the exact\n   * instant cooldown expires and hammer the upstream simultaneously.\n   *\n   * The `sleeper` parameter is a dependency-injection seam for tests:\n   * callers in production omit it and the default `setTimeout`-based\n   * sleeper is used. The seam avoids the `vi.useFakeTimers()` mismatch\n   * that blocked T3.4's wiring.\n   *\n   * @internal\n   */\n  async waitForAvailable(\n    signal: AbortSignal,\n    opts: {\n      maxWaitMs: number;\n      sleeper?: (ms: number, signal: AbortSignal) => Promise<void>;\n    },\n  ): Promise<boolean> {\n    if (signal.aborted) return false;\n    if (this.hasAvailable()) return true;\n    const sleeper = opts.sleeper ?? sleepWithAbort;\n    const deadline = Date.now() + opts.maxWaitMs;\n    while (Date.now() < deadline) {\n      if (signal.aborted) return false;\n      const jittered = this.computeJitteredSleepMs(deadline);\n      await sleeper(jittered, signal);\n      if (signal.aborted) return false;\n      if (this.hasAvailable()) return true;\n    }\n    return this.hasAvailable();\n  }\n\n  /**\n   * Compute the next jittered sleep window (ms) for `waitForAvailable`.\n   * Full-jitter cap: at most (a) time until the earliest reset (plus a\n   * 50 ms grace so the entry actually heals before re-probe), or (b) the\n   * remaining wait window, whichever is smaller. When no entry has a\n   * known reset (rare — only if `markExhaustedAndRotate` was called\n   * without `resetAtMs`), fall back to a 250 ms ceiling so we stay\n   * responsive without hot-looping.\n   */\n  private computeJitteredSleepMs(deadline: number): number {\n    const resetAt = this.earliestResetAt();\n    const remaining = deadline - Date.now();\n    const ceiling =\n      resetAt === undefined\n        ? Math.min(remaining, 250)\n        : Math.min(remaining, Math.max(0, resetAt - Date.now()) + 50);\n    return Math.max(0, Math.floor(Math.random() * ceiling));\n  }\n\n  /** Live (frozen) view of all entries. */\n  list(): readonly PooledCredential[] {\n    return this.entries;\n  }\n\n  /**\n   * Pick a healthy entry according to the configured strategy.\n   * Mutates `requestCount` and (for round_robin) entry order.\n   * Returns null if every entry is in cooldown.\n   *\n   * @internal\n   */\n  async select(): Promise<PooledCredential | null> {\n    return withCwdMutex(`credential-pool:${this.provider}`, async () => this.selectLocked());\n  }\n\n  /**\n   * Mark the entry whose id matches `entryId` as exhausted with the\n   * appropriate cooldown, then return the next healthy entry (or null).\n   * If `entryId` is undefined, marks all currently-active entries (rare —\n   * only used by admin reset scenarios).\n   *\n   * @internal\n   */\n  async markExhaustedAndRotate(args: {\n    entryId: string;\n    statusCode: number;\n    resetAtMs?: number;\n  }): Promise<PooledCredential | null> {\n    return withCwdMutex(`credential-pool:${this.provider}`, async () => {\n      const entry = this.entries.find((e) => e.id === args.entryId);\n      if (entry !== undefined) {\n        const now = Date.now();\n        const cooldown = COOLDOWN_MS[args.statusCode] ?? DEFAULT_COOLDOWN_MS;\n        entry.lastStatus = \"exhausted\";\n        entry.lastStatusAt = now;\n        entry.lastErrorCode = args.statusCode;\n        // EC-5: negative or stale resetAt → ignore, fall through to default.\n        entry.lastErrorResetAt =\n          args.resetAtMs !== undefined && args.resetAtMs > now ? args.resetAtMs : now + cooldown;\n      }\n      return this.selectLocked();\n    });\n  }\n\n  /** Admin escape hatch: clear all cooldowns. */\n  async resetAll(): Promise<void> {\n    await withCwdMutex(`credential-pool:${this.provider}`, async () => {\n      for (const e of this.entries) {\n        e.lastStatus = \"ok\";\n        e.lastStatusAt = undefined;\n        e.lastErrorCode = undefined;\n        e.lastErrorResetAt = undefined;\n      }\n    });\n  }\n\n  /** Materialize for persistence. */\n  toSnapshot(): CredentialPoolSnapshot {\n    return {\n      provider: this.provider,\n      strategy: this.strategy,\n      entries: this.entries.map((e) => ({ ...e })),\n    };\n  }\n\n  /** Hydrate from a previously-saved snapshot. */\n  static fromSnapshot(snapshot: CredentialPoolSnapshot): CredentialPool {\n    return new CredentialPool(snapshot.provider, snapshot.entries, snapshot.strategy);\n  }\n\n  // ─── Internal helpers (always called inside the mutex) ───\n\n  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: strategy dispatch must branch on 4 enum values (random/least_used/round_robin/fill_first) with 1-entry short-circuits per strategy. Each branch is 5-10 lines of focused logic; extracting per-strategy methods fragments the linear narrative.\n  private selectLocked(): PooledCredential | null {\n    const available = this.availableEntries();\n    if (available.length === 0) return null;\n\n    if (this.strategy === \"random\") {\n      const idx = Math.floor(Math.random() * available.length);\n      const picked = available[idx];\n      if (picked === undefined) return null; // unreachable; satisfies strict\n      picked.requestCount += 1;\n      return picked;\n    }\n\n    if (this.strategy === \"least_used\" && available.length > 1) {\n      // EC-3: tie-break by priority ascending (first wins).\n      const picked = [...available].sort(\n        (a, b) => a.requestCount - b.requestCount || a.priority - b.priority,\n      )[0];\n      if (picked === undefined) return null;\n      picked.requestCount += 1;\n      return picked;\n    }\n\n    if (this.strategy === \"round_robin\" && available.length > 1) {\n      // Pick head; move it to the end of `entries` so next call picks the next.\n      const picked = available[0];\n      if (picked === undefined) return null;\n      picked.requestCount += 1;\n      const rest = this.entries.filter((e) => e.id !== picked.id);\n      // Re-assign priorities: rotated entry gets the highest priority value\n      // so it sorts last after `fromSnapshot` rehydration. This makes EC-F\n      // (round-robin state survives save/load) work without a separate field.\n      const maxPriority = this.entries.length - 1;\n      rest.forEach((e, i) => {\n        e.priority = i;\n      });\n      picked.priority = maxPriority;\n      this.entries = [...rest, picked];\n      return picked;\n    }\n\n    // fill_first (default) and 1-entry edge case for round_robin/least_used\n    const picked = available[0];\n    if (picked === undefined) return null;\n    picked.requestCount += 1;\n    return picked;\n  }\n\n  private availableEntries(): PooledCredential[] {\n    const now = Date.now();\n    const out: PooledCredential[] = [];\n    for (const entry of this.entries) {\n      if (entry.lastStatus === \"ok\") {\n        out.push(entry);\n        continue;\n      }\n      // EC-1: auto-heal expired cooldowns inline.\n      const resetAt = entry.lastErrorResetAt;\n      if (resetAt !== undefined && now >= resetAt) {\n        entry.lastStatus = \"ok\";\n        entry.lastStatusAt = undefined;\n        entry.lastErrorCode = undefined;\n        entry.lastErrorResetAt = undefined;\n        out.push(entry);\n      }\n    }\n    return out;\n  }\n}\n\n/**\n * Drop duplicates by `accessToken`. Keeps the first occurrence (lowest\n * priority wins after sort). EC-C from the edge-case review.\n */\nfunction dedupeByToken(entries: PooledCredential[]): PooledCredential[] {\n  const seen = new Set<string>();\n  const out: PooledCredential[] = [];\n  for (const e of entries) {\n    if (seen.has(e.accessToken)) continue;\n    seen.add(e.accessToken);\n    out.push(e);\n  }\n  return out;\n}\n","/**\n * Per-fork credential-pool inheritance via `AsyncLocalStorage` (ADR D131).\n *\n * Mirrors the whitelist context pattern from D111\n * (`runtime/async-local-storage.ts`). Forked sub-agents inherit the\n * parent's pool *by reference* so concurrent rotations all observe\n * the same cooldown state — the desired behavior per Hermes parity.\n *\n * @internal\n */\n\nimport { AsyncLocalStorage } from \"node:async_hooks\";\n\nimport type { CredentialPool } from \"./credential-pool.js\";\n\n/** ALS slot — keyed by provider name → pool. */\nconst credentialPoolStore = new AsyncLocalStorage<Map<string, CredentialPool>>();\n\n/**\n * Run `fn` with `pools` as the active credential-pool registry for the\n * current async context. Nested calls shadow the outer map (parent\n * pools are not visible to children when the child sets its own).\n *\n * @internal\n */\nexport async function withCredentialPool<T>(\n  pools: Map<string, CredentialPool>,\n  fn: () => Promise<T>,\n): Promise<T> {\n  return credentialPoolStore.run(pools, fn);\n}\n\n/**\n * Pool registered for `provider` in the current async context, or\n * `undefined` when no `withCredentialPool(...)` scope is active.\n *\n * @internal\n */\nexport function currentCredentialPool(provider: string): CredentialPool | undefined {\n  return credentialPoolStore.getStore()?.get(provider);\n}\n"]}

package/dist/chunk-O7LZFG6O.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/internal/session/agent-session-store.ts"],"names":["SessionTranscript","reconstructMessages"],"mappings":"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","file":"chunk-O7LZFG6O.cjs","sourcesContent":["/**\n * SE40 — native session store over the Claude-shaped `.jsonl` transcript.\n *\n * The theokit session format IS the Claude Code record shape (see\n * `../../persistence/session-transcript.ts`). This module owns the FS lifecycle:\n * read existing records, seed a {@link SessionTranscript}'s parent chain, append\n * the new turn (user + assistant/tool blocks), and write append-only. Compaction\n * appends a `compact_boundary` record (a new root) — it NEVER shrinks the line\n * set (that would break the DAG). Reads reconstruct `LlmMessage[]` via\n * {@link reconstructMessages}, narrowed to the in-memory {@link SessionMessage}.\n *\n * @internal\n */\n\nimport type { ToolResultContentBlock } from \"../../types/content-blocks.js\";\nimport type { ConversationStep, ConversationTurn } from \"../../types/conversation.js\";\nimport type { SessionStore } from \"../../types/session-store.js\";\nimport {\n  type AssistantTurn,\n  reconstructMessages,\n  type SessionRecord,\n  SessionTranscript,\n} from \"../persistence/session-transcript.js\";\nimport type { SessionMessage, SessionMessagePart } from \"./session-types.js\";\n\n/**\n * Seed a {@link SessionTranscript} from the already-on-disk records so a new\n * append parents correctly on the existing DAG leaf. The transcript re-emits the\n * seeded records verbatim before the new turn, so the whole file rewrites atomically\n * as one append-only line set. Returns the transcript primed with the prior records.\n */\nfunction seedTranscript(\n  prior: readonly SessionRecord[],\n  opts: { cwd: string; sessionId: string; model: string },\n): SessionTranscript {\n  return SessionTranscript.fromRecords(prior, opts);\n}\n\n/** The turn to persist: the user's text plus the rich per-turn conversation view. */\nexport interface PersistTurnInput {\n  userText: string;\n  conversation: readonly ConversationTurn[];\n  /**\n   * M50 — when supplied, size-driven auto-compaction runs in the SAME write chain after the turn\n   * persists (usage real vs the model's context window; summarizer injected by the caller).\n   */\n  autoCompact?: {\n    usageTotal?: number | undefined;\n    contextWindow?: number | undefined;\n    summarize: (\n      messages: readonly import(\"../../compaction.js\").CompressibleMessage[],\n    ) => Promise<string>;\n  };\n}\n\ninterface MappedTurn {\n  assistant: AssistantTurn;\n  toolResults: Array<{ toolUseId: string; content: string; isError?: boolean }>;\n}\n\n/**\n * theokit#122 — record the turn's thinking block, signature included.\n *\n * The signature is what makes the block replayable: without it the resumed turn is rejected by\n * Anthropic with `400 \"thinking blocks cannot be modified\"`.\n */\nfunction applyThinkingStep(\n  assistant: AssistantTurn,\n  message: { text: string; signature?: string },\n): void {\n  assistant.thinking = message.text;\n  if (message.signature !== undefined) assistant.thinkingSignature = message.signature;\n}\n\n/** Fold one agent turn's steps into an assistant record + paired tool results. */\nfunction mapAgentTurn(steps: readonly ConversationStep[]): MappedTurn {\n  const assistant: AssistantTurn = {};\n  const toolResults: MappedTurn[\"toolResults\"] = [];\n  const toolCalls: NonNullable<AssistantTurn[\"toolCalls\"]> = [];\n  for (const step of steps) {\n    if (step.type === \"thinkingMessage\") applyThinkingStep(assistant, step.message);\n    else if (step.type === \"assistantMessage\") assistant.text = step.message.text;\n    else if (step.type === \"toolCall\")\n      toolCalls.push({\n        id: step.message.callId,\n        name: step.message.name,\n        input: (step.message.args as Record<string, unknown> | undefined) ?? {},\n      });\n    else\n      toolResults.push({\n        toolUseId: step.message.callId,\n        content: step.message.result,\n        isError: step.message.isError,\n      });\n  }\n  if (toolCalls.length > 0) assistant.toolCalls = toolCalls;\n  return { assistant, toolResults };\n}\n\n/** True when the assistant record carries any content worth emitting. */\nfunction hasAssistantContent(a: AssistantTurn): boolean {\n  return a.text !== undefined || a.thinking !== undefined || (a.toolCalls?.length ?? 0) > 0;\n}\n\n/**\n * Map the rich `ConversationTurn[]` (from `run.conversation()`) into the native\n * assistant/tool records. One transcript turn is: an `assistant` record carrying\n * thinking + text + tool_use blocks, then (when present) a `user` record carrying\n * the paired tool_result blocks. Tool results pair with tool_use by `callId`.\n */\nfunction appendConversation(\n  transcript: SessionTranscript,\n  conversation: readonly ConversationTurn[],\n): void {\n  for (const ct of conversation) {\n    if (ct.type !== \"agentConversationTurn\") continue;\n    const { assistant, toolResults } = mapAgentTurn(ct.turn.steps);\n    if (hasAssistantContent(assistant)) transcript.appendAssistantTurn(assistant);\n    if (toolResults.length > 0) transcript.appendToolResults(toolResults);\n  }\n}\n\n/**\n * The per-agent transcript metadata used to seed a {@link SessionTranscript}. The\n * actual record I/O goes through the injected {@link SessionStore} (SE41), so this\n * no longer carries a `baseDir` — the store is already bound to its location.\n */\nexport interface TranscriptLocation {\n  cwd: string;\n  agentId: string;\n  model: string;\n}\n\n/**\n * Read the session's records via the {@link SessionStore} and reconstruct the\n * resumable history, narrowed to the in-memory {@link SessionMessage} shape\n * (user/assistant text). Tool turns fold into assistant-role context so resume\n * keeps tool history. Works identically for the FS default and an external store.\n */\nexport async function readSessionMessages(\n  store: SessionStore,\n  agentId: string,\n): Promise<SessionMessage[]> {\n  const records = await store.readRecords(agentId);\n  return reconstructMessages(records).map(narrowToSessionMessage);\n}\n\ntype NarrowPart = {\n  type: string;\n  text?: string;\n  content?: unknown;\n  name?: string;\n  id?: string;\n  toolUseId?: string;\n  input?: unknown;\n  isError?: boolean;\n};\n\n/** Render one reconstructed content part as folded session text. */\nfunction partToText(p: NarrowPart): string {\n  if (p.type === \"text\") return p.text ?? \"\";\n  if (p.type === \"tool_use\") return `[tool call] ${p.name ?? \"\"}`;\n  if (p.type === \"tool_result\") {\n    const body = typeof p.content === \"string\" ? p.content : JSON.stringify(p.content);\n    return `[tool result] ${body}`;\n  }\n  return \"\";\n}\n\n/**\n * theokit#146 — the same part, kept as STRUCTURE.\n *\n * `partToText` above is what the model replay wants; a host rendering tool cards needs the call id,\n * the tool name and the arguments, none of which survive `[tool call] NAME`. Both projections are\n * produced from the one reconstructed part, so they cannot drift apart.\n *\n * Returns `undefined` for a part with no display meaning (e.g. an image placeholder the session\n * projection does not model), which the caller filters out.\n */\nfunction partToStructured(p: NarrowPart): SessionMessagePart | undefined {\n  if (p.type === \"text\") return { type: \"text\", text: p.text ?? \"\" };\n  if (p.type === \"tool_use\") {\n    return {\n      type: \"tool_use\",\n      id: p.id ?? \"\",\n      name: p.name ?? \"\",\n      input: (p.input ?? {}) as Record<string, unknown>,\n    };\n  }\n  if (p.type === \"tool_result\") {\n    return {\n      type: \"tool_result\",\n      toolUseId: p.toolUseId ?? \"\",\n      // Reconstructed tool results carry either a string or the SE7 content blocks; both are\n      // already the session shape, so this narrows `unknown` rather than converting anything.\n      content: p.content as string | ReadonlyArray<ToolResultContentBlock>,\n      ...(p.isError === true ? { isError: true } : {}),\n    };\n  }\n  return undefined;\n}\n\n/** Flatten a reconstructed `LlmMessage` to the narrowed in-memory `SessionMessage`. */\nfunction narrowToSessionMessage(m: {\n  role: \"system\" | \"user\" | \"assistant\";\n  content: NarrowPart[];\n}): SessionMessage {\n  const role = m.role === \"user\" ? \"user\" : \"assistant\";\n  const text = m.content\n    .map(partToText)\n    .filter((s) => s.length > 0)\n    .join(\"\\n\");\n  const parts = m.content\n    .map(partToStructured)\n    .filter((p): p is SessionMessagePart => p !== undefined);\n  return { role, text, parts };\n}\n\n/** The records appended by the last turn (the delta beyond the seeded prior). */\nfunction deltaRecords(\n  transcript: SessionTranscript,\n  priorLength: number,\n): readonly SessionRecord[] {\n  return transcript.records().slice(priorLength);\n}\n\n/**\n * Persist one conversation turn (user + assistant/tool records) to the session\n * store, append-only. Reads the prior records to seed the parent chain, folds the\n * new turn, and appends ONLY the delta via {@link SessionStore.appendRecords}\n * (the store owns the append atomicity — the FS default serializes under a file\n * lock). Within one process, turns for an agent are already chained upstream, so\n * the read→append is ordered; cross-host ordering is the external store's contract.\n */\nexport async function persistTurn(\n  store: SessionStore,\n  loc: TranscriptLocation,\n  sessionId: string,\n  turn: PersistTurnInput,\n): Promise<void> {\n  const prior = await store.readRecords(loc.agentId);\n  const transcript = seedTranscript(prior, { cwd: loc.cwd, sessionId, model: loc.model });\n  transcript.appendUserTurn(turn.userText);\n  appendConversation(transcript, turn.conversation);\n  await store.appendRecords(loc.agentId, deltaRecords(transcript, prior.length));\n}\n\n/**\n * Append-only compaction: add a `compact_boundary` system record (a new root) so\n * resume replays only the post-boundary continuation. Appends only the boundary\n * record via the store — NEVER rewrites or shrinks the prior records.\n */\nexport async function appendCompactBoundaryRecord(\n  store: SessionStore,\n  loc: TranscriptLocation,\n  sessionId: string,\n  meta: { preTokens: number; trigger: string },\n): Promise<void> {\n  const prior = await store.readRecords(loc.agentId);\n  const transcript = seedTranscript(prior, { cwd: loc.cwd, sessionId, model: loc.model });\n  transcript.appendCompactBoundary(meta);\n  await store.appendRecords(loc.agentId, deltaRecords(transcript, prior.length));\n}\n"]}

package/dist/chunk-OFRFZRQ4.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/internal/memory/dreaming/diary.ts","../src/internal/memory/migrate-sqlite-to-lance.ts"],"names":["join","readFile","replaceFileAtomic","createHash","defaultIndexPath","existsSync","openMemoryDb","resolveMemoryRoot","lanceStoragePath","redactSecrets","ConfigurationError","rmSync","mkdirSync","LanceIndex","renameSync"],"mappings":"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","file":"chunk-OFRFZRQ4.cjs","sourcesContent":["import { createHash } from \"node:crypto\";\nimport { readFile } from \"node:fs/promises\";\nimport { join } from \"node:path\";\nimport { replaceFileAtomic } from \"../../persistence/atomic-write.js\";\nimport type { MemoryRoot } from \"../storage/memory-root.js\";\n\n/**\n * Dream-diary append (ADR D7).\n *\n * Diary lives at `.theokit/memory/dream-diary.md` and grows with one entry\n * per sweep. Each entry is content-hashed so the same input produces the\n * same entry — idempotency contract.\n *\n * Writes go through `replaceFileAtomic` (EC-3 of edge-case review) so a\n * crash mid-write can never leave a half-written diary.\n *\n * Shared with `@theokit/sdk-memory`; see the memory-store barrel.\n */\n\nexport interface DiaryEntry {\n  timestampMs: number;\n  factsBefore: number;\n  factsAfter: number;\n  duplicatesRemoved: number;\n  clustersCreated: number;\n  notesWritten: number;\n}\n\n/** `<memory root>/dream-diary.md`. Takes the RESOLVED ROOT — see `storage/memory-root.ts` (#463). */\nexport function diaryPath(root: MemoryRoot): string {\n  return join(root, \"dream-diary.md\");\n}\n\n/**\n * One diary entry as the markdown that gets appended: a timestamp heading, the short entry hash,\n * and the counts the sweep produced. The hash is what makes a re-run recognisable as the same\n * sweep rather than a new one.\n */\nexport function renderDiaryEntry(entry: DiaryEntry): string {\n  const stamp = new Date(entry.timestampMs).toISOString();\n  const hash = entryHash(entry).slice(0, 8);\n  return [\n    `## ${stamp}`,\n    \"\",\n    `- entry-hash: ${hash}`,\n    `- facts before: ${entry.factsBefore}`,\n    `- facts after: ${entry.factsAfter}`,\n    `- duplicates removed: ${entry.duplicatesRemoved}`,\n    `- clusters created: ${entry.clustersCreated}`,\n    `- notes written: ${entry.notesWritten}`,\n    \"\",\n  ].join(\"\\n\");\n}\n\n/**\n * Append one sweep's entry to `<memory root>/dream-diary.md`, creating the file with its header\n * when this is the first sweep. The diary is a human-readable record of what dreaming changed —\n * consolidations are otherwise invisible, because they alter the notes rather than announce\n * themselves.\n */\nexport async function appendDiaryEntry(root: MemoryRoot, entry: DiaryEntry): Promise<void> {\n  const path = diaryPath(root);\n  let raw = \"\";\n  try {\n    raw = await readFile(path, \"utf8\");\n  } catch {\n    raw = \"# Dream Diary\\n\\n\";\n  }\n  const next = `${raw.endsWith(\"\\n\") ? raw : `${raw}\\n`}${renderDiaryEntry(entry)}`;\n  await replaceFileAtomic(path, next);\n}\n\n/**\n * A stable hash of one entry's counts, so two sweeps that did the same work read as the same work.\n * Rendered truncated in the entry; the full value is what callers compare.\n */\nexport function entryHash(entry: DiaryEntry): string {\n  return createHash(\"sha256\")\n    .update(\n      [\n        entry.factsBefore,\n        entry.factsAfter,\n        entry.duplicatesRemoved,\n        entry.clustersCreated,\n        entry.notesWritten,\n      ].join(\"|\"),\n    )\n    .digest(\"hex\");\n}\n","import { existsSync, mkdirSync, renameSync, rmSync } from \"node:fs\";\nimport { join } from \"node:path\";\n\nimport { ConfigurationError } from \"../../errors.js\";\nimport { redactSecrets } from \"../security/index.js\";\nimport { defaultIndexPath, openMemoryDb } from \"./index-db.js\";\nimport { LanceIndex, lanceStoragePath } from \"./lance-index.js\";\nimport { type MemoryRoot, resolveMemoryRoot } from \"./storage/memory-root.js\";\n\n/**\n * Migrate Memory.index from SQLite to LanceDB (ADR D44).\n *\n * EC-3 MUST FIX: validation uses NFC unicode normalization on both sides.\n *\n * Shared with `@theokit/sdk-memory` through the memory-store barrel (#463).\n */\n\nexport interface MigrateOptions {\n  cwd: string;\n  /**\n   * Absolute path (or `~/`-prefixed) of the memory root to migrate, when the agent that wrote it\n   * set `memory.directory`. Defaults to `<cwd>/.theokit/memory` (#463).\n   */\n  directory?: string;\n  dryRun?: boolean;\n  batchSize?: number;\n  /** Inject for tests; defaults to console.log. */\n  logger?: (msg: string) => void;\n}\n\nexport interface MigrateResult {\n  countSqlite: number;\n  countLance: number;\n  /** Set when validation succeeded (or dryRun); false on validation failure. */\n  validated: boolean;\n  /** Per-fact compare results (size = sample count, up to 10). */\n  sampleComparisons: ReadonlyArray<{ id: string; match: boolean }>;\n  /** Lance storage location (final, after migration). */\n  lancePath: string;\n  /** Was the migration committed (false for dry-run). */\n  committed: boolean;\n}\n\n/**\n * One row of the SQLite memory index, as the Lance migration reads it: the chunk plus the tenant\n * columns the target table needs. Shared with `@theokit/sdk-memory`, which migrates the same table.\n */\nexport interface SqliteFactRow {\n  id: string;\n  path: string;\n  source: \"memory\" | \"sessions\" | \"wiki\";\n  start_line: number;\n  end_line: number;\n  text: string;\n  namespace?: string | null;\n  scope?: string | null;\n  user_id?: string | null;\n}\n\n/**\n * Read all facts from the SQLite memory index. Returns empty array if the\n * SQLite db file does not exist (workspace never used Memory).\n *\n * Shared with `@theokit/sdk-memory` through the memory-store barrel, so it carries no visibility\n * tag — naming that tag in this block would delete the function below it (#463).\n */\nexport async function readAllSqliteFacts(root: MemoryRoot): Promise<SqliteFactRow[]> {\n  const dbPath = defaultIndexPath(root);\n  if (!existsSync(dbPath)) return [];\n  const db = await openMemoryDb({ filePath: dbPath });\n  try {\n    // SQLite schema: chunks table holds the facts. Schema may vary; we\n    // probe column existence and fall back to safe defaults.\n    const stmt = db.prepare(\"SELECT id, path, source, start_line, end_line, text FROM chunks\");\n    const rows = stmt.all() as Array<{\n      id: string;\n      path: string;\n      source: \"memory\" | \"sessions\" | \"wiki\";\n      start_line: number;\n      end_line: number;\n      text: string;\n    }>;\n    return rows.map((r) => ({\n      ...r,\n      namespace: \"default\",\n      scope: \"agent\",\n      user_id: \"default\",\n    }));\n  } finally {\n    db.close();\n  }\n}\n\n/**\n * Compare two strings via NFC normalization (EC-3 MUST FIX). Required\n * because SQLite/Lance native bindings can normalize unicode differently\n * (NFC vs NFD), producing false negatives on facts with accents/emojis.\n *\n * @internal\n */\nfunction nfcEqual(a: string, b: string): boolean {\n  return a.normalize(\"NFC\") === b.normalize(\"NFC\");\n}\n\n/**\n * Run the migration. Writes Lance to `<cwd>/.theokit/memory/lance-new/`\n * first, validates round-trip, then renames to `lance/` on success.\n * SQLite db is preserved (CLI prompts user to delete).\n *\n * @internal\n */\n// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: migration is a single transaction (read → write → validate → commit-or-rollback); splitting harms atomicity reasoning.\nexport async function migrateSqliteToLance(opts: MigrateOptions): Promise<MigrateResult> {\n  const cwd = opts.cwd;\n  // One resolution, reused by every path this migration touches (#463).\n  const memoryRoot = resolveMemoryRoot(cwd, { directory: opts.directory });\n  const finalPath = lanceStoragePath(memoryRoot);\n  const newPath = join(memoryRoot, \"lance-new\");\n  // T1.4 (ADR D68): wrap logger so any fact text containing secrets is\n  // masked before reaching the destination (console or user-supplied sink).\n  // Caller-supplied loggers cannot bypass — by design (D70).\n  const rawLog = opts.logger ?? ((m: string) => console.log(m));\n  const log = (m: string) => rawLog(redactSecrets(m));\n\n  // EC: destination exists → typed error.\n  if (existsSync(finalPath)) {\n    throw new ConfigurationError(\n      `Destination already exists: ${finalPath}. Remove it manually (\\`rm -rf ${finalPath}\\`) and re-run.`,\n      { code: \"migration_destination_exists\" },\n    );\n  }\n  if (existsSync(newPath)) {\n    // Leftover from a previous failed/interrupted migration. Safe to delete.\n    log(`Removing stale ${newPath} from a previous run...`);\n    rmSync(newPath, { recursive: true, force: true });\n  }\n\n  log(`Reading SQLite facts from ${cwd}/.theokit/memory/index.sqlite ...`);\n  const sqliteFacts = await readAllSqliteFacts(memoryRoot);\n  log(`SQLite has ${sqliteFacts.length} facts.`);\n  if (sqliteFacts.length === 0) {\n    return {\n      countSqlite: 0,\n      countLance: 0,\n      validated: true,\n      sampleComparisons: [],\n      lancePath: finalPath,\n      committed: false,\n    };\n  }\n\n  // Reuse the embedding runtime configured in the workspace? For v1.2 we\n  // require the caller to pass embedding explicitly via env. The migration\n  // path is documented as: \"set OPENAI_API_KEY (or similar) before running.\"\n  // Here we ship a placeholder embedder that uses a deterministic\n  // content-hash — sufficient for migration validation; consumers should\n  // re-embed on first real query after migration if needed.\n  const placeholderEmbedding = {\n    id: \"migration-placeholder\",\n    model: \"deterministic-hash\",\n    dimension: 8,\n    embed: async (texts: ReadonlyArray<string>) => {\n      // Simple deterministic hash → 8-dim vector (migration validation only).\n      return texts.map((t) => {\n        const arr = new Array(8).fill(0);\n        for (let i = 0; i < t.length; i += 1) {\n          arr[i % 8] += t.charCodeAt(i);\n        }\n        return arr.map((x) => x / 1000);\n      });\n    },\n    stats: () => ({ cacheHits: 0, cacheMisses: 0, httpCalls: 0, retries: 0 }),\n  };\n\n  mkdirSync(newPath, { recursive: true });\n  log(`Writing Lance index to ${newPath} ...`);\n\n  const lance = await LanceIndex.open({\n    cwd,\n    embedding: placeholderEmbedding,\n    storagePath: newPath,\n  });\n\n  const batchSize = opts.batchSize ?? 100;\n  for (let i = 0; i < sqliteFacts.length; i += batchSize) {\n    const batch = sqliteFacts.slice(i, i + batchSize).map((f) => ({\n      id: f.id,\n      text: f.text,\n      source: f.source,\n      namespace: f.namespace ?? \"default\",\n      scope: f.scope ?? \"agent\",\n      user_id: f.user_id ?? \"default\",\n      timestamp: 0,\n    }));\n    await lance.addFacts(batch);\n    log(`  Migrated ${Math.min(i + batchSize, sqliteFacts.length)}/${sqliteFacts.length}`);\n  }\n\n  // Validation: count + sample compare (10 random) with NFC normalization.\n  const lanceCount = await lance.countFacts(\"default\");\n  log(`Lance has ${lanceCount} facts (expected ${sqliteFacts.length}).`);\n\n  const sampleSize = Math.min(10, sqliteFacts.length);\n  const sampleComparisons: { id: string; match: boolean }[] = [];\n  for (let i = 0; i < sampleSize; i += 1) {\n    const sqliteFact = sqliteFacts[Math.floor((i * sqliteFacts.length) / sampleSize)];\n    if (sqliteFact === undefined) continue;\n    // Search Lance for this fact's text — best-effort round-trip.\n    const hits = await lance.search(sqliteFact.text, {\n      namespace: sqliteFact.namespace ?? \"default\",\n      limit: 1,\n    });\n    // EC-3: compare with NFC normalization.\n    const hit = hits[0];\n    const match = hit !== undefined && nfcEqual(hit.text, sqliteFact.text);\n    sampleComparisons.push({ id: sqliteFact.id, match });\n  }\n\n  const allMatch = sampleComparisons.every((c) => c.match);\n  const countMatch = lanceCount === sqliteFacts.length;\n  const validated = allMatch && countMatch;\n\n  await lance.close();\n\n  if (opts.dryRun === true) {\n    log(\"Dry-run mode — discarding Lance staging dir.\");\n    rmSync(newPath, { recursive: true, force: true });\n    return {\n      countSqlite: sqliteFacts.length,\n      countLance: lanceCount,\n      validated,\n      sampleComparisons,\n      lancePath: finalPath,\n      committed: false,\n    };\n  }\n\n  if (!validated) {\n    log(\"Validation FAILED — leaving SQLite intact, removing Lance staging dir.\");\n    rmSync(newPath, { recursive: true, force: true });\n    return {\n      countSqlite: sqliteFacts.length,\n      countLance: lanceCount,\n      validated: false,\n      sampleComparisons,\n      lancePath: finalPath,\n      committed: false,\n    };\n  }\n\n  // Atomic commit via rename.\n  renameSync(newPath, finalPath);\n  log(`Migration committed to ${finalPath}.`);\n  return {\n    countSqlite: sqliteFacts.length,\n    countLance: lanceCount,\n    validated: true,\n    sampleComparisons,\n    lancePath: finalPath,\n    committed: true,\n  };\n}\n"]}

package/dist/chunk-OSEG74VJ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/internal/workflow/event-stream.ts","../src/workflow.ts"],"names":[],"mappings":"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","file":"chunk-OSEG74VJ.js","sourcesContent":["/**\n * SE28 — a minimal pushable async iterator for `Workflow.stream()`. The executor\n * pushes {@link WorkflowEvent}s as steps run; the consumer drains them via\n * `for await`. Buffers events emitted before the consumer is ready; `end()`\n * closes the iterator so a pending/next `next()` resolves `done: true`.\n *\n * @internal\n */\n\nimport type { WorkflowEvent } from \"../../types/workflow.js\";\n\nexport interface PushableEventStream extends AsyncIterableIterator<WorkflowEvent> {\n  push(event: WorkflowEvent): void;\n  end(): void;\n}\n\nexport function createEventStream(): PushableEventStream {\n  const buffer: WorkflowEvent[] = [];\n  const waiters: Array<(r: IteratorResult<WorkflowEvent>) => void> = [];\n  let ended = false;\n\n  const stream: PushableEventStream = {\n    push(event: WorkflowEvent): void {\n      if (ended) return;\n      const waiter = waiters.shift();\n      if (waiter !== undefined) waiter({ value: event, done: false });\n      else buffer.push(event);\n    },\n    end(): void {\n      if (ended) return;\n      ended = true;\n      for (const waiter of waiters.splice(0)) waiter({ value: undefined, done: true });\n    },\n    next(): Promise<IteratorResult<WorkflowEvent>> {\n      const buffered = buffer.shift();\n      if (buffered !== undefined) return Promise.resolve({ value: buffered, done: false });\n      if (ended) return Promise.resolve({ value: undefined, done: true });\n      return new Promise((resolve) => waiters.push(resolve));\n    },\n    // `for await` calls return() on break/throw — close early so events stop\n    // buffering in memory for a consumer that stopped iterating.\n    return(): Promise<IteratorResult<WorkflowEvent>> {\n      stream.end();\n      buffer.length = 0;\n      return Promise.resolve({ value: undefined, done: true });\n    },\n    [Symbol.asyncIterator](): PushableEventStream {\n      return stream;\n    },\n  };\n  return stream;\n}\n","/**\n * Public `Workflow` class — declarative multi-step orchestration over\n * `Agent.send`, `Handoff`, `Agent.batch` and friends (Adoption Roadmap #5;\n * ADRs D230-D248).\n *\n * Usage:\n *\n *   import { Agent } from \"@theokit/sdk\";\n *   import { Workflow, fn, agentStep } from \"@theokit/sdk/workflow\";\n *\n *   const classifier = await Agent.create({ ... });\n *   const wf = Workflow.create({ name: \"demo\" })\n *     .then(fn(\"validate\", (input: { id: string }) => {\n *       if (!input.id) throw new Error(\"missing id\");\n *       return input;\n *     }))\n *     .then(agentStep(\"classify\", classifier, (i) => `Classify: ${JSON.stringify(i)}`))\n *     .commit();\n *\n *   const run = await wf.run({ id: \"x\" });\n *   console.log(run.status, run.output);\n *\n * @public\n */\n\nimport type { ZodType } from \"zod\";\nimport { z } from \"zod\";\nimport { PersistenceSchema } from \"./internal/persistence/persistence-schema.js\";\nimport { sanitizeIdentifier } from \"./internal/security/path-guard.js\";\nimport { createEventStream } from \"./internal/workflow/event-stream.js\";\nimport { toJsonSchema } from \"./internal/zod/to-json-schema.js\";\nimport type { CustomTool, SDKAgent } from \"./types/agent.js\";\nimport type { MessageOrigin } from \"./types/run.js\";\nimport type {\n  AgentStep,\n  BranchStep,\n  DowhileStep,\n  FnStep,\n  ForeachStep,\n  ParallelStep,\n  RetryPolicy,\n  SleepStep,\n  Step,\n  StepContext,\n  SuspendStep,\n  WorkflowDescription,\n  WorkflowEvent,\n  WorkflowOptions,\n  WorkflowResumeOptions,\n  WorkflowRun,\n  WorkflowRunOptions,\n  WorkflowStepDescription,\n  WorkflowStream,\n} from \"./types/workflow.js\";\nimport { WorkflowDuplicateStepIdError, WorkflowNestedError } from \"./types/workflow.js\";\n\n/* ─── Zod validation schemas ─── */\n\nconst RetryPolicySchema = z.object({\n  // EC-3 absorbed: maxAttempts MUST be a finite int in [1, 20].\n  maxAttempts: z\n    .number()\n    .int(\"retry.maxAttempts must be integer\")\n    .min(1, \"retry.maxAttempts must be >= 1\")\n    .max(20, \"retry.maxAttempts must be <= 20\"),\n  initialBackoffMs: z.number().int().min(0).optional(),\n  backoffCoefficient: z.number().min(1).optional(),\n  maximumBackoffMs: z.number().int().min(0).optional(),\n  nonRetryableErrors: z.array(z.string()).optional(),\n});\n\nconst WorkflowOptionsSchema = z.object({\n  name: z.string().min(1).max(128),\n  persistence: PersistenceSchema,\n  // SE27 — declared so a future `new WorkflowBuilder(parsed)` refactor cannot\n  // silently drop them (create() passes the ORIGINAL options today, but the\n  // schema is also the documentation of the shape).\n  inputSchema: z.custom<ZodType>().optional(),\n  outputSchema: z.custom<ZodType>().optional(),\n});\n\n/* ─── Builder ─── */\n\n/**\n * Fluent step accumulator returned by {@link Workflow.create}. Each method\n * appends a step and returns the SAME builder (mutated in place, never a copy);\n * `.commit()` freezes the list into a {@link Workflow} and mints the id its\n * single-flight lock uses.\n *\n *   const wf = Workflow.create({ name: \"demo\" })\n *     .then(fn(\"validate\", (i: { id: string }) => i))\n *     .commit();\n *\n * You never construct one directly — `Workflow.create(options)` validates the\n * options with Zod and hands it back. Import it from `@theokit/sdk/workflow`; the\n * root `@theokit/sdk` barrel does not export it.\n *\n * How it fails:\n *  - Every appending method throws a plain `Error` after `.commit()` —\n *    \"Workflow already committed; create a fresh Workflow.create(...) call.\" A\n *    builder is single-use.\n *  - A step id is validated on the spot by `sanitizeIdentifier`\n *    (`^[a-z0-9][a-z0-9-_]*$`, max 64 chars). Every rejection — length, a space,\n *    `/`, `..`, a leading `-`, a NUL or control char — throws `ConfigurationError`\n *    with code `invalid_identifier`, not a plain `Error` (#368 collapsed a second\n *    class that the control-char branch used to raise).\n *  - `sleep(durationMs)` throws a plain `Error` on a negative or non-finite value.\n *  - A duplicate id anywhere in the tree, including inside `parallel`, `branch`,\n *    `foreach` and `dowhile`, throws `WorkflowDuplicateStepIdError` at\n *    `.commit()` — not at the `.then()` that introduced it.\n *\n * Traps:\n *  - `.then(step)` is a STEP APPENDER, not a promise continuation. That makes the\n *    builder a JavaScript thenable, so `await Workflow.create({ ... })` — the\n *    shape `await Agent.create({ ... })` trains you into — is a mistake:\n *    TypeScript rejects it (TS1320) and plain JavaScript throws an unrelated\n *    `TypeError: Cannot read properties of undefined (reading 'length')` out of\n *    the id validator. `Workflow.create` is synchronous.\n *  - `parallel`, `branch`, `foreach`, `dowhile` and `suspend` widen the output\n *    type to `unknown` (or `unknown[]`); only `.then<T>()` and `sleep` carry a\n *    type through. The generics are a convenience, not a checked pipeline —\n *    nothing verifies that one step's output matches the next step's input.\n *  - Auto-generated ids are POSITIONAL (`parallel_2`, `foreach_5`), so inserting a\n *    step earlier renames the later ones. Pass `opts.id` for any step whose id you\n *    rely on in event streams or resume snapshots.\n */\nexport class WorkflowBuilder<TInput = unknown, TOutput = unknown> {\n  private readonly _steps: Step[] = [];\n  private _committed = false;\n\n  /** @internal */\n  constructor(private readonly options: WorkflowOptions) {}\n\n  /** @internal — only the executor reads this. */\n  get __steps(): ReadonlyArray<Step> {\n    return this._steps;\n  }\n\n  // biome-ignore lint/suspicious/noThenProperty: D233 locks the a peer framework-style `.then(step)` builder DSL. The method is fluent, never awaited.\n  then<TO = unknown>(step: Step): WorkflowBuilder<TInput, TO> {\n    this.assertNotCommitted();\n    validateStepId(step.id);\n    this._steps.push(step);\n    return this as unknown as WorkflowBuilder<TInput, TO>;\n  }\n\n  parallel(\n    branches: ReadonlyArray<ReadonlyArray<Step>>,\n    opts?: { id?: string; concurrency?: number; errorPolicy?: \"fail-fast\" | \"collect\" },\n  ): WorkflowBuilder<TInput, unknown[]> {\n    this.assertNotCommitted();\n    const id = opts?.id ?? `parallel_${this._steps.length}`;\n    validateStepId(id);\n    for (const branch of branches) {\n      for (const inner of branch) validateStepId(inner.id);\n    }\n    const step: ParallelStep = {\n      kind: \"parallel\",\n      id,\n      branches,\n      ...(opts?.concurrency !== undefined ? { concurrency: opts.concurrency } : {}),\n      ...(opts?.errorPolicy !== undefined ? { errorPolicy: opts.errorPolicy } : {}),\n    };\n    this._steps.push(step);\n    return this as unknown as WorkflowBuilder<TInput, unknown[]>;\n  }\n\n  branch(\n    predicates: BranchStep[\"predicates\"],\n    opts?: { id?: string; fallback?: ReadonlyArray<Step> },\n  ): WorkflowBuilder<TInput, unknown> {\n    this.assertNotCommitted();\n    const id = opts?.id ?? `branch_${this._steps.length}`;\n    validateStepId(id);\n    const step: BranchStep = {\n      kind: \"branch\",\n      id,\n      predicates,\n      ...(opts?.fallback !== undefined ? { fallback: opts.fallback } : {}),\n    };\n    this._steps.push(step);\n    return this as unknown as WorkflowBuilder<TInput, unknown>;\n  }\n\n  foreach(\n    iterableFrom: string,\n    step: Step,\n    opts?: { id?: string; concurrency?: number },\n  ): WorkflowBuilder<TInput, unknown[]> {\n    this.assertNotCommitted();\n    const id = opts?.id ?? `foreach_${this._steps.length}`;\n    validateStepId(id);\n    validateStepId(iterableFrom);\n    validateStepId(step.id);\n    const node: ForeachStep = {\n      kind: \"foreach\",\n      id,\n      iterableFrom,\n      step,\n      ...(opts?.concurrency !== undefined ? { concurrency: opts.concurrency } : {}),\n    };\n    this._steps.push(node);\n    return this as unknown as WorkflowBuilder<TInput, unknown[]>;\n  }\n\n  dowhile(\n    step: Step,\n    condFn: DowhileStep[\"condFn\"],\n    opts?: { id?: string; maxIterations?: number },\n  ): WorkflowBuilder<TInput, unknown> {\n    this.assertNotCommitted();\n    const id = opts?.id ?? `dowhile_${this._steps.length}`;\n    validateStepId(id);\n    validateStepId(step.id);\n    const node: DowhileStep = {\n      kind: \"dowhile\",\n      id,\n      step,\n      condFn,\n      ...(opts?.maxIterations !== undefined ? { maxIterations: opts.maxIterations } : {}),\n    };\n    this._steps.push(node);\n    return this as unknown as WorkflowBuilder<TInput, unknown>;\n  }\n\n  sleep(durationMs: number, id?: string): WorkflowBuilder<TInput, TOutput> {\n    this.assertNotCommitted();\n    const stepId = id ?? `sleep_${this._steps.length}`;\n    validateStepId(stepId);\n    if (!Number.isFinite(durationMs) || durationMs < 0) {\n      throw new Error(`sleep durationMs must be finite non-negative: ${durationMs}`);\n    }\n    const step: SleepStep = { kind: \"sleep\", id: stepId, durationMs };\n    this._steps.push(step);\n    return this;\n  }\n\n  suspend(opts?: { id?: string; payloadSchema?: ZodType }): WorkflowBuilder<TInput, unknown> {\n    this.assertNotCommitted();\n    const id = opts?.id ?? `suspend_${this._steps.length}`;\n    validateStepId(id);\n    const step: SuspendStep = {\n      kind: \"suspend\",\n      id,\n      ...(opts?.payloadSchema !== undefined ? { payloadSchema: opts.payloadSchema } : {}),\n    };\n    this._steps.push(step);\n    return this as unknown as WorkflowBuilder<TInput, unknown>;\n  }\n\n  commit(): Workflow<TInput, TOutput> {\n    this.assertNotCommitted();\n    this.validateUniqueIds();\n    this._committed = true;\n    // EC-5 absorbed: mint unique workflowId so single-flight lock is per-instance\n    const workflowId = `wf-${mintShortId()}`;\n    return new Workflow<TInput, TOutput>({ ...this.options, workflowId }, [...this._steps]);\n  }\n\n  private validateUniqueIds(): void {\n    const seen = new Set<string>();\n    walkStepsValidating(this._steps, seen);\n  }\n\n  private assertNotCommitted(): void {\n    if (this._committed) {\n      throw new Error(\"Workflow already committed; create a fresh Workflow.create(...) call.\");\n    }\n  }\n}\n\n/* ─── Workflow class ─── */\n\n/**\n * theokit#161 — project one step to its reflectable shape, recursing into the variants that nest.\n *\n * `parallel` branches are FLATTENED: the grouping is a scheduling detail (which steps may run\n * concurrently), not shape a reader of the workflow needs, and preserving it would put a second,\n * branch-shaped level into a type whose whole purpose is to be renderable.\n */\nfunction describeStep(step: Step): WorkflowStepDescription {\n  const base = { id: step.id, kind: step.kind } as const;\n  if (step.kind === \"parallel\") {\n    return { ...base, steps: step.branches.flat().map(describeStep) };\n  }\n  if (step.kind === \"branch\") {\n    const fromPredicates = step.predicates.flatMap(([, steps]) => steps.map(describeStep));\n    const fromFallback = (step.fallback ?? []).map(describeStep);\n    return { ...base, steps: [...fromPredicates, ...fromFallback] };\n  }\n  if (step.kind === \"foreach\" || step.kind === \"dowhile\") {\n    return { ...base, steps: [describeStep(step.step)] };\n  }\n  return base;\n}\n\n/**\n * A committed, immutable workflow: a fixed list of steps you can `run`, `stream`\n * or `resume`. Built with `Workflow.create(options)` plus `.commit()`; the\n * constructor is not part of the published surface.\n *\n *   import { Workflow, fn } from \"@theokit/sdk/workflow\";\n *   const wf = Workflow.create({ name: \"demo\" })\n *     .then(fn(\"validate\", (i: { id: string }) => i))\n *     .commit();\n *   const run = await wf.run({ id: \"x\" });   // run.status, run.output\n *\n * THE IMPORT SPECIFIER MATTERS. `Workflow` is emitted TWICE — once as the\n * `@theokit/sdk/workflow` sub-path entry, and once inside the shared chunk behind\n * the root `@theokit/sdk` barrel. Both declarations carry private fields, so the\n * two are DISTINCT nominal types and TypeScript refuses to pass one where the\n * other is expected:\n *\n *   Types have separate declarations of a private property '_options'.\n *\n * Import `Workflow` — and everything that consumes one, such as `workflowStep`\n * and `cloneWorkflow` — from `@theokit/sdk/workflow`, and do not mix the two\n * specifiers in one program. The root barrel re-exports only `Workflow`,\n * `agentStep` and `fn`; the builder, the step helpers, the error classes and every\n * workflow type live on the sub-path. (`workflowAsTool` is exempt: it accepts any\n * `{ run }`-shaped value structurally, so either `Workflow` satisfies it.)\n *\n * How it fails: a step that throws does NOT reject `run()`. The promise resolves\n * with `status: \"failed\"` and the cause on `run.error`; `\"suspended\"` and\n * `\"cancelled\"` are the other non-`\"completed\"` terminals, and an `outputSchema`\n * mismatch also lands as `\"failed\"` (`WorkflowOutputError`) rather than a throw.\n * What DOES throw out of `run()` is pre-flight: `WorkflowAlreadyRunningError` when\n * you pin `WorkflowRunOptions.runId` to one still in flight. `Workflow.resume`\n * throws `WorkflowSnapshotNotFoundError` for an unknown `runId`.\n *\n * Traps:\n *  - Without an explicit `runId` each call mints its own, so concurrent runs of\n *    the same committed workflow do NOT collide — the single-flight lock only\n *    bites when you pin the id yourself.\n *  - `stream()` reports progress; its `result` promise is the AUTHORITATIVE\n *    outcome. Not every terminal emits a closing event, so a consumer that only\n *    drains events can miss a failure. Always `await result`.\n *  - `run()` and `stream()` load the executor by dynamic `import()`, so the first\n *    call pays a module load and cannot be made synchronous.\n *\n * @public\n */\nexport class Workflow<TInput = unknown, TOutput = unknown> {\n  /** @internal */\n  constructor(\n    private readonly _options: WorkflowOptions,\n    private readonly _steps: ReadonlyArray<Step>,\n  ) {}\n\n  /** @internal — only the executor reads these. */\n  get __options(): WorkflowOptions {\n    return this._options;\n  }\n  /** @internal */\n  get __steps(): ReadonlyArray<Step> {\n    return this._steps;\n  }\n\n  /**\n   * Construct a workflow builder. Validate options via Zod and return a\n   * `WorkflowBuilder` for fluent chaining. Call `.commit()` to obtain the\n   * immutable `Workflow`.\n   */\n  static create<TI = unknown, TO = unknown>(options: WorkflowOptions): WorkflowBuilder<TI, TO> {\n    WorkflowOptionsSchema.parse(options);\n    return new WorkflowBuilder<TI, TO>(options);\n  }\n\n  /**\n   * theokit#161 — describe this workflow's shape, for a reflection surface.\n   *\n   * Returns `{ name, steps }`, each step carrying its `id` and `kind`, recursing into `parallel`,\n   * `branch`, `foreach` and `dowhile`. Every executable a step holds — predicates, conditions,\n   * agents, prompt templates — is omitted: it cannot cross a process boundary and says nothing about\n   * shape.\n   *\n   * There is deliberately no `Workflow.list()`. A workflow is a value the caller constructs and\n   * holds, so the caller already knows which ones exist; a registry would add process-global state\n   * nothing releases in order to re-answer a question the host can answer itself. A reflection\n   * endpoint maps over its own workflows and calls this.\n   *\n   * @public\n   */\n  describe(): WorkflowDescription {\n    return {\n      name: this._options.name,\n      steps: this._steps.map(describeStep),\n    };\n  }\n\n  /**\n   * Run this workflow with the given input. Returns a populated\n   * `WorkflowRun`. Errors inside a step DO NOT throw — they propagate via\n   * `run.status === \"failed\"`.\n   */\n  async run(input: TInput, opts?: WorkflowRunOptions): Promise<WorkflowRun<TOutput>> {\n    // Lazy import to keep the public façade lean.\n    const { executeWorkflow } = await import(\"./internal/workflow/executor.js\");\n    const result = await executeWorkflow<TInput, TOutput>(this._options, this._steps, input, opts);\n    // T3.4: opt-in Task wrapping (ADRs D363, D374). Workflows are\n    // observable via Task.list/get/subscribe; the underlying run is\n    // already terminal here (executor returned), so the Task just\n    // records the outcome for inspection.\n    if (opts?.task !== undefined) {\n      const { submit: taskSubmit } = await import(\"./internal/task/registry.js\");\n      const taskOpts = opts.task === true ? {} : opts.task;\n      const id = taskOpts.id ?? `wf-${result.id}`;\n      await taskSubmit({\n        kind: \"workflow\",\n        work: async (ctx) => {\n          ctx.emit({ status: result.status, runId: result.id });\n          return { status: result.status, runId: result.id, output: result.output };\n        },\n        id,\n        meta: {\n          workflowName: this._options.name,\n          runId: result.id,\n          status: result.status,\n          ...(taskOpts.meta ?? {}),\n        },\n        allowReservedPrefix: true,\n      });\n    }\n    return result;\n  }\n\n  /**\n   * SE28 — run the workflow and STREAM step-level events as they happen. Returns\n   * an async iterator of {@link WorkflowEvent}s (`step_started` / `step_completed`\n   * / `step_failed` / `workflow_suspended` / `workflow_completed`, top-level\n   * steps) plus a `result` promise resolving to the same terminal\n   * {@link WorkflowRun} `run()` returns. Iterate for progress; await `result` for\n   * the outcome. The stream ends when the run terminates.\n   *\n   * `result` is the AUTHORITATIVE terminal status. Not every terminal state has a\n   * closing event: a step failure emits `step_failed`, but an `outputSchema`\n   * rejection (SE27) or an abort ends the stream WITHOUT `workflow_completed` —\n   * always `await result` to read the final `status`. Consuming order is free:\n   * awaiting `result` without draining, or draining without awaiting `result`,\n   * both work (breaking out of `for await` stops the buffering early).\n   */\n  stream(input: TInput, opts?: WorkflowRunOptions): WorkflowStream<TOutput> {\n    const queue = createEventStream();\n    const result = (async (): Promise<WorkflowRun<TOutput>> => {\n      const { executeWorkflow } = await import(\"./internal/workflow/executor.js\");\n      try {\n        return await executeWorkflow<TInput, TOutput>(this._options, this._steps, input, {\n          ...opts,\n          onStepEvent: (event: WorkflowEvent) => queue.push(event),\n        } as WorkflowRunOptions);\n      } finally {\n        queue.end(); // authoritative terminal is `result`; close the stream\n      }\n    })();\n    return Object.assign(queue, { result });\n  }\n\n  /**\n   * Resume a suspended workflow from its snapshot. Throws\n   * `WorkflowSnapshotNotFoundError` if `runId` is unknown.\n   */\n  static async resume<TO = unknown>(opts: WorkflowResumeOptions): Promise<WorkflowRun<TO>> {\n    const { resumeWorkflow } = await import(\"./internal/workflow/executor.js\");\n    return resumeWorkflow<TO>(opts);\n  }\n}\n\n/* ─── Helper factory functions ─── */\n\n/**\n * Build a `FnStep`. `id` must match `^[a-z0-9][a-z0-9_-]*$`.\n */\nexport function fn<I = unknown, O = unknown>(\n  id: string,\n  step: (input: I, ctx: StepContext) => Promise<O> | O,\n  opts?: { inputSchema?: ZodType; outputSchema?: ZodType; retry?: RetryPolicy },\n): FnStep {\n  validateStepId(id);\n  if (opts?.retry !== undefined) RetryPolicySchema.parse(opts.retry);\n  return {\n    kind: \"fn\",\n    id,\n    fn: step as FnStep[\"fn\"],\n    ...(opts?.inputSchema !== undefined ? { inputSchema: opts.inputSchema } : {}),\n    ...(opts?.outputSchema !== undefined ? { outputSchema: opts.outputSchema } : {}),\n    ...(opts?.retry !== undefined ? { retry: opts.retry } : {}),\n  };\n}\n\n/**\n * Build an `AgentStep`. The `promptTemplate` can be a static string or a\n * function that receives the input and returns the prompt.\n */\nexport function agentStep(\n  id: string,\n  agent: SDKAgent,\n  promptTemplate: string | ((input: unknown) => string),\n  opts?: { retry?: RetryPolicy; origin?: MessageOrigin },\n): AgentStep {\n  validateStepId(id);\n  if (opts?.retry !== undefined) RetryPolicySchema.parse(opts.retry);\n  return {\n    kind: \"agent\",\n    id,\n    agent,\n    promptTemplate,\n    ...(opts?.retry !== undefined ? { retry: opts.retry } : {}),\n    // SE3 — carry the turn's provenance down to `agent.send()` (metadata-only).\n    ...(opts?.origin !== undefined ? { origin: opts.origin } : {}),\n  };\n}\n\n/**\n * SE30 — use a committed {@link Workflow} as a step inside another workflow.\n * Wraps the child as an `FnStep` (opaque — the child runs in its OWN executor\n * with its own id-space, so nested step-ids never collide with the parent's).\n * The child's output becomes the step output. A non-`completed` child fails the\n * parent step with a typed {@link WorkflowNestedError}: nested `suspended` is NOT\n * resumable in v1 (resume continues AFTER the step — the child would be skipped;\n * use a top-level suspend). See ADR 0010.\n *\n * @public\n */\nexport function workflowStep<TI = unknown, TO = unknown>(\n  child: Workflow<TI, TO>,\n  opts?: { id?: string },\n): FnStep {\n  const id = opts?.id ?? `workflow_${child.__options.name}`;\n  validateStepId(id);\n  return {\n    kind: \"fn\",\n    id,\n    fn: async (input: unknown, ctx: StepContext): Promise<unknown> => {\n      const run = await child.run(input as TI, { signal: ctx.signal });\n      if (run.status === \"completed\") return run.output;\n      throw new WorkflowNestedError(id, child.__options.name, run.status, run.error);\n    },\n  };\n}\n\n/**\n * SE30 — clone a committed workflow under a new id/name. The clone runs\n * independently (its own single-flight lock + observability identity) with the\n * same committed steps. Mirrors a peer framework's `cloneWorkflow`.\n *\n * @public\n */\nexport function cloneWorkflow<TI = unknown, TO = unknown>(\n  wf: Workflow<TI, TO>,\n  opts: { id: string },\n): Workflow<TI, TO> {\n  return new Workflow<TI, TO>(\n    { ...wf.__options, name: opts.id, workflowId: `wf-${mintShortId()}` },\n    [...wf.__steps],\n  );\n}\n\n/* ─── Test seam re-export ─── */\n\nexport { __resetSnapshotStoresForTests } from \"./internal/workflow/snapshot-store.js\";\n\n/* ─── Re-exports for ergonomics (errors + all public types). After the\n       sub-path extraction `@theokit/sdk/workflow` is the single import site,\n       so type aliases must surface here (previously they reached consumers\n       via `types/index.ts:25 export type * from \"./workflow.js\"`, which the\n       extraction removes). ─── */\n\nexport type * from \"./types/workflow.js\";\nexport {\n  WorkflowAlreadyRunningError,\n  WorkflowCompensateNotImplementedError,\n  WorkflowDuplicateStepIdError,\n  WorkflowInputError,\n  WorkflowMaxIterationsExceededError,\n  WorkflowNestedError,\n  WorkflowNotSerializableError,\n  WorkflowOutputError,\n  WorkflowParallelError,\n  WorkflowResumeStepNotFoundError,\n  WorkflowSnapshotNotFoundError,\n  WorkflowStateError,\n} from \"./types/workflow.js\";\n\n/* ─── SE19 — workflowAsTool (expose a Workflow as an agent tool) ─── */\n\n/**\n * Raised by a {@link workflowAsTool} tool when the wrapped workflow run does not\n * reach `status: \"completed\"` (a step failed, the run was cancelled/suspended).\n * The dispatch converts it to a `tool_result(isError)`.\n *\n * @public\n */\nexport class WorkflowToolError extends Error {\n  readonly code = \"workflow_tool_failed\" as const;\n  constructor(\n    readonly toolName: string,\n    readonly workflowStatus: string,\n    readonly workflowError?: { name: string; message: string },\n  ) {\n    super(\n      `workflowAsTool(\"${toolName}\"): workflow ${workflowStatus}${\n        workflowError ? `: ${workflowError.message}` : \"\"\n      }`,\n    );\n    this.name = \"WorkflowToolError\";\n  }\n}\n\n/** Spec for {@link workflowAsTool}. `inputSchema` is the workflow's input shape (Zod). */\nexport interface WorkflowAsToolSpec<T extends ZodType> {\n  /** Tool name surfaced to the LLM. Same constraints as a `CustomTool.name`. */\n  name: string;\n  /** Description surfaced to the LLM — when the agent should trigger the workflow. */\n  description: string;\n  /** Zod schema for the workflow's input (a `Workflow` carries no top-level schema). */\n  inputSchema: T;\n}\n\n/**\n * SE19 — expose a {@link Workflow} as an agent {@link CustomTool}, completing the\n * \"X as tools\" trio (tools; agents-as-tools via `defineSubAgent`; workflows-as-tools).\n * The handler validates the model's args against `spec.inputSchema`, runs the\n * workflow, and returns its output (a string as-is, else JSON). A run that does not\n * reach `status: \"completed\"` raises a typed {@link WorkflowToolError} (workflow\n * step errors do NOT throw — they surface via `run.status === \"failed\"`).\n *\n * Accepts any `{ run }`-shaped workflow (structural), so it never imports the\n * `Workflow` class directly.\n *\n * @public\n */\nexport function workflowAsTool<T extends ZodType, TOutput = unknown>(\n  workflow: { run: (input: z.infer<T>) => Promise<WorkflowRun<TOutput>> },\n  spec: WorkflowAsToolSpec<T>,\n): CustomTool {\n  const inputSchema = toJsonSchema(spec.inputSchema, { unrepresentable: \"any\" });\n  return {\n    name: spec.name,\n    description: spec.description,\n    inputSchema,\n    handler: async (rawInput: Record<string, unknown>): Promise<string> => {\n      const parsed = spec.inputSchema.parse(rawInput) as z.infer<T>;\n      const run = await workflow.run(parsed);\n      if (run.status !== \"completed\") {\n        throw new WorkflowToolError(spec.name, run.status, run.error);\n      }\n      const output = run.output;\n      return typeof output === \"string\" ? output : JSON.stringify(output ?? null);\n    },\n  };\n}\n\n/* ─── Internal helpers ─── */\n\nfunction validateStepId(id: string): void {\n  // Reuses D81 grammar: ^[a-z0-9][a-z0-9_-]*$\n  sanitizeIdentifier(id, { maxLen: 64 });\n}\n\nfunction mintShortId(): string {\n  return globalThis.crypto.randomUUID().replace(/-/g, \"\").slice(0, 8);\n}\n\nfunction nestedStepsOf(s: Step): ReadonlyArray<ReadonlyArray<Step>> {\n  if (s.kind === \"parallel\") return s.branches;\n  if (s.kind === \"branch\") {\n    const groups = s.predicates.map(([, branch]) => branch);\n    return s.fallback !== undefined ? [...groups, s.fallback] : groups;\n  }\n  if (s.kind === \"foreach\" || s.kind === \"dowhile\") return [[s.step]];\n  return [];\n}\n\nfunction walkStepsValidating(steps: ReadonlyArray<Step>, seen: Set<string>): void {\n  for (const s of steps) {\n    if (seen.has(s.id)) throw new WorkflowDuplicateStepIdError(s.id);\n    seen.add(s.id);\n    for (const nested of nestedStepsOf(s)) {\n      walkStepsValidating(nested, seen);\n    }\n  }\n}\n"]}

package/dist/chunk-RFMBZPOW.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/types/task.ts","../src/internal/task/store.ts"],"names":["InvalidTaskIdError","mkdirSync","join","atomicWriteText","readFile","diag","readdirSync","unlink"],"mappings":"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","file":"chunk-RFMBZPOW.cjs","sourcesContent":["/**\n * Public type contract for the Task observability registry (ADRs D361-D374).\n *\n * Tasks are an opt-in observability layer over async work in the SDK\n * (`Agent.send`, `Agent.batch`, `Workflow.run`, `Cron` fires). They have\n * a closed 5-state lifecycle (D362), discriminated events (D366), and a\n * pluggable store (D364). The `Task` facade in `task.ts` is the public\n * surface; consumers import these types from `@theokit/sdk`.\n *\n * @public\n */\n\n/**\n * Closed enum of the 5 lifecycle states (D362).\n *\n * Transitions are acyclic:\n *   queued → running → (finished | error | cancelled)\n *   queued → cancelled (direct, no run started)\n */\nexport type TaskState = \"queued\" | \"running\" | \"finished\" | \"error\" | \"cancelled\";\n\n/** Discriminator of the runtime that produced a task (D374). */\nexport type TaskKind = \"run\" | \"batch\" | \"workflow\" | \"cron\" | \"custom\";\n\n/** Discriminated union of task lifecycle events (D366). */\nexport type TaskEvent =\n  | {\n      readonly type: \"submitted\";\n      readonly taskId: string;\n      readonly kind: TaskKind;\n      readonly submittedAt: number;\n      readonly meta?: Record<string, unknown>;\n      /** D372 — flag set on the first yielded event when the ring buffer was at cap. */\n      readonly truncated?: boolean;\n    }\n  | { readonly type: \"started\"; readonly taskId: string; readonly startedAt: number }\n  | {\n      readonly type: \"progress\";\n      readonly taskId: string;\n      readonly at: number;\n      readonly payload: unknown;\n    }\n  | {\n      readonly type: \"finished\";\n      readonly taskId: string;\n      readonly finishedAt: number;\n      readonly result: unknown;\n    }\n  | {\n      readonly type: \"errored\";\n      readonly taskId: string;\n      readonly erroredAt: number;\n      readonly error: { readonly code: string; readonly message: string };\n    }\n  | {\n      readonly type: \"cancelled\";\n      readonly taskId: string;\n      readonly cancelledAt: number;\n      readonly reason?: string;\n    };\n\n/** Public read-only view of a task entry in the registry. */\nexport interface TaskHandle {\n  readonly id: string;\n  readonly kind: TaskKind;\n  readonly state: TaskState;\n  readonly submittedAt: number;\n  readonly startedAt?: number;\n  readonly finishedAt?: number;\n  readonly cancelledAt?: number;\n  readonly erroredAt?: number;\n  readonly result?: unknown;\n  readonly error?: { readonly code: string; readonly message: string };\n  readonly meta?: Record<string, unknown>;\n  /**\n   * EC-7 — cross-process best-effort cancel flag. Set by CLI\n   * `theokit tasks cancel` via JsonFileTaskStore. The owning process\n   * polls at checkpoints and honors via AbortController. Always\n   * `undefined` for in-process cancel paths (which go directly through\n   * AbortController).\n   */\n  readonly cancelRequested?: boolean;\n  /**\n   * Why the task was cancelled, when whoever cancelled it said. Free text, written alongside\n   * `cancelledAt` for a `queued` task and alongside `cancelRequested` for a `running` one.\n   *\n   * Absent when no reason was given — an empty string is not a reason, and a default like\n   * \"cancelled\" would put words in the operator's mouth. `theokit tasks cancel --reason` is what\n   * writes it (#351); nothing in the runtime reads it, because it exists for the human reading the\n   * registry later.\n   */\n  readonly cancelReason?: string;\n}\n\n/** Query filter for `Task.list`. */\nexport interface TaskFilter {\n  readonly state?: TaskState | readonly TaskState[];\n  readonly kind?: TaskKind | readonly TaskKind[];\n  readonly submittedAfter?: number;\n  readonly submittedBefore?: number;\n  /**\n   * Defaults to 100. `JsonFileTaskStore` returns the newest matching tasks first and reads its\n   * whole directory to find them (256 files at a time); page past this limit with\n   * `submittedBefore` (#362).\n   */\n  readonly limit?: number;\n}\n\n/** Options for `Task.submit`. */\nexport interface TaskSubmitOptions {\n  /**\n   * Optional user-supplied ID. Must match grammar `^[a-z0-9][a-z0-9_-]*$`\n   * and MUST NOT start with the reserved prefixes `wf-` / `b-` / `cron-`\n   * (D368, EC-5). When omitted, `crypto.randomUUID()` is used.\n   */\n  readonly id?: string;\n  readonly meta?: Record<string, unknown>;\n  /**\n   * Optional caller-provided AbortSignal. If already aborted at submit\n   * time, the registry short-circuits to `cancelled` without acquiring\n   * a semaphore slot (EC-4).\n   */\n  readonly signal?: AbortSignal;\n  /**\n   * SE2 — an opt-in {@link import(\"./run-events.js\").RunEventSink}. The task's\n   * lifecycle is forwarded to it as typed `task_started` / `task_updated` /\n   * `task_completed` RunEvents, so a caller that spawned the task can observe it\n   * through the same `onRunEvent` channel as the rest of the run. Best-effort (a\n   * throwing sink never breaks the task). The dedicated `Task.subscribe(id)`\n   * channel is unaffected.\n   */\n  readonly onRunEvent?: import(\"./run-events.js\").RunEventSink;\n}\n\n/** Options shape for `TaskStore` factory (D364). */\nexport type TaskStoreOptions =\n  | { readonly backend: \"memory\" }\n  | { readonly backend: \"json\"; readonly dir: string };\n\n/** Result of `Task.cancel` (D365 — idempotent). */\nexport interface TaskCancelResult {\n  readonly cancelled: boolean;\n  readonly alreadyTerminal: boolean;\n}\n\n/**\n * Grammar for user-supplied task IDs (D368).\n * `crypto.randomUUID()` outputs do NOT match this (UUIDs have dashes\n * AND uppercase letters in their canonical form on some Node versions),\n * but the registry normalizes auto-generated IDs to lowercase before\n * insertion, so they pass the same regex.\n */\nconst TASK_ID_GRAMMAR = /^[a-z0-9][a-z0-9_-]*$/;\n\n/** Reserved prefixes for adapter-generated IDs (D368, EC-5). */\nconst RESERVED_PREFIXES = [\"wf-\", \"b-\", \"cron-\"] as const;\n\n/**\n * Validates a task ID against the public grammar + reserved prefixes.\n * Throws `InvalidTaskIdError` from `../errors.js` on rejection.\n *\n * Adapter callers (workflow/batch/cron) MUST set `allowReserved: true`\n * to register their own IDs; user-facing surfaces (`Task.submit`,\n * `agent.send({ task: { id } })`) leave it false.\n */\nexport function isValidTaskId(id: string, allowReserved: boolean): boolean {\n  if (!TASK_ID_GRAMMAR.test(id)) return false;\n  if (allowReserved) return true;\n  for (const prefix of RESERVED_PREFIXES) {\n    if (id.startsWith(prefix)) return false;\n  }\n  return true;\n}\n\n/** Re-exported for adapter implementations + tests. */\nexport const TASK_RESERVED_PREFIXES: readonly string[] = RESERVED_PREFIXES;\n","/**\n * `TaskStore` interface + 2 implementations (ADR D364).\n *\n *   - `InMemoryTaskStore` — default, transient, single-process.\n *   - `JsonFileTaskStore` — opt-in, one JSON file per task under a\n *     dedicated dir; single-process invariant (EC-15 documented).\n *\n * Edge cases absorbed:\n *   - EC-1: constructor auto-creates dir (mkdirSync recursive idempotent).\n *   - EC-2: every method validates the task id against the public\n *     grammar (D368) BEFORE doing any path I/O — path-traversal defense.\n *   - EC-6: `list()` returns `[]` on ENOENT (fresh install path).\n *   - EC-8: `list()` skips `.tmp.*` orphan files left by interrupted\n *     atomic writes.\n *   - EC-14 (DOCUMENT): `list()` JSDoc documents the 256-row hard cap.\n *     It no longer advertises `submittedBefore` as a way to page past it:\n *     the cap is applied to the raw directory listing before any filter, so\n *     paging beyond 256 files is not reachable through this interface.\n *   - EC-15 (DOCUMENT): `JsonFileTaskStore` JSDoc documents the\n *     single-process invariant; v0.2 SQLite covers cross-process.\n *\n * @internal\n */\n\nimport { mkdirSync, readdirSync } from \"node:fs\";\nimport { readFile, unlink } from \"node:fs/promises\";\nimport { join } from \"node:path\";\n\nimport { InvalidTaskIdError } from \"../../errors.js\";\nimport {\n  isValidTaskId,\n  type TaskFilter,\n  type TaskHandle,\n  type TaskState,\n  type TaskStoreOptions,\n} from \"../../types/task.js\";\nimport { diag } from \"../diagnostics.js\";\nimport { atomicWriteText } from \"../persistence/atomic-write.js\";\n\nconst JSON_LOAD_CAP = 256;\nconst DEFAULT_LIST_LIMIT = 100;\n\n/** Storage interface used by `TaskRegistry`. */\nexport interface TaskStore {\n  insert(handle: TaskHandle): Promise<void>;\n  update(id: string, mutate: (h: TaskHandle) => TaskHandle): Promise<TaskHandle | undefined>;\n  get(id: string): Promise<TaskHandle | undefined>;\n  /**\n   * Returns at most `filter.limit ?? 100` matching handles.\n   *\n   * `JsonFileTaskStore` returns them newest-first and considers every task in its\n   * directory, reading at most 256 files concurrently (#362 — that number bounds\n   * I/O, not which tasks are visible). Walk past `limit` by passing the oldest\n   * `submittedAt` of a page as the next call's `submittedBefore`; the ordering is\n   * what makes that a cursor rather than a re-roll of an arbitrary subset.\n   * `InMemoryTaskStore` applies the same filters but does not order its result.\n   */\n  list(filter: TaskFilter): Promise<TaskHandle[]>;\n  delete(id: string): Promise<boolean>;\n  /** Removes terminal handles whose terminal-timestamp is older than `epochMs`. */\n  evictTerminalOlderThan(epochMs: number): Promise<number>;\n}\n\nfunction assertValidIdForStore(id: string): void {\n  if (!isValidTaskId(id, /* allowReserved */ true)) {\n    throw new InvalidTaskIdError(`store rejects invalid task id: ${id}`, id);\n  }\n}\n\nfunction terminalTimestamp(h: TaskHandle): number | undefined {\n  if (h.state === \"finished\") return h.finishedAt;\n  if (h.state === \"error\") return h.erroredAt;\n  if (h.state === \"cancelled\") return h.cancelledAt;\n  return undefined;\n}\n\nfunction isTerminal(state: TaskState): boolean {\n  return state === \"finished\" || state === \"error\" || state === \"cancelled\";\n}\n\nfunction matchesState(h: TaskHandle, filter: TaskFilter): boolean {\n  if (filter.state === undefined) return true;\n  const states = Array.isArray(filter.state) ? filter.state : [filter.state];\n  return states.includes(h.state);\n}\nfunction matchesKind(h: TaskHandle, filter: TaskFilter): boolean {\n  if (filter.kind === undefined) return true;\n  const kinds = Array.isArray(filter.kind) ? filter.kind : [filter.kind];\n  return kinds.includes(h.kind);\n}\nfunction matchesTime(h: TaskHandle, filter: TaskFilter): boolean {\n  if (filter.submittedAfter !== undefined && h.submittedAt <= filter.submittedAfter) return false;\n  if (filter.submittedBefore !== undefined && h.submittedAt >= filter.submittedBefore) return false;\n  return true;\n}\nfunction matchesFilter(h: TaskHandle, filter: TaskFilter): boolean {\n  return matchesState(h, filter) && matchesKind(h, filter) && matchesTime(h, filter);\n}\n\n/** The states `evictTerminalOlderThan` considers terminal. */\nconst TERMINAL_STATES: readonly TaskState[] = [\"finished\", \"error\", \"cancelled\"];\n\n/**\n * Where `submittedAt` belongs in a newest-first list — the first index whose entry is older.\n *\n * Linear rather than binary: the list is bounded by the caller's `limit` (100 by default) and the\n * scan runs once per MATCHING handle, so the comparison count is dwarfed by the file read that\n * produced the handle. A binary search here would trade a real cost for an imagined one.\n */\nfunction insertionIndex(newestFirst: readonly TaskHandle[], submittedAt: number): number {\n  for (let i = 0; i < newestFirst.length; i++) {\n    const entry = newestFirst[i];\n    if (entry !== undefined && entry.submittedAt < submittedAt) return i;\n  }\n  return newestFirst.length;\n}\n\nfunction applyFilter(values: Iterable<TaskHandle>, filter: TaskFilter): TaskHandle[] {\n  const limit = filter.limit ?? DEFAULT_LIST_LIMIT;\n  const out: TaskHandle[] = [];\n  for (const h of values) {\n    if (matchesFilter(h, filter)) {\n      out.push(h);\n      if (out.length >= limit) break;\n    }\n  }\n  return out;\n}\n\n/* ─── InMemory ─── */\n\n/**\n * Default `TaskStore` — a plain `Map` living in the current process.\n *\n * Nothing reaches disk and nothing survives the process, so a task recorded here\n * is invisible to a reader in another process (`theokit tasks`). Select it with\n * `getTaskStoreFor({ backend: \"memory\" })`.\n *\n * How it fails: every id-taking method validates against the task-id grammar\n * (`^[a-z0-9][a-z0-9_-]*$`; reserved `wf-`/`b-`/`cron-` prefixes are permitted\n * here) and throws `InvalidTaskIdError` before touching the map. A missing id is\n * reported by returning `undefined` (`get`, `update`) or `false` (`delete`), never\n * by throwing.\n *\n * Traps:\n *  - `insert()` is a `Map.set`: an existing id is overwritten silently, not\n *    rejected.\n *  - `list()` walks in INSERTION order and stops as soon as `filter.limit ?? 100`\n *    matches are collected. It never sorts, so the limit truncates an\n *    oldest-first scan rather than returning the most recent tasks.\n *  - Nothing evicts on its own; terminal handles accumulate until a caller invokes\n *    `evictTerminalOlderThan`.\n */\nexport class InMemoryTaskStore implements TaskStore {\n  private readonly map = new Map<string, TaskHandle>();\n\n  async insert(handle: TaskHandle): Promise<void> {\n    assertValidIdForStore(handle.id);\n    this.map.set(handle.id, handle);\n  }\n\n  async update(id: string, mutate: (h: TaskHandle) => TaskHandle): Promise<TaskHandle | undefined> {\n    assertValidIdForStore(id);\n    const existing = this.map.get(id);\n    if (existing === undefined) return undefined;\n    const next = mutate(existing);\n    this.map.set(id, next);\n    return next;\n  }\n\n  async get(id: string): Promise<TaskHandle | undefined> {\n    assertValidIdForStore(id);\n    return this.map.get(id);\n  }\n\n  async list(filter: TaskFilter): Promise<TaskHandle[]> {\n    return applyFilter(this.map.values(), filter);\n  }\n\n  async delete(id: string): Promise<boolean> {\n    assertValidIdForStore(id);\n    return this.map.delete(id);\n  }\n\n  async evictTerminalOlderThan(epochMs: number): Promise<number> {\n    let count = 0;\n    for (const [id, h] of this.map.entries()) {\n      if (!isTerminal(h.state)) continue;\n      const ts = terminalTimestamp(h);\n      if (ts !== undefined && ts < epochMs) {\n        this.map.delete(id);\n        count++;\n      }\n    }\n    return count;\n  }\n}\n\n/* ─── JsonFile (opt-in) ───\n *\n * IMPORTANT (EC-15): `JsonFileTaskStore` is **single-process**.\n * Concurrent writers from multiple Node processes against the same\n * directory may corrupt entries (atomic-write protects per-file, but\n * the `list()` scan + `update()` read-modify-write cycle is not\n * serialised across processes). Use only when the `TaskRegistry`\n * runs in exactly one process. v0.2 will add a SQLite backend with\n * the same interface for cross-process scenarios (D364 + D61).\n */\n/**\n * Opt-in `TaskStore` that keeps one JSON file per task under `dir`, so another\n * process can read the registry off disk.\n *\n *   const store = new JsonFileTaskStore(\"/var/lib/theokit/tasks\");\n *\n * Two calls are synchronous, and both are deliberate: the constructor creates `dir`\n * recursively (`mkdirSync`), and `list()` scans it with `readdirSync` before awaiting\n * anything. Every other operation is async — `get` uses `readFile`, `delete` uses\n * `unlink`, and every write goes through an atomic temp-file-plus-rename.\n *\n * SINGLE-PROCESS ONLY — see the note above. Per-file atomicity does not make\n * `update()` safe: it is a read-modify-write, so two writers that both `get`\n * before either writes lose one of the two mutations. That is true within one\n * process as well as across processes.\n *\n * How it fails:\n *  - An invalid id throws `InvalidTaskIdError` BEFORE any path is constructed.\n *    That ordering is the path-traversal defence, and it is why ids are validated\n *    rather than escaped.\n *  - A missing task is `undefined` from `get` and `false` from `delete`.\n *  - A file that exists but does not parse is NOT surfaced as an error: `get`\n *    writes to the diagnostics channel and returns `undefined`, so a corrupted\n *    task also silently vanishes from `list()`.\n *  - `list()` returns `[]` when `dir` does not exist; any other `readdir` failure\n *    (for example a permission error) throws.\n *\n * Traps:\n *  - `list()` reads every task file in the directory (256 at a time) to apply the\n *    filter, because `state`, `kind` and `submittedAt` live inside the files. On a\n *    large directory that is a lot of I/O for one call; the memory it holds is\n *    bounded by `limit`, the time is not.\n *  - `list()` is `async`, but its directory scan is not: `readdirSync` blocks the event\n *    loop for the whole listing before the first `await`. Only the per-file reads that\n *    follow it are concurrent.\n *  - Files whose name contains `.tmp` are skipped as orphans of an interrupted\n *    write, and nothing ever removes them.\n */\nexport class JsonFileTaskStore implements TaskStore {\n  constructor(private readonly dir: string) {\n    // EC-1: idempotent mkdir; ignore EEXIST.\n    try {\n      mkdirSync(dir, { recursive: true });\n    } catch (err) {\n      if ((err as NodeJS.ErrnoException).code !== \"EEXIST\") throw err;\n    }\n  }\n\n  private filePath(id: string): string {\n    return join(this.dir, `${id}.json`);\n  }\n\n  async insert(handle: TaskHandle): Promise<void> {\n    assertValidIdForStore(handle.id);\n    await atomicWriteText(this.filePath(handle.id), JSON.stringify(handle));\n  }\n\n  async update(id: string, mutate: (h: TaskHandle) => TaskHandle): Promise<TaskHandle | undefined> {\n    assertValidIdForStore(id);\n    const existing = await this.get(id);\n    if (existing === undefined) return undefined;\n    const next = mutate(existing);\n    await atomicWriteText(this.filePath(id), JSON.stringify(next));\n    return next;\n  }\n\n  async get(id: string): Promise<TaskHandle | undefined> {\n    assertValidIdForStore(id);\n    try {\n      const raw = await readFile(this.filePath(id), \"utf8\");\n      return JSON.parse(raw) as TaskHandle;\n    } catch (err) {\n      const code = (err as NodeJS.ErrnoException).code;\n      if (code === \"ENOENT\") return undefined;\n      // Corrupt JSON or other I/O error — log + degrade gracefully (D50/EC-7 cache pattern).\n      diag(`[task-store] failed to read ${id}: ${(err as Error).message}\\n`);\n      return undefined;\n    }\n  }\n\n  /**\n   * Task ids backed by a file in `dir`, in readdir order.\n   *\n   * EC-8: orphan `.tmp` files left by an interrupted atomic write are skipped, as is any name\n   * outside the id grammar. EC-6: a missing directory lists as empty; any other `readdir` failure\n   * (a permission error, say) throws rather than being reported as \"no tasks\".\n   */\n  private candidateIds(): string[] {\n    let entries: string[];\n    try {\n      entries = readdirSync(this.dir);\n    } catch (err) {\n      if ((err as NodeJS.ErrnoException).code === \"ENOENT\") return []; // EC-6\n      throw err;\n    }\n    return entries\n      .filter((name) => name.endsWith(\".json\") && !name.includes(\".tmp\"))\n      .map((name) => name.slice(0, -\".json\".length))\n      .filter((id) => isValidTaskId(id, true));\n  }\n\n  /**\n   * Read every task in `ids`, handing each loaded handle to `visit`, at most `JSON_LOAD_CAP` file\n   * reads in flight.\n   *\n   * #362 — the cap used to be applied to the directory listing, which made it a bound on WHICH\n   * tasks were visible rather than on how much I/O ran at once. Every filter then ran on that\n   * arbitrary readdir-ordered prefix. As a concurrency bound it does the job it was named for\n   * without deciding what the caller gets to see; the caller's own bound on memory is whatever\n   * `visit` chooses to retain.\n   */\n  private async forEachHandle(\n    ids: readonly string[],\n    visit: (handle: TaskHandle) => void | Promise<void>,\n  ): Promise<void> {\n    for (let start = 0; start < ids.length; start += JSON_LOAD_CAP) {\n      const batch = ids.slice(start, start + JSON_LOAD_CAP);\n      const loaded = await Promise.all(batch.map(async (id) => this.get(id)));\n      for (const handle of loaded) {\n        if (handle !== undefined) await visit(handle);\n      }\n    }\n  }\n\n  async list(filter: TaskFilter): Promise<TaskHandle[]> {\n    const limit = filter.limit ?? DEFAULT_LIST_LIMIT;\n    // Newest-first, keeping at most `limit` handles in memory regardless of how many match. The\n    // order is what makes `submittedBefore` a real cursor: with the previous readdir order, a page\n    // was an arbitrary subset, so a caller walking the timeline skipped every task that happened\n    // to fall outside its window and could never come back for them.\n    const newest: TaskHandle[] = [];\n    await this.forEachHandle(this.candidateIds(), (handle) => {\n      if (!matchesFilter(handle, filter)) return;\n      const at = insertionIndex(newest, handle.submittedAt);\n      if (at >= limit) return; // older than everything already held, and the page is full\n      newest.splice(at, 0, handle);\n      if (newest.length > limit) newest.pop();\n    });\n    return newest;\n  }\n\n  async delete(id: string): Promise<boolean> {\n    assertValidIdForStore(id);\n    try {\n      await unlink(this.filePath(id));\n      return true;\n    } catch (err) {\n      if ((err as NodeJS.ErrnoException).code === \"ENOENT\") return false;\n      throw err;\n    }\n  }\n\n  async evictTerminalOlderThan(epochMs: number): Promise<number> {\n    // #362 — eviction scans the directory itself rather than borrowing `list()`. Sharing that path\n    // made one call incomplete twice over: it saw only a 256-file window, and it wanted the OLDEST\n    // handles while `list()` is ordered newest-first — so on a large directory it could delete\n    // nothing while thousands of eligible handles sat just outside the page. Sweeping every\n    // candidate is what lets one call mean \"everything eligible is gone\".\n    let count = 0;\n    await this.forEachHandle(this.candidateIds(), async (handle) => {\n      if (!TERMINAL_STATES.includes(handle.state)) return;\n      const ts = terminalTimestamp(handle);\n      if (ts === undefined || ts >= epochMs) return;\n      if (await this.delete(handle.id)) count++;\n    });\n    return count;\n  }\n}\n\n/** Factory used by `TaskRegistry.configure` (D364). */\nexport function getTaskStoreFor(options: TaskStoreOptions): TaskStore {\n  if (options.backend === \"memory\") return new InMemoryTaskStore();\n  return new JsonFileTaskStore(options.dir);\n}\n"]}

package/dist/chunk-RFXWMRFC.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/internal/runtime/retry/with-retry.ts","../src/retry.ts"],"names":[],"mappings":"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","file":"chunk-RFXWMRFC.js","sourcesContent":["/**\n * Generic retry wrapper (plan m0-foundation-expose-primitives, M0-3).\n *\n * Exponential backoff with full jitter, deterministically testable via an\n * injectable `sleep` and `rng` (no real timers in unit tests, per the repo\n * testing rule). The default `isRetryable` predicate is {@link isTransientError}\n * so SDK errors retry exactly as the SDK classifies them. The workflow-internal\n * `withRetry` (RetryPolicy-coupled) is intentionally separate (ADR-M0-3).\n *\n * @internal — public via `@theokit/sdk/retry`\n */\n\nimport { ConfigurationError, isTransientError } from \"../../../errors.js\";\n\n/** Options for {@link withRetry}. All fields optional; sensible defaults applied. */\nexport interface RetryOptions {\n  /** Number of retries after the first attempt (total attempts = retries + 1). Default 3. */\n  retries?: number;\n  /** Predicate deciding whether a thrown error is worth retrying. Default {@link isTransientError}. */\n  isRetryable?: (err: unknown) => boolean;\n  /** Base backoff in ms for the first retry. Default 100. */\n  initialDelayMs?: number;\n  /** Upper bound for a single backoff sleep. Default 30_000. */\n  maxDelayMs?: number;\n  /** Exponential multiplier applied per retry. Default 2. */\n  backoffMultiplier?: number;\n  /** [0, 1) source for full-jitter. Default `Math.random`. Inject for deterministic tests. */\n  rng?: () => number;\n  /** Sleep function. Default a `setTimeout`-based abortable sleep. Inject for deterministic tests. */\n  sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;\n  /** Abort signal; once aborted, the abortable default sleep rejects and the loop stops. */\n  signal?: AbortSignal;\n}\n\nfunction defaultSleep(ms: number, signal?: AbortSignal): Promise<void> {\n  return new Promise<void>((resolve, reject) => {\n    if (signal?.aborted) {\n      reject(signal.reason instanceof Error ? signal.reason : new Error(\"withRetry: aborted\"));\n      return;\n    }\n    const timer = setTimeout(() => {\n      signal?.removeEventListener(\"abort\", onAbort);\n      resolve();\n    }, ms);\n    function onAbort(): void {\n      clearTimeout(timer);\n      reject(signal?.reason instanceof Error ? signal.reason : new Error(\"withRetry: aborted\"));\n    }\n    signal?.addEventListener(\"abort\", onAbort, { once: true });\n  });\n}\n\ninterface ResolvedRetry {\n  retries: number;\n  isRetryable: (err: unknown) => boolean;\n  initialDelayMs: number;\n  maxDelayMs: number;\n  backoffMultiplier: number;\n  rng: () => number;\n  sleep: (ms: number, signal?: AbortSignal) => Promise<void>;\n  signal?: AbortSignal;\n}\n\nfunction resolveRetryOptions(options?: RetryOptions): ResolvedRetry {\n  const retries = options?.retries ?? 3;\n  if (!Number.isInteger(retries) || retries < 0) {\n    throw new ConfigurationError(\n      `withRetry: retries must be a non-negative integer, got ${retries}`,\n      { code: \"invalid_retry_config\" },\n    );\n  }\n  return {\n    retries,\n    isRetryable: options?.isRetryable ?? isTransientError,\n    initialDelayMs: options?.initialDelayMs ?? 100,\n    maxDelayMs: options?.maxDelayMs ?? 30_000,\n    backoffMultiplier: options?.backoffMultiplier ?? 2,\n    rng: options?.rng ?? Math.random,\n    sleep: options?.sleep ?? defaultSleep,\n    signal: options?.signal,\n  };\n}\n\n/** Full-jitter backoff for the given (0-indexed) retry attempt. */\nfunction backoffMs(cfg: ResolvedRetry, attempt: number): number {\n  const ceiling = Math.min(cfg.maxDelayMs, cfg.initialDelayMs * cfg.backoffMultiplier ** attempt);\n  return Math.floor(cfg.rng() * ceiling);\n}\n\n/**\n * Run `fn`, retrying transient failures with exponential backoff + full jitter.\n *\n * @returns the resolved value of the first successful `fn()` call\n * @throws the last error when retries are exhausted or the error is not retryable\n *\n * @example\n *   const data = await withRetry(() => fetchJson(url)); // retries rate-limit/network\n */\nexport async function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T> {\n  const cfg = resolveRetryOptions(options);\n  let attempt = 0;\n  for (;;) {\n    try {\n      return await fn();\n    } catch (err) {\n      if (attempt >= cfg.retries || !cfg.isRetryable(err)) throw err;\n      await cfg.sleep(backoffMs(cfg, attempt), cfg.signal);\n      attempt += 1;\n    }\n  }\n}\n","/**\n * Public generic retry primitive (plan m0-foundation-expose-primitives, M0-3).\n *\n * Split into its own top-level module so `tsup` builds a dedicated\n * `@theokit/sdk/retry` sub-path entry, mirroring the `path-safety` pattern.\n * The default retry predicate is `isTransientError`, so retries follow the\n * SDK's own error classification.\n */\n\nimport { type RetryOptions, withRetry } from \"./internal/runtime/retry/with-retry.js\";\n\nexport type { RetryOptions };\n\n/**\n * SE36 — `Retry.create` replaces `withRetry` (ADR 0015 / ADR-P2). NOTE: `withRetry` is an\n * EXECUTOR, not a constructor — `Retry.create(fn, opts)` RUNS `fn` with retry and resolves to\n * its result (`Promise<T>`), not a `Retry` instance. The `.create` name is the uniformity\n * mandate; the executor semantics are the documented, accepted awkwardness. @public\n */\nexport class Retry {\n  private constructor() {}\n  static create<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T> {\n    return withRetry(fn, options);\n  }\n}\n"]}

package/dist/chunk-RIAM53CP.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/internal/runtime/context/path-containment.ts"],"names":[],"mappings":";;;;AAoCO,SAAS,eAAe,IAAA,EAAsB;AACnD,EAAA,IAAI;AACF,IAAA,OAAO,aAAa,IAAI,CAAA;AAAA,EAC1B,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,IAAA;AAAA,EACT;AACF;AAUO,SAAS,UAAA,CAAW,QAAgB,IAAA,EAAuB;AAChE,EAAA,MAAM,MAAM,QAAA,CAAS,cAAA,CAAe,IAAI,CAAA,EAAG,cAAA,CAAe,MAAM,CAAC,CAAA;AACjE,EAAA,OAAO,GAAA,KAAQ,MAAM,CAAC,GAAA,CAAI,WAAW,IAAI,CAAA,IAAK,CAAC,UAAA,CAAW,GAAG,CAAA;AAC/D;AAgBO,SAAS,cAAA,CAAe,QAAgB,IAAA,EAAuB;AACpE,EAAA,OAAO,UAAA,CAAW,QAAQ,IAAI,CAAA,IAAK,eAAe,MAAM,CAAA,KAAM,eAAe,IAAI,CAAA;AACnF","file":"chunk-RIAM53CP.js","sourcesContent":["/**\n * The one rule for \"is this resolved path inside that root\".\n *\n * Extracted because the package held it twice, at different strengths, for the same question. The\n * correct version lived as a private function in `context-import-resolver.ts`, written for the\n * 4.41.1 patch; the context manager had its own `absolute.startsWith(resolvePath(cwd))`, which\n * admits two escapes:\n *\n *   - **No separator boundary.** With `root = /home/user/proj`, the path `/home/user/proj-evil/x`\n *     starts with the root string and is NOT inside it. A sibling directory whose name merely\n *     extends the project's is enough; no `..` past the parent is needed.\n *   - **Lexical, not real.** A symlink whose name sits inside the root and whose target does not\n *     passes any comparison made before symlink resolution.\n *\n * The obvious escapes (`../../etc/passwd`, an absolute path) ARE refused by a prefix test, which is\n * why the weaker version survived review: it looks like it works on the inputs a reader tries.\n *\n * Both readers of repository-supplied paths now share this module. That is DRY about the RULE\n * rather than about line count — one piece of knowledge, one representation, so the two cannot\n * drift apart again.\n *\n * @internal\n */\n\nimport { realpathSync } from \"node:fs\";\nimport { isAbsolute, relative } from \"node:path\";\n\n/**\n * The real path, or the lexical one when it cannot be resolved.\n *\n * The fallback is load-bearing rather than defensive: the context manager checks containment BEFORE\n * it stats the file, so a source that is legitimately absent must still be judged on its declared\n * location instead of being refused for the wrong reason.\n *\n * @internal\n */\nexport function realOrResolved(path: string): string {\n  try {\n    return realpathSync(path);\n  } catch {\n    return path;\n  }\n}\n\n/**\n * Whether `target` is inside `root`, compared AFTER symlink resolution.\n *\n * `relative()` supplies the separator boundary that a prefix test lacks: it answers `..` for a\n * sibling, `''` for the root itself, and an absolute path when the two are on different roots.\n *\n * @internal\n */\nexport function insideRoot(target: string, root: string): boolean {\n  const rel = relative(realOrResolved(root), realOrResolved(target));\n  return rel !== \"\" && !rel.startsWith(\"..\") && !isAbsolute(rel);\n}\n\n/**\n * Whether `target` is the root ITSELF or inside it, compared after symlink resolution.\n *\n * Separate from {@link insideRoot} because the two answer a genuinely different question and their\n * callers need different ones. The context manager asks \"is this source under the project?\", where\n * the project directory itself is not a source. A path JOIN asks \"did this stay within its base?\",\n * where joining nothing and getting the base back is the ordinary case — `safePathJoin(base)` must\n * return `base`.\n *\n * Named here rather than written out at each call site: it appeared twice within one change, which\n * is how this rule ended up with three copies at three strengths the first time.\n *\n * @internal\n */\nexport function atOrInsideRoot(target: string, root: string): boolean {\n  return insideRoot(target, root) || realOrResolved(target) === realOrResolved(root);\n}\n"]}

package/dist/chunk-RMWTPV3M.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/internal/session/agent-session.ts"],"names":["sessions","transcriptKey","hydratedKeys","persistTurn","diag","readSessionMessages"],"mappings":"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","file":"chunk-RMWTPV3M.cjs","sourcesContent":["import type { SessionStore } from \"../../types/session-store.js\";\nimport {\n  type PersistTurnInput,\n  persistTurn,\n  readSessionMessages,\n  type TranscriptLocation,\n} from \"./agent-session-store.js\";\n\n/**\n * Per-agent conversation history kept across runs (and across `Agent.resume()`\n * within the same process). Lets the fixture responder recall prior facts when\n * the user asks a follow-up question.\n *\n * SE40 — disk persistence IS the native Claude-shaped `.jsonl` transcript. The\n * in-memory cache holds the narrowed `SessionMessage[]` (user/assistant text) so\n * a send can read `priorMessages` synchronously; the whole rich turn (user +\n * assistant + tool blocks) lands on disk once per send via {@link persistTurnToTranscript}\n * (fed by `run.conversation()`). Hydration on resume reconstructs the session by\n * walking the transcript DAG (`readSessionMessages`).\n *\n * @internal\n */\n\n// `SessionMessage` lives in `./session-types.ts` (leaf types file). Re-exported\n// for back-compat with downstream importers that pulled it from here.\nexport type { SessionMessage } from \"./session-types.js\";\n\nimport type { SessionMessage } from \"./session-types.js\";\n\n// M75 — the cache lives in a leaf; see session-cache.ts for the reason (cycle broken by extraction).\nexport {\n  hydratedKeys,\n  invalidateSessionCache,\n  sessions,\n  transcriptKey,\n} from \"./session-cache.js\";\n\nimport { diag } from \"../diagnostics.js\";\nimport { hydratedKeys, sessions, transcriptKey } from \"./session-cache.js\";\n\nconst pendingWrites = new Map<string, Promise<void>>();\nconst recordCounts = new Map<string, number>();\n\n/**\n * Append a session message to the in-memory cache only. Disk persistence for the\n * whole turn happens once per send via {@link persistTurnToTranscript}; the cache\n * feeds `priorMessages` / `onBeforeSend.previousMessageCount` synchronously.\n *\n * @internal\n */\nexport function appendSessionMessage(agentId: string, message: SessionMessage): void {\n  const existing = sessions.get(agentId) ?? [];\n  existing.push(message);\n  // `delete` + `set` reinserts at the END: a JS `Map` preserves insertion order, so the first key\n  // is always the least recently touched. That is the entire LRU, with no new structure (parsimony\n  // rungs 2/5 — the ordering we need is already a language guarantee).\n  sessions.delete(agentId);\n  sessions.set(agentId, existing);\n  enforceCeiling();\n}\n\n/**\n * Ceiling on sessions kept in memory.\n *\n * The runtime only reads the **active** session; the rest is pure cache, rebuildable from the\n * on-disk transcript. 32 is deliberately generous — the primary removal path is the explicit\n * `discardSession()` at the end of the agent's life, and this ceiling is a safety net against a\n * long-lived process running hundreds of sessions (plan risk #2: a tight ceiling could evict a\n * session still referenced by an in-flight async path).\n */\nexport const MAX_CACHED_SESSIONS = 32;\n\nfunction enforceCeiling(): void {\n  while (sessions.size > MAX_CACHED_SESSIONS) {\n    const oldest = sessions.keys().next().value;\n    if (oldest === undefined) return;\n    sessions.delete(oldest);\n    forgetBookkeeping(oldest);\n  }\n}\n\n/**\n * Erases the bookkeeping for an `agentId` across EVERY `cwd` it appears in.\n *\n * The three maps are keyed by `transcriptKey(cwd, agentId)`; `sessions` is the only one keyed by the\n * raw `agentId`. The ceiling's first version deleted from all three using `sessions`' key — that is,\n * deleted nothing — and left `hydratedKeys` **orphaned**. Since `hydrateSession` returns early when\n * the marker is present, an evicted session came back **empty** instead of rehydrating from disk:\n * silent amnesia, and a regression new to M95, because before it nothing evicted.\n *\n * The ceiling only knows the `agentId`, not the `cwd`, so it scans by suffix — which is the format\n * `transcriptKey` produces. A scan rather than an index because these maps hold tens of entries, not\n * thousands: a reverse index here would be new structure for a problem that does not exist.\n */\nfunction forgetBookkeeping(agentId: string): void {\n  const suffix = transcriptKey(\"\", agentId).slice(0 - agentId.length - 2);\n  for (const k of [...hydratedKeys]) if (k.endsWith(suffix)) hydratedKeys.delete(k);\n  for (const k of [...pendingWrites.keys()]) if (k.endsWith(suffix)) pendingWrites.delete(k);\n  for (const k of [...recordCounts.keys()]) if (k.endsWith(suffix)) recordCounts.delete(k);\n}\n\n/**\n * Erases the agent's module bookkeeping and returns how many entries were removed.\n *\n * M95 — `invalidateSessionCache` used to clear **two** of the four maps (`sessions`, `hydratedKeys`);\n * `pendingWrites` and `recordCounts` were never touched by id, so they grew for the life of the\n * process. Neither is large per entry — the leak is in count, not volume — but a cache with no owner\n * for removal is a cache that only grows.\n *\n * Returns the count so the caller can prove the removal; a second discard returns 0, which is what\n * makes the idempotency test possible without exposing the maps.\n */\nexport function discardSession(cwd: string, agentId: string): number {\n  const key = transcriptKey(cwd, agentId);\n  let removed = 0;\n  // `sessions` is NOT erased here — and the distinction is measured, not aesthetic. It holds the\n  // readable conversation, and there is a legitimate reader AFTER dispose: the golden\n  // `two-concurrent-sends-serialize` calls `getSessionMessages(agentId)` after `agent.dispose()`.\n  // Erasing it here returned an empty list and broke two goldens. What bounds it is the LRU ceiling\n  // above; the three below are pure bookkeeping, with no post-dispose reader.\n  //\n  // The key is `transcriptKey(cwd, agentId)` in ALL THREE — not the raw `agentId`. The first version\n  // erased two of them by `agentId` and therefore **never erased anything**; the test did not catch\n  // it because it only asserted that the SECOND call returns 0, which is true either way.\n  if (hydratedKeys.delete(key)) removed++;\n  if (pendingWrites.delete(key)) removed++;\n  if (recordCounts.delete(key)) removed++;\n  return removed;\n}\n\nexport function getSessionMessages(agentId: string): SessionMessage[] {\n  return sessions.get(agentId) ?? [];\n}\n\n/**\n * Persist a full conversation turn (user + assistant + tool blocks) to the native\n * transcript. Chained per-(agent, transcript) so on-disk order matches send order,\n * and fire-and-forget so `send()` is not blocked by disk I/O. Every\n * M50 — when the caller supplies `turn.autoCompact`, size-driven auto-compaction (usage real vs\n * the model's context window) runs in this same chain, surfaced via the optional `onCompact` observer.\n *\n * @internal\n */\nexport function persistTurnToTranscript(\n  store: SessionStore,\n  loc: TranscriptLocation,\n  sessionId: string,\n  turn: PersistTurnInput,\n  onCompact?: () => void,\n): void {\n  const key = transcriptKey(loc.cwd, loc.agentId);\n  // PRE-EXISTING debt, exposed when M75 fixed the Biome config that used to abort before\n  // sweeping these files (a nested root under refactor/). It is not new code and was not touched\n  // by M75; refactoring SDK internals without review would trade a visible problem for a diff\n  // risky. Tracked in usetheodev/theokit-sdk#151.\n  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: see the reason just above\n  const chained = (pendingWrites.get(key) ?? Promise.resolve()).then(async () => {\n    try {\n      await persistTurn(store, loc, sessionId, turn);\n      const count = (recordCounts.get(key) ?? 0) + 1;\n      recordCounts.set(key, count);\n      // M50 — the 50-turn no-summary boundary stub is GONE (it silently amnesia'd the session).\n      // Auto-compaction is now size-driven with a real summary: see `maybeAutoCompact` below,\n      // invoked in this same write chain by the post-run lifecycle when usage is known.\n      if (turn.autoCompact !== undefined) {\n        const { autoCompactIfNeeded } = await import(\"./compact-session.js\");\n        const fired = await autoCompactIfNeeded({\n          store,\n          loc,\n          sessionId,\n          usageTotal: turn.autoCompact.usageTotal,\n          contextWindow: turn.autoCompact.contextWindow,\n          turnCount: count,\n          summarize: turn.autoCompact.summarize,\n        });\n        if (fired) onCompact?.();\n      }\n    } catch (cause) {\n      const msg = cause instanceof Error ? cause.message : String(cause);\n      diag(`[theokit-sdk] session transcript write failed (${loc.agentId}): ${msg}\\n`);\n    }\n  });\n  pendingWrites.set(\n    key,\n    chained.then(\n      () => undefined,\n      () => undefined,\n    ),\n  );\n}\n\n/**\n * Load the persisted transcript into the in-memory cache. Idempotent per\n * (baseDir, cwd, agentId). Call once per agent lifecycle before the first read.\n *\n * @internal\n */\nexport async function hydrateSession(\n  agentId: string,\n  loc: { store: SessionStore; cwd: string },\n): Promise<void> {\n  const key = transcriptKey(loc.cwd, agentId);\n  if (hydratedKeys.has(key)) return;\n  hydratedKeys.add(key);\n\n  const persisted = await readSessionMessages(loc.store, agentId);\n  if (persisted.length === 0) return;\n  // M51 review F4 — the DISK is the source of truth at hydration time: after an invalidation\n  // (compact/inject), an in-flight turn may have repopulated the cache with a SINGLE message before\n  // this hydrate ran; the old \"skip when non-empty\" guard then pinned the parent to a 1-message\n  // context (history + injected pair lost until restart). The persist chain serializes writes, so\n  // the disk already contains that in-flight turn — replacing is always correct.\n  sessions.set(agentId, persisted);\n}\n\n/**\n * Wait for all pending transcript writes to settle. Used by tests and by the\n * agent dispose path so on-disk state matches in-memory before the caller proceeds.\n *\n * @internal\n */\nexport async function flushSessionWrites(): Promise<void> {\n  while (pendingWrites.size > 0) {\n    const all = Array.from(pendingWrites.values());\n    pendingWrites.clear();\n    await Promise.all(all);\n  }\n}\n\n/**\n * Drop the in-memory message cache for `agentId` and NOTHING else — the hydration marker in\n * `hydratedKeys` deliberately stays.\n *\n * That asymmetry is the feature, not an oversight, and it is what separates this from\n * `invalidateSessionCache`, which drops both. The single caller is the personality switch's\n * `reset: true` path (`internal/personality/switch.ts`): leaving the marker set makes\n * `hydrateSession` return early, so the next send starts from an EMPTY context instead of\n * replaying the pre-reset transcript off disk. Clearing the marker here would re-hydrate the\n * conversation the reset was asked to discard.\n *\n * The same shape read as a bug one function up: `forgetBookkeeping` documents an evicted session\n * coming back empty as \"silent amnesia\". The difference is intent — eviction wants the transcript\n * back, a reset does not. Anyone reaching for this to invalidate a cache wants\n * `invalidateSessionCache(cwd, agentId)` instead.\n */\nexport function clearSession(agentId: string): void {\n  sessions.delete(agentId);\n}\n\n/**\n * M50 review F5 — run `fn` serialized on the SAME per-(cwd,agentId) write chain the per-turn\n * persistence uses, so a manual `Agent.compact` can never interleave with an in-flight turn's\n * writes (boundary landing mid-turn would orphan the turn from the replay).\n */\nexport function enqueueSessionWrite<T>(\n  cwd: string,\n  agentId: string,\n  fn: () => Promise<T>,\n): Promise<T> {\n  const key = transcriptKey(cwd, agentId);\n  const prior = pendingWrites.get(key) ?? Promise.resolve();\n  const result = prior.then(fn);\n  pendingWrites.set(\n    key,\n    result.then(\n      () => undefined,\n      () => undefined,\n    ),\n  );\n  return result;\n}\n\n/** Test-only: drop every cached session and hydration marker. @internal */\nexport function clearAllSessions(): void {\n  sessions.clear();\n  hydratedKeys.clear();\n  recordCounts.clear();\n  // M50 review F11 — the auto-compact attempt marks live on globalThis; tests reset them here.\n  const g = globalThis as unknown as Record<symbol, Map<string, number>>;\n  const sym = Symbol.for(\"theokit-sdk.session.auto-compact-attempts\");\n  g[sym]?.clear();\n}\n"]}