flavor-code 1.2.1

package/dist/hallucination/types.d.ts

@@ -0,0 +1,49 @@
+export interface ConfidenceScores {
+    taskAlignment: number;
+    evidenceGrounding: number;
+    processReliability: number;
+}
+export type HallucinationEvaluationStatus = "completed" | "timeout" | "unavailable" | "skipped";
+export interface ConfidenceResult {
+    confidence: number;
+    reason: string;
+    scores?: ConfidenceScores;
+    unsupportedClaims?: string[];
+}
+export interface SlidingWindowConfig {
+    windowSize: number;
+    threshold: number;
+}
+export declare const DEFAULT_SLIDING_WINDOW_SIZE = 20;
+export declare const DEFAULT_SLIDING_WINDOW_THRESHOLD = 15;
+export declare const DEFAULT_MAX_TOOL_RETRIES = 3;
+export declare const DEFAULT_CONFIDENCE_THRESHOLD = 0.7;
+export declare const DEFAULT_EVALUATION_TIMEOUT_MS = 2000;
+export interface ToolCallRecord {
+    toolName: string;
+    params: unknown;
+    paramHash: string;
+    iteration: number;
+    errorCode?: string;
+}
+export interface RetryThresholds {
+    maxToolRetries: number;
+}
+export interface HallucinationReport {
+    confidence: ConfidenceResult | null;
+    evaluationStatus: HallucinationEvaluationStatus;
+    retryViolations: RetryViolation[];
+    circuitBreakerTripped: boolean;
+    circuitBreakerDetail: string | null;
+    passed: boolean;
+    /** Deterministic reasons that may block engineering-loop completion. */
+    blockingReasons: string[];
+    /** Human-readable warning messages already localized to the configured language. */
+    warnings: string[];
+}
+export interface RetryViolation {
+    toolName: string;
+    retryCount: number;
+    maxRetries: number;
+    lastErrorCode: string | null;
+}

package/dist/harness/local.d.ts

@@ -0,0 +1,54 @@
+import { AgentLoop } from "../agent/loop.js";
+import type { TaskNode } from "../agent/planner.js";
+import type { HallucinationGuard } from "../hallucination/guard.js";
+import type { PermissionMode } from "../permissions/engine.js";
+import type { ContextManager } from "../context/manager.js";
+import type { HookBus } from "../hooks/bus.js";
+import type { ModelRegistry } from "../models/registry.js";
+import type { ModelTool } from "../models/types.js";
+import { ToolRuntime, type ApprovalCallback } from "../tools/runtime.js";
+import type { ToolDefinition } from "../tools/types.js";
+export interface LocalHarnessOptions {
+    registry: ModelRegistry;
+    hooks: HookBus;
+    workspace: string;
+    mainModelId: string;
+    subagentModelId: string;
+    tools: readonly ToolDefinition<unknown>[];
+    createContext(agent: "main" | "subagent", tools: readonly ToolDefinition<unknown>[], modelId: string, parentContext?: ContextManager): ContextManager;
+    permissionMode?: PermissionMode;
+    approve?: ApprovalCallback;
+    maxIterationsMain?: number;
+    maxIterationsSubagent?: number;
+    hasActiveProgress?(): boolean;
+    hallucinationGuard?: HallucinationGuard;
+    /** When true, non-destructive tools skip the approval callback. Destructive tools still require confirmation. */
+    loopMode?: boolean;
+}
+export interface HarnessProfile {
+    modelId: string;
+    context: ContextManager;
+    runtime: ToolRuntime;
+    tools: readonly ModelTool[];
+    loop: AgentLoop;
+}
+export interface SubagentHarness extends HarnessProfile {
+    task: TaskNode;
+    dispose(): void;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+export declare class LocalHarness {
+    #private;
+    readonly main: HarnessProfile;
+    constructor(options: LocalHarnessOptions);
+    get mainModelId(): string;
+    get subagentModelId(): string;
+    get permissionMode(): PermissionMode;
+    setModel(role: "main" | "subagent", modelId: string): void;
+    setPermissionMode(mode: PermissionMode): void;
+    replaceMainTools(definitions: readonly ToolDefinition<unknown>[]): void;
+    createSubagent(task: TaskNode, parentContext?: ContextManager): SubagentHarness;
+    runSubagent<T>(task: TaskNode, execute: (harness: SubagentHarness, signal: AbortSignal) => Promise<T>, signal?: AbortSignal, parentContext?: ContextManager): Promise<T>;
+    dispose(): void;
+    [Symbol.asyncDispose](): Promise<void>;
+}

package/dist/hooks/bus.d.ts

@@ -0,0 +1,9 @@
+import type { z } from "zod";
+import { type HookDecision, type HookEvent, type HookEventName, type HookHandler, type HookHandlerOptions, type ShellHookHandler } from "./types.js";
+export declare class HookBus {
+    #private;
+    registerPayloadSchema(type: HookEventName, schema: z.ZodType<Record<string, unknown>>): () => void;
+    on(type: HookEventName, handler: HookHandler | ShellHookHandler, options?: HookHandlerOptions): () => void;
+    hasListeners(type: HookEventName): boolean;
+    emit(rawEvent: HookEvent, externalSignal?: AbortSignal): Promise<HookDecision>;
+}

package/dist/hooks/types.d.ts

@@ -0,0 +1,105 @@
+import { z } from "zod";
+export declare const HOOK_EVENT_NAMES: readonly ["SessionStart", "UserPromptSubmit", "Stop", "SessionEnd", "BeforePlan", "AfterPlan", "SubagentStart", "SubagentStop", "BeforeModelCall", "AfterModelCall", "PreToolUse", "PermissionRequest", "PostToolUse", "PostToolUseFailure", "PreCompact", "PostCompact", "PluginLoad", "PluginUnload", "Notification"];
+export declare const HookEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"SessionStart">;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"UserPromptSubmit">;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"Stop">;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"SessionEnd">;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"BeforePlan">;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"AfterPlan">;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"SubagentStart">;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"SubagentStop">;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"BeforeModelCall">;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"AfterModelCall">;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"PreToolUse">;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"PermissionRequest">;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"PostToolUse">;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"PostToolUseFailure">;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"PreCompact">;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"PostCompact">;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"PluginLoad">;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"PluginUnload">;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"Notification">;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>], "type">;
+export declare const HookDecisionSchema: z.ZodObject<{
+    decision: z.ZodEnum<{
+        allow: "allow";
+        ask: "ask";
+        deny: "deny";
+    }>;
+    reason: z.ZodOptional<z.ZodString>;
+    updatedInput: z.ZodOptional<z.ZodUnknown>;
+    additionalContext: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type HookEvent = z.infer<typeof HookEventSchema>;
+export type HookEventName = (typeof HOOK_EVENT_NAMES)[number];
+export type HookDecision = z.infer<typeof HookDecisionSchema>;
+export type HookHandler = (event: HookEvent, signal: AbortSignal) => HookDecision | Promise<HookDecision>;
+export interface ShellHookHandler {
+    command: string;
+    args?: readonly string[];
+    timeoutMs?: number;
+    failurePolicy?: "error" | "allow" | "deny" | "ask";
+    env?: Readonly<Record<string, string>>;
+    maxOutputBytes?: number;
+}
+export interface HookHandlerOptions {
+    timeoutMs?: number;
+    failurePolicy?: "error" | "allow" | "deny" | "ask";
+}

package/dist/ide/client.d.ts

@@ -0,0 +1,35 @@
+export interface IdePosition {
+    line: number;
+    character: number;
+}
+export interface IdeEditorContext {
+    ideName: string;
+    workspaceFolders: string[];
+    filePath?: string;
+    languageId?: string;
+    dirty?: boolean;
+    selection: {
+        start: IdePosition;
+        end: IdePosition;
+        active: IdePosition;
+        isEmpty: boolean;
+    };
+    selectedText?: string;
+}
+export interface FlavorIdeClientOptions {
+    workspace: string;
+    home: string;
+    environment?: NodeJS.ProcessEnv;
+    fetch?: typeof fetch;
+}
+export declare class FlavorIdeClient {
+    #private;
+    constructor(options: FlavorIdeClientOptions);
+    initialize(): Promise<void>;
+    status(): Promise<string>;
+    editorContext(): Promise<IdeEditorContext | undefined>;
+    promptContext(): Promise<string | undefined>;
+    startSession(sessionId: string): Promise<void>;
+    publishEvent(sessionId: string, event: unknown): void;
+    endSession(sessionId?: string | undefined): Promise<void>;
+}

package/dist/incidents/reporter.d.ts

@@ -0,0 +1,38 @@
+/**
+ * IncidentReporter — bridges flavor-code tool failures to the langgraph-claw
+ * RCA alert pipeline via the AlertManager webhook endpoint.
+ *
+ * Architecture:
+ *   flavor-code tool failure
+ *         │
+ *         ▼
+ *   PostToolUseFailure hook (ToolRuntime)
+ *         │
+ *         ▼
+ *   IncidentReporter.collect() → POST /api/otel/alerts → langgraph-claw
+ *         │
+ *         ▼
+ *   P0: auto-RCA via agent harness  →  code-rca skill
+ *   P1: stored + SSE broadcast  →  manual analysis
+ *
+ * Env vars:
+ *   FLAVOR_INCIDENT_WEBHOOK_URL  — langgraph-claw base URL (default: http://localhost:8000)
+ *   FLAVOR_INCIDENT_ENABLED      — "true" to enable reporting (default: false)
+ */
+import type { HookHandler } from "../hooks/types.js";
+export interface IncidentReporterOptions {
+    /** Base URL of the langgraph-claw server. */
+    webhookUrl?: string;
+    /** When false the reporter is a no-op. */
+    enabled?: boolean;
+    /** Absolute workspace path for git context and alert metadata. */
+    workspace: string;
+}
+/**
+ * Create a ``PostToolUseFailure`` hook handler that reports tool failures to
+ * langgraph-claw as AlertManager-compatible webhook alerts.
+ *
+ * The handler always returns ``{ decision: "allow" }`` — it is a pure observer
+ * and does not alter the tool execution pipeline.
+ */
+export declare function createIncidentReporter(options: IncidentReporterOptions): HookHandler;

package/dist/init/project.d.ts

@@ -0,0 +1,25 @@
+export interface ProjectFacts {
+    cwd: string;
+    projectName: string;
+    languages: string[];
+    packageManager?: string;
+    packageManagers: string[];
+    scripts: Record<string, string>;
+    buildCommands: string[];
+    testCommands: string[];
+    lintCommands: string[];
+    formatCommands: string[];
+    sourceDirectories: string[];
+    instructionFiles: string[];
+    configFiles: string[];
+    gitignorePath?: string;
+    cautions: string[];
+}
+export interface InitResult {
+    path: string;
+    created: boolean;
+    content: string;
+    facts: ProjectFacts;
+}
+export declare function inspectProject(cwd: string): Promise<ProjectFacts>;
+export declare function initializeFlavor(cwd: string): Promise<InitResult>;

package/dist/load-WQGNTCHC.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
+import {
+  loadConfig,
+  redactConfig,
+  setGlobalProviderConfig,
+  setProjectMcpServerDisabled,
+  setProjectProviderConfig,
+  setProjectSkillDisabled
+} from "./chunk-MVIMQEQT.js";
+import "./chunk-JZ322RCJ.js";
+export {
+  loadConfig,
+  redactConfig,
+  setGlobalProviderConfig,
+  setProjectMcpServerDisabled,
+  setProjectProviderConfig,
+  setProjectSkillDisabled
+};
+//# sourceMappingURL=load-WQGNTCHC.js.map

package/dist/load-WQGNTCHC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/loop/budget.d.ts

@@ -0,0 +1,11 @@
+import { type LoopState } from "./types.js";
+export type BudgetDimension = "cycles" | "tokens";
+export type BudgetDecision = {
+    kind: "allow";
+} | {
+    kind: "confirm";
+    dimensions: BudgetDimension[];
+};
+export declare function budgetDecision(input: LoopState): BudgetDecision;
+export declare function extendBudget(input: LoopState, dimensions: readonly BudgetDimension[], approvedAt: string): LoopState;
+export declare function rejectBudget(input: LoopState, terminalReason: string): LoopState;

package/dist/loop/isolation.d.ts

@@ -0,0 +1,21 @@
+export type GoalIntent = "read_only" | "code_change" | "ambiguous";
+export interface LoopWorkspace {
+    root: string;
+    mode: "current" | "worktree";
+    branch?: string;
+}
+export type LoopWorkspaceResolution = {
+    kind: "ready";
+    workspace: LoopWorkspace;
+} | {
+    kind: "needs_human";
+    reason: string;
+};
+export interface PrepareLoopWorkspaceOptions {
+    root: string;
+    loopId: string;
+    goal: string;
+    signal?: AbortSignal;
+}
+export declare function inferGoalIntent(goal: string): GoalIntent;
+export declare function prepareLoopWorkspace(options: PrepareLoopWorkspaceOptions): Promise<LoopWorkspaceResolution>;

package/dist/loop/orchestrator.d.ts

@@ -0,0 +1,82 @@
+import type { AgentEvent } from "../agent/types.js";
+import { type BudgetDimension } from "./budget.js";
+import type { HallucinationGuard } from "../hallucination/guard.js";
+import type { LoopWorkspaceResolution } from "./isolation.js";
+import { type LoopEvent, type LoopState, type LoopStatus, type LoopVerificationEvidence } from "./types.js";
+import type { VerificationPlan } from "./verifier.js";
+export interface LoopPersistence {
+    create(state: LoopState): Promise<void>;
+    save(state: LoopState): Promise<void>;
+    append(event: LoopEvent): Promise<void>;
+}
+export type LoopConfirmation = "approved" | "rejected" | "unavailable";
+export type LoopRuntimeEvent = {
+    type: "loop-resolved";
+    loopId: string;
+    workspace: string;
+    isolation: "current" | "worktree";
+    verifierCommands: string[];
+    cycleCheckpoint: number;
+    tokenCheckpoint: number;
+} | {
+    type: "loop-cycle-start";
+    loopId: string;
+    cycle: number;
+} | {
+    type: "worker-event";
+    event: AgentEvent;
+} | {
+    type: "loop-verification";
+    loopId: string;
+    cycle: number;
+    evidence: LoopVerificationEvidence;
+} | {
+    type: "loop-budget";
+    loopId: string;
+    dimensions: BudgetDimension[];
+    cycleCheckpoint: number;
+    tokenCheckpoint: number;
+} | {
+    type: "loop-terminal";
+    loopId: string;
+    status: Exclude<LoopStatus, "running">;
+    reason: string;
+};
+export interface LoopOrchestratorOptions {
+    workspace: string;
+    config: {
+        maxCycles: number;
+        maxTokens: number;
+        isolation: "auto";
+    };
+    persistence: LoopPersistence;
+    prepareWorkspace(input: {
+        root: string;
+        loopId: string;
+        goal: string;
+        signal: AbortSignal;
+    }): Promise<LoopWorkspaceResolution>;
+    inferVerification(workspace: string): Promise<VerificationPlan>;
+    runWorker(input: {
+        goal: string;
+        cycle: number;
+        workspace: string;
+        prompt: string;
+        signal: AbortSignal;
+    }): AsyncIterable<AgentEvent>;
+    runVerifier(plan: VerificationPlan, workspace: string, signal: AbortSignal): Promise<LoopVerificationEvidence>;
+    confirmBudget(state: LoopState, dimensions: readonly BudgetDimension[], signal: AbortSignal): Promise<LoopConfirmation>;
+    fingerprint(workspace: string): Promise<string>;
+    /** Optional hallucination guard for confidence checks and retry monitoring. */
+    hallucinationGuard?: HallucinationGuard;
+    now?(): string;
+    idFactory?(): string;
+}
+export declare class LoopOrchestrator {
+    #private;
+    constructor(options: LoopOrchestratorOptions);
+    run(request: {
+        goal: string;
+        signal: AbortSignal;
+    }): AsyncIterable<LoopRuntimeEvent>;
+}

package/dist/loop/store.d.ts

@@ -0,0 +1,13 @@
+import { type LoopEvent, type LoopState } from "./types.js";
+export interface LoopStoreOptions {
+    workspace: string;
+    maxBytes?: number;
+}
+export declare class LoopStore {
+    #private;
+    constructor(options: LoopStoreOptions);
+    create(state: LoopState): Promise<void>;
+    save(input: LoopState): Promise<void>;
+    load(loopId: string): Promise<LoopState>;
+    append(input: LoopEvent): Promise<void>;
+}

package/dist/loop/types.d.ts

@@ -0,0 +1,142 @@
+import { z } from "zod";
+export declare const LoopStatusSchema: z.ZodEnum<{
+    blocked: "blocked";
+    budget_exhausted: "budget_exhausted";
+    cancelled: "cancelled";
+    failed: "failed";
+    needs_human: "needs_human";
+    no_progress: "no_progress";
+    running: "running";
+    succeeded: "succeeded";
+}>;
+export declare const LoopApprovalSchema: z.ZodObject<{
+    dimension: z.ZodEnum<{
+        cycles: "cycles";
+        tokens: "tokens";
+    }>;
+    previousCheckpoint: z.ZodNumber;
+    newCheckpoint: z.ZodNumber;
+    usage: z.ZodNumber;
+    approvedAt: z.ZodString;
+}, z.core.$strict>;
+export declare const LoopVerificationCommandSchema: z.ZodObject<{
+    command: z.ZodString;
+    args: z.ZodArray<z.ZodString>;
+    exitCode: z.ZodNullable<z.ZodNumber>;
+    stdout: z.ZodString;
+    stderr: z.ZodString;
+    truncated: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const LoopVerificationEvidenceSchema: z.ZodObject<{
+    passed: z.ZodBoolean;
+    commands: z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        args: z.ZodArray<z.ZodString>;
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        stdout: z.ZodString;
+        stderr: z.ZodString;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+    summary: z.ZodString;
+}, z.core.$strict>;
+export declare const LoopCycleEvidenceSchema: z.ZodObject<{
+    cycle: z.ZodNumber;
+    startedAt: z.ZodString;
+    completedAt: z.ZodString;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    workspaceFingerprint: z.ZodString;
+    verification: z.ZodObject<{
+        passed: z.ZodBoolean;
+        commands: z.ZodArray<z.ZodObject<{
+            command: z.ZodString;
+            args: z.ZodArray<z.ZodString>;
+            exitCode: z.ZodNullable<z.ZodNumber>;
+            stdout: z.ZodString;
+            stderr: z.ZodString;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        summary: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const LoopStateSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    loopId: z.ZodString;
+    goal: z.ZodString;
+    workspace: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    status: z.ZodEnum<{
+        blocked: "blocked";
+        budget_exhausted: "budget_exhausted";
+        cancelled: "cancelled";
+        failed: "failed";
+        needs_human: "needs_human";
+        no_progress: "no_progress";
+        running: "running";
+        succeeded: "succeeded";
+    }>;
+    config: z.ZodObject<{
+        cycleStep: z.ZodNumber;
+        tokenStep: z.ZodNumber;
+        isolation: z.ZodLiteral<"auto">;
+    }, z.core.$strict>;
+    budget: z.ZodObject<{
+        cyclesUsed: z.ZodNumber;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        cycleCheckpoint: z.ZodNumber;
+        tokenCheckpoint: z.ZodNumber;
+        approvals: z.ZodArray<z.ZodObject<{
+            dimension: z.ZodEnum<{
+                cycles: "cycles";
+                tokens: "tokens";
+            }>;
+            previousCheckpoint: z.ZodNumber;
+            newCheckpoint: z.ZodNumber;
+            usage: z.ZodNumber;
+            approvedAt: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    cycles: z.ZodArray<z.ZodObject<{
+        cycle: z.ZodNumber;
+        startedAt: z.ZodString;
+        completedAt: z.ZodString;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        workspaceFingerprint: z.ZodString;
+        verification: z.ZodObject<{
+            passed: z.ZodBoolean;
+            commands: z.ZodArray<z.ZodObject<{
+                command: z.ZodString;
+                args: z.ZodArray<z.ZodString>;
+                exitCode: z.ZodNullable<z.ZodNumber>;
+                stdout: z.ZodString;
+                stderr: z.ZodString;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            summary: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    terminalReason: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const LoopEventSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodEnum<{
+        budget_approved: "budget_approved";
+        created: "created";
+        cycle_completed: "cycle_completed";
+        cycle_started: "cycle_started";
+        terminal: "terminal";
+        verification: "verification";
+    }>;
+    timestamp: z.ZodString;
+    loopId: z.ZodString;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>;
+export type LoopStatus = z.infer<typeof LoopStatusSchema>;
+export type LoopApproval = z.infer<typeof LoopApprovalSchema>;
+export type LoopVerificationEvidence = z.infer<typeof LoopVerificationEvidenceSchema>;
+export type LoopCycleEvidence = z.infer<typeof LoopCycleEvidenceSchema>;
+export type LoopState = z.infer<typeof LoopStateSchema>;
+export type LoopEvent = z.infer<typeof LoopEventSchema>;

package/dist/loop/verifier.d.ts

@@ -0,0 +1,13 @@
+import type { ExecutionEnvironment } from "../execution/types.js";
+import type { LoopVerificationEvidence } from "./types.js";
+export interface VerificationCommand {
+    label: string;
+    command: string;
+    args: string[];
+}
+export interface VerificationPlan {
+    commands: VerificationCommand[];
+    needsHumanReason?: string;
+}
+export declare function inferVerificationPlan(workspace: string): Promise<VerificationPlan>;
+export declare function runVerificationPlan(plan: VerificationPlan, workspace: string, signal: AbortSignal, executionEnvironment?: ExecutionEnvironment): Promise<LoopVerificationEvidence>;