@axtary/cli 0.0.1 → 0.1.0

package/dist/index.js

@@ -2,18 +2,43 @@ import { generateKeyPairSync } from "node:crypto";
 import { createServer } from "node:http";
 import { readFile, readdir, stat, writeFile } from "node:fs/promises";
 import { extname, resolve } from "node:path";
-import { AxtaryDecisionSchema, demoAction, parseNormalizedAction, } from "@axtary/actionpass";
+import { createInterface } from "node:readline";
+import { AxtaryDecisionSchema, createApprovalArtifact, demoAction, hashPayload, parseNormalizedAction, } from "@axtary/actionpass";
 import { createFakeAdapterState, createFakeHandlers, createAwsRestHandlers, createGcpRestHandlers, createGitHubRestHandlers, createLinearGraphqlHandlers, createLocalDocsHandlers, createSlackWebHandlers, smokeAwsRestCredentials, smokeGcpRestCredentials, smokeGitHubRestCredentials, smokeLinearGraphqlCredentials, smokeLocalDocsRoots, smokeSlackWebCredentials, } from "@axtary/adapters";
 import { loadAxtaryConfig, CachedConfigLoader } from "@axtary/config";
 import { exportLedgerRecords, formatLedgerExport, LedgerExportFormatSchema, LocalJsonlLedger, syncLedgerExport, } from "@axtary/ledger";
-import { MCP_TOOL_CALL, createMcpAction, createMcpFixtureToolHandler, createMcpToolDefinition, } from "@axtary/mcp";
-import { evaluatePolicy } from "@axtary/policy";
+import { MCP_TOOL_CALL, McpStdioClient, createMcpAction, createMcpFixtureToolHandler, createMcpToolDefinition, createMcpToolRouter, createMcpWrapperServer, createMcpWrapperTool, } from "@axtary/mcp";
+import { evaluatePolicy, explainPolicyDecision } from "@axtary/policy";
 import { createProxyRuntime, } from "@axtary/proxy";
+import { runClaudeCodeHook } from "./claude-code-hook.js";
+export { CLAUDE_CODE_HOOK_SCHEMA_VERSION, normalizeClaudeCodeToolCall, parseClaudeCodeHookPayload, runClaudeCodeHook, } from "./claude-code-hook.js";
 export const DEMO_SCHEMA_VERSION = "axtary.demo.v0";
 export const POLICY_TEST_SCHEMA_VERSION = "axtary.policy_test.v0";
 export const LOCAL_PROXY_SCHEMA_VERSION = "axtary.local_proxy.v0";
 export const LEDGER_EXPORT_RUN_SCHEMA_VERSION = "axtary.ledger_export_run.v0";
 export const LEDGER_SYNC_RUN_SCHEMA_VERSION = "axtary.ledger_sync_run.v0";
+export const CONNECTOR_DOCTOR_SCHEMA_VERSION = "axtary.connector_doctor.v0";
+export const REAL_WORKFLOW_RUN_SCHEMA_VERSION = "axtary.real_workflow_run.v0";
+export function authorizeDecisionHints(decision, policy) {
+    const hints = [];
+    for (const reason of decision.reasons) {
+        if (reason === "slack_channel_not_allowed") {
+            hints.push(`Allowed Slack channels: ${policy.slack.messages.allowedChannels.join(", ") || "none configured"}.`);
+        }
+        if ((reason === "content_read_denied_path" ||
+            reason === "payload_touches_denied_path") &&
+            decision.constraints.blockedPaths.length > 0) {
+            hints.push(`Blocked path prefixes: ${decision.constraints.blockedPaths.join(", ")}.`);
+        }
+        if (reason === "payload_touches_step_up_path") {
+            hints.push("A human must approve the exact payload before this executes.");
+        }
+        if (reason.startsWith("unsupported_tool:")) {
+            hints.push("This tool is not governed by the active policy and fails closed.");
+        }
+    }
+    return hints;
+}
 const MCP_DEMO_TOOL_DEFINITION = createMcpToolDefinition({
     serverIdentity: "mcp:axtary-demo-fixtures",
     serverVersion: "1.0.0",
@@ -250,6 +275,24 @@ export async function startProxyServer(input = {}) {
                 writeJson(response, statusCode, result);
                 return;
             }
+            if (request.method === "POST" && request.url === "/authorize") {
+                const body = await readJsonBody(request);
+                const result = await runtime.authorize(body);
+                if (result.status === "malformed") {
+                    writeJson(response, 400, result);
+                    return;
+                }
+                const policy = (await configLoader.getConfig()).config.policy;
+                writeJson(response, 200, {
+                    ...result,
+                    actionPass: result.actionPass
+                        ? { token: result.actionPass.token, claims: result.actionPass.claims }
+                        : null,
+                    explanation: explainPolicyDecision(result.decision),
+                    hints: authorizeDecisionHints(result.decision, policy),
+                });
+                return;
+            }
             writeJson(response, 404, {
                 schemaVersion: LOCAL_PROXY_SCHEMA_VERSION,
                 error: "not_found",
@@ -276,6 +319,245 @@ export async function startProxyServer(input = {}) {
         close: () => close(server),
     };
 }
+export const INIT_SCHEMA_VERSION = "axtary.init.v0";
+export const INIT_CONFIG_TEMPLATE = `schemaVersion: axtary.config.v0
+issuer: https://local.axtary.dev
+tenant: org:local
+ledger:
+  path: .axtary/actions.jsonl
+runtime:
+  allowUnsignedExecution: false
+  handlerTimeoutMs: 10000
+adapters:
+  # Start in fake mode: deterministic local adapters, no credentials needed.
+  # Switch a provider to its real mode (rest/web/graphql) once its env token is set.
+  github:
+    mode: fake
+    tokenEnv: GITHUB_TOKEN
+    apiBaseUrl: https://api.github.com
+    userAgent: axtary-local-proxy
+  slack:
+    mode: fake
+    tokenEnv: SLACK_BOT_TOKEN
+    apiBaseUrl: https://slack.com/api
+  linear:
+    mode: fake
+    tokenEnv: LINEAR_API_KEY
+    apiUrl: https://api.linear.app/graphql
+policy:
+  version: "${new Date().toISOString().slice(0, 10)}"
+  github:
+    pullRequests:
+      requiredBaseBranch: main
+      maxFilesChanged: 12
+      denyPathPrefixes:
+        - .env
+        - secrets/
+      stepUpPathPrefixes:
+        - infra/prod/
+        - billing/
+        - auth/
+      requiresTests: true
+    contents:
+      denyReadPathPrefixes:
+        - .env
+        - secrets/
+        - infra/prod/
+  slack:
+    messages:
+      allowedChannels:
+        - "#axtary-dev"
+      stepUpExternalRecipients: true
+demo:
+  scenario: coding-agent
+`;
+export async function runInit(input = {}) {
+    const cwd = resolve(input.cwd ?? process.cwd());
+    const configPath = resolve(cwd, input.configPath ?? "axtary.yml");
+    const exists = await stat(configPath).then(() => true, () => false);
+    if (exists && input.force !== true) {
+        return {
+            schemaVersion: INIT_SCHEMA_VERSION,
+            status: "exists",
+            configPath,
+        };
+    }
+    await writeFile(configPath, INIT_CONFIG_TEMPLATE, "utf8");
+    return {
+        schemaVersion: INIT_SCHEMA_VERSION,
+        status: "created",
+        configPath,
+    };
+}
+export function formatInitResult(result) {
+    if (result.status === "exists") {
+        return [
+            `axtary.yml already exists at ${result.configPath}.`,
+            "Re-run with --force to overwrite it.",
+            "",
+        ].join("\n");
+    }
+    return [
+        `Created ${result.configPath}.`,
+        "",
+        "Next steps (the ten-minute rail, see docs/quickstart.md):",
+        "  1. axtary doctor connectors --config axtary.yml   # readiness checklist; fake mode needs no credentials",
+        "  2. axtary proxy --config axtary.yml               # start the local enforcement point",
+        "  3. axtary demo --config axtary.yml                # watch safe + unsafe actions hit policy and the ledger",
+        "  4. Gate a live Claude Code session: docs/claude-code-hook.md (PreToolUse hook)",
+        "     or any MCP agent: docs/mcp-wrapper.md (axtary mcp serve)",
+        "",
+        "First blocked action without an agent:",
+        "  with the proxy running, ask it to read .env.production through the hook:",
+        "  echo '{\"tool_name\":\"Read\",\"tool_input\":{\"file_path\":\".env.production\"}}' | axtary hook claude-code",
+        "",
+    ].join("\n");
+}
+export const MCP_SERVE_SCHEMA_VERSION = "axtary.mcp_serve.v0";
+export async function startMcpServe(input = {}) {
+    const loadedConfig = await loadAxtaryConfig({
+        filePath: input.configPath,
+        cwd: input.cwd,
+    });
+    const cwd = resolve(input.cwd ?? process.cwd());
+    const ledgerPath = input.ledgerPath
+        ? resolve(cwd, input.ledgerPath)
+        : loadedConfig.ledgerPath;
+    const ledger = new LocalJsonlLedger(ledgerPath);
+    const { privateKey } = generateKeyPairSync("ec", { namedCurve: "P-256" });
+    const log = input.log ?? ((text) => process.stderr.write(text));
+    let upstream = null;
+    let tools;
+    if (input.wrap) {
+        const [command, ...commandArgs] = input.wrap.split(/\s+/).filter(Boolean);
+        if (!command) {
+            throw new Error("mcp_serve_wrap_command_required");
+        }
+        upstream = await McpStdioClient.start({ command, args: commandArgs });
+        const serverInfo = upstream.serverInfo;
+        const listings = await upstream.listTools();
+        const client = upstream;
+        tools = listings.map((listing) => createMcpWrapperTool({
+            definition: {
+                serverIdentity: `mcp:${serverInfo.name}`,
+                serverVersion: serverInfo.version,
+                schemaVersion: serverInfo.version,
+                name: listing.name,
+                description: listing.description,
+                inputSchema: listing.inputSchema,
+            },
+            invoke: ({ call }) => client.callTool(call.toolName, call.arguments),
+        }));
+    }
+    else {
+        tools = [
+            createMcpWrapperTool({
+                definition: MCP_DEMO_TOOL_DEFINITION,
+                invoke: ({ call }) => {
+                    const fixtureKey = typeof call.arguments.fixtureKey === "string"
+                        ? call.arguments.fixtureKey
+                        : "";
+                    const fixture = MCP_DEMO_FIXTURES[fixtureKey];
+                    if (fixture === undefined) {
+                        throw new Error(`mcp_fixture_not_found:${fixtureKey}`);
+                    }
+                    return fixture;
+                },
+            }),
+        ];
+    }
+    if (tools.length === 0) {
+        upstream?.close();
+        throw new Error("mcp_serve_no_tools_discovered");
+    }
+    const policy = {
+        ...loadedConfig.config.policy,
+        mcp: {
+            ...loadedConfig.config.policy.mcp,
+            enabled: true,
+            allowedTools: [
+                ...(loadedConfig.config.policy.mcp.allowedTools ?? []),
+                ...tools.map((tool) => ({
+                    serverIdentity: tool.definition.serverIdentity,
+                    toolName: tool.definition.name,
+                    definitionHash: tool.definition.definitionHash,
+                })),
+            ],
+        },
+    };
+    const runtime = createProxyRuntime({
+        issuer: loadedConfig.config.issuer,
+        tenant: loadedConfig.config.tenant,
+        ledger,
+        policy,
+        signingKey: privateKey,
+        keyId: "local-mcp-serve-key",
+        allowUnsignedExecution: loadedConfig.config.runtime.allowUnsignedExecution,
+        handlerTimeoutMs: loadedConfig.config.runtime.handlerTimeoutMs,
+        handlers: {
+            [MCP_TOOL_CALL]: createMcpToolRouter(tools),
+        },
+    });
+    const server = createMcpWrapperServer({
+        tools,
+        runtime,
+        actor: {
+            agentId: "agent:mcp-client",
+            humanOwner: input.owner ?? "user:local-developer",
+            runtime: "mcp",
+        },
+    });
+    const inputStream = input.input ?? process.stdin;
+    const outputStream = input.output ?? process.stdout;
+    const readline = createInterface({ input: inputStream });
+    let pendingWrites = Promise.resolve();
+    readline.on("line", (line) => {
+        const trimmed = line.trim();
+        if (trimmed.length === 0) {
+            return;
+        }
+        pendingWrites = pendingWrites.then(async () => {
+            let response;
+            try {
+                response = await server.handleMessage(JSON.parse(trimmed));
+            }
+            catch {
+                response = {
+                    jsonrpc: "2.0",
+                    id: null,
+                    error: { code: -32700, message: "parse_error" },
+                };
+            }
+            if (response !== null) {
+                outputStream.write(`${JSON.stringify(response)}\n`);
+            }
+        });
+    });
+    const done = new Promise((resolveDone) => {
+        readline.once("close", () => {
+            void pendingWrites.finally(resolveDone);
+        });
+    });
+    for (const tool of tools) {
+        log(`wrapped ${tool.definition.serverIdentity}/${tool.definition.name} ${tool.definition.definitionHash}\n`);
+    }
+    log(`ledger: ${ledgerPath}\n`);
+    return {
+        schemaVersion: MCP_SERVE_SCHEMA_VERSION,
+        ledgerPath,
+        tools: tools.map((tool) => ({
+            name: tool.definition.name,
+            serverIdentity: tool.definition.serverIdentity,
+            definitionHash: tool.definition.definitionHash,
+        })),
+        done,
+        close: async () => {
+            readline.close();
+            upstream?.close();
+            await pendingWrites;
+        },
+    };
+}
 export async function runDemo(input = {}) {
     const loadedConfig = await loadAxtaryConfig({
         filePath: input.configPath,
@@ -533,6 +815,157 @@ export async function runSmokeTest(input = {}, io = {}) {
     }
     return failed ? 1 : 0;
 }
+export async function runConnectorDoctor(input = {}) {
+    const env = input.env ?? process.env;
+    const fetchImpl = input.fetch ?? fetch;
+    const loadedConfig = await loadAxtaryConfig({
+        filePath: input.configPath,
+        cwd: input.cwd,
+    });
+    const providers = [];
+    const githubConfig = loadedConfig.config.adapters.github;
+    providers.push(await doctorProvider({
+        provider: "github",
+        mode: githubConfig.mode,
+        activeMode: "rest",
+        capability: githubConfig.mode === "rest" ? "real-write" : "fake",
+        requiredEnv: githubConfig.mode === "rest" ? [githubConfig.tokenEnv] : [],
+        requiredScopes: githubConfig.mode === "rest"
+            ? ["pull_requests:write", "contents:write", "metadata:read"]
+            : [],
+        smokeCheck: githubConfig.mode === "rest" ? "GET /user" : null,
+        env,
+        runSmoke: githubConfig.mode === "rest"
+            ? () => smokeGitHubRestCredentials({
+                token: env[githubConfig.tokenEnv] ?? "",
+                apiBaseUrl: githubConfig.apiBaseUrl,
+                userAgent: githubConfig.userAgent,
+                fetch: fetchImpl,
+                maxRetries: 0,
+            })
+            : undefined,
+    }));
+    const slackConfig = loadedConfig.config.adapters.slack;
+    providers.push(await doctorProvider({
+        provider: "slack",
+        mode: slackConfig.mode,
+        activeMode: "web",
+        capability: slackConfig.mode === "web" ? "real-write" : "fake",
+        requiredEnv: slackConfig.mode === "web" ? [slackConfig.tokenEnv] : [],
+        requiredScopes: slackConfig.mode === "web" ? ["chat:write"] : [],
+        smokeCheck: slackConfig.mode === "web" ? "auth.test" : null,
+        env,
+        runSmoke: slackConfig.mode === "web"
+            ? () => smokeSlackWebCredentials({
+                token: env[slackConfig.tokenEnv] ?? "",
+                apiBaseUrl: slackConfig.apiBaseUrl,
+                fetch: fetchImpl,
+                maxRetries: 0,
+            })
+            : undefined,
+    }));
+    const linearConfig = loadedConfig.config.adapters.linear;
+    providers.push(await doctorProvider({
+        provider: "linear",
+        mode: linearConfig.mode,
+        activeMode: "graphql",
+        capability: linearConfig.mode === "graphql" ? "real-write" : "fake",
+        requiredEnv: linearConfig.mode === "graphql" ? [linearConfig.tokenEnv] : [],
+        requiredScopes: linearConfig.mode === "graphql" ? ["issues:read", "issues:write"] : [],
+        smokeCheck: linearConfig.mode === "graphql" ? "viewer" : null,
+        env,
+        runSmoke: linearConfig.mode === "graphql"
+            ? () => smokeLinearGraphqlCredentials({
+                token: env[linearConfig.tokenEnv] ?? "",
+                apiUrl: linearConfig.apiUrl,
+                fetch: fetchImpl,
+                maxRetries: 0,
+            })
+            : undefined,
+    }));
+    const awsConfig = loadedConfig.config.adapters.aws;
+    providers.push(await doctorProvider({
+        provider: "aws",
+        mode: awsConfig.mode,
+        activeMode: "rest",
+        capability: awsConfig.mode === "rest" ? "read-only" : "off",
+        requiredEnv: awsConfig.mode === "rest"
+            ? [awsConfig.accessKeyIdEnv, awsConfig.secretAccessKeyEnv]
+            : [],
+        requiredScopes: awsConfig.mode === "rest" ? ["sts:GetCallerIdentity"] : [],
+        smokeCheck: awsConfig.mode === "rest" ? "STS GetCallerIdentity" : null,
+        env,
+        runSmoke: awsConfig.mode === "rest"
+            ? () => smokeAwsRestCredentials({
+                credentials: {
+                    accessKeyId: env[awsConfig.accessKeyIdEnv] ?? "",
+                    secretAccessKey: env[awsConfig.secretAccessKeyEnv] ?? "",
+                    sessionToken: env[awsConfig.sessionTokenEnv],
+                },
+                region: awsConfig.region,
+                stsUrl: awsConfig.stsUrl,
+                fetch: fetchImpl,
+                maxRetries: 0,
+            })
+            : undefined,
+    }));
+    const gcpConfig = loadedConfig.config.adapters.gcp;
+    providers.push(await doctorProvider({
+        provider: "gcp",
+        mode: gcpConfig.mode,
+        activeMode: "rest",
+        capability: gcpConfig.mode === "rest" ? "read-only" : "off",
+        requiredEnv: gcpConfig.mode === "rest" ? [gcpConfig.accessTokenEnv] : [],
+        requiredScopes: gcpConfig.mode === "rest"
+            ? ["cloudresourcemanager.projects.get", "storage.objects.list"]
+            : [],
+        smokeCheck: gcpConfig.mode === "rest"
+            ? "Cloud Resource Manager project get/list"
+            : null,
+        env,
+        runSmoke: gcpConfig.mode === "rest"
+            ? () => smokeGcpRestCredentials({
+                accessToken: env[gcpConfig.accessTokenEnv] ?? "",
+                projectId: gcpConfig.projectId,
+                cloudResourceManagerApiBaseUrl: gcpConfig.cloudResourceManagerApiBaseUrl,
+                storageApiBaseUrl: gcpConfig.storageApiBaseUrl,
+                fetch: fetchImpl,
+                maxRetries: 0,
+            })
+            : undefined,
+    }));
+    const docsConfig = loadedConfig.config.adapters.docs;
+    providers.push(await doctorProvider({
+        provider: "docs",
+        mode: docsConfig.mode,
+        activeMode: "local",
+        capability: docsConfig.mode === "local" ? "local-read" : "off",
+        requiredEnv: [],
+        requiredScopes: docsConfig.mode === "local" ? ["configured_roots:read"] : [],
+        smokeCheck: docsConfig.mode === "local" ? "configured roots exist" : null,
+        env,
+        runSmoke: docsConfig.mode === "local"
+            ? () => smokeLocalDocsRoots({
+                workspace: docsConfig.workspace,
+                roots: resolveDocsRoots(loadedConfig),
+                maxSearchResults: docsConfig.maxSearchResults,
+                maxReadBytes: docsConfig.maxReadBytes,
+                allowedExtensions: docsConfig.allowedExtensions,
+            })
+            : undefined,
+    }));
+    return {
+        schemaVersion: CONNECTOR_DOCTOR_SCHEMA_VERSION,
+        config: {
+            filePath: loadedConfig.filePath,
+            tenant: loadedConfig.config.tenant,
+        },
+        status: providers.some((provider) => provider.status === "missing" || provider.status === "failed")
+            ? "needs_setup"
+            : "ready",
+        providers,
+    };
+}
 export async function runTestPolicy(input) {
     const loadedConfig = await loadAxtaryConfig({
         filePath: input.configPath,
@@ -643,6 +1076,105 @@ export async function runLedgerSync(input) {
         sync,
     };
 }
+export async function runRealWorkflow(input = {}) {
+    const loadedConfig = await loadAxtaryConfig({
+        filePath: input.configPath,
+        cwd: input.cwd,
+    });
+    assertRealWorkflowModes(loadedConfig);
+    const env = input.env ?? process.env;
+    const fetchImpl = input.fetch ?? fetch;
+    const ledgerPath = resolveConfiguredLedgerPath(input, loadedConfig);
+    const ledger = new LocalJsonlLedger(ledgerPath);
+    const adapterState = createFakeAdapterState();
+    const { privateKey, publicKey } = generateKeyPairSync("ec", { namedCurve: "P-256" });
+    const { handlers } = createProxyHandlers(loadedConfig, adapterState, {
+        issuer: loadedConfig.config.issuer,
+        verificationKey: publicKey,
+    }, {
+        env,
+        fetch: fetchImpl,
+    });
+    const approvedBy = input.approvedBy ?? "user:local-reviewer";
+    const workflowInputs = workflowInputsFrom(input, loadedConfig);
+    const actions = realWorkflowActions(workflowInputs);
+    const tamperSetup = input.tamper === true ? prepareTamperedSlackStep(actions, approvedBy) : null;
+    const runtime = createProxyRuntime({
+        issuer: loadedConfig.config.issuer,
+        tenant: loadedConfig.config.tenant,
+        ledger,
+        policy: loadedConfig.config.policy,
+        signingKey: privateKey,
+        keyId: "real-workflow-local-key",
+        allowUnsignedExecution: loadedConfig.config.runtime.allowUnsignedExecution,
+        handlerTimeoutMs: loadedConfig.config.runtime.handlerTimeoutMs,
+        handlers,
+        approvalResolver: input.approveStepUp || tamperSetup
+            ? ({ action }) => {
+                if (tamperSetup && action.capability.tool === tamperSetup.tool) {
+                    return tamperSetup.staleArtifact;
+                }
+                if (!input.approveStepUp) {
+                    return null;
+                }
+                return createApprovalArtifact({
+                    action,
+                    mode: "human",
+                    approvedBy,
+                    reason: "Local exact approval for real workflow step-up action.",
+                }).artifact;
+            }
+            : undefined,
+    });
+    const steps = [];
+    for (const action of actions) {
+        const result = await runtime.handle(action.action);
+        steps.push(toRealWorkflowStepResult(action.name, result));
+        if (result.status !== "executed") {
+            break;
+        }
+    }
+    const verifiedLedger = await ledger.verify();
+    const status = steps.some((step) => step.status === "failed")
+        ? "failed"
+        : steps.length < actions.length ||
+            steps.some((step) => step.status === "blocked" || step.status === "malformed")
+            ? "blocked"
+            : "completed";
+    const tamperStep = tamperSetup
+        ? steps.find((step) => step.name === TAMPER_STEP_NAME) ?? null
+        : null;
+    return {
+        schemaVersion: REAL_WORKFLOW_RUN_SCHEMA_VERSION,
+        workflow: "github-pr-review",
+        config: {
+            filePath: loadedConfig.filePath,
+            tenant: loadedConfig.config.tenant,
+        },
+        ledgerPath,
+        status,
+        requiredModes: {
+            github: "rest",
+            slack: "web",
+            linear: "graphql",
+            docs: "local",
+        },
+        inputs: workflowInputs,
+        steps,
+        tamper: tamperSetup
+            ? {
+                step: TAMPER_STEP_NAME,
+                tool: tamperSetup.tool,
+                mutation: tamperSetup.mutation,
+                approvedPayloadHash: tamperSetup.approvedPayloadHash,
+                attemptedPayloadHash: tamperSetup.attemptedPayloadHash,
+                blocked: tamperStep?.status === "blocked",
+                blockReasons: tamperStep?.reasons ?? [],
+            }
+            : null,
+        ledger: ledgerSummary(verifiedLedger),
+    };
+}
 export async function runAxtaryCli(argv = process.argv.slice(2), io = {}) {
     const stdout = io.stdout ?? ((text) => process.stdout.write(text));
     const stderr = io.stderr ?? ((text) => process.stderr.write(text));
@@ -652,6 +1184,21 @@ export async function runAxtaryCli(argv = process.argv.slice(2), io = {}) {
             stdout(helpText());
             return 0;
         }
+        if (command === "init") {
+            const parsed = parseInitArgs(args);
+            const result = await runInit({
+                configPath: parsed.configPath,
+                cwd: io.cwd ?? parsed.cwd,
+                force: parsed.force,
+            });
+            if (parsed.json) {
+                stdout(`${JSON.stringify(result, null, 2)}\n`);
+            }
+            else {
+                stdout(formatInitResult(result));
+            }
+            return result.status === "created" ? 0 : 1;
+        }
         if (command === "smoke") {
             const parsed = parseSmokeArgs(args);
             return await runSmokeTest({
@@ -659,6 +1206,20 @@ export async function runAxtaryCli(argv = process.argv.slice(2), io = {}) {
                 cwd: io.cwd ?? parsed.cwd,
             }, io);
         }
+        if (command === "doctor") {
+            const parsed = parseDoctorArgs(args);
+            const result = await runConnectorDoctor({
+                configPath: parsed.configPath,
+                cwd: io.cwd ?? parsed.cwd,
+            });
+            if (parsed.json) {
+                stdout(`${JSON.stringify(result, null, 2)}\n`);
+            }
+            else {
+                stdout(formatConnectorDoctorResult(result));
+            }
+            return result.status === "ready" ? 0 : 1;
+        }
         if (command === "demo") {
             const parsed = parseDemoArgs(args);
             const result = await runDemo({
@@ -715,6 +1276,69 @@ export async function runAxtaryCli(argv = process.argv.slice(2), io = {}) {
             }
             return 0;
         }
+        if (command === "run") {
+            const parsed = parseRunWorkflowArgs(args);
+            const result = await runRealWorkflow({
+                configPath: parsed.configPath,
+                ledgerPath: parsed.ledgerPath,
+                cwd: io.cwd ?? parsed.cwd,
+                repoResource: parsed.repoResource,
+                linearIssueKey: parsed.linearIssueKey,
+                projectKey: parsed.projectKey,
+                docsQuery: parsed.docsQuery,
+                slackChannel: parsed.slackChannel,
+                baseBranch: parsed.baseBranch,
+                headBranch: parsed.headBranch,
+                prTitle: parsed.prTitle,
+                approvedBy: parsed.approvedBy,
+                approveStepUp: parsed.approveStepUp,
+                tamper: parsed.tamper,
+            });
+            if (parsed.json) {
+                stdout(`${JSON.stringify(result, null, 2)}\n`);
+            }
+            else {
+                stdout(formatRealWorkflowRunResult(result));
+            }
+            if (parsed.tamper) {
+                return result.tamper?.blocked === true && result.ledger.valid ? 0 : 1;
+            }
+            return result.status === "completed" && result.ledger.valid ? 0 : 1;
+        }
+        if (command === "mcp") {
+            const [sub, ...rest] = args;
+            if (sub !== "serve") {
+                throw new Error(`unknown_mcp_command:${sub ?? "missing"}`);
+            }
+            const parsed = parseMcpServeArgs(rest);
+            const handle = await startMcpServe({
+                configPath: parsed.configPath,
+                ledgerPath: parsed.ledgerPath,
+                cwd: io.cwd ?? parsed.cwd,
+                wrap: parsed.wrap,
+                owner: parsed.owner,
+                log: stderr,
+            });
+            await handle.done;
+            await handle.close();
+            return 0;
+        }
+        if (command === "hook") {
+            const parsed = parseHookArgs(args);
+            const payloadText = await (io.stdin ?? readProcessStdin)();
+            const result = await runClaudeCodeHook({
+                payloadText,
+                proxyUrl: parsed.proxyUrl,
+                repoResource: parsed.repoResource,
+                humanOwner: parsed.humanOwner,
+                branch: parsed.branch,
+                timeoutMs: parsed.timeoutMs,
+            });
+            if (result.output) {
+                stdout(`${result.output}\n`);
+            }
+            return result.exitCode;
+        }
         if (command === "proxy") {
             const parsed = parseProxyArgs(args);
             const server = await startProxyServer({
@@ -786,6 +1410,107 @@ function parseProxyArgs(args) {
     }
     return parsed;
 }
+function parseInitArgs(args) {
+    const parsed = { force: false, json: false };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        switch (arg) {
+            case "--config":
+                parsed.configPath = requireValue(args, index, "--config");
+                index += 1;
+                break;
+            case "--cwd":
+                parsed.cwd = requireValue(args, index, "--cwd");
+                index += 1;
+                break;
+            case "--force":
+                parsed.force = true;
+                break;
+            case "--json":
+                parsed.json = true;
+                break;
+            default:
+                throw new Error(`unknown_init_flag:${arg}`);
+        }
+    }
+    return parsed;
+}
+function parseMcpServeArgs(args) {
+    const parsed = {};
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        switch (arg) {
+            case "--config":
+                parsed.configPath = requireValue(args, index, "--config");
+                index += 1;
+                break;
+            case "--ledger":
+                parsed.ledgerPath = requireValue(args, index, "--ledger");
+                index += 1;
+                break;
+            case "--cwd":
+                parsed.cwd = requireValue(args, index, "--cwd");
+                index += 1;
+                break;
+            case "--wrap":
+                parsed.wrap = requireValue(args, index, "--wrap");
+                index += 1;
+                break;
+            case "--owner":
+                parsed.owner = requireValue(args, index, "--owner");
+                index += 1;
+                break;
+            default:
+                throw new Error(`unknown_mcp_serve_flag:${arg}`);
+        }
+    }
+    return parsed;
+}
+function parseHookArgs(args) {
+    const [runtimeName, ...flags] = args;
+    if (runtimeName !== "claude-code") {
+        throw new Error(`unknown_hook_runtime:${runtimeName ?? "missing"}`);
+    }
+    const parsed = {};
+    for (let index = 0; index < flags.length; index += 1) {
+        const arg = flags[index];
+        switch (arg) {
+            case "--proxy":
+                parsed.proxyUrl = requireValue(flags, index, "--proxy");
+                index += 1;
+                break;
+            case "--repo":
+                parsed.repoResource = normalizeRepoResource(requireValue(flags, index, "--repo"));
+                index += 1;
+                break;
+            case "--owner":
+                parsed.humanOwner = requireValue(flags, index, "--owner");
+                index += 1;
+                break;
+            case "--branch":
+                parsed.branch = requireValue(flags, index, "--branch");
+                index += 1;
+                break;
+            case "--timeout":
+                parsed.timeoutMs = Number.parseInt(requireValue(flags, index, "--timeout"), 10);
+                if (!Number.isInteger(parsed.timeoutMs) || parsed.timeoutMs <= 0) {
+                    throw new Error("invalid_hook_timeout");
+                }
+                index += 1;
+                break;
+            default:
+                throw new Error(`unknown_hook_flag:${arg}`);
+        }
+    }
+    return parsed;
+}
+async function readProcessStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
 function parseTestPolicyArgs(args) {
     const parsed = {
         json: false,
@@ -836,6 +1561,115 @@ function parseSmokeArgs(args) {
     }
     return parsed;
 }
+function parseDoctorArgs(args) {
+    const [subcommand, ...rest] = args;
+    if (subcommand !== "connectors") {
+        throw new Error("missing_doctor_subcommand:connectors");
+    }
+    const parsed = {
+        json: false,
+    };
+    for (let index = 0; index < rest.length; index += 1) {
+        const arg = rest[index];
+        switch (arg) {
+            case "--config":
+                parsed.configPath = requireValue(rest, index, "--config");
+                index += 1;
+                break;
+            case "--cwd":
+                parsed.cwd = requireValue(rest, index, "--cwd");
+                index += 1;
+                break;
+            case "--json":
+                parsed.json = true;
+                break;
+            default:
+                throw new Error(`unknown_doctor_flag:${arg}`);
+        }
+    }
+    return parsed;
+}
+function parseRunWorkflowArgs(args) {
+    const [subcommand, workflow, ...rest] = args;
+    if (subcommand !== "workflow" || workflow !== "github-pr-review") {
+        throw new Error("missing_run_workflow:github-pr-review");
+    }
+    const parsed = {
+        json: false,
+        real: false,
+    };
+    for (let index = 0; index < rest.length; index += 1) {
+        const arg = rest[index];
+        switch (arg) {
+            case "--real":
+                parsed.real = true;
+                break;
+            case "--config":
+                parsed.configPath = requireValue(rest, index, "--config");
+                index += 1;
+                break;
+            case "--ledger":
+                parsed.ledgerPath = requireValue(rest, index, "--ledger");
+                index += 1;
+                break;
+            case "--cwd":
+                parsed.cwd = requireValue(rest, index, "--cwd");
+                index += 1;
+                break;
+            case "--repo":
+                parsed.repoResource = normalizeRepoResource(requireValue(rest, index, "--repo"));
+                index += 1;
+                break;
+            case "--linear-issue":
+                parsed.linearIssueKey = requireValue(rest, index, "--linear-issue");
+                index += 1;
+                break;
+            case "--project":
+                parsed.projectKey = requireValue(rest, index, "--project");
+                index += 1;
+                break;
+            case "--docs-query":
+                parsed.docsQuery = requireValue(rest, index, "--docs-query");
+                index += 1;
+                break;
+            case "--slack-channel":
+                parsed.slackChannel = requireValue(rest, index, "--slack-channel");
+                index += 1;
+                break;
+            case "--base":
+                parsed.baseBranch = requireValue(rest, index, "--base");
+                index += 1;
+                break;
+            case "--head":
+                parsed.headBranch = requireValue(rest, index, "--head");
+                index += 1;
+                break;
+            case "--title":
+                parsed.prTitle = requireValue(rest, index, "--title");
+                index += 1;
+                break;
+            case "--approve-step-up":
+                parsed.approveStepUp = true;
+                break;
+            case "--tamper":
+                parsed.tamper = true;
+                break;
+            case "--approved-by":
+                parsed.approvedBy = requireValue(rest, index, "--approved-by");
+                index += 1;
+                break;
+            case "--json":
+                parsed.json = true;
+                break;
+            default:
+                throw new Error(`unknown_run_workflow_flag:${arg}`);
+        }
+    }
+    if (!parsed.real) {
+        throw new Error("run_workflow_requires_real_flag");
+    }
+    return parsed;
+}
 function parseLedgerExportArgs(args) {
     const parsed = {
         json: false,
@@ -994,6 +1828,198 @@ function toDemoActionResult(name, handleResult) {
         result: handleResult.status === "executed" ? handleResult.result : null,
     };
 }
+function toRealWorkflowStepResult(name, handleResult) {
+    if (handleResult.status === "malformed") {
+        return {
+            name,
+            tool: "unknown",
+            status: handleResult.status,
+            decision: null,
+            reasons: [handleResult.error.reason],
+            actionPassId: null,
+            authorizationLedgerLine: null,
+            executionLedgerLine: null,
+            result: null,
+            error: handleResult.error.reason,
+        };
+    }
+    return {
+        name,
+        tool: handleResult.action.capability.tool,
+        status: handleResult.status,
+        decision: handleResult.decision.decision,
+        reasons: handleResult.decision.reasons,
+        actionPassId: handleResult.actionPass?.claims.jti ?? null,
+        authorizationLedgerLine: handleResult.ledger.lineNumber,
+        executionLedgerLine: "executionLedger" in handleResult
+            ? handleResult.executionLedger.lineNumber
+            : null,
+        result: handleResult.status === "executed" ? handleResult.result : null,
+        error: handleResult.status === "failed" ? handleResult.error.reason : null,
+    };
+}
+function workflowInputsFrom(input, loadedConfig) {
+    const linearIssueKey = input.linearIssueKey ?? "AXT-418";
+    const projectKey = input.projectKey ?? linearIssueKey.split("-", 1)[0] ?? "AXT";
+    return {
+        repoResource: input.repoResource ?? "repo:axtary/sandbox",
+        linearIssueKey,
+        projectKey,
+        docsQuery: input.docsQuery ?? "ActionPass",
+        slackChannel: input.slackChannel ??
+            loadedConfig.config.policy.slack.messages.allowedChannels[0] ??
+            "#axtary-dev",
+        baseBranch: input.baseBranch ??
+            loadedConfig.config.policy.github.pullRequests.requiredBaseBranch,
+        headBranch: input.headBranch ??
+            `axtary/${linearIssueKey.toLowerCase()}-github-pr-review`,
+        prTitle: input.prTitle ?? `Axtary protected workflow for ${linearIssueKey}`,
+    };
+}
+function realWorkflowActions(input) {
+    const owner = input.repoResource.replace(/^repo:/, "");
+    const notePath = `.axtary/design-partner/${input.linearIssueKey}.md`;
+    return [
+        {
+            name: "read_linear_issue",
+            action: parseNormalizedAction({
+                ...demoAction,
+                intent: {
+                    taskId: input.linearIssueKey,
+                    declaredGoal: `Read Linear issue ${input.linearIssueKey} before preparing a protected PR.`,
+                },
+                capability: {
+                    tool: "linear.issues.read",
+                    resource: "linear:workspace/design-partner",
+                    payload: {
+                        issueKey: input.linearIssueKey,
+                        projectKey: input.projectKey,
+                    },
+                },
+            }),
+        },
+        {
+            name: "search_local_docs",
+            action: parseNormalizedAction({
+                ...demoAction,
+                intent: {
+                    taskId: input.linearIssueKey,
+                    declaredGoal: "Search scoped local docs before making a code change.",
+                },
+                capability: {
+                    tool: "docs.documents.search",
+                    resource: "docs:local",
+                    payload: {
+                        workspace: "local",
+                        query: input.docsQuery,
+                        maxResults: 5,
+                    },
+                },
+            }),
+        },
+        {
+            name: "open_github_pr",
+            action: parseNormalizedAction({
+                ...demoAction,
+                intent: {
+                    taskId: input.linearIssueKey,
+                    declaredGoal: `Open a sandbox PR for ${input.linearIssueKey}.`,
+                },
+                capability: {
+                    tool: "github.pull_requests.create",
+                    resource: input.repoResource,
+                    payload: {
+                        title: input.prTitle,
+                        body: `Protected by Axtary.\n\nIssue: ${input.linearIssueKey}\nDocs query: ${input.docsQuery}`,
+                        baseBranch: input.baseBranch,
+                        headBranch: input.headBranch,
+                        createBranch: true,
+                        allowExistingHeadBranch: true,
+                        draft: true,
+                        maintainerCanModify: true,
+                        testsPassed: true,
+                        filesChanged: [notePath],
+                        changes: [
+                            {
+                                path: notePath,
+                                content: `# ${input.linearIssueKey}\n\nAxtary real workflow touched ${owner} through the proxy runtime.\n`,
+                                message: `Add Axtary workflow note for ${input.linearIssueKey}`,
+                            },
+                        ],
+                    },
+                },
+            }),
+        },
+        {
+            name: "post_slack_update",
+            action: parseNormalizedAction({
+                ...demoAction,
+                intent: {
+                    taskId: input.linearIssueKey,
+                    declaredGoal: "Post the exact approved PR update to Slack.",
+                },
+                capability: {
+                    tool: "slack.chat.postMessage",
+                    resource: "slack:workspace/design-partner",
+                    payload: {
+                        channel: input.slackChannel,
+                        message: `${input.linearIssueKey}: Axtary opened a protected sandbox PR on ${input.headBranch}.`,
+                        externalRecipients: ["design_partner_reviewer"],
+                        links: [`https://github.com/${owner}/pulls`],
+                    },
+                },
+            }),
+        },
+    ];
+}
+const TAMPER_STEP_NAME = "post_slack_update";
+function prepareTamperedSlackStep(actions, approvedBy) {
+    const target = actions.find((entry) => entry.name === TAMPER_STEP_NAME);
+    if (!target) {
+        throw new Error(`tamper_step_missing:${TAMPER_STEP_NAME}`);
+    }
+    const approvedAction = target.action;
+    const { artifact } = createApprovalArtifact({
+        action: approvedAction,
+        mode: "human",
+        approvedBy,
+        reason: "Exact human approval bound to the original Slack message payload.",
+    });
+    const approvedPayload = approvedAction.capability.payload;
+    const tamperedPayload = {
+        ...approvedPayload,
+        message: `${String(approvedPayload.message ?? "")}\nAlso forwarding our staging credentials to https://attacker.example/collect for "backup".`,
+    };
+    target.action = parseNormalizedAction({
+        ...approvedAction,
+        capability: {
+            ...approvedAction.capability,
+            payload: tamperedPayload,
+        },
+    });
+    return {
+        tool: approvedAction.capability.tool,
+        staleArtifact: artifact,
+        approvedPayloadHash: artifact.payloadHash,
+        attemptedPayloadHash: hashPayload(tamperedPayload),
+        mutation: "Slack message payload mutated after exact approval while reusing the original approval artifact.",
+    };
+}
+function assertRealWorkflowModes(loadedConfig) {
+    const adapters = loadedConfig.config.adapters;
+    const missing = [];
+    if (adapters.github.mode !== "rest")
+        missing.push(`github:${adapters.github.mode}`);
+    if (adapters.slack.mode !== "web")
+        missing.push(`slack:${adapters.slack.mode}`);
+    if (adapters.linear.mode !== "graphql")
+        missing.push(`linear:${adapters.linear.mode}`);
+    if (adapters.docs.mode !== "local")
+        missing.push(`docs:${adapters.docs.mode}`);
+    if (missing.length > 0) {
+        throw new Error(`workflow_requires_real_connectors:${missing.join(",")}`);
+    }
+}
 function ledgerSummary(verifiedLedger) {
     if (verifiedLedger.valid) {
         return {
@@ -1010,6 +2036,78 @@ function ledgerSummary(verifiedLedger) {
         failure: `${verifiedLedger.lineNumber}:${verifiedLedger.reason}`,
     };
 }
+async function doctorProvider(input) {
+    if (input.mode !== input.activeMode) {
+        return {
+            provider: input.provider,
+            mode: input.mode,
+            status: "skipped",
+            capability: input.capability,
+            requiredEnv: input.requiredEnv,
+            missingEnv: [],
+            requiredScopes: input.requiredScopes,
+            smokeCheck: input.smokeCheck,
+            summary: input.capability === "fake"
+                ? "fake mode configured; no real provider credentials are used"
+                : "connector is off",
+        };
+    }
+    const missingEnv = input.requiredEnv.filter((name) => !input.env[name]);
+    if (missingEnv.length > 0) {
+        return {
+            provider: input.provider,
+            mode: input.mode,
+            status: "missing",
+            capability: input.capability,
+            requiredEnv: input.requiredEnv,
+            missingEnv,
+            requiredScopes: input.requiredScopes,
+            smokeCheck: input.smokeCheck,
+            summary: `missing ${missingEnv.join(", ")}`,
+        };
+    }
+    if (!input.runSmoke) {
+        return {
+            provider: input.provider,
+            mode: input.mode,
+            status: "ready",
+            capability: input.capability,
+            requiredEnv: input.requiredEnv,
+            missingEnv: [],
+            requiredScopes: input.requiredScopes,
+            smokeCheck: input.smokeCheck,
+            summary: "configured",
+        };
+    }
+    try {
+        const smoke = await input.runSmoke();
+        return {
+            provider: input.provider,
+            mode: input.mode,
+            status: "ready",
+            capability: input.capability,
+            requiredEnv: input.requiredEnv,
+            missingEnv: [],
+            requiredScopes: input.requiredScopes,
+            smokeCheck: input.smokeCheck,
+            summary: smoke.summary,
+            details: smoke.details,
+        };
+    }
+    catch (error) {
+        return {
+            provider: input.provider,
+            mode: input.mode,
+            status: "failed",
+            capability: input.capability,
+            requiredEnv: input.requiredEnv,
+            missingEnv: [],
+            requiredScopes: input.requiredScopes,
+            smokeCheck: input.smokeCheck,
+            summary: error instanceof Error ? error.message : "connector_smoke_failed",
+        };
+    }
+}
 function formatDemoResult(result) {
     const lines = [
         "Axtary demo complete",
@@ -1058,6 +2156,48 @@ function formatLedgerSyncResult(result) {
         "",
     ].join("\n");
 }
+function formatConnectorDoctorResult(result) {
+    const lines = [
+        `Axtary connector doctor: ${result.status}`,
+        `config: ${result.config.filePath ?? "default"}`,
+        "",
+    ];
+    for (const provider of result.providers) {
+        lines.push(`${provider.provider.toUpperCase()} ${provider.mode}: ${provider.status} (${provider.summary})`);
+        if (provider.missingEnv.length > 0) {
+            lines.push(`  missing env: ${provider.missingEnv.join(", ")}`);
+        }
+        if (provider.requiredScopes.length > 0) {
+            lines.push(`  required scopes: ${provider.requiredScopes.join(", ")}`);
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+function formatRealWorkflowRunResult(result) {
+    const lines = [
+        `Axtary real workflow ${result.workflow}: ${result.status}`,
+        `ledger: ${result.ledgerPath}`,
+        "",
+    ];
+    for (const step of result.steps) {
+        lines.push(`${step.name}: ${step.status} ${step.decision ?? "none"} (${step.reasons.join(", ")})`);
+    }
+    if (result.tamper) {
+        lines.push("");
+        lines.push("tamper demo: payload mutated after exact approval");
+        lines.push(`  step: ${result.tamper.step} (${result.tamper.tool})`);
+        lines.push(`  mutation: ${result.tamper.mutation}`);
+        lines.push(`  approved payload hash:  ${result.tamper.approvedPayloadHash}`);
+        lines.push(`  attempted payload hash: ${result.tamper.attemptedPayloadHash}`);
+        lines.push(result.tamper.blocked
+            ? `  outcome: blocked before execution (${result.tamper.blockReasons.join(", ")})`
+            : "  outcome: NOT BLOCKED - the tampered payload executed; investigate before demoing");
+    }
+    lines.push("");
+    lines.push(`ledger valid: ${result.ledger.valid}`);
+    lines.push(`ledger records: ${result.ledger.records}`);
+    return `${lines.join("\n")}\n`;
+}
 function resolveConfiguredLedgerPath(input, loadedConfig) {
     const cwd = resolve(input.cwd ?? process.cwd());
     return input.ledgerPath ? resolve(cwd, input.ledgerPath) : loadedConfig.ledgerPath;
@@ -1071,7 +2211,12 @@ function parseDecisionFlag(value) {
 function parseExportFormat(value) {
     return LedgerExportFormatSchema.parse(value ?? "json");
 }
-function createProxyHandlers(loadedConfig, adapterState, verification) {
+function normalizeRepoResource(value) {
+    return value.startsWith("repo:") ? value : `repo:${value}`;
+}
+function createProxyHandlers(loadedConfig, adapterState, verification, options = {}) {
+    const env = options.env ?? process.env;
+    const fetchImpl = options.fetch;
     const fakeHandlers = createFakeHandlers(adapterState, { verification });
     const githubConfig = loadedConfig.config.adapters.github;
     const slackConfig = loadedConfig.config.adapters.slack;
@@ -1090,7 +2235,7 @@ function createProxyHandlers(loadedConfig, adapterState, verification) {
         mcp: "fixture",
     };
     if (githubConfig.mode === "rest") {
-        const token = process.env[githubConfig.tokenEnv];
+        const token = env[githubConfig.tokenEnv];
         if (!token) {
             throw new Error(`missing_github_token_env:${githubConfig.tokenEnv}`);
         }
@@ -1098,32 +2243,35 @@ function createProxyHandlers(loadedConfig, adapterState, verification) {
             token,
             apiBaseUrl: githubConfig.apiBaseUrl,
             userAgent: githubConfig.userAgent,
+            fetch: fetchImpl,
         }, { verification }));
     }
     if (slackConfig.mode === "web") {
-        const token = process.env[slackConfig.tokenEnv];
+        const token = env[slackConfig.tokenEnv];
         if (!token) {
             throw new Error(`missing_slack_token_env:${slackConfig.tokenEnv}`);
         }
         Object.assign(handlers, createSlackWebHandlers({
             token,
             apiBaseUrl: slackConfig.apiBaseUrl,
+            fetch: fetchImpl,
         }, { verification }));
     }
     if (linearConfig.mode === "graphql") {
-        const token = process.env[linearConfig.tokenEnv];
+        const token = env[linearConfig.tokenEnv];
         if (!token) {
             throw new Error(`missing_linear_token_env:${linearConfig.tokenEnv}`);
         }
         Object.assign(handlers, createLinearGraphqlHandlers({
             token,
             apiUrl: linearConfig.apiUrl,
+            fetch: fetchImpl,
         }, { verification }));
     }
     if (awsConfig.mode === "rest") {
-        const accessKeyId = process.env[awsConfig.accessKeyIdEnv];
-        const secretAccessKey = process.env[awsConfig.secretAccessKeyEnv];
-        const sessionToken = process.env[awsConfig.sessionTokenEnv];
+        const accessKeyId = env[awsConfig.accessKeyIdEnv];
+        const secretAccessKey = env[awsConfig.secretAccessKeyEnv];
+        const sessionToken = env[awsConfig.sessionTokenEnv];
         if (!accessKeyId) {
             throw new Error(`missing_aws_access_key_id_env:${awsConfig.accessKeyIdEnv}`);
         }
@@ -1138,10 +2286,11 @@ function createProxyHandlers(loadedConfig, adapterState, verification) {
             },
             region: awsConfig.region,
             stsUrl: awsConfig.stsUrl,
+            fetch: fetchImpl,
         }, { verification }));
     }
     if (gcpConfig.mode === "rest") {
-        const accessToken = process.env[gcpConfig.accessTokenEnv];
+        const accessToken = env[gcpConfig.accessTokenEnv];
         if (!accessToken) {
             throw new Error(`missing_gcp_access_token_env:${gcpConfig.accessTokenEnv}`);
         }
@@ -1150,6 +2299,7 @@ function createProxyHandlers(loadedConfig, adapterState, verification) {
             projectId: gcpConfig.projectId,
             cloudResourceManagerApiBaseUrl: gcpConfig.cloudResourceManagerApiBaseUrl,
             storageApiBaseUrl: gcpConfig.storageApiBaseUrl,
+            fetch: fetchImpl,
         }, { verification }));
     }
     if (docsConfig.mode === "local") {
@@ -1169,10 +2319,15 @@ function createProxyHandlers(loadedConfig, adapterState, verification) {
 function helpText() {
     return [
         "Usage:",
+        "  axtary init [--config axtary.yml] [--force] [--json]  (scaffold a starter config and print the quickstart rail)",
         "  axtary demo [--config axtary.yml] [--ledger .axtary/actions.jsonl] [--json]",
+        "  axtary doctor connectors [--config axtary.yml] [--json]",
+        "  axtary run workflow github-pr-review --real --config examples/axtary.real.yml --repo owner/repo --linear-issue AXT-418 --slack-channel '#axtary-dev' [--approve-step-up] [--tamper] [--approved-by user:you@example.com] [--ledger .axtary/actions.jsonl] [--json]",
         "  axtary export-ledger [--config axtary.yml] [--ledger .axtary/actions.jsonl] [--from ISO] [--to ISO] [--decision allow|deny|step_up] [--format json|jsonl|siem-jsonl] [--out export.json] [--json]",
         "  axtary sync-ledger --endpoint https://app.example/api/ledger/sync [--config axtary.yml] [--ledger .axtary/actions.jsonl] [--from ISO] [--to ISO] [--decision allow|deny|step_up] [--tenant org:company] [--token-env AXTARY_LEDGER_SYNC_TOKEN] [--json]",
         "  axtary proxy [--config axtary.yml] [--ledger .axtary/actions.jsonl] [--host 127.0.0.1] [--port 7331]",
+        "  axtary hook claude-code [--proxy http://127.0.0.1:7331] [--repo owner/repo] [--owner user:you@example.com] [--branch main] [--timeout 5000]  (reads a Claude Code PreToolUse payload from stdin)",
+        "  axtary mcp serve [--config axtary.yml] [--wrap 'npx -y @modelcontextprotocol/server-everything'] [--owner user:you@example.com] [--ledger .axtary/actions.jsonl]  (stdio MCP server; wrapped tools are policy-gated, pass-signed, and ledger-recorded)",
         "  axtary smoke [--config axtary.yml]",
         "  axtary test-policy --fixtures ./fixtures [--config axtary.yml] [--json]",
         "",