prizmkit 1.1.153 → 1.1.155

package/bundled/skills/recovery-workflow/scripts/detect-recovery-state.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 
 import argparse
 import json
+import re
 import subprocess
 from pathlib import Path
 
@@ -14,19 +15,19 @@ FAMILIES = (
         "name": "feature",
         "state_dir": "features",
         "plan_path": ".prizmkit/plans/feature-list.json",
-        "id_prefix": "F-",
+        "id_pattern": r"^F-\d{3}$",
     },
     {
         "name": "bugfix",
         "state_dir": "bugfix",
         "plan_path": ".prizmkit/plans/bug-fix-list.json",
-        "id_prefix": "B-",
+        "id_pattern": r"^B-\d{3}$",
     },
     {
         "name": "refactor",
         "state_dir": "refactor",
         "plan_path": ".prizmkit/plans/refactor-list.json",
-        "id_prefix": "R-",
+        "id_pattern": r"^R-\d{3}$",
     },
 )
 
@@ -66,7 +67,7 @@ def current_branch(project_root: Path) -> str:
 
 
 def command_for(family: dict[str, str], task_id: str) -> str:
-    return f"python3 ./.prizmkit/dev-pipeline/cli.py {family['name']} run {task_id}"
+    return f"python3 ./.prizmkit/dev-pipeline/cli.py run {family['name']} {task_id}"
 
 
 def detect_candidates(project_root: Path) -> list[dict[str, object]]:
@@ -83,9 +84,18 @@ def detect_candidates(project_root: Path) -> list[dict[str, object]]:
             data = load_json(checkout_path)
             if not data or str(data.get("state") or "") != "active":
                 continue
-            task_id = str(data.get("task_id") or checkout_path.parent.name).strip()
+            raw_task_id = data.get("task_id")
+            if not isinstance(raw_task_id, str):
+                continue
+            task_id = raw_task_id.strip()
             branch = str(data.get("active_dev_branch") or "").strip()
-            if not task_id.startswith(family["id_prefix"]) or not branch_exists(project_root, branch):
+            if (
+                task_id != raw_task_id
+                or data.get("task_type") != family["name"]
+                or checkout_path.parent.name != task_id
+                or re.fullmatch(family["id_pattern"], task_id) is None
+                or not branch_exists(project_root, branch)
+            ):
                 continue
             candidates.append(
                 {

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

@@ -79,7 +79,7 @@ If the project instruction files or package metadata name a baseline test comman
 
 Use one `AskUserQuestion` call with exactly one question:
 
-- **Foreground (Recommended)** — build `refactor run`; output remains attached to the user's terminal.
+- **Foreground (Recommended)** — build `run refactor`; output remains attached to the user's terminal.
 - **Background daemon** — build `daemon refactor start`; the runtime manages detached execution and logs.
 
 Wait for the response before asking configuration.
@@ -113,7 +113,7 @@ Foreground template:
 
 ```bash
 VERBOSE=1 MAX_RETRIES=3 STRICT_BEHAVIOR_CHECK=1 \
-  python3 ./.prizmkit/dev-pipeline/cli.py refactor run .prizmkit/plans/refactor-list.json
+  python3 ./.prizmkit/dev-pipeline/cli.py run refactor .prizmkit/plans/refactor-list.json
 ```
 
 Background template:
@@ -131,7 +131,7 @@ Return:
 
 ```bash
 python3 ./.prizmkit/dev-pipeline/cli.py daemon refactor status
-python3 ./.prizmkit/dev-pipeline/cli.py refactor status .prizmkit/plans/refactor-list.json
+python3 ./.prizmkit/dev-pipeline/cli.py status refactor .prizmkit/plans/refactor-list.json
 ```
 
 Do not infer completion from the plan file alone when runtime state may exist.
@@ -164,39 +164,47 @@ Optionally include the daemon status command for the user to run afterward. Do n
 
 ## Retry Command
 
-Reset changes state only; it never starts execution and rejects `--run`. Always return reset and run as separate commands.
+Reset never starts execution and rejects `--run`. Every reset command must select exactly one mode: `--state-only`, `--fresh-checkout`, `--clean`, or `--preserve-runtime`. Always return reset and run as separate commands.
 
-A standard reset can discard uncommitted changes when the target task branch is currently checked out and records a fresh-checkout boundary. Clean reset additionally deletes the task branch and clears task history/artifacts. Preserve-runtime failed recovery instead scans the whole selected list, restores every failed root and its causal `auto_skipped` descendants, and retains valid checkout identity, sessions, checkpoints, artifacts, branches, worktrees, and WIP. If a recorded branch is missing, it creates a replacement from the recorded base, retains old artifacts for reference, and rewinds implementation-and-later checkpoint stages. Never hide these effects behind the word “retry.”
+State-only recovery resets selected failed/skipped roots and only causal `auto_skipped` descendants whose complete blocker set is recovered. It resets retry/session/continuation state but never changes checkout identity, branches, worktrees, source changes, checkpoints, or artifact files. Selecting an auto-skipped refactor includes all of its transitive blocking roots; `--all` recovers all eligible chains. Fresh-checkout performs the former standard reset, can discard uncommitted changes on the active task branch, and records a new checkout boundary. Clean additionally deletes the task branch and clears task history/artifacts. Preserve-runtime scans the whole list for failed roots, retains runtime history and valid checkout/WIP, and alone may replace a missing branch from the recorded base and rewind implementation-and-later checkpoints. Never hide these effects behind the word “retry.”
 
 Use `AskUserQuestion` before constructing retry commands:
 
-- **Preserve failed runtime (Recommended for continuing failed work)** — recover all failed chains in the selected list without cleanup, then run the list; disclose that this is whole-list recovery rather than a single-ID reset.
-- **Standard fresh retry** — reset one refactor, then run that refactor separately; warn that the active task branch can lose uncommitted changes.
+- **State-only causal recovery** — recover one refactor closure, or all closures with `--all`, while preserving Git/checkouts/checkpoints/artifact files.
+- **Preserve failed runtime (Recommended for continuing failed work)** — recover all failed chains without cleanup while retaining history and continuation evidence; disclose that this is whole-list failed-only recovery.
+- **Fresh-checkout retry** — reset one refactor, then run it separately; warn that the active task branch can lose uncommitted changes.
 - **Clean retry** — reset one refactor, delete its task branch/history/artifacts, then run it separately.
 - **Cancel** — return no reset or run command.
 
+State-only template:
+
+```bash
+python3 ./.prizmkit/dev-pipeline/cli.py reset refactor R-001 --state-only .prizmkit/plans/refactor-list.json
+python3 ./.prizmkit/dev-pipeline/cli.py run refactor R-001 .prizmkit/plans/refactor-list.json
+```
+
 Preserve-runtime template:
 
 ```bash
 python3 ./.prizmkit/dev-pipeline/cli.py reset refactor --failed --preserve-runtime .prizmkit/plans/refactor-list.json
-python3 ./.prizmkit/dev-pipeline/cli.py refactor run .prizmkit/plans/refactor-list.json
+python3 ./.prizmkit/dev-pipeline/cli.py run refactor .prizmkit/plans/refactor-list.json
 ```
 
-Standard template:
+Fresh-checkout template:
 
 ```bash
-python3 ./.prizmkit/dev-pipeline/cli.py reset refactor R-001 .prizmkit/plans/refactor-list.json
-python3 ./.prizmkit/dev-pipeline/cli.py refactor run R-001 .prizmkit/plans/refactor-list.json
+python3 ./.prizmkit/dev-pipeline/cli.py reset refactor R-001 --fresh-checkout .prizmkit/plans/refactor-list.json
+python3 ./.prizmkit/dev-pipeline/cli.py run refactor R-001 .prizmkit/plans/refactor-list.json
 ```
 
 Clean template:
 
 ```bash
 python3 ./.prizmkit/dev-pipeline/cli.py reset refactor R-001 --clean .prizmkit/plans/refactor-list.json
-python3 ./.prizmkit/dev-pipeline/cli.py refactor run R-001 .prizmkit/plans/refactor-list.json
+python3 ./.prizmkit/dev-pipeline/cli.py run refactor R-001 .prizmkit/plans/refactor-list.json
 ```
 
-`--preserve-runtime` requires `--failed` and cannot be combined with `--clean`, an ID, a range, or another reset filter. Retry-budget flags such as `--max-retries` and `--max-infra-retries` belong on the run command, never reset. For clean retry, require explicit acknowledgement of branch deletion and possible uncommitted-change loss before displaying either command.
+State-only requires exactly one ID or explicit `--all` and rejects ranges/status filters. Fresh-checkout and clean accept one ID, range, or supported status filter. Preserve-runtime requires `--failed`, scans the whole list, and rejects IDs, ranges, `--all`, clean, other modes, and other filters. Retry-budget flags belong on the run command, never reset. For fresh-checkout or clean retry, require explicit acknowledgement of possible uncommitted-change loss; clean additionally requires acknowledgement of branch/history/artifact deletion.
 
 ## Output Contract
 

package/bundled/templates/project-memory-template.md

@@ -44,18 +44,22 @@ Placeholders: `<family> = feature | bugfix | refactor`; `<task-id> = F-NNN | B-N
 
 ```bash
 # Run/resume the whole list or one task
-python3 ./.prizmkit/dev-pipeline/cli.py <family> run [<list>] [--max-retries N] [--max-infra-retries N]
-python3 ./.prizmkit/dev-pipeline/cli.py <family> run <task-id> [<list>] [--max-retries N] [--max-infra-retries N]
+python3 ./.prizmkit/dev-pipeline/cli.py run <family> [<list>] [--max-retries N] [--max-infra-retries N]
+python3 ./.prizmkit/dev-pipeline/cli.py run <family> <task-id> [<list>] [--max-retries N] [--max-infra-retries N]
 
-# Inspect or recover task state
-python3 ./.prizmkit/dev-pipeline/cli.py <family> status [<list>]
-python3 ./.prizmkit/dev-pipeline/cli.py <family> unskip [<task-id>] [<list>]
-python3 ./.prizmkit/dev-pipeline/cli.py recovery detect
+# Inspect task state
+python3 ./.prizmkit/dev-pipeline/cli.py status <family> [<list>]
+python3 ./.prizmkit/dev-pipeline/cli.py status all
 
-# Reset state (never starts execution)
-python3 ./.prizmkit/dev-pipeline/cli.py reset <family> <task-id> [<list>]
+# Inspect runtime and AI CLI resolution
+python3 ./.prizmkit/dev-pipeline/cli.py diagnostics ai-cli
+
+# Reset state (exactly one explicit mode; never starts execution)
+python3 ./.prizmkit/dev-pipeline/cli.py reset <family> <task-id> --state-only [<list>]
+python3 ./.prizmkit/dev-pipeline/cli.py reset <family> --state-only --all [<list>]
+python3 ./.prizmkit/dev-pipeline/cli.py reset <family> <task-id-or-range> --fresh-checkout [<list>]
+python3 ./.prizmkit/dev-pipeline/cli.py reset <family> <task-id-or-range> --clean [<list>]
 python3 ./.prizmkit/dev-pipeline/cli.py reset <family> --failed --preserve-runtime [<list>]
-python3 ./.prizmkit/dev-pipeline/cli.py reset <family> <task-id> --clean [<list>]
 
 # Background operation
 python3 ./.prizmkit/dev-pipeline/cli.py daemon <family> start [<list>]
@@ -64,10 +68,14 @@ python3 ./.prizmkit/dev-pipeline/cli.py daemon <family> logs [--lines N|--follow
 python3 ./.prizmkit/dev-pipeline/cli.py daemon <family> stop
 ```
 
+Interrupted-task recovery: invoke `recovery-workflow`. Its read-only detector reports active checkout candidates and returns the ordinary `python3 ./.prizmkit/dev-pipeline/cli.py run <family> <task-id>` command without executing it.
+
 Runtime boundaries:
 - Reset and run are separate operations; reset rejects `--run`. Retry ceilings belong to `run`, not reset.
-- `--preserve-runtime` requires `--failed`, scans the whole selected list, and cannot be combined with `--clean`, an ID/range, or another reset filter.
-- Preserve-runtime recovery keeps valid checkout identity, sessions, checkpoints, artifacts, branches, worktrees, and WIP. If the recorded branch is missing, it creates a replacement from the recorded base and rewinds implementation-and-later checkpoint stages while retaining old artifacts for reference. Clean reset is destructive.
+- Exactly one of `--state-only`, `--fresh-checkout`, `--clean`, or `--preserve-runtime` is required. Missing/conflicting modes fail before state or Git mutation.
+- State-only accepts one ID or explicit `--all`; it resets causal dependency state while preserving checkout identity, branches/worktrees, source changes, checkpoints, and artifact files.
+- Fresh-checkout and clean accept an ID, range, or supported status filter. Fresh-checkout publishes a new checkout boundary; clean additionally deletes branch/history/artifact resources.
+- Preserve-runtime requires `--failed`, scans the whole list, and rejects IDs, ranges, `--all`, clean, other modes, and other filters. It retains runtime history and valid checkout/WIP; a missing branch is replaced from the recorded base with implementation-and-later checkpoint rewind.
 - In zsh/Bash multiline commands, `\` must be the final character on the line with no trailing space.
 
 ### Lightweight Planning Path

package/package.json

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

package/src/scaffold.js

@@ -13,7 +13,8 @@ import path from 'path';
 import { readFileSync } from 'fs';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { dirname, join } from 'path';
-import { execSync } from 'child_process';
+import { execFileSync, execSync } from 'child_process';
+import os from 'os';
 import {
   loadMetadata,
   getTemplatesDir,
@@ -1373,6 +1374,19 @@ export async function installPlaywrightCli(projectRoot, dryRun) {
 // OpenCLI 安装
 // ============================================================
 
+/**
+ * Side-effect-free OpenCLI presence check. Running OpenCLI itself is unsafe here:
+ * browser-oriented commands such as `opencli doctor` create a live browser session.
+ */
+function isOpenCliAvailable() {
+  try {
+    execFileSync(os.platform() === 'win32' ? 'where.exe' : 'which', ['opencli'], { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * 安装 opencli（全局 npm 包）
  * 用于浏览器交互验证，复用 Chrome 已登录会话（OAuth/SSO/第三方集成）
@@ -1383,12 +1397,11 @@ export async function installOpenCli(projectRoot, dryRun, autoDownload = true) {
     return;
   }
 
-  // Check if already installed
-  try {
-    execSync('opencli --version', { stdio: 'pipe' });
+  // Detect the executable without running it. This keeps repeated PrizmKit
+  // installs/upgrades idempotent and avoids starting an OpenCLI browser session.
+  if (isOpenCliAvailable()) {
     console.log(chalk.green('      ✓ opencli (already installed)'));
-  } catch {
-    // Not installed, install it
+  } else {
     try {
       console.log(chalk.blue('      ⏳ Installing @jackwener/opencli globally...'));
       execSync('npm install -g @jackwener/opencli@latest', { stdio: 'pipe', timeout: 120000 });
@@ -1400,22 +1413,20 @@ export async function installOpenCli(projectRoot, dryRun, autoDownload = true) {
     }
   }
 
-  // Verify opencli connectivity — Chrome Browser Bridge extension is a manual install
-  try {
-    const doctorOutput = execSync('opencli doctor 2>&1', { stdio: 'pipe', timeout: 15000 }).toString();
-    if (doctorOutput.includes('[MISSING] Extension') || doctorOutput.includes('[FAIL] Connectivity')) {
-      console.log(chalk.yellow('      ⚠ Chrome Browser Bridge extension is NOT connected'));
-
-      if (autoDownload) {
-        await downloadOpenCliExtension();
-      } else {
-        printOpenCliManualSteps();
-      }
-    } else {
-      console.log(chalk.green('      ✓ opencli connectivity verified'));
-    }
-  } catch {
-    // doctor command itself failed — already warned about install issues
+  // Check only PrizmKit's downloaded extension files. Connectivity checks are
+  // intentionally user-initiated because `opencli doctor` opens a browser tab.
+  const extensionManifest = path.join(
+    process.env.HOME || process.env.USERPROFILE || '.',
+    '.opencli',
+    'extension',
+    'manifest.json',
+  );
+  if (fs.pathExistsSync(extensionManifest)) {
+    console.log(chalk.green('      ✓ OpenCLI extension files (already downloaded)'));
+  } else if (autoDownload) {
+    await downloadOpenCliExtension();
+  } else {
+    printOpenCliManualSteps();
   }
 }
 

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

@@ -1,228 +0,0 @@
-"""Recovery detection and execution for Python foreground runner commands."""
-
-from __future__ import annotations
-
-import json
-import subprocess
-import sys
-import time
-from dataclasses import dataclass
-from pathlib import Path
-
-from .checkpoint_state import load_checkpoint_state
-from .config import load_runtime_config
-from .paths import RuntimePaths
-from .runner_models import RunnerEnvironment, SessionPaths
-from .sessions import AISessionConfig, AISessionLauncher, detect_stream_json_support
-
-
-@dataclass(frozen=True)
-class RecoveryDetectorResolver:
-    """Resolve recovery detector sources without coupling to one platform copy."""
-
-    paths: RuntimePaths
-
-    def candidates(self) -> tuple[Path, ...]:
-        project = self.paths.project_root
-        return (
-            project / ".agents" / "skills" / "recovery-workflow" / "scripts" / "detect-recovery-state.py",
-            project / ".claude" / "command-assets" / "recovery-workflow" / "scripts" / "detect-recovery-state.py",
-            project / ".codebuddy" / "skills" / "recovery-workflow" / "scripts" / "detect-recovery-state.py",
-            project / ".pi" / "skills" / "recovery-workflow" / "scripts" / "detect-recovery-state.py",
-            project
-            / "core"
-            / "skills"
-            / "orchestration-skill"
-            / "workflows"
-            / "recovery-workflow"
-            / "scripts"
-            / "detect-recovery-state.py",
-        )
-
-    def resolve(self) -> Path:
-        for candidate in self.candidates():
-            if candidate.is_file():
-                return candidate
-        raise FileNotFoundError("recovery detector script not found")
-
-
-def run_recovery_detect(paths: RuntimePaths) -> tuple[int, str, str, dict[str, object] | None]:
-    """Run recovery state detection and parse the JSON report."""
-    detector = RecoveryDetectorResolver(paths).resolve()
-    completed = subprocess.run(
-        [sys.executable, str(detector), "--project-root", str(paths.project_root)],
-        cwd=str(paths.project_root),
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        text=True,
-        check=False,
-    )
-    data = None
-    if completed.stdout.strip():
-        try:
-            data = json.loads(completed.stdout)
-        except json.JSONDecodeError:
-            data = None
-    return completed.returncode, completed.stdout, completed.stderr, data
-
-
-def run_recovery(paths: RuntimePaths, legacy_args: tuple[str, ...] = ()) -> tuple[int, str, str]:
-    """Detect recovery state, render a prompt, launch an AI session, and classify."""
-    dry_run = "--dry-run" in legacy_args
-    model_override = _option_value(legacy_args, "--model")
-    code, stdout, stderr, detection = run_recovery_detect(paths)
-    if code != 0 or not detection:
-        return code or 1, stdout, stderr
-    if not detection.get("detected"):
-        return 0, stdout, stderr
-
-    session_id = "recovery-{}-{}".format(
-        str(detection.get("workflow_type") or "workflow"),
-        time.strftime("%Y%m%d-%H%M%S"),
-    )
-    session_dir = paths.recovery_state_dir / session_id
-    session_paths = SessionPaths(
-        session_dir=session_dir,
-        prompt_path=session_dir / "bootstrap-prompt.md",
-        logs_dir=session_dir / "logs",
-        session_log=session_dir / "logs" / "session.log",
-        progress_json=session_dir / "logs" / "progress.json",
-        heartbeat_json=session_dir / "logs" / "heartbeat.json",
-        session_status_json=session_dir / "session-status.json",
-    )
-    detection_json = session_paths.session_dir / "detection.json"
-    session_paths.session_dir.mkdir(parents=True, exist_ok=True)
-    detection_json.write_text(json.dumps(detection, indent=2, ensure_ascii=False), encoding="utf-8")
-    prompt_output = session_paths.prompt_path
-    generator = paths.pipeline_root / "scripts" / "generate-recovery-prompt.py"
-    prompt_cmd = [
-        sys.executable,
-        str(generator),
-        "--detection-json",
-        str(detection_json),
-        "--output",
-        str(prompt_output),
-        "--project-root",
-        str(paths.project_root),
-        "--session-id",
-        session_id,
-    ]
-    prompt_result = subprocess.run(
-        prompt_cmd,
-        cwd=str(paths.project_root),
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        text=True,
-        check=False,
-    )
-    if prompt_result.returncode != 0:
-        return prompt_result.returncode, prompt_result.stdout, prompt_result.stderr
-    if dry_run:
-        return 0, prompt_result.stdout, prompt_result.stderr
-
-    config = load_runtime_config(paths)
-    if not config.ai_client.command:
-        return 1, "", "No supported AI CLI command was found for recovery\n"
-    env = RunnerEnvironment.from_env()
-    stream_json = False
-    if env.live_output and getattr(config.ai_client, "launch_profile", None) is None:
-        stream_json = detect_stream_json_support(config.ai_client.command, config.ai_client.platform).enabled
-    launcher = AISessionLauncher(
-        AISessionConfig(
-            cli_command=config.ai_client.command,
-            platform=config.ai_client.platform or "codebuddy",
-            model=model_override or config.model,
-            prompt_path=prompt_output,
-            cwd=paths.project_root,
-            log_path=session_paths.session_log,
-            progress_path=session_paths.progress_json,
-            heartbeat_path=session_paths.heartbeat_json,
-            effort=config.effort,
-            verbose=env.verbose,
-            live_output=env.live_output,
-            use_stream_json=stream_json,
-            launch_profile=getattr(config.ai_client, "launch_profile", None),
-            stale_kill_threshold_seconds=env.stale_kill_threshold_seconds,
-            heartbeat_stale_threshold_seconds=env.heartbeat_stale_threshold_seconds,
-            live_progress_interval_seconds=env.heartbeat_interval_seconds,
-            live_banner=False,
-            suppress_stream_output=True,
-        )
-    )
-    result = launcher.run()
-    checkpoint_path = _recovery_checkpoint_path(paths.project_root, detection)
-    outcome, semantic = _recovery_outcome(
-        paths.project_root,
-        result.exit_code,
-        checkpoint_path=checkpoint_path,
-    )
-    session_paths.session_status_json.write_text(
-        json.dumps(
-            {
-                "session_id": session_id,
-                "outcome": outcome,
-                "checkpoint_path": str(checkpoint_path) if checkpoint_path else None,
-                "checkpoint_state": semantic,
-            },
-            indent=2,
-        )
-        + "\n",
-        encoding="utf-8",
-    )
-    return 0 if outcome in {"success", "no_changes"} else 1, outcome + "\n", ""
-
-
-def _option_value(args: tuple[str, ...], flag: str) -> str | None:
-    for index, arg in enumerate(args):
-        if arg == flag and index + 1 < len(args):
-            return args[index + 1]
-        if arg.startswith(flag + "="):
-            return arg.split("=", 1)[1]
-    return None
-
-
-def _recovery_checkpoint_path(project_root: Path, detection: dict[str, object]) -> Path | None:
-    """Select the L4 checkpoint identified by recovery inspection."""
-    semantic = detection.get("semantic_checkpoint")
-    if isinstance(semantic, dict) and semantic.get("path"):
-        candidate = project_root / str(semantic["path"])
-        if candidate.is_file():
-            return candidate
-    execution_owner = detection.get("execution_owner")
-    checkpoints = execution_owner.get("l4_checkpoints") if isinstance(execution_owner, dict) else []
-    if isinstance(checkpoints, list) and len(checkpoints) == 1:
-        candidate = project_root / str(checkpoints[0])
-        if candidate.is_file():
-            return candidate
-    return None
-
-
-def _recovery_outcome(
-    project_root: Path,
-    exit_code: int | None,
-    *,
-    checkpoint_path: Path | None = None,
-) -> tuple[str, dict[str, object]]:
-    """Classify recovery from semantic L4 state without mutating partial work."""
-    if checkpoint_path is not None:
-        state = load_checkpoint_state(checkpoint_path, project_root=project_root)
-        semantic = state.semantic_snapshot
-        if state.valid and state.semantic_complete:
-            return "success", semantic
-        if state.valid and state.semantic_blocked:
-            return "workflow_blocked", semantic
-        if state.exists and not state.valid:
-            return "blocked_invalid_checkpoint", semantic
-        return "partial" if exit_code == 0 else "failed", semantic
-
-    status = subprocess.run(
-        ["git", "-C", str(project_root), "status", "--porcelain"],
-        stdout=subprocess.PIPE,
-        stderr=subprocess.DEVNULL,
-        text=True,
-        check=False,
-    )
-    has_changes = bool(status.stdout.strip())
-    if exit_code == 0 and not has_changes:
-        return "no_changes", {}
-    return ("partial" if has_changes else "failed"), {}