aiblueprint-cli 1.4.95 → 1.4.96

package/agents-config/skills/use-delegate/SKILL.md

@@ -0,0 +1,93 @@
+---
+name: use-delegate
+description: "Delegation mode: the host agent (Claude or Codex) plans and reviews while heavy work runs on cheap executors: OpenCode Kimi K3, Codex GPT-5.6 terra/sol. Use when the user invokes /use-delegate, says 'use delegate', 'delegate mode', 'orchestrator mode', or wants to save tokens/rate limits."
+---
+
+# Use Delegate
+
+The host agent (Claude Code or Codex, whichever is running this skill) is the thinker, never the typist. Its tokens are scarce; the executors below are cheap and steerable. The host decides **what** to do and judges **whether it was done well**: everything token-hungry runs elsewhere and reports back.
+
+## Core rule
+
+The host does not execute. It may: read a few targeted files, search, inspect git state, think, plan, decompose, write specs and delegation prompts, review diffs and reports, judge outputs, and talk to the user.
+
+The host must NOT directly do:
+
+- Implementation, refactors, migrations, test writing (any multi-file or >~15-line change)
+- Codebase-wide exploration or analysis (reading many files to "understand")
+- Computer use, browser automation, UI/UX verification
+- Log triage, data analysis, bulk mechanical edits
+- Running long build/test loops and reading their full output
+
+The only direct edits allowed: trivial single-file tweaks (a config value, a typo, a one-liner) where writing a delegation prompt would cost more than the edit itself.
+
+## Executors
+
+| Executor | Command | Use for |
+|---|---|---|
+| OpenCode · Kimi K3 | `opencode run "<prompt>" -m kimi-for-coding/k3` | Default general executor: implementation, refactors, tests, bulk edits |
+| Codex · GPT-5.6 terra (high) | `codex exec -m gpt-5.6-terra "<prompt>"` | Low-stakes tasks: mechanical edits, scripts, quick investigations, log triage |
+| Codex · GPT-5.6 sol (high) | `codex exec "<prompt>"` (config default = sol + high) | Compute-heavy tasks: hard bugs, migrations, architecture-sensitive changes, computer use / UI verification |
+| Host-native subagents | Claude `Agent` tool / Codex collab threads | Exploration summaries the host plans from; taste-sensitive work (UI, copy, API design) |
+
+Read-only investigation: `codex exec -s read-only`, `opencode run --agent plan` (built-in read-only agent).
+
+Model rankings move fast: current DeepSWE scores, API pricing, and the refresh protocol live in `references/models.md`. Check its `Last verified` date before planning a big batch; if older than 14 days, delegate a refresh first (DeepSWE leaderboard + pricing pages), never guess rankings from memory.
+
+## Invocation mechanics
+
+Both CLIs: always end the command with `< /dev/null` and run in background (codex hangs forever on open stdin: full codex mechanics in `~/.claude/rules/launch-codex.md`).
+
+**Codex** (background):
+
+```bash
+codex exec -C <repo-root> -m gpt-5.6-terra \
+  --output-last-message <scratchpad>/codex-<task>.md \
+  "<self-contained prompt>" < /dev/null
+```
+
+Effort override: `-c model_reasoning_effort=high`. Non-git dir: `--skip-git-repo-check`.
+
+**OpenCode** (background):
+
+```bash
+opencode run "<self-contained prompt>" \
+  -m kimi-for-coding/k3 --title "<task>" \
+  > <scratchpad>/oc-<task>.log 2>&1 < /dev/null
+```
+
+- Final answer = tail of the log; `--format json` for machine-readable events.
+- Steer or continue a session: `opencode run -s <sessionID> "<follow-up>"`.
+- Standalone specialized agent: `--agent <name>`: the `~/.config/opencode/agent/` roster (worker, explore-fast, verifier, snipper, code-reviewer…) runs standalone with any `-m` model.
+- Permissions are pre-allowed in the user config (build agent allows all); no interactive prompt will block a non-interactive run.
+
+## Batch / multi-process
+
+- **Parallel processes** (verified): launch N independent `opencode run` / `codex exec` in background; each opencode run spins up its own server + session, results stay isolated.
+- **Shared server** for large batches: `opencode serve --port <p>` once, then N × `opencode run --attach http://localhost:<p> --dir <workdir> ...`: one server, many sessions, less startup overhead. Kill the serve process when done.
+- **In-executor subagents**: Kimi in opencode spawns its own task-tool subagents; codex spawns collab threads (config caps 6). Prefer one executor process per independent task over one giant prompt.
+
+## The loop
+
+1. **Think.** Understand the request. Missing context → delegate the exploration, think on the summaries.
+2. **Spec.** Write a self-contained delegation prompt: exact files, goal, constraints, and what "done" looks like (tests pass, lint clean, behavior X). The executor can't see this conversation: spell everything out.
+3. **Delegate.** Fire independent tasks in parallel in background. Stay available to steer.
+4. **Verify.** Delegate verification too: read-only pass, test run, or `verifier` agent. The host reads the report and the diff, not the whole tree.
+5. **Judge.** Output misses the bar → refine the spec and re-delegate (better prompts beat manual fixes). Escalate terra → Kimi K3 → sol → host-native only when the cheaper tier keeps failing.
+
+## Delegation prompt checklist
+
+- Names exact files/paths and the repo root
+- States the goal in one sentence, then constraints (style, deletion safety: `trash` not `rm -rf`, no scope creep)
+- Defines done: commands to run, expected results
+- Asks for a report: changed files, what was done, tests run, risks
+
+## Anti-patterns
+
+- "It's faster if I just do it": beyond a trivial tweak it isn't, and it burns the budget the whole session depends on.
+- Reading 10 files to plan: delegate exploration, plan from the summary.
+- Fixing an executor's output by hand: refine the prompt and rerun.
+- Serializing independent delegations: parallelize.
+- Escalating everything to sol or the host: terra and Kimi K3 handle most well-spec'd work.
+
+If no delegation path works (CLIs unavailable, Bash denied), say so explicitly and ask the user before falling back to direct execution: never silently drop out of the mode.

package/agents-config/skills/use-delegate/references/models.md

@@ -0,0 +1,32 @@
+# Delegation models: current rankings and pricing
+
+Last verified: 2026-07-20
+
+**Refresh protocol**: if the date above is older than 14 days, refresh BEFORE planning a big delegation batch. Delegate the research (exa-search skill or a read-only executor): pull the DeepSWE leaderboard (https://deepswe.datacurve.ai/) and the provider pricing pages, then update both tables and the date. DeepSWE is the reference signal: 113 original long-horizon engineering tasks, contamination-free, cost-per-task published per model.
+
+## DeepSWE leaderboard (best config per model, snapshot 2026-07-17)
+
+| Model | Pass@1 | Avg cost/task | Read |
+|---|---|---|---|
+| gpt-5.6-sol [max] | 73% | $8.39 | Top score, best cost among frontier |
+| claude-fable-5 [max] | 70% | $21.63 | Host tier: 2.6x sol cost, never a delegation target |
+| gpt-5.6-terra [max] | 70% | $4.95 | Sol-level score at 59% of the cost |
+| kimi-k3 [max] | 69% | $4.65 | Within noise of terra/sol, cheapest of the top pack |
+| gpt-5.6-luna [max] | 67% | $3.03 | Acceptable floor for trivial bulk work |
+| gpt-5.5 [xhigh] | 67% | $7.23 | Superseded by the 5.6 family |
+| claude-opus-4.8 [max] | 59% | $13.22 | Dominated: lower score, higher cost |
+
+## API list pricing (per 1M tokens)
+
+| Model | Input | Cached input | Output | Context |
+|---|---|---|---|---|
+| Kimi K3 (Moonshot) | $3.00 | $0.30 | $15.00 | 1M |
+| GPT-5.6 Sol | $5.00 | $0.50 | $30.00 | 1.05M |
+| GPT-5.6 Terra | $2.50 | $0.25 | $15.00 | 1.05M |
+| GPT-5.6 Luna | $1.00 | ~$0.10 | $6.00 | 1.05M |
+
+## Access notes (this machine)
+
+- Kimi K3: flat-rate through the kimi-for-coding subscription in opencode (`-m kimi-for-coding/k3`), so marginal cost per delegation is ~zero. The opencode-go gateway is unfunded (insufficient balance): do not route through it. Open weights due 2026-07-27; 1M context; native vision; Terminal-Bench 88.3.
+- GPT-5.6 sol/terra/luna: covered by the Codex subscription (`codex exec -m gpt-5.6-<tier>`); config default is sol + effort high.
+- Current call (2026-07-20): Kimi K3 is the default executor (top-pack score, subscription-covered). Terra for low-stakes tasks. Sol for compute-heavy work. Luna only for trivial bulk edits.

package/dist/cli.js

@@ -33746,7 +33746,11 @@ async function hasContent(folderPath) {
 async function copyManagedFolder(source, destination) {
   await import_fs_extra7.default.copy(source, destination, {
     overwrite: true,
-    dereference: os10.platform() === "win32"
+    dereference: os10.platform() === "win32",
+    filter: async (sourcePath) => {
+      const stat = await import_fs_extra7.default.lstat(sourcePath);
+      return !(stat.isSocket() || stat.isFIFO() || stat.isCharacterDevice() || stat.isBlockDevice());
+    }
   });
 }
 async function writeMetadata(snapshotPath, metadata) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiblueprint-cli",
-  "version": "1.4.95",
+  "version": "1.4.96",
   "description": "AIBlueprint CLI for setting up AI coding configurations",
   "author": "AIBlueprint",
   "license": "MIT",

package/agents-config/skills/use-fable/SKILL.md

@@ -1,64 +0,0 @@
----
-name: use-fable
-description: "Orchestrator mode for Fable: Fable thinks, plans, and reviews while Codex CLI and subagents execute all heavy work. Use when the user invokes /use-fable, says 'use fable', 'fable mode', 'orchestrator mode', or wants to save Fable tokens/rate limits."
----
-
-# Use Fable
-
-Fable is the thinker, never the typist. Its tokens are scarce and expensive; Codex (GPT-5.5) is effectively free and highly steerable. In this mode, Fable's job is deciding **what** to do and judging **whether it was done well** — everything token-hungry runs elsewhere and reports back.
-
-Model rankings, Codex mechanics, and effort settings live in `~/.claude/rules/models.md` (already in context). This skill is the enforcement layer.
-
-## Core rule
-
-Fable does not execute. Fable may: read a few targeted files, search, inspect git state, think, plan, decompose, write specs and delegation prompts, review diffs and reports, judge outputs, and talk to the user.
-
-Fable must NOT directly do:
-
-- Implementation, refactors, migrations, test writing (any multi-file or >~15-line change)
-- Codebase-wide exploration or analysis (reading many files to "understand")
-- Computer use, browser automation, UI/UX verification
-- Log triage, data analysis, bulk mechanical edits
-- Running long build/test loops and reading their full output
-
-The only direct edits allowed: trivial single-file tweaks (a config value, a typo, a one-liner) where writing a delegation prompt would cost more than the edit itself.
-
-## Who executes what
-
-| Task | Executor |
-|------|----------|
-| Well-spec'd implementation, refactors, migrations, bulk edits | Codex: `codex exec "<prompt>"` |
-| Investigation, codebase analysis, log/data triage (no writes) | Codex: `codex exec -s read-only "<prompt>"` |
-| Computer use, UI/UX verification, browser checks | Codex (way better at it) or `verifier`/`dev-browser` subagent |
-| Codebase exploration to inform a plan | `Explore` or `explore-fast` subagent — Fable reads the summary, not the files |
-| User-facing taste work (UI, copy, API design) | Claude subagent with `model: "opus"` |
-| Plan/implementation review | Fable itself (its core job), optionally + Codex as second perspective |
-| Inside a Workflow | thin `sonnet`/`effort: low` wrapper agent that runs `codex exec` via Bash and returns output verbatim |
-
-Claude subagents always get `model: "opus"` unless the wrapper-for-Codex pattern applies. Never Haiku.
-
-## The loop
-
-1. **Think.** Understand the request. If context is missing, delegate the exploration (don't read the codebase yourself) and think on the summaries.
-2. **Spec.** Write a self-contained delegation prompt: exact files, goal, constraints, and what "done" looks like (tests pass, lint clean, behavior X). Codex can't see this conversation — spell everything out. See `/codex:gpt-5-4-prompting` for hard cases.
-3. **Delegate.** Fire independent tasks in parallel (multiple `codex exec` in background, or multiple subagents in one message). Stay available to steer.
-4. **Verify.** Delegate verification too — Codex read-only pass, test run, or `verifier` agent. Fable reads the report and the diff, not the whole tree.
-5. **Judge.** If the output misses the bar: refine the spec and re-delegate (Codex is steerable — better prompts beat manual fixes), or escalate to an opus subagent for taste-sensitive work. Do not "just fix it quickly" yourself — that's how the mode dies.
-
-## Delegation prompt checklist (for Codex)
-
-- Names exact files/paths and the repo root
-- States the goal in one sentence, then constraints (style, deletion safety: `trash` not `rm -rf`, no scope creep)
-- Defines done: commands to run, expected results
-- Asks for a report: changed files, what was done, tests run, risks
-- Non-git/untrusted dir → add `--skip-git-repo-check`
-
-## Anti-patterns
-
-- "It's faster if I just do it" — for anything beyond a trivial tweak, it isn't: it burns the budget the whole session depends on.
-- Reading 10 files to plan — delegate exploration, plan from the summary.
-- Fixing Codex's output by hand — refine the prompt and rerun instead.
-- Serializing independent delegations — parallelize.
-- Verifying UI by taking screenshots yourself — Codex does computer use and UI verification better and cheaper.
-
-If no delegation path works (Codex unavailable, Bash denied), say so explicitly and ask the user before falling back to direct execution — never silently drop out of the mode.