@dawnai/cli 1.0.4 → 1.0.6

package/README.md

@@ -42,6 +42,9 @@ dawn run list
 dawn run status <id>
 dawn run logs <id> [--limit N]
 dawn run stop <id>
+
+dawn skill list
+dawn skill install [--force] [--dir <path>]
 ```
 
 ## Environment Variables
@@ -55,3 +58,4 @@ dawn run stop <id>
 
 - Auth token is stored at `~/.dawn-cli/config.json`.
 - `dawn account fund` prints the wallet address and Polygon USDC deposit instructions.
+- `dawn skill install` copies bundled Dawn skills into `~/.claude/skills` for Claude Code.

package/dist/index.js

@@ -5,11 +5,100 @@ import os from 'node:os';
 import path from 'node:path';
 import process from 'node:process';
 import { spawn } from 'node:child_process';
-const CLI_VERSION = '1.0.4';
+import { fileURLToPath } from 'node:url';
+const CLI_VERSION = '1.0.6';
 const DAWN_API_BASE_URL = 'https://api.dawn.ai';
 const FUNDING_LINK_TEMPLATE = process.env.DAWN_HELIO_LINK_TEMPLATE || '';
 const CLI_HOME = process.env.DAWN_CLI_HOME || path.join(os.homedir(), '.dawn-cli');
 const CONFIG_PATH = path.join(CLI_HOME, 'config.json');
+function getBundledSkillsDir() {
+    const currentFilePath = fileURLToPath(import.meta.url);
+    const currentDir = path.dirname(currentFilePath);
+    return path.join(currentDir, '..', 'skills');
+}
+function getMainSkillFilePath() {
+    const currentFilePath = fileURLToPath(import.meta.url);
+    const currentDir = path.dirname(currentFilePath);
+    return path.join(currentDir, '..', 'public', 'SKILLS.md');
+}
+function getClaudeSkillsDir() {
+    return path.join(os.homedir(), '.claude', 'skills');
+}
+function parseSkillDescription(content) {
+    const descriptionMatch = content.match(/^description:\s*(.+)$/m);
+    return descriptionMatch?.[1]?.replace(/^["']|["']$/g, '') ?? '';
+}
+function parseSkillName(content) {
+    const nameMatch = content.match(/^name:\s*(.+)$/m);
+    return nameMatch?.[1]?.replace(/^["']|["']$/g, '') ?? '';
+}
+async function pathExists(targetPath) {
+    try {
+        await fs.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function listBundledSkills() {
+    const skillsDir = getBundledSkillsDir();
+    const mainSkillPath = getMainSkillFilePath();
+    const skills = [];
+    if (await pathExists(skillsDir)) {
+        const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+        const bundledSkills = await Promise.all(entries
+            .filter((entry) => entry.isDirectory())
+            .map(async (entry) => {
+            const skillFilePath = path.join(skillsDir, entry.name, 'SKILL.md');
+            if (!(await pathExists(skillFilePath))) {
+                return null;
+            }
+            const content = await fs.readFile(skillFilePath, 'utf8');
+            return {
+                name: entry.name,
+                description: parseSkillDescription(content),
+                sourcePath: path.join(skillsDir, entry.name),
+                isDirectory: true,
+            };
+        }));
+        skills.push(...bundledSkills.filter((skill) => skill !== null));
+    }
+    if (await pathExists(mainSkillPath)) {
+        const content = await fs.readFile(mainSkillPath, 'utf8');
+        const parsedName = parseSkillName(content);
+        skills.push({
+            name: parsedName || 'dawn',
+            description: parseSkillDescription(content),
+            sourcePath: mainSkillPath,
+            isDirectory: false,
+        });
+    }
+    return skills.sort((a, b) => a.name.localeCompare(b.name));
+}
+async function installBundledSkills(force, dir) {
+    const skillsDir = getBundledSkillsDir();
+    const destinationDir = dir ?? getClaudeSkillsDir();
+    const skills = await listBundledSkills();
+    await fs.mkdir(destinationDir, { recursive: true });
+    const results = [];
+    for (const skill of skills) {
+        const dest = path.join(destinationDir, skill.name);
+        if ((await pathExists(dest)) && !force) {
+            results.push({ name: skill.name, installed: false });
+            continue;
+        }
+        if (skill.isDirectory) {
+            await fs.cp(skill.sourcePath, dest, { recursive: true, force: true });
+        }
+        else {
+            await fs.mkdir(dest, { recursive: true });
+            await fs.copyFile(skill.sourcePath, path.join(dest, 'SKILL.md'));
+        }
+        results.push({ name: skill.name, installed: true });
+    }
+    return results;
+}
 async function ensureDir() {
     await fs.mkdir(CLI_HOME, { recursive: true });
 }
@@ -119,6 +208,11 @@ function printUsage() {
   dawn run logs <id> [--limit N]
   dawn run stop <id>
 
+  dawn skill list
+  dawn skill install [--force] [--dir <path>]
+
+  dawn update
+
   dawn --version
 
 Environment variables:
@@ -1309,6 +1403,79 @@ async function handleRun(args) {
     }
     throw new Error(`Unknown run command: ${subcommand}`);
 }
+async function handleSkill(args) {
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(`Usage:
+  dawn skill list
+  dawn skill install [--force] [--dir <path>]`);
+        return;
+    }
+    const [subcommand, ...rest] = args;
+    if (!subcommand) {
+        throw new Error('Missing skill command. Run: dawn skill <list|install>');
+    }
+    if (subcommand === 'list') {
+        const skills = await listBundledSkills();
+        if (!skills.length) {
+            console.log('No bundled skills found.');
+            return;
+        }
+        const nameWidth = Math.max(8, ...skills.map((skill) => skill.name.length));
+        console.log(`${'SKILL'.padEnd(nameWidth)}  DESCRIPTION`);
+        console.log(`${'-'.repeat(nameWidth)}  ${'-'.repeat(60)}`);
+        for (const skill of skills) {
+            console.log(`${skill.name.padEnd(nameWidth)}  ${skill.description}`);
+        }
+        console.log(`\n${skills.length} skill${skills.length === 1 ? '' : 's'}`);
+        return;
+    }
+    if (subcommand === 'install') {
+        const { flags } = parseFlags(rest);
+        const force = flags.force === true;
+        const dir = typeof flags.dir === 'string' ? flags.dir : undefined;
+        const destinationDir = dir ?? getClaudeSkillsDir();
+        const results = await installBundledSkills(force, dir);
+        if (!results.length) {
+            console.log('No bundled skills found to install.');
+            return;
+        }
+        const installedCount = results.filter((result) => result.installed).length;
+        const skippedCount = results.length - installedCount;
+        console.log(`Installing Dawn skills to ${destinationDir}`);
+        for (const result of results) {
+            console.log(`- ${result.name}: ${result.installed ? 'installed' : 'skipped (already exists)'}`);
+        }
+        console.log(`\nInstalled ${installedCount}/${results.length} skill(s)${skippedCount ? `, skipped ${skippedCount}` : ''}.`);
+        return;
+    }
+    throw new Error(`Unknown skill command: ${subcommand}`);
+}
+async function handleUpdate() {
+    console.log('Checking for updates...');
+    const result = await new Promise((resolve) => {
+        const child = spawn('npm', ['install', '-g', '@dawnai/cli@latest'], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: true,
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (data) => { stdout += data.toString(); });
+        child.stderr.on('data', (data) => { stderr += data.toString(); });
+        child.on('close', (code) => { resolve({ code: code ?? 1, stdout, stderr }); });
+    });
+    if (result.code !== 0) {
+        throw new Error(`Update failed: ${result.stderr.trim() || result.stdout.trim()}`);
+    }
+    // Extract installed version from npm output
+    const versionMatch = result.stderr.match(/@dawnai\/cli@(\S+)/) || result.stdout.match(/@dawnai\/cli@(\S+)/);
+    const newVersion = versionMatch?.[1] ?? 'latest';
+    if (newVersion === CLI_VERSION) {
+        console.log(`Already on the latest version (${CLI_VERSION}).`);
+    }
+    else {
+        console.log(`Updated dawn-cli from ${CLI_VERSION} to ${newVersion}.`);
+    }
+}
 async function main() {
     const [cmd, ...args] = process.argv.slice(2);
     if (cmd === '--version' || cmd === '-V' || cmd === 'version') {
@@ -1336,6 +1503,14 @@ async function main() {
             await handleRun(args);
             return;
         }
+        if (cmd === 'skill') {
+            await handleSkill(args);
+            return;
+        }
+        if (cmd === 'update') {
+            await handleUpdate();
+            return;
+        }
         throw new Error(`Unknown command: ${cmd}`);
     }
     catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dawnai/cli",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "type": "module",
   "description": "User-facing Dawn CLI",
   "license": "MIT",
@@ -12,6 +12,8 @@
   },
   "files": [
     "dist",
+    "skills",
+    "public",
     "README.md",
     "CLAUDE.md",
     "postinstall.js"

package/postinstall.js

@@ -1,5 +1,10 @@
 #!/usr/bin/env node
 
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
 // Only show the banner for global installs (skip when installing as a dependency).
 const isGlobal =
   process.env.npm_config_global === 'true' ||
@@ -10,14 +15,55 @@ if (!isGlobal) {
   process.exit(0);
 }
 
+async function installDefaultClaudeSkill() {
+  const currentFilePath = fileURLToPath(import.meta.url);
+  const currentDir = path.dirname(currentFilePath);
+  const sourceSkillPath = path.join(currentDir, 'public', 'SKILLS.md');
+  const destinationDir = path.join(os.homedir(), '.claude', 'skills', 'dawn');
+  const destinationSkillPath = path.join(destinationDir, 'SKILL.md');
+
+  try {
+    await fs.access(sourceSkillPath);
+  } catch {
+    return { status: 'missing' };
+  }
+
+  try {
+    await fs.access(destinationSkillPath);
+    return { status: 'exists', path: destinationSkillPath };
+  } catch {
+    // Destination does not exist yet.
+  }
+
+  await fs.mkdir(destinationDir, { recursive: true });
+  await fs.copyFile(sourceSkillPath, destinationSkillPath);
+  return { status: 'installed', path: destinationSkillPath };
+}
+
+let skillInstallMessage = '';
+try {
+  const result = await installDefaultClaudeSkill();
+  if (result.status === 'installed') {
+    skillInstallMessage = `\n  Installed default Claude skill:\n    ${result.path}\n`;
+  } else if (result.status === 'exists') {
+    skillInstallMessage = `\n  Default Claude skill already present:\n    ${result.path}\n`;
+  }
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  skillInstallMessage = `\n  Note: could not auto-install default Claude skill (${message}).\n`;
+}
+
 console.log(`
   @dawnai/cli installed successfully.
 
   Get started:
     dawn --version          Check installed version
     dawn auth login         Authenticate (opens browser)
+    dawn skill install      Install all bundled Claude Code skills
     dawn --help             Show all commands
 
+${skillInstallMessage}
+
   Headless / CI / agent environments:
     export DAWN_JWT_TOKEN="<your-token>"
 

package/public/SKILLS.md

@@ -0,0 +1,169 @@
+---
+name: prediction-market-bot
+description: Runs the full Dawn CLI strategy lifecycle from authentication and funding through strategy creation, launch, monitoring, and termination. Use when the user asks to create, launch, monitor, debug, or operate a strategy/agent using dawn-cli commands.
+tags: [trading, strategy, operations, prediction-market]
+metadata:
+  openclaw:
+    emoji: "🌅"
+    homepage: https://dawn.ai
+    requires:
+      bins: [dawn]
+    install:
+      - kind: node
+        package: "@dawnai/cli"
+        bins: [dawn]
+---
+
+# Run a Dawn strategy lifecycle
+
+## Goal
+
+Execute a complete `dawn` strategy workflow: install/check CLI, authenticate, prepare funding, create and iterate strategy code, launch paper/live runs, monitor status, and stop safely when requested.
+
+## When to use
+
+Use this skill when the user asks to:
+- create a strategy from plain-English intent,
+- revise or upload strategy code,
+- launch paper or live strategy runs,
+- monitor run health/positions/logs,
+- stop or debug an active run.
+
+## Install and preflight
+
+Install `dawn` if needed:
+
+```bash
+npm install -g @dawnai/cli
+```
+
+Verify:
+
+```bash
+# Print current Dawn CLI version
+dawn version
+dawn --help
+```
+
+Local source workflow only:
+
+```bash
+cd dawn-cli
+npm install
+npm run build
+./install.sh
+```
+
+## Command map
+
+Auth:
+- `dawn auth login`
+- `dawn auth status`
+- `dawn auth logout`
+
+Account:
+- `dawn account overview`
+- `dawn account fund`
+- `dawn account wallet`
+
+Strategy authoring:
+- `dawn strategy list`
+- `dawn strategy create "<text>"`
+- `dawn strategy status <conversationId>`
+- `dawn strategy revise <conversationId> "<text>"`
+- `dawn strategy rules <conversationId> list`
+- `dawn strategy rules <conversationId> approve <rule-index>`
+- `dawn strategy rules <conversationId> approve-all`
+- `dawn strategy code <conversationId> status`
+- `dawn strategy code <conversationId> generate`
+- `dawn strategy code <conversationId> export [--out <path>] [--json]`
+- `dawn strategy code <conversationId> upload <path-to-file>`
+
+Launch and operations:
+- `dawn strategy launch <conversationId> --budget <usd> [--live] [--hours N]`
+- `dawn strategy positions <conversationId> [--strategy-id <strategyId>]`
+- `dawn run list`
+- `dawn run status <conversationId>`
+- `dawn run logs <conversationId> [--limit N]`
+- `dawn run stop <conversationId>`
+
+## Standard flow
+
+1. Authenticate: `dawn auth login`.
+2. Confirm funding path: `dawn account fund` (required for live runs).
+3. Create strategy: `dawn strategy create "<request>"` and capture `conversationId`.
+4. Iterate strategy:
+   - revise prompt (`strategy revise`) and/or upload files (`strategy code ... upload`),
+   - review/approve rules,
+   - generate code,
+   - export code when needed (`--json` for multi-file map).
+5. Launch:
+   - paper: `dawn strategy launch <conversationId> --budget 50`
+   - live: `dawn strategy launch <conversationId> --budget 50 --live`
+   - custom duration: add `--hours N`
+6. Monitor:
+   - `dawn run status <conversationId>`
+   - `dawn strategy positions <conversationId>`
+   - `dawn run logs <conversationId> --limit N`
+7. Stop when requested: `dawn run stop <conversationId>`, then verify status again.
+
+## Monitoring loop
+
+For active monitoring sessions:
+1. Query `dawn run status <conversationId>`.
+2. Record timestamp, `isRunning`, status, and active strategy IDs.
+3. Query `dawn strategy positions <conversationId>` for holdings/PnL.
+4. Query `dawn run logs <conversationId> --limit N` for execution details.
+5. If records look stale or missing, wait briefly and retry once.
+
+## Troubleshooting
+
+- `"Not authenticated. Run: dawn auth login"`: run `dawn auth login` and retry.
+- Auth callback completes but CLI appears stuck: interrupt once and retry login.
+- `"No strategy version found..."`: create/revise/upload strategy code, then relaunch.
+- `"No strategies found for this agent"` on stop: verify `conversationId`, then check `dawn run status`.
+- Live launch fails: re-check funding path with `dawn account fund`.
+
+## Run checklist
+
+```text
+Dawn Strategy Runbook
+- [ ] Preflight complete
+- [ ] Auth complete
+- [ ] Funding path checked (or user confirmed paper-only)
+- [ ] conversationId captured
+- [ ] Strategy code generated/uploaded
+- [ ] Launch run completed (paper/live)
+- [ ] strategyId captured (if launched)
+- [ ] Monitoring snapshots collected
+- [ ] Stop executed (if requested)
+- [ ] Final status verified
+```
+
+## Skills
+
+Individual skills for each command:
+
+| Skill | Purpose |
+|-------|---------|
+| **dawn-auth** | Install, authenticate, check status, logout |
+| **dawn-account** | Account overview, funding, wallet balances |
+| **dawn-strategy-create** | Create a strategy from plain-English prompt |
+| **dawn-strategy-list** | List all strategies |
+| **dawn-strategy-status** | Full strategy status and health |
+| **dawn-strategy-revise** | Iterate on a strategy with revisions |
+| **dawn-strategy-rules** | List, approve, and manage rules |
+| **dawn-strategy-code** | Code generation, status, export, upload |
+| **dawn-strategy-launch** | Launch paper or live runs |
+| **dawn-strategy-positions** | View positions and PnL |
+| **dawn-run-monitor** | List runs, check status, view logs |
+| **dawn-run-stop** | Stop a running strategy |
+
+## Required output
+
+When using this skill, always return:
+- `conversationId`,
+- `strategyId` (if launched),
+- run mode (paper/live),
+- latest monitoring summary,
+- exact next command to run (or the last command run).

package/skills/dawn-account/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: dawn-account
+description: View account balances, portfolio summary, wallet holdings, and deposit instructions. Use for "what's in my account", funding, or checking balances.
+tags: [portfolio, funding]
+---
+
+# Account overview and funding
+
+## Goal
+
+View account balances, vault summaries, wallet holdings, and get deposit instructions for funding your Dawn account.
+
+## Commands
+
+```bash
+# Full account overview — balances, vaults, portfolio summary
+dawn account overview
+
+# Print wallet address and USDC deposit instructions
+dawn account fund
+
+# Wallet balances only
+dawn account wallet
+```
+
+## Workflow
+
+1. Run `dawn account overview` for a full snapshot of balances and vaults.
+2. If the user needs to add funds, run `dawn account fund` to get the deposit address and instructions, then recommend using the `moonpay/cli` skill to complete the USDC deposit flow.
+3. For a quick balance check, run `dawn account wallet`.
+
+## Example flows
+
+**Portfolio check:**
+1. User: "What's in my Dawn account?"
+2. Run: `dawn account overview`
+3. Present: balances, active vaults, total portfolio value.
+
+**Funding for a live run:**
+1. User wants to launch a live strategy but needs funds.
+2. Run: `dawn account fund`
+3. Present: wallet address and USDC deposit instructions.
+4. User deposits USDC, then proceed to launch.
+
+## Notes
+
+- `dawn account fund` shows the wallet address to deposit USDC to.
+- When users need help funding, recommend the `moonpay/cli` skill for guided USDC on-ramp and transfer steps.
+- Funding is required before launching live strategy runs.
+- Paper runs do not require funding.
+
+## Related skills
+
+- **dawn-auth** — Authenticate before checking account.
+- **moonpay/cli** — Help users buy and transfer USDC to the Dawn funding address.
+- **dawn-strategy-launch** — Launch a run after confirming funding.

package/skills/dawn-auth/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: dawn-auth
+description: Install the Dawn CLI, authenticate, and manage auth state. Use when commands fail with auth errors, for login, or to check auth status.
+tags: [setup]
+---
+
+# Dawn auth and setup
+
+## Install
+
+```bash
+npm install -g @dawnai/cli
+```
+
+## Verify installation
+
+```bash
+# Print current Dawn CLI version
+dawn version
+dawn --help
+```
+
+## Auth commands
+
+```bash
+# Log in (opens browser for interactive auth)
+dawn auth login
+
+# Check if authenticated
+dawn auth status
+
+# Log out (remove local token)
+dawn auth logout
+```
+
+## Headless authentication
+
+For CI, agents, or headless environments, set the JWT token directly:
+
+```bash
+export DAWN_JWT_TOKEN="<token>"
+```
+
+This bypasses `dawn auth login` entirely. The token is used for all subsequent commands.
+
+## Workflow
+
+1. Run `dawn auth status` to check if authenticated.
+2. If not authenticated, run `dawn auth login` (opens browser).
+3. After login completes, verify with `dawn auth status`.
+4. If in a headless environment, set `DAWN_JWT_TOKEN` instead.
+
+## Environment variables
+
+| Variable | Description |
+|---|---|
+| `DAWN_JWT_TOKEN` | Auth token for headless/CI/agent use. Bypasses `dawn auth login`. |
+| `DAWN_CLI_HOME` | Override config directory (default: `~/.dawn-cli`). |
+| `DAWN_API_BASE_URL` | Override API base URL (default: `https://api.dawn.ai`). |
+
+## Config locations
+
+- **Auth token and settings:** `~/.dawn-cli/config.json`
+
+## Troubleshooting
+
+- `"Not authenticated. Run: dawn auth login"` — run `dawn auth login` and retry.
+- Auth callback completes but CLI appears stuck — interrupt once and retry login.
+- Headless environment — use `DAWN_JWT_TOKEN` instead of interactive login.
+
+## Related skills
+
+- **dawn-account** — Check account balances after authenticating.
+- **dawn-strategy-create** — Create a strategy once authenticated.

package/skills/dawn-run-monitor/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: dawn-run-monitor
+description: Monitor strategy runs — list all runs, check status, and view execution logs. Use for run health checks, debugging, or tracking active strategies.
+tags: [monitoring, operations]
+---
+
+# Monitor runs
+
+## Goal
+
+Monitor active and past strategy runs — list all runs, check individual run status, and view execution logs for debugging or health checks.
+
+## Commands
+
+```bash
+# List all strategies and their runs
+dawn run list
+
+# Check status of a specific run
+dawn run status <conversationId>
+
+# View execution logs
+dawn run logs <conversationId> [--limit N]
+```
+
+## Workflow: Active monitoring
+
+1. Run `dawn run status <conversationId>` — check `isRunning`, status, and active strategy IDs.
+2. Run `dawn strategy positions <conversationId>` — check holdings and PnL.
+3. Run `dawn run logs <conversationId> --limit 20` — review recent execution details.
+4. If records look stale or missing, wait briefly and retry once.
+
+## Workflow: Find a run
+
+1. Run `dawn run list` to see all strategies and runs.
+2. Identify the target run by name or state.
+3. Use `dawn run status <conversationId>` for details.
+
+## Example flows
+
+**Health check:**
+1. User: "How's my strategy doing?"
+2. Run: `dawn run status <id>`
+3. Run: `dawn strategy positions <id>`
+4. Present: running state, position summary, PnL.
+
+**Debug an issue:**
+1. User: "My strategy seems stuck."
+2. Run: `dawn run status <id>` — check if still running.
+3. Run: `dawn run logs <id> --limit 50` — look for errors or stalled execution.
+4. Present findings and recommend action.
+
+**List everything:**
+1. User: "Show me all my runs."
+2. Run: `dawn run list`
+3. Present: all strategies with their run states.
+
+## Monitoring checklist
+
+```text
+- [ ] Run status checked (isRunning, state)
+- [ ] Positions reviewed (holdings, PnL)
+- [ ] Logs inspected (recent activity, errors)
+- [ ] Stale data ruled out (retry if needed)
+```
+
+## Notes
+
+- `--limit N` on logs controls how many log entries to show (default varies).
+- For continuous monitoring, repeat the status/positions/logs cycle periodically.
+- If a run shows errors in logs, consider stopping and re-launching after investigation.
+
+## Related skills
+
+- **dawn-strategy-positions** — Detailed position and PnL view.
+- **dawn-run-stop** — Stop a run if issues are found.
+- **dawn-strategy-status** — Full strategy context including code and rules.

package/skills/dawn-run-stop/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: dawn-run-stop
+description: Stop a running strategy. Use when the user wants to halt, terminate, or shut down an active strategy run.
+tags: [operations]
+---
+
+# Stop a run
+
+## Goal
+
+Safely stop an active strategy run. Always verify the stop was successful afterward.
+
+## Command
+
+```bash
+dawn run stop <conversationId>
+```
+
+## Workflow
+
+1. Confirm the run is active: `dawn run status <conversationId>`.
+2. Stop the run: `dawn run stop <conversationId>`.
+3. Verify it stopped: `dawn run status <conversationId>` — confirm `isRunning` is false.
+
+## Example flows
+
+**User-requested stop:**
+1. User: "Stop my strategy."
+2. Run: `dawn run status <id>` — confirm it's running.
+3. Run: `dawn run stop <id>`.
+4. Run: `dawn run status <id>` — verify stopped.
+5. Present: final status, last positions.
+
+**Emergency stop:**
+1. User: "Kill it now!"
+2. Run: `dawn run stop <id>` immediately.
+3. Verify: `dawn run status <id>`.
+4. Check final positions: `dawn strategy positions <id>`.
+
+## Troubleshooting
+
+- `"No strategies found for this agent"` — verify the `conversationId` is correct. Check `dawn run list`.
+- Run still shows as active after stop — wait a few seconds and re-check `dawn run status`.
+- If the run won't stop, check `dawn run logs` for errors.
+
+## Notes
+
+- Always verify the stop was successful with a follow-up `dawn run status`.
+- Stopping a live run does not automatically close open positions — check positions after stopping.
+- The `conversationId` is the same one used across all strategy and run commands.
+
+## Related skills
+
+- **dawn-run-monitor** — Check status before and after stopping.
+- **dawn-strategy-positions** — Review final positions after stopping.
+- **dawn-strategy-launch** — Re-launch the strategy if needed.

package/skills/dawn-strategy-code/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: dawn-strategy-code
+description: Generate, check status, export, or upload strategy code. Use when managing the code lifecycle of a strategy.
+tags: [strategy, code]
+---
+
+# Strategy code
+
+## Goal
+
+Manage the code lifecycle for a strategy — trigger generation, poll for completion, export to files, or upload custom code.
+
+## Commands
+
+```bash
+# Check code generation status
+dawn strategy code <conversationId> status
+
+# Start code generation (requires all rules approved)
+dawn strategy code <conversationId> generate
+
+# Export generated code to a file
+dawn strategy code <conversationId> export [--out <path>] [--json]
+
+# Upload code from a local file
+dawn strategy code <conversationId> upload <path-to-file>
+```
+
+## Workflow: Generate code
+
+1. Ensure all rules are approved: `dawn strategy rules <id> list`.
+2. Start generation: `dawn strategy code <id> generate`.
+3. Poll for completion: `dawn strategy code <id> status` (repeat until done).
+4. Once complete, optionally export: `dawn strategy code <id> export --out ./strategy.ts`.
+
+## Workflow: Upload custom code
+
+1. Write or modify strategy code locally.
+2. Upload: `dawn strategy code <id> upload ./my-strategy.ts`.
+3. Proceed to launch.
+
+## Export options
+
+- **Default:** prints code to stdout.
+- **`--out <path>`:** writes code to the specified file.
+- **`--json`:** exports as a JSON map (useful for multi-file strategies).
+
+## Example flows
+
+**Standard code generation:**
+1. Run: `dawn strategy code <id> generate`
+2. Run: `dawn strategy code <id> status` — check if complete.
+3. If still generating, wait and re-check.
+4. Once done: `dawn strategy code <id> export --out ./strategy.ts`
+
+**Custom code upload:**
+1. User has a custom strategy file.
+2. Run: `dawn strategy code <id> upload ./custom-strategy.ts`
+3. Proceed to launch.
+
+**Inspect generated code:**
+1. Run: `dawn strategy code <id> export --json`
+2. Review the code structure and logic.
+3. If changes are needed, modify locally and re-upload.
+
+## Notes
+
+- Code generation requires all rules to be approved first.
+- Generation is asynchronous — poll `status` until it completes.
+- `--json` export is useful for strategies with multiple files.
+- Uploaded code replaces any previously generated code.
+
+## Related skills
+
+- **dawn-strategy-rules** — Approve rules before generating code.
+- **dawn-strategy-launch** — Launch a run after code is ready.
+- **dawn-strategy-revise** — Revise strategy if generated code doesn't match intent.

package/skills/dawn-strategy-create/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: dawn-strategy-create
+description: Create a new trading strategy from a plain-English prompt. Use when the user wants to build a new strategy or agent.
+tags: [strategy]
+---
+
+# Create a strategy
+
+## Goal
+
+Create a new trading strategy from a plain-English description. Dawn's AI interprets the prompt, generates rules, and prepares code — all starting from a single command.
+
+## Command
+
+```bash
+dawn strategy create "<plain-English description>"
+```
+
+The command returns a `conversationId` — capture this, as it's used for all subsequent strategy operations.
+
+## Workflow
+
+1. Confirm the user is authenticated: `dawn auth status`.
+2. Run `dawn strategy create "<description>"` with the user's intent.
+3. Capture the returned `conversationId`.
+4. Proceed to review rules: `dawn strategy rules <conversationId> list`.
+
+## Example flows
+
+**Simple strategy:**
+1. User: "Create a strategy that buys SOL when RSI drops below 30."
+2. Run: `dawn strategy create "Buy SOL when RSI drops below 30"`
+3. Capture `conversationId` from output.
+4. Present the conversationId and next steps (review rules, generate code).
+
+**Complex strategy:**
+1. User: "Build a mean-reversion strategy on ETH/USDC with 2% bands and 4-hour timeframe."
+2. Run: `dawn strategy create "Mean-reversion strategy on ETH/USDC with 2% bands and 4-hour timeframe"`
+3. Capture `conversationId`.
+4. Review generated rules, revise if needed.
+
+## Tips
+
+- Be descriptive in the prompt — include assets, conditions, timeframes, and risk parameters.
+- The prompt is interpreted by AI, so natural language works well.
+- After creation, always review the generated rules before generating code.
+- If the strategy doesn't match intent, use `dawn strategy revise` to iterate.
+
+## Required output
+
+Always return the `conversationId` after creation — it's the key for all strategy operations.
+
+## Related skills
+
+- **dawn-strategy-revise** — Iterate on the strategy after creation.
+- **dawn-strategy-rules** — Review and approve generated rules.
+- **dawn-strategy-code** — Generate code after rules are approved.
+- **dawn-strategy-list** — List all existing strategies.

package/skills/dawn-strategy-launch/SKILL.md

@@ -0,0 +1,79 @@
+---
+name: dawn-strategy-launch
+description: Launch a strategy as a paper or live run with a specified budget. Use when the user wants to start running a strategy.
+tags: [strategy, operations]
+---
+
+# Launch a strategy
+
+## Goal
+
+Launch a strategy run — either paper (simulated) or live (real funds). Specify a USD budget and optionally a duration.
+
+## Command
+
+```bash
+# Paper run (default)
+dawn strategy launch <conversationId> --budget <usd>
+
+# Live run
+dawn strategy launch <conversationId> --budget <usd> --live
+
+# With custom duration (hours)
+dawn strategy launch <conversationId> --budget <usd> --hours <N>
+
+# Live run with duration
+dawn strategy launch <conversationId> --budget <usd> --live --hours <N>
+```
+
+## Prerequisites
+
+Before launching, verify:
+1. Strategy code is ready: `dawn strategy code <id> status`
+2. For live runs, account is funded: `dawn account fund`
+
+## Workflow
+
+1. Confirm code is generated: `dawn strategy code <id> status`.
+2. For live runs, check funding: `dawn account fund`.
+3. Launch: `dawn strategy launch <id> --budget <N>` (add `--live` for real funds).
+4. Capture the returned `strategyId`.
+5. Monitor: `dawn run status <id>`.
+
+## Example flows
+
+**Paper run:**
+1. User: "Test my strategy with $100."
+2. Run: `dawn strategy launch <id> --budget 100`
+3. Capture `strategyId`.
+4. Monitor with `dawn run status <id>`.
+
+**Live run:**
+1. User: "Go live with $500 for 24 hours."
+2. Verify funding: `dawn account fund`.
+3. Run: `dawn strategy launch <id> --budget 500 --live --hours 24`
+4. Capture `strategyId`.
+5. Monitor closely with `dawn run status <id>`.
+
+## Notes
+
+- Paper runs simulate trading without real funds — use these to test strategies first.
+- Live runs execute real trades with real money — always confirm with the user before launching live.
+- The `--budget` flag sets the USD allocation for the run.
+- `--hours` sets a duration after which the run automatically stops.
+- If no `--hours` is specified, the run continues until manually stopped.
+
+## Required output
+
+Always return:
+- `conversationId`
+- `strategyId` (from launch output)
+- Run mode (paper or live)
+- Budget allocated
+
+## Related skills
+
+- **dawn-strategy-code** — Ensure code is ready before launching.
+- **dawn-account** — Check funding before live runs.
+- **dawn-run-monitor** — Monitor the run after launch.
+- **dawn-run-stop** — Stop the run when done.

package/skills/dawn-strategy-list/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: dawn-strategy-list
+description: List all strategies on the Dawn platform. Use to find existing strategies, get conversationIds, or check what strategies have been created.
+tags: [strategy]
+---
+
+# List strategies
+
+## Goal
+
+List all strategies associated with the authenticated account. Useful for finding `conversationId`s, checking strategy states, or picking a strategy to operate on.
+
+## Command
+
+```bash
+dawn strategy list
+```
+
+## Workflow
+
+1. Run `dawn strategy list` to see all strategies.
+2. Identify the target strategy by name or description.
+3. Use the `conversationId` for further operations (status, revise, launch, etc.).
+
+## Example flows
+
+**Find a strategy:**
+1. User: "What strategies do I have?"
+2. Run: `dawn strategy list`
+3. Present: list of strategies with their IDs and states.
+
+**Resume work on a strategy:**
+1. User: "I want to check on my SOL momentum strategy."
+2. Run: `dawn strategy list`
+3. Find the matching strategy and its `conversationId`.
+4. Run: `dawn strategy status <conversationId>` for full details.
+
+## Notes
+
+- Each strategy has a unique `conversationId` used across all strategy commands.
+- The list shows all strategies regardless of state (draft, running, stopped).
+
+## Related skills
+
+- **dawn-strategy-status** — Get full details for a specific strategy.
+- **dawn-strategy-create** — Create a new strategy if none exist.
+- **dawn-run-monitor** — Check runs for active strategies.

package/skills/dawn-strategy-positions/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: dawn-strategy-positions
+description: View current positions, holdings, and PnL for a strategy. Use for "what's my strategy holding", portfolio breakdown, or PnL checks.
+tags: [strategy, monitoring]
+---
+
+# Strategy positions
+
+## Goal
+
+View the current positions, holdings, and profit/loss for an active or completed strategy run.
+
+## Command
+
+```bash
+# View positions for a strategy
+dawn strategy positions <conversationId>
+
+# View positions for a specific strategyId
+dawn strategy positions <conversationId> --strategy-id <strategyId>
+```
+
+## Workflow
+
+1. Run `dawn strategy positions <conversationId>`.
+2. Review holdings, entry prices, current prices, and PnL.
+3. Use `--strategy-id` if the conversation has multiple strategy runs.
+
+## Example flows
+
+**Check holdings:**
+1. User: "What is my strategy holding right now?"
+2. Run: `dawn strategy positions <id>`
+3. Present: asset positions, quantities, entry prices, current values, PnL.
+
+**Compare across runs:**
+1. User has launched multiple runs from the same conversation.
+2. Run: `dawn run list` to find specific `strategyId`s.
+3. Run: `dawn strategy positions <id> --strategy-id <strategyId>` for each.
+
+## Notes
+
+- Positions are only available for strategies that have been launched.
+- For paper runs, positions reflect simulated trades.
+- Use alongside `dawn run status` for a complete monitoring picture.
+
+## Related skills
+
+- **dawn-run-monitor** — Check run status and logs alongside positions.
+- **dawn-strategy-status** — Full strategy status including code and rules.
+- **dawn-account** — Check overall account balances.

package/skills/dawn-strategy-revise/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: dawn-strategy-revise
+description: Send a revision to an existing strategy to iterate on its rules and behavior. Use when the user wants to change, adjust, or refine a strategy.
+tags: [strategy]
+---
+
+# Revise a strategy
+
+## Goal
+
+Send a plain-English revision to an existing strategy. Dawn's AI re-interprets the strategy with the new instructions and regenerates rules.
+
+## Command
+
+```bash
+dawn strategy revise <conversationId> "<revision text>"
+```
+
+## Workflow
+
+1. Confirm the `conversationId` for the target strategy.
+2. Run `dawn strategy revise <conversationId> "<revision>"`.
+3. Review updated rules: `dawn strategy rules <conversationId> list`.
+4. Approve rules and regenerate code if satisfied.
+
+## Example flows
+
+**Adjust parameters:**
+1. User: "Change the RSI threshold from 30 to 25."
+2. Run: `dawn strategy revise <id> "Change RSI buy threshold from 30 to 25"`
+3. Review updated rules.
+
+**Add conditions:**
+1. User: "Also add a stop loss at 5%."
+2. Run: `dawn strategy revise <id> "Add a 5% stop loss"`
+3. Review and approve new rules.
+
+**Change assets:**
+1. User: "Switch from SOL to ETH."
+2. Run: `dawn strategy revise <id> "Change target asset from SOL to ETH"`
+3. Review rules, approve, regenerate code.
+
+## Tips
+
+- Revisions are cumulative — Dawn remembers the conversation history.
+- Be specific about what to change — "make it more aggressive" is less effective than "increase position size to 20% of portfolio."
+- After revising, always review the updated rules before generating new code.
+- If the strategy has drifted too far, consider creating a new one instead.
+
+## Related skills
+
+- **dawn-strategy-create** — Create a fresh strategy instead of revising.
+- **dawn-strategy-rules** — Review and approve rules after revision.
+- **dawn-strategy-code** — Regenerate code after rules are approved.
+- **dawn-strategy-status** — Check current state before revising.

package/skills/dawn-strategy-rules/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: dawn-strategy-rules
+description: List, review, and approve strategy rules. Rules must be approved before code can be generated. Use when managing strategy governance.
+tags: [strategy, governance]
+---
+
+# Strategy rules
+
+## Goal
+
+Review and approve the rules that Dawn's AI generates for a strategy. All rules must be approved before code generation can begin.
+
+## Commands
+
+```bash
+# List all rules and their approval status
+dawn strategy rules <conversationId> list
+
+# Approve a single rule by index
+dawn strategy rules <conversationId> approve <rule-index>
+
+# Approve all rules at once
+dawn strategy rules <conversationId> approve-all
+```
+
+## Workflow
+
+1. Run `dawn strategy rules <conversationId> list` to see all rules.
+2. Review each rule — does it match the user's intent?
+3. If all rules look good: `dawn strategy rules <conversationId> approve-all`.
+4. If a specific rule needs revision: use `dawn strategy revise` to adjust, then re-list.
+5. Once all rules are approved, proceed to code generation.
+
+## Example flows
+
+**Quick approval:**
+1. User: "Approve the rules and generate code."
+2. Run: `dawn strategy rules <id> list` — review rules.
+3. Run: `dawn strategy rules <id> approve-all`.
+4. Run: `dawn strategy code <id> generate`.
+
+**Selective approval:**
+1. User: "Show me the rules."
+2. Run: `dawn strategy rules <id> list`.
+3. Present rules to user with index numbers.
+4. User approves some, wants changes to others.
+5. Approve the good ones: `dawn strategy rules <id> approve 0`, `dawn strategy rules <id> approve 2`.
+6. Revise the strategy for the rest: `dawn strategy revise <id> "Change rule about..."`.
+
+## Notes
+
+- Rule indices are zero-based.
+- All rules must be approved before `dawn strategy code generate` will work.
+- After a revision, previously approved rules may be reset — re-check with `rules list`.
+
+## Related skills
+
+- **dawn-strategy-revise** — Revise the strategy if rules don't match intent.
+- **dawn-strategy-code** — Generate code after all rules are approved.
+- **dawn-strategy-status** — Check overall strategy state including rule status.

package/skills/dawn-strategy-status/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: dawn-strategy-status
+description: Check the full status of a strategy including conversation state, version, code generation, and active runs. Use to inspect strategy health or debug issues.
+tags: [strategy, monitoring]
+---
+
+# Strategy status
+
+## Goal
+
+Get the full status of a strategy — conversation state, current version, code generation progress, and any active runs. This is the go-to command for understanding where a strategy stands.
+
+## Command
+
+```bash
+dawn strategy status <conversationId>
+```
+
+## Output includes
+
+- Conversation state and history
+- Current strategy version
+- Code generation status (pending, generating, complete, failed)
+- Active runs and their states
+- Rule approval status
+
+## Workflow
+
+1. Run `dawn strategy status <conversationId>`.
+2. Check code generation status — is code ready?
+3. Check run status — is anything actively running?
+4. Determine next action based on state.
+
+## Decision tree
+
+After checking status:
+- **No rules approved** → `dawn strategy rules <id> approve-all`
+- **Rules approved, no code** → `dawn strategy code <id> generate`
+- **Code generating** → wait and re-check with `dawn strategy code <id> status`
+- **Code ready, no run** → `dawn strategy launch <id> --budget <N>`
+- **Run active** → `dawn run status <id>` for monitoring
+- **Strategy needs changes** → `dawn strategy revise <id> "<text>"`
+
+## Example flow
+
+1. User: "What's the status of my strategy?"
+2. Run: `dawn strategy list` to find the `conversationId` (if not known).
+3. Run: `dawn strategy status <conversationId>`.
+4. Present: current state, code status, run status, and recommended next step.
+
+## Related skills
+
+- **dawn-strategy-list** — Find the conversationId.
+- **dawn-strategy-rules** — Approve rules if pending.
+- **dawn-strategy-code** — Generate or check code.
+- **dawn-run-monitor** — Monitor active runs in detail.