prizmkit 1.1.62 → 1.1.64

package/bundled/dev-pipeline-windows/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.62",
+  "version": "1.1.64",
   "skills": {
     "prizm-kit": {
       "description": "Full-lifecycle dev toolkit. Covers spec-driven development, Prizm context docs, code quality, debugging, deployment, and knowledge management.",

package/bundled/templates/project-memory-template.md

@@ -29,6 +29,11 @@ This project uses PrizmKit with the Prizm documentation system for AI-optimized
   2. Generate a new L2 `.prizm` file following Prizm specification
   3. Add a pointer in the parent L1 doc's SUBDIRS section
 
+### Framework Source Parity
+- When working in the PrizmKit framework source, `dev-pipeline/` and `dev-pipeline-windows/` are paired runtimes. Any runtime, prompt, schema, reset/recovery, timeout, heartbeat, logging, or AI CLI behavior change in one must be mirrored in the other, or explicitly documented as platform-specific.
+- When working in the PrizmKit framework source, `core/skills/orchestration-skill/` and `core/skills/orchestration-skill-windows/` are paired skill sources. Any planner, workflow, launcher, prompt, or documentation behavior change in one must be mirrored in the other, or explicitly documented as platform-specific.
+- Before finishing framework work, run `git diff --name-only` and verify these paired Unix/Windows paths were updated together.
+
 ### Available Commands
 Run `/prizm-kit` to see all available PrizmKit commands.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prizmkit",
-  "version": "1.1.62",
+  "version": "1.1.64",
   "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)