@heyai-rules/pilo-masterkit 1.2.2 → 2.1.0

package/.agent/skills/ck/hooks/session-start.mjs

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+/**
+ * ck — Context Keeper v2
+ * session-start.mjs — inject compact project context on session start.
+ *
+ * Injects ~100 tokens (not ~2,500 like v1).
+ * SKILL.md is injected separately (still small at ~50 lines).
+ *
+ * Features:
+ * - Compact 5-line summary for registered projects
+ * - Unsaved session detection → "Last session wasn't saved. Run /ck:save."
+ * - Git activity since last session
+ * - Goal mismatch detection vs CLAUDE.md
+ * - Mini portfolio for unregistered directories
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { homedir } from 'os';
+import { spawnSync } from 'child_process';
+
+const CK_HOME         = resolve(homedir(), '.claude', 'ck');
+const PROJECTS_FILE   = resolve(CK_HOME, 'projects.json');
+const CURRENT_SESSION = resolve(CK_HOME, 'current-session.json');
+const SKILL_FILE      = resolve(homedir(), '.claude', 'skills', 'ck', 'SKILL.md');
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function readJson(p) {
+  try { return JSON.parse(readFileSync(p, 'utf8')); } catch { return null; }
+}
+
+function daysAgo(dateStr) {
+  if (!dateStr) return 'unknown';
+  const diff = Math.floor((Date.now() - new Date(dateStr)) / 86_400_000);
+  if (diff === 0) return 'today';
+  if (diff === 1) return '1 day ago';
+  return `${diff} days ago`;
+}
+
+function stalenessIcon(dateStr) {
+  if (!dateStr) return '○';
+  const diff = Math.floor((Date.now() - new Date(dateStr)) / 86_400_000);
+  return diff < 1 ? '●' : diff <= 5 ? '◐' : '○';
+}
+
+function gitLogSince(projectPath, sinceDate) {
+  if (!sinceDate || !existsSync(resolve(projectPath, '.git'))) return null;
+  try {
+    const result = spawnSync(
+      'git',
+      ['-C', projectPath, 'log', '--oneline', `--since=${sinceDate}`],
+      { timeout: 3000, stdio: 'pipe', encoding: 'utf8' },
+    );
+    if (result.status !== 0) return null;
+    const output = result.stdout.trim();
+    const commits = output.split('\n').filter(Boolean).length;
+    return commits > 0 ? `${commits} commit${commits !== 1 ? 's' : ''} since last session` : null;
+  } catch { return null; }
+}
+
+function extractClaudeMdGoal(projectPath) {
+  const p = resolve(projectPath, 'CLAUDE.md');
+  if (!existsSync(p)) return null;
+  try {
+    const md = readFileSync(p, 'utf8');
+    const m = md.match(/## Current Goal\n([\s\S]*?)(?=\n## |$)/);
+    return m ? m[1].trim().split('\n')[0].trim() : null;
+  } catch { return null; }
+}
+
+// ─── Session ID from stdin ────────────────────────────────────────────────────
+
+function readSessionId() {
+  try {
+    const raw = readFileSync(0, 'utf8');
+    return JSON.parse(raw).session_id || null;
+  } catch { return null; }
+}
+
+// ─── Main ─────────────────────────────────────────────────────────────────────
+
+function main() {
+  const cwd = process.env.PWD || process.cwd();
+  const sessionId = readSessionId();
+
+  // Load skill (always inject — now only ~50 lines)
+  const skill = existsSync(SKILL_FILE) ? readFileSync(SKILL_FILE, 'utf8') : '';
+
+  const projects = readJson(PROJECTS_FILE) || {};
+  const entry = projects[cwd];
+
+  // Read previous session BEFORE overwriting current-session.json
+  const prevSession = readJson(CURRENT_SESSION);
+
+  // Write current-session.json
+  try {
+    writeFileSync(CURRENT_SESSION, JSON.stringify({
+      sessionId,
+      projectPath: cwd,
+      projectName: entry?.name || null,
+      startedAt: new Date().toISOString(),
+    }, null, 2), 'utf8');
+  } catch { /* non-fatal */ }
+
+  const parts = [];
+  if (skill) parts.push(skill);
+
+  // ── REGISTERED PROJECT ────────────────────────────────────────────────────
+  if (entry?.contextDir) {
+    const contextFile = resolve(CK_HOME, 'contexts', entry.contextDir, 'context.json');
+    const context = readJson(contextFile);
+
+    if (context) {
+      const latest = context.sessions?.[context.sessions.length - 1] || {};
+      const sessionDate = latest.date || context.createdAt;
+      const sessionCount = context.sessions?.length || 0;
+      const displayName = context.displayName ?? context.name;
+
+      // ── Compact summary block (~100 tokens) ──────────────────────────────
+      const summaryLines = [
+        `ck: ${displayName} | ${daysAgo(sessionDate)} | ${sessionCount} session${sessionCount !== 1 ? 's' : ''}`,
+        `Goal: ${context.goal || '—'}`,
+        latest.leftOff ? `Left off: ${latest.leftOff.split('\n')[0]}` : null,
+        latest.nextSteps?.length ? `Next: ${latest.nextSteps.slice(0, 2).join(' · ')}` : null,
+      ].filter(Boolean);
+
+      // ── Unsaved session detection ─────────────────────────────────────────
+      if (prevSession?.sessionId && prevSession.sessionId !== sessionId) {
+        // Check if previous session ID exists in sessions array
+        const alreadySaved = context.sessions?.some(s => s.id === prevSession.sessionId);
+        if (!alreadySaved) {
+          summaryLines.push(`WARNING Last session wasn't saved — run /ck:save to capture it`);
+        }
+      }
+
+      // ── Git activity ──────────────────────────────────────────────────────
+      const gitLine = gitLogSince(cwd, sessionDate);
+      if (gitLine) summaryLines.push(`Git: ${gitLine}`);
+
+      // ── Goal mismatch detection ───────────────────────────────────────────
+      const claudeMdGoal = extractClaudeMdGoal(cwd);
+      if (claudeMdGoal && context.goal &&
+          claudeMdGoal.toLowerCase().trim() !== context.goal.toLowerCase().trim()) {
+        summaryLines.push(`WARNING Goal mismatch — ck: "${context.goal.slice(0, 40)}" · CLAUDE.md: "${claudeMdGoal.slice(0, 40)}"`);
+        summaryLines.push(`   Run /ck:save with updated goal to sync`);
+      }
+
+      parts.push([
+        `---`,
+        `## ck: ${displayName}`,
+        ``,
+        summaryLines.join('\n'),
+      ].join('\n'));
+
+      // Instruct Claude to display compact briefing at session start
+      parts.push([
+        `---`,
+        `## ck: SESSION START`,
+        ``,
+        `IMPORTANT: Display the following as your FIRST message, verbatim:`,
+        ``,
+        '```',
+        summaryLines.join('\n'),
+        '```',
+        ``,
+        `After the block, add one line: "Ready — what are we working on?"`,
+        `If you see WARNING lines above, mention them briefly after the block.`,
+      ].join('\n'));
+
+      return parts;
+    }
+  }
+
+  // ── NOT IN A REGISTERED PROJECT ────────────────────────────────────────────
+  const entries = Object.entries(projects);
+  if (entries.length === 0) return parts;
+
+  // Load and sort by most recent
+  const recent = entries
+    .map(([path, info]) => {
+      const ctx = readJson(resolve(CK_HOME, 'contexts', info.contextDir, 'context.json'));
+      const latest = ctx?.sessions?.[ctx.sessions.length - 1] || {};
+      return { name: info.name, path, lastDate: latest.date || '', summary: latest.summary || '—', ctx };
+    })
+    .sort((a, b) => (b.lastDate > a.lastDate ? 1 : -1))
+    .slice(0, 3);
+
+  const miniRows = recent.map(p => {
+    const icon = stalenessIcon(p.lastDate);
+    const when = daysAgo(p.lastDate);
+    const name = p.name.padEnd(16).slice(0, 16);
+    const whenStr = when.padEnd(12).slice(0, 12);
+    const summary = p.summary.slice(0, 32);
+    return `  ${name}  ${icon}  ${whenStr}  ${summary}`;
+  });
+
+  const miniStatus = [
+    `ck — recent projects:`,
+    `  ${'PROJECT'.padEnd(16)}  S  ${'LAST SEEN'.padEnd(12)}  LAST SESSION`,
+    `  ${'─'.repeat(68)}`,
+    ...miniRows,
+    ``,
+    `Run /ck:list · /ck:resume <name> · /ck:init to register this folder`,
+  ].join('\n');
+
+  parts.push([
+    `---`,
+    `## ck: SESSION START`,
+    ``,
+    `IMPORTANT: Display the following as your FIRST message, verbatim:`,
+    ``,
+    '```',
+    miniStatus,
+    '```',
+  ].join('\n'));
+
+  return parts;
+}
+
+const parts = main();
+if (parts.length > 0) {
+  console.log(JSON.stringify({ additionalContext: parts.join('\n\n---\n\n') }));
+}

package/.agent/skills/claude-api/SKILL.md

@@ -0,0 +1,337 @@
+---
+name: claude-api
+description: Anthropic Claude API patterns for Python and TypeScript. Covers Messages API, streaming, tool use, vision, extended thinking, batches, prompt caching, and Claude Agent SDK. Use when building applications with the Claude API or Anthropic SDKs.
+origin: ECC
+---
+
+# Claude API
+
+Build applications with the Anthropic Claude API and SDKs.
+
+## When to Activate
+
+- Building applications that call the Claude API
+- Code imports `anthropic` (Python) or `@anthropic-ai/sdk` (TypeScript)
+- User asks about Claude API patterns, tool use, streaming, or vision
+- Implementing agent workflows with Claude Agent SDK
+- Optimizing API costs, token usage, or latency
+
+## Model Selection
+
+| Model | ID | Best For |
+|-------|-----|----------|
+| Opus 4.1 | `claude-opus-4-1` | Complex reasoning, architecture, research |
+| Sonnet 4 | `claude-sonnet-4-0` | Balanced coding, most development tasks |
+| Haiku 3.5 | `claude-3-5-haiku-latest` | Fast responses, high-volume, cost-sensitive |
+
+Default to Sonnet 4 unless the task requires deep reasoning (Opus) or speed/cost optimization (Haiku). For production, prefer pinned snapshot IDs over aliases.
+
+## Python SDK
+
+### Installation
+
+```bash
+pip install anthropic
+```
+
+### Basic Message
+
+```python
+import anthropic
+
+client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY from env
+
+message = client.messages.create(
+    model="claude-sonnet-4-0",
+    max_tokens=1024,
+    messages=[
+        {"role": "user", "content": "Explain async/await in Python"}
+    ]
+)
+print(message.content[0].text)
+```
+
+### Streaming
+
+```python
+with client.messages.stream(
+    model="claude-sonnet-4-0",
+    max_tokens=1024,
+    messages=[{"role": "user", "content": "Write a haiku about coding"}]
+) as stream:
+    for text in stream.text_stream:
+        print(text, end="", flush=True)
+```
+
+### System Prompt
+
+```python
+message = client.messages.create(
+    model="claude-sonnet-4-0",
+    max_tokens=1024,
+    system="You are a senior Python developer. Be concise.",
+    messages=[{"role": "user", "content": "Review this function"}]
+)
+```
+
+## TypeScript SDK
+
+### Installation
+
+```bash
+npm install @anthropic-ai/sdk
+```
+
+### Basic Message
+
+```typescript
+import Anthropic from "@anthropic-ai/sdk";
+
+const client = new Anthropic(); // reads ANTHROPIC_API_KEY from env
+
+const message = await client.messages.create({
+  model: "claude-sonnet-4-0",
+  max_tokens: 1024,
+  messages: [
+    { role: "user", content: "Explain async/await in TypeScript" }
+  ],
+});
+console.log(message.content[0].text);
+```
+
+### Streaming
+
+```typescript
+const stream = client.messages.stream({
+  model: "claude-sonnet-4-0",
+  max_tokens: 1024,
+  messages: [{ role: "user", content: "Write a haiku" }],
+});
+
+for await (const event of stream) {
+  if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+    process.stdout.write(event.delta.text);
+  }
+}
+```
+
+## Tool Use
+
+Define tools and let Claude call them:
+
+```python
+tools = [
+    {
+        "name": "get_weather",
+        "description": "Get current weather for a location",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "location": {"type": "string", "description": "City name"},
+                "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
+            },
+            "required": ["location"]
+        }
+    }
+]
+
+message = client.messages.create(
+    model="claude-sonnet-4-0",
+    max_tokens=1024,
+    tools=tools,
+    messages=[{"role": "user", "content": "What's the weather in SF?"}]
+)
+
+# Handle tool use response
+for block in message.content:
+    if block.type == "tool_use":
+        # Execute the tool with block.input
+        result = get_weather(**block.input)
+        # Send result back
+        follow_up = client.messages.create(
+            model="claude-sonnet-4-0",
+            max_tokens=1024,
+            tools=tools,
+            messages=[
+                {"role": "user", "content": "What's the weather in SF?"},
+                {"role": "assistant", "content": message.content},
+                {"role": "user", "content": [
+                    {"type": "tool_result", "tool_use_id": block.id, "content": str(result)}
+                ]}
+            ]
+        )
+```
+
+## Vision
+
+Send images for analysis:
+
+```python
+import base64
+
+with open("diagram.png", "rb") as f:
+    image_data = base64.standard_b64encode(f.read()).decode("utf-8")
+
+message = client.messages.create(
+    model="claude-sonnet-4-0",
+    max_tokens=1024,
+    messages=[{
+        "role": "user",
+        "content": [
+            {"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": image_data}},
+            {"type": "text", "text": "Describe this diagram"}
+        ]
+    }]
+)
+```
+
+## Extended Thinking
+
+For complex reasoning tasks:
+
+```python
+message = client.messages.create(
+    model="claude-sonnet-4-0",
+    max_tokens=16000,
+    thinking={
+        "type": "enabled",
+        "budget_tokens": 10000
+    },
+    messages=[{"role": "user", "content": "Solve this math problem step by step..."}]
+)
+
+for block in message.content:
+    if block.type == "thinking":
+        print(f"Thinking: {block.thinking}")
+    elif block.type == "text":
+        print(f"Answer: {block.text}")
+```
+
+## Prompt Caching
+
+Cache large system prompts or context to reduce costs:
+
+```python
+message = client.messages.create(
+    model="claude-sonnet-4-0",
+    max_tokens=1024,
+    system=[
+        {"type": "text", "text": large_system_prompt, "cache_control": {"type": "ephemeral"}}
+    ],
+    messages=[{"role": "user", "content": "Question about the cached context"}]
+)
+# Check cache usage
+print(f"Cache read: {message.usage.cache_read_input_tokens}")
+print(f"Cache creation: {message.usage.cache_creation_input_tokens}")
+```
+
+## Batches API
+
+Process large volumes asynchronously at 50% cost reduction:
+
+```python
+import time
+
+batch = client.messages.batches.create(
+    requests=[
+        {
+            "custom_id": f"request-{i}",
+            "params": {
+                "model": "claude-sonnet-4-0",
+                "max_tokens": 1024,
+                "messages": [{"role": "user", "content": prompt}]
+            }
+        }
+        for i, prompt in enumerate(prompts)
+    ]
+)
+
+# Poll for completion
+while True:
+    status = client.messages.batches.retrieve(batch.id)
+    if status.processing_status == "ended":
+        break
+    time.sleep(30)
+
+# Get results
+for result in client.messages.batches.results(batch.id):
+    print(result.result.message.content[0].text)
+```
+
+## Claude Agent SDK
+
+Build multi-step agents:
+
+```python
+# Note: Agent SDK API surface may change — check official docs
+import anthropic
+
+# Define tools as functions
+tools = [{
+    "name": "search_codebase",
+    "description": "Search the codebase for relevant code",
+    "input_schema": {
+        "type": "object",
+        "properties": {"query": {"type": "string"}},
+        "required": ["query"]
+    }
+}]
+
+# Run an agentic loop with tool use
+client = anthropic.Anthropic()
+messages = [{"role": "user", "content": "Review the auth module for security issues"}]
+
+while True:
+    response = client.messages.create(
+        model="claude-sonnet-4-0",
+        max_tokens=4096,
+        tools=tools,
+        messages=messages,
+    )
+    if response.stop_reason == "end_turn":
+        break
+    # Handle tool calls and continue the loop
+    messages.append({"role": "assistant", "content": response.content})
+    # ... execute tools and append tool_result messages
+```
+
+## Cost Optimization
+
+| Strategy | Savings | When to Use |
+|----------|---------|-------------|
+| Prompt caching | Up to 90% on cached tokens | Repeated system prompts or context |
+| Batches API | 50% | Non-time-sensitive bulk processing |
+| Haiku instead of Sonnet | ~75% | Simple tasks, classification, extraction |
+| Shorter max_tokens | Variable | When you know output will be short |
+| Streaming | None (same cost) | Better UX, same price |
+
+## Error Handling
+
+```python
+import time
+
+from anthropic import APIError, RateLimitError, APIConnectionError
+
+try:
+    message = client.messages.create(...)
+except RateLimitError:
+    # Back off and retry
+    time.sleep(60)
+except APIConnectionError:
+    # Network issue, retry with backoff
+    pass
+except APIError as e:
+    print(f"API error {e.status_code}: {e.message}")
+```
+
+## Environment Setup
+
+```bash
+# Required
+export ANTHROPIC_API_KEY="your-api-key-here"
+
+# Optional: set default model
+export ANTHROPIC_MODEL="claude-sonnet-4-0"
+```
+
+Never hardcode API keys. Always use environment variables.

package/.agent/skills/claude-devfleet/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: claude-devfleet
+description: Orchestrate multi-agent coding tasks via Claude DevFleet — plan projects, dispatch parallel agents in isolated worktrees, monitor progress, and read structured reports.
+origin: community
+---
+
+# Claude DevFleet Multi-Agent Orchestration
+
+## When to Use
+
+Use this skill when you need to dispatch multiple Claude Code agents to work on coding tasks in parallel. Each agent runs in an isolated git worktree with full tooling.
+
+Requires a running Claude DevFleet instance connected via MCP:
+```bash
+claude mcp add devfleet --transport http http://localhost:18801/mcp
+```
+
+## How It Works
+
+```
+User → "Build a REST API with auth and tests"
+  ↓
+plan_project(prompt) → project_id + mission DAG
+  ↓
+Show plan to user → get approval
+  ↓
+dispatch_mission(M1) → Agent 1 spawns in worktree
+  ↓
+M1 completes → auto-merge → auto-dispatch M2 (depends_on M1)
+  ↓
+M2 completes → auto-merge
+  ↓
+get_report(M2) → files_changed, what_done, errors, next_steps
+  ↓
+Report back to user
+```
+
+### Tools
+
+| Tool | Purpose |
+|------|---------|
+| `plan_project(prompt)` | AI breaks a description into a project with chained missions |
+| `create_project(name, path?, description?)` | Create a project manually, returns `project_id` |
+| `create_mission(project_id, title, prompt, depends_on?, auto_dispatch?)` | Add a mission. `depends_on` is a list of mission ID strings (e.g., `["abc-123"]`). Set `auto_dispatch=true` to auto-start when deps are met. |
+| `dispatch_mission(mission_id, model?, max_turns?)` | Start an agent on a mission |
+| `cancel_mission(mission_id)` | Stop a running agent |
+| `wait_for_mission(mission_id, timeout_seconds?)` | Block until a mission completes (see note below) |
+| `get_mission_status(mission_id)` | Check mission progress without blocking |
+| `get_report(mission_id)` | Read structured report (files changed, tested, errors, next steps) |
+| `get_dashboard()` | System overview: running agents, stats, recent activity |
+| `list_projects()` | Browse all projects |
+| `list_missions(project_id, status?)` | List missions in a project |
+
+> **Note on `wait_for_mission`:** This blocks the conversation for up to `timeout_seconds` (default 600). For long-running missions, prefer polling with `get_mission_status` every 30–60 seconds instead, so the user sees progress updates.
+
+### Workflow: Plan → Dispatch → Monitor → Report
+
+1. **Plan**: Call `plan_project(prompt="...")` → returns `project_id` + list of missions with `depends_on` chains and `auto_dispatch=true`.
+2. **Show plan**: Present mission titles, types, and dependency chain to the user.
+3. **Dispatch**: Call `dispatch_mission(mission_id=<first_mission_id>)` on the root mission (empty `depends_on`). Remaining missions auto-dispatch as their dependencies complete (because `plan_project` sets `auto_dispatch=true` on them).
+4. **Monitor**: Call `get_mission_status(mission_id=...)` or `get_dashboard()` to check progress.
+5. **Report**: Call `get_report(mission_id=...)` when missions complete. Share highlights with the user.
+
+### Concurrency
+
+DevFleet runs up to 3 concurrent agents by default (configurable via `DEVFLEET_MAX_AGENTS`). When all slots are full, missions with `auto_dispatch=true` queue in the mission watcher and dispatch automatically as slots free up. Check `get_dashboard()` for current slot usage.
+
+## Examples
+
+### Full auto: plan and launch
+
+1. `plan_project(prompt="...")` → shows plan with missions and dependencies.
+2. Dispatch the first mission (the one with empty `depends_on`).
+3. Remaining missions auto-dispatch as dependencies resolve (they have `auto_dispatch=true`).
+4. Report back with project ID and mission count so the user knows what was launched.
+5. Poll with `get_mission_status` or `get_dashboard()` periodically until all missions reach a terminal state (`completed`, `failed`, or `cancelled`).
+6. `get_report(mission_id=...)` for each terminal mission — summarize successes and call out failures with errors and next steps.
+
+### Manual: step-by-step control
+
+1. `create_project(name="My Project")` → returns `project_id`.
+2. `create_mission(project_id=project_id, title="...", prompt="...", auto_dispatch=true)` for the first (root) mission → capture `root_mission_id`.
+   `create_mission(project_id=project_id, title="...", prompt="...", auto_dispatch=true, depends_on=["<root_mission_id>"])` for each subsequent task.
+3. `dispatch_mission(mission_id=...)` on the first mission to start the chain.
+4. `get_report(mission_id=...)` when done.
+
+### Sequential with review
+
+1. `create_project(name="...")` → get `project_id`.
+2. `create_mission(project_id=project_id, title="Implement feature", prompt="...")` → get `impl_mission_id`.
+3. `dispatch_mission(mission_id=impl_mission_id)`, then poll with `get_mission_status` until complete.
+4. `get_report(mission_id=impl_mission_id)` to review results.
+5. `create_mission(project_id=project_id, title="Review", prompt="...", depends_on=[impl_mission_id], auto_dispatch=true)` — auto-starts since the dependency is already met.
+
+## Guidelines
+
+- Always confirm the plan with the user before dispatching, unless they said to go ahead.
+- Include mission titles and IDs when reporting status.
+- If a mission fails, read its report before retrying.
+- Check `get_dashboard()` for agent slot availability before bulk dispatching.
+- Mission dependencies form a DAG — do not create circular dependencies.
+- Each agent runs in an isolated git worktree and auto-merges on completion. If a merge conflict occurs, the changes remain on the agent's worktree branch for manual resolution.
+- When manually creating missions, always set `auto_dispatch=true` if you want them to trigger automatically when dependencies complete. Without this flag, missions stay in `draft` status.