prizmkit 1.1.117 → 1.1.119

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.117",
-  "bundledAt": "2026-07-09T14:16:53.861Z",
-  "bundledFrom": "7699f61"
+  "frameworkVersion": "1.1.119",
+  "bundledAt": "2026-07-09T15:35:51.674Z",
+  "bundledFrom": "8a729da"
 }

package/bundled/dev-pipeline/prizmkit_runtime/gitops.py

@@ -33,12 +33,13 @@ HIDDEN_TOOL_WORKTREE_EXCLUDES = (
     ":(top,exclude).prizmkit/manifest.json",
     ":(top,exclude).prizmkit/state",
     ":(top,exclude,glob).prizmkit/state/**",
-    ":(top,exclude).prizmkit/dev-pipeline/scripts",
-    ":(top,exclude,glob).prizmkit/dev-pipeline/scripts/**",
-    ":(top,exclude).prizmkit/dev-pipeline/prizmkit_runtime",
-    ":(top,exclude,glob).prizmkit/dev-pipeline/prizmkit_runtime/**",
+    ":(top,exclude).prizmkit/dev-pipeline",
+    ":(top,exclude,glob).prizmkit/dev-pipeline/**",
 )
 
+PIPELINE_FALLBACK_GIT_NAME = "PrizmKit Pipeline"
+PIPELINE_FALLBACK_GIT_EMAIL = "prizmkit-pipeline@example.invalid"
+
 WORKTREE_PLATFORM_SUPPORT_DIRS = (".claude", ".codebuddy", ".codex", ".agents")
 WORKTREE_ROOT_SUPPORT_FILES = ("skills-lock.json", "AGENTS.md")
 WORKTREE_PRIZMKIT_SUPPORT_ENTRIES = ("prizm-docs", "config.json", "manifest.json")
@@ -640,17 +641,60 @@ def branch_ensure_return(project_root: Path, base_branch: str, working_branch: s
     context = BranchContext(base_branch=base_branch, working_branch=working_branch or active, project_root=project_root)
     return run_git_plan(project_root, branch_ensure_return_plan(context))
 
+
+def _git_config_has_value(project_root: Path, key: str) -> bool:
+    completed = subprocess.run(
+        ["git", "-C", str(project_root), "config", "--get", key],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        check=False,
+    )
+    return completed.returncode == 0 and bool(completed.stdout.strip())
+
+
+def _identity_value_available(project_root: Path, config_key: str, author_env: str, committer_env: str) -> bool:
+    return _git_config_has_value(project_root, config_key) or bool(
+        os.environ.get(author_env) and os.environ.get(committer_env)
+    )
+
+
+def _commit_identity_global_args(project_root: Path) -> tuple[str, ...]:
+    global_args: list[str] = []
+    if not _identity_value_available(project_root, "user.name", "GIT_AUTHOR_NAME", "GIT_COMMITTER_NAME"):
+        global_args.extend(("-c", f"user.name={PIPELINE_FALLBACK_GIT_NAME}"))
+    if not _identity_value_available(project_root, "user.email", "GIT_AUTHOR_EMAIL", "GIT_COMMITTER_EMAIL"):
+        global_args.extend(("-c", f"user.email={PIPELINE_FALLBACK_GIT_EMAIL}"))
+    return tuple(global_args)
+
+
+def _commit_args_without_signing(args: tuple[str, ...]) -> tuple[str, ...]:
+    explicit_signing = any(
+        arg == "-S" or arg.startswith("-S") or arg == "--gpg-sign" or arg.startswith("--gpg-sign=")
+        for arg in args[1:]
+    )
+    if explicit_signing or "--no-gpg-sign" in args:
+        return args
+    return ("commit", "--no-gpg-sign", *args[1:])
+
+
 def run_git_command(project_root: Path, args: Sequence[str]) -> GitCommandResult:
     """Run one git command in a project root and capture output."""
+    command_args = tuple(map(str, args))
+    global_args: tuple[str, ...] = ()
+    executable_args = command_args
+    if command_args and command_args[0] == "commit":
+        global_args = _commit_identity_global_args(project_root)
+        executable_args = _commit_args_without_signing(command_args)
     completed = subprocess.run(
-        ["git", "-C", str(project_root), *map(str, args)],
+        ["git", *global_args, "-C", str(project_root), *executable_args],
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
         text=True,
         check=False,
     )
     return GitCommandResult(
-        args=tuple(map(str, args)),
+        args=command_args,
         return_code=completed.returncode,
         stdout=completed.stdout,
         stderr=completed.stderr,

package/bundled/dev-pipeline/prizmkit_runtime/runner_bookkeeping.py

@@ -46,18 +46,27 @@ def _visible_status_result(project_root: Path) -> GitCommandResult:
     return run_git_command(project_root, ("status", "--porcelain", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES))
 
 
+def _paths_from_status(stdout: str) -> tuple[str, ...]:
+    changed: list[str] = []
+    seen: set[str] = set()
+    for line in stdout.splitlines():
+        if len(line) < 4:
+            continue
+        path = line[3:].strip()
+        paths = path.split(" -> ", 1) if " -> " in path else [path]
+        for candidate in paths:
+            candidate = candidate.strip()
+            if candidate and candidate not in seen:
+                changed.append(candidate)
+                seen.add(candidate)
+    return tuple(changed)
+
+
 def _changed_paths_in(project_root: Path, paths: Sequence[str]) -> tuple[str, ...]:
     result = run_git_command(project_root, ("status", "--porcelain", "--", *paths))
     if result.return_code != 0:
         return ()
-    changed: list[str] = []
-    for line in result.stdout.splitlines():
-        path = line[3:].strip()
-        if " -> " in path:
-            path = path.split(" -> ", 1)[1].strip()
-        if path:
-            changed.append(path)
-    return tuple(changed)
+    return _paths_from_status(result.stdout)
 
 
 def commit_bookkeeping_changes(
@@ -80,14 +89,15 @@ def commit_preflight_ready_changes(project_root: Path, item_id: str) -> Bookkeep
     visible_status = _visible_status_result(project_root)
     if visible_status.return_code != 0:
         return BookkeepingResult(attempted=True, committed=False, result=visible_status)
-    if not visible_status.stdout.strip():
+    paths = _paths_from_status(visible_status.stdout)
+    if not paths:
         return BookkeepingResult(attempted=False, committed=False)
-    add_result = run_git_command(project_root, ("add", "-A", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES))
+    add_result = run_git_command(project_root, ("add", "-A", "-f", "--", *paths))
     if add_result.return_code != 0:
         return BookkeepingResult(attempted=True, committed=False, result=add_result)
     result = run_git_command(
         project_root,
-        ("commit", "--no-verify", "-m", f"chore: ready for {item_id}", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES),
+        ("commit", "--no-verify", "-m", f"chore: ready for {item_id}", "--", *paths),
     )
     if result.return_code != 0:
         return BookkeepingResult(attempted=True, committed=False, result=result)

package/bundled/dev-pipeline/tests/test_python_runner_parity.py

@@ -1570,14 +1570,29 @@ def test_no_worktree_interrupt_saves_wip_and_returns_to_base(monkeypatch, tmp_pa
     assert ensure_calls == [("main", "dev/F-001-interrupt")]
 
 
-def _init_bookkeeping_repo(project_root):
+def _init_bookkeeping_repo(project_root, *, configure_identity=True):
     subprocess.run(["git", "init", "-b", "main"], cwd=project_root, check=True, stdout=subprocess.DEVNULL)
-    subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=project_root, check=True)
-    subprocess.run(["git", "config", "user.name", "Test"], cwd=project_root, check=True)
+    if configure_identity:
+        subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=project_root, check=True)
+        subprocess.run(["git", "config", "user.name", "Test"], cwd=project_root, check=True)
     (project_root / "staged.txt").write_text("base staged\n", encoding="utf-8")
     (project_root / "unstaged.txt").write_text("base unstaged\n", encoding="utf-8")
     subprocess.run(["git", "add", "staged.txt", "unstaged.txt"], cwd=project_root, check=True)
-    subprocess.run(["git", "commit", "-m", "base"], cwd=project_root, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(
+        [
+            "git",
+            "-c",
+            "user.email=test@example.com",
+            "-c",
+            "user.name=Test",
+            "commit",
+            "-m",
+            "base",
+        ],
+        cwd=project_root,
+        check=True,
+        stdout=subprocess.DEVNULL,
+    )
 
 
 def _head_commit_count(project_root):
@@ -1754,6 +1769,69 @@ def test_process_item_creates_one_ready_commit_before_branch_setup_for_mixed_vis
 
 
 
+def test_process_item_ready_commit_uses_fallback_identity_before_branch_setup(monkeypatch, tmp_path):
+    from prizmkit_runtime import runner_bookkeeping, runners
+    from prizmkit_runtime.gitops import HIDDEN_TOOL_WORKTREE_EXCLUDES, PIPELINE_FALLBACK_GIT_EMAIL, PIPELINE_FALLBACK_GIT_NAME
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    monkeypatch.setenv("GIT_CONFIG_GLOBAL", str(tmp_path / "missing-global-gitconfig"))
+    monkeypatch.setenv("GIT_CONFIG_NOSYSTEM", "1")
+    for key in ("GIT_AUTHOR_NAME", "GIT_AUTHOR_EMAIL", "GIT_COMMITTER_NAME", "GIT_COMMITTER_EMAIL"):
+        monkeypatch.delenv(key, raising=False)
+    paths = _make_paths(tmp_path)
+    _init_bookkeeping_repo(paths.project_root, configure_identity=False)
+    (paths.project_root / "new-visible.txt").write_text("dirty before run\n", encoding="utf-8")
+    before_count = _head_commit_count(paths.project_root)
+    branch_events = []
+
+    monkeypatch.setenv("DEV_BRANCH", "dev/F-001-ready-no-identity")
+    family = family_for("feature", paths)
+    invocation = parse_invocation(family, "run", ())
+    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
+    _install_runner_session_fakes(monkeypatch, runners)
+    monkeypatch.setattr(runners, "commit_preflight_ready_changes", runner_bookkeeping.commit_preflight_ready_changes)
+
+    def fake_run_git_plan(project_root, plan):
+        if plan.name == "branch_create":
+            author = subprocess.run(
+                ["git", "log", "-1", "--format=%an <%ae>"],
+                cwd=project_root,
+                check=True,
+                stdout=subprocess.PIPE,
+                text=True,
+            ).stdout.strip()
+            branch_events.append(
+                {
+                    "commit_count": _head_commit_count(project_root),
+                    "message": _head_message(project_root),
+                    "author": author,
+                    "visible_status": subprocess.run(
+                        ["git", "status", "--porcelain", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES],
+                        cwd=project_root,
+                        check=True,
+                        stdout=subprocess.PIPE,
+                        text=True,
+                    ).stdout,
+                }
+            )
+        return SimpleNamespace(ok=True, plan=plan, results=())
+
+    monkeypatch.setattr(runners, "run_git_plan", fake_run_git_plan)
+
+    status = runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
+
+    assert status == "completed"
+    assert branch_events == [
+        {
+            "commit_count": before_count + 1,
+            "message": "chore: ready for F-001",
+            "author": f"{PIPELINE_FALLBACK_GIT_NAME} <{PIPELINE_FALLBACK_GIT_EMAIL}>",
+            "visible_status": "",
+        }
+    ]
+    assert "new-visible.txt" in _head_files(paths.project_root)
+
+
 def test_bookkeeping_commits_only_runner_owned_paths(tmp_path):
     from prizmkit_runtime.runner_bookkeeping import commit_final_bookkeeping
     from prizmkit_runtime.runner_models import RunnerFamily

package/bundled/dev-pipeline/tests/test_unified_cli.py

@@ -1771,19 +1771,35 @@ def test_git_status_safe_ignores_worktree_support_assets(monkeypatch, tmp_path):
     joined = " ".join(status_args)
     assert ":(top,exclude).prizmkit-worktree" in status_args
     assert ":(top,exclude).claude" in status_args
-    assert ":(top,exclude).prizmkit/dev-pipeline/scripts" in status_args
+    assert ":(top,exclude).prizmkit/dev-pipeline" in status_args
+    assert ":(top,exclude,glob).prizmkit/dev-pipeline/**" in status_args
     assert all(exclude in status_args for exclude in HIDDEN_TOOL_WORKTREE_EXCLUDES)
     assert ".prizmkit-worktree" in joined
 
 
-def _init_temp_repo(repo):
+def _init_temp_repo(repo, *, configure_identity=True):
     repo.mkdir(parents=True, exist_ok=True)
     subprocess.run(["git", "init", "-b", "main"], cwd=repo, check=True, stdout=subprocess.DEVNULL)
-    subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=repo, check=True)
-    subprocess.run(["git", "config", "user.name", "Test"], cwd=repo, check=True)
+    if configure_identity:
+        subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=repo, check=True)
+        subprocess.run(["git", "config", "user.name", "Test"], cwd=repo, check=True)
     (repo / "base.txt").write_text("base\n", encoding="utf-8")
     subprocess.run(["git", "add", "base.txt"], cwd=repo, check=True)
-    subprocess.run(["git", "commit", "-m", "base"], cwd=repo, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(
+        [
+            "git",
+            "-c",
+            "user.email=test@example.com",
+            "-c",
+            "user.name=Test",
+            "commit",
+            "-m",
+            "base",
+        ],
+        cwd=repo,
+        check=True,
+        stdout=subprocess.DEVNULL,
+    )
 
 
 def _head_commit_message(repo):
@@ -1915,6 +1931,54 @@ def test_preflight_ready_commit_excludes_ignored_tool_worktree_directories(tmp_p
     assert (repo / ".cache" / "worktrees" / "agent" / "artifact.txt").is_file()
 
 
+def test_preflight_ready_commit_preserves_dirty_changes_without_repo_git_identity(tmp_path, monkeypatch):
+    from prizmkit_runtime.gitops import PIPELINE_FALLBACK_GIT_EMAIL, PIPELINE_FALLBACK_GIT_NAME
+    from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
+
+    repo = tmp_path / "repo"
+    monkeypatch.setenv("GIT_CONFIG_GLOBAL", str(tmp_path / "missing-global-gitconfig"))
+    monkeypatch.setenv("GIT_CONFIG_NOSYSTEM", "1")
+    for key in ("GIT_AUTHOR_NAME", "GIT_AUTHOR_EMAIL", "GIT_COMMITTER_NAME", "GIT_COMMITTER_EMAIL"):
+        monkeypatch.delenv(key, raising=False)
+    _init_temp_repo(repo, configure_identity=False)
+    (repo / "visible.txt").write_text("dirty\n", encoding="utf-8")
+
+    result = commit_preflight_ready_changes(repo, "F-007")
+    author = subprocess.run(
+        ["git", "log", "-1", "--format=%an <%ae>"],
+        cwd=repo,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.strip()
+
+    assert result.committed
+    assert _head_commit_message(repo) == "chore: ready for F-007"
+    assert _head_files(repo) == {"visible.txt"}
+    assert author == f"{PIPELINE_FALLBACK_GIT_NAME} <{PIPELINE_FALLBACK_GIT_EMAIL}>"
+    assert _short_status(repo) == ""
+
+
+def test_preflight_ready_commit_force_stages_visible_file_when_prizmkit_dir_is_ignored(tmp_path):
+    from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
+
+    repo = tmp_path / "repo"
+    _init_temp_repo(repo)
+    (repo / ".gitignore").write_text(".prizmkit/*\n", encoding="utf-8")
+    subprocess.run(["git", "add", ".gitignore"], cwd=repo, check=True)
+    subprocess.run(["git", "commit", "-m", "ignore prizmkit"], cwd=repo, check=True, stdout=subprocess.DEVNULL)
+    (repo / ".prizmkit" / "dev-pipeline" / "templates").mkdir(parents=True)
+    (repo / ".prizmkit" / "dev-pipeline" / "templates" / "bootstrap-prompt.md").write_text("ignored runtime\n", encoding="utf-8")
+    (repo / "visible.txt").write_text("dirty\n", encoding="utf-8")
+
+    result = commit_preflight_ready_changes(repo, "F-008")
+
+    assert result.committed
+    assert _head_commit_message(repo) == "chore: ready for F-008"
+    assert _head_files(repo) == {"visible.txt"}
+    assert _short_status(repo) == ""
+
+
 def test_materialize_worktree_support_assets_copies_ignored_assets_without_retired_shell_sources(tmp_path):
     from prizmkit_runtime.gitops import (
         BranchContext,

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.117",
+  "version": "1.1.119",
   "skills": {
     "prizmkit": {
       "description": "Full-lifecycle dev toolkit. Covers spec-driven development, Prizm context docs, code quality, debugging, deployment, and knowledge management.",

package/bundled/skills/bugfix-pipeline-launcher/SKILL.md

@@ -46,13 +46,15 @@ Before any action, validate:
 
 1. **bugfix pipeline exists**: Confirm `.prizmkit/dev-pipeline/cli.py` is present
 2. **For start**: `.prizmkit/plans/bug-fix-list.json` must exist in `.prizmkit/plans/` (or user-specified path)
-3. **Dependencies**: `python3`, `git`, and AI CLI (`cbc` or `claude`) must be in PATH
+3. **Dependencies**: `python3`, `git`, and the configured AI CLI must be in PATH. Resolve and report the AI CLI from `AI_CLI` env, then `.prizmkit/config.json` `ai_cli`, then fallback to `claude` only when neither is configured. Read `${SKILL_DIR}/references/configuration.md` §Configured AI CLI Prerequisite Check before running the AI CLI check.
 4. **Python version**: Requires Python 3.10+ for the unified dev-pipeline runtime
 5. **Browser tools** (optional): If any bug has `browser_interaction` field, check the corresponding tool is available. Bugs may specify `tool: "playwright-cli"`, `tool: "opencli"`, or `tool: "auto"` (AI chooses at runtime).
 
 Quick check:
 ```bash
-command -v python3 && command -v git && (command -v cbc || command -v claude) && echo "All dependencies OK"
+command -v python3 >/dev/null && command -v git >/dev/null && echo "Core dependencies OK"
+# AI CLI check: read `${SKILL_DIR}/references/configuration.md` §Configured AI CLI Prerequisite Check.
+# It must print `Configured AI CLI: <name>` and verify that exact executable.
 # Optional: browser interaction support (check both tools — bugs may use either)
 command -v playwright-cli && echo "playwright-cli OK" || echo "playwright-cli not found (playwright browser verification will be skipped)"
 command -v opencli && echo "opencli OK" || echo "opencli not found (opencli browser verification will be skipped)"

package/bundled/skills/bugfix-pipeline-launcher/references/configuration.md

@@ -2,6 +2,45 @@
 
 Environment variable mappings for the bugfix launcher.
 
+## Configured AI CLI Prerequisite Check
+
+Read this section during launcher prerequisite validation before reporting AI CLI availability.
+
+Runtime AI CLI selection is config-driven. Resolve the executable name in this order:
+1. `AI_CLI` environment variable when set.
+2. `.prizmkit/config.json` `ai_cli` when present.
+3. `claude` fallback only when neither is configured.
+
+Run this quick check from the project root:
+```bash
+command -v python3 >/dev/null && command -v git >/dev/null || { echo "python3 or git missing"; exit 1; }
+AI_CLI="$(
+  python3 - <<'PY'
+import json, os, shlex
+from pathlib import Path
+cli = os.environ.get("AI_CLI", "").strip()
+if not cli:
+    config_path = Path(".prizmkit/config.json")
+    if config_path.is_file():
+        try:
+            data = json.loads(config_path.read_text(encoding="utf-8"))
+            cli = str(data.get("ai_cli") or "").strip()
+        except (OSError, json.JSONDecodeError):
+            cli = ""
+cli = cli or "claude"
+try:
+    print(shlex.split(cli)[0])
+except ValueError:
+    print(cli.split()[0] if cli.split() else "claude")
+PY
+)"
+printf 'Configured AI CLI: %s\n' "$AI_CLI"
+command -v "$AI_CLI" >/dev/null && printf 'AI CLI OK: %s\n' "$(command -v "$AI_CLI")" || { printf 'AI CLI not found: %s\n' "$AI_CLI"; exit 1; }
+echo "All dependencies OK"
+```
+
+Report the configured executable, for example `Configured AI CLI: claude`. Do not report the first arbitrary PATH match such as `cbc` when project config selects a different AI CLI.
+
 ## Environment Variable Mapping
 
 Translating user responses to env vars:
@@ -73,7 +112,7 @@ Note: Bug filter defaults to all bugs. Runtime selects eligible bugs in stable l
 | `.prizmkit/plans/bug-fix-list.json` not found | Tell user to run `bug-planner` skill first |
 | `python3` not installed | Install Python 3.10+ and rerun the Python runtime command |
 | `git` not installed | Install git; the Python runtime uses git for branch/worktree/status operations |
-| `cbc`/`claude` not in PATH | Check AI CLI installation |
+| Configured AI CLI not in PATH | Install the executable selected by `AI_CLI` or `.prizmkit/config.json` `ai_cli`, or update the config to a CLI available in PATH. |
 | Bugfix pipeline already running | Show status, ask if user wants to stop and restart |
 | PID file stale (process dead) | `python3 ./.prizmkit/dev-pipeline/cli.py daemon bugfix start .prizmkit/plans/bug-fix-list.json` auto-cleans, retry start |
 | Launch failed (process died immediately) | Show last 20 lines of log: `python3 ./.prizmkit/dev-pipeline/cli.py daemon bugfix logs --lines 20` |

package/bundled/skills/feature-pipeline-launcher/SKILL.md

@@ -40,13 +40,15 @@ Before any action, validate:
 
 1. **dev-pipeline exists**: Confirm `.prizmkit/dev-pipeline/cli.py` is present
 2. **For start**: `.prizmkit/plans/feature-list.json` must exist in `.prizmkit/plans/` (or user-specified path)
-3. **Dependencies**: `python3`, `git`, and AI CLI (`cbc` or `claude`) must be in PATH
+3. **Dependencies**: `python3`, `git`, and the configured AI CLI must be in PATH. Resolve and report the AI CLI from `AI_CLI` env, then `.prizmkit/config.json` `ai_cli`, then fallback to `claude` only when neither is configured. Read `${SKILL_DIR}/references/configuration.md` §Configured AI CLI Prerequisite Check before running the AI CLI check.
 4. **Python version**: Requires Python 3.10+ for the unified dev-pipeline runtime
 5. **Browser tools** (optional): If any feature has `browser_interaction` field, check the corresponding tool is available. Features may specify `tool: "playwright-cli"`, `tool: "opencli"`, or `tool: "auto"` (AI chooses at runtime).
 
 Quick check:
 ```bash
-command -v python3 && command -v git && (command -v cbc || command -v claude) && echo "All dependencies OK"
+command -v python3 >/dev/null && command -v git >/dev/null && echo "Core dependencies OK"
+# AI CLI check: read `${SKILL_DIR}/references/configuration.md` §Configured AI CLI Prerequisite Check.
+# It must print `Configured AI CLI: <name>` and verify that exact executable.
 # Optional: browser interaction support (check both tools — features may use either)
 command -v playwright-cli && echo "playwright-cli OK" || echo "playwright-cli not found (playwright browser verification will be skipped)"
 command -v opencli && echo "opencli OK" || echo "opencli not found (opencli browser verification will be skipped)"

package/bundled/skills/feature-pipeline-launcher/references/configuration.md

@@ -22,6 +22,45 @@ Asked only when the user chose "Yes" to Advanced config in step 6.
 - xhigh — Extensive reasoning (`PRIZMKIT_EFFORT=xhigh`)
 - max — Maximum reasoning, Claude Code only (`PRIZMKIT_EFFORT=max`)
 
+## Configured AI CLI Prerequisite Check
+
+Read this section during launcher prerequisite validation before reporting AI CLI availability.
+
+Runtime AI CLI selection is config-driven. Resolve the executable name in this order:
+1. `AI_CLI` environment variable when set.
+2. `.prizmkit/config.json` `ai_cli` when present.
+3. `claude` fallback only when neither is configured.
+
+Run this quick check from the project root:
+```bash
+command -v python3 >/dev/null && command -v git >/dev/null || { echo "python3 or git missing"; exit 1; }
+AI_CLI="$(
+  python3 - <<'PY'
+import json, os, shlex
+from pathlib import Path
+cli = os.environ.get("AI_CLI", "").strip()
+if not cli:
+    config_path = Path(".prizmkit/config.json")
+    if config_path.is_file():
+        try:
+            data = json.loads(config_path.read_text(encoding="utf-8"))
+            cli = str(data.get("ai_cli") or "").strip()
+        except (OSError, json.JSONDecodeError):
+            cli = ""
+cli = cli or "claude"
+try:
+    print(shlex.split(cli)[0])
+except ValueError:
+    print(cli.split()[0] if cli.split() else "claude")
+PY
+)"
+printf 'Configured AI CLI: %s\n' "$AI_CLI"
+command -v "$AI_CLI" >/dev/null && printf 'AI CLI OK: %s\n' "$(command -v "$AI_CLI")" || { printf 'AI CLI not found: %s\n' "$AI_CLI"; exit 1; }
+echo "All dependencies OK"
+```
+
+Report the configured executable, for example `Configured AI CLI: claude`. Do not report the first arbitrary PATH match such as `cbc` when project config selects a different AI CLI.
+
 ## Environment Variable Mapping
 
 Translating user responses to env vars:
@@ -55,7 +94,7 @@ Not exposed in interactive menu, pass via `--env`:
 | `.prizmkit/plans/feature-list.json` not found | Tell user to run `feature-planner` skill first |
 | `python3` not installed | Install Python 3.10+ and rerun the Python runtime command |
 | `git` not installed | Install git; the Python runtime uses git for branch/worktree/status operations |
-| `cbc`/`claude` not in PATH | Check AI CLI installation |
+| Configured AI CLI not in PATH | Install the executable selected by `AI_CLI` or `.prizmkit/config.json` `ai_cli`, or update the config to a CLI available in PATH. |
 | Pipeline already running | Show status, ask if user wants to stop and restart |
 | PID file stale (process dead) | `python3 ./.prizmkit/dev-pipeline/cli.py daemon feature start .prizmkit/plans/feature-list.json` auto-cleans, retry start |
 | Launch failed (process died immediately) | Show last 20 lines of log: `python3 ./.prizmkit/dev-pipeline/cli.py daemon feature logs --lines 20` |

package/bundled/skills/refactor-pipeline-launcher/SKILL.md

@@ -47,13 +47,15 @@ Before any action, validate:
 
 1. **refactor pipeline exists**: Confirm `.prizmkit/dev-pipeline/cli.py` is present
 2. **For start**: `.prizmkit/plans/refactor-list.json` must exist in `.prizmkit/plans/` (or user-specified path)
-3. **Dependencies**: `python3`, `git`, and AI CLI (`cbc` or `claude`) must be in PATH
+3. **Dependencies**: `python3`, `git`, and the configured AI CLI must be in PATH. Resolve and report the AI CLI from `AI_CLI` env, then `.prizmkit/config.json` `ai_cli`, then fallback to `claude` only when neither is configured. Read `${SKILL_DIR}/references/configuration.md` §Configured AI CLI Prerequisite Check before running the AI CLI check.
 4. **Python version**: Requires Python 3.10+ for the unified dev-pipeline runtime
 5. **Browser tools** (optional): If any refactor has `browser_interaction` field, check the corresponding tool is available. Refactors may specify `tool: "playwright-cli"`, `tool: "opencli"`, or `tool: "auto"` (AI chooses at runtime).
 
 Quick check:
 ```bash
-command -v python3 && command -v git && (command -v cbc || command -v claude) && echo "All dependencies OK"
+command -v python3 >/dev/null && command -v git >/dev/null && echo "Core dependencies OK"
+# AI CLI check: read `${SKILL_DIR}/references/configuration.md` §Configured AI CLI Prerequisite Check.
+# It must print `Configured AI CLI: <name>` and verify that exact executable.
 # Optional: browser interaction support (check both tools — refactors may use either)
 command -v playwright-cli && echo "playwright-cli OK" || echo "playwright-cli not found (playwright browser verification will be skipped)"
 command -v opencli && echo "opencli OK" || echo "opencli not found (opencli browser verification will be skipped)"

package/bundled/skills/refactor-pipeline-launcher/references/configuration.md

@@ -2,6 +2,45 @@
 
 Environment variable mappings for the refactor launcher.
 
+## Configured AI CLI Prerequisite Check
+
+Read this section during launcher prerequisite validation before reporting AI CLI availability.
+
+Runtime AI CLI selection is config-driven. Resolve the executable name in this order:
+1. `AI_CLI` environment variable when set.
+2. `.prizmkit/config.json` `ai_cli` when present.
+3. `claude` fallback only when neither is configured.
+
+Run this quick check from the project root:
+```bash
+command -v python3 >/dev/null && command -v git >/dev/null || { echo "python3 or git missing"; exit 1; }
+AI_CLI="$(
+  python3 - <<'PY'
+import json, os, shlex
+from pathlib import Path
+cli = os.environ.get("AI_CLI", "").strip()
+if not cli:
+    config_path = Path(".prizmkit/config.json")
+    if config_path.is_file():
+        try:
+            data = json.loads(config_path.read_text(encoding="utf-8"))
+            cli = str(data.get("ai_cli") or "").strip()
+        except (OSError, json.JSONDecodeError):
+            cli = ""
+cli = cli or "claude"
+try:
+    print(shlex.split(cli)[0])
+except ValueError:
+    print(cli.split()[0] if cli.split() else "claude")
+PY
+)"
+printf 'Configured AI CLI: %s\n' "$AI_CLI"
+command -v "$AI_CLI" >/dev/null && printf 'AI CLI OK: %s\n' "$(command -v "$AI_CLI")" || { printf 'AI CLI not found: %s\n' "$AI_CLI"; exit 1; }
+echo "All dependencies OK"
+```
+
+Report the configured executable, for example `Configured AI CLI: claude`. Do not report the first arbitrary PATH match such as `cbc` when project config selects a different AI CLI.
+
 ## Environment Variable Mapping
 
 Translating user responses to env vars:
@@ -38,7 +77,7 @@ Not exposed in interactive menu, pass via `--env`:
 | Test baseline failing | Fix failing tests before starting refactoring — behavior preservation requires a green baseline |
 | `python3` not installed | Install Python 3.10+ and rerun the Python runtime command |
 | `git` not installed | Install git; the Python runtime uses git for branch/worktree/status operations |
-| `cbc`/`claude` not in PATH | Check AI CLI installation |
+| Configured AI CLI not in PATH | Install the executable selected by `AI_CLI` or `.prizmkit/config.json` `ai_cli`, or update the config to a CLI available in PATH. |
 | Refactor pipeline already running | Show status, ask if user wants to stop and restart |
 | PID file stale (process dead) | `python3 ./.prizmkit/dev-pipeline/cli.py daemon refactor start .prizmkit/plans/refactor-list.json` auto-cleans, retry start |
 | Launch failed (process died immediately) | Show last 20 lines of log: `python3 ./.prizmkit/dev-pipeline/cli.py daemon refactor logs --lines 20` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prizmkit",
-  "version": "1.1.117",
+  "version": "1.1.119",
   "description": "Create a new PrizmKit-powered project with clean initialization — no framework dev files, just what you need.",
   "type": "module",
   "bin": {