ace-idea 0.18.0

data/handbook/workflow-instructions/idea/capture.wf.md

@@ -0,0 +1,270 @@
+---
+doc-type: workflow
+title: Capture Idea Workflow Instruction
+purpose: Documentation for ace-idea/handbook/workflow-instructions/idea/capture.wf.md
+ace-docs:
+  last-updated: 2026-03-01
+  last-checked: 2026-03-21
+---
+
+# Capture Idea Workflow Instruction
+
+## Goal
+
+Use the ace-idea tool to capture and enhance raw ideas within project context, transforming informal thoughts into structured, contextual ideas ready for future specification phases.
+
+## Prerequisites
+
+* `ace-idea` tool available (from dev-tools Ruby gem)
+* Raw idea text or concept to capture
+* LLM provider configured (Google Gemini recommended)
+* Write access to the configured ideas directory (default: `.ace-ideas/`)
+
+## Process Steps
+
+1. **Identify the Idea Source:**
+   * Determine the input method for your raw idea:
+     * **Direct text**: You have the idea ready as text
+     * **Clipboard**: Idea is copied to clipboard
+     * **File content**: Idea is stored in a text file
+   * Prepare the idea text - can be informal, unstructured, or just a brief concept
+
+2. **Choose Appropriate Command Options:**
+   * **Basic usage** (most common):
+     ```bash
+     ace-idea create "your raw idea text here"
+     ```
+
+   * **From clipboard**:
+     ```bash
+     ace-idea create --clipboard
+     # OR combine with context:
+     ace-idea create "Main context" --clipboard
+     ```
+
+   * **With explicit title and tags**:
+     ```bash
+     ace-idea create "Explicit idea text here" --title "Refined title" --tags ux,ideas
+     ```
+
+   * **With folder placement**:
+     ```bash
+     # Park uncertain work in _maybe
+     ace-idea create "Future experiment" --move-to maybe
+
+     # Keep low-priority work in _anytime
+     ace-idea create "Nice-to-have polish" --move-to anytime
+
+     # Fresh captures go to root by default (no --move-to needed)
+     ace-idea create "New feature idea"
+     ```
+
+   * **With Git commit**:
+     ```bash
+     ace-idea create "New feature" --git-commit
+     ```
+
+   * **With LLM enhancement**:
+     ```bash
+     ace-idea create "Complex idea" --llm-enhance
+     ```
+
+3. **Execute Idea Capture:**
+   * Run the selected `ace-idea create` command
+   * The tool will automatically:
+     * Create a structured idea file with frontmatter metadata
+     * Generate a folder and spec filename using the raw ID and slug
+     * Optionally enhance with LLM (if `--llm-enhance` or configured)
+     * Optionally commit to git (if `--git-commit` or configured)
+     * Store the idea in `.ace-ideas/` or the configured root, with optional folder placement (e.g., `_maybe`, `_anytime`)
+   * Monitor the output for the created file path
+
+4. **Verify Idea Creation:**
+   * Check that the command completed successfully
+   * Note the output file path showing:
+     - The configured ideas root (default: `.ace-ideas/`)
+     - Optional special folder such as `_maybe`, `_anytime`, or `_archive`
+     - Idea directory (format: `{id}-{slug}/`)
+     - Idea file (format: `{id}-{slug}.idea.s.md`)
+   * Verify the file exists and contains:
+     - Frontmatter with `id`, `status`, `title`, `tags`, and `created_at`
+     - Content body with your idea details
+   * Review the generated content for quality
+
+5. **Document the Captured Idea:**
+   * Record the path to the created idea file for future reference
+   * Note any follow-up actions or related ideas
+   * Consider whether immediate specification work is needed
+
+## Decision Guidance
+
+### When to Use This Workflow
+
+**Use capture-idea when:**
+* You have a raw, unstructured idea that needs project context
+* Ideas come from brainstorming, user feedback, or informal discussions
+* You want to preserve ideas for future development cycles
+* Ideas need contextual questions for proper specification later
+
+**Don't use capture-idea when:**
+* You already have well-structured requirements (use draft-task instead)
+* The idea is just a quick note (simple text file may suffice)
+* You need immediate implementation (use work-on-task workflow)
+
+### Scope Considerations
+
+* **Root ideas** (default): Fresh captures — no `--move-to` needed
+* **Maybe queue** (`--move-to maybe`): Ideas worth revisiting later
+* **Anytime queue** (`--move-to anytime`): Low-priority work with no immediate deadline
+* **Archive** (`--move-to archive`): Completed or retired ideas
+
+## Common Usage Patterns
+
+### Pattern 1: Quick Idea Capture
+```bash
+# Capture a brief concept immediately
+ace-idea create "Add real-time notifications to the dashboard"
+# => Created: .ace-ideas/8ppq7w-real-time-notifications/8ppq7w-real-time-notifications.idea.s.md
+```
+
+### Pattern 2: Place an Idea in _maybe
+```bash
+# Park an idea for later evaluation
+ace-idea create "Migrate to PostgreSQL" --move-to maybe
+# => Created: .ace-ideas/_maybe/8ppq7w-migrate-to-postgresql/8ppq7w-migrate-to-postgresql.idea.s.md
+```
+
+### Pattern 3: Clipboard Integration
+```bash
+# Copy idea text to clipboard first, then:
+ace-idea create --clipboard
+# OR combine with main context:
+ace-idea create "Dashboard improvements" --clipboard
+# => Created: .ace-ideas/8ppq7w-dashboard-improvements/8ppq7w-dashboard-improvements.idea.s.md
+```
+
+### Pattern 4: Enhanced Idea with Git Commit
+```bash
+# Create enhanced idea and automatically commit
+ace-idea create "Complex refactoring task" --llm-enhance --git-commit
+# => LLM enhances idea, creates file, commits to git
+# => Created: .ace-ideas/8ppq7w-complex-refactoring-task/8ppq7w-complex-refactoring-task.idea.s.md
+```
+
+### Pattern 5: GTD-Style Folder Organization
+```bash
+# Uncertain idea
+ace-idea create "Consider switching to TypeScript" --move-to maybe
+
+# Low priority idea
+ace-idea create "Add dark mode theme" --move-to anytime
+
+# Archive an old idea later
+ace-idea update q7w --move-to archive
+```
+
+## Error Handling
+
+### Common Issues and Solutions
+
+**"No content provided" Error:**
+* **Cause**: Missing idea text argument and no clipboard input
+* **Solution**: Provide idea text: `ace-idea create "your idea"`
+* **Alternative**: Use `--clipboard`
+
+**"Could not read from clipboard" Error:**
+* **Cause**: Clipboard tools not available on system (pbpaste/pbcopy on macOS)
+* **Solution**: Use direct text input or ensure clipboard tools are available
+* **Note**: Clipboard functionality requires `ace-support-mac-clipboard` gem
+
+**"Invalid target folder" Error:**
+* **Cause**: `--move-to` was given a virtual filter (e.g., `next`) instead of a physical folder
+* **Solution**: Use a physical folder: `maybe`, `anytime`, `archive`, or any custom name. Note: `next` is a virtual filter for listing, not a physical folder — omit `--move-to` to place ideas in root
+
+**LLM Enhancement Failures:**
+* **Cause**: API issues, model unavailability, or `--no-llm-enhance` flag
+* **Result**: Tool saves raw idea without LLM enhancement
+* **Action**: Check LLM configuration, network/API keys, or accept basic idea file
+* **Note**: Enhancement is optional; ideas work fine without it
+
+**Git Commit Failures:**
+* **Cause**: Git repository issues or `--no-git-commit` flag
+* **Result**: Idea file created but not committed
+* **Action**: Manually commit later or fix git configuration
+
+## Success Criteria
+
+* Idea successfully captured in appropriate directory:
+  - Root: `.ace-ideas/`
+  - Special folder: `.ace-ideas/_maybe/`, `.ace-ideas/_anytime/`, or `.ace-ideas/_archive/`
+* Generated file structure includes:
+  - Idea directory (e.g., `8ppq7w-dark-mode/`)
+  - Idea file with frontmatter (e.g., `8ppq7w-dark-mode.idea.s.md`)
+* Frontmatter contains required metadata:
+  - `id`: Raw idea identifier
+  - `status`: Initial status
+  - `title`: Human-readable title
+  - `tags`: Array of tags
+  - `created_at`: Creation timestamp
+* File content includes idea description and details
+* Tool returns created file path for reference
+* No errors during capture process
+* Optional: Git commit created (if configured or requested)
+* Optional: LLM enhancement applied (if configured or requested)
+
+## Integration with Other Workflows
+
+### Natural Follow-up Workflows
+
+**After capturing ideas:**
+* **draft-task**: When ready to turn idea into actionable task
+* **draft-release**: During release planning to review captured ideas
+* **create-reflection-note**: To document patterns from multiple ideas
+
+**Preparation workflows:**
+* **load-project-context**: If project context files are missing
+* **update-blueprint**: If project structure has changed significantly
+
+## Usage Examples
+
+### Example 1: User Feedback Integration
+```bash
+# After receiving user feedback: "Users want better mobile experience"
+ace-idea create "Users report difficulties with mobile interface - want better responsive design and touch interactions" --llm-enhance
+# Output: Creates enhanced idea with mobile UX questions and project-specific considerations
+# => .ace-ideas/8ppq7w-mobile-interface-improvements/...
+```
+
+### Example 2: Technical Improvement Ideas
+```bash
+# During code review, note performance concerns
+ace-idea create "Database queries in user dashboard are slow - consider caching layer and query optimization" --git-commit
+# Output: Creates idea and commits to git automatically
+# => .ace-ideas/8ppq7w-database-query-optimization/...
+```
+
+### Example 3: Maybe-Later Feature Ideas
+```bash
+# Capture future feature for later evaluation
+ace-idea create "Add GraphQL API alongside REST" --move-to maybe
+# Output: Creates idea in the maybe queue for later evaluation
+# => .ace-ideas/_maybe/8ppq7w-graphql-api-alongside-rest/...
+```
+
+### Example 4: Configuration for Automatic Enhancement
+```yaml
+# ~/.ace/idea/config.yml
+idea:
+  defaults:
+    git_commit: true     # Always commit new ideas
+    llm_enhance: true    # Always enhance new captures
+```
+```bash
+# Now simple command does both
+ace-idea create "New feature concept"
+# => Automatically enhanced and committed
+```
+
+---
+
+This workflow enables efficient capture and enhancement of raw ideas, ensuring they're preserved with proper project context and structured for future development consideration. The ace-idea tool handles the complexity of context loading and enhancement, providing a simple interface for idea preservation.

data/handbook/workflow-instructions/idea/prioritize.wf.md

@@ -0,0 +1,223 @@
+---
+doc-type: workflow
+title: Prioritize and Align Ideas
+purpose: Documentation for ace-idea/handbook/workflow-instructions/idea/prioritize.wf.md
+ace-docs:
+  last-updated: 2026-03-01
+  last-checked: 2026-03-21
+---
+
+# Prioritize and Align Ideas
+
+## Goal
+
+Systematically organize, prioritize, and align queued ideas with current project architecture to create an actionable implementation roadmap.
+
+## Prerequisites
+
+* Access to the project's ideas directory and current queue folders
+* Understanding of project's architecture patterns
+* Access to project documentation in `docs/` directory
+* Knowledge of existing tools and workflows
+
+## Project Context Loading
+
+- Read and follow: `ace-bundle wfi://bundle`
+
+## Process Steps
+
+### 1. **Analyze Current Ideas:**
+   * List all files in the project's current idea queues
+   * Read each idea file to understand:
+     - Problem being solved
+     - Proposed solution
+     - Expected impact
+     - Implementation complexity
+   * Group ideas by theme or category
+   
+   **Validation:**
+   * All idea files have been read and cataloged
+   * Ideas are grouped into logical categories
+
+### 2. **Determine Prioritization Scope:**
+   * Define number of ideas to prioritize:
+     - Default: Top 10 most impactful
+     - Configurable: `--count N` for specific number
+     - All: `--all` to process entire backlog
+   * Apply prioritization criteria:
+     - Impact: Critical > High > Medium > Low
+     - Complexity: Hours > Days > Weeks
+     - Dependencies: Independent > Few > Many
+   
+   **Validation:**
+   * Clear list of ideas to be processed
+   * Prioritization rationale documented
+
+### 3. **Research Project Architecture:**
+   * Identify project's technical patterns:
+     ```bash
+     # For Ruby projects
+     ls -1 exe/ lib/*/
+     
+     # For Node.js projects  
+     ls -1 src/ bin/
+     
+     # For generic projects
+     find . -type f -name "*.md" | head -20
+     ```
+   * Review existing tools and utilities
+   * Understand naming conventions and structure
+   * Identify workflow instruction patterns (if applicable)
+   
+   **Validation:**
+   * Project structure documented
+   * Key architectural patterns identified
+   * Existing tools inventory complete
+
+### 4. **Prioritize Ideas Using Folder Updates:**
+   * Use `ace-idea update --move-to` to place ideas into priority folders
+   * Priority levels:
+     - **High priority** (Critical impact, low complexity): Move to `_next`
+     - **Medium priority** (High impact or medium complexity): Move to `_maybe`
+     - **Lower priority** (remaining ideas): Move to `_anytime`
+
+   * Update pattern:
+     ```bash
+     # Place highest priority ideas in next queue
+     ace-idea update <idea-1> --move-to next
+
+     # Place medium priority ideas in maybe folder
+     ace-idea update <idea-2> --move-to maybe
+
+     # Place lower priority ideas in anytime folder
+     ace-idea update <low-priority-idea> --move-to anytime
+     ```
+
+   **How it works:**
+   * Updates move idea files between folders (`_next`, `_maybe`, `_anytime`)
+   * Ideas are listed per folder when using `ace-idea list --in <folder>`
+   * The same command can also update metadata such as `status` when needed
+
+   **Validation:**
+   * Running `ace-idea list --in next` shows high-priority ideas
+   * Can re-prioritize later by moving ideas between folders again
+
+### 5. **Align Ideas with Project Architecture:**
+   For each prioritized idea:
+   * Update file paths to match project structure
+   * Reference existing tools and utilities
+   * Align with project's architectural patterns
+   * Include implementation approach specific to project
+   * Add testing strategy appropriate to project
+   * Define measurable success metrics
+   
+   Template for aligned idea:
+   ```markdown
+   # [Improvement Name]
+   
+   ## Intention
+   [Clear problem statement]
+   
+   ## Problem It Solves
+   **Current Issues:**
+   **Impact:**
+   
+   ## Solution Direction
+   ### Implementation Approach
+   [Project-specific implementation details]
+   
+   ### Integration Points
+   [How it fits with existing architecture]
+   
+   ## Implementation Plan
+   Phase 1: [Core functionality]
+   Phase 2: [Enhancements]
+   
+   ## Testing Strategy
+   [Project-appropriate testing approach]
+   
+   ## Success Metrics
+   [Measurable outcomes]
+   ```
+   
+   **Validation:**
+   * Ideas reference correct project paths
+   * Implementation aligns with project patterns
+   * Testing approach matches project standards
+
+### 6. **Create Implementation Roadmap:**
+   Generate `000-implementation-roadmap.md` containing:
+   * Executive summary of prioritized improvements
+   * Ordered list with effort estimates
+   * Implementation timeline (weekly/sprint-based)
+   * Technical dependencies and risks
+   * Success metrics and governance
+   
+   **Validation:**
+   * Roadmap provides clear action plan
+   * Timeline is realistic and achievable
+   * Dependencies clearly identified
+
+### 7. **Clean Up and Finalize:**
+   * Remove any temporary files created during process
+   * Verify prioritized ideas are in the expected folders
+   * Verify folder contents with `ace-idea list --in next`, `ace-idea list --in maybe`, and `ace-idea list --in anytime`
+   * Create summary of changes for commit message
+
+   **Validation:**
+   * No temporary files remain
+   * Folder listings reflect the intended priorities
+   * `ace-idea list --in next` shows the most actionable ideas
+   * Git status shows the expected renamed or moved idea directories
+   * Ready for review and commit
+
+## Success Criteria
+
+* All selected ideas are placed in the intended priority folders
+* Ideas aligned with current project architecture
+* Implementation roadmap created with clear timeline
+* No broken references or missing dependencies
+* `ace-idea list --in next` displays the highest-priority ideas
+* Changes ready for version control commit
+
+## Error Handling
+
+**Missing Architecture Documentation:**
+* **Symptoms:** No docs/ directory or architecture files
+* **Solution:** Infer from project structure and existing code
+
+**Conflicting Priorities:**
+* **Symptoms:** Multiple ideas with same impact/complexity
+* **Solution:** Use additional criteria (dependencies, risk, user value)
+
+**Large Backlogs (>50 ideas):**
+* **Symptoms:** Too many ideas to process effectively
+* **Solution:** Focus on top 20, schedule remaining for future cycles
+
+## Usage Example
+
+> "Organize and prioritize our backlog of 47 improvement ideas, focusing on the top 10 most impactful ones that we can implement this quarter"
+
+## Common Patterns
+
+### For Different Project Types
+
+**Ruby/Rails Projects:**
+* Look for `exe/`, `lib/`, `spec/` directories
+* Reference Gemfile for dependencies
+* Align with RSpec testing patterns
+
+**Node.js Projects:**
+* Look for `src/`, `bin/`, `test/` directories
+* Reference package.json for dependencies
+* Align with Jest/Mocha testing patterns
+
+**Python Projects:**
+* Look for `src/`, `tests/`, `scripts/` directories
+* Reference requirements.txt/pyproject.toml
+* Align with pytest patterns
+
+**Generic Projects:**
+* Focus on `docs/` directory structure
+* Identify primary language from file extensions
+* Use general software patterns

data/handbook/workflow-instructions/idea/review.wf.md

@@ -0,0 +1,93 @@
+---
+doc-type: workflow
+title: Review Idea Workflow Instruction
+purpose: Documentation for ace-idea/handbook/workflow-instructions/idea/review.wf.md
+ace-docs:
+  last-updated: 2026-03-02
+  last-checked: 2026-03-21
+---
+
+# Review Idea Workflow Instruction
+
+## Goal
+
+Critically evaluate an idea for clarity, impact, scope boundaries, and execution readiness. This workflow acts as an adversarial quality gate before converting ideas into implementation tasks.
+
+## When to Use
+
+- Reviewing raw idea notes before drafting a task
+- Final synthesis of simulation runs focused on idea quality
+- Evaluating whether an idea is ready for prioritization or needs refinement
+
+## Evaluation Dimensions
+
+Evaluate against these six dimensions. Score each as **PASS**, **WEAK**, or **FAIL**.
+
+### 1. Problem Clarity
+- Is the problem concrete and specific?
+- Is the current pain/risk explicitly described?
+
+### 2. Outcome Clarity
+- Is the desired end state measurable?
+- Are success criteria observable and testable?
+
+### 3. Scope Boundaries
+- Are in-scope and out-of-scope boundaries explicit?
+- Are assumptions/defaults documented?
+
+### 4. Feasibility Signals
+- Are technical constraints, dependencies, and risks acknowledged?
+- Is the effort level realistic for the expected value?
+
+### 5. Decision Gaps
+- Are key unknowns listed with concrete questions?
+- Are blocking decisions separated from nice-to-have details?
+
+### 6. Next-Step Readiness
+- Is there a clear immediate next action (draft task, research, reject, etc.)?
+- Could another agent continue work without guessing?
+
+## Output Format
+
+Return markdown in this structure:
+
+```markdown
+## Idea Critique
+
+**Verdict:** READY TO DRAFT | NEEDS REFINEMENT | INSUFFICIENT
+
+### Dimension Scores
+
+| Dimension | Score | Notes |
+|-----------|-------|-------|
+| Problem Clarity | PASS/WEAK/FAIL | One-line finding |
+| Outcome Clarity | PASS/WEAK/FAIL | One-line finding |
+| Scope Boundaries | PASS/WEAK/FAIL | One-line finding |
+| Feasibility Signals | PASS/WEAK/FAIL | One-line finding |
+| Decision Gaps | PASS/WEAK/FAIL | One-line finding |
+| Next-Step Readiness | PASS/WEAK/FAIL | One-line finding |
+
+### What to Update
+- [Concrete updates to make the idea implementation-ready]
+
+### What Needs Precision
+- [Blocking questions and missing specifics]
+
+### Prioritized Next Actions
+1. [Highest impact next action]
+2. [Second action]
+3. [Third action]
+```
+
+## Verdict Criteria
+
+- **READY TO DRAFT:** No FAIL scores, at most one WEAK score
+- **NEEDS REFINEMENT:** No more than two FAIL scores, or three+ WEAK scores
+- **INSUFFICIENT:** Three or more FAIL scores
+
+## Review Principles
+
+- Be adversarial and specific.
+- Demand explicit decisions where ambiguity blocks execution.
+- Prefer concrete, testable suggestions over generic advice.
+- Avoid introducing implementation details beyond the idea stage unless required for feasibility.

data/lib/ace/idea/atoms/idea_file_pattern.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Ace
+  module Idea
+    module Atoms
+      # Provides glob patterns for finding idea spec files.
+      # Ideas use the .idea.s.md extension to distinguish from task .s.md files.
+      module IdeaFilePattern
+        # Glob pattern for idea spec files within a directory
+        FILE_GLOB = "*.idea.s.md"
+
+        # Full file extension for idea spec files
+        FILE_EXTENSION = ".idea.s.md"
+
+        # Build the spec filename for an idea
+        # @param id [String] Raw 6-char b36ts ID
+        # @param slug [String] Kebab-case slug
+        # @return [String] Spec filename (e.g., "8ppq7w-dark-mode.idea.s.md")
+        def self.spec_filename(id, slug)
+          "#{id}-#{slug}#{FILE_EXTENSION}"
+        end
+
+        # Build the folder name for an idea
+        # @param id [String] Raw 6-char b36ts ID
+        # @param slug [String] Kebab-case slug
+        # @return [String] Folder name (e.g., "8ppq7w-dark-mode")
+        def self.folder_name(id, slug)
+          "#{id}-#{slug}"
+        end
+
+        # Check if a filename matches the idea spec pattern
+        # @param filename [String] Filename to check
+        # @return [Boolean] True if it's an idea spec file
+        def self.idea_file?(filename)
+          filename.to_s.end_with?(FILE_EXTENSION)
+        end
+      end
+    end
+  end
+end

data/lib/ace/idea/atoms/idea_frontmatter_defaults.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Ace
+  module Idea
+    module Atoms
+      # Provides default frontmatter values for idea spec files.
+      # Generates the canonical YAML frontmatter block for new ideas.
+      module IdeaFrontmatterDefaults
+        # Build frontmatter hash for a new idea
+        # @param id [String] Raw 6-char b36ts ID
+        # @param title [String] Idea title
+        # @param tags [Array<String>] List of tags (default: [])
+        # @param status [String] Initial status (default: "pending")
+        # @param created_at [Time] Creation time (default: now)
+        # @return [Hash] Frontmatter hash ready for YAML serialization
+        def self.build(id:, title:, tags: [], status: "pending", created_at: Time.now.utc)
+          {
+            "id" => id,
+            "status" => status,
+            "title" => title,
+            "tags" => Array(tags),
+            "created_at" => created_at.strftime("%Y-%m-%d %H:%M:%S")
+          }
+        end
+
+        # Serialize frontmatter hash to YAML block string.
+        # Delegates to the shared FrontmatterSerializer atom.
+        # @param frontmatter [Hash] Frontmatter data
+        # @return [String] YAML frontmatter block including delimiters
+        def self.serialize(frontmatter)
+          require "ace/support/items"
+          Ace::Support::Items::Atoms::FrontmatterSerializer.serialize(frontmatter)
+        end
+      end
+    end
+  end
+end

data/lib/ace/idea/atoms/idea_id_formatter.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "ace/b36ts"
+
+module Ace
+  module Idea
+    module Atoms
+      # Generates and formats raw b36ts IDs for ideas.
+      # Ideas use raw 6-char b36ts IDs without type markers.
+      # Example: "8ppq7w" (no ".t." or ".i." separator)
+      class IdeaIdFormatter
+        # Generate a new raw 6-char b36ts ID for an idea
+        # @param time [Time] Time to encode (default: now)
+        # @return [String] 6-character raw b36ts ID (e.g., "8ppq7w")
+        def self.generate(time = Time.now.utc)
+          Ace::B36ts.encode(time, format: :"2sec")
+        end
+
+        # Validate that a string is a valid raw idea ID
+        # @param id [String] The ID to validate
+        # @return [Boolean] True if valid 6-char b36ts ID
+        def self.valid?(id)
+          return false if id.nil? || id.empty?
+
+          Ace::B36ts.valid?(id)
+        end
+
+        # Decode a raw idea ID to the time it was created
+        # @param id [String] Raw 6-char b36ts ID
+        # @return [Time] The time encoded in the ID
+        def self.decode_time(id)
+          Ace::B36ts.decode(id)
+        end
+      end
+    end
+  end
+end