prizmkit 1.0.45 → 1.0.58

package/bundled/team/prizm-dev-team.json

@@ -19,14 +19,14 @@
       "name": "dev",
       "role": "developer",
       "agentDefinition": "prizm-dev-team-dev",
-      "prompt": "You are a Dev Agent of the prizm-dev-team. Follow prizmkit.implement workflow with TDD. Read tasks.md/plan.md/spec.md, implement task-by-task, mark completed tasks [x]. Check .prizm-docs/ TRAPS before implementing.",
+      "prompt": "You are a Dev Agent of the prizm-dev-team. Follow /prizmkit-implement workflow with TDD. Read tasks.md/plan.md/spec.md, implement task-by-task, mark completed tasks [x]. Check .prizm-docs/ TRAPS before implementing.",
       "subscriptions": ["*"]
     },
     {
       "name": "reviewer",
       "role": "reviewer",
       "agentDefinition": "prizm-dev-team-reviewer",
-      "prompt": "You are the Reviewer Agent of the prizm-dev-team. In Phase 4: run prizmkit.analyze for cross-document consistency. In Phase 6: run prizmkit.code-review for spec compliance and code quality, write and execute integration tests.",
+      "prompt": "You are the Reviewer Agent of the prizm-dev-team. In Phase 4: run /prizmkit-analyze for cross-document consistency. In Phase 6: run /prizmkit-code-review for spec compliance and code quality, write and execute integration tests.",
       "subscriptions": ["*"]
     }
   ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prizmkit",
-  "version": "1.0.45",
+  "version": "1.0.58",
   "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

@@ -367,7 +367,7 @@ export async function installSettings(platform, projectRoot, options, dryRun) {
 
     // Read hook definition from unified template
     const templatesDir = getTemplatesDir();
-    const hookTemplate = await fs.readJSON(path.join(templatesDir, 'hooks', 'commit-intent-codebuddy.json'));
+    const hookTemplate = await fs.readJSON(path.join(templatesDir, 'hooks', 'commit-intent.json'));
 
     await fs.writeFile(settingsPath, JSON.stringify(hookTemplate, null, 2));
     console.log(chalk.green(`      ✓ .codebuddy/settings.json`));
@@ -392,7 +392,7 @@ export async function installSettings(platform, projectRoot, options, dryRun) {
 
     // Read hook definition from unified template
     const templatesDir = getTemplatesDir();
-    const hookTemplate = await fs.readJSON(path.join(templatesDir, 'hooks', 'commit-intent-claude.json'));
+    const hookTemplate = await fs.readJSON(path.join(templatesDir, 'hooks', 'commit-intent.json'));
 
     // Settings
     const permissions = [
@@ -508,7 +508,7 @@ export async function installPrizmkitScripts(projectRoot, dryRun) {
 async function installProjectMemory(platform, projectRoot, dryRun) {
   const templatesDir = getTemplatesDir();
   const skillsDir = getSkillsDir();
-  const templateName = platform === 'claude' ? 'claude-md-template.md' : 'codebuddy-md-template.md';
+  const templateName = 'project-memory-template.md';
   const targetName = platform === 'claude' ? 'CLAUDE.md' : 'CODEBUDDY.md';
   const targetPath = path.join(projectRoot, targetName);
 

package/bundled/dev-pipeline/lib/worktree.sh

@@ -1,164 +0,0 @@
-#!/usr/bin/env bash
-# ============================================================
-# dev-pipeline/lib/worktree.sh - Git Worktree Lifecycle Library
-#
-# Shared by run.sh and run-bugfix.sh to isolate AI CLI sessions
-# in separate git worktrees. Each session runs on its own branch
-# inside a worktree directory, enabling parallel-safe execution
-# and clean main branch history.
-#
-# Functions:
-#   worktree_create      — Create worktree + branch before session
-#   worktree_merge       — Merge worktree branch into target after success
-#   worktree_cleanup     — Remove worktree directory and branch
-#   worktree_prune_stale — Prune stale worktree references
-#
-# Environment:
-#   USE_WORKTREE  — Set to 1 to enable (default), 0 to disable
-#   AUTO_PUSH     — Set to 1 to auto-push after successful merge
-# ============================================================
-
-# worktree_create <project_root> <worktree_base_dir> <session_id> <source_branch>
-#
-# Creates a git worktree and sets global vars:
-#   _WORKTREE_PATH   — absolute path to the worktree directory
-#   _WORKTREE_BRANCH — branch name (worktree/<session_id>)
-#
-# Returns 0 on success, 1 on failure.
-worktree_create() {
-    local project_root="$1"
-    local worktree_base_dir="$2"
-    local session_id="$3"
-    local source_branch="$4"
-
-    _WORKTREE_PATH=""
-    _WORKTREE_BRANCH=""
-
-    local branch_name="worktree/${session_id}"
-    local worktree_path="${worktree_base_dir}/${session_id}"
-
-    # Ensure base directory exists
-    mkdir -p "$worktree_base_dir"
-
-    # Check if worktree path already exists
-    if [[ -d "$worktree_path" ]]; then
-        log_warn "Worktree path already exists: $worktree_path"
-        return 1
-    fi
-
-    # Check if branch already exists
-    if git -C "$project_root" rev-parse --verify "$branch_name" >/dev/null 2>&1; then
-        log_warn "Branch already exists: $branch_name"
-        return 1
-    fi
-
-    # Create worktree with new branch
-    if ! git -C "$project_root" worktree add -b "$branch_name" "$worktree_path" "$source_branch" 2>/dev/null; then
-        log_error "Failed to create worktree at $worktree_path"
-        return 1
-    fi
-
-    _WORKTREE_PATH="$worktree_path"
-    _WORKTREE_BRANCH="$branch_name"
-
-    log_info "Created worktree: $worktree_path (branch: $branch_name)"
-    return 0
-}
-
-# worktree_merge <project_root> <worktree_branch> <target_branch> <item_id> <session_id>
-#
-# Merges worktree branch into target branch (no fast-forward).
-# Sets global var:
-#   _MERGE_RESULT — "success", "conflict", or "error"
-#
-# Returns 0 on success, 1 on conflict, 2 on other error.
-worktree_merge() {
-    local project_root="$1"
-    local worktree_branch="$2"
-    local target_branch="$3"
-    local item_id="$4"
-    local session_id="$5"
-
-    _MERGE_RESULT=""
-
-    # Switch to target branch in the main working tree
-    local current_branch
-    current_branch=$(git -C "$project_root" rev-parse --abbrev-ref HEAD 2>/dev/null) || {
-        log_error "Failed to determine current branch"
-        _MERGE_RESULT="error"
-        return 2
-    }
-
-    if [[ "$current_branch" != "$target_branch" ]]; then
-        if ! git -C "$project_root" checkout "$target_branch" 2>/dev/null; then
-            log_error "Failed to checkout target branch: $target_branch"
-            _MERGE_RESULT="error"
-            return 2
-        fi
-    fi
-
-    # Attempt merge (no fast-forward to preserve history)
-    local merge_msg="Merge ${worktree_branch} for ${item_id} (session: ${session_id})"
-    if git -C "$project_root" merge --no-ff -m "$merge_msg" "$worktree_branch" 2>/dev/null; then
-        _MERGE_RESULT="success"
-        log_success "Merged $worktree_branch into $target_branch"
-        return 0
-    else
-        # Check if it's a merge conflict
-        if git -C "$project_root" diff --name-only --diff-filter=U 2>/dev/null | head -1 | read -r _; then
-            # Abort the merge to leave working tree clean
-            git -C "$project_root" merge --abort 2>/dev/null || true
-            _MERGE_RESULT="conflict"
-            log_warn "Merge conflict detected for $worktree_branch"
-            return 1
-        else
-            git -C "$project_root" merge --abort 2>/dev/null || true
-            _MERGE_RESULT="error"
-            log_error "Merge failed for $worktree_branch"
-            return 2
-        fi
-    fi
-}
-
-# worktree_cleanup <project_root> <worktree_path> <worktree_branch>
-#
-# Removes worktree directory and deletes the branch.
-# Idempotent — safe to call even if worktree/branch don't exist.
-#
-# Returns 0 always.
-worktree_cleanup() {
-    local project_root="$1"
-    local worktree_path="$2"
-    local worktree_branch="$3"
-
-    # Remove the worktree (if it exists)
-    if [[ -n "$worktree_path" && -d "$worktree_path" ]]; then
-        git -C "$project_root" worktree remove --force "$worktree_path" 2>/dev/null || {
-            # Fallback: manual removal
-            rm -rf "$worktree_path" 2>/dev/null || true
-        }
-        log_info "Removed worktree: $worktree_path"
-    fi
-
-    # Delete the branch (if it exists)
-    if [[ -n "$worktree_branch" ]]; then
-        git -C "$project_root" branch -D "$worktree_branch" 2>/dev/null || true
-    fi
-
-    # Prune stale worktree entries
-    git -C "$project_root" worktree prune 2>/dev/null || true
-
-    return 0
-}
-
-# worktree_prune_stale <project_root>
-#
-# Runs `git worktree prune` to clean up stale worktree references.
-#
-# Returns 0 always.
-worktree_prune_stale() {
-    local project_root="$1"
-
-    git -C "$project_root" worktree prune 2>/dev/null || true
-    return 0
-}

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

@@ -1,131 +0,0 @@
-"""Tests for check-session-status.py."""
-
-import json
-import os
-import sys
-import pytest
-
-
-def _import_check_session():
-    import importlib.util
-    path = os.path.join(
-        os.path.dirname(__file__), "..", "scripts", "check-session-status.py"
-    )
-    spec = importlib.util.spec_from_file_location("check_session_status", path)
-    mod = importlib.util.module_from_spec(spec)
-    sys.modules["check_session_status"] = mod
-    spec.loader.exec_module(mod)
-    return mod
-
-
-css = _import_check_session()
-validate_required_fields = css.validate_required_fields
-determine_status = css.determine_status
-
-
-class TestValidateRequiredFields:
-    def test_all_present(self):
-        data = {
-            "session_id": "s-001",
-            "feature_id": "F-001",
-            "status": "success",
-            "timestamp": "2024-01-01T00:00:00Z",
-        }
-        missing = validate_required_fields(data)
-        assert missing == []
-
-    def test_missing_session_id(self):
-        data = {
-            "feature_id": "F-001",
-            "status": "success",
-            "timestamp": "2024-01-01T00:00:00Z",
-        }
-        missing = validate_required_fields(data)
-        assert "session_id" in missing
-
-    def test_missing_multiple(self):
-        data = {"feature_id": "F-001"}
-        missing = validate_required_fields(data)
-        assert "session_id" in missing
-        assert "status" in missing
-        assert "timestamp" in missing
-
-    def test_empty_string_field(self):
-        data = {
-            "session_id": "",
-            "feature_id": "F-001",
-            "status": "success",
-            "timestamp": "2024-01-01T00:00:00Z",
-        }
-        missing = validate_required_fields(data)
-        assert "session_id" in missing
-
-    def test_whitespace_only_field(self):
-        data = {
-            "session_id": "   ",
-            "feature_id": "F-001",
-            "status": "success",
-            "timestamp": "2024-01-01T00:00:00Z",
-        }
-        missing = validate_required_fields(data)
-        assert "session_id" in missing
-
-    def test_non_string_field(self):
-        data = {
-            "session_id": 123,
-            "feature_id": "F-001",
-            "status": "success",
-            "timestamp": "2024-01-01T00:00:00Z",
-        }
-        missing = validate_required_fields(data)
-        assert "session_id" in missing
-
-    def test_empty_data(self):
-        missing = validate_required_fields({})
-        assert len(missing) == 4
-
-
-class TestDetermineStatus:
-    def test_success(self):
-        data = {"status": "success"}
-        assert determine_status(data) == "success"
-
-    def test_failed(self):
-        data = {"status": "failed"}
-        assert determine_status(data) == "failed"
-
-    def test_partial_resumable(self):
-        data = {"status": "partial", "can_resume": True}
-        assert determine_status(data) == "partial_resumable"
-
-    def test_partial_not_resumable(self):
-        data = {"status": "partial", "can_resume": False}
-        assert determine_status(data) == "partial_not_resumable"
-
-    def test_partial_no_resume_key(self):
-        data = {"status": "partial"}
-        assert determine_status(data) == "partial_not_resumable"
-
-    def test_commit_missing(self):
-        data = {"status": "commit_missing"}
-        assert determine_status(data) == "commit_missing"
-
-    def test_docs_missing(self):
-        data = {"status": "docs_missing"}
-        assert determine_status(data) == "docs_missing"
-
-    def test_merge_conflict(self):
-        data = {"status": "merge_conflict"}
-        assert determine_status(data) == "merge_conflict"
-
-    def test_unknown_status(self):
-        data = {"status": "something_weird"}
-        assert determine_status(data) == "crashed"
-
-    def test_empty_status(self):
-        data = {"status": ""}
-        assert determine_status(data) == "crashed"
-
-    def test_missing_status(self):
-        data = {}
-        assert determine_status(data) == "crashed"

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

@@ -1,119 +0,0 @@
-"""Tests for cleanup-logs.py."""
-
-import json
-import os
-import subprocess
-import sys
-import time
-
-
-def _script_path():
-    return os.path.join(
-        os.path.dirname(__file__), "..", "scripts", "cleanup-logs.py"
-    )
-
-
-def _write_log_file(path, content):
-    os.makedirs(os.path.dirname(path), exist_ok=True)
-    with open(path, "w", encoding="utf-8") as f:
-        f.write(content)
-
-
-def test_iter_log_files_only_sessions_logs(state_dir):
-    # Targeted log path under sessions/*/logs/
-    valid_log = os.path.join(
-        state_dir, "features", "F-001", "sessions", "S-001", "logs", "session.log"
-    )
-    _write_log_file(valid_log, "ok")
-
-    # logs/ not under sessions should be ignored
-    ignored_log = os.path.join(state_dir, "features", "F-001", "logs", "misc.log")
-    _write_log_file(ignored_log, "ignore me")
-
-    # Import script module for direct function test
-    import importlib.util
-
-    path = _script_path()
-    spec = importlib.util.spec_from_file_location("cleanup_logs", path)
-    mod = importlib.util.module_from_spec(spec)
-    sys.modules["cleanup_logs"] = mod
-    spec.loader.exec_module(mod)
-
-    files = list(mod.iter_log_files(state_dir))
-    assert valid_log in files
-    assert ignored_log not in files
-
-
-def test_cleanup_removes_old_logs_by_retention(state_dir):
-    old_log = os.path.join(
-        state_dir, "features", "F-001", "sessions", "S-001", "logs", "session.log"
-    )
-    new_log = os.path.join(
-        state_dir, "features", "F-001", "sessions", "S-002", "logs", "session.log"
-    )
-
-    _write_log_file(old_log, "old")
-    _write_log_file(new_log, "new")
-
-    # Make old log 20 days old
-    old_ts = time.time() - (20 * 86400)
-    os.utime(old_log, (old_ts, old_ts))
-
-    result = subprocess.run(
-        [
-            sys.executable,
-            _script_path(),
-            "--state-dir",
-            state_dir,
-            "--retention-days",
-            "14",
-            "--max-total-mb",
-            "1024",
-        ],
-        check=True,
-        capture_output=True,
-        text=True,
-    )
-
-    report = json.loads(result.stdout)
-    assert report["deleted_by_reason"]["retention"] >= 1
-    assert not os.path.exists(old_log)
-    assert os.path.exists(new_log)
-
-
-def test_cleanup_enforces_total_size_cap(state_dir):
-    log1 = os.path.join(
-        state_dir, "features", "F-001", "sessions", "S-001", "logs", "session.log"
-    )
-    log2 = os.path.join(
-        state_dir, "features", "F-001", "sessions", "S-002", "logs", "session.log"
-    )
-
-    _write_log_file(log1, "a" * 1024)
-    _write_log_file(log2, "b" * 1024)
-
-    # Ensure deterministic ordering: log1 older than log2
-    old_ts = time.time() - 120
-    new_ts = time.time() - 60
-    os.utime(log1, (old_ts, old_ts))
-    os.utime(log2, (new_ts, new_ts))
-
-    result = subprocess.run(
-        [
-            sys.executable,
-            _script_path(),
-            "--state-dir",
-            state_dir,
-            "--retention-days",
-            "999",
-            "--max-total-mb",
-            "0",
-        ],
-        check=True,
-        capture_output=True,
-        text=True,
-    )
-
-    report = json.loads(result.stdout)
-    assert report["deleted_by_reason"]["size"] >= 1
-    assert report["final_total_bytes"] == 0

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

@@ -1,207 +0,0 @@
-"""Tests for detect-stuck.py."""
-
-import json
-import os
-import sys
-import pytest
-from datetime import datetime, timezone, timedelta
-
-
-def _import_detect_stuck():
-    import importlib.util
-    path = os.path.join(
-        os.path.dirname(__file__), "..", "scripts", "detect-stuck.py"
-    )
-    spec = importlib.util.spec_from_file_location("detect_stuck", path)
-    mod = importlib.util.module_from_spec(spec)
-    sys.modules["detect_stuck"] = mod
-    spec.loader.exec_module(mod)
-    return mod
-
-
-ds = _import_detect_stuck()
-parse_iso_timestamp = ds.parse_iso_timestamp
-check_max_retries = ds.check_max_retries
-check_stuck_checkpoint = ds.check_stuck_checkpoint
-check_dependency_deadlock = ds.check_dependency_deadlock
-
-
-class TestParseIsoTimestamp:
-    def test_standard_z_format(self):
-        result = parse_iso_timestamp("2024-01-15T10:30:00Z")
-        assert result is not None
-        assert result.year == 2024
-        assert result.month == 1
-        assert result.day == 15
-        assert result.hour == 10
-        assert result.minute == 30
-
-    def test_plus_zero_offset(self):
-        result = parse_iso_timestamp("2024-01-15T10:30:00+00:00")
-        assert result is not None
-        assert result.year == 2024
-
-    def test_with_microseconds_z(self):
-        result = parse_iso_timestamp("2024-01-15T10:30:00.123456Z")
-        assert result is not None
-
-    def test_with_microseconds_offset(self):
-        result = parse_iso_timestamp("2024-01-15T10:30:00.123456+00:00")
-        assert result is not None
-
-    def test_invalid_string(self):
-        result = parse_iso_timestamp("not a timestamp")
-        assert result is None
-
-    def test_none_input(self):
-        result = parse_iso_timestamp(None)
-        assert result is None
-
-    def test_integer_input(self):
-        result = parse_iso_timestamp(12345)
-        assert result is None
-
-    def test_empty_string(self):
-        result = parse_iso_timestamp("")
-        assert result is None
-
-
-class TestCheckMaxRetries:
-    def test_below_max(self):
-        status = {"retry_count": 1}
-        result = check_max_retries(status, 3)
-        assert result is None
-
-    def test_at_max(self):
-        status = {"retry_count": 3}
-        result = check_max_retries(status, 3)
-        assert result is not None
-        assert result["reason"] == "max_retries_exceeded"
-
-    def test_above_max(self):
-        status = {"retry_count": 5}
-        result = check_max_retries(status, 3)
-        assert result is not None
-
-    def test_zero_retries(self):
-        status = {"retry_count": 0}
-        result = check_max_retries(status, 3)
-        assert result is None
-
-    def test_missing_retry_count(self):
-        status = {}
-        result = check_max_retries(status, 3)
-        assert result is None  # defaults to 0
-
-    def test_non_int_retry_count(self):
-        status = {"retry_count": "not a number"}
-        result = check_max_retries(status, 3)
-        assert result is None
-
-
-class TestCheckStuckCheckpoint:
-    def _setup_sessions(self, tmp_path, checkpoints):
-        """Create a feature dir with sessions having given checkpoints."""
-        feature_dir = tmp_path / "feature"
-        sessions_dir = feature_dir / "sessions"
-        for i, cp in enumerate(checkpoints):
-            session_dir = sessions_dir / "session-{:03d}".format(i)
-            session_dir.mkdir(parents=True)
-            data = {"checkpoint_reached": cp}
-            (session_dir / "session-status.json").write_text(
-                json.dumps(data), encoding="utf-8"
-            )
-        return str(feature_dir)
-
-    def test_stuck_at_same_checkpoint(self, tmp_path):
-        feature_dir = self._setup_sessions(tmp_path, ["CP-3", "CP-3", "CP-3"])
-        result = check_stuck_checkpoint(feature_dir)
-        assert result is not None
-        assert result["reason"] == "stuck_at_checkpoint"
-        assert "CP-3" in result["details"]
-
-    def test_different_checkpoints(self, tmp_path):
-        feature_dir = self._setup_sessions(tmp_path, ["CP-1", "CP-2", "CP-3"])
-        result = check_stuck_checkpoint(feature_dir)
-        assert result is None
-
-    def test_fewer_than_three_sessions(self, tmp_path):
-        feature_dir = self._setup_sessions(tmp_path, ["CP-3", "CP-3"])
-        result = check_stuck_checkpoint(feature_dir)
-        assert result is None
-
-    def test_no_sessions(self, tmp_path):
-        feature_dir = tmp_path / "feature"
-        feature_dir.mkdir()
-        result = check_stuck_checkpoint(str(feature_dir))
-        assert result is None
-
-    def test_none_checkpoints(self, tmp_path):
-        feature_dir = self._setup_sessions(tmp_path, [None, None, None])
-        result = check_stuck_checkpoint(feature_dir)
-        assert result is None  # None checkpoints don't trigger stuck
-
-    def test_mixed_with_last_three_same(self, tmp_path):
-        feature_dir = self._setup_sessions(
-            tmp_path, ["CP-1", "CP-2", "CP-3", "CP-3", "CP-3"]
-        )
-        result = check_stuck_checkpoint(feature_dir)
-        assert result is not None
-        assert "CP-3" in result["details"]
-
-
-class TestCheckDependencyDeadlock:
-    def test_dependency_failed(self, state_dir):
-        # Create a failed dependency
-        dep_dir = os.path.join(state_dir, "features", "F-001")
-        os.makedirs(dep_dir, exist_ok=True)
-        with open(os.path.join(dep_dir, "status.json"), "w") as f:
-            json.dump({"status": "failed"}, f)
-
-        feature_list_data = {
-            "features": [
-                {"id": "F-001", "dependencies": []},
-                {"id": "F-002", "dependencies": ["F-001"]},
-            ]
-        }
-        result = check_dependency_deadlock("F-002", feature_list_data, state_dir)
-        assert result is not None
-        assert result["reason"] == "dependency_failed"
-        assert "F-001" in result["details"]
-
-    def test_dependency_completed(self, state_dir):
-        dep_dir = os.path.join(state_dir, "features", "F-001")
-        os.makedirs(dep_dir, exist_ok=True)
-        with open(os.path.join(dep_dir, "status.json"), "w") as f:
-            json.dump({"status": "completed"}, f)
-
-        feature_list_data = {
-            "features": [
-                {"id": "F-001", "dependencies": []},
-                {"id": "F-002", "dependencies": ["F-001"]},
-            ]
-        }
-        result = check_dependency_deadlock("F-002", feature_list_data, state_dir)
-        assert result is None
-
-    def test_no_dependencies(self, state_dir):
-        feature_list_data = {
-            "features": [
-                {"id": "F-001", "dependencies": []},
-            ]
-        }
-        result = check_dependency_deadlock("F-001", feature_list_data, state_dir)
-        assert result is None
-
-    def test_none_feature_list(self, state_dir):
-        result = check_dependency_deadlock("F-001", None, state_dir)
-        assert result is None
-
-    def test_feature_not_found(self, state_dir):
-        feature_list_data = {
-            "features": [
-                {"id": "F-001", "dependencies": []},
-            ]
-        }
-        result = check_dependency_deadlock("F-999", feature_list_data, state_dir)
-        assert result is None