@borgee/agents-host 0.2.28 → 0.2.31

package/README.md

@@ -54,6 +54,7 @@ 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 cleanup-managed <serverUrl> [--purge]
 agents-host log <serverUrl> [--lines <n>] [--follow]
 agents-host log <serverUrl> --path
 agents-host start --config <path-to-host-config> [--debug]
@@ -77,7 +78,28 @@ 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`.
+Codex now ships on the same default hosted-provider surface as Claude and Copilot. Select `RUNTIME_PROVIDER=codex` directly unless you are explicitly rolling that path back with `AGENTS_HOST_INTERNAL_DISABLED_COMPATIBILITY_GATES=codex-provider`.
+
+### Shipped internal compatibility defaults and rollback controls
+
+The current shipped internal compatibility surface resolves gates in this order:
+
+1. start from the shipped defaults: `copilot-provider-v2`, `codex-provider`, `managed-runtime-convergence`, and `policy-audit-enforcement`
+2. add any explicit entries from `AGENTS_HOST_INTERNAL_COMPATIBILITY_GATES`
+3. subtract any explicit entries from `AGENTS_HOST_INTERNAL_DISABLED_COMPATIBILITY_GATES`
+
+The shipped default set now also includes `connections-state-layer`, `context-injection`, `skill-runtime`, `localhost-gateway`, `token-binding`, `collaboration-outcome-model`, `task-thread-collaboration-contract`, and `collaboration-capabilities-diagnostics`. `attention-follow-semantics`, `collaboration-skill-first`, and hosted `praestoclaw-provider` still remain opt-in.
+
+Managed-runtime settings still preserve the managed rollback rule for `connections-state-layer` plus `token-binding`: when `managed-runtime-convergence` remains enabled, the managed surface forces that pair on; explicitly disabling `managed-runtime-convergence` removes that pair from the managed surface again unless you also explicitly re-enable them.
+
+Managed runtime precedence stays intentional: detached daemon respawns always reuse the persisted `managed-runtime-settings.json` snapshot, bare `start-managed <serverUrl>` and `apply-managed` treat the caller's current env as an explicit request to update that managed runtime surface, and full `start-managed <serverUrl> <apiKey> ...` validates the agent upsert against the existing managed-root snapshot before ambient rollback env can reject an otherwise valid existing surface.
+Legacy managed roots created before `managed-runtime-settings.json` existed need one bare `agents-host start-managed <serverUrl>` migration pass before full per-agent updates can rely on that snapshot-backed precedence.
+
+Rollback and hardening controls stay explicit:
+
+- `AGENTS_HOST_INTERNAL_DISABLED_COMPATIBILITY_GATES=<comma-list>` disables shipped gates for rollback
+- `AGENTS_HOST_INTERNAL_PROVIDER_IMPLEMENTATIONS=copilot:v1` forces Copilot back to the v1 adapter while its v2 gate stays enabled; stale `claude:v1|v2` entries are tolerated as no-ops for compatibility
+- `AGENTS_HOST_INTERNAL_POLICY_MODE=enforce` hardens the shipped `policy-audit-enforcement` gate beyond its default `audit-only` mode
 
 Or with the CLI:
 
@@ -117,6 +139,7 @@ and resumable in that case.
 Each managed runtime root keeps:
 
 - `agents-host.yaml` and `agents/` as the stable generated local-config entrypoints
+- `managed-runtime-settings.json` as the persisted managed runtime surface snapshot
 - `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
@@ -210,8 +233,8 @@ Notes:
 | `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`, `copilot`, or `codex` when `codex-provider` is enabled                                 |
-| `CLAUDE_COMMAND` / `CLAUDE_ARGS`   | `--claude-command` / `--claude-args`   | no       | `claude` / `--print`                          | Local Claude CLI command + args                                                                  |
+| `RUNTIME_PROVIDER`                 | `--provider`                           | no       | `claude`                                      | `claude`, `copilot`, or `codex`                                                                  |
+| `CLAUDE_COMMAND` / `CLAUDE_ARGS`   | `--claude-command` / `--claude-args`   | no       | `claude-agent-acp` / empty                    | Local Claude ACP adapter command + args. The shipped bundled `claude-agent-acp` path requires empty `CLAUDE_ARGS`; non-empty args are only valid when `CLAUDE_COMMAND` points at a custom ACP adapter command. Legacy `claude --print --permission-mode bypassPermissions` is tolerated as a compatibility alias. |
 | `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                                                    |
@@ -294,8 +317,8 @@ The spec shape is:
   "host": {
     "borgeeBaseUrl": "https://borgee.example.com",
     "defaults": {
-      "claudeCommand": "claude",
-      "claudeArgs": ["--print", "--permission-mode", "bypassPermissions"],
+      "claudeCommand": "claude-agent-acp",
+      "claudeArgs": [],
       "codexCommand": "codex-acp",
       "codexArgs": [],
       "copilotCommand": "copilot",
@@ -361,11 +384,8 @@ paths are also allowed.
 borgeeBaseUrl: https://borgee.example.com
 agentsDir: ./agents
 defaults:
-  claudeCommand: claude
-  claudeArgs:
-    - --print
-    - --permission-mode
-    - bypassPermissions
+  claudeCommand: claude-agent-acp
+  claudeArgs: []
   codexCommand: codex-acp
   codexArgs: []
   copilotCommand: copilot
@@ -401,12 +421,6 @@ name: Support Bot
 apiKey: bgr_support_xxxxxxxx
 provider: claude
 enabled: true
-claudeArgs:
-  - --print
-  - --permission-mode
-  - bypassPermissions
-  - --model
-  - sonnet
 ```
 
 Agent config fields:
@@ -414,8 +428,9 @@ Agent config fields:
 - `key` (**required**): stable identity used for diffing and reload decisions
 - `name` (**required**)
 - `apiKey` (**required**)
-- `provider` (**required**): `claude`, `copilot`, or gated `codex`
+- `provider` (**required**): `claude`, `copilot`, or `codex` (roll back Codex only with `AGENTS_HOST_INTERNAL_DISABLED_COMPATIBILITY_GATES=codex-provider`)
 - `enabled` (optional, default `true`)
+- `claudeCommand` / `claudeArgs` (optional): leave unset to use the shipped bundled `claude-agent-acp` path. On that bundled path `claudeArgs` must stay empty. Non-empty `claudeArgs` are only supported when `claudeCommand` points at a custom ACP adapter command.
 - optional overrides for `claudeCommand`, `claudeArgs`, `codexCommand`,
   `codexArgs`, `copilotCommand`, `copilotArgs`, and
   `copilotSessionTtlMinutes`
@@ -455,10 +470,16 @@ successfully applied snapshot running.
 Each Borgee channel is mapped 1:1 to a provider-native session while it stays
 active:
 
-- **Claude**: first turn for a channel uses `--session-id <uuid>`; every turn
-  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.
+- **Claude**: one persistent `@agentclientprotocol/claude-agent-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. 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, restores same-host continuity with
+  ACP `session/resume` when available, retries stale restores with a fresh
+  session immediately, and injects the per-channel local context paths through
+  Claude ACP `_meta.systemPrompt.append`.
 - **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
@@ -481,13 +502,6 @@ active:
   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.

package/dist/agents-host.d.ts

@@ -128,7 +128,7 @@ export declare class AgentsHost {
     private resolveVisibleTurnBody;
     private shouldRelayProtocolReply;
     private normalizeMessage;
-    private markAssignedTaskInProgress;
+    private resolveTaskAssignmentDelivery;
     private ensureSelfAgentId;
     private classifyAuthor;
     private refreshParticipantDirectory;

package/dist/agents-host.js

@@ -527,6 +527,11 @@ export class AgentsHost {
         if (!normalized) {
             return;
         }
+        const effective = await this.resolveTaskAssignmentDelivery(msg, normalized);
+        if (!effective) {
+            return;
+        }
+        msg = effective;
         let taskThreadContext = { state: 'inactive' };
         let attentionSnapshot;
         if (this.attentionFollowSemanticsEnabled
@@ -542,9 +547,6 @@ export class AgentsHost {
                 }
             }
         }
-        if (msg.message_type === 'task_assignment') {
-            await this.markAssignedTaskInProgress(msg.channel_id, normalized.content);
-        }
         await this.runUngatedTurn(msg, normalized.authorId, normalized.content, taskThreadContext, attentionSnapshot);
     }
     async handleCollaborationMessage(msg) {
@@ -552,9 +554,11 @@ export class AgentsHost {
         if (!normalized) {
             return;
         }
-        if (msg.message_type === 'task_assignment') {
-            await this.markAssignedTaskInProgress(msg.channel_id, normalized.content);
+        const effective = await this.resolveTaskAssignmentDelivery(msg, normalized);
+        if (!effective) {
+            return;
         }
+        msg = effective;
         const channelState = this.ensureCollaborationChannelState(msg.channel_id);
         await this.ensureProtocolStateLoaded(msg.channel_id, channelState);
         await this.ensureAttentionSnapshotLoaded(msg.channel_id, channelState);
@@ -2640,28 +2644,51 @@ export class AgentsHost {
             content,
         };
     }
-    async markAssignedTaskInProgress(threadId, content) {
+    // Only a task assigned to this agent drives a task-assignment turn: it keeps the message a
+    // task_assignment (and best-effort flips an open task to in_progress). An unassigned or
+    // other-assigned task_assignment degrades to an ordinary message, and this agent's own echo of
+    // it drops, so the creator never auto-starts work it was not assigned.
+    async resolveTaskAssignmentDelivery(msg, normalized) {
+        if (msg.message_type !== 'task_assignment') {
+            return msg;
+        }
+        const selfAgentId = await this.ensureSelfAgentId();
+        let task;
         try {
-            const selfAgentId = await this.ensureSelfAgentId();
-            const task = await waitForTaskForThread(this.borgee, threadId, {
-                preferredTaskId: extractTaskIdFromTaskAssignmentContent(content),
+            task = await waitForTaskForThread(this.borgee, msg.channel_id, {
+                preferredTaskId: extractTaskIdFromTaskAssignmentContent(normalized.content),
                 attempts: 10,
                 delayMs: 250,
             });
-            if (!task || task.status !== 'open' || task.assigneeId !== selfAgentId) {
-                return;
-            }
-            await this.borgee.updateTask({
-                taskId: task.id,
-                status: 'in_progress',
-            });
         }
         catch (error) {
-            this.logger.debugError('best-effort task auto-start failed', {
-                channelId: threadId,
+            this.logger.debugError('task-assignment resolution failed', {
+                channelId: msg.channel_id,
                 error,
             });
+            task = null;
+        }
+        if (task && task.assigneeId === selfAgentId) {
+            if (task.status === 'open') {
+                try {
+                    await this.borgee.updateTask({
+                        taskId: task.id,
+                        status: 'in_progress',
+                    });
+                }
+                catch (error) {
+                    this.logger.debugError('best-effort task auto-start failed', {
+                        channelId: msg.channel_id,
+                        error,
+                    });
+                }
+            }
+            return msg;
+        }
+        if (normalized.authorId === selfAgentId) {
+            return null;
         }
+        return { ...msg, message_type: 'default' };
     }
     async ensureSelfAgentId() {
         if (this.selfAgentId) {

package/dist/cli-args.d.ts

@@ -83,4 +83,4 @@ export declare function parseLogArgs(argv: string[]): ParsedLogArgs;
 export declare function parseDescribeManagedArgs(argv: string[]): ParsedDescribeManagedArgs;
 export declare function parseCleanupManagedArgs(argv: string[]): ParsedCleanupManagedArgs;
 export declare function parseApplyManagedArgs(argv: string[]): ParsedApplyManagedArgs;
-export declare const USAGE = "Usage:\n  agents-host start <serverUrl> <apiKey> [options]\n  agents-host start-managed <serverUrl>\n  agents-host start-managed <serverUrl> <apiKey> [agent-options]\n  agents-host describe-managed <serverUrl>\n  agents-host cleanup-managed <serverUrl> [--purge]\n  agents-host apply-managed <serverUrl> --stdin\n  agents-host apply-managed <serverUrl> --spec-json <json>\n  agents-host log <serverUrl> [--lines <n>] [--follow]\n  agents-host log <serverUrl> --path\n  agents-host start --config <path-to-host-config> [--debug]\n  agents-host validate --config <path-to-host-config>\n  agents-host describe --config <path-to-host-config>\n  agents-host print-layout --root <dir>\n  agents-host generate-config --root <dir> --stdin\n  agents-host generate-config --root <dir> --spec-json <json>\n\nForeground start options:\n  --debug                         Enable host/provider debug logs (or set AGENTS_HOST_DEBUG=1)\n\nSingle-agent agent options:\n  --name <name>                   Display name (default: Assistant)\n  --provider <claude|codex|copilot>\n                                   Runtime provider (default: claude)\n  --claude-command <cmd>          Local Claude CLI command (default: claude)\n  --claude-args <args>            Local Claude CLI args (default: --print --permission-mode bypassPermissions)\n  --codex-command <cmd>           Local Codex ACP adapter command (default: codex-acp)\n  --codex-args <args>             Local Codex ACP adapter args\n  --copilot-command <cmd>         Local Copilot CLI command (default: copilot)\n  --copilot-args <args>           Ignored by the Copilot ACP prototype\n  --copilot-session-ttl-minutes <minutes>\n                                   Idle session TTL for Copilot ACP sessions (default: 2880)\n\nCommand summary:\n  start <serverUrl> <apiKey>      Start one foreground hosted agent (legacy-compatible behavior)\n  start --config <path>           Start agents + supervisor + watchers from a host config file\n  start-managed <serverUrl>       Restart or resume an existing per-serverUrl managed daemon\n  start-managed <serverUrl> <apiKey>\n                                   Upsert one agent into the per-serverUrl local daemon and exit after reconcile\n  describe-managed <serverUrl>    Print managed-runtime spec JSON for machine callers\n  cleanup-managed <serverUrl>     Stop one managed-runtime daemon locally; --purge also removes its runtime root\n  apply-managed <serverUrl>       Apply one managed-runtime full-set spec for machine callers\n  log <serverUrl>                 Print the managed daemon log tail for one server runtime\n  validate --config <path>        Validate local-config files without starting agents or watchers\n  describe --config <path>        Print the current managed full-set spec as JSON\n  print-layout --root <dir>       Print the canonical default local-config layout as JSON\n  generate-config --root <dir> --stdin  Materialize canonical local-config files from stdin\n  generate-config --root <dir> --spec-json <json>\n                                   Compatibility input; JSON is exposed in process arguments\n\nExamples:\n  agents-host start https://borgee.example.com bgr_xxxxxxxx --provider copilot --debug\n  agents-host start-managed https://borgee.example.com\n  agents-host start-managed https://borgee.example.com bgr_xxxxxxxx --provider copilot\n  agents-host describe-managed https://borgee.example.com\n  agents-host cleanup-managed https://borgee.example.com --purge\n  printf '%s' '{\"host\":{\"borgeeBaseUrl\":\"https://borgee.example.com\"},\"agents\":[{\"key\":\"cp1\",\"name\":\"Copilot\",\"apiKey\":\"bgr_xxx\",\"provider\":\"copilot\"}]}' | agents-host apply-managed https://borgee.example.com --stdin\n  agents-host log https://borgee.example.com --lines 200 --follow\n  agents-host log https://borgee.example.com --path\n  agents-host start --config ./agents-host.yaml --debug\n  agents-host validate --config ./agents-host.yaml\n  agents-host describe --config ./agents-host.yaml\n  agents-host print-layout --root ./runtime-root\n  printf '%s' '{\"host\":{\"borgeeBaseUrl\":\"https://borgee.example.com\"},\"agents\":[{\"key\":\"cp1\",\"name\":\"Copilot\",\"apiKey\":\"bgr_xxx\",\"provider\":\"copilot\"}]}' | agents-host generate-config --root ./runtime-root --stdin\n";
+export declare const USAGE = "Usage:\n  agents-host start <serverUrl> <apiKey> [options]\n  agents-host start-managed <serverUrl>\n  agents-host start-managed <serverUrl> <apiKey> [agent-options]\n  agents-host describe-managed <serverUrl>\n  agents-host cleanup-managed <serverUrl> [--purge]\n  agents-host apply-managed <serverUrl> --stdin\n  agents-host apply-managed <serverUrl> --spec-json <json>\n  agents-host log <serverUrl> [--lines <n>] [--follow]\n  agents-host log <serverUrl> --path\n  agents-host start --config <path-to-host-config> [--debug]\n  agents-host validate --config <path-to-host-config>\n  agents-host describe --config <path-to-host-config>\n  agents-host print-layout --root <dir>\n  agents-host generate-config --root <dir> --stdin\n  agents-host generate-config --root <dir> --spec-json <json>\n\nForeground start options:\n  --debug                         Enable host/provider debug logs (or set AGENTS_HOST_DEBUG=1)\n\nSingle-agent agent options:\n  --name <name>                   Display name (default: Assistant)\n  --provider <claude|codex|copilot>\n                                   Runtime provider (default: claude)\n  --claude-command <cmd>          Local Claude ACP adapter command (default: claude-agent-acp)\n  --claude-args <args>            Local Claude ACP adapter args (empty on the shipped bundled path)\n  --codex-command <cmd>           Local Codex ACP adapter command (default: codex-acp)\n  --codex-args <args>             Local Codex ACP adapter args\n  --copilot-command <cmd>         Local Copilot CLI command (default: copilot)\n  --copilot-args <args>           Ignored by the Copilot ACP prototype\n  --copilot-session-ttl-minutes <minutes>\n                                   Idle session TTL for Copilot ACP sessions (default: 2880)\n\nCommand summary:\n  start <serverUrl> <apiKey>      Start one foreground hosted agent (legacy-compatible behavior)\n  start --config <path>           Start agents + supervisor + watchers from a host config file\n  start-managed <serverUrl>       Restart or resume an existing per-serverUrl managed daemon\n  start-managed <serverUrl> <apiKey>\n                                   Upsert one agent into the per-serverUrl local daemon and exit after reconcile\n  describe-managed <serverUrl>    Print managed-runtime spec JSON for machine callers\n  cleanup-managed <serverUrl>     Stop one managed-runtime daemon locally; --purge also removes its runtime root\n  apply-managed <serverUrl>       Apply one managed-runtime full-set spec for machine callers\n  log <serverUrl>                 Print the managed daemon log tail for one server runtime\n  validate --config <path>        Validate local-config files without starting agents or watchers\n  describe --config <path>        Print the current managed full-set spec as JSON\n  print-layout --root <dir>       Print the canonical default local-config layout as JSON\n  generate-config --root <dir> --stdin  Materialize canonical local-config files from stdin\n  generate-config --root <dir> --spec-json <json>\n                                   Compatibility input; JSON is exposed in process arguments\n\nExamples:\n  agents-host start https://borgee.example.com bgr_xxxxxxxx --provider copilot --debug\n  agents-host start-managed https://borgee.example.com\n  agents-host start-managed https://borgee.example.com bgr_xxxxxxxx --provider copilot\n  agents-host describe-managed https://borgee.example.com\n  agents-host cleanup-managed https://borgee.example.com --purge\n  printf '%s' '{\"host\":{\"borgeeBaseUrl\":\"https://borgee.example.com\"},\"agents\":[{\"key\":\"cp1\",\"name\":\"Copilot\",\"apiKey\":\"bgr_xxx\",\"provider\":\"copilot\"}]}' | agents-host apply-managed https://borgee.example.com --stdin\n  agents-host log https://borgee.example.com --lines 200 --follow\n  agents-host log https://borgee.example.com --path\n  agents-host start --config ./agents-host.yaml --debug\n  agents-host validate --config ./agents-host.yaml\n  agents-host describe --config ./agents-host.yaml\n  agents-host print-layout --root ./runtime-root\n  printf '%s' '{\"host\":{\"borgeeBaseUrl\":\"https://borgee.example.com\"},\"agents\":[{\"key\":\"cp1\",\"name\":\"Copilot\",\"apiKey\":\"bgr_xxx\",\"provider\":\"copilot\"}]}' | agents-host generate-config --root ./runtime-root --stdin\n";

package/dist/cli-args.js

@@ -494,8 +494,8 @@ Single-agent agent options:
   --name <name>                   Display name (default: Assistant)
   --provider <claude|codex|copilot>
                                    Runtime provider (default: claude)
-  --claude-command <cmd>          Local Claude CLI command (default: claude)
-  --claude-args <args>            Local Claude CLI args (default: --print --permission-mode bypassPermissions)
+  --claude-command <cmd>          Local Claude ACP adapter command (default: claude-agent-acp)
+  --claude-args <args>            Local Claude ACP adapter args (empty on the shipped bundled path)
   --codex-command <cmd>           Local Codex ACP adapter command (default: codex-acp)
   --codex-args <args>             Local Codex ACP adapter args
   --copilot-command <cmd>         Local Copilot CLI command (default: copilot)

package/dist/compatibility-gates.d.ts

@@ -14,6 +14,7 @@ export declare const TOKEN_BINDING_COMPATIBILITY_GATE = "token-binding";
 export declare const POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE = "policy-audit-enforcement";
 export declare const MANAGED_RUNTIME_CONVERGENCE_COMPATIBILITY_GATE = "managed-runtime-convergence";
 export declare const COMPATIBILITY_GATES_ENV = "AGENTS_HOST_INTERNAL_COMPATIBILITY_GATES";
+export declare const INTERNAL_DISABLED_COMPATIBILITY_GATES_ENV = "AGENTS_HOST_INTERNAL_DISABLED_COMPATIBILITY_GATES";
 export declare const INTERNAL_POLICY_MODE_ENV = "AGENTS_HOST_INTERNAL_POLICY_MODE";
 export declare const INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV = "AGENTS_HOST_INTERNAL_PROVIDER_IMPLEMENTATIONS";
 export declare const MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION = 1;
@@ -27,8 +28,10 @@ export interface ManagedRuntimeSettingsSnapshot {
     providerImplementationOverrides: string[];
     internalPolicyMode: InternalPolicyMode;
 }
+export declare const DEFAULT_INTERNAL_COMPATIBILITY_GATES: readonly string[];
 export declare function parseCompatibilityGates(rawValue: string | undefined): ReadonlySet<string>;
-export declare function resolveInternalCompatibilityGates(): ReadonlySet<string>;
+export declare function resolveInternalCompatibilityGates(env?: NodeJS.ProcessEnv): ReadonlySet<string>;
+export declare function resolveDisabledDefaultCompatibilityGates(compatibilityGates: Iterable<string>): string[];
 export declare function normalizeInternalProviderImplementationOverrides(rawValue: string | undefined): string[];
 export declare function parseInternalProviderImplementationOverrides(rawValue: string | undefined): InternalProviderImplementationOverrides;
 export declare function resolveManagedRuntimeProviderImplementationOverrides(env?: NodeJS.ProcessEnv, compatibilityGates?: string[]): string[];

package/dist/compatibility-gates.js

@@ -15,10 +15,25 @@ export const TOKEN_BINDING_COMPATIBILITY_GATE = 'token-binding';
 export const POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE = 'policy-audit-enforcement';
 export const MANAGED_RUNTIME_CONVERGENCE_COMPATIBILITY_GATE = 'managed-runtime-convergence';
 export const COMPATIBILITY_GATES_ENV = 'AGENTS_HOST_INTERNAL_COMPATIBILITY_GATES';
+export const INTERNAL_DISABLED_COMPATIBILITY_GATES_ENV = 'AGENTS_HOST_INTERNAL_DISABLED_COMPATIBILITY_GATES';
 export const INTERNAL_POLICY_MODE_ENV = 'AGENTS_HOST_INTERNAL_POLICY_MODE';
 export const INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV = 'AGENTS_HOST_INTERNAL_PROVIDER_IMPLEMENTATIONS';
 export const MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION = 1;
 const VALID_PROVIDER_IMPLEMENTATION_ENTRIES = '"claude:v1", "claude:v2", "copilot:v1", or "copilot:v2"';
+export const DEFAULT_INTERNAL_COMPATIBILITY_GATES = Object.freeze([
+    COLLABORATION_CAPABILITIES_DIAGNOSTICS_COMPATIBILITY_GATE,
+    COLLABORATION_OUTCOME_MODEL_COMPATIBILITY_GATE,
+    CONNECTIONS_STATE_LAYER_COMPATIBILITY_GATE,
+    CONTEXT_INJECTION_COMPATIBILITY_GATE,
+    CODEX_PROVIDER_COMPATIBILITY_GATE,
+    COPILOT_PROVIDER_V2_COMPATIBILITY_GATE,
+    LOCALHOST_GATEWAY_COMPATIBILITY_GATE,
+    MANAGED_RUNTIME_CONVERGENCE_COMPATIBILITY_GATE,
+    POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE,
+    SKILL_RUNTIME_COMPATIBILITY_GATE,
+    TASK_THREAD_COLLABORATION_CONTRACT_COMPATIBILITY_GATE,
+    TOKEN_BINDING_COMPATIBILITY_GATE,
+]);
 const PROVIDER_IMPLEMENTATION_COMPATIBILITY_GATES = {
     claude: CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE,
     copilot: COPILOT_PROVIDER_V2_COMPATIBILITY_GATE,
@@ -50,8 +65,19 @@ export function parseCompatibilityGates(rawValue) {
     }
     return gates;
 }
-export function resolveInternalCompatibilityGates() {
-    return parseCompatibilityGates(process.env[COMPATIBILITY_GATES_ENV]);
+export function resolveInternalCompatibilityGates(env = process.env) {
+    const compatibilityGates = new Set(DEFAULT_INTERNAL_COMPATIBILITY_GATES);
+    for (const gate of parseCompatibilityGates(env[COMPATIBILITY_GATES_ENV])) {
+        compatibilityGates.add(gate);
+    }
+    for (const gate of parseCompatibilityGates(env[INTERNAL_DISABLED_COMPATIBILITY_GATES_ENV])) {
+        compatibilityGates.delete(gate);
+    }
+    return compatibilityGates;
+}
+export function resolveDisabledDefaultCompatibilityGates(compatibilityGates) {
+    const enabledGates = new Set(compatibilityGates);
+    return DEFAULT_INTERNAL_COMPATIBILITY_GATES.filter((gate) => !enabledGates.has(gate));
 }
 export function normalizeInternalProviderImplementationOverrides(rawValue) {
     if (!rawValue || rawValue.trim().length === 0) {
@@ -91,15 +117,28 @@ export function resolveManagedRuntimeProviderImplementationOverrides(env = proce
     const enabledGates = new Set(compatibilityGates);
     return normalizeInternalProviderImplementationOverrides(env[INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV]).filter((assignment) => {
         const [provider] = assignment.split(':');
+        if (provider === 'claude') {
+            return false;
+        }
         return enabledGates.has(PROVIDER_IMPLEMENTATION_COMPATIBILITY_GATES[provider]);
     });
 }
 export function resolveManagedRuntimeCompatibilityGates(env = process.env) {
-    const compatibilityGates = new Set(parseCompatibilityGates(env[COMPATIBILITY_GATES_ENV]));
+    const compatibilityGates = new Set(resolveInternalCompatibilityGates(env));
+    compatibilityGates.delete(CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE);
+    const explicitlyEnabledGates = parseCompatibilityGates(env[COMPATIBILITY_GATES_ENV]);
     if (compatibilityGates.has(MANAGED_RUNTIME_CONVERGENCE_COMPATIBILITY_GATE)) {
         compatibilityGates.add(CONNECTIONS_STATE_LAYER_COMPATIBILITY_GATE);
         compatibilityGates.add(TOKEN_BINDING_COMPATIBILITY_GATE);
     }
+    else {
+        if (!explicitlyEnabledGates.has(CONNECTIONS_STATE_LAYER_COMPATIBILITY_GATE)) {
+            compatibilityGates.delete(CONNECTIONS_STATE_LAYER_COMPATIBILITY_GATE);
+        }
+        if (!explicitlyEnabledGates.has(TOKEN_BINDING_COMPATIBILITY_GATE)) {
+            compatibilityGates.delete(TOKEN_BINDING_COMPATIBILITY_GATE);
+        }
+    }
     return sortUniqueStrings(compatibilityGates);
 }
 export function resolveInternalPolicyMode(gateEnabled, env = process.env) {

package/dist/config.d.ts

@@ -1,6 +1,9 @@
 import type { AgentsHostConfig, ProviderCommandConfig, ProviderKind } from './types.js';
 export declare const MAX_COPILOT_SESSION_TTL_MINUTES: number;
 export declare const DEFAULT_COPILOT_SESSION_TTL_MINUTES: number;
+export declare const DEFAULT_CLAUDE_COMMAND = "claude-agent-acp";
+export declare const LEGACY_CLAUDE_COMMAND = "claude";
+export declare const LEGACY_CLAUDE_ONE_SHOT_ARGS: readonly ["--print", "--permission-mode", "bypassPermissions"];
 export declare const DEFAULT_PROVIDER_COMMAND_CONFIG: ProviderCommandConfig;
 export declare function requireNonEmptyString(value: unknown, message: string): string;
 export declare function optionalNonEmptyString(value: unknown, fieldName: string, sourceLabel: string): string | undefined;
@@ -9,5 +12,10 @@ export declare function optionalStringArray(value: unknown, fieldName: string, s
 export declare function parseCopilotSessionTtlMinutesValue(value: unknown, sourceLabel: string): number;
 export declare function resolveProvider(rawValue: string, sourceLabel: string): ProviderKind;
 export declare function assertProviderCompatibility(provider: ProviderKind, sourceLabel: string, env?: NodeJS.ProcessEnv): void;
+export declare function isLegacyClaudeCompatibilityAlias(command: string, args: string[]): boolean;
+export declare function isLegacyClaudeBinaryCommand(command: string): boolean;
+export declare function hasLegacyClaudeOneShotArgs(args: string[]): boolean;
+export declare function assertClaudeCommandCompatibility(command: string, args: string[], sourceLabel: string): void;
+export declare function assertProviderCommandCompatibility(provider: ProviderKind, config: Pick<ProviderCommandConfig, 'claudeCommand' | 'claudeArgs'>, sourceLabel: string): void;
 export declare function resolveProviderCommandConfig(overrides?: Partial<ProviderCommandConfig>): ProviderCommandConfig;
 export declare function loadConfigFromEnv(env?: NodeJS.ProcessEnv): AgentsHostConfig;

package/dist/config.js

@@ -1,11 +1,15 @@
+import { basename } from 'node:path';
 import { resolveSingleAgentStateRoot } from './state-paths.js';
-import { CODEX_PROVIDER_COMPATIBILITY_GATE, COMPATIBILITY_GATES_ENV, parseCompatibilityGates, } from './compatibility-gates.js';
+import { CODEX_PROVIDER_COMPATIBILITY_GATE, resolveInternalCompatibilityGates, } from './compatibility-gates.js';
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
 export const MAX_COPILOT_SESSION_TTL_MINUTES = MAX_TIMER_DELAY_MS / 60_000;
 export const DEFAULT_COPILOT_SESSION_TTL_MINUTES = 2 * 24 * 60;
+export const DEFAULT_CLAUDE_COMMAND = 'claude-agent-acp';
+export const LEGACY_CLAUDE_COMMAND = 'claude';
+export const LEGACY_CLAUDE_ONE_SHOT_ARGS = ['--print', '--permission-mode', 'bypassPermissions'];
 export const DEFAULT_PROVIDER_COMMAND_CONFIG = {
-    claudeCommand: 'claude',
-    claudeArgs: ['--print', '--permission-mode', 'bypassPermissions'],
+    claudeCommand: DEFAULT_CLAUDE_COMMAND,
+    claudeArgs: [],
     codexCommand: 'codex-acp',
     codexArgs: [],
     copilotCommand: 'copilot',
@@ -69,9 +73,41 @@ export function assertProviderCompatibility(provider, sourceLabel, env = process
     if (provider !== 'codex') {
         return;
     }
-    const compatibilityGates = parseCompatibilityGates(env[COMPATIBILITY_GATES_ENV]);
+    const compatibilityGates = resolveInternalCompatibilityGates(env);
     if (!compatibilityGates.has(CODEX_PROVIDER_COMPATIBILITY_GATE)) {
-        throw new Error(`${sourceLabel}: provider "codex" requires ${COMPATIBILITY_GATES_ENV} to include ${CODEX_PROVIDER_COMPATIBILITY_GATE}`);
+        throw new Error(`${sourceLabel}: provider "codex" requires the shipped ${CODEX_PROVIDER_COMPATIBILITY_GATE} path to remain enabled`);
+    }
+}
+export function isLegacyClaudeCompatibilityAlias(command, args) {
+    if (command !== LEGACY_CLAUDE_COMMAND || args.length !== LEGACY_CLAUDE_ONE_SHOT_ARGS.length) {
+        return false;
+    }
+    return args.every((arg, index) => arg === LEGACY_CLAUDE_ONE_SHOT_ARGS[index]);
+}
+export function isLegacyClaudeBinaryCommand(command) {
+    return basename(command) === LEGACY_CLAUDE_COMMAND;
+}
+export function hasLegacyClaudeOneShotArgs(args) {
+    return (args.length === LEGACY_CLAUDE_ONE_SHOT_ARGS.length
+        && args.every((arg, index) => arg === LEGACY_CLAUDE_ONE_SHOT_ARGS[index]));
+}
+export function assertClaudeCommandCompatibility(command, args, sourceLabel) {
+    if (command === DEFAULT_CLAUDE_COMMAND) {
+        if (args.length > 0) {
+            throw new Error(`Invalid Claude config in ${sourceLabel}: the shipped ${DEFAULT_CLAUDE_COMMAND} path does not accept CLAUDE_ARGS/claudeArgs. Leave them empty or point claudeCommand/CLAUDE_COMMAND at a custom ACP adapter command instead.`);
+        }
+        return;
+    }
+    if (isLegacyClaudeBinaryCommand(command)) {
+        if (isLegacyClaudeCompatibilityAlias(command, args)) {
+            return;
+        }
+        throw new Error(`Invalid Claude config in ${sourceLabel}: raw "${LEGACY_CLAUDE_COMMAND}" commands no longer speak ACP directly. Use the shipped ${DEFAULT_CLAUDE_COMMAND} default, keep only the exact legacy compatibility alias "${LEGACY_CLAUDE_COMMAND} ${LEGACY_CLAUDE_ONE_SHOT_ARGS.join(' ')}", or point claudeCommand/CLAUDE_COMMAND at a real ACP adapter command.`);
+    }
+}
+export function assertProviderCommandCompatibility(provider, config, sourceLabel) {
+    if (provider === 'claude') {
+        assertClaudeCommandCompatibility(config.claudeCommand, config.claudeArgs, sourceLabel);
     }
 }
 export function resolveProviderCommandConfig(overrides = {}) {
@@ -89,20 +125,22 @@ export function loadConfigFromEnv(env = process.env) {
     const provider = resolveProvider(envOr('RUNTIME_PROVIDER', 'claude', env), 'Unsupported RUNTIME_PROVIDER');
     assertProviderCompatibility(provider, 'Unsupported RUNTIME_PROVIDER', env);
     const agentApiKey = requireEnv('BORGEE_AGENT_API_KEY', env);
+    const providerConfig = resolveProviderCommandConfig({
+        claudeCommand: envOr('CLAUDE_COMMAND', DEFAULT_PROVIDER_COMMAND_CONFIG.claudeCommand, env),
+        claudeArgs: parseArgs(envOr('CLAUDE_ARGS', DEFAULT_PROVIDER_COMMAND_CONFIG.claudeArgs.join(' '), env)),
+        codexCommand: envOr('CODEX_COMMAND', DEFAULT_PROVIDER_COMMAND_CONFIG.codexCommand, env),
+        codexArgs: parseArgs(envOr('CODEX_ARGS', DEFAULT_PROVIDER_COMMAND_CONFIG.codexArgs.join(' '), env)),
+        copilotCommand: envOr('COPILOT_COMMAND', DEFAULT_PROVIDER_COMMAND_CONFIG.copilotCommand, env),
+        copilotArgs: parseArgs(envOr('COPILOT_ARGS', DEFAULT_PROVIDER_COMMAND_CONFIG.copilotArgs.join(' '), env)),
+        copilotSessionTtlMinutes: env.COPILOT_SESSION_TTL_MINUTES && env.COPILOT_SESSION_TTL_MINUTES.trim().length > 0
+            ? parseCopilotSessionTtlMinutesValue(env.COPILOT_SESSION_TTL_MINUTES, 'environment variable COPILOT_SESSION_TTL_MINUTES')
+            : DEFAULT_PROVIDER_COMMAND_CONFIG.copilotSessionTtlMinutes,
+    });
+    assertProviderCommandCompatibility(provider, providerConfig, 'environment variables');
     return {
         borgeeBaseUrl: requireEnv('BORGEE_BASE_URL', env),
         stateRootDir: resolveSingleAgentStateRoot(env, undefined, agentApiKey),
-        ...resolveProviderCommandConfig({
-            claudeCommand: envOr('CLAUDE_COMMAND', DEFAULT_PROVIDER_COMMAND_CONFIG.claudeCommand, env),
-            claudeArgs: parseArgs(envOr('CLAUDE_ARGS', DEFAULT_PROVIDER_COMMAND_CONFIG.claudeArgs.join(' '), env)),
-            codexCommand: envOr('CODEX_COMMAND', DEFAULT_PROVIDER_COMMAND_CONFIG.codexCommand, env),
-            codexArgs: parseArgs(envOr('CODEX_ARGS', DEFAULT_PROVIDER_COMMAND_CONFIG.codexArgs.join(' '), env)),
-            copilotCommand: envOr('COPILOT_COMMAND', DEFAULT_PROVIDER_COMMAND_CONFIG.copilotCommand, env),
-            copilotArgs: parseArgs(envOr('COPILOT_ARGS', DEFAULT_PROVIDER_COMMAND_CONFIG.copilotArgs.join(' '), env)),
-            copilotSessionTtlMinutes: env.COPILOT_SESSION_TTL_MINUTES && env.COPILOT_SESSION_TTL_MINUTES.trim().length > 0
-                ? parseCopilotSessionTtlMinutesValue(env.COPILOT_SESSION_TTL_MINUTES, 'environment variable COPILOT_SESSION_TTL_MINUTES')
-                : DEFAULT_PROVIDER_COMMAND_CONFIG.copilotSessionTtlMinutes,
-        }),
+        ...providerConfig,
         agent: {
             agentApiKey,
             agentName: envOr('BORGEE_AGENT_NAME', 'Assistant', env),

package/dist/gateway/localhost-gateway.js

@@ -778,8 +778,12 @@ function parseUpdateTaskInput(taskId, body) {
         status: readOptionalString(body.status),
         assigneeId: readOptionalString(body.assigneeId) ?? readOptionalString(body.assignee_id),
         title: readOptionalString(body.title),
+        description: readOptionalString(body.description),
     };
-    if (input.status === undefined && input.assigneeId === undefined && input.title === undefined) {
+    if (input.status === undefined &&
+        input.assigneeId === undefined &&
+        input.title === undefined &&
+        input.description === undefined) {
         throw new GatewayHttpError(400, { error: 'no_updates' }, 'bad-request');
     }
     return input;

package/dist/local-config.js

@@ -2,7 +2,7 @@ import { promises as fs } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
 import { parseDocument, stringify } from 'yaml';
-import { assertProviderCompatibility, optionalNonEmptyString, optionalStringArray, parseCopilotSessionTtlMinutesValue, requireNonEmptyString, resolveProvider, resolveProviderCommandConfig, } from './config.js';
+import { assertProviderCompatibility, assertProviderCommandCompatibility, optionalNonEmptyString, optionalStringArray, parseCopilotSessionTtlMinutesValue, requireNonEmptyString, resolveProvider, resolveProviderCommandConfig, } from './config.js';
 import { resolveLocalConfigAgentStateRoot } from './state-paths.js';
 const SUPPORTED_CONFIG_EXTENSIONS = new Set(['.json', '.yaml', '.yml']);
 export const DEFAULT_LOCAL_HOST_CONFIG_FILENAME = 'agents-host.yaml';
@@ -186,6 +186,8 @@ export function parseGenerateConfigSpec(value, sourceLabel, env = process.env) {
             throw new Error(`Invalid generate-config agents[${index}] in ${sourceLabel}: expected an object`);
         }
         const agent = parseAgentConfigFile(`generate-config agents[${index}] in ${sourceLabel}`, entry, env);
+        const providerConfig = resolveAgentProviderCommandConfig(host.defaults, agent);
+        assertProviderCommandCompatibility(agent.provider, providerConfig, `generate-config agents[${index}] in ${sourceLabel}`);
         const existingIndex = seenKeys.get(agent.key);
         if (existingIndex !== undefined) {
             throw new Error(`Duplicate generate-config agent key "${agent.key}" in ${sourceLabel} at indexes ${existingIndex} and ${index}`);
@@ -598,6 +600,7 @@ function buildManagedAgentSnapshot(host, stateRootBaseDir, sourcePath, agent) {
         ...host.defaults,
         ...parseProviderCommandOverrides(agent, `agent config ${sourcePath}`),
     });
+    assertProviderCommandCompatibility(agent.provider, providerConfig, `agent config ${sourcePath}`);
     const config = {
         borgeeBaseUrl: host.borgeeBaseUrl,
         stateRootDir: resolveLocalConfigAgentStateRoot(stateRootBaseDir, agent.key),
@@ -614,6 +617,20 @@ function buildManagedAgentSnapshot(host, stateRootBaseDir, sourcePath, agent) {
         config,
     };
 }
+function resolveAgentProviderCommandConfig(hostDefaults, agent) {
+    return resolveProviderCommandConfig({
+        ...hostDefaults,
+        ...(agent.claudeCommand !== undefined ? { claudeCommand: agent.claudeCommand } : {}),
+        ...(agent.claudeArgs !== undefined ? { claudeArgs: agent.claudeArgs } : {}),
+        ...(agent.codexCommand !== undefined ? { codexCommand: agent.codexCommand } : {}),
+        ...(agent.codexArgs !== undefined ? { codexArgs: agent.codexArgs } : {}),
+        ...(agent.copilotCommand !== undefined ? { copilotCommand: agent.copilotCommand } : {}),
+        ...(agent.copilotArgs !== undefined ? { copilotArgs: agent.copilotArgs } : {}),
+        ...(agent.copilotSessionTtlMinutes !== undefined
+            ? { copilotSessionTtlMinutes: agent.copilotSessionTtlMinutes }
+            : {}),
+    });
+}
 export async function loadLocalConfigSnapshot(hostConfigPath, deps = {}) {
     const fileSystem = deps.fileSystem ?? nodeFileSystem;
     const absoluteHostConfigPath = resolve(hostConfigPath);
@@ -698,6 +715,8 @@ export async function loadLocalConfigGenerateSpec(hostConfigPath, deps = {}) {
             }
             const agentRecord = await loadParsedDocument(fileSystem, agentFilePath, 'agent config');
             const agentConfig = parseAgentConfigFile(agentFilePath, agentRecord, deps.env);
+            const providerConfig = resolveAgentProviderCommandConfig(hostConfig.defaults, agentConfig);
+            assertProviderCommandCompatibility(agentConfig.provider, providerConfig, `agent config ${agentFilePath}`);
             const existingPath = seenKeys.get(agentConfig.key);
             if (existingPath) {
                 throw new Error(`Duplicate agent key "${agentConfig.key}" in ${existingPath} and ${agentFilePath}`);