@agent-hive/agent 0.1.0

package/dist/config.d.ts

@@ -0,0 +1,23 @@
+export declare const HIVE_DIR: string;
+export declare const CREDENTIALS_FILE: string;
+export declare const AGENT_CONFIG_FILE: string;
+export declare const DEFAULT_WORKSPACE_DIR: string;
+export interface AgentConfig {
+    workspace: string;
+}
+export declare function getAgentConfig(): AgentConfig | null;
+export declare function saveAgentConfig(config: AgentConfig): void;
+/**
+ * Resolve workspace directory. Priority:
+ * 1. Explicit override (from --workspace flag)
+ * 2. Saved in ~/.hive/agent.json
+ * 3. Default ~/.hive/workspace/
+ */
+export declare function getWorkspaceDir(override?: string): string;
+export declare function getLogsDir(workspaceDir: string): string;
+export declare const SKILLS_MANIFEST: string[];
+export declare const DEFAULT_WORKER_BUDGET_USD = 2;
+export declare const DEFAULT_WATCH_TIMEOUT_SECONDS = 300;
+export declare const WORKER_TIMEOUT_MS: number;
+export declare const CRASH_BACKOFF_MS = 5000;
+export declare const MAX_CONSECUTIVE_CRASHES = 5;

package/dist/config.js

@@ -0,0 +1,59 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+// ~/.hive/ — config and metadata only
+export const HIVE_DIR = join(homedir(), '.hive');
+export const CREDENTIALS_FILE = join(HIVE_DIR, 'credentials.json');
+export const AGENT_CONFIG_FILE = join(HIVE_DIR, 'agent.json');
+// Default workspace (used if no custom path configured)
+export const DEFAULT_WORKSPACE_DIR = join(HIVE_DIR, 'workspace');
+export function getAgentConfig() {
+    if (!existsSync(AGENT_CONFIG_FILE)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(AGENT_CONFIG_FILE, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveAgentConfig(config) {
+    if (!existsSync(HIVE_DIR)) {
+        mkdirSync(HIVE_DIR, { recursive: true });
+    }
+    writeFileSync(AGENT_CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+/**
+ * Resolve workspace directory. Priority:
+ * 1. Explicit override (from --workspace flag)
+ * 2. Saved in ~/.hive/agent.json
+ * 3. Default ~/.hive/workspace/
+ */
+export function getWorkspaceDir(override) {
+    if (override)
+        return override;
+    const config = getAgentConfig();
+    if (config?.workspace)
+        return config.workspace;
+    return DEFAULT_WORKSPACE_DIR;
+}
+export function getLogsDir(workspaceDir) {
+    return join(workspaceDir, 'logs');
+}
+// Skills manifest — installed via `npx skills add <source> -y`
+export const SKILLS_MANIFEST = [
+    'anthropics/skills@pdf',
+    'anthropics/skills@docx',
+    'anthropics/skills@canvas-design',
+    'rknall/claude-skills@svg-logo-designer',
+    'anthropics/skills@frontend-design',
+    'wshobson/agents@visual-design-foundations',
+];
+// Worker defaults
+export const DEFAULT_WORKER_BUDGET_USD = 2.00;
+export const DEFAULT_WATCH_TIMEOUT_SECONDS = 300;
+export const WORKER_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
+// Crash recovery
+export const CRASH_BACKOFF_MS = 5000;
+export const MAX_CONSECUTIVE_CRASHES = 5;

package/dist/credentials.d.ts

@@ -0,0 +1,17 @@
+export interface Credentials {
+    api_key: string;
+    api_url?: string;
+    operator_id?: string;
+}
+export declare function getCredentials(): Credentials | null;
+export declare function getApiUrl(): string;
+export declare function validateCredentials(): Promise<{
+    valid: boolean;
+    stats?: Record<string, unknown>;
+    error?: string;
+}>;
+export declare function checkStripeStatus(): Promise<{
+    connected: boolean;
+    active: boolean;
+    error?: string;
+}>;

package/dist/credentials.js

@@ -0,0 +1,67 @@
+import { readFileSync, existsSync } from 'fs';
+import { CREDENTIALS_FILE } from './config.js';
+export function getCredentials() {
+    if (!existsSync(CREDENTIALS_FILE)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(CREDENTIALS_FILE, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function getApiUrl() {
+    if (process.env.HIVE_API_URL) {
+        return process.env.HIVE_API_URL;
+    }
+    const creds = getCredentials();
+    if (creds?.api_url) {
+        return creds.api_url;
+    }
+    return 'http://localhost:3001';
+}
+export async function validateCredentials() {
+    const creds = getCredentials();
+    if (!creds?.api_key) {
+        return { valid: false, error: 'No API key found' };
+    }
+    const apiUrl = getApiUrl();
+    try {
+        const res = await fetch(`${apiUrl}/operators/stats`, {
+            headers: { 'X-Hive-Api-Key': creds.api_key },
+        });
+        if (!res.ok) {
+            const data = await res.json();
+            return { valid: false, error: data.error || 'Invalid API key' };
+        }
+        const stats = await res.json();
+        return { valid: true, stats };
+    }
+    catch (err) {
+        return { valid: false, error: `Failed to connect to API at ${apiUrl}` };
+    }
+}
+export async function checkStripeStatus() {
+    const creds = getCredentials();
+    if (!creds?.api_key) {
+        return { connected: false, active: false, error: 'No API key found' };
+    }
+    const apiUrl = getApiUrl();
+    try {
+        const res = await fetch(`${apiUrl}/operators/stripe/status`, {
+            headers: { 'X-Hive-Api-Key': creds.api_key },
+        });
+        if (!res.ok) {
+            return { connected: false, active: false, error: 'Failed to check Stripe status' };
+        }
+        const data = await res.json();
+        return {
+            connected: !!data.connected,
+            active: !!(data.connected && data.onboarding_complete),
+        };
+    }
+    catch {
+        return { connected: false, active: false, error: 'Failed to connect to API' };
+    }
+}

package/dist/dispatcher.d.ts

@@ -0,0 +1,7 @@
+export interface DispatcherOptions {
+    budgetPerRun?: number;
+    model?: string;
+    workerTimeoutMs?: number;
+    workspace?: string;
+}
+export declare function startDispatcher(options?: DispatcherOptions): Promise<void>;

package/dist/dispatcher.js

@@ -0,0 +1,258 @@
+import { existsSync } from 'fs';
+import chalk from 'chalk';
+import { CREDENTIALS_FILE, DEFAULT_WATCH_TIMEOUT_SECONDS, DEFAULT_WORKER_BUDGET_USD, WORKER_TIMEOUT_MS, CRASH_BACKOFF_MS, MAX_CONSECUTIVE_CRASHES, getWorkspaceDir, getLogsDir, } from './config.js';
+import { getCredentials, getApiUrl, validateCredentials } from './credentials.js';
+import { setLogsDir, log } from './logger.js';
+import { spawnWorker, buildWorkerPrompt } from './worker.js';
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Parse claimed task IDs from worker stdout.
+ * Worker uses --output-format stream-json, so claim responses are nested inside
+ * stream-json structures with escaped quotes (\" instead of ").
+ * We scan for the UUID pattern near "claimed" regardless of escaping.
+ */
+function parseClaimedTaskIds(output) {
+    const uuid = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}';
+    // Match with optional backslash-escaping on quotes: \" or "
+    const q = `\\\\?"`; // matches either \" or "
+    const re = new RegExp(`${q}task_id${q}\\s*:\\s*${q}(${uuid})${q}[^}]{0,500}${q}claimed${q}\\s*:\\s*true`, 'gi');
+    const matches = output.matchAll(re);
+    const taskIds = Array.from(new Set(Array.from(matches, m => m[1])));
+    return taskIds;
+}
+/**
+ * Call unclaim for each task ID. Best-effort — failures are logged but not fatal.
+ */
+async function unclaimTasks(taskIds, apiUrl, apiKey) {
+    for (const taskId of taskIds) {
+        try {
+            const res = await fetch(`${apiUrl}/tasks/${taskId}/unclaim`, {
+                method: 'POST',
+                headers: {
+                    'X-Hive-Api-Key': apiKey,
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (res.ok) {
+                log({ event: 'info', message: `Unclaimed task ${taskId} after worker failure` });
+            }
+            else {
+                const data = await res.json().catch(() => ({}));
+                log({
+                    event: 'info',
+                    message: `Unclaim task ${taskId} returned ${res.status}: ${data.error || ''}`,
+                });
+            }
+        }
+        catch (err) {
+            log({
+                event: 'error',
+                message: `Failed to unclaim task ${taskId}: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+}
+export async function startDispatcher(options = {}) {
+    const budgetPerRun = options.budgetPerRun ?? DEFAULT_WORKER_BUDGET_USD;
+    const workerTimeoutMs = options.workerTimeoutMs ?? WORKER_TIMEOUT_MS;
+    const model = options.model;
+    const workspaceDir = getWorkspaceDir(options.workspace);
+    const logsDir = getLogsDir(workspaceDir);
+    setLogsDir(logsDir);
+    console.log('');
+    console.log(chalk.bold('Hive Agent Dispatcher'));
+    console.log('');
+    // Pre-flight checks
+    if (!existsSync(CREDENTIALS_FILE)) {
+        console.error(chalk.red('No credentials found. Run: npx hive agent setup'));
+        process.exit(1);
+    }
+    if (!existsSync(workspaceDir)) {
+        console.error(chalk.red(`Workspace not found at ${workspaceDir}. Run: npx hive agent setup`));
+        process.exit(1);
+    }
+    console.log('  Validating credentials...');
+    const credResult = await validateCredentials();
+    if (!credResult.valid) {
+        console.error(chalk.red(`  Credentials invalid: ${credResult.error}`));
+        process.exit(1);
+    }
+    console.log(chalk.green('  Credentials valid'));
+    console.log('');
+    console.log(`  Workspace:     ${workspaceDir}`);
+    console.log(`  Budget per run: $${budgetPerRun.toFixed(2)}`);
+    console.log(`  Worker timeout: ${Math.round(workerTimeoutMs / 1000)}s`);
+    if (model)
+        console.log(`  Model: ${model}`);
+    console.log('');
+    log({
+        event: 'info',
+        message: 'Dispatcher starting',
+        data: { budgetPerRun, workerTimeoutMs, model, workspaceDir },
+    });
+    const creds = getCredentials();
+    const apiUrl = getApiUrl();
+    let running = true;
+    let consecutiveCrashes = 0;
+    const budgetSkipList = new Set(); // Task IDs that exceeded budget — don't retry
+    let currentWorkerOutput = ''; // Track worker output for unclaim on shutdown
+    // Graceful shutdown — unclaim any tasks the worker claimed before exiting
+    const shutdown = async () => {
+        if (!running)
+            return;
+        running = false;
+        log({ event: 'shutdown', message: 'Shutting down gracefully...' });
+        console.log('');
+        console.log(chalk.magenta('Shutting down gracefully...'));
+        // Best-effort unclaim from whatever output we've captured so far
+        if (currentWorkerOutput) {
+            const claimedIds = parseClaimedTaskIds(currentWorkerOutput);
+            if (claimedIds.length > 0) {
+                log({ event: 'info', message: `Shutdown — unclaiming ${claimedIds.length} task(s)` });
+                await unclaimTasks(claimedIds, apiUrl, creds.api_key);
+            }
+        }
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    // Main loop
+    while (running) {
+        log({
+            event: 'watch_start',
+            message: 'Watching for tasks...',
+        });
+        try {
+            // Long-poll for tasks
+            const res = await fetch(`${apiUrl}/tasks/watch?timeout=${DEFAULT_WATCH_TIMEOUT_SECONDS}`, {
+                headers: { 'X-Hive-Api-Key': creds.api_key },
+                signal: AbortSignal.timeout((DEFAULT_WATCH_TIMEOUT_SECONDS + 10) * 1000),
+            });
+            if (!running)
+                break;
+            if (!res.ok) {
+                const errorData = await res.json().catch(() => ({}));
+                log({
+                    event: 'error',
+                    message: `Watch request failed: ${res.status} ${errorData.error || ''}`,
+                });
+                await sleep(CRASH_BACKOFF_MS);
+                continue;
+            }
+            const data = await res.json();
+            // Check if we got tasks
+            const allTasks = data.tasks;
+            if (!allTasks || !Array.isArray(allTasks) || allTasks.length === 0) {
+                log({
+                    event: 'watch_result',
+                    message: 'No tasks available, continuing watch...',
+                });
+                continue;
+            }
+            // Filter out tasks that previously exceeded budget
+            const tasks = allTasks.filter(t => !budgetSkipList.has(String(t.task_id || t.id)));
+            if (tasks.length === 0) {
+                log({
+                    event: 'watch_result',
+                    message: `All ${allTasks.length} task(s) in budget skip list. Waiting ${DEFAULT_WATCH_TIMEOUT_SECONDS}s for new tasks...`,
+                });
+                await sleep(DEFAULT_WATCH_TIMEOUT_SECONDS * 1000);
+                continue;
+            }
+            log({
+                event: 'watch_result',
+                message: `Found ${tasks.length} available task(s)${budgetSkipList.size > 0 ? ` (${budgetSkipList.size} skipped)` : ''}`,
+                data: { task_count: tasks.length, skipped_count: budgetSkipList.size },
+            });
+            // Track task IDs offered to this worker (for budget skip list)
+            const offeredTaskIds = tasks.map(t => String(t.task_id || t.id));
+            // Build prompt and spawn worker
+            const tasksJson = JSON.stringify(tasks, null, 2);
+            const prompt = buildWorkerPrompt(tasksJson);
+            currentWorkerOutput = '';
+            const result = await spawnWorker(prompt, {
+                budgetPerRun,
+                model,
+                workerTimeoutMs,
+                workspaceDir,
+                onOutput: (chunk) => { currentWorkerOutput += chunk; },
+            });
+            if (!running)
+                break;
+            // On any failure, try to unclaim tasks the worker had claimed
+            if (result.exit_code !== 0 || result.budget_exceeded) {
+                const claimedIds = parseClaimedTaskIds(result.output);
+                if (claimedIds.length > 0) {
+                    log({
+                        event: 'info',
+                        message: `Worker failed — unclaiming ${claimedIds.length} task(s): ${claimedIds.join(', ')}`,
+                    });
+                    await unclaimTasks(claimedIds, apiUrl, creds.api_key);
+                }
+            }
+            if (result.budget_exceeded) {
+                // Budget exceeded (any exit code) — skip these tasks, don't count as crash
+                for (const id of offeredTaskIds) {
+                    budgetSkipList.add(id);
+                }
+                log({
+                    event: 'error',
+                    message: `Worker exceeded budget. Skipping ${offeredTaskIds.length} task(s) from this batch.`,
+                    data: { skipped_task_ids: offeredTaskIds },
+                });
+            }
+            else if (result.exit_code === 0) {
+                // Success — reset crash counter
+                consecutiveCrashes = 0;
+                log({
+                    event: 'info',
+                    message: 'Worker completed successfully, continuing...',
+                });
+            }
+            else {
+                // General failure — increment crash counter, allow retry
+                consecutiveCrashes++;
+                log({
+                    event: 'error',
+                    message: `Worker failed (crash ${consecutiveCrashes}/${MAX_CONSECUTIVE_CRASHES})`,
+                    data: { exit_code: result.exit_code, timed_out: result.timed_out },
+                });
+                if (consecutiveCrashes >= MAX_CONSECUTIVE_CRASHES) {
+                    log({
+                        event: 'shutdown',
+                        message: `Stopping after ${MAX_CONSECUTIVE_CRASHES} consecutive crashes`,
+                    });
+                    console.error(chalk.red(`\nStopping: ${MAX_CONSECUTIVE_CRASHES} consecutive worker failures. Check logs in ${logsDir}`));
+                    process.exit(1);
+                }
+                // Backoff before next attempt
+                await sleep(CRASH_BACKOFF_MS * consecutiveCrashes);
+            }
+        }
+        catch (err) {
+            if (!running)
+                break;
+            const message = err instanceof Error ? err.message : String(err);
+            // AbortError from timeout is expected
+            if (message.includes('abort') || message.includes('timeout')) {
+                log({
+                    event: 'watch_result',
+                    message: 'Watch timed out, retrying...',
+                });
+                continue;
+            }
+            log({
+                event: 'error',
+                message: `Dispatcher error: ${message}`,
+            });
+            consecutiveCrashes++;
+            if (consecutiveCrashes >= MAX_CONSECUTIVE_CRASHES) {
+                console.error(chalk.red(`\nStopping: ${MAX_CONSECUTIVE_CRASHES} consecutive failures. Check logs.`));
+                process.exit(1);
+            }
+            await sleep(CRASH_BACKOFF_MS * consecutiveCrashes);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { setup } from './setup.js';
+export type { SetupOptions } from './setup.js';
+export { startDispatcher } from './dispatcher.js';
+export type { DispatcherOptions } from './dispatcher.js';
+export { getWorkspaceDir, getAgentConfig } from './config.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { setup } from './setup.js';
+export { startDispatcher } from './dispatcher.js';
+export { getWorkspaceDir, getAgentConfig } from './config.js';

package/dist/logger.d.ts

@@ -0,0 +1,9 @@
+export type LogEvent = 'watch_start' | 'watch_result' | 'worker_start' | 'worker_end' | 'error' | 'shutdown' | 'setup' | 'info';
+export interface RunLogEntry {
+    event: LogEvent;
+    message: string;
+    data?: Record<string, unknown>;
+}
+/** Set the logs directory. Must be called before log(). */
+export declare function setLogsDir(dir: string): void;
+export declare function log(entry: RunLogEntry): void;

package/dist/logger.js

@@ -0,0 +1,45 @@
+import { mkdirSync, appendFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+let _logsDir = null;
+/** Set the logs directory. Must be called before log(). */
+export function setLogsDir(dir) {
+    _logsDir = dir;
+}
+function getLogFilePath() {
+    if (!_logsDir)
+        return null;
+    const date = new Date().toISOString().slice(0, 10); // YYYY-MM-DD
+    return join(_logsDir, `${date}.jsonl`);
+}
+function formatForStdout(entry) {
+    const timestamp = new Date().toISOString().slice(11, 19); // HH:MM:SS
+    const eventColors = {
+        watch_start: chalk.blue,
+        watch_result: chalk.green,
+        worker_start: chalk.yellow,
+        worker_end: chalk.green,
+        error: chalk.red,
+        shutdown: chalk.magenta,
+        setup: chalk.cyan,
+        info: chalk.white,
+    };
+    const colorize = eventColors[entry.event] || chalk.white;
+    return `${chalk.dim(timestamp)} ${colorize(`[${entry.event}]`)} ${entry.message}`;
+}
+export function log(entry) {
+    // Human-readable to stdout
+    console.log(formatForStdout(entry));
+    // Machine-readable to JSONL file (only if logs dir is configured)
+    const logFile = getLogFilePath();
+    if (!logFile)
+        return;
+    if (!existsSync(_logsDir)) {
+        mkdirSync(_logsDir, { recursive: true });
+    }
+    const logLine = JSON.stringify({
+        timestamp: new Date().toISOString(),
+        ...entry,
+    });
+    appendFileSync(logFile, logLine + '\n');
+}

package/dist/setup.d.ts

@@ -0,0 +1,4 @@
+export interface SetupOptions {
+    workspace?: string;
+}
+export declare function setup(options?: SetupOptions): Promise<void>;

package/dist/setup.js

@@ -0,0 +1,160 @@
+import { existsSync, mkdirSync, copyFileSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+import { CREDENTIALS_FILE, SKILLS_MANIFEST, getWorkspaceDir, getLogsDir, saveAgentConfig, } from './config.js';
+import { validateCredentials, checkStripeStatus } from './credentials.js';
+import { setLogsDir, log } from './logger.js';
+const __filename_resolved = typeof __filename !== 'undefined'
+    ? __filename
+    : fileURLToPath(import.meta.url);
+const __dirname_resolved = dirname(__filename_resolved);
+function getTemplatesDir() {
+    // Check multiple paths (dev vs installed)
+    const candidates = [
+        join(__dirname_resolved, '..', 'templates'), // From dist/
+        join(__dirname_resolved, '..', '..', 'templates'), // From src/ in dev
+    ];
+    for (const dir of candidates) {
+        if (existsSync(join(dir, 'CLAUDE.md'))) {
+            return dir;
+        }
+    }
+    throw new Error('Templates directory not found');
+}
+const TEMPLATE_FILES = [
+    { source: 'CLAUDE.md', target: 'CLAUDE.md' },
+    { source: 'settings.local.json', target: '.claude/settings.local.json' },
+    { source: 'MEMORY.md', target: 'memory/MEMORY.md' },
+    { source: 'quality-checklist.md', target: 'memory/quality-checklist.md' },
+];
+export async function setup(options = {}) {
+    const workspaceDir = getWorkspaceDir(options.workspace);
+    const logsDir = getLogsDir(workspaceDir);
+    setLogsDir(logsDir);
+    console.log('');
+    console.log(chalk.bold('Hive Agent Setup'));
+    console.log('');
+    // 1. Check credentials exist
+    if (!existsSync(CREDENTIALS_FILE)) {
+        console.error(chalk.red('No credentials found at ~/.hive/credentials.json'));
+        console.error('');
+        console.error('Register first using one of:');
+        console.error('  - Interactive Claude Code with Hive skill');
+        console.error('  - The website at thisisagenthive.com');
+        console.error('');
+        console.error('Then run: npx hive agent setup');
+        process.exit(1);
+    }
+    // 2. Validate credentials
+    console.log('  Checking credentials...');
+    const credResult = await validateCredentials();
+    if (!credResult.valid) {
+        console.error(chalk.red(`  Credentials invalid: ${credResult.error}`));
+        process.exit(1);
+    }
+    console.log(chalk.green('  Credentials valid'));
+    // 3. Check Stripe status (warn, don't block)
+    console.log('  Checking Stripe status...');
+    const stripeResult = await checkStripeStatus();
+    if (stripeResult.active) {
+        console.log(chalk.green('  Stripe connected and active'));
+    }
+    else if (stripeResult.connected) {
+        console.log(chalk.yellow('  Stripe connected but onboarding incomplete'));
+        console.log(chalk.yellow('  You can work on free tasks. Complete Stripe for paid tasks: npx hive stripe connect'));
+    }
+    else {
+        console.log(chalk.yellow('  Stripe not connected'));
+        console.log(chalk.yellow('  You can work on free tasks. Set up Stripe for paid tasks: npx hive stripe connect'));
+    }
+    // 4. Scaffold workspace directories
+    console.log('');
+    console.log(`  Scaffolding workspace at ${workspaceDir}...`);
+    const dirs = [
+        workspaceDir,
+        join(workspaceDir, '.claude'),
+        join(workspaceDir, 'memory'),
+        logsDir,
+    ];
+    for (const dir of dirs) {
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+    }
+    // 5. Save workspace location to ~/.hive/agent.json
+    saveAgentConfig({ workspace: workspaceDir });
+    // 6. Copy template files (skip if already exist — user may have customized)
+    const templatesDir = getTemplatesDir();
+    let copiedCount = 0;
+    let skippedCount = 0;
+    for (const tmpl of TEMPLATE_FILES) {
+        const targetPath = join(workspaceDir, tmpl.target);
+        const targetDir = dirname(targetPath);
+        if (!existsSync(targetDir)) {
+            mkdirSync(targetDir, { recursive: true });
+        }
+        if (existsSync(targetPath)) {
+            console.log(chalk.dim(`  Skipped ${tmpl.target} (already exists)`));
+            skippedCount++;
+        }
+        else {
+            copyFileSync(join(templatesDir, tmpl.source), targetPath);
+            console.log(chalk.green(`  Created ${tmpl.target}`));
+            copiedCount++;
+        }
+    }
+    // 7. Install Hive skill
+    console.log('');
+    console.log('  Installing Hive skill...');
+    try {
+        execSync('npx hive setup-skill claude-code', {
+            cwd: workspaceDir,
+            stdio: 'pipe',
+        });
+        console.log(chalk.green('  Hive skill installed'));
+    }
+    catch (err) {
+        console.error(chalk.yellow('  Warning: Failed to install Hive skill (may already be installed)'));
+    }
+    // 8. Install skills from manifest
+    console.log('');
+    console.log('  Installing agent skills...');
+    // Ensure workspace has a package.json for npx skills to work
+    const workspacePkgPath = join(workspaceDir, 'package.json');
+    if (!existsSync(workspacePkgPath)) {
+        writeFileSync(workspacePkgPath, JSON.stringify({
+            name: "hive-workspace",
+            version: "1.0.0",
+            private: true,
+        }, null, 2));
+    }
+    for (const skill of SKILLS_MANIFEST) {
+        const skillName = skill.split('@').pop() || skill;
+        try {
+            execSync(`npx skills add ${skill} -y`, {
+                cwd: workspaceDir,
+                stdio: 'pipe',
+                timeout: 30000,
+            });
+            console.log(chalk.green(`  Installed: ${skillName}`));
+        }
+        catch {
+            console.log(chalk.yellow(`  Skipped: ${skillName} (may already be installed or unavailable)`));
+        }
+    }
+    // 9. Done
+    console.log('');
+    console.log(chalk.bold.green('Setup complete!'));
+    console.log('');
+    console.log(`  Workspace: ${workspaceDir}`);
+    console.log(`  Config:    ~/.hive/agent.json`);
+    console.log(`  Templates: ${copiedCount} created, ${skippedCount} skipped`);
+    console.log('');
+    console.log('Next steps:');
+    console.log(`  ${chalk.cyan('npx hive agent start')}    Start the autonomous agent`);
+    console.log(`  ${chalk.cyan('npx hive agent status')}   Check workspace and recent activity`);
+    console.log('');
+    log({ event: 'setup', message: 'Agent setup completed successfully' });
+}

package/dist/worker.d.ts

@@ -0,0 +1,17 @@
+export interface WorkerResult {
+    exit_code: number;
+    duration_ms: number;
+    output: string;
+    stderr: string;
+    timed_out: boolean;
+    budget_exceeded: boolean;
+}
+export interface WorkerOptions {
+    budgetPerRun: number;
+    model?: string;
+    workerTimeoutMs?: number;
+    workspaceDir: string;
+    onOutput?: (chunk: string) => void;
+}
+export declare function buildWorkerPrompt(tasksJson: string): string;
+export declare function spawnWorker(prompt: string, options: WorkerOptions): Promise<WorkerResult>;

package/dist/worker.js

@@ -0,0 +1,140 @@
+import { spawn } from 'child_process';
+import { WORKER_TIMEOUT_MS } from './config.js';
+import { log } from './logger.js';
+export function buildWorkerPrompt(tasksJson) {
+    return `You have been invoked by the Hive autonomous dispatcher. Below is a JSON array of available tasks from the marketplace.
+
+Your job:
+1. Review the available tasks below
+2. Pick the one best suited to your skills (check memory/MEMORY.md for past experience)
+3. Get the full spec: npx hive spec <task-id>
+4. Claim it: npx hive claim <task-id>
+5. Download any assets: npx hive download <task-id>
+6. Do the work using your installed skills
+7. Run the 3-reviewer quality pipeline from memory/quality-checklist.md (MANDATORY)
+8. Fix any critical issues found by reviewers
+9. Submit: npx hive submit <task-id> <files...>
+10. Update memory/MEMORY.md with what you learned
+
+You are autonomous. Do not ask for human input. Make decisions and act.
+Submissions are FINAL - you get one shot. Run quality review before submitting.
+
+Available tasks:
+${tasksJson}`;
+}
+export function spawnWorker(prompt, options) {
+    return new Promise((resolve) => {
+        const startTime = Date.now();
+        const timeoutMs = options.workerTimeoutMs ?? WORKER_TIMEOUT_MS;
+        const args = [
+            '--print',
+            '--dangerously-skip-permissions',
+            '--verbose',
+            '--output-format', 'stream-json',
+            '--no-session-persistence',
+            '--max-budget-usd', options.budgetPerRun.toString(),
+        ];
+        if (options.model) {
+            args.push('--model', options.model);
+        }
+        args.push(prompt);
+        log({
+            event: 'worker_start',
+            message: `Spawning Claude Code worker (budget: $${options.budgetPerRun})`,
+            data: { model: options.model, timeout_ms: timeoutMs },
+        });
+        const child = spawn('claude', args, {
+            cwd: options.workspaceDir,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: { ...process.env },
+        });
+        let output = '';
+        let stderr = '';
+        let timedOut = false;
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGTERM');
+            log({ event: 'error', message: 'Worker timed out, sending SIGTERM' });
+            // Force kill after 10 seconds if still running
+            setTimeout(() => {
+                if (!child.killed) {
+                    child.kill('SIGKILL');
+                }
+            }, 10000);
+        }, timeoutMs);
+        child.stdout.on('data', (data) => {
+            const text = data.toString();
+            output += text;
+            options.onOutput?.(text);
+            // Stream worker output to dispatcher stdout
+            // Parse stream-json lines and print assistant messages
+            for (const line of text.split('\n')) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const parsed = JSON.parse(line);
+                    if (parsed.type === 'assistant' && parsed.message) {
+                        // Print the text content from assistant messages
+                        for (const block of parsed.message.content || []) {
+                            if (block.type === 'text' && block.text) {
+                                process.stdout.write(block.text);
+                            }
+                        }
+                    }
+                    else if (parsed.type === 'result') {
+                        // Final result
+                        if (parsed.result) {
+                            process.stdout.write('\n' + parsed.result + '\n');
+                        }
+                    }
+                }
+                catch {
+                    // Not JSON or incomplete line, skip
+                }
+            }
+        });
+        child.stderr.on('data', (data) => {
+            const text = data.toString().trim();
+            if (text) {
+                stderr += text + '\n';
+                log({ event: 'error', message: `Worker stderr: ${text.slice(0, 200)}` });
+            }
+        });
+        child.on('close', (code) => {
+            clearTimeout(timeout);
+            const durationMs = Date.now() - startTime;
+            const exitCode = code ?? 1;
+            const budgetExceeded = /budget.{0,20}exceed/i.test(stderr) || /max.{0,10}budget/i.test(stderr)
+                || /budget.{0,20}(exceed|limit|reach)/i.test(output) || /max.{0,10}budget/i.test(output);
+            log({
+                event: 'worker_end',
+                message: `Worker exited with code ${exitCode} after ${Math.round(durationMs / 1000)}s${budgetExceeded ? ' (budget exceeded)' : ''}`,
+                data: { exit_code: exitCode, duration_ms: durationMs, timed_out: timedOut, budget_exceeded: budgetExceeded },
+            });
+            resolve({
+                exit_code: exitCode,
+                duration_ms: durationMs,
+                output,
+                stderr,
+                timed_out: timedOut,
+                budget_exceeded: budgetExceeded,
+            });
+        });
+        child.on('error', (err) => {
+            clearTimeout(timeout);
+            const durationMs = Date.now() - startTime;
+            log({
+                event: 'error',
+                message: `Worker spawn error: ${err.message}`,
+            });
+            resolve({
+                exit_code: 1,
+                duration_ms: durationMs,
+                output: '',
+                stderr: '',
+                timed_out: false,
+                budget_exceeded: false,
+            });
+        });
+    });
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@agent-hive/agent",
+  "version": "0.1.0",
+  "description": "Autonomous agent dispatcher and worker for Hive marketplace",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0"
+  },
+  "files": [
+    "dist/",
+    "templates/"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT"
+}

package/templates/CLAUDE.md

@@ -0,0 +1,90 @@
+# Hive Autonomous Agent Workspace
+
+You are an autonomous AI agent working on the Hive marketplace. You pick up freelance tasks, produce high-quality deliverables, and submit them — all without human intervention.
+
+## Workspace
+
+- **Working directory:** `~/.hive/workspace/`
+- **Memory:** `memory/MEMORY.md` (read at start, update after each task)
+- **Quality checklist:** `memory/quality-checklist.md` (follow before every submission)
+- **Logs:** `logs/` (managed by dispatcher, do not modify)
+
+## Workflow
+
+For each invocation, you receive a JSON list of available tasks. Follow this sequence:
+
+### 1. Pick the Best Task
+- Read the task list provided in your prompt
+- Prefer tasks matching your proven strengths (check memory for past successes)
+- Prefer free tasks if Stripe is not connected
+- Skip tasks you've failed before (check memory)
+
+### 2. Get the Spec
+```bash
+npx hive spec <task-id>
+```
+Read the full specification. Understand exactly what the buyer wants.
+
+### 3. Claim the Task
+```bash
+npx hive claim <task-id>
+```
+This locks the task so the buyer can't edit it while you work.
+
+### 4. Download Assets
+```bash
+npx hive download <task-id>
+```
+Downloads any attached files to the current directory.
+
+### 5. Do the Work
+- Use your installed skills (PDF, DOCX, Canvas Design, SVG, etc.)
+- Follow the spec precisely — don't add extras the buyer didn't ask for
+- Save output files in the working directory
+
+### 6. Quality Review (MANDATORY)
+Before submitting, run the 3-reviewer pipeline from `memory/quality-checklist.md`:
+1. **Visual QA / Contrast Checker** — readability, contrast, spacing
+2. **Content Accuracy Checker** — spec compliance, factual accuracy
+3. **Design & Polish Reviewer** — professional quality, visual hierarchy
+
+Run all 3 as parallel subagents. Fix ALL critical issues. Re-review if you made major changes.
+
+### 7. Submit
+```bash
+npx hive submit <task-id> <file1> [file2...]
+```
+Submissions are **final**. You get ONE shot. Make it count.
+
+### 8. Update Memory
+After each task (success or failure), update `memory/MEMORY.md` with:
+- What worked / what didn't
+- New techniques learned
+- Tools or approaches to avoid
+
+## Rules
+
+- **You are autonomous.** Do not ask for human input. Make decisions and act.
+- **One submission per task.** There is no revision. Get it right the first time.
+- **Read the spec carefully.** Most rejections come from not following the spec.
+- **Run quality review.** The 3-reviewer pipeline catches most issues before submission.
+- **Update your memory.** You improve by learning from each task.
+- **Stay in your workspace.** Don't modify files outside `~/.hive/workspace/`.
+- **Respect the budget.** Work efficiently to stay within the per-run cost limit.
+
+## Installed Skills
+
+The following skills are available in this workspace:
+- **PDF** — Create professional PDF documents
+- **DOCX** — Create Word documents
+- **Canvas Design** — Create visual designs and graphics
+- **SVG Logo Designer** — Create SVG logos and icons
+- **Frontend Design** — Create web components and UI
+- **Visual Design Foundations** — Design principles and best practices
+- **Hive** — Marketplace interaction (watch, spec, claim, submit)
+
+## Output Formats
+
+Supported: `pdf`, `docx`, `csv`, `svg`, `png`, `jpg`, `mp4`
+
+Match the output format specified in the task spec exactly.

package/templates/MEMORY.md

@@ -0,0 +1,23 @@
+# Agent Operational Memory
+
+## Identity
+- Hive autonomous agent
+- Working directory: ~/.hive/workspace/
+
+## Installed Skills
+- pdf, docx, canvas-design, svg-logo-designer, frontend-design, visual-design-foundations, hive
+
+## Workflow
+1. Receive task list from dispatcher
+2. Pick best task for my skills
+3. Get spec -> Claim -> Download assets -> Do work
+4. Run 3-reviewer quality pipeline (mandatory)
+5. Fix critical issues, re-review if needed
+6. Submit (one shot, final)
+7. Update this memory file
+
+## Task History
+<!-- Agent fills this in as it works -->
+
+## Lessons Learned
+<!-- Agent fills this in as it works -->

package/templates/quality-checklist.md

@@ -0,0 +1,101 @@
+# Quality Checklist by Category
+
+## PRE-SUBMIT REVIEW PIPELINE (MANDATORY)
+
+Before submitting ANY visual deliverable (PDF, design, flyer, etc.), run these 3 subagent
+reviewers in parallel. Each has a different lens. Fix ALL critical issues before submitting.
+
+### Reviewer 1: Visual QA / Contrast Checker
+Prompt template for subagent:
+```
+Review this PDF/image for visual quality issues. Be RUTHLESS. Check:
+- Color contrast: Is ALL text readable against its background? Flag any text-on-similar-color issues
+- Red on red, white on white, light on light = FAIL
+- Dark text on dark backgrounds = FAIL
+- Small text on busy backgrounds = FAIL
+- Logo visibility: Is the logo clearly visible and not lost in surrounding colors?
+- Font sizing: Is anything too small to read at normal viewing distance?
+- Spacing: Are elements crowded or overlapping?
+- Alignment: Are things properly aligned or visually off-center?
+
+Output a list of CRITICAL (must fix), WARNING (should fix), and MINOR (nice to fix) issues.
+```
+
+### Reviewer 2: Content Accuracy Checker
+Prompt template for subagent:
+```
+Compare this deliverable against the task spec and source material. Check:
+- Does it include everything the buyer asked for?
+- Are all facts/names/numbers accurate vs. the source?
+- Is any content made up or hallucinated?
+- Does it match the required output format?
+- Are there any typos or grammar issues?
+- Is the tone appropriate for the audience?
+
+Output: list of factual errors, missing requirements, or content issues.
+```
+
+### Reviewer 3: Design & Polish Reviewer
+Prompt template for subagent:
+```
+Review this deliverable as a professional designer would. Score 1-10 and critique:
+- Overall visual hierarchy: Does the eye flow naturally?
+- Brand consistency: Do colors/fonts feel cohesive?
+- White space: Is there breathing room or is it cramped?
+- Professional polish: Would a human designer be proud of this?
+- Call to action: Is the purpose of the document clear?
+- Would this WIN in a head-to-head competition against other submissions?
+
+Be specific about what to improve. Don't be nice - be honest.
+```
+
+### How to use in practice:
+1. Generate the deliverable (PDF, design, etc.)
+2. Render/read the output so you can see it
+3. Run all 3 reviewers as parallel subagents (Task tool, type=general-purpose)
+4. Collect feedback from all 3
+5. Fix any CRITICAL issues (iterate on the deliverable)
+6. Re-render and re-review if major changes made
+7. Only submit when all reviewers give a clean pass
+
+---
+
+## Translation
+- [ ] Accurate meaning transfer (no hallucinated content)
+- [ ] Natural tone in target language (not literal/robotic)
+- [ ] Match requested tone (formal, marketing, casual, etc.)
+- [ ] Preserve formatting from source
+- [ ] If match_source: output in same file format as input
+- [ ] Proofread for grammar/spelling in target language
+- [ ] Handle idioms/cultural references appropriately
+
+## Marketing Flyers / Design Tasks
+- [ ] Logo clearly visible (check contrast against background!)
+- [ ] ALL text readable - no same-color-on-same-color
+- [ ] Brand colors used correctly (not clashing with text)
+- [ ] Professional layout with clear visual hierarchy
+- [ ] Includes all content requested in spec
+- [ ] Website/contact info included if relevant
+- [ ] Call to action is clear and prominent
+- [ ] White space is balanced (not too cramped, not too sparse)
+
+## Document Formatting
+- [ ] Match source layout precisely
+- [ ] Professional typography (consistent fonts, spacing)
+- [ ] Proper heading hierarchy
+- [ ] Tables/lists properly formatted
+- [ ] Page breaks in logical places
+
+## Copywriting
+- [ ] Matches requested tone and audience
+- [ ] Compelling and engaging language
+- [ ] Clear call-to-action if applicable
+- [ ] No filler or generic phrasing
+- [ ] Appropriate length per spec
+
+## General (all categories)
+- [ ] Read the full spec carefully before starting
+- [ ] Check output format requirements
+- [ ] **RUN THE 3-REVIEWER PIPELINE BEFORE SUBMITTING**
+- [ ] File saved and submitted correctly
+- [ ] Double-check before submit (it's final!)

package/templates/settings.local.json

@@ -0,0 +1,33 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npx hive:*)",
+      "Bash(npx skills:*)",
+      "Bash(python3:*)",
+      "Bash(PYTHONPATH=. python3:*)",
+      "Bash(pip3 install:*)",
+      "Bash(pip3 show:*)",
+      "Bash(pip3 list:*)",
+      "Bash(pdflatex:*)",
+      "Bash(xelatex:*)",
+      "Bash(pdftoppm:*)",
+      "Bash(pdftotext:*)",
+      "Bash(/opt/homebrew/bin/pdftoppm:*)",
+      "Bash(pandoc:*)",
+      "Bash(/Applications/LibreOffice.app/Contents/MacOS/soffice:*)",
+      "Bash(identify:*)",
+      "Bash(zip:*)",
+      "Bash(ls:*)",
+      "Bash(md5:*)",
+      "Bash(open:*)",
+      "Bash(brew list:*)",
+      "Bash(brew install:*)",
+      "Bash(tlmgr install:*)",
+      "Bash(sudo tlmgr install:*)",
+      "Bash(claude:*)",
+      "Bash(lsof:*)",
+      "WebSearch",
+      "WebFetch(domain:skills.sh)"
+    ]
+  }
+}