ace-task 0.31.9 → 0.36.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c67dcf6153b34a7d6a72bf8e58bba04945835c1af53ba458391c857f49260ad
-  data.tar.gz: 68546adc536f8f70b260e6e7315bfa965112322e4e25dc737bde18b25169461d
+  metadata.gz: 34781c3bdaae6a3d794b1d2ff7654b80cd0c6df85377960ca85e6b9e3868bf20
+  data.tar.gz: a9da028f06155e0dfa3dd24f39c8d625d1768c965e26af2351f6f5e477d3510e
 SHA512:
-  metadata.gz: dab5c187c7f4f6c031c3510b37b6f0322e8aa73d2aeb57290d7be2d46120ec7c2ea79f4dc18c37a4bfc2d004f760ba502e7f4c377e61cfaa0c83e901cb5668ae
-  data.tar.gz: 7dd3dfd6cf4b25ea4180310ed6240ef0d421c9a724c6662bc95b926e846060b6b08cf8adf625648d878c35858268cb96ae702479c621c0398ceaf31287a22a1b
+  metadata.gz: '0189d7b62882f379f721d5c34a3e5e0ca4aad445631cddc9ab88ecb46c235eb500df1a633be1ccb9dff9aba5c4267935c037baded1d4a3bdc7a76568c2940a2e'
+  data.tar.gz: 755d4133499d1e4f005645affb13a8b723e1f1f48d5739072c25af44e29c172b3b7b068fc7def6e32ebf4a72af8cbcbf88f957e3f990c6fd4fd2711227561a0a

data/CHANGELOG.md

@@ -7,6 +7,166 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.36.1] - 2026-04-19
+
+### Technical
+- Decoupled retained create/list/show and archive E2E goals so task root-state evidence is captured before later archive movement.
+- Clarified `TS-TASK-002` plan-path verification so bounded planner timeout diagnostics are accepted as actionable sandbox evidence.
+
+## [0.36.0] - 2026-04-16
+
+### Changed
+- Added `ace-task plan --timeout` so path-based plan generation can be bounded explicitly from the public CLI.
+- Documented bounded plan generation and timeout troubleshooting in the getting-started and usage guides.
+
+### Fixed
+- Converted planner-provider timeout failures into actionable CLI errors instead of surfacing raw timeout backtraces.
+- Updated `TS-TASK-002` path-mode verification to accept explicit timeout diagnostics when plan generation cannot complete within the requested bound.
+
+## [0.35.7] - 2026-04-16
+
+### Fixed
+- Refined `TS-TASK-001` smoke verification around sandbox-root task trees, archive layout, and invalid-status doctor evidence so retained E2E goals track the current public CLI behavior.
+
+## [0.35.6] - 2026-04-15
+
+### Fixed
+- Tightened `TS-TASK-002` plan-path verification to require at least one successful path-mode plan artifact while keeping explicit diagnostics for failed dependency paths.
+
+## [0.35.5] - 2026-04-15
+
+### Changed
+- Reworked retained `TS-TASK-001` goal contracts to use deterministic task-ref handoff artifacts across create/show/update/archive smoke journeys.
+- Added `TS-TASK-002` auxiliary public CLI journeys for `status` and `plan` command coverage, with explicit sandbox diagnostics for unavailable planning dependencies.
+- Updated usage docs with E2E-safe `ace-task plan <ref>` path-mode guidance and `github-sync` precondition examples.
+- Tightened spike-task drafting, review, and work-on-task guidance so spikes must declare whether they are design-contract or proof-of-concept work, define explicit follow-up tasks, and stop implementation flow when runtime work materially drifts from the promised spike contract.
+
+## [0.35.4] - 2026-04-13
+
+### Fixed
+- Reworked `TS-TASK-001` smoke coverage to validate created and archived tasks from stable task-tree state plus runner observations instead of brittle helper files under `results/`.
+
+## [0.35.3] - 2026-04-13
+
+### Fixed
+- Hardened `TS-TASK-001` task-ref capture so create/show/archive smoke coverage derives the persisted short ref from stable list/filesystem evidence instead of brittle prose parsing.
+
+## [0.35.2] - 2026-04-13
+
+### Technical
+- Refreshed `TS-TASK-001` archive and doctor smoke scenario contracts to match the current `_archive` layout and isolate the invalid-status validation path.
+
+## [0.35.1] - 2026-04-13
+
+### Fixed
+- Accepted subtask IDs in task frontmatter ID validation so doctor frontmatter checks no longer report false invalid-ID errors for valid subtasks.
+- Added atomic task-ID reservation during create so concurrent creates treat lock contention as retryable collisions instead of racing through non-atomic prechecks.
+
+### Technical
+- Narrowed task ID-existence scans to ID-prefixed glob matches and added regression coverage for subtask ID validation plus reservation-lock collision behavior.
+
+## [0.35.0] - 2026-04-13
+
+### Fixed
+- Added duplicate persisted task-ID detection to doctor health checks, including subtask collisions and frontmatter-only doctor validation failures.
+- Added bounded retry handling for standalone `ace-task create` ID collisions with clear retry-exhaustion failures and no partial-artifact leakage.
+
+### Technical
+- Added regression coverage for duplicate-ID doctor failures, create-time retry semantics, and cleanup guarantees.
+
+## [0.34.3] - 2026-04-13
+
+### Fixed
+- Added bounded retry handling for standalone `ace-task create` ID collisions so success is emitted only after a unique persisted task ID exists.
+- Added clear retry-exhaustion failure messaging for create-time ID collisions.
+
+### Technical
+- Added command and molecule regression coverage for task ID collision retries and partial-artifact cleanup guarantees.
+
+## [0.34.2] - 2026-04-13
+
+### Fixed
+- Report duplicate persisted task IDs as explicit doctor health-check errors with file-path context, including top-level and subtask collisions.
+- Include duplicate ID detection in `ace-task doctor --check frontmatter` and fail health status when duplicates are present.
+
+### Technical
+- Added organism and CLI regression coverage for duplicate top-level/subtask ID failures and frontmatter-only doctor checks.
+
+## [0.34.1] - 2026-04-13
+
+### Changed
+- Completed the batch i05 migration follow-through for this package and aligned it with the restarted `fast` / `feat` / `e2e` verification model.
+
+### Technical
+- Included in the coordinated assignment-driven patch release for batch i05 package updates.
+
+
+### Changed
+- Expanded canonical `as-task-plan` and `as-task-work` skill metadata so public `plan-task` and `work-on-task` assign-step discovery is skill-owned rather than catalog-owned.
+
+## [0.34.0] - 2026-04-12
+
+### Changed
+- Migrated package tests to the restarted `fast` / `feat` / `e2e` model by moving deterministic coverage to `test/fast`, retaining `TS-TASK-001` as workflow-value E2E coverage, and updating package testing guidance.
+
+### Fixed
+- Hardened `TS-TASK-001` sandbox bootstrap and doctor error-path runner setup so repeated E2E runs start from a clean healthy baseline before malformed-task injection.
+
+## [0.33.3] - 2026-04-07
+
+### Changed
+- Added linked GitHub issue metadata handling as a single ownership model and kept task/task manager sync behavior aligned with linked-task life cycle updates.
+
+### Fixed
+- Fixed GitHub sync dispatch and manual sync verification paths by routing through the reusable sync flow and tightening demo-task linkage checks.
+
+### Technical
+- Expanded test coverage around GitHub sync assertions, frontmatter ownership validation, and workflow-level linked issue behavior.
+
+## [0.33.2] - 2026-04-07
+
+### Changed
+- Updated the live GitHub sync demo tape to declare semantic verification expectations for exported issue/task refs, forbidden error output, and final closed-issue state.
+
+## [0.33.1] - 2026-04-07
+
+### Fixed
+- Corrected create-time GitHub sync dispatch so `ace-task` resolves the reusable `sync_task` integration instead of the ownership-validator entrypoint.
+- Fixed the live GitHub sync demo tape to recover the created task ref from slugified task filenames during recording.
+
+## [0.33.0] - 2026-04-07
+
+### Fixed
+- Hardened linked-issue synchronization by loading `ace/git` on the main runtime path, reconciling previous/current issue ID sets during updates, and treating GitHub sync failures as non-blocking task warnings.
+- Surfaced manual `github-sync` failures with per-task error details and an explicit non-zero CLI failure when requested sync work does not complete.
+- Updated linked issue sync payloads to use task spec file paths for sticky comment links so GitHub issue references land on `.s.md` source-of-truth files.
+- Updated `ace-task create` to print non-blocking GitHub sync warnings (`last_update_note`) so create-time linked-issue sync failures are visible to operators.
+- Replaced array-style linked issue metadata with singular `github_issue` ownership and reject duplicate `--github-issue` flags.
+
+### Changed
+- Updated ACE-linked GitHub issue lifecycle guidance to treat task metadata and ACE-managed sync as the canonical path, while keeping PR footer closure keywords as optional manual guidance.
+- Updated linked GitHub issue storage and task-manager sync hooks to enforce one canonical owning task per GitHub issue.
+- Reworked the GitHub sync demo to show live issue creation, task linkage, and automatic issue closure.
+
+### Technical
+- Added linked-issue metadata contract checks to task draft/review workflow instructions and aligned related task spec examples for consistency.
+- Expanded create/update/frontmatter/manager test coverage for singular `github_issue` ownership and conflict handling.
+
+## [0.32.0] - 2026-04-05
+
+### Added
+- Added `ace-task github-sync` command for manual linked-issue synchronization by task reference or `--all`.
+- Added `--github-issue` create-time linkage support for storing machine-readable `github_issue` task metadata.
+- Added lifecycle sync orchestration through `TaskManager` and `GithubIssueSyncAdapter` for linked task create/update/reparent flows.
+
+### Changed
+- Extended task frontmatter defaults to emit structured `github_issue` metadata when linked issues are provided.
+- Updated `ace-task` usage documentation with linked issue create flags and manual sync command usage.
+
+### Technical
+- Added validation rules for `github` and `github_issue` frontmatter structure and numeric issue IDs.
+- Expanded command/organism/validator/defaults test coverage for linked issue metadata and sync behavior.
+
 ## [0.31.9] - 2026-03-31
 
 ### Changed

data/README.md

@@ -26,6 +26,13 @@ Tasks are markdown specs living in git - attached to branches and worktrees, not
 2. Review and planning workflows refine scope before implementation.
 3. Oversee execution through worktrees and assignments until ship-ready.
 
+## Testing Model
+
+- `ace-test ace-task` runs deterministic package tests (`test/fast`) for the default feedback loop.
+- `ace-test ace-task feat` runs deterministic feature coverage when `test/feat` exists.
+- `ace-test ace-task all` runs all deterministic lanes.
+- `ace-test-e2e ace-task` runs retained real workflow scenarios from `test/e2e`.
+
 ## Use Cases
 
 **Draft and structure work** - create a task, split it into subtasks, add new subtasks as work reveals scope. Use `/as-task-draft` to draft from an earlier captured [idea](../ace-idea) or short note, or [`ace-task create`](docs/usage.md#ace-task-create-title) from the CLI.

data/handbook/skills/as-task-draft/SKILL.md

@@ -3,7 +3,7 @@ name: as-task-draft
 description: Draft Task with Idea File Movement (SPECS ONLY - no code)
 # bundle: wfi://task/draft
 # context: no-fork
-# agent: general-purpose
+# agent: Plan
 user-invocable: true
 allowed-tools:
   - Bash(ace-task:*)
@@ -22,3 +22,9 @@ skill:
 ---
 
 Load and run `ace-bundle wfi://task/draft` in the current project, then follow the loaded workflow as the source of truth and execute it end-to-end instead of only summarizing it.
+
+This skill is for specification work only.
+
+- Create or update draft task artifacts only.
+- Do not implement package code, tests, or runtime behavior changes.
+- If the user later says "implement", treat that as continuing the drafting/spec workflow unless they explicitly switch to `as-task-work` / `wfi://task/work`.

data/handbook/skills/as-task-plan/SKILL.md

@@ -18,10 +18,15 @@ skill:
   execution:
     workflow: wfi://task/plan
 assign:
-  source: wfi://task/plan
   steps:
     - name: plan-task
       description: Analyze task requirements and create an implementation plan
+      produces: [implementation-plan]
+      consumes: [project-base-context, task-spec]
+      when_to_skip:
+        - "Task is trivial and doesn't need a plan"
+        - "Implementation plan already exists"
+      effort: light
       tags: [planning, analysis]
       context:
         default: fork

data/handbook/skills/as-task-work/SKILL.md

@@ -17,7 +17,6 @@ argument-hint: [task-id like 123]
 last_modified: 2026-02-17
 source: ace-task
 assign:
-  source: wfi://task/work
   steps:
     - name: work-on-task
       description: Implement task changes following project conventions
@@ -27,6 +26,12 @@ assign:
           - "implement task"
           - "task work"
           - "build feature"
+      produces: [code-changes, commits]
+      consumes: [project-base-context, task-spec]
+      when_to_skip:
+        - "Task is documentation-only"
+        - "Changes are already implemented"
+      effort: medium
       tags: [implementation, core-workflow]
       context:
         default: fork

data/handbook/workflow-instructions/bug/analyze.wf.md

@@ -185,8 +185,8 @@ Systematically analyze bug reports to identify root cause, verify reproduction,
 - Purpose: Verify [specific behavior] handles [edge case]
 - Scenario: When [condition], expect [result]
 
-**Integration Test: [test name]**
-- Location: test/integration/[flow]_test.rb
+**Feature Test: [test name]**
+- Location: test/feat/[flow]_test.rb
 - Purpose: Verify [workflow] completes correctly
 - Scenario: Given [setup], when [action], then [verification]
 ```
@@ -357,7 +357,7 @@ Present the analysis to the user in this format:
    - Purpose: [What it validates]
 
 2. **[Test Name]** (integration)
-   - File: `test/integration/flow_test.rb`
+   - File: `test/feat/flow_test.rb`
    - Purpose: [What it validates]
 
 ### Fix Plan
@@ -420,7 +420,7 @@ This workflow provides systematic bug analysis that ensures proper investigation
    - Purpose: [What it validates]
 
 2. **[Test Name]** (integration)
-   - File: `test/integration/flow_test.rb`
+   - File: `test/feat/flow_test.rb`
    - Purpose: [What it validates]
 
 ### Fix Plan
@@ -455,4 +455,4 @@ risks:
   - "Potential side effect description"
 rollback_plan: "How to revert if issues arise"
 </template>
-</documents>
+</documents>

data/handbook/workflow-instructions/bug/fix.wf.md

@@ -140,7 +140,7 @@ git checkout -b fix/[bug-description]
 
 2. **Create integration test if needed:**
    ```ruby
-   # Example: test/integration/workflow_test.rb
+   # Example: test/feat/workflow_test.rb
    def test_complete_flow_with_missing_data
      # Test the full workflow that exhibited the bug
    end
@@ -509,4 +509,4 @@ The fix is ready for code review and merge.
 ### Notes
 [Any additional context about the fix]
 </template>
-</documents>
+</documents>

data/handbook/workflow-instructions/task/draft.wf.md

@@ -172,6 +172,22 @@ This prevents decomposing into subtasks that add concepts the spike later proves
 **Anti-pattern**: 8 subtasks drafted upfront, each adding features, then a late subtask undoes half.
 **Correct pattern**: 1 spike subtask validates the end-state, then remaining subtasks build toward it.
 
+Every spike-first draft must also declare the spike type:
+- **Design-contract spike**: validates target behavior and ownership boundaries, but does not yet claim runnable proof
+- **Proof-of-concept spike**: validates target behavior with runnable proof, not only a design contract
+
+For both spike types, the draft must include:
+1. one **Validated End-State Scenario**
+2. one **Concept Inventory** with kept / changed / new / rejected outcomes
+3. one **Adopted Decisions / Rejected Decisions / Deferred Gaps** section
+4. one **Follow-up Tasks After Spike** section naming the next implementation or adoption work that must happen if the spike succeeds
+
+For proof-of-concept spikes, the draft must additionally include:
+1. one concrete **Proof Artifact Plan** describing what runnable evidence will prove the spike
+2. success criteria that require the proof artifact, not only the concept inventory
+
+Do not treat "we now understand the design" as sufficient spike completion when the spike affects a runtime, UX, or execution-path contract. A useful spike must also leave a clear proof path and explicit next task.
+
 8. **Complete Behavioral Specifications**
    * For each created draft task, populate with:
      * Behavioral Specification section with embedded template
@@ -242,6 +258,9 @@ This prevents decomposing into subtasks that add concepts the spike later proves
      * [ ] Draft is decision-complete: no unresolved behavior choices left for implementer
      * [ ] Defaults are explicit where behavior could otherwise be ambiguous
      * [ ] Usage documentation created in `ux/usage.md` (when task changes any API surface)
+     * [ ] Spike tasks declare whether they are `design-contract` or `proof-of-concept`
+     * [ ] Spike tasks include explicit follow-up task(s) after the spike
+     * [ ] Proof-of-concept spikes include a runnable proof artifact plan
 
 12. **Run Quality Pass (Better, Not More)**
    * Perform one concise quality pass before finalizing:
@@ -549,4 +568,4 @@ the decomposition was premature. Consider consolidating remaining subtasks.
 ## Notes for Implementer
 - Full usage documentation to be completed during work-on-task step using `wfi://docs/update-usage`
 </template>
-</documents>
+</documents>

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

@@ -239,6 +239,27 @@ While review-task primarily serves as the draft-to-pending gate, it can provide
 
 For non-draft tasks, skip the Readiness Checklist and Promote/Block steps. Focus on content enhancement and question generation only.
 
+### Completed Spike Review
+
+When the reviewed task is a completed spike, treat spike usefulness as a review target:
+
+- Compare the archived spike contract against the shipped public/runtime contract instead of assuming the spike remained accurate.
+- Classify every meaningful difference as exactly one of:
+  - **intentional and adopted**
+  - **intentional but deferred to follow-up**
+  - **spec miss that must be corrected**
+- Verify that the spike left a reusable adoption path:
+  - explicit next task(s) exist
+  - deferred gaps are named, not implied
+  - any promised proof artifact exists if the spike was a proof-of-concept
+- Fail closed on spike usefulness if the spike completed without an explicit follow-up task, even if later implementation succeeded through ad-hoc decisions.
+- In the review summary for completed spikes, explicitly state whether the spike produced:
+  - a reusable contract
+  - a reusable proof artifact
+  - a reusable next-task decision
+
+Treat "concept inventory exists" as insufficient by itself for a successful spike review when the spike was meant to guide real runtime or UX work.
+
 ## Decision Guidance
 
 ### When to Use This Workflow
@@ -270,6 +291,7 @@ For non-draft tasks, skip the Readiness Checklist and Promote/Block steps. Focus
 - No loss of existing information
 - Clear improvement in task clarity or completeness
 - User receives actionable list of questions to answer (if any)
+- Completed spike reviews identify contract drift and verify explicit follow-up tasks
 
 ## Task Management Integration
 

data/handbook/workflow-instructions/task/work.wf.md

@@ -41,6 +41,7 @@ To avoid known `--content` stalls in some environments:
    - `ace-task plan <ref>` (path mode, reuse cached plan when available)
    - The most recent plan artifact plus current task spec, documented in the step report
 4. If stalls repeat, add a follow-up fix task and capture evidence in the retrospective.
+5. If implementation reveals the spec or spike contract is materially wrong, stale, or missing an adoption path, stop and either update the spec or add a follow-up task before continuing.
 
 ## Primary Directive
 
@@ -58,6 +59,7 @@ Work through the plan checklist, step by step:
 - If the spec says X, implement X — don't gold-plate, don't simplify away requirements
 - If spec and plan conflict, spec wins — the plan is a HOW, not a WHAT
 - If the spec is ambiguous or incomplete: stop and ask, don't assume
+- If runtime work materially changes a public contract promised by a spike (flags, naming, fallback behavior, proof surface, ownership boundary), do not silently drift. Update the task/spec or create a follow-up task before release or demo cleanup.
 
 **Prior implementation awareness:**
 - Before creating new modules, search for existing implementations of the same concern — especially spike or prototype code from prior subtasks
@@ -75,6 +77,7 @@ Work through the plan checklist, step by step:
 - `draft` status: warn the user that the spec hasn't been reviewed, then continue only with explicit confirmation. In unattended/fork contexts where interactive confirmation is not possible, proceed after marking in-progress — the assignment creation layer is responsible for blocking draft tasks before they reach this point.
 - Mark in-progress before first change, done after last verification
 - Never modify task frontmatter directly — use `ace-task update <ref> --set key=value`
+- If the task implements a spike outcome, verify before marking done that deferred gaps and adoption follow-ups are explicit rather than left implicit in release notes or retrospectives.
 
 ## Code Conventions
 

data/lib/ace/task/atoms/task_frontmatter_defaults.rb

@@ -18,7 +18,17 @@ module Ace
         # @param created_at [Time, nil] Creation time
         # @param parent [String, nil] Parent task ID for subtasks
         # @return [Hash] Frontmatter hash
-        def self.build(id:, status: "pending", priority: nil, tags: [], dependencies: [], created_at: nil, parent: nil, estimate: nil)
+        def self.build(
+          id:,
+          status: "pending",
+          priority: nil,
+          tags: [],
+          dependencies: [],
+          created_at: nil,
+          parent: nil,
+          estimate: nil,
+          github_issue: nil
+        )
           fm = {
             "id" => id,
             "status" => status || "pending",
@@ -29,6 +39,7 @@ module Ace
           fm["dependencies"] = dependencies || []
           fm["tags"] = tags || []
           fm["parent"] = parent if parent
+          fm["github_issue"] = github_issue if github_issue
           fm
         end
 

data/lib/ace/task/atoms/task_validation_rules.rb

@@ -19,7 +19,7 @@ module Ace
         end
 
         def self.valid_id?(id)
-          id.to_s.match?(/^[0-9a-z]{3}\.[a-z]\.[0-9a-z]{3}$/)
+          id.to_s.match?(/\A[0-9a-z]{3}\.[a-z]\.[0-9a-z]{3}(?:\.[0-9a-z])?\z/)
         end
 
         def self.scope_consistent?(status, special_folder)

data/lib/ace/task/cli/commands/create.rb

@@ -20,6 +20,7 @@ module Ace
             '"Fix login bug"                              # Create task with title',
             '"Fix auth" --priority high --tags auth,security  # With priority and tags',
             '"Setup DB" --child-of q7w                    # Create as subtask',
+            '"Track issue" --github-issue 276             # Link GitHub issue',
             '"Quick task" --in maybe                      # Create in _maybe/ folder',
             '"Draft spec" --status draft --estimate TBD   # Create as draft with estimate',
             '"Preview only" --dry-run                     # Show what would be created'
@@ -31,6 +32,7 @@ module Ace
           option :tags, type: :string, aliases: %w[-T], desc: "Tags (comma-separated)"
           option :status, type: :string, aliases: %w[-s], desc: "Initial status (draft, pending, blocked, ...)"
           option :estimate, type: :string, aliases: %w[-e], desc: "Effort estimate (e.g. TBD, 2h, 1d)"
+          option :"github-issue", type: :array, desc: "Linked GitHub issue number"
           option :"child-of", type: :string, desc: "Parent task reference (creates subtask)"
           option :in, type: :string, aliases: %w[-i], desc: "Target folder (e.g. next, maybe)"
           option :"dry-run", type: :boolean, aliases: %w[-n], desc: "Preview without writing"
@@ -48,6 +50,7 @@ module Ace
             tags = tags_str ? tags_str.split(",").map(&:strip).reject(&:empty?) : []
             status = options[:status]
             estimate = options[:estimate]
+            github_issue = parse_github_issue(options[:"github-issue"])
             child_of = options[:"child-of"]
             in_folder = options[:in]
 
@@ -64,6 +67,7 @@ module Ace
               puts "  Status:   #{status}" if status
               puts "  Priority: #{priority}" if priority
               puts "  Estimate: #{estimate}" if estimate
+              puts "  GitHub:   #{github_issue}" if github_issue
               puts "  Tags:     #{tags.join(", ")}" if tags.any?
               puts "  Parent:   #{child_of}" if child_of
               puts "  Folder:   #{in_folder}" if in_folder
@@ -72,10 +76,29 @@ module Ace
 
             manager = Ace::Task::Organisms::TaskManager.new
 
-            task = if child_of
-              manager.create_subtask(child_of, title, status: status, priority: priority, tags: tags, estimate: estimate)
-            else
-              manager.create(title, status: status, priority: priority, tags: tags, estimate: estimate)
+            task = begin
+              if child_of
+                manager.create_subtask(
+                  child_of,
+                  title,
+                  status: status,
+                  priority: priority,
+                  tags: tags,
+                  estimate: estimate,
+                  github_issue: github_issue
+                )
+              else
+                manager.create(
+                  title,
+                  status: status,
+                  priority: priority,
+                  tags: tags,
+                  estimate: estimate,
+                  github_issue: github_issue
+                )
+              end
+            rescue Ace::Task::Organisms::TaskManager::CreateRetriesExhaustedError => e
+              raise Ace::Support::Cli::Error, e.message
             end
 
             unless task
@@ -90,6 +113,9 @@ module Ace
 
             puts "Created task #{task.id}"
             puts "  Path: #{task.file_path}"
+            if manager.last_update_note && !manager.last_update_note.strip.empty?
+              puts "Info: #{manager.last_update_note}"
+            end
 
             if options[:git_commit]
               Ace::Support::Items::Molecules::GitCommitter.commit(
@@ -98,6 +124,22 @@ module Ace
               )
             end
           end
+
+          private
+
+          def parse_github_issue(raw_values)
+            values = Array(raw_values).flatten.compact
+            return nil if values.empty?
+            raise Ace::Support::Cli::Error.new("Only one --github-issue may be provided") if values.length > 1
+
+            candidate = values.first.to_s.strip
+            raise Ace::Support::Cli::Error.new("Invalid GitHub issue '#{values.first}': expected numeric ID") unless candidate.match?(/\A\d+\z/)
+
+            id = candidate.to_i
+            raise Ace::Support::Cli::Error.new("Invalid GitHub issue '#{values.first}': expected positive numeric ID") if id <= 0
+
+            id
+          end
         end
       end
     end

data/lib/ace/task/cli/commands/github_sync.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "ace/support/cli"
+
+module Ace
+  module Task
+    module CLI
+      module Commands
+        # ace-support-cli Command class for ace-task github-sync
+        class GithubSync < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+
+          desc <<~DESC.strip
+            Synchronize linked GitHub issues for a task or all linked tasks
+          DESC
+
+          example [
+            "q7w                         # Sync one task",
+            "--all                       # Sync all linked tasks"
+          ]
+
+          argument :ref, required: false, desc: "Task reference (full ID, short ref, or suffix)"
+          option :all, type: :boolean, aliases: %w[-a], desc: "Sync all linked tasks"
+
+          option :quiet, type: :boolean, aliases: %w[-q], desc: "Suppress non-essential output"
+          option :verbose, type: :boolean, aliases: %w[-v], desc: "Show verbose output"
+          option :debug, type: :boolean, aliases: %w[-d], desc: "Show debug output"
+
+          def call(ref: nil, **options)
+            all = options[:all]
+
+            if !all && (ref.nil? || ref.strip.empty?)
+              raise Ace::Support::Cli::Error.new("Provide a task reference or use --all")
+            end
+
+            manager = Ace::Task::Organisms::TaskManager.new
+            result = manager.github_sync(ref: ref, all: all)
+            raise Ace::Support::Cli::Error.new("Task '#{ref}' not found") if result.nil?
+            print_failures(result[:failures])
+
+            if result[:failed].to_i.positive?
+              raise Ace::Support::Cli::Error.new(
+                "GitHub sync incomplete: synced #{result[:synced]}, failed #{result[:failed]}, skipped #{result[:skipped]}"
+              )
+            elsif all
+              puts "GitHub sync complete: synced #{result[:synced]} linked task(s), skipped #{result[:skipped]} task(s)"
+            elsif result[:synced].positive?
+              puts "GitHub sync complete: #{result[:task_id]}"
+            else
+              puts "No linked GitHub issues for task #{result[:task_id]}"
+            end
+          end
+
+          private
+
+          def print_failures(failures)
+            Array(failures).each do |failure|
+              warn "GitHub sync failed for #{failure[:task_id]}: #{failure[:error]}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/task/cli/commands/plan.rb

@@ -24,6 +24,7 @@ module Ace
             "q7w                          # Reuse fresh plan or generate new",
             "q7w --refresh                # Force regeneration",
             "q7w --content                # Print full plan content",
+            "q7w --timeout 30             # Fail fast if plan generation stalls",
             "q7w --model gemini:flash-latest  # Override planning model"
           ]
 
@@ -32,6 +33,7 @@ module Ace
           option :refresh, type: :boolean, desc: "Force plan regeneration"
           option :content, type: :boolean, desc: "Print full plan content instead of path"
           option :model, type: :string, desc: "Provider:model override for plan generation"
+          option :timeout, type: :integer, desc: "LLM request timeout in seconds for plan generation"
 
           option :quiet, type: :boolean, aliases: %w[-q], desc: "Suppress non-essential output"
           option :verbose, type: :boolean, aliases: %w[-v], desc: "Show verbose output"
@@ -58,7 +60,7 @@ module Ace
 
             context_files = capture_context_files(task)
             model = options[:model] || default_model(config)
-            generator = plan_generator(model)
+            generator = plan_generator(model, timeout: options[:timeout])
             content = generator.generate(
               task: task,
               context_files: context_files,
@@ -104,13 +106,15 @@ module Ace
             end
           end
 
-          def plan_generator(model, cli_args: nil)
+          def plan_generator(model, cli_args: nil, timeout: nil)
             klass = self.class.generator_class || Molecules::TaskPlanGenerator
-            klass.new(model: model, cli_args: cli_args)
+            kwargs = {model: model, cli_args: cli_args}
+            kwargs[:timeout] = timeout if timeout
+            klass.new(**kwargs)
           end
 
           def default_model(config)
-            config.dig("task", "plan", "model") || "gemini:flash-latest"
+            config.dig("task", "plan", "model") || "role:planner"
           end
         end
       end