Ovid/kiro powers#4
Open
Ovid wants to merge 19 commits into
Open
Conversation
Validated via brainstorming + adversarial pushback. Key decisions: single repo (POWER.md + steering/ at the paad repo root, since GitHub installs require POWER.md at root), generated from SKILL.md as the single source of truth, manual inclusion mode (slash-command invocation), and a scripts/kiro-keywords.yaml sidecar for Kiro keywords (testing showed claude plugin validate ignores SKILL.md frontmatter, so keywords stay out of the skills). No conflict with the existing Claude Code plugin: it lives in plugins/paad/, leaving the repo root as a pure marketplace root. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Folds in pushback + alignment review findings: - Reconcile with the already-shipping Kiro/Antigravity path (convert_skills.py -> kiro_and_antigravity/): power supplements the legacy .kiro/skills/ copy path (coexistence), one shared body-cleaning core, exclude makefile to match legacy skip set. - Confirm/resolve empirical questions from Kiro docs: no per-file size cap, $ARGUMENTS has no slash-command equivalent (documented limitation), POWER.md mirrors plugin.json version. - Keep single-repo as recommended (POWER.md at paad root) with a quick busy-root test gate and a dedicated paad-kiro repo as fallback. - Add an ordered implementation plan (Phase 0 gates -> generator -> drift check -> lint -> docs -> ship) with a TDD task breakdown for code phases. - Alignment fixes: legacy-output regression guard, post-generation claude plugin validate, help-sourced POWER.md onboarding. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Curated narrow power-level keyword set plus per-skill entries (drift warning source). Kiro-only metadata kept out of SKILL.md so the Claude plugin stays byte-for-byte untouched. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Task 1 of the Kiro power work: lift convert_skills.py's inline
body-cleaning logic into a pure, unit-testable clean_body() so the
upcoming power generator (build-kiro-power.py) reuses the exact same
section-splitting and section-exclusion rules and the two generators
can never diverge on WHICH sections they keep.
- New scripts/skill_body.py exposes:
- EXCLUDED_SECTIONS: single source of truth for the four dropped
section headers (Arguments, Input Resolution, Pre-flight Checks,
Document classification) — no more copy-pasted list.
- clean_body(content, ...): string in -> string out, no file I/O.
The per-section /paad: handling is an injectable step
(paad_ref_transform) defaulting to the legacy "strip lines"
behavior; the section split + EXCLUDED_SECTIONS drop is fixed and
shared. Path neutralization and whitespace collapsing are shared.
- convert_skills.py imports clean_body and EXCLUDED_SECTIONS and calls
clean_body(content) in place of the inline block. No behavior change.
Tests (pytest, under tests/):
- test_skill_body.py: clean_body() reproduces the committed pushback
body exactly (exercises section exclusion, path neutralization,
whitespace), and pins EXCLUDED_SECTIONS.
- test_legacy_output_unchanged.py: regression guard that runs the
pre-refactor generator (git show HEAD) and the refactored generator
against the same source and asserts byte-for-byte identical output.
Verified to fail when clean_body() behavior is perturbed.
Note: a raw `git diff` after regeneration shows a pre-existing drift in
alignment/SKILL.md (source edited 2026-04-03 without regenerating the
committed tree); the original HEAD generator produces that same diff,
so it is unrelated to this refactor. The committed kiro tree is left
untouched here.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
The committed kiro_and_antigravity/ tree was last regenerated 2026-03-20 but alignment/SKILL.md was edited 2026-04-03 (Step 2 'mandatory' -> 'when applicable'). This regenerates the legacy output so it matches current sources, making the literal git-diff regression guard clean and self-maintaining. Pre-existing drift, unrelated to the shared-core refactor. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
The previous tests/test_legacy_output_unchanged.py sourced the "original" generator via `git show HEAD:scripts/convert_skills.py`. Once the refactor was committed, HEAD became the refactored commit, so the test compared the refactored generator against itself and could never fail (mutating clean_body() to emit .BROKEN/ still passed). Rewrite it as a real golden-output guard: for every in-scope source skill (plugins/paad/skills/* minus the skip_names help and makefile), assert clean_body(<source>) byte-equals the committed kiro_and_antigravity/skills/.kiro/skills/<name>/SKILL.md. This is the golden guard the design called for — read-only (no subprocess, no tree mutation, no artifacts), covering every path replacement and section exclusion across ALL skills, and it can genuinely fail. A sanity test asserts each in-scope skill actually has a committed counterpart so the comparison can't silently cover nothing. Verified mutation-proof: breaking the bare `paad/` -> `.reviews/` replacement now FAILS the guard (caught in agentic-a11y, a skill the old pushback-only test never exercised); reverting restores green. Also refocus tests/test_skill_body.py from a single committed-output snapshot into focused unit tests on small inputs that pin each transform independently: section exclusion, all known path neutralizations, the bare `paad/` fallback, the legacy /paad: line strip, and the injectable paad_ref_transform seam (the future power generator's #name rewrite). This closes the coverage gap where only pushback was exercised. All 14 tests pass; working tree clean (no kiro_and_antigravity/ churn). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Apply three minor code-quality items to de-risk the seam the next task (build-kiro-power.py) consumes: - clean_body() now uses the None-sentinel pattern for excluded_sections instead of a mutable module-level list as the default argument. EXCLUDED_SECTIONS stays a list (the named-constant assertion is intact) and the generated output is unchanged (zero-diff guard still clean). - Remove the dead `import os` from convert_skills.py (unused; pre-existing). - Add a one-line note on neutralize_paad_paths clarifying it is NOT a seam: path neutralization is shared-and-fixed for both generators, unlike the injectable paad_ref_transform. Prevents the next author assuming symmetry. All 14 tests pass; `python3 scripts/convert_skills.py` then `git diff --exit-code -- kiro_and_antigravity/` is ZERO diff. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Generate one `steering/<name>.md` per in-scope PAAD skill from
`plugins/paad/skills/*/SKILL.md`. The 7 files (all skills except `help`
and `makefile`) are shaped as `---\ninclusion: manual\n---` frontmatter
(literal first content, no leading blank, no BOM) followed by the
SKILL.md body.
The body is the source run through the shared `clean_body()` core plus
three power-specific transforms layered on top (not re-implementing
section exclusion / path neutralization):
- cross-skill refs `/paad:<name>` -> `#<name>` (injected as
clean_body's paad_ref_transform, replacing the legacy line-stripping;
also re-run over the whole body to catch intro-prose refs that
clean_body's section-only transform misses, e.g. fix-architecture)
- surviving prose `$ARGUMENTS` -> a "state the scope in your chat
message" prompt (the `If no $ARGUMENTS provided` idiom is rewritten
as a clean conditional); digraph `$ARGUMENTS` is left untouched
- ```dot digraphs pass through verbatim (protected from the
$ARGUMENTS transform)
The source name:/description: frontmatter is stripped (it belongs in
POWER.md, a later task). Output is idempotent and pure
(build_steering_file is string->string; generate writes the files).
Tests cover: exactly 7 files, help/makefile absent, frontmatter-first
shape with single blank line, cross-ref rewrite (sections + intro),
$ARGUMENTS->prose, and verbatim digraph survival.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
The $ARGUMENTS transform stashes/restores ```dot blocks so digraph content is never altered, but the extra whole-body /paad:->#name rewrite (added to catch the fix-architecture intro ref) ran over the entire body including dot blocks, with no such protection. A digraph containing e.g. "Run /paad:agentic-review" would be rewritten to "Run #agentic-review", violating the "digraphs verbatim" rule. It doesn't manifest today (no current skill has a /paad: ref inside a digraph) but is a latent bug a future SKILL.md edit could trip silently. Extract the stash-dot-blocks / run-transform / restore-dot-blocks logic into one shared helper, apply_outside_dot_blocks(text, transform), and use it for BOTH the $ARGUMENTS rewrite and the whole-body /paad: rewrite instead of duplicating the stash/restore logic. Regression test asserts a /paad:<name> ref inside a ```dot block survives verbatim while the same ref in prose is rewritten to #<name>. The 7 generated steering/*.md files are unchanged (no real skill triggers the bug). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Two Minor hardening items protecting the "digraphs verbatim" invariant
against invisible authoring mistakes:
1. The _DOT_BLOCK regex required an exact "```dot\n" open fence, so a
fence written with trailing whitespace ("```dot \n") would NOT be
stashed and any /paad:/$ARGUMENTS inside that digraph would be
rewritten — a silent verbatim violation. Widen the pattern to
"```dot[^\n]*\n.*?\n```" so trailing chars on the open fence line are
tolerated. Regression test asserts a trailing-space-fence digraph
containing a /paad: ref survives verbatim while a prose ref is still
rewritten.
2. apply_outside_dot_blocks stashes blocks behind a NUL sentinel; if
input ever contained a literal NUL the sentinel would collide and
_restore would raise an opaque IndexError. Add an assert that the
input contains no NUL (never valid in hand-authored markdown) so it
fails loudly. No behavior change for real input.
Pure hardening: the 7 generated steering/*.md files are unchanged.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Extend scripts/build-kiro-power.py to emit a single POWER.md at the repo
root that aggregates the 7 in-scope skills into one Kiro power manifest,
alongside the existing steering/*.md generation (which still regenerates
byte-identical).
POWER.md shape:
- Frontmatter (literal first content): name + version READ from
plugin.json so they can't drift; keywords = the curated sidecar
`power:` list VERBATIM (not a union of per-skill keywords);
displayName/description/author are design constants.
- Onboarding SOURCED from help/SKILL.md's overview block (drift-proof).
- A generated "When to load steering files" routing list — one #<name>
entry per in-scope skill, sorted, derived from each skill's
frontmatter description.
Pure/orchestrator split mirrors Task 2:
- build_power_md(...) is PURE and deterministic (no git, no file I/O).
- generate_power(...) loads plugin.json + sidecar + help, warns (stderr)
about any in-scope skill missing a sidecar entry, then appends the git
provenance stamp AFTER the deterministic content as the clearly-
separable final line, so Task 4's drift check can compare a stamp-free
body. Version read and SHA stamp are behind small helpers.
TDD: 22 new tests (a-d frontmatter/onboarding/keywords/warning + routing,
determinism, stamp seam, fallback). Full suite 49 passed. Steering files
and the legacy Kiro tree remain zero-diff.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
The verbatim help overview dragged Claude-Code-isms into POWER.md: a
/paad: slash-command skill list and a makefile line, neither of which
belongs in the Kiro power context. Trim the onboarding to a concise,
help-sourced "what PAAD is":
- Keep the help tagline VERBATIM (still sourced from help/SKILL.md, so it
stays drift-proof).
- Add a short framing sentence: skills are manual steering files the
agent loads on demand, pick from the list below.
The detailed skill directory is now solely the generated "When to load
steering files" routing list (frontmatter-derived #<name>, exactly the 7
in-scope skills) -- no longer duplicated in a second, Claude-Code-flavored
format.
New invariants (added TDD-style, failing first):
- no /paad: substring anywhere in POWER.md (same rule the steering
files follow);
- the routing list has exactly the 7 in-scope skills (no #help/#makefile);
- the trimmed onboarding drops the verbatim overview's skill-list
scaffolding (Available skills:, Run /paad:help).
Everything else unchanged: frontmatter (name/version from plugin.json,
keywords == sidecar power:), routing list, missing-entry warning,
provenance stamp as a separable final line, deterministic stamp-free pure
builder. Full suite 52 passed; steering + legacy Kiro tree zero-diff.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
…test
Code-quality review follow-ups for Task 3. Three changes, all pure
hardening -- the comparable POWER.md content is byte-identical (only the
provenance stamp's short SHA tracks HEAD).
1. (Important) Fix a silent-corruption bug in _help_tagline's fence regex.
The old pattern required a BARE opening fence, so an ordinary markdown
edit adding a language hint to the help overview block (e.g. ```text
instead of ```) would make the regex match the WRONG fence and silently
collapse the onboarding tagline into the literal --- frontmatter marker
(malformed POWER.md, no warning). Switched to ```[^\n]*\n(.*?)\n```,
mirroring _DOT_BLOCK's existing language tolerance, and anchored to the
FIRST fence in the Overview region. Added a TDD test (failing first
against the old regex) using a ```text-hinted help fixture, asserting the
tagline is still extracted and the onboarding does NOT collapse to ---.
2. (Trivial) Reword build_power_md's docstring. It claimed "no git, no
file I/O", but the function reads the 7 SKILL.md files via _routing_list.
The design choice is fine; the contract now reads "no git, deterministic"
and notes the reads explicitly, so the docstring matches reality.
3. (Cheap) Cover the previously-untested defensive branches in
read_skill_frontmatter ({} on no frontmatter) and _routing_list
(.get("description", "")). Added a test with a synthetic tmp_path source
tree containing a frontmatter-less skill, asserting graceful handling:
no exception, an entry with an empty description (not a malformed line),
and deterministic output.
Verify: full suite 54 passed (incl. the 2 new tests). POWER.md content
unchanged except the stamp SHA; steering + legacy Kiro tree zero-diff;
legacy golden guard 8 passed.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Enforce single-source-of-truth for the generated Kiro power (POWER.md +
steering/) without tripping over the floating provenance stamp.
The committed POWER.md's stamp embeds HEAD-at-generation-time, so it always
lags HEAD by one commit and a naive `git diff --exit-code` is forever dirty.
Instead, regenerate in memory and compare against the on-disk files with the
stamp normalized away.
Generator plumbing (scripts/build-kiro-power.py):
* without_stamp(text) — strips the provenance-stamp line; shared by the
idempotency test and the drift check so they cannot disagree.
* find_drift(generated, ondisk) — PURE comparison of {name: content} maps;
POWER.md compared stamp-free, all else byte-for-byte, missing file = drift.
* check_drift() — regenerates in memory, reads on-disk files, calls find_drift.
* --check CLI mode — exits non-zero with a per-file message on real drift.
Makefile:
* kiro — regenerate the Kiro power.
* check-kiro — fail if the committed power is stale or hand-edited (ignores
the provenance stamp); added to the `test` dependency list.
Tests (tests/test_kiro_power_drift.py, 15 new): without_stamp normalization,
find_drift purity, stamp-free idempotency (already deterministic from Tasks
2-3 — kept as a regression guard), and the end-to-end done-condition that a
deliberate hand-edit makes check_drift fail. 69 tests pass.
POWER.md regenerated so its stamp reflects this commit's parent.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Address code-review feedback on Task 4.
Orphan detection (the single-source-of-truth gap): the generators only WRITE,
never DELETE, so removing/renaming a skill leaves a stale steering/<old>.md the
generator would never produce — yet find_drift only looped over generated
files, so check-kiro passed despite the committed power containing it.
* _read_ondisk now also enumerates the real steering/*.md tree (glob), so
extras are visible.
* find_drift flags any on-disk steering/*.md with no generator counterpart as
drift (steering-only; POWER.md is always regenerated). Results stay sorted.
without_stamp: anchor the stamp regex to end-of-text (...-->\n?\Z, drop
re.MULTILINE). The stamp is contractually the FINAL line, so a body line that
merely starts with the stamp literal mid-document is no longer stripped.
DRY: extract _load_power_inputs(source_dir) -> (plugin_meta, sidecar,
help_content), called by both generate_power and _generate_in_memory so the two
paths can't diverge in how they load inputs. Side-effects (warning, writing)
stay in generate_power.
Docstring: the module header no longer claims "Task 2: steering files only" —
it now describes generating POWER.md + steering files plus the --check mode.
Tests (4 new, each watched fail first): check_drift detects an orphan steering
file; find_drift orphan + extra-non-steering cases; without_stamp strips only
the trailing stamp, not a mid-body stamp-like line. 73 tests pass.
POWER.md regenerated so its stamp reflects this commit's parent.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Enforce Kiro's one hard rule: the YAML frontmatter of every generated steering/*.md and POWER.md must be the LITERAL first content of the file (`---` on line 1, no leading blank line, no leading whitespace, no UTF-8 BOM, a closing `---` delimiter, parseable YAML). Kiro silently ignores a steering file whose frontmatter is not first, so a stray blank line disables a skill with no error — this lint catches that loudly. - `frontmatter_first_violation(text)`: pure check returning a per-file reason string (or None), unit-tested against fixtures for the valid case and every violation (leading blank line, leading whitespace, BOM, missing closing `---`, non-`---` first line, unparseable YAML). - `lint_frontmatter_first(root)`: scans on-disk POWER.md + steering/*.md (same enumeration as the drift check, so orphans are linted too) and returns sorted "<file>: <reason>" strings. - `--lint` CLI mode (mirrors `--check`): per-file messages to stderr, exit 1 on any violation, 0 when clean. - Makefile `check-kiro-frontmatter` target, added to `.PHONY` and the `test:` dependency list. REFACTOR seam: the lint reuses `match_leading_frontmatter` — the SAME matcher the generator uses to PARSE source frontmatter (`read_skill_frontmatter`) — so "what we write/parse as valid frontmatter" and "what we lint" share one definition. The generator's output and drift-check behavior are unchanged; POWER.md and the steering files are untouched. 73 prior tests stay green; 14 new tests added (87 total). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
…urced IN_SCOPE Fold in three review follow-ups for the Task 5 lint, all reducing drift/maintenance surface: 1. Share the steering-file enumeration. Extract `_steering_file_names(root)` — the single sorted on-disk `steering/<name>.md` glob — and use it in BOTH `_read_ondisk` (drift check) and `lint_frontmatter_first` (lint). The two checks MUST agree on which files constitute the power; sharing one glob means they can never silently diverge. 2. Reject non-mapping YAML frontmatter. `frontmatter_first_violation` now requires the parsed frontmatter to be a YAML mapping; a scalar (`---\njust a scalar\n---`) or list parses cleanly but is unusable frontmatter. Lint-side only — the shared matcher and `read_skill_frontmatter` are untouched (real frontmatter is always a mapping, so no false-positives). Driven by two failing-first tests. 3. De-hardcode the test's IN_SCOPE. Source it from `_in_scope_skill_names(SOURCE_DIR)` so it tracks the actual skill set instead of a hand-maintained list. Generator OUTPUT and drift-check behavior unchanged (an orphan steering file still triggers drift; a leading-blank file still fails the lint; `make kiro` yields only POWER.md's stamp-line diff). 87 prior tests stay green; 2 new non-mapping tests added (89 total). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Add docs for the experimental Kiro power one-click install alongside the existing manual-copy method: - README `### Kiro`: split into "Power (one-click install)" and "Manual copy" subsections. The power covers Add Custom Power → Import from GitHub using https://github.com/Ovid/paad, invocation via the native `/` list or `#<name>`, refresh-from-remote updates, the no-arguments limitation (state scope in chat instead), and the GitHub-import trust boundary. - README `### Testing`: add `make kiro`, `make check-kiro`, and `make check-kiro-frontmatter`, and note `make test` runs the two Kiro checks. - CLAUDE.md: add kiro-keywords.yaml + `make kiro` steps to the skill-change checklists, and a minimal project-structure note for POWER.md, steering/, and the scripts. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
…aph guard
Final-review hardening batch for the Kiro power feature. No generator OUTPUT
changes (kiro_and_antigravity/, steering/, POWER.md content all byte-identical).
M-2: Consolidate SKIP_NAMES ({help, makefile}) into the shared core.
Add SKIP_NAMES = frozenset(...) to scripts/skill_body.py and import it in
convert_skills.py, build-kiro-power.py, and test_legacy_output_unchanged.py,
deleting the three duplicated literals that had no parity guard. The design
requires the two generators' skill sets stay identical; now they share one
definition. Zero output diff for both generators.
M-1: Make a missing sidecar keyword entry FAIL check-kiro (not just warn on
make kiro). Add check_sidecar_completeness() (reuses missing_sidecar_entries)
and wire it into --check as a hard failure with a distinct SIDECAR message, so
a skill committed without a kiro-keywords.yaml skills: entry no longer passes
make test green. The make kiro warning behavior is preserved.
I-1: Guard + document the accepted digraph drop. The four multi-agent skills
author their digraph inside the excluded "## Pre-flight Checks" section, so
their steering files ship without a dot block; alignment/pushback/vibe author
theirs in the retained intro and keep it. Add guard tests pinning this reality
and update the design doc to describe digraph copying as section-conditional
rather than unconditionally verbatim.
M-3 (doc-only): Add a Phase 0 install-gate bullet to confirm Kiro tolerates the
POWER.md version frontmatter key during the real install test (fall back to
dropping it if rejected).
Tests: 95 pass (was 89: +4 M-1, +2 I-1). make test green on the clean tree.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
There was a problem hiding this comment.
Pull request overview
This PR adds an experimental Kiro “power” distribution channel for PAAD by introducing a shared SKILL body-cleaning core, a new generator that emits POWER.md + steering/*.md, and a comprehensive pytest suite to guard legacy output parity, drift detection, and Kiro’s frontmatter-first constraints.
Changes:
- Extracts shared
clean_body()logic intoscripts/skill_body.pyand refactorsconvert_skills.pyto use it (with golden-output regression coverage). - Adds
scripts/build-kiro-power.pyplusscripts/kiro-keywords.yamlto generate/validate the Kiro power (POWER.md+steering/) with drift and frontmatter linting. - Wires new Make targets + documentation updates, and commits generated
POWER.md/steering/*.md.
Reviewed changes
Copilot reviewed 24 out of 25 changed files in this pull request and generated 2 comments.
Show a summary per file
| File | Description |
|---|---|
tests/conftest.py |
Ensures scripts/ is importable for generator/core tests. |
tests/test_skill_body.py |
Unit tests for shared clean_body() transforms. |
tests/test_legacy_output_unchanged.py |
Golden-output regression guard vs committed legacy .kiro tree. |
tests/test_kiro_power_steering.py |
Tests for steering file generation (frontmatter, rewrites, dot-block protection, orchestration). |
tests/test_kiro_power_md.py |
Tests for deterministic POWER.md aggregation and provenance stamping. |
tests/test_kiro_power_frontmatter_lint.py |
Tests for frontmatter-first linting on POWER.md + steering/. |
tests/test_kiro_power_drift.py |
Tests for stamp-normalized drift detection + idempotency + --check behavior. |
scripts/skill_body.py |
New shared body-cleaning core (section exclusion + path neutralization + /paad: handling seam). |
scripts/convert_skills.py |
Refactored to consume skill_body.clean_body and shared skip list. |
scripts/build-kiro-power.py |
New Kiro power generator + drift check + lint + sidecar enforcement. |
scripts/kiro-keywords.yaml |
Kiro-only keywords sidecar (curated power keywords + per-skill keywords). |
POWER.md |
Generated Kiro power manifest committed at repo root. |
steering/agentic-a11y.md |
Generated manual steering file for agentic-a11y. |
steering/agentic-architecture.md |
Generated manual steering file for agentic-architecture. |
steering/agentic-review.md |
Generated manual steering file for agentic-review. |
steering/alignment.md |
Generated manual steering file for alignment. |
steering/fix-architecture.md |
Generated manual steering file for fix-architecture. |
steering/pushback.md |
Generated manual steering file for pushback. |
steering/vibe.md |
Generated manual steering file for vibe. |
Makefile |
Adds kiro, check-kiro, and check-kiro-frontmatter targets and includes them in make test. |
README.md |
Documents Kiro power install path and the no-arguments behavior. |
CLAUDE.md |
Documents Kiro power generation workflow + sidecar requirement. |
docs/plans/2026-06-30-paad-kiro-power-design.md |
Design document for the power generator and invariants. |
kiro_and_antigravity/skills/.kiro/skills/alignment/SKILL.md |
Updates legacy generated alignment skill text (TDD rewrite step guidance). |
.gitignore |
Ignores Python/pytest caches. |
💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Testing out adding PAAD as a Kiro power.