Hello ACP

{
  "action": {
    "parameter_hash": "ced943f7d4b9016abf9870f03ea4177d658fc7304016417da10e8af45f460aa4",
    "parameters": {
      "text": "Chio governs the tools behind an ACP agent"
    }
  },
  "boundary_class": "prevent",
  "capability_id": "cap-01a08ea1-de21-7130-8ff4-40ba8880b7ec",
  "content_hash": "d43c61337f20d4757305b71d53be031a5205ecb11515715884df023b220b8f39",
  "decision": {
    "verdict": "allow"
  },
  "id": "54e15eb3a95f56967e68ccd7b465f70aee36d79969992d9eade52d3c74a4d96e",
  "kernel_key": "b47ea36c693b9e785582f2dcdad76d52b4a58028cb76baa151316bfb46c65e82",
  "metadata": {
    "admission_operation": {
      "compensation_status": "not_compensated",
      "coordinator_lease_epoch": 1,
      "coordinator_lease_id": "01a08ea1-dd8c-76c3-80a3-3cf8f8b878d5",
      "operation_id": "23cb88dc1d45068a2a3c5c06f4914f321114b0b33e8a4c1f8292af453f130cda",
      "projected_dispatch_state": "terminal",
      "projected_operation_version": 8,
      "projected_state": "completed",
      "request_binding_hash": "78a183c7de4b1f3643f2e575f1460bc02806c7d57528aad912c9103d9913171e",
      "request_id": "acp-prompt:acp-84de6ba3f7b1c894f950257d21dfa3e833b62bab1e78761e445bf372e289aec4:1",
      "request_namespace_digest": "6e65a980e77d2fc1b9216735b61041fbd9ee47347d887543d253a8f734bf3c2a",
      "retained_dispatch_commit": {
        "committed_version": 6,
        "coordinator_lease_epoch": 1,
        "coordinator_lease_id": "01a08ea1-dd8c-76c3-80a3-3cf8f8b878d5",
        "provider_attempt": {
          "attempt_id": "attempt:23cb88dc1d45068a2a3c5c06f4914f321114b0b33e8a4c1f8292af453f130cda",
          "operation_id": "23cb88dc1d45068a2a3c5c06f4914f321114b0b33e8a4c1f8292af453f130cda",
          "transport_id": "kernel-tool-server:documents",
          "transport_key_epoch": 1
        },
        "store_fence": {
          "lease_id": "01a08ea1-dd8c-76c3-80a3-3cf8f8b878d5",
          "owner_epoch": 1,
          "store_uuid": "01a08ea1-dc2d-7467-bff9-d1a2f5c015e8"
        }
      },
      "schema": "chio.admission-receipt.v1",
      "store_fence": {
        "lease_id": "01a08ea1-dd8c-76c3-80a3-3cf8f8b878d5",
        "owner_epoch": 1,
        "store_uuid": "01a08ea1-dc2d-7467-bff9-d1a2f5c015e8"
      },
      "tool_outcome_id": "c88b090cbf798558cd05e1053441c5dcbd5d6b0c1ec88ac5146a3d25d42d01af",
      "tool_outcome_version": 2,
      "trusted_time_unix_ms": 1789099368148
    },
    "attribution": {
      "delegation_depth": 0,
      "grant_index": 0,
      "issuer_key": "b47ea36c693b9e785582f2dcdad76d52b4a58028cb76baa151316bfb46c65e82",
      "subject_key": "8bf3cb8bb468ec947e742267054c4795c84660dd3a8ac114fa95a8f887ac1589"
    },
    "chio_receipt_signing_nonce": "rcpt-01a08ea1-def8-772b-ba5d-06099fd305a8",
    "receipt_context": {
      "request_id": "acp-prompt:acp-84de6ba3f7b1c894f950257d21dfa3e833b62bab1e78761e445bf372e289aec4:1"
    },
    "route_selection": {
      "candidates": [
        {
          "available": true,
          "routeId": "native-route",
          "selectedProtocols": [
            "acp",
            "native"
          ],
          "targetProtocol": "native"
        }
      ],
      "decision": "select",
      "requestedTargetProtocol": "native",
      "routeSelectionId": "d09a1f38b92e97e66778f7b34403fd51fef069b85094048470a28d728e5c85c1",
      "selectedProtocols": [
        "acp",
        "native"
      ],
      "selectedRouteId": "native-route",
      "selectedTargetProtocol": "native",
      "sourceProtocol": "acp"
    },
    "stream": {
      "chunk_hashes": [
        "2e2bd9af8085931de5436f5a344bc74dce2c4e6b8025f64782e180f314140165",
        "b2538f4ac125b83068662cf8f4dc7966e50d1bcbfce089b5824edea204d91624"
      ],
      "chunks_expected": 2,
      "chunks_received": 2,
      "total_bytes": 77
    }
  },
  "policy_hash": "56f393294872b8f8213479eff52ad3fb3e61581cc62a08410ddbbad21c4e745a",
  "receipt_kind": "mediated_decision",
  "redaction_mode": "none",
  "signature": "dcca249bf2fe2e340d53f3ce8e6b67d1b179a578fd13ccadaef217291178ab3e4a0c1ee11a6a7fc688b078cdcede00594b75c6071a6329cf7cb13b4d366d900e",
  "timestamp": 1789099368,
  "tool_name": "count_words",
  "tool_origin": "caller_executed",
  "tool_server": "documents",
  "trust_level": "mediated"
}

{
  "action": {
    "parameter_hash": "ced943f7d4b9016abf9870f03ea4177d658fc7304016417da10e8af45f460aa4",
    "parameters": {
      "text": "Chio governs the tools behind an ACP agent"
    }
  },
  "boundary_class": "prevent",
  "capability_id": "cap-01a08ea1-de21-7130-8ff4-40ba8880b7ec",
  "content_hash": "74234e98afe7498fb5daf1f36ac2d78acc339464f950703b8c019892f982b90b",
  "decision": {
    "guard": "kernel",
    "reason": "invocation budget exhausted for capability cap-01a08ea1-de21-7130-8ff4-40ba8880b7ec",
    "verdict": "deny"
  },
  "id": "97253d897a6f0c36f9156748ecdaf8017a9b90404154cc1bb8a45a8f46f34bee",
  "kernel_key": "b47ea36c693b9e785582f2dcdad76d52b4a58028cb76baa151316bfb46c65e82",
  "metadata": {
    "attribution": {
      "delegation_depth": 0,
      "issuer_key": "b47ea36c693b9e785582f2dcdad76d52b4a58028cb76baa151316bfb46c65e82",
      "subject_key": "8bf3cb8bb468ec947e742267054c4795c84660dd3a8ac114fa95a8f887ac1589"
    },
    "budget_authority": {
      "authority_profile": "authoritative_hold_event",
      "guarantee_level": "single_node_atomic",
      "metering_profile": "max_cost_preauthorize_then_reconcile_actual"
    },
    "chio_receipt_signing_nonce": "rcpt-01a08ea1-e08c-7246-b627-10d14d90d1a5",
    "receipt_context": {
      "request_id": "acp-prompt:acp-84de6ba3f7b1c894f950257d21dfa3e833b62bab1e78761e445bf372e289aec4:3"
    },
    "route_selection": {
      "candidates": [
        {
          "available": true,
          "routeId": "native-route",
          "selectedProtocols": [
            "acp",
            "native"
          ],
          "targetProtocol": "native"
        }
      ],
      "decision": "select",
      "requestedTargetProtocol": "native",
      "routeSelectionId": "f890ef4ad7fcf6b081f7309117c8ebcd86dc598d6099a0b03f070ae8f84fdbdf",
      "selectedProtocols": [
        "acp",
        "native"
      ],
      "selectedRouteId": "native-route",
      "selectedTargetProtocol": "native",
      "sourceProtocol": "acp"
    }
  },
  "policy_hash": "56f393294872b8f8213479eff52ad3fb3e61581cc62a08410ddbbad21c4e745a",
  "receipt_kind": "mediated_decision",
  "redaction_mode": "none",
  "signature": "2cec8e474137df19597413afcb58f413f5122aa1ee6ccea9f1ba417ddffb32d9d581a076c8dd9efa4dd68faf2039fca5ff51fc45136ce623b33d0690d52b5401",
  "timestamp": 1789099368,
  "tool_name": "count_words",
  "tool_origin": "caller_executed",
  "tool_server": "documents",
  "trust_level": "mediated"
}

{
  "schema": "document-tools.authority.v1",
  "tool": "count_words",
  "max_invocations": 2,
  "lifetime_seconds": 1800
}

use chio_kernel::{
    KernelError, NestedFlowBridge, ToolCallChunk, ToolCallStream, ToolServerConnection,
    ToolServerStreamResult,
};
use chio_manifest::{ToolDefinition, ToolManifest};
use serde_json::{json, Value};

pub const SERVER: &str = "documents";
pub const TOOL: &str = "count_words";
pub const TEXT_LIMIT: usize = 65_536;

pub struct DocumentTools;

fn count(tool: &str, arguments: &Value) -> Result<Value, KernelError> {
    if tool != TOOL {
        return Err(KernelError::ToolNotRegistered(tool.to_owned()));
    }
    let text = arguments
        .get("text")
        .and_then(Value::as_str)
        .ok_or_else(|| KernelError::RequestIncomplete("text must be a string".into()))?;
    if text.len() > TEXT_LIMIT {
        return Err(KernelError::RequestIncomplete(
            "text exceeds 65536 UTF-8 bytes".into(),
        ));
    }
    Ok(json!({"words": text.split_whitespace().count(), "bytes": text.len()}))
}

#[async_trait::async_trait]
impl ToolServerConnection for DocumentTools {
    fn server_id(&self) -> &str {
        SERVER
    }
    fn tool_names(&self) -> Vec<String> {
        vec![TOOL.into()]
    }

    async fn invoke(
        &self,
        tool: &str,
        arguments: Value,
        _nested: Option<&mut dyn NestedFlowBridge>,
    ) -> Result<Value, KernelError> {
        count(tool, &arguments)
    }

    async fn invoke_stream(
        &self,
        tool: &str,
        arguments: Value,
        _nested: Option<&mut dyn NestedFlowBridge>,
    ) -> Result<Option<ToolServerStreamResult>, KernelError> {
        let result = count(tool, &arguments)?;
        // These chunks are collated by the edge into one terminal response.
        Ok(Some(ToolServerStreamResult::Complete(ToolCallStream {
            chunks: vec![
                ToolCallChunk { data: result },
                ToolCallChunk {
                    data: json!({"content": [
                        {"type": "text", "text": "Document counted"}
                    ]}),
                },
            ],
        })))
    }
}

pub fn manifest(public_key: String) -> ToolManifest {
    ToolManifest {
        schema: "chio.manifest.v1".into(),
        server_id: SERVER.into(),
        name: "Document tools".into(),
        version: "1.0.0".into(),
        description: Some("Count words in caller-provided text".into()),
        tools: vec![ToolDefinition {
            name: TOOL.into(),
            description: "Count whitespace-separated words and UTF-8 bytes".into(),
            input_schema: json!({
                "type": "object", "properties": {"text": {"type": "string"}},
                "required": ["text"], "x-chio-streaming": true,
                "x-chio-partial-output": true, "x-chio-cancellation": true
            }),
            output_schema: None,
            pricing: None,
            has_side_effects: false,
            latency_hint: None,
        }],
        server_tools: Vec::new(),
        required_permissions: None,
        public_key,
    }
}

#[path = "../host.rs"]
mod host;
#[path = "../service.rs"]
mod service;

use chio_acp_edge::{AcpAgentConnection, AcpEdgeConfig, AcpKernelExecutionContext, ChioAcpEdge};
use std::{
    io::{BufRead, Read, Write},
    path::PathBuf,
};

fn main() -> anyhow::Result<()> {
    let directory = PathBuf::from(
        std::env::args()
            .nth(1)
            .ok_or_else(|| anyhow::anyhow!("Usage: acp-host NEW_SESSION_DIRECTORY"))?,
    );
    let host = host::boot(&directory)?;
    let edge = ChioAcpEdge::new(AcpEdgeConfig::default(), vec![host.manifest])?;
    let mut connection = AcpAgentConnection::new(edge, service::TOOL.into(), "text".into())?;
    let execution = AcpKernelExecutionContext {
        agent_id: host.capability.subject.to_hex(),
        capability: host.capability,
        dpop_proof: None,
        execution_nonce: None,
        governed_intent: None,
        approval_token: None,
        approval_tokens: Vec::new(),
        threshold_approval_proposal: None,
        supplemental_authorization: None,
        model_metadata: None,
    };
    let mut reader = std::io::stdin().lock();
    let mut writer = std::io::stdout().lock();
    loop {
        let mut line = Vec::new();
        if (&mut reader).take(1_048_577).read_until(b'\n', &mut line)? == 0 {
            break;
        }
        anyhow::ensure!(line.len() <= 1_048_576, "ACP message exceeds one MiB");
        if line.iter().all(u8::is_ascii_whitespace) {
            continue;
        }
        let message: serde_json::Value = serde_json::from_slice(&line)?;
        for response in connection.handle_jsonrpc(message, &host.kernel, &execution) {
            serde_json::to_writer(&mut writer, &response)?;
            writeln!(&mut writer)?;
        }
        writer.flush()?;
    }
    Ok(())
}

use chio_core::{
    capability::{
        scope::{ChioScope, Operation, ToolGrant},
        token::CapabilityToken,
    },
    crypto::Keypair,
};
use chio_kernel::{
    ChioKernel, KernelConfig, DEFAULT_CHECKPOINT_BATCH_SIZE, DEFAULT_MAX_STREAM_DURATION_SECS,
    DEFAULT_MAX_STREAM_TOTAL_BYTES,
};
use chio_manifest::ToolManifest;
use std::path::Path;

pub struct Host {
    pub kernel: ChioKernel,
    pub capability: CapabilityToken,
    pub manifest: ToolManifest,
}

pub fn boot(directory: &Path) -> anyhow::Result<Host> {
    let authority_bytes = std::fs::read("authority.json")?;
    let config: serde_json::Value = serde_json::from_slice(&authority_bytes)?;
    let fields = config
        .as_object()
        .ok_or_else(|| anyhow::anyhow!("Authority must be an object"))?;
    anyhow::ensure!(
        fields.keys().all(
            |key| ["schema", "tool", "max_invocations", "lifetime_seconds"].contains(&key.as_str())
        ),
        "Unknown authority field"
    );
    anyhow::ensure!(
        config["schema"] == "document-tools.authority.v1",
        "Unknown authority schema"
    );
    anyhow::ensure!(
        config["tool"] == crate::service::TOOL,
        "This host grants only count_words"
    );
    let call_limit = config["max_invocations"]
        .as_u64()
        .filter(|v| (1..=50).contains(v))
        .ok_or_else(|| anyhow::anyhow!("max_invocations must be an integer from 1 to 50"))?
        as u32;
    let lifetime = config["lifetime_seconds"]
        .as_u64()
        .filter(|v| (1..=3600).contains(v))
        .ok_or_else(|| anyhow::anyhow!("lifetime_seconds must be an integer from 1 to 3600"))?;
    // A new application run gets a fresh session. Refuse to reuse its directory.
    std::fs::create_dir(directory)?;
    #[cfg(unix)]
    {
        use std::os::unix::fs::PermissionsExt;
        std::fs::set_permissions(directory, std::fs::Permissions::from_mode(0o700))?;
    }
    std::fs::write(directory.join("authority.json"), &authority_bytes)?;
    let authority =
        chio_control_plane::DurableAdmissionRuntime::open(&directory.join("admission.db"))?;
    let keypair = authority.kernel_keypair();
    // The host chooses this key before any receipt exists.
    std::fs::write(
        directory.join("kernel-public-key.txt"),
        keypair.public_key().to_hex(),
    )?;
    let mut kernel = ChioKernel::new(KernelConfig {
        keypair,
        ca_public_keys: Vec::new(),
        max_delegation_depth: 3,
        policy_hash: chio_core::sha256_hex(&authority_bytes),
        allow_sampling: false,
        allow_sampling_tool_use: false,
        allow_elicitation: false,
        max_stream_duration_secs: DEFAULT_MAX_STREAM_DURATION_SECS,
        max_stream_total_bytes: DEFAULT_MAX_STREAM_TOTAL_BYTES,
        require_web3_evidence: false,
        allow_ephemeral_receipt_log: true,
        allow_ephemeral_revocation_store: true,
        checkpoint_batch_size: DEFAULT_CHECKPOINT_BATCH_SIZE,
        retention_config: None,
        memory_budget: chio_kernel::MemoryBudgetConfig::defaults(),
        deadlines: chio_kernel::HotPathDeadlineConfig::default(),
    });
    kernel.set_receipt_store(Box::new(chio_store_sqlite::SqliteReceiptStore::open(
        directory.join("receipts.db"),
    )?))?;
    authority.attach(&mut kernel)?;
    let service_key = Keypair::generate();
    let manifest = crate::service::manifest(service_key.public_key().to_hex());
    let signed = chio_manifest::sign_manifest(&manifest, &service_key)?;
    chio_manifest::verify_manifest(&signed, &service_key.public_key())?;
    std::fs::write(
        directory.join("manifest.json"),
        serde_json::to_vec_pretty(&signed)?,
    )?;
    kernel.register_tool_server(Box::new(crate::service::DocumentTools));
    let agent = Keypair::generate();
    let capability = kernel.issue_capability(
        &agent.public_key(),
        ChioScope {
            grants: vec![ToolGrant {
                server_id: crate::service::SERVER.into(),
                tool_name: crate::service::TOOL.into(),
                operations: vec![Operation::Invoke],
                constraints: Vec::new(),
                max_invocations: Some(call_limit),
                max_cost_per_invocation: None,
                max_total_cost: None,
                dpop_required: None,
            }],
            ..ChioScope::default()
        },
        lifetime,
    )?;
    std::fs::write(
        directory.join("capability.json"),
        serde_json::to_vec_pretty(&capability)?,
    )?;
    Ok(Host {
        kernel,
        capability,
        manifest,
    })
}

# /// script
# requires-python = ">=3.11,<3.15"
# dependencies = ["agent-client-protocol==0.12.1", "chio-sdk"]
# [tool.uv.sources]
# chio-sdk = { path = "sdk/chio-py" }
# ///
"""Use the official ACP client to initialize an agent, open a session and run governed tools."""
import argparse
import asyncio
import json
import os
from pathlib import Path
import subprocess
import uuid

from acp import Client, PROTOCOL_VERSION, RequestError, connect_to_agent
from acp.schema import ClientCapabilities, Implementation, TextContentBlock
from chio.invariants import canonicalize_json, sha256_hex_utf8, verify_receipt_with_trusted_signers

ROOT = Path(__file__).resolve().parent


class Reviewer(Client):
    def __init__(self):
        self.updates = []

    async def session_update(self, session_id, update, **kwargs):
        self.updates.append({"session_id": session_id, "update": update.model_dump(by_alias=True, exclude_none=True)})

    async def request_permission(self, **kwargs):
        raise RequestError.method_not_found("No client-side permissions are exposed by this example")


class RecordedStdio:
    """ACP's message transport, with the actual newline frames retained."""
    def __init__(self, process, wire):
        self.process, self.wire = process, wire

    async def send(self, message):
        self.process.stdin.write((json.dumps(message) + "\n").encode())
        await self.process.stdin.drain()
        self.wire.append({"direction": "client", "message": message})

    async def receive(self):
        line = await self.process.stdout.readline()
        if not line:
            return None
        message = json.loads(line)
        self.wire.append({"direction": "server", "message": message})
        return message

    async def close(self):
        self.process.stdin.close()
        await self.process.stdin.wait_closed()


def verify(result, update, text, key, capability, session_id):
    chio = result["_meta"]["chio"]
    receipt = chio["receipt"]
    if not verify_receipt_with_trusted_signers(receipt, [key])["ok"]:
        raise ValueError("Invalid receipt or untrusted kernel")
    if receipt["capability_id"] != capability["id"] or chio["receiptId"] != receipt["id"]:
        raise ValueError("Result belongs to another grant or receipt")
    if update["_meta"]["chio"] != chio:
        raise ValueError("Tool update and terminal result name different evidence")
    request_id = receipt["metadata"]["receipt_context"]["request_id"]
    if update["toolCallId"] != request_id or not request_id.startswith("acp-prompt:" + session_id + ":"):
        raise ValueError("The tool update is not associated with this signed operation")
    arguments = {"text": text}
    if receipt["action"]["parameters"] != arguments or update["rawInput"] != arguments:
        raise ValueError("Receipt binds different text")
    if receipt["action"]["parameter_hash"] != sha256_hex_utf8(canonicalize_json(arguments)):
        raise ValueError("Input hash differs")
    allowed = receipt["decision"]["verdict"] == "allow"
    if (update["status"] == "completed") != allowed:
        raise ValueError("Tool status differs from the signed decision")
    if allowed:
        output = update["rawOutput"]
        chunks = output.get("stream") if isinstance(output, dict) else None
        if chunks is not None:
            hashes = [sha256_hex_utf8(canonicalize_json(chunk)) for chunk in chunks]
            if hashes != receipt["metadata"]["stream"]["chunk_hashes"]:
                raise ValueError("Stream chunk differs from its signed hash")
            digest = sha256_hex_utf8("".join(hashes))
            count = chunks[0]
        else:
            digest, count = sha256_hex_utf8(canonicalize_json(output)), output
        if digest != receipt["content_hash"]:
            raise ValueError("The tool output differs from its signed hash")
        if count != {"words": len(text.split()), "bytes": len(text.encode())}:
            raise ValueError("The tool did not count the supplied document")
    return receipt


async def exercise(binary, directory, text):
    wire = []
    with (directory.parent / (directory.name + ".log")).open("w") as log:
        process = await asyncio.create_subprocess_exec(str(binary), str(directory), cwd=ROOT,
            stdin=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE, stderr=log, limit=4_194_304)
        try:
            reviewer = Reviewer()
            client = connect_to_agent(reviewer, RecordedStdio(process, wire))
            initialized = await client.initialize(protocol_version=PROTOCOL_VERSION,
                client_capabilities=ClientCapabilities(), client_info=Implementation(name="chio-docs-client", version="1.0.0"))
            if initialized.protocol_version != PROTOCOL_VERSION:
                raise ValueError("Client and agent did not negotiate the same ACP version")
            session = await client.new_session(cwd=str(ROOT), mcp_servers=[])
            # The operator selects its own host's public key before any tool prompt.
            key = (directory / "kernel-public-key.txt").read_text().strip()
            capability = json.loads((directory / "capability.json").read_text())
            records = []
            for number in range(3):
                offset = len(reviewer.updates)
                result = (await client.prompt(session_id=session.session_id,
                    prompt=[TextContentBlock(type="text", text=text)])).model_dump(by_alias=True, exclude_none=True)
                updates = reviewer.updates[offset:]
                calls = [entry["update"] for entry in updates if entry["update"]["sessionUpdate"] == "tool_call"]
                if len(calls) != 1:
                    raise ValueError("Each prompt must return one associated tool update")
                receipt = verify(result, calls[0], text, key, capability, session.session_id)
                if receipt["decision"]["verdict"] != ("allow" if number < 2 else "deny"):
                    raise ValueError("The third prompt must exhaust the two-invocation grant")
                records.append({"result": result, "updates": updates, "verified": True})
                print(calls[0]["status"] + ": " + receipt["id"])
            try:
                await client.prompt(session_id="not-an-owned-session", prompt=[TextContentBlock(type="text", text=text)])
            except RequestError:
                unknown_refused = True
            else:
                raise ValueError("An unknown session was accepted")
            (directory / "acp-capture.json").write_text(json.dumps({
                "client": {"package": "agent-client-protocol", "version": "0.12.1"},
                "protocol_version": initialized.protocol_version, "session_id": session.session_id,
                "trusted_kernel_key": key, "runs": records, "wire": wire,
                "verification": {"ok": True, "unknown_session_refused": unknown_refused, "quota_refused": True}
            }, indent=2) + "\n")
            print("Evidence:", directory.relative_to(ROOT) / "acp-capture.json")
        finally:
            if process.returncode is None:
                process.terminate()
            try:
                await asyncio.wait_for(process.wait(), timeout=10)
            except asyncio.TimeoutError:
                process.kill()
                await process.wait()
            if directory.exists():
                (directory / "wire.json").write_text(json.dumps(wire, indent=2) + "\n")


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("text", nargs="?", default="Chio governs the tools behind an ACP agent")
    args = parser.parse_args()
    if not 0 < len(args.text.encode()) <= 60_000:
        parser.error("text must contain 1 to 60000 UTF-8 bytes")
    subprocess.run(["cargo", "build", "--locked", "--bin", "acp-host"], cwd=ROOT, check=True)
    target = Path(os.environ.get("CARGO_TARGET_DIR", ROOT / "target"))
    if not target.is_absolute():
        target = ROOT / target
    os.umask(0o077)
    (ROOT / ".state").mkdir(exist_ok=True)
    directory = ROOT / ".state" / ("acp-" + str(uuid.uuid4()))
    asyncio.run(asyncio.wait_for(exercise(target / "debug/acp-host", directory, args.text), timeout=90))


if __name__ == "__main__":
    main()