yardlet 0.8.0

Yardlet: a local AI workbench. Plan, queue, route, validate, and hand off long-running work using your already-installed Codex and Claude Code CLIs as hidden workers.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

schema_version: 1

workers:
  - id: codex
    kind: cli_worker
    # capabilities are HARD routing constraints (not the soft best_for rubric):
    # a task whose required_capabilities lists one only runs on a worker that
    # declares it. This replaces the old image-keyword router. Add a capability
    # here and the planner can route to it by meaning, with no magic keywords.
    capabilities:
      - image_generation
    # best_for / not_for are the planner's rubric: task characteristics, not
    # model names, so they survive model changes. Keep them contrastive between
    # workers (one worker's not_for is roughly the other's best_for) so the
    # planner can tell them apart. Refine by hand or via `yardlet routing review`.
    best_for: >-
      image and asset generation; issue-to-patch implementation; test-driven
      bugfixes; shell-heavy build/test/debug loops; screenshot/mockup-to-code UI
      implementation; visual UI bugfixes with concrete evidence; mechanical
      transforms, boilerplate, schema/format constrained output, and routine
      document/spreadsheet/code edits when acceptance criteria are clear
    not_for: >-
      underspecified product strategy, high-stakes domain judgment, long-form
      narrative synthesis, broad architecture decisions without a concrete
      implementation target, or policy-bound conversation design
    cost_weight: low
    # Optional. Empty = the CLI's own default. codex: `-m <model>` +
    # `-c model_reasoning_effort=<minimal|low|medium|high>`.
    model: ""
    effort: ""
    role_strengths:
      - image_asset_generation
      - focused_implementation
      - test_driven_bugfix
      - shell_heavy_repo_changes
      - visual_ui_implementation
      - local_code_review
    billing:
      mode: subscription_backed_only
    invocation:
      command: codex
      supports_noninteractive: true
      output_contract: files
    limits:
      max_wall_minutes: 45
      max_retries: 1

  - id: claude-code
    kind: cli_worker
    best_for: >-
      ambiguity reduction and acceptance-criteria design; product strategy,
      PRDs, roadmap and decision briefs; faithful long-document briefing,
      evidence synthesis, and style-sensitive writing/editing; broad codebase
      exploration; architecture and cross-cutting refactor planning; safety,
      legal, finance, healthcare, HR, customer-support, tutoring, and other
      policy-bound reasoning where tradeoffs and source-grounding matter
    not_for: >-
      native image or asset generation, tightly-scoped mechanical edits with an
      already-clear spec, simple boilerplate, shell-heavy tasks with clear
      commands/tests, or cheap fast iteration
    cost_weight: high
    # Optional. Empty = the CLI's own default. claude: `--model <alias|id>` +
    # `--effort <level>`.
    model: ""
    effort: ""
    role_strengths:
      - planning_gate
      - ambiguity_reduction
      - acceptance_criteria
      - research_synthesis
      - long_form_writing
      - policy_bound_reasoning
      - architecture_reasoning
      - review
      - handoff_quality
    billing:
      mode: subscription_backed_only
    invocation:
      command: claude
      supports_noninteractive: true
      output_contract: json_or_files
    limits:
      max_wall_minutes: 45
      max_retries: 1

routing:
  # The human cost dial the planner weighs: cheap | balanced | quality.
  cost_bias: balanced
  # Run-time default + fallback order when a task names no worker / its worker
  # is not ready. Resolution is deterministic; telemetry never overrides it.
  default_worker: codex
  fallback_order: [codex, claude-code]
  # The planner itself runs on this worker (primary, then fallback if not ready).
  planning_gate:
    primary: claude-code
    fallback: codex