mindforge-cc 1.0.4 → 2.0.0-alpha.4

package/.mindforge/engine/autonomous/stuck-detector.md

@@ -0,0 +1,89 @@
+# MindForge v2 — Stuck Detection Engine
+
+## Purpose
+Identify iterative loops where the agent is making no progress but still
+consuming tokens. This engine monitors the AUDIT.jsonl stream and triggers
+ESCALATE when specific failure patterns (S01-S05) are detected.
+
+---
+
+## Stuck patterns (Signatures)
+
+### S01 — The Lint Loop (The "Infinite Fixer")
+**Signature:** Multi-replace calls on the same file 3+ times with identical
+or near-identical (Levenshtein distance < 10) `Instruction` and `TargetContent`.
+**Verdict:** Agent is stuck in a "fix lint -> new lint -> fix lint" cycle
+without resolving the underlying pattern.
+**Action:** ESCALATE. "Stuck in lint loop on [file]."
+
+### S02 — The Command Loop (The "Dead Command")
+**Signature:** `run_command` called with identical `CommandLine` 3+ times
+within 5 minutes, where each command returns status `done` but with
+non-zero exit code or "command not found" stderr.
+**Verdict:** Agent expects a command to exist and is retrying it blindly.
+**Action:** ESCALATE. "Stuck retrying missing or failing command: [command]."
+
+### S03 — The Dependency Loop (The "Circular Wait")
+**Signature:** Two plans (A and B) both mark the other as a dependency in
+the PLAN-N-MM.md files, causing the wave engine to never start either.
+**Verdict:** Broken wave DAG.
+**Action:** ESCALATE. "Circular dependency detected between [A] and [B]."
+
+### S04 — The Verification Loop (The "Proofless Progress")
+**Signature:** Path: EXECUTE → VERIFY (fails) → EXECUTE → VERIFY (fails)
+where the `ReplacementContent` in EXECUTE is identical to the previous attempt.
+**Verdict:** Agent is trying the same fix multiple times expecting a different result.
+**Action:** RETRY (once with forced error injection) → DECOMPOSE.
+If decomposition also fails this loop signature: ESCALATE.
+
+### S05 — The Multi-Agent Collision
+**Signature:** Two subagents in the same wave attempting to `multi_replace`
+the same file simultaneously (Gate 1 violation detected multiple times).
+**Verdict:** Wave planning is too aggressive or files are poorly isolated.
+**Action:** RE-PLAN current wave. Move one of the colliding plans to the next wave.
+
+---
+
+## Stuck detection logic (Monitor)
+
+The stuck monitor runs as a sidecar process in `/mindforge:auto`.
+It reads `.planning/AUDIT.jsonl` in real time.
+
+```javascript
+// bin/autonomous/stuck-monitor.js logic
+const fs = require('fs');
+
+function monitorAuditStream(auditPath) {
+  let lastPos = 0;
+  setInterval(() => {
+    const stats = fs.statSync(auditPath);
+    if (stats.size > lastPos) {
+      const newLines = readLines(auditPath, lastPos, stats.size);
+      newLines.forEach(line => {
+        const event = JSON.parse(line);
+        checkS01(event);
+        checkS02(event);
+        checkS04(event);
+      });
+      lastPos = stats.size;
+    }
+  }, 5000); // Check every 5 seconds
+}
+```
+
+---
+
+## Recovery protocols
+
+When a pattern is matched:
+
+1. **Stop the subagent** immediately if still running.
+2. **Identify the pattern** in the progress stream.
+3. **Execute recovery** based on pattern type:
+   - S01/S02/S03: ESCALATE (requires human to fix command/context).
+   - S04: Invoke NODE_REPAIR with `DECOMPOSE` mandatory.
+   - S05: Invoke AUTO_PLAN --adjust-waves to resolve parallelism issues.
+4. **Write to AUDIT**:
+   ```json
+   { "event": "stuck_pattern_detected", "pattern": "S01", "file": "src/api.js" }
+   ```

package/.mindforge/memory/MEMORY-SCHEMA.md

@@ -0,0 +1,155 @@
+# MindForge v2 — Knowledge Graph Schema
+
+## Overview
+
+The MindForge knowledge graph is built from five JSONL files — all append-only,
+all at `.mindforge/memory/`. Every entry has a consistent base schema plus
+type-specific fields.
+
+## Base schema (all entry types)
+
+```json
+{
+  "id":               "kb-uuid-v4",
+  "timestamp":        "ISO-8601",
+  "type":             "architectural_decision|code_pattern|bug_pattern|team_preference|domain_knowledge",
+  "topic":            "Short title (≤ 80 chars)",
+  "content":          "Full knowledge content (no limit)",
+  "source":           "Where this was captured: 'Phase 3 retro', 'Debug session 2026-01', 'Manual entry'",
+  "project":          "project-name from PROJECT.md",
+  "confidence":       0.0,
+  "tags":             ["tag1", "tag2"],
+  "linked_adrs":      ["ADR-007"],
+  "times_referenced": 0,
+  "last_referenced":  null,
+  "deprecated":       false,
+  "deprecated_by":    null
+}
+```
+
+## Type-specific schemas
+
+### `architectural_decision`
+
+Extended fields:
+
+```json
+{
+  "decision":     "Use argon2id for password hashing",
+  "rationale":    "bcrypt is showing its age; argon2id is the modern standard",
+  "alternatives": ["bcrypt", "scrypt", "pbkdf2"],
+  "phase_number": 3,
+  "adr_reference": "ADR-007"
+}
+```
+
+Capture trigger: Phase completion (ADR files extracted), `/mindforge:discuss-phase`
+
+### `code_pattern`
+
+Extended fields:
+
+```json
+{
+  "pattern_type": "good|anti-pattern",
+  "language":     "typescript",
+  "example_good": "// Code showing the correct pattern",
+  "example_bad":  "// Code showing the incorrect pattern (for anti-patterns)",
+  "applies_to":   ["auth", "database", "api"]
+}
+```
+
+Capture trigger: Smart compaction Block D, debug session root cause
+
+### `bug_pattern`
+
+Extended fields:
+
+```json
+{
+  "bug_category":   "auth|database|api|ui|performance|security",
+  "symptom":        "Login works in tests but fails in production with cookie errors",
+  "root_cause":     "httpOnly cookies require HTTPS; dev server was HTTP",
+  "fix":            "Enable HTTPS in dev or use secure: false in development only",
+  "prevention":     "Always configure cookie settings per-environment",
+  "severity_when_missed": "HIGH",
+  "recurrence_count": 1
+}
+```
+
+Capture trigger: Debug session completion, security findings, retrospective "what went wrong"
+
+### `team_preference`
+
+Extended fields:
+
+```json
+{
+  "preference_type": "style|tool|process|convention|architecture",
+  "applies_when":    "When implementing auth",
+  "preference":      "Always use argon2id, never bcrypt. See ADR-007.",
+  "strength":        "strong|moderate|weak",
+  "override_allowed": true
+}
+```
+
+Capture trigger: Retrospective "what should we keep doing", steering instructions,
+MINDFORGE.md changes from retrospective
+
+### `domain_knowledge`
+
+Extended fields:
+
+```json
+{
+  "domain":     "JWT security",
+  "tech_stack": ["node.js", "typescript"],
+  "knowledge":  "JWT access tokens should be short-lived (15 min). Refresh tokens in httpOnly cookies, not localStorage. Never decode JWT without verifying signature.",
+  "source_url": "https://auth0.com/docs/secure/tokens/json-web-tokens",
+  "verified_at": "2026-01-15"
+}
+```
+
+Capture trigger: Research engine output, `/mindforge:remember --add`
+
+## Confidence scoring
+
+Confidence (0.0–1.0) represents how strongly this knowledge should be applied:
+
+| Confidence | Meaning | How set |
+| :--- | :--- | :--- |
+| 0.9–1.0 | Strong team decision — always apply | Manual entry, strong steering, ADR |
+| 0.7–0.9 | Clear pattern — apply unless there's a reason not to | Retrospective, debug session |
+| 0.5–0.7 | Observed pattern — consider but verify | Smart compaction Block D |
+| 0.3–0.5 | Weak signal — informational only | Single observation |
+| < 0.3 | Hypothesis — don't apply proactively | Auto-captured, unverified |
+
+## Confidence reinforcement
+
+Each time an entry is referenced (retrieved and the advice was followed):
+
+```bash
+confidence = min(1.0, confidence + 0.05)
+times_referenced += 1
+```
+
+Each time an entry is contradicted (a different decision was made):
+
+```bash
+confidence = max(0.0, confidence - 0.10)
+```
+
+## Deprecation
+
+When a knowledge entry becomes outdated (e.g., team switches from argon2id to Passkeys):
+
+```json
+{
+  "deprecated": true,
+  "deprecated_by": "kb-uuid-of-newer-entry",
+  "deprecated_reason": "Superseded by WebAuthn/Passkeys approach (ADR-031)"
+}
+```
+
+Deprecated entries are never deleted — they are excluded from active retrieval
+but available for historical queries.

package/.mindforge/memory/engine/capture-protocol.md

@@ -0,0 +1,36 @@
+# MindForge v2 — Knowledge Capture Protocol
+
+## Purpose
+
+The Capture Engine automatically extracts valuable engineering knowledge from session artifacts to ensure that project-specific wisdom is preserved beyond a single handoff.
+
+## Capture Triggers
+
+MindForge monitors the following lifecycle events for knowledge extraction:
+
+1. **Phase Completion**: Extracting architectural decisions from `PROJECT.md` and phase retrospectives.
+2. **Hardened Debugging**: Capturing "root cause -> fix" patterns from completed debug reports.
+3. **Manual Command**: Using `/mindforge:remember --add` to explicitly record team preferences or domain knowledge.
+4. **ADR Generation**: Parsing newly created Architecture Decision Records.
+
+## Extraction Logic
+
+The extraction process (via `knowledge-capture.js`) involves:
+
+- **Structural Parsing**: Identifying standardized headings (e.g., "Decision", "Root Cause", "Pattern").
+- **Deduplication**: Checking for existing entries with similar content to prevent knowledge bloat.
+- **Initial Confidence**: Assigning a default confidence score (usually 0.5) to newly captured entries.
+- **Auto-Tagging**: Inferring tags based on the file path and content context (e.g., `#nodejs`, `#security`).
+
+## Inhibitors (What NOT to capture)
+
+To prevent the knowledge base from becoming "noisy", the system ignores:
+
+- Transient session state (e.g., local file counts).
+- Intermediate debugging steps that didn't lead to a fix.
+- Content marked with `#no-capture` or inside blocks labeled "Confidential".
+
+## Retention Policy
+
+- **Append-only**: Entries are never physically deleted.
+- **Deprecation**: Outdated entries are marked as `deprecated: true` and replaced by newer entries with the same `source_id`.

package/.mindforge/memory/engine/global-sync-spec.md

@@ -0,0 +1,42 @@
+# MindForge v2 — Global Knowledge Sync Specification
+
+## Purpose
+
+Allow knowledge to flow between projects via a machine-level global store.
+Team members can promote project-specific insights to their global knowledge base,
+which loads into every future project's session start.
+
+## Storage locations
+
+- **Project-local:** `.mindforge/memory/knowledge-base.jsonl` (per repo)
+- **Global (machine):** `~/.mindforge/global-knowledge-base.jsonl` (per developer)
+
+## Sync rules
+
+- Promotion is MANUAL — nothing is auto-promoted to global. Use `/mindforge:remember --promote [ID]`.
+- Loading is AUTOMATIC — global entries load at every session start if relevant.
+- Project entries take precedence over global entries (same ID = local wins).
+- Global entries receive a metadata flag `global: true` but are ranked alongside project entries based on relevance.
+
+## What should be promoted to global
+
+Good candidates for global promotion:
+
+- Language-agnostic security practices ("always validate input before database queries")
+- Technology-specific best practices learned through experience ("argon2id over bcrypt")
+- Universal debugging patterns ("check the timezone mismatch before blaming async code")
+- Cross-project architectural preferences ("Repository pattern over active record")
+
+## Global entry metadata
+
+When promoted to global, entries gain:
+
+```json
+{
+  "global": true,
+  "promoted_at": "ISO-8601",
+  "promoted_from_project": "saas-app",
+  "promoted_by": "git-config-user-email",
+  "global_applicability": "all|typescript|nodejs|react|[specific]"
+}
+```

package/.mindforge/memory/engine/retrieval-spec.md

@@ -0,0 +1,44 @@
+# MindForge v2 — Knowledge Retrieval Specification
+
+## Purpose
+
+The Retrieval Engine is responsible for identifying and loading the most relevant pieces of long-term memory into the current session context to improve agent performance and consistency.
+
+## Components
+
+- **Indexer (`knowledge-indexer.js`)**: Handles the scoring and ranking of knowledge entries.
+- **Session Loader (`session-memory-loader.js`)**: Orchestrates the loading of relevant memories at the start of a session.
+
+## Scoring Logic (TF-IDF + Heuristics)
+
+Relevance is calculated using a multi-factor scoring model:
+
+1. **Text Search (TF-IDF)**:
+    - Tokenizes the query and knowledge text.
+    - Calculates Term Frequency (TF) and Inverse Document Frequency (IDF).
+    - Entries must have a positive TF-IDF score to be considered relevant if keywords are present.
+
+2. **Confidence & Recency**:
+    - **Confidence Score**: Boosts entries with higher confidence levels (reinforced over time).
+    - **Recency Decay**: Prefer more recent knowledge entries, especially for bug patterns.
+
+3. **Tag Overlap**:
+    - Queries can include required tags (e.g., `#typescript`).
+    - Entries with matching tags receive a significant boost.
+
+4. **Inhibitors**:
+    - Deprecated entries are never retrieved.
+    - Low-confidence "noise" entries are filtered out.
+
+## Context Injection
+
+During session start, the loader:
+1. Performs a broad search based on the current project's primary technology stack and recent activities.
+2. Selects the top `N` (default 5-10) most relevant entries.
+3. Injects them into the agent's secondary context (e.g., as a dedicated "Memory context" block).
+
+## SDK Interface
+
+```typescript
+const relevantKnowledge = await memory.query("query string", ["#tag1"], 5);
+```

package/.mindforge/memory/knowledge-base.jsonl

@@ -0,0 +1,7 @@
+{"id":"34a7925f-7361-4836-91eb-916495033861","timestamp":"2026-03-22T17:25:37.659Z","type":"team_preference","topic":"Use Tailwind","content":"Always use Tailwind for CSS.","source":"manual","project":"[Project Name]","confidence":0.9,"tags":["ui","css"],"linked_adrs":[],"times_referenced":0,"last_referenced":null,"deprecated":false,"deprecated_by":null}
+{"id":"34a7925f-7361-4836-91eb-916495033861","timestamp":"2026-03-22T17:25:37.659Z","type":"team_preference","topic":"Use Tailwind","content":"Always use Tailwind for CSS.","source":"manual","project":"[Project Name]","confidence":0.9500000000000001,"tags":["ui","css"],"linked_adrs":[],"times_referenced":1,"last_referenced":"2026-03-22T17:25:37.665Z","deprecated":false,"deprecated_by":null}
+{"id":"34a7925f-7361-4836-91eb-916495033861","timestamp":"2026-03-22T17:25:37.659Z","type":"team_preference","topic":"Use Tailwind","content":"Always use Tailwind for CSS.","source":"manual","project":"[Project Name]","confidence":0.9500000000000001,"tags":["ui","css"],"linked_adrs":[],"times_referenced":1,"last_referenced":"2026-03-22T17:25:37.665Z","deprecated":true,"deprecated_by":null,"deprecated_reason":"Switching to Vanilla CSS","deprecated_at":"2026-03-22T17:25:37.666Z"}
+{"id":"a2d4b3a6-fdaa-4c9a-b654-286d9ea133e2","timestamp":"2026-03-22T17:25:37.670Z","type":"domain_knowledge","topic":"Auth with JWT","content":"Secure JWT with httpOnly cookies.","source":"manual","project":"[Project Name]","confidence":0.8,"tags":["auth"],"linked_adrs":[],"times_referenced":0,"last_referenced":null,"deprecated":false,"deprecated_by":null}
+{"id":"6c1f0f31-3903-4b95-bae8-5473ffbec9eb","timestamp":"2026-03-22T17:25:37.671Z","type":"domain_knowledge","topic":"Database SQL","content":"Use indexed columns for fast queries.","source":"manual","project":"[Project Name]","confidence":0.7,"tags":["db"],"linked_adrs":[],"times_referenced":0,"last_referenced":null,"deprecated":false,"deprecated_by":null}
+{"id":"a9878977-cb7c-4dcf-8161-760ffd5e7de9","timestamp":"2026-03-22T17:25:37.673Z","type":"code_pattern","topic":"React Memo","content":"Use React.memo to prevent re-renders.","source":"manual","project":"[Project Name]","confidence":0.6,"tags":["ui"],"linked_adrs":[],"times_referenced":0,"last_referenced":null,"deprecated":false,"deprecated_by":null}
+{"id":"739dcb0a-9c4b-40d2-846b-535b7e4cb274","timestamp":"2026-03-22T17:25:51.782Z","type":"team_preference","topic":"Use Tailwind","content":"Always use Tailwind for CSS.","source":"manual","project":"[Project Name]","confidence":0.9,"tags":["ui","css"],"linked_adrs":[],"times_referenced":0,"last_referenced":null,"deprecated":false,"deprecated_by":null}

package/.mindforge/memory/pattern-library.jsonl

@@ -0,0 +1 @@
+{"id":"a9878977-cb7c-4dcf-8161-760ffd5e7de9","timestamp":"2026-03-22T17:25:37.673Z","type":"code_pattern","topic":"React Memo","content":"Use React.memo to prevent re-renders.","source":"manual","project":"[Project Name]","confidence":0.6,"tags":["ui"],"linked_adrs":[],"times_referenced":0,"last_referenced":null,"deprecated":false,"deprecated_by":null}

package/.mindforge/memory/team-preferences.jsonl

@@ -0,0 +1,4 @@
+{"id":"34a7925f-7361-4836-91eb-916495033861","timestamp":"2026-03-22T17:25:37.659Z","type":"team_preference","topic":"Use Tailwind","content":"Always use Tailwind for CSS.","source":"manual","project":"[Project Name]","confidence":0.9,"tags":["ui","css"],"linked_adrs":[],"times_referenced":0,"last_referenced":null,"deprecated":false,"deprecated_by":null}
+{"id":"34a7925f-7361-4836-91eb-916495033861","timestamp":"2026-03-22T17:25:37.659Z","type":"team_preference","topic":"Use Tailwind","content":"Always use Tailwind for CSS.","source":"manual","project":"[Project Name]","confidence":0.9500000000000001,"tags":["ui","css"],"linked_adrs":[],"times_referenced":1,"last_referenced":"2026-03-22T17:25:37.665Z","deprecated":false,"deprecated_by":null}
+{"id":"34a7925f-7361-4836-91eb-916495033861","timestamp":"2026-03-22T17:25:37.659Z","type":"team_preference","topic":"Use Tailwind","content":"Always use Tailwind for CSS.","source":"manual","project":"[Project Name]","confidence":0.9500000000000001,"tags":["ui","css"],"linked_adrs":[],"times_referenced":1,"last_referenced":"2026-03-22T17:25:37.665Z","deprecated":true,"deprecated_by":null,"deprecated_reason":"Switching to Vanilla CSS","deprecated_at":"2026-03-22T17:25:37.666Z"}
+{"id":"739dcb0a-9c4b-40d2-846b-535b7e4cb274","timestamp":"2026-03-22T17:25:51.782Z","type":"team_preference","topic":"Use Tailwind","content":"Always use Tailwind for CSS.","source":"manual","project":"[Project Name]","confidence":0.9,"tags":["ui","css"],"linked_adrs":[],"times_referenced":0,"last_referenced":null,"deprecated":false,"deprecated_by":null}

package/.mindforge/models/model-registry.md

@@ -0,0 +1,48 @@
+# MindForge v2 — Model Registry
+# Version: v2.0.0-alpha.3
+
+MindForge v2 uses a tiered multi-model architecture. Models are selected based on the task persona and difficulty tier.
+
+## 1. Primary Reasoning Tier (Tier 1)
+Used for complex architecture, planning, and high-stakes reasoning.
+
+- **Anthropic Claude 3.5 Opus** (`claude-3-opus-20240229`)
+  - Strengths: Deepest reasoning, highly reliable for planning.
+  - Persona mapping: `architect`, `planner`.
+  - Setting: `PLANNER_MODEL`.
+
+- **OpenAI GPT-4o** (`gpt-4o`)
+  - Strengths: Fast reasoning, excellent tool use, adversarial insight.
+  - Persona mapping: `reviewer`, `security-reviewer`.
+  - Setting: `REVIEWER_MODEL`.
+
+## 2. Execution Tier (Tier 2)
+Used for the bulk of code implementation and transformation tasks.
+
+- **Anthropic Claude 3.5 Sonnet** (`claude-3-5-sonnet-20240620`)
+  - Strengths: Balanced speed/quality, best-in-class coding.
+  - Persona mapping: `developer`, `qa-engineer`.
+  - Setting: `EXECUTOR_MODEL`.
+
+- **Google Gemini 1.5 Pro** (`gemini-1.5-pro`)
+  - Strengths: 1M context window, deep codebase research.
+  - Persona mapping: `research-agent`.
+  - Setting: `RESEARCH_MODEL`.
+
+## 3. High-Security/Privacy Tier (Tier 3)
+Used for tasks involving authentication, PII, or financial operations.
+
+- **Anthropic Claude 3.5 Opus** (`claude-3-opus-20240229`)
+  - Setting: `SECURITY_MODEL`.
+
+## 4. Utility/Quick Tier (Tier 4)
+Used for low-ambiguity tasks and micro-transformations.
+
+- **Anthropic Claude 3.5 Haiku** (`claude-3-5-haiku-20241022`)
+  - Setting: `QUICK_MODEL`.
+
+## 5. Fallback Chain
+If a primary model is unavailable (API key missing or 429), follow these defaults:
+1. `gpt-4o` → `claude-3-5-sonnet`
+2. `claude-3-opus` → `gpt-4o`
+3. `gemini-1.5-pro` → `claude-3-5-sonnet` (limited context)

package/.mindforge/models/model-router.md

@@ -0,0 +1,30 @@
+# MindForge v2 — Model Router
+# Version: v2.0.0-alpha.3
+
+## Routing Logic
+
+The MindForge router resolves which model to use at task dispatch time using this algorithm:
+
+1. **Check Persona:** Map the task `<persona>` to a setting key.
+   - `developer` → `EXECUTOR_MODEL`
+   - `architect` → `PLANNER_MODEL`
+   - `security-reviewer` → `SECURITY_MODEL`
+   - `qa-engineer` → `QA_MODEL`
+   - `research-agent` → `RESEARCH_MODEL`
+   - `debug-specialist` → `DEBUG_MODEL`
+   - `unknown` → `EXECUTOR_MODEL`
+
+2. **Check Tier Override:**
+   - If `tier == 3` (Security/Privacy), force `SECURITY_MODEL` regardless of persona.
+
+3. **Check Budget Bias:**
+   - If `difficulty < 2.0` and `MODEL_PREFER_CHEAP_BELOW_DIFFICULTY` is set:
+     - Use `QUICK_MODEL` instead of the resolved model.
+
+4. **Resolve Model ID:**
+   - Read the setting key from `MINDFORGE.md`.
+   - Use baked-in defaults if not present.
+
+5. **Verify Availability:**
+   - Check if matching `[PROVIDER]_API_KEY` is present in environment.
+   - If missing: Apply fallback chain from `model-registry.md`.

package/.mindforge/personas/research-agent.md

@@ -0,0 +1,24 @@
+# Research Agent Persona
+
+## Identity
+You are a thorough technical research specialist with access to Gemini 2.5 Pro's
+1-million-token context window. You are the agent called when a question requires
+ingesting entire documentation sets, large codebases, or multiple long documents
+simultaneously.
+
+## Unique Capabilities
+- **Full documentation ingestion**: Read entire library documentation before making recommendations.
+- **Codebase archaeology**: Ingest the entire codebase to identify undocumented decisions or debt.
+- **Regulatory completeness**: Ingest full regulation texts (GDPR, HIPAA, PCI DSS) for compliance audits.
+
+## Output Standard
+Every research output must have:
+1. **Executive summary** (actionable)
+2. **Detailed findings** (with evidence citations)
+3. **Specific recommendations**
+4. **Open questions**
+5. **Sources consulted**
+
+## Model Assignment
+Default: `RESEARCH_MODEL` (gemini-2.5-pro)
+Context requirement: > 500K tokens.

package/.planning/browser-daemon.log

@@ -0,0 +1,32 @@
+node:internal/modules/cjs/loader:1459
+  throw err;
+  ^
+
+Error: Cannot find module 'playwright-core'
+Require stack:
+- /Users/sairamugge/Desktop/MindForge/bin/browser/browser-daemon.js
+    at Module._resolveFilename (node:internal/modules/cjs/loader:1456:15)
+    at defaultResolveImpl (node:internal/modules/cjs/loader:1066:19)
+    at resolveForCJSWithHooks (node:internal/modules/cjs/loader:1071:22)
+    at Module._load (node:internal/modules/cjs/loader:1242:25)
+    at wrapModuleLoad (node:internal/modules/cjs/loader:255:19)
+    at Module.require (node:internal/modules/cjs/loader:1556:12)
+    at require (node:internal/modules/helpers:152:16)
+    at Object.<anonymous> (/Users/sairamugge/Desktop/MindForge/bin/browser/browser-daemon.js:9:20)
+    at Module._compile (node:internal/modules/cjs/loader:1812:14)
+    at Object..js (node:internal/modules/cjs/loader:1943:10) {
+  code: 'MODULE_NOT_FOUND',
+  requireStack: [
+    '/Users/sairamugge/Desktop/MindForge/bin/browser/browser-daemon.js'
+  ]
+}
+
+Node.js v24.14.0
+[daemon] Browser daemon listening on port 7338
+[daemon] Browser daemon listening on port 7338
+[daemon] Browser daemon listening on port 7338
+[daemon] Browser daemon listening on port 7338
+[daemon] Browser daemon listening on port 7338
+[daemon] Browser daemon listening on port 7338
+[daemon] Browser daemon listening on port 7338
+[daemon] Browser daemon listening on port 7338

package/.planning/decisions/ADR-021-autonomy-boundary.md

@@ -0,0 +1,17 @@
+# ADR-021: Autonomy Boundary
+
+## Status: Proposed
+## Deciders: MindForge Architecture Team
+## Date: 2026-03-22
+
+## Context
+MindForge v2 introduces an Autonomous Execution Engine. We need to define where the human's role ends and the agent's role begins to prevent loss of control while maximizing efficiency.
+
+## Decision
+We define the **Autonomy Boundary** as:
+1. **Human = Mission Control**: Humans define the phase objectives, approve the initial plan, and provide mid-execution steering.
+2. **Agent = Execution Engine**: The agent handles the mechanics of wave execution, parallel task dispatch, automated verification, and self-repair for low-risk failures.
+
+## Consequences
+- The agent will not ask for permission for individual tasks in a wave once the phase is started in `:auto` mode.
+- Any decision involving security, payments, or PII (Tier 3) MUST escalate to the human, as it lies outside the autonomy boundary.

package/.planning/decisions/ADR-022-node-repair-hierarchy.md

@@ -0,0 +1,19 @@
+# ADR-022: Node Repair Hierarchy
+
+## Status: Proposed
+## Deciders: MindForge Architecture Team
+## Date: 2026-03-22
+
+## Context
+Tasks in autonomous mode can fail due to various reasons (timeouts, lint errors, logic bugs). Sequential retrying is often insufficient.
+
+## Decision
+We implement a tiered **Node Repair Hierarchy**:
+1. **RETRY**: Re-execute the same plan with a fresh context + error injection. (Budget: 1)
+2. **DECOMPOSE**: Split a failing multi-domain or high-token task into smaller sub-tasks.
+3. **PRUNE**: Skip non-critical path tasks and defer them to a `DEFERRED-ITEMS.md`.
+4. **ESCALATE**: Stop execution, save state, and notify the human.
+
+## Consequences
+- Increases the survival rate of autonomous sessions without human intervention for trivial errors.
+- Ensures complex failures are handled by human experts.

package/.planning/decisions/ADR-023-gate-3-timing.md

@@ -0,0 +1,15 @@
+# ADR-023: Gate 3 Timing
+
+## Status: Proposed
+## Deciders: MindForge Architecture Team
+## Date: 2026-03-22
+
+## Context
+Gate 3 (Secret Detection) used to run post-wave. In autonomous mode, the agent makes multiple commits per wave. A secret committed to git history is an immediate security incident even if never pushed.
+
+## Decision
+Gate 3 must run **PRE-COMMIT** on the staged diff for every task in autonomous mode. If a secret pattern is detected, the commit is blocked, the changes are unstaged, and the engine ESCALATES immediately.
+
+## Consequences
+- Prevents accidental leakage of credentials into the local git history.
+- Adds slight latency to the commit process, which is acceptable for the security gain.