prizmkit 1.1.108 → 1.1.110

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.108",
-  "bundledAt": "2026-07-08T01:30:44.419Z",
-  "bundledFrom": "d04466a"
+  "frameworkVersion": "1.1.110",
+  "bundledAt": "2026-07-08T05:42:13.015Z",
+  "bundledFrom": "84797b8"
 }

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

@@ -9,6 +9,7 @@ from collections.abc import Sequence
 from .commands import CommandResult, handle_diagnostics, handle_runtime_command
 from .compat import UnsupportedPythonVersion, ensure_supported_python
 from .paths import resolve_runtime_paths
+from .runtime_helper import render_result, run_helper_command
 
 DESCRIPTION = (
     "PrizmKit canonical Python runtime CLI.\n"
@@ -81,6 +82,16 @@ def _add_diagnostics_subparsers(subparsers: argparse._SubParsersAction[argparse.
         action_parser.set_defaults(handler="diagnostics", action=action)
 
 
+def _add_helper_subparser(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    helper_parser = subparsers.add_parser("helper", help="Cross-platform prompt runtime helper commands")
+    helper_parser.add_argument(
+        "args",
+        nargs=argparse.REMAINDER,
+        help="Arguments forwarded to prizmkit-runtime-helper.",
+    )
+    helper_parser.set_defaults(handler="helper", group="helper", action="run", target=None)
+
+
 _PIPELINE_GROUPS = {"feature", "bugfix", "refactor", "recovery"}
 _GLOBAL_OPTIONS_WITH_VALUES = {"--project-root", "--pipeline-root"}
 
@@ -150,6 +161,7 @@ def build_parser() -> argparse.ArgumentParser:
     _add_daemon_subparsers(subparsers)
     _add_status_subparsers(subparsers)
     _add_diagnostics_subparsers(subparsers)
+    _add_helper_subparser(subparsers)
     return parser
 
 
@@ -161,6 +173,14 @@ def _dispatch(args: argparse.Namespace) -> CommandResult:
     paths = _runtime_paths_from_args(args)
     if args.handler == "diagnostics":
         return handle_diagnostics(args.action, paths)
+    if args.handler == "helper":
+        helper_result = run_helper_command(tuple(getattr(args, "args", ()) or ()))
+        return CommandResult(
+            helper_result.exit_code,
+            "Python runtime helper",
+            "Cross-platform prompt runtime helper result.",
+            stdout=render_result(helper_result, json_output="--json" in tuple(getattr(args, "args", ()) or ())),
+        )
     return handle_runtime_command(
         args.group,
         args.action,

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

@@ -280,6 +280,7 @@ def diagnostics_entrypoints(paths: RuntimePaths | None = None) -> CommandResult:
     details: list[str] = [
         f"runtime:cli: {runtime_paths.pipeline_root / 'cli.py'}",
         f"runtime:module: {runtime_paths.pipeline_root / 'prizmkit_runtime'}",
+        f"runtime:helper-module: {runtime_paths.pipeline_root / 'prizmkit_runtime' / 'runtime_helper.py'}",
     ]
     for name, relative_path in sorted(UTILITY_ENTRYPOINTS.items()):
         invocation = describe_existing_entrypoint("utility", name, paths=runtime_paths)

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

@@ -33,6 +33,8 @@ HIDDEN_TOOL_WORKTREE_EXCLUDES = (
     ":(top,exclude).prizmkit/manifest.json",
     ":(top,exclude).prizmkit/dev-pipeline/scripts",
     ":(top,exclude,glob).prizmkit/dev-pipeline/scripts/**",
+    ":(top,exclude).prizmkit/dev-pipeline/prizmkit_runtime",
+    ":(top,exclude,glob).prizmkit/dev-pipeline/prizmkit_runtime/**",
 )
 
 WORKTREE_PLATFORM_SUPPORT_DIRS = (".claude", ".codebuddy", ".codex", ".agents")
@@ -242,6 +244,14 @@ def materialize_worktree_support_assets(runtime: WorktreeRuntimeContext) -> Work
             target = target_root / ".prizmkit" / "dev-pipeline" / "scripts"
             changed = _copy_support_entry(runtime_scripts, target)
             (copied if changed else existing).append(target)
+
+        runtime_package = _runtime_support_package_source(source_root)
+        if runtime_package is None:
+            missing.append(".prizmkit/dev-pipeline/prizmkit_runtime")
+        else:
+            target = target_root / ".prizmkit" / "dev-pipeline" / "prizmkit_runtime"
+            changed = _copy_support_entry(runtime_package, target)
+            (copied if changed else existing).append(target)
     except OSError as exc:
         return WorktreeSupportAssetsResult(False, tuple(copied), tuple(existing), tuple(missing), str(exc))
 
@@ -276,6 +286,17 @@ def _runtime_support_scripts_source(project_root: Path) -> Path | None:
     return None
 
 
+def _runtime_support_package_source(project_root: Path) -> Path | None:
+    candidates = (
+        project_root / ".prizmkit" / "dev-pipeline" / "prizmkit_runtime",
+        project_root / "dev-pipeline" / "prizmkit_runtime",
+    )
+    for candidate in candidates:
+        if candidate.is_dir():
+            return candidate
+    return None
+
+
 def _copy_support_entry(source: Path, target: Path) -> bool:
     if source.is_symlink():
         if target.exists() or target.is_symlink():

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

@@ -24,6 +24,7 @@ UTILITY_ENTRYPOINTS = {
     "init-refactor-pipeline": "scripts/init-refactor-pipeline.py",
     "parse-stream-progress": "scripts/parse-stream-progress.py",
     "patch-completion-notes": "scripts/patch-completion-notes.py",
+    "prizmkit-runtime-helper": "scripts/prizmkit-runtime-helper.py",
     "update-bug-status": "scripts/update-bug-status.py",
     "update-checkpoint": "scripts/update-checkpoint.py",
     "update-feature-status": "scripts/update-feature-status.py",

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

@@ -0,0 +1,208 @@
+"""Shared AI platform and skill path detection for prompt/runtime helpers."""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import Path
+
+SUPPORTED_PLATFORMS = ("claude", "codex", "codebuddy")
+
+
+@dataclass(frozen=True)
+class PlatformResolution:
+    """Resolved AI platform plus the source that selected it."""
+
+    platform: str
+    source: str
+    notes: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class SkillCandidate:
+    """One possible filesystem location for a skill."""
+
+    platform: str
+    scope: str
+    path: Path
+
+
+@dataclass(frozen=True)
+class SkillResolution:
+    """Resolved skill lookup result."""
+
+    marker: str
+    platform: str
+    skill: str
+    path: Path | None
+    candidates: tuple[SkillCandidate, ...]
+
+
+_PLATFORM_MARKERS = {
+    "claude": (".claude/agents", ".claude/commands", ".claude/skills"),
+    "codex": (".codex/agents", ".agents/skills"),
+    "codebuddy": (".codebuddy/agents", ".codebuddy/skills"),
+}
+
+
+_PLATFORM_SKILL_PATTERNS = {
+    "claude": (
+        ("project-command-file", ".claude/commands/{skill}.md"),
+        ("project-command-dir", ".claude/commands/{skill}"),
+        ("project-skill", ".claude/skills/{skill}"),
+        ("home-skill", "~/.claude/skills/{skill}"),
+    ),
+    "codex": (
+        ("project-skill", ".agents/skills/{skill}"),
+        ("project-codex-skill", ".codex/skills/{skill}"),
+    ),
+    "codebuddy": (
+        ("project-skill", ".codebuddy/skills/{skill}"),
+        ("home-skill", "~/.codebuddy/skills/{skill}"),
+        ("legacy-home-skill", "~/.cbc/skills/{skill}"),
+    ),
+}
+
+
+def read_json_object(path: str | Path) -> dict:
+    """Read a JSON object, returning an empty dict when unavailable."""
+    try:
+        with Path(path).expanduser().open("r", encoding="utf-8") as handle:
+            data = json.load(handle)
+    except (OSError, json.JSONDecodeError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def platform_from_command(command: object) -> str:
+    """Map an AI CLI command/config value to a PrizmKit platform name."""
+    cmd = str(command or "").strip().lower()
+    if not cmd:
+        return ""
+    base = os.path.basename(cmd.split()[0])
+    if base in ("claude", "claude-code") or "claude" in base:
+        return "claude"
+    if base in ("codex", "openai-codex") or "codex" in base:
+        return "codex"
+    if base in ("cbc", "codebuddy") or "codebuddy" in base:
+        return "codebuddy"
+    return ""
+
+
+def valid_prompt_platform(value: object) -> str:
+    """Normalize a platform value for prompt path rendering."""
+    platform = str(value or "").strip().lower()
+    return platform if platform in SUPPORTED_PLATFORMS else ""
+
+
+def resolve_platform(project_root: str | Path, env: Mapping[str, str] | None = None) -> PlatformResolution:
+    """Resolve the platform whose paths should appear in prompts/helper output.
+
+    Precedence mirrors prompt generation: explicit environment, active/configured
+    AI CLI, PrizmKit config/manifest platform, then filesystem markers.
+    """
+    environment = os.environ if env is None else env
+    root = Path(project_root).expanduser().resolve()
+
+    explicit = valid_prompt_platform(environment.get("PRIZMKIT_PLATFORM", ""))
+    if explicit:
+        return PlatformResolution(explicit, "environment:PRIZMKIT_PLATFORM")
+
+    for env_name in ("AI_CLI", "CLAUDECODE", "CLAUDE_CODE", "CODEBUDDY_CLI"):
+        detected = platform_from_command(environment.get(env_name, ""))
+        if detected:
+            return PlatformResolution(detected, f"environment:{env_name}")
+
+    config = read_json_object(root / ".prizmkit" / "config.json")
+    for key in ("ai_cli", "aiCli"):
+        detected = platform_from_command(config.get(key, ""))
+        if detected:
+            return PlatformResolution(detected, f"config:{key}")
+    detected = valid_prompt_platform(config.get("platform", ""))
+    if detected:
+        return PlatformResolution(detected, "config:platform")
+
+    manifest = read_json_object(root / ".prizmkit" / "manifest.json")
+    options = manifest.get("options", {}) if isinstance(manifest.get("options"), dict) else {}
+    for key, value in (("aiCli", manifest.get("aiCli", "")), ("options.aiCli", options.get("aiCli", ""))):
+        detected = platform_from_command(value)
+        if detected:
+            return PlatformResolution(detected, f"manifest:{key}")
+    detected = valid_prompt_platform(manifest.get("platform", ""))
+    if detected:
+        return PlatformResolution(detected, "manifest:platform")
+
+    for platform in SUPPORTED_PLATFORMS:
+        for marker in _PLATFORM_MARKERS[platform]:
+            if (root / marker).is_dir():
+                return PlatformResolution(platform, f"filesystem:{marker}")
+
+    return PlatformResolution(
+        "",
+        "unresolved",
+        (
+            "No supported platform marker found. Set PRIZMKIT_PLATFORM, configure .prizmkit/config.json, "
+            "or install Claude/Codex/CodeBuddy platform files.",
+        ),
+    )
+
+
+def _expand_skill_pattern(project_root: Path, skill: str, platform: str, scope: str, pattern: str) -> SkillCandidate:
+    rendered = pattern.format(skill=skill)
+    if rendered.startswith("~"):
+        path = Path(rendered).expanduser()
+    else:
+        path = project_root / rendered
+    return SkillCandidate(platform=platform, scope=scope, path=path.resolve())
+
+
+def skill_candidates(project_root: str | Path, skill: str, platform: str) -> tuple[SkillCandidate, ...]:
+    """Return deterministic candidate locations for a skill on one platform."""
+    normalized = valid_prompt_platform(platform)
+    if not normalized:
+        return ()
+    root = Path(project_root).expanduser().resolve()
+    return tuple(
+        _expand_skill_pattern(root, skill, normalized, scope, pattern)
+        for scope, pattern in _PLATFORM_SKILL_PATTERNS[normalized]
+    )
+
+
+def _candidate_matches(candidate: SkillCandidate, skill: str, *, prefix: bool) -> bool:
+    path = candidate.path
+    if path.exists():
+        return True
+    if not prefix:
+        return False
+    parent = path.parent
+    if not parent.is_dir():
+        return False
+    return any(child.name.startswith(skill) for child in parent.iterdir())
+
+
+def resolve_skill(
+    project_root: str | Path,
+    skill: str,
+    *,
+    platform: str = "auto",
+    env: Mapping[str, str] | None = None,
+    prefix: bool = False,
+) -> SkillResolution:
+    """Resolve a skill path for the selected platform."""
+    normalized_skill = str(skill or "").strip()
+    selected_platform = valid_prompt_platform(platform)
+    if platform == "auto" or not platform:
+        selected_platform = resolve_platform(project_root, env=env).platform
+    if not selected_platform:
+        return SkillResolution("NOT_INSTALLED", "", normalized_skill, None, ())
+
+    candidates = skill_candidates(project_root, normalized_skill, selected_platform)
+    for candidate in candidates:
+        if _candidate_matches(candidate, normalized_skill, prefix=prefix):
+            if candidate.path.exists():
+                return SkillResolution("SKILL_EXISTS", selected_platform, normalized_skill, candidate.path, candidates)
+            matches = sorted(child for child in candidate.path.parent.iterdir() if child.name.startswith(normalized_skill))
+            return SkillResolution("SKILL_EXISTS", selected_platform, normalized_skill, matches[0].resolve(), candidates)
+    return SkillResolution("SKILL_MISSING", selected_platform, normalized_skill, None, candidates)