10491a6a3a4a6b42687eee375a2cfcdd6f0a9804
19 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
 Brummel
|
10491a6a3a |
merge: issue #1 compound-hallucination hardening (P0 + Fixes 1-5)
Brings the spec_validation profile slot and the five defense-in-depth fixes onto main: brainstorm + planner parse gates, grounding-check code-block pass, plan-recon content-pin blast radius, and the aspirational-source marker convention. closes #1 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> |
||
|
Brummel
|
56ef25cae1 |
feat: aspirational-source marker convention (issue #1 Fix 5)
Documents a recommended (not plugin-enforced) frontmatter marker for files under `design_models` / RFCs / proposals: `status: aspirational` + `validated-against: <sha|"no validation">`, plus a recommendation that the design ledger distinguish model rows from contract rows mechanically. Wires the brainstorm skill to consume the signal: Step 1 notes the marker when reading model files, Step 4 flags code lifted from an aspirational source as the spec's most suspect bytes that must clear the Step-7 parse gate. This is the upstream signal whose downstream catch is the Fix-1 parse-every-block gate. Adds a Common Rationalisation and a Red Flag. Missing marker -> signal absent, graceful degradation, never a hard fail. Closes the issue #1 hardening set (P0 + Fixes 1-5). refs #1 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> |
||
|
Brummel
|
e019d04f83 |
feat: plan-recon content-pin blast radius (issue #1 Fix 3)
plan-recon already had a Non-compile-checked sweep, but it was gated behind signature/variant/removal scopes (omittable otherwise). The raw-buf.2 failure was a module addition that shifted a workspace-listing hash pinned in two test files — no signature change — so the sweep was legitimately skipped and the twin pin was missed. Adds "Content-pin-perturbing scopes" to Step 5: when the iteration shifts a content-addressed/hashed/snapshot value a test pins, the Non-compile-checked sweep is MANDATORY and must enumerate EVERY test file that grep-matches the perturbed constant — not just the first. Updates the omission clause accordingly, leans on the CLAUDE.md lockstep-invariant pairs (no new profile slot), and adds a Common Rationalisation plus two Red Flags. Embedded in the agent's own file so the discipline does not depend on orchestrator memory. refs #1 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> |
||
|
Brummel
|
fc36647c28 |
feat: grounding-check code-block parse pass (issue #1 Fix 2)
Adds a third pass to the grounding-check agent: when the profile
declares `spec_validation.parsers`, every fenced spec block whose
fence label has an entry is run through its parser (temp file + `ext`,
`cmd` with {file}); a non-zero exit marks the block unparseable and
the aggregate status becomes BLOCK. Complementary to the existing
test-ratification search (checks the spec's own bytes, not codebase
behaviour) and independent of the orchestrator's Step-7 gate (Fix 1) —
a fresh-context second line of the same defense.
Amends the Iron Law to permit per-block parser runs (same read-only
spirit as test-list/type-check), adds an "Unparseable code blocks"
report section, a Common Rationalisation, a Red Flag, and the agent
description.
refs #1
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
|
||
|
Brummel
|
305d7973d4 |
feat: planner parse-the-bytes-you-inline gate (issue #1 Fix 4)
Adds self-review check #9 to planner Step 5, symmetric to Fix 1: when the profile declares `spec_validation.parsers`, every verbatim code body the plan inlines into a task step whose fence label has an entry must parse clean against the live tool before hand-off. Non-zero exit is a plan failure — the last defensive line before implementer dispatch. Trace goes into the planner session. Targets the surface-language snippets the plan lifts verbatim from the spec (the compound-hallucination bytes); source-language test/impl bodies are out of scope — the implement compile gate catches those. Also adds a Common Rationalisation ("came straight from the spec") and a Red Flag (configured parser, no trace in session). refs #1 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> |
||
|
Brummel
|
e1d33369f5 |
feat: brainstorm parse-every-block gate (issue #1 Fix 1)
Adds self-review check #6 to brainstorm Step 7: when the profile declares `spec_validation.parsers`, every fenced spec block whose fence label has an entry is written to a temp file (entry `ext`) and run through the entry `cmd` ({file} substituted); non-zero exit is a self-review failure that must be fixed before the spec proceeds. The parse-trace goes into the brainstorm chat as the attestation the gate fired. Labels with no entry are skipped-and-documented; a malformed entry surfaces as a profile error; no `spec_validation` -> no-op. Placed in Step 7 (not Step 4 as the issue's prose suggested) because the spec file — and thus its code blocks — exists only after Step 6; Step 7 also already re-runs on post-PASS edits, so a changed block re-triggers the gate for free. Also adds a Common Rationalisation ("it obviously parses") and a Red Flag (configured parser, no trace in chat). refs #1 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> |
||
|
Brummel
|
4a2c70baed |
feat: add spec_validation profile slot (fence -> parser registry)
Defines an optional top-level `spec_validation` profile section: a
registry mapping each markdown fence label to the tool that validates
a spec code block of that kind (`ext` + `cmd`, with a `{file}`
placeholder; exit 0 = clean parse, non-zero = BLOCK). Labels without an
entry are skipped-and-documented; a malformed entry fails closed.
This is P0 of issue #1 — the shared prerequisite for the brainstorm
Step-4 parse gate (Fix 1) and the grounding-check code-block pass
(Fix 2). Contract only; no consumer reads the slot yet.
refs #1
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
|
||
|
Brummel
|
540741e6e9 |
polish: six fixes from skill-migration reviews
Three minor-issues + three optional follow-ups identified by the three parallel reviewers of debug/docwriter/audit, fieldtest/planner/brainstorm, and implement. None blocking; all close calibrated gaps the bulk migration left. Minor-issues: - audit/SKILL.md: handoff field `regression_results` now explicitly carries "raw output verbatim (no rounding, no summarisation)" — restores the verbatim-numbers emphasis the original `bench_numbers` field name implied. - audit/agents/bencher.md: hypothesis examples grouped by axis (Tail-latency / Count reduction / Scalability / Overhead vs floor) with concrete numerical anchors (2× of median, ≥80%, 10-million-element, ±15%). Subjects stay domain-neutral but the calibrated bite returns. The preamble enumerates plausible subjects (allocators, query plans, request handlers, parsing strategies, codecs, caches) so the reader has concrete domains to anchor on. - implement/agents/implementer.md: "Architecture rules" section gains a 5-bullet kind-list (determinism contracts; backend / FFI constraints; schema versions; memory / resource models; effect / capability discipline) so the implementer has scaffolding to look for even when the project's CLAUDE.md is sparse. The "BLOCKED on contradiction" mechanism stays the load-bearing rule. Optional follow-ups: - brainstorm/SKILL.md Step 7.5: failure-mode procedure restores the structured backlog-issue fields (Title / Label / Body with `depends on:` and `context:` lines) and the milestone-container option for big deferred work (Gitea milestones, GitHub milestones, Linear projects). - templates/CLAUDE.md.fragment: adds an optional "Lockstep-invariant pairs" section so projects that have cross-file pairings can declare them in a way the architect agent and plan-recon agent already know to consult. Projects without such pairings omit the section; both agents handle absence gracefully. No discipline regressions; no Iron Law / Common Rationalisations / Red Flags edits. Pure scaffold-and-anchor improvements. |
||
|
Brummel
|
22653e410a |
implement: skill + 5 agents migrated — migration complete
Eighth and final skill via the boss pattern. implement carries the per-task loop mechanics; implementer + spec-reviewer + quality-reviewer + tester are phase references the implement-orchestrator inhales at each role-switch. All eight skills + their agents now live in the plugin. AILang can switch over by dropping a project profile + removing its in-tree skills/ in a follow-up. Vocabulary substitutions: - AILang → "this project" - milestone → cycle - Boss → orchestrator (consistently) - ailang-implement-orchestrator → implement-orchestrator - ailang-implementer → implementer - ailang-spec-reviewer → spec-reviewer - ailang-quality-reviewer → quality-reviewer - ailang-tester → tester AILang-specific bits dropped or generalized: - `docs/plans/<iteration>.md` / `docs/specs/<milestone>.md` → `paths.plan_dir` / `paths.spec_dir` - `/tmp/ail-iter/<iter_id>/` → `/tmp/iter-<iter_id>/` - `bench/orchestrator-stats/` → `/tmp/iter-<iter_id>/stats.json` with note that a project-configured stats dir can be used - `cargo build --workspace` / `cargo test --workspace` → `commands.build` / `commands.test` - `examples/<name>.ail.json` → "fixture in the project's canonical fixture form" - `crates/ail/tests/e2e.rs` → "the project's E2E test location" - The entire AILang "Architecture rules (binding)" block in implementer (determinism via BLAKE3, LLVM text IR, schema ailang/v0, RC + bump allocator, Type::Fn effects, Implicit-mode rule) → generic "the binding architectural rules are declared in CLAUDE.md and the design ledger" - `git log --all --grep='or.2'` reference in implement-orchestrator → dropped (was AILang project history) - `bench/orchestrator-stats/<YYYY-MM-DD>-iter-<iter_id>.json` → generic stats path with project-configured option - AILang-specific quality-bar examples (Implicit-mode RC unflagged, libllvm call, schema break without migration note) → generic "anything that violates a binding architectural rule from CLAUDE.md / design ledger" - AILang-specific tester examples (`(show 42)` Int dispatch, ailang/v0 schema) → generic "feature X variant" / "API response" / observable-behaviour framing - `Brummel` references → dropped - `notify.sh` hardcoded → "the project's configured notification command" - `iter/...` branches (legacy AILang concept) → "iteration branches are not used" Universal substance preserved verbatim across all six files: - implement SKILL Iron Law (7 lines including new-cycle triggers and BLOCKED.md convention) - Per-task sub-status table (9 rows) - implement-orchestrator: 7-phase process (Phase 0 clean tree, Phase 1 context load mode-dependent, Phase 2 per-task loop with 4 sub-phases, Phase 3 E2E, Phase 4 BLOCKED.md, Phase 5 stats, Phase 6 end-report) - implement-orchestrator: BLOCKED.md template, stats.json schema, end-report fixed structure - implementer: TDD-first discipline, RED-first exceptions, 6-step process, 4-state status protocol - spec-reviewer: missing/unrequested-extra definitions, 7-step process, 4-state status protocol - quality-reviewer: 8 quality-bar categories, severity definitions, 6-step process incl. Strengths-first rule - tester: 4-clause Iron Law, "named property" doctrine, 4-state status protocol Common Rationalisations + Red Flags tables preserved across all six files with vocabulary substitution only. No discipline compressed. All seven sibling skills (boss, brainstorm, planner, debug, audit, fieldtest, docwriter) and the AILang reference agents now resolve correctly via `../<skill>/...` relative paths post-flatten. |
||
|
Brummel
|
37482ed03d |
brainstorm: skill + grounding-check agent migrated
Seventh skill via the boss pattern. brainstorm is the spec-generation hard-gate; grounding-check is its Step-7.5 read-only assumption-ratification reviewer. Vocabulary substitutions: - AILang → "this project" - milestone → cycle - Boss → orchestrator - ailang-grounding-check → grounding-check - "the AILang program" / ".ail Form-A" → "the user-facing program in the project's canonical authoring/consumer form" - "Brummel (orchestrator) + Claude" → "orchestrator + Claude" AILang-specific bits dropped or generalized: - `docs/specs/<milestone>.md` / `docs/plans/` → `paths.spec_dir` / `paths.plan_dir` - AILang feature-acceptance criterion's three specific clauses (LLM-author-reaches-for-it, measurable correctness/redundancy improvement, no-reintroduction-of-core-constraint-bug) → "the criterion declared in the project's CLAUDE.md", with the three typical-shape clauses retained as illustrative - `design/contracts/0004-feature-acceptance.md` cross-ref → pointer to project CLAUDE.md - "AILang's own thesis is structured concrete form over prose description" → "concrete code first, prose second" (the discipline survives without the project-thesis hook) - The 2026-05-11 incident date → generic "recurring failure mode" framing (the discipline survives without the date) - `tea issues create --repo Brummel/AILang` → "the project's issue-tracker create command (typically tea/gh)" with both examples shown - `cargo test --list -p <crate>` / `cargo check` → "the project's test-list / type-check command" with Rust example - `crates/*/tests/`, `crates/*/src/**/tests.rs`, `examples/` → derived from `paths.code_roots` and the project's examples / fixtures convention - The `Spec-23 / prelude free-fn ne / typeclass elaboration` worked example → generic "spec section that proposes adding to a table or extending a pass without stating that the existing entries / passes cover the new shape" - AILang skill-system index reference (`skills/README.md`) → `../../README.md` (plugin's top-level) - "Form-A / .ail / monomorphised compare__T symbol" examples → generic "function names, type names, schema fields, pass names" example Universal substance preserved verbatim: - The hard-gate (3 lines) — NO IMPLEMENTATION UNTIL SPEC APPROVED - Nine-step process (explore context → clarify Q&A → propose 2-3 approaches → apply feature-acceptance → present in sections → write spec → self-review → grounding-check → user-review-gate → hand off) - "Concrete code first, prose second" discipline (the universally-applicable form of what was the AILang-thesis hook) - "The criterion is unjudgeable without concrete code" rule (universal good practice; project's CLAUDE.md picks the specific criterion) - Spec structure (Goal / Architecture / Concrete code shapes / Components / Data flow / Error handling / Testing strategy / Acceptance criteria) - Step-7 self-review checklist (5 items) - Step-7.5 grounding-check dispatch + PASS/BLOCK/INFRA_ERROR three-way classification + failure-mode procedure + re- dispatch on post-PASS edit rule - All 8 Common Rationalisations rows - All 9 Red Flags bullets - grounding-check's six-step process incl. assumption extraction, search design, ratification classification, aggregate status computation - grounding-check's Iron Law (5 lines), output format (exact layout preserved), 6 Common Rationalisations rows, 8 Red Flags bullets The brainstorm is the largest skill in the migration (366 → 355 lines after substitutions). Calibrated discipline kept intact per memory feedback_dont_strip_repeated_discipline.md: "concrete code first" + grounding-check hard-gate + "re- dispatch on post-PASS edit" are the load-bearing rules; all survive verbatim except for project-specific identifiers. |
||
|
Brummel
|
62060ba124 |
planner: skill + plan-recon agent migrated
Sixth skill via the boss pattern. planner is the spec→executable- plan transformation; plan-recon is its read-only file-mapper. Vocabulary substitutions: - AILang → "this project" - milestone → cycle - Boss → orchestrator - ailang-plan-recon → plan-recon - "the architect's Lockstep invariants table" → "the project's CLAUDE.md lockstep-invariant pairs" (the lockstep pairs are project-specific; the plugin only carries the pattern that the orchestrator may declare them) AILang-specific bits dropped or generalized: - `docs/specs/<milestone>.md` / `docs/plans/NNNN-<iteration>.md` → `paths.spec_dir` / `paths.plan_dir` - `cargo test --workspace -p <crate>` → "the project's test command from commands.test, scoped to this test" + generic template - `cargo check`, `cargo expand` → "the project's type-checker / compiler" and "the project's macro-expansion tool" with Rust/TypeScript examples in parentheses - Rust code-snippet template in Step 3 → language-neutral placeholder with `(exact source code here)` annotations - Specific past-iter references (loop-recur.1, loop-recur.2, loop-recur.tidy, remove-mut-var-assign.1, form_a.md, iter-revert Concern 2, iter effect-doc-honesty Task 2, iter loop-recur.3 Concern) → generic "recurring defect family in this project's history" (the discipline survives; the AILang iter codes that wouldn't parse for a plugin reader go away) - `error[E0061]` Rust-specific compiler error code → "hard compile error" (universal) Universal substance preserved verbatim: - Iron Law (3 lines) - Six-step process (read spec → map structure → write tasks → header → self-review → hand off) - Step 5 self-review checklist — all 8 calibrated checks (spec coverage, placeholder scan, type consistency, step granularity, no commit steps, pin/replacement substring contiguity, compile-gate vs deferred-caller ordering, verification-command filter strings must resolve) - All 6 Common Rationalisations rows - All 6 Red Flags bullets - plan-recon's nine-step process incl. compile-driven enumeration (Step 5) and spec-named-path existence table (Step 6) - plan-recon's output format including all five sections (Files, Compile-driven site set, Non-compile-checked sites, Spec-named-path existence table, Anchors not yet present) - plan-recon's 8 Common Rationalisations rows and 9 Red Flags bullets Calibrated discipline kept (per memory feedback_dont_strip_ repeated_discipline.md): the three plan-defect families flagged by user memory (pin/replacement soft-wrap, compile-gate vs deferred caller, verification filter must resolve) all stay verbatim — they are project-history scaffolding, just de-AILang'd in the references. |
||
|
Brummel
|
808044c0cf |
fieldtest: skill + fieldtester agent migrated
Fifth skill via the boss pattern. fieldtest empirically tests whether a shipped cycle is usable by a downstream consumer who has only the public interface. Profile gains two slots: - `paths.public_interface` — list of dirs/files the fieldtester may read (the project's outward-facing surface: README, design ledger, docs, examples) - `paths.fieldtest_examples` — where the fieldtester writes its fixtures The forbidden zone is derived: everything not in `paths.public_interface` (especially `paths.code_roots` and `paths.bench_dir`) is closed to the fieldtester. This is the load-bearing source-isolation discipline. Vocabulary substitutions: - AILang → "this project" - milestone → cycle - Boss → orchestrator - ailang-fieldtester → fieldtester - "AIL Surface form / .ail" → "the project's canonical authoring or consumer form" - "design/INDEX.md + design/models/" → `paths.public_interface` - "crates/, runtime/, bench/" → `paths.code_roots`, `paths.bench_dir` AILang-specific bits dropped: - The form-a-default-authoring milestone history (2026-05-13) and the eight `.ail.json` carve-outs — AILang-specific schema-migration detail; the universal rule is just "canonical authoring form only" - The ail check / ail build / ail emit-ir CLI commands — the fieldtester now uses "the project's user-facing entry point" - Per-iter journals reference — replaced with recent iter commit bodies (universal) - Example ideas calibrated to AILang (FizzBuzz, Newton's method on Float, JSON-tree depth, ADT functors) — generalised to "realistic tasks an end-user might be asked to do" - `design/contracts/0004-feature-acceptance.md` cross-ref — dropped (AILang-specific contract); the empirical-vs- prospective brainstorm symmetry survives in prose Universal substance preserved verbatim: - All three Iron Law clauses (public-interface-only, canonical-form-only, record-don't-fix) - Five-phase process structure - Four-class finding taxonomy (bug / friction / spec_gap / working) - Spec template - Status protocol (DONE / DONE_WITH_CONCERNS / NEEDS_CONTEXT / BLOCKED) - All 8 Common Rationalisations rows (vocabulary-substituted) - All 10 Red Flags bullets (vocabulary-substituted, with the AILang-specific .ail.json hand-write bullet generalised to "intermediate representations") The source-isolation contract (Iron Law clause 1) is the load-bearing discipline. Profile slot `paths.public_interface` makes it machine-checkable; the agent's hard limit on opening paths outside that list is the discipline. |
||
|
Brummel
|
71fa6a28de |
audit: skill + architect + bencher agents migrated
Fourth skill via the boss pattern. audit is the cycle-close
cleanup gate; architect does read-only drift review against
the design ledger; bencher does hypothesis-driven performance
diagnostics.
Profile gains one slot:
- `commands.architect_sweeps` — optional list of project-
specific architect sweep commands. The architect agent runs
these in addition to its universal checks; non-zero exit =
drift suspicions. AILang uses this for the
bench/architect_sweeps.sh design-honesty / history-anchor
/ lockstep-invariant detector.
The existing `commands.regression` slot now does double duty:
the audit skill walks it in Step 2; the bencher agent reads
the failing script for diagnostics.
Vocabulary substitutions:
- AILang → "this project"
- milestone → cycle
- Boss → orchestrator
- ailang-architect, ailang-bencher → architect, bencher
AILang-specific bits replaced or removed:
- `bench/check.py && bench/compile_check.py && bench/cross_lang.py`
→ `commands.regression` list
- `bench/architect_sweeps.sh` → `commands.architect_sweeps`
- design/INDEX.md / design/contracts/ / design/models/
→ `paths.design_ledger` / `paths.design_contracts` /
`paths.design_models`
- `bench/run.sh`, `bench/orchestrator-stats/`, `runtime/rc.c`,
`runtime/bump.c` (in bencher) → generic harness / production-
path references
- RC + uniqueness + bump + implicit-mode/explicit-mode
framework (the entire AILang allocator-comparison
calibration) → generic "cost-paying variant vs control"
framing; the hypothesis examples generalised to abstract
perf claims
- The two specific lockstep invariants in architect
(Pattern::Lit::* ↔ pre_desugar_validation; lower_app ↔
is_static_callee) → "the project's CLAUDE.md enumerates
the known pairings; walk each one against the cycle diff"
(the concrete pairings stay AILang-only, in AILang's
CLAUDE.md, not in the plugin)
- The Floats fieldtest "B1 canonical example" reference →
dropped (AILang-specific anchor)
- `design/contracts/0007-honesty-rule.md` cross-ref → dropped
(AILang-specific contract); the honesty principle survives
in the architect's commit-body-truthfulness check
Universal substance preserved verbatim:
- All three Iron Law clauses for audit, architect, bencher
- audit's four-step process; architect's eight-step process;
bencher's hypothesis-first methodology + fixture-pairing
rule + honesty rules
- audit + architect + bencher exit code 0/1/2 semantics
- All Common Rationalisations (5/6/8) and all Red Flags
(5/6/7) rows across the three files, vocabulary-substituted
- bencher's "tie is not a result" doctrine intact
Bencher is the most language-coupled of the seven (was
AILang-allocator-specific). Generalised to a performance-
benchmarker; the discipline (hypothesis-first, design-against
not around, ties-are-bench-info) survives intact. AILang's
RC+bump examples kept in spirit via the generic "cost-paying
vs control" framing.
|
||
|
Brummel
|
7f46e9c027 |
docwriter: skill + agent migrated; commands.doc_build slot added
Third skill via the boss pattern. docwriter was the most language-coupled of the seven (Rust rustdoc, cargo doc, /// + //!, intra-doc links). Generalised the discipline while keeping Rust as the canonical concrete example, with a note that other languages substitute syntax (TSDoc, Python docstrings, Javadoc). Profile gains one slot: - `commands.doc_build` — doc-build command that prints warnings on stderr (e.g. "cargo doc --no-deps 2>&1"); used by the docwriter agent's verification triple and warning enumeration. Optional — projects without API docs omit it. Vocabulary substitutions: - AILang → "this project" - "crates" → "components / packages / crates / modules" (the project's idiom) - "milestone" → "cycle" - "Boss" → "orchestrator" - "ailang-docwriter" → "docwriter" AILang-specific bits replaced: - `cargo doc --no-deps 2>&1` → `commands.doc_build` slot - `cargo build --workspace` / `cargo test --workspace` → `commands.build` / `commands.test` slots - `crate / module / item` levels → "top-level / module-level / item-level" (the universal taxonomy; concrete syntax via language note) - `src/lib.rs` / `src/main.rs` hardcoded paths → "entry-point file" (Rust example kept inline) - `docs/` / `design/` hardcoded dirs → `paths.design_ledger`, `paths.design_contracts`, `paths.design_models`, `paths.spec_dir` slots Universal substance preserved verbatim: - Iron Law (4 lines) - Documentation rules (5 bullets) — substantive content; only the concrete-syntax examples got the Rust-as-example note - Hard limits (4 bullets) - Verification triple (build / test / doc_build) - Status protocol (DONE / DONE_WITH_CONCERNS / NEEDS_CONTEXT / BLOCKED) - All 7 Common Rationalisations rows (with vocabulary edits) - All 7 Red Flags bullets |
||
|
Brummel
|
7715ab44f3 |
debug: skill + debugger agent migrated
Second skill migrated using the boss pattern. Purely a discipline skill (RED-first bug fixing); no AILang-specific contracts. Vocabulary substitutions: - AILang → "this project" / "the project" - "ailang-debugger" / "ailang-bencher" / "ailang-architect" → "debugger" / "bencher" / "architect" (ailang- prefix dropped) - "Boss" → "orchestrator" AILang-specific bits replaced with profile slots: - `cargo build` / `cargo test` → `commands.build` / `commands.test` - `ail emit-ir`, `ail run`, `ail build` → "the project's run command" (generic — these were AILang CLI specifics) - `crates/ail/tests/e2e.rs` hardcoded test path → "the testing location idiomatic for this project" - `design/INDEX.md` → `paths.design_ledger` (optional; if the project does not have one configured, that step short-circuits) Universal substance preserved verbatim: - Iron Law (3 lines) - Four phases + Phase 4.5 (the three-failures-means-architecture rule) - Status protocol (DONE / DONE_WITH_CONCERNS / NEEDS_CONTEXT / BLOCKED) - All 7 Common Rationalisations rows - All 8 Red Flags bullets Dropped from original: - "former CLAUDE.md 'Bug fixes — TDD, always' section before the 2026-05-09 skill-system migration" — AILang history, not load-bearing for the discipline - "for the AILang project at /home/brummel/dev/ailang" — AILang identity, replaced with generic "this project" Cross-refs (post-flatten): - `../implement/SKILL.md` for the GREEN handoff target - `agents/debugger.md` from the skill body |
||
|
Brummel
|
d7256e6f8c |
flatten: skills directly at repo root, no skills/ subdir
~/dev/skills/skills/boss/ was visually awkward (skills/skills read twice) and structurally unnecessary — the skills ARE the repo's main content, not a sub-collection inside it. Layout changes: - boss/SKILL.md moves to the repo root - skills/README.md (migration notes) moves to docs/migration.md where documentation-about-the-system belongs - install.sh discovers skills via the SKILL.md marker file instead of a hardcoded skills/<name>/ path, so future skill additions just drop in at the root Cross-references in boss/SKILL.md (../README.md, ../brainstorm, etc.) now resolve against the repo root instead of the old skills/ subdir, which is what they describe: top-level README is the skill table; sibling skill dirs are the other migrated skills. |
||
|
Brummel
|
9e10e9dfee |
boss: migration pilot — autonomous orchestrator mode generalised
First skill migrated from AILang's in-tree skills/. boss carries the autonomous orchestrator authority (god-mode: dispatches every other skill, decides done-state vs bounce-back), so it is the load-bearing pilot for the migration pattern. Profile schema gains three slots that boss needs: - `git.issue_tracker.url` — browsable issue list URL - `git.issue_tracker.list_cmd` — shell command listing open issues - `notifications.command` — script invoked on done-state / bounce-back; falls back to chat if empty AILang-specific bits dropped from the prose: - AILang/Gitea URL + tea CLI hardcoding → profile slots - `design/contracts/0004-feature-acceptance.md` cross-reference → project CLAUDE.md (not the plugin's concern) - "Boss" terminology → "orchestrator" (the plugin term; "Boss" was AILang vocabulary) - "Brummel-as-LLM" → "the orchestrator" - "milestone" → "cycle" (the profile's vocabulary slot) Universal substance preserved verbatim: Iron Law, the five process steps, the four bounce-back triggers + new-cycle rationale, notification protocol, done-state editorial rules, Common Rationalisations, Red Flags. No discipline-prose compression. design/out-of-scope claim retracted: boss DOES generalise, and its body now demonstrates how — the queue mechanic is a single shell-command slot, not a transport-coupled contract. skills/README.md flags boss as the landed pilot; the other seven skills follow once the pattern is approved. |
||
|
Brummel
|
de26df1727 |
nest agents under their dispatching skill
Top-level agents/ was an arbitrary flat layout from the skeleton commit, with no substantive reason behind it. Mirroring AILang's convention (skills/<name>/agents/<agent>.md) is strictly better: it makes the "no orphan agents" rule structurally true — you cannot place an agent file outside a skill — and it keeps the skill/agent binding visible at first glance. Claude Code's user-level discovery is unaffected: install.sh now symlinks ~/.claude/agents/<name> to skills/<name>/agents/ for each skill that has an agents/ subdirectory. The .claude/ registry stays flat; the source tree stays nested. The two checklists previously living in agents/README.md are folded into skills/README.md. |
||
|
Brummel
|
253273b007 |
skeleton: plugin layout + docs, skill/agent migration deferred to iter 1
Establishes the repository structure for the skills plugin: - README + INSTALL describing the two-layer split (plugin mechanics vs per-project profile) - docs/design, profile-schema, pipeline, agent-template covering the universal discipline constants and the profile slot model - templates/project-profile.yml as a copy-and-fill starting point - templates/CLAUDE.md.fragment with the baseline orchestrator rules a project can import - install.sh / uninstall.sh wiring skills/ + agents/ into ~/.claude/ via idempotent symlinks - skills/ and agents/ directories empty except for migration READMEs; the actual SKILL bodies and agent files migrate from ~/dev/ailang/skills/ in the next iteration. No skill or agent runs yet — this commit only stands up the structure and documents the substitution model. |