@yamo/memory-mesh 3.1.3 → 3.2.0

package/bin/memory_mesh.js

@@ -1,23 +1,36 @@
 #!/usr/bin/env node
 
 /**
- * YAMO MemoryMesh CLI - Protocol-Native Edition (v3.1.0)
+ * YAMO MemoryMesh CLI - Singularity Edition (v3.2.0)
  * 
- * Enforces the "Zero JSON" mandate by using standard CLI flags.
- * Machines don't parse YAMO; they execute commands.
+ * State-of-the-art interface for semantic memory orchestration.
+ * Features: Interactive progress, beautiful formatting, and bulk ingestion.
  */
 
 import { Command } from 'commander';
 import { MemoryMesh } from '../lib/memory/index.js';
 import { createLogger } from '../lib/utils/logger.js';
+import pc from 'picocolors';
+import cliProgress from 'cli-progress';
+import fs from 'fs';
+import path from 'path';
+import { glob } from 'glob';
 
-const logger = createLogger('memory-mesh-cli');
 const program = new Command();
 
 program
   .name('memory-mesh')
-  .description('Portable semantic memory subconscious for YAMO agents')
-  .version('3.1.0');
+  .description('YAMO Semantic Subconscious - Protocol-Native CLI')
+  .version('3.2.0');
+
+// Helper for beautiful logging
+const ui = {
+  info: (msg) => console.log(`${pc.blue('ℹ')} ${pc.white(msg)}`),
+  success: (msg) => console.log(`${pc.green('✔')} ${pc.green(msg)}`),
+  warn: (msg) => console.log(`${pc.yellow('⚠')} ${pc.yellow(msg)}`),
+  error: (msg) => console.error(`${pc.red('✖')} ${pc.red(msg)}`),
+  header: (msg) => console.log(`\n${pc.bold(pc.cyan('── ' + msg + ' ' + '─'.repeat(50 - msg.length - 4)))}\n`)
+};
 
 // 1. Store/Ingest Command
 program
@@ -28,83 +41,89 @@ program
   .option('-t, --type <type>', 'Memory type (e.g., insight, decision, error)', 'event')
   .option('-r, --rationale <text>', 'The constitutional rationale for this memory')
   .option('-h, --hypothesis <text>', 'The associated hypothesis')
-  .option('--metadata <json>', 'Additional metadata (as flat flags or optional JSON)', '{}')
   .action(async (options) => {
     const mesh = new MemoryMesh();
     try {
-      let metadata = {};
-      try {
-        metadata = JSON.parse(options.metadata);
-      } catch (_e) {
-        // Fallback to empty if invalid JSON
-      }
-      
-      if (options.type) metadata.type = options.type;
-      if (options.rationale) metadata.rationale = options.rationale;
-      if (options.hypothesis) metadata.hypothesis = options.hypothesis;
+      ui.info(`Ingesting into subconscious...`);
+      const metadata = {
+        type: options.type,
+        rationale: options.rationale,
+        hypothesis: options.hypothesis,
+        source: 'cli-manual'
+      };
       
       const record = await mesh.add(options.content, metadata);
-      process.stdout.write(`[MemoryMesh] Ingested record ${record.id}\n`);
+      ui.success(`Ingested record ${pc.bold(record.id)}`);
     } catch (err) {
-      console.error(`❌ Error: ${err.message}`);
+      ui.error(`Ingestion failed: ${err.message}`);
       process.exit(1);
     } finally {
       await mesh.close();
     }
   });
 
-// 2. Directory Ingest Command
+// 2. Pull Command (Smart Directory Ingest)
 program
-  .command('ingest-dir')
-  .alias('pull')
-  .description('Recursively ingest a directory of files (Smart Ingest)')
-  .argument('<path>', 'Directory path to ingest')
-  .option('-e, --extension <ext>', 'Filter by file extension', '')
+  .command('pull')
+  .description('Smart recursive repository/directory ingestion')
+  .argument('<path>', 'Directory path to pull')
+  .option('-e, --extension <ext>', 'File extensions (comma-separated)', '.yamo,.md')
   .option('-t, --type <type>', 'Memory type', 'documentation')
-  .option('-r, --recursive', 'Ingest subdirectories', true)
   .action(async (dirPath, options) => {
     const mesh = new MemoryMesh();
     try {
+      ui.header(`Pulling Wisdom: ${dirPath}`);
+      
       const absolutePath = path.resolve(dirPath);
       if (!fs.existsSync(absolutePath)) {
         throw new Error(`Directory not found: ${absolutePath}`);
       }
 
-      const files = [];
-      const walk = (dir) => {
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          const fullPath = path.join(dir, entry.name);
-          if (entry.isDirectory() && options.recursive) {
-            walk(fullPath);
-          } else if (entry.isFile()) {
-            if (!options.extension || entry.name.endsWith(options.extension)) {
-              files.push(fullPath);
-            }
-          }
-        }
-      };
+      // 1. Discover files
+      const extensions = options.extension.split(',').map(e => e.trim());
+      const pattern = `**/*{${extensions.join(',')}}`;
+      
+      ui.info(`Scanning for ${pc.cyan(extensions.join(' ')) } files...`);
+      
+      const files = await glob(pattern, { cwd: absolutePath, absolute: true, nodir: true });
+      
+      if (files.length === 0) {
+        ui.warn('No matching files found.');
+        return;
+      }
 
-      walk(absolutePath);
-      process.stdout.write(`[MemoryMesh] Found ${files.length} files to ingest...\n`);
+      ui.info(`Found ${pc.bold(files.length)} files. Starting bulk ingestion...`);
 
+      // 2. Initialize Progress Bar
+      const bar = new cliProgress.SingleBar({
+        format: `${pc.cyan('Ingesting')} |${pc.cyan('{bar}')}| {percentage}% | {value}/{total} Files | {file}`,
+        barCompleteChar: '\u2588',
+        barIncompleteChar: '\u2591',
+        hideCursor: true
+      }, cliProgress.Presets.shades_classic);
+
+      bar.start(files.length, 0, { file: 'Initializing...' });
+
+      // 3. Process
       for (const file of files) {
+        const relativeName = path.relative(absolutePath, file);
+        bar.update(files.indexOf(file) + 1, { file: relativeName });
+        
         const content = fs.readFileSync(file, 'utf-8');
         if (!content.trim()) continue;
 
-        const metadata = {
-          source: path.relative(process.cwd(), file),
-          ingested_at: new Date().toISOString(),
-          type: options.type
-        };
-
-        const record = await mesh.add(content, metadata);
-        process.stdout.write(`  ✓ Ingested: ${metadata.source} (${record.id})\n`);
+        await mesh.add(content, {
+          source: relativeName,
+          type: options.type,
+          ingest_method: 'smart-pull'
+        });
       }
 
-      process.stdout.write(`[MemoryMesh] Completed bulk ingestion of ${files.length} files.\n`);
+      bar.stop();
+      ui.success(`Successfully distilled ${pc.bold(files.length)} files into memory.`);
+      
     } catch (err) {
-      console.error(`❌ Error: ${err.message}`);
+      ui.error(`Pull failed: ${err.message}`);
       process.exit(1);
     } finally {
       await mesh.close();
@@ -114,159 +133,61 @@ program
 // 3. Search Command
 program
   .command('search')
-  .description('Perform semantic recall')
-  .argument('<query>', 'The semantic search query')
-  .option('-l, --limit <number>', 'Number of results', '10')
-  .option('-f, --filter <string>', 'LanceDB SQL-style filter')
+  .description('Perform high-fidelity semantic recall')
+  .argument('<query>', 'The semantic query')
+  .option('-l, --limit <number>', 'Number of results', '5')
   .action(async (query, options) => {
     const mesh = new MemoryMesh();
     try {
-      const results = await mesh.search(query, {
-        limit: parseInt(options.limit),
-        filter: options.filter || null
+      ui.info(`Searching subconscious for "${pc.italic(query)}"...`);
+      const results = await mesh.search(query, { limit: parseInt(options.limit) });
+      
+      if (results.length === 0) {
+        ui.warn('No relevant memories found.');
+        return;
+      }
+
+      ui.header(`Recalled ${results.length} Memories`);
+      
+      results.forEach((res, i) => {
+        const meta = typeof res.metadata === 'string' ? JSON.parse(res.metadata) : res.metadata;
+        const scoreColor = res.score > 0.8 ? pc.green : (res.score > 0.5 ? pc.yellow : pc.red);
+        
+        console.log(`${pc.bold(pc.cyan('Memory ' + (i + 1)))} [Rel: ${scoreColor(res.score.toFixed(2))}]`);
+        console.log(`${pc.dim('ID: ' + res.id)} | ${pc.dim('Type: ' + (meta.type || 'event'))}`);
+        console.log(`${pc.white(res.content.substring(0, 300))}${res.content.length > 300 ? '...' : ''}`);
+        console.log(pc.dim('─'.repeat(40)));
       });
       
-      process.stdout.write(`[MemoryMesh] Found ${results.length} matches.\n`);
-      process.stdout.write(mesh.formatResults(results));
-      process.stdout.write('\n');
     } catch (err) {
-      console.error(`❌ Error: ${err.message}`);
+      ui.error(`Search failed: ${err.message}`);
       process.exit(1);
     } finally {
       await mesh.close();
     }
   });
 
-// 3. Stats Command
+// 4. Stats Command
 program
   .command('stats')
-  .description('Get database health and statistics')
+  .description('Subconscious health and database metrics')
   .action(async () => {
     const mesh = new MemoryMesh();
     try {
       const stats = await mesh.stats();
-      process.stdout.write(`[MemoryMesh] Total Memories: ${stats.count}\n`);
-      process.stdout.write(`[MemoryMesh] DB Path: ${stats.uri}\n`);
-      process.stdout.write(`[MemoryMesh] Status: ${stats.isConnected ? 'Connected' : 'Disconnected'}\n`);
-    } catch (err) {
-      console.error(`❌ Error: ${err.message}`);
-      process.exit(1);
-    } finally {
-      await mesh.close();
-    }
-  });
-
-// 4. Get Command
-program
-  .command('get')
-  .description('Retrieve a single memory by ID')
-  .requiredOption('--id <id>', 'Memory record ID')
-  .action(async (options) => {
-    const mesh = new MemoryMesh();
-    try {
-      await mesh.init();
-      const record = await mesh.get(options.id);
-      if (!record) {
-        process.stdout.write(`[MemoryMesh] No record found with id: ${options.id}\n`);
-        process.exit(1);
-      }
-      const meta = typeof record.metadata === 'string' ? JSON.parse(record.metadata) : record.metadata;
-      process.stdout.write(`[MemoryMesh] id: ${record.id}\n`);
-      process.stdout.write(`[MemoryMesh] content: ${record.content}\n`);
-      process.stdout.write(`[MemoryMesh] type: ${meta?.type ?? 'unknown'}\n`);
-      process.stdout.write(`[MemoryMesh] created_at: ${record.created_at}\n`);
-      process.stdout.write(`[MemoryMesh] metadata: ${JSON.stringify(meta, null, 2)}\n`);
-    } catch (err) {
-      console.error(`❌ Error: ${err.message}`);
-      process.exit(1);
-    } finally {
-      await mesh.close();
-    }
-  });
-
-// 5. Delete Command
-program
-  .command('delete')
-  .description('Delete a memory by ID')
-  .requiredOption('--id <id>', 'Memory record ID to delete')
-  .action(async (options) => {
-    const mesh = new MemoryMesh();
-    try {
-      await mesh.init();
-      await mesh.delete(options.id);
-      process.stdout.write(`[MemoryMesh] Deleted record ${options.id}\n`);
-    } catch (err) {
-      console.error(`❌ Error: ${err.message}`);
-      process.exit(1);
-    } finally {
-      await mesh.close();
-    }
-  });
-
-// 6. Reflect Command
-program
-  .command('reflect')
-  .description('Query distilled lessons from memory (wisdom distillation)')
-  .option('--topic <text>', 'Topic or query to reflect on', '')
-  .option('--lookback <n>', 'Limit results to this many lessons', '10')
-  .action(async (options) => {
-    const mesh = new MemoryMesh();
-    try {
-      await mesh.init();
-      const query = options.topic || 'lessons learned patterns errors fixes';
-      const limit = parseInt(options.lookback) || 10;
-      const lessons = await mesh.queryLessons(query, { limit });
-      if (lessons.length === 0) {
-        process.stdout.write(`[MemoryMesh] No lessons found${options.topic ? ` for topic: ${options.topic}` : ''}.\n`);
-      } else {
-        process.stdout.write(`[MemoryMesh] Reflecting on ${lessons.length} lesson(s):\n\n`);
-        for (const lesson of lessons) {
-          process.stdout.write(`  scope: ${lesson.applicableScope}\n`);
-          process.stdout.write(`  rule:  ${lesson.preventativeRule}\n`);
-          process.stdout.write(`  confidence: ${lesson.ruleConfidence}\n`);
-          process.stdout.write('\n');
-        }
-      }
-    } catch (err) {
-      console.error(`❌ Error: ${err.message}`);
-      process.exit(1);
-    } finally {
-      await mesh.close();
-    }
-  });
-
-// S-MORA command (RFC-0012)
-program
-  .command('smora')
-  .description('S-MORA enhanced retrieval: HyDE-Lite + multi-channel + heritage-aware reranking (RFC-0012)')
-  .argument('<query>', 'The retrieval query')
-  .option('-l, --limit <n>', 'Max results to return', '10')
-  .option('--no-hyde', 'Disable HyDE-Lite query expansion (Layer 1)')
-  .option('--intent <items>', 'Session intent chain for heritage bonus (comma-separated)', '')
-  .option('--json', 'Output raw JSON response')
-  .action(async (query, options) => {
-    const mesh = new MemoryMesh();
-    try {
-      await mesh.init();
-      const sessionIntent = options.intent
-        ? options.intent.split(',').map((s) => s.trim()).filter(Boolean)
-        : [];
-      const resp = await mesh.smora(query, {
-        limit: parseInt(options.limit) || 10,
-        enableHyDE: options.hyde !== false,
-        sessionIntent,
-      });
-      if (options.json) {
-        process.stdout.write(JSON.stringify(resp, null, 2) + '\n');
-      } else {
-        const p = resp.pipeline;
-        process.stdout.write(`[S-MORA] ${resp.results.length} result(s) | HyDE:${p.queryExpanded} heritage:${p.heritageAware} latency:${p.latencyMs}ms\n\n`);
-        for (const r of resp.results) {
-          process.stdout.write(`  [${r.rrfRank}] score:${r.score.toFixed(3)} | ${r.content.slice(0, 100)}${r.content.length > 100 ? '...' : ''}\n`);
-        }
-      }
+      ui.header('MemoryMesh Subconscious Status');
+      
+      const statusColor = stats.isConnected ? pc.green : pc.red;
+      
+      console.log(`${pc.bold('Status:')}      ${statusColor(stats.isConnected ? 'CONNECTED' : 'DISCONNECTED')}`);
+      console.log(`${pc.bold('Memories:')}    ${pc.cyan(stats.count)} entries`);
+      console.log(`${pc.bold('Skills:')}      ${pc.cyan(stats.totalSkills)} synthesized`);
+      console.log(`${pc.bold('Engine:')}      LanceDB (Vector Index)`);
+      console.log(`${pc.bold('Model:')}       ${pc.dim(stats.embedding.primary?.modelName || 'Unknown')}`);
+      console.log(`${pc.bold('Path:')}        ${pc.dim(stats.uri)}`);
+      
     } catch (err) {
-      console.error(`❌ Error: ${err.message}`);
+      ui.error(`Stats failed: ${err.message}`);
       process.exit(1);
     } finally {
       await mesh.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yamo/memory-mesh",
-  "version": "3.1.3",
+  "version": "3.2.0",
   "description": "Portable semantic memory system with Layer 0 Scrubber for YAMO agents (v3 Singularity Edition)",
   "type": "module",
   "main": "lib/memory/index.js",
@@ -29,7 +29,10 @@
     "commander": "^14.0.3",
     "onnxruntime-node": "^1.18.0",
     "pino": "^10.3.1",
-    "pino-pretty": "^13.1.3"
+    "pino-pretty": "^13.1.3",
+    "cli-progress": "^3.12.0",
+    "picocolors": "^1.1.1",
+    "glob": "^11.0.1"
   },
   "author": "Soverane Labs",
   "license": "MIT",

package/skills/SKILL.md

@@ -1,553 +1,138 @@
 ---
 name: yamo-super
-description: A comprehensive AI coding workflow system that orchestrates test-driven development, systematic debugging, collaborative planning, git worktree isolation, and dual-mode execution (subagent-driven or batched) with mandatory TDD red-green-refactor cycles, root-cause analysis, two-stage code review, and branch lifecycle management. For all code improvement or creation tasks, strictly adhere to the logic, agents, and constraints defined in this yamo skill. 
+description: The execution engine for the YAMO Unified OS. Orchestrates the complete lifecycle from Idea (Macro) to Tested Code (Micro) with Zero-JSON state passing and semantic heritage.
 ---
 
 metadata:
-  name;YamoSuper;
-  version;2.1.0;
-  description;Comprehensive AI coding workflow system with automatic memory integration for pattern recognition and workflow optimization;
-  author;Derived from Superpowers by Jesse Scott;adapted for YAMO by Soverane Labs;
+  name;YamoUnifiedOS;
+  version;3.0.0;
+  description;The Universal Agent Core merging Macro-Orchestration (SDD) with Micro-Execution (YamoSuper) into a single, unbroken semantic chain.;
+  author;Soverane Labs;
   license;MIT;
-  tags;tdd;debugging;collaboration;planning;workflow;subagent;git;review;memory;semantic_search;
-  capabilities;brainstorm_design;write_implementation_plan;execute_plan_batch;test_driven_development;systematic_debugging;verification;code_review;git_worktree;subagent_driven;parallel_dispatch;retrieve_workflow_patterns;store_execution_history;semantic_memory;
+  tags;orchestrator;unified;sdd;yamosuper;llm-first;yamo-v3;memory;
+  capabilities;orchestrate_global_lifecycle;bridge_spec_to_code;enforce_constitutional_discipline;manage_feedback_loops;use_llm_first_state_passing;semantic_memory;
   parameters:
-    workflow_mode:
+    request:
+      type;string;
+      required;true;
+      description;The feature idea or bug report;
+    execution_mode:
       type;string;
       required;false;
-      description;Mode: brainstorm, plan, execute, debug, review;
-      enum;brainstorm;plan;execute;debug;review;
-    dry_run:
-      type;boolean;
-      required;false;
-      description;Preview actions without executing;
-    memory_enabled:
-      type;boolean;
-      required;false;
-      default;true;
-      description;Enable storing and retrieving workflow execution patterns from Memory Mesh;
+      default;full;
+      description;How deep to go into the lifecycle: specification, planning, implementation, full;
+      enum;specification;planning;implementation;full;
   environment:
     requires_filesystem;true;
     requires_local_storage;true;
-    notes;Creates worktrees, writes plans, manages git workflows, and stores execution history in Memory Mesh via tools/memory_mesh.js;
+    notes;Operates under the Singularity Kernel v3.0 protocol. Stores execution history in Memory Mesh via tools/memory_mesh.mjs;
   dependencies:
     required:
       - Git >= 2.30.0
-      - Node >= 18.0.0 (for npm test commands)
-      - MemoryMesh >=1.0.0;
-      - {working_directory}/tools/memory_mesh.js;
-    optional:
-      - YamoChainClient (for blockchain anchoring)
----
-agent: MemorySystemInitializer;
-intent: verify_memory_system_availability;
-context:
-  memory_tool;tools/memory_mesh.js;
-  memory_enabled;provided_by_user.memory_enabled;
-constraints:
-  - if_memory_enabled;verify_tool_exists;
-  - test_memory_connection_with_search;
-  - if_memory_unavailable;warn_user;continue_without_memory;
-  - set_memory_status_flag;
-priority: high;
-output: memory_status.json;
-log: memory_initialized;available;timestamp;
-meta:
-  hypothesis;Memory system availability check prevents runtime failures;
-  rationale;Graceful degradation if memory unavailable;
-  confidence;0.98;
-handoff: WorkflowOrchestrator;
+      - Node >= 18.0.0
+      - MemoryMesh >=3.1.0;
+      - {working_directory}/tools/memory_mesh.mjs;
 ---
-agent: WorkflowOrchestrator;
-intent: determine_workflow_entry_point_with_historical_context;
+agent: GlobalInitiator;
+intent: initialize_unified_lifecycle_context;
 context:
-  user_request;raw_input;
-  project_state;current_git_status;recent_commits;file_tree;
-  available_modes;brainstorm;plan;execute;debug;review;
-  memory_status;from_MemorySystemInitializer;
-  memory_tool;tools/memory_mesh.js;
-  memory_enabled;provided_by_user.memory_enabled;
+  request;provided_by_user.request;
+  execution_mode;provided_by_user.execution_mode;
+  foundation;foundational/yamo-unified-foundation.yamo;
+  state_mode;llm_first;
 constraints:
-  - if_memory_available;search_similar_workflows;
-    - extract_keywords_from_user_request;
-    - search_query_format;"workflow mode project outcome";
-    - retrieve_top_3_similar_patterns;
-    - analyze_past_outcomes_success_failure;
-    - present_similar_patterns_to_inform_decision;
-  - check_if_creative_work_requested;trigger_brainstorming_agent;
-  - check_if_spec_exists;trigger_planning_agent;
-  - check_if_plan_exists;trigger_execution_agent;
-  - check_if_bug_reported;trigger_debugging_agent;
-  - check_if_review_requested;trigger_review_agent;
-  - default_to_brainstorming_if_uncertain;
-  - announce_active_workflow_to_user;
+  - load_unified_foundation;required;
+  - initialize_semantic_heritage;hypothesis;rationale;
+  - determine_pathway;macro_only_or_full_lifecycle;
 priority: critical;
-output: workflow_decision.json;
-log: workflow_determined;timestamp;mode_selected;past_patterns_found;
+output: global_initialization_context.yamo;
+log: unified_os_initialized;mode;timestamp;
 meta:
-  hypothesis;Historical workflow patterns improve decision accuracy;
-  rationale;Similar past workflows provide context for current decision;
-  confidence;0.92;
-  observation;Past success patterns should bias toward proven approaches;
-handoff: BrainstormingAgent;
----
-agent: BrainstormingAgent;
-intent: refine_ideas_through_socratic_dialogue;
-context:
-  project_state;from_WorkflowOrchestrator;
-  workflow_decision;from_WorkflowOrchestrator;
-  user_idea;raw_request;
-  past_patterns;from_WorkflowOrchestrator.similar_workflows;
-constraints:
-  - if_past_patterns_exist;reference_successful_approaches;
-  - check_project_context_first;files;docs;recent_commits;
-  - ask_questions_one_at_a_time;
-  - prefer_multiple_choice_when_possible;
-  - focus_understanding;purpose;constraints;success_criteria;
-  - propose_2_3_alternatives_with_tradeoffs;
-  - present_design_in_sections_200_300_words;
-  - validate_after_each_section;
-  - cover;architecture;components;data_flow;error_handling;testing;
-  - apply_yagni_ruthlessly;
-priority: high;
-output: validated_design.md;
-log: design_validated;timestamp;sections_reviewed;alternatives_proposed;
-meta:
-  hypothesis;Incremental validation produces better designs;
-  rationale;Large designs overwhelm;section-by-section enables feedback;
-  confidence;0.94;
-handoff: DocumentationAgent;
----
-agent: DocumentationAgent;
-intent: persist_and_commit_design;
-context:
-  design;from_BrainstormingAgent;
-  destination;docs/plans/YYYY-MM-DD-<topic>-design.md;
-  memory_tool;tools/memory_mesh.js;
-  memory_status;from_MemorySystemInitializer;
-constraints:
-  - use_clear_concise_writing;
-  - commit_to_git_with_descriptive_message;
-  - tag_commit_with_design_reviewed;
-  - if_memory_available;store_design_summary;
-    - content_format;"Design phase: <topic>. Approach: <architecture>. Components: <list>. Status: validated.";
-    - metadata;{workflow:"yamo-super",phase:"design",project:"<name>",timestamp:"<iso>",commit_sha:"<sha>"};
-  - ask_ready_for_implementation;
-priority: medium;
-output: design_file_path;commit_sha;memory_id;
-log: design_documented;timestamp;file_path;commit_sha;memory_stored;
-meta:
-  hypothesis;Documented designs enable better implementation;
-  rationale;Written specs prevent drift during coding;
-  confidence;0.96;
-handoff: WorktreeAgent;
+  hypothesis;A unified context chain prevents the loss of intent during the spec-to-code transition;
+  rationale;Disconnected tools create information silos; unification creates semantic flow;
+  confidence;0.98;
+handoff: SubconsciousReflector;
 ---
-agent: WorktreeAgent;
-intent: create_isolated_development_workspace;
+agent: SubconsciousReflector;
+intent: query_memory_mesh_for_past_oversights;
 context:
-  design;from_DocumentationAgent;
-  base_branch;main_or_master;
+  init;global_initialization_context.yamo;
+  search_tag;"#lesson_learned";
+  tool;tools/memory_mesh.mjs;
 constraints:
-  - create_git_worktree_at;.git/worktrees/<feature-name>;
-  - checkout_new_branch_feature/<name>;
-  - run_project_setup;npm_install;npm_run_build;
-  - verify_clean_test_baseline;npm_test;
-  - document_worktree_location;
+  - search_similar_past_contexts;based_on_request;
+  - extract_preventative_constraints;from_lessons;
+  - inject_constraints_into_macro_context;required;
+  - meta_rationale;Learning from past mistakes is the only way to achieve senior-level reliability;
 priority: high;
-output: worktree_path;branch_name;
-log: workspace_created;timestamp;path;branch;baseline_tests;
+output: subconscious_reflection_context.yamo;
 meta:
-  hypothesis;Isolated worktrees prevent main branch pollution;
-  rationale;Clean branches enable easy rollback and parallel development;
+  hypothesis;Proactive reflection prevents the repetition of previous architectural errors;
   confidence;0.99;
-handoff: PlanningAgent;
+handoff: MacroWorkflowInvoker;
 ---
-agent: PlanningAgent;
-intent: create_detailed_implementation_plan;
+agent: MacroWorkflowInvoker;
+intent: invoke_macro_sdd_layer;
 context:
-  design;from_DocumentationAgent;
-  worktree_path;from_WorktreeAgent;
-  past_patterns;from_WorkflowOrchestrator.similar_workflows;
-  assumptions;
-    engineer_has_zero_codebase_context;
-    engineer_has_questionable_taste;
-    engineer_needs_explicit_instructions;
+  init;subconscious_reflection_context.yamo;
+  workflows:
+    specification;macro/specification-workflow.yamo;
+    planning;macro/planning-workflow.yamo;
 constraints:
-  - if_similar_plans_exist;adapt_proven_task_breakdowns;
-  - break_into_bite_sized_tasks;2_5_minutes_each;
-  - each_task_one_action;write_test;run_test;implement;verify;commit;
-  - specify_exact_file_paths;
-  - include_complete_code_not_hints;
-  - include_exact_commands_with_expected_output;
-  - reference_relevant_skills_with_at_syntax;
-  - enforce_dry;yagni;tdd;frequent_commits;
-  - save_to;docs/plans/YYYY-MM-DD-<feature-name>.md;
-  - include_required_header;goal;architecture;tech_stack;
-  - include_sub_skill_directive;use_superpowers:executing_plans;
-priority: critical;
-output: implementation_plan.md;
-log: plan_created;timestamp;task_count;file_path;
-meta:
-  hypothesis;Explicit plans enable autonomous subagent execution;
-  rationale;Zero_context engineers need complete information;
-  confidence;0.97;
-handoff: ExecutionSelector;
----
-agent: ExecutionSelector;
-intent: offer_execution_choice;
-context:
-  plan;from_PlanningAgent;
-  worktree_path;from_WorktreeAgent;
-constraints:
-  - present_two_options;subagent_driven;parallel_session;
-  - explain_subagent_driven;same_session;fresh_subagent_per_task;two_stage_review;
-  - explain_parallel_session;new_session;batch_execution;checkpoints;
-  - await_user_choice;
+  - execute_specification_phase;idea_to_prd;
+  - execute_macro_planning_phase;prd_to_roadmap;
+  - enforce_macro_quality_gates;specification_and_compliance;
+  - stop_here;if_mode_is_specification_or_planning;
 priority: high;
-output: execution_mode;session_instructions;
-log: execution_mode_selected;timestamp;mode;
-meta:
-  hypothesis;Choice accommodates different working styles;
-  rationale;Some prefer continuity;others prefer isolation;
-  confidence;0.91;
-handoff: SubagentDriver;
----
-agent: SubagentDriver;
-intent: execute_plan_via_fresh_subagents;
-context:
-  plan;from_PlanningAgent;
-  worktree_path;from_WorktreeAgent;
-constraints:
-  - read_plan_once;extract_all_tasks_with_full_text;
-  - create_todo_write_with_all_tasks;
-  - per_task;
-    - dispatch_implementer_subagent_with_full_context;
-    - allow_subagent_to_ask_questions_before_work;
-    - implementer_subagent_implements_tests_commits_self_reviews;
-    - dispatch_spec_compliance_reviewer_subagent;
-    - spec_reviewer_confirms_code_matches_spec;
-    - if_spec_issues;implementer_fixes;re_review_until_approved;
-    - dispatch_code_quality_reviewer_subagent;
-    - code_reviewer_approves_quality;
-    - if_quality_issues;implementer_fixes;re_review_until_approved;
-    - mark_task_complete_in_todo_write;
-  - after_all_tasks;dispatch_final_code_reviewer;
-  - use_finishing_development_branch_workflow;
-  - never_skip_reviews;
-  - never_parallel_dispatch_implementers;
-  - always_provide_full_text_not_file_references;
-  - ensure_scene_setting_context_per_task;
+output: macro_results_context.yamo;
+handoff: MicroWorkflowInvoker;
+---
+agent: MicroWorkflowInvoker;
+intent: invoke_micro_yamosuper_layer;
+context:
+  macro_results;macro_results_context.yamo;
+  workflows:
+    implementation;micro/implementation-tdd.yamo;
+    debugging;micro/debugging-verification.yamo;
+    review;micro/review-closure.yamo;
+constraints:
+  - transform_roadmap_to_tdd_tasks;semantic_inheritance_required;
+  - execute_tdd_cycles;red_green_refactor;
+  - enforce_micro_quality_gates;implementation_and_audit;
+  - if_critical_logic_error;optionally_return_to_macro_planning;
 priority: critical;
-output: implementation_complete;all_commits;test_results;
-log: execution_complete;timestamp;tasks_completed;commits;tests_passed;
-meta:
-  hypothesis;Fresh subagents per task prevent context pollution;
-  rationale;Two_stage_review ensures_spec_compliance_and_code_quality;
-  confidence;0.95;
-handoff: BatchExecutor;
+output: micro_results_context.yamo;
+handoff: UnifiedReporter;
 ---
-agent: BatchExecutor;
-intent: execute_plan_in_batches_with_checkpoints;
+agent: UnifiedReporter;
+intent: generate_global_lifecycle_report;
 context:
-  plan;from_PlanningAgent;
-  worktree_path;from_WorktreeAgent;
+  macro;macro_results_context.yamo;
+  micro;micro_results_context.yamo;
 constraints:
-  - group_tasks_into_logical_batches;
-  - execute_batch_sequentially;
-  - after_each_batch;
-    - run_all_tests;verify_passing;
-    - request_human_checkpoint;
-    - await_approval_before_next_batch;
-  - commit_after_each_batch;
-  - report_progress_clearly;
+  - trace_intent_from_spec_to_code;
+  - report_constitutional_compliance_summary;
+  - document_hypotheses_validated_vs_rejected;
+  - report_zero_json_status;must_be_zero_json;
 priority: high;
-output: batches_completed;checkpoint_status;
-log: batch_execution_complete;timestamp;batches;checkpoints_passed;
+output: unified_lifecycle_report.md;
 meta:
-  hypothesis;Checkpoints maintain human oversight;
-  rationale;Batch execution balances autonomy_with_control;
-  confidence;0.93;
-handoff: TDDAgent;
----
-agent: TDDAgent;
-intent: enforce_test_driven_development_cycle;
-context:
-  task;from_SubagentDriver_or_BatchExecutor;
-constraints:
-  - iron_law;no_production_code_without_failing_test_first;
-  - red;write_one_minimal_test;
-    - one_behavior_per_test;
-    - clear_name_describing_behavior;
-    - use_real_code_not_mocks;
-  - verify_red;run_test;confirm_fails_correctly;
-    - test_must_fail_not_error;
-    - failure_message_must_be_expected;
-    - fails_because_feature_missing_not_typo;
-  - green;write_minimal_code_to_pass;
-    - simplest_possible_implementation;
-    - no_features_beyond_test;
-    - no_refactoring_during_green;
-  - verify_green;run_test;confirm_passes;
-    - test_passes;
-    - other_tests_still_pass;
-    - output_pristine_no_errors;
-  - refactor;clean_up_only_after_green;
-    - remove_duplication;
-    - improve_names;
-    - extract_helpers;
-    - keep_tests_green;
-  - red_flags;code_before_test;test_passes_immediately;rationalizing_exceptions;
-  - penalty;delete_code_start_over;
-priority: critical;
-output: test_coverage;implementation;
-log: tdd_cycle_complete;timestamp;test_name;status;
-meta:
-  hypothesis;Watching_test_fail_proves_it_tests_something;
-  rationale;tests_after_answer_what_does_this_do;tests_first_answer_what_should_this_do;
-  confidence;0.99;
-handoff: DebuggingAgent;
----
-agent: DebuggingAgent;
-intent: systematic_root_cause_analysis;
-context:
-  bug_report;user_report_or_test_failure;
-  memory_tool;tools/memory_mesh.js;
-  memory_status;from_MemorySystemInitializer;
-constraints:
-  - if_memory_available;search_similar_bugs;
-    - extract_error_signature;
-    - search_query_format;"debug error <signature> <component>";
-    - check_past_solutions;
-  - phase_1_define_problem;
-    - describe_symptoms_precisely;
-    - identify_affected_components;
-    - determine_frequency_always_sometimes_intermittent;
-  - phase_2_gather_evidence;
-    - reproduce_bug_reliably;
-    - collect_logs_stack_traces;
-    - identify_when_started_working;
-  - phase_3_isolate_cause;
-    - use_root_cause_tracing;
-    - use_defense_in_depth_analysis;
-    - use_condition_based_waiting_for_race_conditions;
-    - binary_search_git_history;
-    - minimize_reproduction_case;
-  - phase_4_verify_fix;
-    - write_failing_test_reproducing_bug;
-    - apply_tdd_cycle_to_fix;
-    - use_verification_before_completion;
-  - if_memory_available;store_bug_resolution;
-    - content_format;"Debug: <error_signature>. Root cause: <cause>. Solution: <fix>. Component: <component>.";
-    - metadata;{workflow:"yamo-super",phase:"debug",bug_type:"<type>",resolution:"<fix>",timestamp:"<iso>"};
-  - never_fix_without_test;
-  - never_apply_bandages;
-priority: high;
-output: root_cause;fix_verification_test;memory_id;
-log: bug_resolved;timestamp;root_cause;test_added;similar_bugs_found;
-meta:
-  hypothesis;Systematic_debugging_faster_than_shotgun_debugging;
-  rationale;root_cause_elimination_prevents_reoccurrence;
-  confidence;0.96;
-  observation;Historical bug patterns accelerate diagnosis;
-handoff: VerificationAgent;
----
-agent: VerificationAgent;
-intent: ensure_fix_actually_works;
-context:
-  proposed_fix;from_DebuggingAgent;
-  original_bug;from_DebuggingAgent;
-constraints:
-  - reproduce_original_bug_first;confirm_exists;
-  - apply_fix;
-  - verify_bug_gone;
-  - verify_no_regressions;
-  - verify_edge_cases;
-  - run_full_test_suite;
-  - check_output_pristine;
-  - if_not_fixed;restart_debugging;
-priority: high;
-output: verification_status;regression_check;
-log: verification_complete;timestamp;status;regressions;
-meta:
-  hypothesis;Verification_catches_incomplete_fixes;
-  rationale;feeling_fixed_does_not_mean_fixed;
-  confidence;0.98;
-handoff: CodeReviewAgent;
----
-agent: CodeReviewAgent;
-intent: conduct_pre_merge_quality_gate;
-context:
-  implementation;from_SubagentDriver_or_BatchExecutor;
-  plan;from_PlanningAgent;
-  memory_tool;tools/memory_mesh.js;
-  memory_status;from_MemorySystemInitializer;
-constraints:
-  - review_against_plan;
-    - all_requirements_implemented;
-    - no_extra_features_beyond_spec;
-    - file_matches_match_plan;
-  - code_quality_check;
-    - tests_cover_all_cases;
-    - tests_use_real_code_not_mocks;
-    - code_is_clean_not_clever;
-    - names_are_clear;
-    - no_duplication;
-    - proper_error_handling;
-  - report_by_severity;
-    - critical;blocks_progress;must_fix;
-    - important;should_fix_before_merge;
-    - minor;nice_to_have;
-  - if_critical_issues;block_progress;
-  - if_no_issues;approve;
-  - if_memory_available;store_review_outcome;
-    - content_format;"Code review: <feature>. Quality: <rating>. Issues: <count>. Tests: <coverage>. Outcome: <approved/rejected>.";
-    - metadata;{workflow:"yamo-super",phase:"review",quality_rating:"<rating>",issues_count:"<n>",timestamp:"<iso>"};
-priority: critical;
-output: review_report;approval_status;memory_id;
-log: review_complete;timestamp;critical;important;minor;status;
-meta:
-  hypothesis;Pre_merge_review_catches_issues_early;
-  rationale;merge_reviews_are_too_late_for_easy_fixes;
+  hypothesis;Traceability from spec to code proves cognitive alignment;
   confidence;0.97;
-handoff: BranchFinisher;
----
-agent: BranchFinisher;
-intent: complete_development_branch_workflow;
-context:
-  implementation;from_CodeReviewAgent;
-  worktree_path;from_WorktreeAgent;
-  review_report;from_CodeReviewAgent;
-constraints:
-  - verify_all_tests_pass;
-  - verify_no_regressions;
-  - present_options;
-    - merge_to_main;
-    - create_pull_request;
-    - keep_branch_for_more_work;
-    - discard_branch;
-  - if_merge;merge_fast_forward_or_squash;delete_worktree;
-  - if_pull_request;create_pr_with_description;link_to_plan;
-  - if_discard;delete_branch;remove_worktree;
-  - document_decision;
-priority: high;
-output: merge_status;pr_url_or_branch_deleted;
-log: branch_completed;timestamp;outcome;
-meta:
-  hypothesis;Explicit_branch_completion_prevents_orphan_branches;
-  rationale;clear_decisions_prevent_branch_accumulation;
-  confidence;0.95;
-handoff: WorkflowMemoryStore;
----
-agent: ParallelDispatcher;
-intent: coordinate_concurrent_subagent_workflows;
-context:
-  independent_tasks;task_list;
-constraints:
-  - identify_truly_independent_tasks;
-  - dispatch_subagents_in_parallel;
-  - wait_for_all_subagents;
-  - collect_results;
-  - detect_conflicts;
-  - if_conflicts;resolve_sequentially;
-  - merge_results;
-priority: medium;
-output: parallel_results;conflict_resolution_log;
-log: parallel_dispatch_complete;timestamp;tasks;conflicts;
-meta:
-  hypothesis;Parallel_execution_saves_wall_clock_time;
-  rationale;independent_tasks_have_no_dependencies;
-  confidence;0.89;
-handoff: SkillMetaAgent;
----
-agent: SkillMetaAgent;
-intent: enable_skill_creation_and_extension;
-context:
-  new_skill_idea;user_request;
-constraints:
-  - use_writing_skills_skill;
-  - follow_skill_structure;
-    - metadata_block;
-    - agent_definitions;
-    - constraints_as_semicolon_key_values;
-    - triple_dash_delimiters;
-    - explicit_handoff_chains;
-  - ensure_v1_compliance;
-  - scaffold_tests;
-  - validate_syntax;
-  - classify_category;
-priority: low;
-output: new_skill_yamo;test_plan;
-log: skill_created;timestamp;name;category;
-meta:
-  hypothesis;Meta_skills_enable_ecosystem_growth;
-  rationale;extensible_systems_adapt_to_new_needs;
-  confidence;0.88;
-handoff: End;
+handoff: User;
 ---
 agent: UsageGuide;
-intent: introduce_superpowers_workflow;
+intent: introduce_unified_os_workflow;
 context:
-  user;new_to_superpowers;
+  user;new_to_singularity;
 constraints:
-  - explain_basic_workflow;
-    - brainstorming;design_refinement;
-    - using_git_worktrees;isolated_workspace;
-    - writing_plans;implementation_breakdown;
-    - subagent_driven_or_executing_plans;task_execution;
-    - test_driven_development;red_green_refactor;
-    - systematic_debugging;root_cause_analysis;
-    - requesting_code_review;quality_gate;
-    - finishing_development_branch;merge_pr_discard;
-    - memory_integration;pattern_recognition;
-  - explain_skills_trigger_automatically;
-  - explain_mandatory_not_suggestions;
-  - demonstrate_with_example;
+  - explain_unified_architecture;
+    - macro_layer;idea_to_specification;planning;
+    - micro_layer;tdd_execution;debugging;review;
+  - explain_zero_json_mandate;
+  - demonstrate_semantic_heritage;how_intent_flows_to_code;
+  - explain_subconscious_reflection;proactive_oversight_checks;
 priority: low;
 output: user_understanding;workflow_ready;
 log: onboarded;timestamp;user;
-meta:
-  hypothesis;clear_introduction_enables_effective_use;
-  rationale;understanding_why_builds_compliance;
-  confidence;0.92;
-handoff: WorkflowMemoryStore;
----
-agent: WorkflowMemoryStore;
-intent: store_complete_workflow_execution_for_pattern_recognition;
-context:
-  workflow_decision;from_WorkflowOrchestrator;
-  design_output;from_DocumentationAgent;
-  implementation_result;from_SubagentDriver_or_BatchExecutor;
-  review_result;from_CodeReviewAgent;
-  branch_outcome;from_BranchFinisher;
-  memory_tool;tools/memory_mesh.js;
-  memory_status;from_MemorySystemInitializer;
-constraints:
-  - if_memory_available;store_complete_workflow;
-    - aggregate_all_phase_data;
-    - content_format;"Workflow: yamo-super. Mode: <mode>. Project: <project>. Design: <summary>. Implementation: <tasks_completed>. Review: <quality>. Tests: <passed/failed>. Outcome: <success/failure>. Duration: <time>.";
-    - metadata;{
-        workflow:"yamo-super",
-        mode:"<selected_mode>",
-        project:"<project_name>",
-        phase:"complete",
-        design_commit:"<sha>",
-        implementation_commits:"<count>",
-        tests_passed:"<true/false>",
-        review_approved:"<true/false>",
-        outcome:"<success/failure>",
-        duration_minutes:"<n>",
-        timestamp:"<iso>"
-      };
-  - generate_workflow_embedding;
-  - tag_by_mode_project_type_and_outcome;
-  - enable_future_recommendations;
-  - if_blockchain_available;anchor_to_yamo_chain;
-priority: high;
-output: workflow_memory_receipt.json;
-log: workflow_stored;memory_id;outcome;timestamp;
-meta:
-  hypothesis;Storing complete workflows enables pattern recognition for future recommendations;
-  rationale;Historical success patterns guide future workflow decisions;
-  confidence;0.94;
-  observation;Semantic search finds similar contexts not just keyword matches;
 handoff: End;