@yamo/memory-mesh 2.2.0 → 2.3.0

package/README.md

@@ -31,9 +31,6 @@ memory-mesh store "My important memory" '{"tag":"test"}'
 
 # Search memories
 memory-mesh search "query" 5
-
-# Scrub content only
-scrubber scrub "Raw text content"
 ```
 
 ### Node.js API
@@ -134,9 +131,6 @@ Your skills are now available in Claude Code with automatic memory integration:
 # Use yamo-super workflow system
 # Automatically retrieves similar past workflows and stores execution patterns
 claude /yamo-super
-
-# Use scrubber skill for content sanitization
-claude /scrubber content="raw text"
 ```
 
 **Memory Integration Features:**
@@ -146,7 +140,7 @@ claude /scrubber content="raw text"
 - **Review Phase**: Stores code review outcomes and quality metrics
 - **Complete Workflow**: Stores full execution pattern for future optimization
 
-YAMO agents will automatically find tools in `tools/memory_mesh.js` and `tools/scrubber.js`.
+YAMO agents will automatically find tools in `tools/memory_mesh.js`.
 
 ## Docker
 

package/bin/setup.js

@@ -133,8 +133,7 @@ async function installTools() {
   }
 
   const toolFiles = [
-    { src: 'memory_mesh.js', name: 'Memory Mesh CLI' },
-    { src: 'scrubber.js', name: 'Scrubber CLI' }
+    { src: 'memory_mesh.js', name: 'Memory Mesh CLI' }
   ];
 
   let installed = 0;
@@ -169,7 +168,6 @@ function showUsage() {
 
   log('\n📚 Usage:', 'bright');
   log('  • Use /yamo-super in Claude or Gemini for workflow automation');
-  log('  • Use /scrubber skill for content sanitization');
   log('  • Call tools/memory_mesh.js for memory operations');
 
   log('\n🔗 Learn more:', 'bright');

package/lib/index.js

@@ -2,17 +2,5 @@
 export * from './lancedb/index.js';
 export * from './embeddings/index.js';
 export * from './search/index.js';
-export * from './privacy/index.js';
 export * from './memory/index.js';
 export * from './scrubber/index.js';
-export {
-  HandoffValidator,
-  Spinner,
-  ProgressBar,
-  MultiSpinner,
-  StreamingClient,
-  StreamingLLM,
-  sanitizeErrorForLogging,
-  withSanitizedErrors
-} from './utils/index.js';
-export * from './adapters/index.js';

package/lib/memory/index.js

@@ -1,3 +1 @@
-export { default as VectorMemory } from './vector-memory.js';
 export { default as MemoryMesh } from './memory-mesh.js';
-export { default as MigrateMemory } from './migrate-memory.js';

package/lib/search/index.js

@@ -1,3 +1 @@
-export { default as HybridSearch } from './hybrid.js';
-export { default as FilterBuilder } from './filter.js';
-export { default as PatternMiner } from './pattern-miner.js';
+export { KeywordSearch } from './keyword-search.js';

package/lib/utils/index.js

@@ -1,4 +1 @@
-export { default as HandoffValidator } from './handoff-validator.js';
-export { Spinner, ProgressBar, MultiSpinner } from './spinner.js';
-export { StreamingClient, StreamingLLM } from './streaming-client.js';
-export { sanitizeErrorMessage, sanitizeErrorForLogging, withSanitizedErrors } from './error-sanitizer.js';
+// No exports - all utilities removed as unused

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@yamo/memory-mesh",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Portable semantic memory system with Layer 0 Scrubber for YAMO agents",
   "type": "module",
   "main": "lib/memory/index.js",
   "types": "index.d.ts",
   "bin": {
     "memory-mesh": "./bin/memory_mesh.js",
-    "scrubber": "./bin/scrubber.js",
     "memory-mesh-setup": "./bin/setup.js"
   },
   "files": [

package/skills/SKILL.md

@@ -1,4 +1,553 @@
 ---
 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 skill-super.yamo.
+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. 
 ---
+
+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;
+  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;
+  parameters:
+    workflow_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;
+  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;
+  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;
+---
+agent: WorkflowOrchestrator;
+intent: determine_workflow_entry_point_with_historical_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;
+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;
+priority: critical;
+output: workflow_decision.json;
+log: workflow_determined;timestamp;mode_selected;past_patterns_found;
+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;
+---
+agent: WorktreeAgent;
+intent: create_isolated_development_workspace;
+context:
+  design;from_DocumentationAgent;
+  base_branch;main_or_master;
+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;
+priority: high;
+output: worktree_path;branch_name;
+log: workspace_created;timestamp;path;branch;baseline_tests;
+meta:
+  hypothesis;Isolated worktrees prevent main branch pollution;
+  rationale;Clean branches enable easy rollback and parallel development;
+  confidence;0.99;
+handoff: PlanningAgent;
+---
+agent: PlanningAgent;
+intent: create_detailed_implementation_plan;
+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;
+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;
+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;
+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;
+---
+agent: BatchExecutor;
+intent: execute_plan_in_batches_with_checkpoints;
+context:
+  plan;from_PlanningAgent;
+  worktree_path;from_WorktreeAgent;
+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;
+priority: high;
+output: batches_completed;checkpoint_status;
+log: batch_execution_complete;timestamp;batches;checkpoints_passed;
+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;
+  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;
+---
+agent: UsageGuide;
+intent: introduce_superpowers_workflow;
+context:
+  user;new_to_superpowers;
+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;
+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;