@dawnai/cli 1.0.3 → 1.0.5

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,74 @@ 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.3';
+import { fileURLToPath } from 'node:url';
+const CLI_VERSION = '1.0.5';
 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 getClaudeSkillsDir() {
+    return path.join(os.homedir(), '.claude', 'skills');
+}
+function parseSkillDescription(content) {
+    const descriptionMatch = content.match(/^description:\s*(.+)$/m);
+    return descriptionMatch?.[1]?.replace(/^["']|["']$/g, '') ?? '';
+}
+async function pathExists(targetPath) {
+    try {
+        await fs.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function listBundledSkills() {
+    const skillsDir = getBundledSkillsDir();
+    if (!(await pathExists(skillsDir))) {
+        return [];
+    }
+    const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+    const skills = 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),
+        };
+    }));
+    return skills
+        .filter((skill) => skill !== null)
+        .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 src = path.join(skillsDir, skill.name);
+        const dest = path.join(destinationDir, skill.name);
+        if ((await pathExists(dest)) && !force) {
+            results.push({ name: skill.name, installed: false });
+            continue;
+        }
+        await fs.cp(src, dest, { recursive: true, force: true });
+        results.push({ name: skill.name, installed: true });
+    }
+    return results;
+}
 async function ensureDir() {
     await fs.mkdir(CLI_HOME, { recursive: true });
 }
@@ -103,6 +166,7 @@ function printUsage() {
   dawn strategy list
   dawn strategy create <text>
   dawn strategy status <id>
+  dawn strategy positions <id> [--strategy-id <strategyId>]
   dawn strategy revise <id> <text>
   dawn strategy rules <id> list
   dawn strategy rules <id> approve <rule-index>
@@ -118,6 +182,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:
@@ -664,12 +733,45 @@ function renderAgentOverview(conversationId, conversation, strategies) {
         console.log(`- ${strategy.id ?? 'unknown'} | ${strategy.strategyType || 'unknown'} | ${label} | pnl=${formatUsd(strategy.totalPnl || '0')} | terminateAt=${formatTimestamp(strategy.terminateAt)}`);
     }
 }
+function renderStrategyPositions(conversationId, strategy, positions) {
+    const strategyId = String(strategy.id ?? 'unknown');
+    const strategyType = strategy.strategyType || 'unknown';
+    const strategyState = strategy.isRunning ? 'running' : 'stopped';
+    const walletId = strategy.walletId || 'unknown';
+    console.log(`Strategy positions for conversation ${conversationId}`);
+    console.log('='.repeat(`Strategy positions for conversation ${conversationId}`.length));
+    printKeyValue('Strategy ID', strategyId);
+    printKeyValue('Mode', strategyType);
+    printKeyValue('State', strategyState);
+    printKeyValue('Wallet', shortId(walletId));
+    printKeyValue('Position count', String(positions.length));
+    if (!positions.length) {
+        console.log('\nNo positions found for this strategy.');
+        return;
+    }
+    const totalCurrent = positions.reduce((sum, position) => sum + formatNumeric(position.currentValue), 0);
+    const totalCost = positions.reduce((sum, position) => sum + formatNumeric(position.costBasis), 0);
+    const totalPnl = positions.reduce((sum, position) => sum + formatNumeric(position.unrealizedPnl), 0);
+    printSection('Summary');
+    printKeyValue('Total current value', formatUsd(totalCurrent));
+    printKeyValue('Total cost basis', formatUsd(totalCost));
+    printKeyValue('Total unrealized PnL', `${formatUsd(totalPnl)} (${formatPercent(totalCost === 0 ? 0 : (totalPnl / totalCost) * 100)})`);
+    printSection('Positions');
+    const sorted = [...positions].sort((a, b) => formatNumeric(b.currentValue) - formatNumeric(a.currentValue));
+    for (const position of sorted) {
+        const title = position.marketTitle ||
+            position.groupItemTitle ||
+            `asset:${shortId(position.assetId || position.id)}`;
+        console.log(`- ${title} | value=${formatUsd(position.currentValue || '0')} | cost=${formatUsd(position.costBasis || '0')} | pnl=${formatUsd(position.unrealizedPnl || '0')} (${formatPercent(position.unrealizedPnlPercentage || '0')}) | amount=${formatNumeric(position.amount).toFixed(4)}`);
+    }
+}
 async function handleStrategy(args) {
     if (args.includes('--help') || args.includes('-h')) {
         console.log(`Usage:
   dawn strategy list
   dawn strategy create <text>
   dawn strategy status <id>
+  dawn strategy positions <id> [--strategy-id <strategyId>]
   dawn strategy revise <id> <text>
   dawn strategy rules <id> list
   dawn strategy rules <id> approve <rule-index>
@@ -689,7 +791,16 @@ async function handleStrategy(args) {
     if (!primaryCommand) {
         throw new Error('Missing strategy command.');
     }
-    if (!['list', 'create', 'status', 'revise', 'rules', 'code', 'launch'].includes(primaryCommand)) {
+    if (![
+        'list',
+        'create',
+        'status',
+        'positions',
+        'revise',
+        'rules',
+        'code',
+        'launch',
+    ].includes(primaryCommand)) {
         throw new Error(`Unknown strategy command: ${primaryCommand}. Run \`dawn strategy --help\` for available commands.`);
     }
     let subcommand = primaryCommand;
@@ -753,6 +864,15 @@ async function handleStrategy(args) {
         subcommand = '__status';
         rest.splice(0, rest.length, conversationId);
     }
+    if (primaryCommand === 'positions') {
+        const conversationId = rest[0];
+        const { flags } = parseFlags(rest.slice(1));
+        if (!conversationId) {
+            throw new Error('Usage: dawn strategy positions <id> [--strategy-id <strategyId>]');
+        }
+        subcommand = '__positions';
+        rest.splice(0, rest.length, conversationId, typeof flags['strategy-id'] === 'string' ? flags['strategy-id'] : '');
+    }
     if (primaryCommand === 'revise') {
         const conversationId = rest[0];
         const text = rest.slice(1).join(' ').trim();
@@ -963,6 +1083,35 @@ async function handleStrategy(args) {
         console.log(`Sent edit request to strategy ${conversationId}.`);
         return;
     }
+    if (subcommand === '__positions') {
+        const conversationId = rest[0];
+        const requestedStrategyId = rest[1];
+        if (!conversationId) {
+            throw new Error('Usage: dawn strategy positions <id> [--strategy-id <strategyId>]');
+        }
+        const strategiesRaw = (await apiFetch(config, `/strategy/conversation/${conversationId}`));
+        const strategies = Array.isArray(strategiesRaw) ? strategiesRaw : [];
+        if (!strategies.length) {
+            throw new Error(`No strategies found for conversation ${conversationId}.`);
+        }
+        const selectedStrategy = (requestedStrategyId
+            ? strategies.find((strategy) => String(strategy.id) === requestedStrategyId)
+            : null) ||
+            strategies.find((strategy) => strategy.isRunning) ||
+            strategies[0];
+        if (!selectedStrategy?.id) {
+            throw new Error('Could not determine strategy for this conversation.');
+        }
+        if (!selectedStrategy.walletId) {
+            throw new Error(`Could not determine wallet for strategy ${selectedStrategy.id}.`);
+        }
+        const response = (await apiFetch(config, `/v1/vault-metadata/${selectedStrategy.walletId}/positions?strategyIds=${encodeURIComponent(String(selectedStrategy.id))}`));
+        const positions = Array.isArray(response?.positions)
+            ? response.positions
+            : [];
+        renderStrategyPositions(conversationId, selectedStrategy, positions);
+        return;
+    }
     if (subcommand === 'launch') {
         const conversationId = rest[0];
         const { flags } = parseFlags(rest.slice(1));
@@ -1228,6 +1377,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') {
@@ -1255,6 +1477,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.3",
+  "version": "1.0.5",
   "type": "module",
   "description": "User-facing Dawn CLI",
   "license": "MIT",
@@ -12,6 +12,7 @@
   },
   "files": [
     "dist",
+    "skills",
     "README.md",
     "CLAUDE.md",
     "postinstall.js"

package/postinstall.js

@@ -16,6 +16,7 @@ console.log(`
   Get started:
     dawn --version          Check installed version
     dawn auth login         Authenticate (opens browser)
+    dawn skill install      Install Claude Code skills
     dawn --help             Show all commands
 
   Headless / CI / agent environments:

package/skills/dawn-account/SKILL.md

@@ -0,0 +1,54 @@
+---
+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.
+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.
+- Funding is required before launching live strategy runs.
+- Paper runs do not require funding.
+
+## Related skills
+
+- **dawn-auth** — Authenticate before checking account.
+- **dawn-strategy-launch** — Launch a run after confirming funding.

package/skills/dawn-auth/SKILL.md

@@ -0,0 +1,73 @@
+---
+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
+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.