agent-bober 0.11.5 → 0.12.0

package/dist/contracts/spec.d.ts

@@ -1,101 +1,396 @@
 import { z } from "zod";
-export declare const PrioritySchema: z.ZodEnum<["must", "should", "could"]>;
+/**
+ * Threshold at which a spec must be marked needs-clarification rather than
+ * proceeding to sprint decomposition. Mirrors the planner agent's autonomous
+ * mode rule. Scores are 0..10 inclusive.
+ */
+export declare const AMBIGUITY_BLOCK_THRESHOLD = 7;
+export declare const PrioritySchema: z.ZodEnum<["must-have", "should-have", "nice-to-have"]>;
 export type Priority = z.infer<typeof PrioritySchema>;
+export declare const EstimatedComplexitySchema: z.ZodEnum<["low", "medium", "high"]>;
+export type EstimatedComplexity = z.infer<typeof EstimatedComplexitySchema>;
+/**
+ * Lifecycle of a plan spec.
+ *
+ * - `draft` — planner just emitted, no sprints run yet
+ * - `needs-clarification` — planner refused to fully decompose: ambiguityScore
+ *    >= 7 OR open questions remain. The pipeline will not run sprints from
+ *    this spec until status flips to `ready`.
+ * - `ready` — clarifications resolved (or never needed), pipeline may proceed
+ * - `in-progress` — at least one sprint has started
+ * - `completed` — all sprints finished
+ * - `abandoned` — planner or user explicitly dropped this spec
+ */
+export declare const PlanSpecStatusSchema: z.ZodEnum<["draft", "needs-clarification", "ready", "in-progress", "completed", "abandoned"]>;
+export type PlanSpecStatus = z.infer<typeof PlanSpecStatusSchema>;
+export declare const PlanSpecModeSchema: z.ZodEnum<["greenfield", "brownfield"]>;
+export type PlanSpecMode = z.infer<typeof PlanSpecModeSchema>;
+/**
+ * Categories the planner uses to group clarifying questions. Matches the
+ * categories listed in `.claude/agents/bober-planner.md` Phase 2.
+ */
+export declare const ClarificationCategorySchema: z.ZodEnum<["scope", "user-personas", "data-model", "tech-constraints", "design-ux", "integrations", "non-functional", "error-handling", "integration-risk", "pattern-conflict", "regression-risk", "other"]>;
+export type ClarificationCategory = z.infer<typeof ClarificationCategorySchema>;
+export declare const ClarificationOptionSchema: z.ZodObject<{
+    /** Short label shown to the user (e.g. "A", "B", "Custom") */
+    label: z.ZodString;
+    /** What this option means in plain English */
+    description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    label: string;
+}, {
+    description: string;
+    label: string;
+}>;
+export type ClarificationOption = z.infer<typeof ClarificationOptionSchema>;
+export declare const ClarificationQuestionSchema: z.ZodObject<{
+    questionId: z.ZodString;
+    category: z.ZodEnum<["scope", "user-personas", "data-model", "tech-constraints", "design-ux", "integrations", "non-functional", "error-handling", "integration-risk", "pattern-conflict", "regression-risk", "other"]>;
+    /** The question itself — should end with a "?" */
+    question: z.ZodString;
+    /** Optional multiple-choice options, including an "Other" escape hatch */
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /** Short label shown to the user (e.g. "A", "B", "Custom") */
+        label: z.ZodString;
+        /** What this option means in plain English */
+        description: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        label: string;
+    }, {
+        description: string;
+        label: string;
+    }>, "many">>;
+    /** Planner's recommended answer based on codebase evidence */
+    recommendation: z.ZodOptional<z.ZodString>;
+    /**
+     * How much this question contributes to the overall ambiguityScore.
+     * Useful for the user to know which questions matter most to resolve.
+     */
+    ambiguityWeight: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    questionId: string;
+    category: "other" | "scope" | "user-personas" | "data-model" | "tech-constraints" | "design-ux" | "integrations" | "non-functional" | "error-handling" | "integration-risk" | "pattern-conflict" | "regression-risk";
+    question: string;
+    options?: {
+        description: string;
+        label: string;
+    }[] | undefined;
+    recommendation?: string | undefined;
+    ambiguityWeight?: number | undefined;
+}, {
+    questionId: string;
+    category: "other" | "scope" | "user-personas" | "data-model" | "tech-constraints" | "design-ux" | "integrations" | "non-functional" | "error-handling" | "integration-risk" | "pattern-conflict" | "regression-risk";
+    question: string;
+    options?: {
+        description: string;
+        label: string;
+    }[] | undefined;
+    recommendation?: string | undefined;
+    ambiguityWeight?: number | undefined;
+}>;
+export type ClarificationQuestion = z.infer<typeof ClarificationQuestionSchema>;
+export declare const ResolvedClarificationSchema: z.ZodObject<{
+    questionId: z.ZodString;
+    /** The user-supplied answer (free-form, may reference an option label) */
+    answer: z.ZodString;
+    /** ISO 8601 timestamp when the answer was recorded */
+    resolvedAt: z.ZodString;
+    /** Who answered: "user" (interactive) or "planner" (autonomous self-answer) */
+    resolvedBy: z.ZodDefault<z.ZodEnum<["user", "planner"]>>;
+}, "strip", z.ZodTypeAny, {
+    questionId: string;
+    answer: string;
+    resolvedAt: string;
+    resolvedBy: "planner" | "user";
+}, {
+    questionId: string;
+    answer: string;
+    resolvedAt: string;
+    resolvedBy?: "planner" | "user" | undefined;
+}>;
+export type ResolvedClarification = z.infer<typeof ResolvedClarificationSchema>;
 export declare const FeatureSpecSchema: z.ZodObject<{
-    id: z.ZodString;
+    featureId: z.ZodString;
     title: z.ZodString;
     description: z.ZodString;
-    priority: z.ZodEnum<["must", "should", "could"]>;
-    estimatedSprints: z.ZodNumber;
+    priority: z.ZodEnum<["must-have", "should-have", "nice-to-have"]>;
     acceptanceCriteria: z.ZodArray<z.ZodString, "many">;
+    dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    estimatedComplexity: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    /** Legacy field kept for backward compat — prefer estimatedComplexity */
+    estimatedSprints: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     description: string;
-    id: string;
     title: string;
-    priority: "must" | "should" | "could";
-    estimatedSprints: number;
+    featureId: string;
+    priority: "must-have" | "should-have" | "nice-to-have";
     acceptanceCriteria: string[];
+    dependencies: string[];
+    estimatedComplexity?: "medium" | "low" | "high" | undefined;
+    estimatedSprints?: number | undefined;
 }, {
     description: string;
-    id: string;
     title: string;
-    priority: "must" | "should" | "could";
-    estimatedSprints: number;
+    featureId: string;
+    priority: "must-have" | "should-have" | "nice-to-have";
     acceptanceCriteria: string[];
+    dependencies?: string[] | undefined;
+    estimatedComplexity?: "medium" | "low" | "high" | undefined;
+    estimatedSprints?: number | undefined;
 }>;
 export type FeatureSpec = z.infer<typeof FeatureSpecSchema>;
 export declare const PlanSpecSchema: z.ZodObject<{
-    id: z.ZodString;
+    specId: z.ZodString;
+    version: z.ZodDefault<z.ZodNumber>;
     title: z.ZodString;
     description: z.ZodString;
-    projectType: z.ZodString;
-    techStack: z.ZodArray<z.ZodString, "many">;
+    status: z.ZodEnum<["draft", "needs-clarification", "ready", "in-progress", "completed", "abandoned"]>;
+    mode: z.ZodEnum<["greenfield", "brownfield"]>;
     features: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
+        featureId: z.ZodString;
         title: z.ZodString;
         description: z.ZodString;
-        priority: z.ZodEnum<["must", "should", "could"]>;
-        estimatedSprints: z.ZodNumber;
+        priority: z.ZodEnum<["must-have", "should-have", "nice-to-have"]>;
         acceptanceCriteria: z.ZodArray<z.ZodString, "many">;
+        dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        estimatedComplexity: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+        /** Legacy field kept for backward compat — prefer estimatedComplexity */
+        estimatedSprints: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         description: string;
-        id: string;
         title: string;
-        priority: "must" | "should" | "could";
-        estimatedSprints: number;
+        featureId: string;
+        priority: "must-have" | "should-have" | "nice-to-have";
         acceptanceCriteria: string[];
+        dependencies: string[];
+        estimatedComplexity?: "medium" | "low" | "high" | undefined;
+        estimatedSprints?: number | undefined;
     }, {
         description: string;
-        id: string;
         title: string;
-        priority: "must" | "should" | "could";
-        estimatedSprints: number;
+        featureId: string;
+        priority: "must-have" | "should-have" | "nice-to-have";
         acceptanceCriteria: string[];
+        dependencies?: string[] | undefined;
+        estimatedComplexity?: "medium" | "low" | "high" | undefined;
+        estimatedSprints?: number | undefined;
     }>, "many">;
-    nonFunctional: z.ZodArray<z.ZodString, "many">;
-    constraints: z.ZodArray<z.ZodString, "many">;
+    assumptions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    outOfScope: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Self-rated ambiguity 0..10. >= AMBIGUITY_BLOCK_THRESHOLD must result in
+     * status === "needs-clarification" with at least one open question.
+     */
+    ambiguityScore: z.ZodOptional<z.ZodNumber>;
+    /** Open questions awaiting user answer. Empty when status is ready/completed. */
+    clarificationQuestions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        questionId: z.ZodString;
+        category: z.ZodEnum<["scope", "user-personas", "data-model", "tech-constraints", "design-ux", "integrations", "non-functional", "error-handling", "integration-risk", "pattern-conflict", "regression-risk", "other"]>;
+        /** The question itself — should end with a "?" */
+        question: z.ZodString;
+        /** Optional multiple-choice options, including an "Other" escape hatch */
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            /** Short label shown to the user (e.g. "A", "B", "Custom") */
+            label: z.ZodString;
+            /** What this option means in plain English */
+            description: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            description: string;
+            label: string;
+        }, {
+            description: string;
+            label: string;
+        }>, "many">>;
+        /** Planner's recommended answer based on codebase evidence */
+        recommendation: z.ZodOptional<z.ZodString>;
+        /**
+         * How much this question contributes to the overall ambiguityScore.
+         * Useful for the user to know which questions matter most to resolve.
+         */
+        ambiguityWeight: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        questionId: string;
+        category: "other" | "scope" | "user-personas" | "data-model" | "tech-constraints" | "design-ux" | "integrations" | "non-functional" | "error-handling" | "integration-risk" | "pattern-conflict" | "regression-risk";
+        question: string;
+        options?: {
+            description: string;
+            label: string;
+        }[] | undefined;
+        recommendation?: string | undefined;
+        ambiguityWeight?: number | undefined;
+    }, {
+        questionId: string;
+        category: "other" | "scope" | "user-personas" | "data-model" | "tech-constraints" | "design-ux" | "integrations" | "non-functional" | "error-handling" | "integration-risk" | "pattern-conflict" | "regression-risk";
+        question: string;
+        options?: {
+            description: string;
+            label: string;
+        }[] | undefined;
+        recommendation?: string | undefined;
+        ambiguityWeight?: number | undefined;
+    }>, "many">>;
+    /** Question/answer history, both autonomous self-answers and user inputs */
+    resolvedClarifications: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        questionId: z.ZodString;
+        /** The user-supplied answer (free-form, may reference an option label) */
+        answer: z.ZodString;
+        /** ISO 8601 timestamp when the answer was recorded */
+        resolvedAt: z.ZodString;
+        /** Who answered: "user" (interactive) or "planner" (autonomous self-answer) */
+        resolvedBy: z.ZodDefault<z.ZodEnum<["user", "planner"]>>;
+    }, "strip", z.ZodTypeAny, {
+        questionId: string;
+        answer: string;
+        resolvedAt: string;
+        resolvedBy: "planner" | "user";
+    }, {
+        questionId: string;
+        answer: string;
+        resolvedAt: string;
+        resolvedBy?: "planner" | "user" | undefined;
+    }>, "many">>;
+    techStack: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    techNotes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    nonFunctionalRequirements: z.ZodDefault<z.ZodArray<z.ZodUnknown, "many">>;
+    constraints: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    sprints: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
+    completedAt: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
+    mode: "greenfield" | "brownfield";
+    status: "draft" | "needs-clarification" | "ready" | "in-progress" | "completed" | "abandoned";
     description: string;
-    id: string;
+    specId: string;
+    version: number;
     title: string;
-    projectType: string;
-    techStack: string[];
     features: {
         description: string;
-        id: string;
         title: string;
-        priority: "must" | "should" | "could";
-        estimatedSprints: number;
+        featureId: string;
+        priority: "must-have" | "should-have" | "nice-to-have";
         acceptanceCriteria: string[];
+        dependencies: string[];
+        estimatedComplexity?: "medium" | "low" | "high" | undefined;
+        estimatedSprints?: number | undefined;
+    }[];
+    assumptions: string[];
+    outOfScope: string[];
+    clarificationQuestions: {
+        questionId: string;
+        category: "other" | "scope" | "user-personas" | "data-model" | "tech-constraints" | "design-ux" | "integrations" | "non-functional" | "error-handling" | "integration-risk" | "pattern-conflict" | "regression-risk";
+        question: string;
+        options?: {
+            description: string;
+            label: string;
+        }[] | undefined;
+        recommendation?: string | undefined;
+        ambiguityWeight?: number | undefined;
     }[];
-    nonFunctional: string[];
+    resolvedClarifications: {
+        questionId: string;
+        answer: string;
+        resolvedAt: string;
+        resolvedBy: "planner" | "user";
+    }[];
+    techStack: string[];
+    nonFunctionalRequirements: unknown[];
     constraints: string[];
     createdAt: string;
     updatedAt: string;
+    ambiguityScore?: number | undefined;
+    techNotes?: Record<string, unknown> | undefined;
+    sprints?: unknown[] | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    completedAt?: string | undefined;
 }, {
+    mode: "greenfield" | "brownfield";
+    status: "draft" | "needs-clarification" | "ready" | "in-progress" | "completed" | "abandoned";
     description: string;
-    id: string;
+    specId: string;
     title: string;
-    projectType: string;
-    techStack: string[];
     features: {
         description: string;
-        id: string;
         title: string;
-        priority: "must" | "should" | "could";
-        estimatedSprints: number;
+        featureId: string;
+        priority: "must-have" | "should-have" | "nice-to-have";
         acceptanceCriteria: string[];
+        dependencies?: string[] | undefined;
+        estimatedComplexity?: "medium" | "low" | "high" | undefined;
+        estimatedSprints?: number | undefined;
     }[];
-    nonFunctional: string[];
-    constraints: string[];
     createdAt: string;
     updatedAt: string;
+    version?: number | undefined;
+    assumptions?: string[] | undefined;
+    outOfScope?: string[] | undefined;
+    ambiguityScore?: number | undefined;
+    clarificationQuestions?: {
+        questionId: string;
+        category: "other" | "scope" | "user-personas" | "data-model" | "tech-constraints" | "design-ux" | "integrations" | "non-functional" | "error-handling" | "integration-risk" | "pattern-conflict" | "regression-risk";
+        question: string;
+        options?: {
+            description: string;
+            label: string;
+        }[] | undefined;
+        recommendation?: string | undefined;
+        ambiguityWeight?: number | undefined;
+    }[] | undefined;
+    resolvedClarifications?: {
+        questionId: string;
+        answer: string;
+        resolvedAt: string;
+        resolvedBy?: "planner" | "user" | undefined;
+    }[] | undefined;
+    techStack?: string[] | undefined;
+    techNotes?: Record<string, unknown> | undefined;
+    nonFunctionalRequirements?: unknown[] | undefined;
+    constraints?: string[] | undefined;
+    sprints?: unknown[] | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    completedAt?: string | undefined;
 }>;
 export type PlanSpec = z.infer<typeof PlanSpecSchema>;
+export interface CreateSpecOptions {
+    mode?: PlanSpecMode;
+    status?: PlanSpecStatus;
+    ambiguityScore?: number;
+    clarificationQuestions?: ClarificationQuestion[];
+    assumptions?: string[];
+    outOfScope?: string[];
+    techStack?: string[];
+}
 /**
  * Create a new plan specification with sensible defaults.
  */
-export declare function createSpec(title: string, description: string, features: Omit<FeatureSpec, "id">[]): PlanSpec;
+export declare function createSpec(title: string, description: string, features: Omit<FeatureSpec, "featureId">[], options?: CreateSpecOptions): PlanSpec;
+/**
+ * Return true when the spec has unresolved clarification questions.
+ *
+ * NOTE: This checks question state only, NOT spec.status — `status` is
+ * downstream of this. If you want "is the pipeline blocked?", check
+ * `spec.status === "needs-clarification" || hasOpenClarifications(spec)`
+ * instead, or use `isPipelineReady(spec)`.
+ */
+export declare function hasOpenClarifications(spec: PlanSpec): boolean;
+/**
+ * Return true when the pipeline is allowed to run sprints from this spec.
+ * Combines the explicit status check with the question-resolution check.
+ */
+export declare function isPipelineReady(spec: PlanSpec): boolean;
+/**
+ * Return the questions that haven't been answered yet.
+ */
+export declare function getOpenClarifications(spec: PlanSpec): ClarificationQuestion[];
+/**
+ * Record an answer to a clarification question. Returns a new spec — does
+ * not mutate. If this answer was the last open question, the spec status
+ * flips from `needs-clarification` to `ready`.
+ *
+ * Throws if the questionId doesn't exist on the spec.
+ */
+export declare function resolveClarification(spec: PlanSpec, questionId: string, answer: string, resolvedBy?: ResolvedClarification["resolvedBy"]): PlanSpec;
 //# sourceMappingURL=spec.d.ts.map

package/dist/contracts/spec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spec.d.ts","sourceRoot":"","sources":["../../src/contracts/spec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,cAAc,wCAAsC,CAAC;AAClE,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAItD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;EAO5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAI5D,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWzB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAMtD;;GAEG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,EAAE,GAClC,QAAQ,CAoBV"}
+{"version":3,"file":"spec.d.ts","sourceRoot":"","sources":["../../src/contracts/spec.ts"],"names":[],"mappings":"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"}