@byokit/openclaw 0.23.0 → 0.25.0

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## Unreleased
 
+## 0.25.0 (2026-10-20)
+
+- Dependency update: pins @byokit/accounts 0.29.0.
+
+- FEAT: a MiniMax API key now lists and runs any model MiniMax's own `/models` lists, with no BYOKit model list: `kit.models({ authChoice: 'minimax-global-api' })` answers the vendor's models, and `addKey({ ..., model })` takes an id the list lags (such as `MiniMax-M3.1-Flash-Preview`) with the route's own capabilities (image input included) instead of refusing it or falling back to `MiniMax-M3`.
+- FIX: When a child a run sent work to (`sessions_send`, `timeoutSeconds: 0`) finished, the engine's own reply run bringing its report back to the sender's session was refused `unknown run` at every app tool. That return run is now admitted as the sender: same member and helper, same app-tool subset and delegates, and the sender's system text as its persona; `RunRef.parent` names the finished child. Any other run on that session is still refused.
+
+## 0.24.0 (2026-10-20)
+
+- FEAT: a helper's delegated run now speaks as its helper. A native `sessions_send` carries no system text, so the kit's plugin adds the helper's recorded persona (from `ensureHelper`) as system context to the admitted helper child's run, and only to it. No app change: Chief's `helperDelegates` send to `agent:<agent>:h-<helper>:<rest>` is enough. The kit plugin's config entry now sets `hooks.allowConversationAccess: true` for this hook. `sessions_spawn` children get no persona.
+- FEAT: a tracked `sessions_spawn` into the run's own agent (`delegates` naming it, e.g. Chief spawning under its own signed-in agent) reaches the engine as its own-agent spawn, so an app `subagents.allowAgents` list that names only other agents no longer refuses it.
+- FIX: a delegated child the engine no longer knows (as after an engine restart, when its end never reached the kit) now ends `lost` (new `DelegatedEvent.reason`, outcome unknown) at reconnect instead of staying admitted forever, and a dispatch that finds the 1024-entry journal full reconciles with the engine first, so those children can no longer block delegation. One unreadable `agent.wait` no longer fails the whole reconnect.
+
 ## 0.23.0 (2026-10-20)
 
 - FEATURE: A signed-out `claude-cli` run now says why: its end carries `cause: { code: 'needs_cli_login', cli: 'claude', home, configDir?, signIn }` (the new `CliLoginCause` type, also on `./device`). `signIn: true` means `kit.signIn(member, { authChoice: 'anthropic-cli' })` runs the Claude Code login into the kit's own folder (subscription billing); `signIn: false` means the engine reads the person's own Claude Code login, so they run `claude` on that machine. An `anthropic-cli` sign-in the kit cannot run carries the same `cause` on its failed view. `kind`, `message` and every other run end are unchanged.

package/README.md

@@ -443,14 +443,24 @@ Pass `delegates: { scout: ['report'] }` on `kit.run` to permit native delegation
 that app-tool subset. Ensure the target member first and configure the engine's own A2A/visibility/subagent policy;
 this option does not enable engine tools or bypass `host.gate`. The parent subset narrows descendants too.
 Tracked `sessions_send` requires an explicit full `sessionKey` and `timeoutSeconds: 0`; tracked `sessions_spawn`
-requires an explicit allowed `agentId` and native runtime (not ACP). Unknown children fail closed.
+requires an explicit allowed `agentId` and native runtime (not ACP). A tracked spawn into the run's own agent
+(`delegates: { chief: [...] }` on a `chief` run) goes to the engine as its own-agent spawn, so an app
+`subagents.allowAgents` list for other agents does not refuse it. Unknown children fail closed.
 
 `kit.delegatedRuns()` lists admitted children. `kit.onEvent('byokit.delegated', fn)` reports admission, native streams
 and terminal observations with exact `runId`, `agentId`, `member`, `sessionKey`, `parent` and `root` identity.
 The same identity reaches `ToolHost`; each delegated action has its own gate/approval. Tool arguments/results
 are omitted from this event surface. An accepted native dispatch is not finished work or proof of delivery.
 
-Admitted exact run IDs survive parent settlement and are reconciled on reconnect/start. `abort(rootSessionKey)`
+When a sent child finishes, the engine starts its own reply run on the sender's session to bring the report back.
+The kit admits that exact run as the sender: same member and helper, same app-tool subset and delegates, the sender's
+`system` as its persona, `RunRef.parent` naming the finished child. Only a run whose prompt the engine headed with that
+child's session, on the sender's exact key, within a minute of the child's (or the previous return turn's) end, binds;
+any other run there stays unknown. Return runs are not on `delegatedRuns()` or `byokit.delegated`; read them from the
+engine's `agent` events on the sender's key. The pinned engine starts no reply run for a child that took over 30 s.
+
+Admitted exact run IDs survive parent settlement and are reconciled on reconnect/start; a child the engine no longer
+knows (as after an engine restart) ends `lost`, and a dispatch that finds the journal full reconciles first. `abort(rootSessionKey)`
 durably revokes its recorded subtree, closes parked gates/active calls, then asks the engine to abort; a child key
 revokes its subtree. An engine resume with a different run ID, or a dispatch with no retained receipt, is not
 silently granted authority. No prefix grants or `allowOnce` bypass are used.
@@ -496,8 +506,9 @@ above, builtin gating on): the engine's own `sessions_send` to the exact key `ag
 (`timeoutSeconds: 0`) is admitted from its receipt as writer's run, `RunRef.helper: 'writer'` on every gate and call.
 A target that is not a helper key, a helper on another account, one never ensured, or one the run was not given is
 refused before dispatch; the parent's tool result reads `session: …`, `bound: …` or `unknown_helper: …`.
-`abort(rootSessionKey)` revokes the children, and a helper whose account is removed loses them at their next call. The
-child runs without the helper's persona (a native send carries no system text).
+`abort(rootSessionKey)` revokes the children, and a helper whose account is removed loses them at their next call. A
+native send carries no system text, so the kit adds the helper's recorded persona as system context to the admitted
+child's run; a `sessions_spawn` child gets none.
 
 Conversations from before helpers (plain member sessions) move into a helper with
 `kit.adoptHelperSession({ member, sessionKey }, helper)`: the whole transcript forks to
@@ -510,8 +521,9 @@ both. A helper key, another member's key or a helper never ensured is a typed `H
 
 `kit.onEvent('byokit.delegated', fn)` follows each helper child start to finish: `admitted` (with `run.helper` and
 `run.tools`, its app-tool subset), the engine's events, then one `ended` whose `reason` is `terminal`, `cancelled` (an
-abort, or its admission ended), `error` (with `message`) or `resting`: the model's usage limit ended it, and the kit
-rests the helper's account `until` the stated reset, as a kit run's resting end does. An approval raised by a helper's
+abort, or its admission ended), `error` (with `message`), `lost` (the engine no longer knows the run: outcome unknown)
+or `resting`: the model's usage limit ended it, and the kit rests the helper's account `until` the stated reset, as a
+kit run's resting end does. An approval raised by a helper's
 run names it in `Approval.helper`.
 
 ## Owned browser (unqualified handoff)

package/dist/bridge.js

@@ -316,28 +316,37 @@ export class Bridge {
             return;
         }
         if (message.kind.startsWith('delegation-') && this.delegations) {
-            try {
+            const delegations = this.delegations;
+            void (async () => {
                 if (message.kind === 'delegation-prepare') {
                     if (typeof message.key !== 'string' || typeof message.runId !== 'string'
-                        || (!this.isRegisteredRun(message.key, message.runId) && !this.delegations.has(message.key, message.runId)))
+                        || (!this.isRegisteredRun(message.key, message.runId) && !delegations.has(message.key, message.runId)))
                         return this.deny(socket, 'unknown delegation parent');
-                    this.reply(socket, { tracked: this.delegations.prepare(message) });
+                    this.reply(socket, { tracked: await delegations.prepare(message) });
                 }
                 else if (message.kind === 'delegation-receipt') {
-                    this.delegations.receipt(message);
+                    delegations.receipt(message);
                     this.reply(socket, { ok: true });
                 }
                 else if (message.kind === 'delegation-event' && isRecord(message.event)) {
-                    this.delegations.event(message.event);
+                    delegations.event(message.event);
                     this.reply(socket, { ok: true });
                 }
+                // The plugin's prompt hook on a helper key or an inter-session prompt: an admitted helper child speaks as its
+                // helper (5.8.3), a return run as the kit run that sent the work (5.8.4).
+                else if (message.kind === 'delegation-persona' && typeof message.key === 'string') {
+                    const runId = typeof message.runId === 'string' ? message.runId : undefined;
+                    // A kit run carries its own persona; only an engine-created child is looked up (it may wait for its receipt).
+                    const persona = runId && this.isRegisteredRun(message.key, runId) ? undefined
+                        : await delegations.persona(message.key, runId, typeof message.header === 'string' ? message.header : undefined);
+                    this.reply(socket, persona === undefined ? {} : { persona });
+                }
                 else
                     this.deny(socket, 'invalid delegation message');
-            }
-            catch (error) {
+            })().catch((error) => {
                 // A typed helper refusal (5.8.3) reaches the parent's tool result with its code.
                 this.deny(socket, error instanceof HelperError ? `${error.code}: ${error.message}` : error instanceof Error ? error.message : 'delegation unavailable');
-            }
+            });
             return;
         }
         if (message.kind === 'gate')

package/dist/config.js

@@ -100,7 +100,9 @@ export function reconcileConfig(saved, o) {
             ...o.plugins ?? [],
             ...telegram ? ['telegram'] : []])];
     c.plugins.entries ??= {};
-    c.plugins.entries[o.pluginId] = merge(c.plugins.entries[o.pluginId] ?? {}, { hooks: { timeouts: { before_tool_call: 200_000 } } });
+    // Conversation access lets the plugin's prompt hook give an admitted helper child its persona (5.8.3).
+    c.plugins.entries[o.pluginId] = merge(c.plugins.entries[o.pluginId] ?? {}, { hooks: { timeouts: { before_tool_call: 200_000 },
+            allowConversationAccess: true } });
     if (o.browser) {
         // Replace, never merge caller-controlled profiles/targets. The dead default fails closed without our hook.
         c.browser = { enabled: true, defaultProfile: 'byokit-none', evaluateEnabled: false,
@@ -108,7 +110,6 @@ export function reconcileConfig(saved, o) {
             profiles: { 'byokit-none': { cdpUrl: 'http://127.0.0.1:1', attachOnly: true }, ...o.browser.profiles } };
         c.plugins.allow = [...new Set([...c.plugins.allow, 'browser'])];
         c.plugins.entries.browser = { enabled: true };
-        c.plugins.entries[o.pluginId].hooks.allowConversationAccess = true;
         c.tools ??= {};
         const browserTools = [...new Set([...(c.tools.alsoAllow ?? []), 'browser', 'request_sign_in', ...o.browser.tools])];
         // The stock schema rejects allow + alsoAllow in one scope; an explicit closed allow must absorb additions.

package/dist/constants.d.ts

@@ -2,4 +2,5 @@ export declare const ENGINE_VERSION = "2026.8.35";
 export declare const PROTOCOL_VERSION = 4;
 export declare const LIVE_CATALOGS: string[];
 export declare const REGISTERED_CATALOGS: string[];
+export declare const OPEN_CATALOGS: string[];
 export declare const OPERATOR_SCOPES: readonly ['operator.read', 'operator.write', 'operator.admin', 'operator.approvals', 'operator.questions', 'operator.pairing', 'operator.talk'];

package/dist/constants.js

@@ -4,10 +4,13 @@ export const ENGINE_VERSION = '2026.8.35';
 export const PROTOCOL_VERSION = 4;
 // Providers whose live catalog lists and checks a key's chosen model (5.6), through the catalog hook. OpenRouter is
 // pay-as-you-go: its key takes any model its own catalog lists, with no plan to include it.
-export const LIVE_CATALOGS = ['opencode-go', 'openrouter'];
+export const LIVE_CATALOGS = ['opencode-go', 'openrouter', 'minimax'];
 // Live catalogs the kit registers whole. The engine canonicalizes Google preview ids on config write, so OpenRouter's
 // list collides with itself (`google/x-preview` and `google/x`); an OpenRouter add registers only the chosen model.
-export const REGISTERED_CATALOGS = ['opencode-go'];
+export const REGISTERED_CATALOGS = ['opencode-go', 'minimax'];
+// Pay-as-you-go catalogs whose vendor list can lag a model that already runs: an id the list lacks is warned about, never
+// refused, and takes the capabilities of the route's own models.
+export const OPEN_CATALOGS = ['minimax'];
 export const OPERATOR_SCOPES = [
     'operator.read',
     'operator.write',

package/dist/delegations.d.ts

@@ -1,16 +1,26 @@
 import type { DelegatedEvent, DelegatedRun, GatewayTransport, RunRef } from './types.ts';
+type Back = {
+    member: string;
+    helper?: string;
+    tools: string[];
+    helpers?: Record<string, string[]>;
+};
 type Grant = {
     ref: DelegatedRun;
     tools: string[];
     delegates: Record<string, string[]>;
     helpers?: Record<string, string[]>;
     sourceKey: string;
+    back?: Back;
 };
 export declare class Delegations {
     private loaded;
     private roots;
     private children;
     private pending;
+    private personas;
+    private armed;
+    private returns;
     private changed;
     private early;
     constructor(privateOptions: {
@@ -20,6 +30,7 @@ export declare class Delegations {
         helper(member: string, helper: string): {
             agentId: string;
             account: string;
+            persona: string;
         };
         rest(member: string, account: string, until: number): Promise<void>;
         request: GatewayTransport['request'];
@@ -30,12 +41,19 @@ export declare class Delegations {
     private load;
     private save;
     validate(delegates: Record<string, string[]>, member?: string, helpers?: Record<string, string[]>): void;
-    register(ref: RunRef, runId: string, tools: readonly string[] | undefined, delegates: Record<string, string[]>, sourceKey?: string, helpers?: Record<string, string[]>): () => void;
+    register(ref: RunRef, runId: string, tools: readonly string[] | undefined, delegates: Record<string, string[]>, sourceKey?: string, helpers?: Record<string, string[]>, system?: string): () => void;
     list(): DelegatedRun[];
     has(key: string, runId: string): boolean;
-    prepare(m: Record<string, any>): boolean;
+    private full;
+    prepare(m: Record<string, any>): Promise<boolean>;
     receipt(m: Record<string, any>): void;
     resolve(key: string, runId?: string): Promise<Grant | undefined>;
+    /** The persona of the admitted helper child on this exact key and run, as its own run would carry it (5.8.3), or of
+     * the return run on its sender's key (5.8.4): `header` is the engine's inter-session header on that run's prompt. */
+    persona(key: string, runId?: string, header?: string): Promise<string | undefined>;
+    private bind;
+    private returned;
+    private arm;
     private bound;
     event(event: Record<string, any>): void;
     private ended;

package/dist/delegations.js

@@ -5,6 +5,11 @@ import { classify } from './classify.js';
 import { HELPER_ID, HelperError, helperOf } from './helpers.js';
 // A resting end whose message names no time rests the account this long, as a kit run's does (runs.ts).
 const REST_MS = 300_000;
+// A return binds within this long of its child's end (or of its previous turn's end): the engine's own reply step waits
+// at most 60 s for the child before it starts.
+const RETURN_MS = 60_000;
+// The engine's own header on an inter-session prompt (pin `annotateInterSessionPromptText`), naming the source session.
+const INTER_SESSION = /^\[Inter-session message\] sourceSession=(\S+)(?: sourceChannel=\S+)? sourceTool=sessions_send isUser=false$/;
 const object = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
 const agentOf = (key) => /^agent:([^:]+):.+/.exec(key)?.[1];
 const actionKey = (m) => JSON.stringify([m.key, m.runId, m.callId]);
@@ -13,6 +18,10 @@ export class Delegations {
     roots = new Map();
     children = new Map();
     pending = new Map();
+    // In memory only (no prompt is persisted): a kit run's system text by its run id, its return runs' persona.
+    personas = new Map();
+    armed = [];
+    returns = new Map();
     changed = new Set();
     early = new Map();
     constructor(privateOptions) { this.o = privateOptions; }
@@ -56,9 +65,13 @@ export class Delegations {
             this.o.helper(member, helper); // never ensured, or its account gone: unknown_helper
         }
     }
-    register(ref, runId, tools, delegates, sourceKey = ref.sessionKey, helpers) {
+    register(ref, runId, tools, delegates, sourceKey = ref.sessionKey, helpers, system = '') {
         this.load();
         this.validate(delegates, ref.member, helpers);
+        // ponytail: the oldest 256 kit runs' system texts are kept; a child of an older one gets no return run (fail closed).
+        this.personas.set(runId, system);
+        while (this.personas.size > 256)
+            this.personas.delete(this.personas.keys().next().value);
         const root = { ref: { ...ref, runId, root: { sessionKey: ref.sessionKey, runId } },
             tools: [...tools ?? this.o.tools], delegates: structuredClone(delegates), ...(helpers ? { helpers: structuredClone(helpers) } : {}), sourceKey };
         this.roots.set(runId, root);
@@ -68,11 +81,22 @@ export class Delegations {
     list() { this.load(); return [...this.children.values()].map(g => structuredClone(g.ref)); }
     has(key, runId) {
         this.load();
-        return (this.roots.get(runId) ?? this.children.get(runId))?.ref.sessionKey === key;
+        return (this.roots.get(runId) ?? this.children.get(runId) ?? this.returns.get(runId))?.ref.sessionKey === key;
     }
-    prepare(m) {
+    full() {
+        for (const [id, p] of this.pending)
+            if (p.expires < Date.now())
+                this.pending.delete(id);
+        return this.pending.size + this.children.size >= 1024;
+    }
+    async prepare(m) {
         this.load();
-        const parent = this.roots.get(m.runId) ?? this.children.get(m.runId);
+        // Children whose end never reached the kit would fill the journal for good: settle them with the engine first,
+        // before the parent is read, so an abort meanwhile is seen.
+        // ponytail: a full journal of live children re-reads all 1024 per dispatch; index ends by age if that shows up.
+        if (this.full())
+            await this.reconcile();
+        const parent = this.roots.get(m.runId) ?? this.children.get(m.runId) ?? this.returns.get(m.runId);
         if (!parent || parent.ref.sessionKey !== m.key)
             return false;
         if (typeof m.callId !== 'string' || !m.callId || !object(m.input))
@@ -98,13 +122,13 @@ export class Delegations {
                 throw new HelperError('session', `refused: "${String(m.input.sessionKey ?? agent)}" is not a helper session`);
             throw new Error('delegation target or mode refused');
         }
-        for (const [id, p] of this.pending)
-            if (p.expires < Date.now())
-                this.pending.delete(id);
-        if (this.pending.size + this.children.size >= 1024)
+        if (this.full())
             throw new Error('delegated run journal is full');
-        this.pending.set(actionKey(m), { parent: structuredClone(parent), agent: agent,
-            ...(send ? { key: m.input.sessionKey } : {}), ...(helper !== undefined ? { helper } : {}), expires: Date.now() + 60_000 });
+        const { persona: _, ...grant } = parent; // a return's persona is never persisted
+        this.pending.set(actionKey(m), { parent: structuredClone(grant), agent: agent,
+            ...(send ? { key: m.input.sessionKey } : {}), ...(helper !== undefined ? { helper } : {}),
+            // The engine brings a sent child's report back to the sender's key, as a return run (5.8.4); a spawn's is not one.
+            ...(send && !this.children.has(m.runId) ? { back: true } : {}), expires: Date.now() + 60_000 });
         this.save();
         return true;
     }
@@ -135,7 +159,9 @@ export class Delegations {
             parent: { sessionKey: p.parent.ref.sessionKey, runId: p.parent.ref.runId }, root: p.parent.ref.root, tools };
         const grant = { ref, delegates: p.parent.delegates,
             ...(p.parent.helpers && ref.member === p.parent.ref.member ? { helpers: p.parent.helpers } : {}),
-            sourceKey: p.parent.sourceKey, tools };
+            sourceKey: p.parent.sourceKey, tools,
+            ...(p.back ? { back: { member: p.parent.ref.member, ...(p.parent.ref.helper !== undefined ? { helper: p.parent.ref.helper } : {}),
+                    tools: p.parent.tools, ...(p.parent.helpers ? { helpers: p.parent.helpers } : {}) } } : {}) };
         // A steered/already-admitted run keeps its original parent and cannot acquire a broader grant.
         if (this.children.has(ref.runId)) {
             this.save();
@@ -152,6 +178,13 @@ export class Delegations {
         this.load();
         if (!runId)
             return undefined;
+        const back = this.returns.get(runId);
+        if (back?.ref.sessionKey === key) {
+            if (back.ref.helper === undefined || this.bound(back.ref.member, back.ref.helper, back.ref.agentId))
+                return back;
+            this.returned(runId);
+            return undefined;
+        }
         const get = () => { const g = this.children.get(runId); return g?.ref.sessionKey === key ? g : undefined; };
         if (!get() && [...this.pending.values()].some(p => p.expires > Date.now())) {
             await new Promise(resolve => {
@@ -171,6 +204,68 @@ export class Delegations {
         }
         return grant;
     }
+    /** The persona of the admitted helper child on this exact key and run, as its own run would carry it (5.8.3), or of
+     * the return run on its sender's key (5.8.4): `header` is the engine's inter-session header on that run's prompt. */
+    async persona(key, runId, header) {
+        this.load();
+        const source = header === undefined ? undefined : INTER_SESSION.exec(header)?.[1];
+        if (runId && source !== undefined && !this.returns.has(runId) && !this.children.has(runId))
+            await this.bind(key, runId, source);
+        const back = runId ? this.returns.get(runId) : undefined;
+        if (back?.ref.sessionKey === key)
+            return back.persona || undefined;
+        if (!/^agent:[^:]+:h-/.test(key))
+            return undefined;
+        const helper = (await this.resolve(key, runId))?.ref;
+        return helper?.helper === undefined ? undefined : this.o.helper(helper.member, helper.helper).persona;
+    }
+    // The engine's reply step for a sent child starts a fresh run on the sender's exact key, its prompt headed by the
+    // child's exact session (pin `runSessionsSendA2AFlow`): bound only to a return armed by that child's own terminal end,
+    // one run at a time. A child still running when its report arrives is waited for briefly.
+    async bind(key, runId, source) {
+        const find = () => {
+            const now = Date.now();
+            this.armed = this.armed.filter(a => a.expires > now);
+            return this.armed.find(a => a.key === key && a.child.sessionKey === source && a.live === undefined);
+        };
+        if (!find() && [...this.children.values()].some(g => g.back && g.ref.sessionKey === source && g.ref.parent.sessionKey === key)) {
+            await new Promise(resolve => {
+                const done = () => { clearTimeout(timer); this.changed.delete(check); resolve(); };
+                const check = () => { if (find())
+                    done(); };
+                const timer = setTimeout(done, 5_000);
+                this.changed.add(check);
+            });
+        }
+        const armed = find();
+        if (!armed)
+            return;
+        armed.live = runId;
+        this.returns.set(runId, { ...structuredClone(armed.grant), ref: { ...structuredClone(armed.grant.ref), runId }, persona: armed.persona });
+    }
+    // A return run ended: its report's next turn on the same key may bind within the window (the engine's ping-pong).
+    returned(runId) {
+        const back = this.returns.get(runId);
+        if (!back)
+            return;
+        this.returns.delete(runId);
+        this.o.revoke(back.ref.sessionKey, runId);
+        const armed = this.armed.find(a => a.live === runId);
+        if (armed) {
+            armed.live = undefined;
+            armed.expires = Date.now() + RETURN_MS;
+        }
+    }
+    arm(child) {
+        const { back, ref } = child, persona = this.personas.get(ref.root.runId);
+        if (!back || persona === undefined || this.armed.length >= 64)
+            return; // the root's persona unknown (a restart): none
+        const key = ref.parent.sessionKey;
+        this.armed.push({ key, child: { sessionKey: ref.sessionKey, runId: ref.runId }, persona, expires: Date.now() + RETURN_MS,
+            grant: { ref: { sessionKey: key, member: back.member, ...(back.helper !== undefined ? { helper: back.helper } : {}),
+                    agentId: agentOf(key), parent: { sessionKey: ref.sessionKey, runId: ref.runId }, root: ref.root, tools: back.tools },
+                tools: back.tools, delegates: child.delegates, ...(back.helpers ? { helpers: back.helpers } : {}), sourceKey: child.sourceKey } });
+    }
     bound(member, helper, agent) {
         try {
             return this.o.helper(member, helper).agentId === agent;
@@ -181,6 +276,12 @@ export class Delegations {
     }
     event(event) {
         this.load();
+        const back = this.returns.get(event.runId);
+        if (back) {
+            if (event.sessionKey === back.ref.sessionKey && event.stream === 'lifecycle' && ['end', 'error'].includes(event.data?.phase))
+                this.returned(event.runId);
+            return;
+        }
         const grant = this.children.get(event.runId);
         if (!grant) {
             if (this.pending.size && typeof event.runId === 'string' && this.early.size < 64) {
@@ -219,22 +320,37 @@ export class Delegations {
     }
     end(grant, end) {
         this.children.delete(grant.ref.runId);
+        if (end.reason === 'terminal')
+            this.arm(grant); // before save: a return run waiting on this end sees it armed
         this.save();
         this.o.revoke(grant.ref.sessionKey, grant.ref.runId);
         this.o.emit({ type: 'ended', run: structuredClone(grant.ref), ...end });
     }
+    // An exact recorded run the engine finished ends as it ended. One the engine no longer knows (no job, no queued turn,
+    // no live run, as after an engine restart: a plain `timeout` in the `queue` phase that never reached a provider) ends
+    // `lost`. A live or queued run stays admitted; a run whose wait fails stays for the next reconcile.
     async reconcile() {
         for (const ref of this.list()) {
-            const end = await this.o.request('agent.wait', { runId: ref.runId, timeoutMs: 1 });
+            let end;
+            try {
+                end = await this.o.request('agent.wait', { runId: ref.runId, timeoutMs: 1 });
+            }
+            catch {
+                continue;
+            }
             const grant = this.children.get(ref.runId);
-            if (grant && ['ok', 'error'].includes(end.status ?? ''))
+            if (!grant)
+                continue;
+            if (end.status === 'ok' || end.status === 'error')
                 this.end(grant, { reason: end.status === 'ok' ? 'terminal' : 'error' });
+            else if (end.status === 'timeout' && end.timeoutPhase === 'queue' && end.providerStarted === false)
+                this.end(grant, { reason: 'lost' });
         }
     }
     async abort(key) {
         this.load();
         const ids = new Set();
-        for (const g of [...this.roots.values(), ...this.children.values()])
+        for (const g of [...this.roots.values(), ...this.children.values(), ...this.returns.values()])
             if (g.ref.sessionKey === key || g.ref.parent?.sessionKey === key || g.ref.root.sessionKey === key || g.sourceKey === key)
                 ids.add(g.ref.runId);
         for (;;) {
@@ -246,6 +362,10 @@ export class Delegations {
                 break;
         }
         let removed = false;
+        const armed = this.armed.length;
+        this.armed = this.armed.filter(a => a.key !== key && a.grant.ref.root.sessionKey !== key && !ids.has(a.child.runId) && !ids.has(a.grant.ref.root.runId));
+        if (this.armed.length !== armed)
+            removed = true;
         for (const [id, p] of this.pending)
             if (ids.has(p.parent.ref.runId) || p.parent.ref.sessionKey === key || p.parent.ref.root.sessionKey === key || p.parent.sourceKey === key) {
                 this.pending.delete(id);
@@ -254,9 +374,11 @@ export class Delegations {
         if (!ids.size && !removed)
             return;
         const cancelled = [...this.children.values()].filter(g => ids.has(g.ref.runId));
-        const revoked = [...this.roots.values(), ...cancelled].filter(g => ids.has(g.ref.runId));
-        for (const id of ids)
+        const revoked = [...this.roots.values(), ...this.returns.values(), ...cancelled].filter(g => ids.has(g.ref.runId));
+        for (const id of ids) {
             this.roots.delete(id);
+            this.returns.delete(id);
+        }
         for (const g of cancelled)
             this.children.delete(g.ref.runId);
         this.save(); // revoke durably before any awaited transport call

package/dist/keys.js

@@ -5,7 +5,7 @@ import { activate } from './activation.js';
 import { keyAgentId, MEMBER_ID, KEY_PREFIX, untilListed } from './members.js';
 import { providerOf } from './pick.js';
 import { kitId, modelsOf } from './accounts.js';
-import { LIVE_CATALOGS, REGISTERED_CATALOGS } from './constants.js';
+import { LIVE_CATALOGS, OPEN_CATALOGS, REGISTERED_CATALOGS } from './constants.js';
 export function createKeys(ctx) {
     // Serialize key replacement and key runs, so an in-flight run never sees a half-installed replacement.
     const tails = new Map();
@@ -93,6 +93,16 @@ export function createKeys(ctx) {
         throw new Error(keyed.length ? `${authChoice} takes no API key: add the key with ${keyed.map((r) => r.choice).join(' or ')}.`
             : `${authChoice} takes no API key.`);
     };
+    // The vendor's list can lag a model that runs: an id it lacks rides the route's own models (the richest row's api,
+    // base URL and context, every input modality any row takes), unpriced. Nothing is added to an empty list.
+    const unlisted = (provider, rows, model) => {
+        if (!rows.length || rows.some((m) => kitId(provider, String(m.id)) === model))
+            return [];
+        const base = rows.reduce((a, b) => (Number(b.contextWindow) || 0) > (Number(a.contextWindow) || 0) ? b : a);
+        const input = ['text', 'image'].filter((i) => rows.some((m) => Array.isArray(m.input) && m.input.includes(i)));
+        const id = model.slice(provider.length + 1);
+        return [{ ...base, id, name: id, input, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } }];
+    };
     const listed = (provider, rows) => modelsOf(provider, { models: rows.map((m) => ({ ...m, provider })) });
     const models = async (member, o) => {
         if (!check(member))
@@ -217,6 +227,8 @@ export function createKeys(ctx) {
                         if (result.late)
                             return abandon(failure('retry', 'busy'));
                         const rows = model === undefined ? [] : await catalog(member, route.provider);
+                        const lagging = model !== undefined && OPEN_CATALOGS.includes(route.provider) ? unlisted(route.provider, rows, model) : [];
+                        rows.push(...lagging);
                         if (model !== undefined && !listed(route.provider, rows).some((m) => m.id === model && m.available))
                             return abandon(failure('not_included', 'model'));
                         // Prepare before publishing the ready marker: failed preparation remains unusable even if clear fails.
@@ -229,7 +241,7 @@ export function createKeys(ctx) {
                         if (ac.signal.aborted)
                             return abandon(cancelled());
                         // A live catalog the kit does not register whole (OpenRouter) registers the chosen model alone.
-                        if (model !== undefined && !REGISTERED_CATALOGS.includes(route.provider))
+                        if (model !== undefined && (!REGISTERED_CATALOGS.includes(route.provider) || lagging.length))
                             await ctx.registerModels(route.provider, rows.filter((m) => kitId(route.provider, String(m.id)) === model)).catch(() => { });
                         if (model !== undefined && LIVE_CATALOGS.includes(route.provider) && !(await registered(route.provider, model)))
                             return abandon(failure('retry', 'model'));

package/dist/runs.js

@@ -347,7 +347,7 @@ export function createRuns(ctx) {
         try {
             const ref = { sessionKey, member: spec.member, ...(spec.helper !== undefined ? { helper: spec.helper } : {}) };
             releaseDelegation = spec.delegates || spec.helperDelegates
-                ? ctx.delegations.register(ref, idempotencyKey, spec.tools, spec.delegates ?? {}, spec.sessionKey, spec.helperDelegates) : undefined;
+                ? ctx.delegations.register(ref, idempotencyKey, spec.tools, spec.delegates ?? {}, spec.sessionKey, spec.helperDelegates, system) : undefined;
             release = spec.register !== false ? ctx.bridge.register(ref, spec.tools, idempotencyKey) : undefined;
             if (picked && !chosen) {
                 // The picked account must be the one called: check it is signed in for this member before the run, since

package/dist/testing/fake-gateway.js

@@ -329,6 +329,12 @@ export function fakeGateway(script, o) {
         setTimeout(() => {
             void (async () => {
                 const table = bridgeSock ? pluginTable(bridgeSock) : undefined;
+                // As the plugin's prompt hook: a child on a helper key asks the kit for its helper's persona (5.8.3).
+                if (child && bridgeSock && /^agent:[^:]+:h-[a-z][a-z0-9-]{0,15}:/.test(run.sessionKey)) {
+                    const reply = await bridgeRequest(bridgeSock, { kind: 'delegation-persona', key: run.sessionKey, runId: run.runId }).catch(() => ({}));
+                    calls.push({ method: 'before_prompt_build', params: { sessionKey: run.sessionKey, runId: run.runId,
+                            ...(typeof reply.persona === 'string' ? { appendSystemContext: reply.persona } : {}) } });
+                }
                 let n = 0;
                 for (const call of toolCalls(message)) {
                     const toolCallId = `call-${++n}`;
@@ -688,14 +694,18 @@ export function fakeGateway(script, o) {
             return { status: 'cancelled' };
         },
         agent: (p, bridgeSock) => startRun(p, bridgeSock),
-        'agent.wait': (p) => new Promise((resolve, reject) => {
-            const run = runs.get(String(p.runId));
+        // The pin: a run it never had (or forgot, as after a restart) waits out as a `timeout` in the `queue` phase that never
+        // reached a provider; a live run past `timeoutMs` is a `timeout` while it drains.
+        'agent.wait': (p) => new Promise((resolve) => {
+            const runId = String(p.runId);
+            const run = runs.get(runId);
             if (!run)
-                return reject(new Error(`unknown run: ${p.runId}`));
+                return resolve({ runId, status: 'timeout', timeoutPhase: 'queue', providerStarted: false });
             if (run.result)
-                resolve(run.result);
-            else
-                run.waiters.push(resolve);
+                return resolve(run.result);
+            run.waiters.push(resolve);
+            if (typeof p.timeoutMs === 'number')
+                setTimeout(() => resolve({ runId, status: 'timeout', timeoutPhase: 'gateway_draining' }), p.timeoutMs).unref();
         }),
         'sessions.steer': () => ({}),
         // The pin: a key the agent holds answers its canonical key; a missing one errors unless `allowMissing`, which answers `{ ok: false }`.

package/dist/types.d.ts

@@ -46,12 +46,13 @@ export type DelegatedRun = RunRef & Required<Pick<RunRef, 'runId' | 'agentId' |
     tools: string[];
 };
 /** A delegated child's lifecycle (5.8.3 S3): `admitted`, its engine `event`s, then one `ended` whose `reason` is
- * `terminal` (finished), `error` (`message`), `resting` (its helper's account hit its limit and rests `until`) or
- * `cancelled` (aborted by the kit or the engine, or its admission ended). */
+ * `terminal` (finished), `error` (`message`), `resting` (its helper's account hit its limit and rests `until`),
+ * `cancelled` (aborted by the kit or the engine, or its admission ended) or `lost` (the engine no longer knows the run,
+ * as after an engine restart: outcome unknown, admission ended). */
 export type DelegatedEvent = {
     type: 'admitted' | 'event' | 'ended';
     run: DelegatedRun;
-    reason?: 'terminal' | 'error' | 'resting' | 'cancelled';
+    reason?: 'terminal' | 'error' | 'resting' | 'cancelled' | 'lost';
     until?: number;
     message?: string;
     event?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byokit/openclaw",
-  "version": "0.23.0",
+  "version": "0.25.0",
   "description": "The OpenClaw runtime kit: the pinned engine's full operator surface with plain-words helpers for members, sign-in, runs and approvals.",
   "license": "Apache-2.0",
   "type": "module",
@@ -60,7 +60,7 @@
     "prepack": "tsc -b && node ../../scripts/fix-words-dts.cjs"
   },
   "dependencies": {
-    "@byokit/accounts": "0.28.2",
+    "@byokit/accounts": "0.29.0",
     "@byokit/pair": "0.10.4",
     "@byokit/relay": "0.8.2",
     "@byokit/discover": "0.8.4",

package/plugin/catalog.js

@@ -38,6 +38,19 @@ export function registerCatalog(api) {
         const models = [...live.models, ...(pinned?.models ?? []).filter((m) => !liveIds.has(m.id))]
           .map(({ provider: _p, apiKey: _k, headers: _h, ...model }) =>
             (endpoint.has(model.api) ? { ...model, baseUrl: endpoint.get(model.api) } : model));
+        // MiniMax's engine catalog is a fixed list: its vendor `/models` lists newer ids, which join it with the richest
+        // row's api, base URL and capabilities (the vendor lists ids only). A failed fetch keeps the engine's list.
+        if (provider === 'minimax' && models.length) {
+          const base = models.reduce((a, b) => (b.contextWindow ?? 0) > (a.contextWindow ?? 0) ? b : a);
+          const input = ['text', 'image'].filter((i) => models.some((m) => m.input?.includes(i)));
+          const listed = await fetch(`${String(base.baseUrl).replace(/\/$/, '')}/v1/models`,
+            { headers: { authorization: `Bearer ${apiKey}`, 'anthropic-version': '2023-06-01' }, signal: AbortSignal.timeout(10_000) })
+            .then((r) => r.ok ? r.json() : null, () => null);
+          const have = new Set(models.map((m) => m.id));
+          for (const m of Array.isArray(listed?.data) ? listed.data : [])
+            if (typeof m?.id === 'string' && m.id && !have.has(m.id))
+              models.push({ ...base, id: m.id, name: m.display_name || m.id, input, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } });
+        }
         return respond(true, { ok: true, models });
       }
       respond(true, { ok: false, reason: unreadable ? 'failed' : 'no-key' });

package/plugin/index.js

@@ -159,6 +159,21 @@ export default {
         callId: ctx?.toolCallId ?? event.toolCallId,
         result: { details: d && { status: d.status, runId: d.runId, sessionKey: d.sessionKey, childSessionKey: d.childSessionKey } } });
     });
+    // A native send carries no system text: an admitted helper child gets its helper's persona from the kit (5.8.3).
+    // The engine's reply step bringing a sent child's report back (an inter-session prompt) asks too: the kit binds that
+    // exact run as the sender's return run (5.8.4) and answers the sender's persona. Any other run, or no answer, adds
+    // nothing; the persona is a voice, never a grant.
+    api.on('before_prompt_build', async (event, ctx) => {
+      const key = ctx?.sessionKey;
+      const header = typeof event?.prompt === 'string' && event.prompt.startsWith('[Inter-session message] ')
+        ? event.prompt.slice(0, 1024).split('\n', 1)[0] : undefined;
+      if (typeof key !== 'string' || (!header && !/^agent:[^:]+:h-[a-z][a-z0-9-]{0,15}:/.test(key))) return undefined;
+      try {
+        const reply = await bridgeRequest({ kind: 'delegation-persona', key, runId: ctx?.runId, ...(header ? { header } : {}) }, { timeoutMs: 10_000 });
+        if (typeof reply?.persona === 'string' && reply.persona) return { appendSystemContext: reply.persona };
+      } catch { /* no kit: nothing added */ }
+      return undefined;
+    });
     api.registerAgentEventSubscription?.({ id: 'byokit-delegated-events', handle(event) {
       if (!['assistant', 'tool', 'thinking', 'lifecycle'].includes(event.stream)) return;
       const data = Object.fromEntries(['text', 'name', 'phase', 'toolCallId', 'isError', 'progressTokens', 'aborted', 'error', 'provider', 'model']
@@ -281,6 +296,12 @@ export default {
             callId: ctx?.toolCallId ?? event.toolCallId, tool: event.toolName, input: params });
           if (prepared.allow === false) return { block: true, blockReason: prepared.reason };
         } catch { return { block: true, blockReason: 'delegation admission unavailable' }; }
+        // A tracked spawn into the run's own agent goes without `agentId`, the engine's own-agent spawn, so an app's
+        // `subagents.allowAgents` list for other agents never refuses it. The kit already admitted that exact agent.
+        // Hook params merge over the model's, so the key is overridden, not left out.
+        const own = ctx?.agentId ?? /^agent:([^:]+):/.exec(key)?.[1];
+        if (event.toolName === 'sessions_spawn' && typeof own === 'string' && params.agentId === own)
+          return { params: { ...params, agentId: undefined } };
       }
       if (builtin) return BROWSER && event.toolName === 'browser' ? { params } : undefined;
       // The bridge mints a permit for permitted tools and admits the rest ticket-side; either way the run key