cccc-sdk 0.4.3 → 0.4.40

package/README.md

@@ -5,7 +5,7 @@ TypeScript/Node.js client for the CCCC daemon (IPC v1).
 ## Relationship to CCCC core
 
 - CCCC core repository: https://github.com/ChesterRa/cccc
-- `cccc` core provides daemon/web/CLI and owns runtime state.
+- `cccc` core provides one native Rust daemon/web/CLI product and owns runtime state.
 - `cccc-sdk` provides Node.js client APIs that call the daemon over IPC.
 
 ## Installation
@@ -14,7 +14,9 @@ TypeScript/Node.js client for the CCCC daemon (IPC v1).
 npm install cccc-sdk
 ```
 
-Compatibility is determined by Daemon IPC v1 contracts and operation probing, not by strict package-version matching.
+Compatibility is determined by Daemon IPC v1 contracts and operation probing,
+not by strict package-version matching. The current message contract is an
+intentional atomic cut: upgrade SDK and daemon together.
 
 ## Quick start
 
@@ -26,34 +28,104 @@ async function main() {
 
   await client.assertCompatible({
     requireIpcV: 1,
-    requireCapabilities: { events_stream: true },
-    requireOps: ['groups', 'send', 'reply', 'group_automation_manage'],
+    requireOps: ['groups', 'send', 'reply', 'tracked_send', 'context_sync'],
   });
 
-  const group = await client.groupCreate({ title: 'TS demo' });
-  const groupId = String(group.group_id || '');
+  // Use an existing Group and an Agent ID from that Group.
+  const groupId = 'g_your_group_id';
 
   await client.send({
     groupId,
     text: 'Please check this and reply.',
-    priority: 'attention',
-    replyRequired: true,
+    mode: 'request_reply',
+    to: ['peer-1'],
   });
 }
 
-main().catch(console.error);
+main().catch(error => {
+  console.error(error);
+  process.exitCode = 1;
+});
 ```
 
 ## Message semantics
 
-- `priority`: `'normal' | 'attention'`
-- `replyRequired`: `boolean` (maps to daemon `reply_required`)
+- `mode`: `'mail' | 'send' | 'request_reply'` (required for new messages)
+- `insight`: optional visible, provisional sender perspective for independent recipient judgment
+- `suggestedUserMessage`: optional proposed next human message; stored visibly and never auto-sent
 
 Supported in:
 - `send(options)`
-- `reply(options)`
 - `sendCrossGroup(options)`
 
+`mail` stores without an immediate runtime prompt, `send` performs a
+best-effort immediate Push, and `request_reply` adds a concrete reply request.
+`reply(options)` defaults to Send and accepts `mode: 'mail'` for an agent-only,
+non-urgent reply; both modes fulfill the original reply request. The visible
+message emitted by `trackedSend(options)` remains Send. Generic ACK operations no longer exist; consume Inbox contents
+with `inboxRead(options)`. Inbox contains only Mail; inspect past direct or Mail
+traffic without changing the Mail cursor through `messageHistory(options)`.
+
+`suggestedUserMessage` is supported by `send(options)` and `reply(options)`.
+
+`contextGet(groupId, detail)` accepts `overview`, `summary`, or `full`.
+`taskList(options)` supports exact batches, filters, atomic status pages, and
+pagination. `groupSpaceSync(options)` is a read-only legacy-status call; use
+explicit ingest/source operations for mutations.
+
+## Workflow helpers
+
+Current CCCC workflow contracts are exposed as focused wrappers over daemon IPC:
+
+```typescript
+await client.trackedSend({
+  groupId,
+  title: 'Update SDK',
+  text: 'Please handle the compatibility update.',
+  insight: 'The compatibility plan may preserve an obsolete boundary.',
+  outcome: 'Tests and live compat pass',
+  assignee: 'peer-impl',
+});
+
+await client.coordinationBriefUpdate({
+  groupId,
+  objective: 'Ship SDK updates',
+  currentFocus: 'context v3 compatibility',
+});
+
+await client.taskMove({ groupId, taskId: 't_xxx', status: 'done' });
+await client.agentStateUpdate({ groupId, actorId: 'peer-impl', focus: 'testing' });
+await client.capabilitySearch({ groupId, query: 'docs' });
+await client.memoryHealth({ groupId });
+const profile = await client.memoryProfileGet({
+  groupId,
+  actorId: 'dingtalk-worker',
+  tags: ['dingtalk-profile', 'reply-style'],
+});
+const hits = await client.memorySearch({
+  groupId,
+  actorId: 'dingtalk-worker',
+  query: 'How should I reply to this message?',
+  limit: 5,
+  minScore: 0.2,
+  target: 'memory',
+});
+await client.memoryWrite({
+  groupId,
+  actorId: 'dingtalk-worker',
+  target: 'daily',
+  content: 'user: ...\nassistant: ...',
+  tags: ['dingtalk-auto-reply'],
+  sourceRefs: ['dingtalk:message:m1'],
+  idempotencyKey: 'dingtalk-reply:m1',
+});
+```
+
+Local memory helpers use daemon `memory_*` ops and are intended for fast local
+CCCC memory access. They do not depend on Group Space / NotebookLM bindings.
+For raw ReMe result shapes or source selection, use `memoryRemeSearch` and
+`memoryRemeGet`. See `spec/SDK_LOCAL_MEMORY_API.md` in the repository root.
+
 ## Automation semantics
 
 `groupAutomationManage` is action-list based (canonical daemon shape):
@@ -84,12 +156,10 @@ const client = await CCCCClient.create();
 
 const upsert = await client.actorProfileUpsert({
   profile: {
-    name: 'Codex PTY',
+    name: 'Codex',
     runtime: 'codex',
-    runner: 'pty',
-    command: ['codex', 'exec'],
+    command: ['codex'],
     submit: 'enter',
-    env: { CODEX_MODEL: 'gpt-5' },
     capabilityDefaults: {
       autoloadCapabilities: ['pack:space'],
       defaultScope: 'actor',
@@ -143,6 +213,194 @@ await client.contextSync({
 
 If you need a daemon op that does not have a dedicated helper yet, you can always fall back to `call()` / `callRaw()`.
 
+## Current native-daemon compatibility surface
+
+```typescript
+// Capture the bounded ANSI screen and exact raw cursor boundary.
+const snapshot = await client.terminalSnapshot({
+  groupId,
+  actorId: 'web-model',
+  limitBytes: 512_000,
+});
+
+// Read or change the durable delivery mode for a Web Model actor.
+const preference = await client.webModelDeliveryPreferencesGet({
+  groupId,
+  actorId: 'web-model',
+});
+await client.webModelDeliveryPreferencesUpdate({
+  groupId,
+  actorId: 'web-model',
+  mode: 'image_compat',
+});
+
+// Inspect a committed legacy turn without moving the actor cursor.
+const recovered = await client.webModelRuntimeRecoverTurn({
+  groupId,
+  actorId: 'web-model',
+  eventIds: ['e_xxx'],
+});
+```
+
+`termResize()` sends the standard `term_resize` operation. For older compatible
+daemon builds that expose `terminal_resize`, the SDK falls back only
+after receiving a structured `unknown_op`; transport failures are never
+replayed, and the legacy result is normalized to the standard shape.
+Auto-discovered clients re-read `ccccd.addr.json` when connection
+establishment fails before any request bytes are sent. Explicit endpoints are
+never replaced.
+
+This alignment pass also corrects the exact ReMe, global Remote Access,
+group-scoped IM authorization, Voice model installation, group-copy, and chat
+wire fields. `capabilitySourceDelete()` is deliberately source-scoped: the
+current daemon does not implement instance-scoped deletion and callers should
+not assume otherwise.
+
+## CCCC 0.4.33 compatibility delta
+
+```typescript
+// Deliberately rotate provider session metadata for Claude, Codex and Grok.
+await client.actorNewSession(groupId, 'reviewer');
+
+// Page through retained PTY output by cursor.
+const page = await client.terminalHistory({
+  groupId,
+  actorId: 'reviewer',
+  limitBytes: 64_000,
+});
+
+// Large group copies use a daemon-local package path instead of base64 IPC.
+const exported = await client.groupCopyExportFile({ groupId });
+const packagePath = String(exported.package_path);
+const preview = await client.groupCopyPreviewImport({ packagePath });
+const copied = await client.groupCopyImport({ packagePath });
+
+// Manage the startup body delivered to the next fresh provider session.
+await client.groupPreambleSet({
+  groupId,
+  content: 'This initialization is not a task. Wait for the targeted mission.\n',
+});
+const preamble = await client.groupPreambleGet({ groupId });
+await client.groupPreambleReset({ groupId, confirm: 'preamble' });
+
+// Upload active-scope files and append one message with daemon-owned attachments.
+await client.sendFiles({
+  groupId,
+  paths: ['reference.png', 'candidate.png'],
+  text: 'Inspect these files',
+  to: ['reviewer'],
+});
+
+// Current terminal operations.
+const recent = await client.terminalSince({ groupId, actorId: 'reviewer', after: 0 });
+await client.termResize({ groupId, actorId: 'reviewer', cols: 120, rows: 40 });
+```
+
+A changed preamble applies on its next delivery; it is not reinjected into a
+session that already received one. `groupReset` creates a new group id and
+does not carry the override forward. If the preamble establishes a standby
+boundary, wait until the actor returns to `waiting` or `idle` before sending
+the authoritative mission. `sendFiles` accepts only regular files beneath
+the group's active scope and validates every path before appending the message.
+
+`events_stream` compatibility is verified by probing the operation itself;
+the SDK does not rely only on the daemon's advertised capability flag.
+
+`groupReset` is destructive: it creates a clean replacement and removes the
+old group after copying selected configuration. `confirmGroupId` must equal
+`groupId`:
+
+```typescript
+await client.groupReset({ groupId, confirmGroupId: groupId });
+```
+
+## CCCC 0.4.18 surface — Hermes runtime and Voice Secretary lease
+
+```typescript
+// Hermes runtime setup diagnostics and MCP preparation
+const status = await client.runtimeHermesStatus();
+await client.runtimeHermesPrepare({ cwd: '.', autoEnableTools: true });
+await client.runtimeHermesMcpTest({ groupId, actorId: 'hermes-1' });
+
+// Cross-tab Voice Secretary recording guard
+const lease = await client.assistantVoiceRecordingLease({
+  groupId,
+  action: 'acquire',
+  ownerId: 'browser-tab-1',
+  ttlSeconds: 30,
+});
+```
+
+## CCCC 0.4.17 surface — new op families
+
+```typescript
+const client = await CCCCClient.create();
+
+// Tracked delegation — atomic task.create + send with idempotent replay
+const tracked = await client.trackedSend({
+  groupId,
+  title: 'Fix login race',
+  text: 'Please pick this up — see issue link',
+  insight: 'The proposed fix may target the symptom rather than the ownership boundary.',
+  to: ['alice'],
+  idempotencyKey: 'fix-login-race-1',
+  refs: [{ kind: 'url', url: 'https://example.com/issue/42' }],
+});
+
+// Per-task drill-down
+const task = await client.taskList({ groupId, taskId: String(tracked.task_id) });
+
+// Structured refs on chat
+await client.send({
+  groupId,
+  text: 'Looking at the demo deck',
+  insight: 'The deck may make the current option set look more settled than it is.',
+  refs: [{ kind: 'presentation_ref', slot_id: 'slot-1' }],
+});
+
+// Presentation workspace (slot-based viewer)
+await client.presentationPublish({
+  groupId,
+  slot: 'slot-1',
+  title: 'Plan',
+  cardType: 'markdown',
+  content: '# Sprint plan\n- ...',
+});
+
+// Built-in Voice Secretary lifecycle
+await client.assistantSettingsUpdate({
+  groupId,
+  assistantId: 'voice_secretary',
+  patch: { enabled: true },
+});
+
+// Copy a group for migration / backup
+const pkg = await client.groupCopyExport({ groupId });
+const newGroup = await client.groupCopyImport({ packageB64: String(pkg.package_b64) });
+
+// Headless runtime control
+await client.headlessSetStatus({ groupId, actorId: 'reviewer', status: 'working' });
+
+// Capability Center extensions
+await client.capabilityInstallTarget({
+  groupId,
+  target: 'github:owner/repo',
+  actorId: 'reviewer',
+  scope: 'session',
+  ttlSeconds: 600,
+});
+
+// Operator-side: terminal tail, ledger snapshot, branding/observability
+await client.terminalTail({ groupId, actorId: 'reviewer', maxChars: 4000 });
+await client.ledgerSnapshot({ groupId, reason: 'manual' });
+await client.brandingUpdate({ patch: { product_name: 'My CCCC' } });
+```
+
+Use `call()` for intentionally low-level or newly added non-streaming ops that
+do not yet have a dedicated helper. Duplex browser/VNC/PTY attach operations
+remain outside this request/response client and require a separate streaming
+transport contract. See `spec/ADAPTATION_PLAN.md` for the exact boundary.
+
 ## Events stream
 
 ```typescript
@@ -163,9 +421,37 @@ npm run build
 
 ## Requirements
 
-- Node.js 16+
+- Node.js 18+
 - Running CCCC daemon
 
 ## License
 
 Apache-2.0
+
+## CCCC 0.4.40 alignment
+
+All three SDK package versions are 0.4.40; `spec/core.json` records the supported
+core revision. The matching release number is not a replacement for IPC and
+capability checks.
+
+Qualified Connect sends require a stable caller-owned retry key:
+
+```ts
+await client.connectSend({ groupId: 'local', instanceId: 'remote-instance', targetGroupId: 'remote-group',
+  clientId: 'retained-caller-key', text: 'Please review', mode: 'mail' });
+```
+
+Use `connect_catalog` / `connectCatalog` to read authorized cached peers and
+`connect_send_files` / `connectSendFiles` to send files from the daemon's project
+scope. Accepted means queued locally, not confirmed delivery. Keep the same key
+and body after an uncertain result; the SDK never automatically replays a send.
+Connect replies use the local received event ID with the ordinary reply helper.
+
+`context_sync(if_version=...)` / `contextSync({ ifVersion })` rejects stale
+updates with `version_conflict`. Reload before deciding whether to reapply.
+Terminal history accepts `render_before` / `renderBefore` alongside `before`.
+
+Compatibility requirements that lack an advertised capability and an audited
+safe probe now fail instead of being executed or silently skipped. Retired
+Presentation browser and Voice model-install helpers fail locally with migration
+guidance; their interactive replacement belongs to CCCC Web, not daemon IPC.

package/dist/client.d.ts

@@ -1,7 +1,12 @@
 /**
  * CCCC SDK client
  */
-import type { DaemonEndpoint, DaemonResponse, CCCCClientOptions, CompatibilityOptions, SendOptions, SendCrossGroupOptions, ReplyOptions, ActorAddOptions, ActorUpdateOptions, ActorEnvPrivateUpdateOptions, ActorProfileUpsertOptions, ActorProfileSecretUpdateOptions, ActorProfileSecretCopyFromActorOptions, ActorProfileSecretCopyFromProfileOptions, GroupCreateOptions, GroupUpdateOptions, CapabilityOverviewOptions, CapabilitySearchOptions, CapabilityEnableOptions, CapabilityBlockOptions, CapabilityStateOptions, CapabilityAllowlistGetOptions, CapabilityAllowlistValidateOptions, CapabilityAllowlistUpdateOptions, CapabilityAllowlistResetOptions, CapabilityImportOptions, CapabilityUninstallOptions, CapabilityToolCallOptions, GroupAutomationUpdateOptions, GroupAutomationManageOptions, GroupAutomationResetBaselineOptions, GroupSpaceStatusOptions, GroupSpaceSpacesOptions, GroupSpaceCapabilitiesOptions, GroupSpaceBindOptions, GroupSpaceIngestOptions, GroupSpaceQueryOptions, GroupSpaceSourcesOptions, GroupSpaceArtifactOptions, GroupSpaceJobsOptions, GroupSpaceSyncOptions, GroupSpaceProviderCredentialStatusOptions, GroupSpaceProviderCredentialUpdateOptions, GroupSpaceProviderHealthCheckOptions, GroupSpaceProviderAuthOptions, InboxListOptions, ContextSyncOptions, EventsStreamOptions, EventStreamItem } from './types.js';
+import { type ConnectOps } from './client_connect_ops.js';
+import type { DaemonEndpoint, DaemonResponse, CCCCClientOptions, CompatibilityOptions, ActorAddOptions, ActorUpdateOptions, GroupResetOptions, ActorEnvPrivateUpdateOptions, ActorProfileUpsertOptions, ActorProfileSecretUpdateOptions, ActorProfileSecretCopyFromActorOptions, ActorProfileSecretCopyFromProfileOptions, GroupCreateOptions, GroupUpdateOptions, CapabilityOverviewOptions, CapabilitySearchOptions, CapabilityEnableOptions, CapabilityBlockOptions, CapabilityStateOptions, CapabilityAllowlistGetOptions, CapabilityAllowlistValidateOptions, CapabilityAllowlistUpdateOptions, CapabilityAllowlistResetOptions, CapabilityImportOptions, CapabilityUninstallOptions, CapabilityToolCallOptions, CapabilityVisibilityOptions, CapabilityInstallTargetOptions, CapabilitySourceDeleteOptions, GroupAutomationUpdateOptions, GroupAutomationManageOptions, GroupAutomationResetBaselineOptions, ContextSyncOptions, CoordinationBriefUpdateOptions, CoordinationNoteAddOptions, TaskCreateOptions, TaskUpdateOptions, TaskMoveOptions, TaskRestoreOptions, TaskDeleteOptions, AgentStateUpdateOptions, AgentStateClearOptions, MetaMergeOptions, EventsStreamOptions, EventStreamItem, ContextGetResult, ContextDetail, CapabilityUseOptions, MemorySearchOptions, MemoryGetOptions, MemoryWriteOptions, MemoryHealthOptions, MemoryProfileGetOptions, TrackedSendOptions, TaskListOptions, HeadlessStatusOptions, HeadlessSetStatusOptions, GroupCopyExportOptions, GroupCopyPreviewImportOptions, GroupCopyImportOptions, PresentationGetOptions, PresentationPublishOptions, PresentationClearOptions, PresentationBrowserOpenOptions, PresentationBrowserInfoOptions, PresentationBrowserCloseOptions, AssistantStateOptions, AssistantVoiceRecordingLeaseOptions, AssistantSettingsUpdateOptions, AssistantStatusUpdateOptions, ObservabilityUpdateOptions, BrandingUpdateOptions, DebugSnapshotOptions, DebugTailLogsOptions, DebugClearLogsOptions, TerminalTailOptions, TerminalClearOptions, LedgerSnapshotOptions, LedgerCompactOptions, StreamEmitOptions, SystemNotifyOptions, RegistryReconcileOptions, GroupDetachScopeOptions, RuntimeHermesPrepareOptions, RuntimeHermesMcpTestOptions } from './types.js';
+import { type CCCC0430Ops } from './client_0430_ops.js';
+import { type CCCC0434Ops } from './client_0434_ops.js';
+import { type GroupSpaceOps } from './client_group_space_ops.js';
+import { type ChatOps } from './client_chat_ops.js';
 /**
  * Client for communicating with the CCCC daemon over IPC (Unix socket or TCP).
  *
@@ -12,8 +17,10 @@ import type { DaemonEndpoint, DaemonResponse, CCCCClientOptions, CompatibilityOp
  * ```
  */
 export declare class CCCCClient {
-    private readonly _endpoint;
+    private _endpoint;
     private readonly _timeoutMs;
+    private readonly _ccccHome?;
+    private readonly _endpointExplicit;
     private constructor();
     /**
      * Create a new client instance, auto-discovering the daemon endpoint.
@@ -77,6 +84,8 @@ export declare class CCCCClient {
      * Delete group
      */
     groupDelete(groupId: string, by?: string): Promise<Record<string, unknown>>;
+    /** Replace a group with a clean group while preserving selected configuration. */
+    groupReset(options: GroupResetOptions): Promise<Record<string, unknown>>;
     /**
      * Use group (set active scope)
      */
@@ -123,7 +132,7 @@ export declare class CCCCClient {
     actorList(groupId: string): Promise<Record<string, unknown>>;
     /**
      * 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.
      */
@@ -148,6 +157,9 @@ export declare class CCCCClient {
      * Restart actor
      */
     actorRestart(groupId: string, actorId: string, by?: string): Promise<Record<string, unknown>>;
+    runtimeHermesStatus(): Promise<Record<string, unknown>>;
+    runtimeHermesPrepare(options?: RuntimeHermesPrepareOptions): Promise<Record<string, unknown>>;
+    runtimeHermesMcpTest(options?: RuntimeHermesMcpTestOptions): Promise<Record<string, unknown>>;
     /**
      * List actor private env keys (without values)
      */
@@ -236,105 +248,84 @@ export declare class CCCCClient {
      * Call one enabled dynamic capability tool through daemon IPC.
      */
     capabilityToolCall(options: CapabilityToolCallOptions): Promise<Record<string, unknown>>;
-    /**
-     * Send a chat message to a group.
-     * @param options - Message content, recipients, and priority.
-     * @returns The daemon result (includes event id).
-     * @throws {DaemonAPIError} On invalid group, missing permissions, etc.
-     */
-    send(options: SendOptions): Promise<Record<string, unknown>>;
-    /**
-     * Send message across groups
-     */
-    sendCrossGroup(options: SendCrossGroupOptions): Promise<Record<string, unknown>>;
-    /**
-     * Reply message
-     */
-    reply(options: ReplyOptions): Promise<Record<string, unknown>>;
-    /**
-     * Acknowledge chat message
-     */
-    chatAck(groupId: string, actorId: string, eventId: string, by?: string): Promise<Record<string, unknown>>;
-    /**
-     * List inbox
-     */
-    inboxList(options: InboxListOptions): Promise<Record<string, unknown>>;
-    /**
-     * Mark message as read
-     */
-    inboxMarkRead(groupId: string, actorId: string, eventId: string, by?: string): Promise<Record<string, unknown>>;
-    /**
-     * Mark all messages as read
-     */
-    inboxMarkAllRead(groupId: string, actorId: string, by?: string, kindFilter?: string): Promise<Record<string, unknown>>;
-    /**
-     * Acknowledge notification
-     */
-    notifyAck(groupId: string, actorId: string, notifyEventId: string, by?: string): Promise<Record<string, unknown>>;
+    capabilityUse(options: CapabilityUseOptions): Promise<Record<string, unknown>>;
+    memorySearch(options: MemorySearchOptions): Promise<Record<string, unknown>>;
+    memoryGet(options: MemoryGetOptions): Promise<Record<string, unknown>>;
+    memoryWrite(options: MemoryWriteOptions): Promise<Record<string, unknown>>;
+    memoryHealth(options: MemoryHealthOptions): Promise<Record<string, unknown>>;
+    memoryProfileGet(options: MemoryProfileGetOptions): Promise<Record<string, unknown>>;
     /**
      * Get group context
      */
-    contextGet(groupId: string): Promise<Record<string, unknown>>;
+    contextGet(groupId: string, detail?: ContextDetail): Promise<ContextGetResult>;
     /**
      * Sync context
      */
     contextSync(options: ContextSyncOptions): Promise<Record<string, unknown>>;
-    /**
-     * Read Group Space provider and binding status.
-     */
-    groupSpaceStatus(options: GroupSpaceStatusOptions): Promise<Record<string, unknown>>;
-    /**
-     * List available remote spaces for binding.
-     */
-    groupSpaceSpaces(options: GroupSpaceSpacesOptions): Promise<Record<string, unknown>>;
-    /**
-     * Read the provider capability matrix for a group.
-     */
-    groupSpaceCapabilities(options: GroupSpaceCapabilitiesOptions): Promise<Record<string, unknown>>;
-    /**
-     * Bind or unbind one Group Space lane.
-     */
-    groupSpaceBind(options: GroupSpaceBindOptions): Promise<Record<string, unknown>>;
-    /**
-     * Enqueue one Group Space ingest action.
-     */
-    groupSpaceIngest(options: GroupSpaceIngestOptions): Promise<Record<string, unknown>>;
-    /**
-     * Query Group Space knowledge for one lane.
-     */
-    groupSpaceQuery(options: GroupSpaceQueryOptions): Promise<Record<string, unknown>>;
-    /**
-     * Manage remote sources in the bound Group Space lane.
-     */
-    groupSpaceSources(options: GroupSpaceSourcesOptions): Promise<Record<string, unknown>>;
-    /**
-     * List, generate, or download Group Space artifacts.
-     */
-    groupSpaceArtifact(options: GroupSpaceArtifactOptions): Promise<Record<string, unknown>>;
-    /**
-     * List or manage Group Space jobs.
-     */
-    groupSpaceJobs(options: GroupSpaceJobsOptions): Promise<Record<string, unknown>>;
-    /**
-     * Read or run Group Space synchronization for one lane.
-     */
-    groupSpaceSync(options: GroupSpaceSyncOptions): Promise<Record<string, unknown>>;
-    /**
-     * Read provider credential status.
-     */
-    groupSpaceProviderCredentialStatus(options?: GroupSpaceProviderCredentialStatusOptions): Promise<Record<string, unknown>>;
-    /**
-     * Update provider credentials.
-     */
-    groupSpaceProviderCredentialUpdate(options?: GroupSpaceProviderCredentialUpdateOptions): Promise<Record<string, unknown>>;
-    /**
-     * Run provider health check.
-     */
-    groupSpaceProviderHealthCheck(options?: GroupSpaceProviderHealthCheckOptions): Promise<Record<string, unknown>>;
-    /**
-     * Control provider auth flow.
-     */
-    groupSpaceProviderAuth(options?: GroupSpaceProviderAuthOptions): Promise<Record<string, unknown>>;
+    private contextOp;
+    coordinationBriefUpdate(options: CoordinationBriefUpdateOptions): Promise<Record<string, unknown>>;
+    coordinationNoteAdd(options: CoordinationNoteAddOptions): Promise<Record<string, unknown>>;
+    taskCreate(options: TaskCreateOptions): Promise<Record<string, unknown>>;
+    taskUpdate(options: TaskUpdateOptions): Promise<Record<string, unknown>>;
+    taskMove(options: TaskMoveOptions): Promise<Record<string, unknown>>;
+    taskRestore(options: TaskRestoreOptions): Promise<Record<string, unknown>>;
+    taskDelete(options: TaskDeleteOptions): Promise<Record<string, unknown>>;
+    agentStateUpdate(options: AgentStateUpdateOptions): Promise<Record<string, unknown>>;
+    agentStateClear(options: AgentStateClearOptions): Promise<Record<string, unknown>>;
+    metaMerge(options: MetaMergeOptions): Promise<Record<string, unknown>>;
+    /**
+     * 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).
+     */
+    trackedSend(options: TrackedSendOptions): Promise<Record<string, unknown>>;
+    /**
+     * List all tasks in a group, or fetch a single task (with children) by id.
+     */
+    taskList(options: TaskListOptions): Promise<Record<string, unknown>>;
+    headlessStatus(options: HeadlessStatusOptions): Promise<Record<string, unknown>>;
+    headlessSetStatus(options: HeadlessSetStatusOptions): Promise<Record<string, unknown>>;
+    groupCopyExport(options: GroupCopyExportOptions): Promise<Record<string, unknown>>;
+    groupCopyPreviewImport(options: GroupCopyPreviewImportOptions): Promise<Record<string, unknown>>;
+    groupCopyImport(options: GroupCopyImportOptions): Promise<Record<string, unknown>>;
+    capabilityVisibility(options: CapabilityVisibilityOptions): Promise<Record<string, unknown>>;
+    capabilityInstallTarget(options: CapabilityInstallTargetOptions): Promise<Record<string, unknown>>;
+    capabilitySourceDelete(options: CapabilitySourceDeleteOptions): Promise<Record<string, unknown>>;
+    presentationGet(options: PresentationGetOptions): Promise<Record<string, unknown>>;
+    presentationPublish(options: PresentationPublishOptions): Promise<Record<string, unknown>>;
+    presentationClear(options: PresentationClearOptions): Promise<Record<string, unknown>>;
+    /** @deprecated This browser surface is served by CCCC Web, not daemon IPC. */
+    presentationBrowserOpen(options: PresentationBrowserOpenOptions): Promise<Record<string, unknown>>;
+    /** @deprecated This browser surface is served by CCCC Web, not daemon IPC. */
+    presentationBrowserInfo(options: PresentationBrowserInfoOptions): Promise<Record<string, unknown>>;
+    /** @deprecated This browser surface is served by CCCC Web, not daemon IPC. */
+    presentationBrowserClose(options: PresentationBrowserCloseOptions): Promise<Record<string, unknown>>;
+    assistantState(options: AssistantStateOptions): Promise<Record<string, unknown>>;
+    assistantVoiceRecordingLease(options: AssistantVoiceRecordingLeaseOptions): Promise<Record<string, unknown>>;
+    assistantSettingsUpdate(options: AssistantSettingsUpdateOptions): Promise<Record<string, unknown>>;
+    assistantStatusUpdate(options: AssistantStatusUpdateOptions): Promise<Record<string, unknown>>;
+    /** Trigger graceful daemon shutdown (no-args). */
+    shutdown(): Promise<Record<string, unknown>>;
+    observabilityGet(): Promise<Record<string, unknown>>;
+    observabilityUpdate(options: ObservabilityUpdateOptions): Promise<Record<string, unknown>>;
+    brandingGet(): Promise<Record<string, unknown>>;
+    brandingUpdate(options: BrandingUpdateOptions): Promise<Record<string, unknown>>;
+    debugSnapshot(options: DebugSnapshotOptions): Promise<Record<string, unknown>>;
+    debugTailLogs(options: DebugTailLogsOptions): Promise<Record<string, unknown>>;
+    debugClearLogs(options: DebugClearLogsOptions): Promise<Record<string, unknown>>;
+    terminalTail(options: TerminalTailOptions): Promise<Record<string, unknown>>;
+    terminalClear(options: TerminalClearOptions): Promise<Record<string, unknown>>;
+    ledgerSnapshot(options: LedgerSnapshotOptions): Promise<Record<string, unknown>>;
+    ledgerCompact(options: LedgerCompactOptions): Promise<Record<string, unknown>>;
+    /**
+     * 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'.
+     */
+    streamEmit(options: StreamEmitOptions): Promise<Record<string, unknown>>;
+    systemNotify(options: SystemNotifyOptions): Promise<Record<string, unknown>>;
+    registryReconcile(options?: RegistryReconcileOptions): Promise<Record<string, unknown>>;
+    groupDetachScope(options: GroupDetachScopeOptions): Promise<Record<string, unknown>>;
     /**
      * Subscribe to the group event stream (Server-Sent Events style, long-lived connection).
      * Yields {@link EventStreamItem} objects as they arrive. The socket is destroyed
@@ -345,4 +336,6 @@ export declare class CCCCClient {
      */
     eventsStream(options: EventsStreamOptions): AsyncGenerator<EventStreamItem>;
 }
+export interface CCCCClient extends CCCC0430Ops, CCCC0434Ops, GroupSpaceOps, ChatOps, ConnectOps {
+}
 //# sourceMappingURL=client.d.ts.map