create-walle 0.1.0

package/template/wall-e/decision/confidence.js

@@ -0,0 +1,93 @@
+'use strict';
+const { v4: uuidv4 } = require('uuid');
+const brain = require('../brain');
+
+// Graduation thresholds from spec
+const GRADUATION = {
+  '1_to_2': { memories_required: 50 },
+  '2_to_3': { approval_rate: 0.90, min_actions: 20 },
+  '3_to_4': { approval_rate: 0.95, min_actions: 50 },
+};
+
+function getDomainConfidence(domain) {
+  const db = brain.getDb();
+  let row = db.prepare('SELECT * FROM domain_confidence WHERE domain = ?').get(domain);
+  if (!row) {
+    const id = uuidv4();
+    db.prepare('INSERT INTO domain_confidence (id, domain) VALUES (?, ?)').run(id, domain);
+    row = db.prepare('SELECT * FROM domain_confidence WHERE domain = ?').get(domain);
+  }
+  return row;
+}
+
+function checkGraduation(domain) {
+  const dc = getDomainConfidence(domain);
+  const currentTier = dc.current_tier;
+  let newTier = currentTier;
+
+  if (currentTier === 1) {
+    // Tier 1 -> 2: enough memories in domain
+    const memCount = brain.listMemories({ source: domain, limit: 51 }).length;
+    if (memCount > 50) newTier = 2;
+  } else if (currentTier === 2) {
+    const rate = dc.total_actions > 0 ? dc.approved_actions / dc.total_actions : 0;
+    if (rate > 0.90 && dc.total_actions > 20) newTier = 3;
+  } else if (currentTier === 3) {
+    const rate = dc.total_actions > 0 ? dc.approved_actions / dc.total_actions : 0;
+    if (rate > 0.95 && dc.total_actions > 50) newTier = 4;
+  }
+
+  if (newTier !== currentTier) {
+    brain.getDb().prepare(
+      "UPDATE domain_confidence SET current_tier = ?, last_promotion = datetime('now'), updated_at = datetime('now') WHERE domain = ?"
+    ).run(newTier, domain);
+    return { promoted: true, from: currentTier, to: newTier };
+  }
+  return { promoted: false, tier: currentTier };
+}
+
+function recordAction(domain, approved) {
+  const dc = getDomainConfidence(domain);
+  const updates = {
+    total_actions: dc.total_actions + 1,
+    approved_actions: approved ? dc.approved_actions + 1 : dc.approved_actions,
+    rejected_actions: approved ? dc.rejected_actions : dc.rejected_actions + 1,
+  };
+
+  // Check demotion: 3 rejections in a row
+  if (!approved) {
+    const recentActions = brain.getDb().prepare(
+      "SELECT status FROM agent_actions WHERE domain = ? ORDER BY created_at DESC LIMIT 3"
+    ).all(domain);
+    const allRejected = recentActions.length === 3 && recentActions.every(a => a.status === 'rejected');
+    if (allRejected && dc.current_tier > 1) {
+      updates.current_tier = dc.current_tier - 1;
+      updates.last_demotion = new Date().toISOString();
+    }
+  }
+
+  const keys = Object.keys(updates);
+  const sets = keys.map(k => `${k} = ?`).join(', ');
+  const vals = keys.map(k => updates[k]);
+  brain.getDb().prepare(`UPDATE domain_confidence SET ${sets}, updated_at = datetime('now') WHERE domain = ?`)
+    .run(...vals, domain);
+
+  // Check graduation after recording
+  return checkGraduation(domain);
+}
+
+function canActAutonomously(domain, isHighRisk) {
+  const dc = getDomainConfidence(domain);
+  const tier = dc.current_tier;
+
+  if (tier <= 2) return false; // Always queue
+  if (tier === 3) return !isHighRisk; // Act on low-risk only
+  if (tier === 4) return true; // Full autonomy
+  return false;
+}
+
+function listDomainConfidences() {
+  return brain.getDb().prepare('SELECT * FROM domain_confidence ORDER BY domain').all();
+}
+
+module.exports = { getDomainConfidence, checkGraduation, recordAction, canActAutonomously, listDomainConfidences };

package/template/wall-e/deploy.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+set -e
+
+echo "=== WALL-E Cloud Deployment ==="
+echo ""
+
+# Check fly CLI
+if ! command -v fly &> /dev/null; then
+  echo "Error: fly CLI not installed. Run: brew install flyctl"
+  exit 1
+fi
+
+# Check if app exists
+if ! fly apps list 2>/dev/null | grep -q wall-e-agent; then
+  echo "Creating Fly.io app..."
+  fly apps create wall-e-agent
+  fly volumes create wall_e_data --region sjc --size 1
+fi
+
+# Set secrets
+echo "Setting secrets..."
+echo "Make sure to set ANTHROPIC_API_KEY or Portkey headers:"
+echo "  fly secrets set ANTHROPIC_API_KEY=sk-..."
+echo "  fly secrets set ANTHROPIC_BASE_URL=https://..."
+echo "  fly secrets set ANTHROPIC_CUSTOM_HEADERS_B64=..."
+echo ""
+
+# Deploy
+echo "Deploying..."
+fly deploy
+
+echo ""
+echo "=== Deployment complete ==="
+echo "WALL-E is running at: https://wall-e-agent.fly.dev"
+echo "Health check: https://wall-e-agent.fly.dev/api/wall-e/health"

package/template/wall-e/docs/specs/2026-04-01-publish-plan.md

@@ -0,0 +1,112 @@
+# Publishing Plan: CTM & Wall-E
+
+**Date:** 2026-04-01
+**Author:** Juncao Li
+**Domain:** https://walle.sh
+
+## Overview
+
+Publish CTM (Claude Task Manager) and Wall-E (personal digital twin agent) as open-source tools that others can discover, install, and run locally.
+
+## Phases
+
+### Phase 1: Code Cleanup & Open Source (Current)
+
+**Goal:** Make the codebase safe and portable for public GitHub.
+
+#### Security Cleanup
+
+| Issue | Severity | Files | Fix |
+|---|---|---|---|
+| Hardcoded Slack User ID `YOUR_SLACK_USER_ID` | Critical | 5 files in `scripts/`, `slack-ingest.js` | Env var `SLACK_OWNER_USER_ID` |
+| `owner@example.com` in SKILL.md examples | High | `email-sync/SKILL.md`, `google-calendar/SKILL.md` | Replace with `owner@example.com` |
+| Hardcoded `juncao.li` in Slack queries | High | `slack-backfill.js`, `slack-channel-history.js`, `morning-briefing/run.js` | Read from config/brain |
+| `OWNER_NAME` owner name constant | High | `pull-slack-via-claude.js`, `slack-ingest.js` | Use `brain.getOwnerName()` |
+| Hardcoded `.walle/data` | Medium | `server.js`, `db.js`, `brain.js`, `api-walle.js` | Default to `~/.walle/data` |
+
+#### Repo Hygiene
+
+- [ ] `.env.example` documenting all env vars
+- [ ] `.gitignore` excludes `.db`, `.env`, compiled binaries, oauth tokens
+- [ ] MIT `LICENSE` file
+- [ ] Scrub git history or start fresh public repo (if secrets were ever committed)
+
+#### Already Good
+
+- API keys (ANTHROPIC_API_KEY, SLACK_TOKEN) read from env vars
+- `.db` files not in repo
+- `CTM_DATA_DIR` / `WALL_E_DATA_DIR` env vars already supported
+
+### Phase 2: Distribution & Discovery
+
+**Goal:** Make it easy for others to find and install.
+
+| Channel | Effort | Reach | Priority |
+|---|---|---|---|
+| GitHub repo + README | Low | Devs who search GitHub | P0 |
+| `npx create-walle` scaffolder | Medium | Anyone with Node.js | P1 |
+| Claude Code skill registry | Low | Claude Code users | P1 |
+| Homebrew tap | Medium | macOS users | P2 |
+| walle.sh website | High | Broadest | P2 |
+
+#### README Requirements
+
+- One-paragraph pitch
+- Screenshot / demo GIF
+- "Try it in 2 minutes" quickstart
+- Architecture diagram (CTM <-> Wall-E <-> Brain)
+- List of bundled skills (calendar, slack, email, morning briefing)
+- Configuration reference
+
+#### npx Scaffolder
+
+```bash
+npx create-walle
+# Clones repo, runs npm install, creates ~/.walle/data,
+# prompts for ANTHROPIC_API_KEY, owner name, optional Slack token
+# Starts CTM + Wall-E daemon
+```
+
+### Phase 3: Website — walle.sh
+
+**Goal:** Landing page, docs, and eventually auth + cloud hosting.
+
+| Sub-phase | What | Tech |
+|---|---|---|
+| 3a | Static landing page: pitch, screenshots, install guide | Cloudflare Pages (free, deploys from repo) |
+| 3b | Interactive docs: skill catalog, API reference | Same, or Astro/Starlight |
+| 3c | Auth + cloud DB | Fly.io (already deployed), Turso/Libsql for SQLite-compat cloud DB, Clerk or Passkeys for auth |
+| 3d | Web-based setup wizard | Create account -> configure integrations -> download CLI |
+
+#### Domain DNS Roadmap
+
+| Record | Now | Later |
+|---|---|---|
+| `walle.sh` | `127.0.0.1` (local alias) | Cloudflare Pages (landing) |
+| `app.walle.sh` | — | Fly.io (cloud CTM + Wall-E) |
+| `api.walle.sh` | — | Fly.io (public API) |
+| `docs.walle.sh` | — | Cloudflare Pages (documentation) |
+
+### Phase 4: Multi-User & Marketplace
+
+**Goal:** Let others contribute skills; host as SaaS.
+
+- Per-user data isolation (separate brain DBs)
+- Skill marketplace: browse, install, rate community skills
+- Usage-based pricing or free tier + pro
+- Telemetry opt-in for usage insights
+- Rate limiting / cost management (Wall-E daemon burns API tokens)
+
+## Branding
+
+- **Public name:** Wall-E (memorable, the face of the project)
+- **CTM** is the task manager component (less catchy, keep as internal name)
+- **Domain:** walle.sh
+- **Tagline ideas:** "Your personal digital twin" / "An AI that knows you"
+
+## Open Questions
+
+1. Start fresh public repo or clean history of current repo?
+2. Pricing model for cloud version? Free tier limits?
+3. Skill contribution guidelines and review process?
+4. Should the Slack/Email/Calendar sync skills require specific setup guides per-platform?

package/template/wall-e/docs/specs/SKILL-FORMAT.md

@@ -0,0 +1,326 @@
+# WALL-E Skill Format Specification
+
+**Version:** 1.0.0
+**Date:** 2026-03-31
+**Status:** Draft
+
+## Overview
+
+A WALL-E skill is a **reusable capability** that the agent can invoke to accomplish work. Skills sit between raw tools (Slack MCP, file I/O, shell) and tasks (scheduled/triggered jobs).
+
+```
+┌─────────────────────────────────────┐
+│          TASKS (scheduling)         │  "Run slack-sync every 15m"
+│  When to run, checkpoints, status   │
+├─────────────────────────────────────┤
+│          SKILLS (capabilities)      │  "How to sync Slack messages"
+│  Reusable, composable, shareable    │
+├─────────────────────────────────────┤
+│          TOOLS (primitives)         │  Slack MCP, brain DB, shell
+│  Raw APIs, MCP servers              │
+└─────────────────────────────────────┘
+```
+
+## Skill Directory Structure
+
+Each skill is a directory containing a `SKILL.md` file and optional supporting files:
+
+```
+skills/
+  slack-sync/
+    SKILL.md              # Required: metadata + instructions
+    run.js                # Optional: script entry point
+    lib/                  # Optional: supporting code
+    README.md             # Optional: human docs
+  morning-briefing/
+    SKILL.md              # Agent-based skill (no script)
+  my-custom-skill/
+    SKILL.md
+    run.sh                # Shell scripts work too
+```
+
+## SKILL.md Format
+
+A SKILL.md file has two parts: **YAML frontmatter** (metadata) and **Markdown body** (instructions).
+
+### Minimal Example
+
+```markdown
+---
+name: hello-world
+description: A simple test skill that greets the user
+version: 1.0.0
+execution: agent
+---
+# Hello World
+
+When invoked, respond with a friendly greeting that includes the owner's name.
+```
+
+### Full Example
+
+```markdown
+---
+name: slack-sync
+description: >
+  Pull latest Slack messages from active conversations.
+  Discovers recently active channels, fetches new messages,
+  and stores them in WALL-E's brain for search and context.
+version: 1.2.0
+author: juncao
+
+# Execution mode: "script" (deterministic) or "agent" (LLM-driven)
+execution: script
+entry: run.js
+args: ["--sync"]
+
+# What this skill needs to run
+requires:
+  env: []                          # Environment variables (checked at load time)
+  tools: [slack-mcp]               # MCP servers or tool modules
+  skills: []                       # Other skills this depends on
+
+# Default trigger for tasks that use this skill
+trigger:
+  type: interval                   # interval | cron | manual | event
+  schedule: "every 15m"            # Human-readable schedule
+
+# Skill configuration schema (validated at runtime)
+config:
+  mode:
+    type: string
+    enum: [incremental, full]
+    default: incremental
+    description: "incremental = only new messages, full = complete backfill"
+  max_channels:
+    type: number
+    default: 50
+    description: "Maximum channels to check per run"
+
+# Tags for discovery
+tags: [slack, messaging, sync, ingestion]
+
+# Permissions this skill requires (shown to user before install)
+permissions:
+  - slack:read          # Read Slack messages
+  - brain:write         # Write memories to brain DB
+  - network:outbound    # Make HTTP requests
+---
+
+# Slack Conversation Sync
+
+## What This Skill Does
+
+Incrementally syncs Slack messages from your most active conversations
+into WALL-E's brain. Only checks recently active channels (last 7 days)
+to minimize API calls and run time.
+
+## How It Works
+
+1. Search Slack for YOUR recent messages to discover active channels
+2. Query brain DB for channels with recent activity
+3. For each active channel, fetch messages since last sync
+4. Deduplicate and store new messages as memories
+5. Emit checkpoint after each channel for resume support
+
+## Configuration
+
+- `mode: incremental` — Only pulls channels with activity in the last 7 days (~35 channels, ~1 min)
+- `mode: full` — Pulls ALL known channels (~800 channels, ~15 min)
+
+## Output
+
+Returns: `{ new_messages, skipped, channels_done, total_after }`
+```
+
+## Frontmatter Fields
+
+### Required
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `name` | string | Unique skill identifier (kebab-case, e.g., `slack-sync`) |
+| `description` | string | What this skill does. **This is the primary field used for skill discovery.** Write it like search keywords. |
+| `version` | string | Semver version |
+| `execution` | string | `"script"` or `"agent"` |
+
+### Optional
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `author` | string | — | Skill author |
+| `entry` | string | `run.js` | Entry point file (for script execution) |
+| `args` | string[] | `[]` | Default arguments passed to entry point |
+| `requires.env` | string[] | `[]` | Required environment variables |
+| `requires.tools` | string[] | `[]` | Required MCP servers or tool modules |
+| `requires.skills` | string[] | `[]` | Other skills this depends on |
+| `trigger.type` | string | `manual` | Default trigger: `interval`, `cron`, `manual`, `event` |
+| `trigger.schedule` | string | — | Default schedule (e.g., `"every 15m"`, `"daily at 7am"`) |
+| `config` | object | `{}` | Configuration schema (JSON Schema subset) |
+| `tags` | string[] | `[]` | Discovery tags |
+| `permissions` | string[] | `[]` | Required permissions (shown before install) |
+
+## Execution Modes
+
+### Script Mode (`execution: script`)
+
+Deterministic execution. The skill runs a script file (Node.js, Python, shell) as a child process. No LLM tokens consumed. Fast and predictable.
+
+```yaml
+execution: script
+entry: run.js          # Relative to skill directory
+args: ["--sync"]       # Default CLI arguments
+```
+
+The script receives configuration via environment variables:
+- `WALL_E_SKILL_CONFIG` — JSON string of the config object
+- `WALL_E_DATA_DIR` — Path to WALL-E's data directory
+- `WALL_E_SKILL_DIR` — Path to this skill's directory
+
+Script exit codes:
+- `0` — Success
+- `1` — Failure (stderr captured as error)
+- `2` — Partial success (some work done, checkpoint saved)
+
+### Agent Mode (`execution: agent`)
+
+LLM-driven execution. WALL-E reads the SKILL.md instructions and uses available tools to accomplish the task. Flexible but costs tokens.
+
+```yaml
+execution: agent
+```
+
+The Markdown body below the frontmatter becomes the agent's instructions. The agent can use any available tools (MCP servers, brain DB, shell) to follow the instructions.
+
+Agent skills are ideal for:
+- Tasks requiring judgment (summarization, analysis)
+- Multi-step workflows that may vary each run
+- Skills that compose other skills
+- Natural language output (briefings, reports)
+
+## Skill Discovery
+
+When the agent needs to find relevant skills (e.g., user asks "sync my Slack"), it:
+
+1. Loads all installed skill metadata (name, description, tags)
+2. Matches against the user's request using description + tags
+3. For agent-mode skills: reads the full SKILL.md instructions
+4. For script-mode skills: executes the entry point
+
+The `description` field is critical for discovery. Write it with:
+- Action verbs: "Pull", "Sync", "Search", "Analyze"
+- Domain keywords: "Slack", "messages", "channels"
+- Use case phrases: "keep conversation context fresh"
+
+## Skill Locations & Precedence
+
+Skills are loaded from multiple locations. Higher precedence wins on name conflicts:
+
+1. **Workspace skills** (highest): `<project>/.wall-e/skills/`
+2. **User skills**: `~/.wall-e/skills/`
+3. **Bundled skills**: `wall-e/skills/_bundled/`
+4. **Registry skills** (lowest): `~/.wall-e/registry-skills/`
+
+## Bundled Skills
+
+WALL-E ships with these default skills:
+
+| Skill | Execution | Description |
+|-------|-----------|-------------|
+| `slack-sync` | script | Incremental Slack message sync |
+| `slack-backfill` | script | Full Slack history backfill |
+| `slack-search` | agent | Search Slack messages with context |
+| `morning-briefing` | agent | Daily meeting prep with calendar + Slack context |
+| `team-pulse` | agent | Monitor team messages for urgent items |
+| `memory-search` | agent | Search and summarize memories |
+
+## Skill ↔ Task Relationship
+
+Tasks reference skills by name. A task defines WHEN to run; the skill defines HOW.
+
+```
+Task: "Conversation Sync"
+  type: recurring
+  schedule: "every 15m"
+  skill: "slack-sync"                    # ← references the skill
+  skill_config: { mode: "incremental" }  # ← overrides skill defaults
+```
+
+A task can also chain multiple skills:
+```
+Task: "Morning Briefing"
+  type: recurring
+  schedule: "daily at 7am"
+  skill: "morning-briefing"     # Agent skill that internally uses:
+                                #   - slack-search (find recent context)
+                                #   - memory-search (find related memories)
+                                #   - calendar integration
+```
+
+## Configuration
+
+Skills define a config schema in frontmatter. Tasks can override defaults:
+
+```yaml
+# In SKILL.md
+config:
+  mode:
+    type: string
+    enum: [incremental, full]
+    default: incremental
+```
+
+```json
+// In task definition
+{
+  "skill": "slack-sync",
+  "skill_config": { "mode": "full" }
+}
+```
+
+## Skill Development
+
+### Creating a new skill
+
+```bash
+wall-e skill create my-skill          # Scaffold a new skill directory
+wall-e skill test my-skill            # Run the skill locally
+wall-e skill validate my-skill        # Check SKILL.md format
+```
+
+### Publishing
+
+```bash
+wall-e skill publish my-skill         # Publish to registry
+```
+
+### Installing third-party skills
+
+```bash
+wall-e skill install <name>           # From registry
+wall-e skill install <git-url>        # From Git repo
+wall-e skill list                     # Show installed skills
+wall-e skill update --all             # Update all skills
+```
+
+## Security Model
+
+1. **Bundled skills** — Trusted, shipped with WALL-E
+2. **User skills** — Created by the user, trusted by default
+3. **Registry skills** — Third-party, require explicit permission grant
+   - Permissions declared in `permissions` field
+   - Shown to user before installation
+   - Sandboxed: no access beyond declared permissions
+
+## Migration from Current System
+
+### Current → New
+
+| Current | New |
+|---------|-----|
+| `scripts/slack-backfill.js` | `skills/_bundled/slack-backfill/run.js` + `SKILL.md` |
+| `scripts/slack-channel-history.js` | `skills/_bundled/slack-sync/run.js` + `SKILL.md` |
+| `skills/slack-pull-live.js` | `skills/_bundled/slack-sync/incremental.js` |
+| Task with `execution: script` | Task with `skill: "slack-sync"` |
+| Task with `execution: chat` | Task with `skill: "morning-briefing"` |
+| `skills` DB table | Filesystem-based skills + DB for execution history |