@twelvehart/orcats 0.0.0-seed.0 → 0.2.3

package/dist/model/schemas.d.ts

@@ -0,0 +1,435 @@
+import { z } from "zod";
+export declare const BackendTagSchema: z.ZodEnum<{
+    claude: "claude";
+    codex: "codex";
+    opencode: "opencode";
+    pi: "pi";
+}>;
+export declare const UsageSchema: z.ZodObject<{
+    input: z.ZodNumber;
+    output: z.ZodNumber;
+    reasoning: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const AssistantTextDeltaSchema: z.ZodObject<{
+    type: z.ZodLiteral<"assistant_text_delta">;
+    text: z.ZodString;
+}, z.core.$strip>;
+export declare const AssistantTurnEndSchema: z.ZodObject<{
+    type: z.ZodLiteral<"assistant_turn_end">;
+}, z.core.$strip>;
+export declare const AssistantThinkingDeltaSchema: z.ZodObject<{
+    type: z.ZodLiteral<"assistant_thinking_delta">;
+    text: z.ZodString;
+}, z.core.$strip>;
+export declare const AssistantToolCallSchema: z.ZodObject<{
+    type: z.ZodLiteral<"assistant_tool_call">;
+    id: z.ZodString;
+    name: z.ZodString;
+    input: z.ZodUnknown;
+}, z.core.$strip>;
+export declare const ToolResultSchema: z.ZodObject<{
+    type: z.ZodLiteral<"tool_result">;
+    toolCallId: z.ZodString;
+    output: z.ZodUnknown;
+    isError: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const ConversationErrorSchema: z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    code: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+}, z.core.$strip>;
+export declare const UserPromptSchema: z.ZodObject<{
+    type: z.ZodLiteral<"user_prompt">;
+    text: z.ZodString;
+}, z.core.$strip>;
+export declare const UserQuestionSchema: z.ZodObject<{
+    type: z.ZodLiteral<"user_question">;
+    question: z.ZodString;
+}, z.core.$strip>;
+export declare const ApproveToolSchema: z.ZodObject<{
+    type: z.ZodLiteral<"approve_tool">;
+    toolCallId: z.ZodString;
+    name: z.ZodString;
+    input: z.ZodUnknown;
+}, z.core.$strip>;
+export declare const ConversationEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"assistant_text_delta">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"assistant_turn_end">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"assistant_thinking_delta">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"assistant_tool_call">;
+    id: z.ZodString;
+    name: z.ZodString;
+    input: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool_result">;
+    toolCallId: z.ZodString;
+    output: z.ZodUnknown;
+    isError: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    code: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"user_prompt">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"user_question">;
+    question: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"approve_tool">;
+    toolCallId: z.ZodString;
+    name: z.ZodString;
+    input: z.ZodUnknown;
+}, z.core.$strip>], "type">;
+export declare const StructuredResultEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"structured_result">;
+    raw: z.ZodUnknown;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ToolUseEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"tool_use">;
+    name: z.ZodString;
+    input: z.ZodUnknown;
+}, z.core.$strip>;
+export declare const AssistantMessageEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"assistant_message">;
+    text: z.ZodString;
+}, z.core.$strip>;
+export declare const TokensUsedEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"tokens_used">;
+    usage: z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+        reasoning: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const StepEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"step">;
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        started: "started";
+        completed: "completed";
+        failed: "failed";
+    }>;
+}, z.core.$strip>;
+export declare const OrcaEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"user_prompt">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool_use">;
+    name: z.ZodString;
+    input: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"assistant_message">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tokens_used">;
+    usage: z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+        reasoning: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"structured_result">;
+    raw: z.ZodUnknown;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"step">;
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        started: "started";
+        completed: "completed";
+        failed: "failed";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    code: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+}, z.core.$strip>], "type">;
+export declare const LlmResultSchema: z.ZodObject<{
+    backend: z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        opencode: "opencode";
+        pi: "pi";
+    }>;
+    sessionId: z.ZodString;
+    output: z.ZodString;
+    structured: z.ZodOptional<z.ZodUnknown>;
+    usage: z.ZodOptional<z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+        reasoning: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const NothingToCommitErrorSchema: z.ZodObject<{
+    _tag: z.ZodLiteral<"NothingToCommit">;
+}, z.core.$strip>;
+export declare const BranchAlreadyExistsErrorSchema: z.ZodObject<{
+    _tag: z.ZodLiteral<"BranchAlreadyExists">;
+    branch: z.ZodString;
+}, z.core.$strip>;
+export declare const PushRejectedErrorSchema: z.ZodObject<{
+    _tag: z.ZodLiteral<"PushRejected">;
+    remote: z.ZodOptional<z.ZodString>;
+    stderr: z.ZodString;
+}, z.core.$strip>;
+export declare const CommandFailedErrorSchema: z.ZodObject<{
+    _tag: z.ZodLiteral<"CommandFailed">;
+    command: z.ZodString;
+    exitCode: z.ZodNullable<z.ZodNumber>;
+    stdout: z.ZodString;
+    stderr: z.ZodString;
+}, z.core.$strip>;
+export declare const StructuredOutputValidationFailedErrorSchema: z.ZodObject<{
+    _tag: z.ZodLiteral<"StructuredOutputValidationFailed">;
+    issues: z.ZodArray<z.ZodString>;
+    raw: z.ZodUnknown;
+}, z.core.$strip>;
+export declare const UnsupportedFeatureErrorSchema: z.ZodObject<{
+    _tag: z.ZodLiteral<"UnsupportedFeature">;
+    feature: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export declare const BackendFailedErrorSchema: z.ZodObject<{
+    _tag: z.ZodLiteral<"BackendFailed">;
+    backend: z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        opencode: "opencode";
+        pi: "pi";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>;
+export declare const TypecheckFailedErrorSchema: z.ZodObject<{
+    _tag: z.ZodLiteral<"TypecheckFailed">;
+    stdout: z.ZodString;
+    stderr: z.ZodString;
+    exitCode: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const FileSystemErrorSchema: z.ZodObject<{
+    _tag: z.ZodLiteral<"FileSystemError">;
+    path: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>;
+export declare const IoFailedErrorSchema: z.ZodObject<{
+    _tag: z.ZodLiteral<"IoFailed">;
+    seam: z.ZodEnum<{
+        source: "source";
+        sink: "sink";
+        tool: "tool";
+    }>;
+    kind: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>;
+export declare const RuntimeErrorSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    _tag: z.ZodLiteral<"NothingToCommit">;
+}, z.core.$strip>, z.ZodObject<{
+    _tag: z.ZodLiteral<"BranchAlreadyExists">;
+    branch: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    _tag: z.ZodLiteral<"PushRejected">;
+    remote: z.ZodOptional<z.ZodString>;
+    stderr: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    _tag: z.ZodLiteral<"CommandFailed">;
+    command: z.ZodString;
+    exitCode: z.ZodNullable<z.ZodNumber>;
+    stdout: z.ZodString;
+    stderr: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    _tag: z.ZodLiteral<"StructuredOutputValidationFailed">;
+    issues: z.ZodArray<z.ZodString>;
+    raw: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+    _tag: z.ZodLiteral<"UnsupportedFeature">;
+    feature: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    _tag: z.ZodLiteral<"BackendFailed">;
+    backend: z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        opencode: "opencode";
+        pi: "pi";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    _tag: z.ZodLiteral<"TypecheckFailed">;
+    stdout: z.ZodString;
+    stderr: z.ZodString;
+    exitCode: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    _tag: z.ZodLiteral<"FileSystemError">;
+    path: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    _tag: z.ZodLiteral<"IoFailed">;
+    seam: z.ZodEnum<{
+        source: "source";
+        sink: "sink";
+        tool: "tool";
+    }>;
+    kind: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>], "_tag">;
+export type BackendTag = z.infer<typeof BackendTagSchema>;
+export type Usage = z.infer<typeof UsageSchema>;
+export type ConversationEvent = z.infer<typeof ConversationEventSchema>;
+export type OrcaEvent = z.infer<typeof OrcaEventSchema>;
+export type LlmResult = z.infer<typeof LlmResultSchema>;
+export type RuntimeError = z.infer<typeof RuntimeErrorSchema>;
+export declare const CanonicalSchemas: {
+    readonly BackendTag: z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        opencode: "opencode";
+        pi: "pi";
+    }>;
+    readonly Usage: z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+        reasoning: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    readonly ConversationEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"assistant_text_delta">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"assistant_turn_end">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"assistant_thinking_delta">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"assistant_tool_call">;
+        id: z.ZodString;
+        name: z.ZodString;
+        input: z.ZodUnknown;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_result">;
+        toolCallId: z.ZodString;
+        output: z.ZodUnknown;
+        isError: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"error">;
+        code: z.ZodOptional<z.ZodString>;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"user_prompt">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"user_question">;
+        question: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"approve_tool">;
+        toolCallId: z.ZodString;
+        name: z.ZodString;
+        input: z.ZodUnknown;
+    }, z.core.$strip>], "type">;
+    readonly OrcaEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"user_prompt">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_use">;
+        name: z.ZodString;
+        input: z.ZodUnknown;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"assistant_message">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tokens_used">;
+        usage: z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            reasoning: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"structured_result">;
+        raw: z.ZodUnknown;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"step">;
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            started: "started";
+            completed: "completed";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"error">;
+        code: z.ZodOptional<z.ZodString>;
+        message: z.ZodString;
+    }, z.core.$strip>], "type">;
+    readonly LlmResult: z.ZodObject<{
+        backend: z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            opencode: "opencode";
+            pi: "pi";
+        }>;
+        sessionId: z.ZodString;
+        output: z.ZodString;
+        structured: z.ZodOptional<z.ZodUnknown>;
+        usage: z.ZodOptional<z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            reasoning: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly RuntimeError: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        _tag: z.ZodLiteral<"NothingToCommit">;
+    }, z.core.$strip>, z.ZodObject<{
+        _tag: z.ZodLiteral<"BranchAlreadyExists">;
+        branch: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        _tag: z.ZodLiteral<"PushRejected">;
+        remote: z.ZodOptional<z.ZodString>;
+        stderr: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        _tag: z.ZodLiteral<"CommandFailed">;
+        command: z.ZodString;
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        stdout: z.ZodString;
+        stderr: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        _tag: z.ZodLiteral<"StructuredOutputValidationFailed">;
+        issues: z.ZodArray<z.ZodString>;
+        raw: z.ZodUnknown;
+    }, z.core.$strip>, z.ZodObject<{
+        _tag: z.ZodLiteral<"UnsupportedFeature">;
+        feature: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        _tag: z.ZodLiteral<"BackendFailed">;
+        backend: z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            opencode: "opencode";
+            pi: "pi";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        _tag: z.ZodLiteral<"TypecheckFailed">;
+        stdout: z.ZodString;
+        stderr: z.ZodString;
+        exitCode: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        _tag: z.ZodLiteral<"FileSystemError">;
+        path: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        _tag: z.ZodLiteral<"IoFailed">;
+        seam: z.ZodEnum<{
+            source: "source";
+            sink: "sink";
+            tool: "tool";
+        }>;
+        kind: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>], "_tag">;
+};
+//# sourceMappingURL=schemas.d.ts.map

package/dist/model/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/model/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,gBAAgB;;;;;EAK3B,CAAC;AAEH,eAAO,MAAM,WAAW;;;;iBAItB,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;iBAGnC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;iBAEjC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;iBAGvC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;iBAKlC,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;iBAK3B,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;iBAIlC,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;iBAG3B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;iBAK5B,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAUlC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;iBAItC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;iBAI7B,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;iBAGtC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;iBAGhC,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;iBAI1B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAQ1B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;iBAM1B,CAAC;AAEH,eAAO,MAAM,0BAA0B;;iBAErC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;iBAGzC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;iBAIlC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;iBAMnC,CAAC;AAEH,eAAO,MAAM,2CAA2C;;;;iBAItD,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;iBAIxC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;iBAInC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;iBAKrC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;iBAIhC,CAAC;AAIH,eAAO,MAAM,mBAAmB;;;;;;;;;iBAK9B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAW7B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAChD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOnB,CAAC"}

package/dist/model/structured.d.ts

@@ -0,0 +1,9 @@
+import { type Result } from "neverthrow";
+import type { ZodType } from "zod";
+import type { RuntimeError } from "./schemas.ts";
+export interface StructuredOutput<T> {
+    readonly raw: unknown;
+    readonly value: T;
+}
+export declare function parseStructuredOutput<T>(schema: ZodType<T>, raw: unknown): Result<StructuredOutput<T>, RuntimeError>;
+//# sourceMappingURL=structured.d.ts.map

package/dist/model/structured.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured.d.ts","sourceRoot":"","sources":["../../src/model/structured.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AAEnC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,EAClB,GAAG,EAAE,OAAO,GACX,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,CAY3C"}

package/dist/monitor/index.d.ts

@@ -0,0 +1,139 @@
+import type { Usage } from "../model/index.ts";
+import { type TokenUsageSummary } from "../loop/termination.ts";
+import type { LoopStopReason } from "../loop/builder/types.ts";
+import type { LoopContextPressure } from "../loop/execution.ts";
+import { type RunReporter } from "../run-output/index.ts";
+export type StageStatus = "completed" | "failed";
+/** Discriminated cleanup verdict. `clean`/`repaired` are safe improvements
+ * (pass); `regressed`/`guard-reject` are reverted changes (fail); `declined`
+ * is a neutral no-op; `precondition-skip` is excluded from the backend's
+ * denominator because the file's gate was already red before the agent ran. */
+export type OutcomeVerdict = "clean" | "repaired" | "regressed" | "guard-reject" | "declined" | "precondition-skip";
+/** Why a `regressed` change could not be made to pass the gate. */
+export type RegressedReason = "stuck" | "timeout" | "ceiling";
+export interface StageLog {
+    readonly name: string;
+    readonly startedAt: string;
+    readonly durationMs: number;
+    readonly status: StageStatus;
+}
+export interface CommandLog {
+    readonly command: string;
+    readonly status: "passed" | "failed";
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly exitCode: number | null;
+    readonly durationMs: number;
+}
+export interface OutcomeLog {
+    readonly file: string;
+    readonly verdict: OutcomeVerdict;
+    readonly durationMs: number;
+    readonly smellsRemoved: readonly string[];
+    readonly changedPaths?: readonly string[];
+    readonly validation?: readonly CommandLog[];
+    readonly reason?: string;
+    /** Repair iterations to reach green: 0 for `clean`, K for `repaired`. */
+    readonly iterations?: number;
+    /** Set only when `verdict === "regressed"`. */
+    readonly regressedReason?: RegressedReason;
+    /** Total agent tokens spent on this file (initial edit + repairs). */
+    readonly tokens?: number;
+    readonly usage?: Usage;
+    readonly snapshotPath?: string;
+}
+export interface FailureLog {
+    readonly file: string;
+    readonly error: unknown;
+    readonly durationMs: number;
+    readonly category?: string;
+}
+export interface WorkflowRunSummary {
+    /** Safe improvements: `clean` + `repaired`. */
+    readonly pass: number;
+    /** Reverted changes (`regressed` + `guard-reject`) plus thrown failures. */
+    readonly fail: number;
+    /** Neutral no-ops: `declined`. */
+    readonly skip: number;
+    /** Files whose gate was already red before the agent — excluded from the
+     * pass-rate denominator (`pass + fail + skip`). */
+    readonly preconditionSkip: number;
+    readonly durationMs: number;
+}
+/** Stop status known at a cycle. `running` = no terminal reason yet — the incipient-runaway
+ * window where a flat `delta` with rising `cumulativeUsage` is visible before a guard fires. */
+export type CycleStopStatus = LoopStopReason | "running";
+/** One branch of a fan-out cycle. Missing backend usage is `unknown`, not zero. */
+export interface BranchProgress {
+    readonly id: string;
+    readonly status: StageStatus;
+    readonly usage: Usage | "unknown";
+}
+/** A completed cycle's progress record, appended to the run log. */
+export interface CycleProgress {
+    readonly iteration: number;
+    readonly measure: number;
+    /** Change in `measure` vs the prior recorded cycle (`0` for the first). */
+    readonly delta: number;
+    readonly stopReasonSoFar: CycleStopStatus;
+    /** Present only for a fan-out cycle. */
+    readonly branches?: readonly BranchProgress[];
+    /** Cumulative reported usage across cycles; `unknown` (not zero) once any cycle reports none. */
+    readonly cumulativeUsage: TokenUsageSummary;
+    /** Context pressure evidence from loop execution when offload or compaction ran. */
+    readonly contextPressure?: LoopContextPressure;
+}
+/** A single branch of a fan-out cycle as observed by the caller; `usage` omitted ⇒ `unknown`. */
+export interface BranchObservation {
+    readonly id: string;
+    readonly status: StageStatus;
+    readonly usage?: Usage;
+}
+/** Caller input for {@link WorkflowMonitor.recordCycle}; `delta` and `cumulativeUsage` are derived. */
+export interface CycleObservation {
+    readonly iteration: number;
+    /** Current measure from the manifest projection / loop variant. */
+    readonly measure: number;
+    /** Total backend usage reported this cycle (non-fanout); omit ⇒ cumulative becomes `unknown`. */
+    readonly usage?: Usage;
+    /** Per-branch records for a fan-out cycle; when present, cumulative usage folds each branch. */
+    readonly branches?: readonly BranchObservation[];
+    /** Terminal stop reason for the loop-ending cycle. Defaults to a value derived from the variant:
+     * `converged` when `measure <= floor`, else `running`. */
+    readonly stopReason?: LoopStopReason;
+    /** Convergence floor for the derived stop status; default `0` (the loop builder's floor). */
+    readonly floor?: number;
+    /** Context pressure evidence emitted by loop execution for this cycle. */
+    readonly contextPressure?: LoopContextPressure;
+}
+export interface WorkflowRunLog {
+    readonly runId: string;
+    readonly startedAt: string;
+    readonly backend: string;
+    readonly stages: readonly StageLog[];
+    readonly outcomes: readonly OutcomeLog[];
+    readonly failures: readonly FailureLog[];
+    readonly summary: WorkflowRunSummary;
+    /** Per-cycle progress stream; empty for a non-loop run. */
+    readonly progress: readonly CycleProgress[];
+}
+export interface WorkflowMonitorOptions {
+    readonly writeStatus?: (line: string) => void;
+    readonly reporter?: RunReporter;
+    readonly statusIntervalMs?: number;
+}
+export declare class WorkflowMonitor {
+    #private;
+    constructor(backend: string, options?: WorkflowMonitorOptions);
+    get runId(): string;
+    stage<T>(name: string, fn: () => Promise<T>): Promise<T>;
+    recordOutcome(log: OutcomeLog): void;
+    recordFailure(log: FailureLog): void;
+    /** Append a per-cycle progress record. `delta` is derived against the prior cycle's `measure`
+     * and `cumulativeUsage` is folded with the L02 token counter, so both stay consistent with the
+     * termination variant and a usage-less cycle reports `unknown` rather than zero. */
+    recordCycle(observation: CycleObservation): void;
+    toJson(): WorkflowRunLog;
+    writeLog(logDir: string): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/monitor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/monitor/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAsB,KAAK,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AACpF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAKL,KAAK,WAAW,EACjB,MAAM,wBAAwB,CAAC;AAEhC,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,QAAQ,CAAC;AACjD;;;+EAG+E;AAC/E,MAAM,MAAM,cAAc,GACtB,OAAO,GACP,UAAU,GACV,WAAW,GACX,cAAc,GACd,UAAU,GACV,mBAAmB,CAAC;AAExB,mEAAmE;AACnE,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,CAAC;AAE9D,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;CAC9B;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IACjC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;IAC5C,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,yEAAyE;IACzE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,+CAA+C;IAC/C,QAAQ,CAAC,eAAe,CAAC,EAAE,eAAe,CAAC;IAC3C,sEAAsE;IACtE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;IACvB,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,kBAAkB;IACjC,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,4EAA4E;IAC5E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,kCAAkC;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;uDACmD;IACnD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAOD;gGACgG;AAChG,MAAM,MAAM,eAAe,GAAG,cAAc,GAAG,SAAS,CAAC;AAEzD,mFAAmF;AACnF,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,CAAC;CACnC;AAED,oEAAoE;AACpE,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;IAC1C,wCAAwC;IACxC,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IAC9C,iGAAiG;IACjG,QAAQ,CAAC,eAAe,EAAE,iBAAiB,CAAC;IAC5C,oFAAoF;IACpF,QAAQ,CAAC,eAAe,CAAC,EAAE,mBAAmB,CAAC;CAChD;AAED,iGAAiG;AACjG,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;CACxB;AAED,uGAAuG;AACvG,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,iGAAiG;IACjG,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;IACvB,gGAAgG;IAChG,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACjD;8DAC0D;IAC1D,QAAQ,CAAC,UAAU,CAAC,EAAE,cAAc,CAAC;IACrC,6FAA6F;IAC7F,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,0EAA0E;IAC1E,QAAQ,CAAC,eAAe,CAAC,EAAE,mBAAmB,CAAC;CAChD;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,SAAS,QAAQ,EAAE,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAC;IACzC,QAAQ,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAC;IACzC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,2DAA2D;IAC3D,QAAQ,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,CAAC;CAC7C;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9C,QAAQ,CAAC,QAAQ,CAAC,EAAE,WAAW,CAAC;IAChC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CACpC;AAID,qBAAa,eAAe;;gBAad,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,sBAA2B;IASjE,IAAI,KAAK,IAAI,MAAM,CAElB;IAEK,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAuB9D,aAAa,CAAC,GAAG,EAAE,UAAU,GAAG,IAAI;IAWpC,aAAa,CAAC,GAAG,EAAE,UAAU,GAAG,IAAI;IAWpC;;wFAEoF;IACpF,WAAW,CAAC,WAAW,EAAE,gBAAgB,GAAG,IAAI;IAyChD,MAAM,IAAI,cAAc;IAmBlB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAyB9C"}

package/dist/plan/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./persistent.ts";
+export * from "./verdict.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/plan/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plan/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC"}

package/dist/plan/persistent.d.ts

@@ -0,0 +1,23 @@
+import { type Result } from "neverthrow";
+import type { RuntimeError } from "../model/index.ts";
+import { type FsTool } from "../tools/index.ts";
+export interface PlanTask {
+    readonly id: string;
+    readonly description: string;
+}
+export interface PlanLoopResult {
+    readonly completed: readonly string[];
+}
+export declare function planHash(input: string): string;
+export declare function defaultPlanPath(root: string, input: string): string;
+export declare function writePlan(root: string, input: string, content: string, fsTool?: FsTool): Promise<Result<string, RuntimeError>>;
+export declare function recoverPlan(path: string, fsTool?: FsTool): Promise<Result<string, RuntimeError>>;
+/** Sequential-task `.until()` strategy over loop execution (design D7):
+ * drive the pending-task count to zero, implementing one task per cycle and
+ * stopping at the first typed failure. */
+export declare function sequentialTaskStrategy(tasks: readonly PlanTask[], implement: (task: PlanTask) => Promise<Result<void, RuntimeError>>): Promise<Result<PlanLoopResult, RuntimeError>>;
+/** Deprecated compatibility wrapper kept for one release (design D7): delegates to
+ * `sequentialTaskStrategy` and emits a runtime DeprecationWarning. Not tagged
+ * `@deprecated` so existing callers still using it for this release stay lint-clean. */
+export declare function implementTaskLoop(tasks: readonly PlanTask[], implement: (task: PlanTask) => Promise<Result<void, RuntimeError>>): Promise<Result<PlanLoopResult, RuntimeError>>;
+//# sourceMappingURL=persistent.d.ts.map

package/dist/plan/persistent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistent.d.ts","sourceRoot":"","sources":["../../src/plan/persistent.ts"],"names":[],"mappings":"AAEA,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,YAAY,CAAC;AAElD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAgB,KAAK,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE9D,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEnE;AAED,wBAAsB,SAAS,CAC7B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,MAAM,GAAE,MAAuB,GAC9B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAIvC;AAED,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,MAAM,GAAE,MAAuB,GAC9B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAEvC;AAID;;0CAE0C;AAC1C,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,SAAS,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC,GACjE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC,CA6B/C;AAED;;wFAEwF;AACxF,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,SAAS,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC,GACjE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC,CAG/C"}

package/dist/plan/verdict.d.ts

@@ -0,0 +1,9 @@
+export type Verdict<A> = {
+    readonly kind: "proceed";
+    readonly value: A;
+} | {
+    readonly kind: "rejection";
+    readonly category: "question" | "critique" | "rebuff";
+    readonly body: string;
+};
+//# sourceMappingURL=verdict.d.ts.map

package/dist/plan/verdict.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verdict.d.ts","sourceRoot":"","sources":["../../src/plan/verdict.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,CAAC,CAAC,IACjB;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAC/C;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,UAAU,GAAG,UAAU,GAAG,QAAQ,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA"}

package/dist/review/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./loop.ts";
+export * from "./reviewers.ts";
+export * from "./tool.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/review/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/review/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC"}