@jini-ai/chat 0.5.4 → 0.5.5

package/dist/core/browser/page-actions.d.ts

@@ -0,0 +1,121 @@
+/** Resolved target supplied by the host; the client never derives a path from a title. */
+export interface ResolvedPageTarget {
+    readonly slug: string;
+    readonly title: string;
+    readonly path: string;
+}
+export type PageAction = {
+    readonly type: 'navigate';
+    readonly target: ResolvedPageTarget;
+    readonly auto: boolean;
+} | {
+    readonly type: 'scroll_to' | 'highlight';
+    readonly target: ResolvedPageTarget;
+};
+export type NavigateAction = Extract<PageAction, {
+    type: 'navigate';
+}>;
+export type NonNavigateAction = Exclude<PageAction, {
+    type: 'navigate';
+}>;
+export interface DirectiveCarryingEvent {
+    readonly kind: string;
+    readonly name?: string;
+    readonly data?: unknown;
+}
+export interface SplitPageActions {
+    readonly navigate: NavigateAction | null;
+    readonly other: NonNavigateAction | null;
+}
+/** Narrows an untrusted, bare queued action. URL authorization remains a separate host policy. O(1). */
+export declare function isQueuedPageAction(args: {
+    value: unknown;
+}): args is {
+    value: PageAction;
+};
+/** Narrows an untrusted directive envelope, dropping unknown kinds. O(1). */
+export declare function isPageActionDirective(args: {
+    value: unknown;
+}): args is {
+    value: {
+        kind: 'page_action';
+        action: PageAction;
+    };
+};
+/** Preserves valid action order while ignoring unrelated events. O(events) time and output space. */
+export declare function extractPageActions({ events, directiveEventName }: {
+    events: readonly DirectiveCarryingEvent[] | undefined;
+    directiveEventName: string;
+}): PageAction[];
+/** Returns only the first navigation and first page treatment. O(actions), O(1) extra space. */
+export declare function splitPageActions({ actions }: {
+    actions: readonly PageAction[];
+}): SplitPageActions;
+export interface TargetSelectionPolicy {
+    readonly candidateSelector: string;
+    readonly excludedAncestorSelector: string;
+}
+/** Exact title match first, case-insensitive fallback; never searches excluded UI. O(candidates). */
+export declare function findTargetElement({ title, root, selection }: {
+    title: string;
+    root: Pick<ParentNode, 'querySelectorAll'>;
+    selection: TargetSelectionPolicy;
+}): Element | null;
+export interface PageActionTimerPort {
+    schedule(args: {
+        callback: () => void;
+        delayMs: number;
+    }): unknown;
+    cancel(args: {
+        handle: unknown;
+    }): void;
+}
+export interface PageActionPort {
+    allows(args: {
+        action: PageAction;
+    }): boolean;
+    navigate(args: {
+        action: NavigateAction;
+    }): boolean;
+    execute(args: {
+        action: NonNavigateAction;
+    }): boolean;
+    clearHighlight(args: Record<string, never>): void;
+}
+export interface BrowserPageActionController extends PageActionPort {
+    applyHighlight(args: {
+        element: Element;
+    }): void;
+    scrollToElement(args: {
+        element: Element;
+    }): void;
+}
+export interface BrowserPageActionsArgs {
+    readonly root: Pick<ParentNode, 'querySelectorAll'>;
+    readonly selection: TargetSelectionPolicy;
+    readonly allowPath: (args: {
+        path: string;
+    }) => boolean;
+    readonly navigate: (args: {
+        path: string;
+    }) => void;
+    readonly reducedMotion: (args: Record<string, never>) => boolean;
+    readonly scroll: (args: {
+        element: Element;
+        options: ScrollIntoViewOptions;
+    }) => void;
+    readonly timers: PageActionTimerPort;
+    readonly highlightClass: string;
+    readonly fadeAnimationName: string;
+    readonly cleanupFallbackMs: number;
+}
+/**
+ * Creates page effects with injected DOM, navigation, URL policy, scroll and timers.
+ * At most one highlight belongs to this instance; cleanup and navigation remove it.
+ * URL policy is checked before queueing, navigation or page effects. Stale timers and descendant
+ * animation events cannot remove the current highlight. Navigation paths are resolved by the host,
+ * never guessed from a title; each controller owns its mutable highlight state.
+ * @complexity Execute O(candidates); other operations O(1), with one timer/listener retained.
+ */
+export declare function createBrowserPageActions(args: BrowserPageActionsArgs): BrowserPageActionController;
+//# sourceMappingURL=page-actions.d.ts.map

package/dist/core/browser/page-actions.js

@@ -0,0 +1,113 @@
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function target(value) {
+    return record(value) && typeof value.slug === 'string' && typeof value.title === 'string' && typeof value.path === 'string';
+}
+/** Narrows an untrusted, bare queued action. URL authorization remains a separate host policy. O(1). */
+export function isQueuedPageAction(args) {
+    const { value } = args;
+    if (!record(value) || !target(value.target))
+        return false;
+    return value.type === 'navigate' ? typeof value.auto === 'boolean' : value.type === 'scroll_to' || value.type === 'highlight';
+}
+/** Narrows an untrusted directive envelope, dropping unknown kinds. O(1). */
+export function isPageActionDirective(args) {
+    const { value } = args;
+    return record(value) && value.kind === 'page_action' && isQueuedPageAction({ value: value.action });
+}
+/** Preserves valid action order while ignoring unrelated events. O(events) time and output space. */
+export function extractPageActions({ events, directiveEventName }) {
+    const actions = [];
+    for (const event of events ?? []) {
+        const envelope = { value: event.data };
+        if (event.kind === 'ext' && event.name === directiveEventName && isPageActionDirective(envelope)) {
+            actions.push(envelope.value.action);
+        }
+    }
+    return actions;
+}
+/** Returns only the first navigation and first page treatment. O(actions), O(1) extra space. */
+export function splitPageActions({ actions }) {
+    return {
+        navigate: actions.find((a) => a.type === 'navigate') ?? null,
+        other: actions.find((a) => a.type !== 'navigate') ?? null,
+    };
+}
+/** Exact title match first, case-insensitive fallback; never searches excluded UI. O(candidates). */
+export function findTargetElement({ title, root, selection }) {
+    const needle = title.trim();
+    if (!needle)
+        return null;
+    const candidates = Array.from(root.querySelectorAll(selection.candidateSelector))
+        .filter(el => !el.closest(selection.excludedAncestorSelector));
+    return candidates.find(el => (el.textContent ?? '').trim() === needle)
+        ?? candidates.find(el => (el.textContent ?? '').trim().toLowerCase() === needle.toLowerCase()) ?? null;
+}
+/**
+ * Creates page effects with injected DOM, navigation, URL policy, scroll and timers.
+ * At most one highlight belongs to this instance; cleanup and navigation remove it.
+ * URL policy is checked before queueing, navigation or page effects. Stale timers and descendant
+ * animation events cannot remove the current highlight. Navigation paths are resolved by the host,
+ * never guessed from a title; each controller owns its mutable highlight state.
+ * @complexity Execute O(candidates); other operations O(1), with one timer/listener retained.
+ */
+export function createBrowserPageActions(args) {
+    if (!Number.isFinite(args.cleanupFallbackMs) || args.cleanupFallbackMs < 0)
+        throw new Error('Invalid highlight deadline');
+    let current = null;
+    const clearHighlight = (_args) => {
+        if (!current)
+            return;
+        const old = current;
+        current = null;
+        args.timers.cancel({ handle: old.handle });
+        old.element.removeEventListener('animationend', old.onEnd);
+        old.element.classList.remove(args.highlightClass);
+    };
+    function highlight(element) {
+        if (current?.element === element)
+            return;
+        clearHighlight({});
+        const onEnd = event => {
+            if (event.target === element && event.animationName === args.fadeAnimationName)
+                clearHighlight({});
+        };
+        element.classList.add(args.highlightClass);
+        element.addEventListener('animationend', onEnd);
+        // Identity check makes even a late callback from a canceled timer harmless.
+        const handle = args.timers.schedule({ delayMs: args.cleanupFallbackMs, callback: () => {
+                if (current?.element === element && current.onEnd === onEnd)
+                    clearHighlight({});
+            } });
+        current = { element, handle, onEnd };
+    }
+    const scrollToElement = ({ element }) => {
+        args.scroll({ element, options: { behavior: args.reducedMotion({}) ? 'auto' : 'smooth', block: 'center' } });
+    };
+    return {
+        applyHighlight({ element }) { highlight(element); },
+        scrollToElement,
+        allows({ action }) { return args.allowPath({ path: action.target.path }); },
+        navigate({ action }) {
+            if (!args.allowPath({ path: action.target.path }))
+                return false;
+            clearHighlight({});
+            args.navigate({ path: action.target.path });
+            return true;
+        },
+        execute({ action }) {
+            if (!args.allowPath({ path: action.target.path }))
+                return false;
+            const element = findTargetElement({ title: action.target.title, root: args.root, selection: args.selection });
+            if (!element)
+                return false;
+            scrollToElement({ element });
+            if (action.type === 'highlight')
+                highlight(element);
+            return true;
+        },
+        clearHighlight,
+    };
+}
+//# sourceMappingURL=page-actions.js.map

package/dist/core/durable-runs/continuation.d.ts

@@ -0,0 +1,18 @@
+import type { AgentEvent } from "../index.js";
+import type { AcceptedRunRequest, DurableRun } from "./ports.js";
+export declare const CONTINUATION_DIVIDER = "\n\n---\n\nContinued\n\n";
+export declare const UNKNOWN_MUTATION_ERROR = "This operation may already be done. Its earlier outcome is unknown; verify the current state before repeating it.";
+/** Object-key order and a new tool-use id must not turn the same mutation into a new operation. */
+export declare function canonicalToolInput({ value }: {
+    value: unknown;
+}, _optional?: {}): string;
+export declare function hasUnknownToolCall({ events, toolId, input }: {
+    events: readonly AgentEvent[];
+    toolId: string;
+    input: unknown;
+}, _optional?: {}): boolean;
+export declare function continuationRequest({ run, native }: {
+    run: DurableRun;
+    native: boolean;
+}, _optional?: {}): AcceptedRunRequest;
+//# sourceMappingURL=continuation.d.ts.map

package/dist/core/durable-runs/continuation.js

@@ -0,0 +1,61 @@
+export const CONTINUATION_DIVIDER = "\n\n---\n\nContinued\n\n";
+export const UNKNOWN_MUTATION_ERROR = "This operation may already be done. Its earlier outcome is unknown; verify the current state before repeating it.";
+/** Object-key order and a new tool-use id must not turn the same mutation into a new operation. */
+export function canonicalToolInput({ value }, _optional = {}) {
+    if (Array.isArray(value))
+        return `[${value.map((item) => canonicalToolInput({ value: item }, {})).join(",")}]`;
+    if (value !== null && typeof value === "object") {
+        const object = value;
+        return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${canonicalToolInput({ value: object[key] }, {})}`).join(",")}}`;
+    }
+    return JSON.stringify(value) ?? "null";
+}
+function delegatedCall(event) {
+    const input = event.input;
+    if (input && typeof input.toolId === "string" && /execute.*delegated_tool/.test(event.name))
+        return { toolId: input.toolId, input: input.input };
+    return { toolId: event.name, input: event.input };
+}
+export function hasUnknownToolCall({ events, toolId, input }, _optional = {}) {
+    const completed = new Set(events.filter((event) => event.kind === "tool_result").map((event) => event.toolUseId));
+    const canonical = canonicalToolInput({ value: input }, {});
+    return events.some((event) => {
+        if (event.kind !== "tool_use" || completed.has(event.id))
+            return false;
+        const call = delegatedCall(event);
+        return call.toolId === toolId && canonicalToolInput({ value: call.input }, {}) === canonical;
+    });
+}
+function toolHistory(events) {
+    const results = new Map(events.filter((event) => event.kind === "tool_result").map((event) => [event.toolUseId, event]));
+    return events.filter((event) => event.kind === "tool_use").map((event) => {
+        const result = results.get(event.id);
+        return JSON.stringify({ call: delegatedCall(event), result: result ?? "OUTCOME UNKNOWN: verify state before repeating" });
+    }).join("\n");
+}
+export function continuationRequest({ run, native }, _optional = {}) {
+    const original = JSON.parse(run.request.contextRef);
+    // Native sessions may have disappeared on deploy. Reconstruction includes the saved answer
+    // and tool results for every runtime; completed side effects must never be silently repeated.
+    const transcript = run.transcript.map((message) => `${message.role}: ${message.content}`).join("\n\n");
+    const prompt = [
+        "Continue the interrupted answer from the saved work below. Preserve completed work. Do not repeat completed mutations.",
+        "Calls without a result have an unknown outcome: inspect current state before any retry. Expired plans or approvals must be re-planned and re-approved; never reuse them.",
+        "A pending question may be asked again when its process was lost. The interrupted segment remains visible; append the continuation.",
+        `Accepted task:\n${String(original.prompt ?? "")}`,
+        native ? "Native session is confirmed; continue its saved task." : `Saved conversation:\n${transcript}`,
+        `Saved partial answer:\n${run.message.content}`,
+        `Saved tool calls and results:\n${toolHistory(run.message.events ?? [])}`,
+    ].join("\n\n");
+    return {
+        ...run.request,
+        contextRef: JSON.stringify({ ...original, prompt, conversationId: run.conversationId,
+            assistantMessageId: run.messageId, principalId: run.principalId,
+            recoveryMode: native ? "native" : "reconstruction", recoverySessionId: native ? run.sessionId : undefined,
+            // Old attachment claims have been consumed. Saved transcript/tool results carry their
+            // observations; attempting to claim the same ids again would fail before execution.
+            attachmentIds: [],
+        }),
+    };
+}
+//# sourceMappingURL=continuation.js.map

package/dist/core/durable-runs/ledger-contracts.d.ts

@@ -0,0 +1,53 @@
+import type { ChatMessage } from "../index.js";
+import type { DurableRunStore } from "./ports.js";
+import type { RunRef, RunProgress, RunSettlement } from "./run-contracts.js";
+export type { RunRef, RunProgress, RunSettlement } from "./run-contracts.js";
+/** {@link ChatRunLedger.unlessSettled}'s result: the write's value, or that the run had settled. */
+export type UnlessSettled<T> = {
+    readonly written: true;
+    readonly value: T;
+} | {
+    readonly written: false;
+};
+/** Internal boot recovery, never an HTTP history read. The owner comes from storage, not a client. */
+export interface InterruptedChatTurn {
+    readonly principalId: string | null;
+    readonly conversationId: string;
+    readonly message: ChatMessage;
+}
+export interface ChatRunRecoveryOptions {
+    /** True retains the row: a daemon run was adopted with bounded resolution of uncertainty.
+     * Called outside storage transactions so a daemon request cannot hold the database lock. */
+    readonly recover?: (input: InterruptedChatTurn) => Promise<boolean>;
+}
+export interface ChatRunLedger {
+    readonly durable?: DurableRunStore;
+    /**
+     * Runs `write` only while `run`'s row holds no terminal status (an unknown row, another run id, or
+     * a row still `queued`/`running` all count as unsettled), with no settle able to land in between.
+     * `write` must reach the chat database through this ledger's kernel (the same connection, on
+     * SQLite) so it joins the transaction.
+     */
+    unlessSettled<T>(required: {
+        run: RunRef;
+        write: () => Promise<T>;
+    }, optional?: {}): Promise<UnlessSettled<T>>;
+    /**
+     * Writes the run's final content, events and status — only if the row still belongs to that run
+     * and is not yet terminal. Resolves `true` when this call was the one that settled it.
+     */
+    settle(settlement: RunSettlement, optional?: {}): Promise<boolean>;
+    /**
+     * Saves what a still-running run has produced so far (content and events; the status stays), so
+     * a process that dies mid-run leaves its partial answer for {@link reconcileInterrupted} to keep.
+     * A no-op once the row is terminal or belongs to another run. Resolves `true` when it wrote.
+     */
+    checkpoint(progress: RunProgress, optional?: {}): Promise<boolean>;
+    /** Serving-only discovery of unfinished rows. The injected recovery coordinator owns adopted
+     * runs; rows it cannot adopt are canceled, preserving saved work. Returns handled rows.
+     * Export apps must not invoke discovery while a serving daemon is still alive. */
+    reconcileInterrupted(required?: {
+        now?: number;
+    }, optional?: ChatRunRecoveryOptions): Promise<number>;
+}
+//# sourceMappingURL=ledger-contracts.d.ts.map

package/dist/core/durable-runs/ledger-contracts.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ledger-contracts.js.map

package/dist/core/durable-runs/policies.d.ts

@@ -0,0 +1,6 @@
+export declare const RECOVERY_LIMIT = 3;
+export declare const RECOVERY_WINDOW_MS: number;
+export declare const RUN_STALENESS_MS: number;
+export declare const SAVED_WORK_NOTICE = "The assistant stopped after making no progress. Saved work is above.";
+export declare const EXHAUSTED_NOTICE = "The assistant could not continue this answer. Saved work is above.";
+//# sourceMappingURL=policies.d.ts.map

package/dist/core/durable-runs/policies.js

@@ -0,0 +1,6 @@
+export const RECOVERY_LIMIT = 3;
+export const RECOVERY_WINDOW_MS = 5 * 60_000;
+export const RUN_STALENESS_MS = 30 * 60_000;
+export const SAVED_WORK_NOTICE = "The assistant stopped after making no progress. Saved work is above.";
+export const EXHAUSTED_NOTICE = "The assistant could not continue this answer. Saved work is above.";
+//# sourceMappingURL=policies.js.map

package/dist/core/durable-runs/ports.d.ts

@@ -0,0 +1,123 @@
+import type { AgentEvent, ChatMessage } from "../index.js";
+import type { RunRef, RunSettlement } from "./ledger-contracts.js";
+export interface AcceptedRunRequest {
+    readonly agentId?: string;
+    readonly contextRef: string;
+}
+export interface DurableRun extends RunRef {
+    readonly workspaceId: string;
+    readonly principalId: string | null;
+    readonly engine: string;
+    readonly message: ChatMessage;
+    readonly request: AcceptedRunRequest;
+    readonly transcript: readonly ChatMessage[];
+    readonly recoveryCount: number;
+    readonly recoveryDeadline: number | null;
+    readonly attemptStartedAt: number;
+    readonly lastProgressAt: number;
+    readonly cancelReason: string | null;
+    readonly sessionId: string | null;
+    readonly sessionConfirmed: boolean;
+    readonly child: {
+        pid: number;
+        startedAt: string;
+    } | null;
+    readonly attemptBase: readonly AgentEvent[];
+}
+export interface DurableRunStore {
+    load(required: {
+        messageId: string;
+    }, optional: {}): Promise<DurableRun | null>;
+    find(required: {
+        runId: string;
+        principalId?: string;
+    }, optional: {}): Promise<DurableRun | null>;
+    accept(required: RunRef & {
+        principalId: string;
+        workspaceId: string;
+        request: AcceptedRunRequest;
+        now: number;
+    }, optional: {}): Promise<DurableRun | null>;
+    advance(required: {
+        run: DurableRun;
+        nextRunId: string;
+        now: number;
+        events: readonly AgentEvent[];
+    }, optional: {}): Promise<boolean>;
+    cancel(required: {
+        runId: string;
+        reason: string;
+    }, optional: {}): Promise<void>;
+    cancelPending(required: RunRef & {
+        principalId: string;
+        workspaceId: string;
+        now: number;
+    }, optional: {}): Promise<DurableRun | null>;
+    captureSession(required: {
+        runId: string;
+        sessionId: string;
+        confirmed?: boolean;
+        child?: {
+            pid: number;
+            startedAt: string;
+        };
+    }, optional: {}): Promise<boolean>;
+    clearSession(required: {
+        runId: string;
+        sessionId: string;
+    }, optional: {}): Promise<void>;
+    recoveryClock(required: {
+        runId: string;
+        now: number;
+        active: boolean;
+    }, optional: {}): Promise<void>;
+    guardTool(required: {
+        runId: string;
+        toolId: string;
+        input: unknown;
+        toolUseId?: string;
+    }, optional: {}): Promise<"allowed" | "unknown" | "stale">;
+    completeTool(required: {
+        runId: string;
+        toolUseId: string;
+        content: string;
+    }, optional: {}): Promise<void>;
+}
+export type RunProbe = "live" | "dead" | "uncertain";
+export interface RecoveryPorts {
+    readonly store: DurableRunStore;
+    readonly now: () => number;
+    readonly mintRunId: () => string;
+    readonly probe: (required: DurableRun, optional: {}) => Promise<RunProbe>;
+    readonly attach: (required: DurableRun, optional: {}) => void;
+    readonly launch: (required: {
+        run: DurableRun;
+        request: AcceptedRunRequest;
+    }, optional: {}) => Promise<void>;
+    readonly cancelAttempt: (required: DurableRun, optional: {}) => Promise<void>;
+    readonly verifyChildDead: (required: {
+        pid: number;
+        startedAt: string;
+    }, optional: {}) => Promise<boolean>;
+    readonly supportsNativeResume: (required: {
+        agentId: string;
+    }, optional: {}) => boolean;
+    readonly settle: (required: RunSettlement, optional: {}) => Promise<boolean>;
+}
+export type RecoveryTrigger = "boot" | "browser" | "stream" | "timeout" | "attempt-failed";
+export type RecoveryResult = "gone" | "terminal" | "reattached" | "waiting" | "continued" | "superseded" | "finalized";
+export interface DurableRecovery {
+    recover(required: {
+        messageId: string;
+        trigger: RecoveryTrigger;
+        expectedRunId?: string;
+    }, optional: {
+        /** Fresh HTTP 200 from the owning watch's bounded probe, scoped to exactly that attempt. */
+        liveRunId?: string;
+    }): Promise<RecoveryResult>;
+}
+/** Host run-ID classification; never infer transport identity from an engine default. */
+export type RunIdPolicy = (required: {
+    runId: string;
+}, optional?: {}) => boolean;
+//# sourceMappingURL=ports.d.ts.map

package/dist/core/durable-runs/ports.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ports.js.map

package/dist/core/durable-runs/run-contracts.d.ts

@@ -0,0 +1,17 @@
+import type { AgentEvent } from "../events.js";
+import type { ChatRunStatus } from "../messages.js";
+/** Exactly which run owns the row; the host binds authorization and storage scope. */
+export interface RunRef {
+    readonly conversationId: string;
+    readonly messageId: string;
+    readonly runId: string;
+}
+export interface RunProgress extends RunRef {
+    readonly content: string;
+    readonly events: readonly AgentEvent[];
+}
+export interface RunSettlement extends RunProgress {
+    readonly status: Extract<ChatRunStatus, 'succeeded' | 'failed' | 'canceled'>;
+    readonly endedAt: number;
+}
+//# sourceMappingURL=run-contracts.d.ts.map

package/dist/core/durable-runs/run-contracts.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=run-contracts.js.map

package/dist/core/durable-runs/run-lock.d.ts

@@ -0,0 +1,4 @@
+/** Every checkpoint, settlement and attempt CAS shares this message lock. */
+import type { RunRef } from "./ledger-contracts.js";
+export declare function runLockKey(run: RunRef, _optional?: {}): string;
+//# sourceMappingURL=run-lock.d.ts.map

package/dist/core/durable-runs/run-lock.js

@@ -0,0 +1,4 @@
+export function runLockKey(run, _optional = {}) {
+    return `chat-run:${run.conversationId}:${run.messageId}`;
+}
+//# sourceMappingURL=run-lock.js.map

package/dist/core/index.d.ts

@@ -1,16 +1,7 @@
 /**
- * `@jini-ai/chat/core` — framework-free chat vocabulary + pure parsers.
- *
- * 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 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
- * `@jini-ai/ui`'s `./chat` export), following `@jini-ai/admin`'s umbrella-with-subpaths precedent.
- * `@jini-ai/chat-core` is retired, not deprecated-and-kept — its published npm versions
- * (0.1.0–0.1.2) go end-of-life as-is; `@jini-ai/chat` supersedes it.
+ * @jini-ai/chat/core — framework-free chat vocabulary and pure parsers.
+ * No React, DOM/browser globals, Node built-ins or product-package imports (extraction-plan §12
+ * C2/C3). Hosts can implement the transport port without importing a browser component graph.
  */
 export * from './events.js';
 export * from './messages.js';
@@ -27,13 +18,8 @@ export * from './run-activity.js';
 export * from './surface-expiry.js';
 export * from './assistant-content.js';
 export * from './compact-events.js';
-/**
- * The chat pane's own capability manifest (`CHAT_CAPABILITIES`). The framework-free agent-control
- * 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/archived provenance ledger` and this package's own archived provenance ledger for the extraction.
- */
+/** Chat-pane capability manifest. Generic agent-control vocabulary, markup and projections are
+ * owned by @jini-ai/agentic; import them there so non-chat callers stay independent of chat. */
 export * from './agentic/index.js';
 /**
  * Durable chat history — the storage-neutral `ChatHistoryStore` port and the local title
@@ -45,4 +31,5 @@ export * from './persistence/index.js';
 export { recoveredRunEvents } from './durable-projection.js';
 export { composerHistoryKeyAction, createComposerHistoryState, mergeComposerHistory, normalizeComposerHistory, transitionComposerHistory, } from './composer-history.js';
 export type { ComposerHistoryKeyInput, ComposerHistoryState, ComposerHistoryStoragePort } from './composer-history.js';
+export * from './user-text-redaction.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -1,16 +1,7 @@
 /**
- * `@jini-ai/chat/core` — framework-free chat vocabulary + pure parsers.
- *
- * 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 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
- * `@jini-ai/ui`'s `./chat` export), following `@jini-ai/admin`'s umbrella-with-subpaths precedent.
- * `@jini-ai/chat-core` is retired, not deprecated-and-kept — its published npm versions
- * (0.1.0–0.1.2) go end-of-life as-is; `@jini-ai/chat` supersedes it.
+ * @jini-ai/chat/core — framework-free chat vocabulary and pure parsers.
+ * No React, DOM/browser globals, Node built-ins or product-package imports (extraction-plan §12
+ * C2/C3). Hosts can implement the transport port without importing a browser component graph.
  */
 export * from './events.js';
 export * from './messages.js';
@@ -27,13 +18,8 @@ export * from './run-activity.js';
 export * from './surface-expiry.js';
 export * from './assistant-content.js';
 export * from './compact-events.js';
-/**
- * The chat pane's own capability manifest (`CHAT_CAPABILITIES`). The framework-free agent-control
- * 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/archived provenance ledger` and this package's own archived provenance ledger for the extraction.
- */
+/** Chat-pane capability manifest. Generic agent-control vocabulary, markup and projections are
+ * owned by @jini-ai/agentic; import them there so non-chat callers stay independent of chat. */
 export * from './agentic/index.js';
 /**
  * Durable chat history — the storage-neutral `ChatHistoryStore` port and the local title
@@ -44,4 +30,5 @@ export * from './agentic/index.js';
 export * from './persistence/index.js';
 export { recoveredRunEvents } from './durable-projection.js';
 export { composerHistoryKeyAction, createComposerHistoryState, mergeComposerHistory, normalizeComposerHistory, transitionComposerHistory, } from './composer-history.js';
+export * from './user-text-redaction.js';
 //# sourceMappingURL=index.js.map

package/dist/core/messages.d.ts

@@ -33,6 +33,8 @@ export interface ChatAttachment {
  * host layers those on top via its own message extension, not this type.
  */
 export interface ChatMessage {
+    /** Transient safe receipt; storage requires no new column. */
+    secretRedaction?: import('./user-text-redaction.js').SecretRedactionSignal;
     id: string;
     role: ChatRole;
     content: string;

package/dist/core/question-form/format.d.ts

@@ -1,12 +1,3 @@
-/**
- * @module question-form/format
- *
- * Answer presentation: turning a submitted answer set into the prose the
- * agent reads on its next turn, plus the label/value lookups also used by
- * `normalize.ts`'s default-value resolution. Split out of the original
- * single-file `question-form.ts`; see `../question-form.ts` for the public
- * facade.
- */
 import type { FormOption, QuestionForm } from './types.js';
 /**
  * Format a finished set of answers into a prose user message the agent can