mango-brain 3.3.2__tar.gz → 3.3.3__tar.gz

{mango_brain-3.3.2 → mango_brain-3.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mango-brain
-Version: 3.3.2
+Version: 3.3.3
 Summary: The learning layer for Claude Code — persistent associative memory + development workflow. Claude Code gets smarter the longer you use it.
 Author-email: Federico Anastasi <federico.anastasi@outlook.com>
 License: MIT

{mango_brain-3.3.2 → mango_brain-3.3.3}/mango_brain.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mango-brain
-Version: 3.3.2
+Version: 3.3.3
 Summary: The learning layer for Claude Code — persistent associative memory + development workflow. Claude Code gets smarter the longer you use it.
 Author-email: Federico Anastasi <federico.anastasi@outlook.com>
 License: MIT

{mango_brain-3.3.2 → mango_brain-3.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mango-brain"
-version = "3.3.2"
+version = "3.3.3"
 description = "The learning layer for Claude Code — persistent associative memory + development workflow. Claude Code gets smarter the longer you use it."
 readme = "README.md"
 license = {text = "MIT"}

{mango_brain-3.3.2 → mango_brain-3.3.3}/server/cli.py

@@ -683,10 +683,17 @@ apply_elaboration, reinforce, decay, stats, diagnose, list_memories, sync_codeba
 
 def main() -> None:
     """CLI entry point."""
+    from importlib.metadata import version as pkg_version
+
     parser = argparse.ArgumentParser(
         prog="mangobrain",
         description="MangoBrain — Persistent memory + workflow system for Claude Code",
     )
+    try:
+        ver = pkg_version("mango-brain")
+    except Exception:
+        ver = "dev"
+    parser.add_argument("--version", "-V", action="version", version=f"%(prog)s {ver}")
     sub = parser.add_subparsers(dest="command")
 
     # serve

mango_brain-3.3.3/server/rules/mangobrain-remember.md

@@ -0,0 +1,158 @@
+# MangoBrain — Remember Query Strategy
+
+You have access to the `remember` MCP tool to retrieve relevant memories from the project.
+Use it often, not just at the start of a task. Memories contain gotchas, patterns, decisions, and references that code alone doesn't tell you.
+
+## Query Language
+
+**All remember() queries MUST use English keywords**, regardless of session language.
+Memories are stored in English — queries in other languages degrade retrieval by ~15-20%.
+
+```
+GOOD: remember(query="formatPrice cents euros conversion gotcha", ...)
+BAD:  remember(query="formattazione prezzi conversione centesimi", ...)
+```
+
+Always translate concepts before querying. The conversation stays in the user's language, but queries go to the DB in English.
+
+## When to use remember
+
+- **Task/session start**: broad context (see multi-query strategy below)
+- **Before touching an unfamiliar area**: targeted quick query
+- **When you find a bug**: quick query to check for known patterns
+- **Before creating a component/utility**: quick query to verify if something similar already exists
+- **When making an architectural decision**: quick query for precedents
+- **End of task**: remember(mode="recent") to check WIP and context for mem-manager
+
+## Multi-query strategy (task start)
+
+Do NOT make a single generic query. Use **1 deep + N quick**:
+
+### 1. Read the task and identify 2-4 distinct technical areas
+
+### 2. 1x deep — big picture
+```
+remember(query="[max 10 keywords from the task]", mode="deep", project="{PROJECT}")
+```
+Captures: cross-cutting patterns, conventions, recurring gotchas. ~20 results.
+
+### 3. 2-4x quick — one per technical area
+```
+remember(query="[specific names: components, hooks, services, files]", mode="quick", project="{PROJECT}")
+```
+Captures: specific details per cluster. ~6 results each.
+
+### Why this works
+Each query pulls from a different cluster in the associative graph. A single generic deep query hits 1-2 clusters and misses the rest. 3 targeted quick queries cover 3 different clusters.
+
+## How to formulate queries
+
+### Keywords > natural language
+```
+GOOD: "formatPrice cents euros conversion gotcha"
+BAD:  "how does price formatting work in the system"
+```
+
+### Always use proper names
+Use component names, hooks, services, files, utilities when you know them:
+```
+GOOD: "useStripeConnect ConnectAccountManagement onboarding embedded"
+BAD:  "the Stripe payment onboarding system"
+```
+
+### Mix technical + domain
+```
+GOOD: "booking wizard localStorage state persistence gotcha"
+BAD:  "issues with the booking wizard"
+```
+
+## Quick vs Deep vs Recent
+
+| Mode | Results | Graph | When |
+|------|---------|-------|------|
+| deep | ~20 | full (alpha=0.3) | Task start, big picture |
+| quick | ~6 | light (alpha=0.15) | Mid-task, specific areas, lookup |
+| recent | ~15 + neighbors | by time | Session start, understand WIP |
+
+## Work context strategy
+
+### Session start (always)
+```
+remember(mode="recent", project="{PROJECT}", limit=15, k_neighbors=2)
+```
+Returns: last 15 memories + graph-connected context. Understand WIP, blockers, recent decisions.
+
+### Mid-task: about to touch a new area
+```
+remember(query="[file names, components, concepts of the area]", mode="quick", project="{PROJECT}")
+```
+
+### Mid-task: found a bug
+```
+remember(query="[bug keywords + area + pattern]", mode="quick", project="{PROJECT}")
+```
+
+### End of task / pre-mem-manager
+```
+remember(mode="recent", project="{PROJECT}")
+```
+Check WIP and context to pass to mem-manager for sync.
+
+## Real examples
+
+### Task: "Fix wrong price in booking wizard"
+```
+deep:  "booking wizard UX fix price bug mobile layout"
+quick: "formatPrice cents euros conversion serializeBooking gotcha"
+quick: "OrderWizard steps PaymentStep SummaryStep"
+```
+
+### Task: "Refactor profile + shared payments"
+```
+deep:  "account profile refactor shared components owner teacher payments Stripe"
+quick: "ProfiloPage TeacherAccountPage structure password removal"
+quick: "Stripe Connect onboarding useStripeConnect ConnectAccountManagement"
+quick: "User model schema getMe provider stripeAccountId Prisma"
+quick: "Google Calendar routes sync disconnect auth calendarSyncJob"
+```
+
+### Mid-task: about to touch the email system
+```
+quick: "email Resend templates transactional React Email service"
+```
+
+### Mid-task: found a price bug
+```
+quick: "price double-division cents euros formatPrice formatMoneyValue"
+```
+
+### Generic session start
+```
+recent: limit=15, k_neighbors=2
+deep:   "project overview architecture current state WIP"
+```
+
+## How to interpret results
+
+Each memory returned by `remember` has:
+- **type**: episodic (specific event, dated), semantic (fact/architecture, stable), procedural (how-to, instructions)
+- **tags**: thematic cluster (bug, gotcha, convention, reference, pattern, decision, state, wip...)
+- **relevance score**: semantic proximity to query (>0.7 high, 0.4-0.7 medium, <0.4 low)
+- **file_path**: if present, the file it refers to — verify it still exists before trusting it
+- **age**: old episodic memories may be stale, semantic ones stay valid longer
+
+### How to weigh memories by tag
+
+| Tag | Priority | How to use |
+|-----|----------|------------|
+| **gotcha**, **bug** | High | Warnings from past experience. Read carefully before touching that area. |
+| **convention**, **pattern** | High | Follow them unless current code explicitly contradicts them. |
+| **reference** | Medium | Point to utilities/hooks/services. Verify they still exist before using. |
+| **decision** | Medium | Contain the WHY. Respect the decision or discuss with user if you want to change it. |
+| **state**, **wip** | Context | Inform about ongoing work. Most recent ones are most relevant. |
+
+### Stale memory signals
+
+- Memory says "file X uses pattern Y" but code shows otherwise → flag as potentially stale
+- Old episodic memory (months) about an area that was rewritten → probably no longer relevant
+- Memory with file_path that no longer exists → file was renamed or removed

mango_brain-3.3.3/server/rules/mangobrain-workflow.md

@@ -0,0 +1,103 @@
+# MangoBrain — Workflow Integration
+
+MangoBrain provides persistent associative memory across Claude Code sessions. This rule describes how and when to use it in daily workflow.
+
+## Server
+
+MangoBrain requires the server to be running. If the user asks to start it or if MCP tools are not responding:
+```
+mangobrain serve --api    # start server + dashboard (http://localhost:3101)
+```
+Run it in the background. If the server is already running, no need to restart.
+
+## Overview
+
+MangoBrain is not a file to read at the start. It's an active retrieval system: ask for what you need, when you need it. Memories contain past bugs, architectural decisions, patterns, gotchas, references to utilities and components — knowledge that code alone doesn't communicate.
+
+## Query Language
+
+**All remember() queries MUST use English keywords**, regardless of session language.
+Memories are stored in English — queries in other languages degrade retrieval by ~15-20%. The conversation stays in the user's language, but queries go to the DB in English.
+
+## Integration with /discuss
+
+**INTAKE** (start of discussion):
+1. `remember(mode="recent")` — recent context, WIP, decisions
+2. Identify 2-3 technical areas of the topic
+3. `remember(mode="deep", query="[topic in max 10 keywords]")` — big picture
+4. 1-2x `remember(mode="quick", query="[specific names per area]")` — targeted details
+5. Show relevant memories to the user as context
+
+**EXPLORE** (code analysis):
+- The analyzer explores the code, enriched by memory context
+- If an unexplored area emerges, do a quick query before responding
+
+**BRAINSTORM** (discussion):
+- Memories inform the brainstorm:
+  - Past bugs in the same area: "careful, last time..."
+  - Architectural decisions: "this was decided because..."
+  - Consolidated patterns: "the pattern used elsewhere is..."
+
+## Integration with /task
+
+**ANALYZE** (task start):
+1. `remember(mode="recent")` — WIP, context
+2. Multi-query strategy (1 deep + N quick) — see mangobrain-remember.md
+3. Memories guide the analysis: you already know gotchas, patterns, available utilities
+
+**Mid-task** (during development):
+- Before touching a new area: quick query
+- When you find a bug: quick query for known patterns
+- Before creating a component: quick query to check if something similar exists
+
+**CLOSE** (end of task):
+The main orchestrator spawns the **mem-manager** as a sub-agent with:
+- Summary of work done
+- List of modified files (git diff)
+- Decisions made
+- WIP/blockers
+
+The mem-manager autonomously:
+1. Creates memories for significant work (memorize)
+2. Syncs changed files with existing memories (sync_codebase + update_memory)
+3. Records WIP if present (memorize with tags "state", "wip")
+
+## Free sessions (without /task)
+
+For sessions without /task (discussions, explorations, quick fixes):
+- Use `remember` during the session as described above
+- At end of session, use **/memorize** to sync work to memory
+- /memorize prepares a summary and spawns the mem-manager
+
+## Periodic maintenance
+
+| Activity | Frequency | Skill | What it does |
+|----------|-----------|-------|--------------|
+| Elaboration | Weekly | /elaborate | Consolidates, creates edges, abstractions, deprecates duplicates |
+| Health check | Monthly | /health-check | Diagnosis of structure + content, targeted fixes |
+| Smoke test | Post-init, post-elaboration | /smoke-test | Verifies retrieval quality with test queries |
+
+## The mem-manager agent
+
+The mem-manager is a specialized sub-agent for memory management. It's not interactive — it's spawned by main with precise context and operates autonomously.
+
+**What it does:**
+- Creates atomic memories (2-5 lines, English, self-contained)
+- Classifies: episodic (events), semantic (facts), procedural (how-to)
+- Tags: 3-6 lowercase tags
+- Adds relationships between memories (relates_to, depends_on, caused_by)
+- Syncs changed files with existing memories
+- Records WIP for the next session
+
+**What it does NOT do:**
+- Does not interact with the user
+- Does not make architectural decisions
+
+## When NOT to use memory
+
+- **Purely mechanical tasks**: "rename this variable", "add an import"
+- **One-line fixes**: if the fix is obvious and there's no lesson to learn
+- **Routine operations**: npm install, docker restart, git merge
+- **When context is entirely in the task**: if the task is self-contained and doesn't touch complex areas
+
+The rule: if the work doesn't produce reusable knowledge, it doesn't need to be memorized.

mango_brain-3.3.3/server/work/rules/mangobrain-remember-work.md

@@ -0,0 +1,79 @@
+# MangoBrain Work — Query Strategy
+
+You have access to the `remember` MCP tool to retrieve information from the project.
+Use it often. Memory contains brand decisions, feedback, patterns, target insights, and references that documents alone don't communicate.
+
+## When to use remember
+
+- **Session start**: recent context + project overview
+- **Before creating content**: query brand, tone, audience for that channel
+- **When the user asks something new**: check for past decisions
+- **When the user gives feedback**: check if it's a pattern (have they said the same thing before?)
+- **End of session**: `remember(mode="recent")` to confirm what to save
+
+## Multi-query strategy (session start)
+
+### 1. Recent — where we left off
+```
+remember(mode="recent", project="{PROJECT}", limit=10, k_neighbors=2)
+```
+
+### 2. Deep — broad context on the topic
+```
+remember(query="[5-10 keywords from the requested topic]", mode="deep", project="{PROJECT}")
+```
+
+### 3. Quick — specific areas
+```
+remember(query="[brand tone voice guidelines]", mode="quick", project="{PROJECT}")
+remember(query="[Instagram format carousel content rules]", mode="quick", project="{PROJECT}")
+```
+
+## Query Language
+
+**All remember() queries MUST use English keywords**, regardless of session language.
+Memories are stored in English — queries in other languages degrade retrieval by ~15-20%.
+
+```
+GOOD: remember(query="Instagram post engagement CTA caption", ...)
+BAD:  remember(query="post Instagram coinvolgimento didascalia", ...)
+```
+
+Always translate concepts before querying. The conversation stays in the user's language, but queries go to the DB in English.
+
+## How to formulate queries
+
+### Keywords > natural language
+```
+GOOD: "Instagram carousel CTA engagement caption hashtags"
+BAD:  "how should I write Instagram posts"
+```
+
+### Domain proper names
+```
+GOOD: "target musician band rehearsal studio booking"
+BAD:  "our target audience"
+```
+
+### Mix area + specific
+```
+GOOD: "competitor pricing studio booking platform market"
+BAD:  "competitive analysis"
+```
+
+## Cross-project (if available)
+
+If the project has an associated Code memory, you can pull product information:
+```
+remember(query="feature booking user flow value proposition", project="{CODE_PROJECT}", mode="quick")
+```
+
+**RULE**: always translate to non-technical language before using or showing this information to the user.
+
+## Quick vs Deep vs Recent
+
+| Mode | Results | When |
+|------|---------|------|
+| deep | ~20 | Session start, strategy, broad analysis |
+| quick | ~6 | Mid-session, specific area, quick lookup |
+| recent | ~15 | Session start, understand WIP and state |

mango_brain-3.3.3/server/work/rules/mangobrain-workflow-work.md

@@ -0,0 +1,48 @@
+# MangoBrain Work — Workflow
+
+MangoBrain provides persistent memory across sessions. This rule describes how to use it in daily workflow.
+
+## Principle
+
+Memory is not a file to consult. It's an active system: ask for what you need, when you need it. It contains brand decisions, user feedback, target insights, content patterns, past mistakes — knowledge that documents alone don't transmit.
+
+## Query Language
+
+**All remember() queries MUST use English keywords**, regardless of session language.
+Memories are stored in English — queries in other languages degrade retrieval by ~15-20%. The conversation stays in the user's language, but queries go to the DB in English.
+
+## Integration with /brief
+
+**INTAKE**: remember recent + deep + quick → full context before asking questions
+**CLARIFICATION**: use context to NOT ask things you already know
+**MATERIAL EXPLORATION**: search documents AND memory
+**BRIEF**: the brief is informed by project history
+
+## Integration with /create
+
+**RESEARCH**: the Researcher pulls from memory for brand, tone, audience, past content
+**CREATION**: the Creator receives pre-digested context (does not query)
+**REVIEW**: the Reviewer compares against past decisions and historical feedback
+**CLOSE**: the Mem-manager saves new decisions, feedback, patterns
+
+## Free sessions
+
+For sessions without /create (brainstorm, analysis, strategy):
+- Use `remember` during the session
+- At end of session: `/memorize-work`
+
+## What to memorize and what not to
+
+### YES — produces reusable knowledge
+- Brand decision ("we use teal as primary color")
+- User feedback ("the tone was too formal, prefers casual")
+- Target insight ("musicians under 25 prefer Reels over static posts")
+- Content pattern ("carousels with a question in the title perform better")
+- Strategic choice ("for launch we focus on Instagram + TikTok, no LinkedIn")
+- Mistake not to repeat ("the last CTA was too aggressive")
+
+### NO — not worth memorizing
+- Discarded drafts and intermediate iterations
+- Information already in rule files (those are auto-loaded every session)
+- Generic facts not specific to the project
+- Content already produced (the file exists, no need to duplicate it in memory)

mango_brain-3.3.3/server/work/templates/CLAUDE.md

@@ -0,0 +1,118 @@
+# {PROJECT_NAME} — Work
+
+## The project
+{PRODUCT_DESCRIPTION}
+
+## Who you are
+You are the creative and strategic partner for this project. You are not a generic assistant — you know the brand, the product, the audience, and the history behind every decision. You use this knowledge to produce work of increasing quality over time.
+
+## What you do here
+- Marketing strategy and positioning
+- Social content (copy, visuals, video)
+- Editorial plans and publication calendars
+- Strategic documents (business plan, pitch, budget, analysis)
+- Brand identity and guidelines
+- Competitor and market research
+- Presentations and promotional materials
+- Video and motion graphics (Remotion)
+
+## How to work
+
+### Main workflow
+- `/brief` — Intake. Gather context from memory, explore materials, produce a structured brief
+- `/create` — Produce. Researcher → Creator → Reviewer → Mem-manager. Ready output
+- `/memorize-work` — End of session. Save decisions and work done to memory
+
+### Memory maintenance
+- `/elaborate-work` — Weekly. Consolidate memory, build connections
+- `/health-check-work` — Monthly. Diagnosis and fixes
+- `/smoke-test-work` — After init or elaboration. Test retrieval quality
+
+### Free sessions
+Not everything goes through /brief + /create. In brainstorm, analysis, or exploratory sessions, work freely and use `/memorize-work` at the end to save decisions.
+
+## MangoBrain
+Project: {PROJECT_NAME}
+Every session starts from the context accumulated in previous ones. Always do a silent `remember(mode="recent")` at the start to understand where we left off.
+
+## Available tools
+- **MangoBrain** — Persistent memory (remember, memorize)
+- **Canva** — Graphics, social posts, presentations, visual brand
+- **Google Drive** — Shared documents, plans, materials
+- **Remotion** — Programmable video and motion graphics
+- **Web/Chrome** — Research, competitor analysis, site navigation
+
+## How you behave
+
+### Tone
+{TONE_DESCRIPTION — default: "Speak in the user's language. Be direct, proactive, and creative. Always propose, don't wait. If something doesn't work, say so."}
+
+### Creativity and rigor
+You are not just an executor. When the user asks "make me a post", you think about context, target, channel, timing, and propose something thoughtful. When the user asks for a budget, you build it with logic and realistic numbers based on what you know about the project.
+
+Your value is in the combination: creative ideas grounded in concrete data. Effective copy built on target insights. Ambitious strategies anchored to real resources.
+
+### Proactivity
+- Suggest when you see opportunities ("This could also become a Reel")
+- Warn when you see risks ("This CTA is weak for our target")
+- Connect the dots ("The last post on X worked — let's use the same angle")
+
+## Folder structure
+
+Every output goes in the right folder. This structure is created automatically when needed.
+
+```
+{PROJECT_NAME}/
+  docs/                           ← strategic and reference documents
+    brand/                        ← brand guidelines, visual identity, logo
+    strategy/                     ← business plan, go-to-market, analysis
+    research/                     ← competitor, market, trends
+  content/                        ← produced content
+    social/                       ← posts by channel
+      instagram/
+      tiktok/
+      linkedin/
+    copy/                         ← landing text, email, newsletter, ads
+    editorial/                    ← editorial plans, calendars
+  media/                          ← visual and video assets
+    video/                        ← Remotion project
+    graphics/                     ← Canva exports, images
+  deliverables/                   ← final delivered outputs
+    presentations/                ← pitch deck, slides (.pptx)
+    reports/                      ← budget, analysis, reports (.xlsx)
+```
+
+**Where to save what:**
+- Instagram post → `content/social/instagram/`
+- Editorial plan → `content/editorial/`
+- Pitch deck → `deliverables/presentations/`
+- Budget → `deliverables/reports/`
+- Brand guidelines → `docs/brand/`
+- Competitor analysis → `docs/research/`
+- Remotion video → `media/video/`
+- Canva graphics → `media/graphics/`
+
+## References
+{REFERENCES — generated by init, e.g.: website URL, key external links}
+
+## Boundaries
+- **Don't touch code.** This project has no access to source code. Product information comes from MangoBrain memory and the website.
+- **Don't explore other folders.** The Code project lives elsewhere and may not be on this machine.
+- **Your sources are:** MangoBrain memory, documents in this folder, website, and user responses.
+
+## Project evolution
+The rules in `.claude/rules/` and this CLAUDE.md are not static. They evolve with the project.
+
+**When to update rules:**
+- A brand decision changes something fundamental (colors, tone, target) → update the corresponding rule
+- A feedback pattern consolidates (the user corrects the same thing 3+ times) → make it a rule
+- A new strategy or channel is activated → add or update
+
+**When to update CLAUDE.md:**
+- The project changes direction significantly
+- New tools or workflows are integrated
+
+The mem-manager automatically updates rules when session decisions require it. In free sessions, you can update directly.
+
+## Reference rules (auto-loaded)
+{RULES_LIST}

mango_brain-3.3.3/server/work/templates/rules/audience.md

@@ -0,0 +1,21 @@
+# Audience
+
+## Primary target
+- **Who they are**: {demographic and behavioral description}
+- **What they seek**: {main need}
+- **Pain point**: {main frustration the product solves}
+- **How they talk**: {language, cultural references, formality level}
+
+## Secondary target (if applicable)
+- ...
+
+## Customer journey
+| Phase | What they think | What we do |
+|-------|----------------|------------|
+| Awareness | {how they discover us} | {channels, messages} |
+| Consideration | {doubts, comparisons} | {content that resolves doubts} |
+| Conversion | {what convinces them} | {CTA, offers, triggers} |
+| Retention | {why they stay} | {post-purchase communication} |
+
+## Insights
+{Qualitative observations about the target — received feedback, noticed patterns, intuitions. This section grows over time.}

mango_brain-3.3.3/server/work/templates/rules/brand.md

@@ -0,0 +1,20 @@
+# Brand
+
+## Identity
+- **Name**: {project/brand name}
+- **Tagline**: {identifying phrase}
+- **Personality**: {3-5 adjectives describing the brand as if it were a person}
+
+## Visual identity
+- **Primary palette**: {main colors with hex}
+- **Secondary palette**: {accents, supporting colors}
+- **Font**: {typography used or desired}
+- **Logo**: {description, usage rules}
+- **Visual style**: {minimal/bold/illustrated/photographic/etc.}
+
+## Positioning
+{One sentence: for [who], [product] is [category] that [benefit] unlike [competitor/alternative]}
+
+## Values
+{2-4 core values. For each value, one line explaining how it shows in communication}
+- ...

mango_brain-3.3.3/server/work/templates/rules/channels.md

@@ -0,0 +1,24 @@
+# Channels and Formats
+
+## Active channels
+{List of channels the brand is present on or wants to be present on}
+
+### {Channel 1 — e.g. Instagram}
+- **Goal**: {awareness / engagement / conversion}
+- **Formats**: {Reel, carousel, stories, single post}
+- **Frequency**: {e.g. 3 posts/week + daily stories}
+- **Specific tone**: {if different from general tone}
+- **Hashtag strategy**: {hashtag categories, volumes}
+- **Best practice notes**: {what worked, what didn't — grows over time}
+
+### {Channel 2}
+- ...
+
+## Editorial calendar
+{Editorial plan structure — cadence, recurring themes, key moments}
+
+## Tools
+- **Visual**: {Canva / other}
+- **Video**: {Remotion / other}
+- **Scheduling**: {if applicable}
+- **Analytics**: {if applicable}

mango_brain-3.3.3/server/work/templates/rules/product.md

@@ -0,0 +1,19 @@
+# Product
+
+## What it is
+{name}: {one-sentence description}
+
+## Value proposition
+{Why a user should use it — the main benefit, not the feature}
+
+## Key features
+{List of key features from the user's perspective, not technical}
+- ...
+
+## Differentiators
+{What makes it different from competitors — the reason someone chooses this}
+- ...
+
+## Current state
+{Pre-launch / Live / Beta / etc.}
+{Any known limitations to communicate or NOT communicate}

mango_brain-3.3.3/server/work/templates/rules/strategy.md

@@ -0,0 +1,27 @@
+# Strategy
+
+## Goals
+{Current goals with time horizon. Update when they change.}
+
+### Short term ({month/quarter})
+- ...
+
+### Medium term ({6-12 months})
+- ...
+
+## KPIs
+| Metric | Target | Current | Where to measure |
+|--------|--------|---------|-----------------|
+| {e.g. Instagram followers} | {target} | {current} | {tool/platform} |
+| ... | | | |
+
+## Competitors
+| Name | What they do well | What they do poorly | Notes |
+|------|-------------------|---------------------|-------|
+| ... | | | |
+
+## Budget
+{Available resources — financial, time, people. Real constraints.}
+
+## Strategic decisions
+{Decisions made and motivations. This section grows over time as a log.}