cccc-sdk 0.4.4 → 0.4.40

package/dist/client.js

@@ -1,9 +1,13 @@
 /**
  * CCCC SDK client
  */
-import { DaemonAPIError, IncompatibleDaemonError, ErrorCodes, } from './errors.js';
-import { isStreamEvent } from './types.js';
+import { installConnectOps } from './client_connect_ops.js';
+import { DaemonAPIError, DaemonConnectionError, IncompatibleDaemonError, } from './errors.js';
 import { discoverEndpoint, callDaemon, openEventsStream, readLines, } from './transport.js';
+import { installCCCC0430Ops } from './client_0430_ops.js';
+import { installCCCC0434Ops } from './client_0434_ops.js';
+import { installGroupSpaceOps } from './client_group_space_ops.js';
+import { installChatOps } from './client_chat_ops.js';
 function compactRecord(input) {
     return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
 }
@@ -17,9 +21,11 @@ function compactRecord(input) {
  * ```
  */
 export class CCCCClient {
-    constructor(endpoint, timeoutMs) {
+    constructor(endpoint, timeoutMs, ccccHome, endpointExplicit) {
         this._endpoint = endpoint;
         this._timeoutMs = timeoutMs;
+        this._ccccHome = ccccHome;
+        this._endpointExplicit = endpointExplicit;
     }
     /**
      * Create a new client instance, auto-discovering the daemon endpoint.
@@ -30,7 +36,7 @@ export class CCCCClient {
     static async create(options = {}) {
         const endpoint = options.endpoint ?? await discoverEndpoint(options.ccccHome);
         const timeoutMs = options.timeoutMs ?? 30000;
-        return new CCCCClient(endpoint, timeoutMs);
+        return new CCCCClient(endpoint, timeoutMs, options.ccccHome, options.endpoint !== undefined);
     }
     /** The resolved daemon endpoint this client connects to. */
     get endpoint() {
@@ -53,24 +59,38 @@ export class CCCCClient {
             op,
             args: args ?? {},
         };
-        const response = await callDaemon(this._endpoint, request, this._timeoutMs);
+        let response;
+        try {
+            response = await callDaemon(this._endpoint, request, this._timeoutMs);
+        }
+        catch (error) {
+            if (!(error instanceof DaemonConnectionError) || this._endpointExplicit) {
+                throw error;
+            }
+            // Rediscovery is safe only because DaemonConnectionError means that no
+            // request bytes were written. Exchange failures are never replayed.
+            this._endpoint = await discoverEndpoint(this._ccccHome);
+            response = await callDaemon(this._endpoint, request, this._timeoutMs);
+        }
+        if (response.v !== undefined && response.v !== 1) {
+            throw new IncompatibleDaemonError(`Daemon response uses unsupported IPC version: ${response.v}`);
+        }
         if (!response.ok) {
-            throw new DaemonAPIError(response.error?.code ?? 'error', response.error?.message ?? 'daemon error', response.error?.details ?? {}, response);
+            throw new DaemonAPIError(response.error?.code ?? 'error', response.error?.message ?? 'daemon returned ok=false without an error', response.error?.details ?? {}, response);
         }
         return response;
     }
     /**
      * Send an IPC request and return only the result payload.
-     * @typeParam T - Expected result type (defaults to `Record<string, unknown>`).
      * @param op - The IPC operation name.
      * @param args - Operation arguments.
-     * @returns The `result` field from the daemon response, cast to `T`.
+     * @returns The `result` field from the daemon response (empty object if absent).
      * @throws {DaemonAPIError} If the daemon returns an error.
      * @throws {DaemonUnavailableError} If the connection fails.
      */
     async call(op, args) {
         const response = await this.callRaw(op, args);
-        return (response.result ?? {});
+        return response.result ?? {};
     }
     /**
      * Assert that the connected daemon meets the caller's compatibility requirements.
@@ -82,8 +102,12 @@ export class CCCCClient {
      */
     async assertCompatible(options = {}) {
         const pingResult = await this.ping();
-        const ipcV = pingResult.ipc_v ?? 0;
-        const capabilities = pingResult.capabilities ?? {};
+        const rawIpcV = pingResult['ipc_v'];
+        const ipcV = typeof rawIpcV === 'number' ? rawIpcV : 0;
+        const rawCaps = pingResult['capabilities'];
+        const capabilities = (rawCaps !== null && typeof rawCaps === 'object' && !Array.isArray(rawCaps))
+            ? rawCaps
+            : {};
         // Check IPC version
         const requiredV = options.requireIpcV ?? 1;
         if (ipcV < requiredV) {
@@ -95,19 +119,83 @@ export class CCCCClient {
                 throw new IncompatibleDaemonError(`Missing capability: ${cap}`);
             }
         }
-        // Check operation support by probing
-        const reservedOps = new Set(['ping', 'shutdown', 'events_stream', 'term_attach']);
-        for (const op of options.requireOps ?? []) {
-            if (reservedOps.has(op))
+        // Probe only audited operations with harmless empty arguments.
+        const safeEmptyProbes = new Set([
+            'groups',
+            'group_show',
+            'group_preamble_get',
+            'group_preamble_set',
+            'group_preamble_reset',
+            'send',
+            'tracked_send',
+            'send_files',
+            'reply',
+            'inbox_peek',
+            'inbox_read',
+            'context_get',
+            'context_sync',
+            'message_deliver',
+            'message_history',
+            'reply_request_cancel',
+            'send_cross_group',
+            'memory_search',
+            'memory_get',
+            'memory_write',
+            'memory_profile_get',
+            'memory_health',
+            'actor_new_session',
+            'group_reset',
+            'group_copy_export_file',
+            'terminal_history',
+            'terminal_since',
+            'terminal_snapshot',
+            'term_resize',
+            'web_model_delivery_preferences_get',
+            'web_model_delivery_preferences_update',
+            'web_model_runtime_recover_turn',
+            'events_stream',
+            'connect_catalog',
+            'connect_send',
+            'connect_send_files',
+        ]);
+        for (const requestedOp of options.requireOps ?? []) {
+            const op = requestedOp.trim();
+            if (op === 'ping')
                 continue;
+            if (capabilities[op] === false) {
+                throw new IncompatibleDaemonError(`Operation not supported: ${op}`);
+            }
+            if (!safeEmptyProbes.has(op)) {
+                if (capabilities[op] === true)
+                    continue;
+                throw new IncompatibleDaemonError(`Cannot safely verify operation: ${op}; no advertised capability or safe probe`);
+            }
             try {
                 await this.callRaw(op, {});
             }
             catch (e) {
-                if (e instanceof DaemonAPIError && e.code === ErrorCodes.UNKNOWN_OP) {
+                if (e instanceof DaemonAPIError && e.code === 'unknown_op') {
+                    if (op === 'term_resize') {
+                        try {
+                            await this.callRaw('terminal_resize', {});
+                            continue;
+                        }
+                        catch (aliasError) {
+                            if (aliasError instanceof DaemonAPIError) {
+                                if (aliasError.code !== 'unknown_op') {
+                                    continue;
+                                }
+                            }
+                            else {
+                                throw aliasError;
+                            }
+                        }
+                    }
                     throw new IncompatibleDaemonError(`Operation not supported: ${op}`);
                 }
-                // Other errors (e.g. missing_group_id) imply the operation exists.
+                if (!(e instanceof DaemonAPIError))
+                    throw e;
+                // A structured daemon rejection (e.g. missing_group_id) proves recognition.
             }
         }
         return pingResult;
@@ -164,6 +252,17 @@ export class CCCCClient {
     async groupDelete(groupId, by = 'user') {
         return this.call('group_delete', { group_id: groupId, by });
     }
+    /** Replace a group with a clean group while preserving selected configuration. */
+    async groupReset(options) {
+        if (options.confirmGroupId !== options.groupId) {
+            throw new DaemonAPIError('invalid_args', 'groupReset requires confirmGroupId to equal groupId', {});
+        }
+        return this.call('group_reset', {
+            group_id: options.groupId,
+            confirm: options.confirmGroupId,
+            by: options.by ?? 'user',
+        });
+    }
     /**
      * Use group (set active scope)
      */
@@ -208,7 +307,7 @@ export class CCCCClient {
     async groupAutomationManage(options) {
         const actions = options.actions;
         if (actions.length === 0) {
-            throw new DaemonAPIError(ErrorCodes.INVALID_ARGS, 'groupAutomationManage requires a non-empty actions array', {});
+            throw new DaemonAPIError('invalid_args', 'groupAutomationManage requires a non-empty actions array', {});
         }
         const args = {
             group_id: options.groupId,
@@ -264,7 +363,7 @@ export class CCCCClient {
     }
     /**
      * Add an actor to a group.
-     * @param options - Actor configuration (id, runtime, runner, etc.).
+     * @param options - Actor configuration (id, runtime, command, etc.).
      * @returns The daemon result (includes assigned actor id).
      * @throws {DaemonAPIError} On invalid group or duplicate actor id.
      */
@@ -273,12 +372,14 @@ export class CCCCClient {
             actor_id: options.actorId,
             title: options.title,
             runtime: options.runtime,
-            runner: options.runner,
             command: options.command,
             env: options.env,
             env_private: options.envPrivate,
             capability_autoload: options.capabilityAutoload,
+            capability_hidden: options.capabilityHidden,
             profile_id: options.profileId,
+            profile_scope: options.profileScope,
+            profile_owner: options.profileOwner,
             default_scope_key: options.defaultScopeKey,
             submit: options.submit,
         };
@@ -315,25 +416,10 @@ export class CCCCClient {
         return this.call('actor_remove', { group_id: groupId, actor_id: actorId, by });
     }
     /**
-     * Start actor.
-     * @param groupId - Group ID.
-     * @param actorId - Actor ID.
-     * @param options - Optional settings. Pass `{ idempotent: true }` to suppress errors when the actor is already running.
-     * @returns The daemon result.
-     * @throws {DaemonAPIError} On error (unless idempotent and actor already running).
+     * Start actor
      */
-    async actorStart(groupId, actorId, options) {
-        const by = typeof options === 'string' ? options : (options?.by ?? 'user');
-        const idempotent = typeof options === 'object' && options?.idempotent === true;
-        try {
-            return await this.call('actor_start', { group_id: groupId, actor_id: actorId, by });
-        }
-        catch (e) {
-            if (idempotent && e instanceof DaemonAPIError && e.code === ErrorCodes.CONFLICT) {
-                return {};
-            }
-            throw e;
-        }
+    async actorStart(groupId, actorId, by = 'user') {
+        return this.call('actor_start', { group_id: groupId, actor_id: actorId, by });
     }
     /**
      * Stop actor
@@ -347,6 +433,23 @@ export class CCCCClient {
     async actorRestart(groupId, actorId, by = 'user') {
         return this.call('actor_restart', { group_id: groupId, actor_id: actorId, by });
     }
+    async runtimeHermesStatus() {
+        return this.call('runtime_hermes_status', {});
+    }
+    async runtimeHermesPrepare(options = {}) {
+        return this.call('runtime_hermes_prepare', compactRecord({
+            cwd: options.cwd,
+            auto_enable_tools: options.autoEnableTools,
+            force_mcp: options.forceMcp,
+        }));
+    }
+    async runtimeHermesMcpTest(options = {}) {
+        return this.call('runtime_hermes_mcp_test', compactRecord({
+            cwd: options.cwd,
+            group_id: options.groupId,
+            actor_id: options.actorId,
+        }));
+    }
     /**
      * List actor private env keys (without values)
      */
@@ -482,35 +585,48 @@ export class CCCCClient {
     /**
      * Search the capability registry for one group/caller scope.
      */
-    async capabilitySearch(options = {}) {
-        return this.call('capability_search', compactRecord({
+    async capabilitySearch(options) {
+        const args = {
             group_id: options.groupId,
-            by: options.by,
-            actor_id: options.actorId,
-            query: options.query,
-            kind: options.kind,
-            source_id: options.sourceId,
-            trust_tier: options.trustTier,
-            qualification_status: options.qualificationStatus,
-            include_external: options.includeExternal,
-            limit: options.limit,
-        }));
+            by: options.by ?? 'user',
+        };
+        if (options.actorId)
+            args['actor_id'] = options.actorId;
+        if (options.query)
+            args['query'] = options.query;
+        if (options.kind !== undefined)
+            args['kind'] = options.kind;
+        if (options.sourceId)
+            args['source_id'] = options.sourceId;
+        if (options.trustTier)
+            args['trust_tier'] = options.trustTier;
+        if (options.qualificationStatus !== undefined)
+            args['qualification_status'] = options.qualificationStatus;
+        if (options.includeExternal !== undefined)
+            args['include_external'] = options.includeExternal;
+        if (options.limit !== undefined)
+            args['limit'] = options.limit;
+        return this.call('capability_search', args);
     }
     /**
      * Enable or disable a capability.
      */
     async capabilityEnable(options) {
-        return this.call('capability_enable', compactRecord({
+        const args = {
             group_id: options.groupId,
             capability_id: options.capabilityId,
-            scope: options.scope,
-            enabled: options.enabled,
-            cleanup: options.cleanup,
-            by: options.by,
-            reason: options.reason,
-            ttl_seconds: options.ttlSeconds,
-            actor_id: options.actorId,
-        }));
+            scope: options.scope ?? 'session',
+            enabled: options.enabled ?? true,
+            cleanup: options.cleanup ?? false,
+            by: options.by ?? 'user',
+        };
+        if (options.reason)
+            args['reason'] = options.reason;
+        if (options.ttlSeconds !== undefined)
+            args['ttl_seconds'] = options.ttlSeconds;
+        if (options.actorId)
+            args['actor_id'] = options.actorId;
+        return this.call('capability_enable', args);
     }
     /**
      * Block or unblock a capability.
@@ -534,15 +650,14 @@ export class CCCCClient {
     /**
      * Read effective capability exposure for one caller scope.
      */
-    async capabilityState(options = {}, actorId) {
-        const args = typeof options === 'string'
-            ? { group_id: options, actor_id: actorId }
-            : {
-                group_id: options.groupId,
-                by: options.by,
-                actor_id: options.actorId,
-            };
-        return this.call('capability_state', compactRecord(args));
+    async capabilityState(options) {
+        const args = {
+            group_id: options.groupId,
+            by: options.by ?? 'user',
+        };
+        if (options.actorId)
+            args['actor_id'] = options.actorId;
+        return this.call('capability_state', args);
     }
     /**
      * Read capability allowlist default, overlay, and effective snapshots.
@@ -643,250 +758,68 @@ export class CCCCClient {
             args['actor_id'] = options.actorId;
         return this.call('capability_tool_call', args);
     }
-    // ============================================================
-    // Convenience methods: messaging
-    // ============================================================
-    /**
-     * Send a chat message to a group.
-     * @param options - Message content, recipients, and priority.
-     * @returns The created event and optional ack event.
-     * @throws {DaemonAPIError} On invalid group, missing permissions, etc.
-     */
-    async send(options) {
-        const args = {
-            group_id: options.groupId,
-            text: options.text,
-            by: options.by ?? 'user',
-            priority: options.priority ?? 'normal',
-            reply_required: options.replyRequired ?? false,
-        };
-        if (options.to)
-            args['to'] = options.to;
-        if (options.path)
-            args['path'] = options.path;
-        return this.call('send', args);
-    }
-    /**
-     * Send message across groups.
-     * @returns The created event and optional ack event.
-     */
-    async sendCrossGroup(options) {
-        const args = {
-            group_id: options.groupId,
-            dst_group_id: options.dstGroupId,
-            text: options.text,
-            by: options.by ?? 'user',
-            priority: options.priority ?? 'normal',
-            reply_required: options.replyRequired ?? false,
-        };
-        if (options.to)
-            args['to'] = options.to;
-        return this.call('send_cross_group', args);
-    }
-    /**
-     * Create a durable task and send one linked visible message.
-     */
-    async trackedSend(options) {
-        const args = compactRecord({
+    async capabilityUse(options) {
+        const enableResult = await this.capabilityEnable(options);
+        if (!options.toolName)
+            return enableResult;
+        return this.call('capability_tool_call', compactRecord({
             group_id: options.groupId,
-            title: options.title,
-            text: options.text,
-            outcome: options.outcome,
-            assignee: options.assignee,
-            handoff_to: options.handoffTo,
-            waiting_on: options.waitingOn,
-            checklist: options.checklist,
-            notes: options.notes,
-            by: options.by ?? 'user',
-            to: options.to,
-            priority: options.priority ?? 'normal',
-            reply_required: options.replyRequired ?? true,
-            path: options.path,
-        });
-        return this.call('tracked_send', args);
+            actor_id: options.actorId,
+            by: options.by,
+            tool_name: options.toolName,
+            arguments: options.toolArguments ?? {},
+        }));
     }
-    /**
-     * Reply to a message.
-     * @returns The created event and optional ack event.
-     */
-    async reply(options) {
-        const args = {
+    async memorySearch(options) {
+        return this.call('memory_search', compactRecord({
             group_id: options.groupId,
-            reply_to: options.replyTo,
-            text: options.text,
-            by: options.by ?? 'user',
-            priority: options.priority ?? 'normal',
-            reply_required: options.replyRequired ?? false,
-        };
-        if (options.to)
-            args['to'] = options.to;
-        return this.call('reply', args);
-    }
-    /**
-     * Send a message and wait for a reply to it.
-     * Opens the event stream **before** sending to avoid race conditions,
-     * then yields control to the stream until a matching reply arrives.
-     *
-     * @param options - Send options plus `listenAs` (the actor to listen as) and optional `waitTimeoutMs`.
-     * @returns The reply event (a `chat.message` whose `reply_to` matches the sent event ID).
-     * @throws {DaemonAPIError} On send/stream errors.
-     * @throws {Error} If the timeout elapses or the signal is aborted before a reply arrives.
-     */
-    async sendAndWaitForReply(options) {
-        const waitTimeout = options.waitTimeoutMs ?? 60000;
-        const deadline = Date.now() + waitTimeout;
-        // Open stream FIRST (with sinceTs = now) to avoid missing replies
-        // that arrive between send() returning and stream connecting.
-        const stream = this.eventsStream({
-            groupId: options.groupId,
-            by: options.listenAs,
-            kinds: ['chat.message'],
-            sinceTs: new Date().toISOString(),
-            signal: options.signal,
-        });
-        let nextItem = stream.next();
-        // Now send the message
-        const sendResult = await this.send(options);
-        const sentEventId = sendResult.event.id;
-        try {
-            while (true) {
-                if (options.signal?.aborted) {
-                    throw new Error('sendAndWaitForReply aborted');
-                }
-                if (Date.now() > deadline) {
-                    throw new Error(`sendAndWaitForReply timed out after ${waitTimeout}ms`);
-                }
-                const { value: item, done } = await nextItem;
-                if (done)
-                    break;
-                nextItem = stream.next();
-                if (isStreamEvent(item)) {
-                    const evt = item.event;
-                    if (evt.kind === 'chat.message') {
-                        const data = evt.data;
-                        if (data['reply_to'] === sentEventId) {
-                            return evt;
-                        }
-                    }
-                }
-            }
-        }
-        finally {
-            await stream.return(undefined);
-        }
-        throw new Error('sendAndWaitForReply: stream ended without reply');
-    }
-    /**
-     * Acknowledge chat message
-     */
-    async chatAck(groupId, actorId, eventId, by) {
-        return this.call('chat_ack', {
-            group_id: groupId,
-            actor_id: actorId,
-            event_id: eventId,
-            by: by ?? actorId,
-        });
+            actor_id: options.actorId,
+            query: options.query,
+            limit: options.limit,
+            max_results: options.maxResults,
+            vector_weight: options.vectorWeight,
+            candidate_multiplier: options.candidateMultiplier,
+            min_score: options.minScore,
+            tags: options.tags,
+            target: options.target,
+        }));
     }
-    /**
-     * Send a file as a chat attachment.
-     * @param options - File path (relative to scope root), optional caption and recipients.
-     * @returns The created event and optional ack event.
-     */
-    async fileSend(options) {
-        const args = {
+    async memoryGet(options) {
+        return this.call('memory_get', compactRecord({
             group_id: options.groupId,
+            actor_id: options.actorId,
             path: options.path,
-            by: options.by ?? 'user',
-            priority: options.priority ?? 'normal',
-            reply_required: options.replyRequired ?? false,
-        };
-        if (options.text)
-            args['text'] = options.text;
-        if (options.to)
-            args['to'] = options.to;
-        return this.call('file_send', args);
+            target: options.target,
+            date: options.date,
+            offset: options.offset,
+            limit: options.limit,
+        }));
     }
-    /**
-     * Get recent chat messages from the ledger.
-     * @param options - Group ID, limit, and max chars.
-     * @returns The ledger tail result.
-     */
-    async ledgerTail(options) {
-        const args = {
+    async memoryWrite(options) {
+        return this.call('memory_write', compactRecord({
             group_id: options.groupId,
-            by: options.by ?? 'user',
-        };
-        if (options.limit !== undefined)
-            args['limit'] = options.limit;
-        if (options.maxChars !== undefined)
-            args['max_chars'] = options.maxChars;
-        return this.call('ledger_tail', args);
+            actor_id: options.actorId,
+            target: options.target,
+            content: options.content,
+            tags: options.tags,
+            source_refs: options.sourceRefs,
+            idempotency_key: options.idempotencyKey,
+            dedup_intent: options.dedupIntent,
+            dedup_query: options.dedupQuery,
+        }));
     }
-    /**
-     * Get recent terminal output from an actor.
-     * @param options - Group ID, actor ID, and line count.
-     * @returns The terminal tail result.
-     */
-    async terminalTail(options) {
-        const args = {
+    async memoryHealth(options) {
+        return this.call('memory_health', compactRecord({
             group_id: options.groupId,
-            actor_id: options.actorId,
-            by: options.by ?? 'user',
-        };
-        if (options.lines !== undefined)
-            args['lines'] = options.lines;
-        return this.call('terminal_tail', args);
+        }));
     }
-    // ============================================================
-    // Convenience methods: inbox
-    // ============================================================
-    /**
-     * List inbox
-     */
-    async inboxList(options) {
-        return this.call('inbox_list', {
+    async memoryProfileGet(options) {
+        return this.call('memory_profile_get', compactRecord({
             group_id: options.groupId,
             actor_id: options.actorId,
-            by: options.by ?? 'user',
-            limit: options.limit ?? 50,
-            kind_filter: options.kindFilter ?? 'all',
-        });
-    }
-    /**
-     * Mark message as read
-     */
-    async inboxMarkRead(groupId, actorId, eventId, by = 'user') {
-        return this.call('inbox_mark_read', {
-            group_id: groupId,
-            actor_id: actorId,
-            event_id: eventId,
-            by,
-        });
-    }
-    /**
-     * Mark all messages as read
-     */
-    async inboxMarkAllRead(groupId, actorId, by = 'user', kindFilter = 'all') {
-        return this.call('inbox_mark_all_read', {
-            group_id: groupId,
-            actor_id: actorId,
-            by,
-            kind_filter: kindFilter,
-        });
-    }
-    // ============================================================
-    // Convenience methods: notifications
-    // ============================================================
-    /**
-     * Acknowledge notification
-     */
-    async notifyAck(groupId, actorId, notifyEventId, by) {
-        return this.call('notify_ack', {
-            group_id: groupId,
-            actor_id: actorId,
-            notify_event_id: notifyEventId,
-            by: by ?? actorId,
-        });
+            user_id: options.userId,
+            tags: options.tags,
+        }));
     }
     // ============================================================
     // Convenience methods: context
@@ -894,8 +827,8 @@ export class CCCCClient {
     /**
      * Get group context
      */
-    async contextGet(groupId) {
-        return this.call('context_get', { group_id: groupId });
+    async contextGet(groupId, detail = 'full') {
+        return this.call('context_get', { group_id: groupId, detail });
     }
     /**
      * Sync context
@@ -906,12 +839,12 @@ export class CCCCClient {
             ops: options.ops,
             by: options.by ?? 'system',
             dry_run: options.dryRun ?? false,
+            ...(options.ifVersion !== undefined ? { if_version: options.ifVersion } : {}),
         });
     }
     contextOp(groupId, op, by = 'system', dryRun = false) {
         return this.contextSync({ groupId, by, dryRun, ops: [op] });
     }
-    /** Update the shared coordination brief (Context Ops v3). */
     async coordinationBriefUpdate(options) {
         return this.contextOp(options.groupId, compactRecord({
             op: 'coordination.brief.update',
@@ -922,7 +855,6 @@ export class CCCCClient {
             project_brief_stale: options.projectBriefStale,
         }), options.by, options.dryRun);
     }
-    /** Add a compact coordination decision or handoff note. */
     async coordinationNoteAdd(options) {
         return this.contextOp(options.groupId, compactRecord({
             op: 'coordination.note.add',
@@ -931,7 +863,6 @@ export class CCCCClient {
             task_id: options.taskId,
         }), options.by, options.dryRun);
     }
-    /** Create a Context Ops v3 task. */
     async taskCreate(options) {
         return this.contextOp(options.groupId, compactRecord({
             op: 'task.create',
@@ -949,7 +880,6 @@ export class CCCCClient {
             checklist: options.checklist,
         }), options.by, options.dryRun);
     }
-    /** Update a Context Ops v3 task. */
     async taskUpdate(options) {
         return this.contextOp(options.groupId, compactRecord({
             op: 'task.update',
@@ -966,7 +896,6 @@ export class CCCCClient {
             checklist: options.checklist,
         }), options.by, options.dryRun);
     }
-    /** Move a task through the canonical lifecycle operation. */
     async taskMove(options) {
         return this.contextOp(options.groupId, {
             op: 'task.move',
@@ -974,14 +903,18 @@ export class CCCCClient {
             status: options.status,
         }, options.by, options.dryRun);
     }
-    /** Restore an archived task. */
     async taskRestore(options) {
         return this.contextOp(options.groupId, {
             op: 'task.restore',
             task_id: options.taskId,
         }, options.by, options.dryRun);
     }
-    /** Update per-actor working memory. */
+    async taskDelete(options) {
+        return this.contextOp(options.groupId, {
+            op: 'task.delete',
+            task_id: options.taskId,
+        }, options.by, options.dryRun);
+    }
     async agentStateUpdate(options) {
         return this.contextOp(options.groupId, compactRecord({
             op: 'agent_state.update',
@@ -996,17 +929,14 @@ export class CCCCClient {
             environment_summary: options.environmentSummary,
             user_model: options.userModel,
             persona_notes: options.personaNotes,
-            resume_hint: options.resumeHint,
         }), options.by, options.dryRun);
     }
-    /** Clear per-actor working memory. */
     async agentStateClear(options) {
         return this.contextOp(options.groupId, {
             op: 'agent_state.clear',
             actor_id: options.actorId,
         }, options.by, options.dryRun);
     }
-    /** Merge restricted projection metadata. */
     async metaMerge(options) {
         return this.contextOp(options.groupId, {
             op: 'meta.merge',
@@ -1014,268 +944,449 @@ export class CCCCClient {
         }, options.by, options.dryRun);
     }
     // ============================================================
-    // Convenience methods: capability use and memory
+    // Convenience methods: tracked delegation
     // ============================================================
-    async capabilityUse(options) {
-        const enableResult = await this.capabilityEnable(options);
-        if (!options.toolName)
-            return enableResult;
-        return this.call('capability_tool_call', compactRecord({
-            group_id: options.groupId,
-            actor_id: options.actorId,
-            by: options.by,
-            tool_name: options.toolName,
-            arguments: options.toolArguments ?? {},
-        }));
-    }
-    async memorySearch(options) {
-        return this.call('memory_search', compactRecord({
+    /**
+     * Atomically create a tracked task and send the linked chat message. Daemon
+     * handles task.create + send in one transaction. Use `idempotencyKey` to make
+     * retries safe (the daemon replays the previous result on duplicate keys).
+     */
+    async trackedSend(options) {
+        const args = {
             group_id: options.groupId,
-            actor_id: options.actorId,
-            query: options.query,
-            limit: options.limit,
-            tags: options.tags,
-            target: options.target,
-        }));
+            text: options.text,
+            by: options.by ?? 'user',
+        };
+        if (options.title)
+            args['title'] = options.title;
+        if (options.insight)
+            args['insight'] = options.insight;
+        if (options.to)
+            args['to'] = options.to;
+        if (options.path)
+            args['path'] = options.path;
+        if (options.taskPriority)
+            args['task_priority'] = options.taskPriority;
+        if (options.idempotencyKey)
+            args['idempotency_key'] = options.idempotencyKey;
+        if (options.outcome)
+            args['outcome'] = options.outcome;
+        if (options.status)
+            args['status'] = options.status;
+        if (options.waitingOn)
+            args['waiting_on'] = options.waitingOn;
+        if (options.taskType)
+            args['task_type'] = options.taskType;
+        if (options.checklist)
+            args['checklist'] = options.checklist;
+        if (options.notes)
+            args['notes'] = options.notes;
+        if (options.blockedBy)
+            args['blocked_by'] = options.blockedBy;
+        if (options.handoffTo)
+            args['handoff_to'] = options.handoffTo;
+        if (options.assignee)
+            args['assignee'] = options.assignee;
+        if (options.refs)
+            args['refs'] = options.refs;
+        if (options.insight)
+            args['insight'] = options.insight;
+        if (options.requirePeerInsight !== undefined)
+            args['require_peer_insight'] = options.requirePeerInsight;
+        return this.call('tracked_send', args);
     }
-    async memoryGet(options) {
-        return this.call('memory_get', compactRecord({
-            group_id: options.groupId,
-            actor_id: options.actorId,
-            path: options.path,
-            target: options.target,
-            date: options.date,
-            offset: options.offset,
-            limit: options.limit,
-        }));
+    /**
+     * List all tasks in a group, or fetch a single task (with children) by id.
+     */
+    async taskList(options) {
+        if (options.taskId && options.taskIds?.length) {
+            throw new DaemonAPIError('invalid_args', 'taskId and taskIds are mutually exclusive', {});
+        }
+        if (options.status && options.statuses?.length) {
+            throw new DaemonAPIError('invalid_args', 'status and statuses are mutually exclusive', {});
+        }
+        if (options.offset !== undefined && options.limit === undefined) {
+            throw new DaemonAPIError('invalid_args', 'offset requires limit', {});
+        }
+        if (options.limit !== undefined && (!Number.isInteger(options.limit) || options.limit < 1 || options.limit > 100)) {
+            throw new DaemonAPIError('invalid_args', 'limit must be an integer from 1 through 100', {});
+        }
+        const taskIds = options.taskIds?.map((value) => value.trim()) ?? [];
+        if (taskIds.some((value) => value.length === 0) || taskIds.length > 100) {
+            throw new DaemonAPIError('invalid_args', 'taskIds must contain at most 100 non-empty ids', {});
+        }
+        const args = { group_id: options.groupId };
+        if (options.taskId)
+            args['task_id'] = options.taskId;
+        if (taskIds.length)
+            args['task_ids'] = taskIds.join(',');
+        if (options.status)
+            args['status'] = options.status;
+        if (options.statuses?.length)
+            args['statuses'] = options.statuses.join(',');
+        if (options.query)
+            args['query'] = options.query;
+        if (options.assignee)
+            args['assignee'] = options.assignee;
+        if (options.attention)
+            args['attention'] = options.attention;
+        if (options.offset !== undefined)
+            args['offset'] = options.offset;
+        if (options.limit !== undefined)
+            args['limit'] = options.limit;
+        if (options.includeIndex !== undefined)
+            args['include_index'] = options.includeIndex;
+        return this.call('task_list', args);
     }
-    async memoryWrite(options) {
-        return this.call('memory_write', compactRecord({
+    // ============================================================
+    // Convenience methods: headless runtime control
+    // ============================================================
+    async headlessStatus(options) {
+        return this.call('headless_status', {
             group_id: options.groupId,
             actor_id: options.actorId,
-            target: options.target,
-            content: options.content,
-            tags: options.tags,
-            source_refs: options.sourceRefs,
-            idempotency_key: options.idempotencyKey,
-            dedup_intent: options.dedupIntent,
-            dedup_query: options.dedupQuery,
-        }));
-    }
-    async memoryHealth(options = {}) {
-        return this.call('memory_health', compactRecord({
-            group_id: options.groupId,
-        }));
+        });
     }
-    async memoryProfileGet(options) {
-        return this.call('memory_profile_get', compactRecord({
+    async headlessSetStatus(options) {
+        const args = {
             group_id: options.groupId,
             actor_id: options.actorId,
-            user_id: options.userId,
-            tags: options.tags,
-        }));
+            status: options.status,
+        };
+        if (options.taskId)
+            args['task_id'] = options.taskId;
+        return this.call('headless_set_status', args);
     }
     // ============================================================
-    // Convenience methods: Group Space
+    // Convenience methods: group copy (export/import)
     // ============================================================
-    /**
-     * Read Group Space provider and binding status.
-     */
-    async groupSpaceStatus(options) {
-        return this.call('group_space_status', {
+    async groupCopyExport(options) {
+        return this.call('group_copy_export', {
             group_id: options.groupId,
-            provider: options.provider ?? 'notebooklm',
+            by: options.by ?? 'user',
         });
     }
-    /**
-     * List available remote spaces for binding.
-     */
-    async groupSpaceSpaces(options) {
-        return this.call('group_space_spaces', {
-            group_id: options.groupId,
-            provider: options.provider ?? 'notebooklm',
-        });
+    async groupCopyPreviewImport(options) {
+        const packageB64 = options.packageB64;
+        const packagePath = options.packagePath;
+        if (Boolean(packageB64) === Boolean(packagePath)) {
+            throw new DaemonAPIError('invalid_args', 'exactly one of packageB64 or packagePath is required', {});
+        }
+        return this.call('group_copy_preview_import', compactRecord({
+            package_b64: packageB64,
+            package_path: packagePath,
+        }));
     }
-    /**
-     * Read the provider capability matrix for a group.
-     */
-    async groupSpaceCapabilities(options) {
-        return this.call('group_space_capabilities', {
-            group_id: options.groupId,
-            provider: options.provider ?? 'notebooklm',
+    async groupCopyImport(options) {
+        const packageB64 = options.packageB64;
+        const packagePath = options.packagePath;
+        if (Boolean(packageB64) === Boolean(packagePath)) {
+            throw new DaemonAPIError('invalid_args', 'exactly one of packageB64 or packagePath is required', {});
+        }
+        const args = compactRecord({
+            package_b64: packageB64,
+            package_path: packagePath,
         });
+        if (options.workspaceRoot)
+            args['workspace_root'] = options.workspaceRoot;
+        if (options.title)
+            args['title'] = options.title;
+        return this.call('group_copy_import', args);
     }
-    /**
-     * Bind or unbind one Group Space lane.
-     */
-    async groupSpaceBind(options) {
+    // ============================================================
+    // Convenience methods: capability extensions
+    // ============================================================
+    async capabilityVisibility(options) {
         const args = {
             group_id: options.groupId,
-            provider: options.provider ?? 'notebooklm',
-            lane: options.lane,
-            action: options.action ?? 'bind',
+            capability_id: options.capabilityId,
+            hidden: options.hidden ?? true,
             by: options.by ?? 'user',
         };
-        if (options.remoteSpaceId)
-            args['remote_space_id'] = options.remoteSpaceId;
-        return this.call('group_space_bind', args);
+        if (options.actorId)
+            args['actor_id'] = options.actorId;
+        if (options.reason)
+            args['reason'] = options.reason;
+        return this.call('capability_visibility', args);
     }
-    /**
-     * Enqueue one Group Space ingest action.
-     */
-    async groupSpaceIngest(options) {
+    async capabilityInstallTarget(options) {
         const args = {
             group_id: options.groupId,
-            provider: options.provider ?? 'notebooklm',
-            lane: options.lane,
-            kind: options.kind ?? 'context_sync',
+            target: options.target,
+            scope: options.scope ?? 'actor',
             by: options.by ?? 'user',
         };
-        if (options.payload)
-            args['payload'] = options.payload;
-        if (options.idempotencyKey)
-            args['idempotency_key'] = options.idempotencyKey;
-        return this.call('group_space_ingest', args);
+        if (options.actorId)
+            args['actor_id'] = options.actorId;
+        if (options.ttlSeconds !== undefined)
+            args['ttl_seconds'] = options.ttlSeconds;
+        if (options.reason)
+            args['reason'] = options.reason;
+        return this.call('capability_install_target', args);
     }
-    /**
-     * Query Group Space knowledge for one lane.
-     */
-    async groupSpaceQuery(options) {
+    async capabilitySourceDelete(options) {
         const args = {
             group_id: options.groupId,
-            provider: options.provider ?? 'notebooklm',
-            lane: options.lane,
-            query: options.query,
+            source_id: options.sourceId,
+            by: options.by ?? 'user',
         };
-        if (options.options)
-            args['options'] = options.options;
-        return this.call('group_space_query', args);
+        if (options.reason)
+            args['reason'] = options.reason;
+        if (options.actorId)
+            args['actor_id'] = options.actorId;
+        return this.call('capability_source_delete', args);
     }
-    /**
-     * Manage remote sources in the bound Group Space lane.
-     */
-    async groupSpaceSources(options) {
+    // ============================================================
+    // Convenience methods: presentation workspace
+    // ============================================================
+    async presentationGet(options) {
+        return this.call('presentation_get', { group_id: options.groupId });
+    }
+    async presentationPublish(options) {
         const args = {
             group_id: options.groupId,
-            provider: options.provider ?? 'notebooklm',
-            lane: options.lane,
-            action: options.action ?? 'list',
             by: options.by ?? 'user',
         };
-        if (options.sourceId)
-            args['source_id'] = options.sourceId;
-        if (options.newTitle)
-            args['new_title'] = options.newTitle;
-        return this.call('group_space_sources', args);
-    }
-    /**
-     * List, generate, or download Group Space artifacts.
-     */
-    async groupSpaceArtifact(options) {
+        if (options.slot)
+            args['slot'] = options.slot;
+        if (options.title)
+            args['title'] = options.title;
+        if (options.summary)
+            args['summary'] = options.summary;
+        if (options.sourceLabel)
+            args['source_label'] = options.sourceLabel;
+        if (options.sourceRef)
+            args['source_ref'] = options.sourceRef;
+        if (options.cardType)
+            args['card_type'] = options.cardType;
+        if (options.content)
+            args['content'] = options.content;
+        if (options.path)
+            args['path'] = options.path;
+        if (options.url)
+            args['url'] = options.url;
+        if (options.blobRelPath)
+            args['blob_rel_path'] = options.blobRelPath;
+        if (options.table)
+            args['table'] = options.table;
+        return this.call('presentation_publish', args);
+    }
+    async presentationClear(options) {
         const args = {
             group_id: options.groupId,
-            provider: options.provider ?? 'notebooklm',
-            lane: options.lane,
-            action: options.action ?? 'list',
             by: options.by ?? 'user',
         };
-        if (options.kind)
-            args['kind'] = options.kind;
-        if (options.options)
-            args['options'] = options.options;
-        if (options.wait !== undefined)
-            args['wait'] = options.wait;
-        if (options.saveToSpace !== undefined)
-            args['save_to_space'] = options.saveToSpace;
-        if (options.outputPath)
-            args['output_path'] = options.outputPath;
-        if (options.outputFormat)
-            args['output_format'] = options.outputFormat;
-        if (options.artifactId)
-            args['artifact_id'] = options.artifactId;
-        if (options.timeoutSeconds !== undefined)
-            args['timeout_seconds'] = options.timeoutSeconds;
-        if (options.initialInterval !== undefined)
-            args['initial_interval'] = options.initialInterval;
-        if (options.maxInterval !== undefined)
-            args['max_interval'] = options.maxInterval;
-        return this.call('group_space_artifact', args);
+        if (options.slot)
+            args['slot'] = options.slot;
+        return this.call('presentation_clear', args);
     }
-    /**
-     * List or manage Group Space jobs.
-     */
-    async groupSpaceJobs(options) {
-        const args = {
+    /** @deprecated This browser surface is served by CCCC Web, not daemon IPC. */
+    async presentationBrowserOpen(options) {
+        void options;
+        throw new IncompatibleDaemonError("Presentation browsers are no longer served by daemon IPC; use the CCCC Web Presentation browser surface");
+    }
+    /** @deprecated This browser surface is served by CCCC Web, not daemon IPC. */
+    async presentationBrowserInfo(options) {
+        void options;
+        throw new IncompatibleDaemonError("Presentation browsers are no longer served by daemon IPC; use the CCCC Web Presentation browser surface");
+    }
+    /** @deprecated This browser surface is served by CCCC Web, not daemon IPC. */
+    async presentationBrowserClose(options) {
+        void options;
+        throw new IncompatibleDaemonError("Presentation browsers are no longer served by daemon IPC; use the CCCC Web Presentation browser surface");
+    }
+    // ============================================================
+    // Convenience methods: built-in assistants (PET / Voice Secretary)
+    // ============================================================
+    async assistantState(options) {
+        const args = { group_id: options.groupId };
+        if (options.assistantId)
+            args['assistant_id'] = options.assistantId;
+        if (options.promptRequestId)
+            args['prompt_request_id'] = options.promptRequestId;
+        return this.call('assistant_state', args);
+    }
+    async assistantVoiceRecordingLease(options) {
+        return this.call('assistant_voice_recording_lease', compactRecord({
             group_id: options.groupId,
-            provider: options.provider ?? 'notebooklm',
-            lane: options.lane,
-            action: options.action ?? 'list',
+            action: options.action,
             by: options.by ?? 'user',
-        };
-        if (options.jobId)
-            args['job_id'] = options.jobId;
-        if (options.state)
-            args['state'] = options.state;
-        if (options.limit !== undefined)
-            args['limit'] = options.limit;
-        return this.call('group_space_jobs', args);
+            owner_id: options.ownerId,
+            lease_id: options.leaseId,
+            ttl_seconds: options.ttlSeconds,
+            capture_mode: options.captureMode,
+            recognition_backend: options.recognitionBackend,
+        }));
     }
-    /**
-     * Read or run Group Space synchronization for one lane.
-     */
-    async groupSpaceSync(options) {
-        return this.call('group_space_sync', {
+    async assistantSettingsUpdate(options) {
+        return this.call('assistant_settings_update', {
             group_id: options.groupId,
-            provider: options.provider ?? 'notebooklm',
-            lane: options.lane,
-            action: options.action ?? 'status',
-            force: options.force ?? false,
+            assistant_id: options.assistantId,
+            patch: options.patch,
             by: options.by ?? 'user',
         });
     }
-    /**
-     * Read provider credential status.
-     */
-    async groupSpaceProviderCredentialStatus(options = {}) {
-        return this.call('group_space_provider_credential_status', {
-            provider: options.provider ?? 'notebooklm',
+    async assistantStatusUpdate(options) {
+        const args = {
+            group_id: options.groupId,
+            assistant_id: options.assistantId,
+            lifecycle: options.lifecycle,
+        };
+        if (options.health)
+            args['health'] = options.health;
+        if (options.by)
+            args['by'] = options.by;
+        return this.call('assistant_status_update', args);
+    }
+    // ============================================================
+    // Convenience methods: daemon core
+    // ============================================================
+    /** Trigger graceful daemon shutdown (no-args). */
+    async shutdown() {
+        return this.call('shutdown', {});
+    }
+    async observabilityGet() {
+        return this.call('observability_get', {});
+    }
+    async observabilityUpdate(options) {
+        return this.call('observability_update', {
+            patch: options.patch,
             by: options.by ?? 'user',
         });
     }
-    /**
-     * Update provider credentials.
-     */
-    async groupSpaceProviderCredentialUpdate(options = {}) {
+    async brandingGet() {
+        return this.call('branding_get', {});
+    }
+    async brandingUpdate(options) {
+        return this.call('branding_update', {
+            patch: options.patch,
+            by: options.by ?? 'user',
+        });
+    }
+    // ============================================================
+    // Convenience methods: diagnostics
+    // ============================================================
+    async debugSnapshot(options) {
+        return this.call('debug_snapshot', {
+            group_id: options.groupId,
+            by: options.by ?? 'user',
+        });
+    }
+    async debugTailLogs(options) {
         const args = {
-            provider: options.provider ?? 'notebooklm',
+            component: options.component,
             by: options.by ?? 'user',
-            clear: options.clear ?? false,
+            lines: options.lines ?? 200,
         };
-        if (options.authJson)
-            args['auth_json'] = options.authJson;
-        return this.call('group_space_provider_credential_update', args);
+        if (options.groupId)
+            args['group_id'] = options.groupId;
+        return this.call('debug_tail_logs', args);
     }
-    /**
-     * Run provider health check.
-     */
-    async groupSpaceProviderHealthCheck(options = {}) {
-        return this.call('group_space_provider_health_check', {
-            provider: options.provider ?? 'notebooklm',
+    async debugClearLogs(options) {
+        const args = {
+            component: options.component,
+            by: options.by ?? 'user',
+        };
+        if (options.groupId)
+            args['group_id'] = options.groupId;
+        return this.call('debug_clear_logs', args);
+    }
+    async terminalTail(options) {
+        return this.call('terminal_tail', {
+            group_id: options.groupId,
+            actor_id: options.actorId,
+            max_chars: options.maxChars ?? 8000,
+            strip_ansi: options.stripAnsi ?? true,
+            compact: options.compact ?? true,
+            by: options.by ?? 'user',
+        });
+    }
+    async terminalClear(options) {
+        return this.call('terminal_clear', {
+            group_id: options.groupId,
+            actor_id: options.actorId,
+            by: options.by ?? 'user',
+        });
+    }
+    // ============================================================
+    // Convenience methods: maintenance (ledger)
+    // ============================================================
+    async ledgerSnapshot(options) {
+        return this.call('ledger_snapshot', {
+            group_id: options.groupId,
             by: options.by ?? 'user',
+            reason: options.reason ?? 'manual',
         });
     }
+    async ledgerCompact(options) {
+        return this.call('ledger_compact', {
+            group_id: options.groupId,
+            by: options.by ?? 'user',
+            reason: options.reason ?? 'auto',
+            force: options.force ?? false,
+        });
+    }
+    // ============================================================
+    // Convenience methods: stream / system notify (low-level)
+    // ============================================================
     /**
-     * Control provider auth flow.
+     * Emit a chat.stream event (`op` = 'start' | 'update' | 'end').
+     * For 'start', a new stream_id is generated and returned. For
+     * 'update'/'end', supply the stream_id you got from 'start'.
      */
-    async groupSpaceProviderAuth(options = {}) {
+    async streamEmit(options) {
         const args = {
-            provider: options.provider ?? 'notebooklm',
-            action: options.action ?? 'status',
-            by: options.by ?? 'user',
+            group_id: options.groupId,
+            by: options.by,
+            op: options.op,
+            format: options.format ?? 'plain',
+            seq: options.seq ?? 0,
+        };
+        if (options.streamId)
+            args['stream_id'] = options.streamId;
+        if (options.text !== undefined)
+            args['text'] = options.text;
+        if (options.to)
+            args['to'] = options.to;
+        if (options.replyTo)
+            args['reply_to'] = options.replyTo;
+        if (options.clientId)
+            args['client_id'] = options.clientId;
+        return this.call('stream_emit', args);
+    }
+    async systemNotify(options) {
+        const args = {
+            group_id: options.groupId,
+            by: options.by ?? 'system',
+            kind: options.kind ?? 'info',
+            priority: options.priority ?? 'normal',
         };
-        if (options.timeoutSeconds !== undefined)
-            args['timeout_seconds'] = options.timeoutSeconds;
-        return this.call('group_space_provider_auth', args);
+        if (options.message)
+            args['message'] = options.message;
+        if (options.title)
+            args['title'] = options.title;
+        if (options.targetActorId)
+            args['target_actor_id'] = options.targetActorId;
+        if (options.imVisibility)
+            args['im_visibility'] = options.imVisibility;
+        if (options.context)
+            args['context'] = options.context;
+        return this.call('system_notify', args);
+    }
+    // ============================================================
+    // Convenience methods: registry / group admin
+    // ============================================================
+    async registryReconcile(options = {}) {
+        return this.call('registry_reconcile', {
+            remove_missing: options.removeMissing ?? false,
+        });
+    }
+    async groupDetachScope(options) {
+        return this.call('group_detach_scope', {
+            group_id: options.groupId,
+            scope_key: options.scopeKey,
+            by: options.by ?? 'user',
+        });
     }
     // ============================================================
     // Event stream
@@ -1284,12 +1395,11 @@ export class CCCCClient {
      * Subscribe to the group event stream (Server-Sent Events style, long-lived connection).
      * Yields {@link EventStreamItem} objects as they arrive. The socket is destroyed
      * when the generator is returned or thrown.
-     * @param options - Group ID, event filters, optional since cursor, and optional AbortSignal.
+     * @param options - Group ID, event filters, and optional since cursor.
      * @yields {EventStreamItem} Each event or heartbeat from the stream.
      * @throws {DaemonAPIError} If the handshake fails.
      */
     async *eventsStream(options) {
-        // Check abort before connecting
         if (options.signal?.aborted)
             return;
         const args = {
@@ -1312,44 +1422,61 @@ export class CCCCClient {
             op: 'events_stream',
             args,
         };
-        const { socket, handshake, initialBuffer } = await openEventsStream(this._endpoint, request, options.timeoutMs ?? this._timeoutMs);
+        const streamTimeoutMs = options.timeoutMs ?? this._timeoutMs;
+        let connection;
+        try {
+            connection = await openEventsStream(this._endpoint, request, streamTimeoutMs, options.signal);
+        }
+        catch (error) {
+            if (!(error instanceof DaemonConnectionError) || this._endpointExplicit) {
+                throw error;
+            }
+            this._endpoint = await discoverEndpoint(this._ccccHome);
+            connection = await openEventsStream(this._endpoint, request, streamTimeoutMs, options.signal);
+        }
+        const { socket, handshake, initialBuffer } = connection;
+        if (options.signal?.aborted) {
+            socket.destroy();
+            return;
+        }
+        if (handshake.v !== undefined && handshake.v !== 1) {
+            socket.destroy();
+            throw new IncompatibleDaemonError(`Daemon stream handshake uses unsupported IPC version: ${handshake.v}`);
+        }
         if (!handshake.ok) {
             socket.destroy();
             throw new DaemonAPIError(handshake.error?.code ?? 'unknown', handshake.error?.message ?? 'Handshake failed', handshake.error?.details, handshake);
         }
-        // Wire up AbortSignal to destroy the socket
-        const onAbort = () => { socket.destroy(); };
-        options.signal?.addEventListener('abort', onAbort, { once: true });
+        const abortStream = () => socket.destroy();
+        options.signal?.addEventListener('abort', abortStream, { once: true });
         try {
             for await (const line of readLines(socket, initialBuffer)) {
-                if (options.signal?.aborted)
-                    return;
-                let parsed;
                 try {
-                    parsed = JSON.parse(line);
-                }
-                catch {
-                    // Non-JSON line from daemon; surface as an error so callers know
-                    // something unexpected happened instead of silently losing data.
-                    throw new DaemonAPIError('invalid_stream_data', `Unparseable event stream line: ${line.slice(0, 200)}`, {});
-                }
-                if (parsed !== null && typeof parsed === 'object') {
-                    const obj = parsed;
-                    // Daemon may send error objects in the stream (ok: false).
-                    if ('ok' in obj && obj['ok'] === false) {
-                        const err = obj['error'];
-                        throw new DaemonAPIError(err?.['code'] ?? 'stream_error', err?.['message'] ?? 'Daemon sent error in event stream', err?.['details'] ?? {}, obj);
-                    }
-                    if ('t' in obj) {
+                    const parsed = JSON.parse(line);
+                    if (parsed !== null && typeof parsed === 'object' && 't' in parsed) {
                         yield parsed;
                     }
                 }
+                catch {
+                    // Skip invalid JSON lines.
+                }
             }
         }
+        catch (error) {
+            // Cancelling an established subscription is normal completion. Preserve
+            // unexpected transport/decoding errors when the caller did not cancel.
+            if (!options.signal?.aborted)
+                throw error;
+        }
         finally {
-            options.signal?.removeEventListener('abort', onAbort);
+            options.signal?.removeEventListener('abort', abortStream);
             socket.destroy();
         }
     }
 }
+installCCCC0430Ops(CCCCClient.prototype);
+installCCCC0434Ops(CCCCClient.prototype);
+installGroupSpaceOps(CCCCClient.prototype);
+installChatOps(CCCCClient.prototype);
+installConnectOps(CCCCClient.prototype);
 //# sourceMappingURL=client.js.map