@plico-ai/cli 0.0.0-reserved.0 → 0.1.0

package/NOTICE

@@ -0,0 +1,4 @@
+Plico
+Copyright 2026 Plico contributors
+
+This product includes software developed by the Plico contributors.

package/README.md

@@ -1,6 +1,36 @@
 # @plico-ai/cli
 
-The plico command line and bundled Studio.
+CLI entrypoints for validating Plico projects and running the deterministic dry runtime.
 
-This is a pre-release placeholder. The first developer preview is in progress at
-https://github.com/ITZSHOAIB/plico. Docs: https://plico.sohab.dev
+## Commands
+
+- `plico validate [path]`
+- `plico validate --json [path]`
+- `plico run --dry [path]`
+- `plico run --dry --json [path]`
+- `plico run --dry --script <file> [path]`
+- `plico cancel <runId> [--db <path>] [--json] [path]`
+
+`plico validate` keeps its current behavior. `plico run` is dry-run only in this release and uses the local runtime package for deterministic instruction composition, tool discovery, scripted tool execution, and approval blocking.
+
+
+## Durable runs
+
+`plico run --dry --persist` resumes eligible interrupted runs in the selected database as it starts the requested run. It waits for each recovered execution to finish or reach a wait, reports recovery results on stderr, and uses the requested run's exit code. A waiting run needs a running host or a later persistent start to continue. `plico serve` adopts eligible runs at startup as well.
+
+Set the optional host execution lease in `plico.config.ts`:
+
+```ts
+export default {
+  schemaVersion: 1,
+  name: "my-agent",
+  execution: { leaseMs: 30_000 },
+} as const;
+```
+
+The lease defaults to 30,000 ms and must be a positive integer. The host's setting applies to every run it recovers from its database. A short lease increases the chance that a stalled step runs again; side-effecting tools should use their idempotency key.
+
+`plico cancel <runId> [path]` requests durable cancellation of a persisted run. The
+run's worker records the terminal cancellation event; if no worker is active, the
+next recovery pass finalizes it. `--db <path>` selects a non-default database and
+`--json` prints the cancellation result.

package/dist/args.d.ts

@@ -0,0 +1,25 @@
+export interface ValueOption {
+    /** Message thrown when the option is the last argument and has no value. */
+    missing: string;
+    /** Optional converter; may throw to reject a malformed value. */
+    parse?: (value: string) => unknown;
+}
+export interface ArgSpec {
+    /** Boolean flags, e.g. `--json`. */
+    flags: readonly string[];
+    /** Options that consume the following argument, keyed by option name. */
+    values: Readonly<Record<string, ValueOption>>;
+    /** When false, any other `-`-prefixed argument is treated as a positional. */
+    rejectUnknown: boolean;
+}
+export interface ParsedArgs {
+    flags: ReadonlySet<string>;
+    values: ReadonlyMap<string, unknown>;
+    positionals: string[];
+}
+export declare function parseArgs(args: readonly string[], spec: ArgSpec): ParsedArgs;
+export declare function readStringOption(parsed: ParsedArgs, name: string): string | undefined;
+export declare function readNumberOption(parsed: ParsedArgs, name: string): number | undefined;
+export declare function lastPositional(parsed: ParsedArgs, fallback: string): string;
+export declare function parseCursor(value: string): number;
+export declare function parsePort(value: string): number;

package/dist/args.js

@@ -0,0 +1,58 @@
+export function parseArgs(args, spec) {
+    const flags = new Set();
+    const values = new Map();
+    const positionals = [];
+    let pending;
+    for (const arg of args) {
+        if (pending !== undefined) {
+            if (spec.flags.includes(arg) || Object.hasOwn(spec.values, arg)) {
+                throw new Error(spec.values[pending]?.missing ?? `Missing value after ${pending}`);
+            }
+            const option = spec.values[pending];
+            values.set(pending, option?.parse ? option.parse(arg) : arg);
+            pending = undefined;
+            continue;
+        }
+        if (spec.flags.includes(arg)) {
+            flags.add(arg);
+            continue;
+        }
+        if (Object.hasOwn(spec.values, arg)) {
+            pending = arg;
+            continue;
+        }
+        if (spec.rejectUnknown && arg.startsWith("-")) {
+            throw new Error(`Unknown option: ${arg}`);
+        }
+        positionals.push(arg);
+    }
+    if (pending !== undefined) {
+        throw new Error(spec.values[pending]?.missing ?? `Missing value after ${pending}`);
+    }
+    return { flags, values, positionals };
+}
+export function readStringOption(parsed, name) {
+    const value = parsed.values.get(name);
+    return typeof value === "string" ? value : undefined;
+}
+export function readNumberOption(parsed, name) {
+    const value = parsed.values.get(name);
+    return typeof value === "number" ? value : undefined;
+}
+export function lastPositional(parsed, fallback) {
+    return parsed.positionals.at(-1) ?? fallback;
+}
+export function parseCursor(value) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        throw new Error(`Malformed cursor: ${value}`);
+    }
+    return parsed;
+}
+export function parsePort(value) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
+        throw new Error(`Invalid port: ${value}`);
+    }
+    return parsed;
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function main(argv: string[]): Promise<number>;

package/dist/cli.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { cancelCommand } from "./commands/cancel.js";
+import { evalCommand } from "./commands/eval.js";
+import { eventsCommand } from "./commands/events.js";
+import { readinessCommand } from "./commands/readiness.js";
+import { runCommand } from "./commands/run.js";
+import { runsCommand } from "./commands/runs.js";
+import { serveCommand } from "./commands/serve.js";
+import { usageCommand } from "./commands/usage.js";
+import { validateCommand } from "./commands/validate.js";
+import { isDirectRun } from "./direct-run.js";
+import { quietSqliteWarning } from "./quiet-sqlite-warning.js";
+function readVersion() {
+    const pkg = createRequire(import.meta.url)("../package.json");
+    return pkg.version;
+}
+const commands = {
+    validate: validateCommand,
+    run: runCommand,
+    cancel: cancelCommand,
+    runs: runsCommand,
+    events: eventsCommand,
+    serve: serveCommand,
+    readiness: readinessCommand,
+    eval: evalCommand,
+};
+export async function main(argv) {
+    const name = argv[2] ?? "help";
+    if (name === "help" || name === "--help" || name === "-h") {
+        return usageCommand();
+    }
+    if (name === "--version" || name === "-v") {
+        console.log(readVersion());
+        return 0;
+    }
+    const command = Object.hasOwn(commands, name) ? commands[name] : undefined;
+    if (!command) {
+        console.error(`Unknown command: ${name}`);
+        usageCommand("stderr");
+        return 1;
+    }
+    return command(argv.slice(3));
+}
+if (isDirectRun(import.meta.url, process.argv[1])) {
+    quietSqliteWarning();
+    main(process.argv).then((code) => {
+        process.exitCode = code;
+    });
+}

package/dist/commands/cancel.d.ts

@@ -0,0 +1 @@
+export declare function cancelCommand(args: string[]): Promise<number>;

package/dist/commands/cancel.js

@@ -0,0 +1,42 @@
+import { createSqliteEngine, createSqliteEventStore } from "@plico-ai/runtime";
+import { parseArgs, readStringOption } from "../args.js";
+import { errorMessage } from "../errors.js";
+import { ensureDatabaseExists, resolveDatabasePath } from "../paths.js";
+export async function cancelCommand(args) {
+    try {
+        const parsed = parseArgs(args, {
+            flags: ["--json"],
+            values: { "--db": { missing: "Missing database path after --db" } },
+            rejectUnknown: true,
+        });
+        const [runId, ...rest] = parsed.positionals;
+        if (!runId)
+            throw new Error("Missing run ID for cancel command");
+        const target = rest.at(-1) ?? process.cwd();
+        const databasePath = resolveDatabasePath(target, readStringOption(parsed, "--db"));
+        await ensureDatabaseExists(databasePath);
+        const eventStore = createSqliteEventStore({ databasePath });
+        if (!(await eventStore.getRun(runId))) {
+            console.error(`Unknown run ID: ${runId}`);
+            return 1;
+        }
+        const result = await createSqliteEngine({ databasePath }).cancel(runId);
+        if (parsed.flags.has("--json")) {
+            console.log(JSON.stringify({ runId, result }));
+        }
+        else if (result === "accepted") {
+            console.log(`Cancellation requested for run ${runId}.`);
+        }
+        else if (result === "ignored") {
+            console.log(`Run ${runId} is already finished or cancelled.`);
+        }
+        else {
+            console.error(`Run ${runId} is not known to the execution engine.`);
+        }
+        return result === "unknown" ? 1 : 0;
+    }
+    catch (error) {
+        console.error(errorMessage(error));
+        return 1;
+    }
+}

package/dist/commands/eval-promote.d.ts

@@ -0,0 +1,2 @@
+/** Writes a stored run into the project's evals folder and returns the file it created. */
+export declare function promoteRun(target: string, databasePath: string, runId: string, name: string): Promise<string>;

package/dist/commands/eval-promote.js

@@ -0,0 +1,26 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { getProjectPaths } from "@plico-ai/core";
+import { createSqliteEventStore, evalCaseFromRun } from "@plico-ai/runtime";
+/** Writes a stored run into the project's evals folder and returns the file it created. */
+export async function promoteRun(target, databasePath, runId, name) {
+    if (name === "." || name === ".." || /[\\/]/.test(name))
+        throw new Error(`Invalid --name "${name}". Use a plain file name without path separators.`);
+    const store = createSqliteEventStore({ databasePath, readOnly: true });
+    const run = await store.getRun(runId);
+    if (!run)
+        throw new Error(`Run not found: ${runId}`);
+    const evalCase = evalCaseFromRun(name, run.status, await store.getEvents(runId));
+    const folder = getProjectPaths(target).directories.evals;
+    const file = join(folder, `${name}.script.json`);
+    await mkdir(folder, { recursive: true });
+    try {
+        await writeFile(file, `${JSON.stringify(evalCase, null, 2)}\n`, { flag: "wx" });
+    }
+    catch (error) {
+        if (error.code === "EEXIST")
+            throw new Error(`${file} already exists. Pick another --name.`);
+        throw error;
+    }
+    return file;
+}

package/dist/commands/eval.d.ts

@@ -0,0 +1 @@
+export declare function evalCommand(args: string[]): Promise<number>;

package/dist/commands/eval.js

@@ -0,0 +1,46 @@
+import { createSqliteEventStore, runEvals } from "@plico-ai/runtime";
+import { lastPositional, parseArgs, readStringOption } from "../args.js";
+import { errorMessage } from "../errors.js";
+import { formatEvalSummary } from "../format/eval.js";
+import { resolveDatabasePath } from "../paths.js";
+import { promoteRun } from "./eval-promote.js";
+export async function evalCommand(args) {
+    try {
+        const parsed = parseArgs(args, {
+            flags: ["--json", "--allow-empty"],
+            values: {
+                "--db": { missing: "Missing database path after --db" },
+                "--from-run": { missing: "Missing run id after --from-run" },
+                "--name": { missing: "Missing case name after --name" },
+            },
+            rejectUnknown: true,
+        });
+        const target = lastPositional(parsed, process.cwd());
+        const databasePath = resolveDatabasePath(target, readStringOption(parsed, "--db"));
+        const fromRun = readStringOption(parsed, "--from-run");
+        if (fromRun !== undefined) {
+            const name = readStringOption(parsed, "--name") ?? fromRun;
+            console.log(`Wrote ${await promoteRun(target, databasePath, fromRun, name)}`);
+            return 0;
+        }
+        const eventStore = createSqliteEventStore({ databasePath });
+        const summary = await runEvals(target, { eventStore });
+        if (parsed.flags.has("--json")) {
+            console.log(JSON.stringify(summary));
+        }
+        else {
+            for (const line of formatEvalSummary(target, summary)) {
+                console.log(line);
+            }
+        }
+        if (summary.total === 0 && !parsed.flags.has("--allow-empty")) {
+            console.error("No eval cases found, so nothing was tested. Add cases under evals/ or pass --allow-empty.");
+            return 1;
+        }
+        return summary.failed > 0 ? 1 : 0;
+    }
+    catch (error) {
+        console.error(errorMessage(error));
+        return 1;
+    }
+}

package/dist/commands/events.d.ts

@@ -0,0 +1 @@
+export declare function eventsCommand(args: string[]): Promise<number>;

package/dist/commands/events.js

@@ -0,0 +1,46 @@
+import { createSqliteEventStore } from "@plico-ai/runtime";
+import { parseArgs, parseCursor, readNumberOption, readStringOption } from "../args.js";
+import { errorMessage } from "../errors.js";
+import { formatEvents } from "../format/events.js";
+import { ensureDatabaseExists, resolveDatabasePath } from "../paths.js";
+export async function eventsCommand(args) {
+    try {
+        const parsed = parseArgs(args, {
+            flags: ["--json"],
+            values: {
+                "--after": { missing: "Missing sequence after --after", parse: parseCursor },
+                "--db": { missing: "Missing database path after --db" },
+            },
+            rejectUnknown: true,
+        });
+        const [runId, ...rest] = parsed.positionals;
+        if (!runId) {
+            throw new Error("Missing run ID for events command");
+        }
+        const json = parsed.flags.has("--json");
+        const target = rest.at(-1) ?? process.cwd();
+        const afterSequence = readNumberOption(parsed, "--after");
+        const databasePath = resolveDatabasePath(target, readStringOption(parsed, "--db"));
+        await ensureDatabaseExists(databasePath);
+        const eventStore = createSqliteEventStore({ databasePath });
+        const run = await eventStore.getRun(runId);
+        if (!run) {
+            console.error(`Unknown run ID: ${runId}`);
+            return 1;
+        }
+        const events = await eventStore.getEvents(runId, afterSequence === undefined ? {} : { afterSequence });
+        if (json) {
+            console.log(JSON.stringify(events));
+        }
+        else {
+            for (const line of formatEvents(runId, events)) {
+                console.log(line);
+            }
+        }
+        return 0;
+    }
+    catch (error) {
+        console.error(errorMessage(error));
+        return 1;
+    }
+}

package/dist/commands/interrupt.d.ts

@@ -0,0 +1,9 @@
+import type { Engine } from "@plico-ai/runtime";
+/** Keep track of the requested and recovered runs until all execution settles. */
+export declare function cancelOnInterrupt(engine: Engine, runId: string): {
+    onStarted(): void;
+    onRecoveryStarted(id: string): void;
+    onRecoverySettled(id: string): void;
+    onCompleted(): void;
+    dispose(): void;
+};

package/dist/commands/interrupt.js

@@ -0,0 +1,38 @@
+/** Keep track of the requested and recovered runs until all execution settles. */
+export function cancelOnInterrupt(engine, runId) {
+    const active = new Set();
+    let interrupted = false;
+    const cancel = (id) => {
+        void engine.cancel(id).catch(() => console.error("Could not cancel the run."));
+    };
+    const track = (id) => {
+        active.add(id);
+        if (interrupted)
+            cancel(id);
+    };
+    const onSignal = () => {
+        interrupted = true;
+        for (const id of active)
+            cancel(id);
+    };
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+    return {
+        onStarted() {
+            track(runId);
+        },
+        onRecoveryStarted(id) {
+            track(id);
+        },
+        onRecoverySettled(id) {
+            active.delete(id);
+        },
+        onCompleted() {
+            active.delete(runId);
+        },
+        dispose() {
+            process.off("SIGINT", onSignal);
+            process.off("SIGTERM", onSignal);
+        },
+    };
+}

package/dist/commands/live-output.d.ts

@@ -0,0 +1,3 @@
+import type { EventStore } from "@plico-ai/runtime";
+/** Forward committed model text as it arrives, separating attempts on retries. */
+export declare function streamModelOutput(store: EventStore): EventStore;

package/dist/commands/live-output.js

@@ -0,0 +1,18 @@
+/** Forward committed model text as it arrives, separating attempts on retries. */
+export function streamModelOutput(store) {
+    const attempts = new Set();
+    return {
+        ...store,
+        async appendEvent(event) {
+            await store.appendEvent(event);
+            if (event.type === "model.attempt") {
+                if (attempts.has(event.payload.turn))
+                    process.stdout.write("\n[Retrying model response]\n");
+                attempts.add(event.payload.turn);
+            }
+            else if (event.type === "model.delta") {
+                process.stdout.write(event.payload.text);
+            }
+        },
+    };
+}

package/dist/commands/model-provider.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectConfig } from "@plico-ai/core";
+import { type ModelProvider } from "@plico-ai/runtime";
+export declare function resolveModelProvider(model: ProjectConfig["model"], projectRoot: string): ModelProvider;
+export declare function resolveMessage(message: string | undefined): Promise<string>;

package/dist/commands/model-provider.js

@@ -0,0 +1,21 @@
+import { createConfiguredModelProvider } from "@plico-ai/runtime";
+export function resolveModelProvider(model, projectRoot) {
+    if (!model)
+        throw new Error("Model configuration is missing from plico.config.ts.");
+    const provider = createConfiguredModelProvider(model, projectRoot);
+    if (!provider)
+        throw new Error(`Unsupported model provider: ${model.provider}`);
+    return provider;
+}
+export async function resolveMessage(message) {
+    if (message?.trim())
+        return message;
+    if (!process.stdin.isTTY) {
+        let input = "";
+        for await (const chunk of process.stdin)
+            input += String(chunk);
+        if (input.trim())
+            return input;
+    }
+    throw new Error("A user message is required. Provide --message or pipe input via stdin.");
+}

package/dist/commands/readiness.d.ts

@@ -0,0 +1 @@
+export declare function readinessCommand(args: string[]): Promise<number>;

package/dist/commands/readiness.js

@@ -0,0 +1,31 @@
+import { checkReadiness, loadProjectEnv } from "@plico-ai/runtime";
+import { lastPositional, parseArgs, readStringOption } from "../args.js";
+import { errorMessage } from "../errors.js";
+import { formatReadinessReport } from "../format/readiness.js";
+import { findStudioPath, resolveDatabasePath } from "../paths.js";
+export async function readinessCommand(args) {
+    try {
+        const parsed = parseArgs(args, {
+            flags: ["--json"],
+            values: { "--db": { missing: "Missing database path after --db" } },
+            rejectUnknown: true,
+        });
+        const target = lastPositional(parsed, process.cwd());
+        loadProjectEnv(target);
+        const databasePath = resolveDatabasePath(target, readStringOption(parsed, "--db"));
+        const report = await checkReadiness(target, { databasePath, studioPath: findStudioPath() });
+        if (parsed.flags.has("--json")) {
+            console.log(JSON.stringify(report));
+        }
+        else {
+            for (const line of formatReadinessReport(report)) {
+                console.log(line);
+            }
+        }
+        return report.summary.error > 0 ? 1 : 0;
+    }
+    catch (error) {
+        console.error(errorMessage(error));
+        return 1;
+    }
+}

package/dist/commands/run.d.ts

@@ -0,0 +1 @@
+export declare function runCommand(args: string[]): Promise<number>;

package/dist/commands/run.js

@@ -0,0 +1,152 @@
+import { randomUUID } from "node:crypto";
+import { ARTIFACT_TOOL_NAMES, SKILL_TOOL_NAME, validateProject } from "@plico-ai/core";
+import { createSqliteEngine, createSqliteEventStore, loadProjectEnv, modelProviderRecoveryKey, recoverRuns, runProject, } from "@plico-ai/runtime";
+import { lastPositional, parseArgs, readStringOption } from "../args.js";
+import { errorMessage } from "../errors.js";
+import { formatRunResult } from "../format/run.js";
+import { resolveDatabasePath } from "../paths.js";
+import { loadDryRunScript } from "../script-file.js";
+import { cancelOnInterrupt } from "./interrupt.js";
+import { streamModelOutput } from "./live-output.js";
+import { resolveMessage, resolveModelProvider } from "./model-provider.js";
+export async function runCommand(args) {
+    try {
+        const parsed = parseArgs(args, {
+            flags: ["--dry", "--json", "--persist"],
+            values: {
+                "--script": { missing: "Missing script file after --script" },
+                "--message": { missing: "Missing message text after --message" },
+                "--db": { missing: "Missing database path after --db" },
+            },
+            rejectUnknown: true,
+        });
+        const dry = parsed.flags.has("--dry");
+        const json = parsed.flags.has("--json");
+        const persist = parsed.flags.has("--persist") || !dry;
+        const target = lastPositional(parsed, process.cwd());
+        loadProjectEnv(target);
+        const scriptPath = readStringOption(parsed, "--script");
+        const dbPath = readStringOption(parsed, "--db");
+        let message = readStringOption(parsed, "--message");
+        if (!dry && scriptPath)
+            throw new Error("--script requires --dry.");
+        const script = scriptPath ? await loadDryRunScript(scriptPath) : undefined;
+        const databasePath = persist ? resolveDatabasePath(target, dbPath) : undefined;
+        const validation = databasePath ? await validateProject(target) : undefined;
+        if (!dry && (!validation?.ok || !validation.project)) {
+            throw new Error("Project is invalid. Run plico validate for details.");
+        }
+        const provider = dry
+            ? message === undefined
+                ? undefined
+                : createFakeProvider()
+            : resolveModelProvider(validation?.project?.config.model, target);
+        if (!dry)
+            message = await resolveMessage(message);
+        const recoveryKey = dry
+            ? "plico:dry-fake:v1"
+            : validation?.project?.config.model
+                ? modelProviderRecoveryKey(validation.project.config.model)
+                : undefined;
+        const eventStore = databasePath ? createSqliteEventStore({ databasePath }) : undefined;
+        const leaseMs = validation?.project?.config.execution?.leaseMs;
+        const engine = databasePath
+            ? createSqliteEngine({ databasePath, ...(leaseMs === undefined ? {} : { leaseMs }) })
+            : undefined;
+        const runId = !dry ? `run-${randomUUID()}` : undefined;
+        const interruption = engine && runId ? cancelOnInterrupt(engine, runId) : undefined;
+        const recovery = engine && eventStore
+            ? recoverRuns({
+                engine,
+                eventStore,
+                recoveryFilter: {
+                    projectRoot: target,
+                    ...(recoveryKey ? { providerRecoveryKey: recoveryKey } : {}),
+                },
+                ...(dry ? { provider: createFakeProvider() } : provider ? { provider } : {}),
+                ...(interruption
+                    ? {
+                        onRecoveryStarted: interruption.onRecoveryStarted,
+                        onRecoverySettled: interruption.onRecoverySettled,
+                    }
+                    : {}),
+            }).then((runs) => {
+                for (const run of runs)
+                    console.error(`Recovered run ${run.runId}: ${run.state}${run.error ? ` (${run.error})` : ""}`);
+            }, (error) => {
+                console.error(`Recovery incomplete: ${errorMessage(error)}`);
+            })
+            : Promise.resolve();
+        const outputStore = eventStore && !dry && !json ? streamModelOutput(eventStore) : eventStore;
+        const resultPromise = runProject(target, {
+            ...(script ? { script } : {}),
+            ...(outputStore ? { eventStore: outputStore } : {}),
+            ...(engine ? { engine } : {}),
+            ...(message === undefined ? {} : { message }),
+            ...(provider === undefined ? {} : { provider }),
+            ...(recoveryKey === undefined || provider === undefined
+                ? {}
+                : { providerRecoveryKey: recoveryKey }),
+            ...(runId === undefined ? {} : { runId }),
+            ...(interruption === undefined ? {} : { onStarted: interruption.onStarted }),
+        });
+        const trackedResult = resultPromise.finally(() => interruption?.onCompleted());
+        void Promise.allSettled([trackedResult, recovery]).then(() => interruption?.dispose());
+        const result = await trackedResult;
+        if (json) {
+            console.log(JSON.stringify(result));
+        }
+        else if (result.status === "failed" && result.errors?.length) {
+            for (const error of result.errors) {
+                console.error(`${error.path}: ${error.message}`);
+            }
+        }
+        else if (!dry) {
+            process.stdout.write("\n");
+            if (result.status !== "completed") {
+                for (const line of formatRunResult(target, result, false))
+                    console.error(line);
+            }
+            else if (persist) {
+                console.log(`Persisted run ID: ${result.runId}`);
+            }
+        }
+        else {
+            for (const line of formatRunResult(target, result, dry)) {
+                if (result.status === "completed") {
+                    console.log(line);
+                }
+                else {
+                    console.error(line);
+                }
+            }
+            if (persist && result.status === "completed") {
+                console.log(`Persisted run ID: ${result.runId}`);
+            }
+        }
+        // Exit 0 for completion, 2 when waiting for approval, and 1 for anything else.
+        return result.status === "completed" ? 0 : result.status === "waiting" ? 2 : 1;
+    }
+    catch (error) {
+        console.error(errorMessage(error));
+        return 1;
+    }
+}
+/** Deterministic stand-in used by `--message` until real providers are wired in. */
+function createFakeProvider() {
+    return {
+        async *stream(request) {
+            const lastUserMessage = [...request.messages].reverse().find((m) => m.role === "user");
+            const lastToolMessage = [...request.messages].reverse().find((m) => m.role === "tool");
+            const tool = request.tools?.find(({ name }) => name !== SKILL_TOOL_NAME &&
+                !ARTIFACT_TOOL_NAMES.includes(name));
+            if (!lastToolMessage && tool) {
+                yield { type: "tool.call", call: { name: tool.name, arguments: { title: "Test ticket" } } };
+                yield { type: "finish", usage: { inputTokens: 10, outputTokens: 1 } };
+                return;
+            }
+            yield { type: "text", text: `Fake provider response to: ${lastUserMessage?.content ?? ""}` };
+            yield { type: "finish", usage: { inputTokens: 10, outputTokens: 5 } };
+        },
+    };
+}

package/dist/commands/runs.d.ts

@@ -0,0 +1 @@
+export declare function runsCommand(args: string[]): Promise<number>;