tribunal-kit 4.4.3 → 4.4.4

package/.agent/scripts/marathon_harness.js

@@ -39,7 +39,7 @@ const ARCHIVE_DIR = path.join(MARATHON_DIR, 'archive');
 
 const VALID_COMMANDS = new Set([
     'init', 'status', 'next', 'mark', 'log',
-    'session-start', 'session-end', 'reset', 'add-feature'
+    'session-start', 'session-end', 'reset', 'add-feature', 'distill'
 ]);
 
 // ── Schema Defaults ──────────────────────────────────────────────────────────
@@ -153,25 +153,50 @@ function getGitBranch() {
 // ── Progress Helpers ─────────────────────────────────────────────────────────
 
 /**
- * Count passing features.
+ * Count passing features and blocked features.
  * @param {object} featureList
- * @returns {{ total: number, passing: number, failing: number }}
+ * @returns {{ total: number, passing: number, failing: number, blocked: number }}
  */
 function countFeatures(featureList) {
     const features = featureList.features || [];
     const total = features.length;
     const passing = features.filter(f => f.passes === true).length;
-    return { total, passing, failing: total - passing };
+    let blocked = 0;
+    
+    features.forEach(f => {
+        if (!f.passes && f.dependencies && f.dependencies.length > 0) {
+            const allPassed = f.dependencies.every(depId => {
+                const dep = features.find(d => d.id === depId);
+                return dep && dep.passes === true;
+            });
+            if (!allPassed) blocked++;
+        }
+    });
+    
+    return { total, passing, failing: total - passing, blocked };
 }
 
 /**
- * Get the next unfinished feature.
+ * Get the next unfinished, unblocked feature.
  * @param {object} featureList
  * @returns {object|null}
  */
 function getNextFeature(featureList) {
     const features = featureList.features || [];
-    return features.find(f => f.passes !== true) || null;
+    return features.find(f => {
+        if (f.passes === true) return false;
+        
+        // Check dependencies (DAG)
+        if (f.dependencies && f.dependencies.length > 0) {
+            const allPassed = f.dependencies.every(depId => {
+                const dep = features.find(d => d.id === depId);
+                return dep && dep.passes === true;
+            });
+            if (!allPassed) return false; // Feature is blocked
+        }
+        
+        return true;
+    }) || null;
 }
 
 /**
@@ -240,8 +265,9 @@ function cmdInit(spec) {
  * @param {string} category
  * @param {string} description
  * @param {string[]} steps
+ * @param {number[]} deps
  */
-function cmdAddFeature(category, description, steps) {
+function cmdAddFeature(category, description, steps, deps = []) {
     if (!isActive()) {
         console.error(`${RED}❌ No active marathon. Run ${CYAN}init${RED} first.${RESET}`);
         process.exit(1);
@@ -264,6 +290,9 @@ function cmdAddFeature(category, description, steps) {
         category: category.toLowerCase(),
         description,
         steps: steps.length > 0 ? steps : ['Implement and verify'],
+        dependencies: deps,
+        attempts: 0,
+        failureReasons: [],
         passes: false,
         sessionCompleted: null
     };
@@ -289,7 +318,7 @@ function cmdStatus() {
     const progress = readJSON(PROGRESS_FILE);
     if (!featureList || !progress) return;
 
-    const { total, passing, failing } = countFeatures(featureList);
+    const { total, passing, failing, blocked } = countFeatures(featureList);
     const nextFeature = getNextFeature(featureList);
     const sessions = progress.sessions || [];
     const lastSession = sessions[sessions.length - 1] || null;
@@ -303,7 +332,8 @@ function cmdStatus() {
     console.log();
 
     // ── Progress Bar ──
-    console.log(`  ${BOLD}Progress:${RESET} ${progressBar(passing, total)}  ${GREEN}${passing}${RESET}/${total} features`);
+    const blockedInfo = blocked > 0 ? ` (${YELLOW}${blocked} blocked${RESET})` : '';
+    console.log(`  ${BOLD}Progress:${RESET} ${progressBar(passing, total)}  ${GREEN}${passing}${RESET}/${total} features${blockedInfo}`);
     console.log();
 
     // ── Category Breakdown ──
@@ -382,7 +412,12 @@ function cmdNext() {
     const nextFeature = getNextFeature(featureList);
 
     if (!nextFeature) {
-        console.log(`${GREEN}${BOLD}🎉 All ${total} features are passing! Marathon complete.${RESET}`);
+        if (passing === total) {
+            console.log(`${GREEN}${BOLD}🎉 All ${total} features are passing! Marathon complete.${RESET}`);
+        } else {
+            console.log(`${RED}${BOLD}⚠️ Deadlock detected: ${total - passing} features remain, but all are blocked by failing dependencies.${RESET}`);
+            console.log(`   ${DIM}Check 'status' and use 'mark <id> pass' to resolve dependencies.${RESET}`);
+        }
         return;
     }
 
@@ -400,6 +435,14 @@ function cmdNext() {
         console.log();
     }
 
+    if (nextFeature.failureReasons && nextFeature.failureReasons.length > 0) {
+        console.log(`  ${RED}${BOLD}Previous Failures (${nextFeature.attempts} attempts):${RESET}`);
+        for (const reason of nextFeature.failureReasons) {
+            console.log(`    ${DIM}* ${reason}${RESET}`);
+        }
+        console.log();
+    }
+
     console.log(`  ${DIM}When done: marathon_harness.js mark ${nextFeature.id} pass${RESET}`);
     console.log();
 }
@@ -408,8 +451,9 @@ function cmdNext() {
  * Mark a feature as passing or failing.
  * @param {number} id
  * @param {string} verdict - 'pass' or 'fail'
+ * @param {string} [reason] - Reason for failure
  */
-function cmdMark(id, verdict) {
+function cmdMark(id, verdict, reason) {
     if (!isActive()) {
         console.error(`${RED}❌ No active marathon.${RESET}`);
         process.exit(1);
@@ -437,6 +481,14 @@ function cmdMark(id, verdict) {
     feature.passes = newPasses;
     feature.sessionCompleted = newPasses ? new Date().toISOString() : null;
 
+    if (!newPasses) {
+        feature.attempts = (feature.attempts || 0) + 1;
+        if (reason) {
+            if (!feature.failureReasons) feature.failureReasons = [];
+            feature.failureReasons.push(`Attempt ${feature.attempts}: ${reason}`);
+        }
+    }
+
     writeJSON(FEATURE_LIST_FILE, featureList);
 
     const { total, passing } = countFeatures(featureList);
@@ -482,6 +534,30 @@ function cmdLog(message) {
     ok(`Logged: ${message}`);
 }
 
+/**
+ * Distill a lesson learned into memory context.
+ * @param {string} lesson
+ */
+function cmdDistill(lesson) {
+    if (!isActive()) {
+        console.error(`${RED}❌ No active marathon.${RESET}`);
+        process.exit(1);
+    }
+
+    if (!lesson) {
+        console.error(`${RED}❌ Lesson required. Usage: distill "Your architectural lesson"${RESET}`);
+        process.exit(1);
+    }
+
+    ensureDir();
+    const DISTILL_FILE = path.join(MARATHON_DIR, 'distilled_context.md');
+    const timestamp = new Date().toISOString().slice(0, 16);
+    const entry = `- [${timestamp}] ${lesson}\n`;
+
+    fs.appendFileSync(DISTILL_FILE, entry, 'utf8');
+    ok(`Distilled memory saved: ${lesson}`);
+}
+
 /**
  * Start a new session — reads state, shows bearings.
  */
@@ -567,7 +643,11 @@ function cmdSessionStart() {
             }
         }
     } else {
-        console.log(`  ${GREEN}${BOLD}🎉 All features passing! Nothing to implement.${RESET}`);
+        if (passing === total) {
+            console.log(`  ${GREEN}${BOLD}🎉 All features passing! Nothing to implement.${RESET}`);
+        } else {
+            console.log(`  ${RED}${BOLD}⚠️ Deadlock: ${total - passing} features are blocked by failing dependencies.${RESET}`);
+        }
     }
     console.log();
 
@@ -717,11 +797,12 @@ function showHelp() {
     cmd('status', 'Show progress dashboard');
     cmd('next', 'Show the next unfinished feature');
     cmd('mark <id> pass', 'Mark a feature as passing');
-    cmd('mark <id> fail', 'Mark a feature as failing');
+    cmd('mark <id> fail', 'Mark a feature as failing (optional: "reason")');
     cmd('log "note"', 'Add a timestamped progress note');
+    cmd('distill "rule"', 'Save an architectural rule or lesson to memory');
     cmd('session-start', 'Begin a new work session (reads state, shows bearings)');
     cmd('session-end', 'End session with optional summary');
-    cmd('add-feature', 'Add a feature: add-feature "category" "description" "step1" ...');
+    cmd('add-feature', 'Add a feature (supports --deps=1,2,3 for DAG dependencies)');
     cmd('reset', 'Archive current marathon and start fresh');
     console.log();
 }
@@ -759,11 +840,12 @@ function main() {
         case 'mark': {
             const id = parseInt(args[1], 10);
             const verdict = (args[2] || '').toLowerCase();
+            const reason = args.slice(3).join(' ').trim();
             if (isNaN(id)) {
-                console.error(`${RED}❌ Feature ID required. Usage: mark <id> pass|fail${RESET}`);
+                console.error(`${RED}❌ Feature ID required. Usage: mark <id> pass|fail "reason"${RESET}`);
                 process.exit(1);
             }
-            cmdMark(id, verdict);
+            cmdMark(id, verdict, reason);
             break;
         }
         case 'log': {
@@ -782,8 +864,23 @@ function main() {
         case 'add-feature': {
             const category = args[1] || '';
             const description = args[2] || '';
-            const steps = args.slice(3);
-            cmdAddFeature(category, description, steps);
+            let steps = args.slice(3);
+            let deps = [];
+            
+            steps = steps.filter(step => {
+                if (step.startsWith('--deps=')) {
+                    deps = step.replace('--deps=', '').split(',').map(Number).filter(n => !isNaN(n));
+                    return false;
+                }
+                return true;
+            });
+            
+            cmdAddFeature(category, description, steps, deps);
+            break;
+        }
+        case 'distill': {
+            const lesson = args.slice(1).join(' ').trim();
+            cmdDistill(lesson);
             break;
         }
         case 'reset':

package/.agent/scripts/prompt_compiler.js

@@ -8,30 +8,13 @@ if (!rawInput) {
   process.exit(1);
 }
 
-// 1. Strip conversational fluff (lowers token count)
-let cleanInput = rawInput
-  .replace(/hey,? /gi, '')
-  .replace(/can you /gi, '')
-  .replace(/could you /gi, '')
-  .replace(/please /gi, '')
-  .replace(/i want to /gi, '')
-  .replace(/i need you to /gi, '')
-  .replace(/for me/gi, '')
-  .replace(/would it be possible to /gi, '')
-  .trim();
+// 1. Keep original input, only optionally strip leading "please" for action matching
+const cleanInput = rawInput.trim();
 
 // 2. Extract Action (Intent mapping)
-const actionMatch = cleanInput.match(/^(build|create|fix|debug|refactor|update|write|design|audit)\b/i);
+const actionMatch = cleanInput.match(/^(?:(?:hey,?\s*|please\s+|can you\s+|could you\s+|would you\s+|i need you to\s+|i want to\s+)*)(build|create|fix|debug|refactor|update|write|design|audit)\b/i);
 const action = actionMatch ? actionMatch[1].toLowerCase() : 'execute';
 
-// Remove the action from the target string
-if (actionMatch) {
-  cleanInput = cleanInput.substring(actionMatch[0].length).trim();
-}
-
-// Strip leading articles
-cleanInput = cleanInput.replace(/^(a|an|some)\s+/i, '');
-
 // 3. Extract Technology Stack
 const techKeywords = [
   'react', 'tailwind', 'next.js', 'sql', 'postgres', 'express', 
@@ -41,16 +24,64 @@ const techKeywords = [
 
 const stack = [];
 techKeywords.forEach(tech => {
-  // Use word boundaries to prevent partial matches
   const regex = new RegExp(`\\b${tech.replace('.', '\\.')}\\b`, 'i');
   if (regex.test(cleanInput)) {
     stack.push(tech.toLowerCase());
   }
 });
 
-// 4. Output highly compressed YAML
+// 4. Intelligent Pre-Routing
+const routerMap = {
+  'react': ['react-specialist', 'frontend-design'],
+  'tailwind': ['tailwind-patterns'],
+  'next.js': ['nextjs-react-expert', 'react-specialist'],
+  'sql': ['sql-pro', 'database-design'],
+  'postgres': ['database-design'],
+  'express': ['nodejs-best-practices'],
+  'python': ['python-pro'],
+  'node': ['nodejs-best-practices'],
+  'vue': ['vue-expert'],
+  'svelte': ['frontend-design'],
+  'typescript': ['typescript-advanced'],
+  'js': ['clean-code'],
+  'css': ['tailwind-patterns'],
+  'html': ['frontend-design'],
+  'prisma': ['database-design'],
+  'drizzle': ['database-design']
+};
+
+const actionRouter = {
+  'build': ['architecture'],
+  'create': ['architecture'],
+  'fix': ['systematic-debugging'],
+  'debug': ['systematic-debugging'],
+  'refactor': ['clean-code'],
+  'update': ['clean-code'],
+  'write': ['clean-code'],
+  'design': ['frontend-design'],
+  'audit': ['vulnerability-scanner', 'lint-and-validate']
+};
+
+const recommendedSkills = new Set();
+
+if (actionRouter[action]) {
+  actionRouter[action].forEach(s => recommendedSkills.add(s));
+}
+
+stack.forEach(tech => {
+  if (routerMap[tech]) {
+    routerMap[tech].forEach(s => recommendedSkills.add(s));
+  }
+});
+
+const finalSkills = Array.from(recommendedSkills).slice(0, 3);
+
+// 5. Output highly compressed YAML
 console.log('---');
 console.log(`action: ${action}`);
-console.log(`target: ${cleanInput}`);
+console.log(`target: |`);
+const indentedTarget = cleanInput.split('\n').map(line => '  ' + line).join('\n');
+console.log(indentedTarget);
 console.log(`stack: [${stack.join(', ')}]`);
+console.log(`recommended_skills: [${finalSkills.join(', ')}]`);
 console.log('---');