@alpacakit/agents 0.2.0-beta.2 → 0.2.0-beta.3

package/README.md

@@ -408,6 +408,27 @@ installed skills and MCP servers remains in progress.
 | `/testing` | `fakeExec`, `fakeClock`, `fakeAgent`, `fakeSecretResolver` — no subprocess ever spawns |
 | `/codex` | codex app-server JSON-RPC client: typed requests, `incoming` notifications / server requests, `respond` (advanced) |
 
+## Changes in 0.2.0-beta.3
+
+- `run()` with `sandbox: { mode: "read-only" }` passes
+  `--permission-mode manual` to claude (was `default`), and `run()` with
+  `mode: "full"` passes `--allow-dangerously-skip-permissions` next to
+  `bypassPermissions`, as sessions already did. One function
+  (`permissionModeArgs`) now decides how a mode reaches the CLI for run and
+  session alike; `manual` is the spelling `claude --help` (2.1.270) lists —
+  `default` is not among its choices — and the allow flag is what makes
+  `bypassPermissions` an option at all.
+- `agent.auth.check` for a home-dir material answers `unknown` when the
+  probe cannot start (no binary on PATH, spawn fault) instead of throwing —
+  the same policy the availability probe already had.
+- Internal structure (no API change): the facts of a CLI child process
+  (PATH resolution, output tails, redacted failure evidence, signal
+  escalation) live once in `core/cli-child.ts`; each built-in host spells
+  its vocabulary once in `agents/<host>/cli.ts`; the kernel drives every
+  Session (`kernel/session.ts`) and the host adapters only encode and
+  decode. `SessionEvent.turnId` is the host's turn id when it has one
+  (Codex) and a per-session counter otherwise (Claude).
+
 ## Breaking changes in 0.2.0
 
 - `Agent.session` (and `AgentDefinition.session`) are new; `AgentDefinition`

package/dist/agents/builtin.d.ts

@@ -4,8 +4,8 @@
  * the config layer reuses `BUILTIN_AGENT_ID` for its agent-config kinds —
  * so "codex"/"claude" is spelled once, not once per layer.
  */
-import { claude } from "./claude.js";
-import { codex } from "./codex.js";
+import { claude } from "./claude/index.js";
+import { codex } from "./codex/index.js";
 export declare const BUILTIN_AGENT_ID: {
     readonly codex: "codex";
     readonly claude: "claude";

package/dist/agents/builtin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builtin.d.ts","sourceRoot":"","sources":["../../src/agents/builtin.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,eAAO,MAAM,gBAAgB;;;CAGnB,CAAC;AAEX,MAAM,MAAM,cAAc,GACxB,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,OAAO,gBAAgB,CAAC,CAAC;AAE3D,wEAAwE;AACxE,eAAO,MAAM,qBAAqB;;;CAA6B,CAAC"}
+{"version":3,"file":"builtin.d.ts","sourceRoot":"","sources":["../../src/agents/builtin.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,eAAO,MAAM,gBAAgB;;;CAGnB,CAAC;AAEX,MAAM,MAAM,cAAc,GACxB,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,OAAO,gBAAgB,CAAC,CAAC;AAE3D,wEAAwE;AACxE,eAAO,MAAM,qBAAqB;;;CAA6B,CAAC"}

package/dist/agents/builtin.js

@@ -4,11 +4,13 @@
  * the config layer reuses `BUILTIN_AGENT_ID` for its agent-config kinds —
  * so "codex"/"claude" is spelled once, not once per layer.
  */
-import { claude } from "./claude.js";
-import { codex } from "./codex.js";
+import { CLAUDE } from "./claude/cli.js";
+import { claude } from "./claude/index.js";
+import { CODEX } from "./codex/cli.js";
+import { codex } from "./codex/index.js";
 export const BUILTIN_AGENT_ID = {
-    codex: "codex",
-    claude: "claude",
+    codex: CODEX.id,
+    claude: CLAUDE.id,
 };
 /** Keyed record, not a branch: adding a built-in is adding an entry. */
 export const builtinAgentFactories = { claude, codex };

package/dist/agents/claude/cli.d.ts

@@ -0,0 +1,133 @@
+/**
+ * The Claude CLI vocabulary, spelled once: command and flags, the
+ * permission-mode words and how the flag spells them, the stream-json
+ * record types and fields, and the host's own file names. The run adapter
+ * (`index.ts`), the session adapter (`session.ts`), and the host plane
+ * (`host.ts`) all read from here and never respell a word.
+ */
+import { type UnknownRecord } from "../../core/json.js";
+import type { AgentEvent } from "../../core/run.js";
+import type { CliResultCapture } from "../../kernel/cli-agent.js";
+export declare const CLAUDE_CONFIG_DIR_ENV_VAR = "CLAUDE_CONFIG_DIR";
+export declare const CLAUDE_API_KEY_ENV_VAR = "ANTHROPIC_API_KEY";
+/** Spelled as the transcript's `permissionMode` records it. */
+export declare const CLAUDE_PERMISSION_MODE: {
+    readonly default: "default";
+    readonly acceptEdits: "acceptEdits";
+    readonly auto: "auto";
+    readonly bypassPermissions: "bypassPermissions";
+    readonly dontAsk: "dontAsk";
+    readonly plan: "plan";
+};
+export type ClaudePermissionMode = (typeof CLAUDE_PERMISSION_MODE)[keyof typeof CLAUDE_PERMISSION_MODE];
+export type ClaudeSessionPermissions = {
+    readonly mode: ClaudePermissionMode;
+};
+export declare const CLAUDE: {
+    readonly id: "claude";
+    readonly command: "claude";
+    readonly cli: {
+        readonly prompt: "-p";
+        readonly model: "--model";
+        readonly effort: "--effort";
+        readonly outputFormat: "--output-format";
+        readonly inputFormat: "--input-format";
+        readonly streamJson: "stream-json";
+        readonly permissionMode: "--permission-mode";
+        /** The flag spells the transcript's `default` mode `manual` (claude 2.1.270 `--help`). */
+        readonly manualPermissionMode: "manual";
+        readonly allowDangerouslySkipPermissions: "--allow-dangerously-skip-permissions";
+        readonly permissionPromptTool: "--permission-prompt-tool";
+        readonly stdio: "stdio";
+        readonly resume: "--resume";
+        readonly sessionId: "--session-id";
+        readonly verbose: "--verbose";
+        readonly tools: "--tools";
+        readonly allowedTools: "--allowedTools";
+        readonly safeMode: "--safe-mode";
+        readonly strictMcpConfig: "--strict-mcp-config";
+        readonly noSessionPersistence: "--no-session-persistence";
+    };
+    readonly auth: {
+        readonly statusArgs: readonly ["auth", "status", "--json"];
+        readonly loginArgs: readonly ["auth", "login", "--claudeai"];
+    };
+    readonly mcp: {
+        readonly addJson: "add-json";
+        readonly mcp: "mcp";
+        readonly remove: "remove";
+        readonly scope: "--scope";
+    };
+    readonly plugin: {
+        readonly plugin: "plugin";
+        readonly install: "install";
+    };
+    readonly json: {
+        readonly field: {
+            readonly type: "type";
+            readonly message: "message";
+            readonly role: "role";
+            readonly content: "content";
+            readonly text: "text";
+            readonly name: "name";
+            readonly usage: "usage";
+            readonly result: "result";
+            readonly inputTokens: "input_tokens";
+            readonly outputTokens: "output_tokens";
+            readonly totalCost: "total_cost_usd";
+            readonly request: "request";
+            readonly requestId: "request_id";
+            readonly response: "response";
+            readonly subtype: "subtype";
+            readonly error: "error";
+            readonly toolName: "tool_name";
+            readonly description: "description";
+            readonly input: "input";
+            readonly isError: "is_error";
+            readonly behavior: "behavior";
+            readonly updatedInput: "updatedInput";
+        };
+        readonly type: {
+            readonly user: "user";
+            readonly assistant: "assistant";
+            readonly result: "result";
+            readonly text: "text";
+            readonly toolUse: "tool_use";
+            readonly controlRequest: "control_request";
+            readonly controlResponse: "control_response";
+        };
+        readonly subtype: {
+            readonly interrupt: "interrupt";
+            readonly canUseTool: "can_use_tool";
+            readonly success: "success";
+            readonly error: "error";
+        };
+        readonly behavior: {
+            readonly allow: "allow";
+            readonly deny: "deny";
+        };
+    };
+    readonly files: {
+        readonly root: ".claude";
+        readonly projects: "projects";
+        readonly sessions: "sessions";
+        readonly transcriptExtension: ".jsonl";
+        readonly registryExtension: ".json";
+        readonly cwd: "cwd";
+        readonly permissionMode: "permissionMode";
+        readonly sessionId: "sessionId";
+        readonly pid: "pid";
+        readonly entrypoint: "entrypoint";
+    };
+};
+/**
+ * The one rule for how a permission mode reaches the CLI: the flag spells
+ * `default` as `manual`, and `bypassPermissions` is only an option once
+ * `--allow-dangerously-skip-permissions` enables it (`claude --help`).
+ */
+export declare function permissionModeArgs(mode: ClaudePermissionMode): string[];
+export declare function parseClaudeLine(line: string): AgentEvent[];
+/** Events carried by one already-parsed stream-json record (`assistant` only). */
+export declare function parseClaudeRecord(record: UnknownRecord): AgentEvent[];
+export declare function parseClaudeResult(line: string): CliResultCapture | null;
+//# sourceMappingURL=cli.d.ts.map

package/dist/agents/claude/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../../src/agents/claude/cli.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAML,KAAK,aAAa,EACnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,UAAU,EAAY,MAAM,mBAAmB,CAAC;AAE9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAElE,eAAO,MAAM,yBAAyB,sBAAsB,CAAC;AAC7D,eAAO,MAAM,sBAAsB,sBAAsB,CAAC;AAE1D,+DAA+D;AAC/D,eAAO,MAAM,sBAAsB;;;;;;;CAOzB,CAAC;AAEX,MAAM,MAAM,oBAAoB,GAC9B,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,OAAO,sBAAsB,CAAC,CAAC;AAEvE,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;CACrC,CAAC;AAEF,eAAO,MAAM,MAAM;;;;;;;;;;;QAWf,0FAA0F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkFpF,CAAC;AAEX;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,oBAAoB,GAAG,MAAM,EAAE,CAUvE;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE,CAG1D;AAED,kFAAkF;AAClF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,aAAa,GAAG,UAAU,EAAE,CAgCrE;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAkBvE"}

package/dist/agents/{claude-stream.js → claude/cli.js}

@@ -1,11 +1,23 @@
 /**
- * Claude CLI stream-json vocabulary and line readers, shared by the
- * one-shot run adapter (`claude.ts`) and the long-lived session adapter
- * (`claude-session.ts`): one place spells the CLI's flags and the NDJSON
- * field names both of them read.
+ * The Claude CLI vocabulary, spelled once: command and flags, the
+ * permission-mode words and how the flag spells them, the stream-json
+ * record types and fields, and the host's own file names. The run adapter
+ * (`index.ts`), the session adapter (`session.ts`), and the host plane
+ * (`host.ts`) all read from here and never respell a word.
  */
-import { readJsonRecord, readNumber, readRecord, readString, readUnknownRecord, } from "../core/json.js";
-import { AGENT_EVENT_TYPE } from "../core/run.js";
+import { readJsonRecord, readNumber, readRecord, readString, readUnknownRecord, } from "../../core/json.js";
+import { AGENT_EVENT_TYPE } from "../../core/run.js";
+export const CLAUDE_CONFIG_DIR_ENV_VAR = "CLAUDE_CONFIG_DIR";
+export const CLAUDE_API_KEY_ENV_VAR = "ANTHROPIC_API_KEY";
+/** Spelled as the transcript's `permissionMode` records it. */
+export const CLAUDE_PERMISSION_MODE = {
+    default: "default",
+    acceptEdits: "acceptEdits",
+    auto: "auto",
+    bypassPermissions: "bypassPermissions",
+    dontAsk: "dontAsk",
+    plan: "plan",
+};
 export const CLAUDE = {
     id: "claude",
     command: "claude",
@@ -14,10 +26,16 @@ export const CLAUDE = {
         model: "--model",
         effort: "--effort",
         outputFormat: "--output-format",
+        inputFormat: "--input-format",
         streamJson: "stream-json",
         permissionMode: "--permission-mode",
-        bypassPermissions: "bypassPermissions",
-        defaultPermissionMode: "default",
+        /** The flag spells the transcript's `default` mode `manual` (claude 2.1.270 `--help`). */
+        manualPermissionMode: "manual",
+        allowDangerouslySkipPermissions: "--allow-dangerously-skip-permissions",
+        permissionPromptTool: "--permission-prompt-tool",
+        stdio: "stdio",
+        resume: "--resume",
+        sessionId: "--session-id",
         verbose: "--verbose",
         tools: "--tools",
         allowedTools: "--allowedTools",
@@ -43,6 +61,7 @@ export const CLAUDE = {
         field: {
             type: "type",
             message: "message",
+            role: "role",
             content: "content",
             text: "text",
             name: "name",
@@ -51,19 +70,71 @@ export const CLAUDE = {
             inputTokens: "input_tokens",
             outputTokens: "output_tokens",
             totalCost: "total_cost_usd",
+            request: "request",
+            requestId: "request_id",
+            response: "response",
+            subtype: "subtype",
+            error: "error",
+            toolName: "tool_name",
+            description: "description",
+            input: "input",
+            isError: "is_error",
+            behavior: "behavior",
+            updatedInput: "updatedInput",
         },
         type: {
+            user: "user",
             assistant: "assistant",
             result: "result",
             text: "text",
             toolUse: "tool_use",
+            controlRequest: "control_request",
+            controlResponse: "control_response",
+        },
+        subtype: {
+            interrupt: "interrupt",
+            canUseTool: "can_use_tool",
+            success: "success",
+            error: "error",
         },
+        behavior: { allow: "allow", deny: "deny" },
+    },
+    files: {
+        root: ".claude",
+        projects: "projects",
+        sessions: "sessions",
+        transcriptExtension: ".jsonl",
+        registryExtension: ".json",
+        cwd: "cwd",
+        permissionMode: "permissionMode",
+        sessionId: "sessionId",
+        pid: "pid",
+        entrypoint: "entrypoint",
     },
 };
+/**
+ * The one rule for how a permission mode reaches the CLI: the flag spells
+ * `default` as `manual`, and `bypassPermissions` is only an option once
+ * `--allow-dangerously-skip-permissions` enables it (`claude --help`).
+ */
+export function permissionModeArgs(mode) {
+    return [
+        CLAUDE.cli.permissionMode,
+        mode === CLAUDE_PERMISSION_MODE.default
+            ? CLAUDE.cli.manualPermissionMode
+            : mode,
+        ...(mode === CLAUDE_PERMISSION_MODE.bypassPermissions
+            ? [CLAUDE.cli.allowDangerouslySkipPermissions]
+            : []),
+    ];
+}
 export function parseClaudeLine(line) {
     const record = readJsonRecord(line);
-    if (record === null ||
-        readString(record, CLAUDE.json.field.type) !== CLAUDE.json.type.assistant) {
+    return record === null ? [] : parseClaudeRecord(record);
+}
+/** Events carried by one already-parsed stream-json record (`assistant` only). */
+export function parseClaudeRecord(record) {
+    if (readString(record, CLAUDE.json.field.type) !== CLAUDE.json.type.assistant) {
         return [];
     }
     const message = readRecord(record, CLAUDE.json.field.message);

package/dist/agents/claude/host.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The claude host plane: auth materials and sign-in, installed skills
+ * (`~/.claude/skills`, project `.claude/skills`, plugins), and MCP
+ * registration through the CLI. Outside a run and a session; every path
+ * comes from `HostContext.location`, never `os.homedir()`.
+ */
+import { type LoginCapability } from "../../auth/login.js";
+import type { MaterialHandlers } from "../../auth/material.js";
+import { type McpCapability, type SkillsCapability } from "../../host/capabilities.js";
+export declare const claudeAuth: MaterialHandlers;
+export declare const claudeLogin: LoginCapability;
+export declare const claudeSkills: SkillsCapability;
+export declare const claudeMcp: McpCapability;
+//# sourceMappingURL=host.d.ts.map

package/dist/agents/claude/host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../../../src/agents/claude/host.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,EAEL,KAAK,eAAe,EAErB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAmB,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAOhF,OAAO,EAML,KAAK,aAAa,EAKlB,KAAK,gBAAgB,EAEtB,MAAM,4BAA4B,CAAC;AA2WpC,eAAO,MAAM,UAAU,EAAE,gBAQxB,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,eAIzB,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,gBAO1B,CAAC;AAEF,eAAO,MAAM,SAAS,EAAE,aAMvB,CAAC"}

package/dist/agents/{claude.js → claude/host.js}

@@ -1,44 +1,36 @@
 /**
- * Built-in claude CLI contract:
- * `claude -p [--model m] [--effort e] --output-format stream-json
- *  --permission-mode <mode> [tool args] --verbose`, prompt on stdin.
- * Read-only grants map to `--allowedTools` (`Bash(cmd:*)` for shell
- * grants, the bare tool name otherwise); no grants means `--tools ""`.
+ * The claude host plane: auth materials and sign-in, installed skills
+ * (`~/.claude/skills`, project `.claude/skills`, plugins), and MCP
+ * registration through the CLI. Outside a run and a session; every path
+ * comes from `HostContext.location`, never `os.homedir()`.
  */
 import { cp, mkdir, readdir, readFile, rm, stat } from "node:fs/promises";
 import path from "node:path";
-import { LOGIN_METHOD } from "../auth/login.js";
-import { cliLoginProbe } from "../auth/login-probe.js";
-import { AUTH_MATERIAL_KIND, envVarAuthMaterial } from "../auth/material.js";
-import { requireSecret } from "../auth/secrets.js";
-import { AGENT_ERROR_CODE, AgentError } from "../core/error.js";
-import { isErrnoCode } from "../core/fs.js";
-import { readBoolean, readJsonRecord, readNumber, readRecord, readString, } from "../core/json.js";
-import { TEXT_ENCODING } from "../core/values.js";
-import { cliAvailability } from "../host/availability.js";
-import { INSTALL_STATUS, MCP_TRANSPORT, SKILL_SOURCE_KIND, } from "../host/capabilities.js";
-import { withStagedGithubDirectory, } from "../host/github-dir.js";
-import { listMcpServersViaCli } from "../host/mcp-list.js";
-import { hostCommandFailedError, runHostCommand, runHostCommandResult, } from "../host/run-command.js";
-import { parseEpochTimestamp, } from "../kernel/classify.js";
-import { defineCliAgent } from "../kernel/cli-agent.js";
-import { cliLoginCommand } from "../kernel/cli-login.js";
-import { GRANT_KIND, SANDBOX_MODE } from "../kernel/options.js";
-import { claudeSessions, } from "./claude-session.js";
-import { CLAUDE, parseClaudeLine, parseClaudeResult } from "./claude-stream.js";
-export const CLAUDE_CONFIG_DIR_ENV_VAR = "CLAUDE_CONFIG_DIR";
-export const CLAUDE_API_KEY_ENV_VAR = "ANTHROPIC_API_KEY";
+import { LOGIN_METHOD, } from "../../auth/login.js";
+import { cliLoginProbe } from "../../auth/login-probe.js";
+import { AUTH_MATERIAL_KIND, envVarAuthMaterial } from "../../auth/material.js";
+import { requireSecret } from "../../auth/secrets.js";
+import { NO_FAILURE_EVIDENCE } from "../../core/cli-child.js";
+import { AGENT_ERROR_CODE, AgentError } from "../../core/error.js";
+import { isErrnoCode } from "../../core/fs.js";
+import { TEXT_ENCODING } from "../../core/values.js";
+import { INSTALL_STATUS, MCP_TRANSPORT, SKILL_SOURCE_KIND, } from "../../host/capabilities.js";
+import { withStagedGithubDirectory, } from "../../host/github-dir.js";
+import { listMcpServersViaCli } from "../../host/mcp-list.js";
+import { hostCommandFailedError, runHostCommand, runHostCommandResult, } from "../../host/run-command.js";
+import { cliLoginCommand } from "../../kernel/cli-login.js";
+import { CLAUDE, CLAUDE_API_KEY_ENV_VAR, CLAUDE_CONFIG_DIR_ENV_VAR, } from "./cli.js";
 const COMPETING_TOKEN_VARS = [
-    "ANTHROPIC_API_KEY",
+    CLAUDE_API_KEY_ENV_VAR,
     "ANTHROPIC_AUTH_TOKEN",
     "CLAUDE_CODE_OAUTH_TOKEN",
 ];
 const COMPETING_CONFIG_VARS = [
-    "CLAUDE_CONFIG_DIR",
+    CLAUDE_CONFIG_DIR_ENV_VAR,
     "ANTHROPIC_AUTH_TOKEN",
     "CLAUDE_CODE_OAUTH_TOKEN",
 ];
-const CLAUDE_PROJECT_SKILL_ROOT = ".claude";
+const CLAUDE_PROJECT_SKILL_ROOT = CLAUDE.files.root;
 const SKILLS_DIRECTORY = "skills";
 const SKILL_MARKDOWN = "SKILL.md";
 const PLUGIN_ALREADY_INSTALLED = /already installed/i;
@@ -46,71 +38,6 @@ const CLAUDE_SKILL_SOURCE = {
     project: "claude:project",
     user: "claude:user",
 };
-function grantToToolArg(grant) {
-    return grant.kind === GRANT_KIND.shell
-        ? `Bash(${grant.command}:*)`
-        : grant.name;
-}
-function sharedArgs(ctx, customizations) {
-    return [
-        CLAUDE.cli.prompt,
-        ...(ctx.model === null ? [] : [CLAUDE.cli.model, ctx.model]),
-        ...(ctx.effort === null ? [] : [CLAUDE.cli.effort, ctx.effort]),
-        CLAUDE.cli.outputFormat,
-        CLAUDE.cli.streamJson,
-        ...(customizations === "disabled"
-            ? [
-                CLAUDE.cli.safeMode,
-                CLAUDE.cli.strictMcpConfig,
-                CLAUDE.cli.noSessionPersistence,
-            ]
-            : []),
-    ];
-}
-/**
- * Structured quota signals in Claude CLI NDJSON output (v1 F2), scanned
- * per line: rate_limit_event rejected (with resetsAt), api_error_status
- * 429, and error === "rate_limit". Exported for custom agents that speak
- * the same stream format.
- */
-export function structuredQuotaMatcher() {
-    return (evidence) => {
-        let fallbackCooldownUntil = null;
-        for (const line of evidence.stdout.split(/\r?\n/)) {
-            const record = readJsonRecord(line.trim());
-            if (record === null) {
-                continue;
-            }
-            const rateLimitInfo = readRecord(record, "rate_limit_info");
-            const resetsAt = rateLimitInfo === null ? null : readNumber(rateLimitInfo, "resetsAt");
-            const cooldownUntil = resetsAt === null ? null : parseEpochTimestamp(resetsAt);
-            const rejected = rateLimitInfo !== null &&
-                readString(rateLimitInfo, "status") === "rejected";
-            if (readString(record, "type") === "rate_limit_event" && rejected) {
-                return {
-                    code: AGENT_ERROR_CODE.quota,
-                    message: "Provider rejected the request for rate limiting",
-                    data: { cooldownUntil },
-                };
-            }
-            if (cooldownUntil !== null) {
-                fallbackCooldownUntil = cooldownUntil;
-            }
-            const apiError = readBoolean(record, "is_error") === true &&
-                readNumber(record, "api_error_status") === 429;
-            const rateLimitError = readString(record, "error") === "rate_limit" &&
-                readString(record, "type") !== null;
-            if (apiError || rateLimitError) {
-                return {
-                    code: AGENT_ERROR_CODE.quota,
-                    message: "Provider reported a rate-limit error",
-                    data: { cooldownUntil: fallbackCooldownUntil },
-                };
-            }
-        }
-        return null;
-    };
-}
 const homeDirHandler = envVarAuthMaterial({
     set: (material) => ({ [CLAUDE_CONFIG_DIR_ENV_VAR]: material.path }),
     unset: COMPETING_TOKEN_VARS,
@@ -135,7 +62,7 @@ const homeDirHandler = envVarAuthMaterial({
  * `--sso` are still browser flows), and declaring an unimplemented method
  * would make `agent.login.supports("device")` lie.
  */
-function claudeLogin(args) {
+function claudeLoginCommand(args) {
     return (request, ctx) => cliLoginCommand({
         command: CLAUDE.command,
         args,
@@ -195,7 +122,7 @@ function skillListReadError(target, cause) {
         code: AGENT_ERROR_CODE.failed,
         classification: AgentError.agentFailure(AGENT_ERROR_CODE.failed),
         message: `Could not read installed claude skills: ${target}`,
-        data: { exitCode: null, stdoutTail: null, stderrTail: null },
+        data: NO_FAILURE_EVIDENCE,
         cause,
     });
 }
@@ -361,82 +288,32 @@ async function removeClaudeMcp(ctx, name, options) {
 async function listClaudeMcp(ctx) {
     return listMcpServersViaCli(ctx, { command: CLAUDE.command });
 }
-export function claude(options = {}) {
-    const customizations = options.customizations ?? "inherit";
-    const definition = defineCliAgent({
-        id: CLAUDE.id,
-        command: CLAUDE.command,
-        args: {
-            [SANDBOX_MODE.full]: (_sandbox, ctx) => [
-                ...sharedArgs(ctx, customizations),
-                CLAUDE.cli.permissionMode,
-                CLAUDE.cli.bypassPermissions,
-                CLAUDE.cli.verbose,
-            ],
-            [SANDBOX_MODE.readOnly]: (sandbox, ctx) => [
-                ...sharedArgs(ctx, customizations),
-                CLAUDE.cli.permissionMode,
-                CLAUDE.cli.defaultPermissionMode,
-                ...(sandbox.grants.length === 0
-                    ? [CLAUDE.cli.tools, ""]
-                    : [
-                        CLAUDE.cli.allowedTools,
-                        sandbox.grants.map(grantToToolArg).join(","),
-                    ]),
-                CLAUDE.cli.verbose,
-            ],
-        },
-        parseLine: parseClaudeLine,
-        parseResult: parseClaudeResult,
-        classify: [structuredQuotaMatcher()],
-        // F6: Claude CLI can report a structured quota rejection on exit 0.
-        classifyOnSuccess: [structuredQuotaMatcher()],
-        availability: cliAvailability({
-            command: CLAUDE.command,
-            commandMissingRemediation: {
-                detail: "Install Claude Code and ensure `claude` is on PATH.",
-                command: null,
-            },
-            authentication: {
-                args: CLAUDE.auth.statusArgs,
-                remediation: {
-                    detail: "Sign in to Claude Code.",
-                    command: {
-                        executable: CLAUDE.command,
-                        args: CLAUDE.auth.loginArgs,
-                    },
-                },
-            },
+export const claudeAuth = {
+    [AUTH_MATERIAL_KIND.homeDir]: homeDirHandler,
+    [AUTH_MATERIAL_KIND.apiKey]: envVarAuthMaterial({
+        set: async (material, secrets) => ({
+            [CLAUDE_API_KEY_ENV_VAR]: await requireSecret(secrets, material.secret),
         }),
-        auth: {
-            [AUTH_MATERIAL_KIND.homeDir]: homeDirHandler,
-            [AUTH_MATERIAL_KIND.apiKey]: envVarAuthMaterial({
-                set: async (material, secrets) => ({
-                    [CLAUDE_API_KEY_ENV_VAR]: await requireSecret(secrets, material.secret),
-                }),
-                unset: COMPETING_CONFIG_VARS,
-            }),
-        },
-        login: {
-            methods: {
-                [LOGIN_METHOD.oauth]: claudeLogin(CLAUDE.auth.loginArgs),
-            },
-        },
-        skills: {
-            list: listClaudeSkills,
-            install: {
-                [SKILL_SOURCE_KIND.localDir]: installLocalClaudeSkill,
-                [SKILL_SOURCE_KIND.githubDir]: installGithubClaudeSkill,
-                [SKILL_SOURCE_KIND.plugin]: installClaudePlugin,
-            },
-        },
-        mcp: {
-            list: listClaudeMcp,
-            add: {
-                [MCP_TRANSPORT.stdio]: addClaudeStdioMcp,
-            },
-            remove: removeClaudeMcp,
-        },
-    });
-    return { ...definition, session: claudeSessions({ customizations }) };
-}
+        unset: COMPETING_CONFIG_VARS,
+    }),
+};
+export const claudeLogin = {
+    methods: {
+        [LOGIN_METHOD.oauth]: claudeLoginCommand(CLAUDE.auth.loginArgs),
+    },
+};
+export const claudeSkills = {
+    list: listClaudeSkills,
+    install: {
+        [SKILL_SOURCE_KIND.localDir]: installLocalClaudeSkill,
+        [SKILL_SOURCE_KIND.githubDir]: installGithubClaudeSkill,
+        [SKILL_SOURCE_KIND.plugin]: installClaudePlugin,
+    },
+};
+export const claudeMcp = {
+    list: listClaudeMcp,
+    add: {
+        [MCP_TRANSPORT.stdio]: addClaudeStdioMcp,
+    },
+    remove: removeClaudeMcp,
+};

package/dist/agents/{claude.d.ts → claude/index.d.ts}

@@ -1,15 +1,14 @@
 /**
- * Built-in claude CLI contract:
- * `claude -p [--model m] [--effort e] --output-format stream-json
- *  --permission-mode <mode> [tool args] --verbose`, prompt on stdin.
- * Read-only grants map to `--allowedTools` (`Bash(cmd:*)` for shell
- * grants, the bare tool name otherwise); no grants means `--tools ""`.
+ * The built-in claude agent: the one-shot run contract
+ * (`claude -p [--model m] [--effort e] --output-format stream-json
+ *  --permission-mode <mode> [tool args] --verbose`, prompt on stdin;
+ * read-only grants map to `--allowedTools`, `Bash(cmd:*)` for shell
+ * grants, no grants means `--tools ""`) composed with the session adapter
+ * and the host plane. Vocabulary lives in `cli.ts`.
  */
-import { type FailureMatcher } from "../kernel/classify.js";
-import type { AgentDefinition } from "../kernel/definition.js";
-import { type ClaudeSessionPermissions } from "./claude-session.js";
-export declare const CLAUDE_CONFIG_DIR_ENV_VAR = "CLAUDE_CONFIG_DIR";
-export declare const CLAUDE_API_KEY_ENV_VAR = "ANTHROPIC_API_KEY";
+import { type FailureMatcher } from "../../kernel/classify.js";
+import type { AgentDefinition } from "../../kernel/definition.js";
+import { type ClaudeSessionPermissions } from "./cli.js";
 /**
  * Structured quota signals in Claude CLI NDJSON output (v1 F2), scanned
  * per line: rate_limit_event rejected (with resetsAt), api_error_status
@@ -25,4 +24,4 @@ export type ClaudeOptions = {
     readonly customizations?: "inherit" | "disabled";
 };
 export declare function claude(options?: ClaudeOptions): AgentDefinition<"claude", ClaudeSessionPermissions>;
-//# sourceMappingURL=claude.d.ts.map
+//# sourceMappingURL=index.d.ts.map

package/dist/agents/claude/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/agents/claude/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAWH,OAAO,EACL,KAAK,cAAc,EAEpB,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAElE,OAAO,EAGL,KAAK,wBAAwB,EAI9B,MAAM,UAAU,CAAC;AA8BlB;;;;;GAKG;AACH,wBAAgB,sBAAsB,IAAI,cAAc,CA0CvD;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC;CAClD,CAAC;AAEF,wBAAgB,MAAM,CACpB,OAAO,GAAE,aAAkB,GAC1B,eAAe,CAAC,QAAQ,EAAE,wBAAwB,CAAC,CAmDrD"}