@adaptic/maestro 1.1.0 → 1.1.1

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

@@ -1,17 +1,88 @@
 # /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.
+You are running the Maestro initialization wizard. This is the single most important command in the system -- it configures this repository as a fully operational 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.
+This repo was created by `npx @adaptic/maestro create` and contains the Maestro framework. Your job is to bootstrap the system, give it an identity (a name, a role, responsibilities, and an operating style), configure external services, and bring it online. The wizard handles everything -- the user should not need to run any other setup commands.
 
 ## 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 0: System Bootstrap
+
+Before gathering identity information, ensure the system is ready. Run these checks silently and only report issues:
+
+### Step 1: Prerequisites
+
+Check that required tools are installed. Report any missing ones and offer to install them:
+
+```bash
+# Check each — report OK or missing
+node --version          # Required: >= 20.0.0
+npm --version           # Required
+claude --version        # Required for triggers
+jq --version            # Required for hooks
+```
+
+If Node.js or npm are missing, stop and tell the user to install them. If Claude CLI or jq are missing, warn but continue.
+
+### Step 2: Install dependencies
+
+```bash
+npm install
+```
+
+### Step 3: Create directories
+
+Ensure all operational directories exist (these should already exist from `maestro create`, but init-maestro may be re-run):
+
+```bash
+# Create any missing state/log/memory directories
+for dir in state/inbox/{slack,gmail,calendar,sms,whatsapp,internal,attachments,processed} \
+           state/{queues,dashboards,polling,handoffs,huddle,indexes,rag,sessions} \
+           state/{slack-responded,slack-thread-tracker,tmp} \
+           state/locks/outbound state/triggers/priority \
+           knowledge/{decisions,decisions/archive,entities,memory,sources,syntheses} \
+           memory/{interactions,indexes,templates} \
+           memory/profiles/{users,channels} \
+           memory/precedents/market-signals \
+           outputs/{briefs,drafts,memos,research,tasks,sessions} \
+           logs/{polling,workflows,sessions,audit,security,evolution,huddle,daemon} \
+           logs/{infra,monitor,phone,sms,whatsapp,email} \
+           self-optimization/scenarios tests; do
+  mkdir -p "$dir"
+done
+```
+
+### Step 4: Global Claude Code settings
+
+Install the global Claude Code settings to `~/.claude/settings.json`. Read the current content first — if it already exists and has substantive customisations, ask the user before overwriting. If it doesn't exist or is a default install, write it silently.
+
+The template is in `scripts/setup/init-agent.sh` (the heredoc in Step 4 of that script). Extract and write it.
+
+### Step 5: Environment file
+
+If `.env` doesn't exist, copy from `.env.example`:
+
+```bash
+cp .env.example .env
+```
+
+Tell the user: "I've created a .env file from the template. We'll fill in API keys during service configuration later."
+
+### Step 6: Report
+
+Only print a summary if there were issues. If everything passed silently, just say:
+
+```
+System bootstrap complete. Let's set up your agent.
+```
+
+Then proceed to Phase 1.
+
 ## 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.
@@ -162,10 +233,10 @@ 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:
+Once the user confirms, deploy EIGHT 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...
+Deploying 8 parallel agents to rewrite the repository and generate role-specific tools. This will take a minute or two...
 ```
 
 ### Sub-agent 1: Update config/agent.ts
@@ -262,20 +333,92 @@ Do NOT modify these sections (keep them exactly as they are, except for agent na
 
 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.
 
+### Sub-agent 8: Generate agent-specific tools and capabilities
+
+**Instruction to sub-agent:**
+
+Generate role-specific tool definitions, skills, and integrations for this agent based on their archetype and responsibilities. The goal is to operationalise every responsibility with concrete, callable tools.
+
+1. **Read `lib/tool-definitions.js`** from the maestro package (`~/maestro/lib/tool-definitions.js`) to understand the base set of 27 generic tools already available to all agents.
+
+2. **Generate `lib/agent-tools.js`** — a file containing agent-specific tool definitions that EXTEND the base set. These are tools that only this role needs. Generate based on archetype:
+
+   - **executive-operator**: stakeholder_briefing, board_pack_generator, org_chart_query, founder_dependency_check, communication_quality_audit
+   - **technical-leader**: code_review_trigger, architecture_decision_record, deployment_status, test_coverage_report, dependency_audit, security_scan
+   - **commercial-leader**: deal_stage_update, investor_update_draft, partnership_score, revenue_forecast, competitive_analysis
+   - **compliance-officer**: regulatory_submission_status, licence_gap_check, compliance_calendar, audit_trail_query, policy_violation_scan, cross_jurisdiction_check
+   - **product-leader**: feature_prioritisation, user_feedback_search, roadmap_status, design_review_trigger, metrics_dashboard
+   - **operations-leader**: process_efficiency_report, vendor_management, capacity_planning, sla_compliance_check, cost_analysis
+
+   For each tool, generate a full Claude API tool schema (name, description, input_schema with properties and required fields).
+
+3. **Generate `lib/agent-executor.js`** — execution logic for each agent-specific tool. Follow the same pattern as maestro's action-executor: lookup tools use `claude --print` with MCP-backed prompts, write tools call local scripts.
+
+4. **Create agent-specific Claude Code skills** in `plugins/agent-skills/skills/`:
+   - Generate 3-5 skills based on the archetype's primary workflows
+   - Each skill is a `.md` file with clear triggering rules
+   - Example for compliance-officer: `regulatory-check.md`, `submission-tracker.md`, `audit-readiness.md`
+   - Example for technical-leader: `code-review.md`, `architecture-decision.md`, `deployment-check.md`
+
+5. **Create `plugins/agent-skills/plugin.json`** with the skill manifest.
+
+6. **Update the agent's CLAUDE.md** to document the generated tools and skills:
+   - Add a "## Agent-Specific Tools" section listing the generated tools
+   - Add a "## Skills" section listing the generated skills
+   - Include usage examples
+
+7. **Wire it all together** — update the agent's operational scripts to import both maestro base tools AND agent-specific tools:
+   ```js
+   // In any script needing tools:
+   import { getToolsForAccessLevel } from "~/maestro/lib/tool-definitions.js";
+   import { getAgentTools } from "./lib/agent-tools.js";
+   const tools = [...getToolsForAccessLevel(level), ...getAgentTools(level)];
+   ```
+
+The generated tools should be COMPREHENSIVE — every responsibility listed in Phase 1 should have at least one corresponding tool or skill that enables it. Think of tools as the agent's hands — without them, responsibilities are just words.
+
 ## Phase 3: Machine Configuration
 
-After identity rewriting completes, offer to configure the Mac mini for headless operation:
+After identity rewriting completes, generate and install the launchd plists (these need the agent name from Phase 1):
+
+### Step 1: Generate launchd plists
+
+```bash
+bash scripts/local-triggers/generate-plists.sh
+```
+
+This reads `config/agent.ts` to get the agent's first name and generates all 13 launchd plist files with correct labels and paths.
+
+### Step 2: Install launchd agents
+
+```bash
+LAUNCH_AGENTS_DIR="$HOME/Library/LaunchAgents"
+mkdir -p "$LAUNCH_AGENTS_DIR"
+for plist in scripts/local-triggers/plists/*.plist; do
+    PLIST_NAME=$(basename "$plist")
+    LABEL=$(basename "$plist" .plist)
+    DST="$LAUNCH_AGENTS_DIR/$PLIST_NAME"
+    launchctl unload "$DST" 2>/dev/null || true
+    cp "$plist" "$DST"
+    launchctl load "$DST"
+done
+```
+
+Report how many triggers were installed.
+
+### Step 3: macOS headless configuration (optional)
+
+Offer to configure the Mac mini for headless 24/7 operation:
 
 ```
-Identity configuration complete. Would you like to configure the Mac mini now?
+Would you like to configure the Mac mini for headless operation?
 
-This will:
+This will (requires sudo):
   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)
 ```
@@ -285,11 +428,6 @@ If yes, run:
 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.
@@ -493,7 +631,121 @@ npm run healthcheck
 
 Report the results and flag any services that aren't configured.
 
-## Phase 5: Final Verification
+## Phase 5: Generate Agent README
+
+Generate a comprehensive README.md for this agent's repository. This is NOT the Maestro framework README — it describes THIS specific agent.
+
+**Template structure:**
+
+```markdown
+# {repoName}
+
+**{fullName} — Autonomous {title} for {company}**
+
+Powered by [@adaptic/maestro](https://github.com/adapticai/maestro)
+
+---
+
+## Who is {firstName}?
+
+{firstName} {lastName} is an autonomous AI agent operating as {title} at {company}.
+{companyDescription}. {firstName} runs 24/7 on a dedicated Mac mini ({machineName}),
+using Claude Code as the reasoning engine and orchestrating 30+ specialist sub-agents.
+
+{firstName} reports to {principalFullName} ({principalTitle}) and operates with
+{describe autonomy level based on archetype}.
+
+## Capabilities
+
+{Generate 8-12 bullet points based on the archetype and responsibilities.
+For executive-operator: comms management, briefs, hiring, strategic execution, etc.
+For technical-leader: code review, architecture decisions, engineering health, etc.
+For compliance-officer: regulatory tracking, filing management, audit readiness, etc.
+Tailor to the specific responsibilities gathered in Phase 1.}
+
+## Architecture
+
+Built on the Maestro 5-tier agent architecture:
+
+- **Tier 0**: {firstName} (Executive Cortex) — core identity and reasoning
+- **Tier 1**: {Generate 4-5 domain controllers relevant to the archetype}
+- **Tier 2**: 31 specialist sub-agents
+- **Tier 3**: Slack, Gmail, WhatsApp, Browser, Calendar
+- **Tier 4**: Decision Log, Risk Register, Knowledge Base
+
+## Powered by Maestro
+
+This repo is an agent instance powered by the [@adaptic/maestro](https://www.npmjs.com/package/@adaptic/maestro) framework.
+
+Update framework:   npm update @adaptic/maestro && npm run upgrade
+Health check:       npm run healthcheck
+Emergency stop:     npm run emergency-stop
+
+## Operating Modes
+
+- **Reactive**: Polls Slack/Gmail/Calendar every 60s, classifies and dispatches
+- **Scheduled**: {morningBrief time} brief, midday sweep, {eveningWrap time} wrap, weekly cycles
+- **Proactive**: Backlog executor every 10 min, parallel agent execution
+
+## Commands
+
+| Command | Purpose |
+|---------|---------|
+| npm run daemon | Start the main orchestrator |
+| npm run healthcheck | Verify all subsystems |
+| npm run emergency-stop | Halt all operations |
+| npm run resume | Resume after emergency stop |
+| npm run upgrade | Pull latest Maestro framework |
+| claude "/init-maestro" | Reconfigure agent identity |
+
+## Communication Governance
+
+{Generate based on archetype:
+- executive-operator: broad autonomy with escalation for legal/financial commitments
+- technical-leader: autonomous on technical decisions, escalates on budget/headcount
+- compliance-officer: conservative, escalates on submissions and interpretations
+- etc.}
+
+---
+
+{fullName} | {title} | {company} — Powered by [Maestro](https://github.com/adapticai/maestro)
+```
+
+Write this README.md to the repo root, populated with all the gathered values.
+
+## Phase 6: Create GitHub Repository
+
+Ask the user whether they want to create a GitHub repo for this agent:
+
+```
+Would you like me to create a GitHub repository for this agent? (yes/no)
+```
+
+If yes:
+
+```
+Repository setup:
+  1. GitHub organization or username? (default: adapticai)
+  2. Repository name? (default: {repoName}, e.g., "jacob-ai")
+  3. Visibility: private (recommended) or public? (default: private)
+```
+
+Then run:
+```bash
+gh repo create {org}/{repoName} --private --description "{fullName} — Autonomous {title} for {company} (powered by Maestro)"
+```
+
+After creating the repo, set up git and push:
+```bash
+git remote add origin https://github.com/{org}/{repoName}.git
+git add -A
+git commit -m "Initialize {fullName} as {title} — powered by @adaptic/maestro"
+git push -u origin main
+```
+
+If the user declines, skip this step and remind them to set up a repo manually later.
+
+## Phase 7: Final Verification
 
 After ALL phases are complete, run these verification steps:
 
@@ -515,7 +767,15 @@ Report any stragglers and fix them.
 
 Read `config/agent.ts` and verify it has valid TypeScript syntax and all fields are populated with the new values.
 
-### Step 3: Summary
+### Step 3: Run health check
+
+```bash
+npm run healthcheck
+```
+
+Report the results.
+
+### Step 4: Summary
 
 Print a completion summary:
 
@@ -530,22 +790,25 @@ Maestro initialization complete.
 
   Files modified:
     - config/agent.ts (central identity config)
-    - CLAUDE.md (system prompt and operating instructions)
-    - config/environment.yaml
-    - config/contacts.yaml
-    - config/priorities.yaml
+    - CLAUDE.md (operating charter)
+    - README.md (agent-specific documentation)
+    - config/environment.yaml, contacts.yaml, 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}"
+  Infrastructure:
+    - {N} launchd triggers installed
+    - Global Claude Code settings configured
+    - .env file created {with/without API keys}
+
+  GitHub: https://github.com/{org}/{repoName} (if created)
+
+  Verify everything:
+    1. Review changes: git diff
+    2. Check daemons: launchctl list | grep adaptic
+    3. Health check: npm run healthcheck
+    4. Start daemon: npm run daemon
 ```
 
 ## Guidelines for the Wizard Conversation
@@ -562,4 +825,4 @@ Maestro initialization complete.
 
 - 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.
+- If config/agent.ts cannot be read, warn that the repo may not be properly set up and suggest running `npx @adaptic/maestro create` first.

package/.gitignore

@@ -0,0 +1,29 @@
+# Dependencies
+node_modules/
+
+# Environment
+.env
+.env.local
+.env.production
+!.env.example
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Runtime state (only exists in agent repos, not in the package)
+state/
+logs/
+memory/
+outputs/
+knowledge/
+
+# Editor
+*.swp
+*.swo
+*~
+.idea/
+.vscode/
+
+# npm
+*.tgz