cloving 0.3.19 → 1.0.1

package/dist/src/cli/render.js

@@ -0,0 +1,186 @@
+import { record } from "../protocol.js";
+function show(value) {
+    return typeof value === "string" ? value : JSON.stringify(value);
+}
+function escaped(character) {
+    return `\\u${(character.codePointAt(0) ?? 0).toString(16).padStart(4, "0")}`;
+}
+const hiddenRanges = [
+    [0x00, 0x1f],
+    [0x7f, 0x9f],
+    [0x061c, 0x061c],
+    [0x200b, 0x200f],
+    [0x2028, 0x202e],
+    [0x2060, 0x2069],
+    [0xfeff, 0xfeff],
+];
+function hidden(character) {
+    const code = character.codePointAt(0) ?? 0;
+    return hiddenRanges.some(([first, last]) => code >= first && code <= last);
+}
+function visible(value) {
+    return show(value)
+        .split("\n")
+        .map((line) => Array.from(line, (character) => hidden(character) ? escaped(character) : character).join(""))
+        .join("\n    ");
+}
+export function errorText(error) {
+    const { candidates } = error;
+    const lines = [`${visible(error["code"])}: ${visible(error["detail"])}`];
+    if (Array.isArray(candidates))
+        lines.push(`Candidates: ${candidates.map(visible).join(", ")}`);
+    return lines.map((line) => `${line}\n`).join("");
+}
+function part(value, name) {
+    return record(value)?.[name];
+}
+function listing(value) {
+    const items = Array.isArray(value) ? value.map(show) : [];
+    return items.length === 0 ? "none" : items.join(", ");
+}
+function receiptLines(result) {
+    const receipt = result["receipt"];
+    return [
+        `Command ID: ${show(result["commandId"])}`,
+        `Receipt: sequence ${show(part(receipt, "sequence"))}, recorded at ${show(part(receipt, "recordedAt"))}`,
+        ...(result["replayed"] === true
+            ? ["This is the receipt of the earlier equal command."]
+            : []),
+    ];
+}
+function admitted(result) {
+    return [
+        `Run ${show(result["runId"])} is admitted.`,
+        ...receiptLines(result),
+        "The run is queued. Admission is not completed work.",
+    ];
+}
+function runLine(run) {
+    return `  ${show(part(run, "runId"))}  ${show(part(run, "workflowId"))}  ${show(part(run, "condition"))}  revision ${show(part(run, "revision"))}  latest at ${show(part(run, "latestAt") ?? "none")}`;
+}
+function runList(result) {
+    const runs = result["runs"];
+    const lines = Array.isArray(runs) ? runs.map(runLine) : [];
+    return [
+        `Workflows: ${visible(listing(result["workflows"]))}`,
+        "Runs:",
+        ...(lines.length === 0 ? ["  none"] : lines),
+    ];
+}
+function observation(value) {
+    if (record(value) === undefined)
+        return "none";
+    return `${show(part(value, "at"))} (sequence ${show(part(value, "sequence"))}, ${show(part(value, "source"))})`;
+}
+function feedbackLines(value) {
+    return (Array.isArray(value) ? value : []).map((item) => `Feedback of ${show(part(item, "decisionId"))}: ${visible(part(item, "text"))}`);
+}
+function outcome(value) {
+    if (record(value) === undefined)
+        return "none";
+    const reason = part(value, "reason");
+    const kind = visible(part(value, "kind"));
+    return typeof reason === "string" ? `${kind}: ${visible(reason)}` : kind;
+}
+export function runStatus(result) {
+    const run = result["run"];
+    const reason = part(run, "reason");
+    const recovery = part(run, "recovery");
+    const at = part(run, "nextActionAt") ?? null;
+    const cost = part(run, "claudeCostUsd");
+    return [
+        `Run ${show(part(run, "runId"))} (${show(part(run, "workflowId"))})`,
+        `Title: ${visible(part(run, "title") ?? "none")}`,
+        `State: ${show(part(run, "state"))}`,
+        `Outcome: ${outcome(part(run, "outcome"))}`,
+        `Condition: ${show(part(run, "condition"))}`,
+        `Reason: ${show(part(reason, "code"))}: ${show(part(reason, "detail"))}`,
+        `Revision: ${show(part(run, "revision"))}, latest sequence ${show(part(run, "latestSequence"))}`,
+        `Latest at: ${show(part(run, "latestAt") ?? "none")}`,
+        `Pending decisions: ${listing(part(run, "pendingDecisions"))}`,
+        `Evidence: ${listing(part(run, "evidence"))}`,
+        `Last confirmed observation: ${observation(part(run, "lastConfirmedObservation"))}`,
+        `Recovery: ${show(part(recovery, "attempts"))} of ${show(part(recovery, "limit") ?? "no limit")}`,
+        `Claude cost: ${(typeof cost === "number" ? cost : 0).toFixed(2)} USD`,
+        `Next action: ${show(part(run, "nextAction") ?? "none")}${at === null ? "" : ` at ${show(at)}`}`,
+        `Human input can help: ${part(run, "humanInputCanHelp") === true ? "yes" : "no"}`,
+        ...feedbackLines(part(run, "feedback")),
+    ];
+}
+function binding(decision) {
+    return `--expected-revision ${show(part(decision, "revision"))} --generation ${show(part(decision, "generation"))} --subject-digest ${show(part(decision, "subjectDigest"))}`;
+}
+function suggestion(decision, command) {
+    const reference = part(decision, "label") ?? part(decision, "decisionId");
+    const head = `  cloving ${show(command)} ${show(reference)}`;
+    const tail = binding(decision);
+    if (command === "answer")
+        return `${head} --text <answer> ${tail}`;
+    if (command === "deny")
+        return `${head} --text "<feedback>" ${tail}`;
+    return `${head} ${tail}`;
+}
+export function decisionLines(decision) {
+    const allowed = part(decision, "allowed");
+    const label = part(decision, "label");
+    return [
+        `${label === null ? "" : `${show(label)} `}${show(part(decision, "type"))} ${show(part(decision, "decisionId"))}`,
+        `  Prompt: ${visible(part(decision, "prompt"))}`,
+        ...feedbackLines(part(decision, "feedback")).map((line) => `  ${line}`),
+        ...(Array.isArray(allowed) ? allowed : []).map((command) => suggestion(decision, command)),
+    ];
+}
+export function decisionList(result) {
+    const decisions = result["decisions"];
+    const lines = Array.isArray(decisions)
+        ? decisions.flatMap(decisionLines)
+        : [];
+    return lines.length === 0 ? ["No decision waits."] : lines;
+}
+function decisionRecorded(result) {
+    const run = result["run"];
+    return [
+        `Decision ${show(result["decisionId"])} is recorded as ${show(result["decision"])}.`,
+        ...receiptLines(result),
+        `Run state: ${show(part(run, "state"))}, revision ${show(part(run, "revision"))}`,
+        `Continuation: ${show(result["continuation"])}`,
+    ];
+}
+function runCommand(result) {
+    const committed = result["committed"];
+    const observed = result["observed"];
+    return [
+        `Run ${show(result["runId"])}: ${show(result["command"])} is committed. State ${show(part(committed, "state"))}, revision ${show(part(committed, "revision"))}.`,
+        ...receiptLines(result),
+        `Revoked intents: ${show(part(committed, "revokedIntents"))}`,
+        `Observed: ${show(part(observed, "condition"))}`,
+        `Unresolved effects: ${listing(part(observed, "unresolvedEffects"))}`,
+    ];
+}
+export function eventText(event) {
+    return `${show(event["sequence"])}  ${show(event["recordedAt"])}  ${show(event["type"])}  ${show(event["runId"])}  ${JSON.stringify(event["payload"])}`;
+}
+function eventPage(result) {
+    const events = result["events"];
+    return (Array.isArray(events) ? events : []).map((event) => eventText(record(event) ?? {}));
+}
+const renderers = new Map([
+    ["run-admitted", admitted],
+    ["run-list", runList],
+    ["run-status", runStatus],
+    ["decision-list", decisionList],
+    ["decision-recorded", decisionRecorded],
+    ["run-command", runCommand],
+    ["event-page", eventPage],
+]);
+export function rendered(result) {
+    const lines = renderers.get(show(result["kind"]))?.(result) ?? [];
+    return lines.map((line) => `${line}\n`).join("");
+}
+export function pendingSummary(result) {
+    const decisions = result["decisions"];
+    const lines = (Array.isArray(decisions) ? decisions : []).map((decision) => `  ${show(part(decision, "label") ?? part(decision, "type"))} ${show(part(decision, "decisionId"))}: ${visible(part(decision, "prompt"))}`);
+    return ["Pending decisions:", ...(lines.length === 0 ? ["  none"] : lines)]
+        .map((line) => `${line}\n`)
+        .join("");
+}

package/dist/src/cli/runtime-arguments.d.ts

@@ -0,0 +1,73 @@
+export type RunSource = {
+    readonly kind: "prompt";
+    readonly text: string;
+} | {
+    readonly kind: "ticket";
+    readonly id: string;
+} | {
+    readonly kind: "input";
+    readonly file: string;
+};
+type DecisionCommand = "answer" | "approve" | "deny";
+type RunCommand = "pause" | "resume" | "drop";
+export type RuntimeInvocation = {
+    readonly kind: "command-help";
+    readonly command: string;
+} | {
+    readonly kind: "run";
+    readonly workflowId: string;
+    readonly source: RunSource;
+    readonly commandId: string | null;
+    readonly json: boolean;
+} | {
+    readonly kind: "status";
+    readonly runId: string | null;
+    readonly limit: number | null;
+    readonly after: string | null;
+    readonly json: boolean;
+} | {
+    readonly kind: "questions";
+    readonly runId: string | null;
+    readonly json: boolean;
+} | {
+    readonly kind: "decision";
+    readonly command: DecisionCommand;
+    readonly reference: string;
+    readonly text: string | null;
+    readonly expectedRevision: number;
+    readonly generation: number;
+    readonly subjectDigest: string;
+    readonly commandId: string | null;
+    readonly json: boolean;
+} | {
+    readonly kind: "run-command";
+    readonly command: RunCommand;
+    readonly runId: string;
+    readonly expectedRevision: number;
+    readonly commandId: string | null;
+    readonly json: boolean;
+} | {
+    readonly kind: "events";
+    readonly runId: string | null;
+    readonly after: number;
+    readonly limit: number | null;
+    readonly follow: boolean;
+    readonly json: boolean;
+} | {
+    readonly kind: "watch";
+    readonly port: number | null;
+    readonly json: boolean;
+};
+export interface GivenOption {
+    readonly name: string;
+    readonly value: string | undefined;
+}
+export interface RuntimeRequest {
+    readonly command: string;
+    readonly positionals: readonly string[];
+    readonly options: readonly GivenOption[];
+}
+type Outcome = RuntimeInvocation | string;
+export declare function isRuntimeCommand(command: string): boolean;
+export declare function runtimeInvocation(request: RuntimeRequest): Outcome;
+export {};

package/dist/src/cli/runtime-arguments.js

@@ -0,0 +1,248 @@
+import { isRecordKey } from "../authority/commands.js";
+const identifier = /^[A-Za-z0-9._:/-]{1,128}$/;
+const decisionReference = /^[A-Za-z0-9._:/-]{1,256}$/;
+const sha256Digest = /^sha256:[0-9a-f]{64}$/;
+const wholeNumber = /^(?:0|[1-9][0-9]*)$/;
+const invalid = Symbol("invalid");
+const revisions = { minimum: 1, maximum: Number.MAX_SAFE_INTEGER };
+const sequences = { minimum: 0, maximum: Number.MAX_SAFE_INTEGER };
+const bindingOptions = ["expected-revision", "generation", "subject-digest"];
+const mutationOptions = ["command-id", "json"];
+const shapes = new Map([
+    [
+        "run",
+        {
+            subject: "required",
+            required: [],
+            allowed: () => ["prompt", "input", "ticket", "next", ...mutationOptions],
+            build: run,
+        },
+    ],
+    [
+        "status",
+        {
+            subject: "optional",
+            required: [],
+            allowed: statusOptions,
+            build: status,
+        },
+    ],
+    [
+        "questions",
+        {
+            subject: "optional",
+            required: [],
+            allowed: () => ["json"],
+            build: questions,
+        },
+    ],
+    ["answer", decisionShape("answer")],
+    ["approve", decisionShape("approve")],
+    ["deny", decisionShape("deny")],
+    ["pause", runCommandShape("pause")],
+    ["resume", runCommandShape("resume")],
+    ["drop", runCommandShape("drop")],
+    [
+        "events",
+        {
+            subject: "optional",
+            required: [],
+            allowed: eventOptions,
+            build: events,
+        },
+    ],
+    [
+        "watch",
+        {
+            subject: "none",
+            required: [],
+            allowed: () => ["port"],
+            build: watch,
+        },
+    ],
+]);
+export function isRuntimeCommand(command) {
+    return shapes.has(command);
+}
+export function runtimeInvocation(request) {
+    const shape = shapes.get(request.command);
+    if (shape === undefined)
+        return "unknown-command";
+    const names = request.options.map((option) => option.name);
+    if (new Set(names).size !== names.length)
+        return "repeated-option";
+    if (names.includes("help"))
+        return { kind: "command-help", command: request.command };
+    return shapeFailure(shape, request) ?? shape.build(request);
+}
+function shapeFailure(shape, request) {
+    const names = request.options.map((option) => option.name);
+    const allowed = shape.allowed(request);
+    const count = request.positionals.length;
+    if (names.some((name) => !allowed.includes(name)))
+        return "unexpected-option";
+    if (shape.subject === "required" && count === 0)
+        return "missing-argument";
+    if (count > (shape.subject === "none" ? 0 : 1))
+        return "unexpected-argument";
+    if (shape.required.some((name) => !names.includes(name)))
+        return "missing-option";
+    return undefined;
+}
+function decisionShape(command) {
+    const required = command === "answer" ? [...bindingOptions, "text"] : bindingOptions;
+    const optional = command === "deny" ? ["text"] : [];
+    return {
+        subject: "required",
+        required,
+        allowed: () => [...required, ...optional, ...mutationOptions],
+        build: (request) => decision(command, request),
+    };
+}
+function runCommandShape(command) {
+    return {
+        subject: "required",
+        required: ["expected-revision"],
+        allowed: () => ["expected-revision", ...mutationOptions],
+        build: (request) => runCommand(command, request),
+    };
+}
+function statusOptions(request) {
+    return request.positionals.length === 0
+        ? ["limit", "after", "json"]
+        : ["json"];
+}
+function eventOptions(request) {
+    return given(request, "follow")
+        ? ["after", "follow", "json"]
+        : ["after", "limit", "follow", "json"];
+}
+function given(request, name) {
+    return request.options.some((option) => option.name === name);
+}
+function valueOf(request, name) {
+    return request.options.find((option) => option.name === name)?.value;
+}
+function blank(value) {
+    return value?.trim() === "";
+}
+function matching(value, pattern) {
+    if (value === undefined)
+        return null;
+    return pattern.test(value) ? value : invalid;
+}
+function key(value) {
+    if (value === undefined)
+        return null;
+    return isRecordKey(value) ? value : invalid;
+}
+function whole(value, range) {
+    if (value === undefined)
+        return null;
+    if (!wholeNumber.test(value))
+        return invalid;
+    const number = Number(value);
+    return number >= range.minimum && number <= range.maximum ? number : invalid;
+}
+function inputSource(request) {
+    const prompt = valueOf(request, "prompt");
+    const input = valueOf(request, "input");
+    const ticket = valueOf(request, "ticket");
+    const next = given(request, "next");
+    const sources = [prompt, input, ticket].filter((value) => value !== undefined);
+    if (sources.length + Number(next) > 1)
+        return "conflicting-input-sources";
+    if (prompt !== undefined)
+        return { kind: "prompt", text: prompt };
+    if (input !== undefined)
+        return { kind: "input", file: input };
+    if (ticket !== undefined)
+        return { kind: "ticket", id: ticket };
+    if (next)
+        return { kind: "ticket", id: "next" };
+    return "missing-input-source";
+}
+function run(request) {
+    const source = inputSource(request);
+    if (typeof source === "string")
+        return source;
+    if (blank(valueOf(request, "prompt")))
+        return "empty-prompt";
+    const workflowId = matching(request.positionals[0], identifier);
+    const commandId = key(valueOf(request, "command-id"));
+    const unusable = typeof workflowId !== "string" ||
+        key(valueOf(request, "ticket")) === invalid;
+    if (unusable || commandId === invalid)
+        return "invalid-option-value";
+    const json = given(request, "json");
+    return { kind: "run", workflowId, source, commandId, json };
+}
+function status(request) {
+    const runId = key(request.positionals[0]);
+    const limit = whole(valueOf(request, "limit"), { minimum: 1, maximum: 500 });
+    const after = matching(valueOf(request, "after"), identifier);
+    if (runId === invalid || limit === invalid || after === invalid)
+        return "invalid-option-value";
+    const json = given(request, "json");
+    return { kind: "status", runId, limit, after, json };
+}
+function watch(request) {
+    const port = whole(valueOf(request, "port"), { minimum: 0, maximum: 65535 });
+    if (port === invalid)
+        return "invalid-option-value";
+    return { kind: "watch", port, json: false };
+}
+function questions(request) {
+    const runId = key(request.positionals[0]);
+    if (runId === invalid)
+        return "invalid-option-value";
+    return { kind: "questions", runId, json: given(request, "json") };
+}
+function decision(command, request) {
+    const answer = valueOf(request, "text");
+    if (blank(answer))
+        return "empty-prompt";
+    const reference = matching(request.positionals[0], decisionReference);
+    const expectedRevision = whole(valueOf(request, "expected-revision"), revisions);
+    const generation = whole(valueOf(request, "generation"), revisions);
+    const subjectDigest = matching(valueOf(request, "subject-digest"), sha256Digest);
+    const commandId = key(valueOf(request, "command-id"));
+    if (typeof reference !== "string" ||
+        typeof expectedRevision !== "number" ||
+        typeof generation !== "number" ||
+        typeof subjectDigest !== "string" ||
+        commandId === invalid)
+        return "invalid-option-value";
+    const subject = { command, reference, text: answer ?? null };
+    const binding = { expectedRevision, generation, subjectDigest };
+    const json = given(request, "json");
+    return { kind: "decision", ...subject, ...binding, commandId, json };
+}
+function runCommand(command, request) {
+    const runId = key(request.positionals[0]);
+    const expectedRevision = whole(valueOf(request, "expected-revision"), revisions);
+    const commandId = key(valueOf(request, "command-id"));
+    if (typeof runId !== "string" ||
+        typeof expectedRevision !== "number" ||
+        commandId === invalid)
+        return "invalid-option-value";
+    const json = given(request, "json");
+    return {
+        kind: "run-command",
+        command,
+        runId,
+        expectedRevision,
+        commandId,
+        json,
+    };
+}
+function events(request) {
+    const runId = key(request.positionals[0]);
+    const after = whole(valueOf(request, "after"), sequences);
+    const limit = whole(valueOf(request, "limit"), { minimum: 1, maximum: 1000 });
+    if (runId === invalid || after === invalid || limit === invalid)
+        return "invalid-option-value";
+    const follow = given(request, "follow");
+    const json = given(request, "json");
+    return { kind: "events", runId, after: after ?? 0, limit, follow, json };
+}

package/dist/src/cli/runtime-directory.d.ts

@@ -0,0 +1,4 @@
+type Environment = Readonly<Record<string, string | undefined>>;
+export declare function clientCommand(environment: Environment): string;
+export declare function runtimeDirectory(environment: Environment): string | undefined;
+export {};

package/dist/src/cli/runtime-directory.js

@@ -0,0 +1,25 @@
+import { join } from "node:path";
+function given(value) {
+    return value !== undefined && value.length > 0;
+}
+export function clientCommand(environment) {
+    const explicit = environment["CLOVING_RUNTIME_DIR"];
+    return given(explicit)
+        ? `CLOVING_RUNTIME_DIR=${explicit} cloving`
+        : "cloving";
+}
+export function runtimeDirectory(environment) {
+    const explicit = environment["CLOVING_RUNTIME_DIR"];
+    if (given(explicit))
+        return explicit;
+    const runtime = environment["XDG_RUNTIME_DIR"];
+    if (given(runtime))
+        return join(runtime, "cloving");
+    const state = environment["XDG_STATE_HOME"];
+    if (given(state))
+        return join(state, "cloving", "run");
+    const home = environment["HOME"];
+    return given(home)
+        ? join(home, ".local", "state", "cloving", "run")
+        : undefined;
+}

package/dist/src/cli/toolchain.d.ts

@@ -0,0 +1,3 @@
+import type { ToolchainIdentity } from "../workflow-admission.ts";
+export declare function observedToolchain(start: string): Promise<ToolchainIdentity>;
+export declare function qualifiedToolchain(observed: ToolchainIdentity, start: string): Promise<ToolchainIdentity>;

package/dist/src/cli/toolchain.js

@@ -0,0 +1,74 @@
+import { findPackageJSON } from "node:module";
+import { createHash } from "node:crypto";
+import { access, readFile, realpath } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import packageMetadata from "#package" with { type: "json" };
+const qualifiedNode = "v26.9.0";
+export async function observedToolchain(start) {
+    const root = await projectRoot(start);
+    const sdk = await packageDirectory(start, "workflow");
+    const core = sdk === undefined
+        ? undefined
+        : await packageDirectory(sdk, "@workflow/core");
+    const lock = await readFile(join(root, "package-lock.json")).catch(() => null);
+    return {
+        sdk: `workflow@${await installedVersion(start, "workflow")}`,
+        world: `@workflow/world-local@${await installedVersion(core ?? start, "@workflow/world-local")}`,
+        builder: `@workflow/builders@${await installedVersion(start, "@workflow/builders")}`,
+        node: process.version,
+        dependencies: lock === null
+            ? "missing"
+            : createHash("sha256").update(lock).digest("hex"),
+    };
+}
+export async function qualifiedToolchain(observed, start) {
+    const sdk = await packageDirectory(start, "workflow");
+    const core = await packageFields(sdk ?? start, "@workflow/core");
+    const declared = fields(core["dependencies"])["@workflow/world-local"];
+    return {
+        sdk: `workflow@${packageMetadata.dependencies.workflow}`,
+        world: `@workflow/world-local@${typeof declared === "string" ? declared : "undeclared"}`,
+        builder: `@workflow/builders@${packageMetadata.dependencies["@workflow/builders"]}`,
+        node: qualifiedNode,
+        dependencies: observed.dependencies,
+    };
+}
+async function projectRoot(start) {
+    let directory = start;
+    for (;;) {
+        const found = await access(join(directory, "package-lock.json")).then(() => true, () => false);
+        const parent = dirname(directory);
+        if (found || parent === directory)
+            return directory;
+        directory = parent;
+    }
+}
+async function installedVersion(root, name) {
+    const version = (await packageFields(root, name))["version"];
+    return typeof version === "string" ? version : "missing";
+}
+async function packageFields(root, name) {
+    const directory = await packageDirectory(root, name);
+    if (directory === undefined)
+        return {};
+    const text = await readFile(join(directory, "package.json"), "utf8").catch(() => "{}");
+    return fields(JSON.parse(text));
+}
+function fields(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return {};
+    return Object.fromEntries(Object.entries(value));
+}
+async function packageDirectory(start, name) {
+    try {
+        const file = findPackageJSON(name, join(start, "package.json"));
+        return file === undefined ? undefined : dirname(await realpath(file));
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            "code" in error &&
+            error.code === "ERR_MODULE_NOT_FOUND")
+            return undefined;
+        throw error;
+    }
+}

package/dist/src/cli/usage.d.ts

@@ -0,0 +1,4 @@
+export declare const commandUsage: Readonly<Record<string, string>>;
+export declare const usage = "Usage: cloving [--help] [--version]\n       cloving workflows validate <manifest-path> [--input <json-file>] [--json]\n       cloving <command> [--help]\n\nCommands:\n  workflows validate  Check a compiled workflow manifest, its artifacts and optional runtime input.\n  chats import  Import explicitly selected Claude Code transcripts into private runtime files.\n  run        Submit one run of an admitted workflow.\n  status     List the runs or show one run.\n  questions  List the pending decisions.\n  answer     Answer one design question.\n  approve    Approve one pending approval.\n  deny       Deny one pending approval.\n  pause      Stop new dispatch for a run.\n  resume     Resume a paused run.\n  drop       Cancel a run and keep its files.\n  events     Print the committed events.\n  watch      Serve a page that shows the runs live.\n  start      Start the service for a repository.\n\nThe runtime commands need a Cloving service. CLOVING_RUNTIME_DIR names its runtime directory.\nUse npm exec -- cloving ... for a project-local installation.\n";
+export declare const chatsImportUsage = "Usage: cloving chats import [--] <path> [<path> ...]\n\nImports only the selected Claude Code JSONL files. Relative paths use the current directory.\nThis local command needs no service. It does not expand globs or scan directories.\nThe file limit is 10 MiB (10,485,760 bytes). Links and nonregular files are refused.\nPrivate corpus.jsonl and coverage.json files go into a new import directory under the runtime directory's chats directory.\nThe runtime selection is CLOVING_RUNTIME_DIR, XDG_RUNTIME_DIR, XDG_STATE_HOME, then HOME.\nOutput contains only counts, fixed codes and an opaque import ID. Source paths stay in the private manifest.\nExit codes: 0 for complete coverage, 1 for refused sources or output failure, 2 for invalid usage.\n";
+export declare const validateUsage = "Usage: cloving workflows validate <manifest-path> [--input <json-file>] [--json]\n\nChecks a Cloving workflow manifest, its compiled SDK artifacts, declared resources and toolchain, and an optional runtime input file. Relative paths resolve against the current directory.\n\nOptions:\n  --input <json-file>  Validate this runtime input file.\n  --json               Print one versioned JSON result on stdout.\n\nValidation does not admit a run, dispatch effects, import workflow code or call a model.\n\nExample:\n  cloving workflows validate cloving.workflow.json --input input.json\n";