Grand Diomande Research · Full HTML Reader

Pulse v3 — Autonomous Development Platform

Pulse v3 is a production-grade platform for autonomous AI-driven development. It extends Pulse v2 with advanced features for enterprise use:

Agents That Account for Themselves research note backlog reference score 18 .md

Full Public Reader

---
name: pulse-v3
description: Production-grade autonomous development platform with chains, quality gates, checkpoints, learning, and multi-channel deployment
homepage: https://github.com/clawdbot/pulse-v3
user-invocable: true
command-dispatch: pulse
metadata.clawdbot: {"governance": true, "mcp_aware": true, "version": "3.0.0"}
---

Pulse v3 — Autonomous Development Platform

Pulse v3 is a production-grade platform for autonomous AI-driven development. It extends Pulse v2 with advanced features for enterprise use:

🔗 Chains — Multi-step workflows with dependencies
⚡ Parallel Execution — Run sessions concurrently
✅ Quality Gates — TypeScript, ESLint, tests, builds
💾 Checkpoints — Auto-save and resume from any point
🔄 Rollback — Automatic rollback on failure
📊 Cost Tracking — Budget limits and usage monitoring
🧠 Learning — Pattern recognition and improvement suggestions
🚀 Deployment — Vercel, TestFlight, GitHub Releases
📱 Notifications — iMessage, Discord, Slack support

Quick Start

Basic Session

/pulse "Add user authentication to the app"

With Options

/pulse "Add payment integration" --project my-app --budget 5.00 --notify

Using Template

/pulse template expo-feature --feature_name "checkout" --feature_description "Shopping cart checkout flow"

Chain Execution

/pulse chain full-release --version 2.0.0

Architecture

┌─────────────────────────────────────────────────────────────────┐
│                       Pulse v3 Platform                         │
├─────────────────────────────────────────────────────────────────┤
│  Orchestrator                                                    │
│  ├── Session Management                                          │
│  ├── Chain Execution                                             │
│  └── Parallel Coordination                                       │
├─────────────────────────────────────────────────────────────────┤
│  Core Systems                                                    │
│  ├── Registry (Session Storage)                                  │
│  ├── State Machine (PENDING→RUNNING→COMPLETE)                   │
│  ├── Event Bus (pulse:start, pulse:complete, etc.)              │
│  └── Checkpoints (Auto-save, Resume)                            │
├─────────────────────────────────────────────────────────────────┤
│  Quality & Safety                                                │
│  ├── Quality Gates (TypeScript, ESLint, Tests)                  │
│  ├── Rollback Manager (Git-based safety)                        │
│  └── Interactive Approval (Human-in-the-loop)                   │
├─────────────────────────────────────────────────────────────────┤
│  Intelligence                                                    │
│  ├── Pattern Store (Learn from success)                         │
│  ├── Skill Matcher (Auto-select skills)                         │
│  └── Analyzer (Improvement suggestions)                         │
├─────────────────────────────────────────────────────────────────┤
│  Deployment                                                      │
│  ├── Vercel (Preview/Production)                                │
│  ├── TestFlight (EAS Build)                                     │
│  └── GitHub (Releases, PRs)                                     │
└─────────────────────────────────────────────────────────────────┘

Session States

PENDING → RUNNING → CHECKPOINT → QUALITY_CHECK → DEPLOYING → COMPLETE
            ↓           ↓              ↓              ↓
         PAUSED      PAUSED         PAUSED         FAILED
            ↓           ↓              ↓              ↓
         RUNNING     RUNNING        RUNNING       (retry)

Features

1. Chains — Multi-Step Workflows

Define complex workflows with dependencies:

yaml

# templates/my-chain.yaml
name: feature-release
steps:
  - id: develop
    name: Develop Feature
    task: "Implement the feature..."
    qualityGates: [typescript, eslint]

  - id: test
    name: Run Tests
    task: "Execute test suite"
    dependsOn: [develop]

  - id: deploy
    name: Deploy
    task: "Deploy to production"
    dependsOn: [test]
    deploy:
      platform: vercel
      environment: production

2. Quality Gates

Built-in gates:
- `typescript` — Type checking
- `eslint` — Code quality
- `jest` / `vitest` — Unit tests
- `build` — Production build
- `expo-typecheck` — Expo TypeScript
- `nextjs-build` — Next.js build
- `swift-build` — Swift compilation

Custom gates:

typescript

gateConfig.createFromCommand(
  'custom-lint',
  'Custom Lint',
  'npm run custom-lint',
  { required: true, timeoutSeconds: 120 }
);

3. Checkpoints & Resume

Auto-checkpoint every 5 minutes:

typescript

const session = await orchestrator.startSession({
  task: "...",
  autoCheckpoint: true,
  checkpointIntervalMs: 5 * 60 * 1000
});

Resume from checkpoint:

typescript

await resumeManager.resumeFromLatest(sessionId);
// or
await resumeManager.resumeFromCheckpoint(sessionId, checkpointId);

4. Cost Tracking

Set budget limits:

typescript

const session = await orchestrator.startSession({
  task: "...",
  budgetLimit: 5.00 // $5 max
});

Query costs:

typescript

const summary = costTracker.getSessionSummary(sessionId);
console.log(formatCostSummary(summary));

5. Learning & Patterns

Patterns are automatically learned from successful sessions:

typescript

// Find matching patterns for a task
const matches = patternStore.findByKeywords(['expo', 'feature']);

// Apply a pattern
const pattern = matches[0].pattern;
console.log(pattern.successRate); // 0.85

6. Deployment

Vercel:

typescript

const result = await deploySessionToVercel(session, 'production');

TestFlight:

typescript

const result = await deploySessionToTestFlight(session, {
  profile: 'production',
  autoSubmit: true
});

GitHub Release:

typescript

const result = await createSessionRelease(session, '1.0.0', {
  generateNotes: true
});

7. Notifications

Configure multi-channel notifications:

typescript

notificationManager.configure(sessionId, [
  {
    channel: 'imessage',
    target: '+1234567890',
    onComplete: true,
    onError: true
  },
  {
    channel: 'discord',
    target: 'channel-id',
    verbosity: 'verbose'
  }
]);

8. Interactive Approvals

Request human approval at checkpoints:

typescript

const approved = await interactiveManager.requestApproval(session, {
  type: 'deploy',
  title: 'Deploy to Production?',
  description: 'Review changes before deployment',
  changes: ['file1.ts', 'file2.ts'],
  timeoutMs: 60 * 60 * 1000 // 1 hour
});

Templates

Available templates:
- `expo-feature` — Add feature to Expo app
- `ios-feature` — Add feature to iOS app
- `nextjs-page` — Add page to Next.js app
- `api-endpoint` — Create CRUD API endpoints
- `full-parity` — Port features between platforms
- `bug-fix` — Fix bugs with test coverage
- `refactor` — Refactor with safety
- `documentation` — Create/update docs

Use templates:

typescript

const task = orchestrator.generateFromTemplate(
  'expo-feature',
  { feature_name: 'checkout', feature_description: 'Shopping cart' },
  { project: 'my-app', projectPath: '/path/to/app' }
);

CLI Commands

bash

pulse start "task description"     # Start session
pulse status [sessionId]           # Get status
pulse list --status running        # List sessions
pulse resume <sessionId>           # Resume session
pulse templates                    # List templates
pulse template <name>              # Show template details
pulse schedule "0 9 * * *" "task"  # Schedule task
pulse costs --days 7               # Show costs
pulse patterns --search "expo"     # Search patterns
pulse help                         # Show help

API Reference

Core

typescript

import {
  orchestrator,
  registry,
  pulseEvents,
  pulse // quick start helper
} from '@clawdbot/pulse-v3';

// Quick start
const session = await pulse('Add feature', { budget: 5 });

// Full control
const session = await orchestrator.startSession({...});
await orchestrator.executeSession(session, executor, options);

Events

typescript

pulseEvents.on('pulse:complete', ({ session, summary }) => {
  console.log(`Done in ${summary.duration}ms`);
});

pulseEvents.on('pulse:error', ({ error, recoverable }) => {
  if (recoverable) rollback();
});

Quality

typescript

import { runSessionQuality, gateConfig } from '@clawdbot/pulse-v3';

const result = await runSessionQuality(session, ['typescript', 'eslint']);
if (!result.requiredPassed) {
  // Handle failure
}

Configuration

Data stored in `[home-path]`:
- `sessions.json` — Session registry
- `states/` — State machine snapshots
- `checkpoints/` — Checkpoint data
- `patterns.json` — Learned patterns
- `costs.json` — Cost records
- `schedules.json` — Scheduled tasks

Best Practices

1. Use templates — Consistent task structure
2. Set budgets — Prevent runaway costs
3. Enable checkpoints — Resume on failure
4. Run quality gates — Catch issues early
5. Review patterns — Learn from history
6. Configure notifications — Stay informed

Migration from Pulse v2

Pulse v3 is backward compatible with Pulse v2 preambles. New features are opt-in:

markdown

## PULSE v2 PREAMBLE
(existing format works)

## PULSE v3 OPTIONS (optional)
- autoCheckpoint: true
- qualityGates: [typescript, eslint]
- budgetLimit: 10.00

Troubleshooting

Session stuck in RUNNING?

typescript

const session = registry.get(id);
const sm = registry.getStateMachine(id);
sm.forceState('FAILED', 'Manual intervention');

Checkpoint not found?

typescript

const cps = checkpoints.list(sessionId);
// List all available checkpoints

Quality gate timeout?

typescript

gateConfig.customize('typescript', 'typescript-extended', {
  timeoutSeconds: 600 // 10 minutes
});

License

MIT

Promotion Decision

Keep in the searchable backlog until it intersects a live paper or system.

Source Anchor

homelab/clawdbot/skills/pulse-v3/SKILL.md

Detected Structure

Method · Figures · Code Anchors · Architecture