Client memory synthesizer

Client Memory Synthesizer

Convert fragmented information — SOWs, QBRs, meeting notes, campaign data, emails, escalations — into a structured, reusable memory asset that prevents institutional knowledge loss across teams, quarters, and renewals. Generate the tenant context that makes every Claude Project conversation client-aware from message one.

How This Skill Orchestrates

1. Script execution (scripts/memory_synthesizer.py): Processes client data into 7 memory layers (business/commercial/operational/performance/relationship/governance/strategic), scores confidence per item (8 source types), detects memory gaps (critical/important/nice-to-have), classifies risks, and generates the tenant context prompt for Claude Project Instructions
2. Reference lookup (references/memory_framework.md): 7-layer memory taxonomy with required/optional fields, confidence scoring rules (8 source types), gap detection priorities, evidence classification standards (fact/inference/assumption/question/risk/recommendation), update protocol triggers
3. Reference lookup (references/tenant_context_template.md): Ready-to-paste template for Claude Project Instructions with all sections, formatting rules, complete AcmeAuto MX example, and skill-to-context mapping showing how each OS skill reads the tenant context
4. Upstream context (Claude — PRIMARY): This skill consumes EVERYTHING — every skill output, every conversation, every decision made in the project. It's the memory crystallization point
5. Visual output (Visualizer): Memory completeness dashboard + layer-by-layer status + gap detection + stakeholder map + tenant context preview

Model decision: Interpretation → document intelligence + Governance → risk scoring. Not ML — it's structured knowledge extraction + confidence scoring + gap detection. The LLM does the heavy lifting: reading documents, extracting facts, classifying evidence, and generating the narrative tenant context.

This is the only skill that WRITES to the OS's persistent state — the tenant context it generates becomes the Project Instructions that all other skills read. This makes it the institutional memory engine of the OS.

Quick Reference

Resource	Purpose	Usage
scripts/memory_synthesizer.py	7-layer memory processor, confidence scoring (8 source types), gap detector, risk classifier, snapshot generator, tenant context generator	python memory_synthesizer.py --input client.json --output memory.json --tenant-context tenant.md
references/memory_framework.md	7-layer taxonomy with fields, confidence rules, gap priorities, evidence classification, update protocol	Read for memory structure and quality standards
references/tenant_context_template.md	Template for Claude Project Instructions, formatting rules, complete AcmeAuto MX example, skill-to-context mapping	Read for tenant context generation

How to Use the Script

import sys
sys.path.insert(0, "<skill-path>/scripts")
from memory_synthesizer import MemorySynthesizer

config = {
    "client_name": "AcmeAuto Mexico",
    "brand": "AcmeAuto + AcmeLuxe",
    "time_period": "FY2026",
    "memory_inputs": {
        "business": {
            "business_objectives": "Drive 15% YoY increase in qualified dealer leads, reduce digital CPA to ≤$120",
            "category_context": "Mexican automotive market, $88B MXN category, 5 major OEMs competing",
            "customer_segments": "New prospects (25-45 urban SUV/sedan), existing owners (service), lapsed leads",
        },
        "commercial": {
            "scope_summary": "CRM lifecycle (SFMC), paid media (Meta/Google/TikTok/YouTube), creative production, monthly reporting",
            "fee_model": "Retainer $25K USD/mo + media management 10% of spend",
            "contract_dates": "Jan 2026 - Dec 2026, 90-day renewal notice",
        },
        # ... more layers
    },
    "memory_sources": {
        "business.business_objectives": "documented_sow",
        "commercial.scope_summary": "documented_sow",
        "commercial.fee_model": "documented_sow",
    },
    "stakeholders": [
        {"name": "Marketing Director", "role": "Budget approvals + strategy", "influence": 9, "preference": "Data-led presentations"},
        {"name": "Digital Manager", "role": "Day-to-day approvals", "influence": 7, "preference": "Responsive on Slack"},
    ],
    "risks": [
        {"risk": "Legal approval delays impacting launches", "type": "operational", "severity": 7, "evidence": "SLA breach 3/13 weeks Q3"},
        {"risk": "Meta audience exhaustion", "type": "media", "severity": 6, "evidence": "Saturation detected W6 of Q3"},
    ],
    "operating_rules": [
        "Never launch without written client approval",
        "Do not present platform ROAS as incremental",
        "All scope changes go through AD for CO assessment",
    ],
}

synth = MemorySynthesizer(config)
result = synth.synthesize()
# result.tenant_context → paste into Claude Project Instructions
# result.overall_memory_completeness → how complete is the memory
# result.memory_gaps → what's missing

Process

Step 1 — Identify Client and Time Period

Which client, brand, business unit? What time period does this memory cover?

Step 2 — Gather Available Inputs

Pull from: SOW, QBR outputs, weekly control tower history, meeting notes, email threads, campaign reports, margin simulations, scope audits, CRM data, stakeholder conversations.

Step 3 — Separate Facts from Assumptions

Apply evidence classification: confirmed fact (✓), informed inference (~), assumption (?), open question (◯). Never convert speculation into memory.

Step 4 — Process Through 7 Memory Layers

Run the memory synthesizer to classify all inputs into: business, commercial, operational, performance, relationship, governance, strategic.

Step 5 — Score Confidence

Every memory item gets a confidence score based on its source (SOW = 95%, team observation = 60%, assumption = 40%). Flag Low confidence items.

Step 6 — Detect Memory Gaps

Identify required fields that are missing. Classify as critical (blocks execution), important (weakens planning), or nice-to-have (improves context).

Step 7 — Map Stakeholders

Document decision makers, influencers, detractors with influence level, preferences, sensitivities, and management approach.

Step 8 — Capture Operating Rules

Extract the rules that prevent repeated mistakes: approval requirements, escalation protocols, content restrictions, commercial guardrails.

Step 9 — Generate Tenant Context

Produce the Project Instructions prompt that will be pasted into the Claude Project for this client. This is the PRIMARY deliverable.

Step 10 — Plan Memory Updates

Define update triggers: new SOW → update commercial, QBR → update performance, stakeholder change → update relationship.

Output Format

Produce in THREE forms: inline visual dashboard (Visualizer), tenant context file (markdown for Project Instructions), and full memory brief (markdown).

Visual Dashboard (Primary)

Render as inline HTML widget:

• Snapshot card — client name, scope, fee model, relationship status, main risk, main opportunity
• Memory completeness gauge — overall % with layer breakdown (7 bars)
• Gap detection — critical gaps highlighted in red, with required source
• Confidence distribution — pie chart of High/Medium/Low confidence items
• Stakeholder map — cards per stakeholder with influence level and preference
• Operating rules — numbered list with emphasis
• Tenant context preview — scrollable preview of the generated Project Instructions
• sendPrompt() buttons: "Generate QBR from this client memory" → qbr-generator, "Audit current scope against memory" → scope-audit, "Copy tenant context to clipboard"

Tenant Context File (Critical Deliverable)

The --tenant-context output generates a ready-to-paste markdown file for Claude Project Instructions. Structure defined in references/tenant_context_template.md.

Full Memory Brief (Markdown)

## 🧠 CLIENT MEMORY BRIEF — [Client] — [Brand]

### Memory snapshot
| Field | Value |
[10-field snapshot table]

### Executive memory summary
[1 paragraph C-level summary]

### Memory completeness: [X]%
| Layer | Completeness | Required filled | Status |
[7 rows — color-coded by status]

### Business memory
[Content with confidence badges]

### Commercial memory
[Scope, fees, COs, margin, renewal]

### Operational memory
[Workflows, patterns, blockers]

### Performance memory
[What worked, what didn't, learnings]

### Relationship memory (Stakeholder map)
| Stakeholder | Role | Influence | Preference | Risk |

### Governance memory
[Approval rights, compliance, constraints]

### Strategic memory
[Opportunity, upsell, churn risk, innovation]

### Risks
| Risk | Type | Severity | Evidence | Mitigation |

### Operating rules
[Numbered list]

### Open decisions
| Decision | Owner | Deadline | Impact if unresolved |

### Memory gaps
| Gap | Priority | Why it matters | Required source |

### Tenant context (for Claude Project Instructions)
[Full generated tenant context — ready to copy-paste]

Integration with Claude Projects

This skill is the bridge between the OS and Claude's platform.

How it works operationally:

1. You create a Claude Project for each client (e.g., "AcmeAuto MX")
2. Run client-memory-synthesizer to generate the tenant context
3. Paste the tenant context into Project → Settings → Project Instructions
4. Every conversation in that project — every skill trigger, every analysis, every output — now has full client context
5. After each QBR or major event, re-run the synthesizer to update the tenant context
6. The memory compounds: each quarter adds learnings, refines rules, updates stakeholders

For Claude Enterprise/Team:

• Each team member in the project sees the same tenant context
• Skills trigger with the same client knowledge regardless of who's chatting
• New team members are instantly onboarded — the tenant context IS the briefing

Skill Chaining

Direction	Skill	Connection
Upstream	ALL 16 skills	Memory synthesizes every OS output into persistent knowledge
Upstream	qbr-generator	QBR findings → update performance + learnings layers
Upstream	scope-audit	Scope findings → update commercial layer
Upstream	margin-simulation	Margin data → update commercial layer (margin risk)
Upstream	performance-diagnosis	Root causes → update performance + operating rules
Downstream	ALL skills	Tenant context feeds into every skill via Project Instructions
Downstream	qbr-generator	Memory → starting point for next QBR
Downstream	executive-growth-memo	Memory → contextual narrative for leadership