claude-code-workflow 6.3.8 → 6.3.9

package/.claude/agents/issue-plan-agent.md

@@ -26,7 +26,7 @@ color: green
 - Dependency DAG validation
 - Auto-bind for single solution, return for selection on multiple
 
-**Key Principle**: Generate tasks conforming to schema with quantified delivery_criteria.
+**Key Principle**: Generate tasks conforming to schema with quantified acceptance criteria.
 
 ---
 
@@ -71,11 +71,17 @@ function analyzeIssue(issue) {
     issue_id: issue.id,
     requirements: extractRequirements(issue.description),
     scope: inferScope(issue.title, issue.description),
-    complexity: determineComplexity(issue)  // Low | Medium | High
+    complexity: determineComplexity(issue),  // Low | Medium | High
+    lifecycle: issue.lifecycle_requirements  // User preferences for test/commit
   }
 }
 ```
 
+**Step 3**: Apply lifecycle requirements to tasks
+- `lifecycle.test_strategy` → Configure `test.unit`, `test.commands`
+- `lifecycle.commit_strategy` → Configure `commit.type`, `commit.scope`
+- `lifecycle.regression_scope` → Configure `regression` array
+
 **Complexity Rules**:
 | Complexity | Files | Tasks |
 |------------|-------|-------|
@@ -100,26 +106,76 @@ mcp__ace-tool__search_context({
 - [ ] Discover dependencies
 - [ ] Locate test patterns
 
-**Fallback**: ACE → ripgrep → Glob
+**Fallback Chain**: ACE → smart_search → Grep → rg → Glob
+
+| Tool | When to Use |
+|------|-------------|
+| `mcp__ace-tool__search_context` | Semantic search (primary) |
+| `mcp__ccw-tools__smart_search` | Symbol/pattern search |
+| `Grep` | Exact regex matching |
+| `rg` / `grep` | CLI fallback |
+| `Glob` | File path discovery |
 
 #### Phase 3: Solution Planning
 
+**Multi-Solution Generation**:
+
+Generate multiple candidate solutions when:
+- Issue complexity is HIGH
+- Multiple valid implementation approaches exist
+- Trade-offs between approaches (performance vs simplicity, etc.)
+
+| Condition | Solutions |
+|-----------|-----------|
+| Low complexity, single approach | 1 solution, auto-bind |
+| Medium complexity, clear path | 1-2 solutions |
+| High complexity, multiple approaches | 2-3 solutions, user selection |
+
+**Solution Evaluation** (for each candidate):
+```javascript
+{
+  analysis: {
+    risk: "low|medium|high",      // Implementation risk
+    impact: "low|medium|high",    // Scope of changes
+    complexity: "low|medium|high" // Technical complexity
+  },
+  score: 0.0-1.0  // Overall quality score (higher = recommended)
+}
+```
+
+**Selection Flow**:
+1. Generate all candidate solutions
+2. Evaluate and score each
+3. Single solution → auto-bind
+4. Multiple solutions → return `pending_selection` for user choice
+
 **Task Decomposition** following schema:
 ```javascript
 function decomposeTasks(issue, exploration) {
   return groups.map(group => ({
-    id: `TASK-${String(taskId++).padStart(3, '0')}`,
+    id: `T${taskId++}`,                    // Pattern: ^T[0-9]+$
     title: group.title,
-    type: inferType(group),  // feature | bug | refactor | test | chore | docs
+    scope: inferScope(group),              // Module path
+    action: inferAction(group),            // Create | Update | Implement | ...
     description: group.description,
-    file_context: group.files,
+    modification_points: mapModificationPoints(group),
+    implementation: generateSteps(group),  // Step-by-step guide
+    test: {
+      unit: generateUnitTests(group),
+      commands: ['npm test']
+    },
+    acceptance: {
+      criteria: generateCriteria(group),   // Quantified checklist
+      verification: generateVerification(group)
+    },
+    commit: {
+      type: inferCommitType(group),        // feat | fix | refactor | ...
+      scope: inferScope(group),
+      message_template: generateCommitMsg(group)
+    },
     depends_on: inferDependencies(group, tasks),
-    delivery_criteria: generateDeliveryCriteria(group),  // Quantified checklist
-    pause_criteria: identifyBlockers(group),
-    status: 'pending',
-    current_phase: 'analyze',
     executor: inferExecutor(group),
-    priority: calculatePriority(group)
+    priority: calculatePriority(group)     // 1-5 (1=highest)
   }))
 }
 ```
@@ -139,57 +195,34 @@ ccw issue bind <issue-id> --solution /tmp/sol.json
 
 ---
 
-## 2. Output Specifications
+## 2. Output Requirements
 
-### 2.1 Return Format
+### 2.1 Generate Files (Primary)
 
-```json
-{
-  "bound": [{ "issue_id": "...", "solution_id": "...", "task_count": N }],
-  "pending_selection": [{ "issue_id": "...", "solutions": [{ "id": "...", "description": "...", "task_count": N }] }],
-  "conflicts": [{ "file": "...", "issues": [...] }]
-}
+**Solution file per issue**:
+```
+.workflow/issues/solutions/{issue-id}.jsonl
 ```
 
-### 2.2 Binding Rules
+Each line is a solution JSON containing tasks. Schema: `cat .claude/workflows/cli-templates/schemas/solution-schema.json`
+
+### 2.2 Binding
 
 | Scenario | Action |
 |----------|--------|
-| Single solution | Register AND auto-bind |
-| Multiple solutions | Register only, return for user selection |
-
-### 2.3 Task Schema
+| Single solution | `ccw issue bind <id> --solution <file>` (auto) |
+| Multiple solutions | Register only, return for selection |
 
-**Schema-Driven Output**: Read schema before generating tasks:
-```bash
-cat .claude/workflows/cli-templates/schemas/issue-task-jsonl-schema.json
-```
+### 2.3 Return Summary
 
-**Required Fields**:
-- `id`: Task ID (pattern: `TASK-NNN`)
-- `title`: Short summary (max 100 chars)
-- `type`: feature | bug | refactor | test | chore | docs
-- `description`: Detailed instructions
-- `depends_on`: Array of prerequisite task IDs
-- `delivery_criteria`: Checklist items defining completion
-- `status`: pending | ready | in_progress | completed | failed | paused | skipped
-- `current_phase`: analyze | implement | test | optimize | commit | done
-- `executor`: agent | codex | gemini | auto
-
-**Optional Fields**:
-- `file_context`: Relevant files/globs
-- `pause_criteria`: Conditions to halt execution
-- `priority`: 1-5 (1=highest)
-- `phase_results`: Results from each execution phase
-
-### 2.4 Solution File Structure
-
-```
-.workflow/issues/solutions/{issue-id}.jsonl
+```json
+{
+  "bound": [{ "issue_id": "...", "solution_id": "...", "task_count": N }],
+  "pending_selection": [{ "issue_id": "...", "solutions": [{ "id": "SOL-001", "description": "...", "task_count": N }] }],
+  "conflicts": [{ "file": "...", "issues": [...] }]
+}
 ```
 
-Each line is a complete solution JSON.
-
 ---
 
 ## 3. Quality Standards
@@ -215,12 +248,14 @@ Each line is a complete solution JSON.
 ### 3.3 Guidelines
 
 **ALWAYS**:
-1. Read schema first: `cat .claude/workflows/cli-templates/schemas/issue-task-jsonl-schema.json`
+1. Read schema first: `cat .claude/workflows/cli-templates/schemas/solution-schema.json`
 2. Use ACE semantic search as PRIMARY exploration tool
 3. Fetch issue details via `ccw issue status <id> --json`
-4. Quantify delivery_criteria with testable conditions
+4. Quantify acceptance.criteria with testable conditions
 5. Validate DAG before output
-6. Single solution → auto-bind; Multiple → return for selection
+6. Evaluate each solution with `analysis` and `score`
+7. Single solution → auto-bind; Multiple → return `pending_selection`
+8. For HIGH complexity: generate 2-3 candidate solutions
 
 **NEVER**:
 1. Execute implementation (return plan only)

package/.claude/agents/issue-queue-agent.md

@@ -36,21 +36,21 @@ color: orange
 ```javascript
 {
   tasks: [{
+    key: string,           // e.g., "GH-123:TASK-001"
     issue_id: string,      // e.g., "GH-123"
     solution_id: string,   // e.g., "SOL-001"
-    task: {
-      id: string,          // e.g., "TASK-001"
-      title: string,
-      type: string,
-      file_context: string[],
-      depends_on: string[]
-    }
+    task_id: string,       // e.g., "TASK-001"
+    type: string,          // feature | bug | refactor | test | chore | docs
+    file_context: string[],
+    depends_on: string[]   // composite keys, e.g., ["GH-123:TASK-001"]
   }],
   project_root?: string,
   rebuild?: boolean
 }
 ```
 
+**Note**: Agent generates unique `item_id` (pattern: `T-{N}`) for queue output.
+
 ### 1.2 Execution Flow
 
 ```
@@ -76,19 +76,17 @@ function buildDependencyGraph(tasks) {
   const fileModifications = new Map()
 
   for (const item of tasks) {
-    const key = `${item.issue_id}:${item.task.id}`
-    graph.set(key, { ...item, key, inDegree: 0, outEdges: [] })
+    graph.set(item.key, { ...item, inDegree: 0, outEdges: [] })
 
-    for (const file of item.task.file_context || []) {
+    for (const file of item.file_context || []) {
       if (!fileModifications.has(file)) fileModifications.set(file, [])
-      fileModifications.get(file).push(key)
+      fileModifications.get(file).push(item.key)
     }
   }
 
   // Add dependency edges
   for (const [key, node] of graph) {
-    for (const dep of node.task.depends_on || []) {
-      const depKey = `${node.issue_id}:${dep}`
+    for (const depKey of node.depends_on || []) {
       if (graph.has(depKey)) {
         graph.get(depKey).outEdges.push(key)
         node.inDegree++
@@ -128,6 +126,16 @@ function detectConflicts(fileModifications, graph) {
 
 ### 2.4 Semantic Priority
 
+**Base Priority Mapping** (task.priority 1-5 → base score):
+| task.priority | Base Score | Meaning |
+|---------------|------------|---------|
+| 1 | 0.8 | Highest |
+| 2 | 0.65 | High |
+| 3 | 0.5 | Medium |
+| 4 | 0.35 | Low |
+| 5 | 0.2 | Lowest |
+
+**Action-based Boost** (applied to base score):
 | Factor | Boost |
 |--------|-------|
 | Create action | +0.2 |
@@ -140,6 +148,8 @@ function detectConflicts(fileModifications, graph) {
 | Test action | -0.1 |
 | Delete action | -0.15 |
 
+**Formula**: `semantic_priority = clamp(baseScore + sum(boosts), 0.0, 1.0)`
+
 ### 2.5 Group Assignment
 
 - **Parallel (P*)**: Tasks with no dependencies or conflicts between them
@@ -147,48 +157,29 @@ function detectConflicts(fileModifications, graph) {
 
 ---
 
-## 3. Output Specifications
+## 3. Output Requirements
 
-### 3.1 Queue Schema
+### 3.1 Generate Files (Primary)
 
-Read schema before output:
-```bash
-cat .claude/workflows/cli-templates/schemas/queue-schema.json
+**Queue files**:
+```
+.workflow/issues/queues/{queue-id}.json   # Full queue with tasks, conflicts, groups
+.workflow/issues/queues/index.json        # Update with new queue entry
 ```
 
-### 3.2 Output Format
+Queue ID format: `QUE-YYYYMMDD-HHMMSS` (UTC timestamp)
+
+Schema: `cat .claude/workflows/cli-templates/schemas/queue-schema.json`
+
+### 3.2 Return Summary
 
 ```json
 {
-  "tasks": [{
-    "item_id": "T-1",
-    "issue_id": "GH-123",
-    "solution_id": "SOL-001",
-    "task_id": "TASK-001",
-    "status": "pending",
-    "execution_order": 1,
-    "execution_group": "P1",
-    "depends_on": [],
-    "semantic_priority": 0.7
-  }],
-  "conflicts": [{
-    "file": "src/auth.ts",
-    "tasks": ["GH-123:TASK-001", "GH-124:TASK-002"],
-    "resolution": "sequential",
-    "resolution_order": ["GH-123:TASK-001", "GH-124:TASK-002"],
-    "rationale": "TASK-001 creates file before TASK-002 updates",
-    "resolved": true
-  }],
-  "execution_groups": [
-    { "id": "P1", "type": "parallel", "task_count": 3, "tasks": ["T-1", "T-2", "T-3"] },
-    { "id": "S2", "type": "sequential", "task_count": 2, "tasks": ["T-4", "T-5"] }
-  ],
-  "_metadata": {
-    "total_tasks": 5,
-    "total_conflicts": 1,
-    "resolved_conflicts": 1,
-    "timestamp": "2025-12-27T10:00:00Z"
-  }
+  "queue_id": "QUE-20251227-143000",
+  "total_tasks": N,
+  "execution_groups": [{ "id": "P1", "type": "parallel", "count": N }],
+  "conflicts_resolved": N,
+  "issues_queued": ["GH-123", "GH-124"]
 }
 ```
 
@@ -231,5 +222,6 @@ cat .claude/workflows/cli-templates/schemas/queue-schema.json
 5. Merge conflicting tasks in parallel group
 
 **OUTPUT**:
-1. Write queue via `ccw issue queue` CLI
-2. Return JSON with `tasks`, `conflicts`, `execution_groups`, `_metadata`
+1. Write `.workflow/issues/queues/{queue-id}.json`
+2. Update `.workflow/issues/queues/index.json`
+3. Return summary with `queue_id`, `total_tasks`, `execution_groups`, `conflicts_resolved`, `issues_queued`

package/.claude/commands/issue/plan.md

@@ -1,7 +1,7 @@
 ---
 name: plan
 description: Batch plan issue resolution using issue-plan-agent (explore + plan closed-loop)
-argument-hint: "<issue-id>[,<issue-id>,...] [--batch-size 3] --all-pending"
+argument-hint: "--all-pending <issue-id>[,<issue-id>,...] [--batch-size 3] "
 allowed-tools: TodoWrite(*), Task(*), SlashCommand(*), AskUserQuestion(*), Bash(*), Read(*), Write(*)
 ---
 
@@ -29,8 +29,8 @@ Unified planning command using **issue-plan-agent** that combines exploration an
 - [ ] Solution file generated for each issue
 - [ ] Single solution → auto-bound via `ccw issue bind`
 - [ ] Multiple solutions → returned for user selection
-- [ ] Tasks conform to schema: `cat .claude/workflows/cli-templates/schemas/issue-task-jsonl-schema.json`
-- [ ] Each task has quantified `delivery_criteria`
+- [ ] Tasks conform to schema: `cat .claude/workflows/cli-templates/schemas/solution-schema.json`
+- [ ] Each task has quantified `acceptance.criteria`
 
 ## Core Capabilities
 
@@ -70,9 +70,9 @@ Unified planning command using **issue-plan-agent** that combines exploration an
 ```
 Phase 1: Issue Loading
    ├─ Parse input (single, comma-separated, or --all-pending)
-   ├─ Load issues from .workflow/issues/issues.jsonl
+   ├─ Fetch issue metadata (ID, title, tags)
    ├─ Validate issues exist (create if needed)
-   └─ Group into batches (max 3 per batch)
+   └─ Group by similarity (shared tags or title keywords, max 3 per batch)
 
 Phase 2: Unified Explore + Plan (issue-plan-agent)
    ├─ Launch issue-plan-agent per batch
@@ -97,41 +97,71 @@ Phase 4: Summary
 
 ## Implementation
 
-### Phase 1: Issue Loading (IDs Only)
+### Phase 1: Issue Loading (ID + Title + Tags)
 
 ```javascript
 const batchSize = flags.batchSize || 3;
-let issueIds = [];
+let issues = [];  // {id, title, tags}
 
 if (flags.allPending) {
-  // Get pending issue IDs directly via CLI
-  const ids = Bash(`ccw issue list --status pending,registered --ids`).trim();
-  issueIds = ids ? ids.split('\n').filter(Boolean) : [];
+  // Get pending issues with metadata via CLI (JSON output)
+  const result = Bash(`ccw issue list --status pending,registered --json`).trim();
+  const parsed = result ? JSON.parse(result) : [];
+  issues = parsed.map(i => ({ id: i.id, title: i.title || '', tags: i.tags || [] }));
 
-  if (issueIds.length === 0) {
+  if (issues.length === 0) {
     console.log('No pending issues found.');
     return;
   }
-  console.log(`Found ${issueIds.length} pending issues`);
+  console.log(`Found ${issues.length} pending issues`);
 } else {
-  // Parse comma-separated issue IDs
-  issueIds = userInput.includes(',')
+  // Parse comma-separated issue IDs, fetch metadata
+  const ids = userInput.includes(',')
     ? userInput.split(',').map(s => s.trim())
     : [userInput.trim()];
 
-  // Create if not exists
-  for (const id of issueIds) {
+  for (const id of ids) {
     Bash(`ccw issue init ${id} --title "Issue ${id}" 2>/dev/null || true`);
+    const info = Bash(`ccw issue status ${id} --json`).trim();
+    const parsed = info ? JSON.parse(info) : {};
+    issues.push({ id, title: parsed.title || '', tags: parsed.tags || [] });
   }
 }
 
-// Group into batches
-const batches = [];
-for (let i = 0; i < issueIds.length; i += batchSize) {
-  batches.push(issueIds.slice(i, i + batchSize));
+// Intelligent grouping by similarity (tags → title keywords)
+function groupBySimilarity(issues, maxSize) {
+  const batches = [];
+  const used = new Set();
+
+  for (const issue of issues) {
+    if (used.has(issue.id)) continue;
+
+    const batch = [issue];
+    used.add(issue.id);
+    const issueTags = new Set(issue.tags);
+    const issueWords = new Set(issue.title.toLowerCase().split(/\s+/));
+
+    // Find similar issues
+    for (const other of issues) {
+      if (used.has(other.id) || batch.length >= maxSize) continue;
+
+      // Similarity: shared tags or shared title keywords
+      const sharedTags = other.tags.filter(t => issueTags.has(t)).length;
+      const otherWords = other.title.toLowerCase().split(/\s+/);
+      const sharedWords = otherWords.filter(w => issueWords.has(w) && w.length > 3).length;
+
+      if (sharedTags > 0 || sharedWords >= 2) {
+        batch.push(other);
+        used.add(other.id);
+      }
+    }
+    batches.push(batch);
+  }
+  return batches;
 }
 
-console.log(`Processing ${issueIds.length} issues in ${batches.length} batch(es)`);
+const batches = groupBySimilarity(issues, batchSize);
+console.log(`Processing ${issues.length} issues in ${batches.length} batch(es) (grouped by similarity)`);
 
 TodoWrite({
   todos: batches.map((_, i) => ({
@@ -151,11 +181,16 @@ const pendingSelections = [];  // Collect multi-solution issues for user selecti
 for (const [batchIndex, batch] of batches.entries()) {
   updateTodo(`Plan batch ${batchIndex + 1}`, 'in_progress');
 
+  // Build issue list with metadata for agent context
+  const issueList = batch.map(i => `- ${i.id}: ${i.title}${i.tags.length ? ` [${i.tags.join(', ')}]` : ''}`).join('\n');
+
   // Build minimal prompt - agent handles exploration, planning, and binding
   const issuePrompt = `
 ## Plan Issues
 
-**Issue IDs**: ${batch.join(', ')}
+**Issues** (grouped by similarity):
+${issueList}
+
 **Project Root**: ${process.cwd()}
 
 ### Steps
@@ -164,7 +199,7 @@ for (const [batchIndex, batch] of batches.entries()) {
 3. Register & bind: \`ccw issue bind <id> --solution <file>\`
 
 ### Generate Files
-\`.workflow/issues/solutions/{issue-id}.jsonl\` - Solution with tasks (schema: cat .claude/workflows/cli-templates/schemas/issue-task-jsonl-schema.json)
+\`.workflow/issues/solutions/{issue-id}.jsonl\` - Solution with tasks (schema: cat .claude/workflows/cli-templates/schemas/solution-schema.json)
 
 ### Binding Rules
 - **Single solution**: Auto-bind via \`ccw issue bind <id> --solution <file>\`
@@ -181,10 +216,11 @@ for (const [batchIndex, batch] of batches.entries()) {
 `;
 
   // Launch issue-plan-agent - agent writes solutions directly
+  const batchIds = batch.map(i => i.id);
   const result = Task(
     subagent_type="issue-plan-agent",
     run_in_background=false,
-    description=`Explore & plan ${batch.length} issues`,
+    description=`Explore & plan ${batch.length} issues: ${batchIds.join(', ')}`,
     prompt=issuePrompt
   );
 
@@ -244,7 +280,7 @@ const plannedIds = Bash(`ccw issue list --status planned --ids`).trim();
 const plannedCount = plannedIds ? plannedIds.split('\n').length : 0;
 
 console.log(`
-## Done: ${issueIds.length} issues → ${plannedCount} planned
+## Done: ${issues.length} issues → ${plannedCount} planned
 
 Next: \`/issue:queue\` → \`/issue:execute\`
 `);

package/.claude/workflows/cli-templates/schemas/queue-schema.json

@@ -9,11 +9,11 @@
       "description": "Ordered list of tasks to execute",
       "items": {
         "type": "object",
-        "required": ["queue_id", "issue_id", "solution_id", "task_id", "status"],
+        "required": ["item_id", "issue_id", "solution_id", "task_id", "status"],
         "properties": {
-          "queue_id": {
+          "item_id": {
             "type": "string",
-            "pattern": "^Q-[0-9]+$",
+            "pattern": "^T-[0-9]+$",
             "description": "Unique queue item identifier"
           },
           "issue_id": {

package/.claude/workflows/cli-templates/schemas/solution-schema.json

@@ -23,7 +23,7 @@
       "description": "Task breakdown for this solution",
       "items": {
         "type": "object",
-        "required": ["id", "title", "scope", "action", "acceptance"],
+        "required": ["id", "title", "scope", "action", "implementation", "acceptance"],
         "properties": {
           "id": {
             "type": "string",
@@ -61,10 +61,40 @@
             "items": { "type": "string" },
             "description": "Step-by-step implementation guide"
           },
-          "acceptance": {
+          "test": {
+            "type": "object",
+            "description": "Test requirements",
+            "properties": {
+              "unit": { "type": "array", "items": { "type": "string" } },
+              "integration": { "type": "array", "items": { "type": "string" } },
+              "commands": { "type": "array", "items": { "type": "string" } },
+              "coverage_target": { "type": "number" }
+            }
+          },
+          "regression": {
             "type": "array",
             "items": { "type": "string" },
-            "description": "Quantified completion criteria"
+            "description": "Regression check points"
+          },
+          "acceptance": {
+            "type": "object",
+            "description": "Acceptance criteria & verification",
+            "required": ["criteria", "verification"],
+            "properties": {
+              "criteria": { "type": "array", "items": { "type": "string" } },
+              "verification": { "type": "array", "items": { "type": "string" } },
+              "manual_checks": { "type": "array", "items": { "type": "string" } }
+            }
+          },
+          "commit": {
+            "type": "object",
+            "description": "Commit specification",
+            "properties": {
+              "type": { "type": "string", "enum": ["feat", "fix", "refactor", "test", "docs", "chore"] },
+              "scope": { "type": "string" },
+              "message_template": { "type": "string" },
+              "breaking": { "type": "boolean" }
+            }
           },
           "depends_on": {
             "type": "array",
@@ -80,6 +110,28 @@
             "type": "string",
             "enum": ["codex", "gemini", "agent", "auto"],
             "default": "auto"
+          },
+          "lifecycle_status": {
+            "type": "object",
+            "description": "Lifecycle phase tracking",
+            "properties": {
+              "implemented": { "type": "boolean" },
+              "tested": { "type": "boolean" },
+              "regression_passed": { "type": "boolean" },
+              "accepted": { "type": "boolean" },
+              "committed": { "type": "boolean" }
+            }
+          },
+          "status": {
+            "type": "string",
+            "enum": ["pending", "ready", "executing", "completed", "failed", "blocked"],
+            "default": "pending"
+          },
+          "priority": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 5,
+            "default": 3
           }
         }
       }
@@ -97,6 +149,21 @@
         "integration_points": { "type": "string" }
       }
     },
+    "analysis": {
+      "type": "object",
+      "description": "Solution risk assessment",
+      "properties": {
+        "risk": { "type": "string", "enum": ["low", "medium", "high"] },
+        "impact": { "type": "string", "enum": ["low", "medium", "high"] },
+        "complexity": { "type": "string", "enum": ["low", "medium", "high"] }
+      }
+    },
+    "score": {
+      "type": "number",
+      "minimum": 0,
+      "maximum": 1,
+      "description": "Solution quality score (0.0-1.0)"
+    },
     "status": {
       "type": "string",
       "enum": ["draft", "candidate", "bound", "queued", "executing", "completed", "failed"],

package/ccw/dist/commands/issue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"issue.d.ts","sourceRoot":"","sources":["../../src/commands/issue.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAgKH,UAAU,YAAY;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAw+BD,wBAAsB,YAAY,CAChC,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EACvB,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,IAAI,CAAC,CAiFf"}
+{"version":3,"file":"issue.d.ts","sourceRoot":"","sources":["../../src/commands/issue.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAiLH,UAAU,YAAY;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAw+BD,wBAAsB,YAAY,CAChC,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EACvB,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,IAAI,CAAC,CAiFf"}