sequant 1.13.5 → 1.14.1

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

@@ -60,6 +60,35 @@ export declare const PhaseSchema: z.ZodEnum<{
     merger: "merger";
 }>;
 export type Phase = z.infer<typeof PhaseSchema>;
+/**
+ * Phase marker stored in GitHub issue comments for cross-session detection.
+ *
+ * Embedded as HTML comments: `<!-- SEQUANT_PHASE: {...} -->`
+ */
+export declare const PhaseMarkerSchema: z.ZodObject<{
+    phase: z.ZodEnum<{
+        loop: "loop";
+        verify: "verify";
+        spec: "spec";
+        exec: "exec";
+        qa: "qa";
+        "security-review": "security-review";
+        testgen: "testgen";
+        test: "test";
+        merger: "merger";
+    }>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        skipped: "skipped";
+        completed: "completed";
+        in_progress: "in_progress";
+        failed: "failed";
+    }>;
+    timestamp: z.ZodString;
+    pr: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PhaseMarker = z.infer<typeof PhaseMarkerSchema>;
 /**
  * Individual phase state within an issue
  */
@@ -246,6 +275,43 @@ export declare const IssueStateSchema: z.ZodObject<{
             blocked: z.ZodNumber;
         }, z.core.$strip>;
     }, z.core.$strip>>;
+    scopeAssessment: z.ZodOptional<z.ZodObject<{
+        assessedAt: z.ZodString;
+        skipped: z.ZodBoolean;
+        skipReason: z.ZodOptional<z.ZodString>;
+        verdict: z.ZodEnum<{
+            SCOPE_OK: "SCOPE_OK";
+            SCOPE_WARNING: "SCOPE_WARNING";
+            SCOPE_SPLIT_RECOMMENDED: "SCOPE_SPLIT_RECOMMENDED";
+        }>;
+        metrics: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodNumber;
+            status: z.ZodEnum<{
+                red: "red";
+                green: "green";
+                yellow: "yellow";
+            }>;
+        }, z.core.$strip>>;
+        featureDetection: z.ZodObject<{
+            featureCount: z.ZodNumber;
+            clusters: z.ZodArray<z.ZodObject<{
+                keyword: z.ZodString;
+                acIds: z.ZodArray<z.ZodString>;
+                count: z.ZodNumber;
+            }, z.core.$strip>>;
+            multipleVerbs: z.ZodBoolean;
+            titleVerbs: z.ZodArray<z.ZodString>;
+            directorySpread: z.ZodNumber;
+            directories: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        nonGoals: z.ZodObject<{
+            items: z.ZodArray<z.ZodString>;
+            found: z.ZodBoolean;
+            warning: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        recommendation: z.ZodString;
+    }, z.core.$strip>>;
     sessionId: z.ZodOptional<z.ZodString>;
     lastActivity: z.ZodString;
     createdAt: z.ZodString;
@@ -334,6 +400,43 @@ export declare const WorkflowStateSchema: z.ZodObject<{
                 blocked: z.ZodNumber;
             }, z.core.$strip>;
         }, z.core.$strip>>;
+        scopeAssessment: z.ZodOptional<z.ZodObject<{
+            assessedAt: z.ZodString;
+            skipped: z.ZodBoolean;
+            skipReason: z.ZodOptional<z.ZodString>;
+            verdict: z.ZodEnum<{
+                SCOPE_OK: "SCOPE_OK";
+                SCOPE_WARNING: "SCOPE_WARNING";
+                SCOPE_SPLIT_RECOMMENDED: "SCOPE_SPLIT_RECOMMENDED";
+            }>;
+            metrics: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                value: z.ZodNumber;
+                status: z.ZodEnum<{
+                    red: "red";
+                    green: "green";
+                    yellow: "yellow";
+                }>;
+            }, z.core.$strip>>;
+            featureDetection: z.ZodObject<{
+                featureCount: z.ZodNumber;
+                clusters: z.ZodArray<z.ZodObject<{
+                    keyword: z.ZodString;
+                    acIds: z.ZodArray<z.ZodString>;
+                    count: z.ZodNumber;
+                }, z.core.$strip>>;
+                multipleVerbs: z.ZodBoolean;
+                titleVerbs: z.ZodArray<z.ZodString>;
+                directorySpread: z.ZodNumber;
+                directories: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>;
+            nonGoals: z.ZodObject<{
+                items: z.ZodArray<z.ZodString>;
+                found: z.ZodBoolean;
+                warning: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            recommendation: z.ZodString;
+        }, z.core.$strip>>;
         sessionId: z.ZodOptional<z.ZodString>;
         lastActivity: z.ZodString;
         createdAt: z.ZodString;

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

@@ -17,6 +17,7 @@
  * ```
  */
 import { z } from "zod";
+import { ScopeAssessmentSchema } from "../scope/types.js";
 /**
  * Workflow phases in order of execution
  */
@@ -67,6 +68,23 @@ export const PhaseSchema = z.enum([
     "loop",
     "merger",
 ]);
+/**
+ * Phase marker stored in GitHub issue comments for cross-session detection.
+ *
+ * Embedded as HTML comments: `<!-- SEQUANT_PHASE: {...} -->`
+ */
+export const PhaseMarkerSchema = z.object({
+    /** The workflow phase */
+    phase: PhaseSchema,
+    /** Phase completion status */
+    status: PhaseStatusSchema,
+    /** ISO 8601 timestamp */
+    timestamp: z.string().datetime(),
+    /** PR number if created during this phase */
+    pr: z.number().int().positive().optional(),
+    /** Error message if phase failed */
+    error: z.string().optional(),
+});
 /**
  * Individual phase state within an issue
  */
@@ -178,6 +196,8 @@ export const IssueStateSchema = z.object({
     loop: LoopStateSchema.optional(),
     /** Acceptance criteria tracking (if extracted by /spec) */
     acceptanceCriteria: AcceptanceCriteriaSchema.optional(),
+    /** Scope assessment result (if performed by /spec) */
+    scopeAssessment: ScopeAssessmentSchema.optional(),
     /** Claude session ID (for resume) */
     sessionId: z.string().optional(),
     /** Most recent activity timestamp */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sequant",
-  "version": "1.13.5",
+  "version": "1.14.1",
   "description": "Quantize your development workflow - Sequential AI phases with quality gates",
   "type": "module",
   "bin": {

package/templates/skills/exec/SKILL.md

@@ -37,7 +37,7 @@ allowed-tools:
   - mcp__context7__*  # Library documentation lookup - falls back to web search if unavailable
   - mcp__sequential-thinking__*  # Complex reasoning - falls back to standard analysis if unavailable
   # Task management
-  - Task
+  - Task(general-purpose)
   - TodoWrite
 ---
 
@@ -56,6 +56,55 @@ When invoked as `/exec`, your job is to:
 5. Iterate until the AC appear satisfied or clear blockers are reached.
 6. Draft a progress update for the GitHub issue.
 
+## Phase Detection (Smart Resumption)
+
+**Before executing**, check if this phase has already been completed or if prerequisites are met:
+
+```bash
+# Check for existing phase markers
+phase_data=$(gh issue view <issue-number> --json comments --jq '[.comments[].body]' | \
+  grep -o '{[^}]*}' | grep '"phase"' | tail -1)
+
+if [[ -n "$phase_data" ]]; then
+  phase=$(echo "$phase_data" | jq -r '.phase')
+  status=$(echo "$phase_data" | jq -r '.status')
+
+  # Skip if exec is already completed
+  if [[ "$phase" == "exec" && "$status" == "completed" ]]; then
+    echo "⏭️ Exec phase already completed. Skipping."
+    # Exit early — no work needed
+  fi
+
+  # Resume if exec previously failed
+  if [[ "$phase" == "exec" && "$status" == "failed" ]]; then
+    echo "🔄 Exec phase previously failed. Resuming from failure point."
+    # Continue execution — will retry the implementation
+  fi
+fi
+```
+
+**Behavior:**
+- If `exec:completed` → Skip with message
+- If `exec:failed` → Resume (retry implementation)
+- If `spec:completed` (no exec marker) → Normal execution
+- If no markers found → Normal execution (fresh start)
+- If detection fails (API error) → Fall through to normal execution
+
+**Phase Marker Emission:**
+
+When posting the progress update comment to GitHub, append a phase marker at the end:
+
+```markdown
+<!-- SEQUANT_PHASE: {"phase":"exec","status":"completed","timestamp":"<ISO-8601>","pr":<PR_NUMBER>} -->
+```
+
+If exec fails, emit a failure marker:
+```markdown
+<!-- SEQUANT_PHASE: {"phase":"exec","status":"failed","timestamp":"<ISO-8601>","error":"<error message>"} -->
+```
+
+Include this marker in every `gh issue comment` that represents phase completion or failure.
+
 ## Behavior
 
 Invocation:

package/templates/skills/fullsolve/SKILL.md

@@ -13,7 +13,7 @@ allowed-tools:
   - Grep
   - Bash
   - TodoWrite
-  - Task
+  - Skill  # For invoking child skills (/spec, /exec, /test, /qa)
   # Optional MCP tools (enhanced functionality if available)
   - mcp__chrome-devtools__*  # Browser testing - falls back to manual checklist if unavailable
   - mcp__sequential-thinking__*  # Complex reasoning - falls back to standard analysis if unavailable
@@ -90,6 +90,52 @@ When invoked as `/fullsolve <issue-number>`, execute the complete issue resoluti
 /fullsolve 218 --max-iterations 5 # Override max fix iterations
 ```
 
+## Phase Detection (Smart Resumption)
+
+**Before starting any phase**, detect the current workflow state from GitHub issue comments to enable smart resumption:
+
+```bash
+# Get all phase markers from issue comments
+comments_json=$(gh issue view <issue-number> --json comments --jq '[.comments[].body]')
+markers=$(echo "$comments_json" | grep -o '{[^}]*}' | grep '"phase"')
+
+if [[ -n "$markers" ]]; then
+  echo "Phase markers detected:"
+  echo "$markers" | jq -r '"  \(.phase): \(.status)"'
+
+  # Determine resume point
+  latest_completed=$(echo "$markers" | jq -r 'select(.status == "completed") | .phase' | tail -1)
+  latest_failed=$(echo "$markers" | jq -r 'select(.status == "failed") | .phase' | tail -1)
+
+  echo "Latest completed: ${latest_completed:-none}"
+  echo "Latest failed: ${latest_failed:-none}"
+fi
+```
+
+**Resume Logic:**
+
+| Detected State | Action |
+|---------------|--------|
+| No markers | Start from Phase 1 (spec) — fresh start |
+| `spec:completed` | Skip to Phase 2 (exec) |
+| `exec:completed` | Skip to Phase 3 (test) or Phase 4 (qa) |
+| `exec:failed` | Resume at Phase 2 (exec) — retry |
+| `test:completed` | Skip to Phase 4 (qa) |
+| `qa:completed` | Skip to Phase 5 (PR) |
+| `qa:failed` | Resume at Phase 4 (qa) — retry with /loop |
+| All completed | Skip to PR creation (if no PR exists) |
+
+**Backward Compatibility:**
+- Issues without markers → treat as fresh start (no phase detection)
+- If detection fails (API error) → fall through to standard Phase 0 checks
+
+**Phase Marker Emission:**
+
+When posting progress comments after each phase, append the appropriate marker:
+```markdown
+<!-- SEQUANT_PHASE: {"phase":"<phase>","status":"<completed|failed>","timestamp":"<ISO-8601>"} -->
+```
+
 ## Phase 0: Pre-flight Checks
 
 **CRITICAL after context restoration:** Before starting any work, verify the current git state to avoid duplicate work.

package/templates/skills/qa/SKILL.md

@@ -19,7 +19,7 @@ allowed-tools:
   - Bash(semgrep:*)
   - Bash(npx semgrep:*)
   - Bash(npx tsx scripts/semgrep-scan.ts:*)
-  - Task
+  - Task(general-purpose)
   - AgentOutputTool
 ---
 
@@ -37,6 +37,52 @@ When invoked as `/qa`, your job is to:
 4. Assess whether the change is "A+ status" or needs more work.
 5. Draft a GitHub review/QA comment summarizing findings and recommendations.
 
+## Phase Detection (Smart Resumption)
+
+**Before executing**, check if the exec phase has been completed (prerequisite for QA):
+
+```bash
+# Check for existing phase markers
+comments_json=$(gh issue view <issue-number> --json comments --jq '[.comments[].body]')
+exec_completed=$(echo "$comments_json" | \
+  grep -o '{[^}]*}' | grep '"phase"' | \
+  jq -r 'select(.phase == "exec" and .status == "completed")' 2>/dev/null)
+
+if [[ -z "$exec_completed" ]]; then
+  # Check if any exec marker exists at all
+  exec_any=$(echo "$comments_json" | \
+    grep -o '{[^}]*}' | grep '"phase"' | \
+    jq -r 'select(.phase == "exec")' 2>/dev/null)
+
+  if [[ -n "$exec_any" ]]; then
+    echo "⚠️ Exec phase not completed (status: $(echo "$exec_any" | jq -r '.status')). Run /exec first."
+  else
+    echo "ℹ️ No phase markers found — proceeding with QA (may be a fresh issue or legacy workflow)."
+  fi
+fi
+```
+
+**Behavior:**
+- If `exec:completed` marker found → Normal QA execution
+- If `exec:failed` or `exec:in_progress` → Warn "Exec not complete, run /exec first" (but don't block — QA may still be useful for partial review)
+- If no markers found → Normal execution (backward compatible)
+- If detection fails (API error) → Fall through to normal execution
+
+**Phase Marker Emission:**
+
+When posting the QA review comment to GitHub, append a phase marker at the end:
+
+```markdown
+<!-- SEQUANT_PHASE: {"phase":"qa","status":"completed","timestamp":"<ISO-8601>"} -->
+```
+
+If QA determines AC_NOT_MET, emit:
+```markdown
+<!-- SEQUANT_PHASE: {"phase":"qa","status":"failed","timestamp":"<ISO-8601>","error":"AC_NOT_MET"} -->
+```
+
+Include this marker in every `gh issue comment` that represents QA completion.
+
 ## Behavior
 
 Invocation:

package/templates/skills/security-review/SKILL.md

@@ -9,7 +9,6 @@ allowed-tools:
   - Read
   - Glob
   - Grep
-  - Task
   - Bash(git diff:*)
   - Bash(git status:*)
   - Bash(git log:*)

package/templates/skills/spec/SKILL.md

@@ -13,7 +13,7 @@ allowed-tools:
   - Bash(gh label:*)
   - Bash(git worktree:*)
   - Bash(git -C:*)
-  - Task
+  - Task(Explore)
   - AgentOutputTool
 ---
 
@@ -30,6 +30,44 @@ When invoked as `/spec`, your job is to:
 3. Identify ambiguities, gaps, or risks.
 4. Draft a GitHub issue comment summarizing AC + the agreed plan.
 
+## Phase Detection (Smart Resumption)
+
+**Before executing**, check if this phase has already been completed by reading phase markers from issue comments:
+
+```bash
+# Check for existing phase markers
+phase_data=$(gh issue view <issue-number> --json comments --jq '[.comments[].body]' | \
+  grep -o '{[^}]*}' | grep '"phase"' | tail -1)
+
+if [[ -n "$phase_data" ]]; then
+  phase=$(echo "$phase_data" | jq -r '.phase')
+  status=$(echo "$phase_data" | jq -r '.status')
+
+  # Skip if spec is already completed or a later phase is completed
+  if [[ "$phase" == "spec" && "$status" == "completed" ]] || \
+     [[ "$phase" == "exec" || "$phase" == "test" || "$phase" == "qa" ]]; then
+    echo "⏭️ Spec phase already completed (detected: $phase:$status). Skipping."
+    # Exit early — no work needed
+  fi
+fi
+```
+
+**Behavior:**
+- If `spec:completed` or a later phase is detected → Skip with message
+- If `spec:failed` → Re-run spec (retry)
+- If no markers found → Normal execution (fresh start)
+- If detection fails (API error) → Fall through to normal execution
+
+**Phase Marker Emission:**
+
+When posting the spec plan comment to GitHub, append a phase marker at the end:
+
+```markdown
+<!-- SEQUANT_PHASE: {"phase":"spec","status":"completed","timestamp":"<ISO-8601>"} -->
+```
+
+Include this marker in every `gh issue comment` that represents phase completion.
+
 ## Behavior
 
 When called like `/spec 123`:

package/templates/skills/testgen/SKILL.md

@@ -17,6 +17,7 @@ allowed-tools:
   - Bash(git worktree list:*)
   - Bash(ls:*)
   - Bash(mkdir:*)
+  - Task(general-purpose)
 ---
 
 # Test Generation Command