cloving 1.3.0 → 1.5.0

package/dist/src/broker/command-wait-restore.js

@@ -0,0 +1,86 @@
+import { commandWaitKey, } from "../authority/command-waits.js";
+import { operationPhase } from "../operation-identity.js";
+import { documentDigest } from "./decision-restore.js";
+import { readExecutionManifest } from "../execution-pin.js";
+import { text } from "../storage/domain-rows.js";
+import { commandWaitStatements, loadCommandWaits, } from "../storage/command-wait-rows.js";
+import { checkedVersion, waitingVersion, upgradeSchema, } from "../storage/domain-schema.js";
+export function commandWaitRows(waits) {
+    return Object.values(waits).sort((left, right) => {
+        if (left.runId !== right.runId)
+            return left.runId < right.runId ? -1 : 1;
+        return left.name < right.name ? -1 : 1;
+    });
+}
+export function commandWaitState(rows) {
+    const waits = {};
+    for (const row of rows) {
+        const state = [
+            "waiting",
+            "timed-out",
+            "cancelled",
+            "completed",
+            "failed",
+        ];
+        const kind = state.find((candidate) => candidate === row.state);
+        if (kind === undefined)
+            throw new Error("invalid-command-wait-state");
+        waits[commandWaitKey(row.runId, row.name)] = { ...row, state: kind };
+    }
+    return rows.length === 0 ? {} : { commandWaits: waits };
+}
+export async function readCommandWaits(connection, runId) {
+    return commandWaitState(await loadCommandWaits(connection, { runId }));
+}
+export async function upgradeCommandWaits(database, state) {
+    await database.transaction(async (connection) => {
+        await upgradeSchema(connection, waitingVersion);
+        for (const statement of commandWaitStatements(commandWaitRows(state.commandWaits ?? {}), { version: "opened" }))
+            await connection.run(statement.sql, statement.parameters);
+    });
+}
+export async function upgradeCommandWaitChecks(database) {
+    await database.transaction(async (connection) => {
+        await upgradeSchema(connection, checkedVersion);
+    });
+}
+export function commandWaitDeadline(waits, operationId) {
+    const wait = Object.values(waits).find((wait) => wait.checkOperation === operationId);
+    return wait === undefined
+        ? {}
+        : { commandDeadline: new Date(wait.deadline).toISOString() };
+}
+export async function dispatchCommandWait(connection, check) {
+    if (operationPhase(check.operationId) !== "command-wait")
+        return {};
+    const state = await readCommandWaits(connection, check.runId);
+    const wait = Object.values(state.commandWaits ?? {}).find((wait) => wait.checkOperation === check.operationId);
+    if (wait === undefined)
+        return {};
+    const row = await connection.get("SELECT manifest FROM definitions WHERE pin = ?", [check.workflow]);
+    const declarations = readExecutionManifest(JSON.parse(text(row, "manifest"))).commandWaits ?? {};
+    const permission = Object.hasOwn(declarations, wait.name)
+        ? declarations[wait.name]
+        : undefined;
+    return { commandWait: { wait, declared: declaredWait(wait, permission) } };
+}
+function declaredWait(wait, permission) {
+    return (permission !== undefined &&
+        permission.command === wait.command &&
+        permission.maximumWaitSeconds === wait.maximumWaitSeconds &&
+        permission.pollEverySeconds === wait.pollEverySeconds);
+}
+export function commandOutputsIntact(events) {
+    return events.every((event) => {
+        const output = event.payload["commandOutput"];
+        return (output === undefined ||
+            (event.payload["worker"] === "command" &&
+                documentDigest(output) === event.payload["result"]));
+    });
+}
+export async function readCommandWaitDeadline(connection, scope) {
+    if (operationPhase(scope.operationId) !== "command-wait")
+        return {};
+    const state = await readCommandWaits(connection, scope.runId);
+    return commandWaitDeadline(state.commandWaits ?? {}, scope.operationId);
+}

package/dist/src/broker/decision-restore.d.ts

@@ -2,7 +2,7 @@ import type { RunDetails } from "../authority/details.ts";
 import { type GateState } from "../authority/gates.ts";
 import type { AuthorityState } from "../authority/reducer.ts";
 import type { DecisionRows, DetailRow, DocumentRow, GateRow } from "../storage/decision-rows.ts";
-export type DecisionState = Pick<AuthorityState, "gates" | "details" | "questions">;
+export type DecisionState = Pick<AuthorityState, "gates" | "details" | "questions" | "commandWaits">;
 export declare function documentDigest(body: string): string;
 export declare function gateRecord(gate: GateState): GateRow;
 export declare function detailRecord(details: RunDetails): DetailRow;

package/dist/src/broker/decision-restore.js

@@ -141,6 +141,7 @@ export function decisionRows(state) {
 }
 export function referencedDigests(state) {
     return [
+        ...Object.values(state.commandWaits ?? {}).map((wait) => wait.inputDigest),
         ...Object.values(state.gates).flatMap((gate) => [
             gate.prompt,
             gate.outcome?.answer ?? null,

package/dist/src/broker/effect-upgrade.d.ts

@@ -1,3 +1,6 @@
 import type { Database } from "solid-objects";
 import type { AuthorityState } from "../authority/reducer.ts";
 export declare function upgradeEffects(database: Database, state: AuthorityState): Promise<void>;
+export declare function upgradeSpendingIndexes(database: Database): Promise<void>;
+export declare function upgradeEventIndexes(database: Database): Promise<void>;
+export declare function upgradeRunIndexes(database: Database): Promise<void>;

package/dist/src/broker/effect-upgrade.js

@@ -1,9 +1,18 @@
-import { currentVersion, upgradeSchema } from "../storage/domain-schema.js";
+import { currentVersion, effectedVersion, eventIndexVersion, spendingVersion, upgradeSchema, } from "../storage/domain-schema.js";
 import { persistEffects } from "../storage/effect-changes.js";
 import { effectRows } from "./effect-restore.js";
 export async function upgradeEffects(database, state) {
     await database.transaction(async (connection) => {
-        await upgradeSchema(connection, currentVersion);
+        await upgradeSchema(connection, effectedVersion);
         await persistEffects(connection, effectRows(state.effects, []));
     });
 }
+export async function upgradeSpendingIndexes(database) {
+    await database.transaction((connection) => upgradeSchema(connection, spendingVersion));
+}
+export async function upgradeEventIndexes(database) {
+    await database.transaction((connection) => upgradeSchema(connection, eventIndexVersion));
+}
+export async function upgradeRunIndexes(database) {
+    await database.transaction((connection) => upgradeSchema(connection, currentVersion));
+}

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

@@ -9,6 +9,19 @@ export type Invocation = {
     readonly kind: "help";
 } | {
     readonly kind: "version";
+} | {
+    readonly kind: "mcp";
+} | {
+    readonly kind: "mcp-help";
+} | {
+    readonly kind: "init-prompt";
+} | {
+    readonly kind: "init";
+    readonly harness: string | undefined;
+} | {
+    readonly kind: "init-prompt-help";
+} | {
+    readonly kind: "init-help";
 } | {
     readonly kind: "doctor-help";
 } | {

package/dist/src/cli/arguments.js

@@ -12,6 +12,7 @@ const options = {
     version: { type: "boolean", short: "v" },
     input: { type: "string" },
     json: { type: "boolean" },
+    active: { type: "boolean" },
     prompt: { type: "string" },
     ticket: { type: "string" },
     next: { type: "boolean" },
@@ -26,6 +27,7 @@ const options = {
     follow: { type: "boolean" },
     since: { type: "string" },
     repository: { type: "string" },
+    harness: { type: "string" },
 };
 const textOptions = ["--prompt", "--text"];
 function knownFlag(token) {
@@ -83,8 +85,9 @@ function selectedInvocation(given) {
     const [command, ...remaining] = positionals;
     if (command === undefined)
         return topLevel(values);
-    if (command === "doctor")
-        return doctorInvocation(values, remaining);
+    const inspection = inspectionInvocation(command, { values, remaining });
+    if (inspection !== undefined)
+        return inspection;
     if (command === "workflows" && remaining[0] === "validate")
         return validation(values, remaining.slice(1));
     const outcome = runtimeInvocation({
@@ -96,6 +99,43 @@ function selectedInvocation(given) {
         return { kind: "usage-error", code: outcome, json };
     return outcome;
 }
+function inspectionInvocation(command, input) {
+    const { values, remaining } = input;
+    if (command === "init") {
+        if (unexpected(values, ["harness", "help"]))
+            return { kind: "usage-error", code: "unexpected-option", json: false };
+        if (remaining.length > 0)
+            return { kind: "usage-error", code: "unexpected-argument", json: false };
+        return values.help
+            ? { kind: "init-help" }
+            : { kind: "init", harness: values.harness };
+    }
+    if (command === "doctor")
+        return doctorInvocation(values, remaining);
+    if (command === "mcp")
+        return mcpInvocation(values, remaining);
+    if (command === "init-prompt")
+        return promptInvocation(values, remaining);
+    return undefined;
+}
+function mcpInvocation(values, remaining) {
+    if (unexpected(values, ["help"]))
+        return { kind: "usage-error", code: "unexpected-option", json: false };
+    if (remaining.length > 0)
+        return { kind: "usage-error", code: "unexpected-argument", json: false };
+    return { kind: values.help ? "mcp-help" : "mcp" };
+}
+function promptInvocation(values, remaining) {
+    if (unexpected(values, ["help"]))
+        return {
+            kind: "usage-error",
+            code: "unexpected-option",
+            json: values.json === true,
+        };
+    if (remaining.length > 0)
+        return { kind: "usage-error", code: "unexpected-argument", json: false };
+    return { kind: values.help ? "init-prompt-help" : "init-prompt" };
+}
 function doctorInvocation(values, remaining) {
     const json = values.json === true;
     if (unexpected(values, ["help", "json"]))
@@ -134,7 +174,7 @@ function knownCommand(positionals) {
         return true;
     if (command === "workflows")
         return subcommand === "validate";
-    if (command === "doctor")
+    if (["doctor", "init-prompt", "init", "mcp"].includes(command))
         return true;
     return isRuntimeCommand(command);
 }

package/dist/src/cli/chat-stores.d.ts

@@ -0,0 +1,2 @@
+import type { ChatStore } from "./init-prompt.ts";
+export declare function chatStores(home: string | undefined): Promise<readonly ChatStore[]>;

package/dist/src/cli/chat-stores.js

@@ -0,0 +1,113 @@
+import { lstat, opendir } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+const knownStores = [
+    {
+        name: "Claude Code",
+        folder: ".claude/projects",
+        format: "JSONL",
+        documentation: "https://code.claude.com/docs/en/claude-directory",
+    },
+    {
+        name: "Codex",
+        folder: ".codex/sessions",
+        format: "JSONL, including zstd-compressed .jsonl.zst (read with zstd -dc)",
+        documentation: "https://learn.chatgpt.com/docs/security/sdk",
+    },
+    {
+        name: "Gemini CLI",
+        folder: ".gemini",
+        format: "JSON conversation history and checkpoints under tmp/<project>/",
+        documentation: "https://geminicli.com/docs/cli/checkpointing/",
+    },
+    {
+        name: "opencode",
+        folder: ".local/share/opencode",
+        format: "SQLite (opencode.db); older versions use JSON files under storage/",
+        documentation: "https://docs.opencode.ai/docs/troubleshooting/",
+    },
+    {
+        name: "grok",
+        folder: ".grok",
+        format: "JSONL ACP events in sessions/<encoded-cwd>/<session-id>/updates.jsonl; raw messages in chat_history.jsonl; JSON metadata",
+        documentation: "https://github.com/xai-org/grok-build/blob/main/crates/codegen/xai-grok-pager/docs/user-guide/17-sessions.md",
+    },
+    {
+        name: "Cursor Agent",
+        folder: ".cursor",
+        format: "JSONL under projects/<project>/agent-transcripts/ (older transcripts may be text)",
+        documentation: "https://forum.cursor.com/t/accessing-the-full-agent-transcript-in-cursor/157311/5",
+    },
+];
+async function metadata(path) {
+    return lstat(path).catch((error) => {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return null;
+        throw error;
+    });
+}
+async function* storeFiles(path) {
+    const pending = [path];
+    for (let folder = pending.pop(); folder !== undefined; folder = pending.pop()) {
+        const directory = await opendir(folder);
+        for await (const entry of directory) {
+            const file = join(folder, entry.name);
+            if (entry.isDirectory())
+                pending.push(file);
+            if (!entry.isFile())
+                continue;
+            const info = await metadata(file);
+            if (info?.isFile())
+                yield info;
+        }
+    }
+}
+async function measure(path) {
+    let fileCount = 0;
+    let totalBytes = 0;
+    let oldest = null;
+    let newest = null;
+    for await (const info of storeFiles(path)) {
+        fileCount += 1;
+        totalBytes += info.size;
+        oldest = Math.min(oldest ?? info.mtimeMs, info.mtimeMs);
+        newest = Math.max(newest ?? info.mtimeMs, info.mtimeMs);
+    }
+    return {
+        fileCount,
+        totalBytes,
+        oldestFileDate: oldest === null ? null : new Date(oldest).toISOString(),
+        newestFileDate: newest === null ? null : new Date(newest).toISOString(),
+    };
+}
+async function inspectStore(path) {
+    try {
+        if (!(await metadata(path))?.isDirectory())
+            return null;
+        return await measure(path);
+    }
+    catch (error) {
+        return {
+            unavailable: error instanceof Error &&
+                "code" in error &&
+                typeof error.code === "string"
+                ? error.code
+                : "scan-failed",
+            fileCount: null,
+            totalBytes: null,
+            oldestFileDate: null,
+            newestFileDate: null,
+        };
+    }
+}
+export async function chatStores(home) {
+    if (!home || !isAbsolute(home))
+        return [];
+    const stores = [];
+    for (const { folder, ...store } of knownStores) {
+        const path = join(home, folder);
+        const facts = await inspectStore(path);
+        if (facts)
+            stores.push({ ...store, path, ...facts });
+    }
+    return stores;
+}

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

@@ -3,8 +3,13 @@ export interface Interruption {
     readonly signal: Promise<void>;
     readonly reply: Reply;
 }
-export declare function send(runtimeDirectory: string, request: ServiceRequest): Promise<Reply>;
-export declare function listRuns(runtimeDirectory: string): Promise<Reply>;
+export interface ClientRequest extends ServiceRequest {
+    readonly signal?: AbortSignal;
+}
+export declare function send(runtimeDirectory: string, input: ClientRequest): Promise<Reply>;
+export declare function listRuns(runtimeDirectory: string, selection?: {
+    readonly active?: true;
+}): Promise<Reply>;
 export declare function mutate(runtimeDirectory: string, mutation: {
     readonly request: ServiceRequest;
     readonly signal: Promise<void>;

package/dist/src/cli/client.js

@@ -2,7 +2,7 @@ import net from "node:net";
 import { join } from "node:path";
 import { socketAddress } from "../broker/socket-address.js";
 import { parseReplyLine, record, requestLine, } from "../protocol.js";
-const mutations = ["run", "decision", "run-command"];
+const mutations = ["run", "decision", "run-command", "queue-command"];
 function unavailable(runtimeDirectory) {
     return {
         kind: "error",
@@ -41,7 +41,7 @@ function exchange(context) {
             error: { code: address.reason, detail: address.detail },
         });
     return new Promise((settle) => {
-        const socket = net.connect(address.path);
+        const socket = net.connect({ path: address.path, signal: context.signal });
         let buffered = "";
         let written = false;
         socket.setEncoding("utf8");
@@ -86,8 +86,14 @@ function exchange(context) {
     });
 }
 const unobserved = () => undefined;
-export function send(runtimeDirectory, request) {
-    return exchange({ runtimeDirectory, request, onEvent: unobserved });
+export function send(runtimeDirectory, input) {
+    const { signal, ...request } = input;
+    return exchange({
+        runtimeDirectory,
+        request,
+        onEvent: unobserved,
+        ...(signal === undefined ? {} : { signal }),
+    });
 }
 function listedRuns(result) {
     const runs = result["runs"];
@@ -95,10 +101,10 @@ function listedRuns(result) {
         ? runs.map(record).filter((run) => run !== undefined)
         : [];
 }
-export async function listRuns(runtimeDirectory) {
+export async function listRuns(runtimeDirectory, selection = {}) {
     const first = await send(runtimeDirectory, {
         operation: "status",
-        parameters: { limit: 500 },
+        parameters: { ...selection, limit: 500 },
     });
     if (first.kind === "error")
         return first;
@@ -117,7 +123,7 @@ export async function listRuns(runtimeDirectory) {
         after = next;
         const page = await send(runtimeDirectory, {
             operation: "status",
-            parameters: { limit: 500, after },
+            parameters: { ...selection, limit: 500, after },
         });
         if (page.kind === "error")
             return page;

package/dist/src/cli/command-requests.d.ts

@@ -0,0 +1,46 @@
+import { type Fields, type Reply, type ServiceError, type ServiceRequest } from "../protocol.ts";
+import { type ClientRequest } from "./client.ts";
+import type { DecisionCommand, RunCommand, RunSource } from "./runtime-arguments.ts";
+export interface ReadCommand {
+    readonly kind: "status" | "questions" | "events" | "reload";
+    readonly runId?: string | null;
+    readonly limit?: number | null;
+    readonly after?: string | number | null;
+    readonly active?: boolean;
+    readonly follow?: boolean;
+}
+export type SubmittedSource = Exclude<RunSource, {
+    readonly kind: "input";
+}> | {
+    readonly kind: "input";
+    readonly submission: Fields;
+};
+export declare function runRequest(run: {
+    readonly workflowId: string;
+    readonly source: SubmittedSource;
+    readonly commandId: string;
+}): ServiceRequest;
+export interface DecisionRequest {
+    readonly command: DecisionCommand;
+    readonly reference: string;
+    readonly text: string | null;
+    readonly expectedRevision: number;
+    readonly generation: number;
+    readonly subjectDigest: string;
+    readonly commandId: string;
+}
+export declare function decisionRequest(decision: DecisionRequest): ServiceRequest;
+export declare function runCommandRequest(request: {
+    readonly command: RunCommand;
+    readonly runId: string;
+    readonly expectedRevision: number;
+    readonly commandId: string;
+}): ServiceRequest;
+export declare function readCommandRequest(command: ReadCommand): ServiceRequest;
+export declare function readCommandReply(runtimeDirectory: string, request: ClientRequest): Promise<Reply>;
+export declare function errorObject(error: ServiceError, format?: {
+    readonly commandId?: string;
+}): Fields;
+export declare function commandJson(reply: Reply, format?: {
+    readonly commandId?: string;
+}): Fields;

package/dist/src/cli/command-requests.js

@@ -0,0 +1,84 @@
+import {} from "../protocol.js";
+import { send } from "./client.js";
+import { withCiReruns } from "./github-ci-progress.js";
+import { statusJson } from "./render.js";
+function submission(source) {
+    if (source.kind === "input")
+        return source.submission;
+    return source.kind === "prompt"
+        ? { prompt: source.text }
+        : { ticket: source.id };
+}
+export function runRequest(run) {
+    return {
+        operation: "run",
+        parameters: {
+            workflowId: run.workflowId,
+            source: run.source.kind,
+            submission: submission(run.source),
+            commandId: run.commandId,
+        },
+    };
+}
+export function decisionRequest(decision) {
+    return {
+        operation: "decision",
+        parameters: Object.fromEntries(Object.entries(decision).filter(([, value]) => value !== null)),
+    };
+}
+export function runCommandRequest(request) {
+    return {
+        operation: "run-command",
+        parameters: {
+            command: request.command,
+            runId: request.runId,
+            expectedRevision: request.expectedRevision,
+            commandId: request.commandId,
+        },
+    };
+}
+export function readCommandRequest(command) {
+    const { kind, runId, limit, after, active, follow } = command;
+    const parameters = kind === "questions"
+        ? { runId }
+        : {
+            runId,
+            limit,
+            after,
+            ...(active === true ? { active } : {}),
+            ...(follow === undefined ? {} : { follow }),
+        };
+    return {
+        operation: kind,
+        parameters: Object.fromEntries(Object.entries(parameters).filter(([, value]) => value !== null && value !== undefined)),
+    };
+}
+export async function readCommandReply(runtimeDirectory, request) {
+    const reply = await send(runtimeDirectory, request);
+    return request.operation === "status"
+        ? await withCiReruns(runtimeDirectory, reply)
+        : reply;
+}
+export function errorObject(error, format = {}) {
+    if (error.code === "event-gap")
+        return {
+            schemaVersion: 1,
+            kind: "event-gap",
+            after: error["after"],
+            earliestAvailable: error["earliestAvailable"],
+            latestSequence: error["latestSequence"],
+        };
+    return {
+        schemaVersion: 1,
+        kind: "error",
+        ...error,
+        commandId: error["commandId"] ?? format.commandId ?? null,
+        runId: error["runId"] ?? null,
+        currentRevision: error["currentRevision"] ?? null,
+    };
+}
+export function commandJson(reply, format = {}) {
+    return reply.kind === "error"
+        ? errorObject(reply.error, format)
+        : statusJson(reply.result);
+}

package/dist/src/cli/command-waits.d.ts

@@ -0,0 +1,9 @@
+import { type Shown } from "./watch-element.ts";
+import type { CommandWaitView } from "../authority/command-wait-view.ts";
+export declare function shownCommandWaits(value: unknown): readonly CommandWaitView[];
+export declare function commandWaitText(wait: CommandWaitView): string;
+export declare function CommandWaits(props: {
+    readonly waits: readonly CommandWaitView[];
+}): Shown;
+export declare function effectBudgetText(spent: number | null | undefined, limit: number | null | undefined): string;
+export declare function activeCommandWait(waits: readonly CommandWaitView[]): boolean;

package/dist/src/cli/command-waits.js

@@ -0,0 +1,51 @@
+import { element } from "./watch-element.js";
+import { record } from "../protocol.js";
+function waitTime(value) {
+    return typeof value === "string" ? value : null;
+}
+export function shownCommandWaits(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry) => {
+        const fields = record(entry);
+        if (typeof fields?.["name"] !== "string" ||
+            typeof fields["command"] !== "string" ||
+            typeof fields["state"] !== "string" ||
+            typeof fields["maximumWaitSeconds"] !== "number" ||
+            typeof fields["remainingSeconds"] !== "number" ||
+            typeof fields["checkCount"] !== "number")
+            return [];
+        return [
+            {
+                name: fields["name"],
+                command: fields["command"],
+                state: fields["state"],
+                maximumWaitSeconds: fields["maximumWaitSeconds"],
+                remainingSeconds: fields["remainingSeconds"],
+                checkCount: fields["checkCount"],
+                startedAt: waitTime(fields["startedAt"]),
+                deadline: waitTime(fields["deadline"]),
+                nextCheckAt: waitTime(fields["nextCheckAt"]),
+                reason: waitTime(fields["reason"]),
+            },
+        ];
+    });
+}
+export function commandWaitText(wait) {
+    const reason = wait.reason === null ? "" : ` · ${wait.reason}`;
+    return `Command wait ${wait.name} · ${wait.command} · ${wait.state} · ${String(wait.remainingSeconds)} s left · deadline ${wait.deadline ?? "none"} · next check ${wait.nextCheckAt ?? "none"} · checks ${String(wait.checkCount)}${reason}`;
+}
+export function CommandWaits(props) {
+    return props.waits.map((wait) => element("p", {
+        class: "meta command-wait",
+        children: commandWaitText(wait),
+    }));
+}
+export function effectBudgetText(spent, limit) {
+    return spent == null || limit == null
+        ? ""
+        : `${String(spent)} of ${String(limit)} effect units`;
+}
+export function activeCommandWait(waits) {
+    return waits.some((wait) => wait.state === "waiting");
+}