@jini-ai/chat 0.3.11 → 0.5.0

package/CHANGELOG.md

@@ -0,0 +1,126 @@
+## Unreleased
+
+- Type store fixtures with the shared storage kernel and chat contracts, including host-owned tables;
+  align construction, reopening, paging and message fixtures with current API shapes.
+- Declare jsdom and better-sqlite3 development types for package-wide test compilation.
+
+- Update the A2UI chat renderer and its catalog fixture to the agentic/UI object-argument APIs.
+  Supply the shared system clock and preserve the existing action-ID sequence and timestamp format;
+  adapt interpreter unsubscribe to React cleanup without type assertions.
+- Include tests in package typechecking; align capability/barrel calls, run-event fixtures and the
+  finalizer's asynchronous daemon mock with their current contracts.
+
+- Remove the unexported MCP-UI proof of concept, its fixtures and tests, and the unused internal
+  model picker with its tests. Neither directory was reachable from a public entry point.
+- Exclude both directories' stale compiled output from distribution when rebuilding over an old dist.
+- Drop chat's direct `@mcp-ui/client` and `@mcp-ui/server` dependencies; the live MCP-UI surface
+  continues to use the shared UI implementation. Public exports and runtime behavior are unchanged.
+
+## 0.5.0 — 2026-10-02
+
+### BREAKING
+
+- Browser fetch is injected; run activity/finalization use canonical ports and embed/browser surfaces are isolated. CSS imports remain side effects for bundlers.
+- Distribution includes runtime output, release documentation and required assets only. Process records and per-job neutrality checks are no longer part of the package surface.
+
+- Browser bridge/uploader fetch ports default to global fetch. Partial-upload cleanup now uses the injected uploader fetch; quick deadlines stay 15 seconds. Remove platform dependency and retain native timeout reasons.
+
+- Adopt shared kernel contracts and preserve the module rationale in neutral documentation.
+- Add run-event folding, injected run settlement and the optional AG-UI projection on isolated subpaths.
+- Add opt-in embeddable chat composition, injected fetch/SSE transport, bounded browser session storage and host-controlled page actions on isolated subpaths.
+- Convert public helper and compatibility factory argument shapes to required and optional objects while preserving transcript storage, ownership checks and renderer priority.
+- Correct renderer priority and opt-in stylesheet documentation; retain the layout rationale with neutral provenance.
+- BREAKING: replace the local finalizer Clock with core Clock.nowMs(); core/React helpers and ext-event slot-key callbacks take required objects.
+
+
+- BREAKING: ChatStore methods use required argument objects; paging options move to the second bag. ChatHistoryMaintenance and ChatStoreFactory follow the same convention.
+- BREAKING: SQLite/Postgres/PGlite factories use core `Clock` through `{ clock }` rather than `{ now }`; system-time defaults and SQL behavior are preserved.
+
+## 0.4.0 (unpublished release candidate)
+
+- Owner-scoped transcript adapters and paging live on store subpaths; the host supplies the migrated kernel.
+
+## Unreleased
+
+- Add neutral owner-scoped ChatStore, structured errors and bounded keyset pages.
+- Add SQLite, embedded/socket PGlite and Postgres adapters over the same borrowed kernel SQL body.
+- Preserve the eight-method ChatHistoryStore contract and existing stored schema/projection.
+
+# @jini-ai/chat-core
+
+## @jini-ai/chat 0.3.11
+
+### Patch Changes
+
+- `useChatPaneRuntimeInventory` polls daemon health only while the tab is visible. Hiding the
+  tab clears the interval; showing it checks status once and restarts the interval. A tick is
+  skipped while the previous status call is still in flight. Hosts no longer need their own
+  hidden-tab probe gate for this hook.
+
+## 0.1.2
+
+### Patch Changes
+
+- Add top-level `main`/`types` fields alongside the existing `exports` map. A consumer on
+  TypeScript's classic `moduleResolution: "node"` (node10) — which ignores `package.json#exports`
+  entirely — could not resolve this package's types at all (`TS2307: Cannot find module`) even
+  after the previous exports-map fix restored `require()` at runtime; type resolution and runtime
+  resolution are separate algorithms. Verified against a real external consumer (whose
+  tsconfig uses this legacy resolution mode): adding these two fields, with its tsconfig completely
+  unchanged, made the error disappear. Also fixes absolute-path `require()` (distinct from a bare
+  specifier, which already worked) for the same reason — `main` was previously absent.
+
+  Purely additive: every modern resolver (Node's own runtime `exports` resolution, TypeScript's
+  `bundler`/`node16`/`nodenext`) prefers `exports` over `main`/`types` when both are present, so
+  this changes nothing for a consumer already on a modern resolver.
+
+- Updated dependencies
+  - @jini-ai/agentic@0.1.2
+
+## 0.1.1
+
+### Patch Changes
+
+- Add a `"default"` export condition to every published package's `exports` map — every one of
+  them lacked it, which meant `require()` failed with `ERR_PACKAGE_PATH_NOT_EXPORTED` for any
+  CommonJS consumer (found via a real external integration attempt; Node needs `require(esm)`
+  support, i.e. Node >=22.12, for this to resolve).
+
+  `@jini-ai/agent-runtime`:
+
+  - **New**: `RuntimeBuildOptions.permissionMode` (`'bypass' | 'restricted'`) lets a caller opt a
+    run OUT of the auto-approve-every-permission-prompt flag every def with one
+    (`bypassPermissions` / `--yolo` / `--dangerously-skip-permissions`) previously pushed
+    unconditionally, with no way to turn it off. Omitting it keeps today's default (bypass)
+    behavior unchanged.
+  - **New**: `ClaudeStreamEvent`, `CopilotStreamEvent`, and `QoderEvent` are now real exported
+    discriminated unions instead of `Record<string, unknown>` — a real external consumer guessed a
+    nonexistent field name (`event.text` instead of the actual `event.delta`) against the old
+    untyped sink and silently lost every streamed token with no compile or runtime error.
+  - Fixed a doc/implementation mismatch in `claude-stream.ts`: the module doc claimed `tool_result`
+    events carry `{ tool_use_id, content, is_error }`; the actual emitted shape is
+    `{ toolUseId, content, isError }`.
+
+  `@jini-ai/daemon`: `AgentExecutorRunInput.permissionMode` forwards the new
+  `RuntimeBuildOptions.permissionMode` through to `buildArgs`, so a host can actually reach the new
+  opt-out from the daemon's real run-input surface, not just from `@jini-ai/agent-runtime` in
+  isolation.
+
+  `@jini-ai/agentic`: `setAtPointer` no longer throws on a malformed (e.g. missing leading `/`)
+  `updateDataModel` path — degrades to a no-op like its sibling `getAtPointer`, matching this
+  package's own "a bad binding must not crash the renderer" contract. That path is agent-authored
+  wire data with no error boundary above it in any host, so the uncaught throw could unmount an
+  entire chat UI from ~40 bytes of malformed input.
+
+  `@jini-ai/chat-react`: a local (client-resolved) A2UI button action is no longer a silent no-op —
+  `A2uiSurfaceCard` now surfaces the resolved value. New `ExtEventErrorBoundary` confines a
+  `kind: 'ext'` event group's renderer to its own card instead of letting a render/effect-phase
+  throw from agent-controlled content unmount the whole chat root (there was no error boundary
+  anywhere in this package or its hosts before this).
+
+- Updated dependencies
+  - @jini-ai/agentic@0.1.1
+
+### C2 storage ownership
+- Added `./store/legacy` and `./store/legacy/sqlite`; preserved sync local project chat CRUD and schema.
+- Retained the original owner-isolation suite on the concern adapter after draining the old package.

package/README.md

@@ -3,7 +3,7 @@
 > This README currently documents only the `./core` subpath — chat-core's own content, moved here
 > verbatim. `./react` (formerly `@jini-ai/ui`'s `./chat` export) is landing in the same 2026-08-03
 > consolidation; this file will be extended to cover it once that move is complete rather than
-> rewritten twice. See `packages/chat/src/core/source-map.md` for `./core`'s own provenance.
+> rewritten twice. See the archived provenance ledger for `./core`'s own provenance.
 
 Framework-free chat vocabulary and pure parsers for a chat/artifact frontend: the message and
 run-event types, the `ChatTransport` port a host implements to reach a real agent runtime, and a
@@ -25,7 +25,7 @@ npm install @jini-ai/chat
 import { ChatMessage } from '@jini-ai/chat/core'; // or the bare '@jini-ai/chat' alias
 ```
 
-No peer dependencies. `@jini-ai/agentic` is a regular dependency, pulled in for the
+Core needs no optional peers. `@jini-ai/agentic` is a regular dependency, pulled in for the
 `CapabilityDef` vocabulary this package's `CHAT_CAPABILITIES` manifest is built from.
 
 ## What you get
@@ -78,11 +78,11 @@ const history: ChatMessage[] = [
   { id: '2', role: 'assistant', content: '', runStatus: 'running', events: [] },
 ];
 
-const transcript = buildTranscript(history);
+const transcript = buildTranscript({ history });
 
 function onDone(finalEvents: ChatMessage['events'] = []) {
-  const toolEvents = dedupeToolUsesById(finalEvents);
-  console.log(toolEvents.length, 'tool calls,', isTerminalRunStatus('succeeded'));
+  const toolEvents = dedupeToolUsesById({ events: finalEvents });
+  console.log(toolEvents.length, 'tool calls,', isTerminalRunStatus({ status: 'succeeded' }));
 }
 
 // Implement once per host — a fetch/SSE adapter, a WebSocket adapter, or a test fake.
@@ -105,5 +105,151 @@ ESM only — ships `"type": "module"` with no CommonJS `require` build.
 
 ## Provenance
 
-See [source-map.md](./source-map.md) for per-file provenance and scope decisions. Apache-2.0,
+See the archived provenance ledger for per-file provenance and scope decisions. Apache-2.0,
 inherited from Open Design — see the repo `NOTICE`.
+
+## Durable transcript store
+
+`@jini-ai/chat/store` exports the async `ChatStore`, its immutable owner scope, pages,
+optional search capability contract, and `ChatStoreError`. It loads without SQL, drivers,
+Node builtins or React. The existing eight-method `ChatHistoryStore` remains available
+from core; existing hosts and fakes need no paging methods.
+
+SQL adapters are explicit Node entries: `store/sqlite`, `store/pglite`, `store/postgres`.
+They borrow the host's already-opened, migrated `@jini-ai/db` kernel. They do not open,
+close, migrate or configure it. PGlite accepts embedded and socket transports. PostgreSQL
+requires the node-postgres transport. Each entry rejects mismatched transport/dialect.
+Install db and Kysely for these entries, and inject your own selected driver into db.
+Core supplies the shared `Clock` contract. Pass `{ clock }` as the second factory argument
+(`clock.nowMs()`); omitting it keeps system wall time. All three SQL dialects share the
+same object-method contract. `list()` is a zero-argument read. `pageConversations({},
+{ limit, cursor })` keeps paging in the optional bag; maintenance uses
+`sweepExpired({ now }, { limit })`. Existing hosts and fakes must update positional methods.
+All database and React peers are optional; Kysely dev tests pin 0.29.6 and PGlite 0.5.8.
+
+```ts
+import { createSqliteChatStore } from '@jini-ai/chat/store/sqlite';
+const store = createSqliteChatStore({ kernel, scope: {
+  scopeId: 'workspace', ownerKind: 'user', ownerId: 'account',
+} });
+const page = await store.pageConversations({}, { limit: 50 });
+const conversation = await store.get({ id: 'conversation' });
+await store.appendMessage({ conversationId: 'conversation', message });
+await store.rename({ id: 'conversation', title: 'Title' }, { source: 'manual' });
+```
+
+The host authenticates and binds the scope; guest IDs must already be hashed. Every read
+and mutation enforces all three scope fields, including paging. Missing and foreign IDs
+have identical results. Duplicate creates throw a generic `conflict` without disclosing
+ownership. Driver failures become `unavailable`, retaining the original cause.
+
+Pages default to 50 and accept integer limits 1..200; invalid bounds and continuations
+are structured errors. Conversation pages use `(updatedAt DESC, id ASC)`, message pages
+`(position ASC, id ASC)`. ID ties use UTF-8 byte ordinal ordering (SQLite BINARY / PG C),
+independent of locale. Opaque versioned cursors bind the owner, read kind and conversation;
+validation happens before reading. Deleted anchors remain usable. Pages are live views:
+activity can reorder conversations between calls, so a cursor does not promise a snapshot.
+Each page selects at most limit+1 rows. Compatibility `list` and `messages` return all rows
+and can cost O(N); new consumers should page.
+
+Message upserts keep the original parent, position, role, agent identity and creation time.
+They only persist existing ai_* columns; `resumable` and `lastRunEventId` remain absent.
+Malformed optional JSON leaves text readable and the damaged value absent. No search
+implementation is shipped: the optional capability is absent on every SQL adapter.
+
+Appends join transactions on the exact injected kernel and acquire the conversation lock
+before position allocation. A host ledger must share that kernel and take its run lock
+before calling append; a second kernel for the same file cannot substitute for that context.
+
+Separate privileged `createSqliteChatMaintenance` / PGlite / Postgres factories delete at
+most 500 expired conversations per call (limits 1..500). The host schema supplies cascades;
+SQLite borrowers must have foreign keys enabled. Stores never expose cross-owner maintenance.
+
+SQLite also retains positional `createChatHistoryStore(db, scope, now?)` and
+`createChatHistoryMaintenance(db)` wrappers over db's memoized borrowed kernel. The explicit
+`ensureChatHistoryTables(db)` helper uses the unchanged DDL and is never called by a factory.
+The temporary sqlite-chat entry delegates here; its richer local legacy model stays separate.
+
+Postgres contract tests require `JINI_CHAT_TEST_POSTGRES_URL` naming a disposable
+`jini_chat_test_*` database and fail if it is unavailable; use `pnpm run test:postgres`.
+PGlite socket tests bind a local socket and must run on a host permitting that operation.
+
+## Legacy local-project SQLite API
+
+`@jini-ai/chat/store/legacy` exports the old `ChatSessionMode` vocabulary. `./store/legacy/sqlite`
+exports the unchanged synchronous conversation/message CRUD and `LEGACY_CHAT_DDL`, receiving a
+borrowed structural `SqliteDb`. This is the local single-user `conversations`/`messages` model,
+separate from the owner-scoped `ai_chats`/`ai_chat_messages` ChatStore. Server storage composes its
+schema with projects and rich daemon sessions. No chat constructor opens a driver or migrates a host DB.
+
+## Design decisions
+
+- [Queued page actions are consumed before execution](docs/decisions/DR-001-single-shot-page-actions.md).
+- [Streaming adapters close message boundaries on interruption](docs/decisions/DR-002-stream-interruption-boundaries.md).
+- [Human surfaces survive reconnect with honest status](docs/decisions/DR-003-human-surface-rehydration.md).
+
+## Kernel contracts
+
+Run finalization receives `Clock` from `@jini-ai/core/primitives` and reads `nowMs()`;
+`RunActivityClock` remains a separate activity value object. Public core/React helpers receive
+required argument objects: e.g. `isTerminalRunStatus({ status })`,
+`assistantContentFromEvents({ events })`, `useRunStream({ transport })`, and
+`registerExtEventRenderer({ name, renderer }, { slotKey })`. A slot-key callback receives `{ data }`.
+`interleaveMessageBlocks({ events, content, rows }, { slotOf })` retains its reconstruction checks.
+The isolated `core/run-events`, `core/ag-ui`, `server/run-finalizer`, `react/embed`,
+`transports/fetch-sse`, `browser/session-store` and `browser/page-actions` subpaths are published.
+`FrontendSessionBridgeArgs` is exported from `react`; hosts pass baseUrl and openStream, optionally request or native fetch.
+The SSE transport takes an injected decoder; browser hosts must supply a browser-safe module.
+
+## React integration boundaries
+
+Model/provider selection belongs to the host-injected `ModelAgentPickerSlot`, because choosing
+an LLM or agent is a provider concern rather than a chat-domain concern. The unused internal
+picker was removed after a fresh caller check confirmed that only its own tests reached it.
+It had already been removed from the public React barrel in August 2026; no public export changes.
+
+The retired picker combined provider grouping, credential badges and a searchable trigger/popover
+from earlier UI implementations. Its rules were independent of chat state and React; the hook
+owned open/query state and outside-click/Escape subscriptions. Static host-supplied lists needed
+no transport, while a host could inject a live-catalogue fetch. The popover rendered inline for
+testability because chat had no positioning/collision primitive; hosts handled clipping with CSS.
+Credential ordering preferred configured providers, preserving model order on ties. Unknown
+providers received a fallback label rather than disappearing; unknown selected IDs remained custom
+values, and auto-selection was opt-in. Search was omitted below eight options, blank search kept
+all groups, and subtitles avoided repeating the provider label. Badge labels used host i18n;
+the protocol catalogue type had a local alias to avoid an unrelated runtime model-type collision.
+
+The unexported official MCP-UI proof of concept and its fixtures were also removed. It evaluated
+the upstream resource builder and client through ESM: client 7.1.1's CommonJS entry failed in
+the original experiment. Its pre-fetched HTML bypassed resource fetching; delivery still required
+a sandbox proxy's readiness handshake. The jsdom probe checked iframe creation, sandboxing and
+sizing rather than a live handshake, and jsdom dropped the client's `border: none` shorthand.
+The live `McpUiSurfaceCard` delegates to `@jini-ai/ui/mcp-ui`, whose official client integration
+owns the sandbox lifecycle. Chat therefore no longer declares either MCP-UI vendor dependency.
+The distribution excludes both removed directories' compiled output, including stale files left
+by a build over an existing `dist` directory.
+
+## A2UI renderer integration
+
+`A2uiSurfaceCard` composes the agentic interpreter with the shared core system clock and an
+action-ID sequence. It preserves wall-clock timestamps and the existing
+`a2ui-action-<sequence>-<base36 timestamp>` IDs. Catalog, registry and interpreter calls use
+their required argument objects; React cleanup wraps the interpreter's object-argument
+unsubscribe. Text values retain the catalog's validated wire shape through `DynamicValueSchema`.
+
+Package typechecking includes `src/**/__tests__/**` so fixture API drift is reported alongside
+production errors. Store contract fixtures use the typed chat store and storage kernel,
+including fixture-owned host tables. Paging fixtures require a continuation before reusing it,
+and stored message fixtures conform to the current event and attachment contracts. Development
+declarations for jsdom and better-sqlite3 are provided by their `@types` dependencies.
+
+## Browser fetch defaults
+
+`createFrontendSessionBridge({ baseUrl, openStream, fetch?, request? }, options)`
+uses native fetch by default, with a 15-second deadline. An explicit `request`
+continues to take precedence. `createDaemonAttachmentUploader({ baseUrl, fetch? }, options)`
+uses the same fetch for upload and partial-upload cleanup; omission uses
+`globalThis.fetch`. Cleanup has its own 15-second abort deadline and does not
+inherit the failed upload's cancellation. Upload quotas and its 30-second batch
+deadline are unchanged. Browser timeout reasons remain native; platform is no
+longer a dependency of this package.

package/dist/core/ag-ui/entry.d.ts

@@ -0,0 +1,53 @@
+/** Pure chat-event to AG-UI projection; lifecycle state belongs to one run.
+ * This legacy wire reducer is independent of saved-chat reduction: partial tool input remains
+ * a CUSTOM extension, while media stays in run-event vocabulary and is absent from TOOL_CALL_RESULT.
+ * Strict interruption ordering closes a message before a tool starts. IDs and custom event names
+ * are injected, with official AG-UI types authoritative; auth, routes and encoder stay with the host.
+ * The host emits RUN_STARTED and terminal RUN_FINISHED/RUN_ERROR outside this pure projection. */
+import { EventType, type AGUIEvent } from '@ag-ui/core';
+import type { AgentEvent } from '../events.js';
+export interface EventIdGenerator {
+    next(args: {
+        prefix: string;
+        ordinal: number;
+    }): string;
+}
+export interface CustomEventNames {
+    readonly usage: string;
+    readonly status: string;
+    readonly extensionPrefix: string;
+}
+export interface RunAgentWirePayload {
+    readonly type: string;
+    readonly [key: string]: unknown;
+}
+/** Preserve the legacy AG-UI wire reduction, including partial input as extension events.
+ * Unlike the saved-chat reducer, this projection carries partial tool-input extensions. */
+export declare function reduceAgentWirePayload({ payload }: {
+    payload: RunAgentWirePayload;
+}): AgentEvent | null;
+export type AgUiEvent = Extract<AGUIEvent, {
+    type: EventType.RUN_STARTED | EventType.RUN_FINISHED | EventType.RUN_ERROR | EventType.TEXT_MESSAGE_START | EventType.TEXT_MESSAGE_CONTENT | EventType.TEXT_MESSAGE_END | EventType.REASONING_START | EventType.REASONING_MESSAGE_START | EventType.REASONING_MESSAGE_CONTENT | EventType.REASONING_MESSAGE_END | EventType.REASONING_END | EventType.TOOL_CALL_START | EventType.TOOL_CALL_ARGS | EventType.TOOL_CALL_END | EventType.TOOL_CALL_RESULT | EventType.RAW | EventType.CUSTOM;
+}>;
+export interface AgUiTranslationState {
+    openTextMessageId: string | null;
+    openReasoningMessageId: string | null;
+    nextId: number;
+    readonly ids: EventIdGenerator;
+    readonly customEventNames: CustomEventNames;
+}
+/** Create isolated per-run translation state with explicit IDs and custom-event wire names. */
+export declare function createAgUiTranslationState({ ids, customEventNames }: {
+    ids: EventIdGenerator;
+    customEventNames: CustomEventNames;
+}): AgUiTranslationState;
+/** Emit ordered message/tool lifecycles; a tool call closes the preceding message first. */
+export declare function translateAgentEventToAgUi({ event, state }: {
+    event: AgentEvent;
+    state: AgUiTranslationState;
+}): AgUiEvent[];
+/** Close open text/reasoning before the host emits RUN_FINISHED or RUN_ERROR. */
+export declare function closeAgUiRun({ state }: {
+    state: AgUiTranslationState;
+}): AgUiEvent[];
+//# sourceMappingURL=entry.d.ts.map

package/dist/core/ag-ui/entry.js

@@ -0,0 +1,135 @@
+/** Pure chat-event to AG-UI projection; lifecycle state belongs to one run.
+ * This legacy wire reducer is independent of saved-chat reduction: partial tool input remains
+ * a CUSTOM extension, while media stays in run-event vocabulary and is absent from TOOL_CALL_RESULT.
+ * Strict interruption ordering closes a message before a tool starts. IDs and custom event names
+ * are injected, with official AG-UI types authoritative; auth, routes and encoder stay with the host.
+ * The host emits RUN_STARTED and terminal RUN_FINISHED/RUN_ERROR outside this pure projection. */
+import { EventType } from '@ag-ui/core';
+function asString(v) {
+    return typeof v === "string" ? v : v == null ? "" : JSON.stringify(v);
+}
+function reduceUsagePayload(payload) {
+    const usage = (payload.usage ?? {});
+    return {
+        kind: "usage",
+        ...(typeof usage.input_tokens === "number" ? { inputTokens: usage.input_tokens } : {}),
+        ...(typeof usage.output_tokens === "number" ? { outputTokens: usage.output_tokens } : {}),
+        ...(typeof payload.costUsd === "number" ? { costUsd: payload.costUsd } : {}),
+        ...(typeof payload.durationMs === "number" ? { durationMs: payload.durationMs } : {}),
+    };
+}
+const WIRE_PAYLOAD_REDUCERS = {
+    status: (payload) => ({ kind: "status", label: asString(payload.label), ...(payload.detail ? { detail: asString(payload.detail) } : {}) }),
+    text_delta: (payload) => ({ kind: "text", text: asString(payload.delta) }),
+    thinking_delta: (payload) => ({ kind: "thinking", text: asString(payload.delta) }),
+    tool_use: (payload) => ({ kind: "tool_use", id: asString(payload.id), name: asString(payload.name), input: payload.input }),
+    tool_result: (payload) => ({
+        kind: "tool_result",
+        toolUseId: asString(payload.toolUseId),
+        content: asString(payload.content),
+        isError: Boolean(payload.isError),
+    }),
+    usage: reduceUsagePayload,
+    raw: (payload) => ({ kind: "raw", line: asString(payload.line) }),
+    "mcp-ui": (payload) => ({ kind: "ext", name: "mcp-ui", data: payload.resource }),
+    a2ui: (payload) => ({ kind: "ext", name: "a2ui", data: payload.message }),
+    thinking_start: () => null,
+};
+/** Preserve the legacy AG-UI wire reduction, including partial input as extension events.
+ * Unlike the saved-chat reducer, this projection carries partial tool-input extensions. */
+export function reduceAgentWirePayload({ payload }) {
+    const reducer = Object.hasOwn(WIRE_PAYLOAD_REDUCERS, payload.type) ? WIRE_PAYLOAD_REDUCERS[payload.type] : undefined;
+    return reducer ? reducer(payload) : { kind: "ext", name: payload.type, data: payload };
+}
+/** Create isolated per-run translation state with explicit IDs and custom-event wire names. */
+export function createAgUiTranslationState({ ids, customEventNames }) {
+    return { openTextMessageId: null, openReasoningMessageId: null, nextId: 0, ids, customEventNames: { ...customEventNames } };
+}
+function mintId(state, prefix) {
+    state.nextId += 1;
+    return state.ids.next({ prefix, ordinal: state.nextId });
+}
+function closeOpenMessages(state) {
+    const events = [];
+    if (state.openTextMessageId) {
+        events.push({ type: EventType.TEXT_MESSAGE_END, messageId: state.openTextMessageId });
+        state.openTextMessageId = null;
+    }
+    if (state.openReasoningMessageId) {
+        const messageId = state.openReasoningMessageId;
+        events.push({ type: EventType.REASONING_MESSAGE_END, messageId });
+        events.push({ type: EventType.REASONING_END, messageId });
+        state.openReasoningMessageId = null;
+    }
+    return events;
+}
+function handleTextAgentEvent(event, state) {
+    const events = [];
+    if (state.openReasoningMessageId)
+        events.push(...closeOpenMessages(state));
+    if (!state.openTextMessageId) {
+        state.openTextMessageId = mintId(state, "msg");
+        events.push({ type: EventType.TEXT_MESSAGE_START, messageId: state.openTextMessageId, role: "assistant" });
+    }
+    events.push({ type: EventType.TEXT_MESSAGE_CONTENT, messageId: state.openTextMessageId, delta: event.text });
+    return events;
+}
+function handleThinkingAgentEvent(event, state) {
+    const events = [];
+    if (state.openTextMessageId)
+        events.push(...closeOpenMessages(state));
+    if (!state.openReasoningMessageId) {
+        state.openReasoningMessageId = mintId(state, "reasoning");
+        events.push({ type: EventType.REASONING_START, messageId: state.openReasoningMessageId });
+        events.push({ type: EventType.REASONING_MESSAGE_START, messageId: state.openReasoningMessageId, role: "reasoning" });
+    }
+    events.push({ type: EventType.REASONING_MESSAGE_CONTENT, messageId: state.openReasoningMessageId, delta: event.text });
+    return events;
+}
+function handleToolUseAgentEvent(event, state) {
+    const events = [];
+    if (state.openTextMessageId || state.openReasoningMessageId)
+        events.push(...closeOpenMessages(state));
+    events.push({ type: EventType.TOOL_CALL_START, toolCallId: event.id, toolCallName: event.name });
+    events.push({ type: EventType.TOOL_CALL_ARGS, toolCallId: event.id, delta: JSON.stringify(event.input ?? {}) });
+    events.push({ type: EventType.TOOL_CALL_END, toolCallId: event.id });
+    return events;
+}
+/** Emit ordered message/tool lifecycles; a tool call closes the preceding message first. */
+export function translateAgentEventToAgUi({ event, state }) {
+    switch (event.kind) {
+        case "text":
+            return handleTextAgentEvent(event, state);
+        case "thinking":
+            return handleThinkingAgentEvent(event, state);
+        case "tool_use":
+            return handleToolUseAgentEvent(event, state);
+        case "tool_result":
+            return [
+                {
+                    type: EventType.TOOL_CALL_RESULT,
+                    messageId: mintId(state, "tool_result_msg"),
+                    toolCallId: event.toolUseId,
+                    content: event.content,
+                    role: "tool",
+                },
+            ];
+        case "usage":
+            return [{ type: EventType.CUSTOM, name: state.customEventNames.usage, value: event }];
+        case "status":
+            return [{ type: EventType.CUSTOM, name: state.customEventNames.status, value: event }];
+        case "raw":
+            return [{ type: EventType.RAW, event: event.line }];
+        case "ext":
+            return [{ type: EventType.CUSTOM, name: `${state.customEventNames.extensionPrefix}${event.name}`, value: event.data }];
+        default: {
+            const neverEvent = event;
+            throw new Error(`translateAgentEventToAgUi: unhandled AgentEvent.kind ${JSON.stringify(neverEvent)}`);
+        }
+    }
+}
+/** Close open text/reasoning before the host emits RUN_FINISHED or RUN_ERROR. */
+export function closeAgUiRun({ state }) {
+    return closeOpenMessages(state);
+}
+//# sourceMappingURL=entry.js.map

package/dist/core/agentic/chat-capabilities.d.ts

@@ -11,7 +11,7 @@
  * This is a genuine chat product surface, not vocabulary — unlike its former siblings here
  * (capability.ts, page-capabilities.ts, …), which moved to `@jini-ai/agentic` on 2026-07-26 so a
  * non-chat consumer could depend on the vocabulary without depending on chat. This file stayed
- * behind on purpose: it's the proof the split is real (see `@jini-ai/agentic`'s source-map.md).
+ * behind on purpose: it's the proof the split is real (see `@jini-ai/agentic`'s archived provenance ledger).
  */
 import type { CapabilityDef } from '@jini-ai/agentic';
 /** The bounded, explicit set of chat-pane capabilities every transport surface hosts. */

package/dist/core/agentic/index.d.ts

@@ -6,7 +6,7 @@
  * Everything that used to live here besides `chat-capabilities.ts` (the framework-free
  * `CapabilityDef` vocabulary, the two shipped manifests' shared machinery, the `data-agent-*`
  * markup convention, and the protocol projections) moved to `@jini-ai/agentic` on 2026-07-26 — see
- * `packages/agentic/source-map.md` for the extraction and why. This barrel now only exports
+ * `packages/agentic/archived provenance ledger` for the extraction and why. This barrel now only exports
  * `CHAT_CAPABILITIES`, the seven `chat.*` verbs that are a genuine chat product surface rather
  * than generic vocabulary.
  *

package/dist/core/agentic/index.js

@@ -6,7 +6,7 @@
  * Everything that used to live here besides `chat-capabilities.ts` (the framework-free
  * `CapabilityDef` vocabulary, the two shipped manifests' shared machinery, the `data-agent-*`
  * markup convention, and the protocol projections) moved to `@jini-ai/agentic` on 2026-07-26 — see
- * `packages/agentic/source-map.md` for the extraction and why. This barrel now only exports
+ * `packages/agentic/archived provenance ledger` for the extraction and why. This barrel now only exports
  * `CHAT_CAPABILITIES`, the seven `chat.*` verbs that are a genuine chat product surface rather
  * than generic vocabulary.
  *

package/dist/core/assistant-content.d.ts

@@ -23,7 +23,11 @@ export declare const ASSISTANT_STEP_SEPARATOR = "\n\n";
  * @param events - The turn's events, in arrival order.
  * @complexity O(total text length).
  */
-export declare function assistantContentFromEvents(events: readonly AgentEvent[] | undefined): string;
+export declare function assistantContentFromEvents({ events }: {
+    events: readonly AgentEvent[] | undefined;
+}): string;
 /** The pre-2026-09-27 rule (plain concatenation), kept only so older saved rows still match. */
-export declare function legacyAssistantContentFromEvents(events: readonly AgentEvent[] | undefined): string;
+export declare function legacyAssistantContentFromEvents({ events }: {
+    events: readonly AgentEvent[] | undefined;
+}): string;
 //# sourceMappingURL=assistant-content.d.ts.map

package/dist/core/assistant-content.js

@@ -11,7 +11,7 @@ function separatorBefore(out, text) {
  * @param events - The turn's events, in arrival order.
  * @complexity O(total text length).
  */
-export function assistantContentFromEvents(events) {
+export function assistantContentFromEvents({ events }) {
     let out = '';
     let stepBoundary = false;
     for (const ev of events ?? []) {
@@ -30,7 +30,7 @@ export function assistantContentFromEvents(events) {
     return out;
 }
 /** The pre-2026-09-27 rule (plain concatenation), kept only so older saved rows still match. */
-export function legacyAssistantContentFromEvents(events) {
+export function legacyAssistantContentFromEvents({ events }) {
     let out = '';
     for (const ev of events ?? []) {
         if (ev.kind === 'text')

package/dist/core/compact-events.d.ts

@@ -19,5 +19,7 @@ import type { AgentEvent } from './events.js';
  * @param events - A turn's events, in arrival order.
  * @complexity O(number of events + total text length).
  */
-export declare function mergeAdjacentTextEvents(events: readonly AgentEvent[] | undefined): AgentEvent[];
+export declare function mergeAdjacentTextEvents({ events }: {
+    events: readonly AgentEvent[] | undefined;
+}): AgentEvent[];
 //# sourceMappingURL=compact-events.d.ts.map

package/dist/core/compact-events.js

@@ -8,7 +8,7 @@ function isDelta(event) {
  * @param events - A turn's events, in arrival order.
  * @complexity O(number of events + total text length).
  */
-export function mergeAdjacentTextEvents(events) {
+export function mergeAdjacentTextEvents({ events }) {
     const out = [];
     for (const event of events ?? []) {
         const last = out[out.length - 1];

package/dist/core/events.d.ts

@@ -7,7 +7,7 @@
  * decoupled from it: a host's transport adapter is responsible for reducing
  * wire deltas (`text_delta`, `thinking_delta`, `tool_input_delta`, ...) into
  * the persisted/renderable `AgentEvent` items below before handing them to
- * chat-core's pure helpers. See source-map.md for the provenance of this
+ * chat-core's pure helpers. See archived provenance ledger for the provenance of this
  * split and why chat-core does not itself depend on `@jini-ai/protocol`.
  */
 /**

package/dist/core/events.js

@@ -7,7 +7,7 @@
  * decoupled from it: a host's transport adapter is responsible for reducing
  * wire deltas (`text_delta`, `thinking_delta`, `tool_input_delta`, ...) into
  * the persisted/renderable `AgentEvent` items below before handing them to
- * chat-core's pure helpers. See source-map.md for the provenance of this
+ * chat-core's pure helpers. See archived provenance ledger for the provenance of this
  * split and why chat-core does not itself depend on `@jini-ai/protocol`.
  */
 export {};

package/dist/core/index.d.ts

@@ -4,7 +4,7 @@
  * Zero React, zero DOM/browser globals, zero Node built-ins, zero imports
  * from any product package's scope. See ADS-memory/reports/jini-port/extraction-plan.md
  * §12 C2/C3 and ADS-memory/reports/jini-port/recon/r4b-webui-design.md §1 for the design
- * this package targets, and source-map.md for exact provenance.
+ * this package targets, and archived provenance ledger for exact provenance.
  *
  * Was `@jini-ai/chat-core` (its own top-level package, one entry point) through npm 0.1.2 —
  * consolidated 2026-08-03 into `@jini-ai/chat`'s `./core` subpath alongside `./react` (formerly
@@ -31,13 +31,13 @@ export * from './compact-events.js';
  * vocabulary this used to sit alongside — `CapabilityDef`, `PAGE_CAPABILITIES`, the
  * `data-agent-*` convention, the policy gate, the protocol projections — moved to `@jini-ai/agentic`
  * on 2026-07-26; import it directly rather than through this package. See
- * `packages/agentic/source-map.md` and this package's own source-map.md for the extraction.
+ * `packages/agentic/archived provenance ledger` and this package's own archived provenance ledger for the extraction.
  */
 export * from './agentic/index.js';
 /**
  * Durable chat history — the storage-neutral `ChatHistoryStore` port and the local title
  * heuristic. Types and pure functions only, so this package stays framework-free and
- * `runtime: universal`; the SQLite implementation lives in `@jini-ai/sqlite`'s `chat-history`
+ * `runtime: universal`; the SQLite implementation lives in `@jini-ai/sqlite-chat`'s `chat-history`
  * module, and a host binds it to its own authentication.
  */
 export * from './persistence/index.js';