@byok-sdk/client 0.10.2 → 0.11.0

package/dist/daemon/control-protocol.d.ts

@@ -422,3 +422,41 @@ export interface ShutdownParams {
     reason?: ShutdownReason;
 }
 export declare function parseShutdownParams(value: unknown): ShutdownParams;
+export interface TeamWorkspaceCreateParams {
+    workspaceId: string;
+    members: string[];
+    limits: {
+        maxMembers: number;
+        maxMessages: number;
+        maxBytes: number;
+    };
+}
+export interface TeamWorkspaceJoinParams {
+    workspaceId: string;
+    memberId: string;
+    ttlMs?: number;
+}
+export interface TeamContextParams {
+    context: string;
+}
+export interface TeamMessagePostParams extends TeamContextParams {
+    body: string;
+    contentType?: string;
+}
+export interface TeamMessageReadParams extends TeamContextParams {
+    afterSeq?: number;
+}
+export interface TeamMessageAckParams extends TeamContextParams {
+    throughSeq: number;
+}
+export interface TeamMessageInspectParams {
+    workspaceId: string;
+    afterSeq?: number;
+}
+export declare function parseTeamWorkspaceCreateParams(value: unknown): TeamWorkspaceCreateParams | undefined;
+export declare function parseTeamWorkspaceJoinParams(value: unknown): TeamWorkspaceJoinParams | undefined;
+export declare function parseTeamContextParams(value: unknown): TeamContextParams | undefined;
+export declare function parseTeamMessagePostParams(value: unknown): TeamMessagePostParams | undefined;
+export declare function parseTeamMessageReadParams(value: unknown): TeamMessageReadParams | undefined;
+export declare function parseTeamMessageAckParams(value: unknown): TeamMessageAckParams | undefined;
+export declare function parseTeamMessageInspectParams(value: unknown): TeamMessageInspectParams | undefined;

package/dist/daemon/create-daemon.d.ts

@@ -18,6 +18,7 @@ import { type ProgressBatcherOptions } from './progress-batcher';
 import { type AgentEgressReliableAppendResult } from './agent-egress-controller';
 import { type AgentEgressStatus } from './agent-egress-policy';
 import { type AgentEgressSanitizer } from './agent-egress-sanitizer';
+import { type SdkHelperHostConfig } from '../sdk-reserved-helper-host';
 import { type AgentMemoryHostedProjection } from './agent-memory';
 import type { AgentMemoryFilesystemHelperConfig } from './agent-memory-filesystem';
 import { type AgentContentReadRoot } from './agent-content-read';
@@ -118,6 +119,12 @@ export interface DaemonConfig {
      * 2 on macOS. Windows remains fail-closed pending its native race proof.
      */
     agentMemoryFilesystem?: AgentMemoryFilesystemHelperConfig;
+    /**
+     * Explicit composition for SDK-reserved MCP helpers when this daemon is
+     * embedded in a single-file/SEA product executable. The product entrypoint
+     * must also call `runSdkReservedHelperCommand()` before its own CLI parser.
+     */
+    sdkHelperHost?: SdkHelperHostConfig;
     /**
      * Refuse legacy task offers locally. This is an additive capability only
      * after the SDK-owned Agent home has passed construction-time preflight.

package/dist/daemon/mcp-tools-probe.d.ts

@@ -0,0 +1,105 @@
+import type { McpStdioServerConfig } from '../types';
+export declare const MCP_TOOLS_PROBE_TIMEOUT_MS = 10000;
+/**
+ * Hard cap on the bytes one probed server may write to stdout before its
+ * `tools/list` answer is complete. The probe reads a fixed two-message
+ * handshake, so a server still streaming past this is either broken or
+ * hostile; either way it must not be able to grow the daemon's heap while an
+ * offer waits on admission. Exceeding it is a probe failure, never a partial
+ * observation.
+ */
+export declare const MCP_TOOLS_PROBE_MAX_STDOUT_BYTES = 1048576;
+/**
+ * The single admission budget for observing ALL of one task's projected
+ * toolset servers, however many there are.
+ *
+ * `handleOffer` runs inside its connection's FIFO, so anything it awaits also
+ * delays the `task.cancel` / `task.approve` / next-offer envelopes queued
+ * behind it. Probing a toolset's servers one after another would multiply the
+ * per-server timeout by the server count — a device configured to the current
+ * ceiling (16 toolsets × 16 servers) could hold the control channel for
+ * minutes on a single unresponsive command. The runner therefore starts every
+ * probe at once and gives each one this same deadline, so total admission
+ * latency is bounded by one timeout regardless of server count, and each probe
+ * still kills its own child when the deadline expires.
+ */
+export declare const MCP_TOOLSET_PROBE_ADMISSION_TIMEOUT_MS = 10000;
+/**
+ * Tool names an adapter is allowed to pre-grant must be OBSERVED, never
+ * configured: the daemon's own `mcpToolsets` config carries `command`/`args`
+ * only (see `toolset-registry.ts`), so the single authority for "which tools
+ * does this server actually expose" is the server's own `tools/list` answer.
+ *
+ * A name that survives this filter is about to be interpolated into runtime
+ * CLI authority — `--allowedTools mcp__<server>__<tool>` for claude, and
+ * `mcp_servers.<server>.tools.<tool>.approval_mode` for codex. A comma, a
+ * dot, a quote, or whitespace in a tool name would forge additional grants or
+ * a different config key out of one legitimate one.
+ *
+ * A server that reports ANY name outside this shape fails the whole probe —
+ * the observation is rejected, and the task is declined permanently rather
+ * than partially granted. Granting the well-formed subset and silently
+ * dropping the rest would hand the model a toolset it can only half call, and
+ * would let one bad name ride along with good ones; only observed, validated
+ * names are ever granted, and a list that cannot be validated in full yields
+ * no grant at all. The shape is deliberately narrower than MCP's own
+ * (unbounded) name rule: the two real servers this SDK ships and every toolset
+ * server observed so far satisfy it, and a legitimate server that does not can
+ * still be listed and called by a runtime that grants tools itself — it simply
+ * cannot be pre-granted here, and this SDK will not admit a task for it.
+ */
+export declare const GRANTABLE_TOOL_NAME: RegExp;
+/**
+ * The same rule for the SERVER half of the identifier, enforced at grant
+ * resolution (`../adapters/mcp-tool-grants.ts`). A projected server name is
+ * interpolated into `mcp__<server>__<tool>` for claude and into the flat TOML
+ * key `mcp_servers.<server>.tools.<tool>.approval_mode` for codex: a `.` would
+ * split that key into a different table, and a quote, comma, or space would
+ * forge a second grant out of one. `toolset-registry.ts` already validates
+ * configured server names, so this is the second, local gate that keeps the
+ * grant surface honest for a server that reached an adapter some other way.
+ */
+export declare const GRANTABLE_MCP_SERVER_NAME: RegExp;
+/**
+ * A probe failure caused by the server's own ANSWER rather than by its
+ * environment — an ungrantable tool name, a malformed tool entry, or an
+ * oversized stream. Retrying cannot change it: the same configured command
+ * reports the same names next time. Callers use this to decline the task
+ * permanently instead of re-offering it forever (see `task-runner.ts`).
+ */
+export declare class McpToolsProbeAuthorityError extends Error {
+    constructor(message: string);
+}
+export interface McpToolsProbeOptions {
+    /** Prefix used in every error message, so a failure names the thing that failed. */
+    label?: string;
+    timeoutMs?: number;
+    /**
+     * The exact base environment the RUNTIME child of this task receives
+     * (`buildRuntimeEnv`, `./environment.ts`) — never `process.env`. The probe
+     * spawns a host-configured command, so it must not become the one place the
+     * daemon's own ambient credentials (an `AWS_SECRET_ACCESS_KEY` or
+     * `DATABASE_URL` set for the daemon's own deployment, this SDK's own
+     * `BYOK_*` control-plane variables) reach a server the real runtime path
+     * would have filtered out. Required, deliberately: a caller that forgets it
+     * fails to compile rather than silently reinstating the blanket passthrough.
+     */
+    env: Readonly<Record<string, string>>;
+    /**
+     * Working directory for the probed child — the same directory the runtime
+     * CLI is spawned in, so a server resolving relative paths sees what it will
+     * see for real. Omitted only when no such directory is resolved before
+     * admission.
+     */
+    cwd?: string;
+}
+/**
+ * Start the exact configured stdio MCP server, complete an
+ * `initialize` + `tools/list` handshake, and return the reported tool names.
+ * No `tools/call` is ever sent, so an authenticated task binding stays unused
+ * until the real runtime invokes it.
+ *
+ * The child is always killed before this resolves — the probe proves the
+ * server can start and enumerate its tools; the runtime spawns its own copy.
+ */
+export declare function probeMcpServerTools(server: Readonly<McpStdioServerConfig>, options: McpToolsProbeOptions): Promise<readonly string[]>;

package/dist/daemon/resolve-agent-memory-mcp-bin.d.ts

@@ -1,6 +1,7 @@
+import { type SdkHelperHostConfig } from '../sdk-reserved-helper-host';
 export interface ResolvedAgentMemoryMcpBin {
     readonly command: string;
     readonly args: readonly string[];
 }
 /** Resolve the SDK-owned stdio Agent-memory MCP helper shipped beside the client bundle. */
-export declare function resolveAgentMemoryMcpBin(externalHelperConfigured?: boolean): ResolvedAgentMemoryMcpBin | undefined;
+export declare function resolveAgentMemoryMcpBin(externalHelperConfigured?: boolean, host?: SdkHelperHostConfig): ResolvedAgentMemoryMcpBin | undefined;

package/dist/daemon/resolve-agent-message-mcp-bin.d.ts

@@ -1,6 +1,7 @@
+import { type SdkHelperHostConfig } from '../sdk-reserved-helper-host';
 export interface ResolvedAgentMessageMcpBin {
     readonly command: string;
     readonly args: readonly string[];
 }
 /** Resolve the SDK-owned stdio MCP helper shipped beside the client bundle. */
-export declare function resolveAgentMessageMcpBin(): ResolvedAgentMessageMcpBin;
+export declare function resolveAgentMessageMcpBin(host?: SdkHelperHostConfig): ResolvedAgentMessageMcpBin;

package/dist/daemon/task-runner.d.ts

@@ -1,5 +1,5 @@
 import { type AgentMessageContentType, type AgentEgressPolicy, type Envelope, type PermissionPolicy, type RuntimeId, type TerminalProjectionSelection, type TaskOfferPayload, type TaskOfferForAgentPayload, type TaskOfferForAgentWithEgressPayload, type TaskOfferForAgentWithEgressFreshPayload, type TaskOfferWithToolsetsPayload } from '@byok-sdk/protocol';
-import { type McpToolsetConfig, type RuntimeAdapter } from '../types';
+import { type McpStdioServerConfig, type McpToolsetConfig, type RuntimeAdapter } from '../types';
 import { AgentHomeManager, type AgentRef } from '../agent-home';
 import { AgentSessionHandoffStore, type AgentTerminalCause } from './agent-session-handoff-store';
 import { type RuntimeDisposalStage } from '../runtime-failure';
@@ -12,6 +12,7 @@ import type { SessionWorkspaceStore } from './session-workspace-store';
 import type { GitWorkspaceManager, GitWorkspaceObservation } from './git-workspace';
 import type { GitWorkspaceStore, GitWorkspacePhase } from './git-workspace-store';
 import type { AgentEgressController } from './agent-egress-controller';
+import { type McpToolsProbeOptions } from './mcp-tools-probe';
 import type { ResolvedAgentMessageMcpBin } from './resolve-agent-message-mcp-bin';
 import type { ResolvedAgentMemoryMcpBin } from './resolve-agent-memory-mcp-bin';
 import { type AgentMemoryAuditWarning, type AgentMemoryHostedProjection } from './agent-memory';
@@ -369,6 +370,22 @@ export interface TaskRunnerDeps {
     };
     /** SDK-owned, task-scoped MCP helper. Required only for offers declaring messageEgress. */
     agentMessageMcpBin?: Readonly<ResolvedAgentMessageMcpBin>;
+    /**
+     * Production pre-runtime executability/handshake gate for the exact message
+     * helper config. `env` is the same allowlisted child environment the runtime
+     * gets (`buildRuntimeEnv`), and `cwd` the same working directory, so the
+     * helper is proved under the conditions it will actually run in.
+     */
+    agentMessageMcpPreflight?: (server: Readonly<McpStdioServerConfig>, env: Readonly<Record<string, string>>, cwd?: string) => Promise<void>;
+    /**
+     * Override the `tools/list` observation of a projected toolset MCP server.
+     * Defaults to the real handshake (`mcp-tools-probe.ts`); tests substitute a
+     * stub. It is deliberately NOT optional-with-no-default the way
+     * `agentMessageMcpPreflight` is: an adapter may only grant tool names that
+     * were observed, so a runner with no observation at all would silently
+     * project toolsets the model can list and never call.
+     */
+    mcpToolsetToolsProbe?: (server: Readonly<McpStdioServerConfig>, options: McpToolsProbeOptions) => Promise<readonly string[]>;
     /** SDK-owned MCP helper injected only into strict Agent tasks. */
     agentMemoryMcpBin?: Readonly<ResolvedAgentMemoryMcpBin>;
     /** Explicit external secure-fs helper. No PATH discovery or bundled native addon exists. */

package/dist/daemon/team-workspace.d.ts

@@ -0,0 +1,202 @@
+/**
+ * The local team channel is deliberately a small, versioned contract.  It is
+ * not a task outbox and it has no cloud or runtime authority.  The state file
+ * is an atomic envelope so a post, a receipt, or a membership change is
+ * either wholly visible after a restart or not visible at all.
+ */
+export declare const TEAM_WORKSPACE_VERSION: 1;
+export declare const TEAM_WORKSPACE_DIRECTORY: string;
+export declare const TEAM_WORKSPACE_STATE_FILENAME = "state.json";
+export declare const TEAM_WORKSPACE_DEFAULT_CONTENT_TYPE = "text/plain";
+/** Bounds are intentionally smaller than the control protocol's 64 KiB line. */
+export declare const TEAM_WORKSPACE_MAX_ID_BYTES = 128;
+export declare const TEAM_WORKSPACE_MAX_BODY_BYTES: number;
+export declare const TEAM_WORKSPACE_MAX_CONTENT_TYPE_BYTES = 128;
+export declare const TEAM_WORKSPACE_MAX_MEMBERS = 256;
+export declare const TEAM_WORKSPACE_MAX_MESSAGES = 100000;
+export declare const TEAM_WORKSPACE_MAX_BYTES: number;
+export declare const TEAM_WORKSPACE_DEFAULT_LEASE_TTL_MS: number;
+export declare const TEAM_WORKSPACE_MIN_LEASE_TTL_MS = 1;
+export declare const TEAM_WORKSPACE_MAX_LEASE_TTL_MS: number;
+/** A stable, content-addressed registry revision. */
+export type TeamWorkspaceRevision = `sha256:${string}`;
+export interface TeamWorkspaceLimits {
+    readonly maxMembers: number;
+    readonly maxMessages: number;
+    readonly maxBytes: number;
+}
+export interface TeamWorkspaceDefinition {
+    readonly version: typeof TEAM_WORKSPACE_VERSION;
+    readonly workspaceId: string;
+    readonly revision: TeamWorkspaceRevision;
+    readonly members: readonly string[];
+    readonly limits: TeamWorkspaceLimits;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+export interface TeamWorkspaceMemberReceipt {
+    readonly workspaceId: string;
+    readonly memberId: string;
+    readonly acknowledgedThroughSeq: number;
+    readonly deliveredThroughSeq: number;
+    readonly registryRevision: TeamWorkspaceRevision;
+    readonly updatedAt: string;
+}
+export interface TeamMessage {
+    readonly version: typeof TEAM_WORKSPACE_VERSION;
+    readonly workspaceId: string;
+    readonly seq: number;
+    readonly messageId: string;
+    readonly senderMemberId: string;
+    readonly body: string;
+    readonly contentType: string;
+    readonly byteCount: number;
+    readonly contentHash: TeamWorkspaceRevision;
+    readonly createdAt: string;
+}
+/**
+ * The token is intentionally opaque to callers.  It is returned once from
+ * lease issuance and only its digest is persisted; raw bearer material never
+ * enters the durable state file.
+ */
+export interface TeamMemberLease {
+    readonly opaqueToken: string;
+    readonly workspaceId: string;
+    readonly memberId: string;
+    readonly registryRevision: TeamWorkspaceRevision;
+    readonly expiresAt: string;
+}
+export interface CreateTeamWorkspaceInput {
+    readonly workspaceId: string;
+    readonly members: readonly string[];
+    readonly limits: TeamWorkspaceLimits;
+}
+export interface UpdateTeamWorkspaceInput {
+    readonly workspaceId: string;
+    readonly expectedRevision: TeamWorkspaceRevision;
+    readonly members: readonly string[];
+    readonly limits?: TeamWorkspaceLimits;
+}
+export interface CreateTeamMemberLeaseInput {
+    readonly workspaceId: string;
+    readonly memberId: string;
+    readonly ttlMs?: number;
+}
+export interface TeamPostMessageInput {
+    readonly lease: TeamMemberLease;
+    readonly body: string;
+    readonly contentType?: string;
+}
+export interface TeamReadMessagesInput {
+    readonly lease: TeamMemberLease;
+    readonly afterSeq?: number;
+}
+export interface TeamAckMessagesInput {
+    readonly lease: TeamMemberLease;
+    readonly throughSeq: number;
+}
+export interface TeamMessageAcceptedReceipt {
+    readonly accepted: true;
+    readonly durable: true;
+    readonly workspaceId: string;
+    readonly memberId: string;
+    readonly seq: number;
+    readonly messageId: string;
+    readonly message: TeamMessage;
+}
+export interface TeamReadMessagesResult {
+    readonly workspaceId: string;
+    readonly memberId: string;
+    readonly messages: readonly TeamMessage[];
+    readonly afterSeq: number;
+    readonly deliveredThroughSeq: number;
+    readonly receipt: TeamWorkspaceMemberReceipt;
+}
+export interface TeamAckReceipt {
+    readonly accepted: true;
+    readonly durable: true;
+    readonly throughSeq: number;
+    readonly receipt: TeamWorkspaceMemberReceipt;
+}
+export interface LocalTeamWorkspaceOptions {
+    /** Test seam for deterministic lease expiry and timestamps. */
+    readonly now?: () => number;
+}
+/** Common typed failure for all rejected local team operations. */
+export declare class TeamWorkspaceError extends Error {
+    constructor(message: string);
+}
+export declare class TeamWorkspaceValidationError extends TeamWorkspaceError {
+    constructor(message: string);
+}
+export declare class TeamWorkspaceNotFoundError extends TeamWorkspaceError {
+    readonly workspaceId: string;
+    constructor(workspaceId: string);
+}
+export declare class TeamWorkspaceConflictError extends TeamWorkspaceError {
+    constructor(message: string);
+}
+export declare class TeamWorkspaceQuotaError extends TeamWorkspaceError {
+    readonly quota: 'members' | 'messages' | 'bytes';
+    constructor(quota: 'members' | 'messages' | 'bytes', message: string);
+}
+export declare class TeamWorkspaceLeaseError extends TeamWorkspaceError {
+    constructor(message: string);
+}
+export declare class TeamWorkspaceReceiptError extends TeamWorkspaceError {
+    constructor(message: string);
+}
+export declare class TeamWorkspaceCorruptError extends TeamWorkspaceError {
+    constructor(message: string);
+}
+/** Public fail-closed validators for control/MCP composition sites. */
+export declare function validateTeamWorkspaceId(value: unknown): string;
+export declare function validateTeamMemberId(value: unknown): string;
+export declare function validateTeamMessageBody(value: unknown): string;
+export declare function validateTeamContentType(value: unknown): string;
+/** Encode the full lease as one opaque helper context; it is never model input. */
+export declare function encodeTeamMemberContext(lease: TeamMemberLease): string;
+/** Decode only the exact bounded lease shape emitted by {@link encodeTeamMemberContext}. */
+export declare function decodeTeamMemberContext(value: unknown): TeamMemberLease;
+/**
+ * Local-only durable TeamWorkspace authority.  The service is intentionally
+ * independent from TaskRunner and cloud protocol: a caller must first obtain
+ * a member lease, and all message operations derive workspace/member identity
+ * from that lease rather than accepting it from model input.
+ */
+export declare class LocalTeamWorkspace {
+    private readonly rootDir;
+    private readonly statePath;
+    private readonly now;
+    private readonly queueKey;
+    constructor(storeDir: string, options?: LocalTeamWorkspaceOptions);
+    /** Create the secure state directory; it is safe to call on every start. */
+    initialize(): Promise<void>;
+    createWorkspace(input: CreateTeamWorkspaceInput): Promise<TeamWorkspaceDefinition>;
+    getWorkspace(workspaceId: string): Promise<TeamWorkspaceDefinition | undefined>;
+    listWorkspaces(): Promise<readonly TeamWorkspaceDefinition[]>;
+    /** Local operator read for the tmux pane; it does not create or advance a member receipt. */
+    inspectMessages(workspaceId: string, afterSeq?: number): Promise<readonly TeamMessage[]>;
+    /** CAS-guarded membership/limit update.  A revision change invalidates all leases. */
+    updateWorkspace(input: UpdateTeamWorkspaceInput): Promise<TeamWorkspaceDefinition>;
+    createMemberLease(input: CreateTeamMemberLeaseInput): Promise<TeamMemberLease>;
+    revokeMemberLease(input: {
+        readonly lease: TeamMemberLease;
+    }): Promise<void>;
+    /** Validate the opaque lease and return its daemon-owned identity. */
+    validateMemberLease(lease: TeamMemberLease): Promise<Readonly<{
+        workspaceId: string;
+        memberId: string;
+        registryRevision: TeamWorkspaceRevision;
+        expiresAt: string;
+    }>>;
+    postMessage(input: TeamPostMessageInput): Promise<TeamMessageAcceptedReceipt>;
+    readMessages(input: TeamReadMessagesInput): Promise<TeamReadMessagesResult>;
+    ackMessages(input: TeamAckMessagesInput): Promise<TeamAckReceipt>;
+    private resolveLease;
+    private load;
+    private save;
+    private enqueue;
+}
+/** The longer name is useful at composition sites; both names denote one authority. */
+export { LocalTeamWorkspace as LocalTeamWorkspaceService };

package/dist/daemon/toolset-registry.d.ts

@@ -1,7 +1,5 @@
 import { type ToolsetId } from '@byok-sdk/protocol';
 import type { McpToolsetConfig, McpToolsetObservation, McpToolsetRegistryStatus, McpToolsetReloadReceipt } from '../types';
-export declare const AGENT_MESSAGE_MCP_SERVER_NAME = "byokagentmessage";
-export declare const AGENT_MEMORY_MCP_SERVER_NAME = "byokagentmemory";
 export type McpToolsetConfigInput = Record<string, McpToolsetConfig> | undefined;
 export interface McpToolsetRegistrySnapshot {
     revision: string;

package/dist/index.d.ts

@@ -10,6 +10,8 @@ export { PolicyUnsupportedError, SteerUnsupportedError, freezeRuntimeAdapterDesc
 export type { RuntimeEnvironmentRequirements } from './daemon/environment';
 export { resolveLocalAgentReleaseIdentity } from './release-identity';
 export type { LocalAgentReleaseIdentity } from './release-identity';
+export { BYOK_SDK_HELPER_SUBCOMMAND, resolveSdkReservedHelperBin, runSdkReservedHelperCommand, } from './sdk-reserved-helper-host';
+export type { SdkHelperHostConfig, SdkReservedHelperKind, ResolvedSdkReservedHelperBin, } from './sdk-reserved-helper-host';
 export { RuntimeExecutionFailure, RuntimeDisposalFailure, RUNTIME_ADAPTER_CONTRACT_VIOLATION_REASON, isRuntimeDisposalFailure, isRuntimeExecutionFailure, projectRuntimeBoundaryFailure, projectRuntimeExecutionFailure, } from './runtime-failure';
 export type { RuntimeExecutionFailureInput, RuntimeDisposalFailureInput, RuntimeDisposalStage, RuntimeFailureCategory, RuntimeFailurePhase, RuntimeFailureProjection, RuntimeRetryDisposition, } from './runtime-failure';
 export { GitWorkspaceManager, GitWorkspaceError, isGitWorkspaceConfig, prependGitWorkspaceGuidance } from './daemon/git-workspace';
@@ -17,6 +19,8 @@ export type { GitWorkspaceObservation, GitWorkspaceLease, GitWorkspaceOptions, G
 export { GitWorkspaceStore } from './daemon/git-workspace-store';
 export type { GitWorkspaceLedger, GitWorkspaceLedgerRecord, GitWorkspacePhase } from './daemon/git-workspace-store';
 export { createDaemon, createDaemonWithAdapters } from './daemon/create-daemon';
+export { LocalTeamWorkspace, LocalTeamWorkspaceService, TeamWorkspaceError, TeamWorkspaceValidationError, TeamWorkspaceNotFoundError, TeamWorkspaceConflictError, TeamWorkspaceQuotaError, TeamWorkspaceLeaseError, TeamWorkspaceReceiptError, TeamWorkspaceCorruptError, encodeTeamMemberContext, decodeTeamMemberContext, type TeamWorkspaceDefinition, type TeamWorkspaceLimits, type TeamMessage, type TeamMemberLease, type TeamWorkspaceMemberReceipt, } from './daemon/team-workspace';
+export { openTeamTmuxView, TeamTmuxViewError, type OpenTeamTmuxViewInput } from './bin/team-tmux-view';
 export type { Daemon, DaemonConfig, DaemonStatus, DaemonOverrides, DaemonBranding, HostedJournalConfig, DeviceAssertionConfig, AgentEgressConfig, AgentContentReadConfig, AgentContentReadSurfaceConfig, AgentReliableEgressInput, } from './daemon/create-daemon';
 export { AgentMemoryError, AgentMemoryRevisionConflictError, isAgentMemorySecureFilesystemAvailable, AGENT_MEMORY_AUDIT_FILENAME, AGENT_MEMORY_OUTBOX_FILENAME, } from './daemon/agent-memory';
 export type { AgentMemoryFilesystemHelperConfig } from './daemon/agent-memory-filesystem';