voratiq 0.1.0-beta.21 → 0.1.0-beta.22

package/dist/contracts/list.d.ts

@@ -1,207 +1,187 @@
 import { z } from "zod";
-export declare const listOperators: readonly ["spec", "run", "reduce", "verify", "message"];
+export declare const listOperators: readonly ["spec", "run", "reduce", "verify", "message", "interactive"];
 export declare const listModes: readonly ["table", "detail"];
+export declare const listJsonModes: readonly ["list", "detail"];
 export type ListOperator = (typeof listOperators)[number];
 export type ListMode = (typeof listModes)[number];
-interface ListJsonRecordBase {
-    id: string;
+export type ListJsonMode = (typeof listJsonModes)[number];
+export type SessionListJsonTargetRef = {
+    kind: ListOperator;
+    sessionId: string;
+    agentId?: string;
+};
+export type FileListJsonTargetRef = {
+    kind: "file";
+    path: string;
+};
+export type ListJsonTargetRef = SessionListJsonTargetRef | FileListJsonTargetRef;
+export interface ListJsonSessionBase {
+    operator: ListOperator;
+    sessionId: string;
     status: string;
     createdAt: string;
+    target?: ListJsonTargetRef;
 }
-interface ListJsonTargetRef {
-    kind: string;
-    id: string;
-}
-export interface RunListJsonTableRecord extends ListJsonRecordBase {
-    specPath: string;
-}
-export interface SpecListJsonTableRecord extends ListJsonRecordBase {
-    description: string | null;
-}
-export interface TargetedListJsonTableRecord extends ListJsonRecordBase {
-    target: ListJsonTargetRef;
+export interface ListJsonSummarySession extends ListJsonSessionBase {
+    description?: string | null;
 }
-export interface MessageListJsonTableRecord extends ListJsonRecordBase {
-    promptPreview: string | null;
+export interface ListJsonChanges {
+    filesChanged?: number;
+    insertions?: number;
+    deletions?: number;
 }
-export type ListJsonTableRecord = RunListJsonTableRecord | SpecListJsonTableRecord | TargetedListJsonTableRecord | MessageListJsonTableRecord;
-export interface RunListJsonRow {
-    agentId: string;
-    status: string;
-    duration: string;
-    changes: string | null;
-}
-export interface SpecListJsonRow {
-    agentId: string;
-    status: string;
-    duration: string;
-}
-export interface ReduceListJsonRow {
-    agentId: string;
-    status: string;
-    duration: string;
+export interface ListJsonArtifact {
+    kind: string;
+    role: "output" | "data";
+    path: string;
 }
-export interface VerifyListJsonRow {
+export interface ListJsonAgent {
     agentId: string | null;
-    verifier: string;
     status: string;
-    duration: string;
-}
-export interface MessageListJsonRow {
-    agentId: string;
-    status: string;
-    duration: string;
-}
-export type ListJsonRow = RunListJsonRow | SpecListJsonRow | ReduceListJsonRow | VerifyListJsonRow | MessageListJsonRow;
-export interface SpecListJsonArtifact {
-    kind: "spec";
-    agentId: string;
-    path: string | null;
-}
-export interface ReductionListJsonArtifact {
-    kind: "reduction";
-    agentId: string;
-    path: string | null;
-}
-export interface VerificationListJsonArtifact {
-    kind: "result";
-    agentId: string | null;
-    verifier: string;
-    path: string | null;
-}
-export interface MessageListJsonArtifact {
-    kind: "output";
-    agentId: string;
-    path: string | null;
-}
-export type ListJsonArtifact = SpecListJsonArtifact | ReductionListJsonArtifact | VerificationListJsonArtifact | MessageListJsonArtifact;
-export interface ListJsonTableOutput {
+    startedAt?: string;
+    completedAt?: string;
+    verifier?: string;
+    changes?: ListJsonChanges;
+    artifacts: ListJsonArtifact[];
+}
+export interface ListJsonDetailSession extends ListJsonSessionBase {
+    startedAt?: string;
+    completedAt?: string;
+    workspacePath: string;
+    description?: string | null;
+    agents: ListJsonAgent[];
+}
+export interface ListJsonListOutput {
     operator: ListOperator;
-    mode: "table";
-    records: ListJsonTableRecord[];
+    mode: "list";
+    sessions: ListJsonSummarySession[];
     warnings: string[];
 }
 export interface ListJsonDetailOutput {
     operator: ListOperator;
     mode: "detail";
-    sessionId: string;
-    session: {
-        id: string;
-        status: string;
-        createdAt: string;
-        elapsed?: string;
-        workspacePath: string;
-        target?: ListJsonTargetRef;
-        rows: ListJsonRow[];
-        artifacts: ListJsonArtifact[];
-    } | null;
+    session: ListJsonDetailSession | null;
     warnings: string[];
 }
-export type ListJsonOutput = ListJsonTableOutput | ListJsonDetailOutput;
+export type ListJsonOutput = ListJsonListOutput | ListJsonDetailOutput;
 export declare const listOperatorSchema: z.ZodEnum<{
     message: "message";
-    reduce: "reduce";
     spec: "spec";
+    reduce: "reduce";
     run: "run";
     verify: "verify";
+    interactive: "interactive";
 }>;
 export declare const listModeSchema: z.ZodEnum<{
     detail: "detail";
     table: "table";
 }>;
+export declare const listJsonModeSchema: z.ZodEnum<{
+    detail: "detail";
+    list: "list";
+}>;
 export declare const listJsonOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     operator: z.ZodEnum<{
         message: "message";
-        reduce: "reduce";
         spec: "spec";
+        reduce: "reduce";
         run: "run";
         verify: "verify";
+        interactive: "interactive";
     }>;
-    mode: z.ZodLiteral<"table">;
-    records: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        id: z.ZodString;
-        status: z.ZodString;
-        createdAt: z.ZodString;
-        specPath: z.ZodString;
-    }, z.core.$loose>, z.ZodObject<{
-        id: z.ZodString;
+    mode: z.ZodLiteral<"list">;
+    sessions: z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            message: "message";
+            spec: "spec";
+            reduce: "reduce";
+            run: "run";
+            verify: "verify";
+            interactive: "interactive";
+        }>;
+        sessionId: z.ZodString;
         status: z.ZodString;
         createdAt: z.ZodString;
-        description: z.ZodNullable<z.ZodString>;
-    }, z.core.$loose>, z.ZodObject<{
-        id: z.ZodString;
-        status: z.ZodString;
-        createdAt: z.ZodString;
-        target: z.ZodObject<{
-            kind: z.ZodString;
-            id: z.ZodString;
-        }, z.core.$loose>;
-    }, z.core.$loose>, z.ZodObject<{
-        id: z.ZodString;
-        status: z.ZodString;
-        createdAt: z.ZodString;
-        promptPreview: z.ZodNullable<z.ZodString>;
-    }, z.core.$loose>]>>;
+        target: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodEnum<{
+                message: "message";
+                spec: "spec";
+                reduce: "reduce";
+                run: "run";
+                verify: "verify";
+                interactive: "interactive";
+            }>;
+            sessionId: z.ZodString;
+            agentId: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>, z.ZodObject<{
+            kind: z.ZodLiteral<"file">;
+            path: z.ZodString;
+        }, z.core.$loose>], "kind">>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>>;
     warnings: z.ZodArray<z.ZodString>;
 }, z.core.$loose>, z.ZodObject<{
     operator: z.ZodEnum<{
         message: "message";
-        reduce: "reduce";
         spec: "spec";
+        reduce: "reduce";
         run: "run";
         verify: "verify";
+        interactive: "interactive";
     }>;
     mode: z.ZodLiteral<"detail">;
-    sessionId: z.ZodString;
     session: z.ZodNullable<z.ZodObject<{
-        id: z.ZodString;
+        operator: z.ZodEnum<{
+            message: "message";
+            spec: "spec";
+            reduce: "reduce";
+            run: "run";
+            verify: "verify";
+            interactive: "interactive";
+        }>;
+        sessionId: z.ZodString;
         status: z.ZodString;
         createdAt: z.ZodString;
-        elapsed: z.ZodOptional<z.ZodString>;
-        workspacePath: z.ZodString;
-        target: z.ZodOptional<z.ZodObject<{
-            kind: z.ZodString;
-            id: z.ZodString;
-        }, z.core.$loose>>;
-        rows: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-            agentId: z.ZodString;
-            status: z.ZodString;
-            duration: z.ZodString;
-            changes: z.ZodNullable<z.ZodString>;
-        }, z.core.$loose>, z.ZodObject<{
-            agentId: z.ZodString;
-            status: z.ZodString;
-            duration: z.ZodString;
+        target: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodEnum<{
+                message: "message";
+                spec: "spec";
+                reduce: "reduce";
+                run: "run";
+                verify: "verify";
+                interactive: "interactive";
+            }>;
+            sessionId: z.ZodString;
+            agentId: z.ZodOptional<z.ZodString>;
         }, z.core.$loose>, z.ZodObject<{
+            kind: z.ZodLiteral<"file">;
+            path: z.ZodString;
+        }, z.core.$loose>], "kind">>;
+        startedAt: z.ZodOptional<z.ZodString>;
+        completedAt: z.ZodOptional<z.ZodString>;
+        workspacePath: z.ZodString;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        agents: z.ZodArray<z.ZodObject<{
             agentId: z.ZodNullable<z.ZodString>;
-            verifier: z.ZodString;
-            status: z.ZodString;
-            duration: z.ZodString;
-        }, z.core.$loose>, z.ZodObject<{
-            agentId: z.ZodString;
             status: z.ZodString;
-            duration: z.ZodString;
-        }, z.core.$loose>]>>;
-        artifacts: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-            kind: z.ZodLiteral<"spec">;
-            agentId: z.ZodString;
-            path: z.ZodNullable<z.ZodString>;
-        }, z.core.$loose>, z.ZodObject<{
-            kind: z.ZodLiteral<"reduction">;
-            agentId: z.ZodString;
-            path: z.ZodNullable<z.ZodString>;
-        }, z.core.$loose>, z.ZodObject<{
-            kind: z.ZodLiteral<"result">;
-            agentId: z.ZodNullable<z.ZodString>;
-            verifier: z.ZodString;
-            path: z.ZodNullable<z.ZodString>;
-        }, z.core.$loose>, z.ZodObject<{
-            kind: z.ZodLiteral<"output">;
-            agentId: z.ZodString;
-            path: z.ZodNullable<z.ZodString>;
-        }, z.core.$loose>]>>;
+            startedAt: z.ZodOptional<z.ZodString>;
+            completedAt: z.ZodOptional<z.ZodString>;
+            verifier: z.ZodOptional<z.ZodString>;
+            changes: z.ZodOptional<z.ZodObject<{
+                filesChanged: z.ZodOptional<z.ZodNumber>;
+                insertions: z.ZodOptional<z.ZodNumber>;
+                deletions: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$loose>>;
+            artifacts: z.ZodArray<z.ZodObject<{
+                kind: z.ZodString;
+                role: z.ZodEnum<{
+                    output: "output";
+                    data: "data";
+                }>;
+                path: z.ZodString;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
     }, z.core.$loose>>;
     warnings: z.ZodArray<z.ZodString>;
 }, z.core.$loose>], "mode">;
 export declare function parseListJsonOutput(input: unknown): ListJsonOutput;
-export {};

package/dist/contracts/list.js

@@ -5,134 +5,83 @@ export const listOperators = [
     "reduce",
     "verify",
     "message",
+    "interactive",
 ];
 export const listModes = ["table", "detail"];
+export const listJsonModes = ["list", "detail"];
 export const listOperatorSchema = z.enum(listOperators);
 export const listModeSchema = z.enum(listModes);
-const listJsonTargetRefSchema = z
+export const listJsonModeSchema = z.enum(listJsonModes);
+const listJsonSessionTargetRefSchema = z
     .object({
-    kind: z.string(),
-    id: z.string(),
-})
-    .passthrough();
-const listJsonRecordBaseSchema = z
-    .object({
-    id: z.string(),
-    status: z.string(),
-    createdAt: z.string(),
-})
-    .passthrough();
-const runListJsonTableRecordSchema = listJsonRecordBaseSchema
-    .extend({
-    specPath: z.string(),
-})
-    .passthrough();
-const specListJsonTableRecordSchema = listJsonRecordBaseSchema
-    .extend({
-    description: z.string().nullable(),
-})
-    .passthrough();
-const targetedListJsonTableRecordSchema = listJsonRecordBaseSchema
-    .extend({
-    target: listJsonTargetRefSchema,
-})
-    .passthrough();
-const messageListJsonTableRecordSchema = listJsonRecordBaseSchema
-    .extend({
-    promptPreview: z.string().nullable(),
-})
-    .passthrough();
-const runListJsonRowSchema = z
-    .object({
-    agentId: z.string(),
-    status: z.string(),
-    duration: z.string(),
-    changes: z.string().nullable(),
+    kind: listOperatorSchema,
+    sessionId: z.string(),
+    agentId: z.string().optional(),
 })
     .passthrough();
-const stageListJsonRowSchema = z
+const listJsonFileTargetRefSchema = z
     .object({
-    agentId: z.string(),
-    status: z.string(),
-    duration: z.string(),
+    kind: z.literal("file"),
+    path: z.string(),
 })
     .passthrough();
-const verifyListJsonRowSchema = z
+const listJsonTargetRefSchema = z.discriminatedUnion("kind", [
+    listJsonSessionTargetRefSchema,
+    listJsonFileTargetRefSchema,
+]);
+const listJsonSessionBaseSchema = z
     .object({
-    agentId: z.string().nullable(),
-    verifier: z.string(),
+    operator: listOperatorSchema,
+    sessionId: z.string(),
     status: z.string(),
-    duration: z.string(),
+    createdAt: z.string(),
+    target: listJsonTargetRefSchema.optional(),
 })
     .passthrough();
-const messageListJsonRowSchema = z
-    .object({
-    agentId: z.string(),
-    status: z.string(),
-    duration: z.string(),
+const listJsonSummarySessionSchema = listJsonSessionBaseSchema
+    .extend({
+    description: z.string().nullable().optional(),
 })
     .passthrough();
-const specListJsonArtifactSchema = z
+const listJsonChangesSchema = z
     .object({
-    kind: z.literal("spec"),
-    agentId: z.string(),
-    path: z.string().nullable(),
+    filesChanged: z.number().int().nonnegative().optional(),
+    insertions: z.number().int().nonnegative().optional(),
+    deletions: z.number().int().nonnegative().optional(),
 })
     .passthrough();
-const reductionListJsonArtifactSchema = z
+const listJsonArtifactSchema = z
     .object({
-    kind: z.literal("reduction"),
-    agentId: z.string(),
-    path: z.string().nullable(),
+    kind: z.string(),
+    role: z.enum(["output", "data"]),
+    path: z.string(),
 })
     .passthrough();
-const verificationListJsonArtifactSchema = z
+const listJsonAgentSchema = z
     .object({
-    kind: z.literal("result"),
     agentId: z.string().nullable(),
-    verifier: z.string(),
-    path: z.string().nullable(),
-})
-    .passthrough();
-const messageListJsonArtifactSchema = z
-    .object({
-    kind: z.literal("output"),
-    agentId: z.string(),
-    path: z.string().nullable(),
+    status: z.string(),
+    startedAt: z.string().optional(),
+    completedAt: z.string().optional(),
+    verifier: z.string().optional(),
+    changes: listJsonChangesSchema.optional(),
+    artifacts: z.array(listJsonArtifactSchema),
 })
     .passthrough();
-const listJsonDetailSessionSchema = z
-    .object({
-    id: z.string(),
-    status: z.string(),
-    createdAt: z.string(),
-    elapsed: z.string().optional(),
+const listJsonDetailSessionSchema = listJsonSessionBaseSchema
+    .extend({
+    startedAt: z.string().optional(),
+    completedAt: z.string().optional(),
     workspacePath: z.string(),
-    target: listJsonTargetRefSchema.optional(),
-    rows: z.array(z.union([
-        runListJsonRowSchema,
-        stageListJsonRowSchema,
-        verifyListJsonRowSchema,
-        messageListJsonRowSchema,
-    ])),
-    artifacts: z.array(z.union([
-        specListJsonArtifactSchema,
-        reductionListJsonArtifactSchema,
-        verificationListJsonArtifactSchema,
-        messageListJsonArtifactSchema,
-    ])),
+    description: z.string().nullable().optional(),
+    agents: z.array(listJsonAgentSchema),
 })
     .passthrough();
-const listJsonTableOutputSchema = z
+const listJsonListOutputSchema = z
     .object({
     operator: listOperatorSchema,
-    mode: z.literal("table"),
-    records: z.array(z.union([
-        runListJsonTableRecordSchema,
-        specListJsonTableRecordSchema,
-        targetedListJsonTableRecordSchema,
-        messageListJsonTableRecordSchema,
-    ])),
+    mode: z.literal("list"),
+    sessions: z.array(listJsonSummarySessionSchema),
     warnings: z.array(z.string()),
 })
     .passthrough();
@@ -140,13 +89,12 @@ const listJsonDetailOutputSchema = z
     .object({
     operator: listOperatorSchema,
     mode: z.literal("detail"),
-    sessionId: z.string(),
     session: listJsonDetailSessionSchema.nullable(),
     warnings: z.array(z.string()),
 })
     .passthrough();
 export const listJsonOutputSchema = z.discriminatedUnion("mode", [
-    listJsonTableOutputSchema,
+    listJsonListOutputSchema,
     listJsonDetailOutputSchema,
 ]);
 export function parseListJsonOutput(input) {

package/dist/domain/interactive/persistence/adapter.d.ts

@@ -6,7 +6,30 @@ export interface InteractiveSessionPaths {
     artifactsPath: string;
     runtimePath: string;
 }
+export type InteractiveRecordPredicate = (record: InteractiveSessionRecord) => boolean;
+export interface InteractiveRecordWarningMissing {
+    kind: "missing-record";
+    sessionId: string;
+    recordPath: string;
+    displayPath: string;
+}
+export interface InteractiveRecordWarningParse {
+    kind: "parse-error";
+    sessionId: string;
+    recordPath: string;
+    displayPath: string;
+    details: string;
+}
+export type InteractiveRecordWarning = InteractiveRecordWarningMissing | InteractiveRecordWarningParse;
+export interface ReadInteractiveRecordsOptions {
+    root: string;
+    interactiveFilePath: string;
+    limit?: number;
+    predicate?: InteractiveRecordPredicate;
+    onWarning?: (warning: InteractiveRecordWarning) => void;
+}
 export declare function resolveInteractiveSessionPaths(root: string, sessionId: string): InteractiveSessionPaths;
+export declare function readInteractiveRecords(options: ReadInteractiveRecordsOptions): Promise<InteractiveSessionRecord[]>;
 export declare function ensureInteractiveSessionDirectories(options: {
     sessionRoot: string;
     artifactsPath: string;

package/dist/domain/interactive/persistence/adapter.js

@@ -36,6 +36,23 @@ export function resolveInteractiveSessionPaths(root, sessionId) {
         runtimePath: resolvePath(root, getInteractiveSessionDirectoryPath(sessionId), "runtime"),
     };
 }
+export async function readInteractiveRecords(options) {
+    const { root, interactiveFilePath, limit, predicate, onWarning } = options;
+    const paths = buildInteractivePaths(root, interactiveFilePath);
+    try {
+        return await interactivePersistence.readRecords({
+            paths,
+            limit,
+            predicate,
+            onWarning: onWarning
+                ? (warning) => onWarning(mapWarning(warning))
+                : undefined,
+        });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
 export async function ensureInteractiveSessionDirectories(options) {
     const { sessionRoot, artifactsPath, runtimePath } = options;
     await Promise.all([
@@ -128,6 +145,31 @@ function buildInteractiveSessionStorePaths(root) {
         lockPath: resolvePath(root, getInteractiveHistoryLockPath()),
     };
 }
+function buildInteractivePaths(root, interactiveFilePath) {
+    return {
+        root,
+        indexPath: interactiveFilePath,
+        sessionsDir: resolvePath(root, getInteractiveSessionsDirectoryPath()),
+        lockPath: resolvePath(root, getInteractiveHistoryLockPath()),
+    };
+}
+function mapWarning(warning) {
+    if (warning.kind === "parse-error") {
+        return {
+            kind: "parse-error",
+            sessionId: warning.sessionId,
+            recordPath: warning.recordPath,
+            displayPath: warning.displayPath,
+            details: warning.details,
+        };
+    }
+    return {
+        kind: "missing-record",
+        sessionId: warning.sessionId,
+        recordPath: warning.recordPath,
+        displayPath: warning.displayPath,
+    };
+}
 function parseInteractiveRecord(path, raw) {
     let parsed;
     try {

package/dist/domain/message/model/types.d.ts

@@ -2,6 +2,27 @@ import { z } from "zod";
 import { type MessageRecipientStatus, messageRecipientStatusSchema, type MessageStatus, messageStatusSchema, TERMINAL_MESSAGE_RECIPIENT_STATUSES, TERMINAL_MESSAGE_STATUSES } from "../../../status/index.js";
 export type { MessageRecipientStatus, MessageStatus };
 export { messageRecipientStatusSchema, messageStatusSchema, TERMINAL_MESSAGE_RECIPIENT_STATUSES, TERMINAL_MESSAGE_STATUSES, };
+declare const MESSAGE_TARGET_KIND_VALUES: readonly ["interactive", "run", "spec", "reduce", "verify"];
+export type MessageTargetKind = (typeof MESSAGE_TARGET_KIND_VALUES)[number];
+export declare const messageTargetKindSchema: z.ZodEnum<{
+    spec: "spec";
+    reduce: "reduce";
+    run: "run";
+    verify: "verify";
+    interactive: "interactive";
+}>;
+export declare const messageTargetSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        spec: "spec";
+        reduce: "reduce";
+        run: "run";
+        verify: "verify";
+        interactive: "interactive";
+    }>;
+    sessionId: z.ZodString;
+    agentId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type MessageTarget = z.infer<typeof messageTargetSchema>;
 export declare const messageRecipientEntrySchema: z.ZodObject<{
     agentId: z.ZodString;
     status: z.ZodEnum<{
@@ -52,6 +73,17 @@ export declare const messageRecordSchema: z.ZodObject<{
     }>;
     baseRevisionSha: z.ZodOptional<z.ZodString>;
     prompt: z.ZodString;
+    target: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            spec: "spec";
+            reduce: "reduce";
+            run: "run";
+            verify: "verify";
+            interactive: "interactive";
+        }>;
+        sessionId: z.ZodString;
+        agentId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
     sourceInteractiveSessionId: z.ZodOptional<z.ZodString>;
     extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
     extraContextMetadata: z.ZodOptional<z.ZodArray<z.ZodObject<{