@adaptic/maestro 1.0.0

package/.claude/commands/init-agent.md

@@ -0,0 +1,99 @@
+# /init-agent — Refactor this repo for a new AI agent identity
+
+You are being asked to transform this repository from its current agent identity into a new one. This repo is a template for Adaptic AI agents — autonomous AI employees that each run on a dedicated Mac Mini.
+
+## What you need to gather
+
+Ask the user for the following (or accept them as arguments):
+
+1. **Agent name** (e.g., "Jacob", "Ravi", "Isla") 
+2. **Agent surname** (e.g., "Chen", "Patel", "Roselli")
+3. **Agent role/title** (e.g., "Chief AI Scientist", "Head of Quant Engineering")
+4. **Agent directory name** (e.g., "jacob-ai", "ravi-ai") — defaults to lowercase `{firstname}-ai`
+5. **Mac Mini hostname** (e.g., "jacob-mini", "ravi-mini") — for reference
+6. **Key responsibilities** (2-5 bullet points describing what this agent does)
+7. **Reporting line** (who this agent reports to, e.g., "Mehran Granfar, CEO")
+8. **Communication style notes** (formal/casual, proactive/reactive, etc.)
+
+## What you must change
+
+### 1. CLAUDE.md — Complete identity rewrite
+
+Rewrite the `## Identity` section with the new agent's name, role, and operating context. Update:
+
+- Agent name and title throughout
+- `## Operating Principles` — adapt to the agent's domain (a quant engineer has different principles than a chief of staff)
+- `## Communication Rules` — adapt voice modes and autonomy model for the role
+- `## People` section — update "That's you" line
+
+### 2. Variable names in scripts
+
+Run a global find-and-replace across all scripts:
+
+```bash
+# Replace the directory variable name
+find scripts/ -type f \( -name "*.sh" -o -name "*.mjs" -o -name "*.js" \) \
+  -exec sed -i '' "s/SOPHIE_AI_DIR/${UPPER_NAME}_AI_DIR/g; s/SOPHIE_AI_PATH/${UPPER_NAME}_AI_PATH/g; s/SOPHIE_AI/${UPPER_NAME}_AI/g" {} \;
+```
+
+Where `UPPER_NAME` is the agent's first name in UPPER_SNAKE_CASE (e.g., JACOB, RAVI).
+
+### 3. Launchd plist templates
+
+In `scripts/local-triggers/plists/`, update all plist files:
+- Change label prefix from `ai.adaptic.sophie-` to `ai.adaptic.{agentname}-`
+- Update all paths from `/Users/sophie/sophie-ai` to `/Users/{agentname}/{agentname}-ai`
+
+### 4. package.json
+
+- Update `"name"` field to the new agent directory name
+- Update `"description"` to reflect the new agent's role
+
+### 5. Config files
+
+- `config/environment.yaml` — update agent name, directory paths
+- `config/contacts.yaml` — review and update if the agent has different key contacts
+- `config/priorities.yaml` — replace with priorities relevant to the new agent's domain
+
+### 6. Agent definitions
+
+Review `agents/` directory. Some agents are generic (inbox processor, meeting prep) and should be kept. Others are Sophie-specific and should be adapted or removed based on the new agent's domain.
+
+### 7. Workflow triggers
+
+Review `schedules/triggers/` — keep the generic cadence triggers (morning brief, evening wrap, backlog executor) but adapt the content of each trigger prompt to reference the new agent's identity and responsibilities.
+
+### 8. Hooks in .claude/settings.json (project-level)
+
+Update any references to Sophie-specific hook scripts in `.claude/settings.json` and `.claude/settings.local.json`.
+
+### 9. README.md
+
+Update the repo README to reflect the new agent's identity.
+
+## What NOT to change
+
+- The overall architecture and directory structure
+- The poller/inbox/trigger infrastructure
+- The ruflo hook integration
+- The brand assets (these are Adaptic-wide)
+- The global `~/.claude/settings.json` (already set up by `npm run init-agent`)
+
+## After refactoring
+
+1. Run `npm run init-agent` to install everything on the machine
+2. Fill in the `.env` file with the agent's API keys
+3. Verify with `launchctl list | grep adaptic`
+4. Run `npm run healthcheck`
+
+## Important context
+
+This repo is one of 16+ AI agent instances across Adaptic:
+- **Sophie** (Chief of Staff) — the original, most fully developed
+- **Jacob** (Chief AI Scientist) — research, model evaluation, publications
+- **Ravi** (Head of Quant Engineering) — algorithmic trading, backtesting
+- **Isla** (Head of Engineering) — platform engineering, CI/CD, code quality
+- **Nadia** (Head of Compliance) — regulatory, DFSA, CIMA, cross-jurisdiction
+- And more...
+
+Each agent has its own Mac Mini, its own fork of this repo, and its own identity. The infrastructure is shared; the identity and domain focus is unique.

package/.claude/commands/init-maestro.md

@@ -0,0 +1,565 @@
+# /init-maestro -- Configure a New Maestro Agent Identity
+
+You are running the Maestro initialization wizard. This is the single most important command in the system -- it transforms this repository from its current agent identity into a completely new autonomous AI agent.
+
+Maestro is a framework for deploying autonomous AI agents on dedicated Mac minis. Each agent has its own identity, role, responsibilities, and operating style. This wizard gathers that information conversationally and then rewrites the repo in parallel.
+
+## Important Context
+
+- The central config file is `config/agent.ts` -- this is the single source of truth for all identity values
+- The machine setup script `scripts/setup/init-agent.sh` runs AFTER this wizard completes
+- CLAUDE.md defines the agent's system prompt and operating instructions
+- There are 31 agent definitions in `agents/`, 13 trigger prompts in `schedules/triggers/`, and config files throughout the repo
+- The current agent identity must be fully replaced -- no references to the old agent should remain in critical files
+
+## Phase 1: Gather Information
+
+Run a conversational wizard to collect the new agent's identity. Be friendly, encouraging, and clear. Ask questions in small groups (2-3 at a time), not as a wall of text. Confirm values as you go.
+
+### Step 1: Welcome and Name
+
+Start with a warm welcome, then ask for the basics:
+
+```
+Welcome to Maestro -- let's set up your new AI agent.
+
+First, the fundamentals:
+1. What is the agent's first name? (e.g., "Jacob", "Ravi", "Isla")
+2. What is the agent's last name? (e.g., "Chen", "Patel", "Roselli")
+3. What is their job title? (e.g., "Chief AI Scientist", "Head of Engineering")
+4. What is their email address? (e.g., jacob@adaptic.ai)
+```
+
+### Step 2: Role Archetype
+
+Present the archetype options and ask the user to choose. Explain each briefly:
+
+```
+Now, which role archetype best describes this agent?
+
+  1. executive-operator -- Chief of Staff, COO, executive operations. Coordinates across
+     all functions, manages communications, tracks commitments, runs the office.
+
+  2. technical-leader -- CTO, Head of Engineering, Chief Scientist. Owns technical
+     architecture, engineering quality, R&D strategy, and platform delivery.
+
+  3. commercial-leader -- Head of Sales, IR, Business Development. Owns pipeline,
+     partnerships, investor relations, and commercial strategy.
+
+  4. compliance-officer -- Head of Compliance, Legal, Regulatory. Owns regulatory
+     submissions, licence maintenance, legal obligations, and risk management.
+
+  5. product-leader -- Head of Product, UX. Owns product roadmap, user experience,
+     feature prioritisation, and product-market fit.
+
+  6. operations-leader -- Head of Ops, Fund Ops, HR. Owns operational processes,
+     fund administration, hiring, and organisational design.
+
+Which archetype? (number or name)
+```
+
+### Step 3: Responsibilities and Principles
+
+Ask for the agent's key responsibilities:
+
+```
+What are this agent's key responsibilities? List 3-7 bullet points describing
+what they do day-to-day.
+
+(If you'd like, I can generate defaults based on the archetype you chose.)
+```
+
+Then ask about operating principles:
+
+```
+What operating principles should guide this agent? List 3-6 principles, or type
+"defaults" to use archetype-appropriate principles.
+```
+
+**Default principles by archetype:**
+
+- **executive-operator**: Follow-through over brilliance; Concise over comprehensive; Evidence over opinion; Bias to action; Audit everything; Full autonomy, full accountability
+- **technical-leader**: Technical rigour over speed; Simplicity over cleverness; Measure before optimising; Document decisions; Security by default; Ship incrementally
+- **commercial-leader**: Pipeline over activity; Relationships over transactions; Data-driven targeting; Speed to close; Institutional credibility first; Follow up relentlessly
+- **compliance-officer**: Accuracy over speed; Conservative interpretation; Document everything; Deadline-driven execution; Cross-jurisdiction awareness; Escalate uncertainty
+- **product-leader**: User outcomes over features; Evidence over intuition; Ship and learn; Simplicity over completeness; Cross-functional alignment; Measure impact
+- **operations-leader**: Process over heroics; Automate the repeatable; Measure throughput; Clear ownership; Continuous improvement; Operational resilience
+
+### Step 4: Organisation
+
+```
+Now for the organisational context:
+
+1. Company name (default: the current value in config/agent.ts)
+2. Company domain (default: the current value)
+3. Brief company description (one line)
+```
+
+### Step 5: Principal (Reporting Line)
+
+```
+Who does this agent report to?
+
+1. Principal's full name (e.g., "Mehran Granfar")
+2. Principal's title (e.g., "CEO")
+3. Principal's email (e.g., mehran@adaptic.ai)
+```
+
+### Step 6: Machine and Timezone
+
+```
+A few deployment details:
+
+1. Mac mini hostname (e.g., "jacob-mini") -- defaults to {firstname}-mini
+2. Timezone (IANA format, e.g., "America/New_York") -- defaults to current value
+```
+
+### Step 7: Communication Style
+
+```
+How should this agent communicate?
+
+1. Default tone: formal / warm-professional / casual (default: warm-professional)
+2. Any custom voice modes beyond the standard four (agent, principal, internal, institutional)?
+```
+
+### Step 8: Optional Contact Details
+
+```
+Optional -- skip any you don't have yet:
+
+1. Agent phone number (E.164 format, e.g., +16282656712) -- for Twilio SMS/WhatsApp
+2. Agent Slack member ID (e.g., U097N5R0M7U) -- for mentions and DM routing
+```
+
+### Step 9: Confirmation
+
+Before executing, display a full summary of all gathered values and ask for confirmation:
+
+```
+Here is the complete configuration for the new agent:
+
+  Name:           {firstName} {lastName}
+  Title:          {title}
+  Email:          {email}
+  Archetype:      {archetype}
+  Company:        {company} ({companyDomain})
+  Principal:      {principalName}, {principalTitle}
+  Machine:        {machineName}
+  Timezone:       {timezone}
+  Tone:           {defaultTone}
+  Phone:          {phone || "not set"}
+  Slack ID:       {slackMemberId || "not set"}
+
+  Responsibilities:
+    - {each responsibility}
+
+  Operating Principles:
+    - {each principle}
+
+Does this look correct? (yes to proceed, or tell me what to change)
+```
+
+## Phase 2: Execute Changes
+
+Once the user confirms, deploy SEVEN sub-agents in parallel using the Agent tool with `run_in_background: true`. Announce what you are doing:
+
+```
+Deploying 7 parallel agents to rewrite the repository. This will take a minute or two...
+```
+
+### Sub-agent 1: Update config/agent.ts
+
+**Instruction to sub-agent:** Read `config/agent.ts` and rewrite it with all the gathered values. Preserve the file structure, TypeScript types, JSDoc comments, and derived values section exactly. Only change the literal values in the `agent` object. Update:
+
+- firstName, lastName, fullName, title, archetype
+- email, phone, slackMemberId
+- company, companyDomain, companyDescription
+- principal object (firstName, lastName, fullName, title, email -- keep slackMemberId as empty string unless provided)
+- machineName, launchdLabelPrefix (ai.adaptic.{lowercase-firstname})
+- timezone
+- communication.defaultTone, communication.externalTone (set based on archetype -- compliance/institutional roles default to formal)
+- communication.voiceModes (update labels: "Agent's voice" -> "{firstName}'s voice", "Principal's voice" -> "{principalFirstName}'s voice")
+- responsibilities array
+- operatingPrinciples array
+
+### Sub-agent 2: Rewrite CLAUDE.md
+
+**Instruction to sub-agent:** Read `CLAUDE.md` and rewrite ONLY the identity-related sections. Keep all infrastructure sections intact (Repository Layout, Build & Test, Control Towers, Operating Modes, etc.).
+
+Sections to rewrite:
+- **## Identity** -- New agent name, title, role description. Write 2-3 sentences describing who this agent is and what they do.
+- **## Operating Principles** -- Replace with the new principles. Use the same numbered-list format.
+- **## Communication Rules** -- Adapt the autonomy model to the archetype. An executive-operator has broad autonomy; a compliance-officer escalates more. Rewrite the "sends autonomously" and "escalates" sections with the new agent's name and appropriate boundaries. Keep the Immediate Acknowledgement Rule, Document Sharing, and Logging subsections but replace the agent name throughout.
+- **## People (Key Leadership)** -- Update the "That's you" line to the new agent. Keep other people entries unless the user indicated changes.
+
+Replace ALL instances of the old agent's first name with the new agent's first name throughout the entire CLAUDE.md file. Be thorough -- check every section header, bullet point, and inline reference.
+
+Do NOT modify these sections (keep them exactly as they are, except for agent name substitution):
+- Repository Layout, Key Config Files, Brand Assets, PDF Generation, Visual Media Generation
+- Source Repositories, Hiring Management (unless archetype is not executive-operator, in which case trim or adapt)
+- Operational Infrastructure, Control Towers 1-12
+- Build & Test, Code Standards, Three Operating Modes, Parallel Execution
+- Agent Development, Workflow Development
+
+### Sub-agent 3: Update config files
+
+**Instruction to sub-agent:** Update these configuration files:
+
+1. **config/environment.yaml** -- Replace agent name, email, phone, directory paths, and scheduling references. Update timezone.
+
+2. **config/contacts.yaml** -- Update the principal's entry to match the new principal details. Keep other contacts unless the archetype suggests they are irrelevant. Add the new agent as a contact entry.
+
+3. **config/priorities.yaml** -- Generate 4-6 strategic priorities appropriate for the role archetype:
+   - executive-operator: operational excellence, communication cadence, strategic execution, hiring, institutional memory
+   - technical-leader: platform architecture, engineering quality, technical debt, R&D pipeline, delivery velocity
+   - commercial-leader: pipeline growth, partnership development, investor relations, market positioning, commercial operations
+   - compliance-officer: regulatory submissions, licence maintenance, policy framework, audit readiness, cross-jurisdiction compliance
+   - product-leader: product roadmap, user research, feature delivery, product-market fit, design system
+   - operations-leader: process automation, operational efficiency, fund operations, organisational design, vendor management
+
+### Sub-agent 4: Update package.json and scripts
+
+**Instruction to sub-agent:**
+
+1. **package.json** -- Update the `name` field to `maestro` (or keep current if already correct). Update `description` to reflect the new agent's role (e.g., "Autonomous AI Chief Scientist for Adaptic.ai").
+
+2. **Shell scripts** -- Search all files in `scripts/` for references to the old agent name (case-insensitive) and replace with the new agent name. Specifically target:
+   - Variable names like `SOPHIE_AI_DIR` -> `{UPPER_FIRSTNAME}_AI_DIR`
+   - Path references like `/Users/sophie/sophie-ai` -> `/Users/{lowercase-firstname}/{repoSlug}`
+   - LaunchD labels like `ai.adaptic.sophie-` -> `ai.adaptic.{lowercase-firstname}-`
+
+3. **LaunchD plists** in `scripts/local-triggers/plists/` -- Update labels and paths in all `.plist` files.
+
+### Sub-agent 5: Update agent definitions
+
+**Instruction to sub-agent:**
+
+1. **Rename the core agent directory**: `agents/sophie-chief-of-staff` -> `agents/{lowercase-firstname}-{role-slug}` (e.g., `agents/jacob-chief-ai-scientist`). Derive the role slug from the title by lowercasing and hyphenating.
+
+2. **Rewrite the core agent's agent.md**: Update the name, title, mandate, and responsibilities to match the new agent identity.
+
+3. **Review all 31 agent directories** in `agents/`. For each:
+   - If the agent is generic infrastructure (inbound-dispatcher, session-spawner, workflow-automation, browser-operator, desktop-operator, slack-operator, gmail-operator, whatsapp-operator, calendar-ops, decision-log, communications, pmo-execution): Keep it, but replace any references to the old agent name in its agent.md.
+   - If the agent is role-specific to the old identity and relevant to the new role: Adapt it (e.g., ceo-briefing might become cto-briefing for a technical-leader).
+   - If the agent is role-specific and NOT relevant: Leave a note in the file that it needs review, but do not delete it.
+
+### Sub-agent 6: Update triggers and workflows
+
+**Instruction to sub-agent:**
+
+1. **Trigger prompts** in `schedules/triggers/` -- Read each `.md` file and replace all references to the old agent name with the new agent name. Adapt the trigger content where the old agent's role is referenced (e.g., "Sophie's morning brief" -> "{firstName}'s morning brief").
+
+2. **Workflow configs** in `workflows/` -- Update any agent name references.
+
+3. Keep the cadence structure intact (morning brief, midday sweep, evening wrap, backlog executor, etc.) -- these are generic patterns that work for any agent.
+
+### Sub-agent 7: Update README and miscellaneous
+
+**Instruction to sub-agent:**
+
+1. **README.md** -- Rewrite the repository README to reflect the new agent's identity. Keep the structure but update the agent name, role description, and any old-agent-specific language.
+
+2. **Any other files** that reference the old agent by name in `docs/`, `teams/`, or root-level markdown files. Do a thorough search and replace.
+
+## Phase 3: Machine Configuration
+
+After identity rewriting completes, offer to configure the Mac mini for headless operation:
+
+```
+Identity configuration complete. Would you like to configure the Mac mini now?
+
+This will:
+  1. Enable auto-login (no password on reboot)
+  2. Disable sleep/standby/screen saver
+  3. Configure Parsec for remote desktop access
+  4. Set up Slack with CDP for huddle automation
+  5. Install virtual audio (BlackHole) for voice
+  6. Configure all boot-time services
+
+Run macOS configuration? (yes/no)
+```
+
+If yes, run:
+```bash
+sudo ./scripts/setup/configure-macos.sh
+```
+
+Then run the machine setup:
+```bash
+npm run init-agent
+```
+
+## Phase 4: Third-Party Service Configuration
+
+Guide the user through setting up external integrations. Present this as a checklist — some steps can be automated, others require manual action.
+
+### Classification of Setup Steps
+
+**Automated (the wizard does it):**
+- Twilio WhatsApp sandbox configuration (if TWILIO_ACCOUNT_SID is in .env)
+- Cloudflare tunnel creation (via `cloudflared` CLI if installed)
+- ElevenLabs voice clone setup (via API if ELEVENLABS_API_KEY is in .env)
+- Railway service deployment (via `railway` CLI if installed)
+
+**Guided (requires human action, wizard walks them through):**
+- Slack app creation and token generation
+- Gmail app password generation
+- Twilio phone number purchase
+- Parsec account login (first time only)
+
+### Step 1: Slack App Setup
+
+```
+Let's set up Slack integration.
+
+IMPORTANT: You can reuse an existing Slack app across multiple agents in the
+same workspace. Each agent needs its own bot token and user token, but they
+can share the same app configuration.
+
+If you already have a Maestro Slack app configured:
+  → Just paste the bot token (xoxb-...) and user token (xoxp-...) below.
+
+If you need to create a new Slack app:
+  1. Go to https://api.slack.com/apps → "Create New App" → "From scratch"
+  2. Name it "Maestro - {AgentFirstName}" (or reuse existing "Maestro" app)
+  3. Under "OAuth & Permissions", add these BOT scopes:
+     - chat:write, chat:write.customize
+     - channels:read, channels:history
+     - groups:read, groups:history
+     - im:read, im:history, im:write
+     - users:read, users:read.email
+     - reactions:read, reactions:write
+     - files:read, files:write
+  4. Add these USER scopes:
+     - channels:history, groups:history, im:history
+     - search:read
+  5. Install the app to your workspace
+  6. Copy the Bot User OAuth Token (xoxb-...)
+  7. Copy the User OAuth Token (xoxp-...)
+  
+  For Slack Events API (real-time messages instead of polling):
+  8. Under "Event Subscriptions", enable events
+  9. Set Request URL to your Cloudflare tunnel URL + /slack/events
+  10. Subscribe to bot events: message.channels, message.groups, message.im,
+      app_mention, reaction_added
+  11. Copy the Signing Secret from "Basic Information"
+
+Paste your tokens when ready (or type "skip" to configure later):
+  Bot token (xoxb-...):
+  User token (xoxp-...):
+  Signing secret (optional):
+```
+
+Write the tokens to `.env` using the Edit tool.
+
+**Answer to Slack app reusability question:** A single Slack app CAN serve multiple agents in the same workspace. The app defines scopes and event subscriptions; each workspace installation generates unique bot/user tokens. However, if you want separate bot identities (different names/avatars per agent), create one app per agent. The Event Subscriptions URL can only point to one server per app, so if multiple agents need real-time events, either use separate apps or a shared event router.
+
+### Step 2: Gmail Setup
+
+```
+Let's set up Gmail.
+
+Each agent needs its own Gmail account and app password.
+(The poller connects via IMAP — not OAuth — so app passwords are simpler.)
+
+  1. Log into the agent's Google account ({agent.email})
+  2. Enable 2-Factor Authentication if not already enabled
+  3. Go to https://myaccount.google.com/apppasswords
+  4. Generate an app password for "Mail" on "Mac"
+  5. Copy the 16-character password (no spaces)
+
+Paste the Gmail app password:
+```
+
+Write to `.env` as `GMAIL_APP_PASSWORD`.
+
+If the agent also monitors the principal's inbox:
+```
+Does {principalName} want this agent to monitor their inbox too?
+If yes, generate an app password for {principalEmail} using the same steps above.
+
+Paste the secondary Gmail app password (or "skip"):
+```
+
+Write to `.env` as `SECONDARY_GMAIL_APP_PASSWORD`.
+
+### Step 3: Twilio Setup (Optional)
+
+```
+Does this agent need phone/SMS/WhatsApp capabilities? (yes/no)
+```
+
+If yes:
+```
+Twilio setup:
+  1. Sign up at https://www.twilio.com/ (or use existing account)
+  2. From the Console dashboard, copy:
+     - Account SID (starts with AC...)
+     - Auth Token
+  3. Buy a phone number: Console → Phone Numbers → Buy a Number
+     - Select a number with SMS + Voice capabilities
+     - Copy the phone number (E.164 format, e.g., +15551234567)
+     - Copy the Phone SID (starts with PN...)
+
+Paste your Twilio credentials:
+  Account SID:
+  Auth Token:
+  Phone Number:
+  Phone SID:
+```
+
+Write all to `.env`. Then offer to auto-configure:
+```
+Would you like me to configure the Twilio WhatsApp sandbox automatically? (yes/no)
+```
+
+If yes, run: `bash scripts/configure-whatsapp-sandbox.sh`
+
+### Step 4: Cloudflare Tunnel (Optional)
+
+```
+Does this agent need a public URL for webhooks? (yes/no)
+(Required for: Slack Events API, Twilio voice callbacks, WhatsApp webhooks)
+```
+
+If yes:
+```
+Cloudflare tunnel options:
+
+  1. Quick tunnel (free, URL changes on restart):
+     cloudflared tunnel --url http://localhost:3100
+
+  2. Named tunnel (free, persistent URL — recommended):
+     cloudflared tunnel create {agent-name}
+     cloudflared tunnel route dns {agent-name} {agent-name}.yourdomain.com
+
+  3. Skip (configure manually later)
+
+Which option? (1/2/3)
+```
+
+For option 1, run `cloudflared tunnel --url http://localhost:3100` and capture the URL.
+For option 2, guide through the DNS setup steps.
+
+### Step 5: Voice Integration (Optional)
+
+```
+Does this agent need voice capabilities (phone calls, huddle participation)? (yes/no)
+```
+
+If yes:
+```
+Voice setup requires:
+  1. ElevenLabs API key (for text-to-speech)
+     → Sign up at https://elevenlabs.io/
+     → Copy your API key from Profile → API Keys
+  
+  2. Deepgram API key (for speech-to-text)
+     → Sign up at https://deepgram.com/
+     → Copy your API key from Console → API Keys
+
+  3. BlackHole virtual audio (for huddle participation)
+     → This will be installed by the audio setup script
+
+Paste API keys:
+  ElevenLabs API key:
+  Deepgram API key:
+```
+
+Write to `.env`. Then run: `bash scripts/huddle/setup-audio.sh`
+
+### Step 6: Additional Services (Optional)
+
+```
+Any additional services to configure?
+  1. OpenAI API key (supplemental model access)
+  2. Gemini API key (media generation)
+  3. Greptile API key (code search)
+  4. Done — skip remaining
+
+Which? (comma-separated numbers, or "done")
+```
+
+For each, prompt for the API key and write to `.env`.
+
+### Step 7: Service Verification
+
+After all services are configured, run verification:
+
+```bash
+npm run healthcheck
+```
+
+Report the results and flag any services that aren't configured.
+
+## Phase 5: Final Verification
+
+After ALL phases are complete, run these verification steps:
+
+### Step 1: Grep for old agent references
+
+Search critical files for any remaining references to the old agent's first name (case-insensitive). Check:
+- CLAUDE.md
+- config/agent.ts
+- config/environment.yaml
+- config/contacts.yaml
+- config/priorities.yaml
+- package.json
+- All files in schedules/triggers/
+- All agent.md files in agents/
+
+Report any stragglers and fix them.
+
+### Step 2: Validate config/agent.ts
+
+Read `config/agent.ts` and verify it has valid TypeScript syntax and all fields are populated with the new values.
+
+### Step 3: Summary
+
+Print a completion summary:
+
+```
+Maestro initialization complete.
+
+  Agent:       {fullName}, {title}
+  Archetype:   {archetype}
+  Company:     {company}
+  Principal:   {principalName}
+  Machine:     {machineName}
+
+  Files modified:
+    - config/agent.ts (central identity config)
+    - CLAUDE.md (system prompt and operating instructions)
+    - config/environment.yaml
+    - config/contacts.yaml
+    - config/priorities.yaml
+    - package.json
+    - agents/{agent-slug}/agent.md (+ 30 other agent definitions)
+    - schedules/triggers/ (13 trigger prompts)
+    - README.md
+
+  Next steps:
+    1. Review the changes: git diff
+    2. Run machine setup: npm run init-agent
+    3. Fill in API keys in .env
+    4. Verify daemons: launchctl list | grep adaptic
+    5. Run health check: npm run healthcheck
+    6. Commit when satisfied: git add -A && git commit -m "Initialize {fullName} as {title}"
+```
+
+## Guidelines for the Wizard Conversation
+
+- Be warm and professional. This is a setup experience, not an interrogation.
+- Offer sensible defaults wherever possible. If the user says "defaults" for any field, use the archetype-appropriate default.
+- If the user provides all information upfront (e.g., as arguments to the command), skip the conversational steps and go straight to confirmation.
+- Always confirm before executing. The changes are extensive and hard to undo.
+- When spawning sub-agents, give each one the COMPLETE set of gathered values so they can work independently.
+- Sub-agents MUST run in parallel (use `run_in_background: true`) -- do not run them sequentially.
+- After all sub-agents finish, do the verification grep yourself (do not delegate it).
+
+## Error Handling
+
+- If a sub-agent fails, report which one failed and what went wrong. Offer to retry just that sub-agent.
+- If the user wants to abort mid-wizard, confirm and exit cleanly.
+- If config/agent.ts cannot be read, warn that the repo may not be properly set up and suggest running `npm install` first.