@coffer-org/server 7.1.0 → 7.3.0

package/dist/orchestrator/pipeline.js

@@ -1,23 +1,32 @@
-import { loadAllowed, saveAllowed, isAllowed, addAllowed, makeThrottle, allowFileFor } from "./allow.js";
+import { makeThrottle } from "./allow.js";
 import { loadAgentId, loadGatePolicy } from "./config.js";
-import { buildSystem } from "./system-assembly.js";
+import { assembleSystem, mergeAreas } from "./system-areas.js";
 import { attachmentMaterializer } from "./attachments.js";
 import { makeAttachmentCapabilities } from "./agent-capabilities.js";
 import { makeSystemCapabilities } from "./system-capabilities.js";
-import { makeSuggestionCapabilities } from "./suggestion-capabilities.js";
 import { resolveAgent } from "./registry.js";
 import { recordDiagnostic } from "./diagnostics.js";
 import { getLogger } from '@coffer-org/sdk/logger';
+import { findLinkedUser } from "../identity-link.js";
+import { buildContextFacts } from "./context-facts.js";
+import { systemTimeZone } from "./environment.js";
+import { discoverPlugins } from "../plugin-discovery.js";
+import { SchemaCache } from "../mcp-contract/schema.js";
+import { LocalClient } from "../mcp-local.js";
+import { loadComposedLocales } from "../locale-registry.js";
+import { buildDomainAreas } from "../mcp-tools.js";
+import { getActiveRegistry } from "../registry-context.js";
 const log = getLogger('orchestrator');
 let logDb;
 export function setLogDb(db) {
     logDb = db;
 }
+export const NOTICE_THROTTLE = { max: 5, windowMs: 60_000 };
 const throttleByConnector = new Map();
 function passThrottle(connectorId) {
     let t = throttleByConnector.get(connectorId);
     if (!t) {
-        t = makeThrottle(5, 60_000);
+        t = makeThrottle(NOTICE_THROTTLE.max, NOTICE_THROTTLE.windowMs);
         throttleByConnector.set(connectorId, t);
     }
     return t;
@@ -32,14 +41,75 @@ function cachedAgentBase() {
     }
     return cachedBase;
 }
-function openChannel(connector, chatId, ctx) {
+let cachedWorld;
+export function liveWorld() {
+    if (!cachedWorld) {
+        cachedWorld = (async () => {
+            const [plugins, locales] = await Promise.all([discoverPlugins(), loadComposedLocales()]);
+            const shelves = await new SchemaCache(new LocalClient(), locales).index();
+            const pluginIds = new Set(plugins.map((p) => p.id));
+            const shelfKeys = new Set(shelves.map((s) => `${s.library}/${s.shelf}`));
+            let libraryIds;
+            try {
+                libraryIds = new Set(getActiveRegistry().libraries.map((v) => v.meta.id));
+            }
+            catch {
+                libraryIds = new Set(shelves.map((s) => s.library));
+            }
+            return {
+                hasPlugin: (id) => pluginIds.has(id),
+                hasLibrary: (id) => libraryIds.has(id),
+                hasShelf: (library, shelf) => shelfKeys.has(`${library}/${shelf}`),
+            };
+        })();
+    }
+    return cachedWorld;
+}
+let cachedDomain;
+function cachedDomainAreas() {
+    if (!cachedDomain)
+        cachedDomain = buildDomainAreas();
+    return cachedDomain;
+}
+function foldContextFacts(messages) {
+    const acc = new Map();
+    for (const m of messages) {
+        for (const fact of m.context ?? []) {
+            if (fact.name === 'cleared')
+                acc.delete(fact.value);
+            else
+                acc.set(fact.name, fact);
+        }
+    }
+    return [...acc.values()];
+}
+const COFFER_USER_ID = /^[1-9][0-9]*$/;
+const storeLookup = async (id) => (await import("../auth-store.js")).findUserById(id);
+export async function defaultResolveUser(id, lookup = storeLookup) {
+    if (!COFFER_USER_ID.test(id) || !Number.isSafeInteger(Number(id)))
+        return null;
+    const user = await lookup(Number(id));
+    return user && !user.disabled ? user : null;
+}
+export async function defaultResolveLinkedUser(connectorId, externalId, lookup = storeLookup) {
+    const userId = await findLinkedUser(connectorId, externalId);
+    if (userId === null)
+        return null;
+    return await lookup(userId);
+}
+export async function resolveSpeaker(connectorId, sender, deps) {
+    return sender.idKind === 'coffer-user'
+        ? await (deps?.resolveUser ?? defaultResolveUser)(sender.id)
+        : await (deps?.resolveLinkedUser ?? defaultResolveLinkedUser)(connectorId, sender.id);
+}
+function openSink(connector, envelope) {
     try {
-        return connector.reply(chatId, ctx);
+        return connector.open(envelope);
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        log.error(`connector error in reply: ${message}`);
-        recordDiagnostic('error', 'connector.reply', message);
+        log.error(`connector error in open: ${message}`);
+        recordDiagnostic('error', 'connector.open', message);
         return null;
     }
 }
@@ -54,62 +124,83 @@ async function safeCall(fn, fallback, label) {
         return fallback;
     }
 }
-export async function handleIncoming(connector, conversation, deps) {
+export async function handleIncoming(connector, turn, deps) {
     const policy = deps?.policy ?? (await loadGatePolicy());
-    const selectedAgentId = conversation.agentId ?? policy.agentId ?? (deps?.runAgent ? undefined : await loadAgentId());
+    const selectedAgentId = turn.agentId ?? policy.agentId ?? (deps?.runAgent ? undefined : await loadAgentId());
     const runtime = deps?.runAgent ? undefined : resolveAgent(selectedAgentId);
     const agent = deps?.runAgent ?? runtime.run.bind(runtime);
+    const agentMedia = () => deps?.media ?? runtime.media;
     const db = deps && 'logDb' in deps ? deps.logDb : logDb;
     const agentBase = deps?.agentBase ?? (() => (selectedAgentId ? runtime.systemBase() : cachedAgentBase()));
-    const { connectorId, chatId, sender, messages } = conversation;
+    const { connectorId, chatId } = turn.envelope;
+    const { sender } = turn;
+    const messages = turn.body.messages;
     const last = messages[messages.length - 1];
     if (!last || last.role !== 'user')
         return;
     const incomingMsgId = last.msgId;
-    const allowFile = allowFileFor(connectorId);
-    if (policy.accessPassword) {
-        let allow = loadAllowed(allowFile);
-        if (!isAllowed(allow, sender.id)) {
-            if (last.content.trim() === policy.accessPassword) {
-                allow = addAllowed(allow, sender.id, Date.now());
-                saveAllowed(allowFile, allow);
-                const ch = openChannel(connector, chatId, { parentMsgId: incomingMsgId });
-                if (ch)
-                    await safeCall(() => ch.finish({ text: '✅ Access granted. Send your requests.', reasoning: null, suggestions: null }), null, 'finish(enroll)');
-            }
-            else if (passThrottle(connectorId)(sender.id)) {
-                const ch = openChannel(connector, chatId, { parentMsgId: incomingMsgId });
-                if (ch)
-                    await safeCall(() => ch.finish({
-                        text: '🔒 Access locked. Send the password to gain access.',
-                        reasoning: null,
-                        suggestions: null,
-                    }), null, 'finish(locked)');
+    if (policy.triggerPrefix && !last.content.toLowerCase().startsWith(policy.triggerPrefix.toLowerCase()))
+        return;
+    const speakerRow = await resolveSpeaker(connectorId, sender, deps);
+    if (speakerRow === null) {
+        if (passThrottle(connectorId)(sender.id)) {
+            const sink = openSink(connector, turn.envelope);
+            if (sink) {
+                sink.emit({ kind: 'notice', text: connector.enrolmentNotice });
+                await safeCall(() => sink.done(), undefined, 'done(unidentified)');
             }
-            return;
         }
+        return;
     }
-    if (policy.triggerPrefix && !last.content.toLowerCase().startsWith(policy.triggerPrefix.toLowerCase()))
+    if (turn.signal?.aborted)
         return;
     const queryText = policy.triggerPrefix ? last.content.slice(policy.triggerPrefix.length).trim() : last.content.trim();
     if (!queryText) {
-        if (conversation.prepareAttachments && !policy.triggerPrefix) {
-            await safeCall(() => conversation.prepareAttachments(attachmentMaterializer), messages, 'prepareAttachments');
+        if (turn.prepareAttachments && !policy.triggerPrefix) {
+            await safeCall(() => turn.prepareAttachments(attachmentMaterializer), messages, 'prepareAttachments');
         }
         return;
     }
-    const preparedMessages = conversation.prepareAttachments
-        ? await safeCall(() => conversation.prepareAttachments(attachmentMaterializer), messages, 'prepareAttachments')
+    const preparedMessages = turn.prepareAttachments
+        ? await safeCall(() => turn.prepareAttachments(attachmentMaterializer), messages, 'prepareAttachments')
         : messages;
-    const agentMessages = preparedMessages.map((m, i) => i === preparedMessages.length - 1
-        ? {
-            ...m,
-            ...(policy.triggerPrefix ? { content: queryText } : {}),
-            ...(conversation.turnContext ? { context: conversation.turnContext } : {}),
-        }
-        : m);
-    const base = await agentBase();
-    const system = buildSystem({ base, channelSystem: conversation.channelSystem });
+    const speaker = {
+        id: sender.id,
+        name: speakerRow.displayName ?? sender.displayName ?? sender.id,
+        role: speakerRow.role,
+    };
+    const stated = preparedMessages.filter((m) => m.context?.length);
+    const lastStated = stated[stated.length - 1];
+    const now = deps?.now ? deps.now() : new Date();
+    const facts = buildContextFacts({
+        connectorFacts: turn.turnContext ?? [],
+        speaker,
+        now,
+        timeZone: deps?.timeZone ?? systemTimeZone(),
+        previous: stated.length ? foldContextFacts(preparedMessages) : null,
+        previousAt: lastStated ? new Date(lastStated.ts * 1000) : null,
+    });
+    const withText = preparedMessages.map((m, i) => i === preparedMessages.length - 1 && policy.triggerPrefix ? { ...m, content: queryText } : m);
+    const userMsg = withText[withText.length - 1];
+    const agentMessages = facts.length ? [...withText.slice(0, -1), { ...userMsg, context: facts }] : withText;
+    const persistContext = async () => {
+        if (!facts.length)
+            return;
+        await safeCall(() => connector.recordContext({
+            chatId,
+            userMsgId: incomingMsgId,
+            facts,
+            ts: userMsg.ts - 1,
+        }), undefined, 'recordContext');
+    };
+    const authored = turn.body.systemPrompt;
+    const domain = await (deps?.domainAreas ?? cachedDomainAreas)();
+    const areas = mergeAreas({ root: [await agentBase()] }, domain, authored);
+    const system = assembleSystem(areas, deps?.world ?? (await liveWorld()));
+    if (turn.signal?.aborted) {
+        await persistContext();
+        return;
+    }
     db?.logTurn({
         connector: connectorId,
         chatId,
@@ -120,79 +211,108 @@ export async function handleIncoming(connector, conversation, deps) {
         tokensOut: null,
         ms: null,
         agentId: selectedAgentId ?? null,
-        presetId: conversation.presetId ?? null,
+        presetId: turn.presetId ?? null,
     });
     const startedAt = Date.now();
-    const ch = openChannel(connector, chatId, { parentMsgId: incomingMsgId });
-    if (!ch)
+    const sink = openSink(connector, turn.envelope);
+    if (!sink)
         return;
-    let result;
-    const suggestionCaps = conversation.supportsSuggestions ? makeSuggestionCapabilities() : undefined;
+    let usage;
+    let answerText = null;
+    let runFailed = false;
+    let agentTurn;
     try {
-        const attachmentTools = await makeAttachmentCapabilities(agentMessages.flatMap((m) => m.attachments ?? []));
+        const attachmentTools = await makeAttachmentCapabilities(agentMessages.flatMap((m) => m.attachments ?? []), agentMedia());
         const toolProvider = {
-            tools: [...attachmentTools.tools, ...makeSystemCapabilities().tools, ...(suggestionCaps?.tools ?? [])],
+            tools: [...attachmentTools.tools, ...makeSystemCapabilities().tools],
         };
-        result = await agent({
-            system,
-            messages: agentMessages,
+        agentTurn = {
+            envelope: turn.envelope,
+            body: { system, messages: agentMessages, userTurns: turn.body.userTurns },
             toolProvider,
-            ...(conversation.presetId ? { presetId: conversation.presetId } : {}),
-            onDelta: (acc) => {
-                try {
-                    ch.update(acc);
+            ...(turn.presetId ? { presetId: turn.presetId } : {}),
+            senderRole: speaker.role,
+            ...(turn.signal ? { signal: turn.signal } : {}),
+        };
+        await agent(agentTurn, (event) => {
+            try {
+                if (event.kind === 'usage') {
+                    usage = { tokensIn: event.tokensIn, tokensOut: event.tokensOut, presetId: event.presetId };
                 }
-                catch (err) {
-                    log.error(`connector error in update: ${err instanceof Error ? err.message : String(err)}`);
+                else if (event.kind === 'answer') {
+                    answerText = event.text;
                 }
-            },
-            onReasoning: (acc) => {
+                sink.emit(event);
+            }
+            catch (err) {
+                log.error(`connector error in ${event.kind}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        });
+    }
+    catch (err) {
+        runFailed = true;
+        const message = err instanceof Error ? err.message : String(err);
+        log.error(`agent error: ${message}`);
+        recordDiagnostic('error', 'agent.run', message);
+        try {
+            sink.emit({ kind: 'error', message });
+        }
+        catch (sinkErr) {
+            log.error(`connector error in error: ${sinkErr instanceof Error ? sinkErr.message : String(sinkErr)}`);
+        }
+    }
+    await safeCall(() => sink.done(), undefined, 'done');
+    if (!runFailed && answerText && agentTurn) {
+        const events = turn.body.capabilities.events;
+        const want = { suggestions: events.includes('suggestions'), title: events.includes('title') };
+        const afterwordFn = deps?.afterword ?? runtime?.afterword;
+        if ((want.suggestions || want.title) && afterwordFn) {
+            let extra;
+            try {
+                extra = await afterwordFn(agentTurn, answerText, want);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                recordDiagnostic('error', 'agent.afterword', message);
+            }
+            if (extra?.suggestions?.length) {
                 try {
-                    ch.updateReasoning?.(acc);
+                    sink.emit({ kind: 'suggestions', items: extra.suggestions });
                 }
                 catch (err) {
-                    log.error(`connector error in updateReasoning: ${err instanceof Error ? err.message : String(err)}`);
+                    log.error(`connector error in suggestions: ${err instanceof Error ? err.message : String(err)}`);
                 }
-            },
-            onSegment: () => {
+            }
+            if (extra?.title) {
                 try {
-                    ch.segment();
+                    sink.emit({ kind: 'title', text: extra.title });
                 }
                 catch (err) {
-                    log.error(`connector error in segment: ${err instanceof Error ? err.message : String(err)}`);
+                    log.error(`connector error in title: ${err instanceof Error ? err.message : String(err)}`);
                 }
-            },
-        });
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        log.error(`agent error: ${message}`);
-        recordDiagnostic('error', 'agent.run', message);
+            }
+            if (usage && extra && (extra.tokensIn !== undefined || extra.tokensOut !== undefined)) {
+                usage = {
+                    ...usage,
+                    tokensIn: usage.tokensIn === null ? null : usage.tokensIn + (extra.tokensIn ?? 0),
+                    tokensOut: usage.tokensOut === null ? null : usage.tokensOut + (extra.tokensOut ?? 0),
+                };
+            }
+        }
     }
-    if (result && suggestionCaps)
-        result.suggestions = suggestionCaps.getCaptured();
-    const botMsgId = await safeCall(() => ch.finish({
-        text: result?.text ?? null,
-        reasoning: result?.reasoning ?? null,
-        suggestions: result?.suggestions ?? null,
-    }), null, 'finish');
-    if (result?.text)
+    await safeCall(() => sink.done(), undefined, 'done');
+    if (!runFailed && usage && answerText)
         db?.logTurn({
             connector: connectorId,
             chatId,
             userId: sender.id,
             role: 'assistant',
-            text: result.text,
-            tokensIn: result.tokensIn,
-            tokensOut: result.tokensOut,
+            text: answerText,
+            tokensIn: usage.tokensIn,
+            tokensOut: usage.tokensOut,
             ms: Date.now() - startedAt,
             agentId: selectedAgentId ?? null,
-            presetId: result.presetId,
+            presetId: usage.presetId,
         });
-    await safeCall(() => connector.recordAssistant({
-        parentMsgId: incomingMsgId,
-        botMsgId,
-        text: result?.text ?? '',
-        reasoning: result?.reasoning ?? null,
-    }), undefined, 'recordAssistant');
+    await persistContext();
 }

package/dist/orchestrator/registry.d.ts

@@ -1,4 +1,4 @@
-import type { AgentDescriptor, AgentRuntime, ConnectorRegistration } from './types.ts';
+import type { AgentCatalogEntry, AgentRuntime, ConnectorRegistration } from './types.ts';
 export declare function registerAgent(runtime: AgentRuntime, opts?: {
     default?: boolean;
 }): () => void;
@@ -8,6 +8,8 @@ export declare function registerConnector(registration: ConnectorRegistration):
 export declare function isConnectorRegistered(id: string): boolean;
 export declare function listRegisteredAgents(): string[];
 export declare function listRegisteredConnectors(): string[];
-export declare function listAgentCatalog(): Promise<AgentDescriptor[]>;
+export declare function listLinkableConnectors(): string[];
+export declare function connectorLinkUrl(connectorId: string, code: string): string | undefined;
+export declare function listAgentCatalog(): Promise<AgentCatalogEntry[]>;
 export declare function getDefaultAgentId(): string | undefined;
 export declare function clearRuntimeRegistries(): void;

package/dist/orchestrator/registry.js

@@ -48,6 +48,15 @@ export function listRegisteredAgents() {
 export function listRegisteredConnectors() {
     return [...connectors.keys()].sort();
 }
+export function listLinkableConnectors() {
+    return [...connectors.entries()]
+        .filter(([, registration]) => typeof registration.linkUrl === 'function')
+        .map(([id]) => id)
+        .sort();
+}
+export function connectorLinkUrl(connectorId, code) {
+    return connectors.get(connectorId)?.linkUrl?.(code);
+}
 export async function listAgentCatalog() {
     const ids = [...agents.keys()].sort();
     const out = [];
@@ -56,7 +65,7 @@ export async function listAgentCatalog() {
         if (!runtime)
             continue;
         try {
-            out.push(await runtime.describe());
+            out.push({ ...(await runtime.describe()), media: runtime.media });
         }
         catch (err) {
             log.error(`agent describe failed for ${id}: ${err instanceof Error ? err.message : String(err)}`);

package/dist/orchestrator/system-areas.d.ts

@@ -0,0 +1,12 @@
+export type SystemAreas = Record<string, string[]>;
+export interface AreaWorld {
+    hasPlugin(id: string): boolean;
+    hasLibrary(id: string): boolean;
+    hasShelf(library: string, shelf: string): boolean;
+}
+export declare const KIND_ORDER: readonly ["root", "plugin", "library", "shelf", "channel"];
+export declare const UNCONDITIONAL: ReadonlySet<string>;
+export declare function rank(key: string): number;
+export declare const ALL_PRESENT: AreaWorld;
+export declare function mergeAreas(...areas: SystemAreas[]): SystemAreas;
+export declare function assembleSystem(areas: SystemAreas, world: AreaWorld): string[];

package/dist/orchestrator/system-areas.js

@@ -0,0 +1,63 @@
+import { getLogger } from '@coffer-org/sdk/logger';
+const log = getLogger('orchestrator');
+export const KIND_ORDER = ['root', 'plugin', 'library', 'shelf', 'channel'];
+export const UNCONDITIONAL = new Set(['root', 'channel']);
+function keep(key, world) {
+    if (UNCONDITIONAL.has(key))
+        return true;
+    const colon = key.indexOf(':');
+    if (colon < 0)
+        return null;
+    const kind = key.slice(0, colon);
+    const id = key.slice(colon + 1);
+    if (!id)
+        return null;
+    if (kind === 'plugin')
+        return world.hasPlugin(id);
+    if (kind === 'library')
+        return world.hasLibrary(id);
+    if (kind === 'shelf') {
+        const slash = id.indexOf('/');
+        if (slash < 1 || slash === id.length - 1 || id.indexOf('/', slash + 1) >= 0)
+            return null;
+        return world.hasShelf(id.slice(0, slash), id.slice(slash + 1));
+    }
+    return null;
+}
+export function rank(key) {
+    const colon = key.indexOf(':');
+    const kind = colon < 0 ? key : key.slice(0, colon);
+    const i = KIND_ORDER.indexOf(kind);
+    return i < 0 ? KIND_ORDER.length : i;
+}
+export const ALL_PRESENT = {
+    hasPlugin: () => true,
+    hasLibrary: () => true,
+    hasShelf: () => true,
+};
+export function mergeAreas(...areas) {
+    const out = {};
+    for (const a of areas) {
+        for (const [key, lines] of Object.entries(a)) {
+            out[key] = [...(out[key] ?? []), ...lines];
+        }
+    }
+    return out;
+}
+export function assembleSystem(areas, world) {
+    const kept = [];
+    for (const key of Object.keys(areas)) {
+        const verdict = keep(key, world);
+        if (verdict === null) {
+            log.warn(`unknown system-prompt area '${key}' — dropped`);
+            continue;
+        }
+        if (verdict)
+            kept.push(key);
+    }
+    kept.sort((a, b) => rank(a) - rank(b) || (a < b ? -1 : a > b ? 1 : 0));
+    return kept
+        .flatMap((key) => areas[key] ?? [])
+        .map((line) => line.trim())
+        .filter(Boolean);
+}

package/dist/orchestrator/system-capabilities.js

@@ -42,7 +42,7 @@ export function makeSystemCapabilities() {
             'platform, memory, and the database file path with its size and free disk space. ' +
             'Use it for questions about the instance itself ("which version am I running", "is the disk filling up", ' +
             '"how long has the server been up"). It returns nothing about the user\'s records — use count_records for those. ' +
-            'The current date and time are already given in the system prompt; do not call this tool to find them.',
+            "The current date and time are already given in each turn's context; do not call this tool to find them.",
         inputSchema: {},
         handler: async () => ({
             coffer_version: await runtimeVersion(),

package/dist/orchestrator/turn-context.d.ts

@@ -0,0 +1,18 @@
+import type { AuthRole } from '../plugin-hooks.ts';
+export declare const PAUSE_THRESHOLD_MS: number;
+export interface TurnSpeaker {
+    name: string;
+    role: AuthRole;
+}
+export interface TurnContextInput {
+    connectorLines: readonly string[];
+    speaker: TurnSpeaker;
+    previousSpeakerName: string | null;
+    now: Date;
+    timeZone: string;
+    previousMessageTs: number | null;
+}
+export declare const MAX_SPEAKER_NAME = 80;
+export declare function oneLine(value: string, maxLen?: number): string;
+export declare function humanizePause(ms: number): string;
+export declare function buildTurnContext(input: TurnContextInput): string;

package/dist/orchestrator/turn-context.js

@@ -0,0 +1,39 @@
+import { currentMoment } from "./environment.js";
+export const PAUSE_THRESHOLD_MS = 10 * 60_000;
+export const MAX_SPEAKER_NAME = 80;
+const FORGERY_CHARS = /[\p{Cc}\p{Zl}\p{Zp}\p{Bidi_Control}]+/gu;
+export function oneLine(value, maxLen) {
+    const flat = value.replace(FORGERY_CHARS, ' ').replace(/\s+/g, ' ').trim();
+    return maxLen !== undefined && flat.length > maxLen ? `${flat.slice(0, maxLen - 1).trimEnd()}…` : flat;
+}
+export function humanizePause(ms) {
+    const minutes = Math.round(ms / 60_000);
+    if (minutes < 90)
+        return `about ${minutes} minutes`;
+    const hours = Math.round(ms / 3_600_000);
+    if (hours < 48)
+        return `about ${hours} hours`;
+    return `about ${Math.round(ms / 86_400_000)} days`;
+}
+export function buildTurnContext(input) {
+    const name = oneLine(input.speaker.name, MAX_SPEAKER_NAME) || 'unknown';
+    const previousName = input.previousSpeakerName
+        ? oneLine(input.previousSpeakerName, MAX_SPEAKER_NAME) || 'unknown'
+        : null;
+    const who = `${name} (${input.speaker.role})`;
+    const lines = [
+        previousName ? `Speaking now: ${who} — the previous message was from ${previousName}.` : `Speaking now: ${who}.`,
+        `Current time: ${currentMoment(input.now, input.timeZone)} (${input.timeZone}).`,
+    ];
+    if (input.previousMessageTs !== null) {
+        const gap = input.now.getTime() - input.previousMessageTs * 1000;
+        if (gap >= PAUSE_THRESHOLD_MS)
+            lines.push(`Time since the previous message: ${humanizePause(gap)}.`);
+    }
+    for (const raw of input.connectorLines) {
+        const line = oneLine(raw);
+        if (line)
+            lines.push(line);
+    }
+    return lines.join('\n');
+}