@eve-horizon/cli 0.0.1

package/dist/commands/job.js

@@ -0,0 +1,2266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleJob = handleJob;
+const child_process_1 = require("child_process");
+const args_1 = require("../lib/args");
+const client_1 = require("../lib/client");
+const output_1 = require("../lib/output");
+// ============================================================================
+// Main Handler
+// ============================================================================
+async function handleJob(subcommand, positionals, flags, context) {
+    const json = Boolean(flags.json);
+    switch (subcommand) {
+        case 'create':
+            return handleCreate(flags, context, json);
+        case 'list':
+            return handleList(flags, context, json);
+        case 'ready':
+            return handleReady(flags, context, json);
+        case 'blocked':
+            return handleBlocked(flags, context, json);
+        case 'show':
+            return handleShow(positionals, flags, context, json);
+        case 'current':
+            return handleCurrent(positionals, flags, context, json);
+        case 'diagnose':
+            return handleDiagnose(positionals, context, json);
+        case 'tree':
+            return handleTree(positionals, context, json);
+        case 'update':
+            return handleUpdate(positionals, flags, context, json);
+        case 'close':
+            return handleClose(positionals, flags, context, json);
+        case 'cancel':
+            return handleCancel(positionals, flags, context, json);
+        case 'dep':
+            return handleDep(positionals, flags, context, json);
+        case 'claim':
+            return handleClaim(positionals, flags, context, json);
+        case 'release':
+            return handleRelease(positionals, flags, context, json);
+        case 'attempts':
+            return handleAttempts(positionals, context, json);
+        case 'logs':
+            return handleLogs(positionals, flags, context, json);
+        case 'submit':
+            return handleSubmit(positionals, flags, context, json);
+        case 'approve':
+            return handleApprove(positionals, flags, context, json);
+        case 'reject':
+            return handleReject(positionals, flags, context, json);
+        case 'result':
+            return handleResult(positionals, flags, context);
+        case 'follow':
+            return handleFollow(positionals, flags, context);
+        case 'wait':
+            return handleWait(positionals, flags, context);
+        case 'watch':
+            return handleWatch(positionals, flags, context);
+        case 'runner-logs':
+            return handleRunnerLogs(positionals, flags, context);
+        default:
+            throw new Error('Usage: eve jobs <create|list|ready|blocked|show|current|diagnose|tree|update|close|cancel|dep|claim|release|attempts|logs|submit|approve|reject|result|follow|wait|watch|runner-logs>');
+    }
+}
+// ============================================================================
+// Subcommand Handlers
+// ============================================================================
+/**
+ * eve jobs create --project=X --description="..." [--title="..."] [--parent=X] [--type=task] [--priority=2] [--phase=ready] [--review=none|human|agent]
+ *
+ * --description is required (the work prompt sent to the harness)
+ * --title is optional (defaults to first 64 chars of description's first line)
+ *
+ * Scheduling hints (optional, used when scheduler claims the job):
+ *   --harness=mclaude:fast    Preferred harness (with optional :variant)
+ *   --worker-type=default     Worker type preference
+ *   --permission=auto_edit    Permission policy (default, auto_edit, yolo)
+ *   --timeout=3600            Execution timeout in seconds
+ *
+ * Environment options:
+ *   --env=<name>              Environment name for persistent execution
+ *   --execution-mode=<mode>   Execution mode: 'persistent' or 'ephemeral' (default: persistent)
+ *
+ * Inline execution:
+ *   --claim                   Create and immediately claim the job for execution
+ *   --agent=<id>              Agent ID for claim (default: $EVE_AGENT_ID or cli-user)
+ */
+async function handleCreate(flags, context, json) {
+    const parentId = (0, args_1.getStringFlag)(flags, ['parent']);
+    const projectId = (0, args_1.getStringFlag)(flags, ['project']) ?? context.projectId;
+    const description = (0, args_1.getStringFlag)(flags, ['description']);
+    let title = (0, args_1.getStringFlag)(flags, ['title']);
+    const issueType = (0, args_1.getStringFlag)(flags, ['type']) ?? 'task';
+    const priority = (0, args_1.getStringFlag)(flags, ['priority']);
+    const phase = (0, args_1.getStringFlag)(flags, ['phase']); // API defaults to 'ready'
+    const review = (0, args_1.getStringFlag)(flags, ['review']) ?? 'none';
+    const labels = (0, args_1.getStringFlag)(flags, ['labels']);
+    const assignee = (0, args_1.getStringFlag)(flags, ['assignee']);
+    const deferUntil = (0, args_1.getStringFlag)(flags, ['defer-until']);
+    const dueAt = (0, args_1.getStringFlag)(flags, ['due-at']);
+    // Scheduling hints
+    const harness = (0, args_1.getStringFlag)(flags, ['harness']);
+    const workerType = (0, args_1.getStringFlag)(flags, ['worker-type']);
+    const permission = (0, args_1.getStringFlag)(flags, ['permission']);
+    const timeout = (0, args_1.getStringFlag)(flags, ['timeout']);
+    // Environment options
+    const envName = (0, args_1.getStringFlag)(flags, ['env']);
+    const executionMode = (0, args_1.getStringFlag)(flags, ['execution-mode']) ?? 'persistent';
+    // Validate execution mode
+    if (executionMode !== 'persistent' && executionMode !== 'ephemeral') {
+        throw new Error('--execution-mode must be either "persistent" or "ephemeral"');
+    }
+    // Inline execution
+    const shouldClaim = Boolean(flags.claim);
+    const agentId = (0, args_1.getStringFlag)(flags, ['agent']) ?? process.env.EVE_AGENT_ID ?? 'cli-user';
+    // For root jobs, project is required. For child jobs, project is inherited from parent.
+    if (!parentId && !projectId) {
+        throw new Error('Usage: eve jobs create --project=<id> --description="..." [options]\n' +
+            '       eve jobs create --parent=<id> --description="..." [options]');
+    }
+    if (!description) {
+        throw new Error('--description is required (the work prompt)');
+    }
+    // Auto-generate title from first line of description if not provided
+    if (!title) {
+        const firstLine = description.split('\n')[0].trim();
+        title = firstLine.length > 64 ? firstLine.substring(0, 61) + '...' : firstLine;
+    }
+    const body = {
+        title,
+        description,
+        issue_type: issueType,
+        review_required: review,
+        execution_mode: executionMode,
+    };
+    // Add environment name (can be null)
+    body.env_name = envName ?? null;
+    if (parentId) {
+        body.parent_id = parentId;
+    }
+    if (phase) {
+        body.phase = phase;
+    }
+    if (priority !== undefined) {
+        body.priority = parseInt(priority, 10);
+    }
+    if (labels) {
+        body.labels = labels.split(',').map((l) => l.trim());
+    }
+    if (assignee) {
+        body.assignee = assignee;
+    }
+    if (deferUntil) {
+        body.defer_until = deferUntil;
+    }
+    if (dueAt) {
+        body.due_at = dueAt;
+    }
+    // Build hints object if any hint flags are provided
+    const hints = {};
+    if (harness)
+        hints.harness = harness;
+    if (workerType)
+        hints.worker_type = workerType;
+    if (permission)
+        hints.permission_policy = permission;
+    if (timeout)
+        hints.timeout_seconds = parseInt(timeout, 10);
+    if (Object.keys(hints).length > 0) {
+        body.hints = hints;
+    }
+    // Determine endpoint: root jobs use project endpoint, child jobs can use job-based endpoint
+    // For simplicity, always use project endpoint. If parent_id is set, the API inherits project from parent.
+    const resolvedProjectId = projectId ?? (parentId ? await getProjectFromJob(context, parentId) : undefined);
+    if (!resolvedProjectId) {
+        throw new Error('Could not determine project. Provide --project or ensure --parent exists.');
+    }
+    const response = await (0, client_1.requestJson)(context, `/projects/${resolvedProjectId}/jobs`, {
+        method: 'POST',
+        body,
+    });
+    // If --claim flag is set, immediately claim the job
+    if (shouldClaim) {
+        const claimBody = { agent_id: agentId };
+        // Use harness from hints if available
+        if (harness) {
+            claimBody.harness = harness;
+        }
+        const claimResponse = await (0, client_1.requestJson)(context, `/jobs/${response.id}/claim`, { method: 'POST', body: claimBody });
+        if (json) {
+            (0, output_1.outputJson)({ job: response, attempt: claimResponse.attempt }, json);
+        }
+        else {
+            console.log(`Created and claimed job: ${response.id}`);
+            console.log(`  Title:       ${response.title}`);
+            console.log(`  Phase:       active`);
+            console.log(`  Priority:    P${response.priority}`);
+            console.log(`  Attempt:     #${claimResponse.attempt.attempt_number}`);
+            console.log(`  Agent:       ${claimResponse.attempt.agent_id}`);
+            if (claimResponse.attempt.harness) {
+                console.log(`  Harness:     ${claimResponse.attempt.harness}`);
+            }
+            if (response.parent_id) {
+                console.log(`  Parent:      ${response.parent_id}`);
+            }
+        }
+        return;
+    }
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+    }
+    else {
+        console.log(`Created job: ${response.id}`);
+        console.log(`  Title:    ${response.title}`);
+        console.log(`  Phase:    ${response.phase}`);
+        console.log(`  Priority: P${response.priority}`);
+        if (response.parent_id) {
+            console.log(`  Parent:   ${response.parent_id}`);
+        }
+        if (Object.keys(hints).length > 0) {
+            console.log(`  Hints:    ${JSON.stringify(hints)}`);
+        }
+    }
+}
+/**
+ * Parse a relative time string (e.g., "1h", "30m", "2d") into an ISO timestamp
+ */
+function parseSinceValue(since) {
+    // If it looks like an ISO date, return as-is
+    if (since.includes('T') || since.includes('-')) {
+        return since;
+    }
+    const match = since.match(/^(\d+)([mhd])$/);
+    if (!match) {
+        throw new Error(`Invalid --since format: "${since}". Use formats like "1h", "30m", "2d", or ISO timestamp.`);
+    }
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    const now = new Date();
+    switch (unit) {
+        case 'm':
+            now.setMinutes(now.getMinutes() - value);
+            break;
+        case 'h':
+            now.setHours(now.getHours() - value);
+            break;
+        case 'd':
+            now.setDate(now.getDate() - value);
+            break;
+    }
+    return now.toISOString();
+}
+/**
+ * eve jobs list [--project=X] [--phase=ready] [--assignee=X] [--since=1h] [--stuck] [--limit=50] [--offset=0]
+ * eve jobs list --all [--org=X] [--project=X] [--phase=X] [--limit=50] [--offset=0]
+ */
+async function handleList(flags, context, json) {
+    // Check for --all flag (admin mode - cross-project listing)
+    const all = Boolean(flags.all);
+    if (all) {
+        // Admin mode: list all jobs across projects
+        const query = buildQuery({
+            org_id: (0, args_1.getStringFlag)(flags, ['org']),
+            project_id: (0, args_1.getStringFlag)(flags, ['project']),
+            phase: (0, args_1.getStringFlag)(flags, ['phase']),
+            limit: (0, args_1.getStringFlag)(flags, ['limit']) ?? '50',
+            offset: (0, args_1.getStringFlag)(flags, ['offset']),
+        });
+        const response = await (0, client_1.requestJson)(context, `/jobs${query}`);
+        if (json) {
+            (0, output_1.outputJson)(response, json);
+        }
+        else {
+            if (response.jobs.length === 0) {
+                console.log('No jobs found.');
+                return;
+            }
+            console.log('All jobs (admin view):');
+            console.log('');
+            formatJobsTable(response.jobs);
+        }
+        return;
+    }
+    // Standard mode: project-scoped listing
+    const projectId = (0, args_1.getStringFlag)(flags, ['project']) ?? context.projectId;
+    if (!projectId) {
+        throw new Error('Usage: eve jobs list --project=<id> [--phase=X] [--assignee=X] [--since=1h] [--stuck]\n       eve jobs list --all [--org=X] [--project=X] [--phase=X]');
+    }
+    // Parse --since into ISO timestamp
+    const sinceRaw = (0, args_1.getStringFlag)(flags, ['since']);
+    const since = sinceRaw ? parseSinceValue(sinceRaw) : undefined;
+    // --stuck is a boolean flag
+    const stuck = Boolean(flags.stuck);
+    const stuckMinutes = (0, args_1.getStringFlag)(flags, ['stuck-minutes']);
+    const query = buildQuery({
+        phase: (0, args_1.getStringFlag)(flags, ['phase']),
+        assignee: (0, args_1.getStringFlag)(flags, ['assignee']),
+        priority: (0, args_1.getStringFlag)(flags, ['priority']),
+        since,
+        stuck: stuck ? 'true' : undefined,
+        stuck_minutes: stuckMinutes,
+        limit: (0, args_1.getStringFlag)(flags, ['limit']),
+        offset: (0, args_1.getStringFlag)(flags, ['offset']),
+    });
+    const response = await (0, client_1.requestJson)(context, `/projects/${projectId}/jobs${query}`);
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+    }
+    else {
+        if (stuck && response.jobs.length === 0) {
+            console.log('No stuck jobs found.');
+            return;
+        }
+        formatJobsTable(response.jobs);
+    }
+}
+/**
+ * eve jobs ready [--project=X] [--limit=10]
+ * Shortcut for showing schedulable jobs
+ */
+async function handleReady(flags, context, json) {
+    const projectId = (0, args_1.getStringFlag)(flags, ['project']) ?? context.projectId;
+    if (!projectId) {
+        throw new Error('Usage: eve jobs ready --project=<id> [--limit=10]');
+    }
+    const query = buildQuery({
+        limit: (0, args_1.getStringFlag)(flags, ['limit']) ?? '10',
+    });
+    const response = await (0, client_1.requestJson)(context, `/projects/${projectId}/jobs/ready${query}`);
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+    }
+    else {
+        if (response.jobs.length === 0) {
+            console.log('No ready jobs found.');
+            return;
+        }
+        console.log('Ready jobs (schedulable):');
+        console.log('');
+        formatJobsTable(response.jobs);
+    }
+}
+/**
+ * eve jobs blocked [--project=X]
+ * Show jobs that are blocked by dependencies
+ */
+async function handleBlocked(flags, context, json) {
+    const projectId = (0, args_1.getStringFlag)(flags, ['project']) ?? context.projectId;
+    if (!projectId) {
+        throw new Error('Usage: eve jobs blocked --project=<id>');
+    }
+    const response = await (0, client_1.requestJson)(context, `/projects/${projectId}/jobs/blocked`);
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+    }
+    else {
+        if (response.jobs.length === 0) {
+            console.log('No blocked jobs found.');
+            return;
+        }
+        console.log('Blocked jobs (waiting on dependencies):');
+        console.log('');
+        formatJobsTable(response.jobs);
+    }
+}
+/**
+ * eve jobs show <id>
+ */
+async function handleShow(positionals, flags, context, json) {
+    const jobId = positionals[0];
+    const verbose = Boolean(flags.verbose || flags.v);
+    if (!jobId) {
+        throw new Error('Usage: eve jobs show <job-id> [--verbose]');
+    }
+    const job = await (0, client_1.requestJson)(context, `/jobs/${jobId}`);
+    // Fetch attempts if verbose
+    let attempts = [];
+    let latestAttempt;
+    if (verbose) {
+        const attemptsResponse = await (0, client_1.requestJson)(context, `/jobs/${jobId}/attempts`);
+        attempts = attemptsResponse.attempts || [];
+        // Get result details for the latest attempt
+        if (attempts.length > 0) {
+            const latest = attempts[attempts.length - 1];
+            try {
+                const result = await (0, client_1.requestJson)(context, `/jobs/${jobId}/result?attempt=${latest.attempt_number}`);
+                latestAttempt = { ...latest, result };
+            }
+            catch {
+                latestAttempt = { ...latest };
+            }
+        }
+    }
+    if (json) {
+        (0, output_1.outputJson)(verbose ? { ...job, attempts, latestAttempt } : job, json);
+    }
+    else {
+        formatJobDetails(job);
+        if (verbose && attempts.length > 0) {
+            formatAttemptsVerbose(attempts, latestAttempt);
+        }
+    }
+}
+/**
+ * eve jobs current [<job-id>] [--json|--tree]
+ * Defaults to EVE_JOB_ID when present
+ */
+async function handleCurrent(positionals, flags, context, json) {
+    const jobId = positionals[0] ?? process.env.EVE_JOB_ID;
+    const tree = (0, args_1.getBooleanFlag)(flags, ['tree']) ?? false;
+    if (!jobId) {
+        throw new Error('Usage: eve job current [<job-id>] [--json|--tree]');
+    }
+    if (tree) {
+        const response = await (0, client_1.requestJson)(context, `/jobs/${jobId}/tree`);
+        if (json) {
+            (0, output_1.outputJson)(response, json);
+        }
+        else {
+            formatJobTree(response, 0);
+        }
+        return;
+    }
+    const response = await requestJobContext(context, jobId);
+    (0, output_1.outputJson)(response, true);
+}
+/**
+ * eve jobs diagnose <id>
+ * Comprehensive job debugging - shows job state, attempts, timeline, logs, and recommendations
+ */
+async function handleDiagnose(positionals, context, json) {
+    const jobId = positionals[0];
+    if (!jobId) {
+        throw new Error('Usage: eve jobs diagnose <job-id>');
+    }
+    // Fetch job details
+    const job = await (0, client_1.requestJson)(context, `/jobs/${jobId}`);
+    // Fetch attempts
+    const attemptsResponse = await (0, client_1.requestJson)(context, `/jobs/${jobId}/attempts`);
+    const attempts = attemptsResponse.attempts || [];
+    // Fetch latest result
+    let latestResult = null;
+    if (attempts.length > 0) {
+        const latest = attempts[attempts.length - 1];
+        try {
+            latestResult = await (0, client_1.requestJson)(context, `/jobs/${jobId}/result?attempt=${latest.attempt_number}`);
+        }
+        catch {
+            // No result available
+        }
+    }
+    // Fetch recent logs (if we have attempts)
+    let logs = [];
+    if (attempts.length > 0) {
+        const latest = attempts[attempts.length - 1];
+        try {
+            const logsResponse = await (0, client_1.requestJson)(context, `/jobs/${jobId}/attempts/${latest.attempt_number}/logs?limit=50`);
+            logs = logsResponse.logs || [];
+        }
+        catch {
+            // No logs available
+        }
+    }
+    if (json) {
+        (0, output_1.outputJson)({ job, attempts, latestResult, logs }, json);
+    }
+    else {
+        formatDiagnose(job, attempts, latestResult, logs);
+    }
+}
+/**
+ * eve jobs tree <id>
+ * Show job hierarchy
+ */
+async function handleTree(positionals, context, json) {
+    const jobId = positionals[0];
+    if (!jobId) {
+        throw new Error('Usage: eve jobs tree <job-id>');
+    }
+    const response = await (0, client_1.requestJson)(context, `/jobs/${jobId}/tree`);
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+    }
+    else {
+        formatJobTree(response, 0);
+    }
+}
+/**
+ * eve jobs update <id> --phase=X --priority=X --assignee=X
+ */
+async function handleUpdate(positionals, flags, context, json) {
+    const jobId = positionals[0];
+    if (!jobId) {
+        throw new Error('Usage: eve jobs update <job-id> [--phase=X] [--priority=X] [--assignee=X]');
+    }
+    const body = {};
+    const phase = (0, args_1.getStringFlag)(flags, ['phase']);
+    const priority = (0, args_1.getStringFlag)(flags, ['priority']);
+    const assignee = (0, args_1.getStringFlag)(flags, ['assignee']);
+    const title = (0, args_1.getStringFlag)(flags, ['title']);
+    const description = (0, args_1.getStringFlag)(flags, ['description']);
+    const labels = (0, args_1.getStringFlag)(flags, ['labels']);
+    const deferUntil = (0, args_1.getStringFlag)(flags, ['defer-until']);
+    const dueAt = (0, args_1.getStringFlag)(flags, ['due-at']);
+    const review = (0, args_1.getStringFlag)(flags, ['review']);
+    if (phase)
+        body.phase = phase;
+    if (priority !== undefined)
+        body.priority = parseInt(priority, 10);
+    if (assignee)
+        body.assignee = assignee;
+    if (title)
+        body.title = title;
+    if (description)
+        body.description = description;
+    if (labels)
+        body.labels = labels.split(',').map((l) => l.trim());
+    if (deferUntil)
+        body.defer_until = deferUntil;
+    if (dueAt)
+        body.due_at = dueAt;
+    if (review)
+        body.review_required = review;
+    if (Object.keys(body).length === 0) {
+        throw new Error('No updates provided. Use --phase, --priority, --assignee, etc.');
+    }
+    const response = await (0, client_1.requestJson)(context, `/jobs/${jobId}`, {
+        method: 'PATCH',
+        body,
+    });
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+    }
+    else {
+        console.log(`Updated job: ${response.id}`);
+        console.log(`  Phase:    ${response.phase}`);
+        console.log(`  Priority: P${response.priority}`);
+        if (response.assignee) {
+            console.log(`  Assignee: ${response.assignee}`);
+        }
+    }
+}
+/**
+ * eve jobs close <id> [--reason="..."]
+ * Mark job as done
+ */
+async function handleClose(positionals, flags, context, json) {
+    const jobId = positionals[0];
+    if (!jobId) {
+        throw new Error('Usage: eve jobs close <job-id> [--reason="..."]');
+    }
+    const reason = (0, args_1.getStringFlag)(flags, ['reason']);
+    const body = {
+        phase: 'done',
+    };
+    if (reason) {
+        body.close_reason = reason;
+    }
+    const response = await (0, client_1.requestJson)(context, `/jobs/${jobId}`, {
+        method: 'PATCH',
+        body,
+    });
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+    }
+    else {
+        console.log(`Closed job: ${response.id}`);
+        console.log(`  Phase: ${response.phase}`);
+        if (response.close_reason) {
+            console.log(`  Reason: ${response.close_reason}`);
+        }
+    }
+}
+/**
+ * eve jobs cancel <id> [--reason="..."]
+ * Mark job as cancelled
+ */
+async function handleCancel(positionals, flags, context, json) {
+    const jobId = positionals[0];
+    if (!jobId) {
+        throw new Error('Usage: eve jobs cancel <job-id> [--reason="..."]');
+    }
+    const reason = (0, args_1.getStringFlag)(flags, ['reason']);
+    const body = {
+        phase: 'cancelled',
+    };
+    if (reason) {
+        body.close_reason = reason;
+    }
+    const response = await (0, client_1.requestJson)(context, `/jobs/${jobId}`, {
+        method: 'PATCH',
+        body,
+    });
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+    }
+    else {
+        console.log(`Cancelled job: ${response.id}`);
+        console.log(`  Phase: ${response.phase}`);
+        if (response.close_reason) {
+            console.log(`  Reason: ${response.close_reason}`);
+        }
+    }
+}
+/**
+ * eve jobs dep <add|remove|list> [args]
+ * Manage job dependencies
+ */
+async function handleDep(positionals, flags, context, json) {
+    const depSubcommand = positionals[0];
+    switch (depSubcommand) {
+        case 'add':
+            return handleDepAdd(positionals.slice(1), flags, context, json);
+        case 'remove':
+            return handleDepRemove(positionals.slice(1), context, json);
+        case 'list':
+            return handleDepList(positionals.slice(1), context, json);
+        default:
+            throw new Error('Usage: eve jobs dep <add|remove|list> [args]');
+    }
+}
+/**
+ * eve jobs dep add <from> <to> [--type=blocks]
+ * Add dependency: "from depends on to" (to blocks from)
+ */
+async function handleDepAdd(positionals, flags, context, json) {
+    const fromId = positionals[0];
+    const toId = positionals[1];
+    if (!fromId || !toId) {
+        throw new Error('Usage: eve jobs dep add <from> <to> [--type=blocks]');
+    }
+    const relationType = (0, args_1.getStringFlag)(flags, ['type']) ?? 'blocks';
+    const response = await (0, client_1.requestJson)(context, `/jobs/${fromId}/dependencies`, {
+        method: 'POST',
+        body: {
+            related_job_id: toId,
+            relation_type: relationType,
+        },
+    });
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+    }
+    else {
+        console.log(`Added dependency: ${fromId} depends on ${toId} (${relationType})`);
+    }
+}
+/**
+ * eve jobs dep remove <from> <to>
+ * Remove dependency
+ */
+async function handleDepRemove(positionals, context, json) {
+    const fromId = positionals[0];
+    const toId = positionals[1];
+    if (!fromId || !toId) {
+        throw new Error('Usage: eve jobs dep remove <from> <to>');
+    }
+    const response = await (0, client_1.requestJson)(context, `/jobs/${fromId}/dependencies/${toId}`, {
+        method: 'DELETE',
+    });
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+    }
+    else {
+        console.log(`Removed dependency: ${fromId} no longer depends on ${toId}`);
+    }
+}
+/**
+ * eve jobs dep list <id>
+ * Show dependencies and dependents for a job
+ */
+async function handleDepList(positionals, context, json) {
+    const jobId = positionals[0];
+    if (!jobId) {
+        throw new Error('Usage: eve jobs dep list <job-id>');
+    }
+    const response = await (0, client_1.requestJson)(context, `/jobs/${jobId}/dependencies`);
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+    }
+    else {
+        formatDependencies(response);
+    }
+}
+// ============================================================================
+// Helper Functions
+// ============================================================================
+async function requestJobContext(context, jobId) {
+    const response = await (0, client_1.requestRaw)(context, `/jobs/${jobId}/context`);
+    if (response.ok) {
+        return response.data;
+    }
+    if (response.status !== 404) {
+        const message = typeof response.data === 'string' ? response.data : response.text;
+        throw new Error(`HTTP ${response.status}: ${message}`);
+    }
+    const job = await (0, client_1.requestJson)(context, `/jobs/${jobId}`);
+    return { job };
+}
+function buildQuery(params) {
+    const search = new URLSearchParams();
+    Object.entries(params).forEach(([key, value]) => {
+        if (value === undefined || value === '')
+            return;
+        search.set(key, String(value));
+    });
+    const query = search.toString();
+    return query ? `?${query}` : '';
+}
+/**
+ * Get project ID from an existing job (used when creating child jobs)
+ */
+async function getProjectFromJob(context, jobId) {
+    try {
+        const job = await (0, client_1.requestJson)(context, `/jobs/${jobId}`);
+        return job.project_id;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Format jobs as a human-readable table
+ */
+function formatJobsTable(jobs) {
+    if (jobs.length === 0) {
+        console.log('No jobs found.');
+        return;
+    }
+    // Calculate column widths
+    const idWidth = Math.max(4, ...jobs.map((j) => j.id.length));
+    const phaseWidth = Math.max(5, ...jobs.map((j) => j.phase.length));
+    const titleWidth = Math.min(50, Math.max(5, ...jobs.map((j) => j.title.length)));
+    // Header
+    const header = [
+        padRight('ID', idWidth),
+        padRight('P', 2),
+        padRight('Phase', phaseWidth),
+        padRight('Type', 8),
+        padRight('Title', titleWidth),
+        'Assignee',
+    ].join('  ');
+    console.log(header);
+    console.log('-'.repeat(header.length));
+    // Rows
+    for (const job of jobs) {
+        const title = job.title.length > titleWidth ? job.title.slice(0, titleWidth - 3) + '...' : job.title;
+        const row = [
+            padRight(job.id, idWidth),
+            padRight(`P${job.priority}`, 2),
+            padRight(job.phase, phaseWidth),
+            padRight(job.issue_type, 8),
+            padRight(title, titleWidth),
+            job.assignee ?? '-',
+        ].join('  ');
+        console.log(row);
+    }
+    console.log('');
+    console.log(`Total: ${jobs.length} job(s)`);
+}
+/**
+ * Format a single job's details
+ */
+function formatJobDetails(job) {
+    console.log(`Job: ${job.id}`);
+    console.log('');
+    console.log(`  Title:       ${job.title}`);
+    console.log(`  Phase:       ${job.phase}`);
+    console.log(`  Priority:    P${job.priority}`);
+    console.log(`  Type:        ${job.issue_type}`);
+    console.log(`  Project:     ${job.project_id}`);
+    if (job.parent_id) {
+        console.log(`  Parent:      ${job.parent_id}`);
+    }
+    console.log(`  Depth:       ${job.depth}`);
+    if (job.description) {
+        console.log(`  Description: ${job.description}`);
+    }
+    if (job.labels && job.labels.length > 0) {
+        console.log(`  Labels:      ${job.labels.join(', ')}`);
+    }
+    if (job.assignee) {
+        console.log(`  Assignee:    ${job.assignee}`);
+    }
+    console.log(`  Review:      ${job.review_required}`);
+    if (job.review_status) {
+        console.log(`  Review Status: ${job.review_status}`);
+    }
+    if (job.reviewer) {
+        console.log(`  Reviewer:    ${job.reviewer}`);
+    }
+    if (job.defer_until) {
+        console.log(`  Defer Until: ${job.defer_until}`);
+    }
+    if (job.due_at) {
+        console.log(`  Due At:      ${job.due_at}`);
+    }
+    console.log('');
+    console.log(`  Created:     ${formatDate(job.created_at)}`);
+    console.log(`  Updated:     ${formatDate(job.updated_at)}`);
+    if (job.closed_at) {
+        console.log(`  Closed:      ${formatDate(job.closed_at)}`);
+    }
+    if (job.close_reason) {
+        console.log(`  Close Reason: ${job.close_reason}`);
+    }
+}
+/**
+ * Format attempts with verbose details (for --verbose flag)
+ */
+function formatAttemptsVerbose(attempts, latestAttempt) {
+    console.log('');
+    console.log('Attempts:');
+    for (const attempt of attempts) {
+        const isLatest = latestAttempt && attempt.id === latestAttempt.id;
+        const statusIcon = attempt.status === 'succeeded' ? '✓' :
+            attempt.status === 'failed' ? '✗' :
+                attempt.status === 'running' ? '▶' : '○';
+        console.log(`  ${statusIcon} Attempt #${attempt.attempt_number} (${attempt.status})`);
+        console.log(`      ID:       ${attempt.id}`);
+        console.log(`      Started:  ${formatDate(attempt.started_at)}`);
+        if (attempt.ended_at) {
+            console.log(`      Ended:    ${formatDate(attempt.ended_at)}`);
+        }
+        if (attempt.harness) {
+            console.log(`      Harness:  ${attempt.harness}`);
+        }
+        if (attempt.agent_id) {
+            console.log(`      Agent:    ${attempt.agent_id}`);
+        }
+        // Show result details for latest attempt
+        if (isLatest && latestAttempt?.result) {
+            const r = latestAttempt.result;
+            if (r.exitCode !== null) {
+                console.log(`      Exit:     ${r.exitCode}`);
+            }
+            if (r.durationMs !== null) {
+                console.log(`      Duration: ${(r.durationMs / 1000).toFixed(1)}s`);
+            }
+            if (r.errorMessage) {
+                console.log(`      Error:    ${r.errorMessage}`);
+            }
+            if (r.tokenInput || r.tokenOutput) {
+                console.log(`      Tokens:   ${r.tokenInput || 0} in / ${r.tokenOutput || 0} out`);
+            }
+        }
+        console.log('');
+    }
+}
+/**
+ * Format comprehensive diagnostic output
+ */
+function formatDiagnose(job, attempts, latestResult, logs) {
+    // Header
+    console.log('╭────────────────────────────────────────────────────────────────╮');
+    console.log(`│ Job Diagnosis: ${job.id.padEnd(47)} │`);
+    console.log('╰────────────────────────────────────────────────────────────────╯');
+    console.log('');
+    // Status summary
+    // Note: 'failed' is not a valid job phase - failures are 'cancelled' with a close_reason
+    const statusIcon = job.phase === 'done' ? '✓' :
+        job.phase === 'cancelled' ? '⊘' :
+            job.phase === 'active' ? '▶' : '○';
+    console.log(`Status: ${statusIcon} ${job.phase.toUpperCase()}`);
+    console.log(`  Priority:  P${job.priority}`);
+    console.log(`  Assignee:  ${job.assignee || '(none)'}`);
+    console.log(`  Created:   ${formatDate(job.created_at)}`);
+    console.log(`  Updated:   ${formatDate(job.updated_at)}`);
+    console.log('');
+    // Title and description
+    console.log(`Title: ${job.title}`);
+    if (job.description && job.description !== job.title) {
+        const desc = job.description.length > 200
+            ? job.description.substring(0, 200) + '...'
+            : job.description;
+        console.log(`Description: ${desc}`);
+    }
+    console.log('');
+    // Attempts timeline
+    console.log('Timeline:');
+    console.log(`  ${formatDate(job.created_at)} - Job created (phase: ready)`);
+    for (const attempt of attempts) {
+        const statusIcon = attempt.status === 'succeeded' ? '✓' :
+            attempt.status === 'failed' ? '✗' :
+                attempt.status === 'running' ? '▶' : '○';
+        console.log(`  ${formatDate(attempt.started_at)} - Attempt #${attempt.attempt_number} started`);
+        if (attempt.ended_at) {
+            console.log(`  ${formatDate(attempt.ended_at)} - Attempt #${attempt.attempt_number} ${statusIcon} ${attempt.status}`);
+        }
+    }
+    if (job.closed_at) {
+        console.log(`  ${formatDate(job.closed_at)} - Job closed (${job.phase})`);
+    }
+    console.log('');
+    // Lifecycle timeline from logs
+    const lifecycleLogs = logs.filter(l => l.type?.startsWith('lifecycle_'));
+    if (lifecycleLogs.length > 0) {
+        console.log('Execution Timeline:');
+        for (const log of lifecycleLogs) {
+            const content = log.line;
+            const phase = content?.phase || 'unknown';
+            const action = content?.action || '';
+            const duration = content?.duration_ms;
+            const success = content?.success;
+            const error = content?.error;
+            if (action === 'end') {
+                const durationStr = duration ? `${duration}ms` : '';
+                const statusIcon = success === false ? '✗' : '✓';
+                const errorStr = error ? ` - ${error.split('\n')[0]}` : '';
+                console.log(`  ${statusIcon} ${phase}: ${durationStr}${errorStr}`);
+            }
+        }
+        console.log('');
+    }
+    // Latest attempt details
+    if (attempts.length > 0) {
+        const latest = attempts[attempts.length - 1];
+        console.log(`Latest Attempt (#${latest.attempt_number}):`);
+        console.log(`  Status:    ${latest.status}`);
+        console.log(`  Harness:   ${latest.harness || '(default)'}`);
+        console.log(`  Agent:     ${latest.agent_id || '(none)'}`);
+        if (latestResult) {
+            if (latestResult.exitCode !== null) {
+                console.log(`  Exit Code: ${latestResult.exitCode}`);
+            }
+            if (latestResult.durationMs !== null) {
+                console.log(`  Duration:  ${(latestResult.durationMs / 1000).toFixed(1)}s`);
+            }
+            if (latestResult.errorMessage) {
+                console.log('');
+                console.log('Error Message:');
+                console.log(`  ${latestResult.errorMessage}`);
+            }
+        }
+        console.log('');
+    }
+    // Recent logs
+    if (logs.length > 0) {
+        console.log('Recent Logs:');
+        const recentLogs = logs.slice(-10);
+        for (const log of recentLogs) {
+            const time = formatDate(log.timestamp);
+            let msg = '';
+            try {
+                msg = log.line != null
+                    ? JSON.stringify(log.line).substring(0, 100)
+                    : '(empty)';
+            }
+            catch {
+                msg = '(error formatting log)';
+            }
+            console.log(`  ${time} ${msg}`);
+        }
+        console.log('');
+    }
+    // Diagnosis / recommendations
+    console.log('Diagnosis:');
+    if (job.phase === 'done') {
+        console.log('  ✓ Job completed successfully');
+    }
+    else if (job.phase === 'cancelled') {
+        // Cancelled jobs may have a failure reason in close_reason or attempt error
+        if (latestResult?.errorMessage?.includes('git clone')) {
+            console.log('  ✗ Git clone failed - check repo URL and credentials');
+            console.log('    Hint: Ensure GITHUB_TOKEN is set in project/org secrets');
+        }
+        else if (latestResult?.errorMessage?.includes('Service')) {
+            console.log('  ✗ Service provisioning failed');
+            console.log('    Hint: Check .eve/services.yaml and container logs');
+        }
+        else if (latestResult?.errorMessage) {
+            console.log(`  ⊘ Cancelled: ${latestResult.errorMessage}`);
+        }
+        else if (job.close_reason) {
+            console.log(`  ⊘ Cancelled: ${job.close_reason}`);
+        }
+        else {
+            console.log('  ⊘ Job was cancelled');
+        }
+    }
+    else if (job.phase === 'active' && attempts.length > 0) {
+        const latest = attempts[attempts.length - 1];
+        if (latest.status === 'running') {
+            const startedAt = new Date(latest.started_at).getTime();
+            const elapsed = Math.round((Date.now() - startedAt) / 1000);
+            if (elapsed > 300) {
+                console.log(`  ⚠ Attempt running for ${elapsed}s - may be stuck`);
+                console.log('    Hint: Check orchestrator/worker logs');
+            }
+            else {
+                console.log(`  ▶ Attempt in progress (${elapsed}s elapsed)`);
+            }
+        }
+    }
+    else if (job.phase === 'ready') {
+        console.log('  ○ Job is ready, waiting to be claimed');
+        if (job.assignee) {
+            console.log(`    Assigned to: ${job.assignee}`);
+        }
+    }
+}
+/**
+ * Format job hierarchy as a tree
+ */
+function formatJobTree(node, indent) {
+    const prefix = indent === 0 ? '' : '  '.repeat(indent - 1) + (indent > 0 ? '|- ' : '');
+    const phaseIcon = getPhaseIcon(node.phase);
+    const line = `${prefix}${phaseIcon} ${node.id} [P${node.priority}] ${node.title}`;
+    console.log(line);
+    if (node.children && node.children.length > 0) {
+        for (const child of node.children) {
+            formatJobTree(child, indent + 1);
+        }
+    }
+}
+/**
+ * Get an ASCII icon for a phase
+ */
+function getPhaseIcon(phase) {
+    switch (phase) {
+        case 'idea':
+            return '[?]';
+        case 'backlog':
+            return '[ ]';
+        case 'ready':
+            return '[>]';
+        case 'active':
+            return '[*]';
+        case 'review':
+            return '[R]';
+        case 'done':
+            return '[x]';
+        case 'cancelled':
+            return '[-]';
+        default:
+            return '[ ]';
+    }
+}
+/**
+ * Format a date string for display
+ */
+function formatDate(dateStr) {
+    try {
+        const date = new Date(dateStr);
+        return date.toLocaleString();
+    }
+    catch {
+        return dateStr;
+    }
+}
+/**
+ * Format dependencies output
+ */
+function formatDependencies(response) {
+    console.log('');
+    // Dependencies (jobs this one depends on)
+    if (response.dependencies.length > 0) {
+        console.log('Dependencies (this job depends on):');
+        for (const dep of response.dependencies) {
+            const phaseIcon = getPhaseIcon(dep.phase);
+            const isBlocking = response.blocking.some((b) => b.id === dep.id);
+            const blockingWarning = isBlocking ? ' ⚠️  BLOCKING' : '';
+            const relationType = dep.relation_type !== 'blocks' ? ` (${dep.relation_type})` : '';
+            console.log(`  ${dep.id} ${phaseIcon} "${dep.title}"${relationType}${blockingWarning}`);
+        }
+    }
+    else {
+        console.log('Dependencies (this job depends on): None');
+    }
+    console.log('');
+    // Dependents (jobs that depend on this one)
+    if (response.dependents.length > 0) {
+        console.log('Dependents (jobs depending on this):');
+        for (const dependent of response.dependents) {
+            const phaseIcon = getPhaseIcon(dependent.phase);
+            const relationType = dependent.relation_type !== 'blocks' ? ` (${dependent.relation_type})` : '';
+            console.log(`  ${dependent.id} ${phaseIcon} "${dependent.title}"${relationType}`);
+        }
+    }
+    else {
+        console.log('Dependents (jobs depending on this): None');
+    }
+    console.log('');
+}
+/**
+ * eve jobs claim <id> [--agent=X] [--harness=X]
+ * Claims a job, creating an attempt and transitioning to active phase
+ */
+async function handleClaim(positionals, flags, context, json) {
+    const jobId = positionals[0];
+    if (!jobId) {
+        throw new Error('Usage: eve jobs claim <job-id> [--agent=X] [--harness=X]');
+    }
+    const agentId = (0, args_1.getStringFlag)(flags, ['agent']) ?? 'cli-user';
+    const harness = (0, args_1.getStringFlag)(flags, ['harness']);
+    const body = {
+        agent_id: agentId,
+    };
+    if (harness) {
+        body.harness = harness;
+    }
+    const response = await (0, client_1.requestJson)(context, `/jobs/${jobId}/claim`, {
+        method: 'POST',
+        body,
+    });
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+    }
+    else {
+        console.log(`Claimed job: ${jobId}`);
+        console.log('');
+        console.log(`  Attempt:     #${response.attempt.attempt_number}`);
+        console.log(`  Attempt ID:  ${response.attempt.id}`);
+        console.log(`  Status:      ${response.attempt.status}`);
+        console.log(`  Agent:       ${response.attempt.agent_id}`);
+        if (response.attempt.harness) {
+            console.log(`  Harness:     ${response.attempt.harness}`);
+        }
+        console.log(`  Started:     ${formatDate(response.attempt.started_at)}`);
+    }
+}
+/**
+ * eve jobs release <id> [--agent=X] [--reason="..."]
+ * Releases a job, ending the current attempt and setting back to ready
+ */
+async function handleRelease(positionals, flags, context, json) {
+    const jobId = positionals[0];
+    if (!jobId) {
+        throw new Error('Usage: eve jobs release <job-id> [--agent=X] [--reason="..."]');
+    }
+    const agentId = (0, args_1.getStringFlag)(flags, ['agent']) ?? 'cli-user';
+    const reason = (0, args_1.getStringFlag)(flags, ['reason']);
+    const body = {
+        agent_id: agentId,
+    };
+    if (reason) {
+        body.reason = reason;
+    }
+    const response = await (0, client_1.requestJson)(context, `/jobs/${jobId}/release`, {
+        method: 'POST',
+        body,
+    });
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+    }
+    else {
+        console.log(`Released job: ${jobId}`);
+        console.log('');
+        console.log(`  Phase:       ${response.job.phase}`);
+        console.log(`  Assignee:    ${response.job.assignee ?? '(none)'}`);
+        if (reason) {
+            console.log(`  Reason:      ${reason}`);
+        }
+    }
+}
+/**
+ * eve jobs attempts <id>
+ * Lists all attempts for a job
+ */
+async function handleAttempts(positionals, context, json) {
+    const jobId = positionals[0];
+    if (!jobId) {
+        throw new Error('Usage: eve jobs attempts <job-id>');
+    }
+    const response = await (0, client_1.requestJson)(context, `/jobs/${jobId}/attempts`);
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+    }
+    else {
+        if (response.attempts.length === 0) {
+            console.log('No attempts found for this job.');
+            return;
+        }
+        console.log(`Attempts for job: ${jobId}`);
+        console.log('');
+        for (const attempt of response.attempts) {
+            const statusIcon = getStatusIcon(attempt.status);
+            const duration = attempt.ended_at
+                ? formatDuration(attempt.started_at, attempt.ended_at)
+                : 'running';
+            console.log(`${statusIcon} Attempt #${attempt.attempt_number} (${attempt.id})`);
+            console.log(`  Status:      ${attempt.status}`);
+            console.log(`  Trigger:     ${attempt.trigger_type}`);
+            if (attempt.agent_id) {
+                console.log(`  Agent:       ${attempt.agent_id}`);
+            }
+            if (attempt.harness) {
+                console.log(`  Harness:     ${attempt.harness}`);
+            }
+            console.log(`  Started:     ${formatDate(attempt.started_at)}`);
+            if (attempt.ended_at) {
+                console.log(`  Ended:       ${formatDate(attempt.ended_at)}`);
+            }
+            console.log(`  Duration:    ${duration}`);
+            if (attempt.result_summary) {
+                console.log(`  Summary:     ${attempt.result_summary}`);
+            }
+            console.log('');
+        }
+        console.log(`Total: ${response.attempts.length} attempt(s)`);
+    }
+}
+/**
+ * eve jobs logs <id> [--attempt=N] [--after=N] [--follow]
+ * View execution logs for a job attempt
+ */
+async function handleLogs(positionals, flags, context, json) {
+    const jobId = positionals[0];
+    if (!jobId) {
+        throw new Error('Usage: eve jobs logs <job-id> [--attempt=N] [--after=N]');
+    }
+    // Get attempt number (default to latest)
+    const attemptStr = (0, args_1.getStringFlag)(flags, ['attempt']);
+    let attemptNum;
+    if (attemptStr) {
+        attemptNum = parseInt(attemptStr, 10);
+    }
+    else {
+        // Find the latest attempt
+        const attemptsResponse = await (0, client_1.requestJson)(context, `/jobs/${jobId}/attempts`);
+        if (attemptsResponse.attempts.length === 0) {
+            console.log('No attempts found for this job.');
+            return;
+        }
+        attemptNum = Math.max(...attemptsResponse.attempts.map(a => a.attempt_number));
+    }
+    const afterStr = (0, args_1.getStringFlag)(flags, ['after']);
+    const afterQuery = afterStr ? `?after=${afterStr}` : '';
+    const response = await (0, client_1.requestJson)(context, `/jobs/${jobId}/attempts/${attemptNum}/logs${afterQuery}`);
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+    }
+    else {
+        if (response.logs.length === 0) {
+            console.log(`No logs found for attempt #${attemptNum}.`);
+            return;
+        }
+        console.log(`Logs for job ${jobId}, attempt #${attemptNum}:`);
+        console.log('');
+        for (const log of response.logs) {
+            formatLogEntry(log);
+        }
+        console.log('');
+        console.log(`Total: ${response.logs.length} log entries`);
+    }
+}
+/**
+ * Format a single log entry for display
+ */
+function formatLogEntry(log) {
+    const line = log.line;
+    const timestamp = new Date(log.timestamp).toLocaleTimeString();
+    // Common log line formats from harnesses
+    // Type can be at top level (from API) or inside line (from content)
+    const type = log.type || line.type || 'log';
+    // If type starts with 'lifecycle_', format as lifecycle event
+    if (type.startsWith('lifecycle_')) {
+        const content = line;
+        const phase = content.phase || 'unknown';
+        const action = content.action || 'unknown';
+        const duration = content.duration_ms;
+        const success = content.success;
+        const error = content.error;
+        const meta = content.meta || {};
+        if (action === 'start') {
+            const detail = formatLifecycleMeta(phase, meta);
+            console.log(`[${timestamp}] ${getLifecycleIcon(phase)} Starting ${phase}${detail}...`);
+        }
+        else if (action === 'end') {
+            const durationStr = duration ? ` (${duration}ms)` : '';
+            if (success === false && error) {
+                console.log(`[${timestamp}] ${getLifecycleIcon(phase)} ${capitalize(phase)} failed${durationStr}: ${error}`);
+            }
+            else {
+                console.log(`[${timestamp}] ${getLifecycleIcon(phase)} ${capitalize(phase)} completed${durationStr}`);
+            }
+        }
+        else if (action === 'log') {
+            const msg = meta.message || JSON.stringify(meta);
+            console.log(`[${timestamp}]   > ${msg}`);
+        }
+        return;
+    }
+    const message = line.message || line.text || '';
+    const tool = line.tool;
+    const toolInput = line.tool_input;
+    const toolResult = line.tool_result;
+    // Format based on log type
+    switch (type) {
+        case 'assistant':
+        case 'text':
+            console.log(`[${timestamp}] 🤖 ${message || JSON.stringify(line)}`);
+            break;
+        case 'tool_use':
+            console.log(`[${timestamp}] 🔧 ${tool || 'tool'}: ${toolInput || JSON.stringify(line)}`);
+            break;
+        case 'tool_result':
+            const resultPreview = (toolResult || '').substring(0, 100);
+            console.log(`[${timestamp}]    → ${resultPreview}${(toolResult?.length || 0) > 100 ? '...' : ''}`);
+            break;
+        case 'error':
+            console.log(`[${timestamp}] ❌ ${message || JSON.stringify(line)}`);
+            break;
+        case 'status':
+            console.log(`[${timestamp}] ℹ️  ${message || JSON.stringify(line)}`);
+            break;
+        default:
+            // Generic JSON output for unknown types
+            console.log(`[${timestamp}] ${JSON.stringify(line)}`);
+    }
+}
+/**
+ * Get icon for lifecycle phase
+ */
+function getLifecycleIcon(phase) {
+    switch (phase) {
+        case 'workspace': return '📁';
+        case 'hook': return '🪝';
+        case 'secrets': return '🔐';
+        case 'services': return '🐳';
+        case 'harness': return '🤖';
+        case 'runner': return '☸️';
+        default: return '⚙️';
+    }
+}
+/**
+ * Capitalize first letter of string
+ */
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+ * Format lifecycle metadata for display
+ */
+function formatLifecycleMeta(phase, meta) {
+    switch (phase) {
+        case 'workspace':
+            const repoUrl = meta.repo_url || '';
+            const branch = meta.branch || '';
+            return branch ? ` (${repoUrl}@${branch})` : repoUrl ? ` (${repoUrl})` : '';
+        case 'hook':
+            return meta.hook_name ? ` "${meta.hook_name}"` : '';
+        case 'secrets':
+            return '';
+        case 'services':
+            const svcName = meta.service_name || '';
+            return svcName ? ` "${svcName}"` : '';
+        case 'harness':
+            return meta.harness ? ` ${meta.harness}` : '';
+        case 'runner':
+            return meta.pod_name ? ` (${meta.pod_name})` : '';
+        default:
+            return '';
+    }
+}
+/**
+ * eve jobs submit <id> --summary="..."
+ * Submit a job for review
+ */
+async function handleSubmit(positionals, flags, context, json) {
+    const jobId = positionals[0];
+    if (!jobId) {
+        throw new Error('Usage: eve jobs submit <job-id> --summary="..."');
+    }
+    const summary = (0, args_1.getStringFlag)(flags, ['summary']);
+    if (!summary) {
+        throw new Error('--summary is required');
+    }
+    // Use a default agent ID if not provided (could be from context in future)
+    const agentId = (0, args_1.getStringFlag)(flags, ['agent-id']) ?? 'cli-user';
+    const body = {
+        agent_id: agentId,
+        summary,
+    };
+    const response = await (0, client_1.requestJson)(context, `/jobs/${jobId}/submit`, {
+        method: 'POST',
+        body,
+    });
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+    }
+    else {
+        console.log(`Submitted job for review: ${response.id}`);
+        console.log(`  Phase:         ${response.phase}`);
+        console.log(`  Review Status: ${response.review_status ?? 'N/A'}`);
+        console.log(`  Summary:       ${summary}`);
+    }
+}
+/**
+ * eve jobs approve <id> [--comment="..."]
+ * Approve a job in review
+ */
+async function handleApprove(positionals, flags, context, json) {
+    const jobId = positionals[0];
+    if (!jobId) {
+        throw new Error('Usage: eve jobs approve <job-id> [--comment="..."]');
+    }
+    const comment = (0, args_1.getStringFlag)(flags, ['comment']);
+    const reviewerId = (0, args_1.getStringFlag)(flags, ['reviewer-id']) ?? 'cli-user';
+    const body = {
+        reviewer_id: reviewerId,
+    };
+    if (comment) {
+        body.comment = comment;
+    }
+    const response = await (0, client_1.requestJson)(context, `/jobs/${jobId}/approve`, {
+        method: 'POST',
+        body,
+    });
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+    }
+    else {
+        console.log(`Approved job: ${response.id}`);
+        console.log(`  Phase:         ${response.phase}`);
+        console.log(`  Review Status: ${response.review_status ?? 'N/A'}`);
+        console.log(`  Reviewer:      ${response.reviewer ?? 'N/A'}`);
+        if (comment) {
+            console.log(`  Comment:       ${comment}`);
+        }
+    }
+}
+/**
+ * eve jobs reject <id> --reason="..."
+ * Reject a job in review
+ */
+async function handleReject(positionals, flags, context, json) {
+    const jobId = positionals[0];
+    if (!jobId) {
+        throw new Error('Usage: eve jobs reject <job-id> --reason="..."');
+    }
+    const reason = (0, args_1.getStringFlag)(flags, ['reason']);
+    if (!reason) {
+        throw new Error('--reason is required');
+    }
+    const reviewerId = (0, args_1.getStringFlag)(flags, ['reviewer-id']) ?? 'cli-user';
+    const body = {
+        reviewer_id: reviewerId,
+        reason,
+    };
+    const response = await (0, client_1.requestJson)(context, `/jobs/${jobId}/reject`, {
+        method: 'POST',
+        body,
+    });
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+    }
+    else {
+        console.log(`Rejected job: ${response.id}`);
+        console.log(`  Phase:         ${response.phase}`);
+        console.log(`  Review Status: ${response.review_status ?? 'N/A'}`);
+        console.log(`  Reviewer:      ${response.reviewer ?? 'N/A'}`);
+        console.log(`  Reason:        ${reason}`);
+        console.log('');
+        console.log('A new attempt has been created automatically for retry.');
+    }
+}
+/**
+ * eve jobs result <id> [--format=text|json|full] [--attempt=N]
+ * Fetch and display the result from a completed job attempt
+ */
+async function handleResult(positionals, flags, context) {
+    const jobId = positionals[0];
+    if (!jobId) {
+        throw new Error('Usage: eve jobs result <job-id> [--format=text|json|full] [--attempt=N]');
+    }
+    const format = (0, args_1.getStringFlag)(flags, ['format']) ?? 'text';
+    const attemptStr = (0, args_1.getStringFlag)(flags, ['attempt']);
+    // Validate format
+    if (!['text', 'json', 'full'].includes(format)) {
+        throw new Error('Invalid format. Use --format=text|json|full');
+    }
+    // Build query params
+    const query = attemptStr ? `?attempt=${attemptStr}` : '';
+    let response;
+    try {
+        response = await (0, client_1.requestJson)(context, `/jobs/${jobId}/result${query}`);
+    }
+    catch (error) {
+        const err = error;
+        // Check for specific error cases
+        if (err.statusCode === 404) {
+            console.error(`Error: Job '${jobId}' not found.`);
+            process.exit(1);
+        }
+        throw error;
+    }
+    // Handle job still running
+    if (response.status === 'running' || response.status === 'pending') {
+        console.error(`Error: Job is still ${response.status}. Use 'eve job wait ${jobId}' to wait for completion.`);
+        process.exit(1);
+    }
+    // Handle failed job
+    if (response.status === 'failed') {
+        console.error(`Job failed (attempt #${response.attemptNumber}):`);
+        if (response.errorMessage) {
+            console.error(`  ${response.errorMessage}`);
+        }
+        else {
+            console.error('  No error message available.');
+        }
+        process.exit(1);
+    }
+    // Format output based on --format flag
+    switch (format) {
+        case 'text':
+            formatResultText(response);
+            break;
+        case 'json':
+            formatResultJson(response);
+            break;
+        case 'full':
+            formatResultFull(response);
+            break;
+    }
+}
+/**
+ * Format result as plain text (default)
+ */
+function formatResultText(response) {
+    if (response.resultText) {
+        console.log(response.resultText);
+    }
+    else {
+        console.log('(no result text)');
+    }
+}
+/**
+ * Format result as JSON
+ */
+function formatResultJson(response) {
+    const output = {
+        success: response.status === 'succeeded',
+        exitCode: response.exitCode,
+        resultText: response.resultText,
+        resultJson: response.resultJson,
+        durationMs: response.durationMs,
+        tokenUsage: response.tokenInput !== null || response.tokenOutput !== null
+            ? { input: response.tokenInput, output: response.tokenOutput }
+            : null,
+    };
+    console.log(JSON.stringify(output, null, 2));
+}
+/**
+ * Format result with full details
+ */
+function formatResultFull(response) {
+    console.log(`Job: ${response.jobId}`);
+    console.log(`Attempt: ${response.attemptNumber}`);
+    console.log(`Status: ${response.status}`);
+    if (response.durationMs !== null) {
+        const durationSec = Math.round(response.durationMs / 1000);
+        console.log(`Duration: ${durationSec}s`);
+    }
+    if (response.tokenInput !== null || response.tokenOutput !== null) {
+        const inputStr = response.tokenInput !== null ? formatNumber(response.tokenInput) : '0';
+        const outputStr = response.tokenOutput !== null ? formatNumber(response.tokenOutput) : '0';
+        console.log(`Tokens: ${inputStr} in / ${outputStr} out`);
+    }
+    console.log('');
+    console.log('Result:');
+    if (response.resultText) {
+        console.log(response.resultText);
+    }
+    else {
+        console.log('(no result text)');
+    }
+}
+/**
+ * Format a number with commas for readability
+ */
+function formatNumber(num) {
+    return num.toLocaleString();
+}
+// Exit codes for wait command
+const EXIT_CODE_TIMEOUT = 124;
+const EXIT_CODE_CANCELLED = 125;
+/**
+ * eve job wait <id> [--timeout=300] [--quiet] [--verbose] [--json]
+ * Wait for a job to complete, polling the wait endpoint
+ */
+async function handleWait(positionals, flags, context) {
+    const jobId = positionals[0];
+    if (!jobId) {
+        throw new Error('Usage: eve job wait <job-id> [--timeout=300] [--quiet] [--verbose] [--json]');
+    }
+    const maxTimeout = parseInt((0, args_1.getStringFlag)(flags, ['timeout']) ?? '300', 10);
+    const quiet = Boolean(flags.quiet);
+    const verbose = Boolean(flags.verbose);
+    const json = Boolean(flags.json);
+    const startTime = Date.now();
+    let totalElapsed = 0;
+    // Track state changes for verbose mode
+    let lastPhase;
+    let lastStatus;
+    let lastPeriodicUpdate = 0;
+    const periodicUpdateInterval = 5; // seconds
+    // Progress output
+    if (!quiet && !json) {
+        if (verbose) {
+            console.log(`[0s] Waiting for job ${jobId}...`);
+        }
+        else {
+            console.log(`Waiting for ${jobId}...`);
+        }
+    }
+    // Poll with increasing timeout values to reduce request count
+    // Start with 5s, increase to 30s, cap at 60s per poll
+    let pollTimeout = 5;
+    while (totalElapsed < maxTimeout) {
+        // Calculate remaining time and cap poll timeout (must be integer for API)
+        const remainingTime = maxTimeout - totalElapsed;
+        const currentPollTimeout = Math.floor(Math.min(pollTimeout, remainingTime, 60));
+        const response = await (0, client_1.requestRaw)(context, `/jobs/${jobId}/wait?timeout=${currentPollTimeout}`);
+        if (response.status === 200) {
+            // Job completed - response.data is JobResultResponse
+            const result = response.data;
+            const totalDuration = Math.round((Date.now() - startTime) / 1000);
+            // Show error message immediately in verbose mode if job failed
+            if (verbose && !quiet && !json && result.status === 'failed' && result.errorMessage) {
+                console.log(`[${totalDuration}s] Job failed: ${result.errorMessage}`);
+            }
+            if (json) {
+                (0, output_1.outputJson)({
+                    jobId: result.jobId,
+                    status: result.status,
+                    exitCode: result.exitCode,
+                    durationMs: result.durationMs,
+                    resultText: result.resultText,
+                    resultJson: result.resultJson,
+                    waitDurationSeconds: totalDuration,
+                }, true);
+            }
+            else if (!quiet) {
+                if (verbose) {
+                    console.log(`[${totalDuration}s] Completed`);
+                }
+                else {
+                    console.log(`[+] Completed in ${totalDuration}s`);
+                }
+                console.log('');
+                if (result.resultText) {
+                    console.log(result.resultText);
+                }
+                else if (result.resultJson) {
+                    console.log(JSON.stringify(result.resultJson, null, 2));
+                }
+            }
+            // Exit with job's exit code or based on status
+            if (result.status === 'succeeded') {
+                process.exit(result.exitCode ?? 0);
+            }
+            else if (result.status === 'failed') {
+                process.exit(result.exitCode ?? 1);
+            }
+            else if (result.status === 'cancelled') {
+                process.exit(EXIT_CODE_CANCELLED);
+            }
+            // Default exit code
+            process.exit(result.exitCode ?? 0);
+        }
+        else if (response.status === 202) {
+            // Job still running - continue polling
+            const timeoutResponse = response.data;
+            totalElapsed = Math.round((Date.now() - startTime) / 1000);
+            if (!quiet && !json) {
+                if (verbose) {
+                    // Check for phase changes
+                    if (lastPhase !== undefined && lastPhase !== timeoutResponse.phase) {
+                        console.log(`[${totalElapsed}s] Phase: ${lastPhase} → ${timeoutResponse.phase}`);
+                    }
+                    lastPhase = timeoutResponse.phase;
+                    // Check for status changes
+                    if (lastStatus !== undefined && lastStatus !== timeoutResponse.status) {
+                        console.log(`[${totalElapsed}s] Status: ${lastStatus} → ${timeoutResponse.status}`);
+                    }
+                    lastStatus = timeoutResponse.status;
+                    // Show periodic elapsed time updates
+                    if (totalElapsed - lastPeriodicUpdate >= periodicUpdateInterval) {
+                        console.log(`[${totalElapsed}s] Still waiting... (phase: ${timeoutResponse.phase})`);
+                        lastPeriodicUpdate = totalElapsed;
+                    }
+                }
+                else {
+                    process.stdout.write(`\rWaiting for ${jobId}... (${totalElapsed}s, ${timeoutResponse.status})`);
+                }
+            }
+            // Increase poll timeout for next iteration (with cap)
+            pollTimeout = Math.min(pollTimeout * 1.5, 60);
+        }
+        else if (response.status === 404) {
+            console.error(`Error: Job '${jobId}' not found.`);
+            process.exit(1);
+        }
+        else {
+            // Unexpected error
+            const message = typeof response.data === 'string' ? response.data : response.text;
+            throw new Error(`HTTP ${response.status}: ${message}`);
+        }
+    }
+    // Overall timeout reached
+    if (!quiet && !json) {
+        console.log('');
+    }
+    if (json) {
+        (0, output_1.outputJson)({
+            jobId,
+            status: 'timeout',
+            message: `Timeout after ${maxTimeout}s`,
+            waitDurationSeconds: maxTimeout,
+        }, true);
+    }
+    else {
+        console.error(`Timeout: Job did not complete within ${maxTimeout}s.`);
+    }
+    process.exit(EXIT_CODE_TIMEOUT);
+}
+/**
+ * eve job watch <id> [--timeout=300]
+ * Watch a job by combining status polling + log streaming
+ * Shows phase/status changes like `wait --verbose` while streaming logs like `follow`
+ */
+async function handleWatch(positionals, flags, context) {
+    const jobId = positionals[0];
+    if (!jobId) {
+        throw new Error('Usage: eve job watch <job-id> [--timeout=300]');
+    }
+    const maxTimeout = parseInt((0, args_1.getStringFlag)(flags, ['timeout']) ?? '300', 10);
+    console.log(`Watching job ${jobId}...`);
+    const startTime = Date.now();
+    let lastPhase;
+    let lastStatus;
+    // Set up SSE log streaming
+    const url = `${context.apiUrl}/jobs/${jobId}/stream`;
+    const headers = {
+        Accept: 'text/event-stream',
+    };
+    if (context.token) {
+        headers.Authorization = `Bearer ${context.token}`;
+    }
+    let exitCode = 0;
+    let streamEnded = false;
+    let jobCompleted = false;
+    // Start status polling in background
+    const statusPollingPromise = (async () => {
+        while (!jobCompleted && !streamEnded) {
+            await new Promise(resolve => setTimeout(resolve, 3000)); // Poll every 3 seconds
+            if (jobCompleted || streamEnded)
+                break;
+            const elapsed = Math.round((Date.now() - startTime) / 1000);
+            // Check timeout
+            if (elapsed >= maxTimeout) {
+                console.log('');
+                console.error(`Timeout: Job did not complete within ${maxTimeout}s.`);
+                process.exit(EXIT_CODE_TIMEOUT);
+            }
+            try {
+                // Quick status check
+                const job = await (0, client_1.requestJson)(context, `/jobs/${jobId}`);
+                // Track phase changes
+                if (lastPhase !== undefined && lastPhase !== job.phase) {
+                    console.log(`[${elapsed}s] Phase: ${lastPhase} → ${job.phase}`);
+                }
+                lastPhase = job.phase;
+                // Check if job reached terminal state
+                // Note: 'failed' is not a valid job phase - only 'done' and 'cancelled' are terminal
+                if (job.phase === 'done' || job.phase === 'cancelled') {
+                    jobCompleted = true;
+                    break;
+                }
+                // Get latest attempt to track status changes
+                const attemptsResponse = await (0, client_1.requestJson)(context, `/jobs/${jobId}/attempts`);
+                if (attemptsResponse.attempts.length > 0) {
+                    const latest = attemptsResponse.attempts[attemptsResponse.attempts.length - 1];
+                    if (lastStatus !== undefined && lastStatus !== latest.status) {
+                        console.log(`[${elapsed}s] Attempt status: ${lastStatus} → ${latest.status}`);
+                    }
+                    lastStatus = latest.status;
+                }
+            }
+            catch (error) {
+                // Ignore errors during polling, rely on SSE stream
+            }
+        }
+    })();
+    // Start SSE log streaming
+    try {
+        const response = await fetch(url, { headers });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`HTTP ${response.status}: ${text}`);
+        }
+        if (!response.body) {
+            throw new Error('No response body received');
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            // Process complete SSE events from buffer
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? ''; // Keep incomplete line in buffer
+            let eventType = '';
+            let eventData = '';
+            for (const line of lines) {
+                if (line.startsWith('event:')) {
+                    eventType = line.slice(6).trim();
+                }
+                else if (line.startsWith('data:')) {
+                    eventData = line.slice(5).trim();
+                }
+                else if (line === '' && eventData) {
+                    // Empty line marks end of event
+                    exitCode = processWatchSSEEvent(eventType, eventData);
+                    if (exitCode !== -1) {
+                        // Event signals we should exit
+                        streamEnded = true;
+                        jobCompleted = true;
+                        await statusPollingPromise; // Wait for polling to finish
+                        process.exit(exitCode);
+                    }
+                    eventType = '';
+                    eventData = '';
+                }
+            }
+        }
+        // Process any remaining data
+        if (buffer.trim()) {
+            const remainingLines = buffer.split('\n');
+            let eventType = '';
+            let eventData = '';
+            for (const line of remainingLines) {
+                if (line.startsWith('event:')) {
+                    eventType = line.slice(6).trim();
+                }
+                else if (line.startsWith('data:')) {
+                    eventData = line.slice(5).trim();
+                }
+            }
+            if (eventData) {
+                exitCode = processWatchSSEEvent(eventType, eventData);
+                if (exitCode !== -1) {
+                    streamEnded = true;
+                    jobCompleted = true;
+                    await statusPollingPromise;
+                    process.exit(exitCode);
+                }
+            }
+        }
+        // Stream ended
+        streamEnded = true;
+        jobCompleted = true;
+        await statusPollingPromise;
+        const totalDuration = Math.round((Date.now() - startTime) / 1000);
+        console.log('');
+        console.log(`[${totalDuration}s] Stream ended.`);
+        process.exit(exitCode);
+    }
+    catch (error) {
+        streamEnded = true;
+        jobCompleted = true;
+        await statusPollingPromise;
+        const err = error;
+        console.error(`Error watching job: ${err.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Process a single SSE event for watch command
+ * Returns exit code if we should exit, or -1 to continue
+ */
+function processWatchSSEEvent(eventType, eventData) {
+    let parsed;
+    try {
+        parsed = JSON.parse(eventData);
+    }
+    catch {
+        // If we can't parse, ignore it
+        return -1;
+    }
+    // Handle different event types
+    switch (eventType) {
+        case 'log': {
+            const logEvent = parsed;
+            formatFollowLogLine(logEvent);
+            return -1;
+        }
+        case 'complete': {
+            const completeEvent = parsed;
+            console.log('');
+            console.log('[+] Completed');
+            if (completeEvent.result) {
+                console.log('');
+                console.log(completeEvent.result);
+            }
+            return completeEvent.exit_code ?? 0;
+        }
+        case 'error': {
+            const errorEvent = parsed;
+            console.log('');
+            console.log('[!] Error');
+            if (errorEvent.error) {
+                console.log(`  ${errorEvent.error}`);
+            }
+            return errorEvent.exit_code ?? 1;
+        }
+        default:
+            return -1;
+    }
+}
+/**
+ * eve job follow <id> [--raw] [--no-result]
+ * Stream logs from a running job in real-time via SSE
+ */
+async function handleFollow(positionals, flags, context) {
+    const jobId = positionals[0];
+    if (!jobId) {
+        throw new Error('Usage: eve job follow <job-id> [--raw] [--no-result]');
+    }
+    const raw = Boolean(flags.raw);
+    const showResult = !flags['no-result'];
+    console.log(`Following ${jobId}...`);
+    const url = `${context.apiUrl}/jobs/${jobId}/stream`;
+    const headers = {
+        Accept: 'text/event-stream',
+    };
+    if (context.token) {
+        headers.Authorization = `Bearer ${context.token}`;
+    }
+    let exitCode = 0;
+    try {
+        const response = await fetch(url, { headers });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`HTTP ${response.status}: ${text}`);
+        }
+        if (!response.body) {
+            throw new Error('No response body received');
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            // Process complete SSE events from buffer
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? ''; // Keep incomplete line in buffer
+            let eventType = '';
+            let eventData = '';
+            for (const line of lines) {
+                if (line.startsWith('event:')) {
+                    eventType = line.slice(6).trim();
+                }
+                else if (line.startsWith('data:')) {
+                    eventData = line.slice(5).trim();
+                }
+                else if (line === '' && eventData) {
+                    // Empty line marks end of event
+                    exitCode = processSSEEvent(eventType, eventData, raw, showResult);
+                    if (exitCode !== -1) {
+                        // Event signals we should exit
+                        process.exit(exitCode);
+                    }
+                    eventType = '';
+                    eventData = '';
+                }
+            }
+        }
+        // Process any remaining data
+        if (buffer.trim()) {
+            const remainingLines = buffer.split('\n');
+            let eventType = '';
+            let eventData = '';
+            for (const line of remainingLines) {
+                if (line.startsWith('event:')) {
+                    eventType = line.slice(6).trim();
+                }
+                else if (line.startsWith('data:')) {
+                    eventData = line.slice(5).trim();
+                }
+            }
+            if (eventData) {
+                exitCode = processSSEEvent(eventType, eventData, raw, showResult);
+                if (exitCode !== -1) {
+                    process.exit(exitCode);
+                }
+            }
+        }
+        // Stream ended without explicit complete/error event
+        console.log('');
+        console.log('Stream ended.');
+        process.exit(0);
+    }
+    catch (error) {
+        const err = error;
+        console.error(`Error following job: ${err.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Process a single SSE event
+ * Returns exit code if we should exit, or -1 to continue
+ */
+function processSSEEvent(eventType, eventData, raw, showResult) {
+    let parsed;
+    try {
+        parsed = JSON.parse(eventData);
+    }
+    catch {
+        // If we can't parse, treat as raw text
+        if (raw) {
+            console.log(eventData);
+        }
+        return -1;
+    }
+    // Handle different event types
+    switch (eventType) {
+        case 'log': {
+            const logEvent = parsed;
+            if (raw) {
+                console.log(JSON.stringify(logEvent));
+            }
+            else {
+                formatFollowLogLine(logEvent);
+            }
+            return -1;
+        }
+        case 'complete': {
+            const completeEvent = parsed;
+            if (raw) {
+                console.log(JSON.stringify(completeEvent));
+            }
+            else {
+                console.log('[+] Completed');
+                if (showResult && completeEvent.result) {
+                    console.log('');
+                    console.log(completeEvent.result);
+                }
+            }
+            return completeEvent.exit_code ?? 0;
+        }
+        case 'error': {
+            const errorEvent = parsed;
+            if (raw) {
+                console.log(JSON.stringify(errorEvent));
+            }
+            else {
+                console.log('[!] Error');
+                if (errorEvent.error) {
+                    console.log(`  ${errorEvent.error}`);
+                }
+            }
+            return errorEvent.exit_code ?? 1;
+        }
+        default: {
+            // Unknown event type, still output if raw mode
+            if (raw) {
+                console.log(JSON.stringify(parsed));
+            }
+            return -1;
+        }
+    }
+}
+/**
+ * Format a log line for human-readable output
+ */
+function formatFollowLogLine(event) {
+    const timestamp = new Date(event.timestamp).toLocaleTimeString();
+    const line = event.line;
+    const type = event.type || line.type || 'log';
+    // If type starts with 'lifecycle_', format as lifecycle event
+    if (type.startsWith('lifecycle_')) {
+        const content = line;
+        const phase = content.phase || 'unknown';
+        const action = content.action || 'unknown';
+        const duration = content.duration_ms;
+        const success = content.success;
+        const error = content.error;
+        const meta = content.meta || {};
+        if (action === 'start') {
+            const detail = formatLifecycleMeta(phase, meta);
+            console.log(`[${timestamp}] ${getLifecycleIcon(phase)} Starting ${phase}${detail}...`);
+        }
+        else if (action === 'end') {
+            const durationStr = duration ? ` (${duration}ms)` : '';
+            if (success === false && error) {
+                console.log(`[${timestamp}] ${getLifecycleIcon(phase)} ${capitalize(phase)} failed${durationStr}: ${error}`);
+            }
+            else {
+                console.log(`[${timestamp}] ${getLifecycleIcon(phase)} ${capitalize(phase)} completed${durationStr}`);
+            }
+        }
+        else if (action === 'log') {
+            const msg = meta.message || JSON.stringify(meta);
+            console.log(`[${timestamp}]   > ${msg}`);
+        }
+        return;
+    }
+    // Extract common fields
+    const message = line.message || line.text || '';
+    const tool = line.tool;
+    const toolInput = line.tool_input;
+    // Format based on event/log type
+    switch (type) {
+        case 'assistant':
+        case 'text':
+            if (message) {
+                console.log(`[${timestamp}] ${message}`);
+            }
+            break;
+        case 'tool_use':
+            if (tool) {
+                // Show tool name with optional truncated input
+                const inputPreview = toolInput ? ` ${toolInput.substring(0, 60)}${toolInput.length > 60 ? '...' : ''}` : '';
+                console.log(`[${timestamp}] Tool: ${tool}${inputPreview}`);
+            }
+            break;
+        case 'tool_result':
+            // Don't show tool results in follow mode (too verbose)
+            break;
+        case 'status':
+            console.log(`[${timestamp}] ${message || JSON.stringify(line)}`);
+            break;
+        case 'error':
+            console.log(`[${timestamp}] Error: ${message || JSON.stringify(line)}`);
+            break;
+        default:
+            // For unknown types, show as JSON if it has content
+            if (message) {
+                console.log(`[${timestamp}] ${message}`);
+            }
+            else if (Object.keys(line).length > 0) {
+                console.log(`[${timestamp}] ${JSON.stringify(line)}`);
+            }
+    }
+}
+/**
+ * Get status icon for attempt status
+ */
+function getStatusIcon(status) {
+    switch (status) {
+        case 'pending':
+            return '[⏸]';
+        case 'running':
+            return '[▶]';
+        case 'succeeded':
+            return '[✓]';
+        case 'failed':
+            return '[✗]';
+        case 'cancelled':
+            return '[○]';
+        default:
+            return '[ ]';
+    }
+}
+/**
+ * Format duration between two dates
+ */
+function formatDuration(startStr, endStr) {
+    try {
+        const start = new Date(startStr).getTime();
+        const end = new Date(endStr).getTime();
+        const durationMs = end - start;
+        const seconds = Math.floor(durationMs / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        if (hours > 0) {
+            const remainingMinutes = minutes % 60;
+            return `${hours}h ${remainingMinutes}m`;
+        }
+        if (minutes > 0) {
+            const remainingSeconds = seconds % 60;
+            return `${minutes}m ${remainingSeconds}s`;
+        }
+        return `${seconds}s`;
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/**
+ * Pad a string to the right with spaces
+ */
+function padRight(str, width) {
+    if (str.length >= width)
+        return str;
+    return str + ' '.repeat(width - str.length);
+}
+/**
+ * eve job runner-logs <id> [--attempt N]
+ * Stream K8s runner pod logs for a job
+ */
+async function handleRunnerLogs(positionals, flags, context) {
+    const jobId = positionals[0];
+    if (!jobId) {
+        throw new Error('Usage: eve job runner-logs <job-id> [--attempt N]');
+    }
+    const attemptStr = (0, args_1.getStringFlag)(flags, ['attempt']);
+    // Fetch job with attempts to get runtime_meta
+    const attemptsResponse = await (0, client_1.requestJson)(context, `/jobs/${jobId}/attempts`);
+    if (!attemptsResponse.attempts || attemptsResponse.attempts.length === 0) {
+        console.error(`No attempts found for job ${jobId}`);
+        process.exit(1);
+    }
+    // Select target attempt
+    let targetAttempt;
+    if (attemptStr) {
+        const attemptNum = parseInt(attemptStr, 10);
+        targetAttempt = attemptsResponse.attempts.find(a => a.attempt_number === attemptNum);
+        if (!targetAttempt) {
+            console.error(`Attempt #${attemptNum} not found for job ${jobId}`);
+            process.exit(1);
+        }
+    }
+    else {
+        // Use latest attempt
+        targetAttempt = attemptsResponse.attempts[attemptsResponse.attempts.length - 1];
+    }
+    if (!targetAttempt) {
+        console.error(`No attempt found for job ${jobId}`);
+        process.exit(1);
+    }
+    console.log(`Streaming logs for job ${jobId}, attempt #${targetAttempt.attempt_number}...`);
+    // Try to get pod_name from runtime_meta
+    const podName = targetAttempt.runtime_meta?.pod_name;
+    let kubectlArgs;
+    if (podName) {
+        // Use pod name directly
+        console.log(`Using pod: ${podName}`);
+        kubectlArgs = ['-n', 'eve', 'logs', '-f', podName];
+    }
+    else {
+        // Fall back to label-based lookup
+        console.log(`No pod_name in runtime_meta, using label selector: job-id=${jobId}`);
+        kubectlArgs = ['-n', 'eve', 'logs', '-f', '-l', `job-id=${jobId}`];
+    }
+    // Spawn kubectl process
+    const kubectl = (0, child_process_1.spawn)('kubectl', kubectlArgs, {
+        stdio: 'inherit',
+    });
+    // Handle process exit
+    return new Promise((resolve, reject) => {
+        kubectl.on('error', (error) => {
+            reject(new Error(`Failed to execute kubectl: ${error.message}`));
+        });
+        kubectl.on('exit', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                // Non-zero exit is common (e.g., pod terminated, not found)
+                // Don't treat as error
+                resolve();
+            }
+        });
+    });
+}