prizmkit 1.1.104 → 1.1.106

package/bundled/dev-pipeline/templates/sections/directory-convention-agent.md

@@ -1,8 +1,8 @@
 ## PrizmKit Directory Convention
 
 ```
-.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md  ← orchestrator writes Sections 1-4; Dev appends Implementation Log; Reviewer appends Review Notes
+.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md  ← orchestrator writes Sections 1-4 + Implementation Log; Reviewer appends Review Notes
 .prizmkit/specs/{{FEATURE_SLUG}}/plan.md              ← includes Tasks section
 ```
 
-**`context-snapshot.md`** is the shared knowledge base. Orchestrator writes Sections 1-4; Dev appends Implementation Log; Reviewer appends Review Notes. Append-only after initial creation.
+**`context-snapshot.md`** is the shared knowledge base. Orchestrator writes Sections 1-4 and the Implementation Log; Reviewer appends Review Notes. Append-only after initial creation.

package/bundled/dev-pipeline/templates/sections/directory-convention-full.md

@@ -1,9 +1,9 @@
 ## PrizmKit Directory Convention
 
 ```
-.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md  ← orchestrator writes Sections 1-4; Dev appends Implementation Log; Reviewer appends Review Notes
+.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md  ← orchestrator writes Sections 1-4 + Implementation Log; Reviewer appends Review Notes
 .prizmkit/specs/{{FEATURE_SLUG}}/spec.md
 .prizmkit/specs/{{FEATURE_SLUG}}/plan.md              ← includes Tasks section
 ```
 
-**`context-snapshot.md`** is the shared knowledge base. Orchestrator writes Sections 1-4; Dev appends Implementation Log; Reviewer appends Review Notes. This eliminates redundant I/O across all agents.
+**`context-snapshot.md`** is the shared knowledge base. Orchestrator writes Sections 1-4 and the Implementation Log; Reviewer appends Review Notes. This eliminates redundant I/O across review and orchestration phases.

package/bundled/dev-pipeline/templates/sections/phase-implement-agent.md

@@ -22,6 +22,7 @@ grep -c '^\- \[ \]' .prizmkit/specs/{{FEATURE_SLUG}}/plan.md 2>/dev/null || true
 - Implements task-by-task, marking each `[x]` immediately
 - Creates/updates L2 `.prizm` docs when creating new modules
 - Defers scoped/full test execution until after the code-review loop completes
+- Preserves Reviewer/Critic behavior; only the top-level implementation Dev handoff is removed
 - If plan.md has >5 tasks: update checkpoints after every 3 tasks
 
 **3c. Focused checks only (no test gate here)**:

package/bundled/dev-pipeline/templates/sections/phase-implement-full.md

@@ -23,6 +23,7 @@ Save pre-existing failing tests as `BASELINE_FAILURES`.
 - Implements task-by-task, marking each `[x]` immediately
 - Creates/updates L2 `.prizm` docs when creating new modules
 - Defers scoped/full test execution until after the code-review loop completes
+- Preserves Reviewer/Critic behavior; only the top-level implementation Dev handoff is removed
 - If plan.md has >5 tasks: update checkpoints after every 3 tasks
 
 **3c. Focused checks only (no test gate here)**:

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

@@ -8,6 +8,7 @@ from argparse import Namespace
 from pathlib import Path
 
 from generate_bootstrap_prompt import (
+    ACTIVE_AGENT_PROMPTS,
     compute_feature_slug,
     find_feature,
     format_acceptance_criteria,
@@ -21,6 +22,7 @@ from generate_bootstrap_prompt import (
     build_replacements,
     generate_checkpoint_definition,
     merge_checkpoint_state,
+    load_active_agent_prompts,
     load_log_size_section,
     main as generate_bootstrap_main,
 )
@@ -809,6 +811,50 @@ class TestHeadlessRecoveryReframing:
             assert "run `/compact` after" not in rendered
 
 
+class TestDirectOrchestratorImplementationPrompts:
+    def test_active_agent_prompt_loader_excludes_retired_dev_implement_prompt(self):
+        templates_dir = Path("dev-pipeline/templates").resolve()
+
+        replacements = load_active_agent_prompts(str(templates_dir))
+
+        assert "dev-implement.md" not in ACTIVE_AGENT_PROMPTS
+        assert "{{AGENT_PROMPT_DEV_IMPLEMENT}}" not in replacements
+        assert "{{AGENT_PROMPT_CRITIC_PLAN_CHALLENGE}}" in replacements
+        assert (templates_dir / "agent-prompts" / "dev-implement.md").exists() is False
+
+    def test_sections_all_modes_use_direct_orchestrator_implementation(self):
+        sections_dir = Path("dev-pipeline/templates/sections").resolve()
+
+        for mode in ("lite", "standard", "full"):
+            rendered = "\n".join(
+                section for _name, section in assemble_sections(
+                    mode, str(sections_dir), init_done=True, is_resume=False,
+                    critic_enabled=(mode == "full"), browser_enabled=False,
+                )
+            )
+
+            assert "/prizmkit-implement" in rendered
+            assert "orchestrator) execute" in rendered or "Run `/prizmkit-implement`" in rendered
+            assert "Spawn Dev subagent" not in rendered
+            assert "Spawn Dev agent" not in rendered
+            assert "Implement — Dev" not in rendered
+            assert "{{AGENT_PROMPT_DEV_IMPLEMENT}}" not in rendered
+            assert "dev-implement.md" not in rendered
+            assert "Reviewer Agent → filter → Dev Agent fix" in rendered
+
+    def test_legacy_tier_templates_use_direct_orchestrator_implementation(self):
+        for template_name in ("bootstrap-tier2.md", "bootstrap-tier3.md"):
+            rendered = (Path("dev-pipeline/templates") / template_name).read_text(encoding="utf-8")
+
+            assert "/prizmkit-implement" in rendered
+            assert "Implement — Orchestrator Direct" in rendered
+            assert "Spawn Dev subagent" not in rendered
+            assert "Spawn Dev agent" not in rendered
+            assert "Implement — Dev" not in rendered
+            assert "{{AGENT_PROMPT_DEV_IMPLEMENT}}" not in rendered
+            assert "dev-implement.md" not in rendered
+
+
 # ---------------------------------------------------------------------------
 # continuation handoff
 # ---------------------------------------------------------------------------

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

@@ -847,12 +847,24 @@ def test_default_no_worktree_preserves_main_worktree_branch_launch(monkeypatch,
     invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
     observed = _install_runner_session_fakes(monkeypatch, runners)
     plan_names = []
+    branch_events = []
+    lifecycle_order = []
 
     def fake_run_git_plan(project_root, plan):
         plan_names.append(plan.name)
+        if plan.name == "branch_create":
+            lifecycle_order.append("branch_create")
+            branch_events.append(("create", plan.commands[1].args[2]))
+        if plan.name == "branch_merge":
+            branch_events.append(("merge", plan.commands[5].args[2]))
         return SimpleNamespace(ok=True, plan=plan, results=())
 
+    def fake_start_item(*args, **kwargs):
+        lifecycle_order.append("start_item")
+        return SimpleNamespace(ok=True, text="", data={"new_status": "in_progress"})
+
     monkeypatch.setattr(runners, "run_git_plan", fake_run_git_plan)
+    monkeypatch.setattr(runners, "start_item", fake_start_item)
     monkeypatch.setattr(runners, "ensure_linked_worktree", lambda runtime: (_ for _ in ()).throw(AssertionError("worktree setup should not run")), raising=False)
 
     status = runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
@@ -862,6 +874,211 @@ def test_default_no_worktree_preserves_main_worktree_branch_launch(monkeypatch,
     assert observed.prompt_calls[0].get("execution_root") == paths.project_root
     assert "branch_create" in plan_names
     assert "branch_merge" in plan_names
+    assert lifecycle_order[:2] == ["branch_create", "start_item"]
+    assert branch_events == [("create", "dev/F-001-test"), ("merge", "dev/F-001-test")]
+
+
+def test_default_branch_names_keep_timestamp_for_each_runner_family(monkeypatch, tmp_path):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for
+
+    monkeypatch.setattr(runners.time, "strftime", lambda fmt: "20260707010203")
+    paths = _make_paths(tmp_path)
+
+    assert runners._default_branch_name(family_for("feature", paths), "F-001") == "dev/F-001-20260707010203"
+    assert runners._default_branch_name(family_for("bugfix", paths), "B-001") == "bugfix/B-001-20260707010203"
+    assert runners._default_branch_name(family_for("refactor", paths), "R-001") == "refactor/R-001-20260707010203"
+
+
+@pytest.mark.parametrize(
+    ("kind", "item_id", "branch"),
+    [
+        ("feature", "F-001", "dev/F-001-20260707010203"),
+        ("bugfix", "B-001", "bugfix/B-001-20260707010203"),
+        ("refactor", "R-001", "refactor/R-001-20260707010203"),
+    ],
+)
+def test_no_worktree_failure_stays_on_task_branch_without_merge_for_all_families(monkeypatch, tmp_path, kind, item_id, branch):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    monkeypatch.setenv("DEV_BRANCH", branch)
+    paths = _make_paths(tmp_path / kind)
+    family = family_for(kind, paths)
+    invocation = parse_invocation(family, "run", ())
+    plan_path = {"feature": paths.feature_plan, "bugfix": paths.bugfix_plan, "refactor": paths.refactor_plan}[kind]
+    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": plan_path})
+    _install_runner_session_fakes(monkeypatch, runners, statuses=("crashed",), update_status="pending")
+    events = []
+    final_commits = []
+    wip_commits = []
+
+    def fake_run_git_plan(project_root, plan):
+        events.append(plan.name)
+        return SimpleNamespace(ok=True, plan=plan, results=())
+
+    monkeypatch.setattr(runners, "run_git_plan", fake_run_git_plan)
+    monkeypatch.setattr(runners, "branch_ensure_return", lambda project_root, base, task_branch: events.append(("return", base, task_branch)))
+    monkeypatch.setattr(runners, "commit_final_bookkeeping", lambda project_root, family, item_id, status: final_commits.append((project_root, item_id, status)))
+    monkeypatch.setattr(runners, "commit_wip_changes", lambda project_root, family, item_id, status: wip_commits.append((project_root, item_id, status)))
+
+    status = runners._process_item(family, invocation, item_id, paths, initial_metadata={})
+
+    assert status == "pending"
+    assert events[0] == "branch_create"
+    assert "branch_merge" not in events
+    assert events[-1] == ("return", "main", branch)
+    assert final_commits == [(paths.project_root, item_id, "pending")]
+    assert wip_commits == [(paths.project_root, item_id, "pending")]
+
+
+def test_no_worktree_runner_ignores_recovery_side_effect_branch(monkeypatch, tmp_path):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    monkeypatch.delenv("DEV_BRANCH", raising=False)
+    paths = _make_paths(tmp_path)
+    family = family_for("feature", paths)
+    invocation = parse_invocation(family, "run", ())
+    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
+    observed = _install_runner_session_fakes(monkeypatch, runners)
+    branch_names = []
+
+    monkeypatch.setenv("DEV_BRANCH", "dev/F-001-recovery-20260707")
+    monkeypatch.setattr(runners, "current_branch", lambda _root: "dev/F-001-recovery-20260707")
+
+    def fake_run_git_plan(project_root, plan):
+        if plan.name == "branch_create":
+            branch_names.append(plan.commands[1].args[2])
+        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_names and branch_names[0].startswith("dev/F-001-")
+    assert "recovery" not in branch_names[0]
+    assert observed.updates[-1][2]["active_dev_branch"] == branch_names[0]
+    assert observed.updates[-1][2]["base_branch"] == "main"
+
+
+def test_foreground_runner_emits_structured_feature_progress(monkeypatch, tmp_path, capsys):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    monkeypatch.setenv("DEV_BRANCH", "dev/F-001-output")
+    paths = _make_paths(tmp_path)
+    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, "run_git_plan", lambda project_root, plan: SimpleNamespace(ok=True, plan=plan, results=()))
+
+    status = runners._process_item(
+        family,
+        invocation,
+        "F-001",
+        paths,
+        initial_metadata={"title": "Readable output", "retry_count": 1, "infra_error_count": 2},
+    )
+
+    captured = capsys.readouterr()
+    assert status == "completed"
+    assert "────────────────────────────────────────────────────" in captured.err
+    assert "Feature: F-001 — Readable output" in captured.err
+    assert "Code retry: 1 / 3" in captured.err
+    assert "Infrastructure retry: 2 / 3" in captured.err
+    assert "Pipeline mode: lite (Tier 1 — Single Agent)" in captured.err
+    assert "Agents: 1 (critic: disabled)" in captured.err
+    assert "Spawning AI CLI session: F-001-session-1" in captured.err
+    assert "Session result: success" in captured.err
+
+
+def test_no_worktree_interrupt_saves_wip_and_returns_to_base(monkeypatch, tmp_path):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    monkeypatch.setenv("DEV_BRANCH", "dev/F-001-interrupt")
+    paths = _make_paths(tmp_path)
+    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)
+    ensure_calls = []
+    monkeypatch.setattr(runners, "run_git_plan", lambda project_root, plan: SimpleNamespace(ok=True, plan=plan, results=()))
+    monkeypatch.setattr(runners, "branch_ensure_return", lambda project_root, base, branch: ensure_calls.append((base, branch)))
+
+    class InterruptingLauncher:
+        def __init__(self, config):
+            self.config = config
+
+        def run(self):
+            raise KeyboardInterrupt
+
+    monkeypatch.setattr(runners, "AISessionLauncher", InterruptingLauncher)
+
+    with pytest.raises(KeyboardInterrupt):
+        runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
+
+    assert ensure_calls == [("main", "dev/F-001-interrupt")]
+
+
+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
+
+    subprocess.run(["git", "init", "-b", "main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "config", "user.name", "Test"], cwd=tmp_path, check=True)
+    plans = tmp_path / ".prizmkit" / "plans"
+    state = tmp_path / ".prizmkit" / "state" / "features"
+    item_state = state / "F-001"
+    plans.mkdir(parents=True)
+    item_state.mkdir(parents=True)
+    plan = plans / "feature-list.json"
+    plan.write_text('{"features": []}', encoding="utf-8")
+    (item_state / "status.json").write_text("{}", encoding="utf-8")
+    source = tmp_path / "src.txt"
+    source.write_text("base", encoding="utf-8")
+    subprocess.run(["git", "add", ".prizmkit/plans/feature-list.json", ".prizmkit/state/features/F-001/status.json", "src.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "base"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    plan.write_text('{"features": [{"id": "F-001", "status": "completed"}]}', encoding="utf-8")
+    (item_state / "status.json").write_text('{"last_session_id": "s1"}', encoding="utf-8")
+    source.write_text("dirty source change", encoding="utf-8")
+    family = RunnerFamily(
+        kind="feature",
+        id_prefix="F-",
+        list_key="features",
+        list_arg="--feature-list",
+        item_id_arg="--feature-id",
+        state_dir=state,
+        plan_path=plan,
+        updater_script=tmp_path / "update-feature-status.py",
+        prompt_script=tmp_path / "generate-bootstrap-prompt.py",
+        branch_prefix="dev",
+        artifact_root_name="specs",
+    )
+
+    result = commit_final_bookkeeping(tmp_path, family, "F-001", "completed")
+    committed_files = subprocess.run(
+        ["git", "show", "--name-only", "--format=", "HEAD"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.splitlines()
+    dirty_files = subprocess.run(
+        ["git", "status", "--porcelain", "--", "src.txt"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout
+
+    assert result.committed is True
+    assert committed_files == [".prizmkit/plans/feature-list.json", ".prizmkit/state/features/F-001/status.json"]
+    assert dirty_files.startswith(" M src.txt")
 
 
 def test_context_overflow_reuses_worktree_and_skips_cleanup_until_terminal_outcome(monkeypatch, tmp_path):
@@ -891,6 +1108,52 @@ def test_context_overflow_reuses_worktree_and_skips_cleanup_until_terminal_outco
     assert observed.cleanup_calls[0][1] is True
 
 
+def test_classification_accepts_terminal_success_with_completed_checkpoint_without_git_delta(tmp_path):
+    from prizmkit_runtime.runner_classification import classify_session
+    from prizmkit_runtime.runner_models import PromptGenerationResult
+    from prizmkit_runtime.sessions import AISessionCommand, AISessionResult
+    from prizmkit_runtime.status import ProgressSummary
+
+    subprocess.run(["git", "init", "-b", "main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "config", "user.name", "Test"], cwd=tmp_path, check=True)
+    (tmp_path / ".gitignore").write_text(".prizmkit/*\n", encoding="utf-8")
+    (tmp_path / "base.txt").write_text("base", encoding="utf-8")
+    subprocess.run(["git", "add", ".gitignore", "base.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "base"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    base_head = subprocess.run(["git", "rev-parse", "HEAD"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True).stdout.strip()
+    artifact_dir = tmp_path / ".prizmkit" / "specs" / "001-done"
+    artifact_dir.mkdir(parents=True)
+    checkpoint = artifact_dir / "workflow-checkpoint.json"
+    checkpoint.write_text(json.dumps({"steps": [{"id": "S01", "skill": "done", "status": "completed"}]}), encoding="utf-8")
+    (artifact_dir / "completion-summary.json").write_text("{}", encoding="utf-8")
+    log = tmp_path / "session.log"
+    log.write_text("terminal success", encoding="utf-8")
+    raw = AISessionResult(
+        command=AISessionCommand(("fake",), None, "claude", "stdin"),
+        exit_code=0,
+        timed_out=False,
+        termination_reason=None,
+        stale_marker=None,
+        fatal_error_code="",
+        progress_summary=ProgressSummary(result_subtype="success", terminal_result_text="Completed; working tree clean"),
+        session_log=log,
+        backup_log=tmp_path / "backup.log",
+        log_recovery=None,
+        started_epoch=0,
+        ended_epoch=1,
+    )
+    prompt = PromptGenerationResult(
+        output_path=tmp_path / "prompt.md",
+        checkpoint_path=checkpoint,
+        artifact_path=artifact_dir,
+    )
+
+    classification = classify_session(raw, project_root=tmp_path, base_head=base_head, prompt=prompt)
+    assert classification.session_status == "success"
+    assert classification.reason == "terminal_success_with_completed_checkpoint"
+
+
 def test_classification_preserves_success_before_context_overflow(tmp_path):
     from prizmkit_runtime.runner_classification import classify_session
     from prizmkit_runtime.sessions import AISessionCommand, AISessionResult
@@ -929,6 +1192,43 @@ def test_classification_preserves_success_before_context_overflow(tmp_path):
     assert classification.reason == "commit_since_base"
 
 
+def test_classification_crash_with_commit_since_base_does_not_become_success(tmp_path):
+    from prizmkit_runtime.runner_classification import classify_session
+    from prizmkit_runtime.sessions import AISessionCommand, AISessionResult
+    from prizmkit_runtime.status import ProgressSummary
+
+    subprocess.run(["git", "init", "-b", "main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "config", "user.name", "Test"], cwd=tmp_path, check=True)
+    (tmp_path / "base.txt").write_text("base", encoding="utf-8")
+    subprocess.run(["git", "add", "base.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "base"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    base_head = subprocess.run(["git", "rev-parse", "HEAD"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True).stdout.strip()
+    (tmp_path / "done.txt").write_text("done", encoding="utf-8")
+    subprocess.run(["git", "add", "done.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "done"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    log = tmp_path / "session.log"
+    log.write_text("hard failure", encoding="utf-8")
+    raw = AISessionResult(
+        command=AISessionCommand(("fake",), None, "codebuddy", "stdin"),
+        exit_code=1,
+        timed_out=False,
+        termination_reason=None,
+        stale_marker=None,
+        fatal_error_code="",
+        progress_summary=ProgressSummary(terminal_result_text="hard failure"),
+        session_log=log,
+        backup_log=tmp_path / "backup.log",
+        log_recovery=None,
+        started_epoch=0,
+        ended_epoch=1,
+    )
+
+    classification = classify_session(raw, project_root=tmp_path, base_head=base_head)
+    assert classification.session_status == "crashed"
+    assert classification.reason == "exit_code=1"
+
+
 def test_classification_stalls_after_repeated_no_progress_context_overflow(tmp_path):
     from prizmkit_runtime.runner_classification import classify_session, progress_fingerprint
     from prizmkit_runtime.sessions import AISessionCommand, AISessionResult
@@ -964,6 +1264,14 @@ def test_classification_stalls_after_repeated_no_progress_context_overflow(tmp_p
     assert classification.no_progress_count == 2
 
 
+def test_recovery_prompt_keeps_existing_branch_instead_of_recovery_suffix():
+    text = (PIPELINE_ROOT / "scripts" / "generate-recovery-prompt.py").read_text(encoding="utf-8")
+
+    assert "fix/{bug_id}-recovery" not in text
+    assert "do not create an additional" in text
+    assert "last-resort fallback" in text
+
+
 def test_recovery_detector_resolver_prefers_installed_platform_asset(tmp_path):
     from prizmkit_runtime.paths import resolve_runtime_paths
     from prizmkit_runtime.runner_recovery import RecoveryDetectorResolver

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

@@ -853,6 +853,7 @@ def test_git_branch_worktree_plans_preserve_shell_invariants(tmp_path):
     assert ensure.never_fails is True
     assert any(command.args[:2] == ("rebase", "--abort") for command in ensure.commands)
     assert any(command.args[:2] == ("add", "-A") for command in ensure.commands)
+    assert not any(command.args[:2] == ("stash", "pop") for command in ensure.commands)
     assert any(".*/worktrees/**" in " ".join(command.args) for command in save_wip.commands)
     assert worktree.commands[0].args[:2] == ("worktree", "add")
 

package/bundled/skills/_metadata.json

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

package/package.json

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

package/bundled/dev-pipeline/templates/agent-prompts/dev-implement.md

@@ -1,71 +0,0 @@
-"<!-- DEPRECATED (P0-6): This prompt was injected into a Dev subagent spawn.
-The orchestrator now implements directly (see phase-implement-agent.md / phase-implement-full.md).
-This file is retained only so load_agent_prompts() does not break; it is no longer referenced
-by any phase section. Do not add new rules here — add them to the phase-implement-* sections instead.
-The rules below are the legacy Dev-subagent version, kept for reference only. -->
-
-Read {{DEV_SUBAGENT_PATH}}. Implement feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}).
-
-## Task Summary Card
-
-**Objective**: Implement {{FEATURE_TITLE}}.
-
-**Primary files** (see context-snapshot.md Section 4 for full manifest):
-- Review plan.md Tasks section for the complete task-to-file mapping.
-- Each task's `— file:` suffix identifies the target file.
-
-**Test command**: `{{TEST_CMD}}`
-
-**Known baseline failures**: `{{BASELINE_FAILURES}}`
-
-**DO NOT**:
-- Re-read source files already listed in context-snapshot.md Section 4 File Manifest
-- Create new files unless a plan.md task explicitly requires it
-- Run git commands
-- Use mock success data or fake rows in UI/tests
-
-## Required Inputs
-
-1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` first.
-2. Use Section 4 File Manifest for targeted reads.
-3. Do not expand scope beyond the Task Contract and Verification Gates.
-4. Do not re-read source files already listed in Section 4 unless implementation details are missing from the manifest.
-
-## Work
-
-Run `/prizmkit-implement` to execute `plan.md`.
-
-Test command:
-`{{TEST_CMD}}`
-
-Known baseline failures:
-`{{BASELINE_FAILURES}}`
-
-If plan.md has more than 5 tasks, update durable checkpoints/artifacts after every 3 tasks, minimize output, and rely on runner continuation if context overflow occurs. In an interactive Claude Code session operated manually outside the headless pipeline, `/compact` may be used as an optional convenience only.
-
-## Required Outputs
-
-Before returning, append `## Implementation Log` to `context-snapshot.md` with:
-- files changed/created
-- key decisions
-- deviations from plan
-- test results
-- Verification Gate status
-- unresolved blockers, if any
-
-## Protocol References
-
-- Follow the global Context Budget Rules.
-- Carry forward the Dev-isolated subset: skip scaffold/generated files listed in `context-snapshot.md`; verify dependency versions before install/build commands that resolve dependencies; after build/compile commands, ensure outputs are ignored and never commit generated artifacts.
-- If tests fail, follow this Test Failure Recovery subset: classify failures as baseline, new regression, brittle test, or environment/tooling; fix new regressions and brittle tests while progress is being made; document baseline failures; write `failure-log.md` for blockers.
-- Do not run git commands; staging and commit are handled by the orchestrator.
-- **Edit safety**: If an Edit fails with 'String to replace not found', grep for the target text before retrying. Never guess file offsets — verify them with a Read or grep first.
-- **Read safety**: If 3 consecutive Reads to the same file return 'shorter than offset' or 'Wasted call', STOP and report BLOCKED.
-- **Test gate placement**: Do not run mandatory periodic or full-suite tests here. The scoped/full test gate runs after code review; only use tiny targeted checks when needed for local debugging.
-
-Do not return success unless:
-1. implementation tasks are complete;
-2. `## Implementation Log` exists;
-3. every Verification Gate is verified.
-
-If any Verification Gate is blocked, write `failure-log.md` and return a blocked/incomplete result instead of success."