@coffer-org/server 7.2.0 → 7.3.0

package/dist/orchestrator/live-message.js

@@ -13,7 +13,7 @@ async function swallow(fn, fallback, label) {
         return fallback;
     }
 }
-export function makeLiveChannel(o) {
+export function makeLiveSink(o) {
     let msgId = null;
     let pending = '';
     let lastSent = '';
@@ -62,39 +62,56 @@ export function makeLiveChannel(o) {
     }, o.throttleMs);
     if (typeof timer.unref === 'function')
         timer.unref();
+    async function deliver(r) {
+        closed = true;
+        clearInterval(timer);
+        await inFlight;
+        const parts = o.render(r);
+        const [head, ...rest] = parts;
+        if (msgId && head !== undefined) {
+            const id = msgId;
+            if (head !== lastSent) {
+                await swallow(() => o.ops.edit(id, head), undefined, 'edit(final)');
+                lastSent = head;
+            }
+        }
+        else if (head !== undefined) {
+            await swallow(() => o.ops.send(head), null, 'send(final)');
+        }
+        for (const p of rest) {
+            await swallow(() => o.ops.send(p), null, 'send(overflow)');
+        }
+    }
+    let finished = Promise.resolve();
+    let terminalDelivered = false;
+    function deliverTerminal(kind, r) {
+        if (terminalDelivered) {
+            log.warn(`live-message: a second terminal event (${kind}) after the turn already finished — dropped`);
+            return;
+        }
+        terminalDelivered = true;
+        finished = deliver(r);
+    }
     return {
-        update(text) {
-            pending = text;
-        },
-        segment() {
-            gen++;
-            msgId = null;
-            pending = '';
-            lastSent = '';
+        emit(e) {
+            if (e.kind === 'delta')
+                pending = e.text;
+            else if (e.kind === 'segment') {
+                gen++;
+                msgId = null;
+                pending = '';
+                lastSent = '';
+            }
+            else if (e.kind === 'answer')
+                deliverTerminal('answer', { text: e.text, reasoning: e.reasoning });
+            else if (e.kind === 'notice')
+                deliverTerminal('notice', { text: e.text, reasoning: null });
+            else if (e.kind === 'error')
+                deliverTerminal('error', { text: null, reasoning: null });
         },
-        async finish(r) {
-            closed = true;
+        done: () => {
             clearInterval(timer);
-            await inFlight;
-            const parts = o.render(r);
-            let last = null;
-            const [head, ...rest] = parts;
-            if (msgId && head !== undefined) {
-                const id = msgId;
-                if (head !== lastSent) {
-                    await swallow(() => o.ops.edit(id, head), undefined, 'edit(final)');
-                    lastSent = head;
-                }
-                last = id;
-            }
-            else if (head !== undefined) {
-                last = await swallow(() => o.ops.send(head), null, 'send(final)');
-            }
-            for (const p of rest) {
-                const id = await swallow(() => o.ops.send(p), null, 'send(overflow)');
-                last = id ?? last;
-            }
-            return last;
+            return finished;
         },
     };
 }

package/dist/orchestrator/pipeline.d.ts

@@ -1,11 +1,32 @@
-import type { Connector, IncomingConversation, GatePolicy, AgentRuntime } from './types.ts';
+import type { AgentMediaLimits, Connector, TurnRequest, GatePolicy, AgentRuntime } from './types.ts';
 import type { LogDb } from './db.ts';
+import { type AreaWorld, type SystemAreas } from './system-areas.ts';
+import type { AuthUser } from '../auth-store.ts';
 export declare function setLogDb(db: LogDb | undefined): void;
+export declare const NOTICE_THROTTLE: {
+    readonly max: 5;
+    readonly windowMs: 60000;
+};
 export type RunAgentFn = AgentRuntime['run'];
-export interface PipelineDeps {
+export declare function liveWorld(): Promise<AreaWorld>;
+export type UserLookup = (id: number) => Promise<AuthUser | null>;
+export declare function defaultResolveUser(id: string, lookup?: UserLookup): Promise<AuthUser | null>;
+export declare function defaultResolveLinkedUser(connectorId: string, externalId: string, lookup?: UserLookup): Promise<AuthUser | null>;
+export declare function resolveSpeaker(connectorId: string, sender: TurnRequest['sender'], deps?: Pick<PipelineDeps, 'resolveUser' | 'resolveLinkedUser'>): Promise<AuthUser | null>;
+export interface PipelineOptions {
+    policy?: GatePolicy;
+}
+export interface PipelineDeps extends PipelineOptions {
     runAgent?: RunAgentFn;
+    afterword?: AgentRuntime['afterword'];
     logDb?: LogDb | null;
-    policy?: GatePolicy;
     agentBase?: () => Promise<string>;
+    media?: AgentMediaLimits;
+    resolveUser?: (id: string) => Promise<AuthUser | null>;
+    resolveLinkedUser?: (connectorId: string, externalId: string) => Promise<AuthUser | null>;
+    now?: () => Date;
+    timeZone?: string;
+    world?: AreaWorld;
+    domainAreas?: () => Promise<SystemAreas>;
 }
-export declare function handleIncoming(connector: Connector, conversation: IncomingConversation, deps?: PipelineDeps): Promise<void>;
+export declare function handleIncoming(connector: Connector, turn: TurnRequest, deps?: PipelineDeps): Promise<void>;

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(),