@byok-sdk/client 0.11.0 → 0.13.0

package/dist/daemon/long-poll-transport.d.ts

@@ -1,5 +1,6 @@
 import { type Envelope } from '@byok-sdk/protocol';
 import { AuthManager } from './auth-manager';
+import { ReplayCursorTooOldError } from './replay-cursor';
 import { type TransportEndpoint } from './url';
 /**
  * A long-poll request failed in a way that today told the caller only
@@ -32,21 +33,27 @@ export interface LongPollClientOptions {
     serverUrl: string;
     auth: AuthManager;
     getCursor: () => number | undefined;
-    onEnvelope: (envelope: Envelope) => void;
+    /** Returns false when the envelope was a local duplicate and no handler was queued. */
+    onEnvelope: (envelope: Envelope) => boolean | void;
     /**
      * Capabilities advertised by the server that produced the current poll
      * response. Called before any envelopes from that response are delivered.
      * An older responder omitting the additive field is reported as `[]`.
      */
     onServerCapabilities?: (capabilities: string[]) => void;
+    /** Called when a failed poll invalidates the preceding response's capability snapshot. */
+    onServerCapabilitiesInvalidated?: () => void;
+    /** Called after a poll fails and before the retry delay begins. */
+    onPollFailure?: () => void;
     /** Called once the device is found to be revoked (401 surfaced through {@link AuthManager}) — the loop stops itself rather than retrying. */
     onRevoked?: () => void;
+    /** Called when the server cannot replay the durable cursor supplied to this poll. */
+    onReplayCursorTooOld?: (error: ReplayCursorTooOldError) => void;
     /**
      * M4 Phase 4 (version-negotiation drill fix), scope narrowed by finding F1:
      * called ONLY for a batch entry that failed to parse because its `type`
      * is entirely unrecognized (`parseMessage` throwing
-     * {@link UnknownMessageTypeError} — mirrors `ws-transport.ts`'s identical
-     * per-frame tolerance for that SPECIFIC failure) and which still carries a
+     * {@link UnknownMessageTypeError}) and which still carries a
      * numeric envelope-level `seq` AND a recognizably task-class `type` (a
      * `task.` prefix — see `extractSkippableSeq`'s own doc comment for why a
      * `conn.*`-shaped or type-less entry is deliberately excluded, mirroring
@@ -64,11 +71,8 @@ export interface LongPollClientOptions {
      * not forward-compat tolerance — forwarding its `seq` here would
      * permanently ack a message the daemon never actually understood (the
      * server would stop redelivering it, silently stranding whatever it was
-     * offering). The WS path never had this hazard (an unparseable WS frame
-     * has no skip-side cursor bookkeeping at all — see
-     * `ws-transport.ts` — so it simply gets redelivered later); this callback
-     * being scoped to `UnknownMessageTypeError` only is what makes long-poll
-     * match that same "no silent permanent ack" property for real. Optional
+     * offering). This callback being scoped to `UnknownMessageTypeError` only
+     * preserves the no-silent-permanent-ack property. Optional
      * only for constructor/test convenience — `ConnectionManager` always
      * supplies it.
      */
@@ -111,7 +115,7 @@ export interface LongPollClientOptions {
      * `ConnectionManager` always supplies it.
      */
     isStalled?: () => boolean;
-    /** Backoff between failed poll attempts (network/HTTP errors), AND between cycles that made no cursor progress while stalled (finding P2/Fix 2a — see {@link isStalled}). The reference server holds each successful, non-stalled request open ~50s itself (protocol §8), so this only matters when a request errors outright or is stalled. Default 2s. */
+    /** Backoff between failed poll attempts (network/HTTP errors), stalled cycles, and duplicate-only cycles that made no cursor progress. The reference server holds a genuinely idle request open ~50s itself (protocol §8). Default 2s. */
     retryDelayMs?: number;
     /** Deterministic delay authority for automatic failed/stalled cycles. */
     retryDelayForAttempt?: (attempt: number, baseDelayMs: number) => number;
@@ -125,24 +129,29 @@ export interface LongPollClientOptions {
      */
     idleDelayMs?: number;
 }
+/** A fully-read frozen-v1 count acknowledgement for the batch that was posted. */
+export interface MessageBatchPostResult {
+    readonly accepted: number;
+    readonly rejected?: number;
+}
 /**
- * Protocol §8 long-poll fallback: `GET /byok/events?cursor=N` in a loop,
- * used while WS connectivity is unavailable (see `ConnectionManager`), plus
- * `POST /byok/messages` for the daemon's own outbound envelopes while in
- * this mode (finding F6 — long-poll is a full transport, not receive-only:
- * see docs/protocol.md §8).
+ * Protocol §8 long-poll transport: `GET /byok/events?cursor=N` in a loop,
+ * plus `POST /byok/messages` for the daemon's own outbound envelopes
+ * (finding F6 — long-poll is a full transport, not receive-only: see
+ * docs/protocol.md §8).
  *
- * Design B (finding N4): this is a stateless drainer, symmetric with
- * `WsTransport.sendNow` — it holds no outbound queue of its own.
- * `ConnectionManager` owns the single shared outbox both transports drain
- * from (so a transport switch never strands a queued envelope);
- * `postBatch` is a single POST attempt, reporting back whether the server
- * accepted it. All retry/backoff policy (and re-checking which transport is
- * currently active) lives in the caller (`ConnectionManager.drainOutbox`).
+ * Design B (finding N4): this is a stateless drainer; it holds no outbound
+ * queue of its own. `ConnectionManager` owns the single shared outbox;
+ * `postBatch` is a single POST attempt, reporting only frozen-v1 accepted and
+ * rejected counts after its response body has been read and validated. All
+ * retry/backoff and rejection isolation policy lives in the caller
+ * (`ConnectionManager.drainOutbox`).
  */
 export declare class LongPollClient {
     private readonly opts;
     private running;
+    /** Owns exactly one active loop generation, including its held GET and retry delays. */
+    private loopAbortController;
     /**
      * Finding R1: seqs this loop has already `console.warn`'d about for a
      * validation-failed (recognized-type, invalid-payload) entry — a poison
@@ -201,8 +210,8 @@ export declare class LongPollClient {
      * (`ConnectionHub.handleInbound`), so a resend of the SAME batch (same
      * envelope `id`s — the caller must never rebuild them) is deduped
      * server-side into a safe no-op rather than reprocessed (§9). Returns
-     * `true` once the server has accepted the batch.
+     * validated frozen-v1 counts only after a readable response body.
      */
-    postBatch(envelopes: Envelope[]): Promise<boolean>;
+    postBatch(envelopes: Envelope[]): Promise<MessageBatchPostResult | undefined>;
     private loop;
 }

package/dist/daemon/observer.d.ts

@@ -1,5 +1,5 @@
 import { type AgentEvent, type BlobRef, type Envelope, type RuntimeInfo, type TaskState } from '@byok-sdk/protocol';
-import type { ConnectionState } from './ws-transport';
+import type { ConnectionState } from './connection-manager';
 /**
  * M3-2a: local observability for the daemon — the seam a CLI (M3-2b) drives a
  * live task feed, a task list, and approve/reject/unpair from, all LOCALLY

package/dist/daemon/replay-cursor.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The server retained no contiguous replay history after the cursor the
+ * daemon acknowledged. This is terminal for the current device enrollment:
+ * retrying the same cursor can only repeat the loss condition.
+ */
+export declare class ReplayCursorTooOldError extends Error {
+    readonly recoverableFrom?: number | undefined;
+    constructor(recoverableFrom?: number | undefined);
+}

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

@@ -177,6 +177,15 @@ export type ResultDocumentExtractor = (finalOutput: string, task: ResultDocument
  * opt-out pin.
  */
 export declare const DEFAULT_MAX_TASK_OUTPUT_BYTES: number;
+/**
+ * WP0: default number of Attempts allowed to execute concurrently in one
+ * canonical Agent home. One — the canonical home is every Agent session's
+ * cwd, so a second concurrent Attempt is a second writer of the same
+ * `MEMORY.md`, `notes/` and `.git`. Raising it is an explicit host choice
+ * (`DaemonConfig.maxConcurrentMutableSessionsPerAgentHome`) that re-enables
+ * the 0.12.0 co-writing exposure; there is no implicit fallback to it.
+ */
+export declare const DEFAULT_MAX_CONCURRENT_MUTABLE_SESSIONS_PER_AGENT_HOME = 1;
 export interface TaskRunnerDeps {
     adapters: RuntimeAdapter[];
     runtimeAllowlist?: string[];
@@ -204,6 +213,13 @@ export interface TaskRunnerDeps {
     agentHome?: AgentHomeManager;
     /** Local authority: legacy offers are declined after journal/dedup/cancel precedence. */
     strictAgentOnly?: boolean;
+    /**
+     * WP0: how many Attempts may execute concurrently in ONE canonical Agent
+     * home — see `DaemonConfig.maxConcurrentMutableSessionsPerAgentHome`'s own
+     * doc comment (`create-daemon.ts`) for the validated contract. Unset
+     * defaults to {@link DEFAULT_MAX_CONCURRENT_MUTABLE_SESSIONS_PER_AGENT_HOME}.
+     */
+    maxConcurrentMutableSessionsPerAgentHome?: number;
     /** Exact host-selected policy accepted by `task.offer_for_agent_with_egress`. */
     agentEgressPolicy?: Readonly<AgentEgressPolicy>;
     /** Always-present projection/sanitizer consumer; it defaults to metadata-only. */
@@ -421,6 +437,7 @@ export declare class TaskRunner {
     private readonly deps;
     private readonly tasks;
     private readonly pendingMessageTasks;
+    private readonly messageOutboxesByHome;
     private readonly messageContextByToken;
     private readonly messageContextByTask;
     private readonly memoryContextByToken;
@@ -481,6 +498,8 @@ export declare class TaskRunner {
      * costs nothing.
      */
     private readonly inFlightOffers;
+    /** Blob I/O before an offer becomes an active task still belongs to that offer's cancellation authority. */
+    private readonly inFlightBlobAborts;
     /**
      * Finding P2 (Fix 2c): taskIds that have reached a terminal outcome
      * (Complete/Failed/Cancelled) this session — populated in `finish()`.
@@ -550,6 +569,8 @@ export declare class TaskRunner {
     usesAgentEgress(taskId: string): boolean;
     /** M5 batch-3 (workstream 2): effective `maxTaskOutputBytes` cap for this daemon — see {@link DEFAULT_MAX_TASK_OUTPUT_BYTES}'s own doc comment. */
     private get maxTaskOutputBytes();
+    /** WP0: effective per-canonical-Agent-home Attempt cap — see {@link DEFAULT_MAX_CONCURRENT_MUTABLE_SESSIONS_PER_AGENT_HOME}. */
+    private get maxConcurrentMutableSessionsPerAgentHome();
     /**
      * M4 Phase 4 (part B.3, observability): per-active-task queue watermarks
      * for the control socket's `status` result — see
@@ -592,6 +613,7 @@ export declare class TaskRunner {
     }>;
     /** Restore activated, unaccepted message drafts before transport admission on daemon restart. */
     recoverAgentMessageOutboxes(agentsRoot: string): Promise<void>;
+    private agentMessageOutbox;
     /** Retry stable recovered records after a transport handshake/re-handshake. */
     retryRecoveredAgentMessages(): void;
     private sendAgentMessageRecord;

package/dist/daemon/url.d.ts

@@ -1,7 +1,5 @@
-/** Normalize a configured `serverUrl` (http/https/ws/wss, any path) to an http(s) base with no path/query. */
+/** Normalize a configured HTTP(S) `serverUrl` (any path) to a base with no path/query. */
 export declare function toHttpBase(serverUrl: string): string;
-/** Derive the `/byok/ws` WebSocket URL from a configured `serverUrl`. */
-export declare function toWsUrl(serverUrl: string): string;
 /**
  * Which route a transport diagnostic is about, in the only two fields that
  * are safe to keep: the host (with port) and the path.
@@ -15,7 +13,7 @@ export declare function toWsUrl(serverUrl: string): string;
  * by formatting a raw URL of its own.
  */
 export interface TransportEndpoint {
-    readonly transport: 'ws' | 'long-poll';
+    readonly transport: 'long-poll';
     /** `URL.host` — hostname plus port when non-default. Never userinfo. */
     readonly host: string;
     /** `URL.pathname` — no query, no fragment. */
@@ -23,6 +21,12 @@ export interface TransportEndpoint {
 }
 /** The single construction site for {@link TransportEndpoint} — see that interface's own doc comment for why it is the only one. */
 export declare function describeEndpoint(transport: TransportEndpoint['transport'], url: string | URL): TransportEndpoint;
+/**
+ * The only URL projection used by validation errors. Reading from the parsed
+ * structure means userinfo, query, and fragment never enter the diagnostic.
+ */
+/** The sole secret-safe projection for a configured server URL diagnostic. */
+export declare function formatServerUrl(value: string | URL): string;
 /**
  * M5: thrown by {@link assertServerUrlAllowed} — see that function's own doc
  * comment for the full allow/deny rule this names. Deliberately ONE error
@@ -37,7 +41,7 @@ export declare class InsecureServerUrlError extends Error {
 }
 export interface AssertServerUrlAllowedOptions {
     /**
-     * Explicit escape hatch: when `true`, a `http:`/`ws:` `serverUrl` whose
+     * Explicit escape hatch: when `true`, an `http:` `serverUrl` whose
      * host is NOT loopback is allowed through instead of throwing. Does
      * nothing for an unsupported scheme (see {@link assertServerUrlAllowed}'s
      * own doc comment) — that rejection is unconditional. Threaded from
@@ -51,25 +55,25 @@ export interface AssertServerUrlAllowedOptions {
 }
 /**
  * M5: transport-security gate for a configured `serverUrl` — refuses
- * plaintext (`ws:`/`http:`) transport to any non-loopback host, so a device
+ * plaintext (`http:`) transport to any non-loopback host, so a device
  * can never be talked into pairing with (and sending its pairing code /
  * device credentials to) a remote host in the clear. Call this ONCE at each
  * real entry point a raw, operator-supplied `serverUrl` first enters the
  * client (`create-daemon.ts`'s `pair()`/`start()`) rather than inside
- * `toHttpBase`/`toWsUrl` themselves: ws-transport, the long-poll fallback,
- * and blob-client all read `serverUrl` from that SAME `DaemonConfig`, never
+ * `toHttpBase` itself: long-poll and blob-client both read `serverUrl` from
+ * that same `DaemonConfig`, never
  * an independently-supplied URL of their own, so those two call sites are
  * already the single common path every one of them goes through.
  *
  * Rules, checked in order:
- *  - `https:`/`wss:` — always allowed, any host (TLS is the actual
+ *  - `https:` — always allowed, any host (TLS is the actual
  *    plaintext-network defense; this gate has nothing further to add there).
- *  - `http:`/`ws:` — allowed only when the hostname is loopback: exactly
+ *  - `http:` — allowed only when the hostname is loopback: exactly
  *    `localhost` or any `*.localhost` subdomain, an IPv4 literal in
  *    `127.0.0.0/8`, or the IPv6 loopback `::1` — see {@link isLoopbackHostname}.
- *  - `http:`/`ws:` to any other host — refused with a clear, typed
- *    {@link InsecureServerUrlError} naming the offending URL and the fix
- *    (use `wss:`/`https:`, or pass `dangerouslyAllowInsecureRemote: true` if
+ *  - `http:` to any other host — refused with a clear, typed
+ *    {@link InsecureServerUrlError} naming the redacted scheme/host/path and the fix
+ *    (use `https:`, or pass `dangerouslyAllowInsecureRemote: true` if
  *    this is a deliberate, understood exception) — UNLESS
  *    `opts.dangerouslyAllowInsecureRemote` is `true`.
  *  - Any other scheme (or a `serverUrl` that fails to parse as a URL at

package/dist/diagnostics/support-bundle.d.ts

@@ -28,7 +28,7 @@ export interface SupportBundle {
         status: 'online';
         pid: number;
         uptimeMs: number;
-        transport: 'connecting' | 'open' | 'closed' | 'degraded' | 'revoked' | 'unavailable';
+        transport: 'connecting' | 'open' | 'closed' | 'revoked' | 'unavailable';
         activeTaskCount: number;
         pendingApprovalCount: number;
         operationalHealth: {

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export type { AgentRef } from './agent-home';
 export { AgentHomeError, AgentRefValidationError, AgentHomeResolutionError, AgentHomeCollisionError, AgentHomeBusyError, AgentHomeLeaseCorruptError, AgentHomeLayout, AgentHomeLeaseManager, AgentHomeManager, createAgentHomeProjection, createAgentHomeProjectionConsumer, AGENT_HOME_PROJECTION_STATE_FILE, stableAgentHomeOwnerId, validateAgentRef, } from './agent-home';
 export { AgentSessionHandoffStore, AgentSessionHandoffStoreError, AgentSessionHandoffCorruptError, AgentSessionHandoffMismatchError, } from './daemon/agent-session-handoff-store';
 export type { AgentSessionHandoff, AgentSessionHandoffMatch, AgentTaskTerminalEvidence, AgentTaskTerminalMatch, AgentTerminalCause, } from './daemon/agent-session-handoff-store';
-export type { AgentHomeResolution, AgentHomeProjection, AgentHomeProjectionInput, AgentHomeProjectionApplyInput, AgentHomeProjectionFunction, AgentHomeProjectionApplyFunction, AgentHomeLease, AgentHomeBinding, } from './agent-home';
+export type { AgentHomeResolution, AgentHomeProjection, AgentHomeProjectionInput, AgentHomeProjectionApplyInput, AgentHomeProjectionFunction, AgentHomeProjectionApplyFunction, AgentHomeLease, AgentHomeBinding, AgentHomeExecutionLease, AgentHomeExecutionBinding, AgentHomeExecutionStatus, } from './agent-home';
 export { localStateRelocation, LocalStateRelocationError, LocalStateRelocationBusyError, LocalStateRelocationIntegrityError, } from './local-state-relocation';
 export type { LocalStateRelocationInput, LocalStateRelocationLease, } from './local-state-relocation';
 export { PolicyUnsupportedError, SteerUnsupportedError, freezeRuntimeAdapterDescriptor, sealRuntimeOperationManifest } from './types';
@@ -61,9 +61,10 @@ export { SKILL_PACKS_CAPABILITY, SKILL_PACKS_DIRNAME, SKILL_PACK_AUDIT_FILENAME,
 export type { InstallSkillPacksOptions, InstalledSkillPack, ProjectedSkillPack, SkillPackInstallErrorCode, SkillPackInstallResult, SkillPackLock, } from './daemon/skill-pack-installer';
 export { TruthMemoryClient, TruthMemoryClientError } from './daemon/truth-memory-client';
 export type { LocalMemoryFilter, MemorySelector, TruthManifestQueryInput, TruthManifestRecord, TruthMemoryClientErrorCode, TruthMemoryClientOptions, TruthMemoryMetric, TruthSnapshotCandidateInput, TruthSnapshotWriteInput, TruthTerminalWriteInput, TruthWriteBody, TruthWriteResult, VerifiedTruthRecord, } from './daemon/truth-memory-client';
-export type { ConnectionState } from './daemon/ws-transport';
-export { BlobClient } from './daemon/blob-client';
-export type { BlobResolver } from './daemon/blob-client';
+export type { ConnectionState } from './daemon/connection-manager';
+export { ReplayCursorTooOldError } from './daemon/replay-cursor';
+export { BlobClient, BlobRequestAbortedError } from './daemon/blob-client';
+export type { BlobClientOptions, BlobRequestAbortReason, BlobRequestOptions, BlobResolver } from './daemon/blob-client';
 export { DaemonObserver } from './daemon/observer';
 export type { DaemonEvent, DaemonEventKind, DaemonEventListener, DaemonTaskInfo, Unsubscribe } from './daemon/observer';
 export { createServiceLifecycle, UnsupportedServicePlatformError } from './lifecycle/create-service-lifecycle';