v0.5.6

Full Changelog: v0.5.5...v0.5.6

v0.5.5

Full Changelog: v0.5.4...v0.5.5

Yardlet v0.5.4

Changed

• The published crate no longer ships repo-internal material. Cargo.toml
exclude drops the repo's own .agents/ state, seed queues, CI config, and
  local backups from the tarball, leaving only what builds and runs the crate.

v0.5.3

Added

• Prebuilt binaries + cargo binstall support. A release workflow
  (.github/workflows/release.yml) builds macOS (Intel and Apple Silicon) and
  Linux x86_64 binaries on each version tag and attaches them to the GitHub
  release, so users can grab a binary or run cargo binstall yardlet instead
  of compiling.

Changed

• Public-landing polish: README gains crates.io/CI/downloads/license badges
  and an Install section, and its prose (plus this changelog) drops em-dashes.

Yardlet v0.5.2

Fixed

• Pressing p during an auto-drain now shows feedback. The running status
  line replaces the toast area while busy, so the graceful-pause toast was
  invisible exactly when you'd press p — it looked like a no-op. The busy
  status line now reflects the pause flag directly: request a pause and it
  switches to "pausing — will stop after the current task" (persistent, since
  the flag is). Completes the 0.5.1 pause/stop fix.

Yardlet v0.5.1

Changed

• Renamed the project to Yardlet. The crate, binary, and command are now
  yardlet (the yard name was taken on crates.io by an unrelated parser).
  The container-yard metaphor and identity are unchanged. Existing workspaces
  keep working: the config file is now .agents/yardlet.yaml, but a legacy
  .agents/yard.yaml is still read (and written in place) so nothing breaks on
  upgrade. Internal worktree branches stay yard/<task-id>.

Fixed

• Pause/stop now works from the Monitor screen, and the footer stops lying.
  p (graceful pause) and a new x (stop the worker now) work on the Run
  Monitor, not just Home — the monitor was a dead end for both. The Home footer
  no longer advertises p pause during a planning or single-task run (nothing
  to pause between tasks); it shows Esc stop instead, and pressing p there
  now says so explicitly rather than a vague "busy". Esc/x stop the worker
  immediately; p still only pauses an auto-drain (between tasks).

Yard v0.5.0

Added

• Rule auto-learn + yard harness review (harness H4 completion). The
  learning loop already auto-recorded worker-proposed skills (S3); now a
  run's harness_suggestions of kind "rule" are auto-recorded too, as
  .agents/rules/learned-<slug>.md — an always-apply constraint H1 inlines
  into every packet (the worker proposes, Yard's deterministic core writes; no
  clobber; gated by auto_rule, default on). Because a rule is always-on it
  has no per-task attribution to score, so learned rules are kept until removed
  (git-reversible) rather than auto-pruned like skills. New yard harness review shows the learned rules and the learned skills with their eval
  scores in one place. (Deterministic-observation candidate mining — failure
  themes into candidates — remains the open part of H4.)

• Workspace hooks (harness H3) — deterministic guards that bind every
  worker. Executables in .agents/hooks/pre-run.d/* run before a worker
  spawns; a non-zero exit blocks the run (the task fails with the hook's
  reason, so the drain stops on it — fix the cause and re-run). Executables in
  post-run.d/* run during evaluation; a non-zero exit is a fatal check
  that blocks Done, folded into the evaluation. Each hook runs in the repo
  root with YARD_TASK_ID / YARD_RUN_DIR / YARD_WORKER, a 30s timeout
  (longer is killed and fails), and stdout/stderr captured to
  <run_dir>/hooks/<phase>/. Only executable files run, in sorted filename
  order. Unlike a single CLI's hooks, these bind Codex, Claude Code, and any
  generic-adapter worker alike. Yard ships no enabled hooks — yard init
  lays down empty pre-run.d/post-run.d and a documented README.md. Off
  with hooks: false in yard.yaml.

• Explicit skill authoring: yard skill research / create / apply (S2/S3).
  On-demand skills without hand-writing a SKILL.md. yard skill research "<topic>" runs a researcher-role worker that drafts a candidate skill to a
  run dir and installs nothing; yard skill apply <run-id> installs that
  draft; yard skill create <name> [--from "<topic>"] authors and installs in
  one step. The run is queue-isolated — like the planner it spawns one
  worker, but derives no intent/queue, so authoring a skill never disturbs the
  live intent (the gap that deferred this). The worker proposes the content;
  Yard (the deterministic core) is the sole writer. Authored skills are tagged
  source: created (not learned), so they are user-chosen and never
  auto-pruned — they persist like a library equip until unequip.

Fixed

• Recover a task wrongly stuck Failed by a dead orchestrator. If Yard
  exited after a worker finished but before the result was evaluated, the
  task could end up Failed even though its run produced a clean done
  result — and neither restart-recovery nor yard recover could salvage it
  (recovery only looked at Running tasks), forcing a wasteful full re-run.
  Recovery now also re-evaluates such a task's stranded result, detected by an
  unfinalized orphan run (worker.pid still on disk — a finalized run
  removes it — with the process gone). It routes through the evaluator, so a
  genuinely-bad result stays failed; only real, completed work is reclaimed.
  Surfaced by dogfooding Deadline12, where a completed map task sat Failed.

Yard v0.3.0

Added

• Per-worker API key pass-through (invocation.pass_env). Zero-key is
  now framed as the default for the subscription-first audience, not an
  identity rule: a custom worker profile can name env vars (e.g.
  OPENAI_API_KEY) that reach that worker only, while every other worker
  stays key-scrubbed and Yard never reads or stores the values. README and
  AGENTS.md reworded accordingly; a native API adapter is on the roadmap.

• Self-restart on upgrade. yard notices when its own binary is replaced
  (cargo install while running) — the status line announces the new build
  and u re-execs into it in place. No more silently-stale TUI sessions;
  a now also works on queued tasks (instructions ride into the run).

• Partial = continue, not redo (harness phase H2). Re-running a Partial
  task injects the previous run's checkpoint, summary, and unresolved
  validation failures into the packet ("do not redo finished work"). The
  auto-drain now continues self-reported partials automatically
  (attempts-capped) and halts only on merge-conflict partials (marked via a
  partial-reason file). The TUI a key now also answers Partial/Blocked
  tasks — the reply becomes rerun instructions threaded into the
  continuation packet; the Answer screen shows what the previous run says is
  still missing.

• Worker management from the TUI. The Home arrow keys now continue past
  the queue into the workers panel; Enter/Space toggles a worker on/off
  (persisted as enabled: in workers.yaml — routing and planning skip a
  disabled worker).

• Model/effort presets sync from the CLIs. codex models and reasoning
  efforts come from the CLI's own ~/.codex/models_cache.json (the models
  available to this account); claude effort levels are parsed from
  claude --help, and its model aliases are the documented stable set. No
  hand-maintained id lists; typing an exact id still works.

• Custom workers via config alone. Any subscription-backed CLI can be
  added as a third worker in workers.yaml with an invocation template
  (args, sandbox_args/full_access_args, model_args, effort_args,
  image_args; placeholders {run_dir} {model} {effort} {image}).
  Codex and Claude Code keep their first-class adapters; see README
  "Adding a worker".

• Role profiles (plan §13.4). Tasks run under a prompt-mode role derived
  from their kind — builder / reviewer / researcher / security — with
  role-specific working rules in the packet, replacing the old worker-keyed
  guidance. A workspace extends a role by writing .agents/agents/<role>.md
  (appended to that role's packets as "Workspace role notes").

Fixed

• TUI responsiveness: the mid-run refresh no longer spawns worker --version
  probes every second (which froze the event loop ~100ms and ate keystrokes),
  and the Run Monitor renders from a cache instead of rescanning the runs
  directory and re-parsing the whole worker log every frame.
• Keyboard shortcuts work with the Korean IME on: 2-beolsik jamo map back to
  their QWERTY keys on shortcut screens (ㅡ→m, ㅗ→h, Shift+ㅁ→A).
• Single-press shortcuts under a CJK IME (macOS): on shortcut screens Yard
  auto-selects an ASCII input source (the im-select pattern), so the first
  keypress is no longer swallowed by IME composition; the IME is restored on
  text-input screens and on exit. Toggle via Settings ("Auto IME switch") or
  auto_ime in .agents/yard.yaml.
• Quitting mid-run no longer duplicates work: the worker survives a quit, and
  on restart Yard now ADOPTS a still-alive worker (task stays Running, the
  Monitor tails its live log, the idle loop evaluates and merges its result
  when it lands) instead of requeueing the task into a second worker. The
  auto-drain waits for an adopted worker rather than starting overlapping
  work; only a dead worker with no result is requeued.
• Worker-loss audit fixes: a stale plan finished late by an orphaned planning
  worker can no longer clobber a newer intent/queue (supersession guard); a
  still-running planning worker from a previous session is reported instead
  of being silently duplicated; Esc now also stops an adopted worker; a dead
  background job thread fails the job instead of leaving the UI busy forever;
  and integration only ever aborts its OWN in-progress merge — a merge the
  user has in progress is reported and left untouched.

Yard v0.2.0

Added

• Parallel queue. The auto-drain can run up to max_parallel independent
  tasks at once, each in its own git worktree on branch yard/<task-id>
  (yard run --auto --parallel N, the Settings screen, or
  max_parallel in .agents/yard.yaml). Workers run in parallel; queue state
  keeps a single writer; results merge back sequentially, and a conflict drops
  the task to Partial with its worktree kept for inspection. Design:
  docs/parallel-queue.md.
• Task dependencies. Tasks carry depends_on; the planner is asked to cut
  tasks coarse along scope boundaries and mark only genuine output
  dependencies. Yard sanitizes plans to backward references (no self/forward/
  unknown ids, no cycles) and scheduling skips tasks with unmet dependencies.
• Crash recovery for planning. Plan runs record their mode + request up
  front and a consumed marker once derived; a restart (TUI startup, auto-drain,
  or the new yard recover) consumes a planning result the previous session
  paid for but never read — including run dirs created by older versions.
• yard recover. One command to recover an interrupted session: unread
  plans, finished orphaned runs (worktree runs get merged back), and
  interrupted tasks requeued.
• TUI. Run Monitor follows every running task (tab row + Tab/←→ switching
  when parallel), Settings exposes "Parallel tasks", and the auto-drain
  reports gated-vs-drained queues accurately.
• CI. GitHub Actions: cargo fmt --check + clippy -D warnings gate and
  build/test on Ubuntu and macOS.

Fixed

• Orphan recovery is worktree-aware: a finished parallel run found on startup
  is merged into the workspace instead of leaving its changes stranded.
• Planning results are no longer lost when Yard exits mid-plan.