@defai.digital/contracts 13.3.0 → 13.4.0

package/dist/autonomous-loop/v1/schema.d.ts

@@ -0,0 +1,3796 @@
+/**
+ * Autonomous Loop Contracts v1
+ *
+ * Schemas for governed write-test-fix cycles with guard gate integration.
+ *
+ * This enables autonomous development workflows where agents can iterate
+ * through planning, writing, testing, and fixing code while respecting
+ * governance policies and breakpoints.
+ */
+import { z } from 'zod';
+/**
+ * Phases of the autonomous loop
+ *
+ * - plan: Analyze requirements and plan implementation
+ * - write: Generate or modify code
+ * - test: Execute tests to verify changes
+ * - fix: Attempt to fix failing tests
+ * - verify: Final verification before completion
+ * - complete: Loop finished successfully
+ */
+export declare const AutonomousLoopPhaseSchema: z.ZodEnum<["plan", "write", "test", "fix", "verify", "complete"]>;
+export type AutonomousLoopPhase = z.infer<typeof AutonomousLoopPhaseSchema>;
+/**
+ * Status of the autonomous loop
+ *
+ * - running: Loop is actively executing
+ * - paused: Loop is paused at a breakpoint
+ * - completed: Loop finished successfully
+ * - failed: Loop failed after max retries
+ * - blocked: Loop blocked by guard gate
+ * - cancelled: Loop was cancelled by user
+ */
+export declare const AutonomousLoopStatusSchema: z.ZodEnum<["running", "paused", "completed", "failed", "blocked", "cancelled"]>;
+export type AutonomousLoopStatus = z.infer<typeof AutonomousLoopStatusSchema>;
+/**
+ * Configuration for autonomous loop execution
+ *
+ * Invariants:
+ * - INV-ALO-001: Guard gates run after EVERY write phase
+ * - INV-ALO-002: Test phase required before verify (when requireTestPass=true)
+ * - INV-ALO-003: Fix attempts bounded by maxFixAttempts
+ * - INV-ALO-004: Breakpoints pause for user review
+ */
+export declare const AutonomousLoopConfigSchema: z.ZodObject<{
+    /**
+     * Maximum iterations through the loop
+     */
+    maxIterations: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Maximum fix attempts per iteration
+     * INV-ALO-003: Bounded fix attempts
+     */
+    maxFixAttempts: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Guard policy to enforce
+     * INV-ALO-001: Guards run after write
+     */
+    guardPolicy: z.ZodOptional<z.ZodString>;
+    /**
+     * Whether tests must pass before verify phase
+     * INV-ALO-002: Test requirement
+     */
+    requireTestPass: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Phases that pause for user review
+     * INV-ALO-004: Breakpoint behavior
+     */
+    breakpoints: z.ZodDefault<z.ZodArray<z.ZodEnum<["plan", "write", "test", "fix", "verify", "complete"]>, "many">>;
+    /**
+     * Test command to run
+     */
+    testCommand: z.ZodDefault<z.ZodString>;
+    /**
+     * Timeout for test execution in milliseconds
+     */
+    testTimeout: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Timeout per phase in milliseconds
+     */
+    phaseTimeout: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Whether to auto-commit successful changes
+     */
+    autoCommit: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Commit message template (uses {{phase}}, {{iteration}})
+     */
+    commitMessageTemplate: z.ZodDefault<z.ZodString>;
+    /**
+     * Working directory for execution
+     */
+    workingDirectory: z.ZodOptional<z.ZodString>;
+    /**
+     * Agent ID to use for code generation
+     */
+    agentId: z.ZodOptional<z.ZodString>;
+    /**
+     * Provider to use for LLM calls
+     */
+    provider: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    maxIterations: number;
+    maxFixAttempts: number;
+    requireTestPass: boolean;
+    breakpoints: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[];
+    testCommand: string;
+    testTimeout: number;
+    phaseTimeout: number;
+    autoCommit: boolean;
+    commitMessageTemplate: string;
+    agentId?: string | undefined;
+    provider?: string | undefined;
+    guardPolicy?: string | undefined;
+    workingDirectory?: string | undefined;
+}, {
+    agentId?: string | undefined;
+    provider?: string | undefined;
+    maxIterations?: number | undefined;
+    maxFixAttempts?: number | undefined;
+    guardPolicy?: string | undefined;
+    requireTestPass?: boolean | undefined;
+    breakpoints?: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[] | undefined;
+    testCommand?: string | undefined;
+    testTimeout?: number | undefined;
+    phaseTimeout?: number | undefined;
+    autoCommit?: boolean | undefined;
+    commitMessageTemplate?: string | undefined;
+    workingDirectory?: string | undefined;
+}>;
+export type AutonomousLoopConfig = z.infer<typeof AutonomousLoopConfigSchema>;
+/**
+ * Result of a guard gate check
+ */
+export declare const GuardGateResultSchema: z.ZodObject<{
+    /**
+     * Gate identifier
+     */
+    gateId: z.ZodString;
+    /**
+     * Whether the gate passed
+     */
+    passed: z.ZodBoolean;
+    /**
+     * Severity if failed
+     */
+    severity: z.ZodOptional<z.ZodEnum<["error", "warning", "info"]>>;
+    /**
+     * Message explaining result
+     */
+    message: z.ZodOptional<z.ZodString>;
+    /**
+     * Detailed violations if any
+     */
+    violations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodOptional<z.ZodString>;
+        rule: z.ZodOptional<z.ZodString>;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        path?: string | undefined;
+        rule?: string | undefined;
+    }, {
+        message: string;
+        path?: string | undefined;
+        rule?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    gateId: string;
+    passed: boolean;
+    message?: string | undefined;
+    severity?: "info" | "error" | "warning" | undefined;
+    violations?: {
+        message: string;
+        path?: string | undefined;
+        rule?: string | undefined;
+    }[] | undefined;
+}, {
+    gateId: string;
+    passed: boolean;
+    message?: string | undefined;
+    severity?: "info" | "error" | "warning" | undefined;
+    violations?: {
+        message: string;
+        path?: string | undefined;
+        rule?: string | undefined;
+    }[] | undefined;
+}>;
+export type GuardGateResult = z.infer<typeof GuardGateResultSchema>;
+/**
+ * Result of guard policy check
+ */
+export declare const GuardCheckResultSchema: z.ZodObject<{
+    /**
+     * Policy that was checked
+     */
+    policyId: z.ZodString;
+    /**
+     * Whether all gates passed
+     */
+    passed: z.ZodBoolean;
+    /**
+     * Whether execution is blocked
+     */
+    blocked: z.ZodBoolean;
+    /**
+     * Individual gate results
+     */
+    gateResults: z.ZodArray<z.ZodObject<{
+        /**
+         * Gate identifier
+         */
+        gateId: z.ZodString;
+        /**
+         * Whether the gate passed
+         */
+        passed: z.ZodBoolean;
+        /**
+         * Severity if failed
+         */
+        severity: z.ZodOptional<z.ZodEnum<["error", "warning", "info"]>>;
+        /**
+         * Message explaining result
+         */
+        message: z.ZodOptional<z.ZodString>;
+        /**
+         * Detailed violations if any
+         */
+        violations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodOptional<z.ZodString>;
+            rule: z.ZodOptional<z.ZodString>;
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            path?: string | undefined;
+            rule?: string | undefined;
+        }, {
+            message: string;
+            path?: string | undefined;
+            rule?: string | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        gateId: string;
+        passed: boolean;
+        message?: string | undefined;
+        severity?: "info" | "error" | "warning" | undefined;
+        violations?: {
+            message: string;
+            path?: string | undefined;
+            rule?: string | undefined;
+        }[] | undefined;
+    }, {
+        gateId: string;
+        passed: boolean;
+        message?: string | undefined;
+        severity?: "info" | "error" | "warning" | undefined;
+        violations?: {
+            message: string;
+            path?: string | undefined;
+            rule?: string | undefined;
+        }[] | undefined;
+    }>, "many">;
+    /**
+     * Summary message
+     */
+    summary: z.ZodOptional<z.ZodString>;
+    /**
+     * Check timestamp
+     */
+    checkedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    blocked: boolean;
+    policyId: string;
+    checkedAt: string;
+    passed: boolean;
+    gateResults: {
+        gateId: string;
+        passed: boolean;
+        message?: string | undefined;
+        severity?: "info" | "error" | "warning" | undefined;
+        violations?: {
+            message: string;
+            path?: string | undefined;
+            rule?: string | undefined;
+        }[] | undefined;
+    }[];
+    summary?: string | undefined;
+}, {
+    blocked: boolean;
+    policyId: string;
+    checkedAt: string;
+    passed: boolean;
+    gateResults: {
+        gateId: string;
+        passed: boolean;
+        message?: string | undefined;
+        severity?: "info" | "error" | "warning" | undefined;
+        violations?: {
+            message: string;
+            path?: string | undefined;
+            rule?: string | undefined;
+        }[] | undefined;
+    }[];
+    summary?: string | undefined;
+}>;
+export type GuardCheckResult = z.infer<typeof GuardCheckResultSchema>;
+/**
+ * Test execution result
+ */
+export declare const TestResultSchema: z.ZodObject<{
+    /**
+     * Whether all tests passed
+     */
+    passed: z.ZodBoolean;
+    /**
+     * Total test count
+     */
+    totalTests: z.ZodNumber;
+    /**
+     * Passed test count
+     */
+    passedTests: z.ZodNumber;
+    /**
+     * Failed test count
+     */
+    failedTests: z.ZodNumber;
+    /**
+     * Skipped test count
+     */
+    skippedTests: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Error output if failed
+     */
+    errorOutput: z.ZodOptional<z.ZodString>;
+    /**
+     * Test duration in milliseconds
+     */
+    durationMs: z.ZodNumber;
+    /**
+     * Failed test names
+     */
+    failedTestNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    durationMs: number;
+    passed: boolean;
+    totalTests: number;
+    passedTests: number;
+    failedTests: number;
+    skippedTests: number;
+    errorOutput?: string | undefined;
+    failedTestNames?: string[] | undefined;
+}, {
+    durationMs: number;
+    passed: boolean;
+    totalTests: number;
+    passedTests: number;
+    failedTests: number;
+    skippedTests?: number | undefined;
+    errorOutput?: string | undefined;
+    failedTestNames?: string[] | undefined;
+}>;
+export type TestResult = z.infer<typeof TestResultSchema>;
+/**
+ * Iteration record in the loop
+ */
+export declare const LoopIterationSchema: z.ZodObject<{
+    /**
+     * Iteration number (1-indexed)
+     */
+    iteration: z.ZodNumber;
+    /**
+     * Phase that completed
+     */
+    phase: z.ZodEnum<["plan", "write", "test", "fix", "verify", "complete"]>;
+    /**
+     * Whether phase succeeded
+     */
+    success: z.ZodBoolean;
+    /**
+     * Files changed in this iteration
+     */
+    changedFiles: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Test result if test phase
+     */
+    testResult: z.ZodOptional<z.ZodObject<{
+        /**
+         * Whether all tests passed
+         */
+        passed: z.ZodBoolean;
+        /**
+         * Total test count
+         */
+        totalTests: z.ZodNumber;
+        /**
+         * Passed test count
+         */
+        passedTests: z.ZodNumber;
+        /**
+         * Failed test count
+         */
+        failedTests: z.ZodNumber;
+        /**
+         * Skipped test count
+         */
+        skippedTests: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Error output if failed
+         */
+        errorOutput: z.ZodOptional<z.ZodString>;
+        /**
+         * Test duration in milliseconds
+         */
+        durationMs: z.ZodNumber;
+        /**
+         * Failed test names
+         */
+        failedTestNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        durationMs: number;
+        passed: boolean;
+        totalTests: number;
+        passedTests: number;
+        failedTests: number;
+        skippedTests: number;
+        errorOutput?: string | undefined;
+        failedTestNames?: string[] | undefined;
+    }, {
+        durationMs: number;
+        passed: boolean;
+        totalTests: number;
+        passedTests: number;
+        failedTests: number;
+        skippedTests?: number | undefined;
+        errorOutput?: string | undefined;
+        failedTestNames?: string[] | undefined;
+    }>>;
+    /**
+     * Guard result if write phase
+     */
+    guardResult: z.ZodOptional<z.ZodObject<{
+        /**
+         * Policy that was checked
+         */
+        policyId: z.ZodString;
+        /**
+         * Whether all gates passed
+         */
+        passed: z.ZodBoolean;
+        /**
+         * Whether execution is blocked
+         */
+        blocked: z.ZodBoolean;
+        /**
+         * Individual gate results
+         */
+        gateResults: z.ZodArray<z.ZodObject<{
+            /**
+             * Gate identifier
+             */
+            gateId: z.ZodString;
+            /**
+             * Whether the gate passed
+             */
+            passed: z.ZodBoolean;
+            /**
+             * Severity if failed
+             */
+            severity: z.ZodOptional<z.ZodEnum<["error", "warning", "info"]>>;
+            /**
+             * Message explaining result
+             */
+            message: z.ZodOptional<z.ZodString>;
+            /**
+             * Detailed violations if any
+             */
+            violations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodOptional<z.ZodString>;
+                rule: z.ZodOptional<z.ZodString>;
+                message: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+                path?: string | undefined;
+                rule?: string | undefined;
+            }, {
+                message: string;
+                path?: string | undefined;
+                rule?: string | undefined;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            gateId: string;
+            passed: boolean;
+            message?: string | undefined;
+            severity?: "info" | "error" | "warning" | undefined;
+            violations?: {
+                message: string;
+                path?: string | undefined;
+                rule?: string | undefined;
+            }[] | undefined;
+        }, {
+            gateId: string;
+            passed: boolean;
+            message?: string | undefined;
+            severity?: "info" | "error" | "warning" | undefined;
+            violations?: {
+                message: string;
+                path?: string | undefined;
+                rule?: string | undefined;
+            }[] | undefined;
+        }>, "many">;
+        /**
+         * Summary message
+         */
+        summary: z.ZodOptional<z.ZodString>;
+        /**
+         * Check timestamp
+         */
+        checkedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        blocked: boolean;
+        policyId: string;
+        checkedAt: string;
+        passed: boolean;
+        gateResults: {
+            gateId: string;
+            passed: boolean;
+            message?: string | undefined;
+            severity?: "info" | "error" | "warning" | undefined;
+            violations?: {
+                message: string;
+                path?: string | undefined;
+                rule?: string | undefined;
+            }[] | undefined;
+        }[];
+        summary?: string | undefined;
+    }, {
+        blocked: boolean;
+        policyId: string;
+        checkedAt: string;
+        passed: boolean;
+        gateResults: {
+            gateId: string;
+            passed: boolean;
+            message?: string | undefined;
+            severity?: "info" | "error" | "warning" | undefined;
+            violations?: {
+                message: string;
+                path?: string | undefined;
+                rule?: string | undefined;
+            }[] | undefined;
+        }[];
+        summary?: string | undefined;
+    }>>;
+    /**
+     * Fix attempts made
+     */
+    fixAttempts: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Error message if failed
+     */
+    error: z.ZodOptional<z.ZodString>;
+    /**
+     * Duration in milliseconds
+     */
+    durationMs: z.ZodNumber;
+    /**
+     * Start timestamp
+     */
+    startedAt: z.ZodString;
+    /**
+     * End timestamp
+     */
+    completedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    durationMs: number;
+    success: boolean;
+    startedAt: string;
+    iteration: number;
+    phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+    changedFiles: string[];
+    fixAttempts: number;
+    error?: string | undefined;
+    guardResult?: {
+        blocked: boolean;
+        policyId: string;
+        checkedAt: string;
+        passed: boolean;
+        gateResults: {
+            gateId: string;
+            passed: boolean;
+            message?: string | undefined;
+            severity?: "info" | "error" | "warning" | undefined;
+            violations?: {
+                message: string;
+                path?: string | undefined;
+                rule?: string | undefined;
+            }[] | undefined;
+        }[];
+        summary?: string | undefined;
+    } | undefined;
+    completedAt?: string | undefined;
+    testResult?: {
+        durationMs: number;
+        passed: boolean;
+        totalTests: number;
+        passedTests: number;
+        failedTests: number;
+        skippedTests: number;
+        errorOutput?: string | undefined;
+        failedTestNames?: string[] | undefined;
+    } | undefined;
+}, {
+    durationMs: number;
+    success: boolean;
+    startedAt: string;
+    iteration: number;
+    phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+    error?: string | undefined;
+    guardResult?: {
+        blocked: boolean;
+        policyId: string;
+        checkedAt: string;
+        passed: boolean;
+        gateResults: {
+            gateId: string;
+            passed: boolean;
+            message?: string | undefined;
+            severity?: "info" | "error" | "warning" | undefined;
+            violations?: {
+                message: string;
+                path?: string | undefined;
+                rule?: string | undefined;
+            }[] | undefined;
+        }[];
+        summary?: string | undefined;
+    } | undefined;
+    completedAt?: string | undefined;
+    changedFiles?: string[] | undefined;
+    testResult?: {
+        durationMs: number;
+        passed: boolean;
+        totalTests: number;
+        passedTests: number;
+        failedTests: number;
+        skippedTests?: number | undefined;
+        errorOutput?: string | undefined;
+        failedTestNames?: string[] | undefined;
+    } | undefined;
+    fixAttempts?: number | undefined;
+}>;
+export type LoopIteration = z.infer<typeof LoopIterationSchema>;
+/**
+ * State of an autonomous loop
+ *
+ * Invariants:
+ * - INV-ALO-005: Changed files tracked for guard radius checks
+ */
+export declare const AutonomousLoopStateSchema: z.ZodObject<{
+    /**
+     * Unique loop identifier
+     */
+    loopId: z.ZodString;
+    /**
+     * Current phase
+     */
+    phase: z.ZodEnum<["plan", "write", "test", "fix", "verify", "complete"]>;
+    /**
+     * Current iteration number
+     */
+    iteration: z.ZodNumber;
+    /**
+     * Current status
+     */
+    status: z.ZodEnum<["running", "paused", "completed", "failed", "blocked", "cancelled"]>;
+    /**
+     * Task description
+     */
+    task: z.ZodString;
+    /**
+     * Configuration used
+     */
+    config: z.ZodObject<{
+        /**
+         * Maximum iterations through the loop
+         */
+        maxIterations: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Maximum fix attempts per iteration
+         * INV-ALO-003: Bounded fix attempts
+         */
+        maxFixAttempts: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Guard policy to enforce
+         * INV-ALO-001: Guards run after write
+         */
+        guardPolicy: z.ZodOptional<z.ZodString>;
+        /**
+         * Whether tests must pass before verify phase
+         * INV-ALO-002: Test requirement
+         */
+        requireTestPass: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Phases that pause for user review
+         * INV-ALO-004: Breakpoint behavior
+         */
+        breakpoints: z.ZodDefault<z.ZodArray<z.ZodEnum<["plan", "write", "test", "fix", "verify", "complete"]>, "many">>;
+        /**
+         * Test command to run
+         */
+        testCommand: z.ZodDefault<z.ZodString>;
+        /**
+         * Timeout for test execution in milliseconds
+         */
+        testTimeout: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Timeout per phase in milliseconds
+         */
+        phaseTimeout: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Whether to auto-commit successful changes
+         */
+        autoCommit: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Commit message template (uses {{phase}}, {{iteration}})
+         */
+        commitMessageTemplate: z.ZodDefault<z.ZodString>;
+        /**
+         * Working directory for execution
+         */
+        workingDirectory: z.ZodOptional<z.ZodString>;
+        /**
+         * Agent ID to use for code generation
+         */
+        agentId: z.ZodOptional<z.ZodString>;
+        /**
+         * Provider to use for LLM calls
+         */
+        provider: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        maxIterations: number;
+        maxFixAttempts: number;
+        requireTestPass: boolean;
+        breakpoints: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[];
+        testCommand: string;
+        testTimeout: number;
+        phaseTimeout: number;
+        autoCommit: boolean;
+        commitMessageTemplate: string;
+        agentId?: string | undefined;
+        provider?: string | undefined;
+        guardPolicy?: string | undefined;
+        workingDirectory?: string | undefined;
+    }, {
+        agentId?: string | undefined;
+        provider?: string | undefined;
+        maxIterations?: number | undefined;
+        maxFixAttempts?: number | undefined;
+        guardPolicy?: string | undefined;
+        requireTestPass?: boolean | undefined;
+        breakpoints?: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[] | undefined;
+        testCommand?: string | undefined;
+        testTimeout?: number | undefined;
+        phaseTimeout?: number | undefined;
+        autoCommit?: boolean | undefined;
+        commitMessageTemplate?: string | undefined;
+        workingDirectory?: string | undefined;
+    }>;
+    /**
+     * All changed files across iterations
+     * INV-ALO-005: Tracked for guard radius
+     */
+    changedFiles: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Iteration history
+     */
+    iterations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /**
+         * Iteration number (1-indexed)
+         */
+        iteration: z.ZodNumber;
+        /**
+         * Phase that completed
+         */
+        phase: z.ZodEnum<["plan", "write", "test", "fix", "verify", "complete"]>;
+        /**
+         * Whether phase succeeded
+         */
+        success: z.ZodBoolean;
+        /**
+         * Files changed in this iteration
+         */
+        changedFiles: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Test result if test phase
+         */
+        testResult: z.ZodOptional<z.ZodObject<{
+            /**
+             * Whether all tests passed
+             */
+            passed: z.ZodBoolean;
+            /**
+             * Total test count
+             */
+            totalTests: z.ZodNumber;
+            /**
+             * Passed test count
+             */
+            passedTests: z.ZodNumber;
+            /**
+             * Failed test count
+             */
+            failedTests: z.ZodNumber;
+            /**
+             * Skipped test count
+             */
+            skippedTests: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Error output if failed
+             */
+            errorOutput: z.ZodOptional<z.ZodString>;
+            /**
+             * Test duration in milliseconds
+             */
+            durationMs: z.ZodNumber;
+            /**
+             * Failed test names
+             */
+            failedTestNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            durationMs: number;
+            passed: boolean;
+            totalTests: number;
+            passedTests: number;
+            failedTests: number;
+            skippedTests: number;
+            errorOutput?: string | undefined;
+            failedTestNames?: string[] | undefined;
+        }, {
+            durationMs: number;
+            passed: boolean;
+            totalTests: number;
+            passedTests: number;
+            failedTests: number;
+            skippedTests?: number | undefined;
+            errorOutput?: string | undefined;
+            failedTestNames?: string[] | undefined;
+        }>>;
+        /**
+         * Guard result if write phase
+         */
+        guardResult: z.ZodOptional<z.ZodObject<{
+            /**
+             * Policy that was checked
+             */
+            policyId: z.ZodString;
+            /**
+             * Whether all gates passed
+             */
+            passed: z.ZodBoolean;
+            /**
+             * Whether execution is blocked
+             */
+            blocked: z.ZodBoolean;
+            /**
+             * Individual gate results
+             */
+            gateResults: z.ZodArray<z.ZodObject<{
+                /**
+                 * Gate identifier
+                 */
+                gateId: z.ZodString;
+                /**
+                 * Whether the gate passed
+                 */
+                passed: z.ZodBoolean;
+                /**
+                 * Severity if failed
+                 */
+                severity: z.ZodOptional<z.ZodEnum<["error", "warning", "info"]>>;
+                /**
+                 * Message explaining result
+                 */
+                message: z.ZodOptional<z.ZodString>;
+                /**
+                 * Detailed violations if any
+                 */
+                violations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    path: z.ZodOptional<z.ZodString>;
+                    rule: z.ZodOptional<z.ZodString>;
+                    message: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }, {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }>, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }, {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }>, "many">;
+            /**
+             * Summary message
+             */
+            summary: z.ZodOptional<z.ZodString>;
+            /**
+             * Check timestamp
+             */
+            checkedAt: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            blocked: boolean;
+            policyId: string;
+            checkedAt: string;
+            passed: boolean;
+            gateResults: {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }[];
+            summary?: string | undefined;
+        }, {
+            blocked: boolean;
+            policyId: string;
+            checkedAt: string;
+            passed: boolean;
+            gateResults: {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }[];
+            summary?: string | undefined;
+        }>>;
+        /**
+         * Fix attempts made
+         */
+        fixAttempts: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Error message if failed
+         */
+        error: z.ZodOptional<z.ZodString>;
+        /**
+         * Duration in milliseconds
+         */
+        durationMs: z.ZodNumber;
+        /**
+         * Start timestamp
+         */
+        startedAt: z.ZodString;
+        /**
+         * End timestamp
+         */
+        completedAt: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        durationMs: number;
+        success: boolean;
+        startedAt: string;
+        iteration: number;
+        phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+        changedFiles: string[];
+        fixAttempts: number;
+        error?: string | undefined;
+        guardResult?: {
+            blocked: boolean;
+            policyId: string;
+            checkedAt: string;
+            passed: boolean;
+            gateResults: {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }[];
+            summary?: string | undefined;
+        } | undefined;
+        completedAt?: string | undefined;
+        testResult?: {
+            durationMs: number;
+            passed: boolean;
+            totalTests: number;
+            passedTests: number;
+            failedTests: number;
+            skippedTests: number;
+            errorOutput?: string | undefined;
+            failedTestNames?: string[] | undefined;
+        } | undefined;
+    }, {
+        durationMs: number;
+        success: boolean;
+        startedAt: string;
+        iteration: number;
+        phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+        error?: string | undefined;
+        guardResult?: {
+            blocked: boolean;
+            policyId: string;
+            checkedAt: string;
+            passed: boolean;
+            gateResults: {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }[];
+            summary?: string | undefined;
+        } | undefined;
+        completedAt?: string | undefined;
+        changedFiles?: string[] | undefined;
+        testResult?: {
+            durationMs: number;
+            passed: boolean;
+            totalTests: number;
+            passedTests: number;
+            failedTests: number;
+            skippedTests?: number | undefined;
+            errorOutput?: string | undefined;
+            failedTestNames?: string[] | undefined;
+        } | undefined;
+        fixAttempts?: number | undefined;
+    }>, "many">>;
+    /**
+     * Latest guard check result
+     */
+    lastGuardResult: z.ZodOptional<z.ZodObject<{
+        /**
+         * Policy that was checked
+         */
+        policyId: z.ZodString;
+        /**
+         * Whether all gates passed
+         */
+        passed: z.ZodBoolean;
+        /**
+         * Whether execution is blocked
+         */
+        blocked: z.ZodBoolean;
+        /**
+         * Individual gate results
+         */
+        gateResults: z.ZodArray<z.ZodObject<{
+            /**
+             * Gate identifier
+             */
+            gateId: z.ZodString;
+            /**
+             * Whether the gate passed
+             */
+            passed: z.ZodBoolean;
+            /**
+             * Severity if failed
+             */
+            severity: z.ZodOptional<z.ZodEnum<["error", "warning", "info"]>>;
+            /**
+             * Message explaining result
+             */
+            message: z.ZodOptional<z.ZodString>;
+            /**
+             * Detailed violations if any
+             */
+            violations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodOptional<z.ZodString>;
+                rule: z.ZodOptional<z.ZodString>;
+                message: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+                path?: string | undefined;
+                rule?: string | undefined;
+            }, {
+                message: string;
+                path?: string | undefined;
+                rule?: string | undefined;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            gateId: string;
+            passed: boolean;
+            message?: string | undefined;
+            severity?: "info" | "error" | "warning" | undefined;
+            violations?: {
+                message: string;
+                path?: string | undefined;
+                rule?: string | undefined;
+            }[] | undefined;
+        }, {
+            gateId: string;
+            passed: boolean;
+            message?: string | undefined;
+            severity?: "info" | "error" | "warning" | undefined;
+            violations?: {
+                message: string;
+                path?: string | undefined;
+                rule?: string | undefined;
+            }[] | undefined;
+        }>, "many">;
+        /**
+         * Summary message
+         */
+        summary: z.ZodOptional<z.ZodString>;
+        /**
+         * Check timestamp
+         */
+        checkedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        blocked: boolean;
+        policyId: string;
+        checkedAt: string;
+        passed: boolean;
+        gateResults: {
+            gateId: string;
+            passed: boolean;
+            message?: string | undefined;
+            severity?: "info" | "error" | "warning" | undefined;
+            violations?: {
+                message: string;
+                path?: string | undefined;
+                rule?: string | undefined;
+            }[] | undefined;
+        }[];
+        summary?: string | undefined;
+    }, {
+        blocked: boolean;
+        policyId: string;
+        checkedAt: string;
+        passed: boolean;
+        gateResults: {
+            gateId: string;
+            passed: boolean;
+            message?: string | undefined;
+            severity?: "info" | "error" | "warning" | undefined;
+            violations?: {
+                message: string;
+                path?: string | undefined;
+                rule?: string | undefined;
+            }[] | undefined;
+        }[];
+        summary?: string | undefined;
+    }>>;
+    /**
+     * Latest test result
+     */
+    lastTestResult: z.ZodOptional<z.ZodObject<{
+        /**
+         * Whether all tests passed
+         */
+        passed: z.ZodBoolean;
+        /**
+         * Total test count
+         */
+        totalTests: z.ZodNumber;
+        /**
+         * Passed test count
+         */
+        passedTests: z.ZodNumber;
+        /**
+         * Failed test count
+         */
+        failedTests: z.ZodNumber;
+        /**
+         * Skipped test count
+         */
+        skippedTests: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Error output if failed
+         */
+        errorOutput: z.ZodOptional<z.ZodString>;
+        /**
+         * Test duration in milliseconds
+         */
+        durationMs: z.ZodNumber;
+        /**
+         * Failed test names
+         */
+        failedTestNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        durationMs: number;
+        passed: boolean;
+        totalTests: number;
+        passedTests: number;
+        failedTests: number;
+        skippedTests: number;
+        errorOutput?: string | undefined;
+        failedTestNames?: string[] | undefined;
+    }, {
+        durationMs: number;
+        passed: boolean;
+        totalTests: number;
+        passedTests: number;
+        failedTests: number;
+        skippedTests?: number | undefined;
+        errorOutput?: string | undefined;
+        failedTestNames?: string[] | undefined;
+    }>>;
+    /**
+     * Current fix attempts in iteration
+     */
+    currentFixAttempts: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Pause reason if paused
+     */
+    pauseReason: z.ZodOptional<z.ZodString>;
+    /**
+     * Error if failed or blocked
+     */
+    error: z.ZodOptional<z.ZodString>;
+    /**
+     * Session ID for tracking
+     */
+    sessionId: z.ZodOptional<z.ZodString>;
+    /**
+     * Start timestamp
+     */
+    startedAt: z.ZodString;
+    /**
+     * Last update timestamp
+     */
+    updatedAt: z.ZodString;
+    /**
+     * Completion timestamp
+     */
+    completedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "blocked" | "completed" | "failed" | "running" | "cancelled" | "paused";
+    config: {
+        maxIterations: number;
+        maxFixAttempts: number;
+        requireTestPass: boolean;
+        breakpoints: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[];
+        testCommand: string;
+        testTimeout: number;
+        phaseTimeout: number;
+        autoCommit: boolean;
+        commitMessageTemplate: string;
+        agentId?: string | undefined;
+        provider?: string | undefined;
+        guardPolicy?: string | undefined;
+        workingDirectory?: string | undefined;
+    };
+    task: string;
+    updatedAt: string;
+    startedAt: string;
+    iterations: {
+        durationMs: number;
+        success: boolean;
+        startedAt: string;
+        iteration: number;
+        phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+        changedFiles: string[];
+        fixAttempts: number;
+        error?: string | undefined;
+        guardResult?: {
+            blocked: boolean;
+            policyId: string;
+            checkedAt: string;
+            passed: boolean;
+            gateResults: {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }[];
+            summary?: string | undefined;
+        } | undefined;
+        completedAt?: string | undefined;
+        testResult?: {
+            durationMs: number;
+            passed: boolean;
+            totalTests: number;
+            passedTests: number;
+            failedTests: number;
+            skippedTests: number;
+            errorOutput?: string | undefined;
+            failedTestNames?: string[] | undefined;
+        } | undefined;
+    }[];
+    iteration: number;
+    phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+    changedFiles: string[];
+    loopId: string;
+    currentFixAttempts: number;
+    sessionId?: string | undefined;
+    error?: string | undefined;
+    completedAt?: string | undefined;
+    lastGuardResult?: {
+        blocked: boolean;
+        policyId: string;
+        checkedAt: string;
+        passed: boolean;
+        gateResults: {
+            gateId: string;
+            passed: boolean;
+            message?: string | undefined;
+            severity?: "info" | "error" | "warning" | undefined;
+            violations?: {
+                message: string;
+                path?: string | undefined;
+                rule?: string | undefined;
+            }[] | undefined;
+        }[];
+        summary?: string | undefined;
+    } | undefined;
+    lastTestResult?: {
+        durationMs: number;
+        passed: boolean;
+        totalTests: number;
+        passedTests: number;
+        failedTests: number;
+        skippedTests: number;
+        errorOutput?: string | undefined;
+        failedTestNames?: string[] | undefined;
+    } | undefined;
+    pauseReason?: string | undefined;
+}, {
+    status: "blocked" | "completed" | "failed" | "running" | "cancelled" | "paused";
+    config: {
+        agentId?: string | undefined;
+        provider?: string | undefined;
+        maxIterations?: number | undefined;
+        maxFixAttempts?: number | undefined;
+        guardPolicy?: string | undefined;
+        requireTestPass?: boolean | undefined;
+        breakpoints?: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[] | undefined;
+        testCommand?: string | undefined;
+        testTimeout?: number | undefined;
+        phaseTimeout?: number | undefined;
+        autoCommit?: boolean | undefined;
+        commitMessageTemplate?: string | undefined;
+        workingDirectory?: string | undefined;
+    };
+    task: string;
+    updatedAt: string;
+    startedAt: string;
+    iteration: number;
+    phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+    loopId: string;
+    sessionId?: string | undefined;
+    error?: string | undefined;
+    completedAt?: string | undefined;
+    iterations?: {
+        durationMs: number;
+        success: boolean;
+        startedAt: string;
+        iteration: number;
+        phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+        error?: string | undefined;
+        guardResult?: {
+            blocked: boolean;
+            policyId: string;
+            checkedAt: string;
+            passed: boolean;
+            gateResults: {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }[];
+            summary?: string | undefined;
+        } | undefined;
+        completedAt?: string | undefined;
+        changedFiles?: string[] | undefined;
+        testResult?: {
+            durationMs: number;
+            passed: boolean;
+            totalTests: number;
+            passedTests: number;
+            failedTests: number;
+            skippedTests?: number | undefined;
+            errorOutput?: string | undefined;
+            failedTestNames?: string[] | undefined;
+        } | undefined;
+        fixAttempts?: number | undefined;
+    }[] | undefined;
+    changedFiles?: string[] | undefined;
+    lastGuardResult?: {
+        blocked: boolean;
+        policyId: string;
+        checkedAt: string;
+        passed: boolean;
+        gateResults: {
+            gateId: string;
+            passed: boolean;
+            message?: string | undefined;
+            severity?: "info" | "error" | "warning" | undefined;
+            violations?: {
+                message: string;
+                path?: string | undefined;
+                rule?: string | undefined;
+            }[] | undefined;
+        }[];
+        summary?: string | undefined;
+    } | undefined;
+    lastTestResult?: {
+        durationMs: number;
+        passed: boolean;
+        totalTests: number;
+        passedTests: number;
+        failedTests: number;
+        skippedTests?: number | undefined;
+        errorOutput?: string | undefined;
+        failedTestNames?: string[] | undefined;
+    } | undefined;
+    currentFixAttempts?: number | undefined;
+    pauseReason?: string | undefined;
+}>;
+export type AutonomousLoopState = z.infer<typeof AutonomousLoopStateSchema>;
+/**
+ * Request to start an autonomous loop
+ */
+export declare const StartLoopRequestSchema: z.ZodObject<{
+    /**
+     * Task description
+     */
+    task: z.ZodString;
+    /**
+     * Configuration overrides
+     */
+    config: z.ZodOptional<z.ZodObject<{
+        maxIterations: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        maxFixAttempts: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        guardPolicy: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        requireTestPass: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        breakpoints: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodEnum<["plan", "write", "test", "fix", "verify", "complete"]>, "many">>>;
+        testCommand: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        testTimeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        phaseTimeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        autoCommit: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        commitMessageTemplate: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        workingDirectory: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        agentId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        provider: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        agentId?: string | undefined;
+        provider?: string | undefined;
+        maxIterations?: number | undefined;
+        maxFixAttempts?: number | undefined;
+        guardPolicy?: string | undefined;
+        requireTestPass?: boolean | undefined;
+        breakpoints?: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[] | undefined;
+        testCommand?: string | undefined;
+        testTimeout?: number | undefined;
+        phaseTimeout?: number | undefined;
+        autoCommit?: boolean | undefined;
+        commitMessageTemplate?: string | undefined;
+        workingDirectory?: string | undefined;
+    }, {
+        agentId?: string | undefined;
+        provider?: string | undefined;
+        maxIterations?: number | undefined;
+        maxFixAttempts?: number | undefined;
+        guardPolicy?: string | undefined;
+        requireTestPass?: boolean | undefined;
+        breakpoints?: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[] | undefined;
+        testCommand?: string | undefined;
+        testTimeout?: number | undefined;
+        phaseTimeout?: number | undefined;
+        autoCommit?: boolean | undefined;
+        commitMessageTemplate?: string | undefined;
+        workingDirectory?: string | undefined;
+    }>>;
+    /**
+     * Session ID for tracking
+     */
+    sessionId: z.ZodOptional<z.ZodString>;
+    /**
+     * Initial context/files to work with
+     */
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    task: string;
+    context?: Record<string, unknown> | undefined;
+    config?: {
+        agentId?: string | undefined;
+        provider?: string | undefined;
+        maxIterations?: number | undefined;
+        maxFixAttempts?: number | undefined;
+        guardPolicy?: string | undefined;
+        requireTestPass?: boolean | undefined;
+        breakpoints?: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[] | undefined;
+        testCommand?: string | undefined;
+        testTimeout?: number | undefined;
+        phaseTimeout?: number | undefined;
+        autoCommit?: boolean | undefined;
+        commitMessageTemplate?: string | undefined;
+        workingDirectory?: string | undefined;
+    } | undefined;
+    sessionId?: string | undefined;
+}, {
+    task: string;
+    context?: Record<string, unknown> | undefined;
+    config?: {
+        agentId?: string | undefined;
+        provider?: string | undefined;
+        maxIterations?: number | undefined;
+        maxFixAttempts?: number | undefined;
+        guardPolicy?: string | undefined;
+        requireTestPass?: boolean | undefined;
+        breakpoints?: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[] | undefined;
+        testCommand?: string | undefined;
+        testTimeout?: number | undefined;
+        phaseTimeout?: number | undefined;
+        autoCommit?: boolean | undefined;
+        commitMessageTemplate?: string | undefined;
+        workingDirectory?: string | undefined;
+    } | undefined;
+    sessionId?: string | undefined;
+}>;
+export type StartLoopRequest = z.infer<typeof StartLoopRequestSchema>;
+/**
+ * Response from starting a loop
+ */
+export declare const StartLoopResponseSchema: z.ZodObject<{
+    /**
+     * Loop ID
+     */
+    loopId: z.ZodString;
+    /**
+     * Initial state
+     */
+    state: z.ZodObject<{
+        /**
+         * Unique loop identifier
+         */
+        loopId: z.ZodString;
+        /**
+         * Current phase
+         */
+        phase: z.ZodEnum<["plan", "write", "test", "fix", "verify", "complete"]>;
+        /**
+         * Current iteration number
+         */
+        iteration: z.ZodNumber;
+        /**
+         * Current status
+         */
+        status: z.ZodEnum<["running", "paused", "completed", "failed", "blocked", "cancelled"]>;
+        /**
+         * Task description
+         */
+        task: z.ZodString;
+        /**
+         * Configuration used
+         */
+        config: z.ZodObject<{
+            /**
+             * Maximum iterations through the loop
+             */
+            maxIterations: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Maximum fix attempts per iteration
+             * INV-ALO-003: Bounded fix attempts
+             */
+            maxFixAttempts: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Guard policy to enforce
+             * INV-ALO-001: Guards run after write
+             */
+            guardPolicy: z.ZodOptional<z.ZodString>;
+            /**
+             * Whether tests must pass before verify phase
+             * INV-ALO-002: Test requirement
+             */
+            requireTestPass: z.ZodDefault<z.ZodBoolean>;
+            /**
+             * Phases that pause for user review
+             * INV-ALO-004: Breakpoint behavior
+             */
+            breakpoints: z.ZodDefault<z.ZodArray<z.ZodEnum<["plan", "write", "test", "fix", "verify", "complete"]>, "many">>;
+            /**
+             * Test command to run
+             */
+            testCommand: z.ZodDefault<z.ZodString>;
+            /**
+             * Timeout for test execution in milliseconds
+             */
+            testTimeout: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Timeout per phase in milliseconds
+             */
+            phaseTimeout: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Whether to auto-commit successful changes
+             */
+            autoCommit: z.ZodDefault<z.ZodBoolean>;
+            /**
+             * Commit message template (uses {{phase}}, {{iteration}})
+             */
+            commitMessageTemplate: z.ZodDefault<z.ZodString>;
+            /**
+             * Working directory for execution
+             */
+            workingDirectory: z.ZodOptional<z.ZodString>;
+            /**
+             * Agent ID to use for code generation
+             */
+            agentId: z.ZodOptional<z.ZodString>;
+            /**
+             * Provider to use for LLM calls
+             */
+            provider: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            maxIterations: number;
+            maxFixAttempts: number;
+            requireTestPass: boolean;
+            breakpoints: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[];
+            testCommand: string;
+            testTimeout: number;
+            phaseTimeout: number;
+            autoCommit: boolean;
+            commitMessageTemplate: string;
+            agentId?: string | undefined;
+            provider?: string | undefined;
+            guardPolicy?: string | undefined;
+            workingDirectory?: string | undefined;
+        }, {
+            agentId?: string | undefined;
+            provider?: string | undefined;
+            maxIterations?: number | undefined;
+            maxFixAttempts?: number | undefined;
+            guardPolicy?: string | undefined;
+            requireTestPass?: boolean | undefined;
+            breakpoints?: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[] | undefined;
+            testCommand?: string | undefined;
+            testTimeout?: number | undefined;
+            phaseTimeout?: number | undefined;
+            autoCommit?: boolean | undefined;
+            commitMessageTemplate?: string | undefined;
+            workingDirectory?: string | undefined;
+        }>;
+        /**
+         * All changed files across iterations
+         * INV-ALO-005: Tracked for guard radius
+         */
+        changedFiles: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Iteration history
+         */
+        iterations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /**
+             * Iteration number (1-indexed)
+             */
+            iteration: z.ZodNumber;
+            /**
+             * Phase that completed
+             */
+            phase: z.ZodEnum<["plan", "write", "test", "fix", "verify", "complete"]>;
+            /**
+             * Whether phase succeeded
+             */
+            success: z.ZodBoolean;
+            /**
+             * Files changed in this iteration
+             */
+            changedFiles: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            /**
+             * Test result if test phase
+             */
+            testResult: z.ZodOptional<z.ZodObject<{
+                /**
+                 * Whether all tests passed
+                 */
+                passed: z.ZodBoolean;
+                /**
+                 * Total test count
+                 */
+                totalTests: z.ZodNumber;
+                /**
+                 * Passed test count
+                 */
+                passedTests: z.ZodNumber;
+                /**
+                 * Failed test count
+                 */
+                failedTests: z.ZodNumber;
+                /**
+                 * Skipped test count
+                 */
+                skippedTests: z.ZodDefault<z.ZodNumber>;
+                /**
+                 * Error output if failed
+                 */
+                errorOutput: z.ZodOptional<z.ZodString>;
+                /**
+                 * Test duration in milliseconds
+                 */
+                durationMs: z.ZodNumber;
+                /**
+                 * Failed test names
+                 */
+                failedTestNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                durationMs: number;
+                passed: boolean;
+                totalTests: number;
+                passedTests: number;
+                failedTests: number;
+                skippedTests: number;
+                errorOutput?: string | undefined;
+                failedTestNames?: string[] | undefined;
+            }, {
+                durationMs: number;
+                passed: boolean;
+                totalTests: number;
+                passedTests: number;
+                failedTests: number;
+                skippedTests?: number | undefined;
+                errorOutput?: string | undefined;
+                failedTestNames?: string[] | undefined;
+            }>>;
+            /**
+             * Guard result if write phase
+             */
+            guardResult: z.ZodOptional<z.ZodObject<{
+                /**
+                 * Policy that was checked
+                 */
+                policyId: z.ZodString;
+                /**
+                 * Whether all gates passed
+                 */
+                passed: z.ZodBoolean;
+                /**
+                 * Whether execution is blocked
+                 */
+                blocked: z.ZodBoolean;
+                /**
+                 * Individual gate results
+                 */
+                gateResults: z.ZodArray<z.ZodObject<{
+                    /**
+                     * Gate identifier
+                     */
+                    gateId: z.ZodString;
+                    /**
+                     * Whether the gate passed
+                     */
+                    passed: z.ZodBoolean;
+                    /**
+                     * Severity if failed
+                     */
+                    severity: z.ZodOptional<z.ZodEnum<["error", "warning", "info"]>>;
+                    /**
+                     * Message explaining result
+                     */
+                    message: z.ZodOptional<z.ZodString>;
+                    /**
+                     * Detailed violations if any
+                     */
+                    violations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        path: z.ZodOptional<z.ZodString>;
+                        rule: z.ZodOptional<z.ZodString>;
+                        message: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }, {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }>, "many">>;
+                }, "strip", z.ZodTypeAny, {
+                    gateId: string;
+                    passed: boolean;
+                    message?: string | undefined;
+                    severity?: "info" | "error" | "warning" | undefined;
+                    violations?: {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }[] | undefined;
+                }, {
+                    gateId: string;
+                    passed: boolean;
+                    message?: string | undefined;
+                    severity?: "info" | "error" | "warning" | undefined;
+                    violations?: {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }[] | undefined;
+                }>, "many">;
+                /**
+                 * Summary message
+                 */
+                summary: z.ZodOptional<z.ZodString>;
+                /**
+                 * Check timestamp
+                 */
+                checkedAt: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                blocked: boolean;
+                policyId: string;
+                checkedAt: string;
+                passed: boolean;
+                gateResults: {
+                    gateId: string;
+                    passed: boolean;
+                    message?: string | undefined;
+                    severity?: "info" | "error" | "warning" | undefined;
+                    violations?: {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }[] | undefined;
+                }[];
+                summary?: string | undefined;
+            }, {
+                blocked: boolean;
+                policyId: string;
+                checkedAt: string;
+                passed: boolean;
+                gateResults: {
+                    gateId: string;
+                    passed: boolean;
+                    message?: string | undefined;
+                    severity?: "info" | "error" | "warning" | undefined;
+                    violations?: {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }[] | undefined;
+                }[];
+                summary?: string | undefined;
+            }>>;
+            /**
+             * Fix attempts made
+             */
+            fixAttempts: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Error message if failed
+             */
+            error: z.ZodOptional<z.ZodString>;
+            /**
+             * Duration in milliseconds
+             */
+            durationMs: z.ZodNumber;
+            /**
+             * Start timestamp
+             */
+            startedAt: z.ZodString;
+            /**
+             * End timestamp
+             */
+            completedAt: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            durationMs: number;
+            success: boolean;
+            startedAt: string;
+            iteration: number;
+            phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+            changedFiles: string[];
+            fixAttempts: number;
+            error?: string | undefined;
+            guardResult?: {
+                blocked: boolean;
+                policyId: string;
+                checkedAt: string;
+                passed: boolean;
+                gateResults: {
+                    gateId: string;
+                    passed: boolean;
+                    message?: string | undefined;
+                    severity?: "info" | "error" | "warning" | undefined;
+                    violations?: {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }[] | undefined;
+                }[];
+                summary?: string | undefined;
+            } | undefined;
+            completedAt?: string | undefined;
+            testResult?: {
+                durationMs: number;
+                passed: boolean;
+                totalTests: number;
+                passedTests: number;
+                failedTests: number;
+                skippedTests: number;
+                errorOutput?: string | undefined;
+                failedTestNames?: string[] | undefined;
+            } | undefined;
+        }, {
+            durationMs: number;
+            success: boolean;
+            startedAt: string;
+            iteration: number;
+            phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+            error?: string | undefined;
+            guardResult?: {
+                blocked: boolean;
+                policyId: string;
+                checkedAt: string;
+                passed: boolean;
+                gateResults: {
+                    gateId: string;
+                    passed: boolean;
+                    message?: string | undefined;
+                    severity?: "info" | "error" | "warning" | undefined;
+                    violations?: {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }[] | undefined;
+                }[];
+                summary?: string | undefined;
+            } | undefined;
+            completedAt?: string | undefined;
+            changedFiles?: string[] | undefined;
+            testResult?: {
+                durationMs: number;
+                passed: boolean;
+                totalTests: number;
+                passedTests: number;
+                failedTests: number;
+                skippedTests?: number | undefined;
+                errorOutput?: string | undefined;
+                failedTestNames?: string[] | undefined;
+            } | undefined;
+            fixAttempts?: number | undefined;
+        }>, "many">>;
+        /**
+         * Latest guard check result
+         */
+        lastGuardResult: z.ZodOptional<z.ZodObject<{
+            /**
+             * Policy that was checked
+             */
+            policyId: z.ZodString;
+            /**
+             * Whether all gates passed
+             */
+            passed: z.ZodBoolean;
+            /**
+             * Whether execution is blocked
+             */
+            blocked: z.ZodBoolean;
+            /**
+             * Individual gate results
+             */
+            gateResults: z.ZodArray<z.ZodObject<{
+                /**
+                 * Gate identifier
+                 */
+                gateId: z.ZodString;
+                /**
+                 * Whether the gate passed
+                 */
+                passed: z.ZodBoolean;
+                /**
+                 * Severity if failed
+                 */
+                severity: z.ZodOptional<z.ZodEnum<["error", "warning", "info"]>>;
+                /**
+                 * Message explaining result
+                 */
+                message: z.ZodOptional<z.ZodString>;
+                /**
+                 * Detailed violations if any
+                 */
+                violations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    path: z.ZodOptional<z.ZodString>;
+                    rule: z.ZodOptional<z.ZodString>;
+                    message: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }, {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }>, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }, {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }>, "many">;
+            /**
+             * Summary message
+             */
+            summary: z.ZodOptional<z.ZodString>;
+            /**
+             * Check timestamp
+             */
+            checkedAt: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            blocked: boolean;
+            policyId: string;
+            checkedAt: string;
+            passed: boolean;
+            gateResults: {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }[];
+            summary?: string | undefined;
+        }, {
+            blocked: boolean;
+            policyId: string;
+            checkedAt: string;
+            passed: boolean;
+            gateResults: {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }[];
+            summary?: string | undefined;
+        }>>;
+        /**
+         * Latest test result
+         */
+        lastTestResult: z.ZodOptional<z.ZodObject<{
+            /**
+             * Whether all tests passed
+             */
+            passed: z.ZodBoolean;
+            /**
+             * Total test count
+             */
+            totalTests: z.ZodNumber;
+            /**
+             * Passed test count
+             */
+            passedTests: z.ZodNumber;
+            /**
+             * Failed test count
+             */
+            failedTests: z.ZodNumber;
+            /**
+             * Skipped test count
+             */
+            skippedTests: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Error output if failed
+             */
+            errorOutput: z.ZodOptional<z.ZodString>;
+            /**
+             * Test duration in milliseconds
+             */
+            durationMs: z.ZodNumber;
+            /**
+             * Failed test names
+             */
+            failedTestNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            durationMs: number;
+            passed: boolean;
+            totalTests: number;
+            passedTests: number;
+            failedTests: number;
+            skippedTests: number;
+            errorOutput?: string | undefined;
+            failedTestNames?: string[] | undefined;
+        }, {
+            durationMs: number;
+            passed: boolean;
+            totalTests: number;
+            passedTests: number;
+            failedTests: number;
+            skippedTests?: number | undefined;
+            errorOutput?: string | undefined;
+            failedTestNames?: string[] | undefined;
+        }>>;
+        /**
+         * Current fix attempts in iteration
+         */
+        currentFixAttempts: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Pause reason if paused
+         */
+        pauseReason: z.ZodOptional<z.ZodString>;
+        /**
+         * Error if failed or blocked
+         */
+        error: z.ZodOptional<z.ZodString>;
+        /**
+         * Session ID for tracking
+         */
+        sessionId: z.ZodOptional<z.ZodString>;
+        /**
+         * Start timestamp
+         */
+        startedAt: z.ZodString;
+        /**
+         * Last update timestamp
+         */
+        updatedAt: z.ZodString;
+        /**
+         * Completion timestamp
+         */
+        completedAt: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        status: "blocked" | "completed" | "failed" | "running" | "cancelled" | "paused";
+        config: {
+            maxIterations: number;
+            maxFixAttempts: number;
+            requireTestPass: boolean;
+            breakpoints: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[];
+            testCommand: string;
+            testTimeout: number;
+            phaseTimeout: number;
+            autoCommit: boolean;
+            commitMessageTemplate: string;
+            agentId?: string | undefined;
+            provider?: string | undefined;
+            guardPolicy?: string | undefined;
+            workingDirectory?: string | undefined;
+        };
+        task: string;
+        updatedAt: string;
+        startedAt: string;
+        iterations: {
+            durationMs: number;
+            success: boolean;
+            startedAt: string;
+            iteration: number;
+            phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+            changedFiles: string[];
+            fixAttempts: number;
+            error?: string | undefined;
+            guardResult?: {
+                blocked: boolean;
+                policyId: string;
+                checkedAt: string;
+                passed: boolean;
+                gateResults: {
+                    gateId: string;
+                    passed: boolean;
+                    message?: string | undefined;
+                    severity?: "info" | "error" | "warning" | undefined;
+                    violations?: {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }[] | undefined;
+                }[];
+                summary?: string | undefined;
+            } | undefined;
+            completedAt?: string | undefined;
+            testResult?: {
+                durationMs: number;
+                passed: boolean;
+                totalTests: number;
+                passedTests: number;
+                failedTests: number;
+                skippedTests: number;
+                errorOutput?: string | undefined;
+                failedTestNames?: string[] | undefined;
+            } | undefined;
+        }[];
+        iteration: number;
+        phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+        changedFiles: string[];
+        loopId: string;
+        currentFixAttempts: number;
+        sessionId?: string | undefined;
+        error?: string | undefined;
+        completedAt?: string | undefined;
+        lastGuardResult?: {
+            blocked: boolean;
+            policyId: string;
+            checkedAt: string;
+            passed: boolean;
+            gateResults: {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }[];
+            summary?: string | undefined;
+        } | undefined;
+        lastTestResult?: {
+            durationMs: number;
+            passed: boolean;
+            totalTests: number;
+            passedTests: number;
+            failedTests: number;
+            skippedTests: number;
+            errorOutput?: string | undefined;
+            failedTestNames?: string[] | undefined;
+        } | undefined;
+        pauseReason?: string | undefined;
+    }, {
+        status: "blocked" | "completed" | "failed" | "running" | "cancelled" | "paused";
+        config: {
+            agentId?: string | undefined;
+            provider?: string | undefined;
+            maxIterations?: number | undefined;
+            maxFixAttempts?: number | undefined;
+            guardPolicy?: string | undefined;
+            requireTestPass?: boolean | undefined;
+            breakpoints?: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[] | undefined;
+            testCommand?: string | undefined;
+            testTimeout?: number | undefined;
+            phaseTimeout?: number | undefined;
+            autoCommit?: boolean | undefined;
+            commitMessageTemplate?: string | undefined;
+            workingDirectory?: string | undefined;
+        };
+        task: string;
+        updatedAt: string;
+        startedAt: string;
+        iteration: number;
+        phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+        loopId: string;
+        sessionId?: string | undefined;
+        error?: string | undefined;
+        completedAt?: string | undefined;
+        iterations?: {
+            durationMs: number;
+            success: boolean;
+            startedAt: string;
+            iteration: number;
+            phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+            error?: string | undefined;
+            guardResult?: {
+                blocked: boolean;
+                policyId: string;
+                checkedAt: string;
+                passed: boolean;
+                gateResults: {
+                    gateId: string;
+                    passed: boolean;
+                    message?: string | undefined;
+                    severity?: "info" | "error" | "warning" | undefined;
+                    violations?: {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }[] | undefined;
+                }[];
+                summary?: string | undefined;
+            } | undefined;
+            completedAt?: string | undefined;
+            changedFiles?: string[] | undefined;
+            testResult?: {
+                durationMs: number;
+                passed: boolean;
+                totalTests: number;
+                passedTests: number;
+                failedTests: number;
+                skippedTests?: number | undefined;
+                errorOutput?: string | undefined;
+                failedTestNames?: string[] | undefined;
+            } | undefined;
+            fixAttempts?: number | undefined;
+        }[] | undefined;
+        changedFiles?: string[] | undefined;
+        lastGuardResult?: {
+            blocked: boolean;
+            policyId: string;
+            checkedAt: string;
+            passed: boolean;
+            gateResults: {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }[];
+            summary?: string | undefined;
+        } | undefined;
+        lastTestResult?: {
+            durationMs: number;
+            passed: boolean;
+            totalTests: number;
+            passedTests: number;
+            failedTests: number;
+            skippedTests?: number | undefined;
+            errorOutput?: string | undefined;
+            failedTestNames?: string[] | undefined;
+        } | undefined;
+        currentFixAttempts?: number | undefined;
+        pauseReason?: string | undefined;
+    }>;
+    /**
+     * Whether loop started successfully
+     */
+    started: z.ZodBoolean;
+    /**
+     * Message
+     */
+    message: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    started: boolean;
+    state: {
+        status: "blocked" | "completed" | "failed" | "running" | "cancelled" | "paused";
+        config: {
+            maxIterations: number;
+            maxFixAttempts: number;
+            requireTestPass: boolean;
+            breakpoints: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[];
+            testCommand: string;
+            testTimeout: number;
+            phaseTimeout: number;
+            autoCommit: boolean;
+            commitMessageTemplate: string;
+            agentId?: string | undefined;
+            provider?: string | undefined;
+            guardPolicy?: string | undefined;
+            workingDirectory?: string | undefined;
+        };
+        task: string;
+        updatedAt: string;
+        startedAt: string;
+        iterations: {
+            durationMs: number;
+            success: boolean;
+            startedAt: string;
+            iteration: number;
+            phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+            changedFiles: string[];
+            fixAttempts: number;
+            error?: string | undefined;
+            guardResult?: {
+                blocked: boolean;
+                policyId: string;
+                checkedAt: string;
+                passed: boolean;
+                gateResults: {
+                    gateId: string;
+                    passed: boolean;
+                    message?: string | undefined;
+                    severity?: "info" | "error" | "warning" | undefined;
+                    violations?: {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }[] | undefined;
+                }[];
+                summary?: string | undefined;
+            } | undefined;
+            completedAt?: string | undefined;
+            testResult?: {
+                durationMs: number;
+                passed: boolean;
+                totalTests: number;
+                passedTests: number;
+                failedTests: number;
+                skippedTests: number;
+                errorOutput?: string | undefined;
+                failedTestNames?: string[] | undefined;
+            } | undefined;
+        }[];
+        iteration: number;
+        phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+        changedFiles: string[];
+        loopId: string;
+        currentFixAttempts: number;
+        sessionId?: string | undefined;
+        error?: string | undefined;
+        completedAt?: string | undefined;
+        lastGuardResult?: {
+            blocked: boolean;
+            policyId: string;
+            checkedAt: string;
+            passed: boolean;
+            gateResults: {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }[];
+            summary?: string | undefined;
+        } | undefined;
+        lastTestResult?: {
+            durationMs: number;
+            passed: boolean;
+            totalTests: number;
+            passedTests: number;
+            failedTests: number;
+            skippedTests: number;
+            errorOutput?: string | undefined;
+            failedTestNames?: string[] | undefined;
+        } | undefined;
+        pauseReason?: string | undefined;
+    };
+    loopId: string;
+    message?: string | undefined;
+}, {
+    started: boolean;
+    state: {
+        status: "blocked" | "completed" | "failed" | "running" | "cancelled" | "paused";
+        config: {
+            agentId?: string | undefined;
+            provider?: string | undefined;
+            maxIterations?: number | undefined;
+            maxFixAttempts?: number | undefined;
+            guardPolicy?: string | undefined;
+            requireTestPass?: boolean | undefined;
+            breakpoints?: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[] | undefined;
+            testCommand?: string | undefined;
+            testTimeout?: number | undefined;
+            phaseTimeout?: number | undefined;
+            autoCommit?: boolean | undefined;
+            commitMessageTemplate?: string | undefined;
+            workingDirectory?: string | undefined;
+        };
+        task: string;
+        updatedAt: string;
+        startedAt: string;
+        iteration: number;
+        phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+        loopId: string;
+        sessionId?: string | undefined;
+        error?: string | undefined;
+        completedAt?: string | undefined;
+        iterations?: {
+            durationMs: number;
+            success: boolean;
+            startedAt: string;
+            iteration: number;
+            phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+            error?: string | undefined;
+            guardResult?: {
+                blocked: boolean;
+                policyId: string;
+                checkedAt: string;
+                passed: boolean;
+                gateResults: {
+                    gateId: string;
+                    passed: boolean;
+                    message?: string | undefined;
+                    severity?: "info" | "error" | "warning" | undefined;
+                    violations?: {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }[] | undefined;
+                }[];
+                summary?: string | undefined;
+            } | undefined;
+            completedAt?: string | undefined;
+            changedFiles?: string[] | undefined;
+            testResult?: {
+                durationMs: number;
+                passed: boolean;
+                totalTests: number;
+                passedTests: number;
+                failedTests: number;
+                skippedTests?: number | undefined;
+                errorOutput?: string | undefined;
+                failedTestNames?: string[] | undefined;
+            } | undefined;
+            fixAttempts?: number | undefined;
+        }[] | undefined;
+        changedFiles?: string[] | undefined;
+        lastGuardResult?: {
+            blocked: boolean;
+            policyId: string;
+            checkedAt: string;
+            passed: boolean;
+            gateResults: {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }[];
+            summary?: string | undefined;
+        } | undefined;
+        lastTestResult?: {
+            durationMs: number;
+            passed: boolean;
+            totalTests: number;
+            passedTests: number;
+            failedTests: number;
+            skippedTests?: number | undefined;
+            errorOutput?: string | undefined;
+            failedTestNames?: string[] | undefined;
+        } | undefined;
+        currentFixAttempts?: number | undefined;
+        pauseReason?: string | undefined;
+    };
+    loopId: string;
+    message?: string | undefined;
+}>;
+export type StartLoopResponse = z.infer<typeof StartLoopResponseSchema>;
+/**
+ * Request to continue a paused loop
+ */
+export declare const ContinueLoopRequestSchema: z.ZodObject<{
+    /**
+     * Loop ID to continue
+     */
+    loopId: z.ZodString;
+    /**
+     * Whether to skip to next phase
+     */
+    skipToPhase: z.ZodOptional<z.ZodEnum<["plan", "write", "test", "fix", "verify", "complete"]>>;
+    /**
+     * User feedback/instructions
+     */
+    feedback: z.ZodOptional<z.ZodString>;
+    /**
+     * Override config for remaining iterations
+     */
+    configOverrides: z.ZodOptional<z.ZodObject<{
+        maxIterations: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        maxFixAttempts: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        guardPolicy: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        requireTestPass: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        breakpoints: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodEnum<["plan", "write", "test", "fix", "verify", "complete"]>, "many">>>;
+        testCommand: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        testTimeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        phaseTimeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        autoCommit: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        commitMessageTemplate: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        workingDirectory: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        agentId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        provider: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        agentId?: string | undefined;
+        provider?: string | undefined;
+        maxIterations?: number | undefined;
+        maxFixAttempts?: number | undefined;
+        guardPolicy?: string | undefined;
+        requireTestPass?: boolean | undefined;
+        breakpoints?: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[] | undefined;
+        testCommand?: string | undefined;
+        testTimeout?: number | undefined;
+        phaseTimeout?: number | undefined;
+        autoCommit?: boolean | undefined;
+        commitMessageTemplate?: string | undefined;
+        workingDirectory?: string | undefined;
+    }, {
+        agentId?: string | undefined;
+        provider?: string | undefined;
+        maxIterations?: number | undefined;
+        maxFixAttempts?: number | undefined;
+        guardPolicy?: string | undefined;
+        requireTestPass?: boolean | undefined;
+        breakpoints?: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[] | undefined;
+        testCommand?: string | undefined;
+        testTimeout?: number | undefined;
+        phaseTimeout?: number | undefined;
+        autoCommit?: boolean | undefined;
+        commitMessageTemplate?: string | undefined;
+        workingDirectory?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    loopId: string;
+    skipToPhase?: "write" | "complete" | "plan" | "test" | "fix" | "verify" | undefined;
+    feedback?: string | undefined;
+    configOverrides?: {
+        agentId?: string | undefined;
+        provider?: string | undefined;
+        maxIterations?: number | undefined;
+        maxFixAttempts?: number | undefined;
+        guardPolicy?: string | undefined;
+        requireTestPass?: boolean | undefined;
+        breakpoints?: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[] | undefined;
+        testCommand?: string | undefined;
+        testTimeout?: number | undefined;
+        phaseTimeout?: number | undefined;
+        autoCommit?: boolean | undefined;
+        commitMessageTemplate?: string | undefined;
+        workingDirectory?: string | undefined;
+    } | undefined;
+}, {
+    loopId: string;
+    skipToPhase?: "write" | "complete" | "plan" | "test" | "fix" | "verify" | undefined;
+    feedback?: string | undefined;
+    configOverrides?: {
+        agentId?: string | undefined;
+        provider?: string | undefined;
+        maxIterations?: number | undefined;
+        maxFixAttempts?: number | undefined;
+        guardPolicy?: string | undefined;
+        requireTestPass?: boolean | undefined;
+        breakpoints?: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[] | undefined;
+        testCommand?: string | undefined;
+        testTimeout?: number | undefined;
+        phaseTimeout?: number | undefined;
+        autoCommit?: boolean | undefined;
+        commitMessageTemplate?: string | undefined;
+        workingDirectory?: string | undefined;
+    } | undefined;
+}>;
+export type ContinueLoopRequest = z.infer<typeof ContinueLoopRequestSchema>;
+/**
+ * Request to abort a loop
+ */
+export declare const AbortLoopRequestSchema: z.ZodObject<{
+    /**
+     * Loop ID to abort
+     */
+    loopId: z.ZodString;
+    /**
+     * Reason for aborting
+     */
+    reason: z.ZodOptional<z.ZodString>;
+    /**
+     * Whether to keep changes made
+     */
+    keepChanges: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    loopId: string;
+    keepChanges: boolean;
+    reason?: string | undefined;
+}, {
+    loopId: string;
+    reason?: string | undefined;
+    keepChanges?: boolean | undefined;
+}>;
+export type AbortLoopRequest = z.infer<typeof AbortLoopRequestSchema>;
+/**
+ * Loop status response
+ */
+export declare const LoopStatusResponseSchema: z.ZodObject<{
+    /**
+     * Current state
+     */
+    state: z.ZodObject<{
+        /**
+         * Unique loop identifier
+         */
+        loopId: z.ZodString;
+        /**
+         * Current phase
+         */
+        phase: z.ZodEnum<["plan", "write", "test", "fix", "verify", "complete"]>;
+        /**
+         * Current iteration number
+         */
+        iteration: z.ZodNumber;
+        /**
+         * Current status
+         */
+        status: z.ZodEnum<["running", "paused", "completed", "failed", "blocked", "cancelled"]>;
+        /**
+         * Task description
+         */
+        task: z.ZodString;
+        /**
+         * Configuration used
+         */
+        config: z.ZodObject<{
+            /**
+             * Maximum iterations through the loop
+             */
+            maxIterations: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Maximum fix attempts per iteration
+             * INV-ALO-003: Bounded fix attempts
+             */
+            maxFixAttempts: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Guard policy to enforce
+             * INV-ALO-001: Guards run after write
+             */
+            guardPolicy: z.ZodOptional<z.ZodString>;
+            /**
+             * Whether tests must pass before verify phase
+             * INV-ALO-002: Test requirement
+             */
+            requireTestPass: z.ZodDefault<z.ZodBoolean>;
+            /**
+             * Phases that pause for user review
+             * INV-ALO-004: Breakpoint behavior
+             */
+            breakpoints: z.ZodDefault<z.ZodArray<z.ZodEnum<["plan", "write", "test", "fix", "verify", "complete"]>, "many">>;
+            /**
+             * Test command to run
+             */
+            testCommand: z.ZodDefault<z.ZodString>;
+            /**
+             * Timeout for test execution in milliseconds
+             */
+            testTimeout: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Timeout per phase in milliseconds
+             */
+            phaseTimeout: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Whether to auto-commit successful changes
+             */
+            autoCommit: z.ZodDefault<z.ZodBoolean>;
+            /**
+             * Commit message template (uses {{phase}}, {{iteration}})
+             */
+            commitMessageTemplate: z.ZodDefault<z.ZodString>;
+            /**
+             * Working directory for execution
+             */
+            workingDirectory: z.ZodOptional<z.ZodString>;
+            /**
+             * Agent ID to use for code generation
+             */
+            agentId: z.ZodOptional<z.ZodString>;
+            /**
+             * Provider to use for LLM calls
+             */
+            provider: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            maxIterations: number;
+            maxFixAttempts: number;
+            requireTestPass: boolean;
+            breakpoints: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[];
+            testCommand: string;
+            testTimeout: number;
+            phaseTimeout: number;
+            autoCommit: boolean;
+            commitMessageTemplate: string;
+            agentId?: string | undefined;
+            provider?: string | undefined;
+            guardPolicy?: string | undefined;
+            workingDirectory?: string | undefined;
+        }, {
+            agentId?: string | undefined;
+            provider?: string | undefined;
+            maxIterations?: number | undefined;
+            maxFixAttempts?: number | undefined;
+            guardPolicy?: string | undefined;
+            requireTestPass?: boolean | undefined;
+            breakpoints?: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[] | undefined;
+            testCommand?: string | undefined;
+            testTimeout?: number | undefined;
+            phaseTimeout?: number | undefined;
+            autoCommit?: boolean | undefined;
+            commitMessageTemplate?: string | undefined;
+            workingDirectory?: string | undefined;
+        }>;
+        /**
+         * All changed files across iterations
+         * INV-ALO-005: Tracked for guard radius
+         */
+        changedFiles: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Iteration history
+         */
+        iterations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /**
+             * Iteration number (1-indexed)
+             */
+            iteration: z.ZodNumber;
+            /**
+             * Phase that completed
+             */
+            phase: z.ZodEnum<["plan", "write", "test", "fix", "verify", "complete"]>;
+            /**
+             * Whether phase succeeded
+             */
+            success: z.ZodBoolean;
+            /**
+             * Files changed in this iteration
+             */
+            changedFiles: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            /**
+             * Test result if test phase
+             */
+            testResult: z.ZodOptional<z.ZodObject<{
+                /**
+                 * Whether all tests passed
+                 */
+                passed: z.ZodBoolean;
+                /**
+                 * Total test count
+                 */
+                totalTests: z.ZodNumber;
+                /**
+                 * Passed test count
+                 */
+                passedTests: z.ZodNumber;
+                /**
+                 * Failed test count
+                 */
+                failedTests: z.ZodNumber;
+                /**
+                 * Skipped test count
+                 */
+                skippedTests: z.ZodDefault<z.ZodNumber>;
+                /**
+                 * Error output if failed
+                 */
+                errorOutput: z.ZodOptional<z.ZodString>;
+                /**
+                 * Test duration in milliseconds
+                 */
+                durationMs: z.ZodNumber;
+                /**
+                 * Failed test names
+                 */
+                failedTestNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                durationMs: number;
+                passed: boolean;
+                totalTests: number;
+                passedTests: number;
+                failedTests: number;
+                skippedTests: number;
+                errorOutput?: string | undefined;
+                failedTestNames?: string[] | undefined;
+            }, {
+                durationMs: number;
+                passed: boolean;
+                totalTests: number;
+                passedTests: number;
+                failedTests: number;
+                skippedTests?: number | undefined;
+                errorOutput?: string | undefined;
+                failedTestNames?: string[] | undefined;
+            }>>;
+            /**
+             * Guard result if write phase
+             */
+            guardResult: z.ZodOptional<z.ZodObject<{
+                /**
+                 * Policy that was checked
+                 */
+                policyId: z.ZodString;
+                /**
+                 * Whether all gates passed
+                 */
+                passed: z.ZodBoolean;
+                /**
+                 * Whether execution is blocked
+                 */
+                blocked: z.ZodBoolean;
+                /**
+                 * Individual gate results
+                 */
+                gateResults: z.ZodArray<z.ZodObject<{
+                    /**
+                     * Gate identifier
+                     */
+                    gateId: z.ZodString;
+                    /**
+                     * Whether the gate passed
+                     */
+                    passed: z.ZodBoolean;
+                    /**
+                     * Severity if failed
+                     */
+                    severity: z.ZodOptional<z.ZodEnum<["error", "warning", "info"]>>;
+                    /**
+                     * Message explaining result
+                     */
+                    message: z.ZodOptional<z.ZodString>;
+                    /**
+                     * Detailed violations if any
+                     */
+                    violations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        path: z.ZodOptional<z.ZodString>;
+                        rule: z.ZodOptional<z.ZodString>;
+                        message: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }, {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }>, "many">>;
+                }, "strip", z.ZodTypeAny, {
+                    gateId: string;
+                    passed: boolean;
+                    message?: string | undefined;
+                    severity?: "info" | "error" | "warning" | undefined;
+                    violations?: {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }[] | undefined;
+                }, {
+                    gateId: string;
+                    passed: boolean;
+                    message?: string | undefined;
+                    severity?: "info" | "error" | "warning" | undefined;
+                    violations?: {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }[] | undefined;
+                }>, "many">;
+                /**
+                 * Summary message
+                 */
+                summary: z.ZodOptional<z.ZodString>;
+                /**
+                 * Check timestamp
+                 */
+                checkedAt: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                blocked: boolean;
+                policyId: string;
+                checkedAt: string;
+                passed: boolean;
+                gateResults: {
+                    gateId: string;
+                    passed: boolean;
+                    message?: string | undefined;
+                    severity?: "info" | "error" | "warning" | undefined;
+                    violations?: {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }[] | undefined;
+                }[];
+                summary?: string | undefined;
+            }, {
+                blocked: boolean;
+                policyId: string;
+                checkedAt: string;
+                passed: boolean;
+                gateResults: {
+                    gateId: string;
+                    passed: boolean;
+                    message?: string | undefined;
+                    severity?: "info" | "error" | "warning" | undefined;
+                    violations?: {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }[] | undefined;
+                }[];
+                summary?: string | undefined;
+            }>>;
+            /**
+             * Fix attempts made
+             */
+            fixAttempts: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Error message if failed
+             */
+            error: z.ZodOptional<z.ZodString>;
+            /**
+             * Duration in milliseconds
+             */
+            durationMs: z.ZodNumber;
+            /**
+             * Start timestamp
+             */
+            startedAt: z.ZodString;
+            /**
+             * End timestamp
+             */
+            completedAt: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            durationMs: number;
+            success: boolean;
+            startedAt: string;
+            iteration: number;
+            phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+            changedFiles: string[];
+            fixAttempts: number;
+            error?: string | undefined;
+            guardResult?: {
+                blocked: boolean;
+                policyId: string;
+                checkedAt: string;
+                passed: boolean;
+                gateResults: {
+                    gateId: string;
+                    passed: boolean;
+                    message?: string | undefined;
+                    severity?: "info" | "error" | "warning" | undefined;
+                    violations?: {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }[] | undefined;
+                }[];
+                summary?: string | undefined;
+            } | undefined;
+            completedAt?: string | undefined;
+            testResult?: {
+                durationMs: number;
+                passed: boolean;
+                totalTests: number;
+                passedTests: number;
+                failedTests: number;
+                skippedTests: number;
+                errorOutput?: string | undefined;
+                failedTestNames?: string[] | undefined;
+            } | undefined;
+        }, {
+            durationMs: number;
+            success: boolean;
+            startedAt: string;
+            iteration: number;
+            phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+            error?: string | undefined;
+            guardResult?: {
+                blocked: boolean;
+                policyId: string;
+                checkedAt: string;
+                passed: boolean;
+                gateResults: {
+                    gateId: string;
+                    passed: boolean;
+                    message?: string | undefined;
+                    severity?: "info" | "error" | "warning" | undefined;
+                    violations?: {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }[] | undefined;
+                }[];
+                summary?: string | undefined;
+            } | undefined;
+            completedAt?: string | undefined;
+            changedFiles?: string[] | undefined;
+            testResult?: {
+                durationMs: number;
+                passed: boolean;
+                totalTests: number;
+                passedTests: number;
+                failedTests: number;
+                skippedTests?: number | undefined;
+                errorOutput?: string | undefined;
+                failedTestNames?: string[] | undefined;
+            } | undefined;
+            fixAttempts?: number | undefined;
+        }>, "many">>;
+        /**
+         * Latest guard check result
+         */
+        lastGuardResult: z.ZodOptional<z.ZodObject<{
+            /**
+             * Policy that was checked
+             */
+            policyId: z.ZodString;
+            /**
+             * Whether all gates passed
+             */
+            passed: z.ZodBoolean;
+            /**
+             * Whether execution is blocked
+             */
+            blocked: z.ZodBoolean;
+            /**
+             * Individual gate results
+             */
+            gateResults: z.ZodArray<z.ZodObject<{
+                /**
+                 * Gate identifier
+                 */
+                gateId: z.ZodString;
+                /**
+                 * Whether the gate passed
+                 */
+                passed: z.ZodBoolean;
+                /**
+                 * Severity if failed
+                 */
+                severity: z.ZodOptional<z.ZodEnum<["error", "warning", "info"]>>;
+                /**
+                 * Message explaining result
+                 */
+                message: z.ZodOptional<z.ZodString>;
+                /**
+                 * Detailed violations if any
+                 */
+                violations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    path: z.ZodOptional<z.ZodString>;
+                    rule: z.ZodOptional<z.ZodString>;
+                    message: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }, {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }>, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }, {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }>, "many">;
+            /**
+             * Summary message
+             */
+            summary: z.ZodOptional<z.ZodString>;
+            /**
+             * Check timestamp
+             */
+            checkedAt: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            blocked: boolean;
+            policyId: string;
+            checkedAt: string;
+            passed: boolean;
+            gateResults: {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }[];
+            summary?: string | undefined;
+        }, {
+            blocked: boolean;
+            policyId: string;
+            checkedAt: string;
+            passed: boolean;
+            gateResults: {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }[];
+            summary?: string | undefined;
+        }>>;
+        /**
+         * Latest test result
+         */
+        lastTestResult: z.ZodOptional<z.ZodObject<{
+            /**
+             * Whether all tests passed
+             */
+            passed: z.ZodBoolean;
+            /**
+             * Total test count
+             */
+            totalTests: z.ZodNumber;
+            /**
+             * Passed test count
+             */
+            passedTests: z.ZodNumber;
+            /**
+             * Failed test count
+             */
+            failedTests: z.ZodNumber;
+            /**
+             * Skipped test count
+             */
+            skippedTests: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Error output if failed
+             */
+            errorOutput: z.ZodOptional<z.ZodString>;
+            /**
+             * Test duration in milliseconds
+             */
+            durationMs: z.ZodNumber;
+            /**
+             * Failed test names
+             */
+            failedTestNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            durationMs: number;
+            passed: boolean;
+            totalTests: number;
+            passedTests: number;
+            failedTests: number;
+            skippedTests: number;
+            errorOutput?: string | undefined;
+            failedTestNames?: string[] | undefined;
+        }, {
+            durationMs: number;
+            passed: boolean;
+            totalTests: number;
+            passedTests: number;
+            failedTests: number;
+            skippedTests?: number | undefined;
+            errorOutput?: string | undefined;
+            failedTestNames?: string[] | undefined;
+        }>>;
+        /**
+         * Current fix attempts in iteration
+         */
+        currentFixAttempts: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Pause reason if paused
+         */
+        pauseReason: z.ZodOptional<z.ZodString>;
+        /**
+         * Error if failed or blocked
+         */
+        error: z.ZodOptional<z.ZodString>;
+        /**
+         * Session ID for tracking
+         */
+        sessionId: z.ZodOptional<z.ZodString>;
+        /**
+         * Start timestamp
+         */
+        startedAt: z.ZodString;
+        /**
+         * Last update timestamp
+         */
+        updatedAt: z.ZodString;
+        /**
+         * Completion timestamp
+         */
+        completedAt: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        status: "blocked" | "completed" | "failed" | "running" | "cancelled" | "paused";
+        config: {
+            maxIterations: number;
+            maxFixAttempts: number;
+            requireTestPass: boolean;
+            breakpoints: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[];
+            testCommand: string;
+            testTimeout: number;
+            phaseTimeout: number;
+            autoCommit: boolean;
+            commitMessageTemplate: string;
+            agentId?: string | undefined;
+            provider?: string | undefined;
+            guardPolicy?: string | undefined;
+            workingDirectory?: string | undefined;
+        };
+        task: string;
+        updatedAt: string;
+        startedAt: string;
+        iterations: {
+            durationMs: number;
+            success: boolean;
+            startedAt: string;
+            iteration: number;
+            phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+            changedFiles: string[];
+            fixAttempts: number;
+            error?: string | undefined;
+            guardResult?: {
+                blocked: boolean;
+                policyId: string;
+                checkedAt: string;
+                passed: boolean;
+                gateResults: {
+                    gateId: string;
+                    passed: boolean;
+                    message?: string | undefined;
+                    severity?: "info" | "error" | "warning" | undefined;
+                    violations?: {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }[] | undefined;
+                }[];
+                summary?: string | undefined;
+            } | undefined;
+            completedAt?: string | undefined;
+            testResult?: {
+                durationMs: number;
+                passed: boolean;
+                totalTests: number;
+                passedTests: number;
+                failedTests: number;
+                skippedTests: number;
+                errorOutput?: string | undefined;
+                failedTestNames?: string[] | undefined;
+            } | undefined;
+        }[];
+        iteration: number;
+        phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+        changedFiles: string[];
+        loopId: string;
+        currentFixAttempts: number;
+        sessionId?: string | undefined;
+        error?: string | undefined;
+        completedAt?: string | undefined;
+        lastGuardResult?: {
+            blocked: boolean;
+            policyId: string;
+            checkedAt: string;
+            passed: boolean;
+            gateResults: {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }[];
+            summary?: string | undefined;
+        } | undefined;
+        lastTestResult?: {
+            durationMs: number;
+            passed: boolean;
+            totalTests: number;
+            passedTests: number;
+            failedTests: number;
+            skippedTests: number;
+            errorOutput?: string | undefined;
+            failedTestNames?: string[] | undefined;
+        } | undefined;
+        pauseReason?: string | undefined;
+    }, {
+        status: "blocked" | "completed" | "failed" | "running" | "cancelled" | "paused";
+        config: {
+            agentId?: string | undefined;
+            provider?: string | undefined;
+            maxIterations?: number | undefined;
+            maxFixAttempts?: number | undefined;
+            guardPolicy?: string | undefined;
+            requireTestPass?: boolean | undefined;
+            breakpoints?: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[] | undefined;
+            testCommand?: string | undefined;
+            testTimeout?: number | undefined;
+            phaseTimeout?: number | undefined;
+            autoCommit?: boolean | undefined;
+            commitMessageTemplate?: string | undefined;
+            workingDirectory?: string | undefined;
+        };
+        task: string;
+        updatedAt: string;
+        startedAt: string;
+        iteration: number;
+        phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+        loopId: string;
+        sessionId?: string | undefined;
+        error?: string | undefined;
+        completedAt?: string | undefined;
+        iterations?: {
+            durationMs: number;
+            success: boolean;
+            startedAt: string;
+            iteration: number;
+            phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+            error?: string | undefined;
+            guardResult?: {
+                blocked: boolean;
+                policyId: string;
+                checkedAt: string;
+                passed: boolean;
+                gateResults: {
+                    gateId: string;
+                    passed: boolean;
+                    message?: string | undefined;
+                    severity?: "info" | "error" | "warning" | undefined;
+                    violations?: {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }[] | undefined;
+                }[];
+                summary?: string | undefined;
+            } | undefined;
+            completedAt?: string | undefined;
+            changedFiles?: string[] | undefined;
+            testResult?: {
+                durationMs: number;
+                passed: boolean;
+                totalTests: number;
+                passedTests: number;
+                failedTests: number;
+                skippedTests?: number | undefined;
+                errorOutput?: string | undefined;
+                failedTestNames?: string[] | undefined;
+            } | undefined;
+            fixAttempts?: number | undefined;
+        }[] | undefined;
+        changedFiles?: string[] | undefined;
+        lastGuardResult?: {
+            blocked: boolean;
+            policyId: string;
+            checkedAt: string;
+            passed: boolean;
+            gateResults: {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }[];
+            summary?: string | undefined;
+        } | undefined;
+        lastTestResult?: {
+            durationMs: number;
+            passed: boolean;
+            totalTests: number;
+            passedTests: number;
+            failedTests: number;
+            skippedTests?: number | undefined;
+            errorOutput?: string | undefined;
+            failedTestNames?: string[] | undefined;
+        } | undefined;
+        currentFixAttempts?: number | undefined;
+        pauseReason?: string | undefined;
+    }>;
+    /**
+     * Whether loop is active
+     */
+    isActive: z.ZodBoolean;
+    /**
+     * Whether waiting for user input
+     */
+    awaitingInput: z.ZodBoolean;
+    /**
+     * Progress percentage (0-100)
+     */
+    progress: z.ZodNumber;
+    /**
+     * Estimated remaining iterations
+     */
+    estimatedRemaining: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    progress: number;
+    state: {
+        status: "blocked" | "completed" | "failed" | "running" | "cancelled" | "paused";
+        config: {
+            maxIterations: number;
+            maxFixAttempts: number;
+            requireTestPass: boolean;
+            breakpoints: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[];
+            testCommand: string;
+            testTimeout: number;
+            phaseTimeout: number;
+            autoCommit: boolean;
+            commitMessageTemplate: string;
+            agentId?: string | undefined;
+            provider?: string | undefined;
+            guardPolicy?: string | undefined;
+            workingDirectory?: string | undefined;
+        };
+        task: string;
+        updatedAt: string;
+        startedAt: string;
+        iterations: {
+            durationMs: number;
+            success: boolean;
+            startedAt: string;
+            iteration: number;
+            phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+            changedFiles: string[];
+            fixAttempts: number;
+            error?: string | undefined;
+            guardResult?: {
+                blocked: boolean;
+                policyId: string;
+                checkedAt: string;
+                passed: boolean;
+                gateResults: {
+                    gateId: string;
+                    passed: boolean;
+                    message?: string | undefined;
+                    severity?: "info" | "error" | "warning" | undefined;
+                    violations?: {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }[] | undefined;
+                }[];
+                summary?: string | undefined;
+            } | undefined;
+            completedAt?: string | undefined;
+            testResult?: {
+                durationMs: number;
+                passed: boolean;
+                totalTests: number;
+                passedTests: number;
+                failedTests: number;
+                skippedTests: number;
+                errorOutput?: string | undefined;
+                failedTestNames?: string[] | undefined;
+            } | undefined;
+        }[];
+        iteration: number;
+        phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+        changedFiles: string[];
+        loopId: string;
+        currentFixAttempts: number;
+        sessionId?: string | undefined;
+        error?: string | undefined;
+        completedAt?: string | undefined;
+        lastGuardResult?: {
+            blocked: boolean;
+            policyId: string;
+            checkedAt: string;
+            passed: boolean;
+            gateResults: {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }[];
+            summary?: string | undefined;
+        } | undefined;
+        lastTestResult?: {
+            durationMs: number;
+            passed: boolean;
+            totalTests: number;
+            passedTests: number;
+            failedTests: number;
+            skippedTests: number;
+            errorOutput?: string | undefined;
+            failedTestNames?: string[] | undefined;
+        } | undefined;
+        pauseReason?: string | undefined;
+    };
+    isActive: boolean;
+    awaitingInput: boolean;
+    estimatedRemaining?: number | undefined;
+}, {
+    progress: number;
+    state: {
+        status: "blocked" | "completed" | "failed" | "running" | "cancelled" | "paused";
+        config: {
+            agentId?: string | undefined;
+            provider?: string | undefined;
+            maxIterations?: number | undefined;
+            maxFixAttempts?: number | undefined;
+            guardPolicy?: string | undefined;
+            requireTestPass?: boolean | undefined;
+            breakpoints?: ("write" | "complete" | "plan" | "test" | "fix" | "verify")[] | undefined;
+            testCommand?: string | undefined;
+            testTimeout?: number | undefined;
+            phaseTimeout?: number | undefined;
+            autoCommit?: boolean | undefined;
+            commitMessageTemplate?: string | undefined;
+            workingDirectory?: string | undefined;
+        };
+        task: string;
+        updatedAt: string;
+        startedAt: string;
+        iteration: number;
+        phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+        loopId: string;
+        sessionId?: string | undefined;
+        error?: string | undefined;
+        completedAt?: string | undefined;
+        iterations?: {
+            durationMs: number;
+            success: boolean;
+            startedAt: string;
+            iteration: number;
+            phase: "write" | "complete" | "plan" | "test" | "fix" | "verify";
+            error?: string | undefined;
+            guardResult?: {
+                blocked: boolean;
+                policyId: string;
+                checkedAt: string;
+                passed: boolean;
+                gateResults: {
+                    gateId: string;
+                    passed: boolean;
+                    message?: string | undefined;
+                    severity?: "info" | "error" | "warning" | undefined;
+                    violations?: {
+                        message: string;
+                        path?: string | undefined;
+                        rule?: string | undefined;
+                    }[] | undefined;
+                }[];
+                summary?: string | undefined;
+            } | undefined;
+            completedAt?: string | undefined;
+            changedFiles?: string[] | undefined;
+            testResult?: {
+                durationMs: number;
+                passed: boolean;
+                totalTests: number;
+                passedTests: number;
+                failedTests: number;
+                skippedTests?: number | undefined;
+                errorOutput?: string | undefined;
+                failedTestNames?: string[] | undefined;
+            } | undefined;
+            fixAttempts?: number | undefined;
+        }[] | undefined;
+        changedFiles?: string[] | undefined;
+        lastGuardResult?: {
+            blocked: boolean;
+            policyId: string;
+            checkedAt: string;
+            passed: boolean;
+            gateResults: {
+                gateId: string;
+                passed: boolean;
+                message?: string | undefined;
+                severity?: "info" | "error" | "warning" | undefined;
+                violations?: {
+                    message: string;
+                    path?: string | undefined;
+                    rule?: string | undefined;
+                }[] | undefined;
+            }[];
+            summary?: string | undefined;
+        } | undefined;
+        lastTestResult?: {
+            durationMs: number;
+            passed: boolean;
+            totalTests: number;
+            passedTests: number;
+            failedTests: number;
+            skippedTests?: number | undefined;
+            errorOutput?: string | undefined;
+            failedTestNames?: string[] | undefined;
+        } | undefined;
+        currentFixAttempts?: number | undefined;
+        pauseReason?: string | undefined;
+    };
+    isActive: boolean;
+    awaitingInput: boolean;
+    estimatedRemaining?: number | undefined;
+}>;
+export type LoopStatusResponse = z.infer<typeof LoopStatusResponseSchema>;
+export declare const AutonomousLoopErrorCodes: {
+    /** Loop not found */
+    readonly LOOP_NOT_FOUND: "ALO_LOOP_NOT_FOUND";
+    /** Loop already running */
+    readonly LOOP_ALREADY_RUNNING: "ALO_LOOP_ALREADY_RUNNING";
+    /** Loop not paused */
+    readonly LOOP_NOT_PAUSED: "ALO_LOOP_NOT_PAUSED";
+    /** Max iterations exceeded */
+    readonly MAX_ITERATIONS_EXCEEDED: "ALO_MAX_ITERATIONS_EXCEEDED";
+    /** Max fix attempts exceeded */
+    readonly MAX_FIX_ATTEMPTS_EXCEEDED: "ALO_MAX_FIX_ATTEMPTS_EXCEEDED";
+    /** Guard gate blocked */
+    readonly GUARD_BLOCKED: "ALO_GUARD_BLOCKED";
+    /** Test execution failed */
+    readonly TEST_FAILED: "ALO_TEST_FAILED";
+    /** Phase timeout */
+    readonly PHASE_TIMEOUT: "ALO_PHASE_TIMEOUT";
+    /** Invalid phase transition */
+    readonly INVALID_TRANSITION: "ALO_INVALID_TRANSITION";
+    /** Cancelled by user */
+    readonly CANCELLED: "ALO_CANCELLED";
+    /** Agent execution failed */
+    readonly AGENT_FAILED: "ALO_AGENT_FAILED";
+};
+export type AutonomousLoopErrorCode = (typeof AutonomousLoopErrorCodes)[keyof typeof AutonomousLoopErrorCodes];
+/**
+ * Validates autonomous loop configuration
+ */
+export declare function validateAutonomousLoopConfig(data: unknown): AutonomousLoopConfig;
+/**
+ * Safely validates autonomous loop configuration
+ */
+export declare function safeValidateAutonomousLoopConfig(data: unknown): {
+    success: true;
+    data: AutonomousLoopConfig;
+} | {
+    success: false;
+    error: z.ZodError;
+};
+/**
+ * Validates autonomous loop state
+ */
+export declare function validateAutonomousLoopState(data: unknown): AutonomousLoopState;
+/**
+ * Validates start loop request
+ */
+export declare function validateStartLoopRequest(data: unknown): StartLoopRequest;
+/**
+ * Creates default autonomous loop configuration
+ */
+export declare function createDefaultAutonomousLoopConfig(): AutonomousLoopConfig;
+/**
+ * Creates initial loop state
+ */
+export declare function createInitialLoopState(task: string, config?: Partial<AutonomousLoopConfig>): AutonomousLoopState;
+/**
+ * Creates a loop iteration record
+ */
+export declare function createLoopIteration(iteration: number, phase: AutonomousLoopPhase, success: boolean, options?: Partial<Omit<LoopIteration, 'iteration' | 'phase' | 'success'>>): LoopIteration;
+/**
+ * Valid phase transitions
+ */
+export declare const PHASE_TRANSITIONS: Record<AutonomousLoopPhase, AutonomousLoopPhase[]>;
+/**
+ * Checks if a phase transition is valid
+ */
+export declare function isValidPhaseTransition(from: AutonomousLoopPhase, to: AutonomousLoopPhase): boolean;
+/**
+ * Gets valid next phases from current phase
+ */
+export declare function getValidNextPhases(phase: AutonomousLoopPhase): AutonomousLoopPhase[];
+//# sourceMappingURL=schema.d.ts.map