takt 0.37.0 → 0.39.0

package/builtins/en/config.yaml

@@ -17,6 +17,7 @@ language: en        # UI language: en | ja
 # base_branch: main                # Base branch to clone from (default: current branch)
 # concurrency: 1                   # Number of tasks to run concurrently in takt run (1-10)
 # task_poll_interval_ms: 500       # Polling interval in ms for picking up new tasks (100-5000)
+# sync_project_local_takt_on_retry: true # Sync root project-local .takt before retry / re-execution. Set false to keep the worktree copy
 
 # PR / branch
 # auto_pr: false                   # Auto-create PR after worktree execution
@@ -54,16 +55,22 @@ language: en        # UI language: en | ja
 # Interactive mode
 # interactive_preview_steps: 3 # Number of step previews in interactive mode (0-10)
 
-# Per-persona provider/model overrides
+# Per-persona provider/model/provider_options overrides
 # persona_providers:
 #   coder:
 #     provider: claude
 #     model: opus
+#     provider_options:
+#       claude:
+#         effort: high
 #   reviewer:
 #     provider: codex
 #     model: gpt-5.2-codex
+#     provider_options:
+#       codex:
+#         reasoning_effort: high
 
-# Provider-specific options (lowest priority, overridden by workflow/step)
+# Provider-specific options (config defaults; env-resolved leaf overrides win, otherwise step > workflow > persona > project > global)
 # provider_options:
 #   codex:
 #     network_access: true

package/builtins/en/facets/instructions/supervise.md

@@ -39,6 +39,8 @@ Verify existing evidence for tests, builds, and functional checks, then perform
 - When re-evaluating prior findings, compare the unversioned file with the most recent timestamped history file and verify that the meaning of `new / persists / resolved / reopened` is preserved
 - Treat summary reports as summaries, not as primary evidence. Prefer reports that record execution results, reviewer reports with concrete verification details, and then actual code
 - You may treat `Build Results` / `Test Results` sections in reports that record execution results as primary evidence
+- For `architecture-review`, `qa-review`, `testing-review`, `security-review`, and `requirements-review`, prioritize each report's `Verification Evidence` section when checking evidence
+- Treat each `Verification Evidence` item as supporting evidence only when it states the verified target, what was checked, and observed result. If any part is missing, mark that item as `unverified`
 - Treat reviewer claims such as "confirmed success" as supporting evidence only when they state the verified target, what was checked, and the observed result
 - If items of evidence conflict, prioritize them in this order: `execution-result report > reviewer report with concrete verification details > summary report`
 - If a later report reclassifies an earlier finding as `resolved`, `false_positive`, or `overreach`, decide whether to accept that reclassification by checking it against the task, plan, and code

package/builtins/en/facets/knowledge/architecture.md

@@ -7,10 +7,12 @@
 | Criteria | Judgment |
 |----------|----------|
 | Single file > 200 lines | Consider splitting |
-| Single file > 300 lines | REJECT |
+| Single file > 300 lines | Warning. Suggest splitting |
 | Single file with multiple responsibilities | REJECT |
 | Unrelated code coexisting | REJECT |
 
+Line count is a review or doctor warning signal, not a pass/fail condition for unit tests or snapshot tests.
+
 **Module Structure:**
 
 - High cohesion: Related functionality grouped together

package/builtins/en/facets/knowledge/frontend.md

@@ -14,11 +14,13 @@ Required splits:
 | Criteria | Judgment |
 |----------|----------|
 | Component over 200 lines | Consider splitting |
-| Component over 300 lines | REJECT |
+| Component over 300 lines | Warning. Suggest splitting |
 | Display and logic mixed | Consider separation |
 | Props drilling (3+ levels) | Consider state management |
 | Component with multiple responsibilities | REJECT |
 
+Component line count is a review signal, not a unit-test or snapshot-test failure condition.
+
 Good Component:
 - Single responsibility: Does one thing well
 - Self-contained: Dependencies are clear

package/builtins/en/workflow-categories.yaml

@@ -2,11 +2,14 @@ workflow_categories:
   🚀 Quick Start:
     workflows:
       - default
-      - frontend-mini
-      - backend-mini
-      - compound-eye
+      - default-mini
+      - default-high
+      - frontend
+      - backend
+      - dual
   ⚡ Mini:
     workflows:
+      - default-mini
       - frontend-mini
       - backend-mini
       - backend-cqrs-mini
@@ -57,6 +60,9 @@ workflow_categories:
   🎵 TAKT Development:
     workflows:
       - takt-default
+      - takt-default-refresh-all
+      - takt-default-refresh-fast
+      - auto-improvement-loop
       - review-takt-default
       - review-fix-takt-default
   Others:

package/builtins/en/workflows/auto-improvement-loop.yaml

@@ -0,0 +1,312 @@
+name: auto-improvement-loop
+description: >
+  Infinite orchestration loop that routes between open PR handling,
+  issue-driven planning, and fresh improvement planning.
+max_steps: infinite
+initial_step: route_context
+schemas:
+  followup-task: followup-task
+  pr-followup-task: pr-followup-task
+steps:
+  - name: route_context
+    mode: system
+    system_inputs:
+      - type: task_context
+        source: current_task
+        as: task
+      - type: branch_context
+        source: current_task
+        as: branch
+      - type: pr_list
+        source: current_project
+        as: prs
+        where:
+          head_branch: takt/*
+          managed_by_takt: true
+          same_repository: true
+          draft: false
+      - type: pr_selection
+        source: current_project
+        as: selected_pr
+        where:
+          head_branch: takt/*
+          managed_by_takt: true
+          same_repository: true
+          draft: false
+      # Previously this loop watched issue_context on the current task,
+      # but orchestration should route from repo-wide open Issue observation.
+      - type: issue_selection
+        source: current_project
+        as: selected_issue
+      - type: issue_list
+        source: current_project
+        as: tracked_issues
+        exclude_selected_from: selected_issue
+    rules:
+      - when: context.route_context.selected_pr.exists == true
+        next: plan_from_existing_pr
+      - when: context.route_context.selected_pr.exists == false && context.route_context.selected_issue.exists == true
+        next: plan_from_issue
+      - when: context.route_context.selected_pr.exists == false && context.route_context.selected_issue.exists == false
+        next: plan_fresh_improvement
+
+  - name: plan_from_issue
+    persona: supervisor
+    knowledge:
+      - architecture
+      - takt
+    delay_before_ms: 60000
+    instruction: |
+      Inspect the current issue and code state,
+      and plan exactly one next improvement task.
+
+      Current issue:
+      - exists: {context:route_context.selected_issue.exists}
+      - number: {context:route_context.selected_issue.number}
+      - title: {context:route_context.selected_issue.title}
+      - task_exists: {context:route_context.task.exists}
+      - branch_exists: {context:route_context.branch.exists}
+
+      Current execution context:
+      - task_exists: {context:route_context.task.exists}
+      - branch_exists: {context:route_context.branch.exists}
+
+      Open managed PR snapshot for overlap checks:
+      {context:route_context.prs}
+
+      Other open issue metadata for overlap checks:
+      {context:route_context.tracked_issues}
+      - other_open_issue_count: {context:route_context.tracked_issues.length}
+
+      Prioritize user value. Prefer bug fix > missing capability completion > UX/quality improvement > cosmetic.
+      Plan exactly one task.
+      Only propose a task when it has a concrete deliverable and explicit completion criteria.
+      Avoid cosmetic-only changes unless they clearly unlock meaningful user value.
+      Treat the current issue itself as in-scope, not as a duplicate.
+      Avoid tasks that materially duplicate or overlap with an open PR or the other open issues listed above.
+
+      Do not implement anything. Output only the next task instruction in task_markdown.
+      Output the next action in action.
+      If needed, output the issue creation plan in issue.
+
+      Allowed action values:
+      - enqueue_new_task
+      - wait_before_next_scan
+    structured_output:
+      schema_ref: followup-task
+    rules:
+      - when: structured.plan_from_issue.action == "enqueue_new_task"
+        next: enqueue_from_issue
+      - when: structured.plan_from_issue.action == "wait_before_next_scan"
+        next: wait_before_next_scan
+      - when: "true"
+        next: ABORT
+
+  - name: enqueue_from_issue
+    mode: system
+    effects:
+      - type: enqueue_task
+        mode: new
+        workflow: takt-default
+        base_branch: improve
+        task: "{structured:plan_from_issue.task_markdown}"
+        issue: "{structured:plan_from_issue.issue}"
+        worktree:
+          enabled: true
+          auto_pr: true
+          draft_pr: true
+          managed_pr: true
+    rules:
+      - when: effect.enqueue_from_issue.enqueue_task.success == true
+        next: wait_before_next_scan
+      - when: "true"
+        next: ABORT
+
+  - name: plan_fresh_improvement
+    persona: supervisor
+    knowledge:
+      - architecture
+      - takt
+    delay_before_ms: 60000
+    instruction: |
+      Inspect the current codebase,
+      and plan exactly one next improvement task.
+
+      Open managed PR snapshot for overlap checks:
+      {context:route_context.prs}
+
+      Open issue metadata already tracked:
+      {context:route_context.tracked_issues}
+      - open_issue_count: {context:route_context.tracked_issues.length}
+
+      Prioritize user value. Prefer bug fix > missing capability completion > UX/quality improvement > cosmetic.
+      Plan exactly one task.
+      Only propose a task when it has a concrete deliverable and explicit completion criteria.
+      Avoid cosmetic-only changes unless they clearly unlock meaningful user value.
+      Avoid tasks that materially duplicate or overlap with an open PR or tracked open issue.
+      If you cannot identify a clearly distinct, high-value task, choose wait_before_next_scan.
+
+      Do not implement anything. Output only the next task instruction in task_markdown.
+      Output the next action in action.
+      If needed, output the issue creation plan in issue.
+
+      Allowed action values:
+      - enqueue_new_task
+      - wait_before_next_scan
+    structured_output:
+      schema_ref: followup-task
+    rules:
+      - when: structured.plan_fresh_improvement.action == "enqueue_new_task"
+        next: enqueue_fresh
+      - when: structured.plan_fresh_improvement.action == "wait_before_next_scan"
+        next: wait_before_next_scan
+      - when: "true"
+        next: ABORT
+
+  - name: enqueue_fresh
+    mode: system
+    effects:
+      - type: enqueue_task
+        mode: new
+        workflow: takt-default
+        base_branch: improve
+        task: "{structured:plan_fresh_improvement.task_markdown}"
+        issue: "{structured:plan_fresh_improvement.issue}"
+        worktree:
+          enabled: true
+          auto_pr: true
+          draft_pr: true
+          managed_pr: true
+    rules:
+      - when: effect.enqueue_fresh.enqueue_task.success == true
+        next: wait_before_next_scan
+      - when: "true"
+        next: ABORT
+
+  - name: plan_from_existing_pr
+    persona: supervisor
+    knowledge:
+      - architecture
+      - takt
+    instruction: |
+      Inspect the current PR and choose the next action.
+
+      Current PR:
+      - count: {context:route_context.prs.length}
+      - number: {context:route_context.selected_pr.number}
+      - author: {context:route_context.selected_pr.author}
+      - base_branch: {context:route_context.selected_pr.base_branch}
+      - head_branch: {context:route_context.selected_pr.head_branch}
+
+      Output the next action in action.
+      If a follow-up implementation task is needed, output it in task_markdown.
+
+      Allowed action values:
+      - enqueue_from_pr
+      - prepare_merge
+      - reject_pr
+    structured_output:
+      schema_ref: pr-followup-task
+    rules:
+      - when: structured.plan_from_existing_pr.action == "enqueue_from_pr"
+        next: enqueue_from_pr
+      - when: structured.plan_from_existing_pr.action == "prepare_merge"
+        next: prepare_merge
+      - when: structured.plan_from_existing_pr.action == "reject_pr"
+        next: reject_pr
+      - when: "true"
+        next: ABORT
+
+  - name: reject_pr
+    mode: system
+    effects:
+      - type: close_pr
+        pr: "{context:route_context.selected_pr.number}"
+    rules:
+      - when: effect.reject_pr.close_pr.success == true
+        next: wait_before_next_scan
+      - when: "true"
+        next: ABORT
+
+  - name: enqueue_from_pr
+    mode: system
+    effects:
+      - type: enqueue_task
+        mode: from_pr
+        pr: "{context:route_context.selected_pr.number}"
+        workflow: takt-default
+        base_branch: improve
+        task: "{structured:plan_from_existing_pr.task_markdown}"
+    rules:
+      - when: effect.enqueue_from_pr.enqueue_task.success == true
+        next: wait_before_next_scan
+      - when: "true"
+        next: ABORT
+
+  - name: prepare_merge
+    mode: system
+    effects:
+      - type: sync_with_root
+        pr: "{context:route_context.selected_pr.number}"
+    rules:
+      - when: effect.prepare_merge.sync_with_root.success == true
+        next: merge_pr
+      - when: effect.prepare_merge.sync_with_root.conflicted == true
+        next: resolve_conflicts
+      - when: "true"
+        next: ABORT
+
+  - name: resolve_conflicts
+    mode: system
+    effects:
+      - type: resolve_conflicts_with_ai
+        pr: "{context:route_context.selected_pr.number}"
+    rules:
+      - when: effect.resolve_conflicts.resolve_conflicts_with_ai.success == true
+        next: merge_pr
+      - when: effect.resolve_conflicts.resolve_conflicts_with_ai.failed == true
+        next: enqueue_conflict_resolution_task
+      - when: "true"
+        next: ABORT
+
+  - name: enqueue_conflict_resolution_task
+    mode: system
+    effects:
+      - type: enqueue_task
+        mode: from_pr
+        pr: "{context:route_context.selected_pr.number}"
+        workflow: takt-default
+        base_branch: improve
+        task: |
+          Resolve the conflicts raised while syncing the PR with its base branch.
+          Target PR: {context:route_context.selected_pr.number}
+    rules:
+      - when: effect.enqueue_conflict_resolution_task.enqueue_task.success == true
+        next: wait_before_next_scan
+      - when: "true"
+        next: ABORT
+
+  - name: merge_pr
+    mode: system
+    effects:
+      - type: merge_pr
+        pr: "{context:route_context.selected_pr.number}"
+    rules:
+      - when: effect.merge_pr.merge_pr.success == true
+        next: wait_before_next_scan
+      - when: "true"
+        next: ABORT
+
+  - name: wait_before_next_scan
+    mode: system
+    delay_before_ms: 60000
+    system_inputs:
+      - type: task_queue_context
+        source: current_project
+        as: queue
+        exclude_current_task: true
+    rules:
+      - when: exists(context.wait_before_next_scan.queue.items, item.kind == "running")
+        next: wait_before_next_scan
+      - when: "true"
+        next: route_context