siesa-agents 2.1.78 → 2.1.79

package/siesa-agents/bmm/workflows/4-implementation/code-review/steps/step-04-fix.md

@@ -0,0 +1,92 @@
+---
+name: 'step-04-fix'
+description: 'Present findings and facilitate fixes or task creation'
+
+# Path Definitions
+workflow_path: '{project-root}/_siesa-agents/bmm/workflows/4-implementation/code-review'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-04-fix.md'
+nextStepFile: '{workflow_path}/steps/step-05-sync-sprint.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/review-{story_key}.md'
+---
+
+# Step 4: Present and Fix Findings
+
+## STEP GOAL:
+To present the review findings to the user and either fix them automatically or convert them into action items for the story.
+
+## MANDATORY EXECUTION RULES:
+- 🛑 NEVER apply fixes without user choice
+- 💾 Update Story file if Action Items created
+
+## Sequence of Instructions
+
+### 1. Summarize Status
+
+Analyze the findings from the output file.
+Count: High, Medium, Low issues.
+
+Display to User:
+"**Review Complete!**
+Issues Found: {{High}} High, {{Medium}} Medium, {{Low}} Low."
+
+### 2. Present FIX MENU OPTIONS
+
+Display:
+"**What should I do with these issues?**
+[1] **Fix automatically** (I will update code and tests for High/Med issues)
+[2] **Create Action Items** (Add checklist to Story for later)
+[3] **Show Details** (Deep dive into specific issues)"
+
+**Wait for User Selection.**
+
+### 3. Handle Selection
+
+1. **If [1] Fix Automatically**:
+   - For all HIGH/MEDIUM issues:
+     - Generate fix code.
+     - Apply to files.
+     - Add/Update tests.
+   - Update Story Dev Record / File List.
+   - Record `fixed_count`.
+   - Proceed to Final Menu.
+
+2. **If [2] Create Action Items**:
+   - Create section "Review Follow-ups (AI)" in the Story file.
+   - Add checkbox items: `- [ ] [AI-Review][Severity] Description`
+   - Record `action_count`.
+   - Proceed to Final Menu.
+
+3. **If [3] Show Details**:
+   - Display full details of issues.
+   - Redisplay FIX MENU.
+
+### 4. Determine New Status
+
+Based on the outcome:
+- If **All Critical/High/Med Fixed** AND **ACs Done**: New Status = `done`
+- Else: New Status = `in-progress`
+
+Append to `{outputFile}`:
+```markdown
+## Fix Outcome
+- **Action Taken**: [Fixed/Tasks Created]
+- **Fixed Count**: X
+- **Task Count**: Y
+- **Recommended Status**: {{NewStatus}}
+```
+
+### 5. Present CONTINUATION MENU
+
+Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue"
+
+#### Menu Handling Logic:
+- IF C: Save outcome to {outputFile}, update frontmatter `stepsCompleted: [1, 2, 3, 4]`, then load/execute {nextStepFile}
+- IF A/P: Execute respective flows
+- IF Others: Loop
+
+#### EXECUTION RULES:
+- ALWAYS halt and wait for user input
+- ONLY proceed to next step when user selects 'C'

package/siesa-agents/bmm/workflows/4-implementation/code-review/steps/step-05-sync-sprint.md

@@ -0,0 +1,70 @@
+---
+name: 'step-05-sync-sprint'
+description: 'Update story status content and synchronize sprint tracking file'
+
+# Path Definitions
+workflow_path: '{project-root}/_siesa-agents/bmm/workflows/4-implementation/code-review'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-05-sync-sprint.md'
+nextStepFile: '{workflow_path}/steps/step-06-jira-sync.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/review-{story_key}.md'
+
+# Data References
+sprint_status_file: '{implementation_artifacts}/sprint-status.yaml'
+---
+
+# Step 5: Update Status and Sync Sprint
+
+## STEP GOAL:
+To officially update the story file's status field and synchronize the project's sprint-status.yaml file to reflect the review outcome.
+
+## MANDATORY EXECUTION RULES:
+- 💾 Persist all status changes
+- 🔄 Ensure consistency between Story and Sprint Status
+
+## Sequence of Instructions
+
+### 1. Update Story File
+
+Using the `New Status` determined in Step 4 (`done` or `in-progress`):
+1. **Load** the Story File.
+2. **Find** the `Status:` field in the metadata/header.
+3. **Update** it to the new status.
+4. **Save** the Story File.
+
+### 2. Update Sprint Status YAML
+
+Check if `{sprint_status_file}` exists.
+- **If NO**:
+  - Log "No sprint-status.yaml found. Skipping sync."
+
+- **If YES**:
+  1. **Load** `{sprint_status_file}`.
+  2. **Find** the key `development_status` matching `{{story_key}}`.
+  3. **Update** the value to the new status (`done` or `in-progress`).
+  4. **Save** the file, preserving comments and structure.
+  5. **Log**: "✅ Sprint status synced: {{story_key}} -> {{status}}".
+
+### 3. Log Result
+
+Append to `{outputFile}`:
+```markdown
+## Status Sync
+- **Story File Status**: Updated to {{status}}
+- **Sprint Status YAML**: [Synced/Skipped]
+```
+
+### 4. Present MENU OPTIONS
+
+Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Jira Sync"
+
+#### Menu Handling Logic:
+- IF C: Save result to {outputFile}, update frontmatter `stepsCompleted: [1, 2, 3, 4, 5]`, then load/execute {nextStepFile}
+- IF A/P: Execute respective flows
+- IF Others: Loop
+
+#### EXECUTION RULES:
+- ALWAYS halt and wait for user input
+- ONLY proceed to next step when user selects 'C'

package/siesa-agents/bmm/workflows/4-implementation/code-review/steps/step-06-jira-sync.md

@@ -0,0 +1,372 @@
+---
+name: 'step-06-jira-sync'
+description: 'Full content sync with Jira via Node.js scripts (markdown = source of truth)'
+
+# Path Definitions
+workflow_path: '{project-root}/_siesa-agents/bmm/workflows/4-implementation/code-review'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-06-jira-sync.md'
+nextStepFile: '{workflow_path}/steps/step-07-commit-push.md'
+workflowFile: '{project-root}/_siesa-agents/bmm/workflows/4-implementation/code-review/workflow.md'
+outputFile: '{output_folder}/review-{story_key}.md'
+storyFile: '{{story_path}}'
+
+# Infrastructure References
+tokensFile: '{project-root}/.claude/commands/get-features/tokens.json'
+oauthConfigFile: '{project-root}/.claude/commands/get-features/oauth-config.json'
+jiraConfigFile: '{project-root}/_bmad-output/jira_docs/project_config.yaml'
+storyTemplate: '{project-root}/_siesa-agents/sa/sync-epics-stories/data/templates/story-template.json'
+taskTemplate: '{project-root}/_siesa-agents/sa/sync-epics-stories/data/templates/task-template.json'
+jiraScripts: '{project-root}/_siesa-agents/scripts/jira'
+---
+
+# Step 6: Jira Full Content Sync
+
+## STEP GOAL:
+
+To synchronize the "Done" status with Jira by performing a **full content upsert**. The markdown story file is the **source of truth**. Description, subtasks, and subtask comments must be consistent between the markdown and Jira.
+
+## MANDATORY EXECUTION RULES:
+
+- 🛑 ONLY execute if `{{new_status}} == 'done'` (as determined in step-05-sync-sprint)
+- 🔒 **NEVER use MCP tools** for any Jira operation. MCP is disabled for this workflow.
+- 🔒 **NEVER write inline Node.js** for Jira API calls. Always use the existing scripts.
+- 🤫 Silent execution — display only brief status lines, no menus or prompts.
+- ✅ Scripts auto-discover OAuth tokens from `.claude/commands/get-features/tokens.json`
+- ✅ Scripts auto-discover project config from `_bmad-output/jira_docs/project_config.yaml`
+
+## JIRA API INTEGRATION
+
+All Jira interactions MUST use the **pre-built CLI scripts** located at `{jiraScripts}/`. These scripts handle OAuth refresh, config loading, and API calls automatically.
+
+### Available Scripts (`_siesa-agents/scripts/jira/`)
+
+| Script | Purpose | Example |
+|---|---|---|
+| `search.js` | Search issues via JQL | `node search.js --jql "project = PJIB AND issuetype = Epic" --fields "summary,status"` |
+| `create-issue.js` | Create issue (Epic, Story, Sub-task) | `node create-issue.js --type Epic --summary "Epic 3" --parent PJIB-99` |
+| `batch-create.js` | Create multiple issues from JSON | `node batch-create.js --file issues.json` |
+| `add-comment.js` | Add comment (auto-converts to ADF) | `node add-comment.js --issue PJIB-190 --body "## Sub-tasks\n- Item 1"` |
+| `get-issue.js` | Get issue details | `node get-issue.js --issue PJIB-190 --fields "summary,status"` |
+| `edit-issue.js` | Update issue fields | `node edit-issue.js --issue PJIB-190 --summary "New title"` |
+| `transition.js` | Transition issue status | `node transition.js --issue PJIB-190 --to done` |
+| `refresh-token.js` | Force OAuth token refresh | `node refresh-token.js` |
+
+🛑 **CRITICAL:** If a step says "Using Node.js, call..." — use the corresponding script above. Do NOT create temporary `.js` files or write inline `node -e` commands.
+
+## Sequence of Instructions
+
+### A. Guard Check
+
+If `{{new_status}} != 'done'`:
+- Output: `ℹ️ Story status is '{{new_status}}'. Skipping Jira sync.`
+- Update frontmatter of `{outputFile}`: `stepsCompleted: [1, 2, 3, 4, 5, 6]`
+- Immediately load, read, and execute `{nextStepFile}` without any further action.
+
+### B. Load Jira Configuration (Silent)
+
+1. Check if `{jiraConfigFile}` exists.
+   - If NOT exists: Output `⚠️ No Jira config found (project_config.yaml). Skipping Jira sync.` then proceed to Section G (log) then load `{nextStepFile}`.
+   - If exists: Read and extract `project_key`, `cloud_id`, `jira_url`.
+
+2. Refresh OAuth access token using inline Node.js:
+   - Read `{tokensFile}` → extract `refresh_token`
+   - Read `{oauthConfigFile}` → extract `client_id`, `client_secret`
+   - `POST https://auth.atlassian.com/oauth/token` with `grant_type: refresh_token`
+   - Save new `access_token` (and `refresh_token` if returned) back to `{tokensFile}`
+   - If refresh fails: Output `⚠️ OAuth token refresh failed. Skipping Jira sync.` then proceed to Section G (log) then load `{nextStepFile}`.
+
+Output: `🔄 Syncing story content with Jira...`
+
+### C. Story Resolution — Resolve or Create Jira Issue (Silent)
+
+**Goal:** Ensure the story exists in Jira and `{{jira_key}}` is set.
+
+#### Story File Structure — Exact Heading Mapping
+
+The story markdown file follows this exact structure. Use these headings to extract each field:
+
+| Variable | Exact Markdown Heading | Content to Extract |
+|---|---|---|
+| `{{story_title}}` | H1: `# Story X.Y: <title>` | Full title text after `# ` |
+| `{{story_id}}` | H1: `# Story X.Y: ...` | Numeric ID only (e.g., `1.2`) |
+| `{{status}}` | Plain line below H1: `Status: <value>` | Status value (e.g., `done`) |
+| `{{user_story}}` | `## Story` | All content until next `##` heading |
+| `{{acceptance_criteria}}` | `## Acceptance Criteria` | All content until next `##` heading |
+| `{{tasks_section}}` | `## Tasks / Subtasks` | All content until next `##` heading |
+| `{{completion_notes}}` | `## Dev Agent Record` → `### Completion Notes List` | Content of that subsection only |
+| `{{technical_debt}}` | `## Dev Agent Record` → `### Technical Debt` | Content of that subsection only |
+| `{{jira_key}}` | `## Jira Information` → `**Jira Issue Key:** [KEY](url)` | Key pattern (e.g., `PJIB-427`) |
+
+**IMPORTANT:** `## Dev Notes` contains detailed implementation documentation (often 200–700 lines). Do NOT read this section unless explicitly instructed. It is NOT included in the Jira description — only a reference link is added.
+
+#### Extraction Steps
+
+1. Read `{{story_path}}`. Parse the H1 line to extract `{{story_title}}` and `{{story_id}}`.
+2. Check if the `## Jira Information` section contains a `**Jira Issue Key:**` entry matching the key pattern `[A-Z]+-\d+`.
+
+3. **If key found locally:**
+   - Set `{{jira_key}}` from the local entry.
+   - Output: `✅ Story already in Jira: {{jira_key}}`
+
+4. **If key NOT found locally:**
+
+   a. **Remote search** (Node.js):
+   ```
+   POST https://api.atlassian.com/ex/jira/{{cloud_id}}/rest/api/3/search/jql
+   Body: { "jql": "project = \"{{project_key}}\" AND issuetype in (Story, Historia) AND summary ~ \"{{story_title}}\"", "maxResults": 5, "fields": ["id", "key", "summary"] }
+   ```
+   - If found: set `{{jira_key}}` = found key. Proceed to step c.
+
+   b. **If not found remotely — Create Story** (Node.js):
+
+   Extract the following (using the heading mapping table above):
+   - `{{user_story}}` → content of `## Story` section
+   - `{{acceptance_criteria}}` → content of `## Acceptance Criteria` section
+   - `{{completion_notes}}` → content of `### Completion Notes List` subsection (if exists, else empty)
+   - `{{parent_epic_key}}` → from the referenced parent epic file in `{epicsFolder}` (look for `[KEY-123]` in the epic that matches the story's Epic reference)
+
+   If `{{parent_epic_key}}` not resolvable: Output `⚠️ Parent Epic not synced. Story creation may fail.` and continue.
+
+   Build payload using `{storyTemplate}`:
+   ```
+   POST https://api.atlassian.com/ex/jira/{{cloud_id}}/rest/api/3/issue
+   Body: (inject {{story_id}}, {{story_title}}, {{user_story}}, {{acceptance_criteria}}, {{completion_notes}} as dev_notes, {{story_path}} as file_path, {{parent_epic_key}})
+   ```
+   - On success: set `{{jira_key}}` = new key.
+   - On failure: Output `❌ Story creation failed: {{error}}. Skipping Jira sync.` → proceed to Section G (log) then load `{nextStepFile}`.
+
+   c. **Persist key to story file** (immediately, whether found remotely or just created):
+
+   Append to `{{story_path}}` (only if `## Jira Information` section does not already exist):
+   ```markdown
+
+   ## Jira Information
+
+   **Jira Issue Key:** [{{jira_key}}]({{jira_url}}/browse/{{jira_key}})
+   **Jira URL:** {{jira_url}}/browse/{{jira_key}}
+   **Status:** Synced
+   ```
+
+---
+
+### D. Description Sync — Markdown is Source of Truth (Silent)
+
+**Goal:** Update the story description in Jira to match the current markdown content. Keep it concise — Jira descriptions are for team visibility, not full technical docs.
+
+#### What to Include in the Jira Description
+
+| Section | Source Heading | Include? |
+|---|---|---|
+| User Story | `## Story` | ✅ Full content |
+| Acceptance Criteria | `## Acceptance Criteria` | ✅ Full content |
+| Completion Notes | `## Dev Agent Record → ### Completion Notes List` | ✅ If exists |
+| Technical Debt | `## Dev Agent Record → ### Technical Debt` | ✅ If exists |
+| Dev Notes | `## Dev Notes` | ❌ Reference link only (too large) |
+| Tasks / Subtasks | `## Tasks / Subtasks` | ❌ Handled separately as Sub-tasks |
+
+1. Extract from `{{story_path}}` using the headings above:
+   - `{{user_story}}` → full content of `## Story` section
+   - `{{acceptance_criteria}}` → full content of `## Acceptance Criteria` section
+   - `{{completion_notes}}` → content of `### Completion Notes List` (empty string if missing)
+   - `{{technical_debt}}` → content of `### Technical Debt` (empty string if missing)
+
+2. Build description payload in **Atlassian Document Format (ADF)**:
+
+   ```json
+   {
+     "type": "doc", "version": 1,
+     "content": [
+       { "type": "heading", "attrs": { "level": 2 }, "content": [{ "type": "text", "text": "User Story" }] },
+       { "type": "paragraph", "content": [{ "type": "text", "text": "{{user_story}}" }] },
+       { "type": "heading", "attrs": { "level": 2 }, "content": [{ "type": "text", "text": "Acceptance Criteria" }] },
+       { "type": "paragraph", "content": [{ "type": "text", "text": "{{acceptance_criteria}}" }] },
+       { "type": "heading", "attrs": { "level": 2 }, "content": [{ "type": "text", "text": "Completion Notes" }] },
+       { "type": "paragraph", "content": [{ "type": "text", "text": "{{completion_notes}}" }] },
+       { "type": "heading", "attrs": { "level": 2 }, "content": [{ "type": "text", "text": "Technical Debt" }] },
+       { "type": "paragraph", "content": [{ "type": "text", "text": "{{technical_debt}}" }] },
+       { "type": "rule" },
+       { "type": "paragraph", "content": [
+           { "type": "text", "text": "📄 Source: " },
+           { "type": "text", "text": "{{story_path}}", "marks": [{ "type": "code" }] }
+         ]
+       }
+     ]
+   }
+   ```
+
+   **Rules:**
+   - Omit the `Completion Notes` block entirely if `{{completion_notes}}` is empty.
+   - Omit the `Technical Debt` block entirely if `{{technical_debt}}` is empty.
+   - Always include the `Source:` footer line.
+
+3. Update description in Jira (Node.js):
+   ```
+   PUT https://api.atlassian.com/ex/jira/{{cloud_id}}/rest/api/3/issue/{{jira_key}}
+   Body: { "fields": { "description": {{adf_description_payload}} } }
+   ```
+   - On success: Output `✅ Description synced → {{jira_key}}`
+   - On failure: Output `⚠️ Description update failed: {{error}}` — log and continue (non-blocking).
+
+---
+
+### E. Subtask Upsert — Create Missing, Verify Comments (Silent)
+
+**Goal:** Every level-1 task in the markdown must exist as a Jira Sub-task. Every Sub-task with nested bullets must have its comment. The markdown `## Synced Tasks` table is the local idempotency record.
+
+**HIERARCHY MAPPING:**
+```
+Markdown                         Jira
+────────────────────────         ───────────────────────────
+Story                        →   Story (issue)
+  └─ Level-1 task bullet     →   Sub-task (child of Story)
+       └─ Nested bullet(s)   →   Comment on that Sub-task
+```
+
+**E.1 — Preparation:**
+
+1. GET story from Jira (Node.js):
+   ```
+   GET https://api.atlassian.com/ex/jira/{{cloud_id}}/rest/api/3/issue/{{jira_key}}?fields=subtasks
+   ```
+   - Extract `existingJiraSubtasks` = array of `{ key, summary }` from `fields.subtasks`.
+   - Build `existingJiraSummaries` = normalized set of subtask summary strings.
+
+2. Read `## Synced Tasks` table from `{{story_path}}` → build `syncedTaskNames` set (task names already tracked locally).
+
+3. Parse the `## Tasks / Subtasks` section from `{{story_path}}` (content until the next `##` heading):
+   - **Level-1 bullets**: lines starting with `- [ ]` or `- [x]` at base indentation (no leading spaces). Each is a `task`. Extract text after the checkbox — strip `**Task N:** ` prefix and `(AC: ...)` suffix if present.
+   - **Nested bullets**: lines indented under a level-1 bullet (2+ leading spaces). Each is a `nested_item` of that task. Strip checkbox syntax, keep text only.
+   - Preserve original task text for summary matching against Jira.
+
+**E.2 — Loop: For Each Level-1 Task:**
+
+🛑 **CRITICAL:** Steps A → D are one atomic unit per task. Do NOT batch creations and then add comments separately.
+
+#### A. Already in `## Synced Tasks` table?
+
+- **YES** → extract `{{subtask_key}}` from the table row.
+  - If this task has nested bullets:
+    - Check existing comments: `GET https://api.atlassian.com/ex/jira/{{cloud_id}}/rest/api/3/issue/{{subtask_key}}/comment`
+    - If no comment with heading "Sub-tasks" exists → create comment (Step C below).
+    - If comment already exists → Output: `⏭️ Comment already present: {{subtask_key}}` — skip.
+  - Move to next task.
+
+#### B. NOT in `## Synced Tasks` — Resolve from Jira or Create
+
+- Check if task summary (formatted as `{{story_id}} - {{task_name}}`) is in `existingJiraSummaries`:
+  - **YES (exists in Jira but not tracked locally):**
+    - Find the key from `existingJiraSubtasks`.
+    - Set `{{subtask_key}}` = found key.
+    - Output: `🔗 Subtask already in Jira (untracked): {{subtask_key}}`
+  - **NO (missing in Jira):**
+    - Create Sub-task (Node.js):
+      ```
+      POST https://api.atlassian.com/ex/jira/{{cloud_id}}/rest/api/3/issue
+      Body: { "fields": { "issuetype": { "name": "Sub-task" }, "project": { "key": "{{project_key}}" }, "parent": { "key": "{{jira_key}}" }, "summary": "{{story_id}} - {{task_name}}" } }
+      ```
+    - On success: set `{{subtask_key}}` = new key. Output: `✅ Subtask created: {{subtask_key}} — {{task_name}}`
+    - On failure: log `❌ Subtask creation failed: {{task_name}} — {{error}}`. Skip steps C and D. Move to next task.
+
+#### C. Add Nested Bullets as Comment (MANDATORY if nested bullets exist)
+
+🛑 This step is **NOT optional** if the task has nested bullets.
+
+- Collect all nested bullets under this task. Strip checkbox syntax — keep text only.
+- Build ADF comment body:
+  ```json
+  {
+    "body": {
+      "type": "doc", "version": 1,
+      "content": [
+        { "type": "heading", "attrs": { "level": 3 }, "content": [{ "type": "text", "text": "Sub-tasks" }] },
+        { "type": "bulletList", "content": [
+            { "type": "listItem", "content": [{ "type": "paragraph", "content": [{ "type": "text", "text": "{{nested_bullet_text}}" }] }] }
+          ]
+        }
+      ]
+    }
+  }
+  ```
+  Build one `listItem` node per nested bullet.
+
+- POST comment (Node.js):
+  ```
+  POST https://api.atlassian.com/ex/jira/{{cloud_id}}/rest/api/3/issue/{{subtask_key}}/comment
+  ```
+- On success: Output `✅ Comment added: {{subtask_key}}`
+- On failure: log `⚠️ Comment failed: {{subtask_key}} — {{error}}` — non-blocking, continue.
+
+#### D. Immediate File Persistence
+
+Append or update the `## Synced Tasks` table in `{{story_path}}` (create header if missing):
+
+```markdown
+| {{task_name}} | [{{subtask_key}}]({{jira_url}}/browse/{{subtask_key}}) | Synced | {{date}} |
+```
+
+**Then move to the next level-1 task and repeat from step A.**
+
+**E.3 — Summary Output:**
+
+```
+✅ Subtask sync complete:
+   Created:          X subtasks
+   Already in Jira:  Y subtasks (linked)
+   Comments added:   Z
+   Comments skipped: W (already existed)
+   Failed:           V (see log)
+```
+
+---
+
+### F. Transition Story and All Subtasks to Done (Node.js, Silent)
+
+After content sync is confirmed (has `{{jira_key}}`):
+
+1. **Transition Parent Story:**
+   - Node.js: `GET https://api.atlassian.com/ex/jira/{{cloud_id}}/rest/api/3/issue/{{jira_key}}/transitions`
+   - Find transition where `to.statusCategory.key == "done"` (or name contains "Done"/"Listo"/"Finalizada")
+   - Node.js: `POST .../transitions` body: `{ "transition": { "id": "{{found_id}}" } }`
+   - Output: `✅ {{jira_key}} → Done`
+
+2. **Cascade: Transition all Subtasks:**
+   - Node.js: `GET .../issue/{{jira_key}}?fields=subtasks` → extract all subtask keys (includes newly created ones)
+   - For each subtask:
+     - `GET .../issue/{{subtask_key}}/transitions` → find "done" transition id
+     - `POST .../issue/{{subtask_key}}/transitions` body: `{ "transition": { "id": "{{found_id}}" } }`
+   - If any subtask transition fails: log `⚠️ Subtask {{subtask_key}} transition failed: {{error}}` and continue.
+   - Output: `✅ Subtasks → Done`
+
+3. **Update Markdown Tables in Story File:**
+   - Read `{{story_path}}`
+   - In `## Jira Information`: add column `| Jira State |` with value `| **Done** |`
+   - In `## Synced Tasks`: add column `| Jira State |` with value `| **Done** |` for each row
+   - Save file.
+
+---
+
+### G. Append Result to Output File
+
+Append to `{outputFile}`:
+
+```markdown
+## Jira Sync (Full Content Sync — Markdown Source of Truth)
+- **Story**: {{story_title}}
+- **Jira Key**: {{jira_key}}
+- **Story Resolution**: [Created / Found remotely / Found locally]
+- **Description Sync**: [Updated ✅ / Failed ⚠️]
+- **Subtasks Created**: X
+- **Subtasks Linked**: Y (already in Jira)
+- **Comments Added**: Z
+- **Story Transition**: Done ✅
+- **Subtasks Transitioned**: [N subtasks → Done ✅ / Failed: list]
+- **Infrastructure**: Node.js direct API (OAuth shared with get-features)
+```
+
+Update frontmatter of `{outputFile}`: `stepsCompleted: [1, 2, 3, 4, 5, 6]`
+
+Output: `✅ Jira sync complete. Proceeding to commit...`
+
+Then **immediately load, read, and execute `{nextStepFile}`** — no menu, no waiting for user input.