internal/

Package agentctl is what start, drive, finish and forward ask of whatever hosts a task's agent.

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

Package daemon runs drives for one user, outside any session.

Package doctor checks that the Claude Code plugin and the f10 binary are present, agree with each other and are wired into their environment.

Package driver runs the executable at .f10/driver, a project's tracker driver per docs/driver-contract.md.

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

Package facts merges the declared project.md layers with detection and the contract's defaults.

Package findings reads a review's findings file in the shape steps/review.md fixes: a `key: value` header, a categories list, and a block per finding with the verdict and reason resolve appends.

Package forge binds a forge's CLI, gh or glab.

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

Package gitx is the binary's one door to git: reads mirror the shell-outs bin/f10-load-project.sh makes, the semantics oracle, so the two stay comparable.

Package herdr is the binary's door to Herdr, the terminal multiplexer f10 opens task worktrees in.

Package hook is f10's one entry point for Claude Code hook events: they seed the run's badge, become typed observations and record the run's waits on the user.

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.

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

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

Package lore keeps a change's intent, decisions, findings, verdicts and lessons as immutable markdown entries beside the code (spec: docs/lore.md).

Package mdline reads the `key: value` lines f10 takes out of markdown that people and agents edit.

Package model reads a claude model name as typed: 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.

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

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

Package ref looks up which task a lookaround command is about, one cascade for every noun: an explicit id, then the branch name, then this session's run state.

Package shell is the binary's door to every external command that is not git; gitx stays separate because its reads mirror bin/f10-load-project.sh.

Package standup groups one person's activity in a checkout by task, for `f10 standup`.

Package state owns the run state: one `key value` file per session, 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, 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.

Package timing turns ledger events into the active time a run spent in a step: the 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 except for counting the `## Changes` items.