conatus 0.1.0

package/dist/types/suggest.d.ts

@@ -0,0 +1,92 @@
+import { z } from "zod";
+export declare const SuggestionRepoContextSchema: z.ZodObject<{
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+}, {
+    path: string;
+}>;
+export declare const SuggestionSchema: z.ZodObject<{
+    title: z.ZodString;
+    rationale: z.ZodString;
+    steps: z.ZodArray<z.ZodString, "many">;
+    success_criteria: z.ZodArray<z.ZodString, "many">;
+    repo_context: z.ZodObject<{
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+    }, {
+        path: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    rationale: string;
+    success_criteria: string[];
+    steps: string[];
+    repo_context: {
+        path: string;
+    };
+}, {
+    title: string;
+    rationale: string;
+    success_criteria: string[];
+    steps: string[];
+    repo_context: {
+        path: string;
+    };
+}>;
+export declare const SuggestOutputSchema: z.ZodObject<{
+    suggestions: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        rationale: z.ZodString;
+        steps: z.ZodArray<z.ZodString, "many">;
+        success_criteria: z.ZodArray<z.ZodString, "many">;
+        repo_context: z.ZodObject<{
+            path: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+        }, {
+            path: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        rationale: string;
+        success_criteria: string[];
+        steps: string[];
+        repo_context: {
+            path: string;
+        };
+    }, {
+        title: string;
+        rationale: string;
+        success_criteria: string[];
+        steps: string[];
+        repo_context: {
+            path: string;
+        };
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    suggestions: {
+        title: string;
+        rationale: string;
+        success_criteria: string[];
+        steps: string[];
+        repo_context: {
+            path: string;
+        };
+    }[];
+}, {
+    suggestions: {
+        title: string;
+        rationale: string;
+        success_criteria: string[];
+        steps: string[];
+        repo_context: {
+            path: string;
+        };
+    }[];
+}>;
+export type SuggestionRepoContext = z.infer<typeof SuggestionRepoContextSchema>;
+export type Suggestion = z.infer<typeof SuggestionSchema>;
+export type SuggestOutput = z.infer<typeof SuggestOutputSchema>;
+//# sourceMappingURL=suggest.d.ts.map

package/dist/types/suggest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suggest.d.ts","sourceRoot":"","sources":["../../src/types/suggest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,2BAA2B;;;;;;EAEtC,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM3B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE9B,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/types/suggest.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export const SuggestionRepoContextSchema = z.object({
+    path: z.string().trim().min(1),
+});
+export const SuggestionSchema = z.object({
+    title: z.string().trim().min(1),
+    rationale: z.string().trim().min(1),
+    steps: z.array(z.string().trim().min(1)).min(1),
+    success_criteria: z.array(z.string().trim().min(1)).min(1),
+    repo_context: SuggestionRepoContextSchema,
+});
+export const SuggestOutputSchema = z.object({
+    suggestions: z.array(SuggestionSchema).min(1),
+});
+//# sourceMappingURL=suggest.js.map

package/dist/types/suggest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"suggest.js","sourceRoot":"","sources":["../../src/types/suggest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,CAAC,MAAM,CAAC;IAClD,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CAC/B,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IACvC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/B,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACnC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/C,gBAAgB,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC1D,YAAY,EAAE,2BAA2B;CAC1C,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;CAC9C,CAAC,CAAC"}

package/dist/types/task-group.d.ts

@@ -0,0 +1,231 @@
+import { z } from "zod";
+export declare const TaskGroupSchema: z.ZodObject<{
+    subtasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        goal_id: z.ZodString;
+        strategy_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        target_dimensions: z.ZodArray<z.ZodString, "many">;
+        primary_dimension: z.ZodString;
+        work_description: z.ZodString;
+        rationale: z.ZodString;
+        approach: z.ZodString;
+        success_criteria: z.ZodArray<z.ZodObject<{
+            description: z.ZodString;
+            verification_method: z.ZodString;
+            is_blocking: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            description: string;
+            verification_method: string;
+            is_blocking: boolean;
+        }, {
+            description: string;
+            verification_method: string;
+            is_blocking?: boolean | undefined;
+        }>, "many">;
+        scope_boundary: z.ZodObject<{
+            in_scope: z.ZodArray<z.ZodString, "many">;
+            out_of_scope: z.ZodArray<z.ZodString, "many">;
+            blast_radius: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            in_scope: string[];
+            out_of_scope: string[];
+            blast_radius: string;
+        }, {
+            in_scope: string[];
+            out_of_scope: string[];
+            blast_radius: string;
+        }>;
+        constraints: z.ZodArray<z.ZodString, "many">;
+        plateau_until: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        estimated_duration: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            value: z.ZodNumber;
+            unit: z.ZodEnum<["minutes", "hours", "days", "weeks"]>;
+        }, "strip", z.ZodTypeAny, {
+            value: number;
+            unit: "minutes" | "hours" | "days" | "weeks";
+        }, {
+            value: number;
+            unit: "minutes" | "hours" | "days" | "weeks";
+        }>>>;
+        consecutive_failure_count: z.ZodDefault<z.ZodNumber>;
+        reversibility: z.ZodDefault<z.ZodEnum<["reversible", "irreversible", "unknown"]>>;
+        intended_direction: z.ZodOptional<z.ZodEnum<["increase", "decrease", "neutral"]>>;
+        task_category: z.ZodDefault<z.ZodEnum<["normal", "knowledge_acquisition", "verification", "observation", "capability_acquisition"]>>;
+        status: z.ZodDefault<z.ZodEnum<["pending", "running", "completed", "timed_out", "error"]>>;
+        started_at: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        completed_at: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        timeout_at: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        heartbeat_at: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        created_at: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        status: "error" | "pending" | "running" | "completed" | "timed_out";
+        id: string;
+        constraints: string[];
+        created_at: string;
+        goal_id: string;
+        strategy_id: string | null;
+        target_dimensions: string[];
+        primary_dimension: string;
+        work_description: string;
+        rationale: string;
+        approach: string;
+        success_criteria: {
+            description: string;
+            verification_method: string;
+            is_blocking: boolean;
+        }[];
+        scope_boundary: {
+            in_scope: string[];
+            out_of_scope: string[];
+            blast_radius: string;
+        };
+        plateau_until: string | null;
+        estimated_duration: {
+            value: number;
+            unit: "minutes" | "hours" | "days" | "weeks";
+        } | null;
+        consecutive_failure_count: number;
+        reversibility: "unknown" | "reversible" | "irreversible";
+        task_category: "normal" | "knowledge_acquisition" | "verification" | "observation" | "capability_acquisition";
+        started_at: string | null;
+        completed_at: string | null;
+        timeout_at: string | null;
+        heartbeat_at: string | null;
+        intended_direction?: "increase" | "decrease" | "neutral" | undefined;
+    }, {
+        id: string;
+        constraints: string[];
+        created_at: string;
+        goal_id: string;
+        target_dimensions: string[];
+        primary_dimension: string;
+        work_description: string;
+        rationale: string;
+        approach: string;
+        success_criteria: {
+            description: string;
+            verification_method: string;
+            is_blocking?: boolean | undefined;
+        }[];
+        scope_boundary: {
+            in_scope: string[];
+            out_of_scope: string[];
+            blast_radius: string;
+        };
+        status?: "error" | "pending" | "running" | "completed" | "timed_out" | undefined;
+        strategy_id?: string | null | undefined;
+        plateau_until?: string | null | undefined;
+        estimated_duration?: {
+            value: number;
+            unit: "minutes" | "hours" | "days" | "weeks";
+        } | null | undefined;
+        consecutive_failure_count?: number | undefined;
+        reversibility?: "unknown" | "reversible" | "irreversible" | undefined;
+        intended_direction?: "increase" | "decrease" | "neutral" | undefined;
+        task_category?: "normal" | "knowledge_acquisition" | "verification" | "observation" | "capability_acquisition" | undefined;
+        started_at?: string | null | undefined;
+        completed_at?: string | null | undefined;
+        timeout_at?: string | null | undefined;
+        heartbeat_at?: string | null | undefined;
+    }>, "many">;
+    dependencies: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        from: string;
+        to: string;
+    }, {
+        from: string;
+        to: string;
+    }>, "many">>;
+    file_ownership: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    shared_context: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    dependencies: {
+        from: string;
+        to: string;
+    }[];
+    subtasks: {
+        status: "error" | "pending" | "running" | "completed" | "timed_out";
+        id: string;
+        constraints: string[];
+        created_at: string;
+        goal_id: string;
+        strategy_id: string | null;
+        target_dimensions: string[];
+        primary_dimension: string;
+        work_description: string;
+        rationale: string;
+        approach: string;
+        success_criteria: {
+            description: string;
+            verification_method: string;
+            is_blocking: boolean;
+        }[];
+        scope_boundary: {
+            in_scope: string[];
+            out_of_scope: string[];
+            blast_radius: string;
+        };
+        plateau_until: string | null;
+        estimated_duration: {
+            value: number;
+            unit: "minutes" | "hours" | "days" | "weeks";
+        } | null;
+        consecutive_failure_count: number;
+        reversibility: "unknown" | "reversible" | "irreversible";
+        task_category: "normal" | "knowledge_acquisition" | "verification" | "observation" | "capability_acquisition";
+        started_at: string | null;
+        completed_at: string | null;
+        timeout_at: string | null;
+        heartbeat_at: string | null;
+        intended_direction?: "increase" | "decrease" | "neutral" | undefined;
+    }[];
+    file_ownership: Record<string, string[]>;
+    shared_context?: string | undefined;
+}, {
+    subtasks: {
+        id: string;
+        constraints: string[];
+        created_at: string;
+        goal_id: string;
+        target_dimensions: string[];
+        primary_dimension: string;
+        work_description: string;
+        rationale: string;
+        approach: string;
+        success_criteria: {
+            description: string;
+            verification_method: string;
+            is_blocking?: boolean | undefined;
+        }[];
+        scope_boundary: {
+            in_scope: string[];
+            out_of_scope: string[];
+            blast_radius: string;
+        };
+        status?: "error" | "pending" | "running" | "completed" | "timed_out" | undefined;
+        strategy_id?: string | null | undefined;
+        plateau_until?: string | null | undefined;
+        estimated_duration?: {
+            value: number;
+            unit: "minutes" | "hours" | "days" | "weeks";
+        } | null | undefined;
+        consecutive_failure_count?: number | undefined;
+        reversibility?: "unknown" | "reversible" | "irreversible" | undefined;
+        intended_direction?: "increase" | "decrease" | "neutral" | undefined;
+        task_category?: "normal" | "knowledge_acquisition" | "verification" | "observation" | "capability_acquisition" | undefined;
+        started_at?: string | null | undefined;
+        completed_at?: string | null | undefined;
+        timeout_at?: string | null | undefined;
+        heartbeat_at?: string | null | undefined;
+    }[];
+    dependencies?: {
+        from: string;
+        to: string;
+    }[] | undefined;
+    shared_context?: string | undefined;
+    file_ownership?: Record<string, string[]> | undefined;
+}>;
+export type TaskGroup = z.infer<typeof TaskGroupSchema>;
+//# sourceMappingURL=task-group.d.ts.map

package/dist/types/task-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-group.d.ts","sourceRoot":"","sources":["../../src/types/task-group.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAY1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/types/task-group.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { TaskSchema } from "./task.js";
+export const TaskGroupSchema = z.object({
+    subtasks: z.array(TaskSchema).min(2),
+    dependencies: z
+        .array(z.object({
+        from: z.string(),
+        to: z.string(),
+    }))
+        .default([]),
+    file_ownership: z.record(z.string(), z.array(z.string())).default({}),
+    shared_context: z.string().optional(),
+});
+//# sourceMappingURL=task-group.js.map

package/dist/types/task-group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-group.js","sourceRoot":"","sources":["../../src/types/task-group.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEvC,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC;IACtC,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACpC,YAAY,EAAE,CAAC;SACZ,KAAK,CACJ,CAAC,CAAC,MAAM,CAAC;QACP,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;QAChB,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;KACf,CAAC,CACH;SACA,OAAO,CAAC,EAAE,CAAC;IACd,cAAc,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;IACrE,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CACtC,CAAC,CAAC"}

package/dist/types/task.d.ts

@@ -0,0 +1,258 @@
+import { z } from "zod";
+export declare const CriterionSchema: z.ZodObject<{
+    description: z.ZodString;
+    verification_method: z.ZodString;
+    is_blocking: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    verification_method: string;
+    is_blocking: boolean;
+}, {
+    description: string;
+    verification_method: string;
+    is_blocking?: boolean | undefined;
+}>;
+export type Criterion = z.infer<typeof CriterionSchema>;
+export declare const ScopeBoundarySchema: z.ZodObject<{
+    in_scope: z.ZodArray<z.ZodString, "many">;
+    out_of_scope: z.ZodArray<z.ZodString, "many">;
+    blast_radius: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    in_scope: string[];
+    out_of_scope: string[];
+    blast_radius: string;
+}, {
+    in_scope: string[];
+    out_of_scope: string[];
+    blast_radius: string;
+}>;
+export type ScopeBoundary = z.infer<typeof ScopeBoundarySchema>;
+export declare const TaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    goal_id: z.ZodString;
+    strategy_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    target_dimensions: z.ZodArray<z.ZodString, "many">;
+    primary_dimension: z.ZodString;
+    work_description: z.ZodString;
+    rationale: z.ZodString;
+    approach: z.ZodString;
+    success_criteria: z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+        verification_method: z.ZodString;
+        is_blocking: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        verification_method: string;
+        is_blocking: boolean;
+    }, {
+        description: string;
+        verification_method: string;
+        is_blocking?: boolean | undefined;
+    }>, "many">;
+    scope_boundary: z.ZodObject<{
+        in_scope: z.ZodArray<z.ZodString, "many">;
+        out_of_scope: z.ZodArray<z.ZodString, "many">;
+        blast_radius: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        in_scope: string[];
+        out_of_scope: string[];
+        blast_radius: string;
+    }, {
+        in_scope: string[];
+        out_of_scope: string[];
+        blast_radius: string;
+    }>;
+    constraints: z.ZodArray<z.ZodString, "many">;
+    plateau_until: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    estimated_duration: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        value: z.ZodNumber;
+        unit: z.ZodEnum<["minutes", "hours", "days", "weeks"]>;
+    }, "strip", z.ZodTypeAny, {
+        value: number;
+        unit: "minutes" | "hours" | "days" | "weeks";
+    }, {
+        value: number;
+        unit: "minutes" | "hours" | "days" | "weeks";
+    }>>>;
+    consecutive_failure_count: z.ZodDefault<z.ZodNumber>;
+    reversibility: z.ZodDefault<z.ZodEnum<["reversible", "irreversible", "unknown"]>>;
+    intended_direction: z.ZodOptional<z.ZodEnum<["increase", "decrease", "neutral"]>>;
+    task_category: z.ZodDefault<z.ZodEnum<["normal", "knowledge_acquisition", "verification", "observation", "capability_acquisition"]>>;
+    status: z.ZodDefault<z.ZodEnum<["pending", "running", "completed", "timed_out", "error"]>>;
+    started_at: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    completed_at: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    timeout_at: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    heartbeat_at: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    created_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "error" | "pending" | "running" | "completed" | "timed_out";
+    id: string;
+    constraints: string[];
+    created_at: string;
+    goal_id: string;
+    strategy_id: string | null;
+    target_dimensions: string[];
+    primary_dimension: string;
+    work_description: string;
+    rationale: string;
+    approach: string;
+    success_criteria: {
+        description: string;
+        verification_method: string;
+        is_blocking: boolean;
+    }[];
+    scope_boundary: {
+        in_scope: string[];
+        out_of_scope: string[];
+        blast_radius: string;
+    };
+    plateau_until: string | null;
+    estimated_duration: {
+        value: number;
+        unit: "minutes" | "hours" | "days" | "weeks";
+    } | null;
+    consecutive_failure_count: number;
+    reversibility: "unknown" | "reversible" | "irreversible";
+    task_category: "normal" | "knowledge_acquisition" | "verification" | "observation" | "capability_acquisition";
+    started_at: string | null;
+    completed_at: string | null;
+    timeout_at: string | null;
+    heartbeat_at: string | null;
+    intended_direction?: "increase" | "decrease" | "neutral" | undefined;
+}, {
+    id: string;
+    constraints: string[];
+    created_at: string;
+    goal_id: string;
+    target_dimensions: string[];
+    primary_dimension: string;
+    work_description: string;
+    rationale: string;
+    approach: string;
+    success_criteria: {
+        description: string;
+        verification_method: string;
+        is_blocking?: boolean | undefined;
+    }[];
+    scope_boundary: {
+        in_scope: string[];
+        out_of_scope: string[];
+        blast_radius: string;
+    };
+    status?: "error" | "pending" | "running" | "completed" | "timed_out" | undefined;
+    strategy_id?: string | null | undefined;
+    plateau_until?: string | null | undefined;
+    estimated_duration?: {
+        value: number;
+        unit: "minutes" | "hours" | "days" | "weeks";
+    } | null | undefined;
+    consecutive_failure_count?: number | undefined;
+    reversibility?: "unknown" | "reversible" | "irreversible" | undefined;
+    intended_direction?: "increase" | "decrease" | "neutral" | undefined;
+    task_category?: "normal" | "knowledge_acquisition" | "verification" | "observation" | "capability_acquisition" | undefined;
+    started_at?: string | null | undefined;
+    completed_at?: string | null | undefined;
+    timeout_at?: string | null | undefined;
+    heartbeat_at?: string | null | undefined;
+}>;
+export type Task = z.infer<typeof TaskSchema>;
+export declare const EvidenceSchema: z.ZodObject<{
+    layer: z.ZodEnum<["mechanical", "independent_review", "self_report"]>;
+    description: z.ZodString;
+    confidence: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    confidence: number;
+    description: string;
+    layer: "mechanical" | "independent_review" | "self_report";
+}, {
+    confidence: number;
+    description: string;
+    layer: "mechanical" | "independent_review" | "self_report";
+}>;
+export type Evidence = z.infer<typeof EvidenceSchema>;
+export declare const DimensionUpdateSchema: z.ZodObject<{
+    dimension_name: z.ZodString;
+    previous_value: z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+    new_value: z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+    confidence: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    confidence: number;
+    dimension_name: string;
+    previous_value: string | number | boolean | null;
+    new_value: string | number | boolean | null;
+}, {
+    confidence: number;
+    dimension_name: string;
+    previous_value: string | number | boolean | null;
+    new_value: string | number | boolean | null;
+}>;
+export type DimensionUpdate = z.infer<typeof DimensionUpdateSchema>;
+export declare const VerificationResultSchema: z.ZodObject<{
+    task_id: z.ZodString;
+    verdict: z.ZodEnum<["pass", "partial", "fail"]>;
+    confidence: z.ZodNumber;
+    evidence: z.ZodArray<z.ZodObject<{
+        layer: z.ZodEnum<["mechanical", "independent_review", "self_report"]>;
+        description: z.ZodString;
+        confidence: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        confidence: number;
+        description: string;
+        layer: "mechanical" | "independent_review" | "self_report";
+    }, {
+        confidence: number;
+        description: string;
+        layer: "mechanical" | "independent_review" | "self_report";
+    }>, "many">;
+    dimension_updates: z.ZodArray<z.ZodObject<{
+        dimension_name: z.ZodString;
+        previous_value: z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+        new_value: z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+        confidence: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        confidence: number;
+        dimension_name: string;
+        previous_value: string | number | boolean | null;
+        new_value: string | number | boolean | null;
+    }, {
+        confidence: number;
+        dimension_name: string;
+        previous_value: string | number | boolean | null;
+        new_value: string | number | boolean | null;
+    }>, "many">;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    timestamp: string;
+    confidence: number;
+    task_id: string;
+    verdict: "pass" | "partial" | "fail";
+    evidence: {
+        confidence: number;
+        description: string;
+        layer: "mechanical" | "independent_review" | "self_report";
+    }[];
+    dimension_updates: {
+        confidence: number;
+        dimension_name: string;
+        previous_value: string | number | boolean | null;
+        new_value: string | number | boolean | null;
+    }[];
+}, {
+    timestamp: string;
+    confidence: number;
+    task_id: string;
+    verdict: "pass" | "partial" | "fail";
+    evidence: {
+        confidence: number;
+        description: string;
+        layer: "mechanical" | "independent_review" | "self_report";
+    }[];
+    dimension_updates: {
+        confidence: number;
+        dimension_name: string;
+        previous_value: string | number | boolean | null;
+        new_value: string | number | boolean | null;
+    }[];
+}>;
+export type VerificationResult = z.infer<typeof VerificationResultSchema>;
+//# sourceMappingURL=task.d.ts.map

package/dist/types/task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../src/types/task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAM,eAAe;;;;;;;;;;;;EAI1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAIxD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;EAI9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAIhE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCrB,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAI9C,eAAO,MAAM,cAAc;;;;;;;;;;;;EAIzB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAItD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;EAKhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAIpE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}