loomyard

module
v0.0.0-...-fd387ad Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 20, 2026 License: Apache-2.0

README

LoomYard

LoomYard (LY) is a task-orchestration system for Claude Code. It manages the lifecycle of coding tasks — from triaging issues to merging finished code — using AI subagents for design, planning, implementation, and review, with each task isolated in its own git worktree.

At its center is lyx — a single Go binary (LoomYard eXecutable) that owns the task board, the git topology, and (in progress) the orchestrator; everything else in LY is built around it. The repo is under active development: several modules ship today, and the orchestration layers are being built out.

A re-implementation of Millhouse in Go. LoomYard is a ground-up rebuild of Millhouse — same goal (task orchestration for Claude Code with isolated worktrees and AI subagents), rebuilt in Go instead of Python: one compiled binary, deep internal tests, and a cleaner geometry/overlay model.

Inspiration

Through Millhouse, LoomYard builds on ideas from three projects:

  • claude-code-plugins by Craig Motlin — task tracking and skill plugins for Claude Code
  • autoboard by Willie Tran — autonomous agent orchestration patterns
  • skills by Matt Pocock — Claude Code skill conventions

Naming: lyx · loom · ly

Three names for three layers, deliberately non-overlapping:

  • lyx — the binary/CLI (LoomYard eXecutable): one binary with a namespaced subcommand tree (lyx board, lyx fabric, lyx webster, …).
  • loom — the orchestrator module (lyx loom run), a domain like board or fabric that drives a phased run.
  • ly — the skill / orchestration plugin; skills are /ly-*.

Convenience alias: lyx run → lyx loom run (the everyday autonomous call).

Design principles

  1. Toolkit-first. Build small, composable primitives (board, fabric, reed) before the orchestrator that ties them together.
  2. One-shot, daemonless, file-coordinated. A command does its work, writes JSON to stdout, and exits. Concurrent processes cooperate through files and locks, not a server.
  3. cwd-authoritative. Config and state resolve from the current working directory, which need not equal the git-repo root.
  4. Correctness by tool design, not by recall. A lyx command makes the correct path the path of least resistance and makes drift detectable, rather than relying on an operator or agent to remember a rule.
  5. Go where it can be; LLM only for judgment. Deterministic work — verbs, control-flow, parsing, distillation, geometry, git — is Go; an LLM handles only the judgment a program can't (review verdicts, batch implementation, an orchestrator's recovery decisions).

Weft overlay model

LoomYard keeps the Fabric repo pristine by routing all its own artifacts into a companion weft repo — a separate git repository that lyx controls.

<hub>/                              (top-level Hub, NOT a git repo)
  ├── <prime>/                      (warp worktree, main branch)
  ├── <prime>-weft/                 (weft Prime worktree)
  ├── <slug>/                       (additional warp worktree)
  ├── <slug>-weft/                  (weft worktree for <slug>)
  ├── _board/                       (weft:main worktree; the task store)
  │     └── .lyx/                   (hub-wide machine-local scratch)
  ├── _portals/                     (junctions into each worktree's _lyx)
  └── _launchers/                   (per-worktree launcher scripts)

Each warp worktree uses a junction (Windows) or symlink to route writes (_lyx/config/) into its sibling weft worktree — transparently, so code that writes _lyx/config/board.yaml never sees the indirection. Two state roots with opposite lifecycles: _lyx/ is durable and fabric-synced (config, board, orchestration status — resume works across machines); .lyx/ is ephemeral and machine-bound (live tmux runtime state, never synced).

All cwd resolution goes through a single package, internal/lyxcwd — the sole owner of cwd, worktree-root, and lyx-anchor math, and nothing else. Weft paths, junctions, and every per-module subdirectory are the owning module's own relative constants, joined onto the coordinates lyxcwd resolves. See CONSTRAINTS.md.

Modules

Every user-facing module is a lyx <module> namespace, assembled into one cobra root. All commands print JSON: {"ok":true, ...} on success, {"ok":false,"error":"..."} on failure.

Shipped:

  • init — scaffolds _lyx/ and reconciles every module's config against its template (idempotent; never clobbers existing values).
  • board — the task-tracker board.
  • config — view/edit module configs; lyx config reconcile reconciles all configs against their templates; lyx config <module> --set key=value writes values non-interactively.
  • fabric — the sole warp↔weft git-coordination module, unifying topology (clone, dual-worktree add/remove, coordinated checkout, reconcile, status, prune, cleanup) and weft content-sync (status|commit|push|pull|sync) in one command tree.
  • ide — one-shot IDE launcher for worktrees, with an interactive menu.
  • scout — multi-language code-intelligence lookups over LSP (lyx scout refs|definition|symbol), a uniform path across five languages (Go, Python, C#, TypeScript, Rust) instead of a Go-only in-process approach.
  • reed — the tmux overlay + strand bookkeeping + render. (Superseded muxpoc, the proof-of-concept it was built from — muxpoc proved the risky parts, then was deleted once reed shipped.)
  • shuttle — runs one LLM agent as an interactive tmux strand over a file contract, via a swappable provider engine (Claude today).
  • selfreport — file bugs/enhancements against the repo via go-github, authenticated through internal/githubclient (gh is a fallback token source, not the transport).
  • webster — the implementer module: one long-lived Master session reads the flat card-list plan (plan-format, via internal/planparser) once and forks one implementer per batch in-session instead of spawning a fresh strand per batch.
  • perch — a generic profile-driven review-gate loop: runs burler rounds on one artifact until APPROVED/STUCK, standalone or as loom's gate between phases.
  • burler — one review+fix round (review → fix, no self-grading) over the shuttle file contract; composed by perch.

In progress (design):

  • loom — the phased orchestrator: drives its flat, ordered producer list, each gated by a perch review. Preflight is built; Discussion, Plan, the phase-machine skeleton, Finalize, and session bootstrap are still being built out.

The internal library proc (cross-OS process spawn) sits under all of these; see manifest/designs/ for the not-yet-built ones' design docs.

Orchestration stack

The orchestrator is a layered stack, each layer knowing only the one below. It has this shape because agents run as interactive tmux sessions, never headless claude -p — so spawning an agent is "place a pane, launch a provider, drive it, detect completion," not a plain exec.

internal/proc     spawn any OS process, cross-OS                    [OS primitive]
internal/reed     tmux overlay + strand bookkeeping + render        [builds on proc]
internal/shuttle  run ONE LLM agent via a swappable engine          [builds on reed]
burler            one review+fix round: review → fix                [builds on shuttle]
perch             run burler rounds on one artifact → APPROVED/STUCK [builds on burler]
loom              phase machine: drive each phase through a gate     [builds on perch]

webster branches off shuttle directly (an LLM orchestrator driving fat Go verbs, not a perch/burler gate loop). The whole stack runs headless (auto mode): strands exist, agents run, output files are read, nobody need watch.

Building

go build ./cmd/lyx        # build the lyx binary
go test ./...             # run the full suite (structural invariants included)

deploy.cmd builds and installs lyx onto PATH. Once deployed, run lyx init from a worktree to scaffold its _lyx/ config.

Sandbox Hub

The sandbox Hub is a dedicated bench for dogfooding lyx against itself, exercising the real deployed binary end to end. Build it with sandbox/build.cmd, run the agent suite with sandbox/core-suite.cmd, and collect its findings with sandbox/fetch.cmd. See docs/sandbox-howto.md for the runbook.

Requirements

  • Claude Code
  • Go 1.26+
  • A resolvable GitHub token for selfreport: set GH_TOKEN or GITHUB_TOKEN, or have the gh CLI installed and authenticated (gh auth login) as a fallback token source — gh is not required when either environment variable is set
  • Git 2.42+ (for git worktree add --orphan)
  • tmux (for the orchestration layers; on Windows via psmux)

Documentation

  • CONSTRAINTS.md — the repo's structural invariants (authoritative).
  • docs/overview.md — architecture, naming, module and shared-lib map.
  • manifest/roadmap.md — what's planned and what's shipped.
  • manifest/designs/ — per-module design docs for planned, not-yet-built modules.
  • crucible/ — crucible, the hand-run serial review+fix loop for hardening a live-substrate module before merge (not documentation of shipped code, so it lives at the repo root, not under docs/).

Directories

Path Synopsis
cmd
lyx command
Package main is the cobra root for the lyx CLI.
 Package main is the cobra root for the lyx CLI.
testtiming command
Command testtiming runs the repo's Go test suite and prints a wall-clock timing table, so a slow package or test is visible on its own rather than hidden in one combined number.
 Command testtiming runs the repo's Go test suite and prints a wall-clock timing table, so a slow package or test is visible on its own rather than hidden in one combined number.
contracts
stencils
internal
batcher
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.
 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.
boardcli
boardengine
sync.go — the background pusher that backs up the board to the remote.
 sync.go — the background pusher that backs up the board to the remote.
boardengine/boardtest
Package boardtest holds Loomyard's cross-cutting ("on-the-side") test suites for the boardengine module: benchmarks and concurrency stress tests.
 Package boardtest holds Loomyard's cross-cutting ("on-the-side") test suites for the boardengine module: benchmarks and concurrency stress tests.
buildinfo
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 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.
burlercli
burlerengine
Package burlerengine runs one review+fix round over an artifact and returns a verdict.
 Package burlerengine runs one review+fix round over an artifact and returns a verdict.
clihelp
Package clihelp provides the shared cobra infrastructure used by cmd/lyx and every module's RunCLI seam.
 Package clihelp provides the shared cobra infrastructure used by cmd/lyx and every module's RunCLI seam.
configcli
configengine
configreg
configsync
envsource
Package envsource reads environment variables from a .env file and OS environment.
 Package envsource reads environment variables from a .env file and OS environment.
fabriccli
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.
 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.
fabricengine
dirtiness.go holds the package's sole `git status --porcelain` probe.
 dirtiness.go holds the package's sole `git status --porcelain` probe.
fslink
Package fslink provides a unified cross-platform link primitive that abstracts the differences between Windows junctions and POSIX symlinks.
 Package fslink provides a unified cross-platform link primitive that abstracts the differences between Windows junctions and POSIX symlinks.
fsx
gitexec
githubclient
Package githubclient owns GitHub token resolution, token caching, and construction of an authenticated *github.Client -- nothing else.
 Package githubclient owns GitHub token resolution, token caching, and construction of an authenticated *github.Client -- nothing else.
gitignore
Package gitignore manages a single lyx-managed block in .gitignore that is shared across multiple modules.
 Package gitignore manages a single lyx-managed block in .gitignore that is shared across multiple modules.
gitkit
Package gitkit is the below-fabric leaf holding git primitives only: MustRun, SeedConfig, HermeticGitEnv, and CopyRepo.
 Package gitkit is the below-fabric leaf holding git primitives only: MustRun, SeedConfig, HermeticGitEnv, and CopyRepo.
gitrepo
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 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.
hubforge
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 hubforge is the repo-wide real-hub fixture factory: it builds every hub fixture through fabriccli.CloneAndWire and never replicates that wiring by hand.
hubgeom
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 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.
idecli
ideengine
landingshed
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 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.
lock
logger
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.
 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.
loomcli
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.
 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.
loomengine
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 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).
loomshed
Package loomshed owns loom's own ordered producer list and returns a constructed *shedengine.Shed.
 Package loomshed owns loom's own ordered producer list and returns a constructed *shedengine.Shed.
lyxcwd
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 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".
lyxdirs
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 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.
mergeresolve
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 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.
modelspec
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 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).
output
pattern
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 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.
perchcli
perchengine
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 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.
planparser
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 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).
preflight
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 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.
preflightshed
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 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.
proc
reedcli
reedengine
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 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.
reedengine/render
Package render owns the closed display vocabulary and the deterministic Rules(strands, box, params) -> (layout, focus) function that turns a set of strands into a tmux window_layout string.
 Package render owns the closed display vocabulary and the deterministic Rules(strands, box, params) -> (layout, focus) function that turns a set of strands into a tmux window_layout string.
scoutcli
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 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.
scoutengine
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 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.
selfreportcli
Package selfreportcli provides the cobra command tree for filing LoomYard bugs and enhancements as GitHub issues directly from lyx.exe.
 Package selfreportcli provides the cobra command tree for filing LoomYard bugs and enhancements as GitHub issues directly from lyx.exe.
selfreportengine
Package selfreportengine provides the domain kernel for filing GitHub issues via githubclient's authenticated go-github client.
 Package selfreportengine provides the domain kernel for filing GitHub issues via githubclient's authenticated go-github client.
shedadapters
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 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.
shedengine
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 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.
shell
shuttlecli
shuttleengine
Package shuttleengine runs one LLM agent as an interactive session and returns its result.
 Package shuttleengine runs one LLM agent as an interactive session and returns its result.
shuttleengine/claudeengine
Package claudeengine is the Claude adapter behind shuttleengine.Engine: all Claude-specific knowledge — CLI flags, the settings.json hook schema, TUI startup/trust markers, and pane key choreography — lives here and nowhere else.
 Package claudeengine is the Claude adapter behind shuttleengine.Engine: all Claude-specific knowledge — CLI flags, the settings.json hook schema, TUI startup/trust markers, and pane key choreography — lives here and nowhere else.
standalonegeom
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 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.
standalonestate
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 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.
state
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 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.
stencil
stencilcli
stencilstore
Package stencilstore owns the entire stencil lifecycle -- seeding, hash-stamping, edit detection, reading, and validation -- against a caller-supplied absolute stencils directory.
 Package stencilstore owns the entire stencil lifecycle -- seeding, hash-stamping, edit detection, reading, and validation -- against a caller-supplied absolute stencils directory.
tokenvocab
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 tokenvocab is the shared token vocabulary for prompt/template rendering across lyx: today reed's header text pipeline, later loom's prompt templates.
treadleengine
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.
 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.
vscode
webstercli
awaitbatch.go implements the `await-batch` webster verb: the bounded long-poll Master calls between forking a batch's implementer and recording it.
 awaitbatch.go implements the `await-batch` webster verb: the bounded long-poll Master calls between forking a batch's implementer and recording it.
websterengine
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.
 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.
weftname
yamlengine
tools
deploy command
Command deploy builds lyx and installs it into a directory on PATH.
 Command deploy builds lyx and installs it into a directory on PATH.
godocreflow command
Command godocreflow reflows the text of Go doc-comment blocks -- file-level header comments, package doc comments, and comments immediately preceding an exported declaration -- to semantic line breaks (one sentence per line, plus a break at an internal independent-clause boundary), per the golang-comments skill's "Line-wrap style" section.
 Command godocreflow reflows the text of Go doc-comment blocks -- file-level header comments, package doc comments, and comments immediately preceding an exported declaration -- to semantic line breaks (one sentence per line, plus a break at an internal independent-clause boundary), per the golang-comments skill's "Line-wrap style" section.
internal/devbin
Package devbin locates the repository root and the derived `.dev-bin` directory used to install and resolve dev/test builds of lyx, keeping that derivation in exactly one place in the codebase.
 Package devbin locates the repository root and the derived `.dev-bin` directory used to install and resolve dev/test builds of lyx, keeping that derivation in exactly one place in the codebase.
mdreflow command
Command mdreflow is a one-shot (and repeatable) repo sweep tool for the mill:markdown skill's semantic-line-break rule: reflow markdown prose and list-item paragraphs to one-sentence-per-line, with extra breaks at internal clause boundaries (semicolon, or comma+coordinating- conjunction+explicit-subject).
 Command mdreflow is a one-shot (and repeatable) repo sweep tool for the mill:markdown skill's semantic-line-break rule: reflow markdown prose and list-item paragraphs to one-sentence-per-line, with extra breaks at internal clause boundaries (semicolon, or comma+coordinating- conjunction+explicit-subject).
sandbox command
wordswap command
Command wordswap performs a case-preserving whole-token substitution of one word for another across files of any language: identifiers, comments, string literals, shell variables, and markdown prose all substitute through the same mechanism.
 Command wordswap performs a case-preserving whole-token substitution of one word for another across files of any language: identifiers, comments, string literals, shell variables, and markdown prose all substitute through the same mechanism.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.