internal/

Package batcher groups a plan's flat card list into the execution units webster forks each run: a library of batchifier implementations behind the Batcher interface, a name-keyed registry those implementations self-register into, Select, which resolves a batcher by name, and Active, the config entry point callers reach for.

sync.go — the background pusher that backs up the board to the remote.

Package buildinfo is a stdlib-free leaf existing solely so cmd/lyx and every future standalone CLI package can read the build channel with no cycle risk.

Package burlerengine runs one review+fix round over an artifact and returns a verdict.

Package clihelp provides the shared cobra infrastructure used by cmd/lyx and every module's RunCLI seam.

Package envsource reads environment variables from a .env file and OS environment.

envelope.go declares the helpers every mutating verb handler routes its output through: okWithRecord for the success path, errWithRecord for the failure path, and errConflictsWithRecord for the dedicated conflict-result failure path a merge verb takes when MergeResult.Conflicts is non-empty.

dirtiness.go holds the package's sole `git status --porcelain` probe.

Package fslink provides a unified cross-platform link primitive that abstracts the differences between Windows junctions and POSIX symlinks.

Package githubclient owns GitHub token resolution, token caching, and construction of an authenticated *github.Client -- nothing else.

Package gitignore manages a single lyx-managed block in .gitignore that is shared across multiple modules.

Package gitkit is the below-fabric leaf holding git primitives only: MustRun, SeedConfig, HermeticGitEnv, and CopyRepo.

Package gitrepo provides a typed Repo over a single local git checkout, split across two backends: go-git for local object and ref reads, and internal/gitexec's raw command runner for anything that authenticates to a remote or mutates the working tree.

Package hubforge is the repo-wide real-hub fixture factory: it builds every hub fixture through fabriccli.CloneAndWire and never replicates that wiring by hand.

Package hubgeom is the hub-mode adapter that tells engines their geometry: it converts a resolved *lyxcwd.Location into the geometry struct each engine holds, so no engine derives its own coordinates from a Location itself.

Package landingshed owns landing's two general producers, Publish and Finalize, which any producer list may name -- neither is special-cased by the engine that drives them.

Package logger is a minimal log/slog wrapper shared across lyx's internal packages, extended with a process-wide trace identity, explicit-parent diagnostic spans, and a durable per-process trace-file sink.

cli.go builds the cobra command tree for the loom module and the RunCLI seam that wires it into the standard io.Writer-based call contract.

Package loomengine implements loom's own seed-coherence check, CheckSeed: one of the four preconditions a task must meet before it is fit to run, with the other three now internal/preflight's orchestrator-agnostic tier-1/tier-2 checks (worktree geometry, worktree cleanliness, fabric readiness/sync).

Package loomshed owns loom's own ordered producer list and returns a constructed *shedengine.Shed.

Package lyxcwd is the entry gate that converts "the process started somewhere" into "these are the coordinates of a legal lyx worktree, or here is why this is not one".

Package lyxdirs is a stdlib-free leaf existing solely so internal/configengine, internal/logger, internal/gitkit, internal/fabricengine and every module engine can name the two lyx directory tokens without any of them owning the pair, and without risking the internal/fabricengine -> internal/logger -> internal/lyxcwd import cycle.

Package mergeresolve merges a source branch into the current pair and, on conflict, resolves it through a fresh, higher-capability LLM session run in a clean context, never a `/model` switch inside a polluted one.

Package modelspec parses and resolves the model-spec notation every agent-spawning config in the stack uses to say which LLM runs a role (webster's roles, perch/burler reviewers and judges, loom's producers).

Package pattern answers one question for every code-touching lyx agent — is PATTERN active in this worktree, and what should the agent be told? — and returns the role-appropriate directive text, read from a stencil file, to inject into that agent's prompt.

Package perchengine is the deterministic gate loop over burler rounds: it spawns a fresh burlerengine round each iteration, reads its verdict, and decides APPROVED or STUCK via a milestone-capped round ladder and an ephemeral progress judge — never by trusting a burler's own self-grading.

Package planparser is the SOLE parser of the on-disk plan format written under `_lyx/plan/` (see contracts/specs/loom-plan-spec.md, the pinned spec this package implements).

Package preflight is the orchestrator-agnostic home of the tier-1 and tier-2 preconditions every composing orchestrator — today only loomengine — validates before it runs: worktree geometry, worktree pair cleanliness, and fabric readiness/sync, plus the two cheap predicates and the mode resolver a standalone-capable CLI's pre-run consults before every command.

Package preflightshed owns the general Preflight producer -- a content-free shedengine.ShedProducer wrapping internal/preflight.Check -- which any producer list may name, the same way internal/landingshed frames Publish and Finalize as producers "shared by reference" rather than owned by one product.

Package reedengine is the domain kernel for lyx's tmux window manager: the tmux subprocess overlay, strand bookkeeping, persisted state, config, and (in the operations layer) the lifecycle verbs that compose them.

Package scoutcli wires internal/scoutengine into the lyx cobra tree as the "scout" module, exposing four verbs — "refs" (every reference to a symbol or position), "definition" (a symbol or position's definition), "symbol" (a workspace/symbol name search), and "assert-no-callers" (a CI-shaped gate: fail if a symbol has any caller outside its declaration and an allowed list) — across the languages internal/scoutengine supports.

Package scoutengine finds every reference to a symbol name or an explicit source position, shows a symbol's definition, and searches workspace symbols by name (`lyx scout refs|definition|symbol <symbol|file:line:col>`) in a target project, across whichever of five languages (Go, Python, C#, TypeScript, Rust) the project is written in.

Package selfreportcli provides the cobra command tree for filing LoomYard bugs and enhancements as GitHub issues directly from lyx.exe.

Package selfreportengine provides the domain kernel for filing GitHub issues via githubclient's authenticated go-github client.

Package shedadapters holds the three shedengine.ShedProducer adapters that let a Shed-built product drive shuttle, perch, and Webster as ordinary producers in its own flat producer list.

Package shedengine is a generic outer phase-FSM: it walks one flat, ordered list of producers, with no predefined slots, honoring resume, crash-recovery, and pause uniformly at producer granularity.

Package shuttleengine runs one LLM agent as an interactive session and returns its result.

Package standalonegeom is the told-mode sibling of internal/hubgeom: it builds engine geometry structs from told strings alone, never resolving cwd and never reading the environment.

Package standalonestate is a stdlib-only leaf that derives a per-target-directory hash8 and per-OS state directory, so every standalone CLI package can import it with no cycle risk.

Package state provides generic locked typed JSON I/O for persistent state, and states the rule that governs a locked-JSON read-modify-write: it must hold one lock across both the read and the write.

Package stencilstore owns the entire stencil lifecycle -- seeding, hash-stamping, edit detection, reading, and validation -- against a caller-supplied absolute stencils directory.

Package tokenvocab is the shared token vocabulary for prompt/template rendering across lyx: today reed's header text pipeline, later loom's prompt templates.

Package treadleengine is the generalized round-loop engine perch's existing, shipped orchestration loop was extracted out of: it spawns a round via a caller-supplied RoundRunner each iteration, gates convergence (llm-verdict / command / both), runs an ephemeral progress judge against a milestone-capped round ladder, and persists per-round state for crash/pause resume — everything internal/perchengine's own round loop did, generalized behind a seam so a second consumer (the future Tenter module, see manifest/designs/hardener.md) can supply a different round-runner without duplicating any of this machinery.

awaitbatch.go implements the `await-batch` webster verb: the bounded long-poll Master calls between forking a batch's implementer and recording it.

Package websterengine is the domain kernel behind webster, a fork-based implementer loop: instead of spawning a fresh reed/tmux strand per batch, one long-lived Master session reads the codebase and the whole plan once, then forks one implementer per execution batch in-session (Claude Code's Agent tool, subagent_type "fork"), sequentially, in the plan's declared card order.