@datalayer/agent-runtimes 1.5.70 → 1.5.73

package/lib/portable/attention.js

@@ -0,0 +1,352 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * What a host says outside the chat about a session, and when (VSCODE
+ * VS-07, VS-10; DESKTOP DK-14, DK-25): the approvals, the questions, the
+ * finished turns, a runtime gone — pure, no host API, no React.
+ *
+ * - **An approval raised** — an *ask me first* decision — is said as a
+ *   notification that names the application, the action and its class
+ *   (*read*, *write*, *send*, *buy*, *delete*, *execute*, *publish*) and
+ *   never its arguments (DESKTOP decision D-8: a notification is read on a
+ *   lock screen): the request is read whole in the chat, and a decision
+ *   from the notification is allowed only once the chat has shown it. The
+ *   decision goes through the place's one way after the approval is read
+ *   again: one answered elsewhere (409, or no longer pending) is said so;
+ *   one that is gone (404) reveals nothing.
+ * - **The count** of sessions waiting for the person: the editor's status
+ *   bar, the desktop's dock badge and tray.
+ * - **A finished turn**, a question asked or a runtime gone, of a session
+ *   the chat does not show, is said as a notification with the first line
+ *   of its answer; the session in front is never notified (what the person
+ *   is looking at needs no toast).
+ *
+ * @module portable/attention
+ */
+import { actionOf } from './approvalCard.js';
+/** Every class, for a strict read of what an approval says. */
+export const ACTION_CLASSES = [
+    'read',
+    'write',
+    'send',
+    'buy',
+    'delete',
+    'execute',
+    'publish',
+];
+/**
+ * A coding agent's ACP `kind`, as a class: `read`, `search`, `fetch` read;
+ * `edit`, `move` write; `delete` deletes; `execute` executes; `other` is a
+ * write (fail closed), as the Shield maps them.
+ */
+export const ACP_KIND_CLASSES = {
+    read: 'read',
+    search: 'read',
+    fetch: 'read',
+    edit: 'write',
+    move: 'write',
+    delete: 'delete',
+    execute: 'execute',
+    other: 'write',
+};
+/** The verbs a tool's name starts with, when the approval names no class. */
+const NAMED_CLASSES = [
+    [/^(run|exec|execute|shell|bash|terminal|command)\b/i, 'execute'],
+    [/^(delete|remove|rm|drop|unlink)\b/i, 'delete'],
+    [/^(send|mail|email|reply|message|post)\b/i, 'send'],
+    [/^(publish|deploy|release|push)\b/i, 'publish'],
+    [/^(buy|pay|purchase|order|charge)\b/i, 'buy'],
+    [/^(read|search|fetch|grep|glob|list|find|get|view|open|cat)\b/i, 'read'],
+];
+const text = (value) => typeof value === 'string' ? value : '';
+/**
+ * The class of what an approval asks: `_class` when it names one of the
+ * seven, else its ACP `_kind` mapped, else the verb its tool's name starts
+ * with; `write` when nothing says (fail closed, as `other` is).
+ *
+ * @param approval - Its tool and arguments.
+ *
+ * @returns One of the seven classes.
+ */
+export function actionClassOf(approval) {
+    const named = text(approval.args._class).toLowerCase();
+    if (ACTION_CLASSES.includes(named)) {
+        return named;
+    }
+    const kind = ACP_KIND_CLASSES[text(approval.args._kind).toLowerCase()];
+    if (kind) {
+        return kind;
+    }
+    const words = approval.toolName.replace(/[_\-.:/]+/g, ' ').trim();
+    for (const [verb, cls] of NAMED_CLASSES) {
+        if (verb.test(words)) {
+            return cls;
+        }
+    }
+    return 'write';
+}
+/** The notification's three answers, in their order. */
+export const APPROVAL_ACTIONS = ['Approve', 'Decline', 'Show'];
+/** What a host says of approvals and decisions. */
+export const ATTENTION_WORDS = {
+    /**
+     * The sentence of a notification: *Support Desk asks to Run git push (execute)*.
+     *
+     * @param app - The application asking.
+     * @param action - What it asks to do, in words.
+     * @param cls - The action's class.
+     *
+     * @returns The sentence.
+     */
+    asks: (app, action, cls) => `${app} asks to ${action} (${cls})`,
+    notShown: 'Open the chat to read the whole request before deciding it: Show.',
+    answeredElsewhere: 'This approval was answered elsewhere.',
+    gone: 'This approval is no longer waiting.',
+    approved: (action) => `Approved: ${action}.`,
+    declined: (action) => `Declined: ${action}.`,
+    refused: (status) => `The decision was refused (${status}).`,
+    working: 'Datalayer: working…',
+    waiting: (count) => `Datalayer: ${count} waiting for you`,
+    finished: (title) => `${title} finished its turn.`,
+    asksYou: (title) => `${title} is waiting for you.`,
+    runtimeGone: (title) => `${title}: its runtime went away.`,
+};
+/**
+ * The notification an approval is said as: the application, the action in
+ * words (`send_email` → *Send email*) and its class — never its arguments.
+ *
+ * @param app - The application asking.
+ * @param approval - What it asks: its tool and arguments.
+ *
+ * @returns The message and its answers.
+ */
+export function approvalNotification(app, approval) {
+    return {
+        message: ATTENTION_WORDS.asks(app, actionOf(approval.toolName), actionClassOf(approval)),
+        actions: APPROVAL_ACTIONS,
+    };
+}
+/**
+ * The approvals to notify: those pending now that were not seen before —
+ * each is notified once, however often the banner is read again.
+ *
+ * @param seen - The ids notified already.
+ * @param pending - What is pending now.
+ *
+ * @returns The approvals not seen before, in the order asked.
+ */
+export function newlyRaised(seen, pending) {
+    return pending.filter(approval => !seen.has(approval.id));
+}
+/**
+ * Whether a decision may be taken from the notification: only once the chat
+ * has shown the request whole at least once.
+ *
+ * @param shown - The ids the chat has shown.
+ * @param id - The approval to decide.
+ *
+ * @returns Whether deciding is allowed.
+ */
+export function decisionAllowed(shown, id) {
+    return shown.has(id);
+}
+/**
+ * Whether an approval read again still waits: decided only then.
+ *
+ * @param readAgain - The approval as read again, or null when the read failed.
+ *
+ * @returns Whether it is still pending.
+ */
+export function stillPending(readAgain) {
+    return Boolean(readAgain) && text(readAgain?.status) === 'pending';
+}
+/**
+ * What a decision came to, in a sentence: done; answered elsewhere (409);
+ * gone (404, which reveals nothing of it); refused with its status.
+ *
+ * @param status - The route's status.
+ * @param approved - Whether approval was asked.
+ * @param action - The action in words.
+ *
+ * @returns The sentence.
+ */
+export function decisionOutcome(status, approved, action) {
+    if (status >= 200 && status < 300) {
+        return approved
+            ? ATTENTION_WORDS.approved(action)
+            : ATTENTION_WORDS.declined(action);
+    }
+    if (status === 409) {
+        return ATTENTION_WORDS.answeredElsewhere;
+    }
+    if (status === 404) {
+        return ATTENTION_WORDS.gone;
+    }
+    return ATTENTION_WORDS.refused(status);
+}
+/** The turn's phase in words, after the state. */
+const phaseWords = {
+    idle: '',
+    running: 'answering',
+    waiting: 'waiting for you',
+    '': '',
+};
+/**
+ * One session in a sentence: *Open · answering — shield-mvp-claude-code*.
+ *
+ * @param session - Its state, turn and agent.
+ *
+ * @returns The sentence.
+ */
+export function sessionSaid(session) {
+    const state = session.state.charAt(0).toUpperCase() + session.state.slice(1);
+    const phase = session.state === 'open' ? phaseWords[session.turn] : '';
+    const stated = phase ? `${state} · ${phase}` : state;
+    return session.agent ? `${stated} — ${session.agent}` : stated;
+}
+/**
+ * The sessions waiting for the person: open, their turn waiting.
+ *
+ * @param sessions - The sessions watched.
+ *
+ * @returns The waiting ones, in order.
+ */
+export function waitingSessions(sessions) {
+    return sessions.filter(session => session.state === 'open' && session.turn === 'waiting');
+}
+/**
+ * What a dock badge counts (DK-14): the sessions waiting for the person.
+ *
+ * @param sessions - The sessions watched.
+ *
+ * @returns The count; zero clears the badge.
+ */
+export function badgeCount(sessions) {
+    return waitingSessions(sessions).length;
+}
+/**
+ * The status bar's item (VS-10): *Datalayer: 2 waiting for you* when sessions
+ * wait (the first waiting one is what a click opens), *Datalayer: working…*
+ * while a turn of any runs, nothing otherwise. The tooltip says the
+ * session in front.
+ *
+ * @param sessions - The sessions watched.
+ *
+ * @returns The item, or null when it is hidden.
+ */
+export function statusBarItem(sessions) {
+    const open = sessions.filter(session => session.state === 'open');
+    const waiting = open.filter(session => session.turn === 'waiting');
+    const running = open.filter(session => session.turn === 'running');
+    const front = sessions.find(session => session.inFront);
+    const tooltip = front ? `${front.title}: ${sessionSaid(front)}` : '';
+    const [firstWaiting] = waiting;
+    if (firstWaiting) {
+        return {
+            text: ATTENTION_WORDS.waiting(waiting.length),
+            tooltip: tooltip || `${firstWaiting.title}: ${sessionSaid(firstWaiting)}`,
+            first: firstWaiting.key,
+        };
+    }
+    const [firstRunning] = running;
+    if (firstRunning) {
+        return {
+            text: ATTENTION_WORDS.working,
+            tooltip: tooltip || `${firstRunning.title}: ${sessionSaid(firstRunning)}`,
+            first: firstRunning.key,
+        };
+    }
+    return null;
+}
+/**
+ * The tray's menu: a heading with the count, then one *Open* entry per
+ * session waiting for the person; *Nothing waits for you* when none does.
+ *
+ * @param sessions - The sessions watched.
+ *
+ * @returns The entries, the heading first.
+ */
+export function trayMenuOf(sessions) {
+    const waiting = waitingSessions(sessions);
+    if (waiting.length === 0) {
+        return [{ key: '', label: 'Nothing waits for you' }];
+    }
+    return [
+        { key: '', label: ATTENTION_WORDS.waiting(waiting.length) },
+        ...waiting.map(session => ({
+            key: session.key,
+            label: `Open ${session.title || session.key}`,
+        })),
+    ];
+}
+const firstLine = (value) => (value ?? '').split('\n').find(line => line.trim()) ?? '';
+/**
+ * The turns to notify between two readings: a session **not in front**
+ * whose turn was running and is not any more (the first line of its answer,
+ * else that it finished), whose turn came to wait for the person (a
+ * question, `loop.ask`), or whose runtime went away. The session in front
+ * is never notified; a session first seen is not.
+ *
+ * @param before - The sessions as last read.
+ * @param after - The sessions as read now.
+ *
+ * @returns The notices, in the order of `after`.
+ */
+export function finishedTurns(before, after) {
+    const was = new Map(before.map(session => [session.key, session]));
+    const notices = [];
+    for (const session of after) {
+        if (session.inFront) {
+            continue;
+        }
+        const earlier = was.get(session.key);
+        if (!earlier) {
+            continue;
+        }
+        const title = session.title || session.key;
+        if (earlier.held !== false && session.held === false) {
+            notices.push({
+                key: session.key,
+                title,
+                said: ATTENTION_WORDS.runtimeGone(title),
+                kind: 'gone',
+            });
+            continue;
+        }
+        if (session.state !== 'open') {
+            continue;
+        }
+        if (earlier.turn !== 'waiting' && session.turn === 'waiting') {
+            notices.push({
+                key: session.key,
+                title,
+                said: ATTENTION_WORDS.asksYou(title),
+                kind: 'asks',
+            });
+            continue;
+        }
+        if (earlier.turn === 'running' && session.turn !== 'running') {
+            notices.push({
+                key: session.key,
+                title,
+                said: firstLine(session.lastAnswer) || ATTENTION_WORDS.finished(title),
+                kind: 'finished',
+            });
+        }
+    }
+    return notices;
+}
+/**
+ * How the OS cues the person (DK-14, Omnigent's rule): a banner when the
+ * host is not in front; a dock bounce or a taskbar flash when it is, so
+ * nothing covers what they look at.
+ *
+ * @param frontmost - Whether the host's window is focused.
+ *
+ * @returns `banner` or `cue`.
+ */
+export function cueOf(frontmost) {
+    return frontmost ? 'cue' : 'banner';
+}

package/lib/portable/conversation.js

@@ -35,10 +35,10 @@
  *
  * @module portable/conversation
  */
-import { REACTOR_UI_NAME, toolResultOf, UI_ON_RUN, } from './agui';
-import { DISPLAY_META_KEY, displayOfToolResult, protocolDisplayOf, } from './displays';
-import { RUN_END_WORDS } from './records';
-import { messagesOfThread } from './thread';
+import { REACTOR_UI_NAME, toolResultOf, UI_ON_RUN, } from './agui.js';
+import { DISPLAY_META_KEY, displayOfToolResult, protocolDisplayOf, } from './displays.js';
+import { RUN_END_WORDS } from './records.js';
+import { messagesOfThread } from './thread.js';
 /** How many rows a conversation on a phone keeps: its newest. */
 export const ITEM_LIMIT = 400;
 /** How many characters of an answer a phone keeps. */

package/lib/portable/displays.js

@@ -34,7 +34,7 @@
  *
  * @module portable/displays
  */
-import { isPapSignInTool, readPapSignIn, } from './signIn';
+import { isPapSignInTool, readPapSignIn, } from './signIn.js';
 export const PAP_SIGN_IN_TYPE = 'application/vnd.datalayer.pap.sign-in+json';
 export const PAP_CONFIRM_TYPE = 'application/vnd.datalayer.pap.confirm+json';
 export const PAP_OUTCOME_TYPE = 'application/vnd.datalayer.pap.outcome+json';

package/lib/portable/fixtures.js

@@ -10,8 +10,8 @@
  *
  * @module portable/fixtures
  */
-import { emptyConversation } from './conversation';
-import { RUN_END_WORDS } from './records';
+import { emptyConversation } from './conversation.js';
+import { RUN_END_WORDS } from './records.js';
 /** A fresh copy of the fixture conversation. */
 /**
  * A coding agent's diff and terminal, as the runtime sends them beside a tool

package/lib/portable/hosts/agentClient.js

@@ -14,10 +14,10 @@
  * @module portable/hosts/agentClient
  */
 import { z } from 'zod';
-import { AgUiFrames } from '../agui';
-import { semanticOf, turnOf } from '../semanticOfAgUi';
-import { HostRefusedError } from './client';
-import { exchangeSchema, HOST_KEY_HEADER, IDEMPOTENCY_HEADER, } from './contracts';
+import { AgUiFrames } from '../agui.js';
+import { semanticOf, turnOf } from '../semanticOfAgUi.js';
+import { HostRefusedError } from './client.js';
+import { exchangeSchema, HOST_KEY_HEADER, IDEMPOTENCY_HEADER, } from './contracts.js';
 /**
  * The host credential exchange: the installation's key and
  * the host user it speaks for, exchanged at ai-agents for a fifteen-minute

package/lib/portable/hosts/client.js

@@ -8,7 +8,7 @@
  * @module portable/hosts/client
  */
 import { z } from 'zod';
-import { bindSchema, decisionSchema, deliveryOfOutbox, HOST_KEY_HEADER, linkCodeSchema, linkStateSchema, handoffSchema, presentationSchema, selfSchema, webhookSchema, } from './contracts';
+import { bindSchema, decisionSchema, deliveryOfOutbox, HOST_KEY_HEADER, linkCodeSchema, linkStateSchema, handoffSchema, presentationSchema, selfSchema, webhookSchema, } from './contracts.js';
 /** What ai-agents refused, with its status and its sentence. */
 export class HostRefusedError extends Error {
     status;

package/lib/portable/hosts/deadLetters.js

@@ -16,9 +16,9 @@
  * @module portable/hosts/deadLetters
  */
 import { createHash } from 'node:crypto';
-import { Logger, redact, redactCredentials } from './observability';
-import { PostgresWorkQueue } from './postgresQueue';
-import { tablePrefixOf } from './queue';
+import { Logger, redact, redactCredentials } from './observability.js';
+import { PostgresWorkQueue } from './postgresQueue.js';
+import { tablePrefixOf } from './queue.js';
 export function payloadHash(payload) {
     return createHash('sha256').update(JSON.stringify(payload)).digest('hex');
 }

package/lib/portable/hosts/deliveries.js

@@ -2,7 +2,7 @@
  * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-import { DELIVERY_HEADER, SIGNATURE_HEADER, TIMESTAMP_HEADER, verifyDelivery, } from './contracts';
+import { DELIVERY_HEADER, SIGNATURE_HEADER, TIMESTAMP_HEADER, verifyDelivery, } from './contracts.js';
 /** Where Datalayer pushes an installation's deliveries, under the service's public address. */
 export const DELIVERY_PATH = '/datalayer/deliveries';
 export const DELIVERY_ROUTE = `${DELIVERY_PATH}/:hostUid`;

package/lib/portable/hosts/index.js

@@ -22,24 +22,24 @@
  * @module portable/hosts
  */
 // The run stream and its reduction, from the portable entry's own modules.
-export { AgUiFrames, readRunStream } from '../agui';
-export * from '../semantic';
-export { askQuestionOf, semanticOf, turnOf, } from '../semanticOfAgUi';
-export * from './contracts';
-export { DatalayerHostClient, HostRefusedError, } from './client';
-export { agUiEventsOf, assertTrustedStreamUrl, DevelopmentCredentials, HostKeyCredentials, hostSessionOf, HostStarters, HttpAgentClient, InstallationCredentials, lastAnswer, } from './agentClient';
-export { hostSessionUid } from './sessionUid';
-export { DATALAYER_ONLY, MAIL_WORDS, RENDERERS, renderApproval, } from './approvalRenderers';
-export { DELIVERY_PATH, DELIVERY_ROUTE, DeliveryPoller, deliveryRoute, receiveDelivery, } from './deliveries';
-export { TurnState, } from './turnState';
-export { resolveApplication, usableAllowances, } from './resolution';
-export { MemoryWorkQueue, tablePrefixOf, } from './queue';
-export { PostgresWorkQueue } from './postgresQueue';
-export { DEFAULT_QUOTAS, MemoryQuotaStore, PostgresQuotaStore, quotaEntries, quotaWords, resetOf, userQuotaKey, windowOf, } from './quotas';
-export { SecretCipher } from './secretCipher';
-export { Logger, LogTracer, noTracer, pseudonym, redact, redactCredentials, REDACTED, TOKEN_PATTERNS, } from './observability';
-export { DEAD_LETTERS_USAGE, DeadLetters, deadLetters, payloadHash, runDeadLettersCli, } from './deadLetters';
-export { answerHealth, HEALTH_PATHS, healthServer, readiness, REQUEST_WINDOW_SECONDS, timestampWithinWindow, } from './health';
-export { systemClock } from './rateLimit';
-export { applyHostSchema, hostSchemaSql, hostTables } from './schema';
-export { FORBIDDEN, forbiddenInBundle, forbiddenInGraph, forbiddenInInstalled, importsOf, installedGraph, isForbidden, packageOf, productionGraph, } from './forbiddenGraph';
+export { AgUiFrames, readRunStream } from '../agui.js';
+export * from '../semantic.js';
+export { askQuestionOf, semanticOf, turnOf, } from '../semanticOfAgUi.js';
+export * from './contracts.js';
+export { DatalayerHostClient, HostRefusedError, } from './client.js';
+export { agUiEventsOf, assertTrustedStreamUrl, DevelopmentCredentials, HostKeyCredentials, hostSessionOf, HostStarters, HttpAgentClient, InstallationCredentials, lastAnswer, } from './agentClient.js';
+export { hostSessionUid } from './sessionUid.js';
+export { DATALAYER_ONLY, MAIL_WORDS, RENDERERS, renderApproval, } from './approvalRenderers.js';
+export { DELIVERY_PATH, DELIVERY_ROUTE, DeliveryPoller, deliveryRoute, receiveDelivery, } from './deliveries.js';
+export { TurnState, } from './turnState.js';
+export { resolveApplication, usableAllowances, } from './resolution.js';
+export { MemoryWorkQueue, tablePrefixOf, } from './queue.js';
+export { PostgresWorkQueue } from './postgresQueue.js';
+export { DEFAULT_QUOTAS, MemoryQuotaStore, PostgresQuotaStore, quotaEntries, quotaWords, resetOf, userQuotaKey, windowOf, } from './quotas.js';
+export { SecretCipher } from './secretCipher.js';
+export { Logger, LogTracer, noTracer, pseudonym, redact, redactCredentials, REDACTED, TOKEN_PATTERNS, } from './observability.js';
+export { DEAD_LETTERS_USAGE, DeadLetters, deadLetters, payloadHash, runDeadLettersCli, } from './deadLetters.js';
+export { answerHealth, HEALTH_PATHS, healthServer, readiness, REQUEST_WINDOW_SECONDS, timestampWithinWindow, } from './health.js';
+export { systemClock } from './rateLimit.js';
+export { applyHostSchema, hostSchemaSql, hostTables } from './schema.js';
+export { FORBIDDEN, forbiddenInBundle, forbiddenInGraph, forbiddenInInstalled, importsOf, installedGraph, isForbidden, packageOf, productionGraph, } from './forbiddenGraph.js';

package/lib/portable/hosts/postgresQueue.js

@@ -12,7 +12,7 @@
  *
  * @module portable/hosts/postgresQueue
  */
-import { tablePrefixOf, } from './queue';
+import { tablePrefixOf, } from './queue.js';
 export class PostgresWorkQueue {
     database;
     tablePrefix;

package/lib/portable/hosts/quotas.js

@@ -11,7 +11,7 @@
  *
  * @module portable/hosts/quotas
  */
-import { tablePrefixOf } from './queue';
+import { tablePrefixOf } from './queue.js';
 export const DEFAULT_QUOTAS = {
     application: 600,
     installation: 600,

package/lib/portable/hosts/schema.js

@@ -14,7 +14,7 @@
  *
  * @module portable/hosts/schema
  */
-import { tablePrefixOf } from './queue';
+import { tablePrefixOf } from './queue.js';
 /** The shared tables of one host, as one idempotent script. */
 export function hostSchemaSql(tablePrefix) {
     const p = tablePrefixOf(tablePrefix);

package/lib/portable/index.js

@@ -10,47 +10,47 @@
  *
  * @module portable
  */
-export { messageOfApproval, normalizeApproval, whyAsked, } from './approvals';
+export { messageOfApproval, normalizeApproval, whyAsked, } from './approvals.js';
 // An approval as every card says it (M-016).
-export { actionOf, APPROVAL_CARD_WORDS, approvalCardOf, argumentsShown, } from './approvalCard';
+export { actionOf, APPROVAL_CARD_WORDS, approvalCardOf, argumentsShown, } from './approvalCard.js';
 // A run's stream, read as every client reads it.
-export { AgUiFrames, endsRun, eventsOfStream, NOT_STREAMING, REACTOR_UI_NAME, readRunStream, RUN_CUT_SHORT, toolResultOf, UI_ON_RUN, } from './agui';
+export { AgUiFrames, endsRun, eventsOfStream, NOT_STREAMING, REACTOR_UI_NAME, readRunStream, RUN_CUT_SHORT, toolResultOf, UI_ON_RUN, } from './agui.js';
 // A run's stream reduced to what a chat host shows (DC-005, S-205).
-export { answerParts, isTerminal, SEMANTIC_EVENTS_VERSION, SEMANTIC_KINDS, } from './semantic';
-export { askQuestionOf, semanticOf, turnOf, } from './semanticOfAgUi';
-export { AG_UI_NOT_ALLOWED, AG_UI_NOT_ON_RUNTIME, agUiRefusal, refusalBody, refusalDetail, } from './agUiRefusal';
+export { answerParts, isTerminal, SEMANTIC_EVENTS_VERSION, SEMANTIC_KINDS, } from './semantic.js';
+export { askQuestionOf, semanticOf, turnOf, } from './semanticOfAgUi.js';
+export { AG_UI_NOT_ALLOWED, AG_UI_NOT_ON_RUNTIME, agUiRefusal, refusalBody, refusalDetail, } from './agUiRefusal.js';
 // The record's words, and a person's conversation read again.
-export { ASKED_FOR_TAG, askedOf, RUN_END_WORDS } from './records';
-export { messagesOfThread, openThread, snapshotOfStream, THREAD_WORDS, } from './thread';
+export { ASKED_FOR_TAG, askedOf, RUN_END_WORDS } from './records.js';
+export { messagesOfThread, openThread, snapshotOfStream, THREAD_WORDS, } from './thread.js';
 // A conversation as its stream builds it, for a native client.
-export { BROWSER_LIMITS, CUT_MARK, DEVICE_LIMITS, DIAGNOSTIC_LIMIT, emptyConversation, formFieldsOf, ITEM_LIMIT, MESSAGE_TEXT_LIMIT, questionOf, questionWords, reduceConversation, TOOL_TEXT_LIMIT, withError, withoutItems, withPrompt, withTurnEnded, } from './conversation';
+export { BROWSER_LIMITS, CUT_MARK, DEVICE_LIMITS, DIAGNOSTIC_LIMIT, emptyConversation, formFieldsOf, ITEM_LIMIT, MESSAGE_TEXT_LIMIT, questionOf, questionWords, reduceConversation, TOOL_TEXT_LIMIT, withError, withoutItems, withPrompt, withTurnEnded, } from './conversation.js';
 // What every protocol adapter says, as the conversation reads it (M-030).
-export { conversationEventsOf, sanitizeAssistantContent, snapshotOfMessages, } from './adapterEvents';
+export { conversationEventsOf, sanitizeAssistantContent, snapshotOfMessages, } from './adapterEvents.js';
 // What an application is doing, in the words beside its face (T-08).
-export { PRESENCE_LINES, presenceOfConversation, presenceState, presenceToolOf, } from './presence';
+export { PRESENCE_LINES, presenceOfConversation, presenceState, presenceToolOf, } from './presence.js';
 // One contract for every renderer of a conversation's components.
-export { ANSWER_BELOW, ANSWER_COMPLETE, composerOf, droppedWords, ENDED_WORDS, messageLabel, OPENING_WORDS, presenceLine, showsQuestion, stepLine, TOOL_STATUS_WORDS, toolLabel, } from './views';
-export { activityFixture, conversationFixture } from './fixtures';
+export { ANSWER_BELOW, ANSWER_COMPLETE, composerOf, droppedWords, ENDED_WORDS, messageLabel, OPENING_WORDS, presenceLine, showsQuestion, stepLine, TOOL_STATUS_WORDS, toolLabel, } from './views.js';
+export { activityFixture, conversationFixture } from './fixtures.js';
 // The protocol displays a run's tool results carry (M-037).
 export { DISPLAY_META_KEY, displayLine, displayOfToolResult, PAP_CONFIRM_TYPE, PAP_HANDOFF_TOOL, PAP_OUTCOME_TYPE, PAP_REPLIES_TYPE, PAP_SIGN_IN_TYPE, protocolDisplayOf, replyAuthor, 
 // A coding agent's diff and terminal (SH-16).
-DIFF_LINES_LIMIT, SHIELD_DIFF_TYPE, SHIELD_TERMINAL_TYPE, languageOf, unifiedDiffLines, unifiedDiffText, } from './displays';
-export { shieldDisplayFixtures } from './fixtures';
-export { isPapSignInTool, PAP_SIGN_IN_WORDS, readPapSignIn, safeSignInUrl, } from './signIn';
+DIFF_LINES_LIMIT, SHIELD_DIFF_TYPE, SHIELD_TERMINAL_TYPE, languageOf, unifiedDiffLines, unifiedDiffText, } from './displays.js';
+export { shieldDisplayFixtures } from './fixtures.js';
+export { isPapSignInTool, PAP_SIGN_IN_WORDS, readPapSignIn, safeSignInUrl, } from './signIn.js';
 // A Direct Conversation the person types in themselves (P-08, M-038).
-export { DIRECT_MAX, DIRECT_WORDS, directAnswerOf, directAuthor, directClient, openDirect, withDirectAnswer, } from './direct';
+export { DIRECT_MAX, DIRECT_WORDS, directAnswerOf, directAuthor, directClient, openDirect, withDirectAnswer, } from './direct.js';
 // How a sign-in under way stands, asked by the person's own client (M-039).
-export { SIGN_IN_POLL_MS, SIGN_IN_STATUS_PATH, signInStandsOf, signInStatusClient, } from './signInStatus';
+export { SIGN_IN_POLL_MS, SIGN_IN_STATUS_PATH, signInStandsOf, signInStatusClient, } from './signInStatus.js';
 // What a company asks the person to type in a mediated sign-in, sent with its one-use ticket (M-039).
-export { emptyFields, fieldProblems, MAX_VALUE_LENGTH, PROTECTED_INPUT_WORDS, protectedInputClient, protectedRequestOf, ProtectedRequestGone, sentWords, submitBody, submitWords, ticketComplete, ticketOfPage, } from './protectedInput';
+export { emptyFields, fieldProblems, MAX_VALUE_LENGTH, PROTECTED_INPUT_WORDS, protectedInputClient, protectedRequestOf, ProtectedRequestGone, sentWords, submitBody, submitWords, ticketComplete, ticketOfPage, } from './protectedInput.js';
 // How a streamed turn went, measured without its words (M-036).
-export { failureOf, otlpMetricsOf, RunMeter, } from './runMeasures';
+export { failureOf, otlpMetricsOf, RunMeter, } from './runMeasures.js';
 // What an application is doing, its record's entries, and its sessions as
 // the record lists them (R-15, M-015b).
-export { ACTIVITY_WORDS, activityOf, entryOf, entrySaid, mergeActivityPages, runEndOf, scheduledSays, SESSION_LINEAGE_WORDS, SESSION_STATE_WORDS, SESSION_STATES, SESSION_TURN_WORDS, SESSION_TURNS, sessionAgentSaid, sessionLineageSaid, sessionPageOf, sessionRowOf, sessionSentence, sessionStateSaid, wakesOn, } from './activity';
+export { ACTIVITY_WORDS, activityOf, entryOf, entrySaid, mergeActivityPages, runEndOf, scheduledSays, SESSION_LINEAGE_WORDS, SESSION_STATE_WORDS, SESSION_STATES, SESSION_TURN_WORDS, SESSION_TURNS, sessionAgentSaid, sessionLineageSaid, sessionPageOf, sessionRowOf, sessionSentence, sessionStateSaid, wakesOn, } from './activity.js';
 // A deployment's pause, resume and reset, and its recorded events (R-17, M-041b).
-export { deploymentEventLine, deploymentEventOf, notDeletedOf, resetBody, resetCountsOf, resetLines, stateChangeBody, stoppedWorkLine, stoppedWorkOf, } from './lifecycle';
+export { deploymentEventLine, deploymentEventOf, notDeletedOf, resetBody, resetCountsOf, resetLines, stateChangeBody, stoppedWorkLine, stoppedWorkOf, } from './lifecycle.js';
 // A person's agent runtimes, and an agent's summary (M-014b).
-export { agentRuntimesOf, agentSummaryOfRuntime, CREATING_STATUSES, isAgentRuntime, isCreatingAgent, runtimeOf, } from './runtimes';
+export { agentRuntimesOf, agentSummaryOfRuntime, CREATING_STATUSES, isAgentRuntime, isCreatingAgent, runtimeOf, } from './runtimes.js';
 // The runtime's routes a native client drives.
-export { agentRunClient, agentRuntimesUrlOf, appSessionsClient, RuntimeRefusal, } from './sessions';
+export { agentRunClient, agentRuntimesUrlOf, appSessionsClient, RuntimeRefusal, } from './sessions.js';