@wowyuarm/dsh-agent-team 0.1.15 → 0.2.1

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

@@ -0,0 +1,65 @@
+import type { RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
+import type { AgentTeamEnvironmentResult } from '@wowyuarm/dsh-agent-team/types';
+/**
+ * The Client's one projection of the local environment check.
+ *
+ * Deliberately separate from the Human identity projection: this is a fact
+ * about the installation, not about the Human, it is read once and never
+ * written back, and the settings page is the only surface that renders it.
+ * Folding it into the identity store would make every seat that names the
+ * Human depend on a version comparison it has no use for.
+ *
+ * Reads are demand-driven off the first subscriber, so an ordinary conversation
+ * never calls the Remote. There is no retry: `undetermined` is a settled
+ * verdict about facts the Host could not establish, not a failed request, so a
+ * reader has nothing to retry.
+ */
+/** One read of the environment check, replaced wholesale on every change. */
+export interface TeamEnvironmentSnapshot {
+    /** `loading` until the first read settles, `ready` once it has. */
+    readonly status: 'loading' | 'ready';
+    /** The report to render; undefined until the first read settles. */
+    readonly report?: AgentTeamEnvironmentResult | undefined;
+}
+/** Read-side face the settings page binds. */
+export interface TeamEnvironmentSource {
+    getSnapshot(): TeamEnvironmentSnapshot;
+    subscribe(listener: () => void): () => void;
+}
+/** Host call the store reads through; one loader per Client context. */
+export interface TeamEnvironmentLoader {
+    loadEnvironment: () => Promise<RemoteResult<AgentTeamEnvironmentResult>>;
+}
+export declare class TeamEnvironmentCheck implements TeamEnvironmentSource {
+    private snapshot;
+    private readonly listeners;
+    private reading;
+    private readonly loader;
+    constructor(loader: TeamEnvironmentLoader);
+    readonly getSnapshot: () => TeamEnvironmentSnapshot;
+    /**
+     * Observe the check, 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);
+    /**
+     * Read the Host projection. Concurrent callers share one round trip, and a
+     * failed read keeps the last accepted report — the block never blanks out
+     * over a background read.
+     * @returns settlement of this read (or of the read already in flight).
+     */
+    refresh(): Promise<void>;
+    dispose(): void;
+    private read;
+    /**
+     * Settle a read that produced no report, so a reader stops waiting on a
+     * `loading` that will never finish. A report that already stands is left
+     * untouched: a failed background read never blanks the block.
+     */
+    private fail;
+    private commit;
+}
+/** Subscribe one rendered block to the environment check. */
+export declare function useEnvironmentCheck(environment: TeamEnvironmentSource): TeamEnvironmentSnapshot;
+//# sourceMappingURL=environment-check.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"environment-check.d.ts","sourceRoot":"","sources":["../../../src/client/environment-check.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AACpE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAA;AAEhF;;;;;;;;;;;;;GAaG;AAEH,6EAA6E;AAC7E,MAAM,WAAW,uBAAuB;IACtC,mEAAmE;IACnE,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAA;IACpC,oEAAoE;IACpE,QAAQ,CAAC,MAAM,CAAC,EAAE,0BAA0B,GAAG,SAAS,CAAA;CACzD;AAED,8CAA8C;AAC9C,MAAM,WAAW,qBAAqB;IACpC,WAAW,IAAI,uBAAuB,CAAA;IACtC,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAA;CAC5C;AAED,wEAAwE;AACxE,MAAM,WAAW,qBAAqB;IACpC,eAAe,EAAE,MAAM,OAAO,CAAC,YAAY,CAAC,0BAA0B,CAAC,CAAC,CAAA;CACzE;AAID,qBAAa,oBAAqB,YAAW,qBAAqB;IAChE,OAAO,CAAC,QAAQ,CAAmC;IACnD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwB;IAClD,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuB;gBAElC,MAAM,EAAE,qBAAqB;IAIzC,QAAQ,CAAC,WAAW,QAAO,uBAAuB,CAAiB;IAEnE;;;;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;IAkBlB;;;;OAIG;IACH,OAAO,CAAC,IAAI;IAIZ,OAAO,CAAC,MAAM;CAIf;AAED,6DAA6D;AAC7D,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,qBAAqB,GAAG,uBAAuB,CAE/F"}

package/packages/client-agent-team/lib/types/client/environment-check.js

@@ -0,0 +1,78 @@
+import { useSyncExternalStore } from 'react';
+const INITIAL = { status: 'loading' };
+export class TeamEnvironmentCheck {
+    snapshot = INITIAL;
+    listeners = new Set();
+    reading;
+    loader;
+    constructor(loader) {
+        this.loader = loader;
+    }
+    getSnapshot = () => this.snapshot;
+    /**
+     * Observe the check, 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); };
+    };
+    /**
+     * Read the Host projection. Concurrent callers share one round trip, and a
+     * failed read keeps the last accepted report — the block never blanks out
+     * over a background read.
+     * @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 report;
+        try {
+            const result = await this.loader.loadEnvironment();
+            if (!result.ok) {
+                this.fail();
+                return;
+            }
+            report = result.value;
+        }
+        catch {
+            // A dropped connection surfaces as a thrown carrier error, not a result:
+            // both are read failures and both keep whatever report already stands.
+            this.fail();
+            return;
+        }
+        this.commit({ status: 'ready', report });
+    }
+    /**
+     * Settle a read that produced no report, so a reader stops waiting on a
+     * `loading` that will never finish. A report that already stands is left
+     * untouched: a failed background read never blanks the block.
+     */
+    fail() {
+        if (this.snapshot.report === undefined)
+            this.commit({ status: 'ready' });
+    }
+    commit(snapshot) {
+        this.snapshot = snapshot;
+        for (const listener of this.listeners)
+            listener();
+    }
+}
+/** Subscribe one rendered block to the environment check. */
+export function useEnvironmentCheck(environment) {
+    return useSyncExternalStore(environment.subscribe, environment.getSnapshot, environment.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;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"}
+{"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;AAgDnE,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;AAYhD,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;AAoUD,wBAAsB,KAAK,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAI7D"}

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

@@ -1,6 +1,9 @@
 import agentTeamRemote from '@wowyuarm/dsh-agent-team/remote';
-import { HumanSettingsSection } from "./HumanSettingsSection.js";
+import { TeamSettingsSection } from "./TeamSettingsSection.js";
+import { TeamContextJudgeCheck } from "./context-judge.js";
+import { TeamJudgeForm, TeamJudgeFormSeat } from "./judge-form.js";
 import { TeamHumanIdentity } from "./human-identity.js";
+import { TeamEnvironmentCheck } from "./environment-check.js";
 import { bytesToBase64 } from "./attachment-preview.js";
 import { TeamNavigation } from "./navigation.js";
 import { TeamChangeStream, TeamReadStream } from "./team-changes.js";
@@ -12,8 +15,15 @@ import { TeamWorkspaceBrowser } from "./TeamWorkspaceBrowser.js";
 import { en, zh } from "./locales.js";
 export { TeamNavigation } from "./navigation.js";
 const NS = 'team';
+/**
+ * The Team Host row's settings namespace. Spelled here rather than imported,
+ * because a client package must not depend on a Host package — the profile, the
+ * judge's endpoint, and the gate's thresholds all live in this one row section,
+ * and each settings page renders only the group it owns.
+ */
+const TEAM_SETTINGS_NS = 'wowyuarm-agent-team-host';
 export const inject = [
-    'slots', 'workspaces', 'locale', 'remote', 'remote.session', 'sessions', 'connection', 'conversation', 'uiWorkspace',
+    'slots', 'workspaces', 'layout', 'locale', 'remote', 'remote.session', 'sessions', 'connection', 'conversation', 'uiWorkspace',
 ];
 /**
  * 0.1.7 moved the conversation selection into the workspace service: the
@@ -160,10 +170,31 @@ function applyUi(ctx) {
             return `data:${result.value.mediaType};base64,${result.value.bytesBase64}`;
         },
     });
+    // The local environment check: a fact about this installation rather than
+    // about the Human, so it is its own projection and never a field of the
+    // identity above. Read once, on the first subscriber, and never written back.
+    const environment = new TeamEnvironmentCheck({
+        loadEnvironment: () => ctx.remote.agentTeam.environment({}),
+    });
+    // The long-gap gate's judge: what the Host answers about reachability, and
+    // the thresholds in force. Its own projection rather than a field of the
+    // environment check, because it re-reads after every write that can mount or
+    // unmount the judge while the environment verdict is settled once.
+    const contextJudge = new TeamContextJudgeCheck({
+        loadContextJudge: () => ctx.remote.agentTeam.contextJudge({}),
+    });
+    // The settings page's endpoint form. It is held in a seat rather than handed
+    // over as a value, because the service it is built over may arrive after the
+    // page's injected props were computed — and a slot entry's props are computed
+    // once and cached, so a value would freeze the answer.
+    const judgeForm = new TeamJudgeFormSeat();
     ctx.effect(() => () => {
         navigation.dispose();
         drafts.dispose();
         humanIdentity.dispose();
+        environment.dispose();
+        contextJudge.dispose();
+        judgeForm.dispose();
         void disposeNavigation();
         void disposeDrafts();
     }, 'agent-team: navigation service');
@@ -195,6 +226,25 @@ function applyUi(ctx) {
             restore();
         };
     }, 'agent-team: member session restore');
+    // The shell renders one keyed main panel at a time — `activePanelId ?? 'conversation'`
+    // — so a shipped global panel (the plugin manager) stays on screen after Team mode is
+    // entered, and every Team destination then opens behind it: the sidebar moves while the
+    // column keeps rendering the foreign page. Team mode owns the conversation seat, so
+    // entering it, or navigating inside it, hands the column back to that seat. A null
+    // selection — and every mode but Team, where panel choice belongs to the shipped
+    // sidebar — is left untouched, so this never fights the shell's own selection.
+    ctx.effect(() => {
+        const releaseMainPanel = () => {
+            if (navigation.getSnapshot().mode !== 'team')
+                return;
+            if (ctx.layout.panelInfo.getSnapshot().activePanelId === null)
+                return;
+            ctx.layout.selectPanel(null);
+        };
+        const unsubscribe = navigation.subscribe(releaseMainPanel);
+        releaseMainPanel();
+        return unsubscribe;
+    }, 'agent-team: main panel ownership');
     const changes = new TeamChangeStream(ctx.remote);
     ctx.effect(() => () => changes.dispose(), 'agent-team: change subscriptions');
     // The Harness resumes a live generation across reconnects, but a stream that
@@ -236,20 +286,43 @@ function applyUi(ctx) {
     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.
+    // The Team's settings page: one settings section, ordered between General (0)
+    // and Models (10) so it sits near the top. It holds two groups that write
+    // through two different documents: identity goes 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.
+    //
+    // The judge's endpoint is one group of the Team row's settings section, so it
+    // is offered only while this deployment serves a settings document: the page
+    // is registered here regardless, because identity is reachable without one,
+    // and the seat above stays empty when there is none. The service is read
+    // through `ctx.get` rather than a hard `inject` for the same reason — a
+    // deployment without the settings UI keeps the rest of the Team.
+    ctx.inject(['configForms'], (scope) => {
+        const form = new TeamJudgeForm(scope.configForms.get(TEAM_SETTINGS_NS), contextJudge);
+        judgeForm.hold(form);
+        scope.effect(() => () => {
+            judgeForm.release(form);
+            form.dispose();
+        }, 'agent-team: judge settings form');
+    });
     ctx.slots.inject('settings.section', () => ctx.slots.register({
         name: 'settings.section',
-        id: 'team-human',
+        id: 'team-settings',
         order: 5,
-        label: () => ctx.locale.bind(NS)('humanSettingsNav'),
+        label: () => ctx.locale.bind(NS)('teamSettingsNav'),
         locale: NS,
         inject: () => ({
             identity: humanIdentity,
+            environment,
+            judge: contextJudge,
+            judgeForm,
+            // The key's literal never rides a response; the describe mirror is what
+            // says whether one is stored.
+            keyConfigured: () => ctx.get('configForms')?.describe().getSnapshot().view?.namespaces
+                .find(row => row.ns === TEAM_SETTINGS_NS)?.secrets
+                .some(secret => secret.path.join('.') === 'jev.apiKey' && secret.set) ?? false,
             saveName: async (name) => {
                 const saved = await ctx.remote.agentTeam.setHumanProfile({ name });
                 if (!saved.ok)
@@ -285,7 +358,7 @@ function applyUi(ctx) {
                 return undefined;
             },
         }),
-    }, HumanSettingsSection));
+    }, TeamSettingsSection));
 }
 export async function apply(ctx) {
     const disposeRemote = await ctx.remote.$mount(agentTeamRemote);

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

@@ -0,0 +1,99 @@
+import { type SettingsFieldState, type SettingsFormActions, type SettingsFormScope, type SettingsFormShell } from '@deepseek-ai/dsh-client-ui-primitives';
+import type { TeamContextJudgeCheck } from './context-judge.ts';
+/** Where each control's value lives inside the Team row's settings section. */
+declare const FIELD_PATHS: {
+    readonly apiBase: readonly ["jev", "apiBase"];
+    readonly model: readonly ["jev", "model"];
+    readonly apiKey: readonly ["jev", "apiKey"];
+};
+/** One control this page owns. */
+export type TeamJudgeField = keyof typeof FIELD_PATHS;
+/** The group this form edits, as it sits inside the Team row's section. */
+export interface TeamJudgeSection {
+    /** The judge's endpoint configuration. */
+    readonly jev?: unknown;
+}
+/** Everything the page renders about the form, in one replaceable value. */
+export interface TeamJudgeFormSnapshot {
+    /** Availability, writability, and what a save would do. */
+    readonly shell: SettingsFormShell;
+    /** One state per control this page owns. */
+    readonly fields: Readonly<Record<TeamJudgeField, SettingsFieldState>>;
+}
+export declare class TeamJudgeForm {
+    private readonly section;
+    private readonly judge;
+    private readonly model;
+    private readonly scope;
+    private readonly store;
+    /**
+     * @param section - the Team row's configuration form, as the settings provider serves it.
+     * @param judge - the status projection a landed write re-reads.
+     */
+    constructor(section: SettingsFormScope<TeamJudgeSection>, judge: TeamContextJudgeCheck);
+    /** The form state the page renders. */
+    readonly getSnapshot: () => TeamJudgeFormSnapshot;
+    /** Observe the form state. */
+    readonly subscribe: (listener: () => void) => (() => void);
+    /** Stage a draft, reset a field, save every staged edit, or discard them. */
+    actions(): SettingsFormActions;
+    /**
+     * Remove the stored key literal: the judge unmounts and the status re-reads.
+     *
+     * Deliberately its own write rather than a staged edit — the shared form
+     * model has no clear for a write-only control, and an empty draft must keep
+     * the stored literal instead of clearing it. The page only offers this while
+     * no draft is staged, because a write moves the document revision the staged
+     * save is fenced to.
+     * @returns whether the Host accepted the clear.
+     */
+    clearKey(): Promise<boolean>;
+    dispose(): void;
+    /** Build the page's state from the model's reads and drafts. */
+    private project;
+    /** Write every staged edit, then re-read the status the Host now serves. */
+    save(): Promise<void>;
+}
+/** Read-side face the settings page binds for the endpoint form. */
+export interface TeamJudgeFormSource {
+    getSnapshot(): TeamJudgeForm | undefined;
+    subscribe(listener: () => void): () => void;
+}
+/**
+ * The form's seat on the page, as an observable rather than a value.
+ *
+ * The form exists only while this deployment serves a settings document, and
+ * that service may arrive after the page's first render. A slot entry's
+ * injected props are computed once and cached for the entry's lifetime, so a
+ * value handed over at that moment would freeze the answer: the group would
+ * never appear until a reload. The page therefore observes this seat, which
+ * the service's arrival and departure both publish through.
+ */
+export declare class TeamJudgeFormSeat implements TeamJudgeFormSource {
+    private form;
+    private readonly listeners;
+    readonly getSnapshot: () => TeamJudgeForm | undefined;
+    /**
+     * Observe the form, without reading anything on subscribe: the seat carries
+     * no remote state of its own, so a subscriber renders whatever is held now.
+     * @param listener - invoked after every hold or release.
+     * @returns the disposer removing this listener.
+     */
+    readonly subscribe: (listener: () => void) => (() => void);
+    /**
+     * Publish the form the settings service answers with.
+     * @param form - the form built over that service's section scope.
+     */
+    hold(form: TeamJudgeForm): void;
+    /**
+     * Withdraw the form when its service goes away. Only the holder of the form
+     * in place can withdraw it, so a replacement is never cleared by the
+     * departure of the one it replaced.
+     * @param form - the form this caller holds.
+     */
+    release(form: TeamJudgeForm): void;
+    dispose(): void;
+    private publish;
+}
+export {};
+//# sourceMappingURL=judge-form.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"judge-form.d.ts","sourceRoot":"","sources":["../../../src/client/judge-form.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,kBAAkB,EAAE,KAAK,mBAAmB,EAA2B,KAAK,iBAAiB,EAClE,KAAK,iBAAiB,EACvD,MAAM,uCAAuC,CAAA;AAC9C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAA;AAqB/D,+EAA+E;AAC/E,QAAA,MAAM,WAAW;;;;CAIP,CAAA;AAEV,kCAAkC;AAClC,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,WAAW,CAAA;AAErD,2EAA2E;AAC3E,MAAM,WAAW,gBAAgB;IAC/B,0CAA0C;IAC1C,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAA;CACvB;AA4DD,4EAA4E;AAC5E,MAAM,WAAW,qBAAqB;IACpC,2DAA2D;IAC3D,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;IACjC,4CAA4C;IAC5C,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,cAAc,EAAE,kBAAkB,CAAC,CAAC,CAAA;CACtE;AAQD,qBAAa,aAAa;IAUtB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAVxB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA4C;IAClE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IAEtC;;;OAGG;gBAEgB,OAAO,EAAE,iBAAiB,CAAC,gBAAgB,CAAC,EAC5C,KAAK,EAAE,qBAAqB;IAiB/C,uCAAuC;IACvC,QAAQ,CAAC,WAAW,QAAO,qBAAqB,CAA4B;IAE5E,8BAA8B;IAC9B,QAAQ,CAAC,SAAS,GAAI,UAAU,MAAM,IAAI,KAAG,CAAC,MAAM,IAAI,CAAC,CAAkC;IAE3F,6EAA6E;IAC7E,OAAO,IAAI,mBAAmB;IAI9B;;;;;;;;;OASG;IACG,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;IAYlC,OAAO,IAAI,IAAI;IAIf,gEAAgE;IAChE,OAAO,CAAC,OAAO;IAMf,4EAA4E;IACtE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAI5B;AAED,oEAAoE;AACpE,MAAM,WAAW,mBAAmB;IAClC,WAAW,IAAI,aAAa,GAAG,SAAS,CAAA;IACxC,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAA;CAC5C;AAED;;;;;;;;;GASG;AACH,qBAAa,iBAAkB,YAAW,mBAAmB;IAC3D,OAAO,CAAC,IAAI,CAA2B;IACvC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwB;IAElD,QAAQ,CAAC,WAAW,QAAO,aAAa,GAAG,SAAS,CAAa;IAEjE;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,GAAI,UAAU,MAAM,IAAI,KAAG,CAAC,MAAM,IAAI,CAAC,CAGxD;IAED;;;OAGG;IACH,IAAI,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI;IAK/B;;;;;OAKG;IACH,OAAO,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI;IAMlC,OAAO,IAAI,IAAI;IAIf,OAAO,CAAC,OAAO;CAGhB"}

package/packages/client-agent-team/lib/types/client/judge-form.js

@@ -0,0 +1,208 @@
+import { SettingsFormModel, settingsTextField, } from '@deepseek-ai/dsh-client-ui-primitives';
+/**
+ * The Team settings page's staged form over the judge's endpoint.
+ *
+ * The page edits one group of the Team row's settings section: the `jev`
+ * endpoint the relatedness judge is mounted from. The identity fields that
+ * share that section belong to the Human profile rows and are never rendered
+ * here, so this form reaches its values through a projection — the shared form
+ * model addresses one flat section, and the adapter below maps each control to
+ * the path it really lives at.
+ *
+ * The key literal is the one control that is not read back: the Host redacts
+ * it, so its draft starts blank on every load, a blank draft writes nothing,
+ * and removing a stored literal is an explicit clear rather than an empty
+ * string.
+ */
+/** The group inside the Team row's settings section that this form edits. */
+const JUDGE_GROUP = 'jev';
+/** Where each control's value lives inside the Team row's settings section. */
+const FIELD_PATHS = {
+    apiBase: [JUDGE_GROUP, 'apiBase'],
+    model: [JUDGE_GROUP, 'model'],
+    apiKey: [JUDGE_GROUP, 'apiKey'],
+};
+/** Read the judge group of a section layer as a plain record. */
+function groupOf(layer) {
+    if (layer === null || typeof layer !== 'object')
+        return undefined;
+    const value = layer[JUDGE_GROUP];
+    return value !== null && typeof value === 'object' ? value : undefined;
+}
+/**
+ * Project one section layer onto the controls this page renders. A control the
+ * layer does not carry stays absent rather than becoming an empty string, which
+ * is what the model reads to decide whether a field is overridden and what a
+ * reset reverts to.
+ * @param layer - a section, or one of its composition layers.
+ * @returns the flat control values, or undefined when the layer carries none.
+ */
+function flatten(layer) {
+    if (layer === null || typeof layer !== 'object')
+        return undefined;
+    const group = groupOf(layer);
+    const flat = {};
+    for (const [field, path] of Object.entries(FIELD_PATHS)) {
+        if (group !== undefined && Object.hasOwn(group, path[1]))
+            flat[field] = group[path[1]];
+    }
+    return flat;
+}
+/** Address one control's edit at the path it really lives at. */
+function locate(op) {
+    const path = FIELD_PATHS[op.path[0]];
+    return op.op === 'set'
+        ? { op: 'set', path: [...path], value: op.value }
+        : { op: 'unset', path: [...path] };
+}
+/** The shared form model's view of this page's controls, over the real section. */
+class TeamJudgeScope {
+    section;
+    constructor(section) {
+        this.section = section;
+    }
+    getSnapshot() {
+        const snapshot = this.section.getSnapshot();
+        return {
+            status: snapshot.status,
+            value: flatten(snapshot.value),
+            base: flatten(snapshot.base),
+            user: flatten(snapshot.user),
+            writable: snapshot.writable,
+            revision: snapshot.revision,
+        };
+    }
+    subscribe(listener) {
+        return this.section.subscribe(listener);
+    }
+    mutate(ops, expectedRevision) {
+        return this.section.mutate(ops.map(op => locate(op)), expectedRevision);
+    }
+}
+export class TeamJudgeForm {
+    section;
+    judge;
+    model;
+    scope;
+    store;
+    /**
+     * @param section - the Team row's configuration form, as the settings provider serves it.
+     * @param judge - the status projection a landed write re-reads.
+     */
+    constructor(section, judge) {
+        this.section = section;
+        this.judge = judge;
+        this.scope = new TeamJudgeScope(section);
+        this.model = new SettingsFormModel(this.scope, [
+            settingsTextField('apiBase'),
+            settingsTextField('model'),
+        ], [{
+                field: 'apiKey',
+                // The literal never rides a response, so a draft is only ever what the
+                // reader typed; the write addresses the real path directly.
+                write: text => section.mutate([{ op: 'set', path: [...FIELD_PATHS.apiKey], value: text }]),
+            }]);
+        // The model publishes a projection on every scope change or staged edit;
+        // binding one is how this page observes it.
+        this.store = this.model.bind(() => this.project());
+    }
+    /** The form state the page renders. */
+    getSnapshot = () => this.store.getSnapshot();
+    /** Observe the form state. */
+    subscribe = (listener) => this.store.subscribe(listener);
+    /** Stage a draft, reset a field, save every staged edit, or discard them. */
+    actions() {
+        return { ...this.model.actions(), save: () => { void this.save(); } };
+    }
+    /**
+     * Remove the stored key literal: the judge unmounts and the status re-reads.
+     *
+     * Deliberately its own write rather than a staged edit — the shared form
+     * model has no clear for a write-only control, and an empty draft must keep
+     * the stored literal instead of clearing it. The page only offers this while
+     * no draft is staged, because a write moves the document revision the staged
+     * save is fenced to.
+     * @returns whether the Host accepted the clear.
+     */
+    async clearKey() {
+        let landed;
+        try {
+            landed = await this.section.mutate([{ op: 'unset', path: [...FIELD_PATHS.apiKey] }]);
+        }
+        catch {
+            return false;
+        }
+        if (!landed)
+            return false;
+        await this.judge.refresh();
+        return true;
+    }
+    dispose() {
+        this.model.dispose();
+    }
+    /** Build the page's state from the model's reads and drafts. */
+    project() {
+        const fields = {};
+        for (const field of Object.keys(FIELD_PATHS))
+            fields[field] = this.model.field(field);
+        return { shell: this.model.shell(), fields };
+    }
+    /** Write every staged edit, then re-read the status the Host now serves. */
+    async save() {
+        await this.model.save();
+        if (!this.model.shell().failed)
+            await this.judge.refresh();
+    }
+}
+/**
+ * The form's seat on the page, as an observable rather than a value.
+ *
+ * The form exists only while this deployment serves a settings document, and
+ * that service may arrive after the page's first render. A slot entry's
+ * injected props are computed once and cached for the entry's lifetime, so a
+ * value handed over at that moment would freeze the answer: the group would
+ * never appear until a reload. The page therefore observes this seat, which
+ * the service's arrival and departure both publish through.
+ */
+export class TeamJudgeFormSeat {
+    form;
+    listeners = new Set();
+    getSnapshot = () => this.form;
+    /**
+     * Observe the form, without reading anything on subscribe: the seat carries
+     * no remote state of its own, so a subscriber renders whatever is held now.
+     * @param listener - invoked after every hold or release.
+     * @returns the disposer removing this listener.
+     */
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => { this.listeners.delete(listener); };
+    };
+    /**
+     * Publish the form the settings service answers with.
+     * @param form - the form built over that service's section scope.
+     */
+    hold(form) {
+        this.form = form;
+        this.publish();
+    }
+    /**
+     * Withdraw the form when its service goes away. Only the holder of the form
+     * in place can withdraw it, so a replacement is never cleared by the
+     * departure of the one it replaced.
+     * @param form - the form this caller holds.
+     */
+    release(form) {
+        if (this.form !== form)
+            return;
+        this.form = undefined;
+        this.publish();
+    }
+    dispose() {
+        this.listeners.clear();
+    }
+    publish() {
+        for (const listener of this.listeners)
+            listener();
+    }
+}