prizmkit 1.1.61 → 1.1.63

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.61",
-  "bundledAt": "2026-06-08T16:20:29.783Z",
-  "bundledFrom": "819ffc3"
+  "frameworkVersion": "1.1.63",
+  "bundledAt": "2026-06-08T18:06:47.062Z",
+  "bundledFrom": "72acb14"
 }

package/bundled/adapters/codex/settings-adapter.js

@@ -20,6 +20,7 @@ project_doc_fallback_filenames = ["CLAUDE.md", "CODEBUDDY.md"]
 
 [agents]
 max_depth = 1
+job_max_runtime_seconds = 840
 `;
 
   await writeFile(configPath, configToml);

package/bundled/adapters/codex/skill-adapter.js

@@ -16,12 +16,27 @@ function toCodexSkillReference(commandName) {
   return `PrizmKit skill \`${commandName}\` (\`.agents/skills/${commandName}/SKILL.md\`)`;
 }
 
+function applyCodexInteractionCompatibility(content) {
+  const fallbackInstruction = 'Use `request_user_input` when available. If unavailable in the current Codex surface, including Default mode, ask the same options directly in chat and wait for an explicit answer. Tool unavailability is not permission to choose defaults.';
+
+  return content
+    .replace(/\bAskUserQuestion\b/g, 'request_user_input')
+    .replace(
+      /Do NOT render options as plain text — the user must be able to click\/select\./g,
+      fallbackInstruction
+    )
+    .replace(
+      /Do NOT render options as plain text \(e\.g\., `\[A\] option \[B\] option`\) — the user must be able to click\/select, not type a letter\./g,
+      fallbackInstruction
+    );
+}
+
 export function convertSkill(skillContent, skillName) {
   const { frontmatter, body } = parseFrontmatter(skillContent);
 
   if (!frontmatter.name) frontmatter.name = skillName;
 
-  let convertedBody = body.replace(
+  let convertedBody = applyCodexInteractionCompatibility(body).replace(
     /\$\{SKILL_DIR\}/g,
     `.agents/skills/${skillName}`
   );
@@ -34,7 +49,7 @@ export function convertSkill(skillContent, skillName) {
     }
   );
 
-  const codexNote = `> Codex project install: when instructions mention a PrizmKit slash command such as \`/prizmkit-plan\`, read and execute the matching project skill at \`.agents/skills/prizmkit-plan/SKILL.md\`.\n\n`;
+  const codexNote = `> Codex project install: when instructions mention a PrizmKit slash command such as \`/prizmkit-plan\`, read and execute the matching project skill at \`.agents/skills/prizmkit-plan/SKILL.md\`.\n>\n> Codex interaction compatibility: when this skill or any referenced PrizmKit file says \`AskUserQuestion\`, use Codex \`request_user_input\` if it is available. If the current Codex surface does not expose \`request_user_input\`, including Default mode, ask the same question directly in chat and wait for explicit user input. Tool unavailability is not permission to choose defaults. If a source instruction asks more questions than Codex allows in one call, split them into multiple calls while preserving order. Only true headless/non-interactive runs, such as \`codex exec\` automation with no conversational user available, may skip interaction and choose documented defaults; never silently choose defaults in an interactive session.\n\n`;
 
   return buildMarkdown(frontmatter, codexNote + convertedBody);
 }

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

@@ -369,7 +369,23 @@ prizm_start_ai_session() {
             "$CLI_CMD" "${claude_args[@]}" > "$log_path" 2>&1 &
             ;;
         codex)
-            local codex_args=(--ask-for-approval never --sandbox danger-full-access exec --cd "$PROJECT_ROOT" --skip-git-repo-check)
+            local codex_args=(--ask-for-approval never --sandbox danger-full-access)
+            local codex_subagent_timeout="${CODEX_SUBAGENT_TIMEOUT_SECONDS:-}"
+            if [[ -z "$codex_subagent_timeout" ]]; then
+                local outer_stale_threshold="${STALE_KILL_THRESHOLD:-900}"
+                if [[ "$outer_stale_threshold" =~ ^[0-9]+$ && "$outer_stale_threshold" -gt 120 ]]; then
+                    codex_subagent_timeout=$((outer_stale_threshold - 60))
+                else
+                    codex_subagent_timeout=840
+                fi
+            fi
+            if [[ "$codex_subagent_timeout" =~ ^[0-9]+$ && "$codex_subagent_timeout" -gt 0 ]]; then
+                codex_args+=(--config "agents.job_max_runtime_seconds=$codex_subagent_timeout")
+            fi
+            codex_args+=(exec --cd "$PROJECT_ROOT" --skip-git-repo-check)
+            if [[ "$USE_STREAM_JSON" == "true" ]]; then
+                codex_args+=(--json)
+            fi
             if [[ -n "$model" ]]; then
                 codex_args+=(--model "$model")
             fi
@@ -413,7 +429,23 @@ prizm_run_ai_session() {
             "$CLI_CMD" "${claude_args[@]}" > "$log_path" 2>&1
             ;;
         codex)
-            local codex_args=(--ask-for-approval never --sandbox danger-full-access exec --cd "$PROJECT_ROOT" --skip-git-repo-check)
+            local codex_args=(--ask-for-approval never --sandbox danger-full-access)
+            local codex_subagent_timeout="${CODEX_SUBAGENT_TIMEOUT_SECONDS:-}"
+            if [[ -z "$codex_subagent_timeout" ]]; then
+                local outer_stale_threshold="${STALE_KILL_THRESHOLD:-900}"
+                if [[ "$outer_stale_threshold" =~ ^[0-9]+$ && "$outer_stale_threshold" -gt 120 ]]; then
+                    codex_subagent_timeout=$((outer_stale_threshold - 60))
+                else
+                    codex_subagent_timeout=840
+                fi
+            fi
+            if [[ "$codex_subagent_timeout" =~ ^[0-9]+$ && "$codex_subagent_timeout" -gt 0 ]]; then
+                codex_args+=(--config "agents.job_max_runtime_seconds=$codex_subagent_timeout")
+            fi
+            codex_args+=(exec --cd "$PROJECT_ROOT" --skip-git-repo-check)
+            if [[ "$USE_STREAM_JSON" == "true" ]]; then
+                codex_args+=(--json)
+            fi
             if [[ -n "$model" ]]; then
                 codex_args+=(--model "$model")
             fi
@@ -441,10 +473,12 @@ prizm_detect_subagents() {
     [[ -f "$session_log" ]] || return 0
 
     local count=0
-    if [[ "$USE_STREAM_JSON" == "true" ]]; then
+    if [[ "$USE_STREAM_JSON" == "true" && "${STREAM_JSON_FORMAT:-}" == "codex-json" ]]; then
+        count=$(grep -c '"tool"[[:space:]]*:[[:space:]]*"spawn_agent"' "$session_log" 2>/dev/null) || true
+    elif [[ "$USE_STREAM_JSON" == "true" ]]; then
         count=$(grep -c '"name"[[:space:]]*:[[:space:]]*"Agent"' "$session_log" 2>/dev/null) || true
     else
-        count=$(grep -cE '(Tool: Agent|"tool":\s*"Agent"|tool_use.*Agent|subagent_type)' "$session_log" 2>/dev/null) || true
+        count=$(grep -cE '(Tool: Agent|"tool":\s*"Agent"|"tool":\s*"spawn_agent"|tool_use.*Agent|subagent_type|collab: SpawnAgent)' "$session_log" 2>/dev/null) || true
     fi
 
     count=${count:-0}

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

@@ -88,17 +88,22 @@ start_heartbeat() {
                 local stale_mins=$((stale_seconds / 60))
                 echo -e "  ${RED}[HEARTBEAT]${NC} ${mins}m${secs}s | log: ${size_display} | ${RED}STALE-KILL: no progress for ${stale_mins}m (threshold: ${stale_kill_threshold}s)${NC}"
                 echo -e "  ${RED}[HEARTBEAT]${NC} Killing AI CLI process $cli_pid (stale session)..."
+                # Write the marker before killing. Some CLIs exit quickly, and the
+                # parent runner may stop this heartbeat process immediately after
+                # wait(1) returns.
+                local _marker_dir
+                _marker_dir="$(dirname "$session_log")"
+                echo "{\"killed_at\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\", \"reason\": \"stale_session\", \"stale_seconds\": $stale_seconds, \"threshold\": $stale_kill_threshold}" > "$_marker_dir/stale-kill.json" 2>/dev/null || true
                 kill -TERM "$cli_pid" 2>/dev/null || true
                 # Give process 10s to exit gracefully, then force kill
-                sleep 10
+                local stale_kill_grace_seconds="${STALE_KILL_GRACE_SECONDS:-10}"
+                if [[ $stale_kill_grace_seconds -gt 0 ]]; then
+                    sleep "$stale_kill_grace_seconds"
+                fi
                 if kill -0 "$cli_pid" 2>/dev/null; then
                     echo -e "  ${RED}[HEARTBEAT]${NC} Process still alive after SIGTERM, sending SIGKILL..."
                     kill -9 "$cli_pid" 2>/dev/null || true
                 fi
-                # Write stale-kill marker so spawn_and_wait_session knows this wasn't a crash
-                local _marker_dir
-                _marker_dir="$(dirname "$session_log")"
-                echo "{\"killed_at\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\", \"reason\": \"stale_session\", \"stale_seconds\": $stale_seconds, \"threshold\": $stale_kill_threshold}" > "$_marker_dir/stale-kill.json" 2>/dev/null || true
                 break
             fi
 
@@ -200,7 +205,7 @@ stop_progress_parser() {
     fi
 }
 
-# Detect whether the AI CLI supports --output-format stream-json.
+# Detect whether the AI CLI supports structured JSON progress.
 # Sets USE_STREAM_JSON to "true" or "false".
 #
 # Arguments:
@@ -208,10 +213,35 @@ stop_progress_parser() {
 detect_stream_json_support() {
     local cli_cmd="$1"
     USE_STREAM_JSON="false"
+    STREAM_JSON_FORMAT=""
+
+    local session_platform=""
+    session_platform="$(_prizm_known_platform_from_cli "$cli_cmd" 2>/dev/null || true)"
+    if [[ -z "$session_platform" ]]; then
+        case "$(_prizm_normalize_platform "${PRIZMKIT_PLATFORM:-${PLATFORM:-}}")" in
+            codex|claude|codebuddy)
+                session_platform="$(_prizm_normalize_platform "${PRIZMKIT_PLATFORM:-${PLATFORM:-}}")"
+                ;;
+        esac
+    fi
 
     # CodeBuddy (cbc) always supports stream-json
-    if [[ "$cli_cmd" == "cbc" ]]; then
+    if [[ "$session_platform" == "codebuddy" || "$cli_cmd" == "cbc" ]]; then
         USE_STREAM_JSON="true"
+        STREAM_JSON_FORMAT="stream-json"
+        export USE_STREAM_JSON STREAM_JSON_FORMAT
+        return 0
+    fi
+
+    # Codex uses `codex exec --json` JSONL, not `--output-format stream-json`.
+    if [[ "$session_platform" == "codex" ]]; then
+        local codex_help
+        codex_help=$("$cli_cmd" exec --help 2>&1) || true
+        if echo "$codex_help" | grep -q -- "--json"; then
+            USE_STREAM_JSON="true"
+            STREAM_JSON_FORMAT="codex-json"
+        fi
+        export USE_STREAM_JSON STREAM_JSON_FORMAT
         return 0
     fi
 
@@ -222,5 +252,7 @@ detect_stream_json_support() {
 
     if echo "$help_output" | grep -q "stream-json"; then
         USE_STREAM_JSON="true"
+        STREAM_JSON_FORMAT="stream-json"
     fi
+    export USE_STREAM_JSON STREAM_JSON_FORMAT
 }

package/bundled/dev-pipeline/run-bugfix.sh

@@ -164,31 +164,8 @@ spawn_and_wait_session() {
         session_status="timed_out"
     elif [[ "$was_stale_killed" == true ]]; then
         log_warn "Session stale-killed (no progress for ${STALE_KILL_THRESHOLD}s)"
-        local has_commits=""
-        if git -C "$project_root" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
-            has_commits=$(git -C "$project_root" log "${default_branch}..HEAD" --oneline 2>/dev/null | head -1)
-        fi
-        if [[ -n "$has_commits" ]]; then
-            log_info "Stale-killed session has commits — treating as success"
-            session_status="success"
-        else
-            local uncommitted=""
-            uncommitted=$(git -C "$project_root" status --porcelain 2>/dev/null | head -1 || true)
-            if [[ -n "$uncommitted" ]]; then
-                log_warn "Stale-killed session has uncommitted changes — auto-committing..."
-                git -C "$project_root" add -A 2>/dev/null || true
-                if git -C "$project_root" commit --no-verify -m "chore($bug_id): auto-commit session work (stale-killed)" 2>/dev/null; then
-                    log_info "Auto-commit succeeded"
-                    session_status="success"
-                else
-                    log_warn "Auto-commit failed — no changes to commit"
-                    session_status="crashed"
-                fi
-            else
-                log_warn "Stale-killed session produced no commits and no changes"
-                session_status="crashed"
-            fi
-        fi
+        log_warn "Stale-killed sessions are treated as failed; dev branch is preserved for inspection"
+        session_status="crashed"
     elif [[ $exit_code -ne 0 ]]; then
         log_warn "Session exited with code $exit_code"
         session_status="crashed"

package/bundled/dev-pipeline/run-feature.sh

@@ -174,32 +174,8 @@ spawn_and_wait_session() {
         session_status="timed_out"
     elif [[ "$was_stale_killed" == true ]]; then
         log_warn "Session stale-killed (no progress for ${STALE_KILL_THRESHOLD}s)"
-        # Treat stale-killed as potentially successful — check for commits
-        local has_commits=""
-        if git -C "$project_root" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
-            has_commits=$(git -C "$project_root" log "${default_branch}..HEAD" --oneline 2>/dev/null | head -1)
-        fi
-        if [[ -n "$has_commits" ]]; then
-            log_info "Stale-killed session has commits — treating as success"
-            session_status="success"
-        else
-            local uncommitted=""
-            uncommitted=$(git -C "$project_root" status --porcelain 2>/dev/null | head -1 || true)
-            if [[ -n "$uncommitted" ]]; then
-                log_warn "Stale-killed session has uncommitted changes — auto-committing..."
-                git -C "$project_root" add -A 2>/dev/null || true
-                if git -C "$project_root" commit --no-verify -m "chore($feature_id): auto-commit session work (stale-killed)" 2>/dev/null; then
-                    log_info "Auto-commit succeeded"
-                    session_status="success"
-                else
-                    log_warn "Auto-commit failed — no changes to commit"
-                    session_status="crashed"
-                fi
-            else
-                log_warn "Stale-killed session produced no commits and no changes"
-                session_status="crashed"
-            fi
-        fi
+        log_warn "Stale-killed sessions are treated as failed; dev branch is preserved for inspection"
+        session_status="crashed"
     elif [[ $exit_code -ne 0 ]]; then
         log_warn "Session exited with code $exit_code"
         session_status="crashed"

package/bundled/dev-pipeline/run-refactor.sh

@@ -166,31 +166,8 @@ spawn_and_wait_session() {
         session_status="timed_out"
     elif [[ "$was_stale_killed" == true ]]; then
         log_warn "Session stale-killed (no progress for ${STALE_KILL_THRESHOLD}s)"
-        local has_commits=""
-        if git -C "$project_root" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
-            has_commits=$(git -C "$project_root" log "${default_branch}..HEAD" --oneline 2>/dev/null | head -1)
-        fi
-        if [[ -n "$has_commits" ]]; then
-            log_info "Stale-killed session has commits — treating as success"
-            session_status="success"
-        else
-            local uncommitted=""
-            uncommitted=$(git -C "$project_root" status --porcelain 2>/dev/null | head -1 || true)
-            if [[ -n "$uncommitted" ]]; then
-                log_warn "Stale-killed session has uncommitted changes — auto-committing..."
-                git -C "$project_root" add -A 2>/dev/null || true
-                if git -C "$project_root" commit --no-verify -m "chore($refactor_id): auto-commit session work (stale-killed)" 2>/dev/null; then
-                    log_info "Auto-commit succeeded"
-                    session_status="success"
-                else
-                    log_warn "Auto-commit failed — no changes to commit"
-                    session_status="crashed"
-                fi
-            else
-                log_warn "Stale-killed session produced no commits and no changes"
-                session_status="crashed"
-            fi
-        fi
+        log_warn "Stale-killed sessions are treated as failed; dev branch is preserved for inspection"
+        session_status="crashed"
     elif [[ $exit_code -ne 0 ]]; then
         log_warn "Session exited with code $exit_code"
         session_status="crashed"

package/bundled/dev-pipeline/scripts/parse-stream-progress.py

@@ -73,6 +73,9 @@ class ProgressTracker:
         self.last_text_snippet = ""
         self.is_active = True
         self.errors = []
+        self.event_format = ""
+        self.active_subagent_count = 0
+        self.subagent_status_counts = Counter()
         self._text_buffer = ""
         self._in_tool_use = False
         self._current_tool_input_parts = []
@@ -87,8 +90,72 @@ class ProgressTracker:
         """
         event_type = event.get("type", "")
 
+        # ── Codex exec --json JSONL format ──────────────────────────
+        if event_type in (
+            "thread.started", "turn.started", "turn.completed",
+            "turn.failed", "item.started", "item.completed", "error",
+        ):
+            self.event_format = "codex-json"
+            self.is_active = True
+
+            if event_type == "turn.started":
+                self.message_count += 1
+
+            elif event_type in ("item.started", "item.completed"):
+                item = event.get("item", {})
+                item_type = item.get("type", "")
+
+                if item_type == "agent_message":
+                    text = item.get("text", "")
+                    if text.strip():
+                        self.last_text_snippet = text.strip()[:120]
+                        self._detect_phase(text)
+
+                elif item_type == "collab_tool_call":
+                    tool_name = item.get("tool", "collab")
+                    if event_type == "item.started":
+                        self.current_tool = tool_name
+                        self.tool_call_counts[tool_name] += 1
+                        self.total_tool_calls += 1
+                    elif item.get("status") == "completed":
+                        self.current_tool = None
+                    self._extract_tool_summary_from_dict(item)
+                    self._update_subagent_status_counts(
+                        item.get("agents_states", {})
+                    )
+
+                    prompt = item.get("prompt")
+                    if prompt:
+                        self._detect_phase(prompt)
+
+                else:
+                    tool_name = item.get("tool") or item.get("name")
+                    if tool_name:
+                        if event_type == "item.started":
+                            self.current_tool = tool_name
+                            self.tool_call_counts[tool_name] += 1
+                            self.total_tool_calls += 1
+                        elif item.get("status") == "completed":
+                            self.current_tool = None
+                        self._extract_tool_summary_from_dict(item)
+
+            elif event_type == "turn.completed":
+                self.current_tool = None
+
+            elif event_type == "turn.failed":
+                error = event.get("error") or event.get("message") or "Codex turn failed"
+                self.errors.append(str(error))
+                self.current_tool = None
+
+            elif event_type == "error":
+                error = event.get("error") or event.get("message") or "Unknown error"
+                self.errors.append(str(error))
+
+            return
+
         # ── Claude Code verbose format ──────────────────────────────
         if event_type == "assistant":
+            self.event_format = self.event_format or "stream-json"
             self.message_count += 1
             self.is_active = True
             message = event.get("message", {})
@@ -113,16 +180,19 @@ class ProgressTracker:
 
         elif event_type == "tool_result" or event_type == "user":
             # tool_result contains output from tool execution
+            self.event_format = self.event_format or "stream-json"
             self.is_active = True
 
         elif event_type == "system":
             # System events (hooks, init, etc.) — track but don't count as messages
+            self.event_format = self.event_format or "stream-json"
             subtype = event.get("subtype", "")
             if subtype == "init":
                 self.is_active = True
 
         # ── Claude API raw stream format ────────────────────────────
         elif event_type == "message_start":
+            self.event_format = self.event_format or "stream-json"
             self.message_count += 1
             self.is_active = True
 
@@ -256,14 +326,38 @@ class ProgressTracker:
             elif "prompt" in data:
                 self.current_tool_input_summary = str(data["prompt"])[:100]
 
+    def _update_subagent_status_counts(self, agents_states):
+        """Track Codex subagent state counts from collab_tool_call items."""
+        counts = Counter()
+        active = 0
+        if isinstance(agents_states, dict):
+            for state in agents_states.values():
+                if not isinstance(state, dict):
+                    continue
+                status = str(state.get("status", "unknown"))
+                counts[status] += 1
+                if status not in ("completed", "failed", "cancelled", "canceled"):
+                    active += 1
+                message = state.get("message")
+                if message:
+                    self.last_text_snippet = str(message).strip()[:120]
+                    self._detect_phase(str(message))
+        self.subagent_status_counts = counts
+        self.active_subagent_count = active
+
     def to_dict(self):
         """Export current state as a dictionary for JSON serialization."""
         tool_calls = [
             {"name": name, "count": count}
             for name, count in self.tool_call_counts.most_common()
         ]
+        subagent_states = [
+            {"status": status, "count": count}
+            for status, count in self.subagent_status_counts.most_common()
+        ]
         return {
             "updated_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "event_format": self.event_format,
             "message_count": self.message_count,
             "current_tool": self.current_tool,
             "current_tool_input_summary": self.current_tool_input_summary,
@@ -271,6 +365,8 @@ class ProgressTracker:
             "detected_phases": self.detected_phases,
             "tool_calls": tool_calls,
             "total_tool_calls": self.total_tool_calls,
+            "active_subagent_count": self.active_subagent_count,
+            "subagent_states": subagent_states,
             "last_text_snippet": self.last_text_snippet,
             "is_active": self.is_active,
             "errors": self.errors[-10:],  # Keep last 10 errors

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.61",
+  "version": "1.1.63",
   "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.61",
+  "version": "1.1.63",
   "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

@@ -33,6 +33,23 @@ import { normalizeRuntime, runtimeLabel, RUNTIME_UNIX, RUNTIME_WINDOWS } from '.
 const __scaffoldDirname = dirname(fileURLToPath(import.meta.url));
 const scaffoldPkg = JSON.parse(readFileSync(join(__scaffoldDirname, '..', 'package.json'), 'utf-8'));
 const PIPELINE_INSTALL_EXCLUDE = new Set(['tests', 'docs', '__pycache__', 'node_modules', '.DS_Store']);
+const PIPELINE_MANAGED_DIRS = new Set(['assets', 'lib', 'scripts', 'templates', 'tests', 'docs']);
+const PIPELINE_RUNTIME_PRESERVE_DIRS = new Set([
+  'state',
+  'logs',
+  'runs',
+  'sessions',
+  'tmp',
+  'cache',
+  'node_modules',
+  'venv',
+  '__pycache__',
+]);
+const PIPELINE_MANAGED_TOP_LEVEL_PATTERNS = [
+  /^(run|launch|reset|retry)-.+\.(sh|ps1)$/i,
+  /^README\.md$/i,
+  /^SCHEMA_ANALYSIS\.md$/i,
+];
 
 // ============================================================
 // Adapter 动态加载
@@ -159,6 +176,7 @@ export async function installSkills(platform, skills, projectRoot, dryRun, runti
         continue;
       }
 
+      await fs.remove(targetDir);
       await fs.ensureDir(targetDir);
 
       // 读取并写入 SKILL.md（CodeBuddy 格式基本透传）
@@ -189,17 +207,18 @@ export async function installSkills(platform, skills, projectRoot, dryRun, runti
       // so Claude Code shows it as /skillName (not /skillName:skillName).
       // Assets/scripts are copied into a subdirectory for reference.
       const commandsDir = path.join(projectRoot, '.claude', 'commands');
+      const assetTargetDir = path.join(projectRoot, '.claude', 'command-assets', skillName);
       if (dryRun) {
         console.log(chalk.gray(`      [dry-run] .claude/commands/${skillName}.md`));
         continue;
       }
       await fs.ensureDir(commandsDir);
       await fs.writeFile(path.join(commandsDir, `${skillName}.md`), converted);
+      await fs.remove(assetTargetDir);
 
       if (skillSubdirs.length > 0) {
         // Place subdirectories outside .claude/commands/ to prevent Claude Code
         // from registering them as slash commands (e.g. /skillName:assets:file).
-        const assetTargetDir = path.join(projectRoot, '.claude', 'command-assets', skillName);
         await fs.ensureDir(assetTargetDir);
         for (const subdir of skillSubdirs) {
           await fs.copy(path.join(corePath, subdir), path.join(assetTargetDir, subdir));
@@ -216,6 +235,7 @@ export async function installSkills(platform, skills, projectRoot, dryRun, runti
         continue;
       }
 
+      await fs.remove(targetDir);
       await fs.ensureDir(targetDir);
       await fs.writeFile(path.join(targetDir, 'SKILL.md'), converted);
 
@@ -556,6 +576,7 @@ project_doc_fallback_filenames = ["CLAUDE.md", "CODEBUDDY.md"]
 
 [agents]
 max_depth = 1
+job_max_runtime_seconds = 840
 `;
     await fs.writeFile(configPath, configToml);
     await fs.remove(legacySettingsPath);
@@ -922,6 +943,101 @@ export function resolvePipelineFileList(runtime = 'unix') {
   return collectInstallablePipelineFiles(pipelineSource);
 }
 
+function normalizePipelineRelPath(relativeFile) {
+  return relativeFile.split(path.sep).join('/');
+}
+
+function isPreservedPipelineRuntimeFile(relativeFile) {
+  const normalized = normalizePipelineRelPath(relativeFile);
+  const segments = normalized.split('/');
+  if (segments.some(segment => !segment || segment === '..')) return true;
+  if (segments.some(segment => segment.startsWith('.'))) return true;
+  return segments.some(segment => PIPELINE_RUNTIME_PRESERVE_DIRS.has(segment));
+}
+
+function isLikelyManagedPipelineFile(relativeFile) {
+  const normalized = normalizePipelineRelPath(relativeFile);
+  const segments = normalized.split('/');
+  if (segments.length === 0 || isPreservedPipelineRuntimeFile(normalized)) return false;
+  if (segments.length > 1 && PIPELINE_MANAGED_DIRS.has(segments[0])) return true;
+  return PIPELINE_MANAGED_TOP_LEVEL_PATTERNS.some(pattern => pattern.test(normalized));
+}
+
+async function collectTargetPipelineFiles(dir, base = '') {
+  if (!await fs.pathExists(dir)) return [];
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const rel = base ? path.join(base, entry.name) : entry.name;
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await collectTargetPipelineFiles(fullPath, rel));
+    } else if (entry.isFile()) {
+      files.push(rel);
+    }
+  }
+  return files;
+}
+
+/**
+ * Find PrizmKit-owned pipeline files present in the target install that no
+ * longer exist in the framework source for the selected runtime.
+ *
+ * This intentionally avoids arbitrary top-level files and runtime/state
+ * directories so user scratch files are preserved.
+ */
+export async function findStaleManagedPipelineFiles(projectRoot, runtime = 'unix') {
+  const pipelineTarget = path.join(projectRoot, '.prizmkit', 'dev-pipeline');
+  if (!await fs.pathExists(pipelineTarget)) return [];
+
+  const currentFiles = new Set(
+    resolvePipelineFileList(runtime).map(file => normalizePipelineRelPath(file)),
+  );
+  const targetFiles = await collectTargetPipelineFiles(pipelineTarget);
+
+  return targetFiles
+    .filter(file => !currentFiles.has(normalizePipelineRelPath(file)))
+    .filter(file => isLikelyManagedPipelineFile(file));
+}
+
+export async function removeStaleManagedPipelineFiles(projectRoot, staleFiles, dryRun) {
+  if (!staleFiles.length) return 0;
+
+  const pipelineTarget = path.join(projectRoot, '.prizmkit', 'dev-pipeline');
+  const removedDirs = new Set();
+  let removedCount = 0;
+
+  for (const relativeFile of staleFiles) {
+    const targetFile = path.join(pipelineTarget, relativeFile);
+    if (!await fs.pathExists(targetFile)) continue;
+
+    if (dryRun) {
+      console.log(chalk.gray(`      [dry-run] remove .prizmkit/dev-pipeline/${normalizePipelineRelPath(relativeFile)}`));
+    } else {
+      await fs.remove(targetFile);
+      console.log(chalk.red(`      ✗ removed .prizmkit/dev-pipeline/${normalizePipelineRelPath(relativeFile)}`));
+      removedDirs.add(path.dirname(relativeFile));
+    }
+    removedCount++;
+  }
+
+  if (!dryRun) {
+    const dirsByDepth = [...removedDirs]
+      .filter(dir => dir && dir !== '.')
+      .sort((a, b) => b.split(path.sep).length - a.split(path.sep).length);
+    for (const relativeDir of dirsByDepth) {
+      const targetDir = path.join(pipelineTarget, relativeDir);
+      if (!await fs.pathExists(targetDir)) continue;
+      const entries = await fs.readdir(targetDir);
+      if (entries.length === 0) {
+        await fs.remove(targetDir);
+      }
+    }
+  }
+
+  return removedCount;
+}
+
 async function pruneStalePipelineRuntimeFiles(pipelineTarget, runtime) {
   if (!await fs.pathExists(pipelineTarget)) return false;
 

package/src/upgrade.js

@@ -28,6 +28,8 @@ import {
   installGitignore,
   installProjectMemory,
   resolvePipelineFileList,
+  findStaleManagedPipelineFiles,
+  removeStaleManagedPipelineFiles,
   resolveRuleNamesForRuntime,
   resolveSkillList,
   EXTRAS_REGISTRY,
@@ -296,6 +298,11 @@ export async function runUpgrade(directory, options = {}) {
   }
 
   const diff = oldManifest ? diffManifest(oldManifest, newManifest) : { skills: { added: [], removed: [] }, agents: { added: [], removed: [] }, rules: { added: [], removed: [] }, pipeline: { added: [], removed: [] }, extras: { added: [], removed: [] } };
+  const removedPipelineSet = new Set(diff.pipeline.removed);
+  const staleManagedPipelineFiles = pipeline
+    ? (await findStaleManagedPipelineFiles(projectRoot, runtime))
+        .filter(file => !removedPipelineSet.has(file))
+    : [];
 
   // 5. Display upgrade summary
   const oldVersion = oldManifest?.version || 'unknown';
@@ -307,7 +314,7 @@ export async function runUpgrade(directory, options = {}) {
   console.log('');
 
   const totalAdded = diff.skills.added.length + diff.agents.added.length + diff.rules.added.length + diff.pipeline.added.length + diff.extras.added.length;
-  const totalRemoved = diff.skills.removed.length + diff.agents.removed.length + diff.rules.removed.length + diff.pipeline.removed.length + diff.extras.removed.length;
+  const totalRemoved = diff.skills.removed.length + diff.agents.removed.length + diff.rules.removed.length + diff.pipeline.removed.length + diff.extras.removed.length + staleManagedPipelineFiles.length;
   const totalUpdated = newSkillList.length + newAgentFiles.length + newRuleFiles.length;
 
   if (diff.skills.added.length) console.log(chalk.green(`    + Skills added: ${diff.skills.added.join(', ')}`));
@@ -318,6 +325,7 @@ export async function runUpgrade(directory, options = {}) {
   if (diff.rules.removed.length) console.log(chalk.red(`    - Rules removed: ${diff.rules.removed.join(', ')}`));
   if (diff.pipeline.added.length) console.log(chalk.green(`    + Pipeline files added: ${diff.pipeline.added.length} file(s)`));
   if (diff.pipeline.removed.length) console.log(chalk.red(`    - Pipeline files removed: ${diff.pipeline.removed.length} file(s)`));
+  if (staleManagedPipelineFiles.length) console.log(chalk.red(`    - Stale managed pipeline files: ${staleManagedPipelineFiles.length} file(s)`));
   if (diff.extras.added.length) console.log(chalk.green(`    + Extras added: ${diff.extras.added.join(', ')}`));
   if (diff.extras.removed.length) console.log(chalk.red(`    - Extras removed: ${diff.extras.removed.join(', ')}`));
 
@@ -344,7 +352,7 @@ export async function runUpgrade(directory, options = {}) {
   const platforms = expandPlatforms(platform);
 
   // 7a. Remove orphaned files
-  if (diff.skills.removed.length || diff.agents.removed.length || diff.rules.removed.length || diff.pipeline.removed.length) {
+  if (diff.skills.removed.length || diff.agents.removed.length || diff.rules.removed.length || diff.pipeline.removed.length || staleManagedPipelineFiles.length) {
     console.log(chalk.bold('\n  Removing orphaned files...'));
     for (const p of platforms) {
       if (diff.skills.removed.length) {
@@ -364,6 +372,10 @@ export async function runUpgrade(directory, options = {}) {
       console.log(chalk.blue('\n    Removed pipeline files:'));
       await removePipelineFiles(projectRoot, diff.pipeline.removed, dryRun);
     }
+    if (staleManagedPipelineFiles.length) {
+      console.log(chalk.blue('\n    Removed stale managed pipeline files:'));
+      await removeStaleManagedPipelineFiles(projectRoot, staleManagedPipelineFiles, dryRun);
+    }
   }
 
   // 7b. Re-install all current files (overwrite mode)