@khorsheed/dsh-local-agent 0.1.0-rc.6

package/lib/types/client/live-output.js

@@ -0,0 +1,94 @@
+import { LivePaintDiagnostics } from './live-paint.js';
+export class MemberLiveOutput {
+    id;
+    follow;
+    onIdle;
+    diagnostics;
+    listeners = new Set();
+    snapshot = { items: new Map(), connected: false };
+    controller;
+    constructor(id, follow, onIdle, diagnostics) {
+        this.id = id;
+        this.follow = follow;
+        this.onIdle = onIdle;
+        this.diagnostics = diagnostics;
+    }
+    getSnapshot = () => this.snapshot;
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        if (this.controller === undefined) {
+            const controller = new AbortController();
+            this.controller = controller;
+            void this.run(controller.signal);
+        }
+        return () => {
+            this.listeners.delete(listener);
+            if (this.listeners.size === 0) {
+                this.controller?.abort();
+                this.controller = undefined;
+                this.snapshot = { items: new Map(), connected: false };
+                this.onIdle();
+            }
+        };
+    };
+    publish(snapshot) {
+        this.snapshot = snapshot;
+        for (const listener of this.listeners)
+            listener();
+    }
+    async run(signal) {
+        let delay = 250;
+        while (!signal.aborted) {
+            try {
+                for await (const frame of this.follow(this.id, signal)) {
+                    if (signal.aborted)
+                        return;
+                    const items = frame.baseline ? new Map() : new Map(this.snapshot.items);
+                    for (const update of frame.updates) {
+                        const old = items.get(update.id);
+                        if (update.append && old === undefined)
+                            throw new Error('live output suffix without baseline');
+                        if (old !== undefined && update.revision <= old.revision)
+                            continue;
+                        this.diagnostics.receive(this.id, update, frame.baseline);
+                        items.set(update.id, { ...update, text: update.append ? old.text + update.text : update.text, baseline: frame.baseline });
+                    }
+                    // Retain the final live text until the durable native message removes
+                    // its node; the two transports may arrive in either order.
+                    this.publish({ items, connected: true });
+                    delay = 250;
+                }
+            }
+            catch {
+                // A reconnect obtains a fresh baseline, never replays stale suffixes.
+            }
+            if (signal.aborted)
+                return;
+            this.publish({ ...this.snapshot, connected: false });
+            await new Promise(resolve => {
+                const done = () => { clearTimeout(timer); signal.removeEventListener('abort', done); resolve(); };
+                const timer = setTimeout(done, delay);
+                signal.addEventListener('abort', done, { once: true });
+            });
+            delay = Math.min(delay * 2, 5_000);
+        }
+    }
+}
+/** Cached only while rendered: historical sessions do not retain text or connections. */
+export class MemberLiveOutputs {
+    follow;
+    diagnostics = new LivePaintDiagnostics();
+    stores = new Map();
+    constructor(follow) {
+        this.follow = follow;
+    }
+    get(id) {
+        let store = this.stores.get(id);
+        if (store === undefined)
+            this.stores.set(id, store = new MemberLiveOutput(id, this.follow, () => {
+                if (this.stores.get(id) === store)
+                    this.stores.delete(id);
+            }, this.diagnostics));
+        return store;
+    }
+}

package/lib/types/client/live-paint.d.ts

@@ -0,0 +1,40 @@
+/** Bounded, text-free diagnostics. Receipt times require a shared host/browser clock. */
+import type { LocalAgentStreamItem } from '../types.ts';
+export type PaintSurface = 'room' | 'member';
+export type PaintOutcome = 'pending' | 'painted' | 'hidden' | 'unmounted' | 'clock-mismatch';
+export declare class LivePaintDiagnostics {
+    private readonly maxRounds;
+    private readonly maxReceipts;
+    private readonly rounds;
+    private readonly listeners;
+    private evictedRounds;
+    constructor(maxRounds?: number, maxReceipts?: number);
+    readonly subscribe: (listener: () => void) => (() => void);
+    private changed;
+    receive(sessionId: string, item: LocalAgentStreamItem, baseline: boolean): void;
+    begin(sessionId: string, turn: number, revision: number, surface: PaintSurface): ((outcome: Exclude<PaintOutcome, 'pending'>, now: number) => void) | undefined;
+    /** Survives stream-node unmount; never includes prompts, answers or credentials. */
+    report(sessionId: string): {
+        clock: string;
+        evictedRounds: number;
+        rounds: {
+            turn: number;
+            dropped: number;
+            baselineUpdates: number;
+            liveUpdates: number;
+            surfaces: {
+                [k: string]: {
+                    samples: number[];
+                    p95: number | null | undefined;
+                    painted: number;
+                    pending: number;
+                    hidden: number;
+                    unmounted: number;
+                    clockMismatch: number;
+                    unrendered: number;
+                };
+            };
+        }[];
+    };
+}
+//# sourceMappingURL=live-paint.d.ts.map

package/lib/types/client/live-paint.js

@@ -0,0 +1,74 @@
+export class LivePaintDiagnostics {
+    maxRounds;
+    maxReceipts;
+    rounds = new Map();
+    listeners = new Set();
+    evictedRounds = 0;
+    constructor(maxRounds = 32, maxReceipts = 4_096) {
+        this.maxRounds = maxRounds;
+        this.maxReceipts = maxReceipts;
+    }
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => { this.listeners.delete(listener); };
+    };
+    changed() { for (const listener of this.listeners)
+        listener(); }
+    receive(sessionId, item, baseline) {
+        const key = JSON.stringify([sessionId, item.turn]);
+        let round = this.rounds.get(key);
+        if (!round) {
+            round = { sessionId, turn: item.turn, receipts: new Map(), dropped: 0 };
+            this.rounds.set(key, round);
+            if (this.rounds.size > this.maxRounds) {
+                this.rounds.delete(this.rounds.keys().next().value);
+                this.evictedRounds++;
+            }
+        }
+        // Reconnect baselines must not reclassify an already observed live update.
+        if (round.receipts.has(item.revision))
+            return;
+        round.receipts.set(item.revision, { id: item.id, revision: item.revision, receivedAt: item.receivedAt, baseline, paints: {} });
+        if (round.receipts.size > this.maxReceipts) {
+            round.receipts.delete(round.receipts.keys().next().value);
+            round.dropped++;
+        }
+        this.changed();
+    }
+    begin(sessionId, turn, revision, surface) {
+        const receipt = this.rounds.get(JSON.stringify([sessionId, turn]))?.receipts.get(revision);
+        if (!receipt || receipt.baseline || receipt.paints[surface])
+            return undefined;
+        const paint = { outcome: 'pending' };
+        receipt.paints[surface] = paint;
+        this.changed();
+        return (outcome, now) => {
+            if (paint.outcome !== 'pending')
+                return;
+            const elapsed = now - receipt.receivedAt;
+            paint.outcome = outcome === 'painted' && elapsed < 0 ? 'clock-mismatch' : outcome;
+            if (paint.outcome === 'painted')
+                paint.elapsed = elapsed;
+            this.changed();
+        };
+    }
+    /** Survives stream-node unmount; never includes prompts, answers or credentials. */
+    report(sessionId) {
+        return { clock: 'shared-wall-clock-required', evictedRounds: this.evictedRounds, rounds: [...this.rounds.values()]
+                .filter(round => round.sessionId === sessionId).map(round => {
+                const receipts = [...round.receipts.values()];
+                const live = receipts.filter(receipt => !receipt.baseline);
+                return { turn: round.turn, dropped: round.dropped, baselineUpdates: receipts.length - live.length, liveUpdates: live.length,
+                    surfaces: Object.fromEntries(['room', 'member'].map(surface => {
+                        const paints = live.map(receipt => receipt.paints[surface]);
+                        const samples = paints.flatMap(paint => paint?.elapsed === undefined ? [] : [paint.elapsed]);
+                        const sorted = [...samples].sort((a, b) => a - b);
+                        const count = (outcome) => paints.filter(paint => paint?.outcome === outcome).length;
+                        return [surface, { samples, p95: sorted.length ? sorted[Math.ceil(sorted.length * 0.95) - 1] : null,
+                                painted: count('painted'), pending: count('pending'), hidden: count('hidden'), unmounted: count('unmounted'),
+                                clockMismatch: count('clock-mismatch'), unrendered: paints.filter(paint => paint === undefined).length }];
+                    })),
+                };
+            }) };
+    }
+}

package/lib/types/client/locales.d.ts

@@ -0,0 +1,120 @@
+/** `local-agent` namespace dictionaries. */
+/** Dictionary namespace owned by this plugin. */
+export declare const NS = "local-agent";
+/** Simplified Chinese dictionary (the key-set source of truth). */
+export declare const zh: {
+    readonly 'inbox.title': '待处理消息';
+    readonly 'inbox.pause': '暂停队列';
+    readonly 'inbox.resume': '继续队列';
+    readonly 'inbox.paused': '队列已暂停；重启后请先核对未完成消息。';
+    readonly 'inbox.cancel': '取消这条';
+    readonly 'inbox.evidence': '填写核对结果或证据';
+    readonly 'inbox.confirmDone': '确认已完成';
+    readonly 'inbox.confirmCancelled': '确认已取消';
+    readonly 'inbox.status.queued': '已排队';
+    readonly 'inbox.status.running': '执行中';
+    readonly 'inbox.status.uncertain': '结果待核对';
+    readonly 'inbox.status.failed': '失败';
+    readonly 'inbox.status.done': '已完成';
+    readonly 'inbox.status.cancelled': '已取消';
+    readonly "configuration.title": "模型与推理配置";
+    readonly "configuration.choose": "选择模型";
+    readonly "configuration.unavailable": "暂不可用";
+    readonly "configuration.back": "返回";
+    readonly "configuration.details": "模型目录详情";
+    readonly "configuration.model": "模型";
+    readonly "configuration.effort": "推理强度";
+    readonly "configuration.inherit": "继承成员创建配置";
+    readonly "configuration.default": "跟随 harness 默认值";
+    readonly "configuration.search": "搜索模型名称或 ID";
+    readonly "configuration.custom": "自定义模型 ID";
+    readonly "configuration.source.native": "原生目录";
+    readonly "configuration.source.configuration": "配置项";
+    readonly "configuration.source.history": "历史观测";
+    readonly "configuration.hidden": "扩展候选";
+    readonly "configuration.empty": "暂无匹配的候选模型";
+    readonly "configuration.unverified": "尚未验证此模型的支持情况";
+    readonly "configuration.effortUnknown": "暂未取得此模型的强度选项，当前强度保持不变。";
+    readonly "configuration.directory.loading": "正在读取目录";
+    readonly "configuration.directory.ready": "目录已更新";
+    readonly "configuration.directory.stale": "目录更新失败，展示上次结果";
+    readonly "configuration.directory.error": "目录读取失败";
+    readonly "configuration.directory.unsupported": "此来源未提供完整目录";
+    readonly "configuration.incomplete": "候选列表可能不完整";
+    readonly "configuration.round": "本轮配置";
+    readonly "configuration.ready": "下轮已准备的配置";
+    readonly "configuration.pending": "下轮待生效";
+    readonly "configuration.applying": "正在准备配置";
+    readonly "configuration.boundary": "现在可以选择；当前轮次及工具续跑保持原配置，新选择从下一轮生效。";
+    readonly "configuration.reconnecting": "正在重新连接配置状态…";
+    readonly "configuration.apply": "应用选择";
+    readonly "configuration.cancel": "撤销待生效配置";
+    readonly "configuration.retry": "对账并重试";
+    readonly "configuration.refresh": "刷新模型目录";
+    readonly "configuration.accepted": "选择已接收，请以下方实时状态为准。";
+    readonly "configuration.cancelled": "已接收撤销请求，正在恢复配置。";
+    readonly "configuration.failed": "配置操作失败，请检查原因后重试。";
+    readonly 'stream.thinking': '思考中';
+    readonly 'stream.writing': '正在生成';
+    readonly 'stream.recovering': '部分记录，等待实时连接';
+    readonly 'stream.copy': '复制';
+    readonly 'stream.copied': '已复制';
+    readonly 'stream.footnotes': '脚注';
+    readonly 'list.aria': '{harness} 会话记录';
+    readonly 'list.title': '{harness} 会话记录';
+    readonly empty: '作用域内还没有 {harness} 会话';
+    readonly 'login.hint': '运行 /{command} login 授权后开始委派';
+    readonly loading: '加载中…';
+    readonly error: '无法读取 {harness} 会话记录';
+    readonly 'unknown.command': '/{command} sessions 不可用（{harness} 插件未安装？）';
+    readonly 'row.aria': '{harness} 会话 {sessionId}';
+    readonly workdir: '工作目录';
+    readonly 'settings.nav': '本地 Agent';
+    readonly 'settings.intro': '管理本机安装的编码 agent CLI：查看授权状态，通过网页登录授权。';
+    readonly 'settings.noSession': '先打开一个会话，再管理本地 agent';
+    readonly 'settings.authenticated': '已登录';
+    readonly 'settings.notAuthenticated': '未登录';
+    readonly 'settings.login': '网页登录';
+    readonly 'settings.reauthorize': '重新授权';
+    readonly 'settings.logout': '退出登录';
+    readonly 'settings.loggedOut': '已退出登录';
+    readonly 'settings.openPage': '打开授权页面';
+    readonly 'settings.homeDir': '作用域目录';
+    readonly 'settings.pending': '等待授权…';
+    readonly 'settings.loginSuccess': '{harness} 登录成功，快去试试吧！';
+    readonly 'settings.pasteCode': '粘贴授权页面给出的 code';
+    readonly 'settings.submitCode': '提交 code';
+    readonly 'settings.unsupported': '待支持';
+    readonly 'settings.rosterFailed': '无法读取本地 Agent 列表，请重试';
+    readonly 'settings.retry': '重试';
+    readonly 'member.checking': '正在确认成员身份…';
+    readonly 'member.readonly.title': '一次性子代理记录';
+    readonly 'member.readonly.body': '一次性任务不支持后续消息，可在这里查看完整执行记录。';
+    readonly 'member.title': '{harness} 成员';
+    readonly 'member.placeholder': '给成员发消息，继续同一会话…';
+    readonly 'member.send': '发送';
+    readonly 'member.stop': '停止';
+    readonly 'member.running': '成员运行中…';
+    readonly 'member.sendFailed': '发送失败，请重试';
+    readonly 'member.stats.cacheHit': '缓存命中 {percent}%';
+    readonly 'member.stats.tokens': '输入 {input} tok · 输出 {output} tok';
+    readonly 'member.tasks.summary': '任务 {done}/{total}';
+    readonly 'member.tasks.active': ' · 进行中：{title}';
+    readonly 'member.model.picker': '成员模型';
+    readonly 'member.model.default': '默认';
+    readonly 'member.model.defaultLastObserved': '默认（最近 {model}）';
+    readonly 'member.model.title': '模型：{model}（{source}）';
+    readonly 'member.model.source.override': '会话级覆盖';
+    readonly 'member.model.source.delegation': '委派时指定';
+    readonly 'member.model.source.settings': '插件设置';
+    readonly 'member.model.source.cli-config': 'CLI 配置文件';
+    readonly 'member.model.source.cli-builtin': 'CLI 内置默认：没有任何层级指定模型，运行 CLI 自己的默认；已知时显示最近实际运行的模型';
+    readonly 'member.model.followSettings': '跟随设置';
+    readonly 'member.model.empty': '暂无候选模型';
+    readonly 'member.model.failed': '切换模型失败，请重试';
+};
+/** English dictionary, key-identical to the Chinese source of truth. */
+export declare const en: Record<LocalAgentKey, string>;
+/** Key domain of the `local-agent` namespace (zh is the source of truth). */
+export type LocalAgentKey = keyof typeof zh;
+//# sourceMappingURL=locales.d.ts.map

package/lib/types/client/locales.js

@@ -0,0 +1,227 @@
+/** `local-agent` namespace dictionaries. */
+/** Dictionary namespace owned by this plugin. */
+export const NS = 'local-agent';
+/** Simplified Chinese dictionary (the key-set source of truth). */
+export const zh = {
+    'inbox.title': '待处理消息',
+    'inbox.pause': '暂停队列',
+    'inbox.resume': '继续队列',
+    'inbox.paused': '队列已暂停；重启后请先核对未完成消息。',
+    'inbox.cancel': '取消这条',
+    'inbox.evidence': '填写核对结果或证据',
+    'inbox.confirmDone': '确认已完成',
+    'inbox.confirmCancelled': '确认已取消',
+    'inbox.status.queued': '已排队',
+    'inbox.status.running': '执行中',
+    'inbox.status.uncertain': '结果待核对',
+    'inbox.status.failed': '失败',
+    'inbox.status.done': '已完成',
+    'inbox.status.cancelled': '已取消',
+    "configuration.title": "模型与推理配置",
+    "configuration.choose": "选择模型",
+    "configuration.unavailable": "暂不可用",
+    "configuration.back": "返回",
+    "configuration.details": "模型目录详情",
+    "configuration.model": "模型",
+    "configuration.effort": "推理强度",
+    "configuration.inherit": "继承成员创建配置",
+    "configuration.default": "跟随 harness 默认值",
+    "configuration.search": "搜索模型名称或 ID",
+    "configuration.custom": "自定义模型 ID",
+    "configuration.source.native": "原生目录",
+    "configuration.source.configuration": "配置项",
+    "configuration.source.history": "历史观测",
+    "configuration.hidden": "扩展候选",
+    "configuration.empty": "暂无匹配的候选模型",
+    "configuration.unverified": "尚未验证此模型的支持情况",
+    "configuration.effortUnknown": "暂未取得此模型的强度选项，当前强度保持不变。",
+    "configuration.directory.loading": "正在读取目录",
+    "configuration.directory.ready": "目录已更新",
+    "configuration.directory.stale": "目录更新失败，展示上次结果",
+    "configuration.directory.error": "目录读取失败",
+    "configuration.directory.unsupported": "此来源未提供完整目录",
+    "configuration.incomplete": "候选列表可能不完整",
+    "configuration.round": "本轮配置",
+    "configuration.ready": "下轮已准备的配置",
+    "configuration.pending": "下轮待生效",
+    "configuration.applying": "正在准备配置",
+    "configuration.boundary": "现在可以选择；当前轮次及工具续跑保持原配置，新选择从下一轮生效。",
+    "configuration.reconnecting": "正在重新连接配置状态…",
+    "configuration.apply": "应用选择",
+    "configuration.cancel": "撤销待生效配置",
+    "configuration.retry": "对账并重试",
+    "configuration.refresh": "刷新模型目录",
+    "configuration.accepted": "选择已接收，请以下方实时状态为准。",
+    "configuration.cancelled": "已接收撤销请求，正在恢复配置。",
+    "configuration.failed": "配置操作失败，请检查原因后重试。",
+    'stream.thinking': '思考中',
+    'stream.writing': '正在生成',
+    'stream.recovering': '部分记录，等待实时连接',
+    'stream.copy': '复制',
+    'stream.copied': '已复制',
+    'stream.footnotes': '脚注',
+    'list.aria': '{harness} 会话记录',
+    'list.title': '{harness} 会话记录',
+    'empty': '作用域内还没有 {harness} 会话',
+    'login.hint': '运行 /{command} login 授权后开始委派',
+    'loading': '加载中…',
+    'error': '无法读取 {harness} 会话记录',
+    'unknown.command': '/{command} sessions 不可用（{harness} 插件未安装？）',
+    'row.aria': '{harness} 会话 {sessionId}',
+    'workdir': '工作目录',
+    'settings.nav': '本地 Agent',
+    'settings.intro': '管理本机安装的编码 agent CLI：查看授权状态，通过网页登录授权。',
+    'settings.noSession': '先打开一个会话，再管理本地 agent',
+    'settings.authenticated': '已登录',
+    'settings.notAuthenticated': '未登录',
+    'settings.login': '网页登录',
+    'settings.reauthorize': '重新授权',
+    'settings.logout': '退出登录',
+    'settings.loggedOut': '已退出登录',
+    'settings.openPage': '打开授权页面',
+    'settings.homeDir': '作用域目录',
+    'settings.pending': '等待授权…',
+    'settings.loginSuccess': '{harness} 登录成功，快去试试吧！',
+    'settings.pasteCode': '粘贴授权页面给出的 code',
+    'settings.submitCode': '提交 code',
+    'settings.unsupported': '待支持',
+    'settings.rosterFailed': '无法读取本地 Agent 列表，请重试',
+    'settings.retry': '重试',
+    'member.checking': '正在确认成员身份…',
+    'member.readonly.title': '一次性子代理记录',
+    'member.readonly.body': '一次性任务不支持后续消息，可在这里查看完整执行记录。',
+    'member.title': '{harness} 成员',
+    'member.placeholder': '给成员发消息，继续同一会话…',
+    'member.send': '发送',
+    'member.stop': '停止',
+    'member.running': '成员运行中…',
+    'member.sendFailed': '发送失败，请重试',
+    'member.stats.cacheHit': '缓存命中 {percent}%',
+    'member.stats.tokens': '输入 {input} tok · 输出 {output} tok',
+    'member.tasks.summary': '任务 {done}/{total}',
+    'member.tasks.active': ' · 进行中：{title}',
+    'member.model.picker': '成员模型',
+    'member.model.default': '默认',
+    'member.model.defaultLastObserved': '默认（最近 {model}）',
+    'member.model.title': '模型：{model}（{source}）',
+    'member.model.source.override': '会话级覆盖',
+    'member.model.source.delegation': '委派时指定',
+    'member.model.source.settings': '插件设置',
+    'member.model.source.cli-config': 'CLI 配置文件',
+    'member.model.source.cli-builtin': 'CLI 内置默认：没有任何层级指定模型，运行 CLI 自己的默认；已知时显示最近实际运行的模型',
+    'member.model.followSettings': '跟随设置',
+    'member.model.empty': '暂无候选模型',
+    'member.model.failed': '切换模型失败，请重试',
+};
+/** English dictionary, key-identical to the Chinese source of truth. */
+export const en = {
+    'inbox.title': 'Pending messages',
+    'inbox.pause': 'Pause queue',
+    'inbox.resume': 'Resume queue',
+    'inbox.paused': 'Queue paused; check unfinished inputs after a restart.',
+    'inbox.cancel': 'Cancel input',
+    'inbox.evidence': 'Reconciliation evidence',
+    'inbox.confirmDone': 'Confirm completed',
+    'inbox.confirmCancelled': 'Confirm cancelled',
+    'inbox.status.queued': 'Queued',
+    'inbox.status.running': 'Running',
+    'inbox.status.uncertain': 'Outcome uncertain',
+    'inbox.status.failed': 'Failed',
+    'inbox.status.done': 'Done',
+    'inbox.status.cancelled': 'Cancelled',
+    "configuration.title": "Model and reasoning configuration",
+    "configuration.choose": "Choose model",
+    "configuration.unavailable": "Unavailable",
+    "configuration.back": "Back",
+    "configuration.details": "Model directory details",
+    "configuration.model": "Model",
+    "configuration.effort": "Reasoning effort",
+    "configuration.inherit": "Inherit member configuration",
+    "configuration.default": "Follow harness defaults",
+    "configuration.search": "Search model names or IDs",
+    "configuration.custom": "Custom model ID",
+    "configuration.source.native": "Native directory",
+    "configuration.source.configuration": "Configuration",
+    "configuration.source.history": "Previously observed",
+    "configuration.hidden": "Additional candidate",
+    "configuration.empty": "No matching model candidates",
+    "configuration.unverified": "Not verified for this model",
+    "configuration.effortUnknown": "Reasoning choices are not available yet. The current effort is unchanged.",
+    "configuration.directory.loading": "Loading directory",
+    "configuration.directory.ready": "Directory updated",
+    "configuration.directory.stale": "Refresh failed; showing previous directory",
+    "configuration.directory.error": "Directory unavailable",
+    "configuration.directory.unsupported": "This source does not expose a full directory",
+    "configuration.incomplete": "Candidate list may be incomplete",
+    "configuration.round": "This round",
+    "configuration.ready": "Prepared for the next round",
+    "configuration.pending": "Pending for the next round",
+    "configuration.applying": "Preparing configuration",
+    "configuration.boundary": "You can choose now. The current round, including tool continuations, keeps its configuration; changes apply next round.",
+    "configuration.reconnecting": "Reconnecting configuration state…",
+    "configuration.apply": "Apply selection",
+    "configuration.cancel": "Cancel pending change",
+    "configuration.retry": "Reconcile and retry",
+    "configuration.refresh": "Refresh model directory",
+    "configuration.accepted": "Selection accepted. The live state shows when it is ready.",
+    "configuration.cancelled": "Cancellation accepted; restoring configuration.",
+    "configuration.failed": "Configuration failed; check the reason before retrying.",
+    'stream.thinking': 'Thinking',
+    'stream.writing': 'Writing',
+    'stream.recovering': 'Partial record, awaiting live connection',
+    'stream.copy': 'Copy',
+    'stream.copied': 'Copied',
+    'stream.footnotes': 'Footnotes',
+    'list.aria': '{harness} sessions',
+    'list.title': '{harness} sessions',
+    'empty': 'No {harness} sessions in the scoped home yet',
+    'login.hint': 'Run /{command} login to authorize, then delegate',
+    'loading': 'Loading…',
+    'error': 'Could not read {harness} sessions',
+    'unknown.command': '/{command} sessions unavailable (is the {harness} bundle installed?)',
+    'row.aria': '{harness} session {sessionId}',
+    'workdir': 'workDir',
+    'settings.nav': 'Local Agents',
+    'settings.intro': 'Manage locally-installed coding-agent CLIs: check auth status and authorize through the web login.',
+    'settings.noSession': 'Open a session first, then manage local agents',
+    'settings.authenticated': 'Authenticated',
+    'settings.notAuthenticated': 'Not authenticated',
+    'settings.login': 'Web login',
+    'settings.reauthorize': 'Re-authorize',
+    'settings.logout': 'Sign out',
+    'settings.loggedOut': 'Signed out',
+    'settings.openPage': 'Open authorization page',
+    'settings.homeDir': 'Home',
+    'settings.pending': 'Waiting for authorization…',
+    'settings.loginSuccess': '{harness} login succeeded — go try it out!',
+    'settings.pasteCode': 'Paste the code from the authorization page',
+    'settings.submitCode': 'Submit code',
+    'settings.unsupported': 'Coming soon',
+    'settings.rosterFailed': 'Could not read the local-agent roster; retry',
+    'settings.retry': 'Retry',
+    'member.checking': 'Checking membership…',
+    'member.readonly.title': 'One-shot subagent record',
+    'member.readonly.body': 'One-shot tasks do not accept follow-up messages; the full run record is available here.',
+    'member.title': '{harness} member',
+    'member.placeholder': 'Message the member to continue the same session…',
+    'member.send': 'Send',
+    'member.stop': 'Stop',
+    'member.running': 'Member running…',
+    'member.sendFailed': 'Send failed; try again',
+    'member.stats.cacheHit': 'Cache hit {percent}%',
+    'member.stats.tokens': 'Input {input} tok · Output {output} tok',
+    'member.tasks.summary': 'Tasks {done}/{total}',
+    'member.tasks.active': ' · Active: {title}',
+    'member.model.picker': 'Member model',
+    'member.model.default': 'Default',
+    'member.model.defaultLastObserved': 'Default (last: {model})',
+    'member.model.title': 'Model: {model} ({source})',
+    'member.model.source.override': 'session override',
+    'member.model.source.delegation': 'set at delegation',
+    'member.model.source.settings': 'plugin settings',
+    'member.model.source.cli-config': 'CLI config file',
+    'member.model.source.cli-builtin': "CLI built-in default: no layer names a model, so the CLI's own default runs; the last observed model is shown when known",
+    'member.model.followSettings': 'Follow settings',
+    'member.model.empty': 'No models to pick',
+    'member.model.failed': 'Could not switch the model; try again',
+};

package/lib/types/client/member-configuration.d.ts

@@ -0,0 +1,41 @@
+import type { LocalAgentControlReceipt, LocalAgentMemberConfiguration, LocalAgentMemberControlState, LocalAgentModelDirectory } from '../types.ts';
+export interface MemberConfigurationFace {
+    read(id: string): Promise<LocalAgentMemberControlState>;
+    follow(id: string, signal: AbortSignal): AsyncIterable<LocalAgentMemberControlState>;
+    directory(id: string, refresh: boolean): Promise<LocalAgentModelDirectory | null>;
+    followDirectory(id: string, signal: AbortSignal): AsyncIterable<LocalAgentModelDirectory>;
+    select(id: string, request: string, revision: number, selection: LocalAgentMemberConfiguration): Promise<LocalAgentControlReceipt>;
+    cancel(id: string, request: string, revision: number): Promise<LocalAgentControlReceipt>;
+    retry(id: string, revision: number): Promise<void>;
+}
+export interface MemberConfigurationSnapshot {
+    state?: LocalAgentMemberControlState;
+    directory?: LocalAgentModelDirectory;
+    connected: boolean;
+    error?: string | undefined;
+}
+/** One shared source for every visible entry to the same member. */
+export declare class MemberConfigurationStore {
+    readonly id: string;
+    readonly face: MemberConfigurationFace;
+    private readonly onIdle;
+    private snapshot;
+    private readonly listeners;
+    private controller;
+    constructor(id: string, face: MemberConfigurationFace, onIdle?: () => void);
+    readonly getSnapshot: () => MemberConfigurationSnapshot;
+    readonly subscribe: (listener: () => void) => (() => void);
+    private publish;
+    private accept;
+    private follow;
+    private followDirectory;
+    refreshDirectory(): Promise<void>;
+    refresh(): Promise<void>;
+}
+export declare class MemberConfigurationStores {
+    private readonly face;
+    private readonly stores;
+    constructor(face: MemberConfigurationFace);
+    get(id: string): MemberConfigurationStore;
+}
+//# sourceMappingURL=member-configuration.d.ts.map