prizmkit 1.1.105 → 1.1.106

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.105",
-  "bundledAt": "2026-07-06T18:17:35.126Z",
-  "bundledFrom": "e92eb9f"
+  "frameworkVersion": "1.1.106",
+  "bundledAt": "2026-07-07T02:54:30.507Z",
+  "bundledFrom": "8e4fe49"
 }

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

@@ -565,7 +565,6 @@ def branch_ensure_return_plan(context: BranchContext) -> GitCommandPlan:
             ),
             _git("stash", "push", "-m", "pipeline-ensure-return-stash", allow_failure=True, description="stash checkout blockers"),
             _git("checkout", context.base_branch, allow_failure=True, description="return to original branch"),
-            _git("stash", "pop", allow_failure=True, description="restore stashed checkout blockers"),
         ),
         never_fails=True,
         notes=("Always returns success to support trap/finally cleanup paths.",),

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

@@ -7,10 +7,11 @@ legacy ordering around branch creation and final status updates.
 
 from __future__ import annotations
 
+from collections.abc import Sequence
 from dataclasses import dataclass
 from pathlib import Path
 
-from .gitops import GitCommandResult, git_status_safe, run_git_command
+from .gitops import HIDDEN_TOOL_WORKTREE_EXCLUDES, GitCommandResult, git_status_safe, run_git_command
 from .runner_models import RunnerFamily
 
 
@@ -27,25 +28,95 @@ class BookkeepingResult:
         return self.result is None or self.result.return_code == 0
 
 
-def has_workspace_changes(project_root: Path) -> bool:
-    """Return true when git status has non-hidden-tool worktree changes."""
-    return bool(git_status_safe(project_root).strip())
+def _bookkeeping_paths(project_root: Path, family: RunnerFamily, item_id: str) -> tuple[str, ...]:
+    return (
+        _repo_path(project_root, family.plan_path),
+        _repo_path(project_root, family.state_dir / item_id / "status.json"),
+    )
+
+
+def _repo_path(project_root: Path, path: Path) -> str:
+    try:
+        return path.resolve().relative_to(project_root.resolve()).as_posix()
+    except ValueError:
+        return path.as_posix()
+
+
+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)
+
+
+def commit_bookkeeping_changes(
+    project_root: Path,
+    family: RunnerFamily,
+    item_id: str,
+    message: str,
+) -> BookkeepingResult:
+    """Stage and commit only runner-owned bookkeeping paths when present."""
+    paths = _changed_paths_in(project_root, _bookkeeping_paths(project_root, family, item_id))
+    if not paths:
+        return BookkeepingResult(attempted=False, committed=False)
+    run_git_command(project_root, ("add", "-A", "--", *paths))
+    result = run_git_command(project_root, ("commit", "--no-verify", "-m", message))
+    return BookkeepingResult(attempted=True, committed=result.return_code == 0, result=result)
 
 
-def commit_all_changes(project_root: Path, message: str) -> BookkeepingResult:
-    """Stage and commit current workspace changes when present."""
-    if not has_workspace_changes(project_root):
+def commit_task_branch_changes(
+    project_root: Path,
+    family: RunnerFamily,
+    item_id: str,
+    status: str,
+) -> BookkeepingResult:
+    """Commit task branch code, artifacts, and status without switching branches."""
+    message = f"chore({item_id}): save {family.kind} {status} state"
+    if status == "completed":
+        message = f"chore({item_id}): complete {family.kind} task"
+    if not git_status_safe(project_root).strip():
         return BookkeepingResult(attempted=False, committed=False)
-    run_git_command(project_root, ("add", "-A", "--", "."))
+    run_git_command(project_root, ("add", "-A", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES))
     result = run_git_command(project_root, ("commit", "--no-verify", "-m", message))
     return BookkeepingResult(attempted=True, committed=result.return_code == 0, result=result)
 
 
+def commit_wip_changes(
+    project_root: Path,
+    family: RunnerFamily,
+    item_id: str,
+    status: str,
+) -> BookkeepingResult:
+    """Commit all visible task-branch changes as preserved WIP."""
+    if not git_status_safe(project_root).strip():
+        return BookkeepingResult(attempted=False, committed=False)
+    run_git_command(project_root, ("add", "-A", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES))
+    result = run_git_command(
+        project_root,
+        (
+            "commit",
+            "--no-verify",
+            "-m",
+            f"wip({item_id}): preserve {family.kind} {status} state",
+            "-m",
+            "Pipeline preserved task branch work without merging it to the base branch.",
+        ),
+    )
+    return BookkeepingResult(attempted=True, committed=result.return_code == 0, result=result)
+
+
 def commit_pre_branch_bookkeeping(project_root: Path, family: RunnerFamily, item_id: str) -> BookkeepingResult:
-    """Commit status/list changes before creating the item dev branch."""
-    return commit_all_changes(project_root, f"chore({item_id}): mark in_progress")
+    """Commit in-progress status on the current task branch."""
+    return commit_bookkeeping_changes(project_root, family, item_id, f"chore({item_id}): mark in_progress")
 
 
 def commit_final_bookkeeping(project_root: Path, family: RunnerFamily, item_id: str, status: str) -> BookkeepingResult:
-    """Commit final list/state changes after returning to the base branch."""
-    return commit_all_changes(project_root, f"chore({item_id}): update {family.kind} status {status}")
+    """Commit final runner-owned status changes on the current task branch."""
+    return commit_bookkeeping_changes(project_root, family, item_id, f"chore({item_id}): update {family.kind} status {status}")

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

@@ -43,10 +43,18 @@ def classify_session(
 ) -> SessionClassification:
     """Classify raw AI session signals with durable success precedence."""
     fingerprint = progress_fingerprint(project_root, prompt)
-    if _has_commit_since(project_root, base_head):
-        return SessionClassification("success", reason="commit_since_base", progress_fingerprint=fingerprint)
+    has_commit_since_base = _has_commit_since(project_root, base_head)
+
+    if _is_terminal_success(result) and _has_completed_workflow_artifact(prompt):
+        return SessionClassification(
+            "success",
+            reason="terminal_success_with_completed_checkpoint",
+            progress_fingerprint=fingerprint,
+        )
 
     if _is_context_overflow(result):
+        if has_commit_since_base:
+            return SessionClassification("success", reason="commit_since_base", progress_fingerprint=fingerprint)
         no_progress_count = _next_no_progress_count(previous_fingerprint, fingerprint, previous_no_progress_count)
         if no_progress_count >= 2:
             return SessionClassification(
@@ -72,6 +80,8 @@ def classify_session(
         return SessionClassification("timed_out", reason="timeout", progress_fingerprint=fingerprint)
     if result.exit_code not in (0, None):
         return SessionClassification("crashed", reason=f"exit_code={result.exit_code}", progress_fingerprint=fingerprint)
+    if has_commit_since_base:
+        return SessionClassification("success", reason="commit_since_base", progress_fingerprint=fingerprint)
     if _has_workspace_changes(project_root):
         _auto_commit_workspace(project_root)
         return SessionClassification("success", reason="auto_commit_uncommitted_changes", progress_fingerprint=fingerprint)
@@ -100,6 +110,32 @@ def progress_fingerprint(project_root: Path, prompt: PromptGenerationResult | No
     }
 
 
+def _is_terminal_success(result: AISessionResult) -> bool:
+    return (
+        result.exit_code in (0, None)
+        and not result.timed_out
+        and result.termination_reason not in {"timeout", "stale_session"}
+        and not result.fatal_error_code
+        and not result.progress_summary.fatal_error_code
+        and result.progress_summary.result_subtype == "success"
+    )
+
+
+def _has_completed_workflow_artifact(prompt: PromptGenerationResult | None) -> bool:
+    if prompt is None:
+        return False
+    if prompt.checkpoint_path and prompt.checkpoint_path.is_file():
+        try:
+            data = json.loads(prompt.checkpoint_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            data = {}
+        if isinstance(data, dict) and _checkpoint_cursor(data) == "complete":
+            return True
+    if prompt.artifact_path and (prompt.artifact_path / "completion-summary.json").is_file():
+        return True
+    return False
+
+
 def _next_no_progress_count(previous: object | None, current: object, count: int) -> int:
     if previous and previous == current:
         return max(0, count) + 1

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

@@ -26,7 +26,12 @@ from .gitops import (
     worktree_runtime_context,
     worktree_save_wip,
 )
-from .runner_bookkeeping import commit_final_bookkeeping, commit_pre_branch_bookkeeping
+from .runner_bookkeeping import (
+    commit_final_bookkeeping,
+    commit_pre_branch_bookkeeping,
+    commit_task_branch_changes,
+    commit_wip_changes,
+)
 from .runner_classification import classify_session
 from .runner_models import RunnerEnvironment, RunnerFamily, RunnerInvocation, SessionPaths, family_for, parse_invocation
 from .runner_prompts import PromptGenerationResult, generate_prompt
@@ -180,7 +185,9 @@ def _is_recovery_side_effect_branch(branch: str, family: RunnerFamily, item_id:
 
 
 def _is_current_task_branch(branch: str, family: RunnerFamily, item_id: str) -> bool:
-    return bool(branch) and branch.startswith(f"{family.branch_prefix}/{item_id}-") and not _is_recovery_side_effect_branch(branch, family, item_id)
+    if not branch or _is_recovery_side_effect_branch(branch, family, item_id):
+        return False
+    return branch == f"{family.branch_prefix}/{item_id}" or branch.startswith(f"{family.branch_prefix}/{item_id}-")
 
 
 def _resolve_base_branch(project_root: Path, metadata: dict[str, object], active_branch: str, family: RunnerFamily, item_id: str) -> str:
@@ -313,13 +320,7 @@ def _process_item(
     use_worktree = _use_worktree_for_family(env, family)
     execution_root = paths.project_root
 
-    _emit_item_header(family, invocation, item_id, initial_metadata)
     try:
-        start = start_item(family, invocation, item_id, paths.project_root)
-        if not start.ok:
-            raise RuntimeError(start.text)
-        commit_pre_branch_bookkeeping(paths.project_root, family, item_id)
-
         if use_worktree:
             worktree_runtime = worktree_runtime_context(
                 branch_context,
@@ -332,22 +333,37 @@ def _process_item(
             )
             setup = ensure_linked_worktree(worktree_runtime)
             if not setup.ok:
-                status = update_item(family, invocation, item_id, "infra_error", "", paths.project_root)
-                return _status_from_update(status)
+                return "infra_error"
             worktree_runtime = setup.runtime or worktree_runtime
             _emit_info(f"Dev branch: {branch_name}")
             _emit_info(f"Worktree: {worktree_runtime.worktree_path}")
             support_assets = materialize_worktree_support_assets(worktree_runtime)
             if not support_assets.ok:
-                status = update_item(family, invocation, item_id, "infra_error", "", paths.project_root)
-                return _status_from_update(status)
+                return _record_setup_failure(
+                    family,
+                    invocation,
+                    item_id,
+                    paths.project_root,
+                    worktree_runtime.worktree_path,
+                    base_branch,
+                    branch_name,
+                    worktree_runtime=worktree_runtime,
+                )
             execution_root = worktree_runtime.worktree_path
         else:
             branch_result = run_git_plan(paths.project_root, branch_create_plan(branch_context))
             _emit_branch_setup_result(branch_context, branch_result)
             if not branch_result.ok:
-                status = update_item(family, invocation, item_id, "infra_error", "", paths.project_root)
-                return _status_from_update(status)
+                return "infra_error"
+
+        _emit_item_header(family, invocation, item_id, initial_metadata)
+        status_root = execution_root if use_worktree else paths.project_root
+        status_family = _family_for_execution_root(family, paths.project_root, status_root)
+        status_invocation = _invocation_for_execution_family(invocation, status_family)
+        start = start_item(status_family, status_invocation, item_id, status_root)
+        if not start.ok:
+            raise RuntimeError(start.text)
+        commit_pre_branch_bookkeeping(status_root, status_family, item_id)
 
         previous_fingerprint = initial_metadata.get("last_progress_fingerprint")
         previous_no_progress_count = int(initial_metadata.get("no_progress_count") or 0)
@@ -368,7 +384,7 @@ def _process_item(
                     "task_type": family.task_type,
                     "active_dev_branch": branch_name,
                     "base_branch": base_branch,
-                    "continuation_summary_path": _continuation_summary_path(paths.project_root, family, item_id, None),
+                    "continuation_summary_path": _continuation_summary_path(execution_root, family, item_id, None),
                 }
             prompt = generate_prompt(
                 family,
@@ -417,14 +433,14 @@ def _process_item(
             )
             _emit_session_summary(session_result, session_paths, classification)
             if classification.session_status == "context_overflow":
-                summary_path = _continuation_summary_path(paths.project_root, family, item_id, prompt)
+                summary_path = _continuation_summary_path(execution_root, family, item_id, prompt)
                 update = update_item(
-                    family,
-                    invocation,
+                    status_family,
+                    status_invocation,
                     item_id,
                     "context_overflow",
                     session_id,
-                    paths.project_root,
+                    status_root,
                     active_dev_branch=branch_name,
                     base_branch=base_branch,
                     last_fatal_error_code=classification.fatal_error_code or "context_overflow",
@@ -444,32 +460,65 @@ def _process_item(
                 continue
 
             final_session_status = classification.session_status
-            if use_worktree and worktree_runtime is not None:
-                if final_session_status == "success":
-                    _emit_info(f"Merging {branch_name} into {base_branch}...")
-                    merge = merge_linked_worktree(worktree_runtime, auto_push=env.auto_push)
-                    _emit_git_plan_output(merge)
-                    if merge.ok:
-                        guarded_worktree_remove(worktree_runtime, delete_branch=True)
-                        _emit_success(f"Merged {branch_name} into {base_branch}")
-                    else:
-                        final_session_status = "merge_conflict"
-                        guarded_worktree_remove(worktree_runtime, delete_branch=False)
-                else:
-                    worktree_save_wip(worktree_runtime)
+
+            _write_session_status(
+                session_paths,
+                status=final_session_status,
+                session_id=session_id,
+                task_id=item_id,
+                task_type=family.task_type,
+                base_branch=base_branch,
+                active_dev_branch=branch_name,
+                worktree_path=worktree_runtime.worktree_path if worktree_runtime is not None else None,
+                reason=classification.reason,
+                fatal_error_code=classification.fatal_error_code,
+            )
+
+            update = update_item(
+                status_family,
+                status_invocation,
+                item_id,
+                final_session_status,
+                session_id,
+                status_root,
+                active_dev_branch=branch_name,
+                base_branch=base_branch,
+                last_fatal_error_code=classification.fatal_error_code,
+                no_progress_count=classification.no_progress_count,
+                progress_fingerprint=classification.progress_fingerprint,
+            )
+            if not update.ok:
+                raise RuntimeError(update.text)
+            _emit_update_summary(family, item_id, update)
+            new_status = _status_from_update(update)
+            if final_session_status != "success":
+                commit_final_bookkeeping(status_root, status_family, item_id, new_status)
+                _save_failure_wip(execution_root, family, item_id, new_status, worktree_runtime)
+                if use_worktree and worktree_runtime is not None:
                     guarded_worktree_remove(worktree_runtime, delete_branch=False)
-            else:
-                if final_session_status == "success":
-                    _emit_info(f"Merging {branch_name} into {base_branch}...")
-                    merge = run_git_plan(paths.project_root, branch_merge_plan(branch_context, auto_push=env.auto_push))
-                    _emit_git_plan_output(merge)
-                    if merge.ok:
-                        _emit_success(f"Merged {branch_name} into {base_branch}")
-                    else:
-                        branch_ensure_return(paths.project_root, base_branch, branch_name)
-                        final_session_status = "merge_conflict"
                 else:
                     branch_ensure_return(paths.project_root, base_branch, branch_name)
+                return new_status
+
+            commit_final_bookkeeping(status_root, status_family, item_id, new_status)
+            commit_task_branch_changes(execution_root, family, item_id, new_status)
+            if use_worktree and worktree_runtime is not None:
+                _emit_info(f"Merging {branch_name} into {base_branch}...")
+                merge = merge_linked_worktree(worktree_runtime, auto_push=env.auto_push)
+                _emit_git_plan_output(merge)
+                if merge.ok:
+                    guarded_worktree_remove(worktree_runtime, delete_branch=True)
+                    _emit_success(f"Merged {branch_name} into {base_branch}")
+                    return new_status
+                final_session_status = "merge_conflict"
+            else:
+                _emit_info(f"Merging {branch_name} into {base_branch}...")
+                merge = run_git_plan(paths.project_root, branch_merge_plan(branch_context, auto_push=env.auto_push))
+                _emit_git_plan_output(merge)
+                if merge.ok:
+                    _emit_success(f"Merged {branch_name} into {base_branch}")
+                    return new_status
+                final_session_status = "merge_conflict"
 
             _write_session_status(
                 session_paths,
@@ -480,17 +529,16 @@ def _process_item(
                 base_branch=base_branch,
                 active_dev_branch=branch_name,
                 worktree_path=worktree_runtime.worktree_path if worktree_runtime is not None else None,
-                reason=classification.reason,
+                reason="merge_conflict",
                 fatal_error_code=classification.fatal_error_code,
             )
-
             update = update_item(
-                family,
-                invocation,
+                status_family,
+                status_invocation,
                 item_id,
                 final_session_status,
                 session_id,
-                paths.project_root,
+                status_root,
                 active_dev_branch=branch_name,
                 base_branch=base_branch,
                 last_fatal_error_code=classification.fatal_error_code,
@@ -501,7 +549,12 @@ def _process_item(
                 raise RuntimeError(update.text)
             _emit_update_summary(family, item_id, update)
             new_status = _status_from_update(update)
-            commit_final_bookkeeping(paths.project_root, family, item_id, new_status)
+            commit_final_bookkeeping(status_root, status_family, item_id, new_status)
+            _save_failure_wip(execution_root, family, item_id, new_status, worktree_runtime)
+            if use_worktree and worktree_runtime is not None:
+                guarded_worktree_remove(worktree_runtime, delete_branch=False)
+            else:
+                branch_ensure_return(paths.project_root, base_branch, branch_name)
             return new_status
     except KeyboardInterrupt:
         _emit_warning(f"Interrupted while processing {item_id}; preserving work and returning to {base_branch}")
@@ -513,6 +566,52 @@ def _process_item(
         raise
 
 
+def _save_failure_wip(execution_root: Path, family: RunnerFamily, item_id: str, status: str, worktree_runtime) -> None:
+    if worktree_runtime is not None:
+        worktree_save_wip(worktree_runtime)
+    else:
+        commit_wip_changes(execution_root, family, item_id, status)
+
+
+def _record_setup_failure(
+    family: RunnerFamily,
+    invocation: RunnerInvocation,
+    item_id: str,
+    project_root: Path,
+    status_root: Path,
+    base_branch: str,
+    branch_name: str,
+    *,
+    worktree_runtime=None,
+) -> str:
+    """Record setup-time infra failures on a task branch when one exists."""
+    if status_root.resolve() == project_root.resolve() and current_branch(project_root) != branch_name:
+        return "infra_error"
+    status_family = _family_for_execution_root(family, project_root, status_root)
+    status_invocation = _invocation_for_execution_family(invocation, status_family)
+    start = start_item(status_family, status_invocation, item_id, status_root)
+    if start.ok:
+        commit_pre_branch_bookkeeping(status_root, status_family, item_id)
+    update = update_item(
+        status_family,
+        status_invocation,
+        item_id,
+        "infra_error",
+        "",
+        status_root,
+        active_dev_branch=branch_name,
+        base_branch=base_branch,
+    )
+    new_status = _status_from_update(update) if update.ok else "infra_error"
+    if update.ok:
+        commit_final_bookkeeping(status_root, status_family, item_id, new_status)
+        _save_failure_wip(status_root, family, item_id, new_status, worktree_runtime)
+    if worktree_runtime is not None:
+        guarded_worktree_remove(worktree_runtime, delete_branch=False)
+    elif current_branch(project_root) == branch_name:
+        branch_ensure_return(project_root, base_branch, branch_name)
+    return new_status
+
 def _test_cli(kind: str, paths) -> CommandResult:
     """Report the AI CLI resolution used by Python runner commands."""
     config = load_runtime_config(paths)
@@ -539,6 +638,52 @@ def _use_worktree_for_family(env: RunnerEnvironment, family: RunnerFamily) -> bo
     return env.use_worktree and family.kind in {"feature", "bugfix"}
 
 
+def _family_for_execution_root(family: RunnerFamily, project_root: Path, execution_root: Path) -> RunnerFamily:
+    """Return family paths rooted in the task execution checkout."""
+    if execution_root.resolve() == project_root.resolve():
+        return family
+    return RunnerFamily(
+        kind=family.kind,
+        id_prefix=family.id_prefix,
+        list_key=family.list_key,
+        list_arg=family.list_arg,
+        item_id_arg=family.item_id_arg,
+        state_dir=_path_in_execution_root(family.state_dir, project_root, execution_root),
+        plan_path=_path_in_execution_root(family.plan_path, project_root, execution_root),
+        updater_script=family.updater_script,
+        prompt_script=family.prompt_script,
+        branch_prefix=family.branch_prefix,
+        artifact_root_name=family.artifact_root_name,
+    )
+
+
+def _invocation_for_execution_family(invocation: RunnerInvocation, family: RunnerFamily) -> RunnerInvocation:
+    return RunnerInvocation(
+        action=invocation.action,
+        list_path=family.plan_path,
+        item_id=invocation.item_id,
+        item_filter=invocation.item_filter,
+        max_retries=invocation.max_retries,
+        max_infra_retries=invocation.max_infra_retries,
+        mode=invocation.mode,
+        critic=invocation.critic,
+        dry_run=invocation.dry_run,
+        clean=invocation.clean,
+        no_reset=invocation.no_reset,
+        resume_phase=invocation.resume_phase,
+        help_requested=invocation.help_requested,
+        unknown_args=invocation.unknown_args,
+        raw_args=invocation.raw_args,
+    )
+
+
+def _path_in_execution_root(path: Path, project_root: Path, execution_root: Path) -> Path:
+    try:
+        return execution_root / path.resolve().relative_to(project_root.resolve())
+    except ValueError:
+        return path
+
+
 def _write_session_status(
     session_paths: SessionPaths,
     *,
@@ -579,8 +724,7 @@ def _status_from_update(update_result) -> str:
 
 
 def _default_branch_name(family: RunnerFamily, item_id: str) -> str:
-    stamp = time.strftime("%Y%m%d%H%M")
-    return f"{family.branch_prefix}/{item_id}-{stamp}"
+    return f"{family.branch_prefix}/{item_id}-{time.strftime('%Y%m%d%H%M%S')}"
 
 
 def _session_id(item_id: str) -> str:

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,62 @@ 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):
@@ -956,6 +1024,63 @@ def test_no_worktree_interrupt_saves_wip_and_returns_to_base(monkeypatch, tmp_pa
     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):
     from prizmkit_runtime import runners
     from prizmkit_runtime.runner_models import family_for, parse_invocation
@@ -983,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
@@ -1021,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

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.105",
+  "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.105",
+  "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": {