voratiq 0.1.0-beta.24 → 0.1.0-beta.26

package/README.md

@@ -15,7 +15,7 @@ npm install -g voratiq
 
 - Node 20+
 - git
-- 1+ AI coding agent (Claude [>=2.1.111](https://github.com/anthropics/claude-code?tab=readme-ov-file#get-started), Codex [>=0.122.0](https://github.com/openai/codex?tab=readme-ov-file#quickstart), or Gemini [>=0.31.0](https://github.com/google-gemini/gemini-cli?tab=readme-ov-file#quick-install))
+- 1+ AI coding agent (Claude [>=2.1.111](https://github.com/anthropics/claude-code?tab=readme-ov-file#get-started), Codex [>=0.122.0](https://github.com/openai/codex?tab=readme-ov-file#quickstart), or Gemini [>=0.40.0](https://github.com/google-gemini/gemini-cli?tab=readme-ov-file#quick-install))
 - macOS: `ripgrep`
 - Linux (Debian/Ubuntu): `bubblewrap`, `socat`, `ripgrep`
 

package/dist/agents/runtime/harness.js

@@ -42,7 +42,7 @@ export async function runSandboxedAgent(input) {
             runtimeManifestPath: paths.runtimeManifestPath,
             promptPath,
             workspacePath: paths.workspacePath,
-            env: staged.env,
+            env: applyProviderRunEnvironmentOverrides(providerId, staged.env),
             environment,
         });
         const denialBackoff = resolveDenialBackoff({
@@ -111,6 +111,15 @@ export async function runSandboxedAgent(input) {
         }
     }
 }
+function applyProviderRunEnvironmentOverrides(providerId, env) {
+    if (providerId !== "gemini") {
+        return env;
+    }
+    return {
+        ...env,
+        GEMINI_CLI_TRUST_WORKSPACE: "true",
+    };
+}
 function resolveDenialBackoff(options) {
     if (options.override) {
         return options.override;

package/dist/bin.js

@@ -8,24 +8,68 @@ const SIGNAL_EXIT_CODES = {
     SIGINT: 130,
     SIGTERM: 143,
 };
+const PROCESS_GUARD_SIGNALS = ["SIGHUP", "SIGINT", "SIGTERM"];
 let activeJsonEnvelopeOperator;
 let processGuardsInstalled = false;
+let activeShutdownState;
 function installProcessGuards() {
     if (processGuardsInstalled) {
         return;
     }
     processGuardsInstalled = true;
-    for (const signal of ["SIGHUP", "SIGINT", "SIGTERM"]) {
-        process.once(signal, () => {
-            void handleSignal(signal);
-        });
+    for (const signal of PROCESS_GUARD_SIGNALS) {
+        installSignalGuard(signal);
     }
     process.on("uncaughtException", (error) => {
-        void handleFatalError("uncaught exception", error);
+        void beginFatalShutdown("uncaught exception", error);
     });
     process.on("unhandledRejection", (reason) => {
-        void handleFatalError("unhandled rejection", reason);
+        void beginFatalShutdown("unhandled rejection", reason);
+    });
+}
+function installSignalGuard(signal) {
+    const handler = () => {
+        // Re-arm the listener before awaiting teardown so repeated interrupts stay
+        // inside the coordinated abort path instead of falling through to the
+        // process default signal exit.
+        process.once(signal, handler);
+        void beginSignalShutdown(signal);
+    };
+    process.once(signal, handler);
+}
+async function beginFatalShutdown(context, error) {
+    if (activeShutdownState) {
+        if (activeShutdownState.kind === "signal") {
+            return;
+        }
+        await activeShutdownState.promise;
+        return;
+    }
+    const promise = handleFatalError(context, error).finally(() => {
+        if (activeShutdownState?.promise === promise) {
+            activeShutdownState = undefined;
+        }
+    });
+    activeShutdownState = { kind: "fatal", promise };
+    await promise;
+}
+async function beginSignalShutdown(signal) {
+    if (activeShutdownState) {
+        if (activeShutdownState.kind === "signal") {
+            process.exitCode = activeShutdownState.exitCode;
+            await activeShutdownState.promise;
+        }
+        return;
+    }
+    const exitCode = SIGNAL_EXIT_CODES[signal] ?? 1;
+    process.exitCode = exitCode;
+    const promise = handleSignal(signal).finally(() => {
+        if (activeShutdownState?.promise === promise) {
+            activeShutdownState = undefined;
+        }
     });
+    activeShutdownState = { kind: "signal", exitCode, promise };
+    await promise;
 }
 async function handleFatalError(context, error) {
     await terminateActiveSessionsSafe("failed", context);

package/dist/cli/contract.d.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { type ListMode, type ListOperator } from "../contracts/list.js";
 export declare const externalExecutionOperators: readonly ["spec", "run", "reduce", "verify", "message", "apply"];
 export declare const externalInspectionOperators: readonly ["spec", "run", "reduce", "verify", "message", "interactive"];
-export declare const externalInspectionModes: readonly ["table", "detail"];
+export declare const externalInspectionModes: readonly ["summary", "detail"];
 export type ExternalExecutionOperator = (typeof externalExecutionOperators)[number];
 export type ExternalInspectionOperator = ListOperator;
 export type ExternalInspectionMode = ListMode;
@@ -25,7 +25,7 @@ export declare const externalInspectionOperatorSchema: z.ZodEnum<{
 }>;
 export declare const externalInspectionModeSchema: z.ZodEnum<{
     detail: "detail";
-    table: "table";
+    summary: "summary";
 }>;
 export declare const externalSpecExecutionInputSchema: z.ZodObject<{
     description: z.ZodString;
@@ -87,7 +87,7 @@ export declare const externalApplyExecutionInputSchema: z.ZodObject<{
     ignoreBaseMismatch: z.ZodOptional<z.ZodBoolean>;
     commit: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
-export declare const externalListTableInputSchema: z.ZodObject<{
+export declare const externalListSummaryInputSchema: z.ZodObject<{
     operator: z.ZodEnum<{
         message: "message";
         spec: "spec";
@@ -96,9 +96,9 @@ export declare const externalListTableInputSchema: z.ZodObject<{
         verify: "verify";
         interactive: "interactive";
     }>;
-    verbose: z.ZodOptional<z.ZodBoolean>;
+    mode: z.ZodLiteral<"summary">;
+    allStatuses: z.ZodOptional<z.ZodBoolean>;
     limit: z.ZodOptional<z.ZodNumber>;
-    mode: z.ZodLiteral<"table">;
 }, z.core.$strict>;
 export declare const externalListDetailInputSchema: z.ZodObject<{
     operator: z.ZodEnum<{
@@ -109,10 +109,9 @@ export declare const externalListDetailInputSchema: z.ZodObject<{
         verify: "verify";
         interactive: "interactive";
     }>;
-    verbose: z.ZodOptional<z.ZodBoolean>;
-    limit: z.ZodOptional<z.ZodNumber>;
     mode: z.ZodLiteral<"detail">;
     sessionId: z.ZodString;
+    verbose: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
 export declare const externalListInspectionInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     operator: z.ZodEnum<{
@@ -123,9 +122,9 @@ export declare const externalListInspectionInputSchema: z.ZodDiscriminatedUnion<
         verify: "verify";
         interactive: "interactive";
     }>;
-    verbose: z.ZodOptional<z.ZodBoolean>;
+    mode: z.ZodLiteral<"summary">;
+    allStatuses: z.ZodOptional<z.ZodBoolean>;
     limit: z.ZodOptional<z.ZodNumber>;
-    mode: z.ZodLiteral<"table">;
 }, z.core.$strict>, z.ZodObject<{
     operator: z.ZodEnum<{
         message: "message";
@@ -135,10 +134,9 @@ export declare const externalListInspectionInputSchema: z.ZodDiscriminatedUnion<
         verify: "verify";
         interactive: "interactive";
     }>;
-    verbose: z.ZodOptional<z.ZodBoolean>;
-    limit: z.ZodOptional<z.ZodNumber>;
     mode: z.ZodLiteral<"detail">;
     sessionId: z.ZodString;
+    verbose: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>], "mode">;
 export declare const externalExecutionInputSchemas: {
     readonly spec: z.ZodObject<{
@@ -204,7 +202,7 @@ export declare const externalExecutionInputSchemas: {
 };
 export declare const externalInspectionInputSchemas: {
     readonly list: {
-        readonly table: z.ZodObject<{
+        readonly summary: z.ZodObject<{
             operator: z.ZodEnum<{
                 message: "message";
                 spec: "spec";
@@ -213,9 +211,9 @@ export declare const externalInspectionInputSchemas: {
                 verify: "verify";
                 interactive: "interactive";
             }>;
-            verbose: z.ZodOptional<z.ZodBoolean>;
+            mode: z.ZodLiteral<"summary">;
+            allStatuses: z.ZodOptional<z.ZodBoolean>;
             limit: z.ZodOptional<z.ZodNumber>;
-            mode: z.ZodLiteral<"table">;
         }, z.core.$strict>;
         readonly detail: z.ZodObject<{
             operator: z.ZodEnum<{
@@ -226,10 +224,9 @@ export declare const externalInspectionInputSchemas: {
                 verify: "verify";
                 interactive: "interactive";
             }>;
-            verbose: z.ZodOptional<z.ZodBoolean>;
-            limit: z.ZodOptional<z.ZodNumber>;
             mode: z.ZodLiteral<"detail">;
             sessionId: z.ZodString;
+            verbose: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict>;
         readonly union: z.ZodDiscriminatedUnion<[z.ZodObject<{
             operator: z.ZodEnum<{
@@ -240,9 +237,9 @@ export declare const externalInspectionInputSchemas: {
                 verify: "verify";
                 interactive: "interactive";
             }>;
-            verbose: z.ZodOptional<z.ZodBoolean>;
+            mode: z.ZodLiteral<"summary">;
+            allStatuses: z.ZodOptional<z.ZodBoolean>;
             limit: z.ZodOptional<z.ZodNumber>;
-            mode: z.ZodLiteral<"table">;
         }, z.core.$strict>, z.ZodObject<{
             operator: z.ZodEnum<{
                 message: "message";
@@ -252,10 +249,9 @@ export declare const externalInspectionInputSchemas: {
                 verify: "verify";
                 interactive: "interactive";
             }>;
-            verbose: z.ZodOptional<z.ZodBoolean>;
-            limit: z.ZodOptional<z.ZodNumber>;
             mode: z.ZodLiteral<"detail">;
             sessionId: z.ZodString;
+            verbose: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict>], "mode">;
     };
 };
@@ -279,7 +275,7 @@ export declare const externalAdapterContractReference: {
         readonly command: "list";
         readonly jsonOnly: true;
         readonly operators: readonly ["spec", "run", "reduce", "verify", "message", "interactive"];
-        readonly modes: readonly ["table", "detail"];
+        readonly modes: readonly ["summary", "detail"];
         readonly authoritativeType: "ListJsonOutput";
         readonly versioned: false;
     };

package/dist/cli/contract.js

@@ -90,19 +90,20 @@ export const externalApplyExecutionInputSchema = z
 const externalListInspectionBaseSchema = z
     .object({
     operator: externalInspectionOperatorSchema,
-    verbose: z.boolean().optional(),
-    limit: positiveIntegerSchema.optional(),
 })
     .strict();
-export const externalListTableInputSchema = externalListInspectionBaseSchema.extend({
-    mode: z.literal("table"),
+export const externalListSummaryInputSchema = externalListInspectionBaseSchema.extend({
+    mode: z.literal("summary"),
+    allStatuses: z.boolean().optional(),
+    limit: positiveIntegerSchema.optional(),
 });
 export const externalListDetailInputSchema = externalListInspectionBaseSchema.extend({
     mode: z.literal("detail"),
     sessionId: nonEmptyStringSchema,
+    verbose: z.boolean().optional(),
 });
 export const externalListInspectionInputSchema = z.discriminatedUnion("mode", [
-    externalListTableInputSchema,
+    externalListSummaryInputSchema,
     externalListDetailInputSchema,
 ]);
 export const externalExecutionInputSchemas = {
@@ -115,7 +116,7 @@ export const externalExecutionInputSchemas = {
 };
 export const externalInspectionInputSchemas = {
     list: {
-        table: externalListTableInputSchema,
+        summary: externalListSummaryInputSchema,
         detail: externalListDetailInputSchema,
         union: externalListInspectionInputSchema,
     },
@@ -234,6 +235,7 @@ const listCommandActionOptionsSchema = z
     message: z.union([z.literal(true), nonEmptyStringSchema]).optional(),
     interactive: z.union([z.literal(true), nonEmptyStringSchema]).optional(),
     limit: positiveIntegerSchema.optional(),
+    allStatuses: z.boolean().optional(),
     verbose: z.boolean().optional(),
     json: z.boolean().optional(),
 })
@@ -328,12 +330,34 @@ export function parseListInspectionCommandOptions(options, command) {
         { key: "message", flag: "--message", value: "message" },
         { key: "interactive", flag: "--interactive", value: "interactive" },
     ], parsed, command, "operator flag");
+    const mode = selected.argument ? "detail" : "summary";
+    const verbose = normalizeOptionalBoolean(parsed.verbose);
+    const allStatuses = normalizeOptionalBoolean(parsed.allStatuses);
+    const json = normalizeOptionalBoolean(parsed.json);
+    if (verbose && json) {
+        failCommand(command, "`--verbose` cannot be used with JSON output.");
+    }
+    if (mode === "summary" && verbose) {
+        failCommand(command, "`--verbose` requires detail scope.");
+    }
+    if (mode === "detail" && allStatuses) {
+        failCommand(command, "`--all-statuses` applies only to summary scope.");
+    }
+    if (mode === "detail" && parsed.limit !== undefined) {
+        failCommand(command, "`--limit` applies only to summary scope.");
+    }
     return parseCommandOptions(externalListInspectionInputSchema, {
         operator: selected.value,
-        mode: selected.argument ? "detail" : "table",
+        mode,
         ...(selected.argument ? { sessionId: selected.argument } : {}),
-        limit: parsed.limit,
-        verbose: normalizeOptionalBoolean(parsed.verbose),
+        ...(mode === "summary"
+            ? {
+                limit: parsed.limit,
+                allStatuses,
+            }
+            : {
+                verbose,
+            }),
     }, command);
 }
 function parseCommandOptions(schema, input, command) {

package/dist/cli/list.d.ts

@@ -5,6 +5,7 @@ export interface ListCommandOptions {
     operator: ListOperator;
     sessionId?: string;
     limit?: number;
+    allStatuses?: boolean;
     verbose?: boolean;
 }
 export interface ListCommandResult {

package/dist/cli/list.js

@@ -25,10 +25,11 @@ export async function runListCommand(options) {
         operator: options.operator,
         sessionId: options.sessionId,
         limit: options.limit,
+        allStatuses: options.allStatuses,
         verbose: options.verbose,
     });
     const body = execution.output ??
-        (execution.mode === "table"
+        (execution.mode === "summary"
             ? `No ${options.operator} sessions recorded.`
             : `${options.operator} session \`${options.sessionId}\` not found.`);
     const alerts = execution.warnings.map((warning) => ({
@@ -42,15 +43,16 @@ function parseLimitOption(value) {
 }
 export function createListCommand() {
     return new Command("list")
-        .description("List recorded sessions for an operator")
-        .option("--spec [session-id]", "List spec sessions or show one spec session")
-        .option("--run [session-id]", "List run sessions or show one run session")
-        .option("--reduce [session-id]", "List reduction sessions or show one reduction session")
-        .option("--verify [session-id]", "List verification sessions or show one verification session")
-        .option("--message [session-id]", "List message sessions or show one message session")
-        .option("--interactive [session-id]", "List interactive sessions or show one interactive session")
-        .option("--limit <count>", "Show only the N most recent sessions (default: 10)", parseLimitOption)
-        .option("--verbose", "Show all statuses for the selected operator in table mode")
+        .description("Inspect recorded sessions for an operator in summary or detail scope")
+        .option("--spec [session-id]", "Inspect spec sessions in summary scope or one spec session in detail scope")
+        .option("--run [session-id]", "Inspect run sessions in summary scope or one run session in detail scope")
+        .option("--reduce [session-id]", "Inspect reduction sessions in summary scope or one reduction session in detail scope")
+        .option("--verify [session-id]", "Inspect verification sessions in summary scope or one verification session in detail scope")
+        .option("--message [session-id]", "Inspect message sessions in summary scope or one message session in detail scope")
+        .option("--interactive [session-id]", "Inspect interactive sessions in summary scope or one interactive session in detail scope")
+        .option("--limit <count>", "Show only the N most recent summary sessions (default: 10)", parseLimitOption)
+        .option("--all-statuses", "Include sessions normally hidden by the default summary filter")
+        .option("--verbose", "Show expanded human detail output (requires detail scope)")
         .option("--json", "Emit machine-readable list output")
         .allowExcessArguments(false)
         .action(async (options, command) => {
@@ -58,8 +60,9 @@ export function createListCommand() {
         const result = await runListCommand({
             operator: selection.operator,
             sessionId: selection.mode === "detail" ? selection.sessionId : undefined,
-            limit: selection.limit,
-            verbose: selection.verbose ?? false,
+            limit: selection.mode === "summary" ? selection.limit : undefined,
+            allStatuses: selection.mode === "summary" ? selection.allStatuses : undefined,
+            verbose: selection.mode === "detail" ? (selection.verbose ?? false) : false,
         });
         if (options.json) {
             writeCommandOutput({

package/dist/commands/auto/command.d.ts

@@ -98,7 +98,7 @@ export type AutoCommandEvent = {
     separateWithDivider: boolean;
 };
 export interface AutoPhaseSummary {
-    status: "succeeded" | "failed" | "skipped";
+    status: "succeeded" | "failed" | "aborted" | "skipped";
     durationMs?: number;
     detail?: string;
 }

package/dist/commands/auto/command.js

@@ -19,6 +19,7 @@ export async function executeAutoCommand(options, dependencies) {
         dependencies.onEvent?.(event);
     };
     let hardFailure = false;
+    let hardAbort = false;
     let actionRequired = false;
     let actionRequiredDetail;
     let specStartedAt;
@@ -74,7 +75,7 @@ export async function executeAutoCommand(options, dependencies) {
             recordEvent({ kind: "error", error });
         }
     }
-    if (!hardFailure && !actionRequired && hasDescription) {
+    if (!hardFailure && !hardAbort && !actionRequired && hasDescription) {
         if (!specSessionId) {
             specStatus = "failed";
             specDetail = "Spec stage did not return a session id.";
@@ -138,12 +139,16 @@ export async function executeAutoCommand(options, dependencies) {
             }
         }
     }
-    if (!resolvedSpecPath && !hardFailure && !actionRequired && hasDescription) {
+    if (!resolvedSpecPath &&
+        !hardFailure &&
+        !hardAbort &&
+        !actionRequired &&
+        hasDescription) {
         specStatus = "failed";
         specDetail = "Spec verification did not select a spec path.";
         hardFailure = true;
     }
-    if (!hardFailure && !actionRequired && resolvedSpecPath) {
+    if (!hardFailure && !hardAbort && !actionRequired && resolvedSpecPath) {
         runStartedAt = now();
         try {
             const runResult = await dependencies.runRunStage({
@@ -168,20 +173,30 @@ export async function executeAutoCommand(options, dependencies) {
                     hintLines: ["Re-run the command."],
                 });
             }
-            runStatus = resolvedRunExitCode === 0 ? "succeeded" : "failed";
+            runStatus =
+                resolvedRunExitCode === 0
+                    ? "succeeded"
+                    : runResult.report.status === "aborted"
+                        ? "aborted"
+                        : "failed";
             runId = runResult.report.runId;
             runRecordStatus = runResult.report.status;
             runCreatedAt = runResult.report.createdAt;
             runSpecPath = runResult.report.spec?.path;
             runBaseRevisionSha = runResult.report.baseRevisionSha;
-            if (runStatus === "failed") {
+            if (runStatus !== "succeeded") {
                 const statusDetail = runRecordStatus
                     ? `status \`${runRecordStatus}\``
                     : "a non-success status";
                 runDetail =
                     runDetail ??
                         `Run completed with ${statusDetail} (exit code ${resolvedRunExitCode}).`;
-                hardFailure = true;
+                if (runStatus === "aborted") {
+                    hardAbort = true;
+                }
+                else {
+                    hardFailure = true;
+                }
             }
             recordEvent({
                 kind: "body",
@@ -197,7 +212,10 @@ export async function executeAutoCommand(options, dependencies) {
         }
     }
     const shouldAttemptVerifyRun = runId !== undefined &&
-        (!hardFailure || (!hasDescription && runStatus !== "skipped"));
+        runStatus === "succeeded" &&
+        !hardFailure &&
+        !hardAbort &&
+        !actionRequired;
     if (shouldAttemptVerifyRun && runId) {
         verifyStartedAt = now();
         try {
@@ -321,6 +339,7 @@ export async function executeAutoCommand(options, dependencies) {
     const applyDurationMs = applyStartedAt !== undefined ? now() - applyStartedAt : undefined;
     const autoStatus = resolveAutoTerminalStatus({
         hardFailure,
+        hardAbort,
         actionRequired,
     });
     const autoDetail = resolveAutoTerminalDetail({
@@ -391,6 +410,9 @@ function assertAutoOptionCompatibility(options) {
     validateAutoCommandOptions(options);
 }
 function resolveAutoTerminalStatus(options) {
+    if (options.hardAbort) {
+        return "aborted";
+    }
     if (options.hardFailure) {
         return "failed";
     }
@@ -400,7 +422,13 @@ function resolveAutoTerminalStatus(options) {
     return "succeeded";
 }
 function mapAutoTerminalStatusToExitCode(status) {
-    return status === "succeeded" ? 0 : 1;
+    if (status === "succeeded") {
+        return 0;
+    }
+    if (status === "aborted") {
+        return 3;
+    }
+    return 1;
 }
 function truncateOutcomeDetail(detail) {
     if (!detail) {
@@ -422,6 +450,9 @@ function resolveAutoTerminalDetail(options) {
             options.runDetail ??
             options.specDetail);
     }
+    if (options.status === "aborted") {
+        return truncateOutcomeDetail(options.runDetail ?? options.verifyDetail);
+    }
     return undefined;
 }
 function toHeadline(error) {

package/dist/commands/list/command.d.ts

@@ -10,6 +10,7 @@ export interface ListCommandInput {
     operator: ListOperator;
     sessionId?: string;
     limit?: number;
+    allStatuses?: boolean;
     verbose?: boolean;
 }
 export interface ListCommandResult {