prizmkit 1.1.105 → 1.1.107

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

@@ -659,6 +659,213 @@ def test_session_live_output_prints_paths_and_verbose_cli_output(tmp_path, capsy
     assert "[prizmkit] AI session finished" in captured.err
 
 
+def test_compact_progress_line_includes_stale_and_switches_glyph(tmp_path):
+    from prizmkit_runtime.heartbeat import HeartbeatState
+    from prizmkit_runtime.sessions import _compact_progress_line
+
+    session_log = tmp_path / "session.log"
+    progress = tmp_path / "progress.json"
+    progress.write_text(
+        json.dumps(
+            {
+                "child_total_bytes": 2 * 1024 * 1024,
+                "subagent_spawn_count": 5,
+                "current_phase": "retrospective",
+                "current_tool": "Read",
+                "message_count": 465,
+                "total_tool_calls": 412,
+            }
+        ),
+        encoding="utf-8",
+    )
+    running = HeartbeatState(last_seen_epoch=1.0, stale=False, details="progress", stale_seconds=0, log_size=4 * 1024 * 1024)
+    paused = HeartbeatState(last_seen_epoch=1.0, stale=False, details="no progress", stale_seconds=120, log_size=4 * 1024 * 1024)
+
+    running_line = _compact_progress_line(0, session_log, progress, running, stale_threshold_seconds=15 * 60)
+    paused_line = _compact_progress_line(0, session_log, progress, paused, stale_threshold_seconds=15 * 60)
+
+    assert "▶ [HEARTBEAT]" in running_line
+    assert "log: 4MB" in running_line
+    assert "child: 2MB/5" in running_line
+    assert "phase: retrospective" in running_line
+    assert "tool: Read" in running_line
+    assert "msgs: 465" in running_line
+    assert "412 tool calls" in running_line
+    assert "stale: 0m/15m" in running_line
+    assert "⏸ [HEARTBEAT]" in paused_line
+    assert "stale: 2m/15m" in paused_line
+
+
+def test_heartbeat_observation_stale_accumulates_and_resets_on_progress(tmp_path):
+    from prizmkit_runtime.heartbeat import HeartbeatConfig, observe_heartbeat_state
+
+    session_log = tmp_path / "session.log"
+    progress = tmp_path / "progress.json"
+    session_log.write_text("initial\n", encoding="utf-8")
+    progress.write_text('{"current_phase":"plan","current_tool":"Read","message_count":1,"total_tool_calls":1}\n', encoding="utf-8")
+    config = HeartbeatConfig(
+        heartbeat_file=tmp_path / "heartbeat.json",
+        session_log=session_log,
+        progress_file=progress,
+        interval_seconds=60,
+        stale_after_seconds=15 * 60,
+    )
+
+    first = observe_heartbeat_state(config)
+    stale = observe_heartbeat_state(config, first)
+    progress.write_text('{"current_phase":"plan","current_tool":"Edit","message_count":1,"total_tool_calls":2,"child_total_bytes":10}\n', encoding="utf-8")
+    reset = observe_heartbeat_state(config, stale)
+
+    assert first.details == "progress"
+    assert first.stale_seconds == 0
+    assert stale.details == "no progress"
+    assert stale.stale_seconds == 60
+    assert reset.details == "progress"
+    assert reset.stale_seconds == 0
+
+
+def test_compact_live_heartbeat_stays_out_of_primary_and_backup_logs(tmp_path, capsys, monkeypatch):
+    import prizmkit_runtime.sessions as sessions
+
+    fake_cli = tmp_path / "slow_cli.py"
+    fake_cli.write_text(
+        "#!/usr/bin/env python3\n"
+        "import time\n"
+        "print('logged-payload', flush=True)\n"
+        "time.sleep(0.45)\n",
+        encoding="utf-8",
+    )
+    fake_cli.chmod(0o755)
+    prompt = tmp_path / "prompt.md"
+    prompt.write_text("hello", encoding="utf-8")
+    session_log = tmp_path / "state" / "sessions" / "sess-heartbeat" / "logs" / "session.log"
+    backup_log = tmp_path / "home" / ".prizmkit" / "session-backups" / "sess-heartbeat.log"
+    progress = session_log.with_name("progress.json")
+    backup_text = {}
+    original_recover = sessions.recover_session_log
+
+    def spy_recover(primary, backup, min_size=1024):
+        if backup.is_file():
+            backup_text["content"] = backup.read_text(encoding="utf-8")
+        return original_recover(primary, backup, min_size)
+
+    monkeypatch.setattr(sessions, "recover_session_log", spy_recover)
+    result = sessions.AISessionLauncher(
+        sessions.AISessionConfig(
+            cli_command=str(fake_cli),
+            platform="codebuddy",
+            model=None,
+            prompt_path=prompt,
+            cwd=tmp_path,
+            log_path=session_log,
+            backup_log_path=backup_log,
+            progress_path=progress,
+            live_output=True,
+            live_progress_interval_seconds=0.1,
+            stale_kill_threshold_seconds=15 * 60,
+        )
+    ).run()
+
+    captured = capsys.readouterr()
+    primary_text = session_log.read_text(encoding="utf-8")
+    assert result.exit_code == 0
+    assert "[HEARTBEAT]" in captured.err
+    assert "stale:" in captured.err
+    assert "logged-payload" in primary_text
+    assert "[HEARTBEAT]" not in primary_text
+    assert "stale:" not in primary_text
+    assert "[HEARTBEAT]" not in backup_text.get("content", "")
+    assert "stale:" not in backup_text.get("content", "")
+
+
+def test_recovery_sessions_receive_live_heartbeat_configuration(tmp_path, monkeypatch):
+    import prizmkit_runtime.runner_recovery as runner_recovery
+
+    project = tmp_path / "project"
+    pipeline = tmp_path / "pipeline"
+    recovery_state = tmp_path / "recovery"
+    project.mkdir()
+    pipeline.mkdir()
+    recovery_state.mkdir()
+    paths = type(
+        "Paths",
+        (),
+        {"project_root": project, "pipeline_root": pipeline, "recovery_state_dir": recovery_state},
+    )()
+    captured_config = {}
+
+    monkeypatch.setattr(
+        runner_recovery,
+        "run_recovery_detect",
+        lambda _paths: (0, "{}", "", {"detected": True, "workflow_type": "feature"}),
+    )
+    monkeypatch.setattr(
+        runner_recovery,
+        "load_runtime_config",
+        lambda _paths: type(
+            "Config",
+            (),
+            {
+                "ai_client": type("Client", (), {"command": "fake-cli", "platform": "codebuddy"})(),
+                "model": "model",
+                "effort": "high",
+            },
+        )(),
+    )
+    monkeypatch.setattr(
+        runner_recovery,
+        "RunnerEnvironment",
+        type(
+            "EnvFactory",
+            (),
+            {
+                "from_env": staticmethod(
+                    lambda: type(
+                        "Env",
+                        (),
+                        {
+                            "verbose": True,
+                            "live_output": True,
+                            "heartbeat_interval_seconds": 7,
+                            "stale_kill_threshold_seconds": 42,
+                        },
+                    )()
+                )
+            },
+        ),
+    )
+    monkeypatch.setattr(runner_recovery, "detect_stream_json_support", lambda *_args: type("Support", (), {"enabled": True})())
+    monkeypatch.setattr(
+        runner_recovery.subprocess,
+        "run",
+        lambda *_args, **_kwargs: type("Completed", (), {"returncode": 0, "stdout": "0", "stderr": ""})(),
+    )
+    monkeypatch.setattr(runner_recovery, "_recovery_outcome", lambda *_args: "no_changes")
+
+    class FakeLauncher:
+        def __init__(self, config):
+            captured_config["config"] = config
+
+        def run(self):
+            return type("Result", (), {"exit_code": 0})()
+
+    monkeypatch.setattr(runner_recovery, "AISessionLauncher", FakeLauncher)
+
+    code, stdout, stderr = runner_recovery.run_recovery(paths)
+    config = captured_config["config"]
+
+    assert code == 0
+    assert stdout == "no_changes\n"
+    assert stderr == ""
+    assert config.live_output is True
+    assert config.verbose is True
+    assert config.use_stream_json is True
+    assert config.live_progress_interval_seconds == 7
+    assert config.stale_kill_threshold_seconds == 42
+    assert config.live_banner is False
+    assert config.suppress_stream_output is True
+
+
 def test_session_live_output_does_not_forward_cli_output_without_verbose(tmp_path, capsys):
     from prizmkit_runtime.sessions import AISessionConfig, AISessionLauncher
 
@@ -853,6 +1060,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.105",
+  "version": "1.1.107",
   "skills": {
     "prizm-kit": {
       "description": "Full-lifecycle dev toolkit. Covers spec-driven development, Prizm context docs, code quality, debugging, deployment, and knowledge management.",

package/bundled/skills/prizmkit-code-review/SKILL.md

@@ -1,15 +1,14 @@
 ---
 name: "prizmkit-code-review"
-description: "Iterative review-fix loop against spec and plan. Spawns a read-only Reviewer agent, filters findings, then a Dev agent applies fixes. Loops until PASS (max 3 rounds). Use after /prizmkit-implement as quality gate. Trigger on: 'review', 'check code', 'code review', 'is it ready to commit'. (project)"
+description: "Iterative review-fix loop against spec and plan. Spawns the dedicated prizm-dev-team-reviewer agent, filters findings, then the main orchestrator applies accepted fixes directly. Loops until PASS (max 3 rounds). Use after /prizmkit-implement as quality gate. Trigger on: 'review', 'check code', 'code review', 'is it ready to commit'. (project)"
 ---
 
 # PrizmKit Code Review
 
-An iterative review-fix loop that reviews code changes against the spec and plan, then automatically fixes issues. Uses three separated roles:
+An iterative review-fix loop that reviews code changes against the spec and plan, then automatically fixes accepted issues. Uses two separated roles:
 
-- **Reviewer Agent** (read-only): analyzes git diff against spec goals and plan decisions, produces structured findings
-- **Main Agent** (orchestrator): filters Reviewer findings for reasonableness, coordinates the loop
-- **Dev Agent** (read-write): applies fixes for accepted findings
+- **Reviewer Agent** (`prizm-dev-team-reviewer`, read-only): analyzes orchestrator-provided workspace context against spec goals and plan decisions, then produces structured findings
+- **Main Agent** (orchestrator): filters Reviewer findings for reasonableness, applies accepted fixes directly in the active checkout, and coordinates the loop
 
 The loop repeats until the Reviewer finds no issues or the max round limit is reached.
 
@@ -36,7 +35,7 @@ The loop repeats until the Reviewer finds no issues or the max round limit is re
    - If `{artifact_dir}/test-report-path.txt` exists, read the path, then read that `/prizmkit-test` report.
    - Extract `Scope`, `Generated / Updated Tests`, `In-Scope Failures`, `Baseline Failures`, `Out of Scope Gaps`, `Boundary Matrix` / `Boundary Completion Gate` when present, and `Verdict`.
    - If `context-snapshot.md` contains `## PrizmKit Test Gate`, read that summary too.
-   - If this is a feature artifact under `.prizmkit/specs/` and no test report pointer or summary exists, pass `No scoped /prizmkit-test report found` into the Reviewer context so the reviewer can flag the missing gate.
+   - If this is a feature artifact under `.prizmkit/specs/` and no test report pointer or summary exists, pass `No scoped /prizmkit-test report found (expected for pre-test review)` into the Reviewer context as informational scope context only. Do not ask the Reviewer to report it as a missing gate unless the calling workflow explicitly requires a prior test report.
 4. **Read dev rules** (if configured): If `.prizmkit/prizm-docs/root.prizm` exists, read it and check for a `RULES:` line. If present, read all referenced `.prizmkit/rules/<layer>-rules.md` files. If `root.prizm` or a referenced rules file does not exist, continue with "No custom dev rules configured — use general best practices."
 5. **Capture workspace diff**: run `git diff` (unstaged) + `git diff --cached` (staged) + `git status` to understand the full scope of changes. For new files in git status, note their paths for the Reviewer to read.
    - If no changes are detected, skip Phase 1 and proceed to Phase 2 with verdict PASS, rounds 0, and an empty findings list. Always write `review-report.md`; downstream pipeline steps use it as the review gate.
@@ -64,12 +63,12 @@ The script is stateless — no `--reset` or runtime files. Initialize these valu
 ### Loop Flow
 
 ```
-1. Spawn Reviewer Agent (read-only) → findings or PASS
+1. Spawn Reviewer Agent (`subagent_type: prizm-dev-team-reviewer`) → findings or PASS
 2. Parse result:
    - PASS → Call Loop Exit Gate → Phase 2
    - NEEDS_FIXES → count findings → Step 3 (do not call gate yet)
 3. Main Agent filters findings → Call Loop Exit Gate → if endLoop: Phase 2
-4. Spawn Dev Agent (read-write) → apply fixes
+4. Main Agent applies accepted fixes directly in the active checkout
 5. Increment round and return to Step 1
 ```
 
@@ -116,7 +115,7 @@ When Python is unavailable, apply these rules exactly — they match the script'
 
 ### Step 1: Spawn Reviewer Agent
 
-Include the dev rules read in Phase 0 step 3 in the `## Dev Rules` section of the prompt. Spawn a platform-supported **read-only** reviewer agent; use `subagent_type: Explore` only on platforms that support it. If no read-only agent is available, perform the review in the Main Agent without editing files. Read `${SKILL_DIR}/references/reviewer-agent-prompt.md` for the full prompt template — fill `{goals}`, `{plan decisions}`, `{dev rules}`, `{round N}`, and `{round_context}` before spawning.
+Include the dev rules read in Phase 0 step 4 and the workspace diff/status captured in Phase 0 step 5 in the Reviewer prompt. In Claude Code, spawn the dedicated PrizmKit Reviewer with `subagent_type: prizm-dev-team-reviewer` and `run_in_background=false`. Do not route the PrizmKit reviewer flow through `Explore` or a generic code-explorer agent. If the current platform has no dedicated Reviewer agent, perform the review pass in the Main Agent without editing files during that pass. Read `${SKILL_DIR}/references/reviewer-agent-prompt.md` for the full prompt template — fill `{goals}`, `{plan decisions}`, `{scoped test report}`, `{workspace context}`, `{dev rules}`, `{round N}`, and `{round_context}` before spawning.
 
 Round context varies by round:
 - Round 1: "This is the first review. Examine all changes comprehensively."
@@ -138,16 +137,16 @@ Review each finding and decide whether it's reasonable. This prevents unnecessar
 - Would fixing this improve the code without introducing risk? (Reject fixes that require large refactors outside scope.)
 
 **Output per finding:**
-- **Accepted**: The finding is reasonable — include it in the Dev Agent's task.
+- **Accepted**: The finding is reasonable — queue it for direct Main Agent fix work.
 - **Rejected** (with reason): Brief explanation (e.g., "Out of scope", "Style preference, not a defect").
 
 After filtering: call the **Loop Exit Gate** with `{"reviewer_result": "NEEDS_FIXES", "accepted_count": <N>, "findings_count": <total findings this round>, "round": <current_round>, "findings_history": <current_history>, "max_rounds": 3, "filtering_done": true}`. If `endLoop=true`, proceed to Phase 2.
 
-### Step 4: Spawn Dev Agent
+### Step 4: Main Agent Applies Accepted Fixes
 
-Spawn a platform-supported **read-write** developer agent. If no write-capable agent is available, the Main Agent applies accepted fixes directly. Read `${SKILL_DIR}/references/dev-agent-prompt.md` for the full prompt template — fill `{spec context}` and `{accepted findings}` before spawning.
+Do not spawn a Dev Agent or any review-fix developer subagent. The Main Agent applies accepted findings directly in the active checkout, using the spec context and filtered findings as the fix list. If an accepted finding cannot be safely fixed within scope, record the reason and carry it into `review-report.md` as unresolved.
 
-After the Dev Agent returns, record results and return to Step 1 for the next round.
+After direct fixes are complete, record results and return to Step 1 for the next round.
 
 ## Phase 2: Output
 

package/bundled/skills/prizmkit-code-review/references/reviewer-agent-prompt.md

@@ -1,9 +1,9 @@
 # Reviewer Agent Prompt Template
 
-Used in Phase 1 Step 1 of `/prizmkit-code-review`. The orchestrator fills `{goals}`, `{plan decisions}`, `{dev rules}`, `{round N}`, and `{round_context}` before spawning the Reviewer Agent.
+Used in Phase 1 Step 1 of `/prizmkit-code-review`. The orchestrator fills `{goals}`, `{plan decisions}`, `{scoped test report}`, `{workspace context}`, `{dev rules}`, `{round N}`, and `{round_context}` before spawning the dedicated `prizm-dev-team-reviewer` agent.
 
 ```
-You are a code reviewer. Review workspace changes against the spec goals, plan decisions, and per-layer dev rules.
+You are the dedicated PrizmKit Reviewer agent (`prizm-dev-team-reviewer`). Review workspace changes against the spec goals, plan decisions, scoped test evidence, and per-layer dev rules. Do not modify files and do not apply fixes; the Main Agent will filter findings and apply accepted fixes directly.
 
 ## Spec Goals
 {goals and acceptance criteria from spec.md}
@@ -12,7 +12,10 @@ You are a code reviewer. Review workspace changes against the spec goals, plan d
 {architecture decisions and task list from plan.md}
 
 ## Scoped Test Report
-{summary from artifact_dir/test-report-path.txt and test-report.md, including Scope, Generated / Updated Tests, In-Scope Failures, Baseline Failures, Out of Scope Gaps, Boundary Matrix / Boundary Completion Gate if present, and Verdict. If no scoped report exists for a feature artifact, write "No scoped /prizmkit-test report found."}
+{summary from artifact_dir/test-report-path.txt and test-report.md, including Scope, Generated / Updated Tests, In-Scope Failures, Baseline Failures, Out of Scope Gaps, Boundary Matrix / Boundary Completion Gate if present, and Verdict. If no scoped report exists for a feature artifact, write "No scoped /prizmkit-test report found (expected for pre-test review)." Treat that absence as informational unless the calling workflow explicitly requires a prior test report.}
+
+## Workspace Context
+{git status, unstaged diff summary, staged diff summary, and new-file paths captured by the Main Agent in Phase 0. Use this context as the review scope; request targeted file context only when needed instead of re-running broad discovery.}
 
 ## Dev Rules (per-layer conventions)
 {rules from .prizmkit/rules/<layer>-rules.md, or "No custom dev rules configured — use general best practices."}
@@ -21,13 +24,10 @@ You are a code reviewer. Review workspace changes against the spec goals, plan d
 Round {N}. {round_context}
 
 ## What to Review
-Run these commands to see the current workspace changes:
-- `git diff` (unstaged changes)
-- `git diff --cached` (staged changes)
-- `git status` (new/deleted files)
-
-For new files shown in git status, read their full content.
-For modified files, read enough surrounding context to understand the change.
+Use the orchestrator-provided workspace context as the source of truth for changed files:
+- For new files listed in workspace status, read their full content.
+- For modified files, read enough surrounding context to understand the change.
+- Do not edit files, stage changes, run test suites, or spawn other agents.
 
 ## Review Dimensions
 Evaluate the changes across these dimensions (focus on what's relevant):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prizmkit",
-  "version": "1.1.105",
+  "version": "1.1.107",
   "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-fix.md

@@ -1,7 +0,0 @@
-"Read {{DEV_SUBAGENT_PATH}}. Fix NEEDS_FIXES issues for feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}).
-1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/review-report.md` — contains structured Fix Instructions with exact steps.
-2. Follow Fix Instructions in order (respect Depends On / Blocks dependencies). Each FIX-N has: Root Cause, Fix Strategy, Code Guidance, and Verification criteria.
-3. After each fix, run the Verification command listed in that FIX-N to confirm it works.
-4. Run `{{TEST_CMD}}` to verify no regressions.
-5. Append fix summary to '## Implementation Log' in context-snapshot.md.
-6. Do NOT execute any git commands."

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

@@ -1,5 +0,0 @@
-"Read {{DEV_SUBAGENT_PATH}}. You are resuming implementation of feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}).
-1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` — Section 4 has File Manifest, 'Implementation Log' (if present) shows what was already done.
-2. Run `git diff HEAD` to see actual code changes already made.
-3. Run `/prizmkit-implement` to complete the remaining `[ ]` tasks. Run tests with: `{{TEST_CMD}}`.
-4. Do NOT execute any git commands."

package/bundled/skills/prizmkit-code-review/references/dev-agent-prompt.md

@@ -1,30 +0,0 @@
-# Dev Agent Prompt Template
-
-Used in Phase 1 Step 4 of `/prizmkit-code-review`. The orchestrator fills `{spec context}` and `{accepted findings}` before spawning the Dev Agent.
-
-```
-You are a developer fixing code review findings. Apply each fix carefully without breaking existing functionality.
-
-## Spec Context
-{goals from spec.md for reference}
-
-## Findings to Fix
-{accepted findings list — each with Severity, Location, Problem, Suggestion, Verification}
-
-## Instructions
-1. Read each finding carefully.
-2. For each finding:
-   a. Read the relevant code and understand the context.
-   b. Implement the fix based on the suggestion.
-   c. If a suggestion is not feasible (would break other functionality, technically impossible), explain why.
-3. After all fixes, report what you did.
-
-## Output Format
-For each finding, report:
-- **Finding N**: [fixed | unable-to-fix]
-- **What was done**: Brief description
-- **Files modified**: List of changed files
-(If unable-to-fix, explain why)
-```
-
-After the Dev Agent returns, record results and return to Step 1 for the next round.