voratiq 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/domain/shared/lifecycle.js

@@ -0,0 +1,165 @@
+import { z } from "zod";
+function parseTimestamp(value) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? undefined : parsed;
+}
+function addIssue(ctx, path, message) {
+    ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: [path],
+        message,
+    });
+}
+function includesStatus(statuses, status) {
+    return statuses.includes(status);
+}
+export function resolveLifecycleExecutionDurationMs(lifecycle, options) {
+    const startedAtTime = parseTimestamp(lifecycle.startedAt);
+    if (startedAtTime === undefined) {
+        return undefined;
+    }
+    const { statusGroups } = options;
+    if (includesStatus(statusGroups.running, lifecycle.status)) {
+        const nowTime = options.now ?? Date.now();
+        if (!Number.isFinite(nowTime) || nowTime < startedAtTime) {
+            return undefined;
+        }
+        return nowTime - startedAtTime;
+    }
+    if (includesStatus(statusGroups.terminal, lifecycle.status)) {
+        const completedAtTime = parseTimestamp(lifecycle.completedAt);
+        if (completedAtTime === undefined || completedAtTime < startedAtTime) {
+            return undefined;
+        }
+        return completedAtTime - startedAtTime;
+    }
+    return undefined;
+}
+export function validateRecordLifecycleTimestamps(record, ctx, groups) {
+    const { createdAt, startedAt, completedAt, status } = record;
+    const isQueued = includesStatus(groups.queued, status);
+    const isRunning = includesStatus(groups.running, status);
+    const isTerminal = includesStatus(groups.terminal, status);
+    /**
+     * Canonical lifecycle timestamp contract:
+     * - queued: `startedAt` and `completedAt` MUST be omitted
+     * - running: `startedAt` is required; `completedAt` MUST be omitted
+     * - terminal: `startedAt` and `completedAt` are required
+     *
+     * Record-level invariants:
+     * - `startedAt` must be >= `createdAt`
+     * - `completedAt` must be >= `startedAt`
+     */
+    if (isQueued) {
+        if (startedAt) {
+            addIssue(ctx, "startedAt", "startedAt must be omitted while record status is queued");
+        }
+        if (completedAt) {
+            addIssue(ctx, "completedAt", "completedAt must be omitted while record status is queued");
+        }
+        return;
+    }
+    if (isRunning) {
+        if (!startedAt) {
+            addIssue(ctx, "startedAt", "startedAt is required once record status is running");
+        }
+        if (completedAt) {
+            addIssue(ctx, "completedAt", "completedAt must be omitted while record status is running");
+        }
+    }
+    if (isTerminal) {
+        if (!startedAt) {
+            addIssue(ctx, "startedAt", "startedAt is required once record status is terminal");
+        }
+        if (!completedAt) {
+            addIssue(ctx, "completedAt", "completedAt is required once record status is terminal");
+        }
+    }
+    const createdAtTime = parseTimestamp(createdAt);
+    const startedAtTime = parseTimestamp(startedAt);
+    const completedAtTime = parseTimestamp(completedAt);
+    if (createdAtTime !== undefined &&
+        startedAtTime !== undefined &&
+        startedAtTime < createdAtTime) {
+        addIssue(ctx, "startedAt", "startedAt must be greater than or equal to createdAt");
+    }
+    if (completedAtTime !== undefined &&
+        startedAtTime !== undefined &&
+        completedAtTime < startedAtTime) {
+        addIssue(ctx, "completedAt", "completedAt must be greater than or equal to startedAt");
+    }
+}
+export function validateOperationLifecycleTimestamps(record, ctx, groups) {
+    const { startedAt, completedAt, status } = record;
+    const isQueued = includesStatus(groups.queued, status);
+    const isRunning = includesStatus(groups.running, status);
+    const isTerminal = includesStatus(groups.terminal, status);
+    if (isQueued) {
+        if (startedAt) {
+            addIssue(ctx, "startedAt", "startedAt must be omitted while record status is queued");
+        }
+        if (completedAt) {
+            addIssue(ctx, "completedAt", "completedAt must be omitted while record status is queued");
+        }
+        return;
+    }
+    if (isRunning) {
+        if (!startedAt) {
+            addIssue(ctx, "startedAt", "startedAt is required once record status is running");
+        }
+        if (completedAt) {
+            addIssue(ctx, "completedAt", "completedAt must be omitted while record status is running");
+        }
+    }
+    if (isTerminal) {
+        if (!startedAt) {
+            addIssue(ctx, "startedAt", "startedAt is required once record status is terminal");
+        }
+        if (!completedAt) {
+            addIssue(ctx, "completedAt", "completedAt is required once record status is terminal");
+        }
+    }
+    const startedAtTime = parseTimestamp(startedAt);
+    const completedAtTime = parseTimestamp(completedAt);
+    if (completedAtTime !== undefined &&
+        startedAtTime !== undefined &&
+        completedAtTime < startedAtTime) {
+        addIssue(ctx, "completedAt", "completedAt must be greater than or equal to startedAt");
+    }
+}
+export function buildLifecycleStartFields(options) {
+    return {
+        startedAt: options.existingStartedAt ??
+            options.timestamp ??
+            new Date().toISOString(),
+    };
+}
+export function buildRecordLifecycleCompleteFields(options) {
+    const completedAt = options.completedAt ??
+        options.existing.completedAt ??
+        new Date().toISOString();
+    const startedAt = options.existing.startedAt ?? options.startedAt;
+    if (!startedAt) {
+        throw new Error("Record lifecycle completion requires canonical startedAt.");
+    }
+    return {
+        startedAt,
+        completedAt,
+    };
+}
+export function buildOperationLifecycleCompleteFields(options) {
+    const completedAt = options.completedAt ??
+        options.existing.completedAt ??
+        new Date().toISOString();
+    const startedAt = options.existing.startedAt ?? options.startedAt;
+    if (!startedAt) {
+        throw new Error("Operation lifecycle completion requires canonical startedAt.");
+    }
+    return {
+        startedAt,
+        completedAt,
+    };
+}

package/dist/domain/shared/token-usage.d.ts

@@ -0,0 +1,21 @@
+import type { TokenUsageResult } from "../../workspace/chat/token-usage-result.js";
+import type { ChatArtifactFormat } from "../../workspace/chat/types.js";
+import type { ExtractedTokenUsage } from "../run/model/types.js";
+export declare const DEFAULT_TOKEN_USAGE_UNAVAILABLE_MESSAGE = "Chat usage capture was not enabled or did not produce an artifact.";
+export declare const UNKNOWN_TOKEN_USAGE_PROVIDER = "unknown";
+export declare const UNKNOWN_TOKEN_USAGE_MODEL_ID = "unknown";
+interface TokenUsageResultMetadata {
+    provider?: string;
+    modelId?: string;
+    artifactPath?: string;
+    format?: ChatArtifactFormat;
+}
+export declare function buildUnavailableTokenUsageResult(options: TokenUsageResultMetadata & {
+    message?: string;
+}): TokenUsageResult;
+export declare function resolveTokenUsage(result: TokenUsageResult): ExtractedTokenUsage | undefined;
+export declare function reconstructTokenUsageResult(options: TokenUsageResultMetadata & {
+    tokenUsage?: ExtractedTokenUsage;
+    message?: string;
+}): TokenUsageResult;
+export {};

package/dist/domain/shared/token-usage.js

@@ -0,0 +1,38 @@
+export const DEFAULT_TOKEN_USAGE_UNAVAILABLE_MESSAGE = "Chat usage capture was not enabled or did not produce an artifact.";
+export const UNKNOWN_TOKEN_USAGE_PROVIDER = "unknown";
+export const UNKNOWN_TOKEN_USAGE_MODEL_ID = "unknown";
+export function buildUnavailableTokenUsageResult(options) {
+    const { provider = UNKNOWN_TOKEN_USAGE_PROVIDER, modelId = UNKNOWN_TOKEN_USAGE_MODEL_ID, artifactPath, format, message, } = options;
+    return {
+        status: "unavailable",
+        reason: "chat_not_captured",
+        provider,
+        modelId,
+        ...(artifactPath !== undefined ? { artifactPath } : {}),
+        ...(format !== undefined ? { format } : {}),
+        message: message ?? DEFAULT_TOKEN_USAGE_UNAVAILABLE_MESSAGE,
+    };
+}
+export function resolveTokenUsage(result) {
+    return result.status === "available" ? result.tokenUsage : undefined;
+}
+export function reconstructTokenUsageResult(options) {
+    const { tokenUsage, provider = UNKNOWN_TOKEN_USAGE_PROVIDER, modelId = UNKNOWN_TOKEN_USAGE_MODEL_ID, artifactPath, format, message, } = options;
+    if (!tokenUsage) {
+        return buildUnavailableTokenUsageResult({
+            provider,
+            modelId,
+            artifactPath,
+            format,
+            message,
+        });
+    }
+    return {
+        status: "available",
+        provider,
+        modelId,
+        ...(artifactPath !== undefined ? { artifactPath } : {}),
+        ...(format !== undefined ? { format } : {}),
+        tokenUsage,
+    };
+}

package/dist/domain/spec/competition/adapter.d.ts

@@ -0,0 +1,31 @@
+import type { CompetitionCommandAdapter } from "../../../competition/command-adapter.js";
+import { type ResolvedExtraContextFile } from "../../../competition/shared/extra-context.js";
+import type { AgentDefinition } from "../../../configs/agents/types.js";
+import type { EnvironmentConfig } from "../../../configs/environment/types.js";
+import type { ExtractedTokenUsage } from "../../../domain/run/model/types.js";
+import type { TokenUsageResult } from "../../../workspace/chat/token-usage-result.js";
+import { type AgentWorkspacePaths } from "../../../workspace/layout.js";
+export type SpecCompetitionCandidate = AgentDefinition;
+export interface PreparedSpecCompetitionCandidate {
+    readonly candidate: SpecCompetitionCandidate;
+    readonly workspacePaths: AgentWorkspacePaths;
+    readonly prompt: string;
+}
+export interface SpecCompetitionExecution {
+    readonly agentId: string;
+    readonly outputPath?: string;
+    readonly dataPath?: string;
+    readonly status: "succeeded" | "failed";
+    readonly tokenUsage?: ExtractedTokenUsage;
+    readonly tokenUsageResult: TokenUsageResult;
+    readonly error?: string;
+}
+export interface CreateSpecCompetitionAdapterInput {
+    readonly root: string;
+    readonly sessionId: string;
+    readonly description: string;
+    readonly specTitle?: string;
+    readonly environment: EnvironmentConfig;
+    readonly extraContextFiles?: readonly ResolvedExtraContextFile[];
+}
+export declare function createSpecCompetitionAdapter(input: CreateSpecCompetitionAdapterInput): CompetitionCommandAdapter<SpecCompetitionCandidate, PreparedSpecCompetitionCandidate, SpecCompetitionExecution>;

package/dist/domain/spec/competition/adapter.js

@@ -0,0 +1,196 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { detectAgentProcessFailureDetail } from "../../../agents/runtime/failures.js";
+import { runSandboxedAgent } from "../../../agents/runtime/harness.js";
+import { teardownSessionAuth } from "../../../agents/runtime/registry.js";
+import { stageExtraContextFiles, } from "../../../competition/shared/extra-context.js";
+import { composeStageSandboxPolicy } from "../../../competition/shared/sandbox-policy.js";
+import { createTeardownController, runTeardown, } from "../../../competition/shared/teardown.js";
+import { buildUnavailableTokenUsageResult, resolveTokenUsage, } from "../../../domain/shared/token-usage.js";
+import { buildSpecPrompt } from "../../../domain/spec/competition/prompt.js";
+import { parseSpecData } from "../../../domain/spec/model/output.js";
+import { toErrorMessage } from "../../../utils/errors.js";
+import { normalizePathForDisplay, relativeToRoot, } from "../../../utils/path.js";
+import { slugify } from "../../../utils/slug.js";
+import { extractProviderNativeTokenUsageForSession } from "../../../workspace/chat/native-usage.js";
+import { buildAgentSessionWorkspacePaths, scaffoldAgentWorkspace, } from "../../../workspace/layout.js";
+import { promoteWorkspaceFile } from "../../../workspace/promotion.js";
+import { VORATIQ_SPEC_DIR } from "../../../workspace/structure.js";
+const SPEC_MARKDOWN_FILENAME = "spec.md";
+const SPEC_DATA_FILENAME = "spec.json";
+export function createSpecCompetitionAdapter(input) {
+    const { root, sessionId, description, specTitle, environment, extraContextFiles = [], } = input;
+    const teardown = createTeardownController(`spec \`${sessionId}\``);
+    teardown.addAction({
+        key: `spec-auth:${sessionId}`,
+        label: "session auth",
+        cleanup: async () => {
+            await teardownSessionAuth(sessionId);
+        },
+    });
+    return {
+        failurePolicy: "continue",
+        prepareCandidates: async (candidates) => {
+            const ready = [];
+            const failures = [];
+            for (const candidate of candidates) {
+                const workspacePaths = buildAgentSessionWorkspacePaths({
+                    root,
+                    domain: VORATIQ_SPEC_DIR,
+                    sessionId,
+                    agentId: candidate.id,
+                });
+                registerScratchWorkspaceTeardown(teardown, workspacePaths, candidate.id);
+                try {
+                    await scaffoldAgentWorkspace(workspacePaths);
+                    await stageExtraContextFiles({
+                        contextPath: workspacePaths.contextPath,
+                        files: extraContextFiles,
+                    });
+                    const prompt = buildSpecPrompt({
+                        description,
+                        title: specTitle,
+                        markdownOutputPath: SPEC_MARKDOWN_FILENAME,
+                        dataOutputPath: SPEC_DATA_FILENAME,
+                        repoRootPath: root,
+                        workspacePath: workspacePaths.workspacePath,
+                        extraContextFiles,
+                    });
+                    ready.push({
+                        candidate,
+                        workspacePaths,
+                        prompt,
+                    });
+                }
+                catch (error) {
+                    failures.push({
+                        agentId: candidate.id,
+                        status: "failed",
+                        tokenUsageResult: buildUnavailableTokenUsageResult({
+                            provider: candidate.provider,
+                            modelId: candidate.model,
+                            message: toErrorMessage(error),
+                        }),
+                        error: toErrorMessage(error),
+                    });
+                }
+            }
+            return {
+                ready,
+                failures,
+            };
+        },
+        executeCandidate: async (prepared) => {
+            const { candidate, workspacePaths, prompt } = prepared;
+            try {
+                const result = await runSandboxedAgent({
+                    root,
+                    sessionId,
+                    sandboxStageId: "spec",
+                    agent: candidate,
+                    prompt,
+                    environment,
+                    paths: {
+                        agentRoot: workspacePaths.agentRoot,
+                        workspacePath: workspacePaths.workspacePath,
+                        sandboxHomePath: workspacePaths.sandboxHomePath,
+                        runtimeManifestPath: workspacePaths.runtimeManifestPath,
+                        sandboxSettingsPath: workspacePaths.sandboxSettingsPath,
+                        runtimePath: workspacePaths.runtimePath,
+                        artifactsPath: workspacePaths.artifactsPath,
+                        stdoutPath: workspacePaths.stdoutPath,
+                        stderrPath: workspacePaths.stderrPath,
+                    },
+                    captureChat: true,
+                    teardownAuthOnExit: false,
+                    ...composeStageSandboxPolicy(),
+                });
+                const tokenUsageResult = await extractProviderNativeTokenUsageForSession({
+                    root,
+                    domain: VORATIQ_SPEC_DIR,
+                    sessionId,
+                    agentId: candidate.id,
+                    provider: candidate.provider,
+                    modelId: candidate.model,
+                    chatCaptured: result.chat?.captured === true,
+                    format: result.chat?.format,
+                    artifactPath: result.chat?.artifactPath,
+                });
+                const tokenUsage = resolveTokenUsage(tokenUsageResult);
+                if (result.exitCode !== 0 || result.errorMessage) {
+                    const detectedDetail = result.watchdog?.trigger && result.errorMessage
+                        ? result.errorMessage
+                        : await detectAgentProcessFailureDetail({
+                            provider: candidate.provider,
+                            stdoutPath: workspacePaths.stdoutPath,
+                            stderrPath: workspacePaths.stderrPath,
+                        });
+                    const detail = detectedDetail ??
+                        result.errorMessage ??
+                        `Agent exited with code ${result.exitCode ?? "unknown"}`;
+                    return {
+                        agentId: candidate.id,
+                        status: "failed",
+                        tokenUsage,
+                        tokenUsageResult,
+                        error: detail,
+                    };
+                }
+                const stagedMarkdownPath = join(workspacePaths.workspacePath, SPEC_MARKDOWN_FILENAME);
+                const stagedDataPath = join(workspacePaths.workspacePath, SPEC_DATA_FILENAME);
+                await readFile(stagedMarkdownPath, "utf8");
+                const specData = parseSpecData(await readFile(stagedDataPath, "utf8"));
+                const artifactBasename = slugify(specData.title, "spec");
+                const artifactMarkdownFilename = `${artifactBasename}.md`;
+                const artifactDataFilename = `${artifactBasename}.json`;
+                const markdownPromoteResult = await promoteWorkspaceFile({
+                    workspacePath: workspacePaths.workspacePath,
+                    artifactsPath: workspacePaths.artifactsPath,
+                    stagedRelativePath: SPEC_MARKDOWN_FILENAME,
+                    artifactRelativePath: artifactMarkdownFilename,
+                    deleteStaged: true,
+                });
+                const dataPromoteResult = await promoteWorkspaceFile({
+                    workspacePath: workspacePaths.workspacePath,
+                    artifactsPath: workspacePaths.artifactsPath,
+                    stagedRelativePath: SPEC_DATA_FILENAME,
+                    artifactRelativePath: artifactDataFilename,
+                    deleteStaged: true,
+                });
+                return {
+                    agentId: candidate.id,
+                    outputPath: normalizePathForDisplay(relativeToRoot(root, markdownPromoteResult.artifactPath)),
+                    dataPath: normalizePathForDisplay(relativeToRoot(root, dataPromoteResult.artifactPath)),
+                    status: "succeeded",
+                    tokenUsage,
+                    tokenUsageResult,
+                };
+            }
+            catch (error) {
+                return {
+                    agentId: candidate.id,
+                    status: "failed",
+                    tokenUsageResult: buildUnavailableTokenUsageResult({
+                        provider: candidate.provider,
+                        modelId: candidate.model,
+                        message: toErrorMessage(error),
+                    }),
+                    error: toErrorMessage(error),
+                };
+            }
+        },
+        finalizeCompetition: async () => {
+            await runTeardown(teardown);
+        },
+        sortResults: compareSpecExecutionsByAgentId,
+    };
+}
+function registerScratchWorkspaceTeardown(teardown, workspacePaths, agentId) {
+    teardown.addPath(workspacePaths.workspacePath, `${agentId} workspace`);
+    teardown.addPath(workspacePaths.contextPath, `${agentId} context`);
+    teardown.addPath(workspacePaths.runtimePath, `${agentId} runtime`);
+    teardown.addPath(workspacePaths.sandboxPath, `${agentId} sandbox`);
+}
+function compareSpecExecutionsByAgentId(left, right) {
+    return left.agentId.localeCompare(right.agentId);
+}

package/dist/domain/spec/competition/prompt.d.ts

@@ -0,0 +1,11 @@
+import { type ResolvedExtraContextFile } from "../../../competition/shared/extra-context.js";
+export interface BuildSpecPromptOptions {
+    description: string;
+    title?: string;
+    markdownOutputPath: string;
+    dataOutputPath: string;
+    repoRootPath: string;
+    workspacePath: string;
+    extraContextFiles?: readonly ResolvedExtraContextFile[];
+}
+export declare function buildSpecPrompt(options: BuildSpecPromptOptions): string;

package/dist/domain/spec/competition/prompt.js

@@ -0,0 +1,44 @@
+import { appendExtraContextPromptSection, } from "../../../competition/shared/extra-context.js";
+import { appendConstraints, appendOutputRequirements, buildWorkspaceArtifactRequirements, } from "../../../competition/shared/prompt-helpers.js";
+export function buildSpecPrompt(options) {
+    const { description, title, markdownOutputPath, dataOutputPath, repoRootPath, workspacePath, extraContextFiles = [], } = options;
+    const lines = [
+        "Write a spec for the task described below.",
+        "",
+        "A spec defines **what** to build and **why**, not **how**. Don't prescribe implementation details—agents choose the approach.",
+    ];
+    if (title) {
+        lines.push("", `Title: ${title}`);
+    }
+    lines.push("", "User description:", "```", description.trim(), "```", "", "Required spec structure:", "- **H1 title**", "- **## Objective** — concise prose stating the goal.", "- **## Scope** — flat bullet list.", "- **## Acceptance Criteria** — flat bullet list. Each item independently verifiable, focused on observable outcomes.", "- **## Constraints** — flat bullet list.", "- **## Exit Signal** — concise prose.", "- **## Out of Scope** (optional) — flat bullet list when useful to prevent scope creep.", "", "Authoring guidance:", "- State the goal explicitly and unambiguously.", "- Reference existing code for context, not to dictate where changes go.", "- Be direct, concrete, and executable.", "- Include needed external context inline—don't reference URLs that agents cannot access.", "- Do not embed runtime or execution environment details (sandbox constraints, headless mode, file-access rules) in the spec content. Those are agent instructions, not spec content.");
+    appendConstraints(lines, {
+        readAccess: repoRootPath,
+        writeAccess: workspacePath,
+    });
+    appendExtraContextPromptSection(lines, extraContextFiles);
+    appendOutputRequirements(lines, buildWorkspaceArtifactRequirements([
+        {
+            instruction: "Save the spec as markdown",
+            path: markdownOutputPath,
+        },
+        {
+            instruction: "Save the same spec as JSON",
+            path: dataOutputPath,
+            schema: {
+                leadIn: "with this shape",
+                content: [
+                    "`{`",
+                    "`  title: string,`",
+                    "`  objective: string,`",
+                    "`  scope: string[],`",
+                    "`  acceptanceCriteria: string[],`",
+                    "`  constraints: string[],`",
+                    "`  exitSignal: string,`",
+                    "`  outOfScope?: string[],`",
+                    "`}`",
+                ],
+            },
+        },
+    ], ["- Both files must describe the same spec."]));
+    return `${lines.join("\n")}\n`;
+}

package/dist/domain/spec/model/output.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const specDataSchema: z.ZodObject<{
+    title: z.ZodString;
+    objective: z.ZodString;
+    scope: z.ZodArray<z.ZodString>;
+    acceptanceCriteria: z.ZodArray<z.ZodString>;
+    constraints: z.ZodArray<z.ZodString>;
+    outOfScope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exitSignal: z.ZodString;
+}, z.core.$strip>;
+export type SpecData = z.infer<typeof specDataSchema>;
+export declare function parseSpecData(rawSpecData: string): SpecData;
+export declare function readSpecData(specDataPath: string): Promise<SpecData>;

package/dist/domain/spec/model/output.js

@@ -0,0 +1,36 @@
+import { readFile } from "node:fs/promises";
+import { z } from "zod";
+export const specDataSchema = z.object({
+    title: z.string().trim().min(1),
+    objective: z.string().trim().min(1),
+    scope: z.array(z.string().trim().min(1)).min(1),
+    acceptanceCriteria: z.array(z.string().trim().min(1)).min(1),
+    constraints: z.array(z.string().trim().min(1)).min(1),
+    outOfScope: z.array(z.string().trim().min(1)).optional(),
+    exitSignal: z.string().trim().min(1),
+});
+export function parseSpecData(rawSpecData) {
+    let parsed;
+    try {
+        parsed = JSON.parse(rawSpecData);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : "invalid JSON syntax";
+        throw new Error(`Invalid JSON: ${reason}`);
+    }
+    const validation = specDataSchema.safeParse(parsed);
+    if (!validation.success) {
+        const detail = validation.error.issues
+            .map((issue) => {
+            const path = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
+            return `${path}: ${issue.message}`;
+        })
+            .join("; ");
+        throw new Error(`Schema validation failed: ${detail}`);
+    }
+    return validation.data;
+}
+export async function readSpecData(specDataPath) {
+    const rawSpecData = await readFile(specDataPath, "utf8");
+    return parseSpecData(rawSpecData);
+}

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

@@ -0,0 +1,98 @@
+import { z } from "zod";
+import { type SpecAgentStatus, specAgentStatusSchema, type SpecRecordStatus, specRecordStatusSchema, TERMINAL_SPEC_AGENT_STATUSES, TERMINAL_SPEC_STATUSES } from "../../../status/index.js";
+export type { SpecAgentStatus, SpecRecordStatus };
+export { specAgentStatusSchema, specRecordStatusSchema, TERMINAL_SPEC_AGENT_STATUSES, TERMINAL_SPEC_STATUSES, };
+export declare const specAgentEntrySchema: z.ZodObject<{
+    agentId: z.ZodString;
+    status: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+    }>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    completedAt: z.ZodOptional<z.ZodString>;
+    outputPath: z.ZodOptional<z.ZodString>;
+    dataPath: z.ZodOptional<z.ZodString>;
+    tokenUsage: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        input_tokens: z.ZodOptional<z.ZodNumber>;
+        output_tokens: z.ZodOptional<z.ZodNumber>;
+        cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+        cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        input_tokens: z.ZodOptional<z.ZodNumber>;
+        cached_input_tokens: z.ZodOptional<z.ZodNumber>;
+        output_tokens: z.ZodOptional<z.ZodNumber>;
+        reasoning_output_tokens: z.ZodOptional<z.ZodNumber>;
+        total_tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        input: z.ZodOptional<z.ZodNumber>;
+        output: z.ZodOptional<z.ZodNumber>;
+        cached: z.ZodOptional<z.ZodNumber>;
+        thoughts: z.ZodOptional<z.ZodNumber>;
+        tool: z.ZodOptional<z.ZodNumber>;
+        total: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>]>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type SpecAgentEntry = z.infer<typeof specAgentEntrySchema>;
+export declare const specRecordSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    createdAt: z.ZodString;
+    startedAt: z.ZodString;
+    completedAt: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        aborted: "aborted";
+    }>;
+    baseRevisionSha: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    extraContextMetadata: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        stagedPath: z.ZodString;
+        sourcePath: z.ZodString;
+    }, z.core.$strip>>>;
+    agents: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        status: z.ZodEnum<{
+            queued: "queued";
+            running: "running";
+            succeeded: "succeeded";
+            failed: "failed";
+        }>;
+        startedAt: z.ZodOptional<z.ZodString>;
+        completedAt: z.ZodOptional<z.ZodString>;
+        outputPath: z.ZodOptional<z.ZodString>;
+        dataPath: z.ZodOptional<z.ZodString>;
+        tokenUsage: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            input_tokens: z.ZodOptional<z.ZodNumber>;
+            output_tokens: z.ZodOptional<z.ZodNumber>;
+            cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+            cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            input_tokens: z.ZodOptional<z.ZodNumber>;
+            cached_input_tokens: z.ZodOptional<z.ZodNumber>;
+            output_tokens: z.ZodOptional<z.ZodNumber>;
+            reasoning_output_tokens: z.ZodOptional<z.ZodNumber>;
+            total_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            input: z.ZodOptional<z.ZodNumber>;
+            output: z.ZodOptional<z.ZodNumber>;
+            cached: z.ZodOptional<z.ZodNumber>;
+            thoughts: z.ZodOptional<z.ZodNumber>;
+            tool: z.ZodOptional<z.ZodNumber>;
+            total: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>]>>;
+        error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type SpecRecord = z.infer<typeof specRecordSchema>;
+export type SpecIndexEntry = Pick<SpecRecord, "sessionId" | "createdAt" | "status">;
+/**
+ * Derive the session-level spec status from per-agent outcomes.
+ * Returns "succeeded" when at least one agent succeeds; otherwise "failed".
+ */
+export declare function deriveSpecStatusFromAgents(agentStatuses: readonly SpecAgentStatus[]): SpecRecordStatus;