sequant 1.10.0 → 1.11.0

package/dist/src/lib/workflow/state-schema.d.ts

@@ -20,7 +20,7 @@ import { z } from "zod";
 /**
  * Workflow phases in order of execution
  */
-export declare const WORKFLOW_PHASES: readonly ["spec", "security-review", "exec", "testgen", "test", "qa", "loop"];
+export declare const WORKFLOW_PHASES: readonly ["spec", "security-review", "exec", "testgen", "test", "verify", "qa", "loop", "merger"];
 /**
  * Phase status - tracks individual phase progress
  */
@@ -38,6 +38,7 @@ export type PhaseStatus = z.infer<typeof PhaseStatusSchema>;
 export declare const IssueStatusSchema: z.ZodEnum<{
     in_progress: "in_progress";
     not_started: "not_started";
+    waiting_for_qa_gate: "waiting_for_qa_gate";
     ready_for_merge: "ready_for_merge";
     merged: "merged";
     blocked: "blocked";
@@ -49,12 +50,14 @@ export type IssueStatus = z.infer<typeof IssueStatusSchema>;
  */
 export declare const PhaseSchema: z.ZodEnum<{
     loop: "loop";
+    verify: "verify";
     spec: "spec";
     exec: "exec";
     qa: "qa";
     "security-review": "security-review";
     testgen: "testgen";
     test: "test";
+    merger: "merger";
 }>;
 export type Phase = z.infer<typeof PhaseSchema>;
 /**
@@ -91,6 +94,80 @@ export declare const LoopStateSchema: z.ZodObject<{
     maxIterations: z.ZodNumber;
 }, z.core.$strip>;
 export type LoopState = z.infer<typeof LoopStateSchema>;
+/**
+ * Acceptance criteria verification status
+ */
+export declare const ACStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    blocked: "blocked";
+    met: "met";
+    not_met: "not_met";
+}>;
+export type ACStatus = z.infer<typeof ACStatusSchema>;
+/**
+ * Acceptance criteria verification method
+ */
+export declare const ACVerificationMethodSchema: z.ZodEnum<{
+    unit_test: "unit_test";
+    integration_test: "integration_test";
+    browser_test: "browser_test";
+    manual: "manual";
+}>;
+export type ACVerificationMethod = z.infer<typeof ACVerificationMethodSchema>;
+/**
+ * Individual acceptance criterion state
+ */
+export declare const AcceptanceCriterionSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    verificationMethod: z.ZodEnum<{
+        unit_test: "unit_test";
+        integration_test: "integration_test";
+        browser_test: "browser_test";
+        manual: "manual";
+    }>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        blocked: "blocked";
+        met: "met";
+        not_met: "not_met";
+    }>;
+    verifiedAt: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AcceptanceCriterion = z.infer<typeof AcceptanceCriterionSchema>;
+/**
+ * Acceptance criteria tracking for an issue
+ */
+export declare const AcceptanceCriteriaSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        verificationMethod: z.ZodEnum<{
+            unit_test: "unit_test";
+            integration_test: "integration_test";
+            browser_test: "browser_test";
+            manual: "manual";
+        }>;
+        status: z.ZodEnum<{
+            pending: "pending";
+            blocked: "blocked";
+            met: "met";
+            not_met: "not_met";
+        }>;
+        verifiedAt: z.ZodOptional<z.ZodString>;
+        notes: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    extractedAt: z.ZodString;
+    summary: z.ZodObject<{
+        total: z.ZodNumber;
+        met: z.ZodNumber;
+        notMet: z.ZodNumber;
+        pending: z.ZodNumber;
+        blocked: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type AcceptanceCriteria = z.infer<typeof AcceptanceCriteriaSchema>;
 /**
  * Complete state for a single issue
  */
@@ -100,6 +177,7 @@ export declare const IssueStateSchema: z.ZodObject<{
     status: z.ZodEnum<{
         in_progress: "in_progress";
         not_started: "not_started";
+        waiting_for_qa_gate: "waiting_for_qa_gate";
         ready_for_merge: "ready_for_merge";
         merged: "merged";
         blocked: "blocked";
@@ -109,12 +187,14 @@ export declare const IssueStateSchema: z.ZodObject<{
     branch: z.ZodOptional<z.ZodString>;
     currentPhase: z.ZodOptional<z.ZodEnum<{
         loop: "loop";
+        verify: "verify";
         spec: "spec";
         exec: "exec";
         qa: "qa";
         "security-review": "security-review";
         testgen: "testgen";
         test: "test";
+        merger: "merger";
     }>>;
     phases: z.ZodRecord<z.ZodString, z.ZodObject<{
         status: z.ZodEnum<{
@@ -138,6 +218,34 @@ export declare const IssueStateSchema: z.ZodObject<{
         iteration: z.ZodNumber;
         maxIterations: z.ZodNumber;
     }, z.core.$strip>>;
+    acceptanceCriteria: z.ZodOptional<z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            verificationMethod: z.ZodEnum<{
+                unit_test: "unit_test";
+                integration_test: "integration_test";
+                browser_test: "browser_test";
+                manual: "manual";
+            }>;
+            status: z.ZodEnum<{
+                pending: "pending";
+                blocked: "blocked";
+                met: "met";
+                not_met: "not_met";
+            }>;
+            verifiedAt: z.ZodOptional<z.ZodString>;
+            notes: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        extractedAt: z.ZodString;
+        summary: z.ZodObject<{
+            total: z.ZodNumber;
+            met: z.ZodNumber;
+            notMet: z.ZodNumber;
+            pending: z.ZodNumber;
+            blocked: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
     sessionId: z.ZodOptional<z.ZodString>;
     lastActivity: z.ZodString;
     createdAt: z.ZodString;
@@ -157,6 +265,7 @@ export declare const WorkflowStateSchema: z.ZodObject<{
         status: z.ZodEnum<{
             in_progress: "in_progress";
             not_started: "not_started";
+            waiting_for_qa_gate: "waiting_for_qa_gate";
             ready_for_merge: "ready_for_merge";
             merged: "merged";
             blocked: "blocked";
@@ -166,12 +275,14 @@ export declare const WorkflowStateSchema: z.ZodObject<{
         branch: z.ZodOptional<z.ZodString>;
         currentPhase: z.ZodOptional<z.ZodEnum<{
             loop: "loop";
+            verify: "verify";
             spec: "spec";
             exec: "exec";
             qa: "qa";
             "security-review": "security-review";
             testgen: "testgen";
             test: "test";
+            merger: "merger";
         }>>;
         phases: z.ZodRecord<z.ZodString, z.ZodObject<{
             status: z.ZodEnum<{
@@ -195,6 +306,34 @@ export declare const WorkflowStateSchema: z.ZodObject<{
             iteration: z.ZodNumber;
             maxIterations: z.ZodNumber;
         }, z.core.$strip>>;
+        acceptanceCriteria: z.ZodOptional<z.ZodObject<{
+            items: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                description: z.ZodString;
+                verificationMethod: z.ZodEnum<{
+                    unit_test: "unit_test";
+                    integration_test: "integration_test";
+                    browser_test: "browser_test";
+                    manual: "manual";
+                }>;
+                status: z.ZodEnum<{
+                    pending: "pending";
+                    blocked: "blocked";
+                    met: "met";
+                    not_met: "not_met";
+                }>;
+                verifiedAt: z.ZodOptional<z.ZodString>;
+                notes: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            extractedAt: z.ZodString;
+            summary: z.ZodObject<{
+                total: z.ZodNumber;
+                met: z.ZodNumber;
+                notMet: z.ZodNumber;
+                pending: z.ZodNumber;
+                blocked: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
         sessionId: z.ZodOptional<z.ZodString>;
         lastActivity: z.ZodString;
         createdAt: z.ZodString;
@@ -222,3 +361,15 @@ export declare function createIssueState(issueNumber: number, title: string, opt
  * Create initial phase state
  */
 export declare function createPhaseState(status?: PhaseStatus): PhaseState;
+/**
+ * Create acceptance criterion
+ */
+export declare function createAcceptanceCriterion(id: string, description: string, verificationMethod?: ACVerificationMethod): AcceptanceCriterion;
+/**
+ * Create acceptance criteria tracking structure
+ */
+export declare function createAcceptanceCriteria(items: AcceptanceCriterion[]): AcceptanceCriteria;
+/**
+ * Update acceptance criteria summary based on item statuses
+ */
+export declare function updateAcceptanceCriteriaSummary(ac: AcceptanceCriteria): AcceptanceCriteria;

package/dist/src/lib/workflow/state-schema.js

@@ -26,8 +26,10 @@ export const WORKFLOW_PHASES = [
     "exec",
     "testgen",
     "test",
+    "verify",
     "qa",
     "loop",
+    "merger",
 ];
 /**
  * Phase status - tracks individual phase progress
@@ -45,6 +47,7 @@ export const PhaseStatusSchema = z.enum([
 export const IssueStatusSchema = z.enum([
     "not_started", // Issue tracked but no work begun
     "in_progress", // Actively being worked on
+    "waiting_for_qa_gate", // QA completed, waiting for gate approval in chain mode
     "ready_for_merge", // All phases passed, PR ready for review
     "merged", // PR merged, work complete
     "blocked", // Waiting on external input or dependency
@@ -59,8 +62,10 @@ export const PhaseSchema = z.enum([
     "exec",
     "testgen",
     "test",
+    "verify",
     "qa",
     "loop",
+    "merger",
 ]);
 /**
  * Individual phase state within an issue
@@ -97,6 +102,58 @@ export const LoopStateSchema = z.object({
     /** Maximum iterations allowed */
     maxIterations: z.number().int().positive(),
 });
+/**
+ * Acceptance criteria verification status
+ */
+export const ACStatusSchema = z.enum([
+    "pending", // Not yet verified
+    "met", // Verified as satisfied
+    "not_met", // Verified as not satisfied
+    "blocked", // Cannot verify due to external dependency
+]);
+/**
+ * Acceptance criteria verification method
+ */
+export const ACVerificationMethodSchema = z.enum([
+    "unit_test",
+    "integration_test",
+    "browser_test",
+    "manual",
+]);
+/**
+ * Individual acceptance criterion state
+ */
+export const AcceptanceCriterionSchema = z.object({
+    /** AC identifier (e.g., "A1", "B2") */
+    id: z.string(),
+    /** Description of the acceptance criterion */
+    description: z.string(),
+    /** How this AC should be verified */
+    verificationMethod: ACVerificationMethodSchema,
+    /** Current verification status */
+    status: ACStatusSchema,
+    /** When the AC was last verified */
+    verifiedAt: z.string().datetime().optional(),
+    /** Additional notes about verification */
+    notes: z.string().optional(),
+});
+/**
+ * Acceptance criteria tracking for an issue
+ */
+export const AcceptanceCriteriaSchema = z.object({
+    /** List of acceptance criteria */
+    items: z.array(AcceptanceCriterionSchema),
+    /** When the AC list was extracted from the issue */
+    extractedAt: z.string().datetime(),
+    /** Summary counts for quick access */
+    summary: z.object({
+        total: z.number().int().nonnegative(),
+        met: z.number().int().nonnegative(),
+        notMet: z.number().int().nonnegative(),
+        pending: z.number().int().nonnegative(),
+        blocked: z.number().int().nonnegative(),
+    }),
+});
 /**
  * Complete state for a single issue
  */
@@ -119,6 +176,8 @@ export const IssueStateSchema = z.object({
     pr: PRInfoSchema.optional(),
     /** Quality loop state (if loop enabled) */
     loop: LoopStateSchema.optional(),
+    /** Acceptance criteria tracking (if extracted by /spec) */
+    acceptanceCriteria: AcceptanceCriteriaSchema.optional(),
     /** Claude session ID (for resume) */
     sessionId: z.string().optional(),
     /** Most recent activity timestamp */
@@ -188,3 +247,43 @@ export function createPhaseState(status = "pending") {
     }
     return { status };
 }
+/**
+ * Create acceptance criterion
+ */
+export function createAcceptanceCriterion(id, description, verificationMethod = "manual") {
+    return {
+        id,
+        description,
+        verificationMethod,
+        status: "pending",
+    };
+}
+/**
+ * Create acceptance criteria tracking structure
+ */
+export function createAcceptanceCriteria(items) {
+    return {
+        items,
+        extractedAt: new Date().toISOString(),
+        summary: {
+            total: items.length,
+            met: 0,
+            notMet: 0,
+            pending: items.length,
+            blocked: 0,
+        },
+    };
+}
+/**
+ * Update acceptance criteria summary based on item statuses
+ */
+export function updateAcceptanceCriteriaSummary(ac) {
+    const summary = {
+        total: ac.items.length,
+        met: ac.items.filter((i) => i.status === "met").length,
+        notMet: ac.items.filter((i) => i.status === "not_met").length,
+        pending: ac.items.filter((i) => i.status === "pending").length,
+        blocked: ac.items.filter((i) => i.status === "blocked").length,
+    };
+    return { ...ac, summary };
+}

package/dist/src/lib/workflow/state-utils.d.ts

@@ -12,6 +12,18 @@
  * const result = await cleanupStaleEntries({ dryRun: true });
  * ```
  */
+import { type Phase } from "./state-schema.js";
+/**
+ * PR merge status from GitHub
+ */
+export type PRMergeStatus = "MERGED" | "CLOSED" | "OPEN" | null;
+/**
+ * Check the merge status of a PR using the gh CLI
+ *
+ * @param prNumber - The PR number to check
+ * @returns "MERGED" | "CLOSED" | "OPEN" | null (null if PR not found or gh unavailable)
+ */
+export declare function checkPRMergeStatus(prNumber: number): PRMergeStatus;
 export interface RebuildOptions {
     /** Log directory path (default: .sequant/logs) */
     logPath?: string;
@@ -46,21 +58,73 @@ export interface CleanupOptions {
     verbose?: boolean;
     /** Remove issues older than this many days */
     maxAgeDays?: number;
+    /** Remove all orphaned entries (both merged and abandoned) in one step */
+    removeAll?: boolean;
 }
 export interface CleanupResult {
     /** Whether cleanup was successful */
     success: boolean;
     /** Issues that were removed or would be removed */
     removed: number[];
-    /** Issues that were marked as orphaned */
+    /** Issues that were marked as orphaned (abandoned) */
     orphaned: number[];
+    /** Issues detected as merged PRs */
+    merged: number[];
     /** Error message if failed */
     error?: string;
 }
 /**
  * Clean up stale and orphaned entries from workflow state
  *
- * - Removes issues with non-existent worktrees (orphaned)
- * - Optionally removes old merged/abandoned issues
+ * - Checks GitHub to detect if associated PR was merged
+ * - Orphaned entries with merged PRs get status "merged" and are removed automatically
+ * - Orphaned entries without merged PRs get status "abandoned" (kept for review)
+ * - Use removeAll to remove both merged and abandoned orphaned entries in one step
+ * - Use maxAgeDays to remove old merged/abandoned issues
  */
 export declare function cleanupStaleEntries(options?: CleanupOptions): Promise<CleanupResult>;
+export interface DiscoverOptions {
+    /** State file path (default: .sequant/state.json) */
+    statePath?: string;
+    /** Enable verbose logging */
+    verbose?: boolean;
+}
+export interface DiscoveredWorktree {
+    /** Issue number extracted from branch name */
+    issueNumber: number;
+    /** Issue title (fetched from GitHub or placeholder) */
+    title: string;
+    /** Full path to the worktree */
+    worktreePath: string;
+    /** Branch name */
+    branch: string;
+    /** Inferred current phase from logs (if available) */
+    inferredPhase?: Phase;
+}
+export interface SkippedWorktree {
+    /** Path to the worktree */
+    path: string;
+    /** Reason it was skipped */
+    reason: string;
+}
+export interface DiscoverResult {
+    /** Whether discovery was successful */
+    success: boolean;
+    /** Number of worktrees scanned */
+    worktreesScanned: number;
+    /** Number of worktrees already tracked */
+    alreadyTracked: number;
+    /** Discovered worktrees not yet in state */
+    discovered: DiscoveredWorktree[];
+    /** Worktrees that were skipped (not matching pattern, etc.) */
+    skipped: SkippedWorktree[];
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Discover worktrees that are not yet tracked in state
+ *
+ * Scans all git worktrees, identifies those with issue-related branch names,
+ * and returns information about worktrees not yet in the state file.
+ */
+export declare function discoverUntrackedWorktrees(options?: DiscoverOptions): Promise<DiscoverResult>;