@arthai/agents 1.0.0

package/skills/consulting/SKILL.md

@@ -0,0 +1,282 @@
+---
+name: consulting
+description: "Run a full AI consulting engagement. Usage: /consulting <client-name> [--phase discovery|assess|propose|design|deliver|track] [-- <brief>]"
+user-invocable: true
+arguments: "<client-name> [--phase] [-- brief]"
+---
+
+# AI Consulting Engagement Orchestrator
+
+Run structured AI consulting engagements for SMB and mid-market clients. This skill orchestrates the full engagement lifecycle — from initial discovery through delivery and tracking — coordinating all sub-skills and maintaining engagement state.
+
+## Steps
+
+### Step 1: Parse Arguments and Load Engagement State
+
+Parse the command arguments:
+- `<client-name>` (required): The client identifier, used for directory naming and file lookups
+- `--phase <phase>` (optional): Jump to a specific phase. One of: `discovery`, `assess`, `propose`, `design`, `deliver`, `track`
+- `-- <brief>` (optional): Free-text brief describing the engagement context or specific request
+
+Check if an engagement already exists for this client:
+
+```bash
+# Check for existing engagement
+ls consulting-toolkit/clients/{client-name}/engagement.json 2>/dev/null
+```
+
+If `engagement.json` exists, read it and resume from the current phase. If it does not exist, initialize a new engagement.
+
+### Step 2: Initialize Client Workspace
+
+If this is a new engagement, create the client directory structure:
+
+```bash
+mkdir -p consulting-toolkit/clients/{client-name}
+```
+
+Create `consulting-toolkit/clients/{client-name}/engagement.json` with this schema:
+
+```json
+{
+  "client": "{client-name}",
+  "engagement_id": "{client-name}-{YYYYMMDD}",
+  "created": "YYYY-MM-DDTHH:MM:SSZ",
+  "updated": "YYYY-MM-DDTHH:MM:SSZ",
+  "status": "active",
+  "current_phase": "discovery",
+  "phases": {
+    "discovery": { "status": "not_started", "started": null, "completed": null, "deliverables": [] },
+    "assess": { "status": "not_started", "started": null, "completed": null, "deliverables": [] },
+    "propose": { "status": "not_started", "started": null, "completed": null, "deliverables": [] },
+    "design": { "status": "not_started", "started": null, "completed": null, "deliverables": [] },
+    "deliver": { "status": "not_started", "started": null, "completed": null, "deliverables": [] },
+    "track": { "status": "not_started", "started": null, "completed": null, "deliverables": [] }
+  },
+  "brief": "{brief or null}",
+  "contacts": [],
+  "decisions": [],
+  "risks": [],
+  "value_captured": {
+    "total_projected": 0,
+    "total_actual": 0,
+    "by_initiative": []
+  }
+}
+```
+
+Create `consulting-toolkit/clients/{client-name}/profile.md` with this stub:
+
+```markdown
+# Client Profile: {Client Name}
+
+> Generated by AI Consulting Toolkit | v1.0 | {date}
+
+## Company Overview
+- **Company:** {client-name}
+- **Industry:** [TBD]
+- **Size:** [employees]
+- **Revenue:** [annual revenue range]
+- **Location:** [HQ location]
+
+## Key Contacts
+| Name | Role | Email | Decision Authority |
+|------|------|-------|--------------------|
+|      |      |       |                    |
+
+## Business Context
+[To be completed during discovery phase]
+
+## AI Maturity Score
+[To be completed during assessment phase]
+- Strategy: _/5
+- Data: _/5
+- Technology: _/5
+- People: _/5
+- Process: _/5
+- **Total: _/25**
+
+## Current Technology Stack
+[To be completed during discovery phase]
+
+## Pain Points & Priorities
+[To be completed during discovery phase]
+
+## Engagement History
+| Date | Phase | Activity | Outcome |
+|------|-------|----------|---------|
+|      |       |          |         |
+```
+
+### Step 3: Route to Active Phase
+
+Based on the current phase (from `engagement.json` or `--phase` argument), execute the appropriate skill:
+
+**Phase: `discovery`**
+```
+Run /client-discovery {client-name} -- {brief}
+```
+Activities:
+- Structured interview guide generation
+- Business model canvas completion
+- Technology stack assessment
+- Data landscape mapping
+- Stakeholder identification
+- Pain point prioritization
+
+Output: Updated `profile.md`, interview notes, data inventory
+
+**Phase: `assess`**
+```
+Run /opportunity-map {client-name}
+```
+Activities:
+- AI Maturity Model assessment (Deloitte-adapted)
+- MECE problem decomposition of key challenges
+- Jobs-to-be-Done AI opportunity analysis
+- Porter's Five Forces AI impact assessment
+- BCG Priority Matrix for AI initiatives
+- Market research on industry AI adoption
+
+Output: Maturity scorecard, opportunity register, priority matrix
+
+**Phase: `propose`**
+```
+Run /pitch-generator {client-name}
+Run /roi-calculator {client-name}
+```
+Activities:
+- Solution options development (2-3 alternatives)
+- ROI model for each recommended initiative
+- Risk assessment and mitigation plan
+- Pricing and engagement structure
+- Proposal document generation
+
+Output: Proposal document, ROI models, risk register
+
+**Phase: `design`**
+```
+Run /solution-architect {client-name}
+```
+Activities:
+- Technical architecture design
+- Integration mapping with existing systems
+- Data pipeline architecture
+- Build vs Buy analysis
+- Implementation sprint plan
+- Technology vendor evaluation
+
+Output: Architecture document, sprint plan, vendor comparison
+
+**Phase: `deliver`**
+```
+Run /deliverable-builder {client-name}
+```
+Activities:
+- Sprint execution tracking
+- Deliverable assembly and review
+- Client presentation preparation
+- Knowledge transfer documentation
+- Change management support
+
+Output: Final deliverables package, handoff documentation
+
+**Phase: `track`**
+```
+Run /engagement-tracker {client-name}
+```
+Activities:
+- Value realization tracking
+- Sprint scorecard updates
+- RAG status reporting
+- Phase transition readiness assessment
+- Engagement health monitoring
+
+Output: Status reports, value tracker updates, phase gate reviews
+
+### Step 4: Phase Transition Protocol
+
+When a phase is complete, follow this transition protocol:
+
+1. **Verify phase completion criteria:**
+   - All required deliverables produced
+   - Client review completed (or flagged for review)
+   - Decision log updated with phase decisions
+   - Risks identified and logged
+
+2. **Update engagement.json:**
+   - Set current phase status to `"completed"`
+   - Set completion timestamp
+   - Record deliverables produced
+   - Advance `current_phase` to next phase
+
+3. **Generate phase transition summary:**
+   ```markdown
+   ## Phase Transition: {previous_phase} -> {next_phase}
+
+   ### Completed
+   - [List of deliverables produced]
+
+   ### Key Decisions
+   - [Decision 1]: [Rationale]
+
+   ### Risks Carried Forward
+   - [Risk 1]: [Mitigation]
+
+   ### Next Phase Objectives
+   - [Objective 1]
+   - [Objective 2]
+   ```
+
+4. **Confirm with user** before advancing to the next phase. Never auto-advance without explicit approval.
+
+### Step 5: Engagement Status Report
+
+At any point, the user can request a status report. Generate it from `engagement.json`:
+
+```markdown
+# Engagement Status: {client-name}
+> {engagement_id} | Updated: {date}
+
+## Phase Progress
+| Phase     | Status       | Started    | Completed  | Deliverables |
+|-----------|-------------|------------|------------|--------------|
+| Discovery | [GREEN/AMBER/RED] | {date} | {date}     | {count}      |
+| Assess    | [status]    | {date}     | {date}     | {count}      |
+| Propose   | [status]    | {date}     | {date}     | {count}      |
+| Design    | [status]    | {date}     | {date}     | {count}      |
+| Deliver   | [status]    | {date}     | {date}     | {count}      |
+| Track     | [status]    | {date}     | {date}     | {count}      |
+
+## Value Summary
+- Projected Annual Value: ${total_projected}
+- Actual Value Captured: ${total_actual}
+- Realization Rate: {percentage}%
+
+## Open Risks ({count})
+{risk_list}
+
+## Recent Decisions ({count})
+{decision_list}
+
+## Next Actions
+{action_items}
+```
+
+### Step 6: Multi-Engagement Management
+
+When no client name is provided, list all active engagements:
+
+```bash
+ls consulting-toolkit/clients/*/engagement.json 2>/dev/null
+```
+
+Display a dashboard:
+
+```markdown
+# Active Engagements
+
+| Client | Phase | Status | Last Updated | Value Projected |
+|--------|-------|--------|--------------|-----------------|
+| ...    | ...   | ...    | ...          | ...             |
+```

package/skills/continue/SKILL.md

@@ -0,0 +1,174 @@
+---
+name: continue
+description: "Resume previous session — summarize what was done, what's pending, and suggest next steps. Usage: /continue"
+user-invocable: true
+arguments: ""
+---
+
+# Continue Skill — Session Continuity Intelligence
+
+Parses the previous session's transcript to build a comprehensive "what was I doing" briefing.
+Writes a structured summary and presents actionable next steps.
+
+**Key principle: Read the transcript, not just git state.** Git shows *what* changed, but the
+transcript shows *why*, what was being debugged, what decisions were made, and what's still pending.
+
+## How It Works
+
+1. Find the previous session's transcript JSONL file
+2. Spawn a Haiku agent to parse it and extract structured signals
+3. Write summary to `.claude/session-state/latest.md` in the project
+4. Present the briefing with actionable next steps
+
+## Execution Steps
+
+### 1. Find Previous Session Transcript
+
+Claude Code stores session transcripts as JSONL files in a project-specific directory
+under `~/.claude/projects/`. The directory name is the project path with `/` replaced by `-`.
+
+Derive the transcript directory:
+
+```bash
+# Convert project dir to Claude's transcript directory name
+# e.g., /Users/foo/myproject → -Users-foo-myproject
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+TRANSCRIPT_DIR_NAME=$(echo "$PROJECT_DIR" | sed 's|/|-|g')
+TRANSCRIPT_DIR="$HOME/.claude/projects/${TRANSCRIPT_DIR_NAME}"
+
+# List JSONL files by modification time (newest first)
+ls -t "$TRANSCRIPT_DIR"/*.jsonl 2>/dev/null | head -5
+```
+
+**Selection logic:**
+- If the newest file was modified < 2 minutes ago, it's the current session — use the 2nd file
+- If the newest file was modified > 2 minutes ago, use it (we're in a fresh session, it's the previous one)
+- If no JSONL files exist, report "No previous session found" and stop
+
+Store the selected file path as `PREV_TRANSCRIPT`.
+
+### 2. Spawn Haiku Agent for Transcript Parsing
+
+Spawn an `explore-light` agent (Haiku) with this prompt:
+
+```
+Parse this session transcript and extract a structured summary.
+
+Transcript file: {PREV_TRANSCRIPT}
+
+IMPORTANT: The file may be very large. Use this strategy:
+1. First, run: wc -l {PREV_TRANSCRIPT}  (to know total size)
+2. Read the FIRST 100 lines (session start — initial intent)
+3. Read the LAST 300 lines (most recent work — pending items)
+4. If the file has > 1000 lines, also sample the MIDDLE (line count/2, read 100 lines)
+5. Use Grep to search for these high-signal patterns:
+   - "role":"human" entries (user messages — understand intent)
+   - "tool_name":"Edit" or "tool_name":"Write" (files changed)
+   - "tool_name":"Bash".*git (git operations)
+   - "error" or "Error" or "failed" (problems encountered)
+   - "TODO" or "next step" or "pending" (explicit pending items)
+   - "PR" or "pull request" (PR activity)
+   - "commit" (commits made)
+
+Extract and return this EXACT structure (use these headers):
+
+## Session Date
+[Date/time of the session based on timestamps in transcript]
+
+## What Was Done
+- [Bullet list of completed tasks/actions, in chronological order]
+- [Include: files edited, PRs created/merged, bugs fixed, features added]
+- [Include: key decisions made and WHY]
+
+## Key Decisions
+- [Any architectural or design decisions that were made]
+- [Include the reasoning if available]
+
+## Problems Encountered
+- [Errors, bugs, failed attempts]
+- [How they were resolved (if they were)]
+
+## Files Modified
+- [List of files that were edited/written during the session]
+
+## Pending / Not Finished
+- [Tasks that were discussed but not completed]
+- [Things the user said they'd do next]
+- [Any "TODO" items mentioned]
+- [If the session ended mid-task, describe what was in progress]
+
+## Suggested Next Steps
+- [Based on pending items, what should be done first]
+- [Prioritize: unfinished work > follow-ups > new tasks]
+
+Keep each section concise (3-5 bullets max). If a section has no items, write "None."
+```
+
+### 3. Write Session State
+
+Take the Haiku agent's output and write it to:
+```
+{PROJECT_DIR}/.claude/session-state/latest.md
+```
+
+Prepend metadata:
+```markdown
+---
+source_transcript: {PREV_TRANSCRIPT filename only}
+generated_at: {ISO timestamp}
+---
+```
+
+Also archive to history (keep last 5):
+```bash
+# Create history dir if needed
+mkdir -p .claude/session-state/history
+
+# Archive current latest (if it exists)
+if [ -f .claude/session-state/latest.md ]; then
+  cp .claude/session-state/latest.md ".claude/session-state/history/$(date +%Y-%m-%d-%H%M).md"
+fi
+
+# Clean old history (keep last 5)
+ls -t .claude/session-state/history/*.md 2>/dev/null | tail -n +6 | xargs rm -f 2>/dev/null
+```
+
+### 4. Present the Briefing
+
+Show the user the summary in a clean format:
+
+```
+**Previous Session Summary**
+
+{Content from the Haiku agent's parsed output}
+
+---
+Type a task to continue, or run `/onboard` for full project status.
+```
+
+### 5. Route Based on User Response
+
+After presenting:
+- If user picks a pending item -> start working on it directly
+- If user says "continue" or picks the first suggested next step -> begin that work
+- If user asks something else -> hand off to normal triage
+- If user says "/onboard" -> route to onboard skill for full project context
+
+## Edge Cases
+
+- **Very short previous session** (< 20 lines): Just show the user messages and any files touched. Don't over-analyze.
+- **Very long previous session** (> 5000 lines): The sampling strategy (first 100 + last 300 + middle 100) handles this. Focus on recent activity.
+- **No JSONL files**: Report "No previous session transcript found. Run `/onboard` for project status."
+- **Multiple rapid sessions**: If the 2nd newest file is also < 5 min old (rapid restarts), check the 3rd file.
+- **Transcript has no useful signals**: Report "Previous session was brief — no significant work detected."
+- **Current session already has context** (user is continuing after a compact): Check if the conversation already has substantial context. If so, skip transcript parsing and just read the session-state file if it exists.
+
+## Integration with Onboard
+
+`/continue` complements `/onboard`:
+- `/onboard` = project-level context (git, PRs, issues, plans, environment health)
+- `/continue` = session-level context (what was discussed, decisions made, pending work)
+
+For the richest briefing, use both: `/continue` first (personal context), then `/onboard` (project context).
+
+The `session-bootstrap.sh` hook auto-detects if a recent session-state exists and hints at `/continue`.