voratiq 0.1.0-beta.21 → 0.1.0-beta.23

package/dist/commands/list/command.js

@@ -1,20 +1,21 @@
+import { readInteractiveRecords, } from "../../domain/interactive/persistence/adapter.js";
 import { readMessageRecords, } from "../../domain/message/persistence/adapter.js";
 import { readReductionRecords, } from "../../domain/reduce/persistence/adapter.js";
 import { readRunRecords, } from "../../domain/run/persistence/adapter.js";
 import { readSpecRecords, } from "../../domain/spec/persistence/adapter.js";
 import { TERMINAL_VERIFICATION_STATUSES } from "../../domain/verify/model/types.js";
 import { readVerificationRecords, } from "../../domain/verify/persistence/adapter.js";
-import { renderListTableTranscript, renderMessageList, renderReduceList, renderRunList, renderSpecList, renderVerifyList, } from "../../render/transcripts/list.js";
+import { renderInteractiveTranscript } from "../../render/transcripts/interactive.js";
+import { renderInteractiveListTable, renderListTableTranscript, renderMessageListTable, renderReduceListTable, renderRunListTable, renderSpecListTable, renderVerifyListTable, } from "../../render/transcripts/list.js";
 import { formatMessageElapsed, formatMessageRecipientDuration, renderMessageTranscript, } from "../../render/transcripts/message.js";
 import { formatReduceElapsed, formatReducerDuration, renderReduceTranscript, } from "../../render/transcripts/reduce.js";
-import { formatRunElapsed, renderRunTranscript, } from "../../render/transcripts/run.js";
+import { renderRunTranscript } from "../../render/transcripts/run.js";
 import { formatSpecAgentDuration, formatSpecElapsed, renderSpecTranscript, } from "../../render/transcripts/spec.js";
 import { formatVerifyElapsed, renderVerifyTranscript, } from "../../render/transcripts/verify.js";
-import { formatAgentDuration } from "../../render/utils/agents.js";
-import { formatRenderLifecycleDuration } from "../../render/utils/duration.js";
-import { formatCompactDiffStatistics } from "../../utils/diff.js";
+import { formatRenderLifecycleDuration, formatRenderLifecycleRowDuration, } from "../../render/utils/duration.js";
 import { pathExists } from "../../utils/fs.js";
-import { getMessageSessionDirectoryPath, getReductionSessionDirectoryPath, getRunDirectoryPath, getSpecSessionDirectoryPath, getVerificationSessionDirectoryPath, } from "../../workspace/structure.js";
+import { formatTargetDisplay, formatTargetTablePreview, normalizeListDetailSession, normalizeListSession, toListJsonTargetRef, } from "./normalization.js";
+import { getListRecordId } from "./records.js";
 const DEFAULT_LIMIT = 10;
 const DASH = "—";
 export async function executeListCommand(input) {
@@ -30,21 +31,22 @@ export async function executeListCommand(input) {
 }
 async function executeTableMode(input) {
     const { operator, limit, verbose = false } = input;
-    const query = await readOperatorRecords({ ...input, limit: undefined });
-    const filtered = verbose
-        ? query.records
-        : query.records.filter((record) => shouldIncludeInDefaultTable(operator, getRecordStatus(record)));
-    const records = filtered.slice(0, limit);
+    const predicate = verbose
+        ? undefined
+        : (record) => shouldIncludeInDefaultTable(operator, getRecordStatus(record));
+    const query = await readOperatorRecords({ ...input, limit, predicate });
+    const records = query.records;
+    const sessions = records.map((record) => normalizeListSession(operator, record));
     const warnings = query.warnings;
-    const output = renderTableOutput(operator, records);
+    const output = renderTableOutput(operator, records, sessions);
     return {
         warnings,
         output,
         mode: "table",
         json: {
             operator,
-            mode: "table",
-            records: records.map((record) => toJsonTableRecord(operator, record)),
+            mode: "list",
+            sessions: sessions.map(toJsonSummarySession),
             warnings,
         },
     };
@@ -70,74 +72,117 @@ async function executeDetailMode(input) {
             json: {
                 operator,
                 mode: "detail",
-                sessionId,
                 session: null,
                 warnings,
             },
         };
     }
+    const detailSession = normalizeListDetailSession(operator, record);
     return {
         warnings,
-        output: renderDetailOutput(operator, record),
+        output: renderDetailOutput(operator, detailSession),
         mode: "detail",
         json: {
             operator,
             mode: "detail",
-            sessionId,
-            session: toJsonDetailSession(operator, record),
+            session: toJsonDetailSession(detailSession),
             warnings,
         },
     };
 }
-function renderTableOutput(operator, records) {
+function renderTableOutput(operator, records, sessions) {
     if (records.length === 0) {
         return undefined;
     }
     const table = operator === "run"
-        ? renderRunList(records)
+        ? renderRunListTable(sessions.map((session) => ({
+            id: session.sessionId,
+            target: session.target
+                ? formatTargetTablePreview(session.target)
+                : DASH,
+            status: session.status,
+            createdAt: session.createdAt,
+        })))
         : operator === "spec"
-            ? renderSpecList(records)
+            ? renderSpecListTable(sessions.map((session) => {
+                return {
+                    id: session.sessionId,
+                    description: session.description ?? null,
+                    status: session.status,
+                    createdAt: session.createdAt,
+                };
+            }))
             : operator === "message"
-                ? renderMessageList(records)
-                : operator === "reduce"
-                    ? renderReduceList(records)
-                    : renderVerifyList(records);
+                ? renderMessageListTable(sessions.map((session) => ({
+                    id: session.sessionId,
+                    target: session.target
+                        ? formatTargetTablePreview(session.target)
+                        : DASH,
+                    status: session.status,
+                    createdAt: session.createdAt,
+                })))
+                : operator === "interactive"
+                    ? renderInteractiveListTable(sessions.map((session) => ({
+                        id: session.sessionId,
+                        status: session.status,
+                        createdAt: session.createdAt,
+                    })))
+                    : operator === "reduce"
+                        ? renderReduceListTable(sessions.map((session) => ({
+                            id: session.sessionId,
+                            target: session.target
+                                ? formatTargetTablePreview(session.target)
+                                : DASH,
+                            status: session.status,
+                            createdAt: session.createdAt,
+                        })))
+                        : renderVerifyListTable(sessions.map((session) => ({
+                            id: session.sessionId,
+                            target: session.target
+                                ? formatTargetTablePreview(session.target)
+                                : DASH,
+                            status: session.status,
+                            createdAt: session.createdAt,
+                        })));
     return renderListTableTranscript(table);
 }
-function renderDetailOutput(operator, record) {
+function renderDetailOutput(operator, session) {
     if (operator === "run") {
-        const runRecord = record;
         return renderRunTranscript({
-            runId: runRecord.runId,
-            status: runRecord.status,
-            workspacePath: getRunDirectoryPath(runRecord.runId),
-            createdAt: runRecord.createdAt,
-            startedAt: runRecord.startedAt,
-            completedAt: runRecord.completedAt,
-            agents: runRecord.agents.map((agent) => ({
-                agentId: agent.agentId,
+            runId: session.sessionId,
+            status: session.status,
+            workspacePath: session.workspacePath,
+            createdAt: session.createdAt,
+            startedAt: session.startedAt,
+            completedAt: session.completedAt,
+            targetDisplay: session.target
+                ? formatTargetDisplay(session.target)
+                : undefined,
+            agents: session.agents.map((agent) => ({
+                agentId: agent.agentId ?? DASH,
                 status: agent.status,
                 startedAt: agent.startedAt,
                 completedAt: agent.completedAt,
                 diffStatistics: agent.diffStatistics,
+                outputPath: agent.outputPath,
+                errorLine: agent.errorLine,
             })),
             isTty: process.stdout.isTTY,
         });
     }
     if (operator === "spec") {
-        const specRecord = record;
         return renderSpecTranscript({
-            sessionId: specRecord.sessionId,
-            createdAt: specRecord.createdAt,
+            sessionId: session.sessionId,
+            createdAt: session.createdAt,
             elapsed: formatSpecElapsed({
-                status: specRecord.status,
-                startedAt: specRecord.startedAt,
-                completedAt: specRecord.completedAt,
+                status: session.status,
+                startedAt: session.startedAt,
+                completedAt: session.completedAt,
             }) ?? DASH,
-            workspacePath: getSpecSessionDirectoryPath(specRecord.sessionId),
-            status: specRecord.status,
-            agents: specRecord.agents.map((agent) => ({
-                agentId: agent.agentId,
+            workspacePath: session.workspacePath,
+            status: session.status,
+            agents: session.agents.map((agent) => ({
+                agentId: agent.agentId ?? DASH,
                 status: agent.status,
                 duration: formatSpecAgentDuration({
                     status: agent.status,
@@ -146,346 +191,155 @@ function renderDetailOutput(operator, record) {
                 }),
                 outputPath: agent.outputPath,
                 dataPath: agent.dataPath,
-                errorLine: agent.error ?? undefined,
+                errorLine: agent.errorLine,
             })),
             isTty: process.stdout.isTTY,
         }, { suppressHint: true });
     }
     if (operator === "reduce") {
-        const reductionRecord = record;
         return renderReduceTranscript({
-            reductionId: reductionRecord.sessionId,
-            createdAt: reductionRecord.createdAt,
+            reductionId: session.sessionId,
+            createdAt: session.createdAt,
             elapsed: formatReduceElapsed({
-                status: reductionRecord.status,
-                startedAt: reductionRecord.startedAt,
-                completedAt: reductionRecord.completedAt,
+                status: session.status,
+                startedAt: session.startedAt,
+                completedAt: session.completedAt,
             }) ?? DASH,
-            workspacePath: getReductionSessionDirectoryPath(reductionRecord.sessionId),
-            status: reductionRecord.status,
-            reducers: reductionRecord.reducers.map((reducer) => ({
-                reducerAgentId: reducer.agentId,
-                status: reducer.status,
+            workspacePath: session.workspacePath,
+            status: session.status,
+            targetDisplay: session.target
+                ? formatTargetDisplay(session.target)
+                : undefined,
+            reducers: session.agents.map((agent) => ({
+                reducerAgentId: agent.agentId ?? DASH,
+                status: agent.status,
                 duration: formatReducerDuration({
-                    status: reducer.status,
-                    startedAt: reducer.startedAt,
-                    completedAt: reducer.completedAt,
+                    status: agent.status,
+                    startedAt: agent.startedAt,
+                    completedAt: agent.completedAt,
                 }),
-                outputPath: reducer.outputPath,
-                dataPath: reducer.dataPath,
-                errorLine: reducer.error ?? undefined,
+                outputPath: agent.outputPath,
+                dataPath: agent.dataPath,
+                errorLine: agent.errorLine,
             })),
             suppressHint: true,
             isTty: process.stdout.isTTY,
         });
     }
     if (operator === "message") {
-        const messageRecord = record;
         return renderMessageTranscript({
-            messageId: messageRecord.sessionId,
-            createdAt: messageRecord.createdAt,
+            messageId: session.sessionId,
+            createdAt: session.createdAt,
             elapsed: formatMessageElapsed({
-                status: messageRecord.status,
-                startedAt: messageRecord.startedAt,
-                completedAt: messageRecord.completedAt,
+                status: session.status,
+                startedAt: session.startedAt,
+                completedAt: session.completedAt,
             }) ?? DASH,
-            workspacePath: getMessageSessionDirectoryPath(messageRecord.sessionId),
-            status: messageRecord.status,
-            recipients: messageRecord.recipients.map((recipient) => ({
-                agentId: recipient.agentId,
-                status: recipient.status,
+            workspacePath: session.workspacePath,
+            status: session.status,
+            targetDisplay: session.target
+                ? formatTargetDisplay(session.target)
+                : undefined,
+            recipients: session.agents.map((agent) => ({
+                agentId: agent.agentId ?? DASH,
+                status: agent.status,
                 duration: formatMessageRecipientDuration({
-                    status: recipient.status,
-                    startedAt: recipient.startedAt,
-                    completedAt: recipient.completedAt,
-                }) ?? DASH,
-                outputPath: recipient.outputPath,
-                errorLine: recipient.error ?? undefined,
+                    status: agent.status,
+                    startedAt: agent.startedAt,
+                    completedAt: agent.completedAt,
+                }),
+                outputPath: agent.outputPath,
+                errorLine: agent.errorLine,
             })),
             isTty: process.stdout.isTTY,
         });
     }
-    const verificationRecord = record;
+    if (operator === "interactive") {
+        const interactiveAgent = session.agents[0];
+        return renderInteractiveTranscript({
+            sessionId: session.sessionId,
+            createdAt: session.createdAt,
+            elapsed: formatInteractiveElapsed({
+                status: session.status,
+                startedAt: session.startedAt,
+                completedAt: session.completedAt,
+            }) ?? DASH,
+            workspacePath: session.workspacePath,
+            status: session.status,
+            agents: [
+                {
+                    agentId: interactiveAgent?.agentId ?? DASH,
+                    status: interactiveAgent?.status ??
+                        "failed",
+                    duration: formatInteractiveAgentDuration(interactiveAgent),
+                    outputPath: interactiveAgent?.outputPath,
+                },
+            ],
+            isTty: process.stdout.isTTY,
+        });
+    }
     return renderVerifyTranscript({
-        verificationId: verificationRecord.sessionId,
-        createdAt: verificationRecord.createdAt,
+        verificationId: session.sessionId,
+        createdAt: session.createdAt,
         elapsed: formatVerifyElapsed({
-            status: verificationRecord.status,
-            startedAt: verificationRecord.startedAt,
-            completedAt: verificationRecord.completedAt,
+            status: session.status,
+            startedAt: session.startedAt,
+            completedAt: session.completedAt,
         }) ?? DASH,
-        workspacePath: getVerificationSessionDirectoryPath(verificationRecord.sessionId),
-        target: verificationRecord.target,
-        status: verificationRecord.status,
-        methods: verificationRecord.methods.map((method) => ({
-            verifierLabel: method.method === "programmatic"
-                ? "programmatic"
-                : (method.template ?? "rubric"),
-            agentLabel: method.verifierId,
-            status: method.status,
-            duration: formatVerifyMethodDuration(method),
-            artifactPath: method.artifactPath,
-            errorLine: method.error ?? undefined,
+        workspacePath: session.workspacePath,
+        targetDisplay: session.target
+            ? formatTargetDisplay(session.target)
+            : undefined,
+        status: session.status,
+        methods: session.agents.map((agent) => ({
+            verifierLabel: agent.verifier ?? "rubric",
+            agentLabel: agent.agentId ?? undefined,
+            status: agent.status,
+            duration: formatVerifyAgentDuration(agent),
+            artifactPath: agent.outputPath,
+            errorLine: agent.errorLine,
         })),
         suppressHint: true,
         isTty: process.stdout.isTTY,
     });
 }
-function toJsonTableRecord(operator, record) {
-    if (operator === "run") {
-        const runRecord = record;
-        return {
-            id: runRecord.runId,
-            status: runRecord.status,
-            createdAt: runRecord.createdAt,
-            specPath: runRecord.spec.path,
-        };
-    }
-    if (operator === "spec") {
-        const specRecord = record;
-        return {
-            id: specRecord.sessionId,
-            status: specRecord.status,
-            createdAt: specRecord.createdAt,
-            description: normalizeDescription(specRecord.description),
-        };
-    }
-    if (operator === "reduce") {
-        const reductionRecord = record;
-        return {
-            id: reductionRecord.sessionId,
-            status: reductionRecord.status,
-            createdAt: reductionRecord.createdAt,
-            target: {
-                kind: reductionRecord.target.type,
-                id: reductionRecord.target.id,
-            },
-        };
-    }
-    if (operator === "message") {
-        const messageRecord = record;
-        return {
-            id: messageRecord.sessionId,
-            status: messageRecord.status,
-            createdAt: messageRecord.createdAt,
-            promptPreview: normalizePreviewText(messageRecord.prompt),
-        };
-    }
-    const verificationRecord = record;
-    return {
-        id: verificationRecord.sessionId,
-        status: verificationRecord.status,
-        createdAt: verificationRecord.createdAt,
-        target: {
-            kind: verificationRecord.target.kind,
-            id: verificationRecord.target.sessionId,
-        },
-    };
-}
-function toJsonDetailSession(operator, record) {
-    if (operator === "run") {
-        const runRecord = record;
-        return {
-            id: runRecord.runId,
-            status: runRecord.status,
-            createdAt: runRecord.createdAt,
-            elapsed: formatRunRecordElapsed(runRecord),
-            workspacePath: getRunDirectoryPath(runRecord.runId),
-            rows: runRecord.agents.map(toRunJsonRow),
-            artifacts: [],
-        };
-    }
-    if (operator === "spec") {
-        const specRecord = record;
-        return {
-            id: specRecord.sessionId,
-            status: specRecord.status,
-            createdAt: specRecord.createdAt,
-            elapsed: formatSpecRecordElapsed(specRecord),
-            workspacePath: getSpecSessionDirectoryPath(specRecord.sessionId),
-            rows: specRecord.agents.map(toSpecJsonRow),
-            artifacts: specRecord.agents.map(toSpecArtifact),
-        };
-    }
-    if (operator === "reduce") {
-        const reductionRecord = record;
-        return {
-            id: reductionRecord.sessionId,
-            status: reductionRecord.status,
-            createdAt: reductionRecord.createdAt,
-            elapsed: formatReductionRecordElapsed(reductionRecord),
-            workspacePath: getReductionSessionDirectoryPath(reductionRecord.sessionId),
-            target: {
-                kind: reductionRecord.target.type,
-                id: reductionRecord.target.id,
-            },
-            rows: reductionRecord.reducers.map(toReductionJsonRow),
-            artifacts: reductionRecord.reducers.map(toReductionArtifact),
-        };
-    }
-    if (operator === "message") {
-        const messageRecord = record;
-        return {
-            id: messageRecord.sessionId,
-            status: messageRecord.status,
-            createdAt: messageRecord.createdAt,
-            elapsed: formatMessageRecordElapsed(messageRecord),
-            workspacePath: getMessageSessionDirectoryPath(messageRecord.sessionId),
-            rows: messageRecord.recipients.map(toMessageJsonRow),
-            artifacts: messageRecord.recipients.flatMap(toMessageArtifacts),
-        };
-    }
-    const verificationRecord = record;
+function toJsonSummarySession(session) {
     return {
-        id: verificationRecord.sessionId,
-        status: verificationRecord.status,
-        createdAt: verificationRecord.createdAt,
-        elapsed: formatVerificationRecordElapsed(verificationRecord),
-        workspacePath: getVerificationSessionDirectoryPath(verificationRecord.sessionId),
-        target: {
-            kind: verificationRecord.target.kind,
-            id: verificationRecord.target.sessionId,
-        },
-        rows: verificationRecord.methods.map(toVerificationJsonRow),
-        artifacts: verificationRecord.methods.map(toVerificationArtifact),
+        operator: session.operator,
+        sessionId: session.sessionId,
+        status: session.status,
+        createdAt: session.createdAt,
+        ...(session.target ? { target: toListJsonTargetRef(session.target) } : {}),
+        ...(session.description !== undefined
+            ? { description: session.description }
+            : {}),
     };
 }
-function formatRunRecordElapsed(record) {
-    return formatRunElapsed({
-        status: record.status,
-        startedAt: record.startedAt,
-        completedAt: record.completedAt,
-    });
-}
-function formatSpecRecordElapsed(record) {
-    return formatSpecElapsed({
-        status: record.status,
-        startedAt: record.startedAt,
-        completedAt: record.completedAt,
-    });
-}
-function formatReductionRecordElapsed(record) {
-    return formatReduceElapsed({
-        status: record.status,
-        startedAt: record.startedAt,
-        completedAt: record.completedAt,
-    });
-}
-function formatMessageRecordElapsed(record) {
-    return formatMessageElapsed({
-        status: record.status,
-        startedAt: record.startedAt,
-        completedAt: record.completedAt,
-    });
-}
-function normalizePreviewText(value) {
-    if (!value) {
-        return null;
-    }
-    const normalized = value.replace(/\s+/gu, " ").trim();
-    return normalized.length > 0 ? normalized : null;
-}
-function formatVerificationRecordElapsed(record) {
-    return formatVerifyElapsed({
-        status: record.status,
-        startedAt: record.startedAt,
-        completedAt: record.completedAt,
-    });
-}
-function formatRunRowDuration(agent) {
-    return agent.status === "running"
-        ? DASH
-        : (formatAgentDuration(agent) ?? DASH);
-}
-function toRunJsonRow(agent) {
+function toJsonDetailSession(session) {
     return {
-        agentId: agent.agentId,
-        status: agent.status,
-        duration: formatRunRowDuration(agent),
-        changes: formatCompactDiffStatistics(agent.diffStatistics) ?? null,
+        operator: session.operator,
+        sessionId: session.sessionId,
+        status: session.status,
+        createdAt: session.createdAt,
+        ...(session.startedAt ? { startedAt: session.startedAt } : {}),
+        ...(session.completedAt ? { completedAt: session.completedAt } : {}),
+        workspacePath: session.workspacePath,
+        ...(session.target ? { target: toListJsonTargetRef(session.target) } : {}),
+        ...(session.description !== undefined
+            ? { description: session.description }
+            : {}),
+        agents: session.agents.map(toJsonAgent),
     };
 }
-function formatSpecRowDuration(agent) {
-    return (formatSpecAgentDuration({
-        status: agent.status,
-        startedAt: agent.startedAt,
-        completedAt: agent.completedAt,
-    }) ?? DASH);
-}
-function toSpecJsonRow(agent) {
+function toJsonAgent(agent) {
     return {
         agentId: agent.agentId,
         status: agent.status,
-        duration: formatSpecRowDuration(agent),
-    };
-}
-function toSpecArtifact(agent) {
-    return {
-        kind: "spec",
-        agentId: agent.agentId,
-        path: agent.outputPath ?? null,
-    };
-}
-function formatReductionRowDuration(reducer) {
-    return (formatReducerDuration({
-        status: reducer.status,
-        startedAt: reducer.startedAt,
-        completedAt: reducer.completedAt,
-    }) ?? DASH);
-}
-function toReductionJsonRow(reducer) {
-    return {
-        agentId: reducer.agentId,
-        status: reducer.status,
-        duration: formatReductionRowDuration(reducer),
-    };
-}
-function toReductionArtifact(reducer) {
-    return {
-        kind: "reduction",
-        agentId: reducer.agentId,
-        path: reducer.outputPath ?? null,
-    };
-}
-function toMessageJsonRow(recipient) {
-    return {
-        agentId: recipient.agentId,
-        status: recipient.status,
-        duration: formatMessageRecipientDuration({
-            status: recipient.status,
-            startedAt: recipient.startedAt,
-            completedAt: recipient.completedAt,
-        }) ?? DASH,
-    };
-}
-function toMessageArtifacts(recipient) {
-    return [
-        {
-            kind: "output",
-            agentId: recipient.agentId,
-            path: recipient.outputPath ?? null,
-        },
-    ];
-}
-function getVerificationMethodLabel(method) {
-    return method.method === "programmatic"
-        ? "programmatic"
-        : (method.template ?? "rubric");
-}
-function toVerificationJsonRow(method) {
-    return {
-        agentId: method.verifierId ?? null,
-        verifier: getVerificationMethodLabel(method),
-        status: method.status,
-        duration: formatVerifyMethodDuration(method),
-    };
-}
-function toVerificationArtifact(method) {
-    return {
-        kind: "result",
-        agentId: method.verifierId ?? null,
-        verifier: getVerificationMethodLabel(method),
-        path: method.artifactPath ?? null,
+        ...(agent.startedAt ? { startedAt: agent.startedAt } : {}),
+        ...(agent.completedAt ? { completedAt: agent.completedAt } : {}),
+        ...(agent.verifier ? { verifier: agent.verifier } : {}),
+        ...(agent.changes ? { changes: agent.changes } : {}),
+        artifacts: agent.artifacts,
     };
 }
 function shouldIncludeInDefaultTable(operator, status) {
@@ -567,6 +421,23 @@ async function readOperatorRecords(input) {
             warnings: warnings.map(formatSessionWarning),
         };
     }
+    if (operator === "interactive") {
+        if (!(await pathExists(input.interactiveFilePath))) {
+            return { records: [], warnings: [] };
+        }
+        const warnings = [];
+        const records = await readInteractiveRecords({
+            root,
+            interactiveFilePath: input.interactiveFilePath,
+            limit: input.limit,
+            predicate: input.predicate,
+            onWarning: (warning) => warnings.push(warning),
+        });
+        return {
+            records,
+            warnings: warnings.map(formatSessionWarning),
+        };
+    }
     if (!(await pathExists(input.verificationsFilePath))) {
         return { records: [], warnings: [] };
     }
@@ -590,28 +461,37 @@ function getRecordStatus(record) {
     return record.status;
 }
 function getRecordId(operator, record) {
-    if (operator === "run") {
-        return record.runId;
-    }
-    return record.sessionId;
+    return getListRecordId(operator, record);
 }
 function formatSessionWarning(warning) {
     return `Ignoring corrupt session ${warning.displayPath}`;
 }
-function normalizeDescription(value) {
-    if (!value) {
-        return null;
-    }
-    const normalized = value.replace(/\s+/g, " ").trim();
-    return normalized.length > 0 ? normalized : null;
-}
-function formatVerifyMethodDuration(method) {
-    return (formatRenderLifecycleDuration({
+function formatVerifyAgentDuration(agent) {
+    return formatRenderLifecycleRowDuration({
         lifecycle: {
-            status: method.status,
-            startedAt: method.startedAt,
-            completedAt: method.completedAt,
+            status: agent.status,
+            startedAt: agent.startedAt,
+            completedAt: agent.completedAt,
         },
         terminalStatuses: TERMINAL_VERIFICATION_STATUSES,
-    }) ?? DASH);
+    });
+}
+function formatInteractiveElapsed(input) {
+    return formatRenderLifecycleDuration({
+        lifecycle: input,
+        terminalStatuses: ["succeeded", "failed"],
+    });
+}
+function formatInteractiveAgentDuration(agent) {
+    if (!agent) {
+        return DASH;
+    }
+    return formatRenderLifecycleRowDuration({
+        lifecycle: {
+            status: agent.status,
+            startedAt: agent.startedAt,
+            completedAt: agent.completedAt,
+        },
+        terminalStatuses: ["succeeded", "failed"],
+    });
 }