super-dsh 0.3.2 → 0.3.3

package/remote/provenance.json

@@ -3,24 +3,25 @@
   "entry": "better-dsh/src/remote/plugin.ts",
   "workerEntry": "better-dsh/src/remote/file-worker.ts",
   "sources": {
-    "better-dsh/src/remote/agent-registration.ts": "459301354ea1ab713984bb01bc491a080256d4e983e55ff074e2665c3213d355",
+    "better-dsh/src/remote/agent-registration.ts": "cb08eb9f5d592201054410da69b3bf383e2604899d9494a8cbd8ba2f86b3f7ad",
     "better-dsh/src/remote/archive.ts": "fd32f96dc63421be7d56eb545badf355c6ee2498599605ffa48958b9efca9a63",
     "better-dsh/src/remote/copy.ts": "ab2aec5ee8df814f4bc568370977d229c402489248c738eff147431a52650c52",
-    "better-dsh/src/remote/driver.ts": "3b0ce9edeb3a3b4f6c6e3ff22df2b0bfb64d46944271333f6518c0e25f00e97a",
+    "better-dsh/src/remote/driver.ts": "8bfa05e056b9099a1d9fcdf6cb67d15ec6e9a895ea061ea2e65cd3a513fe4fdf",
     "better-dsh/src/remote/endpoints.ts": "e4ab0fa1afcee815ad78976eba4036e2ed2b21eaea11f7451874b56229f12eac",
     "better-dsh/src/remote/file-worker.ts": "31ac019a944cf7fdcd0ff044f8b330d923bf4d384c77056f9b7e3032bc8c9598",
     "better-dsh/src/remote/helper.ts": "789a802610fc480bb1c922dd284787ca22d7394fa906c729ee33d78ade79973c",
-    "better-dsh/src/remote/hub-contract.ts": "9801ac934553a57fe1a7aeb273175e68be57163e21606c35728901654f702770",
+    "better-dsh/src/remote/hub-contract.ts": "a7ae5501c4ffe63ced1526c2d64d7d83798fc2025f9b4aea998e033a124fe598",
+    "better-dsh/src/remote/hub-pty-pump.mjs": "dfe0cb331cc585eb4d858fbb6d8f3ff22414f3ee55109c933df0fc14502aee5c",
     "better-dsh/src/remote/input.ts": "dfe087d34e9e9aefc0d8ec2e33371dc86981b05723d436419ad1afb6ac8426b4",
-    "better-dsh/src/remote/jobs.ts": "f6c6d1e6fe9e93021923b0f8c3977bb0d6a58d0145764a14df92a84d96d43d0d",
+    "better-dsh/src/remote/jobs.ts": "4556bd9f30580a8bf90800c7a945282e276abb548df6db7fe95e7091bb1543c6",
     "better-dsh/src/remote/labels.ts": "d9dcfdc1c6bb292b37d3250e7897b239c416b55b3102943bcc4f1d0ce7d2e709",
     "better-dsh/src/remote/native-copy.ts": "3f8691abb14dfb7a94e956956fb4d182b7732ffbe70f1a8ff7dec5dd2b9afb7c",
-    "better-dsh/src/remote/nonce-framing.ts": "e2590293fe44c2997f6d65e0d6828aa67e51e0fc6d12cb71726063eec2f922b2",
+    "better-dsh/src/remote/nonce-framing.ts": "2f2f80d6aa9934f96ba171d575dbe4cddbe2e127da3b0eec3032c5ea522cadc3",
     "better-dsh/src/remote/oneshot.ts": "99f2c809ba1159c7865ec3cff2e6d7b1f165a7f03185a6fc9505c1a534ba57bc",
     "better-dsh/src/remote/output-ring.ts": "a79104bd3dcddab06a3fe7e52d239a70becd4f2dcddd0c9b6513f5fe3c4ed0bc",
-    "better-dsh/src/remote/plugin.ts": "c869e25bedccfa9e018e90e92110a0aaacc847c853a8db0519a6e171d1dd670c",
+    "better-dsh/src/remote/plugin.ts": "da6b985cd013ffc253ee8cf5605dc2d729e26534139dd28269db5d246511fac9",
     "better-dsh/src/remote/process.ts": "f4491c76457b662703e0b1e4a876299b9c8b7b3da5b304c6baee5576017de448",
-    "better-dsh/src/remote/pty-session.ts": "ee11d10baf52c6326f9cf0f5aa434b6330bb90562ee8871eac0b5a663ce1182a",
+    "better-dsh/src/remote/pty-session.ts": "3cb07345b90f0e54cbcea00204ae0b5346d9bb6edf3a784f009fc1b07357f799",
     "better-dsh/src/remote/roster.ts": "b84f75edc87550bb96803042487cfd7c39135b1710ff9715dd5ca402df0aa378",
     "better-dsh/src/remote/rsync.ts": "f9c15279fdfa67b3265eeda216bcd0c46d8b4f05c6026cf2750a1c818ff333ba",
     "better-dsh/src/remote/ssh-argv.ts": "e7f46ef3e53eaba6cfe92033afad046435db18b0b2f4b86832353d609c535662",
@@ -29,9 +30,10 @@
     "better-dsh/src/remote/ssh-rsync-native-relay.ts": "5d9585ab30a11aeeba19ce7b43aa31f47e2ee0bde2e7c006ac3e811cf7940bdf",
     "better-dsh/src/remote/ssh-targets.ts": "2a7e754fc26cf34e05ffb5d7f7406f35c09fd0770684db904dbf4c56d2c00beb",
     "better-dsh/src/remote/status.ts": "e144c1cf98388dbaca8dab5622e6e37ceac85d898119e37d07f88e129113a82e",
-    "better-dsh/src/remote/target.ts": "d72346382c0b49659a29807141af19e65d17478a7bf7b1ec4032148ba66c4aa3",
-    "better-dsh/src/remote/tool.ts": "a73b57009a4fcda8c58d57181f5f18bf88c8d6980316714a8c4c8b8835cb1466",
-    "better-dsh/src/remote/transports.ts": "55dbdef8f2522b262b2df8879884499cdaa7e508fa42f70ae615b5064f43bcc9",
+    "better-dsh/src/remote/target.ts": "bce47c6c61975a52e5cb77a6b727f68cbe78ecdcb3866c237fb932444ecc954e",
+    "better-dsh/src/remote/tool.ts": "ecb431c4b1dfa4981063ea78b90288ac9ac12070c08a113b51602f18887f194b",
+    "better-dsh/src/remote/transfer-tool.ts": "d02b216a31314e98fdf6933230b57adce58b9c8aebe9798aae7be808105b41e2",
+    "better-dsh/src/remote/transports.ts": "8a7190d6013f12901d9007e6b30708645baa4aa0770fcb1087ae6fcde656a8d0",
     "better-dsh/third_party/schemastery/lib/index.cjs": "aca1c1a47c7b6034feee01501aefca3e6dd97a0bac4fe334fd30647ae5a9e480",
     "better-dsh/third_party/schemastery/lib/index.d.mts": "66847f605af58c42575333c825eefdec4ad38278ad6cb260e37aa0cc63803bbd",
     "better-dsh/third_party/schemastery/lib/index.mjs": "cfcbe46c7416bdb35ce891c252152bbf519e08199bede5930dd7cb880c65f1ef",
@@ -68,7 +70,8 @@
     "helper-bin/x86_64-pc-windows-gnu/superd-run.exe": "1372450238c5bda702b4529f4148aa79e80a255c3c125d1a6229afd4693e9d90",
     "helper-bin/x86_64-unknown-linux-musl/BUILT-VER": "8601d3c2ff79795c9657b02080afffe91c42775534dd6687c6dbdc0f4924db70",
     "helper-bin/x86_64-unknown-linux-musl/superd-run": "05b428657942abf22a0ad609433d5cab6b6182fe389851345459a0274b5a6533",
-    "plugin.d.ts": "6ec2c6b6a09425c1f2c30d975cdf86c77f0cb1d23590ef67d87dc78515a915c8",
-    "plugin.js": "605386387879837631730a74f461c69568126f829c7e9efe470003c24d5367c1"
+    "hub-pty-pump.mjs": "dfe0cb331cc585eb4d858fbb6d8f3ff22414f3ee55109c933df0fc14502aee5c",
+    "plugin.d.ts": "da9bfcbb1a0f37bd2994452ac4cfed284615e5cea45c05ff97569474a442e91f",
+    "plugin.js": "8dd1843f2c57097a1bbcfeddaf50193985bf25b942cc784ca501311d16aae7f3"
   }
 }

package/superd-hub/dist/agent-model-face.d.ts

@@ -0,0 +1,93 @@
+/**
+ * agent-model-face.ts — the 0.2.2+ `Agent.model` face for foreign-runtime
+ * bridges.
+ *
+ * dsh 0.2.2 made `model` a required `Agent` member: the Web UI's model switcher
+ * reaches every agent — native and foreign alike — through
+ * `session/selectModel` → `agent.model.select()` (session-controller
+ * commands.ts). The native `AgentModel` (dsh-agent model-selection.ts) records
+ * a `model/selection` session event durably and resolves `current()` as
+ * pending ?? lastUsed ?? live options.
+ *
+ * This module hands the foreign bridges (claude/codex/hermes/pi/agy/omp) the
+ * same semantics without mounting the projection registry:
+ *
+ *  - {@link recordedModelSelection} — the native `modelSelection` projection
+ *    fold, replayed as one pass over the session's events. A recorded
+ *    `model/selection` is the pending choice and survives non-matching
+ *    `request/header`s; a matching header retires it; `lastUsed` is the last
+ *    header's config. (The adapters that DO mount `sessionProjections` —
+ *    claude, codex — may keep reading the projection directly; both produce
+ *    the same answer.)
+ *  - {@link createAgentModelFace} — the face itself: `current()` resolves
+ *    pending → logged header → deployment default → agent options (each level
+ *    must name both halves), `select()` appends the same durable
+ *    `model/selection` event as the native face, deduped against the recorded
+ *    choice.
+ *
+ * Structural session face on the system-head pattern: the real (generic-typed)
+ * `Session` satisfies it without this package taking a dsh-agent dependency.
+ *
+ * @module superd-hub/agent-model-face
+ */
+/** A model selection: both route halves, with an optional explicit effort. */
+export interface ModelSelectionLike {
+    provider: string;
+    model: string;
+    reasoningEffort?: unknown;
+}
+/** The `Agent.model` shape (dsh-agent runtime-types `Model`), over the bridge's own selection type. */
+export interface BridgeModelFace<Sel extends ModelSelectionLike> {
+    current(): Readonly<Sel> | undefined;
+    select(selection: Readonly<Sel>): void;
+}
+/**
+ * The session slice the fold reads. Deliberately loose so the real
+ * (generic-typed) `Session` satisfies it; the events the fold inspects arrive
+ * as `unknown` data and are narrowed inside this module only.
+ */
+export interface ModelSessionFace {
+    snapshotEvents(): ReadonlyArray<{
+        type: string;
+        data: unknown;
+    }>;
+    requestHeader(): {
+        readonly config: {
+            readonly provider: string;
+            readonly model: string;
+        };
+    } | undefined;
+}
+/**
+ * The native `modelSelection` projection fold over one session's events.
+ * @param events - the session's full event snapshot (order is the log order).
+ * @returns the recorded choice — a pending selection, else the last request
+ * header's config — or `null` when the log names neither.
+ */
+export declare function recordedModelSelection(events: ReadonlyArray<{
+    type: string;
+    data: unknown;
+}>): ModelSelectionLike | null;
+/** Readers the face resolves through; each adapter wires its own sources. */
+export interface AgentModelFaceParts<Sel extends ModelSelectionLike> {
+    /** The session whose events and request header back the fold. */
+    session: ModelSessionFace;
+    /** The agent's live route options (the options fallback names both halves or neither). */
+    options: {
+        readonly provider?: string;
+        readonly model?: string;
+    };
+    /** Appends the durable `model/selection` event (the adapter's own typed append). */
+    appendSelection: (selection: Sel) => void;
+    /** Reads the deployment default (`ctx.agentDefaultModel`); absent when the service is not mounted. */
+    readDefault?: () => {
+        provider: string;
+        model: string;
+    } | undefined;
+}
+/**
+ * Build the `Agent.model` face for one foreign-runtime agent.
+ * @param parts - the session, options, typed append, and optional default reader.
+ * @returns the face; assign it to the agent's `model` member.
+ */
+export declare function createAgentModelFace<Sel extends ModelSelectionLike>(parts: AgentModelFaceParts<Sel>): BridgeModelFace<Sel>;

package/superd-hub/dist/agent-model-face.js

@@ -0,0 +1,113 @@
+/**
+ * agent-model-face.ts — the 0.2.2+ `Agent.model` face for foreign-runtime
+ * bridges.
+ *
+ * dsh 0.2.2 made `model` a required `Agent` member: the Web UI's model switcher
+ * reaches every agent — native and foreign alike — through
+ * `session/selectModel` → `agent.model.select()` (session-controller
+ * commands.ts). The native `AgentModel` (dsh-agent model-selection.ts) records
+ * a `model/selection` session event durably and resolves `current()` as
+ * pending ?? lastUsed ?? live options.
+ *
+ * This module hands the foreign bridges (claude/codex/hermes/pi/agy/omp) the
+ * same semantics without mounting the projection registry:
+ *
+ *  - {@link recordedModelSelection} — the native `modelSelection` projection
+ *    fold, replayed as one pass over the session's events. A recorded
+ *    `model/selection` is the pending choice and survives non-matching
+ *    `request/header`s; a matching header retires it; `lastUsed` is the last
+ *    header's config. (The adapters that DO mount `sessionProjections` —
+ *    claude, codex — may keep reading the projection directly; both produce
+ *    the same answer.)
+ *  - {@link createAgentModelFace} — the face itself: `current()` resolves
+ *    pending → logged header → deployment default → agent options (each level
+ *    must name both halves), `select()` appends the same durable
+ *    `model/selection` event as the native face, deduped against the recorded
+ *    choice.
+ *
+ * Structural session face on the system-head pattern: the real (generic-typed)
+ * `Session` satisfies it without this package taking a dsh-agent dependency.
+ *
+ * @module superd-hub/agent-model-face
+ */
+/** One recorded selection read structurally; incomplete routes answer `null`. */
+function selectionOf(value) {
+    if (typeof value !== 'object' || value === null)
+        return null;
+    const { provider, model } = value;
+    if (typeof provider !== 'string' || provider === '' || typeof model !== 'string' || model === '')
+        return null;
+    const reasoningEffort = value.reasoningEffort;
+    return {
+        provider,
+        model,
+        ...(typeof reasoningEffort === 'string' && reasoningEffort !== ''
+            ? { reasoningEffort }
+            : {}),
+    };
+}
+/** Route equality without the effort, and full equality with it (the fold's own rules). */
+function sameRoute(left, right) {
+    return left.provider === right.provider && left.model === right.model;
+}
+function sameSelection(left, right) {
+    return sameRoute(left, right) && left.reasoningEffort === right.reasoningEffort;
+}
+/**
+ * The native `modelSelection` projection fold over one session's events.
+ * @param events - the session's full event snapshot (order is the log order).
+ * @returns the recorded choice — a pending selection, else the last request
+ * header's config — or `null` when the log names neither.
+ */
+export function recordedModelSelection(events) {
+    let pending = null;
+    let lastUsed = null;
+    for (const event of events) {
+        if (event.type === 'model/selection') {
+            const selection = selectionOf(event.data);
+            if (selection !== null && !(pending !== null && sameSelection(pending, selection)))
+                pending = selection;
+        }
+        else if (event.type === 'request/header') {
+            const header = event.data;
+            const config = header === null || typeof header !== 'object' ? undefined : header.header?.config;
+            const selection = selectionOf(config);
+            if (selection !== null) {
+                lastUsed = selection;
+                if (pending !== null && sameRoute(pending, selection))
+                    pending = null;
+            }
+        }
+    }
+    return pending ?? lastUsed;
+}
+/**
+ * Build the `Agent.model` face for one foreign-runtime agent.
+ * @param parts - the session, options, typed append, and optional default reader.
+ * @returns the face; assign it to the agent's `model` member.
+ */
+export function createAgentModelFace(parts) {
+    const recorded = () => recordedModelSelection(parts.session.snapshotEvents());
+    const current = () => {
+        const fold = recorded();
+        if (fold !== null)
+            return { ...fold };
+        const preferred = parts.readDefault?.();
+        if (preferred !== undefined && preferred.provider !== '' && preferred.model !== '') {
+            return { provider: preferred.provider, model: preferred.model };
+        }
+        const { provider, model } = parts.options;
+        return provider !== undefined && provider !== '' && model !== undefined && model !== ''
+            ? { provider, model }
+            : undefined;
+    };
+    return {
+        current,
+        select(selection) {
+            const fold = recorded();
+            if (fold !== null && sameSelection(fold, selection))
+                return;
+            parts.appendSelection({ ...selection });
+        },
+    };
+}

package/superd-hub/dist/exec.d.ts

@@ -27,8 +27,9 @@ export interface OneShotExecResult {
      */
     outcome: 'exited' | 'signaled' | 'timeout' | 'spawn-error';
 }
-/** Per-stream returned tail: at most 30,000 bytes, beginning on a UTF8 boundary. */
-export declare const EXEC_TAIL_WINDOW = 30000;
+/** 0.3.2-e: the 30K returned-tail window is REMOVED — output returns in full up to
+ * retention and model-context sizing is the native agent runtime's job (spill policy
+ * or its foreign equivalent). Retention below stays the memory-safety bound. */
 /** Hub oneshot per-stream raw-byte retention: 4MiB, distinct from native/PTy UTF16 caps. */
 export declare const EXEC_RING_HARD_CAP: number;
 export declare const EXEC_DEFAULT_TIMEOUT_SEC = 120;

package/superd-hub/dist/exec.js

@@ -5,7 +5,7 @@
 // tool); it never decides policy — auth is the shared /api fence's, and the
 // initiator-side per-machine knob lives on the caller's registry row.
 //
-// Output discipline (better-dash lesson, spec §8.1): return the LAST 30k of
+// Output discipline (0.3.2-e): return output IN FULL up to the 4MiB retention ring;
 // each stream, retain at most 4M per stream while running (the tail of a
 // capped ring is still the tail of the stream), mark `truncated` whenever a
 // stream's total exceeded what is returned. Kill discipline: SIGTERM to the
@@ -15,8 +15,9 @@ import { spawn } from 'node:child_process';
 import { ByteTailRing } from '../../remote/plugin.js';
 /** Shared-channel Fetch route path this API owns. */
 export const EXEC_API_BASE = '/api/superd/exec';
-/** Per-stream returned tail: at most 30,000 bytes, beginning on a UTF8 boundary. */
-export const EXEC_TAIL_WINDOW = 30_000;
+/** 0.3.2-e: the 30K returned-tail window is REMOVED — output returns in full up to
+ * retention and model-context sizing is the native agent runtime's job (spill policy
+ * or its foreign equivalent). Retention below stays the memory-safety bound. */
 /** Hub oneshot per-stream raw-byte retention: 4MiB, distinct from native/PTy UTF16 caps. */
 export const EXEC_RING_HARD_CAP = 4 * 1024 * 1024;
 export const EXEC_DEFAULT_TIMEOUT_SEC = 120;
@@ -109,7 +110,7 @@ export async function runOneShotExec(input, log) {
     clearTimeout(killTimer);
     if (graceTimer !== undefined)
         clearTimeout(graceTimer);
-    const outTail = stdout.tail(EXEC_TAIL_WINDOW), errTail = stderr.tail(EXEC_TAIL_WINDOW);
+    const outTail = stdout.tail(), errTail = stderr.tail();
     const outText = outTail.toString('utf8');
     const errText = spawnError !== undefined
         ? `exec: spawn failed — ${spawnError}${input.cwd === undefined ? '' : ` (cwd: ${input.cwd})`}`
@@ -127,7 +128,7 @@ export async function runOneShotExec(input, log) {
         stdout: outText,
         stderr: errText,
         durationMs: Date.now() - started,
-        truncated: stdout.total > outTail.length || stderr.total > errTail.length,
+        truncated: stdout.total > outTail.length || stderr.total > errTail.length, // 0.3.2-e: true 仅当 retention 驱逐（>4MiB）
         outputStats: { stdout: stdout.stats(outTail.length), stderr: stderr.stats(errTail.length) },
         timedOut,
         outcome,

package/superd-hub/dist/hub-tool.d.ts

@@ -19,7 +19,7 @@ export interface HubToolExecFace {
     pty(sessionKey: string, machine: string, cmd: string, opts?: {
         timeoutSec?: number;
         stdin?: string;
-    }): Promise<import('./exec-pty-session.js').PtyDispatchResult>;
+    }): Promise<import('../../remote/plugin.js').PtyDispatchResult>;
 }
 import type { A2aAddress, A2aInitiator, A2aService } from './a2a-service.js';
 /** The service face the tool consumes (structural subset of T2/T3's A2aService). */

package/superd-hub/dist/hub-tool.js

@@ -36,8 +36,8 @@
  *   - `exec` is the P4 placeholder leg: `"not yet implemented: exec (P4)"`.
  */
 import { defineTool } from '@deepseek-ai/dsh-tools';
-import { parseOneShotExecBody, EXEC_TAIL_WINDOW } from './exec.js';
-import { tailWindow } from './exec-pty-framing.js';
+import { parseOneShotExecBody } from './exec.js';
+import { disclose } from '../../remote/plugin.js';
 // F2 (0.1.7-n, PC 0.1.7-m first-person): the wire/registry sentinel stays
 // '[undefined]', but the DISPLAY surface must not show it to a human — D17
 // already sanctions display-layer beautification.
@@ -190,7 +190,7 @@ const DESCRIPTION = 'SuperD Hub — agent-to-agent messaging across the Super D
     '  {action:"send", agent?, conversationId?, title?, message, delivery?} → open-or-resume: omit conversationId to OPEN (then agent = the recipient, REQUIRED; title optional; message is the first turn); pass conversationId to RESUME (agent optional — the hub derives the route; a wrong agent is refused). Receipt {outcome: delivered|accepted|failed, messageId, conversationId, sessionId, created, error?, note?}: `delivered` = end-to-end complete; `accepted` = the hub took it and the SAME in-flight request keeps running (its `delivered`/`undelivered` outcome arrives as a notice — do not resend); `failed` = immediate rejection.\n' +
     '  {action:"read"} → sweep messages buffered for this session while it was not live.\n' +
     '  {action:"stop", conversationId, agent?, scope?} → cancel the conversation\'s ACTIVE turn (the session owner is derived from the conversation id; agent is optional). `stopped:true` means this call cancelled a live turn; a turn that finished on its own is IDLE, never `stopped` — so stop answers stopped:false with a note when nothing was running.\n' +
-    '  {action:"exec", cmd, machine?, cwd?, stdin?, timeoutSec?, mode?} → run one shell command on a remote machine (machine required; self/local execution disabled unless localExec is explicitly enabled). mode "oneshot" (default): {exit, stdout (last 30k), stderr, durationMs, truncated, timedOut, outcome}; cwd sets its working directory. String stdin is piped and closed in oneshot; in PTY it is written immediately after cmd (REPL input, not script mode). Hub oneshot hard retention is 4MiB bytes per stream, PTY is 4,000,000 UTF-16 code units. outputStats reports real total/retained/dropped/returned and units; discarded head cannot be recovered by restarting. mode "pty": a PERSISTENT shell per (your session, machine) — the shell OWNS its cwd and env and they SURVIVE across dispatches (cd once inside the command, then keep working); {output (tail 30k), exit, cwd, timedOut, reconnected, durationMs}. cwd is oneshot-only: passing it with mode "pty" is refused (use `cd <dir> && …` inside the command). Prefer oneshot for independent commands; pty when shell state matters.\n' +
+    '  {action:"exec", cmd, machine?, cwd?, stdin?, timeoutSec?, mode?} → run one shell command on a remote machine (machine required; self/local execution disabled unless localExec is explicitly enabled). mode "oneshot" (default): {exit, stdout (full up to 4MiB retention; beyond it the retained tail plus outputStats), stderr, durationMs, truncated (retention eviction only), timedOut, outcome}; cwd sets its working directory. String stdin is piped and closed in oneshot; in PTY it is written immediately after cmd (REPL input, not script mode). Hub oneshot hard retention is 4MiB bytes per stream, PTY is 4,000,000 UTF-16 code units. outputStats reports real total/retained/dropped/returned and units; discarded head cannot be recovered by restarting. mode "pty": a PERSISTENT shell per (your session, machine) — the shell OWNS its cwd and env and they SURVIVE across dispatches (cd once inside the command, then keep working); {output (full up to 4M UTF-16 units; beyond it the retained tail plus outputStats), exit, cwd, timedOut, reconnected, durationMs}. cwd is oneshot-only: passing it with mode "pty" is refused (use `cd <dir> && …` inside the command). Prefer oneshot for independent commands; pty when shell state matters.\n' +
     'Addresses are "<m4>-<a6>" (machine-agent); call agents first to list valid ids. delivery: "queue" (default) is injected into the peer\'s session as a waking turn — it never interrupts an active turn, it queues behind it; "steer" submits steering for the peer\'s nearest step boundary — use it only when urgency demands. NEVER poll for a reply: the peer\'s reply arrives in this conversation as a new message WHEN THE PEER SENDS one (peers that never use the channel get their last output at turn end delivered as their reply instead, form=transcript); a turn that ends with no channel artifact yields one notice whose reason= distinguishes peer-silent (ended, said nothing) / peer-error (stream died or turn aborted) / stopped-by-initiator (you stopped it). read only sweeps what was buffered while this session was down. stop is a hard stop of the peer\'s active turn (the UI stop button); scope "session" degrades to turn-only — no session-close exists upstream — and the conversation stays resumable: send again to resume it. agent_status reads a cache refreshed by the 5-minute sweep (collectedAt says when); the window is alive-first, ≤5 rows, newest first, and not being in it implies nothing; a `note` says why when the window has no collection behind it (the last collection failed, or none has happened yet). MESSAGING HAS NO STATUS QUERY: to check whether a peer is idle or running, call agent_status (a 5-minute cache — never a delivery receipt); if that is not enough and you cannot wait, send another message.';
 /**
  * Build the one SuperD Hub tool.
@@ -284,8 +284,8 @@ export function createSuperdHubTool(deps) {
                     count: { type: 'integer' },
                     messages: { type: 'json', description: 'read sweep: buffered messages with from as "<m4>-<a6>"' },
                     exit: { type: 'json', description: 'exec: the command exit code (null when killed by timeout/signal)' },
-                    stdout: { type: 'json', description: 'exec: the last 30k of stdout' },
-                    stderr: { type: 'json', description: 'exec: the last 30k of stderr' },
+                    stdout: { type: 'json', description: 'exec: full stdout up to retention (4MiB bytes; PTY 4,000,000 UTF-16 units)' },
+                    stderr: { type: 'json', description: 'exec: full stderr up to retention (4MiB bytes)' },
                     durationMs: { type: 'integer', description: 'exec: wall-clock duration' },
                     outputStats: { type: 'json', description: 'exec per-stream counters with explicit bytes/utf16 units; total, retained, dropped head, returned payload (excludes banners), retentionLimit. Absent on older peers: exact metrics unavailable.' },
                     truncated: { type: 'boolean', description: 'exec: a stream\'s total output exceeded the returned tail window' },
@@ -422,7 +422,7 @@ export function createSuperdHubTool(deps) {
                         const machine = args.machine ?? deps.exec.selfM4();
                         try {
                             const r = await deps.exec.pty(sessionKey, machine, args.cmd, { ...(args.timeoutSec === undefined ? {} : { timeoutSec: args.timeoutSec }), ...(args.stdin === undefined ? {} : { stdin: args.stdin }) });
-                            const out = tailWindow(r.output, EXEC_TAIL_WINDOW, r.outputStats?.stdout);
+                            const out = disclose(r.output, r.outputStats?.stdout); // 0.3.2-e: 全量返回，仅 retention 驱逐打 banner
                             return {
                                 action,
                                 mode: 'pty',

package/superd-hub/dist/index.d.ts

@@ -36,6 +36,7 @@ export { createOwnershipIndex, type OwnershipIndex, type OwnershipRow } from './
 export { registerHostMount, takeHostMount, listHostMounts, noteWorldServer, worldServerOf, type HostMount } from './world-host.js';
 export { worldMountPatches, superdTrustedHosts, WORLD_WAVE1_DISABLED_ROWS, WORLD_WAVE2_DISABLED_ROWS, WORLD_MOUNT_PLUGIN, WORLD_MOUNT_ROW_ID, WORLD_HUB_PLUGIN, WORLD_HUB_ROW_ID, type WorldPatchLayer, } from './world-mount.js';
 export { withSystemHead, type HeadAwareSessionFace, type HeadPlaceholder, type WithSystemHead } from './system-head.js';
+export { createAgentModelFace, recordedModelSelection, type AgentModelFaceParts, type BridgeModelFace, type ModelSelectionLike, type ModelSessionFace, } from './agent-model-face.js';
 export { default as worldApply, name as worldPluginName, type Config as WorldEntryConfig } from './world-entry.js';
 export { default as joinApply, name as worldJoinPluginName, type Config as WorldJoinConfig } from './world-join.js';
 export { createA2aService, A2A_MESSAGE_TEMPLATE, A2A_UNTITLED, A2A_BUFFER_MAX, A2A_NO_SESSION_CLOSE_REASON, A2A_NO_TURN_ACTIVE_NOTE, renderA2aEnvelope, loadConversations, saveConversations, shortIdFor, isDegenerateShortId, migrateConversations, type A2aService, subscribeSessionCompletion, sessionRpc, turnLivenessOf, addressErrorBody, type A2aSessionSource, type A2aGateway, type A2aAddress, type A2aInitiator, type A2aDelivery, type A2aSendRequest, type A2aReceipt, type A2aReceiptOutcome, type A2aReceiptError, type A2aConversationRef, type A2aCompletion, type A2aCompletionCb, type A2aErrorCb, type A2aSubscribeOptions, type A2aStopScope, type A2aStopResult, type A2aBufferedMessage, type A2aBufferInput, type ConversationRow, type ConversationsFile, } from './a2a-service.js';

package/superd-hub/dist/index.js

@@ -36,6 +36,7 @@ export { createOwnershipIndex } from './ownership.js';
 export { registerHostMount, takeHostMount, listHostMounts, noteWorldServer, worldServerOf } from './world-host.js';
 export { worldMountPatches, superdTrustedHosts, WORLD_WAVE1_DISABLED_ROWS, WORLD_WAVE2_DISABLED_ROWS, WORLD_MOUNT_PLUGIN, WORLD_MOUNT_ROW_ID, WORLD_HUB_PLUGIN, WORLD_HUB_ROW_ID, } from './world-mount.js';
 export { withSystemHead } from './system-head.js';
+export { createAgentModelFace, recordedModelSelection, } from './agent-model-face.js';
 export { default as worldApply, name as worldPluginName } from './world-entry.js';
 export { default as joinApply, name as worldJoinPluginName } from './world-join.js';
 export { createA2aService, A2A_MESSAGE_TEMPLATE, A2A_UNTITLED, A2A_BUFFER_MAX, A2A_NO_SESSION_CLOSE_REASON, A2A_NO_TURN_ACTIVE_NOTE, renderA2aEnvelope, loadConversations, saveConversations, shortIdFor, isDegenerateShortId, migrateConversations, 

package/superd-hub/dist/remote-provider.js

@@ -1,13 +1,28 @@
 import { createRemoteFileEndpoint } from './remote-file-rpc.js';
 import { startRemoteProcess } from './remote-job-client.js';
+/** Hub transport implementation. HTTP/WS/pool mechanics stay in the existing exec modules. */
+import { PtySession, buildHubPtyArgv, hubPtyAssets } from '../../remote/plugin.js';
+// ws 模块绝对路径：在 superd-hub 上下文解析（分叉的 proven 链——闭包/泵子树解析不到，
+// 0.3.2-c 定稿：按名解析只在 transport 侧做一次，经 ptyEndpoint/argv 下传）。
+const wsModulePath = () => {
+    try {
+        return createRequire(import.meta.url).resolve('ws');
+    }
+    catch (error) {
+        throw new Error(`[E_HUB_PTY_SETUP] superd-hub: the ws module could not be resolved from the hub tree — hub PTY spawns a local pump child that opens the peer WebSocket with ws; ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+import { randomUUID } from 'node:crypto';
+import { createRequire } from 'node:module';
 import { ensureSelf, listRemotes } from './machines.js';
 import { cookieOf } from './mesh-link.js';
 import { runOneShotExec, postOneShotExec, parseOneShotExecBody } from './exec.js';
-import { PtyPool } from './exec-pty-session.js';
-import { LocalScriptChannel, WsPtyChannel } from './exec-pty-channel.js';
 import { PTY_EXEC_PATH } from './exec-pty-rpc.js';
 /** One shared initiator implementation for legacy tool and the optional remote service. */
 export function createHubExec(home, log) {
+    // 0.3.2-c（Q2）：分叉 exec-pty-session 已删——本 face 与 remote 工具共用 canonical
+    // PtySession（闭包导出）。per-owner 每机器一个持久 shell（A2A 语义保持：cwd/env 跨调用存活；
+    // dead → dispatch 内部重连 = 旧 markDead/重启；disposed → 下次调用重建）。
     const owners = new Map();
     let closed = false;
     const assertOpen = () => { if (closed)
@@ -21,6 +36,16 @@ export function createHubExec(home, log) {
             throw new Error(`exec is disabled for machine "${machine}" on this registry row (enabled/execEnabled=false)`);
         return row;
     };
+    const genCommandId = () => `remote-${randomUUID().replace(/-/g, '').slice(0, 16)}`;
+    const createPtySession = (machine, row, owner) => new PtySession({
+        key: `${owner}|hub-pty:${machine}`,
+        argv: row === undefined
+            ? ['script', '-qfec', 'bash', '/dev/null']
+            : buildHubPtyArgv({ url: `${row.origin.replace(/^http/, 'ws')}${PTY_EXEC_PATH}`, cookie: cookieOf(row.id, home) ?? '', wsPath: wsModulePath() }, hubPtyAssets()),
+        id: `p-${randomUUID().slice(0, 8)}`,
+        connection: row === undefined ? 'local' : `hub:${machine}`,
+        idleTtlSec: 900,
+    });
     const face = {
         selfM4: () => ensureSelf(home, 'local').id,
         run: input => { assertOpen(); return runOneShotExec(input, log); },
@@ -37,14 +62,34 @@ export function createHubExec(home, log) {
             const row = machine === face.selfM4() ? undefined : remote(machine);
             let pool = owners.get(owner);
             if (!pool)
-                owners.set(owner, pool = new PtyPool({ idleTtlSec: 600 }));
-            const key = `${machine}|${row?.origin ?? 'local'}`;
-            const session = pool.getOrCreate(key, () => row
-                ? new WsPtyChannel(`${row.origin.replace(/^http/, 'ws')}${PTY_EXEC_PATH}`, { cookie: cookieOf(row.id, home) })
-                : new LocalScriptChannel());
-            const result = await session.dispatch(cmd, opts);
-            log?.('info', 'exec.pty.run', { machine, cmd: cmd.slice(0, 120), exit: result.exit ?? 'none', durationMs: result.durationMs });
-            return result;
+                owners.set(owner, pool = new Map());
+            const attempt = async (session) => {
+                const r = await session.dispatch(cmd, { stdin: opts.stdin, timeoutSec: opts.timeoutSec, commandId: genCommandId() });
+                // P4 handoff（超时不杀）对 A2A 面保持旧语义：显式两段 ^C 后等帧结算——分叉自动中断的等价物。
+                if (r.running === true && r.job !== undefined) {
+                    r.job.interrupt();
+                    const settled = await r.job.done;
+                    return { output: settled.output, outputStats: settled.outputStats, exit: settled.exit, cwd: settled.cwd, timedOut: true, reconnected: r.reconnected, durationMs: r.durationMs, commandId: r.commandId };
+                }
+                return r;
+            };
+            const settle = (result) => {
+                log?.('info', 'exec.pty.run', { machine, cmd: cmd.slice(0, 120), exit: result.exit ?? 'none', durationMs: result.durationMs });
+                return result;
+            };
+            const existing = pool.get(machine);
+            if (existing !== undefined && existing.sessionState !== 'disposed')
+                return settle(await attempt(existing));
+            const session = createPtySession(machine, row, owner);
+            pool.set(machine, session);
+            try {
+                return settle(await attempt(session));
+            }
+            catch (err) {
+                if (session.sessionState === 'disposed' && pool.get(machine) === session)
+                    pool.delete(machine); // init 失败/auto-dispose 不留死项
+                throw err;
+            }
         },
     };
     return {
@@ -52,12 +97,11 @@ export function createHubExec(home, log) {
         async releaseOwner(owner) {
             const pool = owners.get(owner);
             if (pool) {
-                await pool.disposeAll();
-                if (owners.get(owner) === pool)
-                    owners.delete(owner);
+                await Promise.all([...pool.values()].map(s => s.dispose()));
+                owners.delete(owner);
             }
         },
-        async dispose() { closed = true; await Promise.all([...owners.values()].map(p => p.disposeAll())); owners.clear(); },
+        async dispose() { closed = true; await Promise.all([...owners.values()].flatMap(p => [...p.values()].map(s => s.dispose()))); owners.clear(); },
     };
 }
 export function createHubRemoteTransport(home, log) {
@@ -67,25 +111,10 @@ export function createHubRemoteTransport(home, log) {
     const fileAbort = new AbortController();
     const files = new Set();
     const processes = new Map();
-    const pending = new Map();
     const requireRemote = (machine) => {
         if (!machine || machine === exec.face.selfM4())
             throw new Error('Select a remote machine from the Hub roster; local execution is not available through remote');
     };
-    const track = async (owner, work) => {
-        let set = pending.get(owner);
-        if (!set)
-            pending.set(owner, set = new Set());
-        set.add(work);
-        try {
-            return await work;
-        }
-        finally {
-            set.delete(work);
-            if (!set.size)
-                pending.delete(owner);
-        }
-    };
     return {
         protocol: 1,
         listTargets: () => listRemotes(home).filter(r => r.id !== exec.face.selfM4()).map(r => ({ id: r.id, label: r.name, execEnabled: r.enabled && r.execEnabled !== false })),
@@ -110,12 +139,17 @@ export function createHubRemoteTransport(home, log) {
                 processes.delete(owner); });
             return process;
         },
-        async pty(machine, cmd, owner, options) {
+        ptyEndpoint(machine) {
             requireRemote(machine);
-            if (closed || released.has(owner))
-                throw new Error('Hub remote owner disposed');
-            const { output, ...result } = await track(owner, exec.face.pty(owner, machine, cmd, { timeoutSec: options.timeout, stdin: options.stdin }));
-            return { mode: 'pty', target: `hub:${machine}`, ...result, stdout: output };
+            if (closed)
+                throw new Error('Hub remote provider disposed');
+            const row = listRemotes(home).find(r => r.id === machine);
+            if (!row)
+                throw new Error(`unknown machine "${machine}"`);
+            if (!row.enabled || row.execEnabled === false)
+                throw new Error(`exec is disabled for machine "${machine}"`);
+            // P10：创建与每次 dispatch 都重取本端点（driver 侧调用）——pairing 复用不豁免。
+            return { url: `${row.origin.replace(/^http/, 'ws')}${PTY_EXEC_PATH}`, cookie: cookieOf(row.id, home) ?? '', wsPath: wsModulePath() };
         },
         fileEndpoint(machine) {
             requireRemote(machine);
@@ -135,7 +169,7 @@ export function createHubRemoteTransport(home, log) {
             const owned = [...processes.get(owner) ?? []];
             for (const process of owned)
                 process.cancel('owner released');
-            await Promise.all([exec.releaseOwner(owner), ...owned.map(p => p.done), ...pending.get(owner) ?? []]);
+            await Promise.all([exec.releaseOwner(owner), ...owned.map(p => p.done)]);
         },
         async dispose() {
             closed = true;
@@ -145,7 +179,7 @@ export function createHubRemoteTransport(home, log) {
             for (const process of owned)
                 process.cancel('provider disposed');
             await exec.dispose();
-            await Promise.allSettled([...owned.map(p => p.done), ...[...pending.values()].flatMap(s => [...s])]);
+            await Promise.allSettled([...owned.map(p => p.done)]);
         },
     };
 }

package/superd-hub/dist/world-entry.js

@@ -1,3 +1,4 @@
+import { modelSelectionProjectionDefinition } from '@deepseek-ai/dsh-agent';
 import { noteWorldServer, publishWorldFetch, takeHostMount } from './world-host.js';
 import { WorldWebServer } from './world-web-server.js';
 import { superdTrustedHosts } from './world-mount.js';
@@ -43,6 +44,35 @@ export function apply(ctx, config) {
             dropWorldFetch = publishWorldFetch(key, connection.createSharedFetchHandler('/api'), mount);
         }
     });
+    // 0.2.2: register the `modelSelection` projection in THIS world's registry.
+    // Upstream's only registrant is the agent-loop row (agent-loop/src:334),
+    // which wave-1 minimization keeps out of world trees — without it the
+    // native model seat's projection frame never resolves and the trigger
+    // label stays "loading models…" forever (the catalog and selectModel RPC
+    // take different paths, which is why they keep working). The definition is
+    // a pure event fold (`model/selection` + `request/header`), no loop
+    // machinery; register() is ref-counted and duplicate-tolerant, so a future
+    // tree that also mounts agent-loop shares the registration cleanly.
+    ctx.inject(['sessionProjections'], (projCtx) => {
+        const projections = projCtx.get('sessionProjections');
+        if (projections === undefined)
+            return;
+        let disposed = false;
+        let handle;
+        void projections.register(modelSelectionProjectionDefinition).then((registered) => {
+            if (disposed) {
+                void registered.dispose();
+                return;
+            }
+            handle = registered;
+        }, (error) => {
+            ctx.logger?.warn?.(`superd-world-mount: modelSelection projection registration failed: ${String(error)}`);
+        });
+        return () => {
+            disposed = true;
+            void handle?.dispose();
+        };
+    });
     ctx.effect(() => () => {
         dropWorldFetch?.();
     }, 'superd-world-mount: virtual webServer');