@a5c-ai/babysitter-sdk 0.0.169 → 0.0.170-staging.00aac85c

package/dist/cli/main.js

@@ -34,6 +34,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports._resolveRunDir = resolveRunDir;
+exports._collapseDoubledA5cRuns = collapseDoubledA5cRuns;
 exports.createBabysitterCli = createBabysitterCli;
 const node_fs_1 = require("node:fs");
 const path = __importStar(require("node:path"));
@@ -48,17 +50,42 @@ const tasks_1 = require("../storage/tasks");
 const journal_1 = require("../storage/journal");
 const runFiles_1 = require("../storage/runFiles");
 const runIterate_1 = require("./commands/runIterate");
-const completionSecret_1 = require("./completionSecret");
+const runExecuteTasks_1 = require("./commands/runExecuteTasks");
+const health_1 = require("./commands/health");
+const configure_1 = require("./commands/configure");
+const session_1 = require("./commands/session");
+const skill_1 = require("./commands/skill");
+const hookLog_1 = require("./commands/hookLog");
+const hookRun_1 = require("./commands/hookRun");
+const completionProof_1 = require("./completionProof");
+const exceptions_1 = require("../runtime/exceptions");
+const defaults_1 = require("../config/defaults");
+const session_2 = require("../session");
 const USAGE = `Usage:
-  babysitter run:create --process-id <id> --entry <path#export> [--runs-dir <dir>] [--inputs <file>] [--run-id <id>] [--process-revision <rev>] [--request <id>] [--json] [--dry-run]
+  babysitter run:create --process-id <id> --entry <path#export> [--runs-dir <dir>] [--inputs <file>] [--run-id <id>] [--process-revision <rev>] [--request <id>] [--prompt <text>] [--session-id <id>] [--plugin-root <dir>] [--json] [--dry-run]
   babysitter run:status <runDir> [--runs-dir <dir>] [--json]
   babysitter run:events <runDir> [--runs-dir <dir>] [--json] [--limit <n>] [--reverse] [--filter-type <type>]
   babysitter run:rebuild-state <runDir> [--runs-dir <dir>] [--json] [--dry-run]
   babysitter run:repair-journal <runDir> [--runs-dir <dir>] [--json] [--dry-run]
   babysitter run:iterate <runDir> [--runs-dir <dir>] [--json] [--verbose] [--iteration <n>]
+  babysitter run:execute-tasks <runDir> [--runs-dir <dir>] [--json] [--verbose] [--dry-run] [--max-tasks <n>] [--kind <kind>] [--timeout <ms>]
   babysitter task:post <runDir> <effectId> --status <ok|error> [--runs-dir <dir>] [--json] [--dry-run] [--value <file>] [--error <file>] [--stdout-ref <ref>] [--stderr-ref <ref>] [--stdout-file <file>] [--stderr-file <file>] [--started-at <iso8601>] [--finished-at <iso8601>] [--metadata <file>] [--invocation-key <key>]
   babysitter task:list <runDir> [--runs-dir <dir>] [--pending] [--kind <kind>] [--json]
   babysitter task:show <runDir> <effectId> [--runs-dir <dir>] [--json]
+  babysitter session:init --session-id <id> --state-dir <dir> [--max-iterations <n>] [--run-id <id>] [--prompt <text>] [--json]
+  babysitter session:associate --session-id <id> --state-dir <dir> --run-id <id> [--json]
+  babysitter session:resume --session-id <id> --state-dir <dir> --run-id <id> [--max-iterations <n>] [--runs-dir <dir>] [--json]
+  babysitter session:state --session-id <id> --state-dir <dir> [--json]
+  babysitter session:update --session-id <id> --state-dir <dir> [--iteration <n>] [--last-iteration-at <iso8601>] [--iteration-times <csv>] [--delete] [--json]
+  babysitter session:check-iteration --session-id <id> --state-dir <dir> [--json]
+  babysitter session:last-message --transcript-path <file> [--json]
+  babysitter session:iteration-message --iteration <n> [--run-id <id>] [--runs-dir <dir>] [--plugin-root <dir>] [--json]
+  babysitter skill:discover --plugin-root <dir> [--run-id <id>] [--cache-ttl <seconds>] [--runs-dir <dir>] [--include-remote] [--summary-only] [--process-path <path>] [--json]
+  babysitter hook:log --hook-type <type> --log-file <path> [--json]
+  babysitter hook:run --hook-type <stop|session-start> [--harness <claude-code>] [--plugin-root <dir>] [--state-dir <dir>] [--runs-dir <dir>] [--json] [--verbose]
+  babysitter skill:fetch-remote --source-type <github|well-known> --url <url> [--json]
+  babysitter health [--json] [--verbose]
+  babysitter configure [show|validate|paths] [--json] [--defaults-only]
   babysitter version
 
 Global flags:
@@ -66,20 +93,27 @@ Global flags:
   --json             Emit JSON output when supported by the command.
   --dry-run          Describe planned mutations without changing on-disk state.
   --verbose          Log resolved paths and options to stderr for debugging.
+  --show-config      Show current configuration before executing command.
   --help, -h         Show this help text.
   --version, -v      Show CLI version.`;
-const LARGE_RESULT_PREVIEW_LIMIT = 1024 * 1024; // 1 MiB
+/**
+ * Maximum size for inline result preview.
+ * @see DEFAULTS.largeResultPreviewLimit for the centralized default
+ */
+const LARGE_RESULT_PREVIEW_LIMIT = defaults_1.DEFAULTS.largeResultPreviewLimit;
 function parseArgs(argv) {
     const [initialCommand, ...rest] = argv;
     const parsed = {
         command: initialCommand,
-        runsDir: ".a5c/runs",
+        runsDir: process.env[defaults_1.CONFIG_ENV_VARS.RUNS_DIR] ?? defaults_1.DEFAULTS.runsDir,
         json: false,
         dryRun: false,
         verbose: false,
         helpRequested: false,
         pendingOnly: false,
         reverseOrder: false,
+        showConfig: false,
+        defaultsOnly: false,
     };
     if (parsed.command === "--help" || parsed.command === "-h") {
         parsed.command = undefined;
@@ -214,6 +248,105 @@ function parseArgs(argv) {
             parsed.requestId = expectFlagValue(rest, ++i, "--request");
             continue;
         }
+        if (arg === "--show-config") {
+            parsed.showConfig = true;
+            continue;
+        }
+        if (arg === "--defaults-only") {
+            parsed.defaultsOnly = true;
+            continue;
+        }
+        // Session command flags
+        if (arg === "--session-id") {
+            parsed.sessionId = expectFlagValue(rest, ++i, "--session-id");
+            continue;
+        }
+        if (arg === "--state-dir") {
+            parsed.stateDir = expectFlagValue(rest, ++i, "--state-dir");
+            continue;
+        }
+        if (arg === "--max-iterations") {
+            const raw = expectFlagValue(rest, ++i, "--max-iterations");
+            parsed.maxIterations = parsePositiveInteger(raw, "--max-iterations");
+            continue;
+        }
+        if (arg === "--prompt") {
+            parsed.prompt = expectFlagValue(rest, ++i, "--prompt");
+            continue;
+        }
+        if (arg === "--last-iteration-at") {
+            parsed.lastIterationAt = expectFlagValue(rest, ++i, "--last-iteration-at");
+            continue;
+        }
+        if (arg === "--iteration-times") {
+            parsed.iterationTimes = expectFlagValue(rest, ++i, "--iteration-times");
+            continue;
+        }
+        if (arg === "--max-tasks") {
+            const raw = expectFlagValue(rest, ++i, "--max-tasks");
+            parsed.maxTasks = parsePositiveInteger(raw, "--max-tasks");
+            continue;
+        }
+        if (arg === "--timeout") {
+            const raw = expectFlagValue(rest, ++i, "--timeout");
+            parsed.timeout = parsePositiveInteger(raw, "--timeout");
+            continue;
+        }
+        if (arg === "--delete") {
+            parsed.deleteSession = true;
+            continue;
+        }
+        if (arg === "--transcript-path") {
+            parsed.transcriptPath = expectFlagValue(rest, ++i, "--transcript-path");
+            continue;
+        }
+        // Hook command flags
+        if (arg === "--hook-type") {
+            parsed.hookType = expectFlagValue(rest, ++i, "--hook-type");
+            continue;
+        }
+        if (arg === "--harness") {
+            parsed.harness = expectFlagValue(rest, ++i, "--harness");
+            continue;
+        }
+        if (arg === "--log-file") {
+            parsed.logFile = expectFlagValue(rest, ++i, "--log-file");
+            continue;
+        }
+        // Skill command flags
+        if (arg === "--plugin-root") {
+            parsed.pluginRoot = expectFlagValue(rest, ++i, "--plugin-root");
+            continue;
+        }
+        if (arg === "--cache-ttl") {
+            const raw = expectFlagValue(rest, ++i, "--cache-ttl");
+            parsed.cacheTtl = parsePositiveInteger(raw, "--cache-ttl");
+            continue;
+        }
+        if (arg === "--source-type") {
+            const raw = expectFlagValue(rest, ++i, "--source-type");
+            if (raw !== "github" && raw !== "well-known") {
+                throw new Error(`--source-type must be "github" or "well-known" (received: ${raw})`);
+            }
+            parsed.sourceType = raw;
+            continue;
+        }
+        if (arg === "--url") {
+            parsed.url = expectFlagValue(rest, ++i, "--url");
+            continue;
+        }
+        if (arg === "--include-remote") {
+            parsed.includeRemote = true;
+            continue;
+        }
+        if (arg === "--summary-only") {
+            parsed.summaryOnly = true;
+            continue;
+        }
+        if (arg === "--process-path") {
+            parsed.processPath = expectFlagValue(rest, ++i, "--process-path");
+            continue;
+        }
         positionals.push(arg);
     }
     if (parsed.command === "task:post") {
@@ -234,18 +367,73 @@ function parseArgs(argv) {
     else if (parsed.command === "run:events") {
         [parsed.runDirArg] = positionals;
     }
+    else if (parsed.command === "run:execute-tasks") {
+        [parsed.runDirArg] = positionals;
+    }
     else if (parsed.command === "run:rebuild-state") {
         [parsed.runDirArg] = positionals;
     }
     else if (parsed.command === "run:repair-journal") {
         [parsed.runDirArg] = positionals;
     }
+    else if (parsed.command === "configure") {
+        [parsed.configureSubcommand] = positionals;
+    }
     return parsed;
 }
+/**
+ * Resolve a run directory from a base directory and a user-provided argument.
+ *
+ * Handles several common edge cases:
+ *  - Absolute paths are used directly (no base dir prepended).
+ *  - If the arg already contains the base dir prefix (e.g. ".a5c/runs/01RUN"
+ *    when base is ".a5c/runs"), it is resolved from CWD to avoid doubling.
+ *  - Doubled ".a5c/runs" segments in the final path are collapsed.
+ *  - If the resolved path doesn't exist, falls back to resolving from CWD.
+ */
 function resolveRunDir(baseDir, runDirArg) {
     if (!runDirArg)
         throw new Error("Run directory argument is required.");
-    return path.resolve(baseDir, runDirArg);
+    // Absolute path → use directly
+    if (path.isAbsolute(runDirArg)) {
+        return collapseDoubledA5cRuns(path.normalize(runDirArg));
+    }
+    // Detect if arg already starts with the base dir prefix to avoid
+    // ".a5c/runs" + ".a5c/runs/01RUN" → ".a5c/runs/.a5c/runs/01RUN"
+    const normalBase = normalizePosix(baseDir);
+    const normalArg = normalizePosix(runDirArg);
+    if (normalBase && (normalArg === normalBase || normalArg.startsWith(normalBase + "/"))) {
+        return collapseDoubledA5cRuns(path.resolve(runDirArg));
+    }
+    // Standard resolution: baseDir + arg
+    const standard = collapseDoubledA5cRuns(path.resolve(baseDir, runDirArg));
+    // Fallback: if the standard path doesn't exist, try from CWD
+    try {
+        if (!(0, node_fs_1.existsSync)(standard)) {
+            const fromCwd = path.resolve(runDirArg);
+            if ((0, node_fs_1.existsSync)(fromCwd))
+                return collapseDoubledA5cRuns(fromCwd);
+        }
+    }
+    catch {
+        // Ignore filesystem errors during resolution
+    }
+    return standard;
+}
+/** Normalize a path to forward slashes with no trailing slash (for prefix comparison). */
+function normalizePosix(p) {
+    return path.normalize(p).replace(/\\/g, "/").replace(/\/+$/, "");
+}
+/** Collapse doubled ".a5c/runs" segments: ".a5c/runs/.a5c/runs/X" → ".a5c/runs/X" */
+function collapseDoubledA5cRuns(p) {
+    // Match both forward and back-slash variants
+    const pattern = /([/\\]?\.a5c[/\\]runs)[/\\]\.a5c[/\\]runs([/\\]|$)/;
+    let result = p;
+    // Collapse repeatedly in case of triple+ duplication
+    while (pattern.test(result)) {
+        result = result.replace(pattern, "$1$2");
+    }
+    return result;
 }
 function expectFlagValue(args, index, flag) {
     const value = args[index];
@@ -484,6 +672,96 @@ async function readInputsFile(filePath) {
         throw new Error(`Failed to parse inputs file ${absolute} as JSON: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
+/**
+ * Dispatch session binding to the appropriate harness implementation.
+ */
+async function bindRunToHarnessSession(opts) {
+    switch (opts.harness) {
+        case "claude-code":
+            return bindRunToClaudeCodeSession(opts);
+        default:
+            // Unknown harness — return a descriptive error but don't fail the run
+            return {
+                harness: opts.harness,
+                sessionId: opts.sessionId,
+                error: `Unknown harness "${opts.harness}" — session not bound`,
+            };
+    }
+}
+/**
+ * Claude Code harness: create a session state file (markdown + YAML frontmatter)
+ * with the run ID already associated. Combines session:init + session:associate
+ * into a single atomic operation.
+ *
+ * State dir resolution: --state-dir flag > $PLUGIN_ROOT/skills/babysit/state
+ */
+async function bindRunToClaudeCodeSession(opts) {
+    const { sessionId, runId, pluginRoot, maxIterations = 256, prompt, verbose } = opts;
+    // Resolve state directory
+    let stateDir = opts.stateDir;
+    if (!stateDir && pluginRoot) {
+        stateDir = path.join(pluginRoot, "skills", "babysit", "state");
+    }
+    if (!stateDir) {
+        return {
+            harness: "claude-code",
+            sessionId,
+            error: "Cannot bind session: --state-dir or --plugin-root required for claude-code harness",
+        };
+    }
+    const filePath = (0, session_2.getSessionFilePath)(stateDir, sessionId);
+    // Check for existing session (prevent re-entrant runs)
+    if (await (0, session_2.sessionFileExists)(filePath)) {
+        try {
+            const existing = await (0, session_2.readSessionFile)(filePath);
+            if (existing.state.runId && existing.state.runId !== runId) {
+                return {
+                    harness: "claude-code",
+                    sessionId,
+                    stateFile: filePath,
+                    error: `Session already associated with run: ${existing.state.runId}`,
+                };
+            }
+            // Session exists but has no run or same run — update it
+            await (0, session_2.updateSessionState)(filePath, { runId, active: true }, {
+                state: existing.state,
+                prompt: existing.prompt,
+            });
+            if (verbose) {
+                process.stderr.write(`[run:create] Updated existing session ${sessionId} with run ${runId}\n`);
+            }
+            return { harness: "claude-code", sessionId, stateFile: filePath };
+        }
+        catch {
+            // Corrupted state file — overwrite it
+        }
+    }
+    // Create new session state file with run already associated
+    const now = (0, session_2.getCurrentTimestamp)();
+    const state = {
+        active: true,
+        iteration: 1,
+        maxIterations,
+        runId,
+        startedAt: now,
+        lastIterationAt: now,
+        iterationTimes: [],
+    };
+    try {
+        await (0, session_2.writeSessionFile)(filePath, state, prompt);
+    }
+    catch (e) {
+        return {
+            harness: "claude-code",
+            sessionId,
+            error: `Failed to write session state: ${e instanceof Error ? e.message : String(e)}`,
+        };
+    }
+    if (verbose) {
+        process.stderr.write(`[run:create] Session ${sessionId} initialized and bound to run ${runId}\n`);
+    }
+    return { harness: "claude-code", sessionId, stateFile: filePath };
+}
 async function handleRunCreate(parsed) {
     if (!parsed.processId) {
         console.error("--process-id is required for run:create");
@@ -513,6 +791,7 @@ async function handleRunCreate(parsed) {
         dryRun: parsed.dryRun,
         json: parsed.json,
         request: parsed.requestId,
+        prompt: parsed.prompt,
         processRevision: parsed.processRevision,
         runId: parsed.runIdOverride,
         inputsPath: parsed.inputsPath ? path.resolve(parsed.inputsPath) : undefined,
@@ -570,6 +849,7 @@ async function handleRunCreate(parsed) {
         runsDir,
         runId: parsed.runIdOverride,
         request: parsed.requestId,
+        prompt: parsed.prompt,
         processRevision: parsed.processRevision,
         process: {
             processId: parsed.processId,
@@ -579,11 +859,59 @@ async function handleRunCreate(parsed) {
         inputs,
     });
     const entrySpec = formatEntrypointSpecifier(result.metadata.entrypoint);
+    // --- Harness-specific session binding ---
+    // When --session-id and --harness are provided, bind the new run to the
+    // caller's session. Each harness has its own session management strategy.
+    let sessionBound;
+    const sessionId = parsed.sessionId || process.env.CLAUDE_SESSION_ID;
+    const harness = parsed.harness;
+    if (sessionId && harness) {
+        sessionBound = await bindRunToHarnessSession({
+            harness,
+            sessionId,
+            runId: result.runId,
+            runDir: result.runDir,
+            pluginRoot: parsed.pluginRoot || process.env.CLAUDE_PLUGIN_ROOT,
+            stateDir: parsed.stateDir,
+            maxIterations: parsed.maxIterations,
+            prompt: parsed.prompt ?? "",
+            verbose: parsed.verbose,
+            json: parsed.json,
+        });
+    }
+    // Discover available skills and agents for the new run
+    let discoveredSkills;
+    let discoveredAgents;
+    const discoverPluginRoot = parsed.pluginRoot || process.env.CLAUDE_PLUGIN_ROOT;
+    if (discoverPluginRoot) {
+        try {
+            const discoverResult = await (0, skill_1.discoverSkillsInternal)({
+                pluginRoot: discoverPluginRoot,
+                runId: result.runId,
+                runsDir: parsed.runsDir,
+            });
+            discoveredSkills = discoverResult.skills.map(s => s.name);
+            discoveredAgents = discoverResult.agents.map(a => a.name);
+        }
+        catch {
+            // Non-fatal
+        }
+    }
     if (parsed.json) {
-        console.log(JSON.stringify({ runId: result.runId, runDir: result.runDir, entry: entrySpec }));
+        console.log(JSON.stringify({
+            runId: result.runId,
+            runDir: result.runDir,
+            entry: entrySpec,
+            session: sessionBound ?? undefined,
+            discoveredSkills,
+            discoveredAgents,
+        }));
     }
     else {
         console.log(`[run:create] runId=${result.runId} runDir=${result.runDir} entry=${entrySpec}`);
+        if (sessionBound) {
+            console.log(`[run:create] session=${sessionId} bound via ${harness}`);
+        }
     }
     return 0;
 }
@@ -618,20 +946,29 @@ async function handleRunStatus(parsed) {
     const lastLifecycleEvent = findLastLifecycleEvent(journal);
     const state = deriveRunState(lastLifecycleEvent?.type, pendingTotal);
     const lastSummary = formatLastEventSummary(lastEvent);
+    const autoRunnableCount = pendingRecords.filter(r => r.kind === "node").length;
+    const pendingEffectsSummary = {
+        totalPending: pendingTotal,
+        countsByKind: pendingByKind,
+        autoRunnableCount,
+    };
+    const needsMoreIterations = state === "waiting" && autoRunnableCount > 0;
     if (parsed.json) {
-        const completionSecret = state === "completed" ? (0, completionSecret_1.resolveCompletionSecret)(metadata) : null;
+        const completionProof = state === "completed" ? (0, completionProof_1.resolveCompletionProof)(metadata) : null;
         console.log(JSON.stringify({
             state,
             lastEvent: lastEvent ? serializeJournalEvent(lastEvent, runDir) : null,
             pendingByKind,
+            pendingEffectsSummary,
+            needsMoreIterations,
             metadata: formattedMetadata.jsonMetadata ?? null,
-            completionSecret,
+            completionProof,
         }));
         return 0;
     }
     const suffix = formattedMetadata.textParts.length ? ` ${formattedMetadata.textParts.join(" ")}` : "";
-    const completionSecret = state === "completed" ? (0, completionSecret_1.resolveCompletionSecret)(metadata) : undefined;
-    const secretSuffix = completionSecret ? ` completionSecret=${completionSecret}` : "";
+    const completionProof = state === "completed" ? (0, completionProof_1.resolveCompletionProof)(metadata) : undefined;
+    const secretSuffix = completionProof ? ` completionProof=${completionProof}` : "";
     console.log(`[run:status] state=${state} last=${lastSummary}${suffix}${secretSuffix}`);
     return 0;
 }
@@ -653,6 +990,7 @@ async function handleRunIterate(parsed) {
             iteration: parsed.iteration,
             verbose: parsed.verbose,
             json: parsed.json,
+            pluginRoot: parsed.pluginRoot || process.env.CLAUDE_PLUGIN_ROOT,
         });
         if (parsed.json) {
             console.log(JSON.stringify(result, null, 2));
@@ -660,9 +998,10 @@ async function handleRunIterate(parsed) {
         else {
             const countInfo = result.count ? ` count=${result.count}` : "";
             const actionInfo = result.action ? ` action=${result.action}` : "";
-            console.log(`[run:iterate] iteration=${result.iteration} status=${result.status}${actionInfo}${countInfo} reason=${result.reason}`);
-            if (result.status === "completed" && result.completionSecret) {
-                console.log(`[run:iterate] completionSecret=${result.completionSecret}`);
+            const progressInfo = result.iterationCount > 0 ? ` (${result.iterationCount} completed)` : "";
+            console.log(`[run:iterate] iteration=${result.iteration}${progressInfo} status=${result.status}${actionInfo}${countInfo} reason=${result.reason}`);
+            if (result.status === "completed" && result.completionProof) {
+                console.log(`[run:iterate] completionProof=${result.completionProof}`);
             }
             if (result.status === "waiting" && result.until) {
                 console.log(`[run:iterate] Waiting until: ${new Date(result.until).toISOString()}`);
@@ -675,6 +1014,47 @@ async function handleRunIterate(parsed) {
         return 1;
     }
 }
+async function handleRunExecuteTasks(parsed) {
+    if (!parsed.runDirArg) {
+        console.error(USAGE);
+        return 1;
+    }
+    const runDir = resolveRunDir(parsed.runsDir, parsed.runDirArg);
+    logVerbose("run:execute-tasks", parsed, {
+        runDir,
+        maxTasks: parsed.maxTasks,
+        kind: parsed.kindFilter,
+        timeout: parsed.timeout,
+        dryRun: parsed.dryRun,
+        json: parsed.json,
+        verbose: parsed.verbose,
+    });
+    try {
+        const result = await (0, runExecuteTasks_1.runExecuteTasks)({
+            runDir,
+            maxTasks: parsed.maxTasks,
+            kind: parsed.kindFilter,
+            timeout: parsed.timeout,
+            verbose: parsed.verbose,
+            json: parsed.json,
+            dryRun: parsed.dryRun,
+        });
+        if (parsed.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            const taskSummary = result.tasks.length > 0
+                ? ` tasks=[${result.tasks.map((t) => `${t.effectId}:${t.status}`).join(",")}]`
+                : "";
+            console.log(`[run:execute-tasks] action=${result.action} count=${result.count} reason=${result.reason}${taskSummary}`);
+        }
+        return 0;
+    }
+    catch (error) {
+        console.error(`[run:execute-tasks] Error: ${error instanceof Error ? error.message : String(error)}`);
+        return 1;
+    }
+}
 async function handleRunEvents(parsed) {
     if (!parsed.runDirArg) {
         console.error(USAGE);
@@ -1363,11 +1743,126 @@ async function readCliVersion() {
     const parsed = JSON.parse(raw);
     return parsed.version ?? "unknown";
 }
+/**
+ * Checks if stdout/stderr supports colors
+ */
+function supportsColors() {
+    // Check NO_COLOR environment variable (https://no-color.org/)
+    if (process.env.NO_COLOR !== undefined) {
+        return false;
+    }
+    // Check FORCE_COLOR environment variable
+    if (process.env.FORCE_COLOR !== undefined) {
+        return true;
+    }
+    // Check if running in a TTY
+    if (process.stderr && typeof process.stderr.isTTY === "boolean") {
+        return process.stderr.isTTY;
+    }
+    return false;
+}
+/**
+ * Valid CLI commands
+ */
+const VALID_COMMANDS = [
+    "run:create",
+    "run:status",
+    "run:iterate",
+    "run:events",
+    "run:rebuild-state",
+    "run:repair-journal",
+    "run:execute-tasks",
+    "task:post",
+    "task:list",
+    "task:show",
+    "session:init",
+    "session:associate",
+    "session:resume",
+    "session:state",
+    "session:update",
+    "session:check-iteration",
+    "session:last-message",
+    "session:iteration-message",
+    "hook:log",
+    "hook:run",
+    "skill:discover",
+    "skill:fetch-remote",
+    "health",
+    "configure",
+    "version",
+];
+/**
+ * Handles unknown commands with suggestions
+ */
+function handleUnknownCommand(command, json) {
+    const suggestion = (0, exceptions_1.suggestCommand)(command);
+    const suggestions = suggestion ? [`Did you mean: ${suggestion}?`] : [];
+    const nextSteps = ["Run with --help to see all available commands"];
+    const error = new exceptions_1.BabysitterRuntimeError("UnknownCommandError", `Unknown command: ${command}`, {
+        category: exceptions_1.ErrorCategory.Validation,
+        suggestions,
+        nextSteps,
+        details: { command, validCommands: VALID_COMMANDS },
+    });
+    if (json) {
+        console.error(JSON.stringify((0, exceptions_1.toStructuredError)(error)));
+    }
+    else {
+        const colors = supportsColors();
+        console.error((0, exceptions_1.formatErrorWithContext)(error, { colors }));
+    }
+    return 1;
+}
+/**
+ * Shows configuration before executing a command when --show-config is provided
+ */
+async function showConfigBeforeCommand(parsed) {
+    const { configureShow } = await Promise.resolve().then(() => __importStar(require("./commands/configure")));
+    const result = configureShow({ json: parsed.json, defaultsOnly: false });
+    if (parsed.json) {
+        console.error(JSON.stringify({ showConfig: result }, null, 2));
+    }
+    else {
+        console.error("[show-config] Current effective configuration:");
+        for (const item of result.values) {
+            const sourceTag = item.source === "env" ? " (env)" : "";
+            console.error(`  ${item.key}=${formatVerboseValue(item.value)}${sourceTag}`);
+        }
+        console.error("");
+    }
+}
+/**
+ * Formats and outputs an error in the appropriate format
+ */
+function outputError(error, options) {
+    const { json, verbose = false } = options;
+    if (json) {
+        console.error(JSON.stringify((0, exceptions_1.toStructuredError)(error, verbose)));
+    }
+    else {
+        const colors = supportsColors();
+        if ((0, exceptions_1.isBabysitterError)(error)) {
+            console.error((0, exceptions_1.formatErrorWithContext)(error, { colors, includeStack: verbose }));
+        }
+        else {
+            // For non-babysitter errors, wrap them with basic formatting
+            const wrappedError = new exceptions_1.BabysitterRuntimeError(error.name || "Error", error.message, {
+                category: exceptions_1.ErrorCategory.Internal,
+                nextSteps: ["If this error persists, please report it as a bug"],
+            });
+            console.error((0, exceptions_1.formatErrorWithContext)(wrappedError, { colors, includeStack: verbose }));
+        }
+    }
+}
 function createBabysitterCli() {
     return {
         async run(argv = process.argv.slice(2)) {
+            let parsedJson = false;
+            let parsedVerbose = false;
             try {
                 const parsed = parseArgs(argv);
+                parsedJson = parsed.json;
+                parsedVerbose = parsed.verbose;
                 if (parsed.command === "version") {
                     console.log(await readCliVersion());
                     return 0;
@@ -1376,6 +1871,14 @@ function createBabysitterCli() {
                     console.log(USAGE);
                     return 0;
                 }
+                // Show config if --show-config flag is provided
+                if (parsed.showConfig) {
+                    await showConfigBeforeCommand(parsed);
+                }
+                // Check for valid commands and provide suggestions for unknown ones
+                if (!VALID_COMMANDS.includes(parsed.command)) {
+                    return handleUnknownCommand(parsed.command, parsed.json);
+                }
                 if (parsed.command === "run:create") {
                     return await handleRunCreate(parsed);
                 }
@@ -1391,6 +1894,9 @@ function createBabysitterCli() {
                 if (parsed.command === "run:iterate") {
                     return await handleRunIterate(parsed);
                 }
+                if (parsed.command === "run:execute-tasks") {
+                    return await handleRunExecuteTasks(parsed);
+                }
                 if (parsed.command === "run:events") {
                     return await handleRunEvents(parsed);
                 }
@@ -1403,11 +1909,138 @@ function createBabysitterCli() {
                 if (parsed.command === "task:show") {
                     return await handleTaskShow(parsed);
                 }
-                console.error(USAGE);
-                return 1;
+                // Session commands
+                if (parsed.command === "session:init") {
+                    return await (0, session_1.handleSessionInit)({
+                        sessionId: parsed.sessionId,
+                        stateDir: parsed.stateDir,
+                        maxIterations: parsed.maxIterations,
+                        runId: parsed.runIdOverride,
+                        prompt: parsed.prompt,
+                        json: parsed.json,
+                    });
+                }
+                if (parsed.command === "session:associate") {
+                    return await (0, session_1.handleSessionAssociate)({
+                        sessionId: parsed.sessionId,
+                        stateDir: parsed.stateDir,
+                        runId: parsed.runIdOverride,
+                        json: parsed.json,
+                    });
+                }
+                if (parsed.command === "session:resume") {
+                    return await (0, session_1.handleSessionResume)({
+                        sessionId: parsed.sessionId,
+                        stateDir: parsed.stateDir,
+                        runId: parsed.runIdOverride,
+                        maxIterations: parsed.maxIterations,
+                        runsDir: parsed.runsDir,
+                        json: parsed.json,
+                    });
+                }
+                if (parsed.command === "session:state") {
+                    return await (0, session_1.handleSessionState)({
+                        sessionId: parsed.sessionId,
+                        stateDir: parsed.stateDir,
+                        json: parsed.json,
+                    });
+                }
+                if (parsed.command === "session:update") {
+                    return await (0, session_1.handleSessionUpdate)({
+                        sessionId: parsed.sessionId,
+                        stateDir: parsed.stateDir,
+                        iteration: parsed.iteration,
+                        lastIterationAt: parsed.lastIterationAt,
+                        iterationTimes: parsed.iterationTimes,
+                        delete: parsed.deleteSession,
+                        json: parsed.json,
+                    });
+                }
+                if (parsed.command === "session:check-iteration") {
+                    return await (0, session_1.handleSessionCheckIteration)({
+                        sessionId: parsed.sessionId,
+                        stateDir: parsed.stateDir,
+                        json: parsed.json,
+                    });
+                }
+                if (parsed.command === "session:last-message") {
+                    if (!parsed.transcriptPath) {
+                        console.error("--transcript-path is required for session:last-message");
+                        console.error(USAGE);
+                        return 1;
+                    }
+                    return (0, session_1.handleSessionLastMessage)({
+                        transcriptPath: parsed.transcriptPath,
+                        json: parsed.json,
+                    });
+                }
+                if (parsed.command === "session:iteration-message") {
+                    return await (0, session_1.handleSessionIterationMessage)({
+                        iteration: parsed.iteration,
+                        runId: parsed.runIdOverride,
+                        runsDir: parsed.runsDir,
+                        pluginRoot: parsed.pluginRoot,
+                        json: parsed.json,
+                    });
+                }
+                // Hook commands
+                if (parsed.command === "hook:log") {
+                    return await (0, hookLog_1.handleHookLog)({
+                        hookType: parsed.hookType ?? "",
+                        logFile: parsed.logFile ?? "",
+                        json: parsed.json,
+                    });
+                }
+                if (parsed.command === "hook:run") {
+                    return await (0, hookRun_1.handleHookRun)({
+                        hookType: parsed.hookType ?? "",
+                        harness: parsed.harness ?? "claude-code",
+                        pluginRoot: parsed.pluginRoot,
+                        stateDir: parsed.stateDir,
+                        runsDir: parsed.runsDir,
+                        json: parsed.json,
+                        verbose: parsed.verbose,
+                    });
+                }
+                // Skill commands
+                if (parsed.command === "skill:discover") {
+                    return await (0, skill_1.handleSkillDiscover)({
+                        pluginRoot: parsed.pluginRoot,
+                        runId: parsed.runIdOverride,
+                        cacheTtl: parsed.cacheTtl,
+                        runsDir: parsed.runsDir,
+                        json: parsed.json,
+                        includeRemote: parsed.includeRemote,
+                        summaryOnly: parsed.summaryOnly,
+                        processPath: parsed.processPath,
+                    });
+                }
+                if (parsed.command === "skill:fetch-remote") {
+                    return await (0, skill_1.handleSkillFetchRemote)({
+                        sourceType: parsed.sourceType,
+                        url: parsed.url,
+                        json: parsed.json,
+                    });
+                }
+                if (parsed.command === "health") {
+                    return await (0, health_1.handleHealthCommand)({
+                        json: parsed.json,
+                        verbose: parsed.verbose,
+                    });
+                }
+                if (parsed.command === "configure") {
+                    const args = parsed.configureSubcommand ? [parsed.configureSubcommand] : [];
+                    return await (0, configure_1.handleConfigureCommand)(args, {
+                        json: parsed.json,
+                        defaultsOnly: parsed.defaultsOnly,
+                    });
+                }
+                // This should not be reached due to the VALID_COMMANDS check above
+                return handleUnknownCommand(parsed.command, parsed.json);
             }
             catch (error) {
-                console.error(error instanceof Error ? error.message : String(error));
+                const err = error instanceof Error ? error : new Error(String(error));
+                outputError(err, { json: parsedJson, verbose: parsedVerbose });
                 return 1;
             }
         },