@wowyuarm/dsh-agent-team 0.1.14-alpha.2 → 0.1.15

package/packages/client-agent-team/lib/types/client/avatar-image.js

@@ -0,0 +1,9 @@
+import { useState } from 'react';
+export function useAvatarImage(url) {
+    const [broken, setBroken] = useState(undefined);
+    return {
+        src: url === undefined || url === broken ? undefined : url,
+        failed: () => { if (url !== undefined)
+            setBroken(url); },
+    };
+}

package/packages/client-agent-team/lib/types/client/human-identity.d.ts

@@ -0,0 +1,90 @@
+import type { RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
+import type { AgentTeamHumanProfileResult } from '@wowyuarm/dsh-agent-team/types';
+/**
+ * The Client's one projection of the Human identity.
+ *
+ * The durable facts live in the Host: the display name and the avatar
+ * reference in the Team Host row's own Config, the avatar bytes in the
+ * persistent avatar store. This store is the only place the Team Client reads
+ * them, so every seat that names or draws the Human — message rows, member
+ * refs, mention chips, the settings page — shows one rename and one face, and a
+ * single refresh after a write moves all of them together. Writes go back
+ * through the Host's `setHumanProfile` Remote, which owns the profile entry the
+ * Client would otherwise have to name.
+ *
+ * Seats render before the first read settles; `name` stays undefined until then
+ * and every caller falls back to its own localized name for the Human. Reads
+ * are demand-driven: the first subscriber starts the read, so a Client that
+ * never opens Team mode or the profile page never calls the Remote.
+ */
+/** One read of the Human identity, replaced wholesale on every change. */
+export interface TeamHumanIdentitySnapshot {
+    /**
+     * `loading` until the first read settles, `ready` while an accepted value
+     * stands (also when a later refresh failed), `unavailable` when no value was
+     * ever accepted — the one state that hands the page a retry.
+     */
+    readonly status: 'loading' | 'ready' | 'unavailable';
+    /** Host-resolved display name; undefined before the first accepted read. */
+    readonly name?: string | undefined;
+    /** Configured avatar reference; undefined means the identity fallback is the avatar. */
+    readonly avatarRef?: string | undefined;
+    /** Avatar bytes as a data URL for `<img>`; undefined renders the fallback. */
+    readonly avatarUrl?: string | undefined;
+    /** Bundle version for the settings footnote. */
+    readonly version?: string | undefined;
+    /** Repository home the footnote links to. */
+    readonly repoUrl?: string | undefined;
+    readonly updateAvailable: boolean;
+    readonly latestVersion?: string | undefined;
+    /** Last failure, kept beside the last accepted value so a page can report it. */
+    readonly error?: string | undefined;
+}
+/** Read-side face every consumer binds: the seats' hook and the settings page alike. */
+export interface TeamHumanIdentitySource {
+    getSnapshot(): TeamHumanIdentitySnapshot;
+    subscribe(listener: () => void): () => void;
+}
+/** The settings page's extra face: re-read after a failed or superseded read. */
+export interface TeamHumanIdentityFace extends TeamHumanIdentitySource {
+    refresh(): Promise<void>;
+}
+/** Host calls the store reads through; one loader per Client context. */
+export interface TeamHumanIdentityLoader {
+    loadProfile: () => Promise<RemoteResult<AgentTeamHumanProfileResult>>;
+    /** Resolve one avatar reference to a displayable URL; null falls back to the initial. */
+    loadAvatarUrl: (avatarRef: string) => Promise<string | null>;
+}
+export declare class TeamHumanIdentity implements TeamHumanIdentityFace {
+    private snapshot;
+    private readonly listeners;
+    private reading;
+    private readonly loader;
+    constructor(loader: TeamHumanIdentityLoader);
+    readonly getSnapshot: () => TeamHumanIdentitySnapshot;
+    /**
+     * Observe the identity, starting the first read when nobody has read yet.
+     * @param listener - invoked after every snapshot replacement.
+     * @returns the disposer removing this listener.
+     */
+    readonly subscribe: (listener: () => void) => (() => void);
+    /**
+     * Re-read the Host projection. Concurrent callers share one round trip, and a
+     * failed refresh keeps the last accepted value beside the reported error —
+     * the seats never blank out because a background read failed.
+     * @returns settlement of this read (or of the read already in flight).
+     */
+    refresh(): Promise<void>;
+    dispose(): void;
+    private read;
+    /**
+     * Record one read failure. A value that was already accepted stays on screen
+     * (the seats never blank out over a background read), and only an identity
+     * that never loaded becomes `unavailable` — the state that offers a retry.
+     */
+    private fail;
+    private commit;
+}
+/** Subscribe one rendered seat to the identity. */
+export declare function useHumanIdentity(identity: TeamHumanIdentitySource): TeamHumanIdentitySnapshot;
+//# sourceMappingURL=human-identity.d.ts.map

package/packages/client-agent-team/lib/types/client/human-identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"human-identity.d.ts","sourceRoot":"","sources":["../../../src/client/human-identity.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AACpE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,gCAAgC,CAAA;AAEjF;;;;;;;;;;;;;;;;GAgBG;AAEH,0EAA0E;AAC1E,MAAM,WAAW,yBAAyB;IACxC;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,GAAG,aAAa,CAAA;IACpD,4EAA4E;IAC5E,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAClC,wFAAwF;IACxF,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACvC,8EAA8E;IAC9E,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACvC,gDAAgD;IAChD,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACrC,6CAA6C;IAC7C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACrC,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAA;IACjC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3C,iFAAiF;IACjF,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACpC;AAED,wFAAwF;AACxF,MAAM,WAAW,uBAAuB;IACtC,WAAW,IAAI,yBAAyB,CAAA;IACxC,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAA;CAC5C;AAED,iFAAiF;AACjF,MAAM,WAAW,qBAAsB,SAAQ,uBAAuB;IACpE,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB;AAED,yEAAyE;AACzE,MAAM,WAAW,uBAAuB;IACtC,WAAW,EAAE,MAAM,OAAO,CAAC,YAAY,CAAC,2BAA2B,CAAC,CAAC,CAAA;IACrE,yFAAyF;IACzF,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;CAC7D;AAID,qBAAa,iBAAkB,YAAW,qBAAqB;IAC7D,OAAO,CAAC,QAAQ,CAAqC;IACrD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwB;IAClD,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAyB;gBAEpC,MAAM,EAAE,uBAAuB;IAI3C,QAAQ,CAAC,WAAW,QAAO,yBAAyB,CAAiB;IAErE;;;;OAIG;IACH,QAAQ,CAAC,SAAS,GAAI,UAAU,MAAM,IAAI,KAAG,CAAC,MAAM,IAAI,CAAC,CAIxD;IAED;;;;;OAKG;IACH,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IASxB,OAAO,IAAI,IAAI;YAID,IAAI;IAkClB;;;;OAIG;IACH,OAAO,CAAC,IAAI;IAOZ,OAAO,CAAC,MAAM;CAIf;AAED,mDAAmD;AACnD,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,uBAAuB,GAAG,yBAAyB,CAE7F"}

package/packages/client-agent-team/lib/types/client/human-identity.js

@@ -0,0 +1,96 @@
+import { useSyncExternalStore } from 'react';
+const INITIAL = { status: 'loading', updateAvailable: false };
+export class TeamHumanIdentity {
+    snapshot = INITIAL;
+    listeners = new Set();
+    reading;
+    loader;
+    constructor(loader) {
+        this.loader = loader;
+    }
+    getSnapshot = () => this.snapshot;
+    /**
+     * Observe the identity, starting the first read when nobody has read yet.
+     * @param listener - invoked after every snapshot replacement.
+     * @returns the disposer removing this listener.
+     */
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        if (this.snapshot.status === 'loading' && this.reading === undefined)
+            void this.refresh();
+        return () => { this.listeners.delete(listener); };
+    };
+    /**
+     * Re-read the Host projection. Concurrent callers share one round trip, and a
+     * failed refresh keeps the last accepted value beside the reported error —
+     * the seats never blank out because a background read failed.
+     * @returns settlement of this read (or of the read already in flight).
+     */
+    refresh() {
+        if (this.reading !== undefined)
+            return this.reading;
+        const reading = this.read().finally(() => {
+            if (this.reading === reading)
+                this.reading = undefined;
+        });
+        this.reading = reading;
+        return reading;
+    }
+    dispose() {
+        this.listeners.clear();
+    }
+    async read() {
+        let profile;
+        try {
+            const result = await this.loader.loadProfile();
+            if (!result.ok) {
+                this.fail(result.error.message);
+                return;
+            }
+            profile = result.value;
+        }
+        catch (error) {
+            // A dropped connection surfaces as a thrown carrier error, not a result:
+            // both are read failures and both keep whatever value already stands.
+            this.fail(error instanceof Error ? error.message : String(error));
+            return;
+        }
+        // Bytes are immutable per reference, so one fetch serves every later
+        // refresh that still carries the same avatar.
+        const avatarUrl = profile.avatarRef === undefined
+            ? undefined
+            : profile.avatarRef === this.snapshot.avatarRef && this.snapshot.avatarUrl !== undefined
+                ? this.snapshot.avatarUrl
+                : (await this.loader.loadAvatarUrl(profile.avatarRef)) ?? undefined;
+        this.commit({
+            status: 'ready',
+            name: profile.name,
+            ...(profile.avatarRef === undefined ? {} : { avatarRef: profile.avatarRef }),
+            ...(avatarUrl === undefined ? {} : { avatarUrl }),
+            version: profile.version,
+            repoUrl: profile.repoUrl,
+            updateAvailable: profile.updateAvailable,
+            ...(profile.latestVersion === undefined ? {} : { latestVersion: profile.latestVersion }),
+        });
+    }
+    /**
+     * Record one read failure. A value that was already accepted stays on screen
+     * (the seats never blank out over a background read), and only an identity
+     * that never loaded becomes `unavailable` — the state that offers a retry.
+     */
+    fail(message) {
+        const held = this.snapshot;
+        this.commit(held.name === undefined
+            ? { ...held, status: 'unavailable', error: message }
+            : { ...held, status: 'ready', error: message });
+    }
+    commit(snapshot) {
+        this.snapshot = snapshot;
+        for (const listener of this.listeners)
+            listener();
+    }
+}
+/** Subscribe one rendered seat to the identity. */
+export function useHumanIdentity(identity) {
+    return useSyncExternalStore(identity.subscribe, identity.getSnapshot, identity.getSnapshot);
+}

package/packages/client-agent-team/lib/types/client/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAuCnE,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEhD,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAK5C,OAAO,EAAU,KAAK,OAAO,EAAE,MAAM,cAAc,CAAA;AAEnD,YAAY,EAAE,QAAQ,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAA;AAC9F,YAAY,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAIhD,eAAO,MAAM,MAAM,UAElB,CAAA;AAuBD,OAAO,QAAQ,kCAAkC,CAAC;IAChD,UAAU,kBAAkB;QAC1B,IAAI,EAAE,OAAO,CAAA;KACd;CACF;AAED,OAAO,QAAQ,qBAAqB,CAAC;IACnC,UAAU,OAAO;QACf,cAAc,EAAE,cAAc,CAAA;QAC9B,UAAU,EAAE,cAAc,CAAA;KAC3B;CACF;AAqMD,wBAAsB,KAAK,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAI7D"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,qBAAqB,CAAA;AA6CnE,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEhD,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAK5C,OAAO,EAAU,KAAK,OAAO,EAAE,MAAM,cAAc,CAAA;AAEnD,YAAY,EAAE,QAAQ,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAA;AAC9F,YAAY,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAIhD,eAAO,MAAM,MAAM,UAElB,CAAA;AAuBD,OAAO,QAAQ,kCAAkC,CAAC;IAChD,UAAU,kBAAkB;QAC1B,IAAI,EAAE,OAAO,CAAA;KACd;CACF;AAED,OAAO,QAAQ,qBAAqB,CAAC;IACnC,UAAU,OAAO;QACf,cAAc,EAAE,cAAc,CAAA;QAC9B,UAAU,EAAE,cAAc,CAAA;KAC3B;CACF;AAsQD,wBAAsB,KAAK,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAI7D"}

package/packages/client-agent-team/lib/types/client/index.js

@@ -1,4 +1,7 @@
 import agentTeamRemote from '@wowyuarm/dsh-agent-team/remote';
+import { HumanSettingsSection } from "./HumanSettingsSection.js";
+import { TeamHumanIdentity } from "./human-identity.js";
+import { bytesToBase64 } from "./attachment-preview.js";
 import { TeamNavigation } from "./navigation.js";
 import { TeamChangeStream, TeamReadStream } from "./team-changes.js";
 import { TeamDraftStore } from "./drafts.js";
@@ -31,7 +34,7 @@ function currentMainSessionId(ctx) {
  * target.
  */
 const openedMemberSessions = new WeakMap();
-function registerModeShadow(ctx, navigation, changes, reads, drafts, name, component, extraInject, 
+function registerModeShadow(ctx, navigation, changes, reads, drafts, humanIdentity, name, component, extraInject, 
 // Keyed seats (`main`) address one panel by key; the reserved 'conversation'
 // key is where the shipped Conversation registers, so the Team seat shadows
 // that same panel instead of adding a second one.
@@ -58,6 +61,7 @@ entryKey) {
         subscribeReads: (listener) => reads.subscribe(listener),
         subscribeChanges: (scope, listener) => changes.subscribe(scope, listener),
         drafts,
+        humanIdentity,
         loadMembers: (request) => ctx.remote.agentTeam.members(request),
         joinChannel: (request) => ctx.remote.agentTeam.joinChannel(request),
         removeChannelMember: (request) => ctx.remote.agentTeam.removeChannelMember(request),
@@ -111,6 +115,7 @@ entryKey) {
                             changeTask: (request) => ctx.remote.agentTeam.changeTask(request),
                             promoteThread: (request) => ctx.remote.agentTeam.promoteThread(request),
                             resolveTaskRefs: (request) => ctx.remote.agentTeam.resolveTaskRefs(request),
+                            resolveThreadRefs: (request) => ctx.remote.agentTeam.resolveThreadRefs(request),
                         } : {}),
                         ...(name === 'sidebar.workspaces' ? {
                             addMember: (request) => ctx.remote.agentTeam.addMember(request),
@@ -139,9 +144,26 @@ function applyUi(ctx) {
     const disposeNavigation = ctx.reflect.provide('teamNavigation', navigation);
     const drafts = new TeamDraftStore();
     const disposeDrafts = ctx.reflect.provide('teamDrafts', drafts);
+    // The Human's own identity: one projection every seat reads, refreshed once
+    // after a profile write so a rename reaches the timeline and the member refs
+    // without a reload. Reads are demand-driven — the first seat that subscribes
+    // starts the read. The profile page writes back through the Team Remote, so
+    // the Client never names the Host's own profile entry.
+    const humanIdentity = new TeamHumanIdentity({
+        loadProfile: () => ctx.remote.agentTeam.humanProfile({}),
+        loadAvatarUrl: async (avatarRef) => {
+            // Avatar bytes ride the dedicated avatar Remote (never the TTL-bound
+            // attachment cache); a data URL is what an `<img>` seat can show directly.
+            const result = await ctx.remote.agentTeam.getHumanAvatar({ avatarRef });
+            if (!result.ok || !result.value.mediaType.startsWith('image/'))
+                return null;
+            return `data:${result.value.mediaType};base64,${result.value.bytesBase64}`;
+        },
+    });
     ctx.effect(() => () => {
         navigation.dispose();
         drafts.dispose();
+        humanIdentity.dispose();
         void disposeNavigation();
         void disposeDrafts();
     }, 'agent-team: navigation service');
@@ -211,9 +233,59 @@ function applyUi(ctx) {
             },
         }),
     }, TeamFooterAction));
-    registerModeShadow(ctx, navigation, changes, reads, drafts, 'sidebar.workspaces', TeamWorkspaceBrowser);
-    registerModeShadow(ctx, navigation, changes, reads, drafts, 'main', TeamConversation, undefined, 'conversation');
-    registerModeShadow(ctx, navigation, changes, reads, drafts, 'sidebar.settings', TeamMembersAction, () => ({ loadMemberGroups }));
+    registerModeShadow(ctx, navigation, changes, reads, drafts, humanIdentity, 'sidebar.workspaces', TeamWorkspaceBrowser);
+    registerModeShadow(ctx, navigation, changes, reads, drafts, humanIdentity, 'main', TeamConversation, undefined, 'conversation');
+    registerModeShadow(ctx, navigation, changes, reads, drafts, humanIdentity, 'sidebar.settings', TeamMembersAction, () => ({ loadMemberGroups }));
+    // The Human profile page: one settings section, ordered between General (0)
+    // and Models (10) so identity sits near the top. Writes go through the Team
+    // Remote, which answers with the Host's own rejection reason (a name
+    // collides, an empty one), and the shared identity re-reads afterwards, so a
+    // rename lands in the timeline and the member refs at the same moment the
+    // page shows it.
+    ctx.slots.inject('settings.section', () => ctx.slots.register({
+        name: 'settings.section',
+        id: 'team-human',
+        order: 5,
+        label: () => ctx.locale.bind(NS)('humanSettingsNav'),
+        locale: NS,
+        inject: () => ({
+            identity: humanIdentity,
+            saveName: async (name) => {
+                const saved = await ctx.remote.agentTeam.setHumanProfile({ name });
+                if (!saved.ok)
+                    return saved.error.message;
+                await humanIdentity.refresh();
+                return undefined;
+            },
+            uploadAvatar: async (file) => {
+                const put = await ctx.remote.agentTeam.putHumanAvatar({
+                    name: file.name,
+                    ...(file.type === '' ? {} : { mediaType: file.type }),
+                    bytesBase64: bytesToBase64(new Uint8Array(await file.arrayBuffer())),
+                });
+                if (!put.ok)
+                    return put.error.message;
+                const saved = await ctx.remote.agentTeam.setHumanProfile({ avatarRef: put.value.avatarRef });
+                if (!saved.ok)
+                    return saved.error.message;
+                await humanIdentity.refresh();
+                return undefined;
+            },
+            removeAvatar: async () => {
+                const { avatarRef } = humanIdentity.getSnapshot();
+                if (avatarRef === undefined)
+                    return undefined;
+                // Bytes first, then the reference: a failed clear leaves a readable
+                // avatar instead of a reference to bytes nobody can load.
+                await ctx.remote.agentTeam.removeHumanAvatar({ avatarRef });
+                const cleared = await ctx.remote.agentTeam.setHumanProfile({ avatarRef: null });
+                if (!cleared.ok)
+                    return cleared.error.message;
+                await humanIdentity.refresh();
+                return undefined;
+            },
+        }),
+    }, HumanSettingsSection));
 }
 export async function apply(ctx) {
     const disposeRemote = await ctx.remote.$mount(agentTeamRemote);

package/packages/client-agent-team/lib/types/client/locales.d.ts

@@ -111,6 +111,28 @@ export declare const zh: {
     readonly timelineLabel: "消息时间线";
     readonly taskClosedNotice: "任务已关闭，重新打开后可继续讨论";
     readonly human: "Human";
+    readonly humanSettingsNav: "我的资料";
+    readonly humanSettingsTitle: "我的资料";
+    readonly humanSettingsIntro: "这是 Agent Team 的资料页：名字用在 Team 的消息与成员列表里，头像出现在你发出的消息旁。";
+    readonly humanSettingsName: "名字";
+    readonly humanSettingsNameHint: "Agents 用这个名字 @ 到你；改名只对之后的消息生效。";
+    readonly humanSettingsNameEmpty: "名字不能为空。";
+    readonly humanSettingsNameFailed: "名字没保存上：{message}";
+    readonly humanSettingsAvatar: "头像";
+    readonly humanSettingsAvatarHint: "只收图片，最大 10MB；移除或损坏时回退为默认头像。";
+    readonly humanSettingsSave: "保存";
+    readonly humanSettingsSaving: "正在保存…";
+    readonly humanSettingsUpload: "上传头像";
+    readonly humanSettingsUploading: "正在上传…";
+    readonly humanSettingsReplace: "更换头像";
+    readonly humanSettingsRemoveAvatar: "移除头像";
+    readonly humanSettingsAvatarNotImage: "只收图片文件。";
+    readonly humanSettingsAvatarTooLarge: "图片不能超过 10MB。";
+    readonly humanSettingsAvatarFailed: "头像没能保存：{message}";
+    readonly humanSettingsLoading: "正在载入资料…";
+    readonly humanSettingsUnavailable: "资料读不出来：{message}";
+    readonly humanSettingsVersion: "版本 {version}";
+    readonly humanSettingsUpdateAvailable: "有新版本 {version}，去查看发布说明";
     readonly taskStatusTodo: "待处理";
     readonly taskStatusInProgress: "进行中";
     readonly taskStatusInReview: "待验收";
@@ -123,6 +145,8 @@ export declare const zh: {
     readonly openTaskUnread: "打开 Task #{number}（{count} 条新动态）";
     readonly openThreadUnread: "打开讨论（{count} 条新动态）";
     readonly threadLabel: "讨论";
+    readonly channelLabel: "频道 · {name}";
+    readonly memberLabel: "成员 · @{name}";
     readonly recentActivity: "最近活动 {time}";
     readonly replyAction: "回复";
     readonly claimers: "由 {names} 处理";
@@ -147,7 +171,18 @@ export declare const zh: {
     readonly autoReadIncomplete: "仍有未读更新未能自动读取";
     readonly olderHistory: "更早历史";
     readonly runtimeRisk: "当前运行风险";
-    readonly runtimeRiskDetail: "@{member} 当前不可用：{diagnostic}";
+    readonly riskClassSessionRefused: "会话被拒绝";
+    readonly riskClassSessionUnreadable: "会话不可读";
+    readonly riskClassPresetComposition: "预设装配失败";
+    readonly riskClassRollover: "上下文交接中";
+    readonly riskClassRuntime: "运行时故障";
+    readonly riskClassActivation: "激活失败";
+    readonly riskSessionRefused: "{member} 当前不可用";
+    readonly riskSessionUnreadable: "{member} 的会话无法读取";
+    readonly riskPresetComposition: "{member} 的预设无法装配";
+    readonly riskRollover: "{member} 正在交接上下文";
+    readonly riskRuntime: "{member} 遇到运行时故障";
+    readonly riskActivation: "{member} 激活失败";
     readonly acceptTask: "验收";
     readonly closeTask: "关闭任务";
     readonly reopenTask: "重新打开";
@@ -288,6 +323,28 @@ export declare const en: {
     readonly timelineLabel: "Message timeline";
     readonly taskClosedNotice: "This task is closed; reopen it to continue the discussion";
     readonly human: "Human";
+    readonly humanSettingsNav: "Profile";
+    readonly humanSettingsTitle: "Profile";
+    readonly humanSettingsIntro: "This is your Agent Team profile: the name applies to Team messages and member lists, and the avatar appears beside your messages.";
+    readonly humanSettingsName: "Name";
+    readonly humanSettingsNameHint: "Agents @ you by this name; a rename applies to later messages only.";
+    readonly humanSettingsNameEmpty: "A name is required.";
+    readonly humanSettingsNameFailed: "The name was not saved: {message}";
+    readonly humanSettingsAvatar: "Avatar";
+    readonly humanSettingsAvatarHint: "Images only, up to 10MB; removing it — or unreadable bytes — falls back to the default avatar.";
+    readonly humanSettingsSave: "Save";
+    readonly humanSettingsSaving: "Saving…";
+    readonly humanSettingsUpload: "Upload avatar";
+    readonly humanSettingsUploading: "Uploading…";
+    readonly humanSettingsReplace: "Replace avatar";
+    readonly humanSettingsRemoveAvatar: "Remove avatar";
+    readonly humanSettingsAvatarNotImage: "Images only.";
+    readonly humanSettingsAvatarTooLarge: "The image must be 10MB or smaller.";
+    readonly humanSettingsAvatarFailed: "The avatar was not saved: {message}";
+    readonly humanSettingsLoading: "Loading profile…";
+    readonly humanSettingsUnavailable: "The profile could not be read: {message}";
+    readonly humanSettingsVersion: "Version {version}";
+    readonly humanSettingsUpdateAvailable: "New version {version} available — see the release notes";
     readonly taskStatusTodo: "To do";
     readonly taskStatusInProgress: "In progress";
     readonly taskStatusInReview: "In review";
@@ -300,6 +357,8 @@ export declare const en: {
     readonly openTaskUnread: "Open Task #{number} ({count} new updates)";
     readonly openThreadUnread: "Open thread ({count} new updates)";
     readonly threadLabel: "Thread";
+    readonly channelLabel: "Channel · {name}";
+    readonly memberLabel: "Member · @{name}";
     readonly recentActivity: "Last activity {time}";
     readonly replyAction: "Reply";
     readonly claimers: "Handled by {names}";
@@ -324,7 +383,18 @@ export declare const en: {
     readonly autoReadIncomplete: "Some unread updates could not be read automatically";
     readonly olderHistory: "Older history";
     readonly runtimeRisk: "Current runtime risk";
-    readonly runtimeRiskDetail: "@{member} is unavailable: {diagnostic}";
+    readonly riskClassSessionRefused: "Session refused";
+    readonly riskClassSessionUnreadable: "Session unreadable";
+    readonly riskClassPresetComposition: "Preset composition failed";
+    readonly riskClassRollover: "Context rollover";
+    readonly riskClassRuntime: "Runtime failure";
+    readonly riskClassActivation: "Activation failed";
+    readonly riskSessionRefused: "{member} is unavailable";
+    readonly riskSessionUnreadable: "{member} has an unreadable Session";
+    readonly riskPresetComposition: "{member} has an uncomposable preset";
+    readonly riskRollover: "{member} is rolling over its context";
+    readonly riskRuntime: "{member} hit a runtime failure";
+    readonly riskActivation: "{member} failed to activate";
     readonly acceptTask: "Accept";
     readonly closeTask: "Close task";
     readonly reopenTask: "Reopen";

package/packages/client-agent-team/lib/types/client/locales.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"locales.d.ts","sourceRoot":"","sources":["../../../src/client/locales.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgLL,CAAA;AAEV,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgLL,CAAA;AAEV,MAAM,MAAM,OAAO,GAAG,MAAM,OAAO,EAAE,CAAA"}
+{"version":3,"file":"locales.d.ts","sourceRoot":"","sources":["../../../src/client/locales.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuNL,CAAA;AAEV,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqNL,CAAA;AAEV,MAAM,MAAM,OAAO,GAAG,MAAM,OAAO,EAAE,CAAA"}

package/packages/client-agent-team/lib/types/client/locales.js

@@ -111,6 +111,28 @@ export const zh = {
     timelineLabel: '消息时间线',
     taskClosedNotice: '任务已关闭，重新打开后可继续讨论',
     human: 'Human',
+    humanSettingsNav: '我的资料',
+    humanSettingsTitle: '我的资料',
+    humanSettingsIntro: '这是 Agent Team 的资料页：名字用在 Team 的消息与成员列表里，头像出现在你发出的消息旁。',
+    humanSettingsName: '名字',
+    humanSettingsNameHint: 'Agents 用这个名字 @ 到你；改名只对之后的消息生效。',
+    humanSettingsNameEmpty: '名字不能为空。',
+    humanSettingsNameFailed: '名字没保存上：{message}',
+    humanSettingsAvatar: '头像',
+    humanSettingsAvatarHint: '只收图片，最大 10MB；移除或损坏时回退为默认头像。',
+    humanSettingsSave: '保存',
+    humanSettingsSaving: '正在保存…',
+    humanSettingsUpload: '上传头像',
+    humanSettingsUploading: '正在上传…',
+    humanSettingsReplace: '更换头像',
+    humanSettingsRemoveAvatar: '移除头像',
+    humanSettingsAvatarNotImage: '只收图片文件。',
+    humanSettingsAvatarTooLarge: '图片不能超过 10MB。',
+    humanSettingsAvatarFailed: '头像没能保存：{message}',
+    humanSettingsLoading: '正在载入资料…',
+    humanSettingsUnavailable: '资料读不出来：{message}',
+    humanSettingsVersion: '版本 {version}',
+    humanSettingsUpdateAvailable: '有新版本 {version}，去查看发布说明',
     taskStatusTodo: '待处理',
     taskStatusInProgress: '进行中',
     taskStatusInReview: '待验收',
@@ -123,6 +145,8 @@ export const zh = {
     openTaskUnread: '打开 Task #{number}（{count} 条新动态）',
     openThreadUnread: '打开讨论（{count} 条新动态）',
     threadLabel: '讨论',
+    channelLabel: '频道 · {name}',
+    memberLabel: '成员 · @{name}',
     recentActivity: '最近活动 {time}',
     replyAction: '回复',
     claimers: '由 {names} 处理',
@@ -147,7 +171,22 @@ export const zh = {
     autoReadIncomplete: '仍有未读更新未能自动读取',
     olderHistory: '更早历史',
     runtimeRisk: '当前运行风险',
-    runtimeRiskDetail: '@{member} 当前不可用：{diagnostic}',
+    // The diagnostic's structured class is the localizable axis: it names what
+    // kind of problem this is, while the Host detail stays English and moves to
+    // the row's title. One label names the class, one sentence states it of the
+    // Member.
+    riskClassSessionRefused: '会话被拒绝',
+    riskClassSessionUnreadable: '会话不可读',
+    riskClassPresetComposition: '预设装配失败',
+    riskClassRollover: '上下文交接中',
+    riskClassRuntime: '运行时故障',
+    riskClassActivation: '激活失败',
+    riskSessionRefused: '{member} 当前不可用',
+    riskSessionUnreadable: '{member} 的会话无法读取',
+    riskPresetComposition: '{member} 的预设无法装配',
+    riskRollover: '{member} 正在交接上下文',
+    riskRuntime: '{member} 遇到运行时故障',
+    riskActivation: '{member} 激活失败',
     acceptTask: '验收',
     closeTask: '关闭任务',
     reopenTask: '重新打开',
@@ -288,6 +327,28 @@ export const en = {
     timelineLabel: 'Message timeline',
     taskClosedNotice: 'This task is closed; reopen it to continue the discussion',
     human: 'Human',
+    humanSettingsNav: 'Profile',
+    humanSettingsTitle: 'Profile',
+    humanSettingsIntro: 'This is your Agent Team profile: the name applies to Team messages and member lists, and the avatar appears beside your messages.',
+    humanSettingsName: 'Name',
+    humanSettingsNameHint: 'Agents @ you by this name; a rename applies to later messages only.',
+    humanSettingsNameEmpty: 'A name is required.',
+    humanSettingsNameFailed: 'The name was not saved: {message}',
+    humanSettingsAvatar: 'Avatar',
+    humanSettingsAvatarHint: 'Images only, up to 10MB; removing it — or unreadable bytes — falls back to the default avatar.',
+    humanSettingsSave: 'Save',
+    humanSettingsSaving: 'Saving…',
+    humanSettingsUpload: 'Upload avatar',
+    humanSettingsUploading: 'Uploading…',
+    humanSettingsReplace: 'Replace avatar',
+    humanSettingsRemoveAvatar: 'Remove avatar',
+    humanSettingsAvatarNotImage: 'Images only.',
+    humanSettingsAvatarTooLarge: 'The image must be 10MB or smaller.',
+    humanSettingsAvatarFailed: 'The avatar was not saved: {message}',
+    humanSettingsLoading: 'Loading profile…',
+    humanSettingsUnavailable: 'The profile could not be read: {message}',
+    humanSettingsVersion: 'Version {version}',
+    humanSettingsUpdateAvailable: 'New version {version} available — see the release notes',
     taskStatusTodo: 'To do',
     taskStatusInProgress: 'In progress',
     taskStatusInReview: 'In review',
@@ -300,6 +361,8 @@ export const en = {
     openTaskUnread: 'Open Task #{number} ({count} new updates)',
     openThreadUnread: 'Open thread ({count} new updates)',
     threadLabel: 'Thread',
+    channelLabel: 'Channel · {name}',
+    memberLabel: 'Member · @{name}',
     recentActivity: 'Last activity {time}',
     replyAction: 'Reply',
     claimers: 'Handled by {names}',
@@ -324,7 +387,20 @@ export const en = {
     autoReadIncomplete: 'Some unread updates could not be read automatically',
     olderHistory: 'Older history',
     runtimeRisk: 'Current runtime risk',
-    runtimeRiskDetail: '@{member} is unavailable: {diagnostic}',
+    // See the zh block: the structured class names the kind of problem, the
+    // sentence states it of the Member, and the Host detail rides the title.
+    riskClassSessionRefused: 'Session refused',
+    riskClassSessionUnreadable: 'Session unreadable',
+    riskClassPresetComposition: 'Preset composition failed',
+    riskClassRollover: 'Context rollover',
+    riskClassRuntime: 'Runtime failure',
+    riskClassActivation: 'Activation failed',
+    riskSessionRefused: '{member} is unavailable',
+    riskSessionUnreadable: '{member} has an unreadable Session',
+    riskPresetComposition: '{member} has an uncomposable preset',
+    riskRollover: '{member} is rolling over its context',
+    riskRuntime: '{member} hit a runtime failure',
+    riskActivation: '{member} failed to activate',
     acceptTask: 'Accept',
     closeTask: 'Close task',
     reopenTask: 'Reopen',

package/packages/client-agent-team/lib/types/client/refs.d.ts

@@ -0,0 +1,71 @@
+import type { SessionId } from '@deepseek-ai/dsh-session';
+import type { RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
+import type { AgentTeamChannel, AgentTeamChannelRef, AgentTeamClientMemberStatus, AgentTeamMemberId, AgentTeamResolveTaskRefsRequest, AgentTeamResolveTaskRefsResult, AgentTeamResolveThreadRefsRequest, AgentTeamResolveThreadRefsResult, AgentTeamTaskRef, AgentTeamThreadRef } from '@wowyuarm/dsh-agent-team/types';
+/** Navigation facts for one branded Task ref, resolved once per session. */
+export interface ResolvedTaskRef {
+    readonly taskRef: AgentTeamTaskRef;
+    readonly channelRef: AgentTeamChannelRef;
+    readonly threadRef: AgentTeamThreadRef;
+    readonly taskNumber: number;
+}
+/** Navigation facts for one branded Thread ref, resolved once per session. */
+export interface ResolvedThreadRef {
+    readonly threadRef: AgentTeamThreadRef;
+    readonly channelRef: AgentTeamChannelRef;
+    readonly taskRef?: AgentTeamTaskRef;
+    readonly taskNumber?: number;
+    /** Opening-line gist distinguishing one Thread chip from another. */
+    readonly title: string;
+}
+/** One roster-resolved Member behind a `member:` chip. */
+export interface ResolvedMemberRef {
+    readonly memberId: AgentTeamMemberId;
+    /** Bare handle without the `@`; the chip renders it. */
+    readonly handle: string;
+    /** Present for agent Members; absent for the Human (no session to open). */
+    readonly sessionId?: SessionId;
+    /** Only active agent Members open a session — mirrors the agent card rule. */
+    readonly openable: boolean;
+}
+/** Compare refs by branded prefix plus hyphen-stripped UUID, so abbreviated spellings line up with their full form. */
+export declare function refKeyOf(ref: string): string;
+/** React binding: re-renders the caller when any Task ref resolution lands. */
+export declare const useResolvedTaskRefVersion: () => number;
+export declare const cachedResolvedTaskRef: (ref: AgentTeamTaskRef) => ResolvedTaskRef | undefined;
+/** Store one Task resolution (click path) and wake every rendered link. */
+export declare const rememberResolvedTaskRef: (entry: ResolvedTaskRef) => void;
+export declare const resolveUnknownTaskRefs: (refs: readonly AgentTeamTaskRef[], lookup: (refs: readonly AgentTeamTaskRef[]) => Promise<readonly ResolvedTaskRef[]>) => Promise<void>;
+/** React binding: re-renders the caller when any Thread ref resolution lands. */
+export declare const useResolvedThreadRefVersion: () => number;
+export declare const cachedResolvedThreadRef: (ref: AgentTeamThreadRef) => ResolvedThreadRef | undefined;
+/** Store one Thread resolution (click path) and wake every rendered link. */
+export declare const rememberResolvedThreadRef: (entry: ResolvedThreadRef) => void;
+export declare const resolveUnknownThreadRefs: (refs: readonly AgentTeamThreadRef[], lookup: (refs: readonly AgentTeamThreadRef[]) => Promise<readonly ResolvedThreadRef[]>) => Promise<void>;
+/**
+ * Click-path Task lookup: remember every resolved entry and hand them back
+ * for immediate navigation (see hostRefLookup for the ordering contract).
+ */
+export declare const hostTaskRefLookup: (resolveTaskRefs: (request: AgentTeamResolveTaskRefsRequest) => Promise<RemoteResult<AgentTeamResolveTaskRefsResult>>, workspaceId: AgentTeamResolveTaskRefsRequest["workspaceId"]) => ((taskRefs: readonly AgentTeamTaskRef[]) => Promise<readonly ResolvedTaskRef[]>);
+/**
+ * Click-path Thread lookup: remember every resolved entry and hand them back
+ * for immediate navigation (see hostRefLookup for the ordering contract).
+ */
+export declare const hostThreadRefLookup: (resolveThreadRefs: (request: AgentTeamResolveThreadRefsRequest) => Promise<RemoteResult<AgentTeamResolveThreadRefsResult>>, workspaceId: AgentTeamResolveThreadRefsRequest["workspaceId"]) => ((threadRefs: readonly AgentTeamThreadRef[]) => Promise<readonly ResolvedThreadRef[]>);
+/** Resolve one Task ref through the Host and jump to its home Channel Thread. */
+export declare const jumpToTaskThread: (resolveTaskRefs: (request: AgentTeamResolveTaskRefsRequest) => Promise<RemoteResult<AgentTeamResolveTaskRefsResult>>, workspaceId: AgentTeamResolveTaskRefsRequest["workspaceId"], taskRef: AgentTeamTaskRef, selectThread: (threadRef: AgentTeamThreadRef, channelRef?: AgentTeamChannelRef, taskRef?: AgentTeamTaskRef, taskNumber?: number) => void) => void;
+/** Resolve one Thread ref through the Host and jump to its home Channel Thread. */
+export declare const jumpToThread: (resolveThreadRefs: (request: AgentTeamResolveThreadRefsRequest) => Promise<RemoteResult<AgentTeamResolveThreadRefsResult>>, workspaceId: AgentTeamResolveThreadRefsRequest["workspaceId"], threadRef: AgentTeamThreadRef, selectThread: (threadRef: AgentTeamThreadRef, channelRef?: AgentTeamChannelRef, taskRef?: AgentTeamTaskRef, taskNumber?: number) => void) => void;
+/**
+ * Display name for one authored channel ref, or undefined when the loaded
+ * roster does not know it — the caller keeps plain text. Archived Channels
+ * never resolve: they are gone from every Team surface, so their refs are
+ * not links either.
+ */
+export declare const rosterChannelName: (channels: readonly AgentTeamChannel[], channelRef: AgentTeamChannelRef) => string | undefined;
+/**
+ * Roster facts for one authored member ref, or undefined when nobody on the
+ * roster answers to it — the caller keeps plain text. The Human resolves to
+ * a handle with no session: informative, never a link.
+ */
+export declare const rosterMember: (members: readonly AgentTeamClientMemberStatus[], humanMemberId: AgentTeamMemberId | undefined, humanHandle: string, memberRef: AgentTeamMemberId) => ResolvedMemberRef | undefined;
+//# sourceMappingURL=refs.d.ts.map