internal/

Package agent runs an agent step's LLM tool-calling conversation: it resolves the agent's model/connection, compiles the step's granted tools, drives the request/tool-execute/append loop (see runAgentConversation), and enforces required: true tools via the provider's tool_choice.

Package blobstore is a content-addressed store for artifact trees on S3.

Package cli implements steps' command-line grammar and every command behind it: check discovers resource versions, get fetches one via a rendered shell command, and task runs a plan step's command.

Package compress is the one opinion about zstd this repo holds.

Package config parses and resolves a Concourse-style pipeline YAML file (resource_types/resources/jobs) and the config-merge logic (task and agent-invocation resolution) that both plan-time hashing and run-time execution share.

Package dockerapi talks to a docker engine, and is the only package in this repo that holds an engine client.

Package events is the run-event bus: a stdlib-only leaf that carries what a run is doing, as it does it, from the packages executing a job to whatever is watching.

Package exprlang evaluates the expression form of a resource type's check/in/out — the JSON-over-HTTP alternative to writing those three as shell commands.

Package mcp is the shared MCP (Model Context Protocol) client layer: it connects to a configured mcp_servers: entry (config.MCPServer) over either Streamable HTTP (endpoint:) or a local subprocess speaking newline- delimited JSON on stdin/stdout (command:, see stdio.go), lists its tools, and calls one.

Package merkle plans a job's steps into content-addressed chains and computes the hashes used to skip already-succeeded work.

Package outcome classifies a step's or job's error into the categories the hook system dispatches on: a task-level failure (nonzero exit / red verdict / a required tool that never succeeded), an infrastructure error, or an abort (the job's context was canceled).

Package pipeline orchestrates a job's plan: resolving/fetching get steps, running task/put/agent steps in order, and recording each step's outcome so later runs can skip unchanged work (see internal/merkle).

Package resource runs a resource type's check/in/out shell commands and selects among the versions a check returns.

Package retry provides a linear-backoff retry loop.

Package shell runs pipeline-defined commands via `sh -c`, either on the host (HostRunner) or inside a container (DockerRunner, see docker.go).

Package shim is the remote half of a tagged step.

Package store is the contract steps holds its state database to: the row types every driver returns, the errors every driver raises, and the Store interface every driver implements.

Package template renders Go templates against source/version data.

Package trigger polls resources named by a get step's trigger: true and runs every job affected by a version change — the cross-job counterpart to internal/pipeline's single-job orchestration.

Package venue runs a step's commands somewhere other than this machine.

Package web serves the pipeline UI: a read-and-operate view of what the runner has done and is doing, over the same sqlite store the CLI writes.

Package webhook turns one delivery into a version; expressions reach it compiled, so one can build a string but never decide that a signature is valid.

Package wire carries a step's work across a venue: the framed protocol an orchestrator and a pushed shim speak, and the codec that moves a step's directory tree between them.

Package workspace materializes the per-step/per-build filesystem views a job's get/task/put/agent steps run against — either the default shared (single-mutable-directory) implementation, or, when a pipeline opts into workspace: isolation, per-step copy/btrfs-backed directories built from each step's declared inputs/outputs.