@borgee/agents-host 0.2.2 → 0.2.28

package/README.md

@@ -2,7 +2,7 @@
 
 Minimal local runtime host for Borgee agents.
 
-- **Single-agent mode** keeps the existing one-process / one-agent flow.
+- **Standalone env mode** keeps the existing one-process / one-agent flow.
 - **Local-config mode** adds first-step multi-agent local hosting from a host
   config file plus one config file per agent, with hot reload.
 
@@ -15,14 +15,15 @@ Borgee channel message
   → /ws/plugin (BPP)
   → @borgee/plugin-sdk
   → AgentsHost.handleMessage
-  → local claude / copilot CLI subprocess
+  → local claude / codex-acp / copilot runtime
   → BPP reply
   → Borgee channel
 ```
 
 **In scope:**
 
-- single-agent env / CLI startup
+- standalone env startup
+- foreground CLI startup for one hosted agent
 - local-config multi-agent startup
 - one isolated `AgentsHost` per effective agent key
 - per-channel conversation memory via each provider's native session mechanism
@@ -48,14 +49,22 @@ For the published CLI entry point:
 
 ```bash
 agents-host start <serverUrl> <apiKey> [options]
-agents-host start --config <path-to-host-config>
+agents-host start-managed <serverUrl>
+agents-host start-managed <serverUrl> <apiKey> [agent-options]
+agents-host describe-managed <serverUrl>
+agents-host apply-managed <serverUrl> --stdin
+agents-host apply-managed <serverUrl> --spec-json <json>
+agents-host log <serverUrl> [--lines <n>] [--follow]
+agents-host log <serverUrl> --path
+agents-host start --config <path-to-host-config> [--debug]
 agents-host validate --config <path-to-host-config>
+agents-host describe --config <path-to-host-config>
 agents-host print-layout --root <dir>
 agents-host generate-config --root <dir> --stdin
 agents-host generate-config --root <dir> --spec-json <json>
 ```
 
-## Single-agent mode
+## Standalone env mode
 
 Use the existing env-var flow when you want exactly one hosted agent per
 process.
@@ -68,21 +77,142 @@ RUNTIME_PROVIDER=claude \
 pnpm --filter @borgee/agents-host dev
 ```
 
+Codex remains opt-in. Select `RUNTIME_PROVIDER=codex` only when `AGENTS_HOST_INTERNAL_COMPATIBILITY_GATES` includes `codex-provider`.
+
 Or with the CLI:
 
 ```bash
-agents-host start https://your-borgee-server bgr_xxxxxxxx --provider copilot
+agents-host start https://your-borgee-server bgr_xxxxxxxx --provider copilot --debug
+```
+
+## Managed daemon bootstrap mode
+
+`agents-host start-managed` has two forms:
+
+- `agents-host start-managed <serverUrl> <apiKey> [agent-options]` bootstraps or
+  reuses the per-server managed daemon, then upserts the requested agent
+- `agents-host start-managed <serverUrl>` restarts or resumes an already-managed
+  runtime for that server without re-supplying the agent API key or options
+
+Unlike foreground `start`, both forms exit after the managed daemon is ready,
+and the full form additionally waits for the requested agent reconcile.
+
+It:
+
+1. resolves a managed runtime root under `~/.borgee/agents-host/managed/`
+   specific to that normalized `serverUrl`
+2. reuses the daemon already serving that runtime root when it is alive
+3. otherwise starts one local supervisor daemon for that managed root and waits
+   for it to become ready
+4. for the full `<serverUrl> <apiKey> ...` form only, upserts the requested
+   agent and waits for that reconcile before reporting success
+
+The short resume form does **not** auto-seed a new managed runtime. It fails
+clearly unless that serverUrl already has a persisted managed config with at
+least one persisted agent entry from an earlier full
+`start-managed <serverUrl> <apiKey> ...` bootstrap. Those persisted agents may
+all currently be disabled; the managed runtime is still considered bootstrapped
+and resumable in that case.
+
+Each managed runtime root keeps:
+
+- `agents-host.yaml` and `agents/` as the stable generated local-config entrypoints
+- `daemon.log` as the detached managed daemon stdout/stderr log file
+- `.state/` as the per-agent runtime state base
+- `ctl.sock` as the local control socket
+
+Detached `start-managed` daemon launches append both stdout and stderr to
+`<managed-root>/daemon.log`. This change does not add rotation or truncation;
+the daemon keeps appending to the same private log file until tooling or the
+operator moves or clears it.
+
+This MVP does not migrate legacy `~/.borgee/agents-host/single-agent` state
+into the managed runtime root.
+
+Agent identities generated through `start-managed` are internal and stable for
+the same API key within one server runtime root; repeated starts with the same
+API key replace that generated agent entry instead of appending duplicates.
+
+Example:
+
+```bash
+agents-host start-managed https://your-borgee-server bgr_xxxxxxxx --provider copilot
+agents-host start-managed https://your-borgee-server
+```
+
+### Machine-oriented managed-runtime commands
+
+`describe-managed` and `apply-managed` are JSON-only commands for machine callers.
+They operate on the same per-server managed runtime root as `start-managed`, but
+they expose full-set managed-runtime state instead of the legacy single-agent
+upsert flow.
+
+```bash
+agents-host describe-managed https://your-borgee-server
+printf '%s' '{"host":{"borgeeBaseUrl":"https://your-borgee-server"},"agents":[{"key":"cp1","name":"Copilot","apiKey":"bgr_xxx","provider":"copilot"}]}' \
+  | agents-host apply-managed https://your-borgee-server --stdin
+```
+
+- `describe-managed` prints one JSON object to stdout only:
+  - `{ "ok": true, "present": false }`
+  - `{ "ok": true, "present": true, "spec": { ... } }`
+  - `{ "ok": false, "error": { "code": "...", "message": "..." } }`
+- `apply-managed` accepts one full-set managed spec, validates that its
+  `host.borgeeBaseUrl` matches the requested runtime binding, rejects empty
+  full-set specs, then prints one JSON object to stdout only
+- expected managed failures are reported as structured JSON on stdout and exit 0
+- malformed CLI usage still follows the normal usage stderr + non-zero exit path
+- `--stdin` is preferred because `--spec-json` exposes the JSON in process
+  arguments
+
+### Managed daemon logs
+
+Resolve or stream the managed daemon log for one server runtime directly from the
+managed runtime root helpers:
+
+```bash
+agents-host log https://your-borgee-server
+agents-host log https://your-borgee-server --lines 0 --follow
+agents-host log https://your-borgee-server --path
 ```
 
-### Environment variables / equivalent single-agent CLI flags
+- default output prints the last 100 log lines
+- `--follow` keeps polling for appended content and resumes after truncation or
+  replacement
+- `--lines <n>` accepts non-negative integers only; `0` suppresses the initial
+  tail before follow mode
+- `--path` prints only the resolved log path and does not require the file to
+  exist yet
+
+### Debug mode
+
+Enable extra host/provider lifecycle logs with either:
+
+```bash
+agents-host start https://your-borgee-server bgr_xxxxxxxx --provider copilot --debug
+AGENTS_HOST_DEBUG=1 agents-host start --config ./agents-host.yaml
+```
+
+Notes:
+
+- `--debug` applies to foreground `start <serverUrl> <apiKey>` and `start --config <path>`
+- `AGENTS_HOST_DEBUG=1` is the env fallback for both the CLI and `pnpm --filter @borgee/agents-host dev`
+- `start-managed` intentionally does not accept `--debug` or `AGENTS_HOST_DEBUG=1`, because it may reuse an already-running daemon whose log mode is already fixed
+- host-authored debug logs stay secret-safe: they avoid API keys, raw prompt text, raw replies, and other sensitive tokens
+- Copilot child-process stderr is passed through only in debug mode
+- local-config mode prefixes debug logs with the managed agent key so interleaved output stays readable
+
+### Environment variables / equivalent single-agent agent options
 
 | Variable                           | CLI flag                               | Required | Default                                       | Description                                                                                      |
 | ---------------------------------- | -------------------------------------- | -------- | --------------------------------------------- | ------------------------------------------------------------------------------------------------ |
 | `BORGEE_BASE_URL`                  | positional `<serverUrl>`               | yes      | —                                             | Borgee server base URL                                                                           |
 | `BORGEE_AGENT_API_KEY`             | positional `<apiKey>`                  | yes      | —                                             | Agent API key from the web UI                                                                    |
+| `AGENTS_HOST_DEBUG`                | `--debug`                              | no       | off                                           | Extra host/provider lifecycle logs. Set `AGENTS_HOST_DEBUG=1` to enable without the CLI flag.   |
 | `BORGEE_AGENT_NAME`                | `--name`                               | no       | `Assistant`                                   | Display name used in prompts                                                                     |
-| `RUNTIME_PROVIDER`                 | `--provider`                           | no       | `claude`                                      | `claude` or `copilot`                                                                            |
+| `RUNTIME_PROVIDER`                 | `--provider`                           | no       | `claude`                                      | `claude`, `copilot`, or `codex` when `codex-provider` is enabled                                 |
 | `CLAUDE_COMMAND` / `CLAUDE_ARGS`   | `--claude-command` / `--claude-args`   | no       | `claude` / `--print`                          | Local Claude CLI command + args                                                                  |
+| `CODEX_COMMAND` / `CODEX_ARGS`     | `--codex-command` / `--codex-args`     | no       | `codex-acp` / empty                           | Local Codex ACP adapter command + args. The default launch resolves the bundled `@agentclientprotocol/codex-acp` entrypoint. |
 | `COPILOT_COMMAND` / `COPILOT_ARGS` | `--copilot-command` / `--copilot-args` | no       | `copilot` / parsed but ignored by ACP runtime | Local Copilot CLI command. The persistent Copilot ACP prototype always launches `copilot --acp`. |
 | `COPILOT_SESSION_TTL_MINUTES`      | `--copilot-session-ttl-minutes`        | no       | `2880`                                        | Idle TTL for per-channel Copilot ACP sessions                                                    |
 
@@ -165,7 +295,9 @@ The spec shape is:
     "borgeeBaseUrl": "https://borgee.example.com",
     "defaults": {
       "claudeCommand": "claude",
-      "claudeArgs": ["--print"],
+      "claudeArgs": ["--print", "--permission-mode", "bypassPermissions"],
+      "codexCommand": "codex-acp",
+      "codexArgs": [],
       "copilotCommand": "copilot",
       "copilotArgs": ["-s", "--no-color", "--allow-all-tools", "--output-format", "text"],
       "copilotSessionTtlMinutes": 2880
@@ -232,6 +364,10 @@ defaults:
   claudeCommand: claude
   claudeArgs:
     - --print
+    - --permission-mode
+    - bypassPermissions
+  codexCommand: codex-acp
+  codexArgs: []
   copilotCommand: copilot
   copilotArgs:
     - -s
@@ -248,12 +384,14 @@ Host config fields:
 - `agentsDir` (optional, default `./agents` relative to the host config file)
 - `defaults.claudeCommand`
 - `defaults.claudeArgs`
+- `defaults.codexCommand`
+- `defaults.codexArgs`
 - `defaults.copilotCommand`
 - `defaults.copilotArgs`
 - `defaults.copilotSessionTtlMinutes`
 
 Absent host defaults fall back to the same code-level defaults used by the
-single-agent env / CLI flow.
+standalone env flow, foreground `start`, and `start-managed`.
 
 ### Agent config
 
@@ -265,6 +403,8 @@ provider: claude
 enabled: true
 claudeArgs:
   - --print
+  - --permission-mode
+  - bypassPermissions
   - --model
   - sonnet
 ```
@@ -274,10 +414,11 @@ Agent config fields:
 - `key` (**required**): stable identity used for diffing and reload decisions
 - `name` (**required**)
 - `apiKey` (**required**)
-- `provider` (**required**): `claude` or `copilot`
+- `provider` (**required**): `claude`, `copilot`, or gated `codex`
 - `enabled` (optional, default `true`)
-- optional overrides for `claudeCommand`, `claudeArgs`, `copilotCommand`,
-  `copilotArgs`, and `copilotSessionTtlMinutes`
+- optional overrides for `claudeCommand`, `claudeArgs`, `codexCommand`,
+  `codexArgs`, `copilotCommand`, `copilotArgs`, and
+  `copilotSessionTtlMinutes`
 
 Array overrides are **replacement**, not concatenation. For example, an agent
 `claudeArgs` value replaces the host default `claudeArgs` entirely.
@@ -318,16 +459,38 @@ active:
   after uses `-r/--resume <uuid>`. The host persists the channel→session map in
   its state root, serializes cross-channel map rewrites, and retries once with a
   fresh session immediately if Claude reports a stale `--resume` target.
+- **Codex**: one persistent `@agentclientprotocol/codex-acp` subprocess is
+  shared by a single `AgentsHost`, with one ACP session per Borgee channel. When
+  the current turn has a materialized channel context payload, Codex refreshes a
+  same-directory `AGENTS.md` project document inside a provider-visible
+  per-channel projection directory and exposes that directory to Codex through
+  ACP `additionalDirectories`. Ordinary threads keep the shared runtime
+  workspace as the ACP session cwd, while eligible `task_assignment` threads
+  switch the real ACP session cwd to a hidden local task workspace under
+  `<startup-workspace>/.borgee-task-workspaces/<thread>/<task>/`; that local
+  writable workspace is explicitly not a claim that the target repository is
+  already checked out there. The host persists the channel→ACP-session map in
+  its state root and attempts ACP `session/resume` first when the adapter
+  advertises it, otherwise `session/load`.
 - **Copilot**: one persistent `copilot --acp` subprocess is shared by a single
   `AgentsHost`, with one ACP session per Borgee channel. Same-channel turns are
-  serialized; different channels keep isolated ACP sessions. The host persists
-  the channel→ACP-session map in its state root and restores same-host
-  continuity with ACP `session/resume` when available, otherwise `session/load`
-  plus local replay cleanup on runtimes that advertise only load support.
-
-There is no separate transcript/history store on our side. Claude and Copilot
-only persist the native session ids they should try to resume later; cross-host
-continuity still does not exist in this runtime.
+  serialized; different channels keep isolated ACP sessions. Ordinary threads
+  keep the shared runtime workspace cwd, while eligible `task_assignment`
+  threads switch the real ACP session cwd to that same hidden local
+  task-scoped workspace. The host persists the channel→ACP-session map in its
+  state root and restores same-host continuity with ACP `session/resume` when
+  available, otherwise `session/load` plus local replay cleanup on runtimes
+  that advertise only load support.
+- **Claude**: Claude still keeps one provider-native session mapping per Borgee
+  channel, but unlike the ACP-backed adapters it spawns a fresh CLI process for
+  each turn. Ordinary threads inherit the host runtime cwd; eligible
+  `task_assignment` threads run the CLI process with the hidden local
+  task-scoped workspace as the process cwd, again without implying that the
+  target repository is already checked out there.
+
+There is no separate transcript/history store on our side. Claude, Codex, and
+Copilot only persist the native session ids they should try to resume later;
+cross-host continuity still does not exist in this runtime.
 
 ## Testing
 

package/dist/agents-host-supervisor.d.ts

@@ -1,3 +1,4 @@
+import type { AgentsHostRuntimeOptions, LoggerLike } from './debug.js';
 import type { AgentsHostConfig, LocalConfigSnapshot } from './types.js';
 export interface HostRunner {
     start(): Promise<void>;
@@ -10,15 +11,12 @@ export interface WatchEventInfo {
     eventType?: string;
     filename?: string;
 }
-export interface LoggerLike {
-    log(...args: unknown[]): void;
-    error(...args: unknown[]): void;
-}
 export interface AgentsHostSupervisorDeps {
-    createHost?: (config: AgentsHostConfig) => HostRunner;
+    createHost?: (config: AgentsHostConfig, runtimeOptions?: AgentsHostRuntimeOptions) => HostRunner;
     loadSnapshot?: (configPath: string) => Promise<LocalConfigSnapshot>;
     watchPath?: (path: string, onEvent: (event?: WatchEventInfo) => void) => WatchHandle;
     logger?: LoggerLike;
+    debug?: boolean;
 }
 export declare class AgentsHostSupervisor {
     private readonly hostConfigPath;
@@ -26,18 +24,22 @@ export declare class AgentsHostSupervisor {
     private readonly loadSnapshot;
     private readonly watchPath;
     private readonly logger;
+    private readonly debug;
     private readonly activeHosts;
     private readonly watchers;
     private currentSnapshot;
     private reloadTimer;
     private reloadInFlight;
     private pendingReload;
+    private pendingReloadFailOnStartError;
     private runningReloadPromise;
     private shuttingDown;
     private started;
     constructor(hostConfigPath: string, deps?: AgentsHostSupervisorDeps);
     start(): Promise<void>;
     stop(): Promise<void>;
+    reloadNow(failOnStartError?: boolean): Promise<void>;
+    hasActiveAgent(key: string): boolean;
     private scheduleReload;
     private clearReloadTimer;
     private runReloadLoop;

package/dist/agents-host-supervisor.js

@@ -12,18 +12,20 @@ export class AgentsHostSupervisor {
     loadSnapshot;
     watchPath;
     logger;
+    debug;
     activeHosts = new Map();
     watchers = new Map();
     currentSnapshot = null;
     reloadTimer = null;
     reloadInFlight = false;
     pendingReload = false;
+    pendingReloadFailOnStartError = false;
     runningReloadPromise = null;
     shuttingDown = false;
     started = false;
     constructor(hostConfigPath, deps = {}) {
         this.hostConfigPath = resolve(hostConfigPath);
-        this.createHost = deps.createHost ?? ((config) => new AgentsHost(config));
+        this.createHost = deps.createHost ?? ((config, runtimeOptions) => new AgentsHost(config, { runtimeOptions }));
         this.loadSnapshot = deps.loadSnapshot ?? ((configPath) => loadLocalConfigSnapshot(configPath));
         this.watchPath =
             deps.watchPath ??
@@ -34,6 +36,7 @@ export class AgentsHostSupervisor {
                     });
                 }));
         this.logger = deps.logger ?? console;
+        this.debug = deps.debug === true;
     }
     async start() {
         if (this.started) {
@@ -81,6 +84,12 @@ export class AgentsHostSupervisor {
             await this.stopActiveHost(key, activeHost);
         }
     }
+    async reloadNow(failOnStartError = false) {
+        await this.runReloadLoop(failOnStartError);
+    }
+    hasActiveAgent(key) {
+        return this.activeHosts.has(key);
+    }
     scheduleReload() {
         if (this.shuttingDown) {
             return;
@@ -88,7 +97,7 @@ export class AgentsHostSupervisor {
         this.clearReloadTimer();
         this.reloadTimer = setTimeout(() => {
             this.reloadTimer = null;
-            void this.runReloadLoop();
+            void this.runReloadLoop().catch(() => undefined);
         }, RELOAD_DEBOUNCE_MS);
     }
     clearReloadTimer() {
@@ -100,18 +109,25 @@ export class AgentsHostSupervisor {
     async runReloadLoop(failOnStartError = false) {
         if (this.reloadInFlight) {
             this.pendingReload = true;
+            this.pendingReloadFailOnStartError ||= failOnStartError;
+            await this.runningReloadPromise;
             return;
         }
         this.reloadInFlight = true;
+        let nextFailOnStartError = failOnStartError;
         this.runningReloadPromise = (async () => {
             try {
                 do {
+                    const currentFailOnStartError = nextFailOnStartError;
                     this.pendingReload = false;
-                    await this.reloadOnce(failOnStartError);
+                    this.pendingReloadFailOnStartError = false;
+                    await this.reloadOnce(currentFailOnStartError);
+                    nextFailOnStartError = this.pendingReloadFailOnStartError;
                 } while (this.pendingReload && !this.shuttingDown);
             }
             finally {
                 this.reloadInFlight = false;
+                this.pendingReloadFailOnStartError = false;
                 this.runningReloadPromise = null;
             }
         })();
@@ -256,7 +272,11 @@ export class AgentsHostSupervisor {
         if (this.shuttingDown) {
             return;
         }
-        const runner = this.createHost(agent.config);
+        const runner = this.createHost(agent.config, {
+            debug: this.debug,
+            logger: this.logger,
+            logPrefix: `[agents-host][agent:${agent.key}]`,
+        });
         try {
             await runner.start();
             this.activeHosts.set(agent.key, {

package/dist/agents-host.d.ts

@@ -1,44 +1,143 @@
 import type { ChatControlPlane } from './chat/chat-control-plane.js';
+import { type AgentsHostRuntimeOptions } from './debug.js';
 import type { ProviderAdapter } from './providers/provider-adapter.js';
 import type { AgentsHostConfig } from './types.js';
 /**
  * Minimal single-agent agents host: connects one local Claude/Copilot CLI
  * to exactly one Borgee agent over `@borgee/plugin-sdk` (BPP / `/ws/plugin`).
- *
- * Conversation memory is handled entirely by each provider's native
- * per-channel CLI session (Claude `--resume`, Copilot `--session-id`) — see
- * the cli-client.ts file under each provider's folder. This class does not
- * keep any message history itself.
- *
- * Out of scope for this single-agent runner (see README): execution/remote-command
- * dispatch, node provisioning, systemd install, and scheduled (periodic)
- * prompts. Multi-agent local hosting is handled one level up by the local-config
- * supervisor, which creates one isolated `AgentsHost` per effective agent key.
- *
- * Message gating (mention-only / DM rules) is NOT done here: the server
- * enforces per-agent + per-channel `require_mention` at BPP fan-out, so this
- * host simply replies to every message it is handed (minus its own).
  */
 export declare class AgentsHost {
     private readonly config;
+    private readonly runtime;
     private readonly provider;
     private readonly borgee;
+    private readonly logger;
+    private readonly contextInjectionEnabled;
+    private readonly collaborationEnabled;
+    private readonly collaborationOutcomeModelEnabled;
+    private readonly attentionFollowSemanticsEnabled;
+    private readonly taskThreadCollaborationContractEnabled;
+    private readonly collaborationCapabilitiesDiagnosticsEnabled;
     private readonly activeTurns;
+    private readonly awaitingUserByChannel;
+    private readonly collaborationOutcomeByChannel;
+    private readonly attentionSnapshotByChannel;
+    private readonly missedCollaborationDiagnosticByChannel;
     private readonly progressChannelQueues;
     private readonly progressDrafts;
+    private readonly collaborationDrafts;
+    private readonly collaborationChannels;
+    private readonly participantDirectoryByUserId;
+    private readonly participantKindsByUserId;
+    private readonly participantRefreshBackoffByUserId;
+    private participantRefreshPromise;
+    private participantDirectorySupported;
     private selfAgentId;
+    private selfAgentProfile;
     private selfAgentIdPromise;
     private started;
     private controlPlaneClosed;
     constructor(config: AgentsHostConfig, deps?: {
         borgee?: ChatControlPlane;
         provider?: ProviderAdapter;
+        runtimeOptions?: AgentsHostRuntimeOptions;
     });
     start(): Promise<void>;
     stop(): Promise<void>;
-    private handleMessage;
     private trackActiveTurn;
+    private dispatchMessage;
+    private handleLegacyMessage;
+    private handleCollaborationMessage;
+    private detectProtocolKickoffCandidate;
+    private validateProtocolKickoffCandidate;
+    private resolveProtocolKickoffRequest;
+    private validateProtocolKickoffRounds;
+    private protocolRequestFromKickoffDecision;
+    private evaluateIssuerProtocolKickoff;
+    private waitForProtocolKickoffDecision;
+    private ensureProtocolKickoffDecisionRecord;
+    private finalizeProtocolKickoffDecision;
+    private matchesProtocolKickoffDecisionRecord;
+    private resolveProtocolKickoffDecisionPath;
+    private resolveSharedProtocolStatusPath;
+    private readProtocolKickoffDecisionRecord;
+    private writeProtocolKickoffDecisionRecord;
+    private handleActiveProtocolAnchorReplay;
+    private startProtocolForAnchor;
+    private deliverDeferredTurnReply;
+    private handleActiveProtocolParticipantMessage;
+    private enqueueCollaborationMessage;
+    private ensureCollaborationChannelState;
+    private ensureCollaborationProcessor;
+    private processCollaborationQueue;
+    private tryResumeBlockedFromQueue;
+    private runCollaborationTurn;
+    private runProtocolManagedTurn;
+    private buildIncomingContent;
+    private otherProtocolParticipant;
+    private resolveProtocolStatePath;
+    private ensureProtocolStateLoaded;
+    private reconcileOwnProtocolStateFromPeers;
+    private loadPersistedProtocolStates;
+    private resumeOwnedProtocolTurns;
+    private buildResumedProtocolMessage;
+    private persistProtocolState;
+    private persistSharedProtocolStatus;
+    private readSharedProtocolStatus;
+    private clearProtocolFallback;
+    private armProtocolFallback;
+    private runProtocolFallback;
+    private handleProtocolFallbackFailure;
+    private finishProtocolState;
+    private cancelProtocolState;
+    private confirmProtocolMessage;
+    private resolveAttentionStatePath;
+    private buildDefaultAttentionSnapshot;
+    private buildTurnTaskThreadContext;
+    private ensureAttentionSnapshotLoaded;
+    private revalidateAttentionSnapshotForTurn;
+    private getAttentionSnapshotForTurn;
+    private isHumanWakeFiltered;
+    private applyAttentionUpdate;
+    private commitAttentionSnapshot;
+    private resolveTaskThreadCollaborationContractForTurn;
+    private resolveCollaborationCapabilityDeclarationForTurn;
+    private resolveMissedCollaborationDiagnosticForTurn;
+    private updateMissedCollaborationDiagnostic;
+    private noteWakeSuppressedAttentionPolicy;
+    private runUngatedTurn;
+    private executeTurn;
+    private canAcceptTurnOutput;
+    private canAcceptCompletedTurnOutput;
+    private canContinueSharedProtocol;
     private enqueueProgressChannelTurn;
     private ensureProgressDraft;
+    private publishCollaborationDraft;
+    private finalizeCollaborationDraft;
+    private clearCollaborationDraft;
+    private readCollaborationDraft;
+    private discardDraft;
+    private supersedeActiveTurn;
+    private invalidateChannelTurn;
+    private rememberRecentTurn;
+    private resolveAuthorizedCollaborationTurn;
+    private updateAwaitingUserState;
+    private recordBlockedSuppressionOutcome;
+    private recordCollaborationOutcome;
+    private syncMissedCollaborationDiagnosticFromOutcome;
+    private resolveVisibleTurnBody;
+    private shouldRelayProtocolReply;
+    private normalizeMessage;
+    private markAssignedTaskInProgress;
     private ensureSelfAgentId;
+    private classifyAuthor;
+    private refreshParticipantDirectory;
+    private classifyBlockedWakeAuthor;
+    private classifyQueuedBlockedWakeCandidate;
+    private inferAuthorKind;
+    private buildCollaborationGrounding;
+    private hydratePromptIdentityCache;
+    private resolvePromptIdentity;
+    private isUnsupportedSemanticOperation;
+    private authorizeCollaborationSend;
 }