@schilling.mark.a/atdd-guardian 1.0.0

package/dist/schemas/tool-schemas.d.ts

@@ -0,0 +1,404 @@
+/**
+ * Zod Schemas for MCP Tool Inputs (v2 — Context-Aware)
+ */
+import { z } from "zod";
+export declare const StartFeatureInputSchema: z.ZodObject<{
+    projectRoot: z.ZodString;
+    storyId: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    acceptanceCriteria: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        testStatus: z.ZodDefault<z.ZodEnum<["no-test", "red", "green", "skipped"]>>;
+        testFile: z.ZodOptional<z.ZodString>;
+        notes: z.ZodOptional<z.ZodString>;
+        unitCycles: z.ZodDefault<z.ZodArray<z.ZodAny, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        text: string;
+        testStatus: "no-test" | "red" | "green" | "skipped";
+        unitCycles: any[];
+        testFile?: string | undefined;
+        notes?: string | undefined;
+    }, {
+        id: string;
+        text: string;
+        testStatus?: "no-test" | "red" | "green" | "skipped" | undefined;
+        testFile?: string | undefined;
+        notes?: string | undefined;
+        unitCycles?: any[] | undefined;
+    }>, "many">;
+    architectureDecisions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        decision: z.ZodString;
+        rationale: z.ZodString;
+        implications: z.ZodArray<z.ZodString, "many">;
+        decidedBy: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        decision: string;
+        rationale: string;
+        implications: string[];
+        decidedBy?: string | undefined;
+    }, {
+        id: string;
+        decision: string;
+        rationale: string;
+        implications: string[];
+        decidedBy?: string | undefined;
+    }>, "many">>;
+    affectedModules: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    expectedFiles: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        purpose: z.ZodString;
+        fileType: z.ZodDefault<z.ZodEnum<["component", "service", "model", "spec", "e2e", "page-object", "step-def", "module", "pipe", "guard", "interceptor", "directive", "other"]>>;
+        status: z.ZodDefault<z.ZodEnum<["planned", "created", "modified", "reviewed"]>>;
+        relatedDecisions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        status: "planned" | "created" | "modified" | "reviewed";
+        purpose: string;
+        fileType: "component" | "service" | "model" | "spec" | "e2e" | "page-object" | "step-def" | "module" | "pipe" | "guard" | "interceptor" | "directive" | "other";
+        relatedDecisions?: string[] | undefined;
+    }, {
+        path: string;
+        purpose: string;
+        status?: "planned" | "created" | "modified" | "reviewed" | undefined;
+        fileType?: "component" | "service" | "model" | "spec" | "e2e" | "page-object" | "step-def" | "module" | "pipe" | "guard" | "interceptor" | "directive" | "other" | undefined;
+        relatedDecisions?: string[] | undefined;
+    }>, "many">>;
+    definitionOfDone: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        completed: z.ZodDefault<z.ZodBoolean>;
+        automatable: z.ZodDefault<z.ZodBoolean>;
+        automatedBy: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        text: string;
+        completed: boolean;
+        automatable: boolean;
+        automatedBy?: string | undefined;
+    }, {
+        id: string;
+        text: string;
+        completed?: boolean | undefined;
+        automatable?: boolean | undefined;
+        automatedBy?: string | undefined;
+    }>, "many">>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    projectRoot: string;
+    storyId: string;
+    title: string;
+    description: string;
+    acceptanceCriteria: {
+        id: string;
+        text: string;
+        testStatus: "no-test" | "red" | "green" | "skipped";
+        unitCycles: any[];
+        testFile?: string | undefined;
+        notes?: string | undefined;
+    }[];
+    architectureDecisions: {
+        id: string;
+        decision: string;
+        rationale: string;
+        implications: string[];
+        decidedBy?: string | undefined;
+    }[];
+    affectedModules: string[];
+    expectedFiles: {
+        path: string;
+        status: "planned" | "created" | "modified" | "reviewed";
+        purpose: string;
+        fileType: "component" | "service" | "model" | "spec" | "e2e" | "page-object" | "step-def" | "module" | "pipe" | "guard" | "interceptor" | "directive" | "other";
+        relatedDecisions?: string[] | undefined;
+    }[];
+    definitionOfDone: {
+        id: string;
+        text: string;
+        completed: boolean;
+        automatable: boolean;
+        automatedBy?: string | undefined;
+    }[];
+    reviewers?: string[] | undefined;
+    labels?: string[] | undefined;
+}, {
+    projectRoot: string;
+    storyId: string;
+    title: string;
+    description: string;
+    acceptanceCriteria: {
+        id: string;
+        text: string;
+        testStatus?: "no-test" | "red" | "green" | "skipped" | undefined;
+        testFile?: string | undefined;
+        notes?: string | undefined;
+        unitCycles?: any[] | undefined;
+    }[];
+    architectureDecisions?: {
+        id: string;
+        decision: string;
+        rationale: string;
+        implications: string[];
+        decidedBy?: string | undefined;
+    }[] | undefined;
+    affectedModules?: string[] | undefined;
+    expectedFiles?: {
+        path: string;
+        purpose: string;
+        status?: "planned" | "created" | "modified" | "reviewed" | undefined;
+        fileType?: "component" | "service" | "model" | "spec" | "e2e" | "page-object" | "step-def" | "module" | "pipe" | "guard" | "interceptor" | "directive" | "other" | undefined;
+        relatedDecisions?: string[] | undefined;
+    }[] | undefined;
+    definitionOfDone?: {
+        id: string;
+        text: string;
+        completed?: boolean | undefined;
+        automatable?: boolean | undefined;
+        automatedBy?: string | undefined;
+    }[] | undefined;
+    reviewers?: string[] | undefined;
+    labels?: string[] | undefined;
+}>;
+export type StartFeatureInput = z.infer<typeof StartFeatureInputSchema>;
+export declare const AdvancePhaseInputSchema: z.ZodObject<{
+    projectRoot: z.ZodString;
+    phase: z.ZodEnum<["requirements", "test-design", "implementation", "refactor", "pre-pr-review", "pr-submitted", "pr-feedback", "done"]>;
+}, "strict", z.ZodTypeAny, {
+    projectRoot: string;
+    phase: "requirements" | "test-design" | "implementation" | "refactor" | "pre-pr-review" | "pr-submitted" | "pr-feedback" | "done";
+}, {
+    projectRoot: string;
+    phase: "requirements" | "test-design" | "implementation" | "refactor" | "pre-pr-review" | "pr-submitted" | "pr-feedback" | "done";
+}>;
+export type AdvancePhaseInput = z.infer<typeof AdvancePhaseInputSchema>;
+export declare const UpdateCriterionInputSchema: z.ZodObject<{
+    projectRoot: z.ZodString;
+    criterionId: z.ZodString;
+    testStatus: z.ZodEnum<["no-test", "red", "green", "skipped"]>;
+    testFile: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    testStatus: "no-test" | "red" | "green" | "skipped";
+    projectRoot: string;
+    criterionId: string;
+    testFile?: string | undefined;
+}, {
+    testStatus: "no-test" | "red" | "green" | "skipped";
+    projectRoot: string;
+    criterionId: string;
+    testFile?: string | undefined;
+}>;
+export type UpdateCriterionInput = z.infer<typeof UpdateCriterionInputSchema>;
+export declare const ReviewCodeInputSchema: z.ZodObject<{
+    directory: z.ZodString;
+    rulesFile: z.ZodOptional<z.ZodString>;
+    includePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    excludePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    severityFilter: z.ZodOptional<z.ZodArray<z.ZodEnum<["error", "warning", "info"]>, "many">>;
+    categoryFilter: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    format: z.ZodDefault<z.ZodEnum<["markdown", "json"]>>;
+}, "strict", z.ZodTypeAny, {
+    directory: string;
+    format: "markdown" | "json";
+    rulesFile?: string | undefined;
+    includePatterns?: string[] | undefined;
+    excludePatterns?: string[] | undefined;
+    severityFilter?: ("error" | "warning" | "info")[] | undefined;
+    categoryFilter?: string[] | undefined;
+}, {
+    directory: string;
+    rulesFile?: string | undefined;
+    includePatterns?: string[] | undefined;
+    excludePatterns?: string[] | undefined;
+    severityFilter?: ("error" | "warning" | "info")[] | undefined;
+    categoryFilter?: string[] | undefined;
+    format?: "markdown" | "json" | undefined;
+}>;
+export type ReviewCodeInput = z.infer<typeof ReviewCodeInputSchema>;
+export declare const ReviewFileInputSchema: z.ZodObject<{
+    filePath: z.ZodString;
+    projectRoot: z.ZodString;
+    rulesFile: z.ZodOptional<z.ZodString>;
+    format: z.ZodDefault<z.ZodEnum<["markdown", "json"]>>;
+}, "strict", z.ZodTypeAny, {
+    projectRoot: string;
+    format: "markdown" | "json";
+    filePath: string;
+    rulesFile?: string | undefined;
+}, {
+    projectRoot: string;
+    filePath: string;
+    rulesFile?: string | undefined;
+    format?: "markdown" | "json" | undefined;
+}>;
+export type ReviewFileInput = z.infer<typeof ReviewFileInputSchema>;
+export declare const GetContextInputSchema: z.ZodObject<{
+    projectRoot: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    projectRoot: string;
+}, {
+    projectRoot: string;
+}>;
+export type GetContextInput = z.infer<typeof GetContextInputSchema>;
+export declare const ListRulesInputSchema: z.ZodObject<{
+    rulesFile: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    rulesFile?: string | undefined;
+    category?: string | undefined;
+}, {
+    rulesFile?: string | undefined;
+    category?: string | undefined;
+}>;
+export type ListRulesInput = z.infer<typeof ListRulesInputSchema>;
+export declare const ExplainRuleInputSchema: z.ZodObject<{
+    ruleId: z.ZodString;
+    rulesFile: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    ruleId: string;
+    rulesFile?: string | undefined;
+}, {
+    ruleId: string;
+    rulesFile?: string | undefined;
+}>;
+export type ExplainRuleInput = z.infer<typeof ExplainRuleInputSchema>;
+export declare const AddRuleInputSchema: z.ZodObject<{
+    rulesFile: z.ZodString;
+    id: z.ZodString;
+    name: z.ZodString;
+    category: z.ZodString;
+    severity: z.ZodEnum<["error", "warning", "info"]>;
+    description: z.ZodString;
+    applicablePhases: z.ZodDefault<z.ZodArray<z.ZodEnum<["requirements", "test-design", "implementation", "refactor", "pre-pr-review", "pr-submitted", "pr-feedback", "done"]>, "many">>;
+    pattern: z.ZodOptional<z.ZodString>;
+    matchIsViolation: z.ZodBoolean;
+    appliesTo: z.ZodArray<z.ZodString, "many">;
+    excludes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    suggestion: z.ZodString;
+    goodExample: z.ZodOptional<z.ZodString>;
+    badExample: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    description: string;
+    rulesFile: string;
+    category: string;
+    name: string;
+    severity: "error" | "warning" | "info";
+    applicablePhases: ("requirements" | "test-design" | "implementation" | "refactor" | "pre-pr-review" | "pr-submitted" | "pr-feedback" | "done")[];
+    matchIsViolation: boolean;
+    appliesTo: string[];
+    suggestion: string;
+    pattern?: string | undefined;
+    excludes?: string[] | undefined;
+    goodExample?: string | undefined;
+    badExample?: string | undefined;
+}, {
+    id: string;
+    description: string;
+    rulesFile: string;
+    category: string;
+    name: string;
+    severity: "error" | "warning" | "info";
+    matchIsViolation: boolean;
+    appliesTo: string[];
+    suggestion: string;
+    applicablePhases?: ("requirements" | "test-design" | "implementation" | "refactor" | "pre-pr-review" | "pr-submitted" | "pr-feedback" | "done")[] | undefined;
+    pattern?: string | undefined;
+    excludes?: string[] | undefined;
+    goodExample?: string | undefined;
+    badExample?: string | undefined;
+}>;
+export type AddRuleInput = z.infer<typeof AddRuleInputSchema>;
+export declare const RecordPrFeedbackInputSchema: z.ZodObject<{
+    projectRoot: z.ZodString;
+    feedback: z.ZodArray<z.ZodString, "many">;
+    notes: z.ZodDefault<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    notes: string;
+    projectRoot: string;
+    feedback: string[];
+}, {
+    projectRoot: string;
+    feedback: string[];
+    notes?: string | undefined;
+}>;
+export type RecordPrFeedbackInput = z.infer<typeof RecordPrFeedbackInputSchema>;
+export declare const StartUnitCycleInputSchema: z.ZodObject<{
+    projectRoot: z.ZodString;
+    criterionId: z.ZodString;
+    unitDescription: z.ZodString;
+    testFile: z.ZodString;
+    sourceFile: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    testFile: string;
+    projectRoot: string;
+    criterionId: string;
+    unitDescription: string;
+    sourceFile: string;
+}, {
+    testFile: string;
+    projectRoot: string;
+    criterionId: string;
+    unitDescription: string;
+    sourceFile: string;
+}>;
+export type StartUnitCycleInput = z.infer<typeof StartUnitCycleInputSchema>;
+export declare const AdvanceUnitCycleInputSchema: z.ZodObject<{
+    projectRoot: z.ZodString;
+    criterionId: z.ZodString;
+    cycleNumber: z.ZodNumber;
+    targetState: z.ZodEnum<["green", "refactored", "abandoned"]>;
+    notes: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    projectRoot: string;
+    criterionId: string;
+    cycleNumber: number;
+    targetState: "green" | "refactored" | "abandoned";
+    notes?: string | undefined;
+}, {
+    projectRoot: string;
+    criterionId: string;
+    cycleNumber: number;
+    targetState: "green" | "refactored" | "abandoned";
+    notes?: string | undefined;
+}>;
+export type AdvanceUnitCycleInput = z.infer<typeof AdvanceUnitCycleInputSchema>;
+export declare const RunTestsInputSchema: z.ZodObject<{
+    projectRoot: z.ZodString;
+    testLevel: z.ZodEnum<["acceptance", "unit", "all"]>;
+    command: z.ZodOptional<z.ZodString>;
+    testFile: z.ZodOptional<z.ZodString>;
+    relatedCriterionId: z.ZodOptional<z.ZodString>;
+    relatedUnitCycle: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    projectRoot: string;
+    testLevel: "acceptance" | "unit" | "all";
+    testFile?: string | undefined;
+    command?: string | undefined;
+    relatedCriterionId?: string | undefined;
+    relatedUnitCycle?: number | undefined;
+}, {
+    projectRoot: string;
+    testLevel: "acceptance" | "unit" | "all";
+    testFile?: string | undefined;
+    command?: string | undefined;
+    relatedCriterionId?: string | undefined;
+    relatedUnitCycle?: number | undefined;
+}>;
+export type RunTestsInput = z.infer<typeof RunTestsInputSchema>;
+export declare const GetTddStatusInputSchema: z.ZodObject<{
+    projectRoot: z.ZodString;
+    criterionId: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    projectRoot: string;
+    criterionId?: string | undefined;
+}, {
+    projectRoot: string;
+    criterionId?: string | undefined;
+}>;
+export type GetTddStatusInput = z.infer<typeof GetTddStatusInputSchema>;
+//# sourceMappingURL=tool-schemas.d.ts.map

package/dist/schemas/tool-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-schemas.d.ts","sourceRoot":"","sources":["../../src/schemas/tool-schemas.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAkExB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BzB,CAAC;AAEZ,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAMxE,eAAO,MAAM,uBAAuB;;;;;;;;;EAKzB,CAAC;AAEZ,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAMxE,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;EAO5B,CAAC;AAEZ,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAM9E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;EAUvB,CAAC;AAEZ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAMpE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;EAOvB,CAAC;AAEZ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAMpE,eAAO,MAAM,qBAAqB;;;;;;EAIvB,CAAC;AAEZ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAMpE,eAAO,MAAM,oBAAoB;;;;;;;;;EAKtB,CAAC;AAEZ,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,sBAAsB;;;;;;;;;EAKxB,CAAC;AAEZ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBpB,CAAC;AAEZ,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAM9D,eAAO,MAAM,2BAA2B;;;;;;;;;;;;EAS7B,CAAC;AAEZ,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAMhF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;EAoB3B,CAAC;AAEZ,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;EAa7B,CAAC;AAEZ,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAMhF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;EAuBrB,CAAC;AAEZ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAMhE,eAAO,MAAM,uBAAuB;;;;;;;;;EAQzB,CAAC;AAEZ,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/schemas/tool-schemas.js

@@ -0,0 +1,267 @@
+/**
+ * Zod Schemas for MCP Tool Inputs (v2 — Context-Aware)
+ */
+import { z } from "zod";
+// ─── Shared enums ────────────────────────────────────────────────
+const AtddPhaseEnum = z.enum([
+    "requirements",
+    "test-design",
+    "implementation",
+    "refactor",
+    "pre-pr-review",
+    "pr-submitted",
+    "pr-feedback",
+    "done",
+]);
+const SeverityEnum = z.enum(["error", "warning", "info"]);
+// ═══════════════════════════════════════════════════════════════════
+// start_feature — Set the story context for everything that follows
+// ═══════════════════════════════════════════════════════════════════
+const AcceptanceCriterionSchema = z.object({
+    id: z.string().describe("Unique AC id, e.g. 'AC-1'"),
+    text: z.string().describe("The criterion in Given/When/Then or plain language"),
+    testStatus: z
+        .enum(["no-test", "red", "green", "skipped"])
+        .default("no-test"),
+    testFile: z.string().optional(),
+    notes: z.string().optional(),
+    unitCycles: z.array(z.any()).default([]).describe("Managed by start_unit_cycle / advance_unit_cycle tools"),
+});
+const ArchitectureDecisionSchema = z.object({
+    id: z.string().describe("Decision id, e.g. 'AD-1'"),
+    decision: z.string().describe("What was decided"),
+    rationale: z.string().describe("Why"),
+    implications: z
+        .array(z.string())
+        .describe("What this means for implementation"),
+    decidedBy: z.string().optional(),
+});
+const ExpectedFileSchema = z.object({
+    path: z.string().describe("Relative path from project root"),
+    purpose: z.string().describe("What this file should contain"),
+    fileType: z
+        .enum([
+        "component", "service", "model", "spec", "e2e",
+        "page-object", "step-def", "module", "pipe",
+        "guard", "interceptor", "directive", "other",
+    ])
+        .default("other"),
+    status: z
+        .enum(["planned", "created", "modified", "reviewed"])
+        .default("planned"),
+    relatedDecisions: z.array(z.string()).optional(),
+});
+const DodItemSchema = z.object({
+    id: z.string(),
+    text: z.string(),
+    completed: z.boolean().default(false),
+    automatable: z.boolean().default(false),
+    automatedBy: z.string().optional(),
+});
+export const StartFeatureInputSchema = z
+    .object({
+    projectRoot: z.string().min(1).describe("Absolute path to project root"),
+    storyId: z.string().min(1).describe("Jira/ADO story ID, e.g. 'PROJ-1234'"),
+    title: z.string().min(1).describe("Story title"),
+    description: z.string().describe("Full story description or user story text"),
+    acceptanceCriteria: z
+        .array(AcceptanceCriterionSchema)
+        .min(1)
+        .describe("Acceptance criteria — these drive what gets tested and reviewed"),
+    architectureDecisions: z
+        .array(ArchitectureDecisionSchema)
+        .default([])
+        .describe("Architecture decisions made for this feature"),
+    affectedModules: z
+        .array(z.string())
+        .default([])
+        .describe("Module paths affected by this feature"),
+    expectedFiles: z
+        .array(ExpectedFileSchema)
+        .default([])
+        .describe("Files expected to be created or modified"),
+    definitionOfDone: z
+        .array(DodItemSchema)
+        .default([])
+        .describe("DoD checklist items"),
+    reviewers: z.array(z.string()).optional(),
+    labels: z.array(z.string()).optional(),
+})
+    .strict();
+// ═══════════════════════════════════════════════════════════════════
+// advance_phase — Move to next ATDD phase
+// ═══════════════════════════════════════════════════════════════════
+export const AdvancePhaseInputSchema = z
+    .object({
+    projectRoot: z.string().min(1),
+    phase: AtddPhaseEnum.describe("The ATDD phase to advance to"),
+})
+    .strict();
+// ═══════════════════════════════════════════════════════════════════
+// update_criterion — Update AC test status
+// ═══════════════════════════════════════════════════════════════════
+export const UpdateCriterionInputSchema = z
+    .object({
+    projectRoot: z.string().min(1),
+    criterionId: z.string().min(1).describe("AC id to update, e.g. 'AC-1'"),
+    testStatus: z.enum(["no-test", "red", "green", "skipped"]),
+    testFile: z.string().optional().describe("Path to the test file covering this AC"),
+})
+    .strict();
+// ═══════════════════════════════════════════════════════════════════
+// review_code — Context-aware full review
+// ═══════════════════════════════════════════════════════════════════
+export const ReviewCodeInputSchema = z
+    .object({
+    directory: z.string().min(1).describe("Absolute path to project root"),
+    rulesFile: z.string().optional(),
+    includePatterns: z.array(z.string()).optional(),
+    excludePatterns: z.array(z.string()).optional(),
+    severityFilter: z.array(SeverityEnum).optional(),
+    categoryFilter: z.array(z.string()).optional(),
+    format: z.enum(["markdown", "json"]).default("markdown"),
+})
+    .strict();
+// ═══════════════════════════════════════════════════════════════════
+// review_file — Quick single-file review
+// ═══════════════════════════════════════════════════════════════════
+export const ReviewFileInputSchema = z
+    .object({
+    filePath: z.string().min(1),
+    projectRoot: z.string().min(1),
+    rulesFile: z.string().optional(),
+    format: z.enum(["markdown", "json"]).default("markdown"),
+})
+    .strict();
+// ═══════════════════════════════════════════════════════════════════
+// get_context — Show current feature context and workflow state
+// ═══════════════════════════════════════════════════════════════════
+export const GetContextInputSchema = z
+    .object({
+    projectRoot: z.string().min(1),
+})
+    .strict();
+// ═══════════════════════════════════════════════════════════════════
+// list_rules / explain_rule / add_rule (unchanged from v1)
+// ═══════════════════════════════════════════════════════════════════
+export const ListRulesInputSchema = z
+    .object({
+    rulesFile: z.string().optional(),
+    category: z.string().optional(),
+})
+    .strict();
+export const ExplainRuleInputSchema = z
+    .object({
+    ruleId: z.string().min(1),
+    rulesFile: z.string().optional(),
+})
+    .strict();
+export const AddRuleInputSchema = z
+    .object({
+    rulesFile: z.string().min(1),
+    id: z.string().min(1),
+    name: z.string().min(1),
+    category: z.string().min(1),
+    severity: SeverityEnum,
+    description: z.string().min(1),
+    applicablePhases: z.array(AtddPhaseEnum).default(["pre-pr-review"]),
+    pattern: z.string().optional(),
+    matchIsViolation: z.boolean(),
+    appliesTo: z.array(z.string()).min(1),
+    excludes: z.array(z.string()).optional(),
+    suggestion: z.string().min(1),
+    goodExample: z.string().optional(),
+    badExample: z.string().optional(),
+})
+    .strict();
+// ═══════════════════════════════════════════════════════════════════
+// record_pr_feedback — PDCA Check phase
+// ═══════════════════════════════════════════════════════════════════
+export const RecordPrFeedbackInputSchema = z
+    .object({
+    projectRoot: z.string().min(1),
+    feedback: z
+        .array(z.string())
+        .min(1)
+        .describe("List of PR rejection reasons or reviewer comments"),
+    notes: z.string().default("").describe("Additional notes about the feedback"),
+})
+    .strict();
+// ═══════════════════════════════════════════════════════════════════
+// start_unit_cycle / advance_unit_cycle — Track nested unit TDD RED→GREEN→REFACTOR
+// ═══════════════════════════════════════════════════════════════════
+export const StartUnitCycleInputSchema = z
+    .object({
+    projectRoot: z.string().min(1),
+    criterionId: z
+        .string()
+        .min(1)
+        .describe("AC id this unit cycle belongs to, e.g. 'AC-1'"),
+    unitDescription: z
+        .string()
+        .min(1)
+        .describe("What unit of behavior is being implemented, e.g. 'validate email format'"),
+    testFile: z
+        .string()
+        .min(1)
+        .describe("Path to the unit test file"),
+    sourceFile: z
+        .string()
+        .min(1)
+        .describe("Path to the production code file"),
+})
+    .strict();
+export const AdvanceUnitCycleInputSchema = z
+    .object({
+    projectRoot: z.string().min(1),
+    criterionId: z.string().min(1).describe("AC id"),
+    cycleNumber: z.number().int().min(1).describe("Unit cycle number"),
+    targetState: z
+        .enum(["green", "refactored", "abandoned"])
+        .describe("State to advance to: red→green→refactored, or abandoned"),
+    notes: z
+        .string()
+        .optional()
+        .describe("Refactoring notes or abandonment reason"),
+})
+    .strict();
+// ═══════════════════════════════════════════════════════════════════
+// run_tests — Execute tests and capture results
+// ═══════════════════════════════════════════════════════════════════
+export const RunTestsInputSchema = z
+    .object({
+    projectRoot: z.string().min(1),
+    testLevel: z
+        .enum(["acceptance", "unit", "all"])
+        .describe("Which tests to run"),
+    command: z
+        .string()
+        .optional()
+        .describe("Override the test command (uses config defaults otherwise)"),
+    testFile: z
+        .string()
+        .optional()
+        .describe("Run a specific test file"),
+    relatedCriterionId: z
+        .string()
+        .optional()
+        .describe("AC id this test run verifies"),
+    relatedUnitCycle: z
+        .number()
+        .optional()
+        .describe("Unit cycle number this test run verifies"),
+})
+    .strict();
+// ═══════════════════════════════════════════════════════════════════
+// get_tdd_status — Show nested TDD cycle status for an AC
+// ═══════════════════════════════════════════════════════════════════
+export const GetTddStatusInputSchema = z
+    .object({
+    projectRoot: z.string().min(1),
+    criterionId: z
+        .string()
+        .optional()
+        .describe("Specific AC to show. If omitted, shows all ACs."),
+})
+    .strict();
+//# sourceMappingURL=tool-schemas.js.map