@adaptic/maestro 1.0.0

package/docs/superpowers/specs/2026-04-03-phase1-executive-core-design.md

@@ -0,0 +1,516 @@
+# Phase 1: Executive Core — Design Spec
+
+**Date**: 2026-04-03
+**Author**: Sophie Nguyen (Chief of Staff)
+**Approved by**: Mehran Granfar (CEO)
+**Status**: Approved
+**Scope**: Control Towers 1-3 — Strategy & Decisions, Executive Office & Follow-Through, Operating Cadence & PMO
+**Depends on**: Phase 0 Operational Foundation (complete)
+
+## Context
+
+Phase 0 built the operational runtime: 15 queues, dashboards, event polling, interaction memory, user/channel profiles, audit hooks, prompt injection defence, and scheduled triggers. Phase 1 builds the three core control towers that make Sophie a functioning executive office — converting infrastructure into operational intelligence.
+
+### Current State (Post Phase 0)
+
+- 15 operational queues in `state/queues/` (empty, ready for population)
+- Executive summary dashboard at `state/dashboards/executive-summary.yaml`
+- 5 user profiles and 10 channel profiles in `memory/profiles/`
+- Scheduled triggers: morning brief, evening wrap (remote cloud); midday sweep, inbox processor, weekly workflows (local launchd)
+- 60-second Slack poller running via launchd
+- Audit hooks active on all outbound communications
+
+### Gap Summary
+
+- **Strategy**: Static priority definitions exist but no drift detection, decision archive, coherence validation, or living strategy state
+- **Follow-through**: Queue infrastructure exists but no meeting action capture, loop closure verification, SLA tracking, or blocker playbooks
+- **Cadence**: Triggers run on schedule but no meeting prep automation, post-meeting routing, initiative scorecards, or cadence quality auditing
+
+## Architecture
+
+Phase 1 adds operational intelligence on top of Phase 0's state layer:
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                 PHASE 1: EXECUTIVE CORE                      │
+├───────────────────┬─────────────────┬───────────────────────┤
+│  CT1: Strategy    │  CT2: Follow-   │  CT3: Cadence         │
+│  & Decisions      │  Through        │  & PMO                │
+├───────────────────┴─────────────────┴───────────────────────┤
+│  Drift Detection │ Meeting Capture │ Meeting Prep           │
+│  Decision Library│ Loop Closure    │ Initiative Scorecard   │
+│  Coherence Check │ SLA Tracking    │ Cadence Quality Audit  │
+│  Strategy State  │ Blocker Plays   │ Action Router          │
+├─────────────────────────────────────────────────────────────┤
+│              PHASE 0: OPERATIONAL FOUNDATION                 │
+│  Queues │ Dashboards │ Memory │ Polling │ Triggers │ Audit   │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## Control Tower 1: Strategy & Decisions
+
+### 1.1 Priority Drift Detector
+
+**Purpose**: Continuously monitor strategic priorities for milestone slippage and auto-escalate.
+
+**Mechanism**: The evening-wrap workflow is enhanced to:
+
+1. Read `config/priorities.yaml` — extract all milestones with target dates
+2. For each milestone, assess current status against target
+3. Calculate drift: `drift_days = today - target_date` (for incomplete milestones past target)
+4. Update `state/dashboards/strategy-scorecard.yaml` with per-priority health
+5. When drift exceeds threshold (7 days for high priority, 14 for medium):
+   - Create item in `state/queues/high-risk-items.yaml` if not already present
+   - Flag in morning brief with recommended action
+
+**Strategy Scorecard Schema** (`state/dashboards/strategy-scorecard.yaml`):
+
+```yaml
+generated: ISO-8601
+priorities:
+  P1-dfsa-licensing:
+    status: on_track | at_risk | overdue | blocked
+    milestones_total: int
+    milestones_completed: int
+    milestones_overdue: int
+    max_drift_days: int
+    active_initiatives: int
+    blockers: int
+    last_update: ISO-8601
+    owner: string
+    notes: string
+  # ... P2 through P5
+overall:
+  on_track: int
+  at_risk: int
+  overdue: int
+  unlinked_initiatives: int # Work not tied to any priority
+```
+
+### 1.2 Decision Library
+
+**Purpose**: Persistent archive of decisions with full context, rationale, and outcomes.
+
+**Location**: `knowledge/decisions/archive/{YYYY-MM-DD}-{decision-slug}.yaml`
+
+**Decision Record Schema** (based on existing `knowledge/decisions/decision-schema.yaml`):
+
+```yaml
+id: string
+title: string
+date: ISO-8601
+status: proposed | decided | implemented | reviewed | reversed
+category: strategy | operations | hiring | legal | financial | product | regulatory
+decided_by: string
+participants: [string]
+context: string
+options:
+  - name: string
+    description: string
+    pros: [string]
+    cons: [string]
+    risk_level: low | medium | high
+chosen_option: string
+rationale: string
+success_criteria: [string]
+review_date: ISO-8601
+outcome: string # Populated at review date
+source: meeting | slack | email | interactive | workflow
+source_ref: string
+```
+
+**Capture triggers**:
+
+- Interactive sessions where Mehran makes a decision → Sophie logs it
+- Meeting action capture identifies a decision → auto-logged
+- Slack messages containing decision language → inbox processor flags for logging
+- Weekly priorities review identifies resolved decisions → Sophie logs outcome
+
+**Decision index** (`knowledge/decisions/index.yaml`): Lightweight pointer file listing all decisions by date and category, regenerated by the evening wrap.
+
+### 1.3 Strategic Coherence Check
+
+**Purpose**: Validate that current work aligns with stated strategy. Flag drift and unlinked effort.
+
+**Mechanism**: Added to the Friday strategic memo workflow:
+
+1. Read `config/priorities.yaml` for the 5 strategic priorities
+2. Scan all queue items across all 15 queues — map each to a priority (or "unlinked")
+3. Check source repositories (`~/adapticai`, `~/dfsa-submission`, `~/rollup-strategy`) for recent commit activity — map to priorities
+4. Flag:
+   - Priorities with zero active queue items (stalled)
+   - Queue items not mapped to any priority (unlinked work)
+   - Priorities where all items are blocked
+   - Conflicting initiatives (two initiatives with opposing goals)
+5. Include findings in the strategic memo under "Coherence Check" section
+
+### 1.4 Living Strategy State
+
+**Purpose**: A continuously-evolved document capturing the company's strategic position.
+
+**Location**: `knowledge/syntheses/strategy-state.yaml`
+
+```yaml
+last_updated: ISO-8601
+updated_by: weekly-strategic-memo
+
+strategic_position:
+  one_liner: string # "Where we are in one sentence"
+  phase: string # "Pre-revenue regulated AI asset management platform"
+  primary_vector: string # "DFSA licensing + Project Aether rollup"
+
+key_assumptions:
+  - assumption: string
+    status: holding | weakening | invalidated
+    evidence: string
+    last_checked: ISO-8601
+
+emerging_signals:
+  - signal: string
+    source: string
+    date: ISO-8601
+    implication: string
+    action_taken: string
+
+strategic_risks:
+  - risk: string
+    severity: critical | high | medium | low
+    likelihood: high | medium | low
+    mitigation: string
+    owner: string
+
+recent_decisions:
+  - id: string
+    title: string
+    date: ISO-8601
+    impact: string
+
+next_quarter_focus: [string]
+```
+
+**Update cadence**: Regenerated by the weekly strategic memo workflow every Friday. Each update preserves history by appending to a `history` section at the bottom.
+
+## Control Tower 2: Executive Office & Follow-Through
+
+### 2.1 Meeting Integration Workflow (Hybrid Approach C)
+
+**Purpose**: Automatically capture action items, decisions, and follow-ups from meetings.
+
+**New trigger**: `meeting-action-capture` — runs every 30 minutes via local launchd.
+
+**Prompt**: `schedules/triggers/meeting-action-capture.md`
+
+**Workflow**:
+
+1. Read Calendar MCP for meetings that ended in the last 30 minutes
+2. For each ended meeting:
+   a. Check Granola MCP for meeting transcript/notes
+   b. Check Slack #ceo-office and relevant channels for post-meeting summaries
+   c. Check `memory/interactions/meetings/` to see if already processed
+3. If notes found (from either source):
+   a. Extract action items (who, what, when)
+   b. Extract decisions made
+   c. Extract follow-ups needed
+   d. Route actions to `state/queues/action-stack.yaml` or `state/queues/follow-ups.yaml`
+   e. Route decisions to `knowledge/decisions/archive/`
+   f. Write meeting record to `memory/interactions/meetings/{date}-{slug}.yaml`
+4. If no notes found 30 minutes after meeting end:
+   a. Send gentle Slack message: "Hey {attendees} — just finished {meeting name}. Any key takeaways or actions I should track?"
+   b. When response comes in via inbox processor, process it as meeting output
+5. Log to `logs/workflows/{date}-meeting-action-capture.jsonl`
+
+**Meeting Record Schema** (`memory/interactions/meetings/{date}-{slug}.yaml`):
+
+```yaml
+meeting_name: string
+date: ISO-8601
+start_time: ISO-8601
+end_time: ISO-8601
+attendees: [string]
+source: granola | slack | both
+summary: string
+actions:
+  - description: string
+    owner: string
+    due: ISO-8601
+    queue_id: string # Reference to queue item created
+decisions:
+  - description: string
+    decision_id: string # Reference to decision archive entry
+follow_ups:
+  - description: string
+    owner: string
+    queue_id: string
+notes_source_ref: string # Granola ID or Slack message ref
+```
+
+### 2.2 Loop Closure Verification
+
+**Purpose**: Verify that items marked "resolved" actually completed, not just acknowledged.
+
+**Mechanism**: Enhanced midday sweep logic:
+
+1. Scan all queues for items with `status: resolved` updated in the last 48 hours
+2. For each resolved item, check:
+   - Was an expected deliverable produced? (file created, message sent, PR merged)
+   - Did the owner confirm completion?
+   - Is the source thread/conversation actually closed?
+3. If verification fails:
+   - Reopen the item with status `open` and note: "Reopened — closure not verified"
+   - Notify the owner via Slack
+4. If verification passes:
+   - Update status to `closed` (final state)
+   - Update history with closure verification timestamp
+
+**Status flow**: `open → in_progress → blocked → resolved → closed`
+
+- `resolved` = owner says it's done
+- `closed` = Sophie verified it's actually done
+
+### 2.3 Commitment SLA Tracking
+
+**Purpose**: Track response time commitments and flag breaches.
+
+**New queue item fields** (added to standard schema):
+
+```yaml
+sla:
+  response_hours: int # Expected response time in hours
+  sla_deadline: ISO-8601 # Calculated from created + response_hours
+  sla_status: on_track | at_risk | breached
+```
+
+**SLA defaults** (stored in `config/sla-defaults.yaml`):
+
+```yaml
+sla_defaults:
+  ceo_request: 4 # CEO asks for something → 4 hour response
+  leadership_request: 24 # Leadership team request → 24 hours
+  external_partner: 48 # External partner follow-up → 48 hours
+  regulatory: 24 # Regulatory items → 24 hours
+  candidate: 24 # Candidate communications → 24 hours
+  general: 72 # General items → 72 hours
+```
+
+**Mechanism**:
+
+- When items are created in queues, the inbox processor or meeting capture assigns an SLA based on source and sender
+- Midday sweep calculates `sla_status` for all items with SLAs
+- `at_risk` = 75% of SLA time elapsed, no update
+- `breached` = past SLA deadline, not resolved
+- Breached items auto-surface in morning brief with red flag
+- SLA metrics tracked in `state/dashboards/executive-summary.yaml`
+
+### 2.4 Blocker Resolution Playbooks
+
+**Purpose**: Provide resolution patterns for common blocker types.
+
+**Location**: `knowledge/sources/blocker-playbooks.yaml`
+
+```yaml
+playbooks:
+  awaiting_approval:
+    description: Item blocked waiting for someone's approval
+    steps:
+      - Check if approver was notified
+      - Send direct reminder with context and deadline
+      - If no response in 24h, escalate via different channel
+      - If no response in 48h, escalate to CEO
+    auto_actions:
+      - send_reminder_after: 24h
+      - escalate_after: 48h
+
+  technical_blocker:
+    description: Engineering or infrastructure issue blocking progress
+    steps:
+      - Identify the specific technical issue
+      - Check if it's already tracked in a platform-blockers queue item
+      - Route to relevant engineering channel
+      - Set review deadline
+    auto_actions:
+      - create_platform_blocker_if_missing: true
+      - notify_engineering_channel: true
+
+  dependency_on_external:
+    description: Waiting on external party (vendor, partner, regulator)
+    steps:
+      - Check last communication with external party
+      - Send professional follow-up if > 48h since last contact
+      - Check if alternative approaches exist
+      - Escalate to CEO if strategic relationship
+    auto_actions:
+      - send_followup_after: 48h
+      - escalate_if_strategic: true
+
+  waiting_for_information:
+    description: Need information from someone before proceeding
+    steps:
+      - Identify who has the information
+      - Send specific request with clear deadline
+      - Offer to help gather the information if possible
+    auto_actions:
+      - send_request_with_deadline: true
+
+  resource_constraint:
+    description: Not enough people, budget, or time
+    steps:
+      - Quantify the constraint
+      - Identify what could be deprioritised to free resources
+      - Present trade-off to CEO
+    auto_actions:
+      - create_decision_queue_item: true
+```
+
+**Mechanism**: The weekly execution review reads blocked items, matches them to playbook patterns, and applies the resolution steps. Auto-actions are executed where Sophie has autonomy; others are drafted for CEO review.
+
+## Control Tower 3: Operating Cadence & PMO
+
+### 3.1 Meeting Prep Automation
+
+**Purpose**: Auto-generate prep briefs before calendar events.
+
+**New trigger**: `meeting-prep` — runs every 15 minutes via local launchd.
+
+**Prompt**: `schedules/triggers/meeting-prep.md`
+
+**Workflow**:
+
+1. Read Calendar MCP for meetings starting in the next 15 minutes
+2. Skip meetings that already have a prep brief in `outputs/briefs/`
+3. For each upcoming meeting:
+   a. Read attendee list from calendar event
+   b. For each attendee, read `memory/profiles/users/{person}.yaml` for context
+   c. Check `memory/indexes/by-person.yaml` for recent interactions
+   d. Check all queues for open items involving attendees
+   e. Check `knowledge/decisions/archive/` for recent decisions involving attendees
+   f. Read `memory/interactions/meetings/` for last meeting with same attendees
+4. Generate prep brief covering:
+   - Attendees and their context
+   - Last interaction with each person
+   - Open items to discuss
+   - Pending decisions relevant to attendees
+   - Suggested talking points
+   - Items to avoid (if any, from user profiles)
+5. Write to `outputs/briefs/{date}-prep-{meeting-slug}.md`
+6. Send to Mehran via Slack DM 10 minutes before meeting start
+7. Log to `logs/workflows/{date}-meeting-prep.jsonl`
+
+### 3.2 Post-Meeting Action Router
+
+**Purpose**: Route extracted actions from meetings to owners with proper tracking.
+
+**Mechanism**: Part of the meeting action capture workflow (CT2, section 2.1). After actions are extracted:
+
+1. For each action item:
+   a. Identify owner (from meeting context or attendee who was assigned it)
+   b. Assign SLA based on urgency and owner type (from `config/sla-defaults.yaml`)
+   c. Create queue item in `state/queues/action-stack.yaml` or `state/queues/follow-ups.yaml`
+   d. Add `source: meeting`, `source_ref: meeting-{date}-{slug}`
+   e. If owner is not Mehran, send Slack notification: "Action from {meeting}: {description}. I've added this to your items for tracking."
+2. For each decision:
+   a. Log to `knowledge/decisions/archive/`
+   b. If decision affects priorities, update `config/priorities.yaml`
+3. For each follow-up:
+   a. Create queue item with assigned SLA
+   b. Set reminder for Sophie to chase if no progress
+
+### 3.3 Initiative Scorecard
+
+**Purpose**: Per-priority health tracking dashboard.
+
+**Location**: `state/dashboards/strategy-scorecard.yaml` (shared with CT1 drift detector)
+
+**Regeneration**: Evening wrap workflow regenerates the scorecard by:
+
+1. Reading `config/priorities.yaml` for all priorities and milestones
+2. Scanning all queues for items tagged with each priority
+3. Calculating per-priority metrics:
+   - Milestone completion rate
+   - Active vs blocked items
+   - Days since last progress
+   - Owner engagement (are assigned owners updating items?)
+4. Calculating overall health score
+
+**Surfacing**: The morning brief includes a one-line-per-priority status from the scorecard. The weekly strategic memo includes a full scorecard analysis.
+
+### 3.4 Cadence Quality Audit
+
+**Purpose**: Ensure meetings and workflows are producing outcomes, not just consuming time.
+
+**Mechanism**: Added to the Friday strategic memo workflow:
+
+1. Read `memory/interactions/meetings/` for all meetings this week
+2. For each meeting, check:
+   - Were actions captured? (exists in meetings directory with actions list)
+   - Were actions assigned owners and deadlines?
+   - Were previous meeting's actions closed?
+3. Calculate:
+   - Meeting → action capture rate
+   - Action → closure rate
+   - Average actions per meeting
+   - Meetings with zero outputs
+4. Flag:
+   - Recurring meetings with consistently zero outputs → suggest cancellation
+   - Meetings where actions are captured but never closed → accountability gap
+   - Meetings without clear purpose (no agenda, no outcomes)
+5. Include in strategic memo under "Cadence Health" section
+
+## New Files Summary
+
+### New state files
+
+- `state/dashboards/strategy-scorecard.yaml` — Per-priority health tracking
+- `config/sla-defaults.yaml` — SLA definitions by item type
+
+### New knowledge files
+
+- `knowledge/decisions/archive/` — Decision record directory
+- `knowledge/decisions/index.yaml` — Decision index
+- `knowledge/syntheses/strategy-state.yaml` — Living strategy document
+- `knowledge/sources/blocker-playbooks.yaml` — Blocker resolution patterns
+
+### New trigger prompts
+
+- `schedules/triggers/meeting-action-capture.md` — Post-meeting action extraction
+- `schedules/triggers/meeting-prep.md` — Pre-meeting brief generation
+
+### New launchd plists
+
+- `ai.adaptic.sophie-meeting-action-capture.plist` — Every 30 min
+- `ai.adaptic.sophie-meeting-prep.plist` — Every 15 min
+
+### Modified files
+
+- `schedules/triggers/daily-morning-brief.md` — Add scorecard summary, SLA breach alerts
+- `schedules/triggers/daily-midday-sweep.md` — Add loop closure verification, SLA tracking
+- `schedules/triggers/daily-evening-wrap.md` — Add drift detection, scorecard regeneration, decision index
+- `schedules/triggers/weekly-strategic-memo.md` — Add coherence check, cadence quality audit, strategy state update
+- `schedules/triggers/weekly-execution.md` — Add blocker playbook matching
+- `CLAUDE.md` — Add Phase 1 documentation
+
+## Implementation Sequence
+
+1. Create new state/knowledge files (scorecard, SLA defaults, strategy state, blocker playbooks, decision archive)
+2. Create meeting-action-capture trigger prompt
+3. Create meeting-prep trigger prompt
+4. Enhance morning brief with scorecard + SLA breach alerts
+5. Enhance midday sweep with loop closure + SLA tracking
+6. Enhance evening wrap with drift detection + scorecard regeneration + decision indexing
+7. Enhance weekly strategic memo with coherence check + cadence audit + strategy state update
+8. Enhance weekly execution with blocker playbook matching
+9. Create launchd plists for meeting triggers
+10. Install meeting trigger daemons
+11. Update CLAUDE.md with Phase 1 documentation
+12. Verify all triggers are active and configured
+
+## Success Criteria
+
+- Strategic priorities are tracked with drift detection; overdue milestones auto-flagged
+- Decisions are logged with full context within 24h of being made
+- Meeting actions are captured and routed within 30 minutes of meeting end
+- 90%+ of resolved items go through closure verification
+- SLA breaches are flagged in morning brief
+- Meeting prep briefs are delivered 10 minutes before every meeting
+- Weekly strategic memo includes coherence check and cadence audit
+- Strategy state document evolves weekly with meaningful content
+- Blocker resolution follows playbook patterns, not ad-hoc escalation