@coffer-org/plugin-orchestrator 1.3.1 → 2.0.0

package/dist/index.js

@@ -4,7 +4,7 @@ import { field } from '@coffer-org/sdk/fields';
 export default definePlugin({
     id: 'orchestrator',
     version: '1.0.0',
-    dependsOn: ['agent'],
+    dependsOn: ['claude-agent'],
     settings: defineSettings({
         label: 'orchestrator.settings.label',
         fields: [

package/dist/runtime/db.d.ts

@@ -4,7 +4,6 @@ export type LogTurn = {
     userId: string;
     role: 'user' | 'assistant';
     text: string;
-    sessionId: string | null;
     tokensIn: number | null;
     tokensOut: number | null;
     ms: number | null;

package/dist/runtime/index.d.ts

@@ -2,5 +2,8 @@ import type { PluginHooks } from '@coffer-org/server/plugin-hooks';
 export { handleIncoming } from './pipeline.ts';
 export type { PipelineDeps, RunAgentFn } from './pipeline.ts';
 export { buildPolicy, loadGatePolicy } from './config.ts';
-export type { Connector, ConnectorCapabilities, IncomingPayload, GatePolicy } from './types.ts';
+export { makeLiveChannel, plainRender } from './live-message.ts';
+export type { LiveChannelOps, LiveChannelOpts, RenderFn } from './live-message.ts';
+export { chunk } from './format.ts';
+export type { Connector, IncomingConversation, GatePolicy, ReplyContext, ReplyPayload, ReplyChannel, ConvMessage, SystemLayer, AgentRequest, AgentResult, } from './types.ts';
 export declare const serverHooks: PluginHooks;

package/dist/runtime/index.js

@@ -2,6 +2,8 @@ import { openLogDb } from "./db.js";
 import { setLogDb } from "./pipeline.js";
 export { handleIncoming } from "./pipeline.js";
 export { buildPolicy, loadGatePolicy } from "./config.js";
+export { makeLiveChannel, plainRender } from "./live-message.js";
+export { chunk } from "./format.js";
 let db;
 export const serverHooks = {
     init: () => { db = openLogDb(); setLogDb(db); },

package/dist/runtime/live-message.d.ts

@@ -0,0 +1,14 @@
+import type { ReplyChannel, ReplyPayload } from './types.ts';
+export interface LiveChannelOps {
+    send(text: string): Promise<string | null>;
+    edit(msgId: string, text: string): Promise<void>;
+}
+export type RenderFn = (r: ReplyPayload) => string[];
+export interface LiveChannelOpts {
+    ops: LiveChannelOps;
+    throttleMs: number;
+    render: RenderFn;
+    maxLength: number;
+}
+export declare function plainRender(max: number): RenderFn;
+export declare function makeLiveChannel(o: LiveChannelOpts): ReplyChannel;

package/dist/runtime/live-message.js

@@ -0,0 +1,83 @@
+import { chunk } from "./format.js";
+import { getLogger } from '@coffer-org/sdk/logger';
+const log = getLogger('orchestrator');
+export function plainRender(max) {
+    return (r) => chunk((r.text ?? '').trim() || '⚠️ the agent returned no response', max);
+}
+async function swallow(fn, fallback, label) {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        log.error(`live-message ${label}: ${err instanceof Error ? err.message : String(err)}`);
+        return fallback;
+    }
+}
+export function makeLiveChannel(o) {
+    let msgId = null;
+    let pending = '';
+    let lastSent = '';
+    let busy = false;
+    let closed = false;
+    let gen = 0;
+    let inFlight = Promise.resolve();
+    const timer = setInterval(() => {
+        if (closed || busy)
+            return;
+        const t = pending.slice(0, o.maxLength);
+        if (!t || t === lastSent)
+            return;
+        busy = true;
+        const myGen = gen;
+        if (!msgId) {
+            inFlight = o.ops.send(t)
+                .then((id) => { if (gen === myGen) {
+                msgId = id;
+                lastSent = t;
+            } })
+                .catch((err) => { log.error(`live-message send: ${err instanceof Error ? err.message : String(err)}`); })
+                .finally(() => { busy = false; });
+            return;
+        }
+        const id = msgId;
+        inFlight = o.ops.edit(id, t)
+            .then(() => { if (gen === myGen)
+            lastSent = t; })
+            .catch((err) => { log.error(`live-message edit: ${err instanceof Error ? err.message : String(err)}`); })
+            .finally(() => { busy = false; });
+    }, o.throttleMs);
+    if (typeof timer.unref === 'function')
+        timer.unref();
+    return {
+        update(text) {
+            pending = text;
+        },
+        segment() {
+            gen++;
+            msgId = null;
+            pending = '';
+            lastSent = '';
+        },
+        async finish(r) {
+            closed = true;
+            clearInterval(timer);
+            await inFlight;
+            const parts = o.render(r);
+            let last = null;
+            const [head, ...rest] = parts;
+            if (msgId && head !== undefined) {
+                const id = msgId;
+                await swallow(() => o.ops.edit(id, head), undefined, 'edit(final)');
+                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;
+        },
+    };
+}

package/dist/runtime/pipeline.d.ts

@@ -1,12 +1,12 @@
-import { runAgent } from '@coffer-org/plugin-agent/runtime';
-import type { Connector, IncomingPayload, GatePolicy } from './types.ts';
+import { runAgent } from '@coffer-org/plugin-claude-agent/runtime';
+import type { Connector, IncomingConversation, GatePolicy } from './types.ts';
 import type { LogDb } from './db.ts';
 export declare function setLogDb(db: LogDb | undefined): void;
 export type RunAgentFn = typeof runAgent;
 export interface PipelineDeps {
     runAgent?: RunAgentFn;
     logDb?: LogDb | null;
-    throttleMs?: number;
     policy?: GatePolicy;
+    agentBase?: () => Promise<string>;
 }
-export declare function handleIncoming(connector: Connector, payload: IncomingPayload, deps?: PipelineDeps): Promise<void>;
+export declare function handleIncoming(connector: Connector, conversation: IncomingConversation, deps?: PipelineDeps): Promise<void>;

package/dist/runtime/pipeline.js

@@ -1,12 +1,10 @@
-import { runAgent } from '@coffer-org/plugin-agent/runtime';
-import { chunk } from "./format.js";
+import { runAgent, agentSystemBase } from '@coffer-org/plugin-claude-agent/runtime';
 import { join } from 'node:path';
-import { loadThreads, saveThreads, resolveParent, getSession, recordSession, pruneThreads, } from "./threads.js";
 import { loadAllowed, saveAllowed, isAllowed, addAllowed, makeThrottle } from "./allow.js";
 import { loadGatePolicy } from "./config.js";
+import { buildSystem } from "./system-assembly.js";
 import { getLogger } from '@coffer-org/sdk/logger';
 const log = getLogger('orchestrator');
-const DEFAULT_STREAM_THROTTLE_MS = 2000;
 const stateDir = () => process.env['ORCHESTRATOR_STATE_DIR']
     ?? join(new URL('../../runtime/state', import.meta.url).pathname);
 let logDb;
@@ -20,6 +18,17 @@ function passThrottle(connectorId) {
     }
     return t;
 }
+let cachedBase;
+function cachedAgentBase() { return (cachedBase ??= agentSystemBase()); }
+function openChannel(connector, chatId, ctx) {
+    try {
+        return connector.reply(chatId, ctx);
+    }
+    catch (err) {
+        log.error(`connector error in reply: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
 async function safeCall(fn, fallback, label) {
     try {
         return await fn();
@@ -29,115 +38,85 @@ async function safeCall(fn, fallback, label) {
         return fallback;
     }
 }
-export async function handleIncoming(connector, payload, deps) {
+export async function handleIncoming(connector, conversation, deps) {
     const agent = deps?.runAgent ?? runAgent;
     const db = deps && 'logDb' in deps ? deps.logDb : logDb;
-    const throttleMs = deps?.throttleMs ?? DEFAULT_STREAM_THROTTLE_MS;
     const policy = deps?.policy ?? await loadGatePolicy();
-    const { chatId, userId, text, replyToId } = payload;
+    const agentBase = deps?.agentBase ?? cachedAgentBase;
+    const { connectorId, chatId, sender, messages } = conversation;
+    const last = messages[messages.length - 1];
+    if (!last || last.role !== 'user')
+        return;
+    const incomingMsgId = last.msgId;
     const dir = stateDir();
-    const allowFile = join(dir, `${connector.id}.allowed.json`);
-    const threadsFile = join(dir, `${connector.id}.threads.json`);
+    const allowFile = join(dir, `${connectorId}.allowed.json`);
     if (policy.accessPassword) {
         let allow = loadAllowed(allowFile);
-        if (!isAllowed(allow, userId)) {
-            if (text.trim() === policy.accessPassword) {
-                allow = addAllowed(allow, userId, Date.now());
+        if (!isAllowed(allow, sender.id)) {
+            if (last.content.trim() === policy.accessPassword) {
+                allow = addAllowed(allow, sender.id, Date.now());
                 saveAllowed(allowFile, allow);
-                await safeCall(() => connector.sendMessage(chatId, '✅ Access granted. Send your requests.'), null, 'sendMessage(enroll)');
+                const ch = openChannel(connector, chatId, { parentMsgId: incomingMsgId });
+                if (ch)
+                    await safeCall(() => ch.finish({ text: '✅ Access granted. Send your requests.', reasoning: null }), null, 'finish(enroll)');
             }
-            else if (passThrottle(connector.id)(userId)) {
-                await safeCall(() => connector.sendMessage(chatId, '🔒 Access locked. Send the password to gain access.'), null, 'sendMessage(locked)');
+            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 }), null, 'finish(locked)');
             }
             return;
         }
     }
-    if (policy.triggerPrefix && !text.toLowerCase().startsWith(policy.triggerPrefix.toLowerCase()))
+    if (policy.triggerPrefix && !last.content.toLowerCase().startsWith(policy.triggerPrefix.toLowerCase()))
         return;
-    const queryText = policy.triggerPrefix ? text.slice(policy.triggerPrefix.length).trim() : text.trim();
+    const queryText = policy.triggerPrefix ? last.content.slice(policy.triggerPrefix.length).trim() : last.content.trim();
     if (!queryText)
         return;
-    const now = Date.now();
-    let threads = loadThreads(threadsFile);
-    const parent = resolveParent(threads, { replyToMsgId: replyToId, now }, policy.replyWindow);
-    const parentSession = getSession(threads, parent);
-    db?.logTurn({ connector: connector.id, chatId, userId, role: 'user', text: queryText, sessionId: parentSession, tokensIn: null, tokensOut: null, ms: null });
+    const agentMessages = policy.triggerPrefix
+        ? messages.map((m, i) => (i === messages.length - 1 ? { ...m, content: queryText } : m))
+        : messages;
+    const base = await agentBase();
+    const system = buildSystem({
+        base,
+        channelSystem: conversation.channelSystem,
+        volatileSystem: conversation.volatileSystem,
+    });
+    db?.logTurn({ connector: connectorId, chatId, userId: sender.id, role: 'user', text: queryText, tokensIn: null, tokensOut: null, ms: null });
     const startedAt = Date.now();
-    const canStream = connector.capabilities.streaming && typeof connector.editMessage === 'function';
-    const max = connector.capabilities.maxMessageLength;
+    const ch = openChannel(connector, chatId, { parentMsgId: incomingMsgId });
+    if (!ch)
+        return;
     let result;
-    let placeholderId = null;
-    if (canStream) {
-        const stopTyping = connector.capabilities.typing && connector.startTyping
-            ? await safeCall(async () => connector.startTyping(chatId), undefined, 'startTyping')
-            : undefined;
-        let pending = '', lastEdited = '', editing = false, closed = false;
-        let editPromise = Promise.resolve();
-        const timer = setInterval(() => {
-            if (closed || editing)
-                return;
-            const t = pending.slice(0, max);
-            if (!t || t === lastEdited)
-                return;
-            editing = true;
-            if (!placeholderId) {
-                editPromise = safeCall(() => connector.sendMessage(chatId, t), null, 'sendMessage(stream-create)')
-                    .then((s) => { placeholderId = s?.msgId ?? null; lastEdited = t; })
-                    .finally(() => { editing = false; });
-                return;
+    try {
+        result = await agent({
+            system,
+            messages: agentMessages,
+            onDelta: (acc) => { try {
+                ch.update(acc);
             }
-            editPromise = safeCall(() => connector.editMessage(chatId, placeholderId, t), undefined, 'editMessage(stream)')
-                .then(() => { lastEdited = t; })
-                .finally(() => { editing = false; });
-        }, throttleMs);
-        try {
-            result = await agent({ prompt: queryText, sessionId: parentSession, onDelta: (acc) => { pending = acc; } });
-            if (result.text == null && parentSession)
-                result = await agent({ prompt: queryText, sessionId: null, onDelta: (acc) => { pending = acc; } });
-        }
-        finally {
-            closed = true;
-            clearInterval(timer);
-            await editPromise;
-            stopTyping?.();
-        }
-    }
-    else {
-        const stopTyping = connector.capabilities.typing && connector.startTyping
-            ? await safeCall(async () => connector.startTyping(chatId), undefined, 'startTyping')
-            : undefined;
-        try {
-            result = await agent({ prompt: queryText, sessionId: parentSession });
-            if (result.text == null && parentSession)
-                result = await agent({ prompt: queryText, sessionId: null });
-        }
-        finally {
-            stopTyping?.();
-        }
-    }
-    let botMsgId = null;
-    const out = result.text ?? '⚠️ the agent returned no response';
-    const parts = chunk(out, max);
-    if (canStream && placeholderId) {
-        await safeCall(() => connector.editMessage(chatId, placeholderId, parts[0]), undefined, 'editMessage(final)');
-        botMsgId = placeholderId;
-        for (const p of parts.slice(1)) {
-            const s = await safeCall(() => connector.sendMessage(chatId, p), null, 'sendMessage(overflow)');
-            botMsgId = s?.msgId ?? botMsgId;
-        }
-    }
-    else {
-        for (const p of parts) {
-            const s = await safeCall(() => connector.sendMessage(chatId, p), null, 'sendMessage(deliver)');
-            botMsgId = s?.msgId ?? botMsgId;
-        }
+            catch (err) {
+                log.error(`connector error in update: ${err instanceof Error ? err.message : String(err)}`);
+            } },
+            onReasoning: (acc) => { try {
+                ch.updateReasoning?.(acc);
+            }
+            catch (err) {
+                log.error(`connector error in updateReasoning: ${err instanceof Error ? err.message : String(err)}`);
+            } },
+            onSegment: () => { try {
+                ch.segment();
+            }
+            catch (err) {
+                log.error(`connector error in segment: ${err instanceof Error ? err.message : String(err)}`);
+            } },
+        });
     }
-    if (result.text)
-        db?.logTurn({ connector: connector.id, chatId, userId, role: 'assistant', text: result.text, sessionId: result.sessionId, tokensIn: result.tokensIn, tokensOut: result.tokensOut, ms: Date.now() - startedAt });
-    if (result.sessionId) {
-        const incomingMsgId = replyToId ?? String(now);
-        threads = recordSession(threads, { msgId: incomingMsgId, botMsgId, sessionId: result.sessionId, now });
-        threads = pruneThreads(threads, now, 7);
-        saveThreads(threadsFile, threads);
+    catch (err) {
+        log.error(`agent error: ${err instanceof Error ? err.message : String(err)}`);
     }
+    const botMsgId = await safeCall(() => ch.finish({ text: result?.text ?? null, reasoning: result?.reasoning ?? null }), null, 'finish');
+    if (result?.text)
+        db?.logTurn({ connector: connectorId, chatId, userId: sender.id, role: 'assistant', text: result.text, tokensIn: result.tokensIn, tokensOut: result.tokensOut, ms: Date.now() - startedAt });
+    await safeCall(() => connector.recordAssistant({ parentMsgId: incomingMsgId, botMsgId, text: result?.text ?? '', reasoning: result?.reasoning ?? null }), undefined, 'recordAssistant');
 }

package/dist/runtime/system-assembly.d.ts

@@ -0,0 +1,6 @@
+import type { SystemLayer } from './types.ts';
+export declare function buildSystem(input: {
+    base: string;
+    channelSystem?: string;
+    volatileSystem?: string;
+}): SystemLayer[];

package/dist/runtime/system-assembly.js

@@ -0,0 +1,7 @@
+export function buildSystem(input) {
+    const text = [input.base, input.channelSystem].filter(Boolean).join('\n\n');
+    const layers = [{ text, stable: true }];
+    if (input.volatileSystem?.trim())
+        layers.push({ text: input.volatileSystem, stable: false });
+    return layers;
+}

package/dist/runtime/types.d.ts

@@ -1,22 +1,38 @@
-export interface ConnectorCapabilities {
-    streaming: boolean;
-    typing: boolean;
-    maxMessageLength: number;
+export type { ConvMessage, SystemLayer, AgentRequest, AgentResult } from '@coffer-org/plugin-claude-agent/runtime';
+import type { ConvMessage } from '@coffer-org/plugin-claude-agent/runtime';
+export interface IncomingConversation {
+    connectorId: string;
+    chatId: string;
+    channelSystem?: string;
+    volatileSystem?: string;
+    sender: {
+        id: string;
+        displayName?: string;
+    };
+    messages: ConvMessage[];
+}
+export interface ReplyContext {
+    parentMsgId: string | null;
+}
+export interface ReplyPayload {
+    text: string | null;
+    reasoning: string | null;
+}
+export interface ReplyChannel {
+    update(text: string): void;
+    updateReasoning?(acc: string): void;
+    segment(): void;
+    finish(r: ReplyPayload): Promise<string | null>;
 }
 export interface Connector {
     id: string;
-    capabilities: ConnectorCapabilities;
-    sendMessage(chatId: string, text: string): Promise<{
-        msgId: string;
-    } | null>;
-    editMessage?(chatId: string, msgId: string, text: string): Promise<void>;
-    startTyping?(chatId: string): () => void;
-}
-export interface IncomingPayload {
-    chatId: string;
-    userId: string;
-    text: string;
-    replyToId: string | null;
+    reply(chatId: string, ctx: ReplyContext): ReplyChannel;
+    recordAssistant(m: {
+        parentMsgId: string | null;
+        botMsgId: string | null;
+        text: string;
+        reasoning: string | null;
+    }): Promise<void>;
 }
 export interface GatePolicy {
     accessPassword: string;

package/dist/schema.js

@@ -154,7 +154,10 @@ function assignProp(target, prop, value) {
 }
 function mergeDefs(...defs) {
 	const mergedDescriptors = {};
-	for (const def of defs) Object.assign(mergedDescriptors, Object.getOwnPropertyDescriptors(def));
+	for (const def of defs) {
+		const descriptors = Object.getOwnPropertyDescriptors(def);
+		Object.assign(mergedDescriptors, descriptors);
+	}
 	return Object.defineProperties({}, mergedDescriptors);
 }
 function esc(str) {
@@ -476,7 +479,7 @@ var _parse = (_Err) => (schema, value, _ctx, _params) => {
 	}, ctx);
 	if (result instanceof Promise) throw new $ZodAsyncError();
 	if (result.issues.length) {
-		const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+		const e = new ((_params?.Err) ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
 		captureStackTrace(e, _params?.callee);
 		throw e;
 	}
@@ -493,7 +496,7 @@ var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
 	}, ctx);
 	if (result instanceof Promise) result = await result;
 	if (result.issues.length) {
-		const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+		const e = new ((params?.Err) ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
 		captureStackTrace(e, params?.callee);
 		throw e;
 	}
@@ -1589,13 +1592,13 @@ var $ZodObject = /*@__PURE__*/ $constructor("$ZodObject", (inst, def) => {
 		}
 		return propValues;
 	});
-	const isObject$1 = isObject;
+	const isObject$2 = isObject;
 	const catchall = def.catchall;
 	let value;
 	inst._zod.parse = (payload, ctx) => {
 		value ?? (value = _normalized.value);
 		const input = payload.value;
-		if (!isObject$1(input)) {
+		if (!isObject$2(input)) {
 			payload.issues.push({
 				expected: "object",
 				code: "invalid_type",
@@ -1718,7 +1721,7 @@ var $ZodObjectJIT = /*@__PURE__*/ $constructor("$ZodObjectJIT", (inst, def) => {
 		return (payload, ctx) => fn(shape, payload, ctx);
 	};
 	let fastpass;
-	const isObject$2 = isObject;
+	const isObject$1 = isObject;
 	const jit = !globalConfig.jitless;
 	const fastEnabled = jit && allowsEval.value;
 	const catchall = def.catchall;
@@ -1726,7 +1729,7 @@ var $ZodObjectJIT = /*@__PURE__*/ $constructor("$ZodObjectJIT", (inst, def) => {
 	inst._zod.parse = (payload, ctx) => {
 		value ?? (value = _normalized.value);
 		const input = payload.value;
-		if (!isObject$2(input)) {
+		if (!isObject$1(input)) {
 			payload.issues.push({
 				expected: "object",
 				code: "invalid_type",
@@ -1945,7 +1948,7 @@ var $ZodOptional = /*@__PURE__*/ $constructor("$ZodOptional", (inst, def) => {
 	inst._zod.optin = "optional";
 	inst._zod.optout = "optional";
 	defineLazy(inst._zod, "values", () => {
-		return def.innerType._zod.values ? new Set([...def.innerType._zod.values, void 0]) : void 0;
+		return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, void 0]) : void 0;
 	});
 	defineLazy(inst._zod, "pattern", () => {
 		const pattern = def.innerType._zod.pattern;
@@ -1979,7 +1982,7 @@ var $ZodNullable = /*@__PURE__*/ $constructor("$ZodNullable", (inst, def) => {
 		return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0;
 	});
 	defineLazy(inst._zod, "values", () => {
-		return def.innerType._zod.values ? new Set([...def.innerType._zod.values, null]) : void 0;
+		return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, null]) : void 0;
 	});
 	inst._zod.parse = (payload, ctx) => {
 		if (payload.value === null) return payload;
@@ -4587,7 +4590,7 @@ function password(raw) {
 * Internal API-token list — keyValue-shaped collection (name + write-only
 * token + timestamps), custom renderer (`kind:'internalApiToken'`, own
 * create/revoke UI — same trick as url()/perWeekday()). "Internal" = not a
-* general-purpose field type for plugin modules, only for the core account
+* general-purpose field type for plugin shelves, only for the core account
 * settings page. `token` is `kind:'password'` so maskSecrets/preserveTree
 * already mask/preserve it for free.
 */
@@ -4606,6 +4609,25 @@ function internalApiToken(o) {
 		]
 	});
 }
+/**
+* Internal "connected apps" list — the OAuth clients (claude.ai & co) the user
+* has authorized for MCP access. Same "internal" caveat and custom-renderer
+* trick as internalApiToken(): read-only rows + a revoke action, never part of
+* the parent form's save.
+*/
+function internalOauthGrants(o) {
+	return group({
+		key: o.key,
+		label: o.label ?? o.key,
+		multiple: true,
+		view: { kind: "internalOauthGrants" },
+		fields: [
+			string({ key: "clientName" }),
+			string({ key: "createdAt" }),
+			string({ key: "lastUsedAt" })
+		]
+	});
+}
 var SLUG_RE = /^[a-z0-9-]+$/;
 function slug(raw) {
 	const o = normalizeOpts(raw);
@@ -4686,7 +4708,7 @@ var TEL_RE = /^\+?[\d\s()-]{4,}$/;
 /** Loose URL: будь-який scheme:// АБО host-з-крапкою (+опц. порт/шлях). Без пробілів. */
 var LINK_RE = /^([a-z][a-z0-9+.-]*:\/\/\S+|[\w-]+(\.[\w-]+)+(:\d+)?(\/\S*)?)$/i;
 /** CSS named colors (CSS Color Module L4) — для f.colorname. */
-var CSS_COLOR_NAMES = new Set([
+var CSS_COLOR_NAMES = /* @__PURE__ */ new Set([
 	"aliceblue",
 	"antiquewhite",
 	"aqua",
@@ -5035,7 +5057,8 @@ var presets = {
 	weight,
 	dimensions,
 	country,
-	internalApiToken
+	internalApiToken,
+	internalOauthGrants
 };
 //#endregion
 //#region ../../node_modules/iso-639-1/src/data.js
@@ -5147,7 +5170,7 @@ var require_data = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		},
 		cs: {
 			name: "Czech",
-			nativeName: "Čeština"
+			nativeName: "čeština"
 		},
 		cu: {
 			name: "Old Church Slavonic",
@@ -5611,7 +5634,7 @@ var require_data = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		},
 		sk: {
 			name: "Slovak",
-			nativeName: "Slovenčina"
+			nativeName: "slovenčtina"
 		},
 		sl: {
 			name: "Slovenian",
@@ -5862,7 +5885,7 @@ function group(o) {
 		required: o.required,
 		unique: r.unique,
 		label: o.label,
-		icon: v.icon,
+		icon: o.icon,
 		display: v.display ?? "wrap",
 		kind: v.kind,
 		fixed: r.fixed,
@@ -5873,11 +5896,9 @@ function group(o) {
 function row(o) {
 	return group({
 		label: o.label,
+		icon: o.icon,
 		fields: o.fields,
-		view: {
-			...o.view,
-			display: "scroll"
-		}
+		view: { display: "scroll" }
 	});
 }
 /** Tabular collection (array of rows → <table>, aligned by columns). Sugar. */
@@ -5885,14 +5906,12 @@ function table(o) {
 	return group({
 		key: o.key,
 		label: o.label,
+		icon: o.icon,
 		fields: o.fields,
 		multiple: true,
 		required: o.required,
 		rules: o.rules,
-		view: {
-			...o.view,
-			display: "table"
-		}
+		view: { display: "table" }
 	});
 }
 /**
@@ -5908,11 +5927,9 @@ function sheet(o) {
 	});
 	return group({
 		label: o.label,
+		icon: o.icon,
 		fields: flat,
-		view: {
-			...o.view,
-			display: "sheet"
-		}
+		view: { display: "sheet" }
 	});
 }
 /**
@@ -5944,8 +5961,8 @@ function keyed(o) {
 	return {
 		...(o.container ?? group)({
 			label: o.label,
-			fields: [o.by, ...o.fields],
-			view: o.view
+			icon: o.icon,
+			fields: [o.by, ...o.fields]
 		}),
 		key: o.key,
 		multiple: true,
@@ -5989,6 +6006,34 @@ function wrapKey(opts, meta) {
 			noEditControl: true
 		}
 	};
+	if (opts.emphasis) m = {
+		...m,
+		hints: {
+			...m.hints,
+			emphasis: opts.emphasis
+		}
+	};
+	if (opts.noLabel) m = {
+		...m,
+		hints: {
+			...m.hints,
+			noLabel: true
+		}
+	};
+	if (opts.role) m = {
+		...m,
+		hints: {
+			...m.hints,
+			role: opts.role
+		}
+	};
+	if (opts.pinned) m = {
+		...m,
+		hints: {
+			...m.hints,
+			pinned: true
+		}
+	};
 	if (opts.default !== void 0) m = {
 		...m,
 		default: opts.default
@@ -6352,8 +6397,8 @@ function relation(raw) {
 			displayKey: o.displayKey ?? "name"
 		},
 		relation: {
-			vault: raw.options.vault,
-			type: raw.options.module
+			library: raw.options.library,
+			shelf: raw.options.shelf
 		},
 		...multi && { json: true },
 		zod: optionalize(s, required)
@@ -6733,15 +6778,44 @@ function period(raw) {
 		zod: optionalize(s, required)
 	});
 }
+/** Keys a file entry may carry. Everything else is rejected — see fileEntryIssue. */
+var FILE_KEYS = /* @__PURE__ */ new Set([
+	"name",
+	"mime",
+	"size"
+]);
+/** Keys that mean "the author pasted a remote address" — the one mistake worth naming. */
+var FILE_URL_KEYS = [
+	"url",
+	"src",
+	"href",
+	"link"
+];
+/**
+* A file entry points at a file already uploaded to the server: `{ name }`, where
+* name is the bare filename returned by POST /api/upload. Anything else — a remote
+* URL, an extra key, a path — is refused here, so a record can never hold a
+* reference the server cannot serve. `mime`/`size` are accepted (legacy payloads
+* and the web uploader send them) but the server overwrites them from disk.
+* Returns a vmsg code, or null when the entry is well-formed.
+*/
+function fileEntryIssue(it) {
+	if (typeof it !== "object" || it === null || Array.isArray(it)) return "file_structure";
+	const rec = it;
+	if (FILE_URL_KEYS.some((k) => k in rec)) return "file_remote_url";
+	const name = rec["name"];
+	if (typeof name !== "string" || name === "") return "file_structure";
+	if (name.includes("://") || name.startsWith("//")) return "file_remote_url";
+	if (/[\\/]/.test(name) || name.includes("..")) return "file_name";
+	for (const k of Object.keys(rec)) if (!FILE_KEYS.has(k)) return "file_unknown_key";
+	if (rec["mime"] !== void 0 && typeof rec["mime"] !== "string") return "file_structure";
+	if (rec["size"] !== void 0 && typeof rec["size"] !== "number") return "file_structure";
+	return null;
+}
 function makeFile(kind, raw) {
 	const o = normalizeOpts(raw);
 	const required = o.required ?? false;
 	const multiple = o.multiple ?? false;
-	const rowSchema = object({
-		name: string$1().min(1),
-		mime: string$1().optional(),
-		size: number$1().optional()
-	});
 	const s = unknown().superRefine((raw, ctx) => {
 		if (typeof raw === "string") try {
 			JSON.parse(raw);
@@ -6754,12 +6828,15 @@ function makeFile(kind, raw) {
 		}
 		const parsed = jsonValue(raw);
 		const items = Array.isArray(parsed) ? parsed : [parsed];
-		for (const it of items) if (!rowSchema.safeParse(it).success) {
-			ctx.addIssue({
-				code: ZodIssueCode.custom,
-				message: vmsg("file_structure")
-			});
-			return;
+		for (const it of items) {
+			const code = fileEntryIssue(it);
+			if (code) {
+				ctx.addIssue({
+					code: ZodIssueCode.custom,
+					message: vmsg(code)
+				});
+				return;
+			}
 		}
 	});
 	return wrapKey(o, {
@@ -7003,7 +7080,7 @@ function toClient(field) {
 var src_default = definePlugin({
 	id: "orchestrator",
 	version: "1.0.0",
-	dependsOn: ["agent"],
+	dependsOn: ["claude-agent"],
 	settings: defineSettings({
 		label: "orchestrator.settings.label",
 		fields: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coffer-org/plugin-orchestrator",
-  "version": "1.3.1",
+  "version": "2.0.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -25,9 +25,9 @@
     "postpack": "node ../../scripts/swap-exports.mjs src"
   },
   "dependencies": {
-    "@coffer-org/sdk": "^1.4.0",
-    "@coffer-org/server": "^1.4.0",
-    "@coffer-org/plugin-agent": "^1.3.1"
+    "@coffer-org/sdk": "^2.0.0",
+    "@coffer-org/server": "^2.0.1",
+    "@coffer-org/plugin-claude-agent": "^2.0.0"
   },
   "coffer": {
     "schema": "dist/schema.js"