cli

Package agentctl is what `f10 start`, `drive`, `finish` and `forward` ask of whatever hosts a task's agent: a workspace per checkout, an agent started and prompted in it, and whether that agent is working.

Package asks keeps the questions driven agents stop on in one per-user inbox, so the user is told about them and can answer from anywhere.

Package daemon runs drives for one user, outside any session: `f10 drive` starts the daemon when none listens, hands it the command line, and tails the drive's log.

Package doctor checks that the two halves of an f10 install - the Claude Code plugin and the f10 binary - are present, agree with each other, and are wired into the environment they run in.

Package driver runs a project's tracker driver: an executable at .f10/driver satisfying the verb contract in docs/driver-contract.md.

Package drives keeps `f10 drive` durable: a record per drive under the storage root, and a lease per task that one process holds while it acts on the task, so two drives, or a drive and `f10 finish`, never act on the same task at once.

Package facts interprets the declared project.md layers, merges them with the detection probes and the contract's defaults, and attributes every effective value to its origin.

Package findings reads a review's findings file, the shape steps/review.md fixes: a header of `key: value` lines, a `## Categories` list with a count per category, and a block per finding under `## Prior round` and `## Findings`, each a `### <id> <title>` heading with `key: value` lines, the `verdict:` and `reason:` that resolve appends among them.

Package forge is the binding to a forge's CLI, gh or glab, and the reads more than one command shares: the pull requests a host lists, their commits, the checks on a commit.

Package frontmatter splits a markdown file's leading YAML block from its body.

Package gitx is the binary's one door to git.

Package herdr is the binary's door to Herdr, the terminal multiplexer `f10 start` opens a task's worktree in, `f10 forward` reaches its agent through and `f10 finish` closes it from.

Package hook is f10's one entry point for Claude Code hook events: a skill starting seeds the run's badge, a Bash call or a file write becomes typed observations, Stop backs up the most-dropped badge call, and SessionStart keeps the status line wired and the state directory small.

Package images downloads the images a task links, so an agent reads local files instead of fetching urls that expire (Notion's signed links) or need auth its fetch tool lacks (a private repo's attachments).

Package layout locates the f10 configuration layers for a working directory: the checkout root, the instruction layers in precedence order, their layering mode, and the storage root.

Package ledger is f10's local record of what runs did: one append-only events table in ~/.f10/f10.db, outside every repo, so stealth is unaffected.

Package lookaround collects facts about one project and derives what changed in a window (the feed) or where each of its tasks stands (the state).

Package lore keeps a change's intent, decisions, findings, verdicts and lessons as immutable markdown entries next to the code, and answers why a line is the way it is and what to know before editing a file.

Package mdline reads the `key: value` lines f10 takes out of markdown that people and agents edit: project.md's facts and a task body's After: line.

Package model reads a claude model name as a person or an agent typed it: a family, a family and a version, or a full id.

Package observe turns what a hook sees - a Bash command and its output, a file written - into typed facts about a run: an issue or PR opened, a commit, a push, a step loaded, a plan or findings file saved.

Package probe runs the deterministic detection probes bin/f10-load-project.sh runs: remote host and CLI routing, stack and verify marker files, and the existing plans.

Package projects maps a bare project name to a checkout directory, for `-C r3` run from somewhere else entirely.

Package ref looks up which task a lookaround command is about.

Package shell is the binary's door to every external command that is not git: a tracker CLI, a project's driver, a pager, an editor, the OS opener.

Package standup groups one person's activity in a checkout by task: the commits they authored and the PRs or MRs they opened, reviewed or merged, collected by `f10 standup` from git and the host CLI.

Package state owns the run state: one small `key value` file per session under ~/.claude/f10/state, keyed by session rather than by repo because two sessions over one checkout are two runs.

Package tasktitle is tracker.title: the template a task's title is written through on the tracker (`{id}: {title}`), and the strip that takes a leading id back off, so f10's own output never shows it twice.

Package tasktree draws every task tree f10 prints: a row per task on box-drawing lines down each After: chain, and under a row its title and labelled notes.

Package timing turns ledger events into the active time a run spent in a step: a window between two step boundaries, minus every wait on the user inside it.

Package trace is the vocabulary of what f10 leaves on the host for a reader of the history: the git trailers a step's commit carries.

Package verdict reads a judge's verdict file, the shape steps/judge.md fixes: a header of `key: value` lines up to the first `## ` heading, then prose the parser ignores.