cadence-skill-installer 0.2.19 → 0.2.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cadence-skill-installer",
-  "version": "0.2.19",
+  "version": "0.2.20",
   "description": "Install the Cadence skill into supported AI tool skill directories.",
   "repository": "https://github.com/snowdamiz/cadence",
   "private": false,

package/skill/SKILL.md

@@ -19,11 +19,12 @@ description: Structured project operating system for end-to-end greenfield or br
 
 ## Repo Status Gate
 1. At Cadence entry (first assistant response in the conversation), resolve `PROJECT_ROOT` with `python3 scripts/resolve-project-root.py --project-root "$PWD"` (resolve script paths from this skill directory but keep command cwd at the active project).
-2. Run `python3 scripts/check-project-repo-status.py --project-root "$PROJECT_ROOT"`.
-3. Read `repo_enabled` from script output and treat it as the authoritative push mode for the active subskill conversation.
-4. If `repo_enabled` is false, continue with local commits only until a GitHub remote is configured.
-5. Do not rerun this gate between normal user replies inside the same active subskill conversation.
-6. Rerun this gate only when:
+2. If `"$PROJECT_ROOT/.cadence"` exists, run `python3 scripts/check-project-repo-status.py --project-root "$PROJECT_ROOT"`.
+3. If `"$PROJECT_ROOT/.cadence"` does not exist, skip this gate at root entry and let `skills/scaffold/SKILL.md` establish repo mode after scaffold initialization.
+4. Read `repo_enabled` from script output and treat it as the authoritative push mode for the active subskill conversation.
+5. If `repo_enabled` is false, continue with local commits only until a GitHub remote is configured.
+6. Do not rerun this gate between normal user replies inside the same active subskill conversation.
+7. Rerun this gate only when:
    - starting a new Cadence conversation
    - transitioning to a different subskill after a completed checkpoint
    - handling explicit resume/status/reroute requests

package/skill/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
   display_name: "Cadence"
   short_description: "Lifecycle + delivery system for structured project execution"
-  default_prompt: "Use Cadence to guide this project from lifecycle setup through phased execution, traceability, audit, and milestone completion. Always read and apply the active SOUL persona from .cadence/SOUL.json (fallback: SOUL.json). Keep user-facing responses concise and outcome-focused, and never expose internal skill-routing or command-execution traces unless the user explicitly asks. Do not announce successful internal checks; only surface them when a check fails and blocks progress. At Cadence entry (first assistant response in a conversation), first resolve PROJECT_ROOT with scripts/resolve-project-root.py --project-root \"$PWD\", run scripts/check-project-repo-status.py --project-root \"$PROJECT_ROOT\" and treat repo_enabled as the authoritative push mode (if false, keep commits local-only), run scaffold only when \"$PROJECT_ROOT/.cadence\" is missing, then run scripts/read-workflow-state.py --project-root \"$PROJECT_ROOT\" and treat route.skill_name as authoritative for the next state-changing skill. During normal multi-turn subskill conversation flow, do not rerun repo/route gates between each user reply; rerun them only when checkpointing into a new subskill, handling explicit resume/status/reroute requests, or recovering from assertion/gate failures. Invoke skills/prerequisite-gate/SKILL.md only when route.skill_name is prerequisite-gate. If scaffold and prerequisite complete in-thread and route advances to ideator, force subskill handoff with: Start a new chat and either say \"help me define my project\" or share your project brief. In later chats, if route.skill_name is ideator, do not rerun prerequisite; invoke skills/ideator/SKILL.md in the same chat, and if the user has not provided ideation input yet, ask one kickoff ideation question in-thread instead of handing off again. Do not force a new-chat handoff when route advances from ideator to researcher; on the next cadence invocation, route directly from workflow state. If route.skill_name is researcher, invoke skills/researcher/SKILL.md and enforce one pass per conversation; when more passes remain, end with: Start a new chat and say \"continue research\". If user intent indicates resuming/continuing work or asking progress, invoke skills/project-progress/SKILL.md first, report current phase, then route to the next step. If the user manually requests a Cadence subskill, resolve PROJECT_ROOT with scripts/resolve-project-root.py --project-root \"$PWD\" and then run scripts/assert-workflow-route.py --skill-name <subskill> --project-root \"$PROJECT_ROOT\" before any state-changing actions. Ensure direct subskill execution follows the same Git Checkpoints policy from this main skill: run scripts/finalize-skill-checkpoint.py with each subskill's configured --scope/--checkpoint and --paths ., allow status=no_changes without failure, and treat checkpoint or push failures as blocking errors surfaced verbatim."
+  default_prompt: "Use Cadence to guide this project from lifecycle setup through phased execution, traceability, audit, and milestone completion. Always read and apply the active SOUL persona from .cadence/SOUL.json (fallback: SOUL.json). Keep user-facing responses concise and outcome-focused, and never expose internal skill-routing or command-execution traces unless the user explicitly asks. Do not announce successful internal checks; only surface them when a check fails and blocks progress. At Cadence entry (first assistant response in a conversation), resolve PROJECT_ROOT with scripts/resolve-project-root.py --project-root \"$PWD\". If \"$PROJECT_ROOT/.cadence\" exists, run scripts/check-project-repo-status.py --project-root \"$PROJECT_ROOT\" and treat repo_enabled as the authoritative push mode (if false, keep commits local-only). If \"$PROJECT_ROOT/.cadence\" is missing, run scaffold first and let scaffold establish repo mode. After scaffold handling, run scripts/read-workflow-state.py --project-root \"$PROJECT_ROOT\" and treat route.skill_name as authoritative for the next state-changing skill. During normal multi-turn subskill conversation flow, do not rerun repo/route gates between each user reply; rerun them only when checkpointing into a new subskill, handling explicit resume/status/reroute requests, or recovering from assertion/gate failures. Invoke skills/prerequisite-gate/SKILL.md only when route.skill_name is prerequisite-gate. If scaffold and prerequisite complete in-thread and route advances to ideator, force subskill handoff with: Start a new chat and either say \"help me define my project\" or share your project brief. In later chats, if route.skill_name is ideator, do not rerun prerequisite; invoke skills/ideator/SKILL.md in the same chat, and if the user has not provided ideation input yet, ask one kickoff ideation question in-thread instead of handing off again. Do not force a new-chat handoff when route advances from ideator to researcher; on the next cadence invocation, route directly from workflow state. If route.skill_name is researcher, invoke skills/researcher/SKILL.md and enforce one pass per conversation; when more passes remain, end with: Start a new chat and say \"continue research\". If user intent indicates resuming/continuing work or asking progress, invoke skills/project-progress/SKILL.md first, report current phase, then route to the next step. If the user manually requests a Cadence subskill, resolve PROJECT_ROOT with scripts/resolve-project-root.py --project-root \"$PWD\" and then run scripts/assert-workflow-route.py --skill-name <subskill> --project-root \"$PROJECT_ROOT\" before any state-changing actions. Ensure direct subskill execution follows the same Git Checkpoints policy from this main skill: run scripts/finalize-skill-checkpoint.py with each subskill's configured --scope/--checkpoint and --paths ., allow status=no_changes without failure, and treat checkpoint or push failures as blocking errors surfaced verbatim."

package/skill/scripts/run-prerequisite-gate.py

@@ -29,6 +29,11 @@ def parse_args() -> argparse.Namespace:
         default="",
         help="Explicit project root path override.",
     )
+    parser.add_argument(
+        "--scripts-dir",
+        default="",
+        help="Optional pre-resolved cadence scripts directory. Skips scripts-dir resolution when provided.",
+    )
     return parser.parse_args()
 
 
@@ -108,6 +113,7 @@ def write_prerequisite_state(scripts_dir, pass_state, project_root: Path):
 def main():
     args = parse_args()
     explicit_project_root = args.project_root.strip() or None
+    explicit_scripts_dir = args.scripts_dir.strip()
     try:
         project_root, _ = resolve_project_root(
             script_dir=SCRIPT_DIR,
@@ -121,7 +127,18 @@ def main():
 
     write_project_root_hint(SCRIPT_DIR, project_root)
     assert_expected_route(project_root)
-    scripts_dir = resolve_scripts_dir(project_root)
+    if explicit_scripts_dir:
+        scripts_path = Path(explicit_scripts_dir).expanduser()
+        if not scripts_path.is_absolute():
+            scripts_path = (project_root / scripts_path).resolve()
+        else:
+            scripts_path = scripts_path.resolve()
+        if not scripts_path.is_dir():
+            print("INVALID_CADENCE_SCRIPTS_DIR", file=sys.stderr)
+            raise SystemExit(1)
+        scripts_dir = str(scripts_path)
+    else:
+        scripts_dir = resolve_scripts_dir(project_root)
     state = read_prerequisite_state(scripts_dir, project_root)
 
     if state == "true":

package/skill/skills/prerequisite-gate/SKILL.md

@@ -9,13 +9,12 @@ description: Run and persist Cadence prerequisite checks for Python availability
 2. Resolve project root by running `python3 ../../scripts/resolve-project-root.py --require-cadence` and store stdout in `PROJECT_ROOT`.
 3. Resolve helper scripts dir by running `python3 ../../scripts/resolve-project-scripts-dir.py --project-root "$PROJECT_ROOT"` and store stdout in `CADENCE_SCRIPTS_DIR`.
 4. Run `python3 "$CADENCE_SCRIPTS_DIR/check-project-repo-status.py" --project-root "$PROJECT_ROOT"` and parse the JSON output. Treat `repo_enabled` as the authoritative push mode (`false` means local-only commits).
-5. Run `python3 "$CADENCE_SCRIPTS_DIR/assert-workflow-route.py" --skill-name prerequisite-gate --project-root "$PROJECT_ROOT"` and parse the JSON response.
-6. If route assertion fails, stop and surface the exact error to the user.
-7. Run `python3 "$CADENCE_SCRIPTS_DIR/run-prerequisite-gate.py" --project-root "$PROJECT_ROOT"`.
-8. If the script reports `MISSING_PYTHON3`, stop and ask the user for confirmation to install prerequisites.
-9. Do not continue Cadence lifecycle or delivery execution while prerequisites are missing.
-10. At end of this successful skill conversation, run `cd "$PROJECT_ROOT" && python3 "$CADENCE_SCRIPTS_DIR/finalize-skill-checkpoint.py" --scope prerequisite-gate --checkpoint prerequisites-passed --paths .`.
-11. If `finalize-skill-checkpoint.py` returns `status=no_changes`, continue without failure.
-12. If `finalize-skill-checkpoint.py` reports an error, stop and surface it verbatim.
-13. Surface script failures verbatim instead of adding custom fallback logic.
-14. In normal user-facing updates, share the prerequisite outcome without raw command traces or internal routing details unless explicitly requested.
+5. Run `python3 "$CADENCE_SCRIPTS_DIR/run-prerequisite-gate.py" --project-root "$PROJECT_ROOT" --scripts-dir "$CADENCE_SCRIPTS_DIR"`.
+6. `run-prerequisite-gate.py` performs workflow route assertion internally; if assertion fails, stop and surface the exact error.
+7. If the script reports `MISSING_PYTHON3`, stop and ask the user for confirmation to install prerequisites.
+8. Do not continue Cadence lifecycle or delivery execution while prerequisites are missing.
+9. At end of this successful skill conversation, run `cd "$PROJECT_ROOT" && python3 "$CADENCE_SCRIPTS_DIR/finalize-skill-checkpoint.py" --scope prerequisite-gate --checkpoint prerequisites-passed --paths .`.
+10. If `finalize-skill-checkpoint.py` returns `status=no_changes`, continue without failure.
+11. If `finalize-skill-checkpoint.py` reports an error, stop and surface it verbatim.
+12. Surface script failures verbatim instead of adding custom fallback logic.
+13. In normal user-facing updates, share the prerequisite outcome without raw command traces or internal routing details unless explicitly requested.

package/skill/skills/prerequisite-gate/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
   display_name: "Prerequisite Gate"
   short_description: "Run and persist Cadence prerequisite checks for Python availability"
-  default_prompt: "Run Cadence prerequisite checks, verify Python availability, and persist pass state before lifecycle or delivery execution. Resolve PROJECT_ROOT first with scripts/resolve-project-root.py --require-cadence, then resolve CADENCE_SCRIPTS_DIR with scripts/resolve-project-scripts-dir.py --project-root \"$PROJECT_ROOT\". Run scripts/check-project-repo-status.py --project-root \"$PROJECT_ROOT\" and treat repo_enabled as the authoritative push mode (false means local-only commits). Before running prerequisite actions, assert route with scripts/assert-workflow-route.py --skill-name prerequisite-gate --project-root \"$PROJECT_ROOT\" and stop on mismatch. Execute checkpoint commit commands from PROJECT_ROOT so git operations target the active project. At end of a successful prerequisite conversation, run scripts/finalize-skill-checkpoint.py from PROJECT_ROOT with --scope prerequisite-gate --checkpoint prerequisites-passed --paths .; allow status=no_changes and treat checkpoint or push failures as blocking errors surfaced verbatim. Keep user-facing messages focused on prerequisite outcomes and avoid internal command/routing traces unless explicitly requested."
+  default_prompt: "Run Cadence prerequisite checks, verify Python availability, and persist pass state before lifecycle or delivery execution. Resolve PROJECT_ROOT first with scripts/resolve-project-root.py --require-cadence, then resolve CADENCE_SCRIPTS_DIR with scripts/resolve-project-scripts-dir.py --project-root \"$PROJECT_ROOT\". Run scripts/check-project-repo-status.py --project-root \"$PROJECT_ROOT\" and treat repo_enabled as the authoritative push mode (false means local-only commits). Run scripts/run-prerequisite-gate.py --project-root \"$PROJECT_ROOT\" --scripts-dir \"$CADENCE_SCRIPTS_DIR\" (this command performs route assertion internally) and stop on mismatch. Execute checkpoint commit commands from PROJECT_ROOT so git operations target the active project. At end of a successful prerequisite conversation, run scripts/finalize-skill-checkpoint.py from PROJECT_ROOT with --scope prerequisite-gate --checkpoint prerequisites-passed --paths .; allow status=no_changes and treat checkpoint or push failures as blocking errors surfaced verbatim. Keep user-facing messages focused on prerequisite outcomes and avoid internal command/routing traces unless explicitly requested."

package/skill/skills/scaffold/SKILL.md

@@ -6,30 +6,27 @@ description: Initialize Cadence project scaffolding for first-time setup. Use wh
 # Scaffold
 
 1. Resolve project root by running `python3 ../../scripts/resolve-project-root.py` and store stdout in `PROJECT_ROOT`.
-2. Run `python3 ../../scripts/assert-workflow-route.py --skill-name scaffold --project-root "$PROJECT_ROOT"` and parse the JSON response.
-3. If route assertion fails, stop and surface the exact error to the user.
-4. Run `python3 ../../scripts/run-scaffold-gate.py --project-root "$PROJECT_ROOT"` (resolve this relative path from this sub-skill directory) and parse the JSON response.
-5. If the script errors, stop and surface the exact error to the user.
-6. Resolve helper scripts dir by running `python3 ../../scripts/resolve-project-scripts-dir.py --project-root "$PROJECT_ROOT"` and store stdout in `CADENCE_SCRIPTS_DIR`.
-7. Run `python3 "$CADENCE_SCRIPTS_DIR/check-project-repo-status.py" --project-root "$PROJECT_ROOT"` and parse the JSON output. Treat `repo_enabled` as the authoritative push mode (`false` means local-only commits).
-8. If `repo_enabled` is false, ask the user: `No GitHub remote is configured yet. Do you want to initialize a GitHub repo now? (yes/no)`.
-9. If the user answers yes:
+2. Run `python3 ../../scripts/run-scaffold-gate.py --project-root "$PROJECT_ROOT"` (resolve this relative path from this sub-skill directory) and parse the JSON response.
+3. `run-scaffold-gate.py` performs workflow route assertion internally; if it errors, stop and surface the exact error to the user.
+4. Resolve helper scripts dir by running `python3 ../../scripts/resolve-project-scripts-dir.py --project-root "$PROJECT_ROOT"` and store stdout in `CADENCE_SCRIPTS_DIR`.
+5. Run `python3 "$CADENCE_SCRIPTS_DIR/check-project-repo-status.py" --project-root "$PROJECT_ROOT"` and parse the JSON output. Treat `repo_enabled` as the authoritative push mode (`false` means local-only commits).
+6. If `repo_enabled` is false, ask the user: `No GitHub remote is configured yet. Do you want to initialize a GitHub repo now? (yes/no)`.
+7. If the user answers yes:
    - If `git_initialized` is false, run `cd "$PROJECT_ROOT" && git init`.
    - Ask for repo name and visibility, then run `cd "$PROJECT_ROOT" && gh repo create <name> --source . --remote origin --<public|private>`.
    - Rerun `python3 "$CADENCE_SCRIPTS_DIR/check-project-repo-status.py" --project-root "$PROJECT_ROOT"` and verify `repo_enabled` is true.
    - If repo setup still fails, stop and surface the exact failure to the user.
-10. If the user answers no:
+8. If the user answers no:
    - If `git_initialized` is false, run `cd "$PROJECT_ROOT" && git init` so local commits can be stored.
-   - Run `python3 "$CADENCE_SCRIPTS_DIR/check-project-repo-status.py" --project-root "$PROJECT_ROOT" --set-local-only` to persist `state.repo-enabled=false`.
-   - Continue in local-only commit mode until the user configures a GitHub repo later.
-11. Ask the user: `Do you want .cadence tracked in git history? (yes/no)`.
-12. If the user answers yes:
+   - Keep local-only mode (`state.repo-enabled=false`) and continue until the user configures a GitHub repo later.
+9. Ask the user: `Do you want .cadence tracked in git history? (yes/no)`.
+10. If the user answers yes:
    - Run `cd "$PROJECT_ROOT" && python3 "$CADENCE_SCRIPTS_DIR/configure-cadence-gitignore.py" --mode track`.
    - At end of this skill conversation, run `cd "$PROJECT_ROOT" && python3 "$CADENCE_SCRIPTS_DIR/finalize-skill-checkpoint.py" --scope scaffold --checkpoint cadence-tracked --paths .`.
-13. If the user answers no:
+11. If the user answers no:
    - Run `cd "$PROJECT_ROOT" && python3 "$CADENCE_SCRIPTS_DIR/configure-cadence-gitignore.py" --mode ignore`.
    - At end of this skill conversation, run `cd "$PROJECT_ROOT" && python3 "$CADENCE_SCRIPTS_DIR/finalize-skill-checkpoint.py" --scope scaffold --checkpoint cadence-ignored --paths .`.
-14. If `finalize-skill-checkpoint.py` returns `status=no_changes`, continue without failure.
-15. If `finalize-skill-checkpoint.py` reports an error, stop and surface it verbatim.
-16. Execute scaffold actions serially. Do not run this flow in parallel with other setup gates.
-17. In user-facing replies, summarize only the result. Do not expose internal command lines, skill chains, or execution traces unless explicitly requested.
+12. If `finalize-skill-checkpoint.py` returns `status=no_changes`, continue without failure.
+13. If `finalize-skill-checkpoint.py` reports an error, stop and surface it verbatim.
+14. Execute scaffold actions serially. Do not run this flow in parallel with other setup gates.
+15. In user-facing replies, summarize only the result. Do not expose internal command lines, skill chains, or execution traces unless explicitly requested.

package/skill/skills/scaffold/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
   display_name: "Scaffold"
   short_description: "Initialize Cadence project scaffolding for first-time setup"
-  default_prompt: "Initialize Cadence project scaffolding in the target project root, creating .cadence state files only when they do not already exist. Resolve PROJECT_ROOT first with scripts/resolve-project-root.py, then resolve CADENCE_SCRIPTS_DIR with scripts/resolve-project-scripts-dir.py --project-root \"$PROJECT_ROOT\". Before running scaffold actions, assert route with scripts/assert-workflow-route.py --skill-name scaffold --project-root \"$PROJECT_ROOT\" and stop on mismatch. Run scripts/check-project-repo-status.py --project-root \"$PROJECT_ROOT\" and treat repo_enabled as the authoritative push mode (false means local-only commits). Execute git/state-changing scaffold commands from PROJECT_ROOT so commits and .cadence updates target the correct repository. At end of a successful scaffold conversation, run scripts/finalize-skill-checkpoint.py from PROJECT_ROOT with --paths . and scope/checkpoint aligned to the selected .cadence policy (scaffold/cadence-tracked for track mode, scaffold/cadence-ignored for ignore mode); allow status=no_changes and treat checkpoint or push failures as blocking errors surfaced verbatim. In user-facing replies, summarize outcome only and avoid internal command or routing traces unless explicitly requested."
+  default_prompt: "Initialize Cadence project scaffolding in the target project root, creating .cadence state files only when they do not already exist. Resolve PROJECT_ROOT first with scripts/resolve-project-root.py, then run scripts/run-scaffold-gate.py --project-root \"$PROJECT_ROOT\" (this command performs route assertion internally). Next resolve CADENCE_SCRIPTS_DIR with scripts/resolve-project-scripts-dir.py --project-root \"$PROJECT_ROOT\" and run scripts/check-project-repo-status.py --project-root \"$PROJECT_ROOT\"; treat repo_enabled as the authoritative push mode (false means local-only commits). Rerun scripts/check-project-repo-status.py only after creating a GitHub remote to confirm repo_enabled=true. If the user chooses local-only mode, do not run an extra repo-status write pass just to persist false. Execute git/state-changing scaffold commands from PROJECT_ROOT so commits and .cadence updates target the correct repository. At end of a successful scaffold conversation, run scripts/finalize-skill-checkpoint.py from PROJECT_ROOT with --paths . and scope/checkpoint aligned to the selected .cadence policy (scaffold/cadence-tracked for track mode, scaffold/cadence-ignored for ignore mode); allow status=no_changes and treat checkpoint or push failures as blocking errors surfaced verbatim. In user-facing replies, summarize outcome only and avoid internal command or routing traces unless explicitly requested."