@coffer-org/server 7.1.0 → 7.3.0

package/dist/mcp-tools.js

@@ -10,6 +10,7 @@ import { pluginHooks, pluginCtx } from "./plugin-hooks.js";
 import { getActiveRegistry } from "./registry-context.js";
 import { countTargetsFor, recordCounts } from "./counts.js";
 import { describeCondition } from '@coffer-org/sdk/condition';
+import { normalizeAgentMeta } from '@coffer-org/sdk/library';
 import { getEm } from "./db.js";
 import { getPluginSettings } from "./plugin-runtime.js";
 import { configuredPublicUrl } from "./public-url.js";
@@ -46,7 +47,7 @@ export async function resolveRagDeps() {
         return null;
     return { embeddingApiKey };
 }
-export async function collectMcpTools(opts = {}) {
+export async function collectMcpTools(opts) {
     const out = [];
     const client = new LocalClient();
     const locales = await loadComposedLocales();
@@ -201,54 +202,52 @@ export async function collectMcpTools(opts = {}) {
             },
         });
     }
-    if (opts.includeAdmin) {
-        const actor = opts.actor ?? 'mcp';
-        out.push({
-            server: 'coffer',
-            bareName: 'list_settings',
-            httpName: 'list_settings',
-            description: "List every settings group (the instance's own `system` group and each plugin's): each field's key/kind/required and the current values (secrets masked). Call before update_settings.",
-            inputSchema: {},
-            scope: 'settings',
-            role: 'admin',
-            handler: async () => {
-                try {
-                    return ok(await listSettings());
-                }
-                catch (e) {
-                    return fail(`Error: ${e.message}`);
-                }
-            },
-        });
-        out.push({
-            server: 'coffer',
-            bareName: 'update_settings',
-            httpName: 'update_settings',
-            description: 'Update a plugin or system settings group. group — the settings group id (e.g. "system", "claude-agent"); fields — only the settings to change (see list_settings). Send real secret values; the masked placeholder (********) is treated as unchanged.',
-            inputSchema: { group: z.string(), fields: z.record(z.string(), z.unknown()) },
-            scope: 'settings',
-            role: 'admin',
-            handler: async (args) => {
-                try {
-                    const row = await writePluginSettings(getEm().fork(), args.group, args.fields, actor);
-                    return ok(row);
-                }
-                catch (e) {
-                    if (e instanceof ValidationError) {
-                        const lines = e.issues.map((i) => {
-                            const o = i;
-                            return `- ${o.field ?? '?'}: ${o.code ?? 'invalid'}`;
-                        });
-                        return fail(`Validation error:\n${lines.join('\n')}`);
-                    }
-                    if (e instanceof NotFoundError)
-                        return fail(`No settings group '${String(args.group)}'.`);
-                    return fail(`Error: ${e.message}`);
+    const actor = opts.actor ?? 'mcp';
+    out.push({
+        server: 'coffer',
+        bareName: 'list_settings',
+        httpName: 'list_settings',
+        description: "List every settings group (the instance's own `system` group and each plugin's): each field's key/kind/required and the current values (secrets masked). Call before update_settings.",
+        inputSchema: {},
+        scope: 'settings',
+        role: 'admin',
+        handler: async () => {
+            try {
+                return ok(await listSettings());
+            }
+            catch (e) {
+                return fail(`Error: ${e.message}`);
+            }
+        },
+    });
+    out.push({
+        server: 'coffer',
+        bareName: 'update_settings',
+        httpName: 'update_settings',
+        description: 'Update a plugin or system settings group. group — the settings group id (e.g. "system", "claude-agent"); fields — only the settings to change (see list_settings). Send real secret values; the masked placeholder (********) is treated as unchanged.',
+        inputSchema: { group: z.string(), fields: z.record(z.string(), z.unknown()) },
+        scope: 'settings',
+        role: 'admin',
+        handler: async (args) => {
+            try {
+                const row = await writePluginSettings(getEm().fork(), args.group, args.fields, actor);
+                return ok(row);
+            }
+            catch (e) {
+                if (e instanceof ValidationError) {
+                    const lines = e.issues.map((i) => {
+                        const o = i;
+                        return `- ${o.field ?? '?'}: ${o.code ?? 'invalid'}`;
+                    });
+                    return fail(`Validation error:\n${lines.join('\n')}`);
                 }
-            },
-        });
-    }
-    return out;
+                if (e instanceof NotFoundError)
+                    return fail(`No settings group '${String(args.group)}'.`);
+                return fail(`Error: ${e.message}`);
+            }
+        },
+    });
+    return opts.role === 'admin' ? out : out.filter((t) => t.role === 'member');
 }
 export async function collectPluginInstructions(hooks = pluginHooks, emFactory = () => getEm().fork()) {
     const out = [];
@@ -296,60 +295,65 @@ export function collectLibraryPurposes(reg, locales) {
     if (!registry)
         return [];
     return registry.libraries
-        .filter((v) => v.meta.agent)
+        .filter((v) => normalizeAgentMeta(v.meta.agent)?.description)
         .map((v) => ({
         id: v.meta.id,
         name: (v.meta.label ? locales?.resolve(v.meta.label) : undefined) ?? v.meta.id,
-        agent: v.meta.agent,
-        extends: registry.extends_.flatMap((e) => e.agent
-            ? e.attachTo
-                .filter((a) => a.library === v.meta.id)
-                .map((a) => ({ id: e.id, shelf: a.shelf, agent: e.agent, showWhen: e.showWhen }))
-            : []),
+        agent: normalizeAgentMeta(v.meta.agent).description,
+        extends: registry.extends_.flatMap((e) => {
+            const meta = normalizeAgentMeta(e.agent);
+            return meta?.description
+                ? e.attachTo
+                    .filter((a) => a.library === v.meta.id)
+                    .map((a) => ({ id: e.id, shelf: a.shelf, agent: meta.description, showWhen: e.showWhen }))
+                : [];
+        }),
     }));
 }
 export async function siteSection(siteUrl) {
     const site = await frontendInstructions(siteUrl);
     return site ? `## web\n${site}` : null;
 }
-export async function buildDomainSections(locales) {
+const DATA_MODEL = '## Data model\n' +
+    'Library (top-level area) → shelf (a kind of record, e.g. things/item) → record (addressed library/shelf/id) → fields. ' +
+    'Some field values are JSON (e.g. quantity {"value":2000,"unit":"ml"}); some are relations (hold another record\'s id); ' +
+    "some are collections (nested rows — an array). Extends add extra field-sets to a shelf's records, shown only when a " +
+    'condition holds (the "when …" notes below); in a fetched record they sit under `_extends`. ' +
+    'Read: list_libraries → describe_shelf → list_records/get_record. Write: create_record/update_record (call describe_shelf first); ' +
+    'delete_record moves a record to reversible trash — do not blank fields. Before editing, read the complete record and patch only requested fields. ' +
+    'For duplicates, read both records completely, compare fields/collections/extends/attachments, recommend the less complete record for trash, and offer a field-by-field merge first. ' +
+    'Use list_trash and restore_record for recovery; purge_record is irreversible and requires explicit confirmation. ' +
+    'Each library below names what it holds and when to use it — pick the right one before searching. ' +
+    'A single-record shelf holds exactly one document — read it directly, do not search the shelf.';
+function renderLibrary(v) {
+    let s = v.name === v.id ? `### ${v.id} — ${v.agent}` : `### ${v.id} ("${v.name}") — ${v.agent}`;
+    if (v.extends.length) {
+        s +=
+            '\nExtra field-sets some records carry (which one depends on the record):\n' +
+                v.extends
+                    .map((e) => {
+                    const when = describeCondition(e.showWhen, (f) => f).join(' and ');
+                    return `- ${e.id} (on ${e.shelf}${when ? `, when ${when}` : ''}): ${e.agent.replace(/\s*\n\s*/g, ' ')}`;
+                })
+                    .join('\n');
+    }
+    return s;
+}
+export async function buildDomainAreas(locales) {
     const i18n = locales ?? (await loadComposedLocales());
-    const libraries = collectLibraryPurposes(undefined, i18n);
-    let overview = null;
-    if (libraries.length) {
-        const blocks = libraries.map((v) => {
-            let s = v.name === v.id ? `### ${v.id} — ${v.agent}` : `### ${v.id} ("${v.name}") — ${v.agent}`;
-            if (v.extends.length) {
-                s +=
-                    '\nExtra field-sets some records carry (which one depends on the record):\n' +
-                        v.extends
-                            .map((e) => {
-                            const when = describeCondition(e.showWhen, (f) => f).join(' and ');
-                            return `- ${e.id} (on ${e.shelf}${when ? `, when ${when}` : ''}): ${e.agent.replace(/\s*\n\s*/g, ' ')}`;
-                        })
-                            .join('\n');
-            }
-            return s;
-        });
-        overview =
-            '## Libraries (what each holds / when to use it — pick the right one before searching)\n\n' + blocks.join('\n\n');
+    const areas = { root: [DATA_MODEL] };
+    for (const v of collectLibraryPurposes(undefined, i18n)) {
+        areas[`library:${v.id}`] = [renderLibrary(v)];
+    }
+    for (const s of collectSingleShelves()) {
+        areas[`shelf:${s.library}/${s.shelf}`] = [
+            `### ${s.library}/${s.shelf} — single record: read it directly, do not search the shelf. ${s.agent.replace(/\s*\n\s*/g, ' ')}`,
+        ];
+    }
+    for (const { id, instructions } of await collectPluginInstructions()) {
+        areas[`plugin:${id}`] = [`## ${id}\n${instructions}`];
     }
-    const singles = collectSingleShelves();
-    const singleSection = singles.length
-        ? '## Single-record shelves (one document each — read the record, do not search the shelf)\n\n' +
-            singles.map((s) => `- ${s.library}/${s.shelf}: ${s.agent.replace(/\s*\n\s*/g, ' ')}`).join('\n')
-        : null;
-    const dataModel = '## Data model\n' +
-        'Library (top-level area) → shelf (a kind of record, e.g. things/item) → record (addressed library/shelf/id) → fields. ' +
-        'Some field values are JSON (e.g. quantity {"value":2000,"unit":"ml"}); some are relations (hold another record\'s id); ' +
-        "some are collections (nested rows — an array). Extends add extra field-sets to a shelf's records, shown only when a " +
-        'condition holds (the "when …" notes below); in a fetched record they sit under `_extends`. ' +
-        'Read: list_libraries → describe_shelf → list_records/get_record. Write: create_record/update_record (call describe_shelf first); ' +
-        'delete_record moves a record to reversible trash — do not blank fields. Before editing, read the complete record and patch only requested fields. ' +
-        'For duplicates, read both records completely, compare fields/collections/extends/attachments, recommend the less complete record for trash, and offer a field-by-field merge first. ' +
-        'Use list_trash and restore_record for recovery; purge_record is irreversible and requires explicit confirmation.';
-    const rules = (await collectPluginInstructions()).map(({ id, instructions }) => `## ${id}\n${instructions}`);
-    return [dataModel, ...(overview ? [overview] : []), ...(singleSection ? [singleSection] : []), ...rules];
+    return areas;
 }
 export const CORE_STARTER_HINT = 'what this Coffer instance itself holds — which libraries are present and what kinds of ' +
     'questions the stored data can answer';

package/dist/media/image.d.ts

@@ -0,0 +1,23 @@
+export interface ImageTarget {
+    maxEdge: number;
+    maxPixels?: number;
+    maxBytes: number;
+    encode: readonly string[];
+}
+export interface ImageFacts {
+    mime: string;
+    width: number;
+    height: number;
+    bytes: number;
+}
+export interface NormalizedImage {
+    bytes: Buffer;
+    mime: string;
+    width: number;
+    height: number;
+    source: ImageFacts;
+    changed: boolean;
+}
+export declare class ImageNormalizeError extends Error {
+}
+export declare function normalizeImage(bytes: Buffer, target: ImageTarget): Promise<NormalizedImage>;

package/dist/media/image.js

@@ -0,0 +1,103 @@
+import sharp from 'sharp';
+export class ImageNormalizeError extends Error {
+}
+const MIME_BY_FORMAT = {
+    jpeg: 'image/jpeg',
+    jpg: 'image/jpeg',
+    png: 'image/png',
+    webp: 'image/webp',
+    gif: 'image/gif',
+    avif: 'image/avif',
+    tiff: 'image/tiff',
+    heif: 'image/heif',
+};
+const QUALITY_LADDER = [85, 72, 58, 44];
+const MAX_ATTEMPTS = 6;
+const QUALITY_CAN_CLOSE = 2;
+function fit(width, height, maxEdge, maxPixels) {
+    let scale = Math.min(1, maxEdge / Math.max(width, height));
+    if (maxPixels)
+        scale = Math.min(scale, Math.sqrt(maxPixels / (width * height)));
+    return scaleTo(width, height, scale);
+}
+function scaleTo(width, height, scale) {
+    return {
+        width: Math.max(1, Math.floor(width * scale)),
+        height: Math.max(1, Math.floor(height * scale)),
+    };
+}
+function pickEncoding(target, hasAlpha) {
+    const accepts = (mime) => target.encode.includes(mime);
+    const order = hasAlpha ? ['image/webp', 'image/png', 'image/jpeg'] : ['image/jpeg', 'image/webp', 'image/png'];
+    for (const mime of order)
+        if (accepts(mime))
+            return mime;
+    throw new ImageNormalizeError(`the agent takes back none of the encodings this image could be produced in: ${target.encode.join(', ') || '(none declared)'}`);
+}
+function encode(pipeline, mime, quality) {
+    switch (mime) {
+        case 'image/jpeg':
+            return pipeline.jpeg({ quality, mozjpeg: true }).toBuffer();
+        case 'image/webp':
+            return pipeline.webp({ quality }).toBuffer();
+        case 'image/png':
+            return pipeline.png({ compressionLevel: 9, palette: true, quality }).toBuffer();
+        default:
+            throw new ImageNormalizeError(`Unsupported target encoding: ${mime}`);
+    }
+}
+export async function normalizeImage(bytes, target) {
+    let meta;
+    try {
+        meta = await sharp(bytes).metadata();
+    }
+    catch (err) {
+        throw new ImageNormalizeError(`Not a decodable image: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const format = meta.format ? MIME_BY_FORMAT[meta.format] : undefined;
+    const swap = (meta.orientation ?? 0) >= 5;
+    const width = swap ? meta.height : meta.width;
+    const height = swap ? meta.width : meta.height;
+    if (!format || !width || !height)
+        throw new ImageNormalizeError('Image has no readable format or dimensions.');
+    const source = { mime: format, width, height, bytes: bytes.length };
+    const target1 = fit(width, height, target.maxEdge, target.maxPixels);
+    const fitsNow = target.encode.includes(format) &&
+        bytes.length <= target.maxBytes &&
+        target1.width === width &&
+        target1.height === height;
+    if (fitsNow)
+        return { bytes, mime: format, width, height, source, changed: false };
+    const mime = pickEncoding(target, meta.hasAlpha === true);
+    const flatten = meta.hasAlpha === true && mime === 'image/jpeg';
+    let dims = target1;
+    let qualityStep = 0;
+    let last;
+    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+        let pipeline = sharp(bytes).rotate();
+        if (flatten)
+            pipeline = pipeline.flatten({ background: '#ffffff' });
+        pipeline = pipeline.resize({ ...dims, fit: 'inside', withoutEnlargement: true });
+        const quality = QUALITY_LADDER[Math.min(qualityStep, QUALITY_LADDER.length - 1)];
+        last = await encode(pipeline, mime, quality);
+        if (last.length <= target.maxBytes) {
+            const out = await sharp(last).metadata();
+            return {
+                bytes: last,
+                mime,
+                width: out.width ?? dims.width,
+                height: out.height ?? dims.height,
+                source,
+                changed: true,
+            };
+        }
+        if (last.length <= target.maxBytes * QUALITY_CAN_CLOSE && qualityStep < QUALITY_LADDER.length - 1) {
+            qualityStep += 1;
+        }
+        else {
+            const shrink = Math.sqrt(target.maxBytes / last.length) * 0.9;
+            dims = scaleTo(dims.width, dims.height, Math.min(0.9, shrink));
+        }
+    }
+    throw new ImageNormalizeError(`Could not bring the image within ${target.maxBytes} bytes: ${last?.length ?? source.bytes} bytes after ${MAX_ATTEMPTS} attempts.`);
+}

package/dist/media/index.d.ts

@@ -0,0 +1 @@
+export { normalizeImage, ImageNormalizeError, type ImageTarget, type ImageFacts, type NormalizedImage, } from './image.ts';

package/dist/media/index.js

@@ -0,0 +1 @@
+export { normalizeImage, ImageNormalizeError, } from "./image.js";

package/dist/migrations.js

@@ -394,7 +394,7 @@ export function makeTable(em, table, record) {
 export async function renameSystemShelfKey(em) {
     await makeTable(em, '_embeddings').renameColumn('type', 'shelf_key');
 }
-const LEGACY_ORCHESTRATOR_FIELDS = ['agent_id', 'access_password', 'trigger_prefix', 'reply_window'];
+const LEGACY_ORCHESTRATOR_FIELDS = ['agent_id', 'trigger_prefix', 'reply_window'];
 export const SYSTEM_MIGRATIONS = [
     {
         name: 'embeddings-shelf-key',

package/dist/orchestrator/agent-capabilities.d.ts

@@ -1,2 +1,2 @@
-import type { AgentToolProvider, AttachmentRef } from './types.ts';
-export declare function makeAttachmentCapabilities(attachments: AttachmentRef[]): Promise<AgentToolProvider>;
+import type { AgentMediaLimits, AgentToolProvider, AttachmentRef } from './types.ts';
+export declare function makeAttachmentCapabilities(attachments: AttachmentRef[], limits: AgentMediaLimits): Promise<AgentToolProvider>;

package/dist/orchestrator/agent-capabilities.js

@@ -57,8 +57,8 @@ function fileItems(value) {
 function findTool(defs, name) {
     return defs.find((def) => def.server === 'coffer' && def.bareName === name);
 }
-export async function makeAttachmentCapabilities(attachments) {
-    const defs = await collectMcpTools();
+export async function makeAttachmentCapabilities(attachments, limits) {
+    const defs = await collectMcpTools({ role: 'member' });
     const getRecord = findTool(defs, 'get_record');
     const updateRecord = findTool(defs, 'update_record');
     const tools = [];
@@ -115,7 +115,7 @@ export async function makeAttachmentCapabilities(attachments) {
                 return inspectUpload(item['name'], {
                     ...(typeof item['mime'] === 'string' ? { mime: item['mime'] } : {}),
                     ...(typeof item['size'] === 'number' ? { size: item['size'] } : {}),
-                });
+                }, limits);
             },
         });
     }

package/dist/orchestrator/allow.d.ts

@@ -1,16 +1 @@
-import type { GatePolicy } from './types.ts';
-export declare const stateDir: () => string;
-export declare function carryLegacyState(): void;
-export declare function allowFileFor(connectorId: string): string;
-export interface AllowState {
-    ids: Record<string, number>;
-}
-export declare function emptyAllowed(): AllowState;
-export declare function loadAllowed(file: string): AllowState;
-export declare function saveAllowed(file: string, state: AllowState): void;
-export declare function isAllowed(state: AllowState, id: string | number | null | undefined): boolean;
-export declare function addAllowed(state: AllowState, id: string | number, now: number): AllowState;
-export declare function isSenderAllowed(connectorId: string, senderId: string, deps?: {
-    policy?: GatePolicy;
-}): Promise<boolean>;
-export declare function makeThrottle(maxAttempts?: number, windowMs?: number): (id: string | number, now?: number) => boolean;
+export declare function makeThrottle(maxNotices?: number, windowMs?: number): (id: string | number, now?: number) => boolean;

package/dist/orchestrator/allow.js

@@ -1,63 +1,13 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { loadGatePolicy } from "./config.js";
-import { carryInto, dataDir } from "../data-dir.js";
-export const stateDir = () => process.env['ORCHESTRATOR_STATE_DIR'] ?? path.join(dataDir(), 'state');
-function legacyStateDirs() {
-    return [
-        path.join(process.cwd(), 'packages', 'plugin-orchestrator', 'runtime', 'state'),
-        path.join(process.cwd(), 'node_modules', '@coffer-org', 'plugin-orchestrator', 'runtime', 'state'),
-    ];
-}
-export function carryLegacyState() {
-    carryInto(stateDir(), ...legacyStateDirs());
-}
-export function allowFileFor(connectorId) {
-    return path.join(stateDir(), `${connectorId}.allowed.json`);
-}
-export function emptyAllowed() {
-    return { ids: {} };
-}
-export function loadAllowed(file) {
-    try {
-        const obj = JSON.parse(fs.readFileSync(file, 'utf-8'));
-        if (obj && typeof obj === 'object' && 'ids' in obj && typeof obj.ids === 'object') {
-            return obj;
-        }
-        return emptyAllowed();
-    }
-    catch {
-        return emptyAllowed();
-    }
-}
-export function saveAllowed(file, state) {
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    const tmp = `${file}.${process.pid}.tmp`;
-    fs.writeFileSync(tmp, JSON.stringify(state), 'utf-8');
-    fs.renameSync(tmp, file);
-}
-export function isAllowed(state, id) {
-    return id != null && Object.prototype.hasOwnProperty.call(state.ids, String(id));
-}
-export function addAllowed(state, id, now) {
-    return { ids: { ...state.ids, [String(id)]: now } };
-}
-export async function isSenderAllowed(connectorId, senderId, deps) {
-    const policy = deps?.policy ?? (await loadGatePolicy());
-    if (!policy.accessPassword)
-        return true;
-    return isAllowed(loadAllowed(allowFileFor(connectorId)), senderId);
-}
-export function makeThrottle(maxAttempts = 5, windowMs = 60_000) {
+export function makeThrottle(maxNotices = 5, windowMs = 60_000) {
     const hits = new Map();
-    return function allowAttempt(id, now = Date.now()) {
+    return function allowNotice(id, now = Date.now()) {
         const key = String(id);
         const rec = hits.get(key);
         if (!rec || now - rec.start >= windowMs) {
             hits.set(key, { start: now, count: 1 });
             return true;
         }
-        if (rec.count >= maxAttempts)
+        if (rec.count >= maxNotices)
             return false;
         rec.count += 1;
         return true;

package/dist/orchestrator/config.js

@@ -3,7 +3,6 @@ export function buildPolicy(dbSettings = {}) {
     const db = dbSettings;
     return {
         ...(typeof db.agent_id === 'string' && db.agent_id ? { agentId: db.agent_id } : {}),
-        accessPassword: db.access_password ?? '',
         triggerPrefix: db.trigger_prefix ?? '',
         replyWindow: Number(db.reply_window ?? 1800) || 1800,
     };

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

@@ -0,0 +1,27 @@
+import type { AuthRole } from '../plugin-hooks.ts';
+export interface ContextFact {
+    name: string;
+    value: string;
+    attrs?: Record<string, string>;
+}
+export declare const CONNECTOR_FACT_NAME: RegExp;
+export declare const CONTEXT_GAP_MS: number;
+export declare const MAX_SPEAKER_NAME = 80;
+export declare const MAX_FACT_VALUE = 200;
+export declare const MAX_CONNECTOR_FACTS = 12;
+export declare function oneLine(value: string, maxLen?: number): string;
+export interface ContextSpeaker {
+    id: string;
+    name: string;
+    role: AuthRole;
+}
+export interface ContextInput {
+    connectorFacts: readonly ContextFact[];
+    speaker: ContextSpeaker;
+    now: Date;
+    timeZone: string;
+    previous: readonly ContextFact[] | null;
+    previousAt: Date | null;
+}
+export declare function humanizeGap(ms: number): string;
+export declare function buildContextFacts(input: ContextInput): ContextFact[];

package/dist/orchestrator/context-facts.js

@@ -0,0 +1,89 @@
+import { currentMoment } from "./environment.js";
+export const CONNECTOR_FACT_NAME = /^[a-z][a-z0-9-]*$/;
+export const CONTEXT_GAP_MS = 60 * 60_000;
+export const MAX_SPEAKER_NAME = 80;
+export const MAX_FACT_VALUE = 200;
+export const MAX_CONNECTOR_FACTS = 12;
+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;
+}
+const ORCHESTRATOR_FACT_NAMES = new Set(['at', 'gap', 'speaker', 'cleared']);
+function sameFact(a, b) {
+    if (a.value !== b.value)
+        return false;
+    const ka = Object.keys(a.attrs ?? {}).sort();
+    const kb = Object.keys(b.attrs ?? {}).sort();
+    if (ka.length !== kb.length || ka.some((k, i) => k !== kb[i]))
+        return false;
+    return ka.every((k) => a.attrs[k] === b.attrs[k]);
+}
+function dayAndZone(atValue) {
+    const [date, , ...zone] = atValue.split(' ');
+    return `${date} ${zone.join(' ')}`;
+}
+export function humanizeGap(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 buildContextFacts(input) {
+    const prev = input.previous;
+    const stated = (name) => prev?.find((f) => f.name === name);
+    const moment = currentMoment(input.now, input.timeZone);
+    const at = { name: 'at', value: `${moment} ${input.timeZone}` };
+    const speakerName = oneLine(input.speaker.name, MAX_SPEAKER_NAME) || 'unknown';
+    const speaker = {
+        name: 'speaker',
+        value: speakerName,
+        attrs: { id: oneLine(input.speaker.id, MAX_SPEAKER_NAME), role: input.speaker.role },
+    };
+    const facts = [];
+    const gapMs = input.previousAt ? input.now.getTime() - input.previousAt.getTime() : null;
+    const prevAt = stated('at');
+    const dayChanged = prevAt !== undefined && dayAndZone(prevAt.value) !== dayAndZone(at.value);
+    const stale = gapMs !== null && gapMs >= CONTEXT_GAP_MS;
+    if (!prevAt || dayChanged || stale) {
+        facts.push(at);
+        if (stale && gapMs !== null)
+            facts.push({ name: 'gap', value: humanizeGap(gapMs) });
+    }
+    const prevSpeaker = stated('speaker');
+    if (!prevSpeaker || !sameFact(prevSpeaker, speaker))
+        facts.push(speaker);
+    const validConnectorFacts = input.connectorFacts
+        .filter((f) => typeof f?.name === 'string' &&
+        CONNECTOR_FACT_NAME.test(f.name) &&
+        !ORCHESTRATOR_FACT_NAMES.has(f.name) &&
+        typeof f.value === 'string' &&
+        Object.entries(f.attrs ?? {}).every(([k, v]) => CONNECTOR_FACT_NAME.test(k) && typeof v === 'string'))
+        .slice(0, MAX_CONNECTOR_FACTS);
+    const currentConnectorNames = new Set(validConnectorFacts.map((f) => f.name));
+    for (const raw of validConnectorFacts) {
+        const fact = {
+            name: raw.name,
+            value: oneLine(raw.value, MAX_FACT_VALUE),
+            ...(raw.attrs
+                ? { attrs: Object.fromEntries(Object.entries(raw.attrs).map(([k, v]) => [k, oneLine(v, MAX_FACT_VALUE)])) }
+                : {}),
+        };
+        const before = stated(fact.name);
+        if (!before || !sameFact(before, fact))
+            facts.push(fact);
+    }
+    if (prev) {
+        for (const priorFact of prev) {
+            if (ORCHESTRATOR_FACT_NAMES.has(priorFact.name))
+                continue;
+            if (currentConnectorNames.has(priorFact.name))
+                continue;
+            facts.push({ name: 'cleared', value: oneLine(priorFact.name) });
+        }
+    }
+    return facts;
+}

package/dist/orchestrator/conversation-access.d.ts

@@ -0,0 +1,9 @@
+export interface ConversationAccess {
+    owner: string | null;
+    visibility: 'private' | null;
+}
+export declare function mayRead(access: ConversationAccess, viewerId: string): boolean;
+export declare function mayWrite(access: ConversationAccess, viewerId: string): boolean;
+export declare function mayBePrivate(capabilities: {
+    privateChats: boolean;
+}): boolean;

package/dist/orchestrator/conversation-access.js

@@ -0,0 +1,12 @@
+function isOwner(access, viewerId) {
+    return access.owner !== null && access.owner === viewerId;
+}
+export function mayRead(access, viewerId) {
+    return access.visibility !== 'private' || isOwner(access, viewerId);
+}
+export function mayWrite(access, viewerId) {
+    return access.visibility !== 'private' || isOwner(access, viewerId);
+}
+export function mayBePrivate(capabilities) {
+    return capabilities.privateChats;
+}

package/dist/orchestrator/environment.d.ts

@@ -1,2 +1,3 @@
 export declare function systemTimeZone(): string;
 export declare function todayDateString(now?: Date, timeZone?: string): string;
+export declare function currentMoment(now?: Date, timeZone?: string): string;