prizmkit 1.0.76 → 1.0.78

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

@@ -170,6 +170,9 @@ python3 "$SCRIPTS_DIR/update-feature-status.py" \
     log_warn "Failed to clean feature artifacts (continuing with fresh session only)"
 }
 
+# Auto-detect available models (quiet, non-blocking)
+bash "$SCRIPT_DIR/scripts/detect-models.sh" --quiet 2>/dev/null || true
+
 # ============================================================
 # Generate bootstrap prompt
 # ============================================================
@@ -182,7 +185,7 @@ mkdir -p "$SESSION_DIR/logs"
 BOOTSTRAP_PROMPT="$SESSION_DIR/bootstrap-prompt.md"
 
 log_info "Generating bootstrap prompt..."
-python3 "$SCRIPTS_DIR/generate-bootstrap-prompt.py" \
+GEN_OUTPUT=$(python3 "$SCRIPTS_DIR/generate-bootstrap-prompt.py" \
     --feature-list "$FEATURE_LIST" \
     --feature-id "$FEATURE_ID" \
     --session-id "$SESSION_ID" \
@@ -190,7 +193,11 @@ python3 "$SCRIPTS_DIR/generate-bootstrap-prompt.py" \
     --retry-count 0 \
     --resume-phase "null" \
     --state-dir "$STATE_DIR" \
-    --output "$BOOTSTRAP_PROMPT" >/dev/null 2>&1
+    --output "$BOOTSTRAP_PROMPT" 2>/dev/null) || {
+    log_error "Failed to generate bootstrap prompt"
+    exit 1
+}
+FEATURE_MODEL=$(echo "$GEN_OUTPUT" | python3 -c "import json,sys; print(json.load(sys.stdin).get('model',''))" 2>/dev/null || echo "")
 
 # ============================================================
 # Run single AI CLI session
@@ -234,9 +241,12 @@ python3 "$SCRIPTS_DIR/update-feature-status.py" \
     --action start >/dev/null 2>&1 || true
 
 # Spawn AI CLI session
+# Spawn AI CLI session — model priority: feature.model > $MODEL env > none
+EFFECTIVE_MODEL="${FEATURE_MODEL:-${MODEL:-}}"
 MODEL_FLAG=""
-if [[ -n "${MODEL:-}" ]]; then
-    MODEL_FLAG="--model $MODEL"
+if [[ -n "$EFFECTIVE_MODEL" ]]; then
+    MODEL_FLAG="--model $EFFECTIVE_MODEL"
+    log_info "Model: $EFFECTIVE_MODEL"
 fi
 
 unset CLAUDECODE 2>/dev/null || true
@@ -331,8 +341,36 @@ elif [[ -f "$SESSION_STATUS_FILE" ]]; then
     SESSION_STATUS=$(python3 "$SCRIPTS_DIR/check-session-status.py" \
         --status-file "$SESSION_STATUS_FILE" 2>/dev/null) || SESSION_STATUS="crashed"
 else
+    # No session-status.json found. Check if session produced git commits
+    # (e.g., context window exhausted after committing but before writing status).
     log_warn "Session ended without status file"
-    SESSION_STATUS="crashed"
+    PROJECT_ROOT_CHECK="$(cd "$SCRIPT_DIR/.." && pwd)"
+    RECENT_FEATURE_COMMITS=""
+    if git -C "$PROJECT_ROOT_CHECK" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+        # Use session directory creation time as lower bound for commit search
+        SESSION_START_ISO=$(python3 -c "
+import os, sys
+from datetime import datetime, timezone
+p = sys.argv[1]
+if os.path.isdir(p):
+    ts = os.path.getctime(p)
+    print(datetime.fromtimestamp(ts, tz=timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ'))
+else:
+    print('')
+" "$SESSION_DIR" 2>/dev/null) || SESSION_START_ISO=""
+        if [[ -n "$SESSION_START_ISO" ]]; then
+            RECENT_FEATURE_COMMITS=$(git -C "$PROJECT_ROOT_CHECK" log --since="$SESSION_START_ISO" --oneline --grep="$FEATURE_ID" 2>/dev/null | head -5)
+        fi
+    fi
+
+    if [[ -n "$RECENT_FEATURE_COMMITS" ]]; then
+        log_warn "Found commits from this session:"
+        echo "$RECENT_FEATURE_COMMITS" | sed 's/^/  - /'
+        log_warn "Treating as commit_missing (artifacts preserved for retry)"
+        SESSION_STATUS="commit_missing"
+    else
+        SESSION_STATUS="crashed"
+    fi
 fi
 
 if [[ "$SESSION_STATUS" == "success" ]]; then

package/bundled/dev-pipeline/run.sh

@@ -90,6 +90,7 @@ spawn_and_wait_session() {
     local bootstrap_prompt="$4"
     local session_dir="$5"
     local max_retries="$6"
+    local feature_model="${7:-}"
 
     local session_log="$session_dir/logs/session.log"
     local progress_json="$session_dir/logs/progress.json"
@@ -108,8 +109,9 @@ spawn_and_wait_session() {
     fi
 
     local model_flag=""
-    if [[ -n "$MODEL" ]]; then
-        model_flag="--model $MODEL"
+    local effective_model="${feature_model:-$MODEL}"
+    if [[ -n "$effective_model" ]]; then
+        model_flag="--model $effective_model"
     fi
 
     # Unset CLAUDECODE to prevent "nested session" error when launched from
@@ -648,7 +650,13 @@ sys.exit(1)
     fi
 
     log_info "Generating bootstrap prompt..."
-    python3 "$SCRIPTS_DIR/generate-bootstrap-prompt.py" "${prompt_args[@]}" >/dev/null 2>&1
+    local gen_output
+    gen_output=$(python3 "$SCRIPTS_DIR/generate-bootstrap-prompt.py" "${prompt_args[@]}" 2>/dev/null) || {
+        log_error "Failed to generate bootstrap prompt for $feature_id"
+        return 1
+    }
+    local feature_model
+    feature_model=$(echo "$gen_output" | python3 -c "import json,sys; print(json.load(sys.stdin).get('model',''))" 2>/dev/null || echo "")
 
     # Dry-Run: Print info and exit
     if [[ "$dry_run" == true ]]; then
@@ -664,6 +672,13 @@ sys.exit(1)
         else
             log_info "Mode:          auto-detect (from complexity)"
         fi
+        if [[ -n "$feature_model" ]]; then
+            log_info "Feature Model: $feature_model"
+        elif [[ -n "${MODEL:-}" ]]; then
+            log_info "Model (env):   $MODEL"
+        else
+            log_info "Model:         (CLI default)"
+        fi
         echo ""
         log_info "Bootstrap prompt written to:"
         echo "  $bootstrap_prompt"
@@ -736,7 +751,7 @@ sys.exit(1)
 
     spawn_and_wait_session \
         "$feature_id" "$feature_list" "$session_id" \
-        "$bootstrap_prompt" "$session_dir" 999
+        "$bootstrap_prompt" "$session_dir" 999 "$feature_model"
     local session_status="$_SPAWN_RESULT"
 
     # Auto-push after successful session
@@ -850,6 +865,14 @@ main() {
         log_info "Resuming existing pipeline..."
     fi
 
+    # Auto-detect available models + validate feature model fields
+    bash "$SCRIPT_DIR/scripts/detect-models.sh" --quiet 2>/dev/null || true
+    if [[ -f ".prizmkit/available-models.json" ]]; then
+        python3 "$SCRIPTS_DIR/validate-feature-models.py" \
+            --feature-list "$feature_list" \
+            --models-file ".prizmkit/available-models.json" 2>&1 | head -5 || true
+    fi
+
     # Print header
     echo ""
     echo -e "${BOLD}════════════════════════════════════════════════════${NC}"
@@ -992,7 +1015,13 @@ for f in data.get('stuck_features', []):
             fi
         fi
 
-        python3 "$SCRIPTS_DIR/generate-bootstrap-prompt.py" "${main_prompt_args[@]}" >/dev/null 2>&1
+        local gen_output
+        gen_output=$(python3 "$SCRIPTS_DIR/generate-bootstrap-prompt.py" "${main_prompt_args[@]}" 2>/dev/null) || {
+            log_error "Failed to generate bootstrap prompt for $feature_id"
+            continue
+        }
+        local feature_model
+        feature_model=$(echo "$gen_output" | python3 -c "import json,sys; print(json.load(sys.stdin).get('model',''))" 2>/dev/null || echo "")
 
         # Update current session tracking (atomic write via temp file)
         python3 -c "
@@ -1020,11 +1049,14 @@ os.replace(tmp, target)
 
         # Spawn session and wait
         log_info "Spawning AI CLI session: $session_id"
+        if [[ -n "$feature_model" ]]; then
+            log_info "Feature model: $feature_model"
+        fi
         _SPAWN_RESULT=""
 
         spawn_and_wait_session \
             "$feature_id" "$feature_list" "$session_id" \
-            "$bootstrap_prompt" "$session_dir" "$MAX_RETRIES"
+            "$bootstrap_prompt" "$session_dir" "$MAX_RETRIES" "$feature_model"
         local session_status="$_SPAWN_RESULT"
 
         # Auto-push after successful session

package/bundled/dev-pipeline/scripts/detect-models.sh

@@ -0,0 +1,150 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# ============================================================
+# detect-models.sh - CLI model detection adapter
+#
+# Detects available AI models for the current CLI platform.
+# Usage: ./detect-models.sh [--quiet]
+# Writes: $PROJECT_ROOT/.prizmkit/available-models.json
+# ============================================================
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/../lib/common.sh" && prizm_detect_cli_and_platform
+
+# --- Parse flags ---
+QUIET=false
+for arg in "$@"; do
+    case "$arg" in
+        --quiet) QUIET=true ;;
+        *) log_warn "Unknown argument: $arg" ;;
+    esac
+done
+
+# --- Project root ---
+PROJECT_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
+
+# --- CLI version ---
+CLI_VERSION="$($CLI_CMD -v 2>&1 | head -1 | sed 's/^[^0-9]*//')" || CLI_VERSION="unknown"
+
+# --- Platform-specific detection ---
+MODELS_JSON="[]"
+DEFAULT_MODEL=""
+MODEL_SWITCH_SUPPORTED="false"
+DETECTION_METHOD="unknown"
+
+case "$PLATFORM" in
+    codebuddy)
+        DETECTION_METHOD="probe"
+        MODEL_SWITCH_SUPPORTED="true"
+
+        PROBE_OUTPUT="$(echo "x" | $CLI_CMD --print -y --model _probe_ 2>&1)" || true
+
+        MODELS_JSON="$(python3 -c "
+import sys, re, json
+
+output = sys.stdin.read()
+models = []
+
+# Look for 'Currently supported models' line and extract model names
+for line in output.splitlines():
+    if 'supported model' in line.lower():
+        # Extract everything after the colon/are:
+        match = re.search(r'(?:are|:)\s*(.+)', line, re.IGNORECASE)
+        if match:
+            raw = match.group(1)
+            # Split by comma, clean up
+            for m in raw.split(','):
+                m = m.strip().rstrip('.')
+                if m:
+                    models.append(m)
+
+# Fallback: look for model-like identifiers anywhere
+if not models:
+    models = re.findall(r'claude-[\w.-]+', output)
+    models = list(dict.fromkeys(models))  # dedupe preserving order
+
+print(json.dumps(models))
+" <<< "$PROBE_OUTPUT")" || MODELS_JSON="[]"
+
+        # Set default_model to first model if available
+        DEFAULT_MODEL="$(python3 -c "
+import json, sys
+models = json.loads(sys.stdin.read())
+print(models[0] if models else '')
+" <<< "$MODELS_JSON")" || DEFAULT_MODEL=""
+        ;;
+
+    claude)
+        DETECTION_METHOD="self-report"
+        MODEL_SWITCH_SUPPORTED="false"
+        MODELS_JSON="[]"
+
+        DEFAULT_MODEL="$($CLI_CMD -p "Reply with ONLY your model identifier, nothing else" \
+            --dangerously-skip-permissions --no-session-persistence 2>&1 \
+            | head -1 | tr -d '[:space:]')" || DEFAULT_MODEL="unknown"
+        ;;
+
+    *)
+        DETECTION_METHOD="help-parse"
+        MODEL_SWITCH_SUPPORTED="false"
+
+        HELP_OUTPUT="$($CLI_CMD --help 2>&1)" || HELP_OUTPUT=""
+
+        MODELS_JSON="$(python3 -c "
+import sys, re, json
+
+output = sys.stdin.read()
+models = re.findall(r'claude-[\w.-]+', output)
+models = list(dict.fromkeys(models))  # dedupe preserving order
+print(json.dumps(models))
+" <<< "$HELP_OUTPUT")" || MODELS_JSON="[]"
+        ;;
+esac
+
+# --- Write output JSON atomically ---
+mkdir -p "$PROJECT_ROOT/.prizmkit"
+
+OUTPUT_FILE="$PROJECT_ROOT/.prizmkit/available-models.json"
+TMP_FILE="$(mktemp "${OUTPUT_FILE}.XXXXXX")"
+
+# Determine cli short name
+CLI_SHORT="$(basename "$CLI_CMD")"
+
+python3 -c "
+import json, sys
+from datetime import datetime, timezone
+
+data = {
+    'cli': sys.argv[1],
+    'cli_version': sys.argv[2],
+    'platform': sys.argv[3],
+    'models': json.loads(sys.argv[4]),
+    'default_model': sys.argv[5],
+    'model_switch_supported': sys.argv[6] == 'true',
+    'detection_method': sys.argv[7],
+    'updated_at': datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')
+}
+
+with open(sys.argv[8], 'w') as f:
+    json.dump(data, f, indent=2)
+    f.write('\n')
+" "$CLI_SHORT" "$CLI_VERSION" "$PLATFORM" "$MODELS_JSON" "$DEFAULT_MODEL" \
+  "$MODEL_SWITCH_SUPPORTED" "$DETECTION_METHOD" "$TMP_FILE"
+
+mv "$TMP_FILE" "$OUTPUT_FILE"
+
+# --- Summary ---
+if [[ "$QUIET" != "true" ]]; then
+    MODEL_COUNT="$(python3 -c "import json; print(len(json.loads(open('$OUTPUT_FILE').read())['models']))")"
+    log_info "Model detection complete"
+    log_info "  CLI:        $CLI_SHORT ($CLI_VERSION)"
+    log_info "  Platform:   $PLATFORM"
+    log_info "  Method:     $DETECTION_METHOD"
+    log_info "  Models:     $MODEL_COUNT detected"
+    if [[ -n "$DEFAULT_MODEL" ]]; then
+        log_info "  Default:    $DEFAULT_MODEL"
+    fi
+    log_info "  Switch:     $MODEL_SWITCH_SUPPORTED"
+    log_info "  Written to: $OUTPUT_FILE"
+fi

package/bundled/dev-pipeline/scripts/generate-bootstrap-prompt.py

@@ -630,9 +630,11 @@ def main():
         emit_failure(err)
 
     # Success
+    feature_model = feature.get("model", "")
     output = {
         "success": True,
         "output_path": os.path.abspath(args.output),
+        "model": feature_model,
     }
     print(json.dumps(output, indent=2, ensure_ascii=False))
     sys.exit(0)

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

@@ -25,15 +25,45 @@ from collections import Counter
 from datetime import datetime, timezone
 
 
-# Phase keywords for detection
+# Ordered pipeline phases — index defines forward-only progression.
+# Phase detection is monotonic: once a phase is reached, earlier phases
+# cannot be re-entered (prevents false positives from file content mentions).
+PHASE_ORDER = ["specify", "plan", "analyze", "implement", "code-review", "retrospective", "commit"]
+
+# Keywords for phase detection.
+# "strong" keywords are skill invocations — high confidence, but still
+# forward-only (a mention of prizmkit-plan while in commit phase is noise).
+# "weak" keywords are contextual hints — also forward-only, used when no
+# strong keyword matches.
 PHASE_KEYWORDS = {
-    "specify": ["prizmkit-specify", "spec.md", "specification", "gathering requirements"],
-    "plan": ["prizmkit-plan", "plan.md", "architecture", "design plan", "task checklist", "task breakdown"],
-    "analyze": ["prizmkit-analyze", "cross-check", "consistency", "analyzing"],
-    "implement": ["prizmkit-implement", "implement", "TDD", "coding", "writing code"],
-    "code-review": ["prizmkit-code-review", "code review", "review verdict", "reviewing"],
-    "retrospective": ["prizmkit-retrospective", "retrospective", "knowledge distillation", "TRAPS", ".prizm-docs/ sync", "structural sync"],
-    "commit": ["prizmkit-committer", "git commit", "feat(", "fix(", "committing"],
+    "specify": {
+        "strong": ["prizmkit-specify"],
+        "weak": ["spec.md", "specification", "gathering requirements"],
+    },
+    "plan": {
+        "strong": ["prizmkit-plan"],
+        "weak": ["plan.md", "architecture", "task checklist", "task breakdown"],
+    },
+    "analyze": {
+        "strong": ["prizmkit-analyze"],
+        "weak": ["cross-check", "consistency analysis", "analyzing"],
+    },
+    "implement": {
+        "strong": ["prizmkit-implement"],
+        "weak": ["implement", "writing code", "TDD", "coding"],
+    },
+    "code-review": {
+        "strong": ["prizmkit-code-review"],
+        "weak": ["code review", "review verdict", "reviewing"],
+    },
+    "retrospective": {
+        "strong": ["prizmkit-retrospective"],
+        "weak": ["retrospective", "structural sync", "knowledge distillation", ".prizm-docs/ sync", "memory sedimentation"],
+    },
+    "commit": {
+        "strong": ["prizmkit-committer"],
+        "weak": ["git commit", "committing", "feat(", "fix("],
+    },
 }
 
 
@@ -171,15 +201,42 @@ class ProgressTracker:
             pass
 
     def _detect_phase(self, text):
-        """Detect pipeline phase from text content."""
+        """Detect pipeline phase from text content.
+
+        Uses monotonic (forward-only) progression to avoid false positives.
+        Strong keywords (skill invocations) always trigger; weak keywords
+        only trigger for phases at or ahead of the current position.
+        """
         text_lower = text.lower()
-        for phase, keywords in PHASE_KEYWORDS.items():
-            for keyword in keywords:
+        current_idx = (
+            PHASE_ORDER.index(self.current_phase)
+            if self.current_phase in PHASE_ORDER
+            else -1
+        )
+
+        for phase, kw_groups in PHASE_KEYWORDS.items():
+            phase_idx = PHASE_ORDER.index(phase)
+
+            # Check strong keywords — high confidence but still forward-only
+            for keyword in kw_groups.get("strong", []):
                 if keyword.lower() in text_lower:
-                    self.current_phase = phase
-                    if phase not in self.detected_phases:
-                        self.detected_phases.append(phase)
-                    return
+                    if phase_idx >= current_idx:
+                        self.current_phase = phase
+                        if phase not in self.detected_phases:
+                            self.detected_phases.append(phase)
+                        return
+                    # Backward strong match — skip this phase but do NOT
+                    # early-return, so forward weak matches can still fire.
+                    break
+
+            # Check weak keywords — only trigger for forward phases
+            if phase_idx >= current_idx:
+                for keyword in kw_groups.get("weak", []):
+                    if keyword.lower() in text_lower:
+                        self.current_phase = phase
+                        if phase not in self.detected_phases:
+                            self.detected_phases.append(phase)
+                        return
 
     def _extract_tool_summary(self, raw_input):
         """Extract a human-readable summary from tool input JSON string."""

package/bundled/dev-pipeline/scripts/update-feature-status.py

@@ -462,15 +462,11 @@ def action_update(args, feature_list_path, state_dir):
             error_out("Failed to update feature-list.json: {}".format(err))
             return
     else:
+        # crashed / failed / timed_out — preserve all artifacts for debugging.
+        # Previous behavior deleted everything via cleanup_feature_artifacts(),
+        # making it impossible to diagnose why the session failed.
         fs["retry_count"] = fs.get("retry_count", 0) + 1
 
-        cleaned = cleanup_feature_artifacts(
-            feature_list_path=feature_list_path,
-            state_dir=state_dir,
-            feature_id=feature_id,
-            project_root=args.project_root,
-        )
-
         if fs["retry_count"] >= max_retries:
             fs["status"] = "failed"
             target_status = "failed"
@@ -479,8 +475,9 @@ def action_update(args, feature_list_path, state_dir):
             target_status = "pending"
 
         fs["resume_from_phase"] = None
-        fs["sessions"] = []
-        fs["last_session_id"] = None
+        # Keep sessions list and last_session_id for debugging
+        # fs["sessions"] = []
+        # fs["last_session_id"] = None
 
         err = update_feature_in_list(feature_list_path, feature_id, target_status)
         if err:
@@ -514,8 +511,8 @@ def action_update(args, feature_list_path, state_dir):
         summary["degraded_reason"] = session_status
         summary["restart_policy"] = "finalization_retry"
     elif session_status != "success":
-        summary["restart_policy"] = "full_restart"
-        summary["cleanup_performed"] = cleaned
+        summary["restart_policy"] = "preserve_and_retry"
+        summary["artifacts_preserved"] = True
 
     print(json.dumps(summary, indent=2, ensure_ascii=False))
 

package/bundled/dev-pipeline/scripts/validate-feature-models.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""Validate model fields in feature-list.json against available-models.json."""
+
+import argparse
+import json
+import os
+import sys
+
+
+def validate_feature(feature, models_data):
+    """Check a single feature's model field and print warnings if needed."""
+    feature_id = feature.get("id", "unknown")
+    model = feature.get("model")
+    if not model:
+        return
+
+    model_switch_supported = models_data.get("model_switch_supported", True)
+    cli = models_data.get("cli", "unknown")
+    available_models = models_data.get("models", [])
+
+    if not model_switch_supported:
+        print(
+            f"\u26a0 {feature_id}: CLI '{cli}' does not support --model switching "
+            f"(model field '{model}' will be ignored)"
+        )
+    elif available_models and model not in available_models:
+        print(f"\u26a0 {feature_id}: Model '{model}' not in available models list")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Validate model fields in feature-list.json against available-models.json"
+    )
+    parser.add_argument("--feature-list", required=True, help="Path to feature-list.json")
+    parser.add_argument("--models-file", required=True, help="Path to available-models.json")
+    args = parser.parse_args()
+
+    if not os.path.exists(args.models_file):
+        sys.exit(0)
+
+    with open(args.feature_list) as f:
+        feature_data = json.load(f)
+
+    with open(args.models_file) as f:
+        models_data = json.load(f)
+
+    features = feature_data if isinstance(feature_data, list) else feature_data.get("features", [])
+
+    for feature in features:
+        validate_feature(feature, models_data)
+        for sub in feature.get("sub_features", []):
+            validate_feature(sub, models_data)
+
+
+if __name__ == "__main__":
+    main()

package/bundled/dev-pipeline/templates/bootstrap-tier1.md

@@ -31,6 +31,20 @@ You are the **session orchestrator**. Implement Feature {{FEATURE_ID}}: "{{FEATU
 
 {{GLOBAL_CONTEXT}}
 
+## ⚠️ Context Budget Rules (CRITICAL — read before any phase)
+
+You are running in headless mode with a FINITE context window. Exceeding it will crash the session and lose all work. Follow these rules strictly:
+
+1. **context-snapshot.md is your single source of truth** — After Phase 1 builds it, ALWAYS read context-snapshot.md instead of re-reading individual source files
+2. **Never re-read your own writes** — After you create/modify a file, do NOT read it back to verify. Trust your write was correct.
+3. **Stay focused** — Do NOT explore code unrelated to this feature. No curiosity-driven reads.
+4. **One task at a time** — In Phase 3 (implement), complete and test one task before starting the next.
+5. **Minimize tool output** — When running commands, use `| head -20` or `| tail -20` to limit output. Never dump entire test suites or logs.
+6. **Write session-status.json early** — Write a preliminary status file at the START of Phase 3, not just at the end.
+7. **Incremental commits when possible** — If a feature has multiple independent tasks, commit after each completed task rather than one big commit at the end.
+
+---
+
 ## PrizmKit Directory Convention
 
 ```
@@ -108,6 +122,18 @@ If plan.md missing, write it directly:
 
 ### Phase 3: Implement
 
+**Before starting implementation**, write a preliminary session-status.json to `{{SESSION_STATUS_PATH}}`:
+```json
+{
+  "status": "partial",
+  "current_phase": 3,
+  "feature_id": "{{FEATURE_ID}}",
+  "session_id": "{{SESSION_ID}}",
+  "started_at": "<current ISO timestamp>"
+}
+```
+This ensures the pipeline sees a "partial" status even if the session crashes mid-implementation.
+
 For each task in plan.md Tasks section:
 1. Read the relevant section from `context-snapshot.md` (no need to re-read individual files)
 2. Write/edit the code

package/bundled/dev-pipeline/templates/bootstrap-tier2.md

@@ -31,6 +31,20 @@ You are the **session orchestrator**. Implement Feature {{FEATURE_ID}}: "{{FEATU
 
 {{GLOBAL_CONTEXT}}
 
+## ⚠️ Context Budget Rules (CRITICAL — read before any phase)
+
+You are running in headless mode with a FINITE context window. Exceeding it will crash the session and lose all work. Follow these rules strictly:
+
+1. **context-snapshot.md is your single source of truth** — After Phase 1 builds it, ALWAYS read context-snapshot.md instead of re-reading individual source files
+2. **Never re-read your own writes** — After you create/modify a file, do NOT read it back to verify. Trust your write was correct.
+3. **Stay focused** — Do NOT explore code unrelated to this feature. No curiosity-driven reads.
+4. **One task at a time** — In Phase 3 (implement), complete and test one task before starting the next.
+5. **Minimize tool output** — When running commands, use `| head -20` or `| tail -20` to limit output. Never dump entire test suites or logs.
+6. **Write session-status.json early** — Write a preliminary status file at the START of Phase 3, not just at the end.
+7. **Incremental commits when possible** — If a feature has multiple independent tasks, commit after each completed task rather than one big commit at the end.
+
+---
+
 ## PrizmKit Directory Convention
 
 ```
@@ -118,6 +132,18 @@ If either missing, write them yourself:
 
 ### Phase 3: Implement — Dev Subagent
 
+**Before spawning Dev**, write a preliminary session-status.json to `{{SESSION_STATUS_PATH}}`:
+```json
+{
+  "status": "partial",
+  "current_phase": 3,
+  "feature_id": "{{FEATURE_ID}}",
+  "session_id": "{{SESSION_ID}}",
+  "started_at": "<current ISO timestamp>"
+}
+```
+This ensures the pipeline sees a "partial" status even if the session crashes mid-implementation.
+
 Spawn Dev subagent (Agent tool, subagent_type="prizm-dev-team-dev", run_in_background=false).
 
 Prompt: