cloving 1.0.1 → 1.2.0

package/dist/src/cli/arguments.js

@@ -50,6 +50,8 @@ function textValues(argumentsList) {
 export function parseInvocation(given) {
     if (given[0] === "chats" && given[1] === "import")
         return chatsImport(given.slice(2));
+    if (given[0] === "chats" && given[1] === "redact")
+        return chatsRedact(given.slice(2));
     const argumentsList = textValues(given);
     const json = given.includes("--json");
     const parsed = parsedArguments(argumentsList);
@@ -70,6 +72,17 @@ export function parseInvocation(given) {
         return { kind: "usage-error", code: outcome, json };
     return outcome;
 }
+function chatsRedact(argumentsList) {
+    if (argumentsList.length === 1 &&
+        ["--help", "-h"].includes(String(argumentsList[0])))
+        return { kind: "chats-redact-help" };
+    const importId = argumentsList[0];
+    if (argumentsList.length !== 1 ||
+        importId === undefined ||
+        !/^[a-f\d]{8}-[a-f\d]{4}-4[a-f\d]{3}-[89ab][a-f\d]{3}-[a-f\d]{12}$/.test(importId))
+        return { kind: "usage-error", code: "invalid-import-id", json: false };
+    return { kind: "chats-redact", importId };
+}
 function chatsImport(argumentsList) {
     const error = (code) => ({
         kind: "usage-error",
@@ -79,21 +92,89 @@ function chatsImport(argumentsList) {
     if (argumentsList.length === 1 &&
         ["--help", "-h"].includes(String(argumentsList[0])))
         return { kind: "chats-import-help" };
-    const paths = [];
-    let literal = false;
+    const state = {
+        paths: [],
+        roots: [],
+        excludeProjects: [],
+        literal: false,
+        option: undefined,
+        previousImportId: undefined,
+    };
     for (const argument of argumentsList) {
-        if (!literal && argument === "--")
-            literal = true;
-        else if (!literal && argument.startsWith("-"))
-            return error("unexpected-option");
-        else if (argument === "")
-            return error("missing-argument");
-        else
-            paths.push(argument);
+        const failure = importArgument(state, argument);
+        if (failure !== undefined)
+            return error(failure);
+    }
+    if (state.option !== undefined)
+        return error("missing-value");
+    if (state.excludeProjects.length > 0 && state.roots.length === 0)
+        return error("roots-required");
+    if (state.paths.length + state.roots.length === 0)
+        return error("missing-argument");
+    return importInvocation(state);
+}
+function importInvocation(state) {
+    const previous = state.previousImportId === undefined
+        ? {}
+        : { previousImportId: state.previousImportId };
+    return state.roots.length === 0
+        ? { kind: "chats-import", paths: state.paths, ...previous }
+        : {
+            kind: "chats-import",
+            paths: state.paths,
+            ...previous,
+            roots: state.roots,
+            excludeProjects: state.excludeProjects,
+        };
+}
+function importArgument(state, argument) {
+    if (state.option !== undefined)
+        return importValue(state, argument);
+    if (argument === "")
+        return "missing-argument";
+    if (state.literal) {
+        state.paths.push(argument);
+        return;
     }
-    return paths.length === 0
-        ? error("missing-argument")
-        : { kind: "chats-import", paths };
+    if (argument === "--previous-import" && state.previousImportId !== undefined)
+        return "repeated-previous-import";
+    if (["--root", "--exclude-project", "--previous-import"].includes(argument)) {
+        state.option = argument;
+        return;
+    }
+    if (argument === "--") {
+        state.literal = true;
+        return;
+    }
+    if (argument.startsWith("-"))
+        return "unexpected-option";
+    state.paths.push(argument);
+    return;
+}
+function importValue(state, argument) {
+    if (argument === "" || argument.startsWith("-"))
+        return "missing-value";
+    const option = state.option;
+    state.option = undefined;
+    if (option === "--root") {
+        state.roots.push(argument);
+        return;
+    }
+    if (option === "--exclude-project" && !validProjectName(argument))
+        return "invalid-exclusion";
+    if (option === "--exclude-project") {
+        state.excludeProjects.push(argument);
+        return;
+    }
+    if (!/^[a-f\d]{8}-[a-f\d]{4}-4[a-f\d]{3}-[89ab][a-f\d]{3}-[a-f\d]{12}$/.test(argument))
+        return "invalid-import-id";
+    state.previousImportId = argument;
+    return;
+}
+function validProjectName(name) {
+    return (name !== "." &&
+        name !== ".." &&
+        !["/", "\\", "\0", "*", "?", "[", "]"].some((character) => name.includes(character)));
 }
 function parsedArguments(argumentsList) {
     try {

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

@@ -4,6 +4,7 @@ export interface Interruption {
     readonly reply: Reply;
 }
 export declare function send(runtimeDirectory: string, request: ServiceRequest): Promise<Reply>;
+export declare function listRuns(runtimeDirectory: string): Promise<Reply>;
 export declare function mutate(runtimeDirectory: string, mutation: {
     readonly request: ServiceRequest;
     readonly signal: Promise<void>;

package/dist/src/cli/client.js

@@ -1,7 +1,7 @@
 import net from "node:net";
 import { join } from "node:path";
 import { socketAddress } from "../broker/socket-address.js";
-import { parseReplyLine, requestLine, } from "../protocol.js";
+import { parseReplyLine, record, requestLine, } from "../protocol.js";
 const mutations = ["run", "decision", "run-command"];
 function unavailable(runtimeDirectory) {
     return {
@@ -89,6 +89,43 @@ const unobserved = () => undefined;
 export function send(runtimeDirectory, request) {
     return exchange({ runtimeDirectory, request, onEvent: unobserved });
 }
+function listedRuns(result) {
+    const runs = result["runs"];
+    return Array.isArray(runs)
+        ? runs.map(record).filter((run) => run !== undefined)
+        : [];
+}
+export async function listRuns(runtimeDirectory) {
+    const first = await send(runtimeDirectory, {
+        operation: "status",
+        parameters: { limit: 500 },
+    });
+    if (first.kind === "error")
+        return first;
+    const runs = listedRuns(first.result);
+    let next = first.result["next"];
+    let after = "";
+    while (typeof next === "string") {
+        if (next <= after)
+            return {
+                kind: "error",
+                error: {
+                    code: "invalid-run-page",
+                    detail: "The run-list cursor did not advance.",
+                },
+            };
+        after = next;
+        const page = await send(runtimeDirectory, {
+            operation: "status",
+            parameters: { limit: 500, after },
+        });
+        if (page.kind === "error")
+            return page;
+        runs.push(...listedRuns(page.result));
+        next = page.result["next"];
+    }
+    return { kind: "result", result: { ...first.result, runs, next: null } };
+}
 export function mutate(runtimeDirectory, mutation) {
     return exchange({
         runtimeDirectory,

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

@@ -1,3 +1,4 @@
+import type { WatchPrSettings } from "./watch-pr-settings.ts";
 import type { RuntimeInvocation } from "./runtime-arguments.ts";
 export interface Terminal {
     readonly out: (text: string) => void;
@@ -5,6 +6,8 @@ export interface Terminal {
 }
 export interface CommandEnvironment {
     readonly runtimeDirectory: string | undefined;
+    readonly watchActions?: string;
+    readonly watchPr?: WatchPrSettings;
     readonly client?: string;
     readonly workingDirectory: string;
     readonly terminal: Terminal;

package/dist/src/cli/commands.js

@@ -1,8 +1,8 @@
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { record, } from "../protocol.js";
-import { follow, mutate, send } from "./client.js";
-import { errorText, eventText, pendingSummary, rendered } from "./render.js";
+import { follow, listRuns, mutate, send } from "./client.js";
+import { errorText, eventText, pendingSummary, rendered, runOverview, statusJson, } from "./render.js";
 import { commandUsage } from "./usage.js";
 import { defaultWatchPort, watchServer } from "./watch-server.js";
 function errorObject(error, format) {
@@ -39,7 +39,9 @@ function presented(environment, outcome) {
     const { reply, format } = outcome;
     if (reply.kind === "error")
         return failed(environment, { error: reply.error, format });
-    environment.terminal.out(format.json ? `${JSON.stringify(reply.result)}\n` : rendered(reply.result));
+    environment.terminal.out(format.json
+        ? `${JSON.stringify(statusJson(reply.result))}\n`
+        : rendered(reply.result));
     return 0;
 }
 async function requested(environment, exchange) {
@@ -135,6 +137,15 @@ async function status(environment, invocation) {
     const { runId, limit, after, json } = invocation;
     if (!json && runId === null)
         await summarized(environment);
+    if (!json && runId === null && limit === null && after === null) {
+        const reply = await listRuns(environment.runtimeDirectory);
+        return presented(environment, {
+            format: { json },
+            reply: reply.kind === "result"
+                ? { kind: "result", result: runOverview(reply.result) }
+                : reply,
+        });
+    }
     return requested(environment, {
         format: { json },
         request: {
@@ -235,14 +246,7 @@ function located(invocation, environment) {
     if (invocation.kind === "events")
         return events(environment, invocation);
     if (invocation.kind === "watch")
-        return watchServer({
-            runtimeDirectory: environment.runtimeDirectory,
-            port: invocation.port ?? defaultWatchPort,
-            client: environment.client ?? "cloving",
-            announce: environment.terminal.out,
-            complain: environment.terminal.error,
-            stopped: environment.interrupted(),
-        });
+        return watch(environment, invocation);
     return requested(environment, {
         format: { json: invocation.json },
         request: {
@@ -251,3 +255,17 @@ function located(invocation, environment) {
         },
     });
 }
+function watch(environment, invocation) {
+    return watchServer({
+        actions: environment.watchActions ?? "on",
+        ...(environment.watchPr === undefined
+            ? {}
+            : { pullRequests: environment.watchPr }),
+        runtimeDirectory: environment.runtimeDirectory,
+        port: invocation.port ?? defaultWatchPort,
+        client: environment.client ?? "cloving",
+        announce: environment.terminal.out,
+        complain: environment.terminal.error,
+        stopped: environment.interrupted(),
+    });
+}

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

@@ -1 +1,2 @@
-export declare function main(argumentsList: readonly string[]): Promise<void>;
+import type { WatchPrSettings } from "./watch-pr-settings.ts";
+export declare function main(argumentsList: readonly string[], watchPr?: WatchPrSettings): Promise<void>;

package/dist/src/cli/main.js

@@ -1,34 +1,43 @@
 import { randomUUID } from "node:crypto";
 import packageMetadata from "#package" with { type: "json" };
+import { redactImport } from "../chats/redact-import.js";
+import { emptyCounts } from "../chats/redaction.js";
 import { importChats } from "../chats/import.js";
 import { parseInvocation } from "./arguments.js";
 import { runtimeCommand } from "./commands.js";
 import { clientCommand, runtimeDirectory } from "./runtime-directory.js";
-import { chatsImportUsage, usage, validateUsage } from "./usage.js";
+import { chatsRedactUsage, chatsImportUsage, usage, validateUsage, } from "./usage.js";
 import { validateWorkflow } from "./validate.js";
-export async function main(argumentsList) {
+const helpTexts = {
+    help: usage,
+    version: `${packageMetadata.version}\n`,
+    "validate-help": validateUsage,
+    "chats-import-help": chatsImportUsage,
+    "chats-redact-help": chatsRedactUsage,
+};
+function helpInvocation(invocation) {
+    return Object.hasOwn(helpTexts, invocation.kind);
+}
+export async function main(argumentsList, watchPr) {
     const invocation = parseInvocation(argumentsList);
+    if (refuseChatPlatform(invocation))
+        return;
+    if (helpInvocation(invocation)) {
+        process.stdout.write(helpTexts[invocation.kind]);
+        return;
+    }
     if (invocation.kind === "usage-error") {
         presentUsageError(invocation);
     }
     else if (invocation.kind === "validate") {
         await validationCommand(invocation);
     }
-    else if (invocation.kind === "version") {
-        process.stdout.write(`${packageMetadata.version}\n`);
-    }
-    else if (invocation.kind === "help") {
-        process.stdout.write(usage);
-    }
-    else if (invocation.kind === "validate-help") {
-        process.stdout.write(validateUsage);
-    }
-    else if (invocation.kind === "chats-import-help") {
-        process.stdout.write(chatsImportUsage);
+    else if (invocation.kind === "chats-redact") {
+        await redactionCommand(invocation.importId);
     }
     else if (invocation.kind === "chats-import") {
         const result = await importChats({
-            paths: invocation.paths,
+            ...invocation,
             workingDirectory: process.cwd(),
             runtimeDirectory: runtimeDirectory(process.env),
         });
@@ -38,6 +47,10 @@ export async function main(argumentsList) {
     else {
         process.exitCode = await runtimeCommand(invocation, {
             runtimeDirectory: runtimeDirectory(process.env),
+            ...(process.env["CLOVING_WATCH_ACTIONS"] === undefined
+                ? {}
+                : { watchActions: process.env["CLOVING_WATCH_ACTIONS"] }),
+            ...(watchPr === undefined ? {} : { watchPr }),
             client: clientCommand(process.env),
             workingDirectory: process.cwd(),
             terminal: {
@@ -54,6 +67,16 @@ export async function main(argumentsList) {
         });
     }
 }
+function refuseChatPlatform(invocation) {
+    if (process.platform === "darwin")
+        return false;
+    if (invocation.kind !== "chats-import" && invocation.kind !== "chats-redact")
+        return false;
+    process.stdout.write(`${JSON.stringify({ code: "platform-unsupported" })}\n`);
+    process.stderr.write("platform-unsupported: Chat commands require macOS.\n");
+    process.exitCode = 1;
+    return true;
+}
 function presentUsageError(invocation) {
     if (invocation.json)
         process.stdout.write(`${JSON.stringify({ schemaVersion: 1, kind: "usage-error", code: invocation.code })}\n`);
@@ -78,3 +101,27 @@ function present(report, format) {
     for (const error of report.errors)
         process.stderr.write(`${error.code}: ${error.file}: ${error.detail}\n`);
 }
+async function redactionCommand(importId) {
+    let privateTexts = [];
+    try {
+        const setting = process.env["CLOVING_PRIVATE_TEXTS"];
+        if (setting !== undefined)
+            privateTexts = JSON.parse(setting);
+        if (!Array.isArray(privateTexts) ||
+            !privateTexts.every((item) => typeof item === "string" && item.trim() !== ""))
+            throw new Error("invalid-settings");
+    }
+    catch {
+        process.stdout.write(`${JSON.stringify({ code: "invalid-settings", importId, recordCount: 0, counts: emptyCounts(), totalCount: 0 })}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const result = await redactImport({
+        importId,
+        workingDirectory: process.cwd(),
+        runtimeDirectory: runtimeDirectory(process.env),
+        settings: { home: process.env["HOME"] || null, privateTexts },
+    });
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    process.exitCode = result.code === "redaction-complete" ? 0 : 1;
+}

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

@@ -1,5 +1,8 @@
 import { type Fields } from "../protocol.ts";
 export declare function errorText(error: Fields): string;
+export declare function runOverview(result: Fields): Fields;
+export declare function queueLines(value: unknown): readonly string[];
+export declare function statusJson(result: Fields): Fields;
 export declare function runStatus(result: Fields): readonly string[];
 export declare function decisionLines(decision: unknown): readonly string[];
 export declare function decisionList(result: Fields): readonly string[];

package/dist/src/cli/render.js

@@ -1,4 +1,6 @@
+import { priceText, usageText, totalsSuffix } from "./usage-render.js";
 import { record } from "../protocol.js";
+import { workflowRefusals } from "../workflow-refusals.js";
 function show(value) {
     return typeof value === "string" ? value : JSON.stringify(value);
 }
@@ -56,15 +58,74 @@ function admitted(result) {
     ];
 }
 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")}`;
+    const line = `  ${show(part(run, "runId"))}  ${show(part(run, "workflowId"))}  ${show(part(run, "condition"))}  revision ${show(part(run, "revision"))}  latest at ${show(part(run, "latestAt") ?? "none")}`;
+    return [line, ...chainLines(run).map((link) => `    ${link}`)].join("\n");
+}
+function chainLines(run) {
+    return [
+        `Parent run: ${visible(part(run, "parentRunId") ?? "none")}`,
+        `Chain: ${visible(part(run, "chainId") ?? part(run, "runId") ?? "none")}`,
+        `Child runs: ${visible(listing(part(run, "childRunIds")))}`,
+    ];
+}
+function ended(run) {
+    return ["completed", "failed", "cancelled"].includes(show(run["state"]));
+}
+function newest(first, second) {
+    return show(second["latestAt"] ?? "").localeCompare(show(first["latestAt"] ?? ""));
+}
+export function runOverview(result) {
+    const listed = result["runs"];
+    const runs = Array.isArray(listed)
+        ? listed.map(record).filter((run) => run !== undefined)
+        : [];
+    const active = runs.filter((run) => !ended(run)).toSorted(newest);
+    const finished = runs.filter(ended).toSorted(newest);
+    return {
+        ...result,
+        runs: [...active, ...finished.slice(0, 20)],
+        hiddenRuns: Math.max(0, finished.length - 20),
+    };
 }
 function runList(result) {
     const runs = result["runs"];
     const lines = Array.isArray(runs) ? runs.map(runLine) : [];
+    const hiddenRuns = result["hiddenRuns"];
+    const refusals = workflowRefusals(result["workflowRefusals"]);
     return [
         `Workflows: ${visible(listing(result["workflows"]))}`,
+        ...queueLines(result["queue"]),
+        ...(refusals.length === 0
+            ? []
+            : [
+                "Refused workflows:",
+                ...refusals.map((entry) => `  ${entry.scope} ${entry.label}: ${entry.codes.join(", ")}`),
+            ]),
         "Runs:",
         ...(lines.length === 0 ? ["  none"] : lines),
+        ...(typeof hiddenRuns === "number" && hiddenRuns > 0
+            ? [
+                `${String(hiddenRuns)} older runs: use --limit and --after to see them`,
+            ]
+            : []),
+    ];
+}
+export function queueLines(value) {
+    const queue = record(value);
+    if (queue === undefined)
+        return [];
+    const skipped = queue["skipped"];
+    return [
+        `Queue: ${visible(queue["busy"])} of ${visible(queue["lanes"])} lanes busy`,
+        ...(Array.isArray(skipped)
+            ? skipped.map((item) => {
+                const dependencies = part(item, "dependencies");
+                const needs = Array.isArray(dependencies)
+                    ? `; needs ${dependencies.map(visible).join(", ")}`
+                    : "";
+                return `Skipped ticket ${visible(part(item, "ticketId"))}: ${visible(part(item, "reason"))}${needs}`;
+            })
+            : []),
     ];
 }
 function observation(value) {
@@ -75,36 +136,90 @@ function observation(value) {
 function feedbackLines(value) {
     return (Array.isArray(value) ? value : []).map((item) => `Feedback of ${show(part(item, "decisionId"))}: ${visible(part(item, "text"))}`);
 }
-function outcome(value) {
+function outcomeLines(value) {
     if (record(value) === undefined)
-        return "none";
+        return ["Outcome: none"];
     const reason = part(value, "reason");
     const kind = visible(part(value, "kind"));
-    return typeof reason === "string" ? `${kind}: ${visible(reason)}` : kind;
+    return [
+        `Outcome: ${typeof reason === "string" ? `${kind}: ${visible(reason)}` : kind}`,
+        ...(typeof part(value, "promotionId") === "string"
+            ? [`Promotion: ${visible(part(value, "promotionId"))}`]
+            : []),
+        ...(typeof part(value, "ticketStatus") === "string"
+            ? [`Ticket status: ${visible(part(value, "ticketStatus"))}`]
+            : []),
+        ...(part(value, "issueUpdate") === "failed"
+            ? ["Issue status update failed; check the GitHub operation."]
+            : []),
+    ];
+}
+function workerLines(value) {
+    return (Array.isArray(value) ? value : []).flatMap((turn) => [
+        `Worker turn ${visible(part(turn, "operationId"))}: ${priceText(part(turn, "costUsd"), part(turn, "estimatedCostUsd"))}`,
+        `  ${usageText(part(turn, "usage"))}`,
+    ]);
+}
+export function statusJson(result) {
+    const run = record(result["run"]);
+    if (result["kind"] !== "run-status" || run === undefined)
+        return result;
+    const turns = run["workerTurns"];
+    return {
+        ...result,
+        run: {
+            ...run,
+            costDisplay: priceText(run["claudeCostUsd"], run["estimatedCostUsd"]),
+            ...(Array.isArray(turns)
+                ? {
+                    workerTurns: turns.map((turn) => {
+                        const fields = record(turn);
+                        if (fields === undefined)
+                            return turn;
+                        return {
+                            ...fields,
+                            costDisplay: priceText(fields["costUsd"], fields["estimatedCostUsd"]),
+                        };
+                    }),
+                }
+                : {}),
+        },
+    };
+}
+function inputText(value) {
+    const text = visible(record(value) ?? null);
+    const characters = Array.from(text);
+    return characters.length > 200
+        ? `${characters.slice(0, 200).join("")}…`
+        : text;
 }
 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");
+    const suffix = totalsSuffix(part(run, "state"));
     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"))}`,
+        ...outcomeLines(part(run, "outcome")),
         `Condition: ${show(part(run, "condition"))}`,
         `Reason: ${show(part(reason, "code"))}: ${show(part(reason, "detail"))}`,
+        `Input: ${inputText(part(run, "input"))}`,
         `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`,
+        `Cost${suffix}: ${priceText(part(run, "claudeCostUsd"), part(run, "estimatedCostUsd"))}`,
+        `Token usage${suffix}: ${usageText(part(run, "usage"))}`,
+        ...workerLines(part(run, "workerTurns")),
         `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")),
+        ...chainLines(run),
     ];
 }
 function binding(decision) {

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

@@ -0,0 +1,3 @@
+export declare function priceText(value: unknown, estimate?: unknown): string;
+export declare function usageText(value: unknown): string;
+export declare function totalsSuffix(state: unknown): string;

package/dist/src/cli/usage-render.js

@@ -0,0 +1,28 @@
+import { priceOf, usageOf } from "../worker-usage.js";
+export function priceText(value, estimate) {
+    const price = priceOf(value);
+    if (price === null && priceOf(estimate) !== null)
+        return `≈ ${priceText(estimate)} (estimate)`;
+    if (price === null)
+        return "Price not known";
+    return `${price.toLocaleString("en-US", {
+        useGrouping: false,
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+    })} USD`;
+}
+export function usageText(value) {
+    const usage = usageOf(value);
+    return [
+        ["Input tokens", usage.input_tokens],
+        ["Cache read tokens", usage.cache_read_input_tokens],
+        ["Output tokens", usage.output_tokens],
+    ]
+        .map(([label, count]) => `${String(label)}: ${count === null ? "Token usage not known" : String(count)}`)
+        .join(" · ");
+}
+export function totalsSuffix(state) {
+    return ["completed", "failed", "cancelled"].includes(String(state))
+        ? ""
+        : " so far";
+}

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

@@ -1,4 +1,5 @@
 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 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 redact  Redact one imported chat corpus into private runtime files.\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       cloving chats import --root <projects-folder> [--root <projects-folder> ...] [--exclude-project <name> ...] [-- <path> ...]\n\nImports only the selected Claude Code JSONL files. Relative paths use the current directory.\nThis local command needs no service. It scans only explicitly named roots and does not expand globs or discover configuration.\nPositional files come first, retaining order and repetitions. Roots sort by canonical path, then entries by relative path in JavaScript string order.\nExclusions match direct project folder names exactly and prune their children. Exclusions require a root.\nScans accept lowercase .jsonl filenames, attempt at most 100 eligible files across roots, and stop before entering folders at depth four.\nLater file candidates and depth-limited folders are pending. Select pending files explicitly in a later import.\nLinked components, containment changes and roots in Git repositories are refused. Scan protections require the supported macOS kernel.\nThe file limit is 10 MiB (10,485,760 bytes). Links and nonregular files are refused.\nThe total normalized corpus limit is 50 MiB (52,428,800 UTF-8 bytes), including newlines and repeated selections.\nExceeding that total returns output-failed with exit code 1 and no completed coverage manifest; partial files may remain.\n--previous-import <IMPORT_ID> compares against one explicitly named UUID v4 import before --.\nThe earlier coverage and optional revision must be valid, completed private metadata; otherwise previous-import-refused returns exit 1 with no new import.\nA comparison writes private revision.json with ordered selection evidence and six status counts. Matching uses source path and selected root path; repetitions pair in order.\nByte-verified extensions are extended; shorter sources are truncated. Legacy imports without sizes can establish unchanged digests but cannot prove extension or truncation.\nMissing or truncated evidence makes the import partial. History completeness remains unknown.\nPrivate corpus.jsonl, structure.json 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.\nStructure preserves branches and marks known copies without removing records. History completeness remains unknown.\nRoot imports write coverage version 2 and add excluded and pending entry counts; positional-only imports retain coverage version 1.\nExit codes: 0 for no refused, pending, missing or truncated entries (exclusions alone permit success without comparison), 1 for partial coverage or processing 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";
+export declare const chatsRedactUsage = "Usage: cloving chats redact <IMPORT_ID>\n\nRedact one existing import selected by its UUID v4 import ID. No service is required.\nWrite redacted.jsonl and redaction.json beside the original corpus with mode 0600.\nHOME supplies the home folder. CLOVING_PRIVATE_TEXTS is an optional JSON list of nonblank strings.\nOriginals and metadata remain private. Redaction does not authorize model use or guarantee removal of every private value.\nExit codes: 0 complete, 1 processing failure, 2 invalid usage.\n";