azclaude-copilot 0.5.3 → 0.5.5

package/README.md

@@ -758,11 +758,11 @@ An agent is a sub-process. Use one when work must happen **in parallel** or **in
 
 ## Verified
 
-1767 tests. Every template, command, capability, agent, hook, and CLI feature verified.
+1788 tests. Every template, command, capability, agent, hook, and CLI feature verified.
 
 ```bash
 bash tests/test-features.sh
-# Results: 1767 passed, 0 failed, 1767 total
+# Results: 1788 passed, 0 failed, 1788 total
 ```
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azclaude-copilot",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "AI coding environment — 39 commands, 10 skills, 15 agents, memory, reflexes, evolution. Install: npx azclaude-copilot@latest, then open Claude Code.",
   "bin": {
     "azclaude": "bin/cli.js",

package/templates/capabilities/manifest.md

@@ -28,6 +28,7 @@ Load only the files that match the current task. Never load the full list.
 | shared/intelligent-dispatch.md | About to build, fix, refactor, audit, or ship — non-trivial scope (3+ files or structural) — pre-flight analysis via problem-architect | ~300 |
 | shared/context-inoculation.md | /copilot dispatch, milestone-builder spawn, autonomous agent context — inject anti-reward-hack boundaries (75-90% reduction) | ~120 |
 | shared/reward-hack-detection.md | /audit, /ship, post-milestone review — detect reward hacking patterns in test modifications | ~150 |
+| shared/ultrathink.md | $ARGUMENTS contains --deep, or command needs extended thinking for complex analysis | ~80 |
 
 ## Level Builders — load ONE at a time
 | File | When to load | Tokens |

package/templates/capabilities/shared/ultrathink.md

@@ -0,0 +1,34 @@
+---
+name: ultrathink
+description: >
+  Load when $ARGUMENTS contains --deep, or when a command needs extended thinking
+  for complex analysis. Activates deep reasoning mode — coupling analysis, root-cause
+  hypotheses, architectural trade-offs, and multi-constraint planning all benefit.
+tokens: ~80
+---
+
+## Deep Reasoning Mode — ultrathink
+
+Extended thinking is now active. Use it for the current task.
+
+### When Deep Reasoning Helps
+
+- **Coupling analysis** — trace dependencies across 5+ files before committing to a plan
+- **Root-cause hypotheses** — consider 3+ competing explanations before picking one
+- **Architectural trade-offs** — weigh multiple criteria (performance, maintainability, cost) simultaneously
+- **Wave planning** — optimize parallel dispatch across milestones with shared resources
+- **Adversarial analysis** — steelman both sides of a debate before declaring a winner
+
+### How to Apply
+
+1. **Think before acting** — spend more reasoning on analysis steps, not on boilerplate
+2. **Consider alternatives** — explicitly enumerate 2-3 approaches before choosing
+3. **Trace consequences** — for each change, trace downstream effects before writing
+4. **Challenge assumptions** — question whether the obvious approach is actually correct
+5. **Deeper search** — read more files, grep more broadly, check edge cases others skip
+
+### What NOT to Do
+
+- Do not add verbosity to output — deep thinking is internal, output stays concise
+- Do not slow down mechanical steps (file writes, test runs) — only deepen analysis
+- Do not second-guess decisions already made — apply deep thinking forward, not backward

package/templates/commands/add.md

@@ -18,6 +18,17 @@ Load: shared/tdd.md + shared/completion-rule.md
 
 ---
 
+## Deep Mode Detection
+
+If `$ARGUMENTS` contains `--deep`:
+1. Strip `--deep` from arguments before processing
+2. Load `shared/ultrathink.md` — enables extended thinking for complex features
+3. At the Complexity Gate: analyze 2-3 implementation approaches with trade-offs before choosing
+4. Trace downstream effects — what tests, configs, and consumers will this change affect?
+5. Consider edge cases that quick implementation would miss
+
+---
+
 ## Pre-Flight: Constitution + Code Rules + Spec Check
 
 ```bash

package/templates/commands/blueprint.md

@@ -17,6 +17,17 @@ allowed-tools: Read, Grep, Glob, Bash
 
 $ARGUMENTS
 
+## Deep Mode Detection
+
+If `$ARGUMENTS` contains `--deep`:
+1. Strip `--deep` from arguments before processing
+2. Load `shared/ultrathink.md` — enables extended thinking for coupling analysis, wave planning, and risk assessment
+3. In Step 2 (Map the Impact): read MORE files, trace dependencies deeper, check 2nd-order effects
+4. In Step 3 (Write the Plan): consider 2-3 alternative approaches before choosing the plan structure
+5. In Parallel Planning: spend more reasoning on coupling analysis — catch subtle shared-resource conflicts
+
+---
+
 **Use /add for straightforward features. Use /blueprint when:**
 - The change touches 4+ files
 - It involves a schema, API contract, or interface change

package/templates/commands/debate.md

@@ -11,6 +11,15 @@ $ARGUMENTS
 
 ---
 
+## Deep Mode Detection
+
+If `$ARGUMENTS` contains `--deep`:
+1. Strip `--deep` from arguments before processing
+2. Load `shared/ultrathink.md` — enables extended thinking for adversarial analysis
+3. Steelman each position harder — find the strongest version of every argument before comparing
+4. Consider 2nd-order consequences: "if we pick A, what breaks in 6 months?"
+5. Search for hidden third options that neither side proposed
+
 ---
 
 ## When to Use This

package/templates/commands/dream.md

@@ -13,6 +13,17 @@ $ARGUMENTS
 
 ---
 
+## Deep Mode Detection
+
+If `$ARGUMENTS` contains `--deep`:
+1. Strip `--deep` from arguments before processing
+2. Load `shared/ultrathink.md` — enables extended thinking for vision exploration
+3. Explore 3+ architectural approaches before choosing the stack
+4. Consider scaling implications, deployment complexity, and team skill requirements
+5. Research deeper — use WebSearch for current best practices before committing to a direction
+
+---
+
 ## Copilot Mode Detection
 
 ```bash

package/templates/commands/fix.md

@@ -14,6 +14,17 @@ Load: shared/tdd.md + shared/completion-rule.md before starting.
 
 ---
 
+## Deep Mode Detection
+
+If `$ARGUMENTS` contains `--deep`:
+1. Strip `--deep` from arguments before processing
+2. Load `shared/ultrathink.md` — enables extended thinking for root-cause analysis
+3. In Phase 3 (Hypothesize): generate 3+ competing hypotheses before committing to one
+4. Trace each hypothesis through the full call chain — don't stop at the first plausible explanation
+5. Check for systemic causes: is this a symptom of a deeper architectural issue?
+
+---
+
 ## Pre-Flight: Constitution + Code Rules Check
 
 ```bash

package/templates/hooks/user-prompt.js

@@ -195,6 +195,48 @@ try {
   }
 } catch (_) {}
 
+// ── Compaction Guard — auto-snapshot before context is lost ─────────────────
+// Reads context % signal from statusline (written to temp file after each turn).
+// At >= 70%: warns Claude to save state. At >= 85%: auto-saves checkpoint.
+try {
+  const ctxSignalPath = path.join(os.tmpdir(), `.azclaude-ctx-${process.ppid || process.pid}`);
+  if (fs.existsSync(ctxSignalPath)) {
+    const ctxSignal = JSON.parse(fs.readFileSync(ctxSignalPath, 'utf8'));
+    const pct = ctxSignal.ctxPct || 0;
+
+    if (pct >= 85) {
+      // AUTO-SAVE: context is critically high — save checkpoint before compaction wipes it
+      const checkpointDir = path.join(cfg, 'memory', 'checkpoints');
+      try { fs.mkdirSync(checkpointDir, { recursive: true }); } catch (_) {}
+      const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 16);
+      const cpPath = path.join(checkpointDir, `${ts}-auto-compaction.md`);
+
+      // Only auto-save once per threshold crossing (check if already saved)
+      const autoSaveMarker = path.join(os.tmpdir(), `.azclaude-autosave-${process.ppid || process.pid}`);
+      if (!fs.existsSync(autoSaveMarker)) {
+        // Copy goals.md as checkpoint
+        if (fs.existsSync(goalsPath)) {
+          const goalsContent = fs.readFileSync(goalsPath, 'utf8');
+          const header = `---\ndate: ${new Date().toISOString()}\nlabel: auto-compaction-guard-${pct}pct\nfiles_in_progress: []\n---\n\n`;
+          fs.writeFileSync(cpPath, header + '## Auto-saved before compaction\n\n' + goalsContent);
+          fs.writeFileSync(autoSaveMarker, '');
+        }
+
+        console.log('');
+        console.log(`--- COMPACTION GUARD (${pct}%) ---`);
+        console.log(`Context at ${pct}% — AUTO-SAVED checkpoint to ${path.basename(cpPath)}`);
+        console.log('Run /snapshot NOW to save your reasoning and decisions (goals.md alone is not enough).');
+        console.log('--- END GUARD ---');
+      }
+    } else if (pct >= 70) {
+      console.log('');
+      console.log(`--- COMPACTION WARNING (${pct}%) ---`);
+      console.log(`Context at ${pct}% — compaction approaching. Run /snapshot to save session state.`);
+      console.log('--- END WARNING ---');
+    }
+  }
+} catch (_) {}
+
 // ── First message only — inject full context ────────────────────────────────
 if (!isFirstMessage) process.exit(0);
 

package/templates/scripts/statusline.js

@@ -117,6 +117,13 @@ process.stdin.on('end', () => {
   const empty  = 10 - filled;
   const bar    = '\u2593'.repeat(filled) + '\u2591'.repeat(empty);
 
+  // ── Compaction signal — write context % to temp file for hook to read ──
+  // This enables the UserPromptSubmit hook to auto-snapshot before compaction.
+  try {
+    const signalPath = path.join(require('os').tmpdir(), `.azclaude-ctx-${process.ppid || process.pid}`);
+    fs.writeFileSync(signalPath, JSON.stringify({ ctxPct, turnsLeft: compactHint ? parseInt(compactHint.replace(/[^0-9]/g,'')) : 999 }));
+  } catch (_) {}
+
   // ── Color thresholds ──
   let ctxColor, ctxWarn = '';
   if (ctxPct >= 80)      { ctxColor = RED;    ctxWarn = ' COMPACT SOON'; }