prizmkit 1.1.122 → 1.1.124

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.122",
-  "bundledAt": "2026-07-11T17:19:34.691Z",
-  "bundledFrom": "fbcb3f4"
+  "frameworkVersion": "1.1.124",
+  "bundledAt": "2026-07-12T05:54:30.044Z",
+  "bundledFrom": "f15301f"
 }

package/bundled/adapters/claude/command-adapter.js

@@ -20,6 +20,69 @@ function toClaudePrizmkitCommand(sub) {
   return `prizmkit-${normalized}`;
 }
 
+const REVIEWER_ROLE_SKILL = 'prizmkit-code-review';
+const REVIEWER_ROLE_FILE = 'prizmkit-code-reviewer.md';
+const REVIEWER_REQUIRED_UNAVAILABLE = new Set([
+  'workspace-mutation',
+  'shell-execution',
+  'downstream-execution-creation',
+  'delegation-equivalent-behavior',
+  'orchestration-reentry',
+  'skill-invocation',
+]);
+const CLAUDE_OBSERVATIONAL_TOOLS = new Map([
+  ['read-files', 'Read'],
+  ['search-content', 'Grep'],
+  ['search-paths', 'Glob'],
+]);
+
+function buildReviewerRoleDefinition(roleManifest) {
+  if (!roleManifest || roleManifest.role_name !== 'prizmkit-code-reviewer') {
+    throw new Error('prizmkit-code-review requires assets/reviewer-role.json');
+  }
+  const unavailable = new Set(roleManifest.unavailable_capabilities || []);
+  for (const capability of REVIEWER_REQUIRED_UNAVAILABLE) {
+    if (!unavailable.has(capability)) {
+      throw new Error(`Reviewer role must make ${capability} unavailable`);
+    }
+  }
+  if (roleManifest.execution_mode !== 'foreground-single-authority'
+    || roleManifest.max_descendant_execution_units !== 0
+    || roleManifest.max_delegation_depth !== 0) {
+    throw new Error('Reviewer role violates the single-authority execution topology');
+  }
+
+  const tools = (roleManifest.observational_capabilities || []).map(capability => {
+    const tool = CLAUDE_OBSERVATIONAL_TOOLS.get(capability);
+    if (!tool) throw new Error(`Unsupported Reviewer observational capability: ${capability}`);
+    return tool;
+  });
+  if (tools.length === 0) throw new Error('Reviewer role requires observational capabilities');
+
+  return `---
+name: ${roleManifest.role_name}
+description: ${roleManifest.description}
+tools: ${tools.join(', ')}
+permissionMode: dontAsk
+maxTurns: 200
+---
+
+You are a capability-restricted read-only Reviewer execution role.
+
+Read and follow the complete prompt supplied by the Main Agent. Perform the complete review yourself. Your tool allowlist intentionally excludes workspace mutation, shell execution, skill invocation, downstream execution creation, delegation-equivalent behavior, and orchestration re-entry.
+
+If the supplied review cannot be completed with the available observational capabilities and current execution context, return \`REVIEW_INFRASTRUCTURE_BLOCKED\`. Do not delegate, request a helper, mutate the workspace, or claim \`PASS\` from incomplete work.
+`;
+}
+
+export function getClaudeSkillAgentDefinitions(skillName, roleManifest = null) {
+  if (skillName !== REVIEWER_ROLE_SKILL) return [];
+  return [{
+    fileName: REVIEWER_ROLE_FILE,
+    content: buildReviewerRoleDefinition(roleManifest),
+  }];
+}
+
 /**
  * Convert a core SKILL.md to Claude Code command.md format.
  * @param {string} skillContent - Content of the core SKILL.md
@@ -97,6 +160,20 @@ export async function installCommand(corePath, targetRoot) {
     for (const subdir of subdirs) {
       cpSync(path.join(corePath, subdir), path.join(targetDir, subdir), { recursive: true });
     }
+
+    // Install platform-native capability roles generated from canonical skill semantics.
+    const roleManifestPath = path.join(corePath, 'assets', 'reviewer-role.json');
+    const roleManifest = existsSync(roleManifestPath)
+      ? JSON.parse(await readFile(roleManifestPath, 'utf8'))
+      : null;
+    const agentDefinitions = getClaudeSkillAgentDefinitions(skillName, roleManifest);
+    if (agentDefinitions.length > 0) {
+      const agentsDir = path.join(targetRoot, '.claude', 'agents');
+      mkdirSync(agentsDir, { recursive: true });
+      for (const definition of agentDefinitions) {
+        await writeFile(path.join(agentsDir, definition.fileName), definition.content);
+      }
+    }
   } else {
     // Single file command
     const targetDir = path.join(targetRoot, COMMANDS_DIR);

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

@@ -11,14 +11,20 @@ from dataclasses import dataclass
 from pathlib import Path
 
 
-HIDDEN_TOOL_WORKTREE_EXCLUDES = (
+PIPELINE_TRANSIENT_EXCLUDES = (
     ":(top,exclude).prizmkit-worktree",
-    ":(top,exclude).skills-lock.json",
-    ":(top,exclude).AGENTS.md",
     ":(top,exclude,glob).*/worktree",
     ":(top,exclude,glob).*/worktree/**",
     ":(top,exclude,glob).*/worktrees",
     ":(top,exclude,glob).*/worktrees/**",
+    ":(top,exclude).prizmkit/state",
+    ":(top,exclude,glob).prizmkit/state/**",
+)
+
+HIDDEN_TOOL_WORKTREE_EXCLUDES = (
+    *PIPELINE_TRANSIENT_EXCLUDES,
+    ":(top,exclude).skills-lock.json",
+    ":(top,exclude).AGENTS.md",
     ":(top,exclude).claude",
     ":(top,exclude,glob).claude/**",
     ":(top,exclude).codebuddy",
@@ -31,12 +37,17 @@ HIDDEN_TOOL_WORKTREE_EXCLUDES = (
     ":(top,exclude,glob).prizmkit/prizm-docs/**",
     ":(top,exclude).prizmkit/config.json",
     ":(top,exclude).prizmkit/manifest.json",
-    ":(top,exclude).prizmkit/state",
-    ":(top,exclude,glob).prizmkit/state/**",
     ":(top,exclude).prizmkit/dev-pipeline",
     ":(top,exclude,glob).prizmkit/dev-pipeline/**",
 )
 
+UNTRACKED_TRANSIENT_EXCLUDES = (
+    *HIDDEN_TOOL_WORKTREE_EXCLUDES,
+    ":(top,exclude,glob)**/__pycache__",
+    ":(top,exclude,glob)**/__pycache__/**",
+    ":(top,exclude,glob)**/*.py[cod]",
+)
+
 PIPELINE_FALLBACK_GIT_NAME = "PrizmKit Pipeline"
 PIPELINE_FALLBACK_GIT_EMAIL = "prizmkit-pipeline@example.invalid"
 

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

@@ -11,10 +11,37 @@ from collections.abc import Sequence
 from dataclasses import dataclass
 from pathlib import Path
 
-from .gitops import HIDDEN_TOOL_WORKTREE_EXCLUDES, GitCommandResult, git_status_safe, run_git_command
+from .gitops import (
+    HIDDEN_TOOL_WORKTREE_EXCLUDES,
+    UNTRACKED_TRANSIENT_EXCLUDES,
+    GitCommandResult,
+    git_status_safe,
+    run_git_command,
+)
 from .runner_models import RunnerFamily
 
 
+LOCAL_ONLY_PLATFORM_PATHS = (
+    ".claude/settings.local.json",
+    ".codebuddy/settings.local.json",
+    ".codex/settings.local.json",
+    ".agents/settings.local.json",
+)
+
+
+@dataclass(frozen=True)
+class PreflightWorkspace:
+    """Exact Git paths participating in startup preservation."""
+
+    tracked: tuple[str, ...]
+    visible_untracked: tuple[str, ...]
+    unsafe_local: tuple[str, ...]
+
+    @property
+    def preservable(self) -> tuple[str, ...]:
+        return _unique_paths((*self.tracked, *self.visible_untracked))
+
+
 @dataclass(frozen=True)
 class BookkeepingResult:
     """Result from an optional bookkeeping commit boundary."""
@@ -42,6 +69,81 @@ def _repo_path(project_root: Path, path: Path) -> str:
         return path.as_posix()
 
 
+def _tracked_status_result(project_root: Path) -> GitCommandResult:
+    return run_git_command(project_root, ("status", "--porcelain=v1", "-z", "--untracked-files=no", "--", "."))
+
+
+def _untracked_status_result(project_root: Path) -> GitCommandResult:
+    return run_git_command(
+        project_root,
+        ("ls-files", "--others", "--exclude-standard", "-z", "--", ".", *UNTRACKED_TRANSIENT_EXCLUDES),
+    )
+
+
+def _unique_paths(paths: Sequence[str]) -> tuple[str, ...]:
+    return tuple(dict.fromkeys(path for path in paths if path))
+
+
+def _literal_pathspecs(paths: Sequence[str]) -> tuple[str, ...]:
+    return tuple(f":(top,literal){path}" for path in paths)
+
+
+def _status_record_paths(stdout: str) -> tuple[str, ...]:
+    """Decode exact paths from NUL-delimited porcelain-v1 records."""
+    records = stdout.split("\0")
+    changed: list[str] = []
+    index = 0
+    while index < len(records):
+        record = records[index]
+        index += 1
+        if not record:
+            continue
+        if len(record) < 4 or record[2] != " ":
+            continue
+        status = record[:2]
+        changed.append(record[3:])
+        if "R" in status or "C" in status:
+            if index < len(records) and records[index]:
+                changed.append(records[index])
+                index += 1
+    return _unique_paths(changed)
+
+
+def _preflight_workspace(project_root: Path) -> tuple[PreflightWorkspace | None, GitCommandResult | None]:
+    tracked_result = _tracked_status_result(project_root)
+    if tracked_result.return_code != 0:
+        return None, tracked_result
+    untracked_result = _untracked_status_result(project_root)
+    if untracked_result.return_code != 0:
+        return None, untracked_result
+
+    tracked = _status_record_paths(tracked_result.stdout)
+    visible_untracked = _unique_paths(untracked_result.stdout.split("\0"))
+    unsafe_local = tuple(path for path in tracked if path in LOCAL_ONLY_PLATFORM_PATHS)
+    return PreflightWorkspace(tracked, visible_untracked, unsafe_local), None
+
+
+def _preflight_failure(message: str) -> GitCommandResult:
+    return GitCommandResult(args=("status", "preflight"), return_code=1, stdout="", stderr=message)
+
+
+def _remaining_preflight_changes(project_root: Path) -> GitCommandResult:
+    workspace, failure = _preflight_workspace(project_root)
+    if failure is not None:
+        return failure
+    assert workspace is not None
+    if workspace.unsafe_local:
+        return _preflight_failure(
+            "Refusing to auto-commit local-only platform settings: " + ", ".join(workspace.unsafe_local)
+        )
+    return GitCommandResult(
+        args=("status", "preflight"),
+        return_code=0,
+        stdout="\0".join(workspace.preservable),
+        stderr="",
+    )
+
+
 def _visible_status_result(project_root: Path) -> GitCommandResult:
     return run_git_command(project_root, ("status", "--porcelain", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES))
 
@@ -85,23 +187,33 @@ def commit_bookkeeping_changes(
 
 
 def commit_preflight_ready_changes(project_root: Path, item_id: str) -> BookkeepingResult:
-    """Preserve visible pre-existing changes before task branch setup."""
-    visible_status = _visible_status_result(project_root)
-    if visible_status.return_code != 0:
-        return BookkeepingResult(attempted=True, committed=False, result=visible_status)
-    paths = _paths_from_status(visible_status.stdout)
+    """Preserve tracked changes and visible untracked files before task branch setup."""
+    workspace, failure = _preflight_workspace(project_root)
+    if failure is not None:
+        return BookkeepingResult(attempted=True, committed=False, result=failure)
+    assert workspace is not None
+    if workspace.unsafe_local:
+        return BookkeepingResult(
+            attempted=True,
+            committed=False,
+            result=_preflight_failure(
+                "Refusing to auto-commit local-only platform settings: " + ", ".join(workspace.unsafe_local)
+            ),
+        )
+    paths = workspace.preservable
     if not paths:
         return BookkeepingResult(attempted=False, committed=False)
-    add_result = run_git_command(project_root, ("add", "-A", "-f", "--", *paths))
+    pathspecs = _literal_pathspecs(paths)
+    add_result = run_git_command(project_root, ("add", "-A", "-f", "--", *pathspecs))
     if add_result.return_code != 0:
         return BookkeepingResult(attempted=True, committed=False, result=add_result)
     result = run_git_command(
         project_root,
-        ("commit", "--no-verify", "-m", f"chore: ready for {item_id}", "--", *paths),
+        ("commit", "--no-verify", "-m", f"chore: ready for {item_id}", "--", *pathspecs),
     )
     if result.return_code != 0:
         return BookkeepingResult(attempted=True, committed=False, result=result)
-    clean_result = _visible_status_result(project_root)
+    clean_result = _remaining_preflight_changes(project_root)
     if clean_result.return_code != 0 or clean_result.stdout.strip():
         return BookkeepingResult(attempted=True, committed=False, result=clean_result)
     return BookkeepingResult(attempted=True, committed=True, result=result)

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

@@ -107,31 +107,39 @@ def _run_pipeline(family: RunnerFamily, invocation: RunnerInvocation, paths) ->
     from .runner_models import PipelineRunResult
 
     processed = 0
-    details: list[str] = []
+    item_statuses: dict[str, str] = {}
     if invocation.item_id:
         try:
             status = _process_item(family, invocation, invocation.item_id, paths, initial_metadata={})
         except KeyboardInterrupt:
-            return PipelineRunResult(False, 1, "interrupted", "interrupted", tuple(details))
-        return PipelineRunResult(status == "completed", 1, "single_item_done", status, tuple(details))
+            return PipelineRunResult(False, 1, "interrupted", "interrupted")
+        return PipelineRunResult(status == "completed", 1, "single_item_done", status)
 
     while True:
         next_result = get_next(family, invocation, paths.project_root)
+        details = _render_item_statuses(item_statuses)
         if not next_result.ok:
             return PipelineRunResult(False, processed, "get_next_failed", details=(next_result.text,))
         marker = next_result.stdout.strip()
         if marker == "PIPELINE_COMPLETE":
-            if _has_non_terminal_details(details):
+            blocking_statuses = _blocking_statuses(family, item_statuses)
+            if blocking_statuses:
                 return PipelineRunResult(
                     False,
                     processed,
                     "pipeline_complete_with_non_terminal_history",
-                    _last_detail_status(details),
-                    tuple(details),
+                    blocking_statuses[-1],
+                    details,
                 )
-            return PipelineRunResult(True, processed, "pipeline_complete", details=tuple(details))
+            return PipelineRunResult(
+                True,
+                processed,
+                "pipeline_complete",
+                _last_item_status(item_statuses),
+                details,
+            )
         if marker == "PIPELINE_BLOCKED":
-            return PipelineRunResult(False, processed, "pipeline_blocked", details=tuple(details))
+            return PipelineRunResult(False, processed, "pipeline_blocked", details=details)
         if not isinstance(next_result.data, dict):
             return PipelineRunResult(False, processed, "invalid_get_next_output", details=(marker[:500],))
         item_id = str(next_result.data.get(f"{family.kind}_id") or next_result.data.get("feature_id") or next_result.data.get("bug_id") or next_result.data.get("refactor_id") or "")
@@ -141,50 +149,50 @@ def _run_pipeline(family: RunnerFamily, invocation: RunnerInvocation, paths) ->
             final_status = _process_item(family, invocation, item_id, paths, initial_metadata=next_result.data)
         except KeyboardInterrupt:
             processed += 1
-            details.append(f"{item_id}:interrupted")
-            return PipelineRunResult(False, processed, "interrupted", "interrupted", tuple(details))
+            item_statuses[item_id] = "interrupted"
+            return PipelineRunResult(
+                False,
+                processed,
+                "interrupted",
+                "interrupted",
+                _render_item_statuses(item_statuses),
+            )
         processed += 1
-        details.append(f"{item_id}:{final_status}")
-        if final_status == "completed":
-            _emit_info(f"Pausing 5s before next {family.kind}...")
+        item_statuses[item_id] = final_status
+        if final_status in _completion_compatible_statuses(family):
+            if final_status == "completed":
+                _emit_info(f"Pausing 5s before next {family.kind}...")
             continue
         if final_status == "pending":
             continue
+        details = _render_item_statuses(item_statuses)
         if RunnerEnvironment.from_env().stop_on_failure:
-            return PipelineRunResult(False, processed, "stop_on_failure", final_status, tuple(details))
+            return PipelineRunResult(False, processed, "stop_on_failure", final_status, details)
         if final_status in {"failed", "needs_info"}:
-            return PipelineRunResult(False, processed, "item_failed", final_status, tuple(details))
+            return PipelineRunResult(False, processed, "item_failed", final_status, details)
+
 
+_COMPLETION_COMPATIBLE_STATUSES = {"completed", "skipped", "auto_skipped"}
 
-_NON_TERMINAL_DETAIL_STATUSES = {
-    "pending",
-    "retryable",
-    "in_progress",
-    "infra_error",
-    "context_overflow",
-    "stalled_context_continuation",
-    "crashed",
-    "timed_out",
-    "failed",
-    "needs_info",
-    "merge_conflict",
-    "interrupted",
-    "unknown",
-}
 
+def _completion_compatible_statuses(family: RunnerFamily) -> set[str]:
+    statuses = set(_COMPLETION_COMPATIBLE_STATUSES)
+    if family.kind == "feature":
+        statuses.add("split")
+    return statuses
 
-def _detail_status(detail: str) -> str:
-    return detail.rsplit(":", 1)[-1] if ":" in detail else detail
 
+def _render_item_statuses(item_statuses: Mapping[str, str]) -> tuple[str, ...]:
+    return tuple(f"{item_id}:{status}" for item_id, status in item_statuses.items())
 
-def _last_detail_status(details: list[str]) -> str:
-    if not details:
-        return ""
-    return _detail_status(details[-1])
+
+def _last_item_status(item_statuses: Mapping[str, str]) -> str:
+    return next(reversed(item_statuses.values()), "")
 
 
-def _has_non_terminal_details(details: list[str]) -> bool:
-    return any(_detail_status(detail) in _NON_TERMINAL_DETAIL_STATUSES for detail in details)
+def _blocking_statuses(family: RunnerFamily, item_statuses: Mapping[str, str]) -> tuple[str, ...]:
+    compatible = _completion_compatible_statuses(family)
+    return tuple(status for status in item_statuses.values() if status not in compatible)
 
 
 _SEPARATOR = "─" * 52