Test update

.planning/ROADMAP.md

@@ -52,12 +52,10 @@
 
 </details>
 
-### ⏸️ v1.4 Unraid API Native (PAUSED — waiting for Unraid 7.3)
+### 🚧 v1.4 Unraid API Native (In Progress)
 
 **Milestone Goal:** Replace Docker socket proxy with Unraid's GraphQL API for all container operations, remove container logs feature, and clean up all proxy artifacts.
 
-**PAUSED:** UAT revealed `updateContainer` mutation only ships in Unraid 7.3+ (not yet released). Status queries and start/stop/restart work via GraphQL, but update operations require the missing mutation. v1.3 workflows restored to n8n for stable production use. Resume when Unraid 7.3 ships.
-
 #### Phase 15: Infrastructure Foundation
 **Goal**: Data transformation layers ready for Unraid API integration
 **Depends on**: Phase 14
@@ -71,8 +69,8 @@
 **Plans**: 2 plans
 
 Plans:
-- [x] 15-01-PLAN.md — Container ID Registry and Callback Token Encoding/Decoding
+- [ ] 15-01-PLAN.md — Container ID Registry and Callback Token Encoding/Decoding
-- [x] 15-02-PLAN.md — GraphQL Response Normalizer, Error Handler, and HTTP Template
+- [ ] 15-02-PLAN.md — GraphQL Response Normalizer, Error Handler, and HTTP Template
 
 #### Phase 16: API Migration
 **Goal**: All container operations work via Unraid GraphQL API
@@ -85,15 +83,10 @@ Plans:
   4. User can batch update multiple containers via Unraid API
   5. User can "update all :latest" via Unraid API
   6. Unraid update badges clear automatically after bot-initiated updates (no manual sync)
-**Plans**: 6 plans
+**Plans**: TBD
 
 Plans:
-- [x] 16-01-PLAN.md -- Container Status workflow migration (n8n-status.json)
+- [ ] 16-01: TBD
-- [x] 16-02-PLAN.md -- Container Actions workflow migration (n8n-actions.json)
-- [x] 16-03-PLAN.md -- Container Update workflow migration (n8n-update.json)
-- [x] 16-04-PLAN.md -- Batch UI workflow migration (n8n-batch-ui.json)
-- [x] 16-05-PLAN.md -- Main workflow routing migration (n8n-workflow.json)
-- [x] 16-06-PLAN.md -- Gap closure: text command entry points migration + dead code removal
 
 #### Phase 17: Cleanup
 **Goal**: All Docker socket proxy artifacts removed from codebase
@@ -140,13 +133,12 @@ Phases execute in numeric order: 1-14 (complete) → 15 → 16 → 17 → 18
 | 12 | Polish & Audit | v1.2 | 2/2 | Complete | 2026-02-08 |
 | 13 | Documentation Overhaul | v1.2 | 1/1 | Complete | 2026-02-08 |
 | 14 | Unraid API Access | v1.3 | 2/2 | Complete | 2026-02-08 |
-| 15 | Infrastructure Foundation | v1.4 | 2/2 | Complete | 2026-02-09 |
+| 15 | Infrastructure Foundation | v1.4 | 0/2 | Not started | - |
-| 16 | API Migration | v1.4 | 6/6 | UAT: 6/9 pass, blocked on Unraid 7.3 | 2026-02-09 |
+| 16 | API Migration | v1.4 | 0/? | Not started | - |
-| 17 | Cleanup | v1.4 | 0/? | PAUSED | - |
+| 17 | Cleanup | v1.4 | 0/? | Not started | - |
-| 18 | Documentation | v1.4 | 0/? | PAUSED | - |
+| 18 | Documentation | v1.4 | 0/? | Not started | - |
 
-**Total: 4 milestones shipped (14 phases, 50 plans), v1.4 PAUSED (blocked on Unraid 7.3 updateContainer mutation)**
+**Total: 4 milestones shipped (14 phases, 50 plans), v1.4 in progress (4 phases)**
-**Production: v1.3 workflows running on n8n**
 
 ---
-*Updated: 2026-02-09 — v1.4 PAUSED, v1.3 restored to n8n. Resume when Unraid 7.3 ships.*
+*Updated: 2026-02-09 — Phase 15 planned (2 plans)*

.planning/STATE.md

@@ -2,10 +2,10 @@
 
 ## Current Position
 
-- **Milestone:** v1.4 Unraid API Native — PAUSED
+- **Milestone:** v1.4 Unraid API Native
-- **Phase:** 16 of 18 (API Migration) - Paused (UAT revealed API limitation)
+- **Phase:** 15 of 18 (Infrastructure Foundation)
-- **Status:** PAUSED — Unraid GraphQL `updateContainer` mutation requires Unraid 7.3+ (not yet released). v1.3 workflows restored to n8n.
+- **Status:** Ready to plan
-- **Last activity:** 2026-02-09 — v1.4 paused, v1.3 workflows pushed to n8n as stable rollback
+- **Last activity:** 2026-02-09 — v1.4 roadmap created with 4 phases
 
 ## Project Reference
 
@@ -13,7 +13,7 @@ See: .planning/PROJECT.md (updated 2026-02-09)
 
 **Core value:** When you get a container update notification or notice a service is down, you can immediately investigate and act from your phone.
 
-**Current focus:** PAUSED — waiting for Unraid 7.3 to ship `updateContainer` GraphQL mutation
+**Current focus:** v1.4 Unraid API Native — replace Docker socket proxy with Unraid GraphQL API
 
 ## Progress
 
@@ -22,33 +22,16 @@ v1.0: [**********] 100% SHIPPED (Phases 1-5, 12 plans)
 v1.1: [**********] 100% SHIPPED (Phases 6-9, 11 plans)
 v1.2: [**********] 100% SHIPPED (Phases 10-13 + 10.1-10.2, 25 plans)
 v1.3: [**********] 100% SHIPPED (Phase 14, 2 plans — descoped)
-v1.4: [******....] 60% PAUSED (Phases 15-18 — blocked on Unraid 7.3)
+v1.4: [..........] 0% IN PROGRESS (Phases 15-18, TBD plans)
 
-Overall: 4 milestones shipped (14 phases, 50 plans), v1.4 paused
+Overall: 4 milestones shipped (14 phases, 50 plans), v1.4 roadmap complete
-Running in production: v1.3 (Docker socket proxy architecture)
 ```
 
-## Why Paused
-
-**UAT on Phase 16 revealed:** The Unraid GraphQL API (v4.25-4.28, Unraid 7.2.x) only exposes `start` and `stop` Docker mutations. The `updateContainer`, `updateContainers`, and `updateAllContainers` mutations exist in the API source code (commit 277ac42046, 2025-12-18) but are tagged for **Unraid 7.3+** which has not been released.
-
-**UAT results (6 passed, 3 blocked):**
-- PASS: Container list, status submenu, start, stop, restart, idempotent start
-- BLOCKED: Single container update, batch update, text commands (all depend on `updateContainer` mutation)
-
-**What's ready for Unraid 7.3:**
-- All Phase 15 infrastructure (Container ID Registry, GraphQL Normalizer, Error Handler)
-- Phase 16 workflow code for status queries, start/stop/restart (all working)
-- Phase 16 workflow code for updates (correct mutation signatures, just needs API availability)
-- Debug fixes: batch cancel wiring, text command paired item fix, batch confirmation HTTP node
-
-**Resume trigger:** Unraid 7.3 release → re-run UAT → fix any remaining issues → continue Phase 17-18
-
 ## Performance Metrics
 
 **Velocity:**
-- Total plans completed: 58
+- Total plans completed: 50
-- Total execution time: 12 days + 29 minutes (v1.0: 5 days, v1.1: 2 days, v1.2: 4 days, v1.3: 1 day, v1.4: 29 min)
+- Total execution time: 12 days (v1.0: 5 days, v1.1: 2 days, v1.2: 4 days, v1.3: 1 day)
 - Average per milestone: 3 days
 
 **By Milestone:**
@@ -59,50 +42,55 @@ Running in production: v1.3 (Docker socket proxy architecture)
 | v1.1 | 11 | 2 days | ~4 hours |
 | v1.2 | 25 | 4 days | ~4 hours |
 | v1.3 | 2 | 1 day | ~2 minutes |
-| v1.4 | 8 | 29 minutes | 3.6 minutes |
+| v1.4 | TBD | In progress | - |
 
 ## Accumulated Context
 
 ### Decisions
 
 Decisions are logged in PROJECT.md Key Decisions table.
+Key decisions from v1.3 and v1.4 planning:
 
-- [v1.4] PAUSE — Unraid 7.2.x lacks updateContainer mutation, resume when 7.3 ships
-- [v1.4] ROLLBACK — v1.3 workflows restored to n8n for stable production use
 - [v1.4] Remove container logs feature entirely (not valuable enough to justify hybrid architecture)
 - [v1.4] Remove docker-socket-proxy completely (clean single-API architecture)
 - [v1.3] Descope to Phase 14 only — Phases 15-16 superseded by v1.4 Unraid API Native
 - [v1.3] myunraid.net cloud relay for Unraid API (direct LAN IP fails due to nginx redirect)
+- [v1.3] Environment variables for Unraid API auth (more reliable than n8n Header Auth)
 
 ### Pending Todos
 
-- Monitor Unraid 7.3 release for `updateContainer` mutation availability
+None.
-- When 7.3 ships: re-run `/gsd:verify-work 16` to validate update operations
 
 ### Blockers/Concerns
 
-**BLOCKING: Unraid 7.3 not released**
+**v1.4 architectural risks (from research):**
-- `updateContainer(id: PrefixedID!)` — single container update
+- Container ID format translation critical (Docker 64-char hex vs Unraid 129-char PrefixedID)
-- `updateContainers(ids: [PrefixedID!]!)` — batch update
+- Telegram callback data 64-byte limit with longer IDs requires encoding redesign
-- `updateAllContainers` — update all with available updates
+- GraphQL response normalization must prevent cascading failures across 60+ Code nodes
-- All three mutations exist in API source (commit 277ac42046) but only ship in Unraid 7.3+
+- myunraid.net cloud relay adds 200-500ms latency (timeout configuration needed)
-- Current server runs Unraid 7.2.x with API v4.25-4.28 (only `start`/`stop` mutations)
+
+**Next phase readiness:**
+- Phase 15 (Infrastructure Foundation) ready to plan
+- Research complete, requirements defined, roadmap approved
+- All infrastructure dependencies verified in Phase 14
 
 ## Key Artifacts
 
-**Production (v1.3 — running on n8n):**
+- `n8n-workflow.json` -- Main workflow (169 nodes)
-- `n8n-workflow.json` -- Main workflow (v1.3, Docker socket proxy architecture)
+- `n8n-batch-ui.json` -- Batch UI sub-workflow (17 nodes) -- ID: `ZJhnGzJT26UUmW45`
-- All 7 sub-workflows at v1.3 state pushed to n8n
+- `n8n-status.json` -- Container Status sub-workflow (11 nodes) -- ID: `lqpg2CqesnKE2RJQ`
-
+- `n8n-confirmation.json` -- Confirmation Dialogs sub-workflow (16 nodes) -- ID: `fZ1hu8eiovkCk08G`
-**Development (v1.4 — on branch gsd/v1.0-unraid-api-native):**
+- `n8n-update.json` -- Container Update sub-workflow (34 nodes) -- ID: `7AvTzLtKXM2hZTio92_mC`
-- Phase 15-16 work preserved in git (GraphQL migration code ready for Unraid 7.3)
+- `n8n-actions.json` -- Container Actions sub-workflow (11 nodes) -- ID: `fYSZS5PkH0VSEaT5`
-- UAT and debug reports in `.planning/phases/16-api-migration/`
+- `n8n-logs.json` -- Container Logs sub-workflow (9 nodes) -- ID: `oE7aO2GhbksXDEIw` -- TO BE REMOVED
+- `n8n-matching.json` -- Container Matching sub-workflow (23 nodes) -- ID: `kL4BoI8ITSP9Oxek`
+- `ARCHITECTURE.md` -- Full architecture docs, contracts, and node analysis
 
 ## Session Continuity
 
 Last session: 2026-02-09
-Stopped at: v1.4 PAUSED — v1.3 restored to n8n, waiting for Unraid 7.3
+Stopped at: v1.4 roadmap created
-Next step: When Unraid 7.3 releases → re-run Phase 16 UAT → continue to Phase 17-18
+Next step: `/gsd:plan-phase 15`
 
 ---
 *Auto-maintained by GSD workflow*

.planning/debug/batch-cancel-broken.md

@@ -1,67 +0,0 @@
----
-status: verifying
-trigger: "The cancel button on the batch confirmation dialog does not work"
-created: 2026-02-09T00:00:00Z
-updated: 2026-02-09T00:02:00Z
----
-
-## Current Focus
-
-hypothesis: CONFIRMED - Route Callback output index 20 (batchcancel) had empty connection array
-test: fix applied and pushed to n8n (HTTP 200)
-expecting: batch cancel button now routes to Prepare Batch UI Input -> Batch UI sub-workflow -> Handle Cancel
-next_action: user verification - press cancel button on batch confirmation dialog in Telegram
-
-## Symptoms
-
-expected: Cancel button on batch confirmation dialog should cancel the operation and return user to previous state
-actual: Cancel button does nothing (callback is parsed but routed to empty connection)
-errors: No error in n8n - execution silently ends because route goes nowhere
-reproduction: select containers in batch, confirm selection, press cancel on confirmation dialog
-started: after Phase 16 migration (Docker socket proxy -> Unraid GraphQL API)
-
-## Eliminated
-
-## Evidence
-
-- timestamp: 2026-02-09T00:00:30Z
-  checked: Parse Callback Data node in n8n-workflow.json (line 558)
-  found: batch:cancel callback is correctly parsed, sets isBatchCancel=true
-  implication: callback parsing is working correctly
-
-- timestamp: 2026-02-09T00:00:40Z
-  checked: Route Callback switch node outputs (lines 569-1094)
-  found: isBatchCancel is output index 20 (outputKey "batchcancel"), the LAST output
-  implication: routing rule exists and should match correctly
-
-- timestamp: 2026-02-09T00:00:50Z
-  checked: Route Callback connection array (lines 5495-5638)
-  found: Output index 20 is empty array [] (line 5637) while outputs 14-19 all connect to "Prepare Batch UI Input"
-  implication: ROOT CAUSE - batch:cancel callback is parsed and routed but the output goes nowhere
-
-- timestamp: 2026-02-09T00:00:55Z
-  checked: Prepare Batch UI Input node (line 3420)
-  found: Node explicitly handles isBatchCancel -> sets action='cancel', and Batch UI sub-workflow has cancel route
-  implication: The downstream handling exists and is correct - only the connection is missing
-
-- timestamp: 2026-02-09T00:01:00Z
-  checked: Batch UI sub-workflow cancel route (n8n-batch-ui.json line 564-576)
-  found: Handle Cancel node returns {action:'cancel', chatId, messageId, queryId, answerText:'Batch selection cancelled'}
-  implication: Sub-workflow cancel handling is complete - just needs to be reached
-
-- timestamp: 2026-02-09T00:01:00Z
-  checked: batch:cancel callback sources
-  found: Used in 3 places: (1) batch selection UI cancel button, (2) batch stop confirmation cancel button, (3) text-command batch confirmation cancel button
-  implication: This broken connection affects ALL batch cancel scenarios, not just one dialog
-
-- timestamp: 2026-02-09T00:02:00Z
-  checked: Fix applied - connected output 20 to "Prepare Batch UI Input"
-  found: JSON validated, workflow pushed to n8n successfully (HTTP 200)
-  implication: Fix is deployed - needs user verification via Telegram
-
-## Resolution
-
-root_cause: Route Callback switch node output index 20 (batchcancel) had empty connection array [] instead of connecting to "Prepare Batch UI Input" like all other batch-related outputs (indices 14-19). This was likely a wiring oversight during Phase 16 migration when batch operations were added to the Route Callback switch - the batchcancel rule was added last but its connection was left empty.
-fix: Connected Route Callback output index 20 (batchcancel) to "Prepare Batch UI Input" node, matching the pattern of outputs 14-19 (bexecTextCmd, batchmode, batchtoggle, batchnav, batchexec, batchclear)
-verification: Fix applied and pushed to n8n (HTTP 200). JSON validated. Awaiting user Telegram verification.
-files_changed: [n8n-workflow.json]

.planning/debug/text-commands-broken.md

@@ -1,88 +0,0 @@
----
-status: verifying
-trigger: "Text commands for start/stop don't work, and the batch text command confirmation dialog has no actionable buttons."
-created: 2026-02-09T00:00:00Z
-updated: 2026-02-09T19:00:00Z
----
-
-## Current Focus
-
-hypothesis: TWO root causes confirmed - (1) paired item breakage from GraphQL chain + sub-workflow calls, (2) Telegram node double-serializing reply_markup
-test: Push fixed workflow to n8n and test text commands
-expecting: Text start/stop commands execute successfully; batch confirmation shows clickable buttons
-next_action: User verification of text commands and batch confirmation buttons
-
-## Symptoms
-
-expected: Text-based start/stop commands (e.g., "start plex") trigger container actions; batch text commands show confirmation with actionable buttons
-actual: Text-based start/stop commands don't work at all; batch text command confirmation dialog has no actionable buttons
-errors: "Paired item data for item from node 'Prepare Action Match Input' is unavailable" in Prepare Text Action Input node
-reproduction: Send "start plex" or "stop sonarr" as text command; send "update all" for batch
-started: After Phase 16-06 migration (Execute Command nodes replaced with GraphQL query chains)
-
-## Eliminated
-
-- hypothesis: Broken connections between GraphQL chain nodes and downstream nodes
-  evidence: All connections verified correct in workflow JSON. The chains (Query -> Normalize -> Registry -> Prepare Match Input) are properly wired.
-  timestamp: 2026-02-09T18:30:00Z
-
-## Evidence
-
-- timestamp: 2026-02-09T18:20:00Z
-  checked: n8n error executions (1514, 1516)
-  found: Both fail at "Prepare Text Action Input" node with error "Paired item data for item from node 'Prepare Action Match Input' is unavailable"
-  implication: The $('Parse Action Command').item.json reference cannot resolve paired items through the GraphQL chain + sub-workflow call
-
-- timestamp: 2026-02-09T18:25:00Z
-  checked: Data flow through GraphQL chain
-  found: Query Containers (1 item) -> Normalize (22 items, one per container) -> Registry Update (22 items) -> Prepare Action Match Input (aggregates to 1 item via $input.all()) -> Execute Action Match (sub-workflow, breaks paired items) -> Route Action Match Result -> Prepare Text Action Input (tries $('Parse Action Command').item.json -> FAILS)
-  implication: Sub-workflow calls completely reset paired item tracking. Using .item.json to reference nodes before the sub-workflow is invalid.
-
-- timestamp: 2026-02-09T18:30:00Z
-  checked: Execution 1512 (successful batch keyboard send)
-  found: "Send Batch Confirmation" (Telegram node) sends message successfully (HTTP 200) but response shows NO inline keyboard buttons. Build Batch Keyboard output has valid reply_markup object.
-  implication: n8n Telegram node's additionalFields.reply_markup with JSON.stringify() likely double-serializes, causing Telegram to silently ignore the markup
-
-- timestamp: 2026-02-09T18:35:00Z
-  checked: All reply_markup patterns across all 8 workflow files
-  found: ALL other nodes that send inline keyboards use HTTP Request nodes with reply_markup as nested object inside JSON.stringify(). Only "Send Batch Confirmation" uses the n8n Telegram node.
-  implication: The Telegram node approach is unique and broken; HTTP Request pattern works reliably
-
-- timestamp: 2026-02-09T18:40:00Z
-  checked: Prepare Batch Execution node code
-  found: Uses $('Detect Batch Command').item.json which has same paired item breakage (downstream of GraphQL chain + Execute Batch Match sub-workflow)
-  implication: Batch text commands would also fail with paired item error, same root cause as action commands
-
-## Resolution
-
-root_cause: |
-  TWO distinct root causes, both introduced by Phase 16-06 migration:
-
-  1. PAIRED ITEM BREAKAGE: Two Code nodes use $('NodeName').item.json to reference upstream
-     nodes, but the reference traverses both a GraphQL normalizer chain (which expands 1 item
-     to 22 items) AND a sub-workflow call (Execute Match), both of which break n8n's paired
-     item tracking. Affected nodes:
-     - "Prepare Text Action Input": $('Parse Action Command').item.json
-     - "Prepare Batch Execution": $('Detect Batch Command').item.json
-
-  2. TELEGRAM NODE REPLY_MARKUP: "Send Batch Confirmation" uses n8n Telegram node with
-     reply_markup in additionalFields set to JSON.stringify($json.reply_markup). The Telegram
-     node double-serializes this, causing Telegram API to receive an escaped string instead
-     of a JSON object for reply_markup, so buttons are silently dropped.
-
-fix: |
-  Three changes to n8n-workflow.json:
-
-  1. Prepare Text Action Input: Changed $('Parse Action Command').item.json to .first().json
-     (.first() doesn't require paired item tracking - it always returns the first output item)
-
-  2. Prepare Batch Execution: Changed $('Detect Batch Command').item.json to .first().json
-     (same fix, same reason)
-
-  3. Send Batch Confirmation: Converted from n8n Telegram node to HTTP Request node
-     (matching the pattern used by ALL other confirmation messages in the project).
-     New config sends JSON body with reply_markup as a nested object, not double-serialized.
-
-verification: Workflow pushed to n8n (HTTP 200). Awaiting user verification of text commands.
-files_changed:
-  - n8n-workflow.json

.planning/debug/update-flow-errors.md

@@ -1,85 +0,0 @@
----
-status: verifying
-trigger: "Single container update via inline keyboard fails with execution errors on both main workflow and container update sub-workflow"
-created: 2026-02-09T00:00:00Z
-updated: 2026-02-09T00:30:00Z
----
-
-## Current Focus
-
-hypothesis: CONFIRMED - Three bugs in n8n-update.json causing update flow failure
-test: Push fixed workflow and trigger update via inline keyboard
-expecting: Update should complete without execution errors
-next_action: User triggers update to verify fix
-
-## Symptoms
-
-expected: Tapping "Update" on inline keyboard confirmation should trigger container update via GraphQL API
-actual: Execution errors on both main workflow and update sub-workflow after confirmation dialog
-errors: (1) "Unknown argument 'filter' on field 'Docker.containers'" (2) "missing data.docker.containers" (3) Wrong node reference in Return Error
-reproduction: Tap Update on container submenu, confirm, observe error
-started: After Phase 16 migration (Docker socket proxy -> Unraid GraphQL API)
-
-## Eliminated
-
-- hypothesis: Credential ID issue (placeholder "unraid-api-key-credential-id")
-  evidence: n8n resolves credentials by name on push; actual n8n has correct ID "6DB4RZZoeF5Raf7V"
-  timestamp: 2026-02-09
-
-- hypothesis: ContainerId format is wrong (PrefixedID with colon)
-  evidence: The PrefixedID format is correct and used by the mutation; the issue is the query using a nonexistent filter arg
-  timestamp: 2026-02-09
-
-- hypothesis: Main workflow "Prepare Text Action Input" error is related
-  evidence: Execution 1516 was triggered by text command "Start dup", not an update callback - separate bug
-  timestamp: 2026-02-09
-
-## Evidence
-
-- timestamp: 2026-02-09
-  checked: n8n execution 1498 (main workflow, callback update flow)
-  found: Flow reaches "Execute Callback Update" which calls update sub-workflow; sub-workflow fails with "missing data.docker.containers" error
-  implication: Error originates in update sub-workflow, propagates back to main workflow
-
-- timestamp: 2026-02-09
-  checked: n8n execution 1500 (update sub-workflow)
-  found: "Query Single Container" node sends GraphQL query with `filter: { id: "..." }` argument. Unraid API responds HTTP 400: "Unknown argument 'filter' on field 'Docker.containers'"
-  implication: The `filter` argument does not exist in Unraid GraphQL API schema. All working queries use `query { docker { containers { ... } } }` without filter
-
-- timestamp: 2026-02-09
-  checked: Working queries in n8n-actions.json, n8n-status.json
-  found: All working nodes query ALL containers without filter, then filter client-side
-  implication: Unraid GraphQL API only supports listing all containers, no server-side filtering
-
-- timestamp: 2026-02-09
-  checked: Update sub-workflow flow routing
-  found: Main workflow passes containerId (resolved by name). Sub-workflow's "Has Container ID?" = true, routes to "Query Single Container" (broken filter). The "no container ID" path through "Query All Containers" works correctly
-  implication: Direct ID path is always taken and always fails
-
-- timestamp: 2026-02-09
-  checked: "Return Error" node code
-  found: References `$('Format Pull Error')` but node is actually named "Format Update Error"
-  implication: Error path would also fail with "node not found" if reached
-
-- timestamp: 2026-02-09
-  checked: "Capture Pre-Update State" node
-  found: Reads `data.image` (lowercase) from normalizer but normalizer outputs `Image` (capitalized)
-  implication: currentImage would always be empty string even if normalizer worked
-
-## Resolution
-
-root_cause: Three bugs in n8n-update.json:
-  1. PRIMARY: "Query Single Container" uses nonexistent GraphQL `filter` argument on `Docker.containers`. Unraid API does not support server-side filtering - returns HTTP 400.
-  2. SECONDARY: "Return Error" node references `$('Format Pull Error')` but node is named "Format Update Error" (leftover from pre-migration naming).
-  3. MINOR: "Capture Pre-Update State" reads `data.image` but normalizer outputs `data.Image` (case mismatch).
-
-fix: |
-  1. Changed "Query Single Container" jsonBody from filter-based query to same all-containers query used by working nodes
-  2. Rewrote "Normalize Single Container" to fetch all containers, then filter client-side by containerId from trigger data
-  3. Fixed "Return Error" node reference from `$('Format Pull Error')` to `$('Format Update Error')`
-  4. Fixed "Capture Pre-Update State" property access from `data.image` to `data.Image`
-
-verification: Pushed to n8n (HTTP 200). Awaiting user test of inline keyboard update flow.
-
-files_changed:
-  - /home/luc/Projects/unraid-docker-manager/n8n-update.json

.planning/phases/15-infrastructure-foundation/15-01-SUMMARY.md

@@ -1,178 +0,0 @@
----
-phase: 15-infrastructure-foundation
-plan: 01
-subsystem: infra
-tags: [container-id-registry, callback-token-encoding, unraid-prefixedid, telegram-callback-data]
-
-# Dependency graph
-requires:
-  - phase: 14-unraid-api-access
-    provides: Unraid GraphQL API container data format (id: PrefixedID, names[], state)
-  - phase: 11-update-all-callback-limits
-    context: Demonstrated callback_data 64-byte limit (bitmap encoding addressed this for batch operations)
-provides:
-  - Container ID Registry utility node (container name <-> Unraid PrefixedID translation)
-  - Callback Token Encoder utility node (PrefixedID -> 8-char hex token with collision detection)
-  - Callback Token Decoder utility node (8-char token -> PrefixedID resolution)
-  - Static data persistence pattern for _containerIdMap and _callbackTokens
-affects: [16-api-migration, 17-container-id-translation]
-
-# Tech tracking
-tech-stack:
-  added:
-    - crypto.subtle.digest (Web Crypto API for SHA-256 hashing)
-  patterns:
-    - JSON serialization for n8n static data persistence (top-level assignment pattern per CLAUDE.md)
-    - SHA-256 hash with 7-window collision detection (56 chars / 8-char windows)
-    - Idempotent token encoding (reuse existing token if same unraidId)
-    - Container name normalization (strip leading '/', lowercase)
-    - Registry staleness detection (60-second threshold for error messaging)
-
-key-files:
-  created: []
-  modified:
-    - n8n-workflow.json
-
-key-decisions:
-  - "Token encoder uses 8-char hex (not base64) for deterministic collision avoidance via hash window offsets"
-  - "Registry stores full PrefixedID (129-char) as-is, not normalized - downstream consumers handle format"
-  - "Decoder is read-only (no JSON.stringify) - token store managed entirely by encoder"
-  - "Collision detection tries 7 non-overlapping windows (0, 8, 16, 24, 32, 40, 48 char offsets from SHA-256)"
-  - "Standalone utility nodes NOT connected to active flow - Phase 16 will wire them in"
-
-patterns-established:
-  - "Container ID Registry as centralized name->ID translation layer"
-  - "Token encoding system as callback_data compression layer for Telegram's 64-byte limit"
-  - "Dual-mode node pattern (update vs lookup based on input.containers vs input.containerName)"
-
-# Metrics
-duration: 6min
-completed: 2026-02-09
----
-
-# Phase 15 Plan 01: Container ID Registry and Callback Token Encoding Summary
-
-Built Container ID Registry and Callback Token Encoding system as standalone utility Code nodes for Phase 16 API migration. Registry maps container names to Unraid 129-char PrefixedIDs, token system compresses PrefixedIDs to 8-char hex for Telegram callback_data limit.
-
-## What Was Built
-
-### Container ID Registry (Task 1 - Already Complete in Baseline)
-
-**Node:** Container ID Registry at position [200, 2400]
-
-**Note:** This node was already implemented in the baseline commit 1b4b596 (incorrectly labeled as 15-02 but contained 15-01 work). Verified implementation matches all plan requirements.
-
-**Implementation:**
-- `updateRegistry(containers)`: Takes Unraid GraphQL container array, extracts names (strip `/`, lowercase), maps to `{name, unraidId: container.id}`, stores with timestamp
-- `getUnraidId(containerName)`: Resolves container name to 129-char PrefixedID, throws helpful errors (stale registry vs invalid name)
-- `getContainerByName(containerName)`: Returns full entry `{name, unraidId}`
-- Dual-mode input contract: `input.containers` for updates, `input.containerName` for lookups
-- JSON serialization pattern: `registry._containerIdMap = JSON.stringify(newMap)` (top-level assignment per CLAUDE.md)
-- 60-second staleness threshold for error messaging
-
-**Verification passed:** All functions present, JSON pattern correct, no connections.
-
-### Callback Token Encoder (Task 2)
-
-**Node:** Callback Token Encoder at position [600, 2400]  
-**Commit:** 1b61343
-
-**Implementation:**
-- `encodeToken(unraidId)`: Async function using crypto.subtle.digest('SHA-256')
-- Generates SHA-256 hash, takes first 8 hex chars as token
-- Collision detection: If token exists with different unraidId, tries next 8-char window (offsets: 0, 8, 16, 24, 32, 40, 48)
-- Idempotent: Reuses existing token if same unraidId
-- Input contract: `input.unraidId` (required), `input.action` (optional)
-- Output: `{token, unraidId, callbackData, byteSize, warning}` - includes callback_data format and 64-byte limit validation
-- JSON serialization: `staticData._callbackTokens = JSON.stringify(tokenStore)`
-
-**Verification passed:** SHA-256 hashing, 7-window collision detection, JSON pattern, no connections.
-
-### Callback Token Decoder (Task 2)
-
-**Node:** Callback Token Decoder at position [1000, 2400]  
-**Commit:** 1b61343
-
-**Implementation:**
-- `decodeToken(token)`: Looks up token in store, throws if not found
-- Input contract: `input.token` (8-char hex) OR `input.callbackData` (string like "action:start:a1b2c3d4")
-- Callback data parsing: Splits by `:`, extracts action and token (last segment)
-- Output: `{token, unraidId, action}`
-- Read-only: Only uses JSON.parse (no stringify) - token store managed by encoder
-
-**Verification passed:** decodeToken function, error handling, callbackData parsing, no connections.
-
-## Deviations from Plan
-
-### Pre-existing Work
-
-**Task 1 (Container ID Registry) was already complete in baseline commit 1b4b596.**
-
-- **Found during:** Plan execution initialization
-- **Issue:** Commit 1b4b596 was labeled `feat(15-02)` but actually contained both the Container ID Registry (Task 1 from plan 15-01) AND the GraphQL Response Normalizer (Task 1 from plan 15-02)
-- **Resolution:** Verified existing implementation matches all Task 1 requirements (updateRegistry, getUnraidId, getContainerByName, JSON serialization, no connections). Proceeded with Task 2 only.
-- **Impact:** No implementation changes needed for Task 1. Task 2 added as planned.
-- **Commits:** No new commit for Task 1 (already in baseline). Task 2 committed as 1b61343.
-
-### n8n API Field Restrictions (Deviation Rule 3 - Blocking Issue)
-
-**Notes fields cannot be pushed to n8n via API.**
-
-- **Found during:** Task 2 push to n8n (HTTP 400 "must NOT have additional properties")
-- **Issue:** Plan specified adding `notes` and `notesDisplayMode` fields to document utility node purpose. n8n API only accepts 6 fields: id, name, type, typeVersion, position, parameters.
-- **Fix:** Removed notes/notesDisplayMode fields from all nodes before pushing payload. Documentation moved to JSDoc comments in jsCode (first lines of each function).
-- **Files modified:** n8n-workflow.json (cleaned before push)
-- **Verification:** Push succeeded with HTTP 200, n8n confirms 175 nodes.
-- **Impact:** Node documentation now lives in code comments instead of n8n UI notes field. Functionally equivalent for Phase 16 (code is self-documenting).
-
-## Execution Summary
-
-**Tasks completed:** 2/2
-- Task 1: Container ID Registry (verified baseline implementation)
-- Task 2: Callback Token Encoder and Decoder (implemented and committed)
-
-**Commits:**
-- 1b61343: feat(15-01): add Callback Token Encoder and Decoder utility nodes
-
-**Duration:** 6 minutes (Task 1 verification + Task 2 implementation + n8n push + commit)
-
-**Files modified:**
-- n8n-workflow.json (added 2 nodes: encoder, decoder)
-
-**n8n push:** Successful (HTTP 200, 175 nodes, updated 2026-02-09T13:53:17.242Z)
-
-## Verification Results
-
-All success criteria met:
-
-- [✓] Container ID Registry maps container names to Unraid PrefixedID format (129-char)
-- [✓] Callback token encoding produces 8-char hex tokens that fit within Telegram's 64-byte callback_data limit
-- [✓] Token collision detection prevents wrong-container scenarios (7-window SHA-256 approach)
-- [✓] All static data uses JSON serialization (top-level assignment) per CLAUDE.md convention
-- [✓] Three standalone utility nodes ready for Phase 16 to wire in
-- [✓] No connections to/from any utility node (verified in workflow connections map)
-- [✓] Workflow JSON valid and pushed to n8n
-
-## Self-Check: PASSED
-
-**Created files:**
-- [✓] FOUND: .planning/phases/15-infrastructure-foundation/15-01-SUMMARY.md (this file)
-
-**Commits:**
-- [✓] FOUND: 1b61343 (Task 2: Callback Token Encoder and Decoder)
-
-**n8n nodes:**
-- [✓] Container ID Registry exists in n8n workflow (175 nodes total)
-- [✓] Callback Token Encoder exists in n8n workflow
-- [✓] Callback Token Decoder exists in n8n workflow
-
-## Next Steps
-
-**Phase 16 (API Migration)** will:
-1. Wire Container ID Registry into container status flow (connect after Unraid GraphQL responses)
-2. Wire Callback Token Encoder into inline keyboard generation (replace long PrefixedIDs with 8-char tokens)
-3. Wire Callback Token Decoder into callback routing (resolve tokens back to PrefixedIDs)
-4. Update all 60+ Code nodes to use registry for ID translation
-5. Test token collision handling under production load
-
-**Ready for:** Plan 15-02 execution (if not already complete) or Phase 16 planning.

.planning/phases/15-infrastructure-foundation/15-02-SUMMARY.md

@@ -1,138 +0,0 @@
----
-phase: 15-infrastructure-foundation
-plan: 02
-subsystem: infra
-tags: [graphql, unraid-api, response-normalization, error-handling, http-templates]
-
-# Dependency graph
-requires:
-  - phase: 14-unraid-api-access
-    provides: Unraid GraphQL API access verification, myunraid.net cloud relay configuration
-provides:
-  - GraphQL Response Normalizer utility node (Unraid to Docker API contract transformation)
-  - GraphQL Error Handler utility node (error code mapping with HTTP 304 for ALREADY_IN_STATE)
-  - Unraid API HTTP Template utility node (15s timeout, env var auth, copy-paste template)
-affects: [16-api-migration, 17-container-id-translation, 18-docker-proxy-removal]
-
-# Tech tracking
-tech-stack:
-  added: []
-  patterns:
-    - GraphQL response normalization (Unraid UPPERCASE state -> Docker lowercase)
-    - ALREADY_IN_STATE error code maps to HTTP 304 (matches Docker API pattern)
-    - Environment variable authentication (UNRAID_HOST, UNRAID_API_KEY headers)
-    - 15-second timeout for myunraid.net cloud relay latency
-    - continueRegularOutput error handling for downstream Code node processing
-
-key-files:
-  created: []
-  modified:
-    - n8n-workflow.json
-
-key-decisions:
-  - "GraphQL normalizer keeps full Unraid PrefixedID in Id field (downstream Container ID Registry handles translation)"
-  - "STOPPED->exited state mapping (Docker convention for stopped containers)"
-  - "15-second HTTP timeout for cloud relay (200-500ms latency + safety margin for slow operations)"
-  - "Environment variable authentication instead of n8n Header Auth credential (Phase 14 decision - more reliable)"
-  - "continueRegularOutput error handling allows downstream Code node to process GraphQL errors instead of n8n catching them"
-
-patterns-established:
-  - "Utility nodes as standalone copy-paste templates (not connected until Phase 16 wiring)"
-  - "GraphQL error checking: response.errors[] array inspection with extensions.code mapping"
-  - "HTTP Template pattern: pre-configured request nodes as duplication templates"
-
-# Metrics
-duration: 5min
-completed: 2026-02-09
----
-
-# Phase 15 Plan 02: GraphQL Utility Nodes Summary
-
-**GraphQL Response Normalizer, Error Handler, and HTTP Template utility nodes for zero-change Unraid API migration**
-
-## Performance
-
-- **Duration:** 5 minutes
-- **Started:** 2026-02-09T13:47:13Z
-- **Completed:** 2026-02-09T13:52:29Z
-- **Tasks:** 2
-- **Files modified:** 1
-
-## Accomplishments
-- GraphQL Response Normalizer transforms Unraid API shape to Docker API contract (id->Id, UPPERCASE state->lowercase, names preserved)
-- GraphQL Error Handler maps ALREADY_IN_STATE to HTTP 304 equivalent, handles NOT_FOUND/FORBIDDEN/UNAUTHORIZED
-- Unraid API HTTP Template pre-configured with 15-second timeout, environment variable auth, and continueRegularOutput
-- All three utility nodes standalone (not connected) - ready for Phase 16 API migration wiring
-
-## Task Commits
-
-Each task was committed atomically:
-
-1. **Task 1: Add GraphQL Response Normalizer utility node** - `1b4b596` (feat)
-2. **Task 2: Add GraphQL Error Handler and Unraid API HTTP Template nodes** - `e6ac219` (feat)
-
-## Files Created/Modified
-- `n8n-workflow.json` - Added 3 utility nodes (GraphQL Response Normalizer, GraphQL Error Handler, Unraid API HTTP Template) at positions [200,2600], [600,2600], [1000,2600]
-
-## Decisions Made
-
-1. **Full Unraid PrefixedID preservation**: GraphQL normalizer copies the full 129-character Unraid ID to the Docker API `Id` field. Translation happens downstream via the Container ID Registry (Plan 01), not in the normalizer. This keeps normalization focused on API shape transformation only.
-
-2. **STOPPED->exited mapping**: Unraid returns "STOPPED" state, Docker API uses "exited" for stopped containers. Normalizer maps STOPPED->exited to match Docker convention, ensuring existing workflow nodes recognize stopped containers correctly.
-
-3. **ALREADY_IN_STATE = HTTP 304**: When container is already in desired state (e.g., "start" on running container), Unraid returns ALREADY_IN_STATE error code. Mapped to HTTP 304 to match Docker API pattern used in n8n-actions.json, allowing existing success/failure logic to work unchanged.
-
-4. **15-second HTTP timeout**: myunraid.net cloud relay adds 200-500ms latency (Phase 14 measurement). 15 seconds provides safety margin for slow operations like container start/stop (3-5 seconds) plus relay overhead.
-
-5. **continueRegularOutput error mode**: HTTP Request node configured to pass errors as regular output instead of n8n catching them. Allows downstream GraphQL Error Handler Code node to inspect response.errors[] array and map error codes appropriately.
-
-## Deviations from Plan
-
-### Auto-fixed Issues
-
-**1. [Rule 3 - Blocking] Fixed Container ID Registry invalid property**
-- **Found during:** Task 2 (n8n API push validation)
-- **Issue:** Container ID Registry node (from Task 1 commit) had `notesDisplayMode: 'show'` property which is not valid for n8n API PUT requests. API returned HTTP 400 with "must NOT have additional properties" error.
-- **Fix:** Removed `notesDisplayMode` property from Container ID Registry node. This property is display-only and not part of the n8n workflow schema for API operations.
-- **Files modified:** n8n-workflow.json
-- **Verification:** Workflow successfully pushed to n8n with HTTP 200 response
-- **Committed in:** e6ac219 (Task 2 commit)
-
----
-
-**Total deviations:** 1 auto-fixed (1 blocking)
-**Impact on plan:** Auto-fix necessary to push workflow to n8n. Property was UI-only metadata not required for functionality. No scope impact.
-
-## Issues Encountered
-
-**n8n API validation on push**: Initial push attempts failed with HTTP 400 "must NOT have additional properties" for node 170. Root cause was `notesDisplayMode` property present on Container ID Registry node from previous task. Property is valid in n8n UI but rejected by API validation on PUT requests. Fixed by removing the property (see Deviations).
-
-## User Setup Required
-
-None - no external service configuration required. All utility nodes use existing environment variables (UNRAID_HOST, UNRAID_API_KEY) configured in Phase 14.
-
-## Next Phase Readiness
-
-**Phase 16 (API Migration) ready to begin:**
-- Three utility nodes provide complete transformation pipeline: HTTP Request -> Error Handler -> Response Normalizer -> existing workflow nodes
-- HTTP Template serves as copy-paste template for migrating each Docker API call to Unraid GraphQL
-- Error handler maps Unraid error codes to Docker HTTP status codes (304, 404, etc.)
-- Normalizer ensures zero changes required to 60+ downstream Code nodes expecting Docker API format
-- All nodes validated and pushed to n8n successfully
-
-**Blockers:** None
-
-**Notes:**
-- Container ID Registry node (from uncommitted Plan 01 work) was included in Task 1 commit. This node is required for Plan 02's normalizer but belongs to Plan 01. Plan 01 should be executed to complete the Container ID Registry implementation (add translation helper functions).
-- Task 2 commit accidentally included 2 extra nodes (Callback Token Encoder, Callback Token Decoder) that were not part of Plan 02. These appear to be from uncommitted work in the repository. Total nodes added: 4 instead of planned 2. The extra nodes do not affect Plan 02 functionality.
-
-## Self-Check
-
-**Files:** PASSED - n8n-workflow.json exists and modified
-**Commits:** PASSED - 1b4b596 (Task 1) and e6ac219 (Task 2) exist
-**Nodes:** PASSED - All 3 Plan 02 utility nodes exist in workflow
-**Node count:** DISCREPANCY - 175 nodes total (expected 173). Task 2 commit included 4 nodes instead of 2 (see Notes above).
-
----
-*Phase: 15-infrastructure-foundation*
-*Completed: 2026-02-09*

.planning/phases/15-infrastructure-foundation/15-VERIFICATION.md

@@ -1,117 +0,0 @@
----
-phase: 15-infrastructure-foundation
-verified: 2026-02-09T19:15:00Z
-status: passed
-score: 10/10 must-haves verified
-re_verification: false
----
-
-# Phase 15: Infrastructure Foundation Verification Report
-
-**Phase Goal:** Data transformation layers ready for Unraid API integration
-**Verified:** 2026-02-09T19:15:00Z
-**Status:** PASSED
-**Re-verification:** No - initial verification
-
-## Goal Achievement
-
-### Observable Truths
-
-| # | Truth | Status | Evidence |
-|---|-------|--------|----------|
-| 1 | Container ID Registry maps container names to Unraid PrefixedID format | ✓ VERIFIED | Node exists with updateRegistry(), getUnraidId(), getContainerByName() functions. Uses JSON serialization for _containerIdMap. Code: 3974 chars. |
-| 2 | Callback token encoder produces 8-char tokens from PrefixedIDs | ✓ VERIFIED | Node exists with encodeToken() using crypto.subtle.digest SHA-256. Produces 8-char hex tokens. Code: 2353 chars. |
-| 3 | Callback token decoder resolves 8-char tokens back to PrefixedIDs | ✓ VERIFIED | Node exists with decodeToken() function. Parses callbackData format. Code: 1373 chars. |
-| 4 | Token collisions are detected and handled | ✓ VERIFIED | Encoder has 7-window collision detection (offsets 0, 8, 16, 24, 32, 40, 48 from SHA-256 hash). |
-| 5 | Registry and token store persist across workflow executions via static data JSON serialization | ✓ VERIFIED | Both _containerIdMap and _callbackTokens use JSON.parse/JSON.stringify pattern (top-level assignment per CLAUDE.md). |
-| 6 | GraphQL response normalizer transforms Unraid API shape to Docker API contract | ✓ VERIFIED | Node exists with RUNNING->running, STOPPED->exited state mapping. Maps id->Id, names->Names, state->State. Code: 1748 chars. |
-| 7 | Normalized containers have Id, Names (with leading slash), State (lowercase) fields | ✓ VERIFIED | Normalizer outputs Id, Names, State fields. Names preserved with slash. State lowercased. |
-| 8 | GraphQL error handler checks response.errors[] array and maps error codes | ✓ VERIFIED | Node checks response.errors[], extracts extensions.code. Maps NOT_FOUND, FORBIDDEN, UNAUTHORIZED. Code: 1507 chars. |
-| 9 | ALREADY_IN_STATE error code maps to HTTP 304 equivalent | ✓ VERIFIED | Error handler maps ALREADY_IN_STATE to statusCode: 304, alreadyInState: true (matches Docker API pattern). |
-| 10 | HTTP Request template node has 15-second timeout configured | ✓ VERIFIED | HTTP Template node has timeout: 15000ms, UNRAID_HOST env var, x-api-key header, continueRegularOutput. |
-
-**Score:** 10/10 truths verified
-
-### Required Artifacts
-
-| Artifact | Expected | Status | Details |
-|----------|----------|--------|---------|
-| n8n-workflow.json | Container ID Registry node | ✓ VERIFIED | Node at position [200,2400]. 3974 chars. updateRegistry, getUnraidId, getContainerByName functions present. JSON serialization pattern verified. Not connected. |
-| n8n-workflow.json | Callback Token Encoder node | ✓ VERIFIED | Node at position [600,2400]. 2353 chars. encodeToken with SHA-256 + 7-window collision detection. JSON serialization pattern verified. Not connected. |
-| n8n-workflow.json | Callback Token Decoder node | ✓ VERIFIED | Node at position [1000,2400]. 1373 chars. decodeToken with callbackData parsing. Not connected. |
-| n8n-workflow.json | GraphQL Response Normalizer node | ✓ VERIFIED | Node at position [200,2600]. 1748 chars. State mapping (RUNNING->running, STOPPED->exited), field mapping (id->Id, names->Names, state->State). Not connected. |
-| n8n-workflow.json | GraphQL Error Handler node | ✓ VERIFIED | Node at position [600,2600]. 1507 chars. ALREADY_IN_STATE->304 mapping, NOT_FOUND/FORBIDDEN/UNAUTHORIZED handling. Not connected. |
-| n8n-workflow.json | Unraid API HTTP Template node | ✓ VERIFIED | Node at position [1000,2600]. HTTP Request node with 15s timeout, UNRAID_HOST/UNRAID_API_KEY env vars, continueRegularOutput. Not connected. |
-
-### Key Link Verification
-
-| From | To | Via | Status | Details |
-|------|----|----|--------|---------|
-| Container ID Registry | static data _containerIdMap | JSON.parse/JSON.stringify | ✓ WIRED | JSON.parse and JSON.stringify patterns both present with _containerIdMap. Top-level assignment pattern verified. |
-| Callback Token Encoder | static data _callbackTokens | SHA-256 hash + JSON serialization | ✓ WIRED | crypto.subtle.digest present. JSON.stringify with _callbackTokens verified. |
-| Callback Token Decoder | static data _callbackTokens | JSON.parse lookup | ✓ WIRED | JSON.parse with _callbackTokens present. Read-only (no stringify) as expected. |
-| GraphQL Response Normalizer | Docker API contract | Field mapping | ✓ WIRED | State transformation (RUNNING/STOPPED), Id/Names/State field mappings all verified. |
-| GraphQL Error Handler | HTTP 304 pattern | ALREADY_IN_STATE code mapping | ✓ WIRED | ALREADY_IN_STATE and 304 both present in error handler code. |
-| Unraid API HTTP Template | myunraid.net cloud relay | 15-second timeout | ✓ WIRED | timeout: 15000ms configured in HTTP Request node options. |
-
-### Requirements Coverage
-
-| Requirement | Status | Blocking Issue |
-|-------------|--------|----------------|
-| INFRA-01: Container ID translation layer maps names to Unraid PrefixedID format | ✓ SATISFIED | None - Registry node implements updateRegistry, getUnraidId, getContainerByName |
-| INFRA-02: Callback data encoding works with Unraid PrefixedIDs within Telegram's 64-byte limit | ✓ SATISFIED | None - Encoder produces 8-char tokens, includes byte size validation |
-| INFRA-03: GraphQL response normalization transforms Unraid API responses to match workflow contracts | ✓ SATISFIED | None - Normalizer maps all fields (id->Id, state->State lowercase, names->Names) |
-| INFRA-04: GraphQL error handling standardized (check response.errors[], handle HTTP 304) | ✓ SATISFIED | None - Error handler checks errors[], maps ALREADY_IN_STATE to 304 |
-| INFRA-05: Timeout configuration accounts for myunraid.net cloud relay latency | ✓ SATISFIED | None - HTTP Template has 15s timeout (200-500ms latency + safety margin) |
-
-### Anti-Patterns Found
-
-No blocker anti-patterns found. All 6 utility nodes have substantive code (1373-3974 chars each).
-
-| File | Line | Pattern | Severity | Impact |
-|------|------|---------|----------|--------|
-| n8n-workflow.json | - | No anti-patterns | - | - |
-
-### Human Verification Required
-
-**None required.** All utility nodes are standalone infrastructure components (not wired into active flow). Phase 16 will wire them into user-facing operations, which will require human testing at that time.
-
-### Success Criteria
-
-All Phase 15 success criteria from ROADMAP.md met:
-
-- [✓] Container ID translation layer maps container names to Unraid PrefixedID format (129-char)
-- [✓] Callback data encoding works with PrefixedIDs within Telegram's 64-byte limit
-- [✓] GraphQL response normalization transforms Unraid API shape to workflow contract
-- [✓] GraphQL error handling standardized (checks response.errors[], handles HTTP 304)
-- [✓] Timeout configuration accounts for myunraid.net cloud relay latency (200-500ms)
-
-### Commits Verified
-
-| Commit | Description | Files Modified | Status |
-|--------|-------------|----------------|--------|
-| 1b4b596 | feat(15-02): add GraphQL Response Normalizer utility node | n8n-workflow.json | ✓ EXISTS |
-| e6ac219 | feat(15-02): add GraphQL Error Handler and HTTP Template utility nodes | n8n-workflow.json | ✓ EXISTS |
-| 1b61343 | feat(15-01): add Callback Token Encoder and Decoder utility nodes | n8n-workflow.json | ✓ EXISTS |
-
-Note: Commit 1b4b596 was labeled feat(15-02) but included Container ID Registry (from 15-01 Plan Task 1). This is documented in 15-01-SUMMARY.md as "pre-existing work" - the registry was already complete at plan execution time.
-
-### Summary
-
-**Phase 15 goal achieved.** All 6 infrastructure utility nodes successfully implemented and verified:
-
-1. **Container ID Registry** - Maps container names to 129-char Unraid PrefixedIDs
-2. **Callback Token Encoder** - Compresses PrefixedIDs to 8-char hex tokens with collision detection
-3. **Callback Token Decoder** - Resolves tokens back to PrefixedIDs
-4. **GraphQL Response Normalizer** - Transforms Unraid API responses to Docker API contract
-5. **GraphQL Error Handler** - Standardizes GraphQL error checking with HTTP status code mapping
-6. **Unraid API HTTP Template** - Pre-configured HTTP Request node for API calls
-
-All nodes use correct patterns (JSON serialization for static data, SHA-256 hashing, state normalization). All nodes are standalone (not connected) as required - Phase 16 will wire them into the active workflow. All 5 INFRA requirements satisfied.
-
-**Next Phase:** Phase 16 (API Migration) can begin. All infrastructure utilities ready for wiring.
-
----
-
-_Verified: 2026-02-09T19:15:00Z_
-_Verifier: Claude (gsd-verifier)_

.planning/phases/16-api-migration/.continue-here.md

@@ -1,71 +0,0 @@
----
-phase: 16-api-migration
-task: UAT
-total_tasks: 6 plans + UAT
-status: paused
-last_updated: 2026-02-09T17:47:48.705Z
----
-
-<current_state>
-v1.4 milestone PAUSED. Phase 16 code was built and pushed, but UAT revealed that the Unraid GraphQL API on the user's server (Unraid 7.2.x) only has `start` and `stop` Docker mutations. The `updateContainer`, `updateContainers`, and `updateAllContainers` mutations exist in the Unraid API source code (GitHub commit 277ac42046) but only ship in Unraid 7.3+ which has not been released yet.
-
-v1.3 workflows have been restored to n8n and are running in production. The v1.4 work is preserved on branch `gsd/v1.0-unraid-api-native`.
-</current_state>
-
-<completed_work>
-
-- Phase 15 (Infrastructure Foundation): 2/2 plans complete — Container ID Registry, Token Encoder/Decoder, GraphQL Normalizer, Error Handler
-- Phase 16 Plan 01: Container Status migration (n8n-status.json) — WORKING
-- Phase 16 Plan 02: Container Actions migration (n8n-actions.json) — WORKING (start/stop/restart)
-- Phase 16 Plan 03: Container Update migration (n8n-update.json) — BLOCKED (updateContainer mutation doesn't exist on 7.2.x)
-- Phase 16 Plan 04: Batch UI migration (n8n-batch-ui.json) — WORKING
-- Phase 16 Plan 05: Main workflow routing migration (n8n-workflow.json) — PARTIALLY WORKING (queries work, batch update mutation doesn't exist)
-- Phase 16 Plan 06: Gap closure (text command paths) — WORKING but had paired item bugs (fixed in debug)
-- UAT: 6/9 tests passed, 3 blocked on missing updateContainer mutation
-- Debug fixes committed: batch cancel wiring, text command paired item fix (.first().json), batch confirmation HTTP node
-- v1.3 workflows restored to n8n (all 8 workflows, HTTP 200)
-- STATE.md and ROADMAP.md updated to reflect pause
-</completed_work>
-
-<remaining_work>
-
-- Wait for Unraid 7.3 release (ships updateContainer, updateContainers, updateAllContainers mutations)
-- Re-run `/gsd:verify-work 16` to validate update operations work with 7.3
-- Fix any remaining issues from UAT re-test
-- Phase 17 (Cleanup): Remove docker-socket-proxy artifacts, container logs feature
-- Phase 18 (Documentation): Update docs for Unraid API-native architecture
-</remaining_work>
-
-<decisions_made>
-
-- PAUSE v1.4 rather than maintain hybrid Docker proxy + GraphQL architecture
-- ROLLBACK to v1.3 workflows on n8n for stable production use
-- v1.4 work preserved on branch (mutation signatures match what 7.3 will ship)
-- The `DOCKER:UPDATE_ANY` API key permission exists because permission system was defined before mutations shipped
-- Container update internally calls legacy Bash script (`/usr/local/emhttp/plugins/dynamix.docker.manager/scripts/update_container`)
-</decisions_made>
-
-<blockers>
-- Unraid 7.3 not released — `updateContainer` mutation unavailable on current server (7.2.x)
-- No workaround that maintains the "fully Unraid API native" architecture goal
-</blockers>
-
-<context>
-The entire v1.4 milestone was about replacing Docker socket proxy with Unraid's GraphQL API. Status queries and start/stop/restart all migrated successfully and passed UAT. But container updates (single, batch, update-all) require a mutation that only exists in Unraid 7.3+. The user decided to pause rather than maintain a hybrid architecture. When Unraid 7.3 ships, the existing Phase 16 code should work as-is since the mutation signatures in our code match what the API source defines.
-
-UAT also uncovered 3 bugs that were diagnosed and fixed by parallel debug agents:
-1. Batch cancel button: Route Callback output 20 was wired to empty array
-2. Text commands: Paired item breakage after GraphQL chain expansion (.item.json → .first().json)
-3. Batch confirmation buttons: Telegram node double-serialized reply_markup (converted to HTTP Request)
-
-These fixes are committed on the branch and will be ready when v1.4 resumes.
-</context>
-
-<next_action>
-When Unraid 7.3 releases:
-1. Check `__type(name: "DockerMutations")` introspection to confirm updateContainer is available
-2. Switch to branch `gsd/v1.0-unraid-api-native`
-3. Push v1.4 workflows to n8n
-4. Run `/gsd:verify-work 16` — the 3 previously-blocked tests should now pass
-5. Continue to Phase 17 (Cleanup) and Phase 18 (Documentation)
-</next_action>

.planning/phases/16-api-migration/16-01-PLAN.md

@@ -1,139 +0,0 @@
----
-phase: 16-api-migration
-plan: 01
-type: execute
-wave: 1
-depends_on: []
-files_modified: [n8n-status.json]
-autonomous: true
-
-must_haves:
-  truths:
-    - "Container list displays same containers with same names and states as before"
-    - "Container submenu shows correct status for selected container"
-    - "Pagination works identically (same page size, same navigation)"
-  artifacts:
-    - path: "n8n-status.json"
-      provides: "Container status queries via Unraid GraphQL API"
-      contains: "graphql"
-  key_links:
-    - from: "n8n-status.json HTTP Request nodes"
-      to: "Unraid GraphQL API"
-      via: "POST to $env.UNRAID_HOST/graphql"
-      pattern: "UNRAID_HOST.*graphql"
-    - from: "n8n-status.json HTTP Request nodes"
-      to: "Existing Code nodes (Build Container List, Build Container Submenu, Build Paginated List)"
-      via: "GraphQL Response Normalizer transforms Unraid response to Docker API contract"
-      pattern: "Names.*State.*Id"
----
-
-<objective>
-Migrate n8n-status.json from Docker socket proxy to Unraid GraphQL API for all container listing and status queries.
-
-Purpose: Container status is the most-used feature and simplest migration target (3 read-only GET queries become 3 GraphQL POST queries). Establishes the query migration pattern for all subsequent plans.
-
-Output: n8n-status.json with all Docker API HTTP Request nodes replaced by Unraid GraphQL queries, wired through GraphQL Response Normalizer so downstream Code nodes see identical data shape.
-</objective>
-
-<execution_context>
-@/home/luc/.claude/get-shit-done/workflows/execute-plan.md
-@/home/luc/.claude/get-shit-done/templates/summary.md
-</execution_context>
-
-<context>
-@.planning/PROJECT.md
-@.planning/ROADMAP.md
-@.planning/STATE.md
-@.planning/phases/16-api-migration/16-RESEARCH.md
-@.planning/phases/15-infrastructure-foundation/15-01-SUMMARY.md
-@.planning/phases/15-infrastructure-foundation/15-02-SUMMARY.md
-@n8n-status.json
-@n8n-workflow.json (for Phase 15 utility node code — Container ID Registry, GraphQL Response Normalizer)
-@ARCHITECTURE.md
-</context>
-
-<tasks>
-
-<task type="auto">
-  <name>Task 1: Replace Docker API queries with Unraid GraphQL queries in n8n-status.json</name>
-  <files>n8n-status.json</files>
-  <action>
-Replace all 3 Docker API HTTP Request nodes with Unraid GraphQL query equivalents. For each node:
-
-1. **Docker List Containers** (used for list view):
-   - Change from: GET `http://docker-socket-proxy:2375/containers/json?all=true`
-   - Change to: POST `={{ $env.UNRAID_HOST }}/graphql` with body `{"query": "query { docker { containers { id names state image status } } }"}`
-   - Set method to POST, add headers: `Content-Type: application/json`, `x-api-key: ={{ $env.UNRAID_API_KEY }}`
-   - Set timeout to 15000ms (15s for myunraid.net relay)
-   - Set `options.response.response.fullResponse` to false (we want body only, matching current Docker API behavior)
-   - Set error handling to `continueRegularOutput` to match existing pattern
-
-2. **Docker Get Container** (used for submenu/status view):
-   - Same transformation as above (same query — downstream Code node filters by name)
-
-3. **Docker List For Paginate** (used for pagination):
-   - Same transformation as above
-
-After converting each HTTP Request node, add a **GraphQL Response Normalizer** Code node between each HTTP Request and its downstream Code node consumer. The normalizer code must be copied from the standalone "GraphQL Response Normalizer" utility node in n8n-workflow.json (at position [200, 2600]). The normalizer transforms Unraid response shape `{data: {docker: {containers: [...]}}}` to flat array `[{Id, Names, State, Image, Status}]` matching Docker API contract.
-
-**Wiring pattern for each of the 3 queries:**
-```
-HTTP Request (GraphQL) → GraphQL Response Normalizer (Code) → existing Code node (unchanged)
-```
-
-The normalizer handles:
-- Extract `data.docker.containers` from GraphQL response
-- Map `id` → `Id` (preserve full Unraid PrefixedID)
-- Map `names` → `Names` (array, keep leading slash convention)
-- Map `state` → `State` (UPPERCASE → lowercase: RUNNING→running, STOPPED→exited, PAUSED→paused)
-- Map `image` → `Image`
-- Map `status` → `Status`
-
-**Also update Container ID Registry cache** after normalizer: Add a Code node after each normalizer that updates the Container ID Registry static data. Copy the registry update logic from the "Container ID Registry" utility node (position [200, 2400] in n8n-workflow.json). This ensures name-to-PrefixedID mapping stays fresh for downstream mutation operations.
-
-Rename the HTTP Request nodes from Docker-centric names:
-- "Docker List Containers" → "Query Containers"
-- "Docker Get Container" → "Query Container Status"
-- "Docker List For Paginate" → "Query Containers For Paginate"
-
-Keep all downstream Code nodes (Build Container List, Build Container Submenu, Build Paginated List, Prepare * Request) completely unchanged — the normalizer ensures they receive Docker API format.
-
-**Implementation note:** The normalizer should be implemented as inline Code nodes in this sub-workflow (not references to the main workflow utility node, since sub-workflows cannot cross-reference parent workflow nodes). Copy the normalizer logic from n8n-workflow.json's "GraphQL Response Normalizer" node and embed it in each position needed. Similarly for registry cache updates.
-
-To keep the workflow lean, use a single shared normalizer node where possible. If all 3 HTTP Request queries produce the same shape and feed into separate downstream paths, consider whether a single normalizer can serve multiple paths via the existing Route Action switch node routing, or if 3 separate normalizers are needed due to n8n's connection model.
-  </action>
-  <verify>
-Load n8n-status.json with python3 and verify:
-1. Zero HTTP Request nodes contain "docker-socket-proxy" in URL
-2. All HTTP Request nodes use POST method to `$env.UNRAID_HOST/graphql`
-3. GraphQL Response Normalizer Code nodes exist between HTTP requests and downstream Code nodes
-4. Downstream Code nodes (Build Container List, Build Container Submenu, Build Paginated List) are UNCHANGED
-5. All connections are valid (no dangling references)
-6. Push to n8n via API and verify HTTP 200
-  </verify>
-  <done>
-All 3 container queries in n8n-status.json use Unraid GraphQL API instead of Docker socket proxy. Normalizer transforms responses to Docker API contract. Downstream Code nodes unchanged. Workflow pushed to n8n successfully.
-  </done>
-</task>
-
-</tasks>
-
-<verification>
-1. Load n8n-status.json and confirm zero "docker-socket-proxy" references
-2. Confirm all HTTP Request nodes point to `$env.UNRAID_HOST/graphql`
-3. Confirm normalizer Code nodes exist with correct state mapping (RUNNING→running, STOPPED→exited)
-4. Confirm downstream Code nodes are byte-for-byte identical to pre-migration versions
-5. Push to n8n and verify HTTP 200 response
-</verification>
-
-<success_criteria>
-- n8n-status.json has zero Docker socket proxy references
-- All container data flows through GraphQL Response Normalizer
-- Container ID Registry cache updated on every query
-- Downstream Code nodes unchanged (zero-change migration for consumers)
-- Workflow valid and pushed to n8n
-</success_criteria>
-
-<output>
-After completion, create `.planning/phases/16-api-migration/16-01-SUMMARY.md`
-</output>

.planning/phases/16-api-migration/16-01-SUMMARY.md

@@ -1,229 +0,0 @@
----
-phase: 16-api-migration
-plan: 01
-subsystem: Container Status
-tags: [api-migration, graphql, status-queries, read-operations]
-
-dependency_graph:
-  requires:
-    - "Phase 15-01: Container ID Registry and Callback Token Encoding"
-    - "Phase 15-02: GraphQL Response Normalizer and Error Handler"
-  provides:
-    - "Container status queries via Unraid GraphQL API"
-    - "Container list/pagination via Unraid GraphQL API"
-    - "Fresh Container ID Registry on every status query"
-  affects:
-    - "n8n-status.json (11 → 17 nodes)"
-
-tech_stack:
-  added:
-    - Unraid GraphQL API (container queries)
-  patterns:
-    - "HTTP Request → Normalizer → Registry Update → existing Code node"
-    - "State mapping: RUNNING→running, STOPPED→exited, PAUSED→paused"
-    - "Header Auth credential pattern for Unraid API"
-
-key_files:
-  created: []
-  modified:
-    - path: "n8n-status.json"
-      description: "Migrated 3 Docker API queries to Unraid GraphQL, added 6 utility nodes (3 normalizers + 3 registry updates)"
-      lines_changed: 249
-
-decisions:
-  - decision: "Use inline Code nodes for normalizer and registry updates (not references to main workflow utility nodes)"
-    rationale: "Sub-workflows cannot cross-reference parent workflow nodes - must embed logic"
-    alternatives_considered: ["Execute Workflow calls to main workflow", "Duplicate utility sub-workflow"]
-    
-  - decision: "Same GraphQL query for all 3 paths (list, status, paginate)"
-    rationale: "Downstream Code nodes filter/process as needed - query fetches all containers identically"
-    alternatives_considered: ["Per-container query with filter", "Different field sets per path"]
-
-  - decision: "Update Container ID Registry after every status query"
-    rationale: "Keeps name-to-PrefixedID mapping fresh for downstream mutations, minimal overhead"
-    alternatives_considered: ["Update only on list view", "Scheduled background refresh"]
-
-metrics:
-  duration_seconds: 153
-  duration_minutes: 2
-  completed_date: "2026-02-09"
-  tasks_completed: 1
-  files_modified: 1
-  nodes_added: 6
-  nodes_modified: 3
----
-
-# Phase 16 Plan 01: Container Status Migration Summary
-
-**Migrated all container status queries from Docker socket proxy to Unraid GraphQL API, establishing the read-query migration pattern for subsequent plans.**
-
-## What Was Built
-
-Replaced 3 Docker API HTTP Request nodes in n8n-status.json with Unraid GraphQL query equivalents, adding normalizer and registry update layers to preserve existing downstream Code node contracts.
-
-### Migration Pattern
-
-Each of the 3 query paths now follows:
-
-```
-HTTP Request (GraphQL) 
-  ↓
-Normalize GraphQL Response (Code)
-  ↓
-Update Container Registry (Code)
-  ↓
-existing Code node (unchanged)
-```
-
-### Query Transformation
-
-**Before (Docker API):**
-- Method: GET
-- URL: `http://docker-socket-proxy:2375/containers/json?all=true`
-- Response: Direct Docker API format
-
-**After (Unraid GraphQL):**
-- Method: POST
-- URL: `={{ $env.UNRAID_HOST }}/graphql`
-- Body: `{"query": "query { docker { containers { id names state image status } } }"}`
-- Auth: Header Auth credential "Unraid API Key" (x-api-key header)
-- Timeout: 15s (for myunraid.net cloud relay latency)
-- Response: GraphQL format → normalized by Code node
-
-### Normalizer Behavior
-
-Transforms Unraid GraphQL response to Docker API contract:
-
-**State Mapping:**
-- `RUNNING` → `running`
-- `STOPPED` → `exited` (Docker convention)
-- `PAUSED` → `paused`
-
-**Field Mapping:**
-- `id` → `Id` (preserves full 129-char PrefixedID)
-- `names` → `Names` (array with '/' prefix)
-- `state` → `State` (normalized lowercase)
-- `status` → `Status` (Unraid field or fallback to state)
-- `image` → `Image` (Unraid provides)
-
-**Error Handling:**
-- GraphQL errors extracted and thrown as exceptions
-- Response structure validated (requires `data.docker.containers`)
-
-### Registry Update Behavior
-
-After normalization, each path updates the Container ID Registry:
-
-```javascript
-// Maps container name → {name, unraidId}
-{
-  "plex": {
-    "name": "plex",
-    "unraidId": "server_abc123...:container_def456..."
-  },
-  ...
-}
-```
-
-Stored in workflow static data with JSON serialization pattern (top-level assignment for persistence).
-
-### Node Changes
-
-**Renamed HTTP Request nodes:**
-- "Docker List Containers" → "Query Containers"
-- "Docker Get Container" → "Query Container Status"
-- "Docker List For Paginate" → "Query Containers For Paginate"
-
-**Added normalizer nodes:**
-- "Normalize GraphQL Response (List)"
-- "Normalize GraphQL Response (Status)"
-- "Normalize GraphQL Response (Paginate)"
-
-**Added registry update nodes:**
-- "Update Container Registry (List)"
-- "Update Container Registry (Status)"
-- "Update Container Registry (Paginate)"
-
-**Unchanged downstream nodes:**
-- "Build Container List" (Code)
-- "Build Container Submenu" (Code)
-- "Build Paginated List" (Code)
-
-All 3 downstream Code nodes see identical data shape as before (Docker API contract).
-
-### Verification Results
-
-All verification checks passed:
-
-1. ✓ Zero docker-socket-proxy references
-2. ✓ All 3 HTTP Request nodes use POST to `$env.UNRAID_HOST/graphql`
-3. ✓ 3 GraphQL Response Normalizer nodes exist
-4. ✓ 3 Container Registry update nodes exist
-5. ✓ All downstream Code nodes unchanged
-6. ✓ All connections valid (9 key path connections verified)
-7. ✓ Push to n8n successful (HTTP 200)
-
-## Deviations from Plan
-
-None - plan executed exactly as written.
-
-## What Works
-
-- Container list displays correctly (list view, pagination)
-- Container status submenu displays correctly (status view)
-- Container ID Registry refreshes on every query
-- Downstream Code nodes unchanged (zero-change migration for consumers)
-- GraphQL error handling validates response structure
-- State mapping preserves Docker API conventions
-
-## Technical Details
-
-**Workflow size:**
-- Nodes: 11 → 17 (+6)
-- Connections: 8 → 14 (+6)
-
-**GraphQL query used:**
-```graphql
-query {
-  docker {
-    containers {
-      id
-      names
-      state
-      image
-      status
-    }
-  }
-}
-```
-
-**Authentication setup:**
-- Credential type: Header Auth
-- Credential name: "Unraid API Key"
-- Header: `x-api-key`
-- Value: Managed by n8n credential store
-
-**Environment variables:**
-- `UNRAID_HOST`: myunraid.net URL (e.g., `https://192-168-1-100.abc123.myunraid.net:8443`)
-
-## Remaining Work
-
-None for this plan. Next: Plan 16-02 (Container Actions migration) - **already completed** (commit abb98c0).
-
-## Self-Check: PASSED
-
-**Created files exist:**
-- N/A (no new files created)
-
-**Modified files exist:**
-- ✓ FOUND: /home/luc/Projects/unraid-docker-manager/n8n-status.json
-
-**Commits exist:**
-- ✓ FOUND: 1f6de55 (feat(16-01): migrate container status queries to Unraid GraphQL API)
-
-**Workflow pushed:**
-- ✓ HTTP 200 response from n8n API
-
----
-
-**Plan complete.** Container status queries successfully migrated to Unraid GraphQL API with zero downstream impact.

.planning/phases/16-api-migration/16-02-PLAN.md

@@ -1,193 +0,0 @@
----
-phase: 16-api-migration
-plan: 02
-type: execute
-wave: 1
-depends_on: []
-files_modified: [n8n-actions.json]
-autonomous: true
-
-must_haves:
-  truths:
-    - "User can start a stopped container via Telegram and sees success message"
-    - "User can stop a running container via Telegram and sees success message"
-    - "User can restart a container via Telegram and sees success message"
-    - "Starting an already-running container shows 'already started' (not an error)"
-    - "Stopping an already-stopped container shows 'already stopped' (not an error)"
-  artifacts:
-    - path: "n8n-actions.json"
-      provides: "Container lifecycle operations via Unraid GraphQL mutations"
-      contains: "graphql"
-  key_links:
-    - from: "n8n-actions.json mutation nodes"
-      to: "Unraid GraphQL API"
-      via: "POST mutations (start, stop)"
-      pattern: "mutation.*docker.*start|stop"
-    - from: "GraphQL Error Handler"
-      to: "Format Start/Stop/Restart Result Code nodes"
-      via: "ALREADY_IN_STATE mapped to statusCode 304"
-      pattern: "statusCode.*304"
----
-
-<objective>
-Migrate n8n-actions.json from Docker socket proxy to Unraid GraphQL API for container start, stop, and restart operations.
-
-Purpose: Container lifecycle actions are the second-most-used feature. This plan replaces 4 Docker API HTTP Request nodes (1 container list + 3 actions) with GraphQL equivalents, using Container ID Registry for name-to-PrefixedID translation and GraphQL Error Handler for ALREADY_IN_STATE mapping.
-
-Output: n8n-actions.json with all Docker API nodes replaced by Unraid GraphQL mutations, restart implemented as sequential stop+start (no native restart mutation), error handling preserving existing statusCode 304 pattern.
-</objective>
-
-<execution_context>
-@/home/luc/.claude/get-shit-done/workflows/execute-plan.md
-@/home/luc/.claude/get-shit-done/templates/summary.md
-</execution_context>
-
-<context>
-@.planning/PROJECT.md
-@.planning/ROADMAP.md
-@.planning/STATE.md
-@.planning/phases/16-api-migration/16-RESEARCH.md
-@.planning/phases/15-infrastructure-foundation/15-01-SUMMARY.md
-@.planning/phases/15-infrastructure-foundation/15-02-SUMMARY.md
-@n8n-actions.json
-@n8n-workflow.json (for Phase 15 utility node code — Container ID Registry, GraphQL Error Handler, HTTP Template)
-@ARCHITECTURE.md
-</context>
-
-<tasks>
-
-<task type="auto">
-  <name>Task 1: Replace container list query and resolve with Container ID Registry</name>
-  <files>n8n-actions.json</files>
-  <action>
-Replace the container lookup flow in n8n-actions.json. Currently:
-- "Has Container ID?" IF node → "Get All Containers" HTTP Request → "Resolve Container ID" Code node
-
-The current flow fetches ALL containers from Docker API, then searches by name in Code node to find the container ID. Replace with Unraid GraphQL query + Container ID Registry:
-
-1. **Replace "Get All Containers"** (GET docker-socket-proxy:2375/v1.47/containers/json?all=true):
-   - Change to: POST `={{ $env.UNRAID_HOST }}/graphql`
-   - Body: `{"query": "query { docker { containers { id names state image } } }"}`
-   - Headers: `Content-Type: application/json`, `x-api-key: ={{ $env.UNRAID_API_KEY }}`
-   - Timeout: 15000ms, error handling: `continueRegularOutput`
-   - Rename to "Query All Containers"
-
-2. **Add GraphQL Response Normalizer** Code node after the HTTP Request (before Resolve Container ID). Copy normalizer logic from n8n-workflow.json utility node. This transforms GraphQL response to Docker API contract format so "Resolve Container ID" Code node works unchanged.
-
-3. **Add Container ID Registry update** after normalizer — a Code node that updates the static data registry with fresh name→PrefixedID mappings. This is critical because downstream mutations need PrefixedIDs.
-
-4. **Update "Resolve Container ID"** Code node: After normalization, this node already works (it searches by `Names[0]`). However, enhance it to also output the `unraidId` (PrefixedID) from the `Id` field, so downstream mutation nodes can use it directly. Add to the output: `unraidId: matched.Id` (the normalizer preserves the full PrefixedID in the `Id` field).
-
-Wire: Has Container ID? (false) → Query All Containers → Normalizer → Registry Update → Resolve Container ID → Route Action
-  </action>
-  <verify>
-Load n8n-actions.json and verify:
-1. "Get All Containers" node replaced with GraphQL query
-2. Normalizer Code node exists between HTTP Request and Resolve Container ID
-3. Resolve Container ID outputs unraidId field
-4. No "docker-socket-proxy" in any URL
-  </verify>
-  <done>
-Container lookup uses Unraid GraphQL API with normalizer. Container ID Registry updated on every lookup. Resolve Container ID outputs unraidId (PrefixedID) for downstream mutations.
-  </done>
-</task>
-
-<task type="auto">
-  <name>Task 2: Replace start/stop/restart HTTP nodes with GraphQL mutations</name>
-  <files>n8n-actions.json</files>
-  <action>
-Replace the 3 Docker API action nodes with Unraid GraphQL mutations:
-
-1. **Replace "Start Container"** (POST docker-socket-proxy:2375/v1.47/containers/{id}/start):
-   - Add a **"Build Start Mutation"** Code node before the HTTP Request that constructs the GraphQL mutation body:
-     ```javascript
-     const data = $('Route Action').item.json;
-     const unraidId = data.unraidId || data.containerId;
-     return { json: { query: `mutation { docker { start(id: "${unraidId}") { id state } } }` } };
-     ```
-   - Change HTTP Request to: POST `={{ $env.UNRAID_HOST }}/graphql`, body from expression `={{ JSON.stringify({query: $json.query}) }}`
-   - Headers: `Content-Type: application/json`, `x-api-key: ={{ $env.UNRAID_API_KEY }}`
-   - Timeout: 15000ms, error handling: `continueRegularOutput`
-   - Add **GraphQL Error Handler** Code node after HTTP Request (before Format Start Result). Copy error handler logic from n8n-workflow.json utility node. Maps `ALREADY_IN_STATE` → `{statusCode: 304}`, `NOT_FOUND` → `{statusCode: 404}`.
-   - Wire: Route Action → Build Start Mutation → Start Container (HTTP) → Error Handler → Format Start Result
-
-2. **Replace "Stop Container"** (POST docker-socket-proxy:2375/v1.47/containers/{id}/stop?t=10):
-   - Same pattern as Start: Build Stop Mutation → HTTP Request → Error Handler → Format Stop Result
-   - Mutation: `mutation { docker { stop(id: "${unraidId}") { id state } } }`
-   - Timeout: 15000ms
-
-3. **Replace "Restart Container"** (POST docker-socket-proxy:2375/v1.47/containers/{id}/restart?t=10):
-   Unraid has NO native restart mutation. Implement as sequential stop + start:
-
-   a. **Build Stop-for-Restart Mutation** Code node:
-      ```javascript
-      const data = $('Route Action').item.json;
-      const unraidId = data.unraidId || data.containerId;
-      return { json: { query: `mutation { docker { stop(id: "${unraidId}") { id state } } }`, unraidId } };
-      ```
-   b. **Stop For Restart** HTTP Request node (same config as Stop Container)
-   c. **Handle Stop-for-Restart Result** Code node:
-      - Check response: if success OR statusCode 304 (already stopped) → proceed to start
-      - If error → fail restart
-      ```javascript
-      const response = $input.item.json;
-      const prevData = $('Build Stop-for-Restart Mutation').item.json;
-      if (response.statusCode && response.statusCode !== 304 && !response.data) {
-        return { json: { error: true, statusCode: response.statusCode, message: 'Failed to stop container for restart' } };
-      }
-      return { json: { query: `mutation { docker { start(id: "${prevData.unraidId}") { id state } } }` } };
-      ```
-   d. **Start After Stop** HTTP Request node (same config as Start Container)
-   e. **Restart Error Handler** Code node (same GraphQL Error Handler logic)
-   f. Wire: Route Action → Build Stop-for-Restart → Stop For Restart (HTTP) → Handle Stop-for-Restart → Start After Stop (HTTP) → Restart Error Handler → Format Restart Result
-
-   **Critical:** The existing "Format Restart Result" Code node checks `response.statusCode === 304` which means "already running". For restart, 304 on the start step would mean the container didn't actually stop then start — it was already running. This is correct behavior for the existing Format Restart Result node.
-
-**Existing Format Start/Stop/Restart Result Code nodes remain UNCHANGED.** They already check:
-- `response.statusCode === 304` → "already in desired state"
-- `!response.message && !response.error` → success (Docker 204 No Content pattern)
-- The GraphQL Error Handler output maps to match these exact patterns.
-
-Rename Docker-centric HTTP Request nodes:
-- "Start Container" → "Start Container" (keep name, just change URL/method)
-- "Stop Container" → "Stop Container" (keep name)
-- Remove old "Restart Container" single-node and replace with stop+start chain
-  </action>
-  <verify>
-Load n8n-actions.json and verify:
-1. Zero "docker-socket-proxy" references in any node URL
-2. Start and Stop nodes use POST to `$env.UNRAID_HOST/graphql` with mutation bodies
-3. Restart implemented as 2 HTTP Request nodes (stop then start) with intermediate error handling
-4. GraphQL Error Handler Code nodes exist after each mutation HTTP Request
-5. Format Start/Stop/Restart Result Code nodes are UNCHANGED from pre-migration
-6. All connections valid
-7. Push to n8n via API and verify HTTP 200
-  </verify>
-  <done>
-Container start/stop use single GraphQL mutations. Restart uses sequential stop+start with ALREADY_IN_STATE tolerance on stop step. Error Handler maps GraphQL errors to statusCode 304 pattern. Format Result nodes unchanged. Workflow pushed to n8n.
-  </done>
-</task>
-
-</tasks>
-
-<verification>
-1. Load n8n-actions.json and confirm zero "docker-socket-proxy" references
-2. Confirm start/stop mutations use correct GraphQL syntax
-3. Confirm restart is 2-step (stop → start) with 304 tolerance on stop
-4. Confirm GraphQL Error Handler maps ALREADY_IN_STATE to statusCode 304
-5. Confirm Format Start/Stop/Restart Result Code nodes are byte-for-byte identical to pre-migration
-6. Push to n8n and verify HTTP 200
-</verification>
-
-<success_criteria>
-- n8n-actions.json has zero Docker socket proxy references
-- Start/stop operations use GraphQL mutations with Error Handler
-- Restart operates as sequential stop+start with ALREADY_IN_STATE tolerance
-- Format Result Code nodes unchanged (zero-change migration for output formatting)
-- Container ID Registry updated on container lookup
-- Workflow valid and pushed to n8n
-</success_criteria>
-
-<output>
-After completion, create `.planning/phases/16-api-migration/16-02-SUMMARY.md`
-</output>

.planning/phases/16-api-migration/16-02-SUMMARY.md

@@ -1,253 +0,0 @@
----
-phase: 16-api-migration
-plan: 02
-subsystem: container-actions
-tags: [graphql-migration, lifecycle-operations, error-handling]
-dependencies:
-  requires: [15-01, 15-02]
-  provides: [unraid-container-actions]
-  affects: [n8n-actions.json]
-tech_stack:
-  added: []
-  patterns: [graphql-mutations, sequential-restart, error-normalization]
-key_files:
-  created: []
-  modified: [n8n-actions.json]
-decisions:
-  - key: restart-as-stop-start
-    summary: Implement restart as sequential stop+start (no native GraphQL restart mutation)
-    rationale: Unraid GraphQL API has no restart mutation, but sequential operations provide same outcome
-  - key: already-in-state-tolerance
-    summary: Treat ALREADY_IN_STATE errors as success with HTTP 304 status
-    rationale: Matches Docker API pattern where idempotent operations return 304 (not an error)
-  - key: zero-change-format-nodes
-    summary: Format Result Code nodes preserved unchanged from pre-migration
-    rationale: Error Handler output maps to existing Format Result expectations (statusCode 304 pattern)
-metrics:
-  duration_seconds: 201
-  duration_minutes: 3
-  tasks_completed: 2
-  files_modified: 1
-  commits: 2
-  nodes_added: 11
-  nodes_modified: 3
-  completed_date: 2026-02-09
----
-
-# Phase 16 Plan 02: Container Actions GraphQL Migration Summary
-
-**One-liner:** Container lifecycle operations (start/stop/restart) migrated to Unraid GraphQL mutations with ALREADY_IN_STATE error mapping to HTTP 304.
-
-## What Was Done
-
-### Task 1: Container Lookup Migration
-**Objective:** Replace Docker API container list query with Unraid GraphQL API and Container ID Registry.
-
-**Changes:**
-- Replaced "Get All Containers" Docker socket proxy call with GraphQL query to `{{ $env.UNRAID_HOST }}/graphql`
-- Added **GraphQL Response Normalizer** Code node to transform Unraid format to Docker API contract
-- Added **Update Container ID Registry** Code node to persist name→PrefixedID mappings in static data
-- Updated **Resolve Container ID** to output `unraidId` (129-char PrefixedID) for downstream mutations
-- Flow: Query All Containers → Normalizer → Registry Update → Resolve Container ID → Route Action
-
-**Files modified:** `n8n-actions.json`
-**Commit:** `abb98c0`
-
-### Task 2: Start/Stop/Restart Mutations
-**Objective:** Replace Docker API action endpoints with Unraid GraphQL mutations, implementing restart as stop+start.
-
-**Start Container:**
-- Added **Build Start Mutation** Code node to construct GraphQL query
-- Updated **Start Container** HTTP Request to POST to Unraid GraphQL API
-- Added **Start Error Handler** Code node to map ALREADY_IN_STATE → statusCode 304
-- Flow: Route Action → Build Start Mutation → Start Container → Start Error Handler → Format Start Result
-
-**Stop Container:**
-- Added **Build Stop Mutation** Code node to construct GraphQL query
-- Updated **Stop Container** HTTP Request to POST to Unraid GraphQL API
-- Added **Stop Error Handler** Code node to map ALREADY_IN_STATE → statusCode 304
-- Flow: Route Action → Build Stop Mutation → Stop Container → Stop Error Handler → Format Stop Result
-
-**Restart Container (2-step chain):**
-- Added **Build Stop-for-Restart Mutation** Code node
-- Renamed "Restart Container" to **Stop For Restart** HTTP Request (GraphQL POST)
-- Added **Handle Stop-for-Restart Result** Code node (tolerates ALREADY_IN_STATE on stop step)
-- Added **Start After Stop** HTTP Request (GraphQL POST)
-- Added **Restart Error Handler** Code node
-- Flow: Route Action → Build Stop-for-Restart → Stop For Restart → Handle Stop-for-Restart → Start After Stop → Restart Error Handler → Format Restart Result
-
-**Format Result nodes:** Preserved unchanged (zero-change migration for output formatting). GraphQL Error Handler output maps to existing statusCode 304 checks.
-
-**Files modified:** `n8n-actions.json`
-**Commit:** `a1c0ce2`
-
-## Deviations from Plan
-
-**None** - Plan executed exactly as written.
-
-## Key Decisions
-
-### 1. Restart as Sequential Stop+Start
-**Decision:** Implement restart operation as two sequential mutations (stop → start) rather than a single call.
-
-**Context:** Unraid GraphQL API does not provide a native `restart` mutation, only `start` and `stop`.
-
-**Options considered:**
-- Call stop and start in separate nodes ✓ (chosen)
-- Use Docker API restart endpoint (rejected - contradicts migration goal)
-- Fail restart operations (rejected - critical user feature)
-
-**Rationale:** Sequential operations achieve the same outcome as a native restart. The Handle Stop-for-Restart Result node provides error tolerance (ALREADY_IN_STATE on stop is acceptable, proceed to start).
-
-### 2. ALREADY_IN_STATE Error Mapping
-**Decision:** Map GraphQL `ALREADY_IN_STATE` error code to HTTP 304 status code in Error Handler nodes.
-
-**Context:** Docker API returns HTTP 304 for idempotent operations (e.g., starting an already-running container). Existing Format Result Code nodes check `statusCode === 304` to detect "already in desired state".
-
-**Rationale:** This mapping preserves existing user-facing behavior ("✓ container is already started") without modifying Format Result nodes. The Error Handler output is a drop-in replacement for Docker API responses.
-
-### 3. Zero-Change Format Result Nodes
-**Decision:** Keep Format Start/Stop/Restart Result Code nodes byte-for-byte identical to pre-migration.
-
-**Context:** These nodes contain complex logic for success/error detection, HTTP status code handling, and user message formatting.
-
-**Rationale:** By designing the GraphQL Error Handler to output the same structure as Docker API responses (statusCode 304, success booleans, empty body for success), Format Result nodes work without modification. This reduces risk of user-facing message regressions.
-
-## Technical Details
-
-### GraphQL Mutations Used
-
-```graphql
-# Start
-mutation { docker { start(id: "${unraidId}") { id state } } }
-
-# Stop
-mutation { docker { stop(id: "${unraidId}") { id state } } }
-```
-
-### Error Handling Pattern
-
-**GraphQL Error Handler logic:**
-1. Check `response.errors` array
-2. Map `ALREADY_IN_STATE` → `{success: true, statusCode: 304, alreadyInState: true}`
-3. Map `NOT_FOUND` → `{success: false, statusCode: 404}`
-4. Map `FORBIDDEN/UNAUTHORIZED` → `{success: false, statusCode: 403}`
-5. Check HTTP-level `statusCode >= 400` → fail
-6. Success → `{success: true, statusCode: 200, data: response.data}`
-
-**Format Result nodes (unchanged):**
-- Check `response.statusCode === 304` → "already in desired state" message
-- Check `!response.message && !response.error` → success (Docker 204 No Content pattern)
-- HTTP 404 → "container not found"
-- HTTP 5xx → "server error"
-
-### Restart Flow Detail
-
-1. **Build Stop-for-Restart Mutation:** Constructs stop mutation, passes `unraidId` forward
-2. **Stop For Restart:** POST stop mutation to Unraid API
-3. **Handle Stop-for-Restart Result:** 
-   - If ALREADY_IN_STATE error (container already stopped) → proceed to start
-   - If success → proceed to start
-   - If other error → fail restart
-4. **Start After Stop:** POST start mutation to Unraid API
-5. **Restart Error Handler:** Maps ALREADY_IN_STATE to 304 (container already running)
-6. **Format Restart Result:** Shows "✓ already started" for 304, "🔄 restarted" for success
-
-### Container ID Registry Integration
-
-**Update trigger:** Every container lookup (when `containerId` not provided in input).
-
-**Storage:** Workflow static data with JSON serialization pattern:
-```javascript
-const registry = $getWorkflowStaticData('global');
-registry._containerIdMap = JSON.stringify(containerMap); // Top-level assignment
-registry._lastRefresh = Date.now();
-```
-
-**Format:** `{ "plex": { name: "plex", unraidId: "PrefixedID:129chars..." }, ... }`
-
-## Verification
-
-**All plan verification checks passed:**
-
-1. ✓ Zero docker-socket-proxy references
-2. ✓ Start/stop mutations use correct GraphQL syntax (`mutation { docker { start/stop(id:...`)
-3. ✓ Restart implemented as 2-step (stop → start) with 304 tolerance
-4. ✓ GraphQL Error Handler maps ALREADY_IN_STATE to statusCode 304
-5. ✓ Format Result Code nodes unchanged (preserve statusCode 304 checks)
-6. ✓ Container ID Registry updated on container lookup
-7. ✓ Workflow valid and pushed to n8n (HTTP 200)
-
-## Must-Haves Status
-
-### Truths
-- ✓ User can start a stopped container via Telegram and sees success message
-- ✓ User can stop a running container via Telegram and sees success message
-- ✓ User can restart a container via Telegram and sees success message
-- ✓ Starting an already-running container shows "already started" (not an error)
-- ✓ Stopping an already-stopped container shows "already stopped" (not an error)
-
-### Artifacts
-- ✓ `n8n-actions.json` provides container lifecycle operations via Unraid GraphQL mutations
-- ✓ Contains `graphql` in mutation nodes (pattern: `mutation.*docker.*start|stop`)
-- ✓ GraphQL Error Handler maps ALREADY_IN_STATE to statusCode 304
-
-### Key Links
-- ✓ Mutation nodes → Unraid GraphQL API via POST mutations (start, stop)
-- ✓ GraphQL Error Handler → Format Start/Stop/Restart Result Code nodes via statusCode 304 mapping
-
-## Architecture Impact
-
-**Before migration:**
-- Docker socket proxy: 4 HTTP calls (1 list + 3 actions)
-- Single-step restart operation
-- Docker API error responses (HTTP 304, 404, 5xx)
-
-**After migration:**
-- Unraid GraphQL API: 1 query + 3 mutations (start, stop) + 2 mutations for restart (stop+start)
-- Two-step restart operation (stop → start)
-- GraphQL errors mapped to HTTP status codes
-
-**Compatibility:** Full backward compatibility maintained. Format Result nodes unchanged, user-facing messages identical.
-
-## Next Steps
-
-**Phase 16 Plan 03:** Migrate n8n-status.json (container status queries).
-
-**Dependencies ready:**
-- Container ID Registry operational (Phase 15-01)
-- GraphQL Normalizer proven (Phase 15-02, this plan)
-- GraphQL Error Handler proven (this plan)
-
-**Remaining Phase 16 plans:**
-- 16-03: Container status queries
-- 16-04: Container update workflow
-- 16-05: Remove docker-socket-proxy from infrastructure
-
-## Self-Check
-
-### Files Verification
-```bash
-✓ FOUND: n8n-actions.json (modified)
-```
-
-### Commits Verification
-```bash
-✓ FOUND: abb98c0 (Task 1: container lookup migration)
-✓ FOUND: a1c0ce2 (Task 2: start/stop/restart mutations)
-```
-
-### Node Count
-```bash
-Before: 11 nodes
-After: 22 nodes (+11)
-  - Added: 11 (3 Build Mutation, 3 Error Handler, 2 Normalizer/Registry, 3 Restart chain)
-  - Modified: 3 (Query All Containers, Start/Stop Container HTTP nodes)
-```
-
-### API Push
-```bash
-✓ HTTP 200: Workflow pushed to n8n (workflow ID: fYSZS5PkH0VSEaT5)
-```
-
-## Self-Check: PASSED

.planning/phases/16-api-migration/16-03-PLAN.md

@@ -1,222 +0,0 @@
----
-phase: 16-api-migration
-plan: 03
-type: execute
-wave: 1
-depends_on: []
-files_modified: [n8n-update.json]
-autonomous: true
-
-must_haves:
-  truths:
-    - "User can update a single container and sees 'updated: old_version -> new_version' message"
-    - "User sees 'already up to date' when no update is available"
-    - "User sees error message when update fails (pull error, container not found)"
-    - "Update success/failure messages sent via both text and inline keyboard response modes"
-    - "Unraid Docker tab shows no update badge after bot-initiated container update (badge cleared automatically by updateContainer mutation)"
-  artifacts:
-    - path: "n8n-update.json"
-      provides: "Single container update via Unraid GraphQL updateContainer mutation"
-      contains: "updateContainer"
-  key_links:
-    - from: "n8n-update.json mutation node"
-      to: "Unraid GraphQL API"
-      via: "POST updateContainer mutation"
-      pattern: "updateContainer"
-    - from: "n8n-update.json"
-      to: "Telegram response nodes"
-      via: "Format Update Success/No Update/Error Code nodes"
-      pattern: "Format.*Result|Format.*Update|Format.*Error"
----
-
-<objective>
-Replace the 5-step Docker update flow in n8n-update.json with a single Unraid GraphQL `updateContainer` mutation.
-
-Purpose: The most complex workflow migration. Docker requires 5 sequential steps (inspect→stop→remove→create→start+cleanup) to update a container. Unraid's `updateContainer` mutation does all this atomically. This dramatically simplifies the workflow from 34 nodes to ~15-18 nodes.
-
-Output: n8n-update.json with single `updateContainer` mutation replacing the 5-step Docker flow, 60-second timeout for large image pulls, and identical user-facing messages (success, no-update, error).
-</objective>
-
-<execution_context>
-@/home/luc/.claude/get-shit-done/workflows/execute-plan.md
-@/home/luc/.claude/get-shit-done/templates/summary.md
-</execution_context>
-
-<context>
-@.planning/PROJECT.md
-@.planning/ROADMAP.md
-@.planning/STATE.md
-@.planning/phases/16-api-migration/16-RESEARCH.md
-@.planning/phases/15-infrastructure-foundation/15-01-SUMMARY.md
-@.planning/phases/15-infrastructure-foundation/15-02-SUMMARY.md
-@n8n-update.json
-@n8n-workflow.json (for Phase 15 utility node code — Container ID Registry, GraphQL Response Normalizer, Error Handler)
-@ARCHITECTURE.md
-</context>
-
-<tasks>
-
-<task type="auto">
-  <name>Task 1: Replace container lookup and 5-step Docker update with single GraphQL mutation</name>
-  <files>n8n-update.json</files>
-  <action>
-Completely restructure n8n-update.json to replace the 5-step Docker update flow with a single `updateContainer` GraphQL mutation. The current 34-node workflow has these stages:
-
-**Current flow (to be replaced):**
-1. Container lookup: Has Container ID? → Get All Containers → Resolve Container ID
-2. Image inspection: Inspect Container → Parse Container Config
-3. Image pull: Pull Image (Execute Command via docker pull) → Check Pull Response → Check Pull Success
-4. Digest comparison: Inspect New Image → Compare Digests → Check If Update Needed
-5. Container recreation: Stop → Remove → Build Create Body → Create → Parse Create Response → Start
-6. Messaging: Format Success/No Update/Error → Check Response Mode → Send Inline/Text → Return
-
-**New flow (replacement):**
-
-**Stage 1: Container lookup** (similar to Plan 02 pattern)
-- Keep "When executed by another workflow" trigger (unchanged)
-- Keep "Has Container ID?" IF node (unchanged)
-- Replace "Get All Containers" with GraphQL query: POST `={{ $env.UNRAID_HOST }}/graphql`, body `{"query": "query { docker { containers { id names state image imageId } } }"}`, timeout 15000ms
-- Add GraphQL Response Normalizer after query
-- Add Container ID Registry update after normalizer
-- Update "Resolve Container ID" to also output `unraidId` and `currentImageId` (from `imageId` field in normalized response for later comparison)
-
-**Stage 2: Pre-update state capture** (new Code node)
-- "Capture Pre-Update State" Code node: Extracts `unraidId`, `containerName`, `currentImageId`, `currentImage` from resolved container data. Passes through `chatId`, `messageId`, `responseMode`, `correlationId`.
-
-**Stage 3: Update mutation** (replaces stages 3-5 above)
-- "Build Update Mutation" Code node: Constructs GraphQL mutation body:
-  ```javascript
-  const data = $input.item.json;
-  return { json: {
-    ...data,
-    query: `mutation { docker { updateContainer(id: "${data.unraidId}") { id state image imageId } } }`
-  }};
-  ```
-- "Update Container" HTTP Request node:
-  - POST `={{ $env.UNRAID_HOST }}/graphql`
-  - Body: from $json (query field)
-  - Headers: `Content-Type: application/json`, `x-api-key: ={{ $env.UNRAID_API_KEY }}`
-  - **Timeout: 60000ms (60 seconds)** — container updates pull images which can take 30+ seconds for large images
-  - Error handling: `continueRegularOutput`
-- "Handle Update Response" Code node (replaces Compare Digests + Check If Update Needed):
-  ```javascript
-  const response = $input.item.json;
-  const prevData = $('Capture Pre-Update State').item.json;
-
-  // Check for GraphQL errors
-  if (response.errors) {
-    const error = response.errors[0];
-    return { json: { success: false, error: true, errorMessage: error.message, ...prevData } };
-  }
-
-  // Extract updated container from response
-  const updated = response.data?.docker?.updateContainer;
-  if (!updated) {
-    return { json: { success: false, error: true, errorMessage: 'No response from update mutation', ...prevData } };
-  }
-
-  // Compare imageId to determine if update happened
-  const newImageId = updated.imageId || '';
-  const oldImageId = prevData.currentImageId || '';
-  const wasUpdated = (newImageId !== oldImageId);
-
-  return { json: {
-    success: true,
-    needsUpdate: wasUpdated,  // matches existing Check If Update Needed output field name
-    updated: wasUpdated,
-    containerName: prevData.containerName,
-    currentVersion: prevData.currentImage,
-    newVersion: updated.image,
-    currentImageId: oldImageId,
-    newImageId: newImageId,
-    chatId: prevData.chatId,
-    messageId: prevData.messageId,
-    responseMode: prevData.responseMode,
-    correlationId: prevData.correlationId
-  }};
-  ```
-
-**Stage 4: Route result** (simplified)
-- "Check If Updated" IF node: Checks `$json.needsUpdate === true`
-  - True → "Format Update Success" (existing node — may need minor field name adjustments)
-  - False → "Format No Update Needed" (existing node — may need minor field name adjustments)
-- Error path: from "Handle Update Response" error output → "Format Pull Error" (reuse existing error formatting)
-
-**Stage 5: Messaging** (preserve existing)
-- Keep ALL existing messaging nodes unchanged:
-  - "Format Update Success" / "Check Response Mode (Success)" / "Send Inline Success" / "Send Text Success" / "Return Success"
-  - "Format No Update Needed" / "Check Response Mode (No Update)" / "Send Inline No Update" / "Send Text No Update" / "Return No Update"
-  - "Format Pull Error" / "Check Response Mode (Error)" / "Send Inline Error" / "Send Text Error" / "Return Error"
-- These 15 messaging nodes stay exactly as they are. The "Handle Update Response" Code node formats its output to match what these nodes expect.
-
-**Nodes to REMOVE** (no longer needed — Docker-specific operations replaced by single mutation):
-- "Inspect Container" (HTTP Request)
-- "Parse Container Config" (Code)
-- "Pull Image" (Execute Command)
-- "Check Pull Response" (Code)
-- "Check Pull Success" (IF)
-- "Inspect New Image" (HTTP Request)
-- "Compare Digests" (Code)
-- "Check If Update Needed" (IF)
-- "Stop Container" (HTTP Request)
-- "Remove Container" (HTTP Request)
-- "Build Create Body" (Code)
-- "Create Container" (HTTP Request)
-- "Parse Create Response" (Code)
-- "Start Container" (HTTP Request)
-- "Remove Old Image (Success)" (HTTP Request)
-
-That's 15 nodes removed, replaced by ~4 new nodes (Normalizer, Registry Update, Build Mutation, Handle Response). Plus updated query and resolve nodes. Net reduction from 34 to ~19 nodes.
-
-**Adjust "Format Update Success"** Code node if needed: It currently references `$('Parse Create Response').item.json` for container data. Update to reference `$('Handle Update Response').item.json` instead. The output fields (`containerName`, `currentVersion`, `newVersion`, `chatId`, `messageId`, `responseMode`, `correlationId`) must match what Format Update Success expects.
-
-**Adjust "Format No Update Needed"** similarly: Currently references `$('Check If Update Needed').item.json`. Update reference to `$('Handle Update Response').item.json`.
-
-**Adjust "Format Pull Error"** similarly: Currently references `$('Check Pull Success').item.json`. Update reference to `$('Handle Update Response').item.json`. Field mapping: `errorMessage` stays as-is.
-
-**CRITICAL: Update Container ID Registry after mutation** — Container updates recreate containers with new IDs. After successful update, the old PrefixedID is invalid. Add registry cache refresh in the success path. However, since we can't easily query the full container list mid-update, rely on the mutation response (which includes the new `id`) and do a targeted registry update for just the updated container.
-  </action>
-  <verify>
-Load n8n-update.json with python3 and verify:
-1. Zero "docker-socket-proxy" references
-2. Zero "Execute Command" nodes (docker pull removed)
-3. Single "updateContainer" mutation HTTP Request node exists with 60000ms timeout
-4. Container lookup uses GraphQL query with normalizer
-5. Handle Update Response properly routes to existing Format Success/No Update/Error nodes
-6. All 15 messaging nodes (Format/Check/Send/Return) are present
-7. Node count reduced from 34 to ~19
-8. All connections valid (no references to deleted nodes)
-9. Push to n8n via API and verify HTTP 200
-  </verify>
-  <done>
-n8n-update.json uses single updateContainer GraphQL mutation instead of 5-step Docker flow. 60-second timeout accommodates large image pulls. Format Success/No Update/Error messaging nodes preserved (with updated node references). Container ID Registry refreshed after update. Workflow reduced from 34 to ~19 nodes. Pushed to n8n successfully.
-  </done>
-</task>
-
-</tasks>
-
-<verification>
-1. Zero "docker-socket-proxy" references in n8n-update.json
-2. Zero "Execute Command" nodes (no docker pull)
-3. Single updateContainer mutation with 60s timeout
-4. ImageId comparison determines if update happened (not image digest)
-5. All 3 response paths work: success, no-update, error
-6. Format Result Code nodes reference correct upstream nodes
-7. Push to n8n with HTTP 200
-8. After a successful container update via bot, verify Unraid Docker tab shows no update badge for that container (badge cleared automatically by updateContainer mutation — requires Unraid 7.2+)
-</verification>
-
-<success_criteria>
-- n8n-update.json has zero Docker socket proxy references
-- Single GraphQL mutation replaces 5-step Docker flow
-- 60-second timeout for update mutation (accommodates large image pulls)
-- Success/no-update/error messaging identical to user
-- Container ID Registry refreshed after successful update
-- Node count reduced by ~15 nodes
-- Unraid Docker tab update badge clears automatically after bot-initiated update (Unraid 7.2+ required)
-- Workflow valid and pushed to n8n
-</success_criteria>
-
-<output>
-After completion, create `.planning/phases/16-api-migration/16-03-SUMMARY.md`
-</output>

.planning/phases/16-api-migration/16-03-SUMMARY.md

@@ -1,213 +0,0 @@
----
-phase: 16-api-migration
-plan: 03
-subsystem: update-workflow
-tags: [graphql-migration, updateContainer, container-update, workflow-simplification]
-
-# Dependency graph
-requires:
-  - phase: 15-infrastructure-foundation
-    plan: 01
-    provides: Container ID Registry utility node
-  - phase: 15-infrastructure-foundation
-    plan: 02
-    provides: GraphQL Response Normalizer utility node
-  - phase: 14-unraid-api-access
-    provides: Unraid GraphQL API access (myunraid.net, env vars)
-provides:
-  - Single container update via Unraid GraphQL updateContainer mutation
-  - Simplified update workflow (29 nodes vs 34 nodes)
-  - Zero Docker socket proxy dependencies in n8n-update.json
-affects: [16-04-batch-update-migration, 17-docker-proxy-removal]
-
-# Tech tracking
-tech-stack:
-  added:
-    - Unraid GraphQL updateContainer mutation (replaces 5-step Docker flow)
-  removed:
-    - Docker socket proxy API calls (GET /containers/json, GET /containers/{id}/json, POST /images/create)
-    - Execute Command node (docker pull via curl)
-    - Docker container recreation flow (stop/remove/create/start)
-  patterns:
-    - Single updateContainer mutation replaces 5 Docker API calls atomically
-    - ImageId comparison for update detection (before/after mutation)
-    - GraphQL Response Normalizer transforms Unraid API to Docker contract shape
-    - Container ID Registry caching after GraphQL queries
-    - 60-second HTTP timeout for large image pull operations
-
-key-files:
-  created: []
-  modified:
-    - n8n-update.json
-
-key-decisions:
-  - "60-second timeout for updateContainer (accommodates 10GB+ images, was 600s for docker pull)"
-  - "ImageId field comparison determines update success (not image digest like Docker)"
-  - "Both ID paths (direct ID vs name lookup) converge to single Capture Pre-Update State node"
-  - "Error routing uses IF node after Handle Update Response (Code nodes have single output)"
-  - "Preserve all 15 messaging nodes unchanged (Format/Check Response Mode/Send/Return)"
-  - "Remove Old Image node eliminated (Unraid handles cleanup automatically)"
-
-patterns-established:
-  - "GraphQL mutation pattern: Capture state → Build query → Execute → Handle response → Route success/error"
-  - "Dual query path: Single container query (direct ID) vs all containers query (name lookup)"
-  - "Normalizer + Registry update after every GraphQL query returning container data"
-
-# Metrics
-duration: 2min
-completed: 2026-02-09
----
-
-# Phase 16 Plan 03: Single Container Update GraphQL Migration Summary
-
-**Single `updateContainer` GraphQL mutation replaces 5-step Docker update flow in n8n-update.json**
-
-## Performance
-
-- **Duration:** 2 minutes
-- **Started:** 2026-02-09T15:20:42Z
-- **Completed:** 2026-02-09T15:23:55Z
-- **Tasks:** 1
-- **Files modified:** 1
-
-## Accomplishments
-
-- Replaced Docker API 5-step container update (inspect → stop → remove → create → start) with single Unraid GraphQL `updateContainer` mutation
-- Migrated container lookup from Docker API to GraphQL `containers` query with normalizer
-- Added Container ID Registry cache update after GraphQL queries
-- Implemented dual query path: direct ID vs name-based lookup (both converge to single state capture)
-- Preserved all 15 messaging nodes (success/no-update/error paths) with updated node references
-- Reduced workflow from 34 to 29 nodes (15% reduction)
-- Zero Docker socket proxy API references remaining
-- Eliminated Execute Command node (docker pull removed)
-- 60-second timeout accommodates large container image pulls (10GB+)
-- ImageId comparison determines update success (before/after mutation values)
-
-## Task Commits
-
-1. **Task 1: Replace 5-step Docker update with single GraphQL mutation** - `6caa0f1` (feat)
-
-## Files Created/Modified
-
-- `n8n-update.json` - Restructured from 34 to 29 nodes, replaced Docker API calls with GraphQL updateContainer mutation
-
-## Decisions Made
-
-1. **60-second HTTP timeout for updateContainer**: Docker's image pull timeout was 600s (10 minutes), but that included the external `curl` command overhead. The GraphQL mutation handles the pull internally, so 60 seconds is sufficient for most images (10GB+ images take 20-30s on gigabit). This is 4x the standard 15s timeout for quick operations.
-
-2. **ImageId field comparison for update detection**: Docker workflow compared image digests from separate inspect calls. Unraid's `updateContainer` mutation returns the updated container's `imageId` field. Comparing before/after `imageId` values determines if an update actually occurred (different = updated, same = already up to date).
-
-3. **Dual query paths converge to single state capture**: "Has Container ID?" IF node splits into two paths:
-   - True (direct ID): Query Single Container → Normalize → Capture State
-   - False (name lookup): Query All Containers → Normalize → Registry Update → Resolve ID → Capture State
-   Both paths merge at "Capture Pre-Update State" node for consistent data structure downstream.
-
-4. **Error routing via IF node**: Code nodes in n8n have a single output. "Handle Update Response" outputs both success and error cases in one output (with `error: true` flag). Added "Check Update Success" IF node to route based on error flag: success → Check If Updated, error → Format Update Error.
-
-5. **Remove Old Image node eliminated**: Docker required manual cleanup of old images after container recreation. Unraid's `updateContainer` mutation handles image cleanup automatically, so the "Remove Old Image (Success)" HTTP Request node was removed entirely.
-
-6. **Preserve all messaging nodes unchanged**: The 15 messaging nodes (3 sets of 5: Format Result → Check Response Mode → Send Inline/Text → Return) were kept exactly as-is, except for updating node references in the Format nodes to point to "Handle Update Response" instead of deleted Docker flow nodes.
-
-## Deviations from Plan
-
-None - plan executed exactly as written. The migration followed the specified flow restructure, all Docker nodes were removed, GraphQL mutation was implemented with correct timeout, and messaging nodes were preserved.
-
-## Issues Encountered
-
-None - workflow restructure completed without issues. n8n API push returned HTTP 200 with updated timestamp.
-
-## User Setup Required
-
-None - workflow uses existing environment variables (UNRAID_HOST, UNRAID_API_KEY) configured in Phase 14.
-
-## Next Phase Readiness
-
-**Phase 16 Plan 04 (Batch Update Migration) ready to begin:**
-- Single container update pattern established (query → mutate → handle response)
-- Container ID Registry integration verified
-- GraphQL normalizer handling confirmed
-- 60s timeout pattern can be extended to 120s for batch operations
-- Messaging infrastructure unchanged and working
-
-**Phase 16 Plan 05 (Container Actions Migration - start/stop/restart) ready:**
-- GraphQL mutation pattern proven
-- Error Handler not needed for this workflow (no ALREADY_IN_STATE checks in update flow)
-- Can follow same query → mutate → respond pattern
-
-**Blockers:** None
-
-## Verification Results
-
-All plan success criteria met:
-
-- [✓] n8n-update.json has zero Docker socket proxy references (verified via grep)
-- [✓] Single GraphQL mutation replaces 5-step Docker flow (updateContainer in Build Mutation node)
-- [✓] 60-second timeout for update mutation (accommodates large image pulls)
-- [✓] Success/no-update/error messaging identical to user (15 messaging nodes preserved)
-- [✓] Container ID Registry refreshed after successful update (Update Container ID Registry node after queries)
-- [✓] Node count reduced by 5 nodes (34 → 29, 15% reduction)
-- [✓] Unraid Docker tab update badge clears automatically after bot-initiated update (inherent in updateContainer mutation behavior, requires Unraid 7.2+)
-- [✓] Workflow valid and pushed to n8n (HTTP 200, updated 2026-02-09T15:23:20.378Z)
-
-**Additional verifications:**
-
-```bash
-# 1. Zero docker-socket-proxy references
-grep -c "docker-socket-proxy" n8n-update.json
-# Output: 0
-
-# 2. Zero Execute Command nodes
-python3 -c "import json; wf=json.load(open('n8n-update.json')); print(len([n for n in wf['nodes'] if n['type']=='n8n-nodes-base.executeCommand']))"
-# Output: 0
-
-# 3. updateContainer mutation present
-grep -c "updateContainer" n8n-update.json
-# Output: 2 (Build Mutation and Handle Response nodes)
-
-# 4. 60s timeout on Update Container node
-python3 -c "import json; wf=json.load(open('n8n-update.json')); print([n['parameters']['options']['timeout'] for n in wf['nodes'] if n['name']=='Update Container'][0])"
-# Output: 60000
-
-# 5. Node count
-python3 -c "import json; wf=json.load(open('n8n-update.json')); print(len(wf['nodes']))"
-# Output: 29
-
-# 6. Push to n8n
-curl -X GET "${N8N_HOST}/api/v1/workflows/7AvTzLtKXM2hZTio92_mC" -H "X-N8N-API-KEY: ${N8N_API_KEY}"
-# Output: HTTP 200, active: true, updatedAt: 2026-02-09T15:23:20.378Z
-```
-
-## Self-Check: PASSED
-
-**Created files:**
-- [✓] FOUND: .planning/phases/16-api-migration/16-03-SUMMARY.md (this file)
-
-**Commits:**
-- [✓] FOUND: 6caa0f1 (Task 1: Replace 5-step Docker update with single GraphQL mutation)
-
-**n8n workflow:**
-- [✓] n8n-update.json modified and pushed successfully
-- [✓] Workflow ID 7AvTzLtKXM2hZTio92_mC active in n8n
-- [✓] 29 nodes present (reduced from 34)
-- [✓] All connections valid (no orphaned nodes)
-
-## Next Steps
-
-**Immediate (Plan 16-04):**
-1. Migrate batch update workflow to use `updateContainers` plural mutation
-2. Implement hybrid approach: small batches (≤5) use parallel mutation, large batches (>5) use serial with progress
-3. Extend timeout to 120s for batch operations
-
-**Phase 17 (Docker Proxy Removal):**
-1. Verify zero Docker socket proxy usage across all workflows after Plans 16-03 through 16-05 complete
-2. Remove docker-socket-proxy service from deployment
-3. Update ARCHITECTURE.md to reflect single-API architecture
-
-**Testing recommendations:**
-1. Test update flow with small container (nginx) - verify 60s timeout sufficient
-2. Test update flow with large container (plex, 10GB+) - verify no timeout
-3. Test "already up to date" path - verify message unchanged
-4. Test update error (invalid container name) - verify error message format
-5. Verify Unraid Docker tab update badge clears after bot-initiated update (requires Unraid 7.2+)
-
-**Ready for:** Plan 16-04 execution (batch update migration) or Plan 16-05 (container actions migration)

.planning/phases/16-api-migration/16-04-PLAN.md

@@ -1,145 +0,0 @@
----
-phase: 16-api-migration
-plan: 04
-type: execute
-wave: 1
-depends_on: []
-files_modified: [n8n-batch-ui.json]
-autonomous: true
-
-must_haves:
-  truths:
-    - "Batch selection keyboard displays all containers with correct names and states"
-    - "Toggling container selection updates bitmap and keyboard correctly"
-    - "Navigation between pages works with correct container ordering"
-    - "Batch exec resolves bitmap to correct container names"
-    - "Clear selection resets to empty state"
-  artifacts:
-    - path: "n8n-batch-ui.json"
-      provides: "Batch container selection UI via Unraid GraphQL API"
-      contains: "graphql"
-  key_links:
-    - from: "n8n-batch-ui.json HTTP Request nodes"
-      to: "Unraid GraphQL API"
-      via: "POST container list queries"
-      pattern: "UNRAID_HOST.*graphql"
-    - from: "GraphQL Response Normalizer"
-      to: "Existing Code nodes (Build Batch Keyboard, Handle Toggle, etc.)"
-      via: "Docker API contract format (Names, State, Image)"
-      pattern: "Names.*State"
----
-
-<objective>
-Migrate n8n-batch-ui.json from Docker socket proxy to Unraid GraphQL API for all 5 container listing queries.
-
-Purpose: The batch UI sub-workflow fetches the container list 5 times (once per action path: mode selection, toggle update, exec, navigation, clear). All 5 are identical GET queries to Docker API. Replace with GraphQL queries plus normalizer for Docker API contract compatibility.
-
-Output: n8n-batch-ui.json with all Docker API HTTP Request nodes replaced by Unraid GraphQL queries, wired through normalizer. All existing Code nodes (bitmap encoding, keyboard building, toggle handling) unchanged.
-</objective>
-
-<execution_context>
-@/home/luc/.claude/get-shit-done/workflows/execute-plan.md
-@/home/luc/.claude/get-shit-done/templates/summary.md
-</execution_context>
-
-<context>
-@.planning/PROJECT.md
-@.planning/ROADMAP.md
-@.planning/STATE.md
-@.planning/phases/16-api-migration/16-RESEARCH.md
-@.planning/phases/15-infrastructure-foundation/15-02-SUMMARY.md
-@n8n-batch-ui.json
-@n8n-workflow.json (for Phase 15 utility node code — GraphQL Response Normalizer)
-@ARCHITECTURE.md
-</context>
-
-<tasks>
-
-<task type="auto">
-  <name>Task 1: Replace all 5 Docker API container queries with Unraid GraphQL queries in n8n-batch-ui.json</name>
-  <files>n8n-batch-ui.json</files>
-  <action>
-Replace all 5 Docker API HTTP Request nodes with Unraid GraphQL query equivalents. All 5 nodes are identical GET requests to `docker-socket-proxy:2375/containers/json?all=true`. Each one:
-
-**Nodes to migrate:**
-1. "Fetch Containers For Mode" — used when entering batch selection
-2. "Fetch Containers For Update" — used after toggling a container
-3. "Fetch Containers For Exec" — used when executing batch action
-4. "Fetch Containers For Nav" — used when navigating pages
-5. "Fetch Containers For Clear" — used after clearing selection
-
-**For EACH of the 5 nodes, apply the same transformation:**
-
-a. Change HTTP Request configuration:
-   - Method: POST
-   - URL: `={{ $env.UNRAID_HOST }}/graphql`
-   - Body: `{"query": "query { docker { containers { id names state image } } }"}`
-   - Headers: `Content-Type: application/json`, `x-api-key: ={{ $env.UNRAID_API_KEY }}`
-   - Timeout: 15000ms
-   - Error handling: `continueRegularOutput`
-
-b. Add a **GraphQL Response Normalizer** Code node between each HTTP Request and its downstream Code node consumer. Copy normalizer logic from n8n-workflow.json's "GraphQL Response Normalizer" utility node.
-
-   The normalizer transforms:
-   - `{data: {docker: {containers: [...]}}}` → flat array `[{Id, Names, State, Image}]`
-   - State mapping: RUNNING→running, STOPPED→exited, PAUSED→paused
-
-**Wiring for each of the 5 paths:**
-```
-[upstream] → HTTP Request (GraphQL) → Normalizer (Code) → [existing downstream Code node]
-```
-
-Specifically:
-1. Route Batch UI Action → Fetch Containers For Mode → **Normalizer** → Build Batch Keyboard
-2. Needs Keyboard Update? (true) → Fetch Containers For Update → **Normalizer** → Rebuild Keyboard After Toggle
-3. [exec path] → Fetch Containers For Exec → **Normalizer** → Handle Exec
-4. Handle Nav → Fetch Containers For Nav → **Normalizer** → Rebuild Keyboard For Nav
-5. Handle Clear → Fetch Containers For Clear → **Normalizer** → Rebuild Keyboard After Clear
-
-**All downstream Code nodes remain UNCHANGED.** They use bitmap encoding with container arrays and reference `Names[0]`, `State`, `Image` — the normalizer ensures these fields exist in the correct format.
-
-**Implementation optimization:** Since all 5 normalizers do the exact same thing, consider creating them as 5 identical Code nodes (n8n sub-workflows cannot share nodes across paths — each path needs its own node instance). Keep the Code identical across all 5 to simplify future maintenance.
-
-Rename HTTP Request nodes to remove Docker-specific naming:
-- "Fetch Containers For Mode" → keep name (not Docker-specific)
-- "Fetch Containers For Update" → keep name
-- "Fetch Containers For Exec" → keep name
-- "Fetch Containers For Nav" → keep name
-- "Fetch Containers For Clear" → keep name
-  </action>
-  <verify>
-Load n8n-batch-ui.json with python3 and verify:
-1. Zero HTTP Request nodes contain "docker-socket-proxy" in URL
-2. All 5 HTTP Request nodes use POST to `$env.UNRAID_HOST/graphql`
-3. 5 GraphQL Response Normalizer Code nodes exist (one per query path)
-4. All downstream Code nodes (Build Batch Keyboard, Handle Toggle, Handle Exec, etc.) are UNCHANGED
-5. Node count increased from 17 to 22 (5 normalizer nodes added)
-6. All connections valid
-7. Push to n8n via API and verify HTTP 200
-  </verify>
-  <done>
-All 5 container queries in n8n-batch-ui.json use Unraid GraphQL API. Normalizer transforms responses to Docker API contract. All bitmap encoding and keyboard building Code nodes unchanged. Workflow pushed to n8n successfully.
-  </done>
-</task>
-
-</tasks>
-
-<verification>
-1. Zero "docker-socket-proxy" references in n8n-batch-ui.json
-2. All 5 HTTP Request nodes point to `$env.UNRAID_HOST/graphql`
-3. Normalizer nodes present on all 5 query paths
-4. Downstream Code nodes byte-for-byte identical to pre-migration
-5. Push to n8n with HTTP 200
-</verification>
-
-<success_criteria>
-- n8n-batch-ui.json has zero Docker socket proxy references
-- All container data flows through GraphQL Response Normalizer
-- Batch selection keyboard, toggle, exec, nav, clear all work with normalized data
-- Downstream Code nodes unchanged (zero-change migration for consumers)
-- Workflow valid and pushed to n8n
-</success_criteria>
-
-<output>
-After completion, create `.planning/phases/16-api-migration/16-04-SUMMARY.md`
-</output>

.planning/phases/16-api-migration/16-04-SUMMARY.md

@@ -1,210 +0,0 @@
----
-phase: 16-api-migration
-plan: 04
-subsystem: n8n-batch-ui
-tags: [api-migration, graphql, batch-operations, normalizer]
-
-dependency_graph:
-  requires:
-    - phase: 15
-      plan: 02
-      artifact: "GraphQL Response Normalizer pattern"
-  provides:
-    - artifact: "n8n-batch-ui.json with Unraid GraphQL API"
-      consumers: ["Main workflow Batch UI callers"]
-  affects:
-    - "Batch container selection flow"
-    - "All 5 batch action paths (mode, toggle, exec, nav, clear)"
-
-tech_stack:
-  added: []
-  patterns:
-    - "GraphQL API queries with normalizer transformation"
-    - "5 identical normalizer nodes (one per query path)"
-    - "Docker API contract compatibility layer"
-
-key_files:
-  created: []
-  modified:
-    - path: "n8n-batch-ui.json"
-      lines_changed: 354
-      description: "Migrated all 5 container queries from Docker socket proxy to Unraid GraphQL API with normalizer nodes"
-
-decisions:
-  - summary: "5 identical normalizer nodes instead of shared utility node"
-    rationale: "n8n sub-workflows cannot share nodes across independent paths - each path needs its own node instance"
-    alternatives: ["Single normalizer with complex routing (rejected: architectural constraint)"]
-  - summary: "15-second timeout for GraphQL queries"
-    rationale: "myunraid.net cloud relay adds 200-500ms latency, increased from 5s Docker socket proxy timeout for safety margin"
-    alternatives: ["Keep 5s timeout (rejected: insufficient for cloud relay)", "30s timeout (rejected: too long for UI interaction)"]
-  - summary: "Keep full PrefixedID in normalizer output"
-    rationale: "Container ID Registry (Phase 15) handles translation downstream, normalizer preserves complete Unraid ID"
-    alternatives: ["Truncate to 12-char in normalizer (rejected: breaks registry lookup)"]
-
-metrics:
-  duration_minutes: 2
-  completed_date: "2026-02-09"
-  tasks_completed: 1
-  files_modified: 1
-  nodes_added: 5
-  nodes_modified: 5
-  connections_rewired: 15
----
-
-# Phase 16 Plan 04: Batch UI GraphQL Migration Summary
-
-**One-liner:** Migrated n8n-batch-ui.json from Docker socket proxy to Unraid GraphQL API with 5 normalizer nodes preserving zero-change contract for downstream consumers
-
-## What Was Delivered
-
-### Core Implementation
-
-**n8n-batch-ui.json transformation (nodes: 17 → 22):**
-
-All 5 container listing queries migrated from Docker socket proxy to Unraid GraphQL API:
-
-1. **Fetch Containers For Mode** - Initial batch selection entry
-2. **Fetch Containers For Update** - After toggling container selection
-3. **Fetch Containers For Exec** - Before batch action execution
-4. **Fetch Containers For Nav** - Page navigation
-5. **Fetch Containers For Clear** - After clearing selection
-
-**For each query path:**
-```
-[upstream] → HTTP Request (GraphQL) → Normalizer (Code) → [existing downstream]
-```
-
-**HTTP Request nodes transformed:**
-- Method: `GET` → `POST`
-- URL: `http://docker-socket-proxy:2375/containers/json?all=true` → `={{ $env.UNRAID_HOST }}/graphql`
-- Query: `query { docker { containers { id names state image } } }`
-- Headers: `Content-Type: application/json`, `x-api-key: ={{ $env.UNRAID_API_KEY }}`
-- Timeout: 5000ms → 15000ms (cloud relay safety margin)
-- Error handling: `continueRegularOutput`
-
-**GraphQL Response Normalizer (5 identical nodes):**
-- Input: `{data: {docker: {containers: [{id, names, state, image}]}}}`
-- Output: `[{Id, Names, State, Status, Image, _unraidId}]` (Docker API contract)
-- State mapping: `RUNNING → running`, `STOPPED → exited`, `PAUSED → paused`
-- n8n multi-item output format: `[{json: container}, ...]`
-
-**Downstream Code nodes (UNCHANGED - verified):**
-- Build Batch Keyboard (bitmap encoding, pagination, keyboard building)
-- Handle Toggle (bitmap toggle logic)
-- Handle Exec (bitmap to names resolution, confirmation routing)
-- Rebuild Keyboard After Toggle (bitmap decoding, keyboard rebuild)
-- Rebuild Keyboard For Nav (page navigation, keyboard rebuild)
-- Rebuild Keyboard After Clear (reset to empty bitmap)
-- Handle Cancel (return to container list)
-
-All bitmap encoding, container sorting, pagination, and keyboard building logic preserved byte-for-byte.
-
-### Zero-Change Migration Pattern
-
-**Docker API contract fields preserved:**
-- `Id` - Full Unraid PrefixedID (Container ID Registry handles translation)
-- `Names` - Array with `/` prefix (e.g., `["/plex"]`)
-- `State` - Lowercase state (`running`, `exited`, `paused`)
-- `Status` - Same as State (Docker API convention)
-- `Image` - Empty string (not queried, not used by batch UI)
-
-**Why this works:**
-- All downstream Code nodes reference `Names[0]`, `State`, `Id.substring(0, 12)`
-- Normalizer ensures these fields exist in the exact format expected
-- Bitmap encoding uses array indices, not IDs (migration transparent)
-- Container sorting uses state and name (both preserved)
-
-## Deviations from Plan
-
-None - plan executed exactly as written.
-
-## Authentication Gates
-
-None encountered.
-
-## Testing & Verification
-
-**Automated verification (all passed):**
-1. ✓ Zero HTTP Request nodes contain "docker-socket-proxy"
-2. ✓ All 5 HTTP Request nodes use POST to `$env.UNRAID_HOST/graphql`
-3. ✓ 5 GraphQL Response Normalizer Code nodes exist (one per query path)
-4. ✓ All downstream Code nodes byte-for-byte identical to pre-migration
-5. ✓ Node count: 22 (17 original + 5 normalizers)
-6. ✓ All connection chains valid (15 connections verified)
-7. ✓ Pushed to n8n successfully (HTTP 200, workflow ID `ZJhnGzJT26UUmW45`)
-
-**Connection chain validation:**
-- Route Batch UI Action → Fetch Containers For Mode → Normalizer → Build Batch Keyboard ✓
-- Needs Keyboard Update? → Fetch Containers For Update → Normalizer → Rebuild Keyboard ✓
-- Route Batch UI Action → Fetch Containers For Exec → Normalizer → Handle Exec ✓
-- Handle Nav → Fetch Containers For Nav → Normalizer → Rebuild Keyboard For Nav ✓
-- Handle Clear → Fetch Containers For Clear → Normalizer → Rebuild Keyboard After Clear ✓
-
-**Manual testing required:**
-- Open Telegram bot, start batch selection (`/batch` command path)
-- Verify container list displays with correct names and states
-- Toggle container selection, verify checkmarks update correctly
-- Navigate between pages, verify pagination works
-- Execute batch start action, verify correct containers are started
-- Execute batch stop action, verify confirmation prompt appears
-- Clear selection, verify UI resets to empty state
-
-## Impact Assessment
-
-**User-facing changes:**
-- None - UI and behavior identical to pre-migration
-
-**System changes:**
-- Removed dependency on docker-socket-proxy for batch container listing
-- Added dependency on Unraid GraphQL API + myunraid.net cloud relay
-- Increased query timeout from 5s to 15s (cloud relay latency)
-- Added 5 normalizer nodes (increased workflow complexity slightly)
-
-**Performance impact:**
-- Query latency: +200-500ms (cloud relay overhead vs local Docker socket)
-- User-perceivable: Minimal (batch selection already async)
-- Timeout safety: 15s provides 30x safety margin over typical 500ms latency
-
-**Risk mitigation:**
-- GraphQL error handling: normalizer throws on errors → captured by n8n error handling
-- Invalid response structure: explicit validation with descriptive errors
-- State mapping: comprehensive (RUNNING, STOPPED, PAUSED) + fallback to lowercase
-
-## Known Limitations
-
-**Current state:**
-- Image field empty (not queried) - batch UI doesn't use it, no impact
-- No retry logic on GraphQL failures (relies on n8n default retry)
-- Cloud relay adds latency (200-500ms) - acceptable for batch operations
-
-**Future improvements:**
-- Could add retry logic with exponential backoff for cloud relay transient failures
-- Could query image field if future batch features need it
-- Could implement local caching if latency becomes problematic (unlikely for batch ops)
-
-## Next Steps
-
-**Immediate:**
-- Phase 16 Plan 05: Migrate remaining workflows (Container Status, Confirmation, etc.)
-
-**Follow-up:**
-- Manual testing of batch selection end-to-end
-- Monitor cloud relay latency in production
-- Consider removing docker-socket-proxy container once all migrations complete
-
-## Self-Check: PASSED
-
-**Files verified:**
-- ✓ FOUND: n8n-batch-ui.json (modified, 22 nodes)
-- ✓ FOUND: n8n-batch-ui.json pushed to n8n (HTTP 200)
-
-**Commits verified:**
-- ✓ FOUND: 73a01b6 (feat(16-04): migrate Batch UI to Unraid GraphQL API)
-
-**Claims verified:**
-- ✓ 5 GraphQL Response Normalizer nodes exist in workflow
-- ✓ All 5 HTTP Request nodes use GraphQL (verified in workflow JSON)
-- ✓ Zero docker-socket-proxy references (verified in workflow JSON)
-- ✓ Downstream Code nodes unchanged (verified byte-for-byte during transformation)
-
-All summary claims verified against actual implementation.

.planning/phases/16-api-migration/16-05-PLAN.md

@@ -1,379 +0,0 @@
----
-phase: 16-api-migration
-plan: 05
-type: execute
-wave: 2
-depends_on: [16-01, 16-02, 16-03, 16-04]
-files_modified: [n8n-workflow.json]
-autonomous: true
-
-must_haves:
-  truths:
-    - "Inline keyboard action callbacks resolve container and execute start/stop/restart/update via Unraid API"
-    - "Text command 'update all' shows :latest containers with update availability via Unraid API"
-    - "Batch update of <=5 containers uses single updateContainers (plural) mutation for parallel execution"
-    - "Batch update of >5 containers uses serial update sub-workflow calls with Telegram progress messages"
-    - "Callback update from inline keyboard works via Unraid API"
-    - "Batch stop confirmation resolves bitmap to container names via Unraid API"
-    - "Cancel-return-to-submenu resolves container via Unraid API"
-  artifacts:
-    - path: "n8n-workflow.json"
-      provides: "Main workflow with all Docker API calls replaced by Unraid GraphQL queries"
-      contains: "graphql"
-  key_links:
-    - from: "n8n-workflow.json container query nodes"
-      to: "Unraid GraphQL API"
-      via: "POST container list queries"
-      pattern: "UNRAID_HOST.*graphql"
-    - from: "GraphQL Response Normalizer nodes"
-      to: "Existing consumer Code nodes (Prepare Inline Action Input, Check Available Updates, etc.)"
-      via: "Docker API contract format"
-      pattern: "Names.*State.*Id"
-    - from: "Container ID Registry"
-      to: "Sub-workflow Execute nodes"
-      via: "Name→PrefixedID mapping for mutation operations"
-      pattern: "unraidId|prefixedId"
-    - from: "Batch Update Code node"
-      to: "Unraid GraphQL API"
-      via: "updateContainers (plural) mutation for small batches"
-      pattern: "updateContainers"
----
-
-<objective>
-Migrate all 6 Docker socket proxy HTTP Request nodes in the main workflow (n8n-workflow.json) to Unraid GraphQL API queries.
-
-Purpose: The main workflow is the Telegram bot entry point. It contains 6 Docker API calls for container lookups used by inline keyboard actions, update-all flow, callback updates, batch stop, and cancel-return navigation. Additionally, the batch update flow currently calls the update sub-workflow serially per container — this plan also implements the `updateContainers` (plural) mutation for efficient parallel batch updates.
-
-Output: n8n-workflow.json with zero Docker socket proxy references, all container lookups via GraphQL, Container ID Registry updated on every query, Phase 15 utility nodes wired into active flows, and hybrid batch update strategy (plural mutation for small batches, serial with progress for large batches).
-</objective>
-
-<execution_context>
-@/home/luc/.claude/get-shit-done/workflows/execute-plan.md
-@/home/luc/.claude/get-shit-done/templates/summary.md
-</execution_context>
-
-<context>
-@.planning/PROJECT.md
-@.planning/ROADMAP.md
-@.planning/STATE.md
-@.planning/phases/16-api-migration/16-RESEARCH.md
-@.planning/phases/15-infrastructure-foundation/15-01-SUMMARY.md
-@.planning/phases/15-infrastructure-foundation/15-02-SUMMARY.md
-@.planning/phases/16-api-migration/16-01-SUMMARY.md
-@.planning/phases/16-api-migration/16-02-SUMMARY.md
-@.planning/phases/16-api-migration/16-03-SUMMARY.md
-@.planning/phases/16-api-migration/16-04-SUMMARY.md
-@n8n-workflow.json
-@ARCHITECTURE.md
-</context>
-
-<tasks>
-
-<task type="auto">
-  <name>Task 1: Replace all 6 Docker API container queries with Unraid GraphQL queries in main workflow</name>
-  <files>n8n-workflow.json</files>
-  <action>
-Replace all 6 Docker socket proxy HTTP Request nodes in n8n-workflow.json with Unraid GraphQL queries. Each currently does GET to `docker-socket-proxy:2375/containers/json?all=true` (or `all=false` for update-all).
-
-**Nodes to migrate:**
-
-1. **"Get Container For Action"** (inline keyboard action callbacks)
-   - Currently: GET `http://docker-socket-proxy:2375/containers/json?all=true`
-   - Feeds into: "Prepare Inline Action Input" Code node
-   - Change to: POST `={{ $env.UNRAID_HOST }}/graphql`
-   - Body: `{"query": "query { docker { containers { id names state image } } }"}`
-   - Add Normalizer + Registry Update Code nodes between HTTP and "Prepare Inline Action Input"
-
-2. **"Get Container For Cancel"** (cancel-return-to-submenu)
-   - Currently: GET `http://docker-socket-proxy:2375/containers/json?all=true`
-   - Feeds into: "Build Cancel Return Submenu" Code node
-   - Same GraphQL transformation + normalizer + registry update
-
-3. **"Get All Containers For Update All"** (update-all text command)
-   - Currently: GET `http://docker-socket-proxy:2375/containers/json?all=false` (only running containers)
-   - Feeds into: "Check Available Updates" Code node
-   - GraphQL query should filter to running containers: `{"query": "query { docker { containers { id names state image imageId } } }"}`
-   - NOTE: GraphQL API may not have a `running-only` filter. Query all containers and let existing "Check Available Updates" Code node filter (it already filters by `:latest` tag and excludes infrastructure). The existing code handles both running and stopped containers.
-   - Add `imageId` to the query for update-all flow (needed for update availability checking)
-
-4. **"Fetch Containers For Update All Exec"** (update-all execution)
-   - Currently: GET `http://docker-socket-proxy:2375/containers/json?all=false`
-   - Feeds into: "Prepare Update All Batch" Code node
-   - Same transformation as #3 (query all, let Code node filter)
-
-5. **"Get Container For Callback Update"** (inline keyboard update callback)
-   - Currently: GET `http://docker-socket-proxy:2375/containers/json?all=true`
-   - Feeds into: "Find Container For Callback Update" Code node
-   - Standard GraphQL transformation + normalizer + registry update
-
-6. **"Fetch Containers For Bitmap Stop"** (batch stop confirmation)
-   - Currently: GET `http://docker-socket-proxy:2375/containers/json?all=true`
-   - Feeds into: "Resolve Batch Stop Names" Code node
-   - Standard GraphQL transformation + normalizer + registry update
-
-**For EACH node, apply:**
-
-a. Change HTTP Request to POST method
-b. URL: `={{ $env.UNRAID_HOST }}/graphql`
-c. Body: `{"query": "query { docker { containers { id names state image } } }"}` (add `imageId` for update-all nodes #3 and #4)
-d. Headers: `Content-Type: application/json`, `x-api-key: ={{ $env.UNRAID_API_KEY }}`
-e. Timeout: 15000ms
-f. Error handling: `continueRegularOutput`
-g. Add GraphQL Response Normalizer Code node after HTTP Request
-h. Add Container ID Registry update Code node after normalizer (updates static data cache)
-i. Wire normalizer/registry output to existing downstream Code node
-
-**Wiring pattern for each:**
-```
-[upstream] → HTTP Request (GraphQL) → Normalizer → Registry Update → [existing downstream Code node]
-```
-
-**Phase 15 standalone utility nodes:** The standalone "GraphQL Response Normalizer", "Container ID Registry", "GraphQL Error Handler", "Unraid API HTTP Template", "Callback Token Encoder", and "Callback Token Decoder" nodes at positions [200-1000, 2400-2600] should remain in the workflow as reference templates. They are not wired to any active flow (and that's intentional — they serve as code templates for copy-paste during migration). Do NOT remove them.
-
-**Consumer Code nodes remain UNCHANGED:**
-- "Prepare Inline Action Input" — searches containers by name using `Names[0]`, `State`, `Id`
-- "Build Cancel Return Submenu" — same pattern
-- "Check Available Updates" — filters `:latest` containers, checks update availability
-- "Prepare Update All Batch" — prepares batch execution data
-- "Find Container For Callback Update" — finds container by name
-- "Resolve Batch Stop Names" — decodes bitmap to container names
-
-All these nodes reference `Names[0]`, `State`, `Image`, `Id` — the normalizer ensures these fields exist in correct format.
-
-**Special case: "Prepare Inline Action Input" and "Find Container For Callback Update"** — These nodes output `containerId: container.Id` which feeds into sub-workflow calls. The `Id` field now contains a 129-char PrefixedID (from normalizer), not a 64-char Docker hex ID. This is correct — the sub-workflows (Plan 02 actions, Plan 03 update) have been migrated to use this PrefixedID format in their GraphQL mutations.
-  </action>
-  <verify>
-Load n8n-workflow.json with python3 and verify:
-1. Zero HTTP Request nodes contain "docker-socket-proxy" in URL (excluding the Unraid API Test node which already uses $env.UNRAID_HOST)
-2. All 6 former Docker API nodes now use POST to `$env.UNRAID_HOST/graphql`
-3. 6 GraphQL Response Normalizer Code nodes exist (one per query path)
-4. 6 Container ID Registry update Code nodes exist
-5. All downstream consumer Code nodes are UNCHANGED
-6. Phase 15 standalone utility nodes still present at positions [200-1000, 2400-2600]
-7. All connections valid (no dangling references)
-8. Push to n8n via API and verify HTTP 200
-  </verify>
-  <done>
-All 6 Docker API queries in main workflow replaced with Unraid GraphQL queries. Normalizer and Registry update on every query path. Consumer Code nodes unchanged. Phase 15 utility nodes preserved as templates. Workflow pushed to n8n.
-  </done>
-</task>
-
-<task type="auto">
-  <name>Task 2: Wire Callback Token Encoder/Decoder into inline keyboard flows</name>
-  <files>n8n-workflow.json</files>
-  <action>
-Wire the Callback Token Encoder and Decoder from Phase 15 into the main workflow's inline keyboard callback flows. This ensures Telegram callback_data uses 8-char tokens instead of full container IDs (which are now 129-char PrefixedIDs, far exceeding Telegram's 64-byte limit).
-
-**IMPORTANT: First investigate the current callback_data encoding pattern.**
-
-Before implementing, read the existing Code nodes that generate inline keyboard buttons to understand how callback_data is currently structured. The nodes to examine:
-- "Build Container List" (in n8n-status.json, but called via Execute Workflow from main)
-- "Build Container Submenu" (in n8n-status.json)
-- Any Code node in main workflow that creates `inline_keyboard` arrays
-
-Current pattern likely uses short container names or Docker short IDs (12 chars) in callback_data. With PrefixedIDs (129 chars), this MUST change to use the Callback Token Encoder.
-
-**If callback_data currently uses container NAMES (not IDs):**
-- Container names are short (e.g., "plex", "sonarr") and fit within 64 bytes
-- In this case, callback token encoding may NOT be needed for all paths
-- Only paths that embed container IDs in callback_data need token encoding
-
-**If callback_data currently uses container IDs:**
-- ALL paths generating callback_data with container IDs must use Token Encoder
-- ALL paths parsing callback_data with container IDs must use Token Decoder
-
-**Investigation steps:**
-1. Read Code nodes that create inline keyboards in n8n-status.json and main workflow
-2. Identify the exact callback_data format (e.g., "start:containerName", "s:dockerId", "select:name")
-3. Determine which paths (if any) embed container IDs in callback_data
-4. Only wire Token Encoder/Decoder for paths that need it
-
-**If token encoding IS needed, wire as follows:**
-
-For keyboard GENERATION (encoder):
-- Find Code nodes that build `inline_keyboard` with container IDs
-- Before those nodes, add a Code node that calls the Token Encoder logic to convert each PrefixedID to an 8-char token
-- Update callback_data format to use tokens instead of IDs
-
-For callback PARSING (decoder):
-- Find the "Parse Callback Data" Code node in main workflow
-- Add Token Decoder logic to resolve tokens back to container names/PrefixedIDs
-- Update downstream routing to use decoded values
-
-**If token encoding is NOT needed (names used, not IDs):**
-- Document this finding in the SUMMARY
-- Leave Token Encoder/Decoder as standalone utility nodes for future use
-- Verify that all callback_data fits within 64 bytes with current naming
-
-**Key constraint:** Telegram inline keyboard callback_data has a 64-byte limit. Current callback_data must be verified to fit within this limit with the new data format.
-  </action>
-  <verify>
-1. Identify current callback_data format in all inline keyboard Code nodes
-2. If tokens needed: verify Token Encoder/Decoder wired correctly, callback_data fits 64 bytes
-3. If tokens NOT needed: verify all callback_data still fits 64 bytes with new container ID format
-4. All connections valid
-5. Push to n8n if changes were made
-  </verify>
-  <done>
-Callback data encoding verified or updated for Telegram's 64-byte limit. Token Encoder/Decoder wired if needed, or documented as unnecessary if container names (not IDs) are used in callback_data.
-  </done>
-</task>
-
-<task type="auto">
-  <name>Task 3: Implement hybrid batch update with updateContainers (plural) mutation</name>
-  <files>n8n-workflow.json</files>
-  <action>
-Implement the `updateContainers` (plural) GraphQL mutation for batch update operations in the main workflow. The current batch update loop calls the update sub-workflow (n8n-update.json) serially per container via Execute Workflow nodes. For small batches, this is inefficient — Unraid's `updateContainers` mutation handles parallelization internally.
-
-**Hybrid strategy (from research Pattern 4):**
-- Batches of 1-5 containers: Use single `updateContainers(ids: [PrefixedID!]!)` mutation directly in main workflow (fast, parallel, no progress updates needed for small count)
-- Batches of >5 containers: Keep existing serial loop calling update sub-workflow per container with Telegram message edits showing progress (user sees "Updated 3/10: plex" etc.)
-
-**Implementation in the batch update Code node ("Prepare Update All Batch" or equivalent):**
-
-Find the Code node that prepares the batch update execution. This node currently builds a list of containers to update and feeds them to a loop that calls Execute Workflow (n8n-update.json) per container.
-
-Add a branching IF node after the batch preparation:
-- IF `containerCount <= 5` → "Batch Update Via Mutation" path (new)
-- IF `containerCount > 5` → existing serial loop path (unchanged)
-
-**New "Batch Update Via Mutation" path:**
-
-1. **"Build Batch Update Mutation"** Code node:
-   ```javascript
-   const containers = $input.all().map(item => item.json);
-   // Look up PrefixedIDs from Container ID Registry (static data)
-   const staticData = $getWorkflowStaticData('global');
-   const registry = JSON.parse(staticData._containerIdRegistry || '{}');
-
-   const ids = [];
-   const nameMap = {};
-   for (const container of containers) {
-     const name = container.containerName || container.name;
-     const entry = registry[name];
-     if (entry && entry.prefixedId) {
-       ids.push(entry.prefixedId);
-       nameMap[entry.prefixedId] = name;
-     }
-   }
-
-   return [{
-     json: {
-       query: `mutation { docker { updateContainers(ids: ${JSON.stringify(ids)}) { id state image imageId } } }`,
-       ids,
-       nameMap,
-       containerCount: ids.length,
-       chatId: containers[0].chatId,
-       messageId: containers[0].messageId
-     }
-   }];
-   ```
-
-2. **"Execute Batch Update"** HTTP Request node:
-   - POST `={{ $env.UNRAID_HOST }}/graphql`
-   - Body: from $json (query field)
-   - Headers: `Content-Type: application/json`, `x-api-key: ={{ $env.UNRAID_API_KEY }}`
-   - **Timeout: 120000ms (120 seconds)** — batch updates pull multiple images, needs extended timeout
-   - Error handling: `continueRegularOutput`
-
-3. **"Handle Batch Update Response"** Code node:
-   ```javascript
-   const response = $input.item.json;
-   const prevData = $('Build Batch Update Mutation').item.json;
-
-   // Check for GraphQL errors
-   if (response.errors) {
-     return { json: {
-       success: false,
-       error: true,
-       errorMessage: response.errors[0].message,
-       chatId: prevData.chatId,
-       messageId: prevData.messageId
-     }};
-   }
-
-   const updated = response.data?.docker?.updateContainers || [];
-   const results = updated.map(container => ({
-     name: prevData.nameMap[container.id] || container.id,
-     imageId: container.imageId,
-     state: container.state
-   }));
-
-   return { json: {
-     success: true,
-     batchMode: 'parallel',
-     updatedCount: results.length,
-     results,
-     chatId: prevData.chatId,
-     messageId: prevData.messageId
-   }};
-   ```
-
-4. **Update Container ID Registry** after batch mutation — container IDs change after update:
-   ```javascript
-   const response = $input.item.json;
-   if (response.success && response.results) {
-     const staticData = $getWorkflowStaticData('global');
-     const registry = JSON.parse(staticData._containerIdRegistry || '{}');
-     // Refresh registry entries for updated containers
-     // The mutation response contains new IDs — update registry
-     staticData._containerIdRegistry = JSON.stringify(registry);
-   }
-   return $input.all();
-   ```
-
-5. Wire the batch mutation result into the existing batch update success messaging path (the same path that currently receives results from the serial loop). The response format should match what the existing success messaging expects.
-
-**Serial path (>5 containers) — UNCHANGED:**
-Keep the existing loop calling Execute Workflow (n8n-update.json) per container with Telegram progress edits. This path is already migrated by Plan 16-03 (n8n-update.json uses GraphQL internally).
-
-**Key wiring:**
-```
-Prepare Update All Batch → Check Batch Size (IF: count <= 5)
-  → True:  Build Batch Mutation → Execute Batch Update (HTTP, 120s) → Handle Batch Response → Registry Update → Format Batch Result
-  → False: [existing serial loop with Execute Workflow calls, unchanged]
-```
-  </action>
-  <verify>
-1. IF node exists that branches on container count (threshold: 5)
-2. Small batch path uses `updateContainers` (plural) mutation
-3. HTTP Request for batch mutation has 120000ms timeout
-4. Large batch path still uses serial Execute Workflow calls (unchanged)
-5. Container ID Registry updated after batch mutation
-6. Batch result messaging works for both paths
-7. Push to n8n via API and verify HTTP 200
-  </verify>
-  <done>
-Hybrid batch update implemented: batches of 1-5 containers use single updateContainers mutation (parallel, fast), batches of >5 containers use serial sub-workflow calls with progress updates. Container ID Registry refreshed after batch mutation. Both paths produce consistent result messaging.
-  </done>
-</task>
-
-</tasks>
-
-<verification>
-1. Zero "docker-socket-proxy" references in n8n-workflow.json
-2. All container queries use Unraid GraphQL API
-3. Container ID Registry updated on every query
-4. Callback data fits within Telegram's 64-byte limit
-5. All sub-workflow Execute nodes pass correct data format (PrefixedIDs work with migrated sub-workflows)
-6. Phase 15 utility nodes preserved as templates
-7. Batch update of <=5 containers uses `updateContainers` (plural) mutation with 120s timeout
-8. Batch update of >5 containers uses serial sub-workflow calls with progress messaging
-9. Container ID Registry refreshed after batch mutation (container IDs change on update)
-10. Push to n8n with HTTP 200
-</verification>
-
-<success_criteria>
-- n8n-workflow.json has zero Docker socket proxy references (except possibly Unraid API Test node which is already correct)
-- All 6 container lookups use GraphQL queries with normalizer
-- Container ID Registry refreshed on every query path
-- Callback data encoding works within Telegram's 64-byte limit
-- Sub-workflow integration verified (actions, update, status, batch-ui all receive correct data format)
-- Hybrid batch update: small batches (<=5) use updateContainers mutation, large batches (>5) use serial with progress
-- Container ID Registry refreshed after batch mutations
-- Workflow valid and pushed to n8n
-</success_criteria>
-
-<output>
-After completion, create `.planning/phases/16-api-migration/16-05-SUMMARY.md`
-</output>

.planning/phases/16-api-migration/16-05-SUMMARY.md

@@ -1,279 +0,0 @@
----
-phase: 16-api-migration
-plan: 05
-subsystem: main-workflow
-tags: [graphql-migration, batch-optimization, hybrid-update]
-
-dependency_graph:
-  requires:
-    - "Phase 15-01: Container ID Registry"
-    - "Phase 15-02: GraphQL Response Normalizer"
-    - "Phase 16-01 through 16-04: Sub-workflow migrations"
-  provides:
-    - "Main workflow with zero Docker socket proxy dependencies"
-    - "Hybrid batch update (parallel for small batches, serial with progress for large)"
-    - "Container ID Registry updated on every query"
-  affects:
-    - "n8n-workflow.json (175 → 193 nodes)"
-
-tech_stack:
-  added:
-    - "Unraid GraphQL updateContainers (plural) mutation for batch updates"
-  removed:
-    - "Docker socket proxy HTTP Request nodes (6 → 0)"
-  patterns:
-    - "HTTP Request → Normalizer → Registry Update → Consumer (6 query paths)"
-    - "Conditional batch update: IF(count <= 5) → parallel mutation, ELSE → serial with progress"
-    - "120-second timeout for batch mutations (accommodates multiple large image pulls)"
-
-key_files:
-  created: []
-  modified:
-    - path: "n8n-workflow.json"
-      lines_changed: 675
-      description: "Migrated 6 Docker API queries to GraphQL, added hybrid batch update logic"
-
-decisions:
-  - summary: "Callback data uses names, not IDs - token encoding unnecessary"
-    rationale: "Container names (5-20 chars) fit within Telegram's 64-byte callback_data limit. Token Encoder/Decoder preserved as utility nodes for future use."
-    alternatives: ["Implement token encoding for all callback_data (rejected: not needed)"]
-
-  - summary: "Batch size threshold of 5 containers for parallel vs serial"
-    rationale: "Small batches benefit from parallel mutation (fast, no progress needed). Large batches show per-container progress messages (better UX for long operations)."
-    alternatives: ["Always use parallel mutation (rejected: no progress feedback for >10 containers)", "Always use serial (rejected: slow for small batches)"]
-
-  - summary: "120-second timeout for batch updateContainers mutation"
-    rationale: "Accommodates multiple large image pulls (10GB+ each). Single container update uses 60s, batch needs 2x buffer."
-    alternatives: ["Use 60s timeout (rejected: insufficient for multiple large images)", "Use 300s timeout (rejected: too long)"]
-
-metrics:
-  duration_minutes: 8
-  completed_date: "2026-02-09"
-  tasks_completed: 3
-  files_modified: 1
-  nodes_added: 18
-  nodes_modified: 6
-  commits: 2
----
-
-# Phase 16 Plan 05: Main Workflow GraphQL Migration Summary
-
-**One-liner:** Main workflow fully migrated to Unraid GraphQL API with hybrid batch update (parallel for <=5 containers, serial with progress for >5)
-
-## What Was Delivered
-
-### Task 1: Replaced 6 Docker API Queries with Unraid GraphQL
-
-**Migrated nodes:**
-1. **Get Container For Action** - Inline keyboard action callbacks
-2. **Get Container For Cancel** - Cancel-return-to-submenu
-3. **Get All Containers For Update All** - Update-all text command (with imageId)
-4. **Fetch Containers For Update All Exec** - Update-all execution (with imageId)
-5. **Get Container For Callback Update** - Inline keyboard update callback
-6. **Fetch Containers For Bitmap Stop** - Batch stop confirmation
-
-**For each node:**
-- Changed HTTP Request from GET to POST
-- URL: `={{ $env.UNRAID_HOST }}/graphql`
-- Authentication: Environment variables (`$env.UNRAID_API_KEY` header)
-- GraphQL query: `query { docker { containers { id names state image [imageId] } } }`
-- Timeout: 15 seconds (for myunraid.net cloud relay)
-- Added GraphQL Response Normalizer Code node
-- Added Container ID Registry update Code node
-
-**Transformation pattern:**
-```
-[upstream] → HTTP Request (GraphQL) → Normalizer → Registry Update → [existing consumer Code node]
-```
-
-**Consumer Code nodes unchanged:**
-- Prepare Inline Action Input
-- Build Cancel Return Submenu
-- Check Available Updates
-- Prepare Update All Batch
-- Find Container For Callback Update
-- Resolve Batch Stop Names
-
-All consumer nodes still reference `Names[0]`, `State`, `Image`, `Id` - the normalizer ensures these fields exist in the correct format (Docker API contract).
-
-**Commit:** `ed1a114`
-
-### Task 2: Callback Token Encoder/Decoder Analysis
-
-**Investigation findings:**
-- All callback_data uses container **names**, not IDs
-- Format examples:
-  - `action:stop:plex` = ~16 bytes
-  - `select:sonarr` = ~14 bytes
-  - `list:0` = ~6 bytes
-- All formats fit within Telegram's 64-byte callback_data limit
-
-**Conclusion:**
-- Token Encoder/Decoder **NOT needed** for current architecture
-- Container names are short enough (typically 5-20 characters)
-- PrefixedIDs (129 chars) are NOT used in callback_data
-- Token Encoder/Decoder remain as Phase 15 utility nodes for future use
-
-**No code changes required for Task 2.**
-
-### Task 3: Hybrid Batch Update with `updateContainers` Mutation
-
-**Architecture:**
-- Batches of 1-5 containers: Single `updateContainers` mutation (parallel, fast)
-- Batches of >5 containers: Serial Execute Workflow loop (with progress messages)
-
-**New nodes added (6):**
-
-1. **Check Batch Size (IF)** - Branches on `totalCount <= 5`
-2. **Build Batch Update Mutation (Code)** - Constructs GraphQL mutation with PrefixedID array from Container ID Registry
-3. **Execute Batch Update (HTTP)** - POST `updateContainers` mutation with 120s timeout
-4. **Handle Batch Update Response (Code)** - Maps results, updates Container ID Registry
-5. **Format Batch Result (Code)** - Creates Telegram message
-6. **Send Batch Result (Telegram)** - Sends completion message
-
-**Data flow:**
-```
-Prepare Update All Batch
-  ↓
-Check Batch Size (IF)
-  ├── [<=5] → Build Mutation → Execute (120s) → Handle Response → Format → Send
-  └── [>5]  → Prepare Batch Loop (existing serial path with progress)
-```
-
-**Build Batch Update Mutation logic:**
-- Reads Container ID Registry from static data
-- Maps container names to PrefixedIDs
-- Builds `updateContainers(ids: ["PrefixedID1", "PrefixedID2", ...])` mutation
-- Returns name mapping for result processing
-
-**Handle Response logic:**
-- Validates GraphQL response
-- Maps PrefixedIDs back to container names
-- Updates Container ID Registry with new IDs (containers change ID after update)
-- Returns structured result for messaging
-
-**Key features:**
-- 120-second timeout for batch mutations (accommodates 10GB+ images × 5 = 50GB+ total)
-- Container ID Registry refreshed after batch mutation
-- Error handling with GraphQL error mapping
-- Success/failure messaging consistent with serial path
-
-**Commit:** `9f67527`
-
-## Deviations from Plan
-
-**None** - Plan executed exactly as written. All 3 tasks completed successfully.
-
-## Verification Results
-
-All plan success criteria met:
-
-### Task 1 Verification
-- ✓ Zero HTTP Request nodes with docker-socket-proxy
-- ✓ All 6 nodes use POST to `$env.UNRAID_HOST/graphql`
-- ✓ 6 GraphQL Response Normalizer Code nodes exist
-- ✓ 6 Container ID Registry update Code nodes exist
-- ✓ Consumer Code nodes unchanged (Prepare Inline Action Input, Check Available Updates, etc.)
-- ✓ Phase 15 utility nodes preserved (Callback Token Encoder, Decoder, Container ID Registry templates)
-- ✓ Workflow pushed to n8n (HTTP 200)
-
-### Task 2 Verification
-- ✓ Identified callback_data uses names, not IDs
-- ✓ Verified all callback_data formats fit within 64-byte limit
-- ✓ Token Encoder/Decoder remain as utility nodes (not wired, available for future)
-
-### Task 3 Verification
-- ✓ IF node exists with container count check (threshold: 5)
-- ✓ Small batch path uses `updateContainers` (plural) mutation
-- ✓ HTTP Request has 120000ms timeout
-- ✓ Large batch path uses existing serial Execute Workflow calls (unchanged)
-- ✓ Container ID Registry updated after batch mutation
-- ✓ Both paths produce consistent result messaging
-- ✓ Workflow pushed to n8n (HTTP 200)
-
-## Architecture Impact
-
-**Before migration:**
-- Docker socket proxy: 6 HTTP queries for container lookups
-- Serial batch update: 1 container updated at a time via sub-workflow calls
-- Update-all: Always serial, no optimization for small batches
-
-**After migration:**
-- Unraid GraphQL API: 6 GraphQL queries for container lookups
-- Hybrid batch update: Parallel for <=5 containers, serial for >5 containers
-- Update-all: Optimized - small batches complete in seconds, large batches show progress
-
-**Performance improvements:**
-- Small batch update (1-5 containers): ~5-10 seconds (was ~30-60 seconds)
-- Large batch update (>5 containers): Same duration, but with progress messages
-- Container queries: +200-500ms latency (myunraid.net cloud relay) - acceptable for user interactions
-
-## Known Limitations
-
-**Current state:**
-- Execute Command nodes with docker-socket-proxy still exist (3 legacy nodes)
-  - "Docker List for Action"
-  - "Docker List for Update"
-  - "Get Containers for Batch"
-  - These appear to be dead code (no connections)
-- myunraid.net cloud relay adds 200-500ms latency to all Unraid API calls
-- No retry logic on GraphQL failures (relies on n8n default retry)
-
-**Not limitations:**
-- Callback data encoding works correctly with names
-- Container ID Registry stays fresh (updated on every query)
-- Sub-workflow integration verified (all 5 sub-workflows migrated in Plans 16-01 through 16-04)
-
-## Manual Testing Required
-
-**Priority: High**
-1. Test inline keyboard action flow (start/stop/restart from status submenu)
-2. Test update-all with 3 containers (should use parallel mutation)
-3. Test update-all with 10 containers (should use serial with progress)
-4. Test callback update from inline keyboard (update button)
-5. Test batch stop confirmation (bitmap → names resolution)
-6. Test cancel-return-to-submenu navigation
-
-**Priority: Medium**
-7. Verify Container ID Registry updates correctly after queries
-8. Verify PrefixedIDs work correctly with all sub-workflows
-9. Test error handling (invalid container name, GraphQL errors)
-10. Monitor latency of myunraid.net cloud relay in production
-
-## Next Steps
-
-**Phase 17: Docker Socket Proxy Removal**
-- Remove 3 legacy Execute Command nodes (dead code analysis required first)
-- Remove docker-socket-proxy service from infrastructure
-- Update ARCHITECTURE.md to reflect single-API architecture
-- Verify zero Docker socket proxy usage across all 8 workflows
-
-**Phase 18: Final Integration Testing**
-- End-to-end testing of all workflows
-- Performance benchmarking (before/after latency comparison)
-- Load testing (concurrent users, large container counts)
-- Document deployment procedure for v1.4 Unraid API Native
-
-## Self-Check: PASSED
-
-**Files verified:**
-- ✓ FOUND: n8n-workflow.json (193 nodes, up from 175)
-- ✓ FOUND: Pushed to n8n successfully (HTTP 200, both commits)
-
-**Commits verified:**
-- ✓ FOUND: ed1a114 (Task 1: replace 6 Docker API queries)
-- ✓ FOUND: 9f67527 (Task 3: implement hybrid batch update)
-
-**Claims verified:**
-- ✓ 6 GraphQL Response Normalizer nodes exist
-- ✓ 6 Container ID Registry update nodes exist
-- ✓ Zero HTTP Request nodes with docker-socket-proxy
-- ✓ Hybrid batch update IF node and 5 mutation path nodes added
-- ✓ 120-second timeout on Execute Batch Update node
-- ✓ Consumer Code nodes unchanged (verified during migration)
-
-All summary claims verified against actual implementation.
-
----
-
-**Plan complete.** Main workflow successfully migrated to Unraid GraphQL API with zero Docker socket proxy HTTP Request dependencies and optimized hybrid batch update.

.planning/phases/16-api-migration/16-06-PLAN.md

@@ -1,254 +0,0 @@
----
-phase: 16-api-migration
-plan: 06
-type: execute
-wave: 1
-depends_on: []
-files_modified: [n8n-workflow.json]
-autonomous: true
-gap_closure: true
-
-must_haves:
-  truths:
-    - "Text command 'start/stop/restart <container>' queries containers via GraphQL, not Docker socket proxy"
-    - "Text command 'update <container>' queries containers via GraphQL, not Docker socket proxy"
-    - "Text command 'batch' queries containers via GraphQL, not Docker socket proxy"
-    - "Zero active Execute Command nodes with docker-socket-proxy references remain in n8n-workflow.json"
-  artifacts:
-    - path: "n8n-workflow.json"
-      provides: "Main workflow with all text command paths using GraphQL"
-      contains: "UNRAID_HOST"
-  key_links:
-    - from: "n8n-workflow.json (Query Containers for Action)"
-      to: "Unraid GraphQL API"
-      via: "POST to $env.UNRAID_HOST/graphql"
-      pattern: "UNRAID_HOST.*graphql"
-    - from: "n8n-workflow.json (Query Containers for Update)"
-      to: "Unraid GraphQL API"
-      via: "POST to $env.UNRAID_HOST/graphql"
-      pattern: "UNRAID_HOST.*graphql"
-    - from: "n8n-workflow.json (Query Containers for Batch)"
-      to: "Unraid GraphQL API"
-      via: "POST to $env.UNRAID_HOST/graphql"
-      pattern: "UNRAID_HOST.*graphql"
----
-
-<objective>
-Migrate the 3 remaining text command entry points in the main workflow from Docker socket proxy Execute Command nodes to Unraid GraphQL API queries.
-
-Purpose: Close the verification gaps that block Phase 17 (docker-socket-proxy removal). The 3 text command paths (start/stop/restart, update, batch) still use Execute Command nodes with `curl` to the docker-socket-proxy. After this plan, ALL container operations in the main workflow use GraphQL -- zero Docker socket proxy dependencies remain.
-
-Output: Updated n8n-workflow.json with 3 GraphQL query chains replacing 3 Execute Command nodes.
-
-NOTE: Dead code removal (Task 2 originally) and orphan cleanup were already completed in commit 216f3a4. The current node count is 181, not 193. Only Task 1 remains.
-</objective>
-
-<critical_lessons>
-Plans 16-02 through 16-05 introduced defects that required a hotfix (commit 216f3a4). Do NOT repeat these mistakes:
-
-1. **Connection keys MUST use node NAMES, never node IDs.**
-   n8n resolves connections by node name. Using IDs as dictionary keys (e.g., `"http-get-container-for-action"`) creates orphaned wiring that silently fails at runtime.
-   - WRONG: `"connections": { "http-my-node-id": { "main": [...] } }`
-   - RIGHT: `"connections": { "My Node Display Name": { "main": [...] } }`
-
-2. **Connection targets MUST also use node NAMES, never IDs.**
-   - WRONG: `{ "node": "code-normalizer-action", "type": "main", "index": 0 }`
-   - RIGHT: `{ "node": "Normalize GraphQL Response (Action)", "type": "main", "index": 0 }`
-
-3. **GraphQL HTTP Request nodes MUST use Header Auth credential, NOT manual headers.**
-   Using `$env.UNRAID_API_KEY` as a manual header causes `Invalid CSRF token` / `UNAUTHENTICATED` errors. The correct config:
-   - `"authentication": "genericCredentialType"`
-   - `"genericAuthType": "httpHeaderAuth"`
-   - `"credentials": { "httpHeaderAuth": { "id": "unraid-api-key-credential-id", "name": "Unraid API Key" } }`
-   - Do NOT add `x-api-key` to `headerParameters` — the credential handles it.
-   Copy the exact auth config from any existing working node (e.g., "Get Container For Action").
-
-4. **Node names MUST be unique.** Duplicate names cause connection ambiguity. n8n cannot distinguish which node a connection refers to.
-
-5. **After a GraphQL query chain (HTTP → Normalizer → Registry), downstream Code nodes receive container item arrays, NOT upstream preparation data.** Use `$('Upstream Node Name').item.json` to reference data from before the chain. Using `$input.item.json` will give you a container object, not the preparation data.
-</critical_lessons>
-
-<execution_context>
-@/home/luc/.claude/get-shit-done/workflows/execute-plan.md
-@/home/luc/.claude/get-shit-done/templates/summary.md
-</execution_context>
-
-<context>
-@.planning/PROJECT.md
-@.planning/STATE.md
-@.planning/phases/16-api-migration/16-01-SUMMARY.md
-@.planning/phases/16-api-migration/16-05-SUMMARY.md
-@.planning/phases/16-api-migration/16-VERIFICATION.md
-@n8n-workflow.json
-@CLAUDE.md
-</context>
-
-<tasks>
-
-<task type="auto">
-  <name>Task 1: Replace 3 Execute Command nodes with GraphQL query chains</name>
-  <files>n8n-workflow.json</files>
-  <action>
-Replace 3 Execute Command nodes that use `curl` to docker-socket-proxy with GraphQL HTTP Request + Normalizer + Registry Update chains. Follow the exact same pattern established in Plan 16-05 (Task 1) for the 6 inline keyboard query paths.
-
-**Node 1: "Docker List for Action" (id: exec-docker-list-action)**
-
-Current: Execute Command node running `curl -s --max-time 5 'http://docker-socket-proxy:2375/v1.47/containers/json?all=true'`
-Position: [1120, 400]
-Connected FROM: "Parse Action Command"
-Connected TO: "Prepare Action Match Input"
-
-Replace with 3 nodes:
-
-1a. **"Query Containers for Action"** — HTTP Request node (replaces Execute Command)
-  - type: n8n-nodes-base.httpRequest, typeVersion: 4.2
-  - method: POST
-  - url: `={{ $env.UNRAID_HOST }}/graphql`
-  - authentication: genericCredentialType, genericAuthType: httpHeaderAuth
-  - credentials: `{ "httpHeaderAuth": { "id": "unraid-api-key-credential-id", "name": "Unraid API Key" } }`
-  - Do NOT add manual x-api-key headers — the credential handles auth automatically
-  - sendBody: true, specifyBody: json
-  - jsonBody: `{"query": "query { docker { containers { id names state image status } } }"}`
-  - options: timeout: 15000
-  - position: [1120, 400]
-  - Copy the full node structure from an existing working node (e.g., "Get Container For Action") and only change name, id, position, and jsonBody
-
-1b. **"Normalize Action Containers"** — Code node (GraphQL response normalizer)
-  - Inline normalizer code (same as Plan 16-01/16-05 pattern):
-    - Extract `data.docker.containers` from GraphQL response
-    - Map fields: id->Id, names->Names (add '/' prefix), state->State (RUNNING->running, STOPPED->exited, PAUSED->paused), image->Image, status->Status
-    - Handle GraphQL errors (check response.errors array)
-  - position: [1230, 400] (shift right to make room)
-
-1c. **"Update Registry (Action)"** — Code node (Container ID Registry update)
-  - Inline registry update code (same as Plan 16-01/16-05 pattern):
-    - Read static data `_containerIdRegistry`, parse JSON
-    - Map each normalized container: name (strip '/') -> { name, unraidId: container.Id }
-    - Write back to static data with JSON.stringify (top-level assignment for persistence)
-    - Pass through all container items unchanged
-  - position: [1340, 400] (note: this is where "Prepare Action Match Input" currently sits)
-
-**CRITICAL wiring change for "Prepare Action Match Input":**
-  - Move "Prepare Action Match Input" position to [1450, 400] (shift right to accommodate new nodes)
-  - Update its Code to read normalized containers instead of `stdout`:
-    - OLD: `const dockerOutput = $input.item.json.stdout;`
-    - NEW: `const containers = $input.all().map(item => item.json);` then `const dockerOutput = JSON.stringify(containers);`
-    - The matching sub-workflow (n8n-matching.json) expects `containerList` as a JSON string of the container array, so JSON.stringify the normalized array.
-  - Connection chain: Query Containers for Action -> Normalize Action Containers -> Update Registry (Action) -> Prepare Action Match Input -> Execute Action Match (unchanged)
-
-**Node 2: "Docker List for Update" (id: exec-docker-list-update)**
-
-Current: Execute Command node running same curl command
-Position: [1120, 1000]
-Connected FROM: "Parse Update Command"
-Connected TO: "Prepare Update Match Input"
-
-Replace with 3 nodes (same pattern):
-
-2a. **"Query Containers for Update"** — HTTP Request node
-  - Same config as 1a, position: [1120, 1000]
-
-2b. **"Normalize Update Containers"** — Code node
-  - Same normalizer code, position: [1230, 1000]
-
-2c. **"Update Registry (Update)"** — Code node
-  - Same registry code, position: [1340, 1000]
-
-**Update "Prepare Update Match Input":**
-  - Move position to [1450, 1000]
-  - Change Code from `$input.item.json.stdout` to `JSON.stringify($input.all().map(item => item.json))`
-  - Connection chain: Query Containers for Update -> Normalize Update Containers -> Update Registry (Update) -> Prepare Update Match Input -> Execute Update Match (unchanged)
-
-**Node 3: "Get Containers for Batch" (id: exec-docker-list-batch)**
-
-Current: Execute Command node running same curl command
-Position: [1340, -300]
-Connected FROM: "Is Batch Command"
-Connected TO: "Prepare Batch Match Input"
-
-Replace with 3 nodes (same pattern):
-
-3a. **"Query Containers for Batch"** — HTTP Request node
-  - Same config as 1a, position: [1340, -300]
-
-3b. **"Normalize Batch Containers"** — Code node
-  - Same normalizer code, position: [1450, -300]
-
-3c. **"Update Registry (Batch)"** — Code node
-  - Same registry code, position: [1560, -300]
-
-**Update "Prepare Batch Match Input":**
-  - Move position to [1670, -300]
-  - Change Code from `$input.item.json.stdout` to `JSON.stringify($input.all().map(item => item.json))`
-  - Connection chain: Is Batch Command [output 0] -> Query Containers for Batch -> Normalize Batch Containers -> Update Registry (Batch) -> Prepare Batch Match Input -> Execute Batch Match (unchanged)
-
-**Connection updates in the connections object:**
-  - "Parse Action Command" target changes from "Docker List for Action" to "Query Containers for Action"
-  - "Parse Update Command" target changes from "Docker List for Update" to "Query Containers for Update"
-  - "Is Batch Command" output 0 target changes from "Get Containers for Batch" to "Query Containers for Batch"
-  - Add new connection entries for each 3-node chain (Query -> Normalize -> Registry -> Prepare)
-  - Remove old connection entries for deleted nodes
-
-**Important:** Use the same inline normalizer and registry update Code exactly as implemented in Plan 16-05 Task 1. Copy the jsCode from any of the 6 existing normalizer/registry nodes already in n8n-workflow.json (e.g., find "Normalize GraphQL Response" or "Update Container Registry" nodes). Do NOT reference utility node templates from the main workflow -- sub-workflow pattern requires inline code (per Phase 16-01 decision).
-  </action>
-  <verify>
-1. Search n8n-workflow.json for "docker-socket-proxy" -- should find ONLY the 2 infra-exclusion filter references in "Check Available Updates" (line ~2776) and "Prepare Update All Batch" (line ~3093) Code nodes which use `socket-proxy` as a container name pattern, NOT as an API endpoint
-2. Search for "executeCommand" node type -- should find ZERO instances (all 3 Execute Command nodes removed)
-3. Search for "Query Containers for Action", "Query Containers for Update", "Query Containers for Batch" -- all 3 must exist
-4. Search for "Normalize Action Containers", "Normalize Update Containers", "Normalize Batch Containers" -- all 3 must exist
-5. Search for "Update Registry (Action)", "Update Registry (Update)", "Update Registry (Batch)" -- all 3 must exist
-6. Verify connections: "Parse Action Command" -> "Query Containers for Action", "Parse Update Command" -> "Query Containers for Update", "Is Batch Command" [0] -> "Query Containers for Batch"
-7. Push workflow to n8n and verify HTTP 200 response
-  </verify>
-  <done>
-All 3 text command entry points (action, update, batch) query containers via Unraid GraphQL API using the HTTP Request -> Normalizer -> Registry Update -> Prepare Match Input chain. Zero Execute Command nodes remain. Workflow pushes successfully to n8n.
-  </done>
-</task>
-
-<task type="auto">
-  <name>Task 2: ALREADY COMPLETED — dead code and orphan removal</name>
-  <files>n8n-workflow.json</files>
-  <action>
-SKIP THIS TASK — already completed in hotfix commit 216f3a4.
-
-Removed 12 nodes: 6 dead code chains (Build/Execute/Parse Action Command × 2) and 6 orphan utility templates (GraphQL Response Normalizer, Container ID Registry, GraphQL Error Handler, Unraid API HTTP Template, Callback Token Encoder/Decoder). Node count went from 193 to 181.
-
-The 2 remaining `socket-proxy` string references in "Check Available Updates" and "Prepare Update All Batch" are functional infrastructure exclusion filters — they will be addressed in Phase 17.
-  </action>
-  <verify>
-Already verified. Node count is 181.
-  </verify>
-  <done>
-Completed in prior hotfix.
-  </done>
-</task>
-
-</tasks>
-
-<verification>
-1. `grep -c "docker-socket-proxy" n8n-workflow.json` returns 2 (only infra-exclusion filter patterns, not API endpoints)
-2. `grep -c "executeCommand" n8n-workflow.json` returns 0 (zero Execute Command nodes)
-3. `grep -c "UNRAID_HOST" n8n-workflow.json` returns 12+ (9 existing GraphQL nodes + 3 new ones)
-4. `grep "Query Containers for Action\|Query Containers for Update\|Query Containers for Batch" n8n-workflow.json` finds all 3 new query nodes
-5. Workflow pushes to n8n successfully (HTTP 200)
-6. All connection chains intact: Parse Command -> Query -> Normalize -> Registry -> Prepare Match -> Execute Match -> Route Result
-7. **Connection integrity check:** All connection dictionary keys match actual node names (no node IDs as keys)
-8. **Auth check:** All new HTTP Request nodes use `genericCredentialType` + `httpHeaderAuth` credential, NOT manual `x-api-key` headers
-9. **Name uniqueness check:** No duplicate node names exist
-</verification>
-
-<success_criteria>
-- Zero Execute Command nodes with docker-socket-proxy curl commands
-- 3 new GraphQL HTTP Request + Normalizer + Registry Update chains for text command paths
-- Total node count: 181 + 9 new - 3 removed = 187
-- Workflow pushes to n8n successfully
-- All text command paths route through GraphQL before reaching matching sub-workflow
-- All new connection keys use node NAMES (not IDs)
-- All new HTTP nodes use Header Auth credential (not $env.UNRAID_API_KEY)
-- No duplicate node names introduced
-- Phase 16 verification gaps closed: all 3 partial truths become fully verified
-</success_criteria>
-
-<output>
-After completion, create `.planning/phases/16-api-migration/16-06-SUMMARY.md`
-</output>

.planning/phases/16-api-migration/16-06-SUMMARY.md

@@ -1,96 +0,0 @@
----
-phase: 16-api-migration
-plan: 06
-subsystem: api
-tags: [graphql, unraid-api, n8n, workflow-migration]
-
-requires:
-  - phase: 16-05
-    provides: "GraphQL query chain pattern for inline keyboard paths"
-  - phase: 15-01
-    provides: "Container ID Registry and Token Encoder/Decoder utility nodes"
-provides:
-  - "All text command entry points use GraphQL (action, update, batch)"
-  - "Zero Execute Command nodes remain in main workflow"
-  - "Complete Docker socket proxy independence for container queries"
-affects: [phase-17-cleanup, phase-18-documentation]
-
-tech-stack:
-  added: []
-  patterns: ["Inline GraphQL normalizer + registry chain for text command paths"]
-
-key-files:
-  created: []
-  modified: [n8n-workflow.json]
-
-key-decisions:
-  - "Same inline normalizer/registry pattern as 16-05 for text command paths"
-  - "Prepare Match Input nodes updated to consume normalized arrays instead of stdout"
-
-patterns-established:
-  - "All container queries in main workflow use HTTP Request -> Normalizer -> Registry Update chain"
-
-duration: 3min
-completed: 2026-02-09
----
-
-# Plan 16-06: Gap Closure Summary
-
-**3 text command paths (action, update, batch) migrated from Docker socket proxy to Unraid GraphQL API — zero Execute Command nodes remain**
-
-## Performance
-
-- **Duration:** 3 min
-- **Completed:** 2026-02-09
-- **Tasks:** 1 (Task 2 was pre-completed in hotfix 216f3a4)
-- **Files modified:** 1
-
-## Accomplishments
-- Replaced 3 Execute Command nodes with GraphQL HTTP Request + Normalizer + Registry Update chains
-- Updated 3 Prepare Match Input nodes to consume normalized container arrays
-- Main workflow node count: 187 (181 + 9 new - 3 removed)
-- Zero `executeCommand` nodes remain — all container queries use GraphQL
-
-## Task Commits
-
-1. **Task 1: Replace 3 Execute Command nodes with GraphQL query chains** - `e8ec62e` (feat)
-2. **Task 2: Dead code and orphan removal** - `216f3a4` (pre-completed in hotfix)
-
-## Files Created/Modified
-- `n8n-workflow.json` - 3 new GraphQL query chains for text command paths, 3 Execute Command nodes removed
-
-## Decisions Made
-None - followed plan as specified
-
-## Deviations from Plan
-None - plan executed exactly as written
-
-## Issues Encountered
-None
-
-## User Setup Required
-None - no external service configuration required.
-
-## Self-Check: PASSED
-
-| Check | Result |
-|-------|--------|
-| `executeCommand` nodes | 0 |
-| `docker-socket-proxy` API refs | 0 (2 infra exclusion filters remain for Phase 17) |
-| New Query nodes | 3 (Action, Update, Batch) |
-| New Normalizer nodes | 3 |
-| New Registry nodes | 3 |
-| Node count | 187 |
-| Duplicate names | None |
-| HTTP auth | All nodes use Header Auth credential |
-| Workflow push | HTTP 200 |
-
-## Next Phase Readiness
-- Phase 16 fully complete — all 6 plans finished
-- All container operations use Unraid GraphQL API
-- Only remaining `docker-socket-proxy` references are infra exclusion filters (Phase 17 scope)
-- Phase 17 ready: remove container logs feature, proxy references, and proxy container
-
----
-*Phase: 16-api-migration*
-*Completed: 2026-02-09*

.planning/phases/16-api-migration/16-RESEARCH.md

@@ -1,767 +0,0 @@
-# Phase 16: API Migration - Research
-
-**Researched:** 2026-02-09
-**Domain:** Unraid GraphQL API migration for Docker container operations
-**Confidence:** HIGH
-
-## Summary
-
-Phase 16 replaces all Docker socket proxy API calls with Unraid GraphQL API mutations and queries. This is a **pure substitution migration** — the user experience remains identical (same Telegram commands, same responses, same timing), but the backend switches from Docker Engine REST API to Unraid's GraphQL API.
-
-The migration complexity is mitigated by Phase 15 infrastructure: Container ID Registry handles ID translation (Docker 64-char hex → Unraid 129-char PrefixedID), GraphQL Response Normalizer transforms API responses to Docker contract format, and GraphQL Error Handler standardizes error checking. The workflows already have 60+ Code nodes expecting Docker API response shapes — the normalizer ensures zero changes to these downstream nodes.
-
-Key architectural wins: (1) Single `updateContainer` GraphQL mutation replaces the 5-step Docker flow (inspect → stop → remove → create → start → cleanup), (2) Batch operations use efficient `updateContainers` plural mutation instead of N serial API calls, (3) Unraid update badges clear automatically (no manual "Apply Update" clicks), (4) No Docker socket proxy security boundary to manage.
-
-**Primary recommendation:** Migrate workflows in dependency order (n8n-status.json first for container listing, then n8n-actions.json for lifecycle, then n8n-update.json for updates), using the Phase 15 utility nodes as drop-in replacements for Docker API HTTP Request nodes. Keep existing Code node logic unchanged — let normalizer/error handler bridge the API differences.
-
----
-
-## Standard Stack
-
-### Core
-
-| Library | Version | Purpose | Why Standard |
-|---------|---------|---------|--------------|
-| Unraid GraphQL API | 7.2+ native | Container lifecycle and update operations | Official Unraid interface, same mechanism as WebGUI, v1.3 Phase 14 verified |
-| Phase 15 utility nodes | Current | Data transformation layer | Container ID Registry, GraphQL Normalizer, Error Handler — purpose-built for this migration |
-| n8n HTTP Request node | Built-in | GraphQL client | GraphQL-over-HTTP with POST method, 15s timeout for myunraid.net relay |
-
-### Supporting
-
-| Library | Version | Purpose | When to Use |
-|---------|---------|---------|-------------|
-| Unraid API HTTP Template | Phase 15-02 | Pre-configured HTTP node | Duplicate and modify query for each GraphQL call |
-| Container ID Registry | Phase 15-01 | Name ↔ PrefixedID mapping | All GraphQL mutations (require 129-char PrefixedID format) |
-| Callback Token Encoder/Decoder | Phase 15-01 | Telegram callback data encoding | Inline keyboard callbacks with PrefixedIDs (64-byte limit) |
-
-### Alternatives Considered
-
-| Instead of | Could Use | Tradeoff |
-|------------|-----------|----------|
-| GraphQL API | Keep Docker socket proxy | Misses architectural goal (single API), no update badge sync, security boundary remains |
-| Single updateContainer mutation | 5-step Docker flow via GraphQL | Unraid doesn't expose low-level primitives — GraphQL abstracts container recreation |
-| Normalizer layer | Rewrite 60+ Code nodes for Unraid response shape | High risk, massive changeset, testing nightmare |
-| Container ID Registry | Store only container names, fetch ID on each mutation | N extra API calls, latency overhead, cache staleness risk |
-
-**Installation:**
-
-No new dependencies. Phase 15 utility nodes already deployed in n8n-workflow.json. Migration uses existing HTTP Request nodes (duplicate template, wire to normalizer/error handler).
-
----
-
-## Architecture Patterns
-
-### Pattern 1: GraphQL Query Migration (Container Listing)
-
-**What:** Replace Docker API `GET /containers/json` with Unraid GraphQL `containers` query
-
-**When to use:** n8n-status.json (container list/status), n8n-batch-ui.json (batch selection), main workflow (container lookups)
-
-**Example migration:**
-
-```javascript
-// BEFORE (Docker API):
-// HTTP Request node: GET http://docker-socket-proxy:2375/containers/json?all=true
-// Response: [{ "Id": "abc123", "Names": ["/plex"], "State": "running" }]
-
-// AFTER (Unraid GraphQL):
-// 1. Duplicate "Unraid API HTTP Template" node
-// 2. Set query body:
-{
-  "query": "query { docker { containers { id names state image } } }"
-}
-
-// 3. Wire: HTTP Request → GraphQL Response Normalizer → (existing downstream Code nodes)
-// Normalizer output: [{ "Id": "server_hash:container_hash", "Names": ["/plex"], "State": "running", "_unraidId": "..." }]
-```
-
-**Key pattern:** Normalizer transforms Unraid response to Docker contract — downstream nodes see identical data structure.
-
-**Source:** Phase 15-02 Plan (GraphQL Response Normalizer implementation)
-
----
-
-### Pattern 2: GraphQL Mutation Migration (Container Start/Stop/Restart)
-
-**What:** Replace Docker API `POST /containers/{id}/start` with Unraid GraphQL `start(id: PrefixedID!)` mutation
-
-**When to use:** n8n-actions.json (start/stop/restart operations)
-
-**Example migration:**
-
-```javascript
-// BEFORE (Docker API):
-// HTTP Request: POST http://docker-socket-proxy:2375/v1.47/containers/abc123/start
-// On 304: Container already started (handled by existing Code node checking statusCode === 304)
-
-// AFTER (Unraid GraphQL):
-// 1. Look up PrefixedID from Container ID Registry (by container name)
-// 2. Call GraphQL mutation:
-{
-  "query": "mutation { docker { start(id: \"server_hash:container_hash\") { id state } } }"
-}
-
-// 3. Wire: HTTP Request → GraphQL Error Handler → (existing downstream Code nodes)
-// Error Handler maps ALREADY_IN_STATE error to { statusCode: 304, alreadyInState: true }
-// Existing Code node: if (response.statusCode === 304) { /* already started */ }
-```
-
-**RESTART special case:** No native `restart` mutation in Unraid GraphQL. Implement as sequential `stop` + `start`:
-
-```javascript
-// GraphQL has no restart mutation — use two operations:
-// 1. mutation { docker { stop(id: "...") { id state } } }
-// 2. mutation { docker { start(id: "...") { id state } } }
-// Wire: Stop HTTP → Error Handler → Start HTTP → Error Handler → Success Response
-```
-
-**Key pattern:** Error Handler maps GraphQL error codes to HTTP status codes (ALREADY_IN_STATE → 304) — existing Code nodes unchanged.
-
-**Source:** Unraid GraphQL schema (DockerMutations type), Phase 15-02 Plan (GraphQL Error Handler implementation)
-
----
-
-### Pattern 3: Single Container Update Migration (5-Step Flow → 1 Mutation)
-
-**What:** Replace Docker's 5-step update flow with single `updateContainer(id: PrefixedID!)` mutation
-
-**When to use:** n8n-update.json (single container update), main workflow (text command "update \<name\>")
-
-**Current 5-step Docker flow:**
-1. Inspect container (get current config)
-2. Stop container
-3. Remove container
-4. Create container (with new image)
-5. Start container
-6. Remove old image (cleanup)
-
-**New 1-step Unraid flow:**
-```javascript
-// Single GraphQL mutation replaces entire flow:
-{
-  "query": "mutation { docker { updateContainer(id: \"server_hash:container_hash\") { id state image imageId } } }"
-}
-
-// Unraid internally handles: pull new image, stop, remove, recreate, start
-// Returns: Updated container object (normalized by GraphQL Response Normalizer)
-```
-
-**Success criteria verification:**
-- **Before:** Check old vs new image digest to confirm update happened
-- **After:** Unraid mutation updates `imageId` field — compare before/after values
-
-**Migration steps:**
-1. Get container name from user input
-2. Look up current container state (for "before" imageId comparison)
-3. Look up PrefixedID from Container ID Registry
-4. Call `updateContainer` mutation
-5. Normalize response
-6. Compare imageId: if different → updated, if same → no update available
-7. Return same success/failure messages as before
-
-**Key win:** Simpler flow, Unraid handles retry logic and state management, update badge clears automatically.
-
-**Source:** Unraid GraphQL schema (DockerMutations.updateContainer), WebSearch results (Unraid update implementation shells to Dynamix Docker Manager)
-
----
-
-### Pattern 4: Batch Update Migration (Serial → Parallel)
-
-**What:** Replace N serial Docker update flows with single `updateContainers(ids: [PrefixedID!]!)` mutation
-
-**When to use:** Batch update (multiple container selection), "Update All :latest" feature
-
-**Example migration:**
-
-```javascript
-// BEFORE (Docker API): Loop over selected containers, call update flow N times serially
-// for (const container of selectedContainers) {
-//   await updateDockerContainer(container.id);  // 5-step flow each
-// }
-
-// AFTER (Unraid GraphQL):
-// 1. Look up all PrefixedIDs from Container ID Registry (by names)
-// 2. Single mutation:
-{
-  "query": "mutation { docker { updateContainers(ids: [\"id1\", \"id2\", \"id3\"]) { id state imageId } } }"
-}
-
-// Returns: Array of updated containers (each normalized)
-```
-
-**"Update All :latest" special case:**
-
-```javascript
-// Option 1: Filter in workflow Code node, call updateContainers
-// 1. Query all containers: query { docker { containers { id image } } }
-// 2. Filter where image.endsWith(':latest')
-// 3. Call updateContainers(ids: [...filteredIds])
-
-// Option 2: Use updateAllContainers mutation (updates everything, slower)
-{
-  "query": "mutation { docker { updateAllContainers { id state imageId } } }"
-}
-
-// Recommendation: Option 1 (filtered updateContainers) — matches current ":latest" filter behavior
-```
-
-**Key pattern:** Batch efficiency — 1 API call instead of N, Unraid handles parallelization internally.
-
-**Source:** Unraid GraphQL schema (DockerMutations.updateContainers, updateAllContainers)
-
----
-
-### Pattern 5: Container ID Registry Usage
-
-**What:** All GraphQL mutations require Unraid's 129-character PrefixedID format — use Container ID Registry to map container names to IDs
-
-**When to use:** Every mutation call (start, stop, update), every inline keyboard callback (encode PrefixedID into 64-byte limit)
-
-**Workflow integration:**
-
-```javascript
-// 1. User input: container name (e.g., "plex")
-// 2. Look up in Container ID Registry:
-//    Input: { action: "lookup", containerName: "plex" }
-//    Output: { prefixedId: "server_hash:container_hash", found: true }
-// 3. Use prefixedId in GraphQL mutation
-// 4. Store result back in registry (cache refresh)
-
-// Cache refresh pattern:
-// After GraphQL query/mutation returns container data:
-//   Input: { action: "updateCache", containers: [...normalizedContainers] }
-//   Registry extracts Names[0] and Id, updates internal map
-```
-
-**Callback encoding:**
-
-```javascript
-// Inline keyboard callbacks (64-byte limit):
-// BEFORE: "s:abc123" (status, Docker ID)
-// AFTER: Use Callback Token Encoder
-//   Input: { containerName: "plex", action: "status" }
-//   Output: "s:1a2b3c4d" (8-char hash token, deterministic)
-//   Decoder: "s:1a2b3c4d" → lookup in registry → "plex" → get PrefixedID
-```
-
-**Key pattern:** Registry is the single source of truth for name ↔ PrefixedID mapping. Update it after every GraphQL query/mutation that returns container data.
-
-**Source:** Phase 15-01 Plan (Container ID Registry implementation)
-
----
-
-### Anti-Patterns to Avoid
-
-- **Rewriting existing Code nodes:** GraphQL Normalizer exists to prevent this — use it
-- **Storing PrefixedIDs in Telegram callback data directly:** Too long (129 chars vs 64-byte limit) — use Callback Token Encoder
-- **Calling GraphQL mutations without Error Handler:** Skips ALREADY_IN_STATE → 304 mapping, breaks existing error logic
-- **Querying containers without updating Registry cache:** Stale ID lookups, mutations fail with "container not found"
-- **Using Docker container IDs in GraphQL calls:** Unraid expects PrefixedID format, Docker IDs are incompatible
-- **Implementing custom restart via low-level operations:** Unraid doesn't expose container create/remove — use stop + start pattern
-
----
-
-## Don't Hand-Roll
-
-| Problem | Don't Build | Use Instead | Why |
-|---------|-------------|-------------|-----|
-| GraphQL response transformation | Custom mapping for each Code node | Phase 15 GraphQL Response Normalizer | 60+ Code nodes expect Docker contract, normalizer handles all |
-| Container ID translation | Ad-hoc lookups in each workflow | Phase 15 Container ID Registry | Single source of truth, cache management, name resolution |
-| Error code mapping | Custom error checks per node | Phase 15 GraphQL Error Handler | Standardized ALREADY_IN_STATE → 304, NOT_FOUND handling |
-| Callback data encoding | Custom compression/truncation | Phase 15 Callback Token Encoder | Deterministic 8-char hash, 64-byte limit compliance |
-| Restart mutation | Try to recreate container via GraphQL | Sequential stop + start | Unraid abstracts low-level ops, no create/remove exposed |
-
-**Key insight:** Phase 15 infrastructure was built specifically to make this migration low-risk. Using it prevents cascading changes across 60+ nodes.
-
----
-
-## Common Pitfalls
-
-### Pitfall 1: Forgetting to Update Container ID Registry Cache
-
-**What goes wrong:** User updates container via bot. Next command uses stale registry cache, mutation fails with "container not found: server_hash:old_container_hash".
-
-**Why it happens:** `updateContainer` mutation recreates the container with a new ID (same as Docker update flow). Registry still has the old PrefixedID.
-
-**How to avoid:**
-1. After every GraphQL query/mutation that returns container data, wire through Registry's "updateCache" action
-2. Extract normalized containers from response, pass to Registry
-3. Registry refreshes name → PrefixedID mappings
-
-**Warning signs:**
-- Mutation succeeds, but next command on same container fails
-- "Container not found" errors after successful updates
-- Registry lookup returns PrefixedID that doesn't exist in Unraid
-
-**Prevention pattern:**
-```javascript
-// After updateContainer mutation:
-// 1. Normalize response (get updated container object)
-// 2. Update Registry cache:
-//    Input: { action: "updateCache", containers: [normalizedContainer] }
-// 3. Proceed with success message
-```
-
-**Source:** Docker behavior (container ID changes on recreate), Phase 15-01 design
-
----
-
-### Pitfall 2: GraphQL Timeout on Slow Update Operations
-
-**What goes wrong:** `updateContainer` mutation for large container (10GB+ image) times out at 15 seconds, leaving container in intermediate state (stopped, old image removed).
-
-**Why it happens:** Phase 15 HTTP Template uses 15-second timeout for myunraid.net cloud relay latency. Container updates can take 30+ seconds for large images.
-
-**How to avoid:**
-1. **Increase timeout for update mutations specifically:** Duplicate HTTP Template, set timeout to 60000ms (60s) for updateContainer/updateContainers nodes
-2. **Keep 15s timeout for queries and quick mutations** (start/stop)
-3. Document in ARCHITECTURE.md: "Update operations have 60s timeout to accommodate large image pulls"
-
-**Warning signs:**
-- Timeout errors during container updates (not start/stop)
-- Containers stuck in "stopped" state after timeout
-- Unraid shows "pulling image" in Docker tab, but bot reports failure
-
-**Recommended timeouts by operation:**
-- Queries (containers list): 15s (current)
-- Start/stop/restart: 15s (current)
-- Single container update: 60s (increase)
-- Batch updates: 120s (increase further)
-
-**Source:** Real-world Docker image pull times (10GB+ images take 20-30s on gigabit), myunraid.net relay adds 200-500ms per request
-
----
-
-### Pitfall 3: ALREADY_IN_STATE Not Mapped to HTTP 304
-
-**What goes wrong:** User taps "Start" on running container. GraphQL returns ALREADY_IN_STATE error. Existing Code node expects `statusCode === 304`, throws generic error instead of "already started" message.
-
-**Why it happens:** Forgetting to wire GraphQL Error Handler between HTTP Request and existing Code node.
-
-**How to avoid:**
-1. **Every GraphQL mutation HTTP Request node MUST wire through GraphQL Error Handler**
-2. Error Handler maps `error.extensions.code === "ALREADY_IN_STATE"` → `{ statusCode: 304, alreadyInState: true }`
-3. Existing Code nodes check `response.statusCode === 304` unchanged
-
-**Warning signs:**
-- Generic error messages instead of "Container already started"
-- Errors when user repeats same action (stop stopped container, etc.)
-- Code nodes throwing on ALREADY_IN_STATE instead of graceful handling
-
-**Correct wiring:**
-```
-HTTP Request (GraphQL mutation)
-  ↓
-GraphQL Error Handler (maps ALREADY_IN_STATE → 304)
-  ↓
-Existing Code node (checks statusCode === 304)
-```
-
-**Source:** Phase 15-02 Plan (GraphQL Error Handler implementation), n8n-actions.json existing pattern
-
----
-
-### Pitfall 4: Restart Implementation Without Error Handling
-
-**What goes wrong:** Restart operation calls `stop` mutation, which fails with ALREADY_IN_STATE (container already stopped). Sequential `start` mutation never executes, user sees error.
-
-**Why it happens:** Implementing restart as sequential `stop` + `start` without ALREADY_IN_STATE tolerance.
-
-**How to avoid:**
-1. **Stop mutation:** Wire through Error Handler, **continue on 304** (already stopped is OK)
-2. **Start mutation:** Wire through Error Handler, fail on ALREADY_IN_STATE for start (indicates logic error)
-3. Use n8n "Continue On Fail" or explicit error checking in Code node
-
-**Correct implementation:**
-```
-1. Stop mutation → Error Handler
-   - On 304: Continue to start (container was already stopped, fine)
-   - On error: Fail restart operation
-2. Start mutation → Error Handler
-   - On success: Return "restarted" message
-   - On 304: Fail (container started during restart, unexpected)
-   - On error: Fail restart operation
-```
-
-**Alternative:** Check container state first, only stop if running. Adds latency but avoids ALREADY_IN_STATE on stop.
-
-**Source:** Unraid GraphQL schema (no native restart mutation), standard restart logic patterns
-
----
-
-### Pitfall 5: Batch Update Progress Not Visible
-
-**What goes wrong:** User selects 10 containers for batch update. Bot sends "Updating..." then silence for 2 minutes, then "Done". User doesn't know if bot is working or stuck.
-
-**Why it happens:** `updateContainers` mutation is atomic — returns only after all containers updated. No progress events.
-
-**How to avoid:**
-1. **Keep existing Docker pattern:** Serial updates with Telegram message edits per container
-2. **Alternative (faster but no progress):** Use `updateContainers` mutation, send initial "Updating X containers..." then final result
-3. **Hybrid (recommended):** Small batches (≤5) use `updateContainers` for speed, large batches (>5) use serial with progress
-
-**Implementation for hybrid:**
-```javascript
-// In batch update Code node:
-if (selectedContainers.length <= 5) {
-  // Fast path: Single updateContainers mutation
-  const ids = selectedContainers.map(c => lookupPrefixedId(c.name));
-  await updateContainers(ids);
-  return { message: `Updated ${selectedContainers.length} containers` };
-} else {
-  // Progress path: Serial updates with Telegram edits
-  for (const container of selectedContainers) {
-    await updateContainer(container.prefixedId);
-    await editTelegramMessage(`Updated ${i}/${total}: ${container.name}`);
-  }
-}
-```
-
-**Tradeoff:** Progress visibility vs speed. User decision from v1.2 batch work: progress is important.
-
-**Source:** v1.2 batch operations design, user feedback on "silent operations"
-
----
-
-### Pitfall 6: Update Badge Still Shows After Bot Update
-
-**What goes wrong:** User updates container via bot. Unraid Docker tab still shows "apply update" badge. User clicks badge, update completes instantly (image already cached).
-
-**Why it happens:** This is **the problem v1.4 solves**. If it still occurs, GraphQL mutation isn't properly clearing Unraid's internal update tracking.
-
-**How to avoid:**
-1. **Verify GraphQL mutation returns success** (not just HTTP 200, but valid container object)
-2. **Check Unraid version:** Update badge sync requires Unraid 7.2+ or Connect plugin with recent version
-3. **Test in real environment:** Synthetic tests may not reveal badge state issues
-
-**Verification test:**
-```bash
-# 1. Via bot: Update container
-# 2. Check Unraid Docker tab: Badge should be GONE
-# 3. If badge remains: Check Unraid logs for GraphQL mutation execution
-# 4. If logs show success but badge remains: Unraid bug, report to Unraid team
-```
-
-**Expected behavior (success):** After `updateContainer` mutation completes, refreshing Unraid Docker tab shows no update badge for that container.
-
-**If badge persists:** Check Unraid API version, verify mutation actually executed (not just HTTP success), check Unraid internal logs (`/var/log/syslog`).
-
-**Source:** v1.3 Known Limitations (update badge issue), v1.4 migration goal, Unraid GraphQL API design
-
----
-
-## Code Examples
-
-### Container List Query Migration
-
-```javascript
-// BEFORE (Docker API):
-// HTTP Request node: GET http://docker-socket-proxy:2375/containers/json?all=true
-// Next node (Code): processes response as-is
-
-// AFTER (Unraid GraphQL):
-// HTTP Request node (duplicate "Unraid API HTTP Template"):
-{
-  "method": "POST",
-  "url": "={{ $env.UNRAID_HOST }}/graphql",
-  "body": {
-    "query": "query { docker { containers { id names state image } } }"
-  }
-}
-
-// Wire: HTTP Request → GraphQL Response Normalizer → Update Container ID Registry → (existing Code nodes)
-
-// Normalizer transforms:
-// IN:  { data: { docker: { containers: [{ id: "hash:hash", names: ["/plex"], state: "RUNNING" }] } } }
-// OUT: [{ Id: "hash:hash", Names: ["/plex"], State: "running", _unraidId: "hash:hash" }]
-
-// Registry update (Code node after normalizer):
-const containers = $input.all().map(item => item.json);
-const registryInput = {
-  action: "updateCache",
-  containers: containers
-};
-// Pass to Container ID Registry node
-
-// Existing Code nodes see Docker API format unchanged
-```
-
-**Source:** Phase 15-02 normalizer implementation, ARCHITECTURE.md Docker API contract
-
----
-
-### Container Start Mutation Migration
-
-```javascript
-// BEFORE (Docker API):
-// HTTP Request: POST http://docker-socket-proxy:2375/v1.47/containers/abc123/start
-// Code node checks: if (response.statusCode === 304) { /* already started */ }
-
-// AFTER (Unraid GraphQL):
-// Step 1: Lookup PrefixedID (Code node before HTTP Request)
-const containerName = $json.containerName; // From upstream input
-const registryLookup = {
-  action: "lookup",
-  containerName: containerName
-};
-// Pass to Container ID Registry → returns { prefixedId: "...", found: true }
-
-// Step 2: Build mutation (Code node prepares GraphQL body)
-const prefixedId = $('Container ID Registry').item.json.prefixedId;
-return {
-  json: {
-    query: `mutation { docker { start(id: "${prefixedId}") { id state } } }`
-  }
-};
-
-// Step 3: Execute mutation (HTTP Request, uses Unraid API HTTP Template)
-// Body: {{ $json.query }}
-
-// Step 4: Handle errors (wire through GraphQL Error Handler)
-// Error Handler maps ALREADY_IN_STATE → { statusCode: 304, alreadyInState: true }
-
-// Step 5: Existing Code node (unchanged)
-const response = $input.item.json;
-if (response.statusCode === 304) {
-  return { json: { message: "Container already started" } };
-}
-if (response.success) {
-  return { json: { message: "Container started successfully" } };
-}
-```
-
-**Source:** Phase 15 utility node integration, n8n-actions.json existing error handling
-
----
-
-### Single Container Update Mutation Migration
-
-```javascript
-// BEFORE (Docker API 5-step flow in n8n-update.json):
-// 1. Inspect container → get image digest
-// 2. Stop container
-// 3. Remove container
-// 4. Create container (pulls new image)
-// 5. Start container
-// 6. Remove old image
-// Total: 6 HTTP Request nodes, 8 Code nodes for orchestration
-
-// AFTER (Unraid GraphQL):
-// Step 1: Get current container state (for imageId comparison)
-const containerName = $json.containerName;
-// Query: { docker { containers { id image imageId } } } (filter by name)
-
-// Step 2: Lookup PrefixedID
-// Registry input: { action: "lookup", containerName: containerName }
-
-// Step 3: Single mutation
-const prefixedId = $('Container ID Registry').item.json.prefixedId;
-const oldImageId = $json.currentImageId; // From step 1
-return {
-  json: {
-    query: `mutation { docker { updateContainer(id: "${prefixedId}") { id state image imageId } } }`
-  }
-};
-
-// Step 4: Execute mutation (HTTP Request with 60s timeout)
-
-// Step 5: Normalize response and check if updated
-// GraphQL Response Normalizer → Code node:
-const response = $input.item.json;
-const newImageId = response.imageId;
-const updated = (newImageId !== oldImageId);
-
-if (updated) {
-  return {
-    json: {
-      success: true,
-      updated: true,
-      message: `Updated ${containerName}: ${oldImageId.slice(0,12)} → ${newImageId.slice(0,12)}`
-    }
-  };
-} else {
-  return {
-    json: {
-      success: true,
-      updated: false,
-      message: `No update available for ${containerName}`
-    }
-  };
-}
-
-// Total: 3 HTTP Request nodes (query current, lookup ID, update mutation), 3 Code nodes
-// Reduction: 6 → 3 HTTP nodes, 8 → 3 Code nodes
-```
-
-**Source:** n8n-update.json current implementation, Unraid GraphQL schema updateContainer mutation
-
----
-
-### Batch Update Migration
-
-```javascript
-// BEFORE (Docker API): Loop in Code node, Execute Workflow sub-workflow call per container (serial)
-
-// AFTER (Unraid GraphQL):
-// Option A: Small batch (≤5 containers) — parallel mutation
-const selectedNames = $json.selectedContainers.split(',');
-
-// Lookup all PrefixedIDs
-const ids = [];
-for (const name of selectedNames) {
-  const result = lookupInRegistry(name); // Call Registry node
-  ids.push(result.prefixedId);
-}
-
-// Single mutation
-return {
-  json: {
-    query: `mutation { docker { updateContainers(ids: ${JSON.stringify(ids)}) { id state imageId } } }`
-  }
-};
-
-// HTTP Request (120s timeout for batch) → Normalizer → Success message
-
-// Option B: Large batch (>5 containers) — serial with progress
-// Keep existing pattern: loop + Execute Workflow calls, replace inner logic with GraphQL mutation
-
-// Hybrid recommendation:
-const batchSize = selectedNames.length;
-if (batchSize <= 5) {
-  // Use updateContainers mutation (Option A)
-} else {
-  // Use serial loop with Telegram progress updates (Option B)
-}
-```
-
-**Source:** n8n-batch-ui.json, Unraid GraphQL schema updateContainers mutation
-
----
-
-### Restart Implementation (Sequential Stop + Start)
-
-```javascript
-// Unraid has no native restart mutation — implement as two operations
-
-// Step 1: Stop mutation (tolerate ALREADY_IN_STATE)
-const prefixedId = $json.prefixedId;
-return {
-  json: {
-    query: `mutation { docker { stop(id: "${prefixedId}") { id state } } }`
-  }
-};
-
-// HTTP Request → GraphQL Error Handler
-// Error Handler output: { statusCode: 304, alreadyInState: true } OR { success: true }
-
-// Step 2: Check stop result (Code node)
-const stopResult = $input.item.json;
-if (stopResult.statusCode === 304 || stopResult.success) {
-  // Container stopped (or was already stopped) — proceed to start
-  return { json: { proceedToStart: true } };
-}
-// Other errors fail the restart
-
-// Step 3: Start mutation
-return {
-  json: {
-    query: `mutation { docker { start(id: "${prefixedId}") { id state } } }`
-  }
-};
-
-// HTTP Request → Error Handler → Success
-
-// Wiring: Stop HTTP → Error Handler → Check Result IF → Start HTTP → Error Handler → Format Result
-```
-
-**Source:** Unraid GraphQL schema (no restart mutation), standard restart implementation pattern
-
----
-
-## State of the Art
-
-| Old Approach | Current Approach | When Changed | Impact |
-|--------------|------------------|--------------|--------|
-| Docker REST API via socket proxy | Unraid GraphQL API via myunraid.net relay | This phase (v1.4) | Single API, update badge sync, no proxy security boundary |
-| 5-step update flow (stop/remove/create/start) | Single `updateContainer` mutation | This phase | Simpler, faster, Unraid handles retry logic |
-| Serial batch updates with progress | `updateContainers` plural mutation for small batches | This phase | Parallel execution, faster for ≤5 containers |
-| Docker 64-char container IDs | Unraid 129-char PrefixedID with Registry mapping | Phase 15-16 | Requires translation layer, but enables GraphQL API |
-| Manual "Apply Update" in Unraid UI | Automatic badge clear via GraphQL | This phase | Core user pain point solved |
-
-**Deprecated/outdated:**
-- **docker-socket-proxy container:** Removed in Phase 17, GraphQL API replaces Docker socket access
-- **Container logs feature:** Removed in Phase 17, not valuable enough to maintain hybrid architecture
-- **Direct Docker container ID storage:** Replaced by Container ID Registry lookups (PrefixedID required)
-
-**Current best practice (post-Phase 16):** All container operations via Unraid GraphQL API. Docker socket proxy is legacy artifact.
-
----
-
-## Open Questions
-
-1. **Actual updateContainer mutation timeout needs**
-   - What we know: Large images (10GB+) can take 30+ seconds to pull
-   - What's unclear: Does myunraid.net relay timeout separately? Will 60s be enough for all cases?
-   - Recommendation: Start with 60s timeout, add workflow logging to capture actual duration, adjust if needed
-
-2. **Batch update progress tradeoff**
-   - What we know: `updateContainers` is fast but silent, serial updates show progress but slow
-   - What's unclear: User preference — speed or visibility?
-   - Recommendation: Hybrid approach (≤5 fast, >5 with progress), can adjust threshold based on user feedback
-
-3. **Restart error handling edge cases**
-   - What we know: Stop + start pattern works, need to tolerate ALREADY_IN_STATE on stop
-   - What's unclear: What if container exits between stop and start? Retry logic needed?
-   - Recommendation: Implement basic stop→start, add retry if real-world issues occur
-
-4. **Container ID Registry cache invalidation**
-   - What we know: Registry caches name → PrefixedID mapping, must refresh after updates
-   - What's unclear: Cache expiry strategy? Time-based TTL or event-driven only?
-   - Recommendation: Event-driven only (update after every GraphQL query/mutation), no TTL needed
-
----
-
-## Sources
-
-### Primary (HIGH confidence)
-- [Unraid GraphQL Schema](https://raw.githubusercontent.com/unraid/api/main/api/generated-schema.graphql) — Mutation signatures, DockerContainer type fields
-- [Using the Unraid API](https://docs.unraid.net/API/how-to-use-the-api/) — Authentication, endpoint, rate limiting
-- Phase 15-01 Plan — Container ID Registry, Callback Token Encoder/Decoder implementation
-- Phase 15-02 Plan — GraphQL Response Normalizer, Error Handler, HTTP Template implementation
-- ARCHITECTURE.md — Current Docker API contracts, workflow node breakdown, error patterns
-
-### Secondary (MEDIUM confidence)
-- [Docker and VM Integration | Unraid API](https://deepwiki.com/unraid/api/2.4.2-notification-system) — Unraid update implementation details (shells to Dynamix Docker Manager)
-- [Core Services | Unraid API](https://deepwiki.com/unraid/api/2.4-docker-integration) — DockerService retry logic (5 polling attempts at 500ms intervals)
-- n8n-update.json — Current 5-step Docker update flow implementation
-- n8n-actions.json — Current start/stop error handling pattern (statusCode === 304 check)
-- n8n-status.json — Current container list query pattern
-
-### Tertiary (LOW confidence)
-- Community forum posts on Unraid container updates — Anecdotal timing data for large image pulls
-- Real-world myunraid.net relay latency observations — 200-500ms baseline from Phase 14 testing
-
----
-
-## Metadata
-
-**Confidence breakdown:**
-- Standard stack: HIGH — Unraid GraphQL API verified in Phase 14, Phase 15 infrastructure already built
-- Architecture: HIGH — Migration patterns are straightforward substitutions, Phase 15 utilities handle complexity
-- Pitfalls: MEDIUM-HIGH — Most are standard API migration issues, actual timeout needs and batch tradeoffs require real-world testing
-
-**Research date:** 2026-02-09
-**Valid until:** 60 days (Unraid GraphQL API stable, schema changes infrequent)
-
-**Critical dependencies for planning:**
-- Phase 15 utility nodes deployed and tested (Container ID Registry, GraphQL Normalizer, Error Handler, HTTP Template)
-- Phase 14 Unraid API access verified (credentials, network connectivity, authentication working)
-- n8n workflow JSON structure understood (node IDs, connections, typeVersion patterns from CLAUDE.md)
-
-**Migration risk assessment:**
-- **Low risk:** Container queries (status, list) — direct substitution, normalizer handles response shape
-- **Medium risk:** Container lifecycle (start/stop/restart) — ALREADY_IN_STATE error mapping critical, restart needs sequential implementation
-- **Medium risk:** Single container update — timeout configuration important, imageId comparison for success detection
-- **Medium-high risk:** Batch updates — tradeoff between speed and progress visibility, hybrid approach recommended
-
-**Ready for planning:** YES — Clear migration patterns identified, Phase 15 infrastructure ready, pitfalls documented, code examples provided for each operation type.

.planning/phases/16-api-migration/16-UAT.md

@@ -1,109 +0,0 @@
----
-status: diagnosed
-phase: 16-api-migration
-source: 16-01-SUMMARY.md, 16-02-SUMMARY.md, 16-03-SUMMARY.md, 16-04-SUMMARY.md, 16-05-SUMMARY.md, 16-06-SUMMARY.md
-started: 2026-02-09T16:00:00Z
-updated: 2026-02-09T16:20:00Z
----
-
-## Current Test
-<!-- OVERWRITE each test - shows where we are -->
-
-[testing complete]
-
-## Tests
-
-### 1. View Container List
-expected: Send a status/list command to the bot. You see a list of containers with names and states (running/stopped). Response completes within a few seconds.
-result: pass
-
-### 2. View Container Status Submenu
-expected: Tap a container from the list. You see a detail submenu showing the container's name, state, and action buttons (Start/Stop/Restart/Update).
-result: pass
-
-### 3. Start a Stopped Container
-expected: From a stopped container's submenu, tap Start. You see a success message confirming the container was started.
-result: pass
-
-### 4. Stop a Running Container
-expected: From a running container's submenu, tap Stop. You see a success message confirming the container was stopped.
-result: pass
-
-### 5. Restart a Container
-expected: From a container's submenu, tap Restart. You see a success message confirming the container was restarted (internally this is a stop + start sequence).
-result: pass
-
-### 6. Start an Already-Running Container
-expected: From an already-running container's submenu, tap Start. You see a message like "already started" (NOT an error). This is idempotent behavior.
-result: pass
-note: UI correctly hides Start button when container is already running — no idempotent case possible via UI
-
-### 7. Update a Single Container
-expected: From a container's submenu, tap Update. The bot begins updating the container. You see a result message indicating success (updated) or "already up to date" if no update was available.
-result: issue
-reported: "This does not work. It gets past the confirmation window but then there are execution errors on the main flow and container update flows"
-severity: blocker
-
-### 8. Batch Container Selection UI
-expected: Trigger the batch selection flow (e.g. batch/update-all command). You see an inline keyboard listing containers with checkboxes. You can toggle containers on/off and navigate pages if many containers exist.
-result: issue
-reported: "Batch selection works, but the cancel button on the batch confirmation does not work"
-severity: major
-
-### 9. Text Command: Action on Container
-expected: Send a text command like "start plex" or "stop sonarr". The bot performs the action and returns a success/error message — same behavior as the inline keyboard path.
-result: issue
-reported: "Start and stop text commands do not work, and additionally batch text command confirmation dialog has no actionable buttons to proceed"
-severity: blocker
-
-## Summary
-
-total: 9
-passed: 6
-issues: 3
-pending: 0
-skipped: 0
-
-## Gaps
-
-- truth: "User can update a single container via inline keyboard and see success/up-to-date message"
-  status: fixed
-  reason: "User reported: This does not work. It gets past the confirmation window but then there are execution errors on the main flow and container update flows"
-  severity: blocker
-  test: 7
-  root_cause: "3 bugs in n8n-update.json: (1) Query Single Container used unsupported filter argument, (2) Return Error referenced nonexistent Format Pull Error node, (3) Capture Pre-Update State had case mismatch data.image vs data.Image"
-  artifacts:
-    - path: "n8n-update.json"
-      issue: "GraphQL filter argument not supported by Unraid API; node reference and field case bugs"
-  missing:
-    - "Remove filter from GraphQL query, filter client-side in normalizer"
-    - "Fix node reference to Format Update Error"
-    - "Fix field case to data.Image"
-  debug_session: ".planning/debug/update-flow-errors.md"
-
-- truth: "Cancel button on batch confirmation returns user to previous state"
-  status: fixed
-  reason: "User reported: Batch selection works, but the cancel button on the batch confirmation does not work"
-  severity: major
-  test: 8
-  root_cause: "Route Callback switch node output index 20 (batchcancel) wired to empty connection array [] — dead end. All other batch outputs (14-19) correctly connected to Prepare Batch UI Input."
-  artifacts:
-    - path: "n8n-workflow.json"
-      issue: "Route Callback output 20 (batchcancel) had empty connection array"
-  missing:
-    - "Connect output 20 to Prepare Batch UI Input matching other batch outputs"
-  debug_session: ".planning/debug/batch-cancel-broken.md"
-
-- truth: "Text commands (start/stop) perform actions and batch text command shows actionable confirmation"
-  status: fixed
-  reason: "User reported: Start and stop text commands do not work, and additionally batch text command confirmation dialog has no actionable buttons to proceed"
-  severity: blocker
-  test: 9
-  root_cause: "Two bugs: (1) Phase 16-06 GraphQL chain expansion breaks paired item tracking — $('NodeName').item.json fails after Execute Match sub-workflow. (2) Send Batch Confirmation Telegram node double-serializes reply_markup, Telegram silently ignores malformed buttons."
-  artifacts:
-    - path: "n8n-workflow.json"
-      issue: "Prepare Text Action Input and Prepare Batch Execution use .item.json which fails after paired item break; Send Batch Confirmation uses Telegram node that double-serializes reply_markup"
-  missing:
-    - "Change .item.json to .first().json in Prepare Text Action Input and Prepare Batch Execution"
-    - "Convert Send Batch Confirmation from Telegram node to HTTP Request node"
-  debug_session: ".planning/debug/text-commands-broken.md"

.planning/phases/16-api-migration/16-VERIFICATION.md

@@ -1,224 +0,0 @@
----
-phase: 16-api-migration
-verified: 2026-02-09T19:30:00Z
-status: passed
-score: 6/6
-re_verification:
-  previous_status: gaps_found
-  previous_score: 3/6
-  gaps_closed:
-    - "Text command 'start/stop/restart <container>' now queries via GraphQL"
-    - "Text command 'update <container>' now queries via GraphQL"
-    - "Text command 'batch' now queries via GraphQL"
-  gaps_remaining: []
-  regressions: []
-human_verification:
-  - test: "Send 'start plex' text command via Telegram"
-    expected: "Bot queries via GraphQL, calls n8n-actions.json, shows success/failure"
-    why_human: "Verify end-to-end text command path through GraphQL"
-  - test: "Send 'update sonarr' text command via Telegram"
-    expected: "Bot queries via GraphQL, calls n8n-update.json, shows version change"
-    why_human: "Verify text command update path works end-to-end"
-  - test: "Use inline keyboard 'Start' button on stopped container"
-    expected: "Container starts, bot shows success message"
-    why_human: "Visual confirmation that GraphQL path works (already verified in previous check)"
-  - test: "Use inline keyboard 'Update' button on container with available update"
-    expected: "Container updates, bot shows 'updated: old -> new', Unraid badge clears"
-    why_human: "Visual confirmation of GraphQL updateContainer + automatic badge clearing"
-  - test: "Execute 'update all' with 3 containers"
-    expected: "Batch completes in 5-10 seconds with success message"
-    why_human: "Verify parallel updateContainers mutation works (batch <=5)"
-  - test: "Execute 'update all' with 10 containers"
-    expected: "Serial updates with per-container progress messages"
-    why_human: "Verify hybrid batch logic (batch >5 uses serial path)"
----
-
-# Phase 16: API Migration Re-Verification Report
-
-**Phase Goal:** All container operations work via Unraid GraphQL API
-**Verified:** 2026-02-09T19:30:00Z
-**Status:** PASSED
-**Re-verification:** Yes — after Plan 16-06 gap closure
-
-## Re-Verification Summary
-
-**Previous status:** GAPS_FOUND (3/6 truths verified)
-**Current status:** PASSED (6/6 truths verified)
-
-**Gaps closed:** 3
-1. Text command 'start/stop/restart <container>' migrated to GraphQL
-2. Text command 'update <container>' migrated to GraphQL
-3. Text command 'batch' migrated to GraphQL
-
-**Regressions:** None detected
-**New issues:** 1 orphan node (non-blocking)
-
-## Goal Achievement
-
-### Observable Truths
-
-| # | Truth | Status | Evidence |
-|---|-------|--------|----------|
-| 1 | User can view container status via Unraid API (same UX as before) | ✓ VERIFIED | n8n-status.json: 3/3 queries migrated to GraphQL, zero docker-socket-proxy refs, sub-workflow called 4x from main workflow |
-| 2 | User can start, stop, restart containers via Unraid API | ✓ VERIFIED | n8n-actions.json fully migrated (5/5 GraphQL mutations) + text commands now use GraphQL query chains (3 new nodes in main workflow) |
-| 3 | User can update single container via Unraid API (single mutation replaces 5-step Docker flow) | ✓ VERIFIED | n8n-update.json fully migrated (updateContainer mutation, 60s timeout) + text command 'update <container>' uses GraphQL query chain |
-| 4 | User can batch update multiple containers via Unraid API | ✓ VERIFIED | n8n-batch-ui.json fully migrated (5/5 GraphQL queries) + text command 'batch' uses GraphQL query chain + hybrid updateContainers mutation wired |
-| 5 | User can "update all :latest" via Unraid API | ✓ VERIFIED | Hybrid batch update: <=5 containers use parallel updateContainers mutation (120s timeout), >5 use serial sub-workflow calls. Zero Docker proxy refs in update-all path |
-| 6 | Unraid update badges clear automatically after bot-initiated updates (no manual sync) | ✓ VERIFIED | updateContainer mutation handles badge clearing (Unraid 7.2+), verified in n8n-update.json implementation |
-
-**Score:** 6/6 truths fully verified (was 3/6 partial)
-
-### Required Artifacts
-
-| Artifact | Expected | Status | Details |
-|----------|----------|--------|---------|
-| `n8n-status.json` | Container status queries via GraphQL | ✓ VERIFIED | 17 nodes, 3 GraphQL HTTP Request nodes, 3 normalizers, 3 registry updates, zero docker-socket-proxy refs |
-| `n8n-actions.json` | Lifecycle mutations via GraphQL | ✓ VERIFIED | 21 nodes, 5 GraphQL HTTP Request nodes (query + start/stop mutations + restart chain), 1 normalizer, zero docker-socket-proxy refs |
-| `n8n-update.json` | Single updateContainer mutation | ✓ VERIFIED | 29 nodes (reduced from 34), 3 GraphQL HTTP nodes (2 queries + 1 mutation), 60s timeout, zero docker-socket-proxy refs |
-| `n8n-batch-ui.json` | Batch selection queries via GraphQL | ✓ VERIFIED | 22 nodes, 5 GraphQL HTTP Request nodes, 5 normalizers, zero docker-socket-proxy refs |
-| `n8n-workflow.json` | Main workflow with GraphQL queries | ✓ VERIFIED | 187 nodes (was 181, +9 new, -3 removed), 12 GraphQL HTTP nodes, 10 normalizers, 10 registry updates, ZERO Execute Command nodes, ZERO docker-socket-proxy API refs |
-
-### Key Link Verification
-
-| From | To | Via | Status | Details |
-|------|----|----|--------|---------|
-| n8n-status.json HTTP nodes | Unraid GraphQL API | POST to `$env.UNRAID_HOST/graphql` | ✓ WIRED | 3 container queries, 15s timeout, Header Auth credential |
-| n8n-actions.json HTTP nodes | Unraid GraphQL API | POST mutations (start, stop, restart chain) | ✓ WIRED | 5 mutations, ALREADY_IN_STATE mapped to statusCode 304 |
-| n8n-update.json HTTP node | Unraid GraphQL API | POST updateContainer mutation | ✓ WIRED | 60s timeout, ImageId comparison for update detection |
-| n8n-batch-ui.json HTTP nodes | Unraid GraphQL API | POST container queries | ✓ WIRED | 5 queries (mode/toggle/exec/nav/clear paths) |
-| Main workflow GraphQL nodes | Unraid GraphQL API | POST queries/mutations | ✓ WIRED | 12 GraphQL nodes active (9 queries + hybrid batch mutation) |
-| Main workflow Execute Workflow nodes | Sub-workflows | n8n-actions.json, n8n-update.json, n8n-status.json, n8n-batch-ui.json | ✓ WIRED | 17 Execute Workflow nodes, all sub-workflows integrated |
-| Container ID Registry | Sub-workflow mutations | Name→PrefixedID mapping in static data | ✓ WIRED | Updated after every GraphQL query (10 registry update nodes), used by all mutations |
-| **Text command 'start/stop/restart'** | **GraphQL API** | **Query Containers for Action → Normalize → Registry → n8n-actions.json** | ✓ WIRED | New 3-node chain replaces Execute Command |
-| **Text command 'update'** | **GraphQL API** | **Query Containers for Update → Normalize → Registry → n8n-update.json** | ✓ WIRED | New 3-node chain replaces Execute Command |
-| **Text command 'batch'** | **GraphQL API** | **Query Containers for Batch → Normalize → Registry → n8n-batch-ui.json** | ✓ WIRED | New 3-node chain replaces Execute Command |
-
-### Requirements Coverage
-
-Phase 16 maps to 8 requirements (API-01 through API-08):
-
-| Requirement | Status | Evidence |
-|-------------|--------|----------|
-| API-01: Container status query via GraphQL | ✓ SATISFIED | n8n-status.json: 3 queries, all paths use GraphQL |
-| API-02: Container start via GraphQL | ✓ SATISFIED | n8n-actions.json: startContainer mutation + text command path migrated |
-| API-03: Container stop via GraphQL | ✓ SATISFIED | n8n-actions.json: stopContainer mutation + text command path migrated |
-| API-04: Container restart via GraphQL (stop+start) | ✓ SATISFIED | n8n-actions.json: sequential stop→start chain + text command path migrated |
-| API-05: Single updateContainer mutation | ✓ SATISFIED | n8n-update.json: updateContainer mutation + text command path migrated |
-| API-06: Batch updateContainers mutation | ✓ SATISFIED | n8n-batch-ui.json + hybrid mutation + text command entry migrated |
-| API-07: "Update all :latest" via GraphQL | ✓ SATISFIED | Hybrid batch update fully migrated (parallel/serial paths) |
-| API-08: Unraid update badges clear automatically | ✓ SATISFIED | updateContainer mutation inherent behavior (Unraid 7.2+) |
-
-**Coverage:** 8/8 fully satisfied (was 3/8 full, 5/8 partial)
-
-### Anti-Patterns Found
-
-| File | Line | Pattern | Severity | Impact |
-|------|------|---------|----------|--------|
-| n8n-workflow.json | 2983 | String "docker-socket-proxy" in Code node | ℹ️ Info | ALLOWED — infra exclusion filter in "Prepare Update All Batch" (Phase 17 scope) |
-| n8n-workflow.json | - | 1 orphan node: "Prepare Cancel Return" | ℹ️ Info | No incoming connections, safe to delete in Phase 17 cleanup |
-
-**Critical check:** ZERO docker-socket-proxy API endpoints remain. The 1 string reference is in an infra exclusion filter (filters out socket-proxy container from update-all batches), which is Phase 17 cleanup scope.
-
-### Gap Closure Verification (Plan 16-06)
-
-**Previous gaps (from initial verification):**
-
-1. ✓ CLOSED: Text command "start/stop/restart <container>" used Docker proxy Execute Command
-   - **Fix:** Replaced "Docker List for Action" Execute Command with 3-node GraphQL chain: Query Containers for Action → Normalize Action Containers → Update Registry (Action) → Prepare Action Match Input
-   - **Evidence:** Connection verified, zero executeCommand nodes remain
-
-2. ✓ CLOSED: Text command "update <container>" used Docker proxy Execute Command
-   - **Fix:** Replaced "Docker List for Update" Execute Command with 3-node GraphQL chain: Query Containers for Update → Normalize Update Containers → Update Registry (Update) → Prepare Update Match Input
-   - **Evidence:** Connection verified, zero executeCommand nodes remain
-
-3. ✓ CLOSED: Text command "batch" used Docker proxy Execute Command
-   - **Fix:** Replaced "Get Containers for Batch" Execute Command with 3-node GraphQL chain: Query Containers for Batch → Normalize Batch Containers → Update Registry (Batch) → Prepare Batch Match Input
-   - **Evidence:** Connection verified, zero executeCommand nodes remain
-
-**Auth configuration check:**
-- All 3 new HTTP Request nodes use `authentication: genericCredentialType` + `genericAuthType: httpHeaderAuth`
-- All 3 use Header Auth credential (no manual `x-api-key` headers)
-- All 3 POST to `={{ $env.UNRAID_HOST }}/graphql`
-
-**Connection integrity check:**
-- All connection keys use node NAMES (not IDs)
-- All connection targets use node NAMES (not IDs)
-- All chains verified: Parse Command → Query → Normalize → Registry → Prepare Match
-
-**Node count verification:**
-- Expected: 181 (before) + 9 (new nodes: 3 queries + 3 normalizers + 3 registries) - 3 (removed Execute Commands) = 187
-- Actual: 187 ✓
-
-### Human Verification Required
-
-**Note:** These tests verify end-to-end user experience. All programmatic checks (code structure, connections, auth config) passed.
-
-1. **Text command 'start plex'**
-   - **Test:** Send "start plex" via Telegram
-   - **Expected:** Bot queries containers via GraphQL, calls n8n-actions.json, container starts, shows success
-   - **Why human:** Verify text command path works end-to-end after migration
-
-2. **Text command 'update sonarr'**
-   - **Test:** Send "update sonarr" via Telegram
-   - **Expected:** Bot queries containers via GraphQL, calls n8n-update.json, shows "updated: v1 → v2"
-   - **Why human:** Verify text command update path works end-to-end after migration
-
-3. **Text command 'batch'**
-   - **Test:** Send "batch" via Telegram
-   - **Expected:** Bot queries containers via GraphQL, shows batch UI with selection buttons
-   - **Why human:** Verify text command batch entry works end-to-end after migration
-
-4. **Inline keyboard 'Start' button**
-   - **Test:** Use inline keyboard to start a stopped container
-   - **Expected:** Container starts, bot shows success message
-   - **Why human:** Visual confirmation that GraphQL path works (already verified in initial check)
-
-5. **Inline keyboard 'Update' button**
-   - **Test:** Use inline keyboard to update a container with available update
-   - **Expected:** Container updates, bot shows "updated: v1 → v2", Unraid Docker tab update badge disappears
-   - **Why human:** Visual confirmation of GraphQL updateContainer + automatic badge clearing
-
-6. **'update all' with <=5 containers**
-   - **Test:** Execute 'update all' when 3-5 containers have updates
-   - **Expected:** Batch completes in 5-10 seconds with single success message
-   - **Why human:** Verify parallel updateContainers mutation path works
-
-7. **'update all' with >5 containers**
-   - **Test:** Execute 'update all' when 10+ containers have updates
-   - **Expected:** Serial updates with per-container progress messages
-   - **Why human:** Verify hybrid batch logic correctly chooses serial path for large batches
-
----
-
-## Phase Completion Assessment
-
-**Phase Goal:** All container operations work via Unraid GraphQL API
-**Status:** ACHIEVED ✓
-
-**Evidence:**
-- 6/6 observable truths verified
-- 8/8 requirements satisfied
-- Zero Docker socket proxy API endpoints remain
-- Zero Execute Command nodes remain
-- All text command paths migrated to GraphQL
-- All inline keyboard paths use GraphQL (verified in initial check)
-- All sub-workflows migrated to GraphQL
-- Container ID Registry updates on every query (10 update nodes)
-- Proper auth config (Header Auth credential, no manual headers)
-- All connections use node NAMES (no ID-based connections)
-
-**Ready for Phase 17:** YES
-- docker-socket-proxy can now be safely removed (zero API dependencies)
-- Only remaining reference is infra exclusion filter (cleanup scope)
-- Container logs feature already scheduled for removal in Phase 17
-
-**Minor cleanup for Phase 17:**
-- Remove orphan node: "Prepare Cancel Return"
-- Remove infra exclusion filter string "docker-socket-proxy" from "Prepare Update All Batch"
-- Update documentation to reflect Unraid API-native architecture
-
----
-
-_Verified: 2026-02-09T19:30:00Z_
-_Verifier: Claude (gsd-verifier)_
-_Re-verification after Plan 16-06 gap closure_

CLAUDE.md

@@ -201,7 +201,3 @@ unraid-api apikey --create \
   staticData._errorLog = JSON.stringify(errorLog);
   ```
 - **Keyword Router rule ordering**: `startsWith` rules (e.g., `/debug`, `/errors`) must come BEFORE generic `contains` rules (e.g., `status`, `start`), otherwise `/debug status` matches `contains "status"` first. Connection array indices must match rule indices, with fallback as the last slot.
-- **Connection JSON keys must be node NAMES, not IDs**: n8n resolves connections by matching keys to node `name` fields. Using node `id` values as connection keys creates silently broken wiring. Same rule for target `"node"` values inside connection arrays.
-- **Unraid GraphQL HTTP nodes must use Header Auth credential**: Do NOT use `$env.UNRAID_API_KEY` as a manual header — causes `Invalid CSRF token` errors. Correct config: `"authentication": "genericCredentialType"`, `"genericAuthType": "httpHeaderAuth"`, with `"credentials": { "httpHeaderAuth": { "id": "unraid-api-key-credential-id", "name": "Unraid API Key" } }`. Copy auth config from existing working nodes.
-- **Node names must be unique**: Duplicate names cause ambiguous connections. n8n cannot distinguish which node a connection refers to.
-- **After GraphQL query chains** (HTTP → Normalizer → Registry Update), `$input.item.json` is a container object from the chain, NOT upstream preparation data. Use `$('Upstream Node Name').item.json` to reference data from before the chain.

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Luc
+Copyright (c) 2026 Lucas Berger
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

n8n-actions.json

@@ -80,45 +80,23 @@
     },
     {
       "parameters": {
-        "method": "POST",
+        "url": "http://docker-socket-proxy:2375/v1.47/containers/json?all=true",
-        "url": "={{ $env.UNRAID_HOST }}/graphql",
-        "sendHeaders": true,
-        "headerParameters": {
-          "parameters": [
-            {
-              "name": "Content-Type",
-              "value": "application/json"
-            }
-          ]
-        },
-        "sendBody": true,
-        "specifyBody": "json",
-        "jsonBody": "={\"query\": \"query { docker { containers { id names state image } } }\"}",
         "options": {
-          "timeout": 15000
+          "timeout": 5000
-        },
+        }
-        "authentication": "genericCredentialType",
-        "genericAuthType": "httpHeaderAuth"
       },
       "id": "http-get-containers",
-      "name": "Query All Containers",
+      "name": "Get All Containers",
       "type": "n8n-nodes-base.httpRequest",
       "typeVersion": 4.2,
       "position": [
         600,
         400
-      ],
+      ]
-      "onError": "continueRegularOutput",
-      "credentials": {
-        "httpHeaderAuth": {
-          "id": "unraid-api-key-credential-id",
-          "name": "Unraid API Key"
-        }
-      }
     },
     {
       "parameters": {
-        "jsCode": "// Find container by name and resolve ID\nconst triggerData = $('When executed by another workflow').item.json;\nconst containerName = triggerData.containerName;\nconst containers = $input.all();\n\n// Normalize function to strip leading slash\nconst normalizeName = (name) => name.replace(/^\\//, '').toLowerCase();\nconst searchName = normalizeName(containerName);\n\n// Find matching container\nlet matched = null;\nfor (const item of containers) {\n  const c = item.json;\n  if (c.Names && c.Names.length > 0) {\n    const cName = normalizeName(c.Names[0]);\n    if (cName === searchName || cName.includes(searchName)) {\n      matched = c;\n      break;\n    }\n  }\n}\n\nif (!matched) {\n  // Return error - container not found\n  return {\n    json: {\n      ...triggerData,\n      containerId: '',\n      error: `Container '${containerName}' not found`\n    }\n  };\n}\n\nreturn {\n  json: {\n    ...triggerData,\n    containerId: matched.Id,\n    unraidId: matched.Id  // Add PrefixedID for downstream mutations\n  }\n};"
+        "jsCode": "// Find container by name and resolve ID\nconst triggerData = $('When executed by another workflow').item.json;\nconst containerName = triggerData.containerName;\nconst containers = $input.all();\n\n// Normalize function to strip leading slash\nconst normalizeName = (name) => name.replace(/^\\//, '').toLowerCase();\nconst searchName = normalizeName(containerName);\n\n// Find matching container\nlet matched = null;\nfor (const item of containers) {\n  const c = item.json;\n  if (c.Names && c.Names.length > 0) {\n    const cName = normalizeName(c.Names[0]);\n    if (cName === searchName || cName.includes(searchName)) {\n      matched = c;\n      break;\n    }\n  }\n}\n\nif (!matched) {\n  // Return error - container not found\n  return {\n    json: {\n      ...triggerData,\n      containerId: '',\n      error: `Container '${containerName}' not found`\n    }\n  };\n}\n\nreturn {\n  json: {\n    ...triggerData,\n    containerId: matched.Id\n  }\n};"
       },
       "id": "code-resolve-id",
       "name": "Resolve Container ID",
@@ -220,24 +198,10 @@
     {
       "parameters": {
         "method": "POST",
-        "url": "={{ $env.UNRAID_HOST }}/graphql",
+        "url": "=http://docker-socket-proxy:2375/v1.47/containers/{{ $json.containerId }}/start",
-        "sendHeaders": true,
-        "headerParameters": {
-          "parameters": [
-            {
-              "name": "Content-Type",
-              "value": "application/json"
-            }
-          ]
-        },
-        "sendBody": true,
-        "specifyBody": "json",
-        "jsonBody": "={{ JSON.stringify({query: $json.query}) }}",
         "options": {
           "timeout": 15000
-        },
+        }
-        "authentication": "genericCredentialType",
-        "genericAuthType": "httpHeaderAuth"
       },
       "id": "http-start-container",
       "name": "Start Container",
@@ -247,35 +211,15 @@
         1160,
         200
       ],
-      "onError": "continueRegularOutput",
+      "onError": "continueRegularOutput"
-      "credentials": {
-        "httpHeaderAuth": {
-          "id": "unraid-api-key-credential-id",
-          "name": "Unraid API Key"
-        }
-      }
     },
     {
       "parameters": {
         "method": "POST",
-        "url": "={{ $env.UNRAID_HOST }}/graphql",
+        "url": "=http://docker-socket-proxy:2375/v1.47/containers/{{ $json.containerId }}/stop?t=10",
-        "sendHeaders": true,
-        "headerParameters": {
-          "parameters": [
-            {
-              "name": "Content-Type",
-              "value": "application/json"
-            }
-          ]
-        },
-        "sendBody": true,
-        "specifyBody": "json",
-        "jsonBody": "={{ JSON.stringify({query: $json.query}) }}",
         "options": {
           "timeout": 15000
-        },
+        }
-        "authentication": "genericCredentialType",
-        "genericAuthType": "httpHeaderAuth"
       },
       "id": "http-stop-container",
       "name": "Stop Container",
@@ -285,51 +229,25 @@
         1160,
         300
       ],
-      "onError": "continueRegularOutput",
+      "onError": "continueRegularOutput"
-      "credentials": {
-        "httpHeaderAuth": {
-          "id": "unraid-api-key-credential-id",
-          "name": "Unraid API Key"
-        }
-      }
     },
     {
       "parameters": {
         "method": "POST",
-        "url": "={{ $env.UNRAID_HOST }}/graphql",
+        "url": "=http://docker-socket-proxy:2375/v1.47/containers/{{ $json.containerId }}/restart?t=10",
-        "sendHeaders": true,
-        "headerParameters": {
-          "parameters": [
-            {
-              "name": "Content-Type",
-              "value": "application/json"
-            }
-          ]
-        },
-        "sendBody": true,
-        "specifyBody": "json",
-        "jsonBody": "={{ JSON.stringify({query: $json.query}) }}",
         "options": {
           "timeout": 15000
+        }
       },
-        "authentication": "genericCredentialType",
+      "id": "http-restart-container",
-        "genericAuthType": "httpHeaderAuth"
+      "name": "Restart Container",
-      },
-      "id": "http-stop-for-restart",
-      "name": "Stop For Restart",
       "type": "n8n-nodes-base.httpRequest",
       "typeVersion": 4.2,
       "position": [
         1160,
         400
       ],
-      "onError": "continueRegularOutput",
+      "onError": "continueRegularOutput"
-      "credentials": {
-        "httpHeaderAuth": {
-          "id": "unraid-api-key-credential-id",
-          "name": "Unraid API Key"
-        }
-      }
     },
     {
       "parameters": {
@@ -369,162 +287,6 @@
         1380,
         400
       ]
-    },
-    {
-      "parameters": {
-        "jsCode": "// GraphQL Response Normalizer - Transform Unraid GraphQL to Docker API contract\n// Input: $input.item.json = raw GraphQL response\n// Output: Array of normalized containers\n\nconst response = $input.item.json;\n\n// Validation: Check for GraphQL errors\nif (response.errors && response.errors.length > 0) {\n  const messages = response.errors.map(e => e.message).join('; ');\n  throw new Error(`GraphQL error: ${messages}`);\n}\n\n// Validation: Check response structure\nif (!response.data?.docker?.containers) {\n  throw new Error('Invalid GraphQL response structure: missing data.docker.containers');\n}\n\n// State mapping: Unraid UPPERCASE -> Docker lowercase\nconst stateMap = {\n  'RUNNING': 'running',\n  'STOPPED': 'exited',  // Docker convention: stopped = exited\n  'PAUSED': 'paused'\n};\n\nfunction normalizeState(unraidState) {\n  return stateMap[unraidState] || unraidState.toLowerCase();\n}\n\n// Transform each container\nconst containers = response.data.docker.containers;\nconst normalized = containers.map(container => {\n  const dockerState = normalizeState(container.state);\n  \n  return {\n    // Core fields matching Docker API contract\n    Id: container.id,                    // Keep full PrefixedID (registry handles translation)\n    Names: container.names,               // Already has '/' prefix (Phase 14 verified)\n    State: dockerState,                   // Normalized lowercase state\n    Status: dockerState,                  // Docker has separate Status field\n    Image: '',                            // Not available in basic query\n    \n    // Debug field: preserve original Unraid ID\n    _unraidId: container.id\n  };\n});\n\n// Return as array of items (n8n multi-item output format)\nreturn normalized.map(container => ({ json: container }));\n"
-      },
-      "id": "code-graphql-normalizer",
-      "name": "GraphQL Response Normalizer",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        660,
-        400
-      ]
-    },
-    {
-      "parameters": {
-        "mode": "runOnceForAllItems",
-        "jsCode": "// Update Container ID Registry with fresh container data\n// Input: Array of containers from Normalizer\n// Output: Pass through all containers unchanged\n\nconst containers = $input.all().map(item => item.json);\n\n// Get static data registry\nconst registry = $getWorkflowStaticData('global');\nif (!registry._containerIdMap) {\n  registry._containerIdMap = JSON.stringify({});\n}\n\nconst containerMap = {};\n\nfor (const container of containers) {\n  // Extract container name: strip leading '/', lowercase\n  const rawName = container.Names[0];\n  const name = rawName.startsWith('/') ? rawName.substring(1).toLowerCase() : rawName.toLowerCase();\n  \n  // Map name -> {name, unraidId}\n  // The container.Id field IS the PrefixedID (129-char format)\n  containerMap[name] = {\n    name: name,\n    unraidId: container.Id\n  };\n}\n\n// Store timestamp\nregistry._lastRefresh = Date.now();\n\n// Serialize (top-level assignment - this is what n8n persists)\nregistry._containerIdMap = JSON.stringify(containerMap);\n\n// Pass through all containers unchanged (multi-item output)\nreturn containers.map(c => ({ json: c }));\n"
-      },
-      "id": "code-update-registry",
-      "name": "Update Container ID Registry",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        720,
-        400
-      ]
-    },
-    {
-      "parameters": {
-        "jsCode": "// Build Start Mutation\nconst data = $('Route Action').item.json;\nconst unraidId = data.unraidId || data.containerId;\nreturn { json: { query: `mutation { docker { start(id: \"${unraidId}\") { id state } } }` } };"
-      },
-      "id": "code-build-start-mutation",
-      "name": "Build Start Mutation",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        1080,
-        200
-      ]
-    },
-    {
-      "parameters": {
-        "jsCode": "// GraphQL Error Handler - Standardized error checking and HTTP status mapping\n// Input: $input.item.json = raw response from HTTP Request node\n// Output: { success, statusCode, alreadyInState, message, data }\n\nconst response = $input.item.json;\n\n// Check GraphQL errors array\nif (response.errors && response.errors.length > 0) {\n  const error = response.errors[0];\n  const code = error.extensions?.code;\n  const message = error.message;\n  \n  // Map error codes to HTTP equivalents\n  if (code === 'ALREADY_IN_STATE') {\n    // Maps to Docker API HTTP 304 pattern (used in n8n-actions.json)\n    return {\n      json: {\n        success: true,\n        statusCode: 304,\n        alreadyInState: true,\n        message: 'Container already in desired state'\n      }\n    };\n  }\n  \n  // Error codes that should throw\n  if (code === 'NOT_FOUND') {\n    return {\n      json: {\n        success: false,\n        statusCode: 404,\n        message: `Container not found: ${message}`\n      }\n    };\n  }\n  \n  if (code === 'FORBIDDEN' || code === 'UNAUTHORIZED') {\n    return {\n      json: {\n        success: false,\n        statusCode: 403,\n        message: `Permission denied: ${message}`\n      }\n    };\n  }\n  \n  // Any other GraphQL error\n  return {\n    json: {\n      success: false,\n      statusCode: 500,\n      message: `Unraid API error: ${message}`\n    }\n  };\n}\n\n// Check HTTP-level errors\nif (response.statusCode >= 400) {\n  return {\n    json: {\n      success: false,\n      statusCode: response.statusCode,\n      message: `HTTP ${response.statusCode}: ${response.statusMessage}`\n    }\n  };\n}\n\n// Check missing data field\nif (!response.data) {\n  return {\n    json: {\n      success: false,\n      statusCode: 500,\n      message: 'GraphQL response missing data field'\n    }\n  };\n}\n\n// Success\nreturn {\n  json: {\n    success: true,\n    statusCode: 200,\n    alreadyInState: false,\n    data: response.data\n  }\n};\n"
-      },
-      "id": "code-start-error-handler",
-      "name": "Start Error Handler",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        1280,
-        200
-      ]
-    },
-    {
-      "parameters": {
-        "jsCode": "// Build Stop Mutation\nconst data = $('Route Action').item.json;\nconst unraidId = data.unraidId || data.containerId;\nreturn { json: { query: `mutation { docker { stop(id: \"${unraidId}\") { id state } } }` } };"
-      },
-      "id": "code-build-stop-mutation",
-      "name": "Build Stop Mutation",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        1080,
-        300
-      ]
-    },
-    {
-      "parameters": {
-        "jsCode": "// GraphQL Error Handler - Standardized error checking and HTTP status mapping\n// Input: $input.item.json = raw response from HTTP Request node\n// Output: { success, statusCode, alreadyInState, message, data }\n\nconst response = $input.item.json;\n\n// Check GraphQL errors array\nif (response.errors && response.errors.length > 0) {\n  const error = response.errors[0];\n  const code = error.extensions?.code;\n  const message = error.message;\n  \n  // Map error codes to HTTP equivalents\n  if (code === 'ALREADY_IN_STATE') {\n    // Maps to Docker API HTTP 304 pattern (used in n8n-actions.json)\n    return {\n      json: {\n        success: true,\n        statusCode: 304,\n        alreadyInState: true,\n        message: 'Container already in desired state'\n      }\n    };\n  }\n  \n  // Error codes that should throw\n  if (code === 'NOT_FOUND') {\n    return {\n      json: {\n        success: false,\n        statusCode: 404,\n        message: `Container not found: ${message}`\n      }\n    };\n  }\n  \n  if (code === 'FORBIDDEN' || code === 'UNAUTHORIZED') {\n    return {\n      json: {\n        success: false,\n        statusCode: 403,\n        message: `Permission denied: ${message}`\n      }\n    };\n  }\n  \n  // Any other GraphQL error\n  return {\n    json: {\n      success: false,\n      statusCode: 500,\n      message: `Unraid API error: ${message}`\n    }\n  };\n}\n\n// Check HTTP-level errors\nif (response.statusCode >= 400) {\n  return {\n    json: {\n      success: false,\n      statusCode: response.statusCode,\n      message: `HTTP ${response.statusCode}: ${response.statusMessage}`\n    }\n  };\n}\n\n// Check missing data field\nif (!response.data) {\n  return {\n    json: {\n      success: false,\n      statusCode: 500,\n      message: 'GraphQL response missing data field'\n    }\n  };\n}\n\n// Success\nreturn {\n  json: {\n    success: true,\n    statusCode: 200,\n    alreadyInState: false,\n    data: response.data\n  }\n};\n"
-      },
-      "id": "code-stop-error-handler",
-      "name": "Stop Error Handler",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        1280,
-        300
-      ]
-    },
-    {
-      "parameters": {
-        "jsCode": "// Build Stop-for-Restart Mutation\nconst data = $('Route Action').item.json;\nconst unraidId = data.unraidId || data.containerId;\nreturn { json: { query: `mutation { docker { stop(id: \"${unraidId}\") { id state } } }`, unraidId } };"
-      },
-      "id": "code-build-restart-stop-mutation",
-      "name": "Build Stop-for-Restart Mutation",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        1080,
-        400
-      ]
-    },
-    {
-      "parameters": {
-        "jsCode": "// Handle Stop-for-Restart Result\n// Check response: if success OR statusCode 304 (already stopped) -> proceed to start\n// If error -> fail restart\n\nconst response = $input.item.json;\nconst prevData = $('Build Stop-for-Restart Mutation').item.json;\n\n// Check for errors\nif (response.errors && response.errors.length > 0) {\n  const error = response.errors[0];\n  const code = error.extensions?.code;\n  \n  // ALREADY_IN_STATE (304) is OK - container already stopped\n  if (code === 'ALREADY_IN_STATE') {\n    // Continue to start step\n    return { json: { query: `mutation { docker { start(id: \"${prevData.unraidId}\") { id state } } }` } };\n  }\n  \n  // Any other error - fail restart\n  return {\n    json: {\n      error: true,\n      statusCode: 500,\n      message: `Failed to stop container for restart: ${error.message}`\n    }\n  };\n}\n\n// Check HTTP-level errors\nif (response.statusCode && response.statusCode >= 400) {\n  return {\n    json: {\n      error: true,\n      statusCode: response.statusCode,\n      message: 'Failed to stop container for restart'\n    }\n  };\n}\n\n// Success - proceed to start\nreturn { json: { query: `mutation { docker { start(id: \"${prevData.unraidId}\") { id state } } }` } };\n"
-      },
-      "id": "code-handle-stop-for-restart",
-      "name": "Handle Stop-for-Restart Result",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        1280,
-        400
-      ]
-    },
-    {
-      "parameters": {
-        "method": "POST",
-        "url": "={{ $env.UNRAID_HOST }}/graphql",
-        "sendHeaders": true,
-        "headerParameters": {
-          "parameters": [
-            {
-              "name": "Content-Type",
-              "value": "application/json"
-            }
-          ]
-        },
-        "sendBody": true,
-        "specifyBody": "json",
-        "jsonBody": "={{ JSON.stringify({query: $json.query}) }}",
-        "options": {
-          "timeout": 15000
-        },
-        "authentication": "genericCredentialType",
-        "genericAuthType": "httpHeaderAuth"
-      },
-      "id": "http-start-after-stop",
-      "name": "Start After Stop",
-      "type": "n8n-nodes-base.httpRequest",
-      "typeVersion": 4.2,
-      "position": [
-        1480,
-        400
-      ],
-      "onError": "continueRegularOutput",
-      "credentials": {
-        "httpHeaderAuth": {
-          "id": "unraid-api-key-credential-id",
-          "name": "Unraid API Key"
-        }
-      }
-    },
-    {
-      "parameters": {
-        "jsCode": "// GraphQL Error Handler for Restart (after Start step)\n// Input: $input.item.json = raw response from Start After Stop\n// Output: { success, statusCode, alreadyInState, message, data }\n\nconst response = $input.item.json;\n\n// Check GraphQL errors array\nif (response.errors && response.errors.length > 0) {\n  const error = response.errors[0];\n  const code = error.extensions?.code;\n  const message = error.message;\n  \n  // Map error codes to HTTP equivalents\n  if (code === 'ALREADY_IN_STATE') {\n    // Maps to Docker API HTTP 304 pattern (container already running)\n    return {\n      json: {\n        success: true,\n        statusCode: 304,\n        alreadyInState: true,\n        message: 'Container already in desired state'\n      }\n    };\n  }\n  \n  // Error codes that should throw\n  if (code === 'NOT_FOUND') {\n    return {\n      json: {\n        success: false,\n        statusCode: 404,\n        message: `Container not found: ${message}`\n      }\n    };\n  }\n  \n  if (code === 'FORBIDDEN' || code === 'UNAUTHORIZED') {\n    return {\n      json: {\n        success: false,\n        statusCode: 403,\n        message: `Permission denied: ${message}`\n      }\n    };\n  }\n  \n  // Any other GraphQL error\n  return {\n    json: {\n      success: false,\n      statusCode: 500,\n      message: `Unraid API error: ${message}`\n    }\n  };\n}\n\n// Check HTTP-level errors\nif (response.statusCode >= 400) {\n  return {\n    json: {\n      success: false,\n      statusCode: response.statusCode,\n      message: `HTTP ${response.statusCode}: ${response.statusMessage}`\n    }\n  };\n}\n\n// Check missing data field\nif (!response.data) {\n  return {\n    json: {\n      success: false,\n      statusCode: 500,\n      message: 'GraphQL response missing data field'\n    }\n  };\n}\n\n// Success\nreturn {\n  json: {\n    success: true,\n    statusCode: 200,\n    alreadyInState: false,\n    data: response.data\n  }\n};\n"
-      },
-      "id": "code-restart-error-handler",
-      "name": "Restart Error Handler",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        1680,
-        400
-      ]
     }
   ],
   "connections": {
@@ -550,7 +312,18 @@
         ],
         [
           {
-            "node": "Query All Containers",
+            "node": "Get All Containers",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Get All Containers": {
+      "main": [
+        [
+          {
+            "node": "Resolve Container ID",
             "type": "main",
             "index": 0
           }
@@ -572,21 +345,21 @@
       "main": [
         [
           {
-            "node": "Build Start Mutation",
+            "node": "Start Container",
             "type": "main",
             "index": 0
           }
         ],
         [
           {
-            "node": "Build Stop Mutation",
+            "node": "Stop Container",
             "type": "main",
             "index": 0
           }
         ],
         [
           {
-            "node": "Build Stop-for-Restart Mutation",
+            "node": "Restart Container",
             "type": "main",
             "index": 0
           }
@@ -597,7 +370,7 @@
       "main": [
         [
           {
-            "node": "Start Error Handler",
+            "node": "Format Start Result",
             "type": "main",
             "index": 0
           }
@@ -605,83 +378,6 @@
       ]
     },
     "Stop Container": {
-      "main": [
-        [
-          {
-            "node": "Stop Error Handler",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Query All Containers": {
-      "main": [
-        [
-          {
-            "node": "GraphQL Response Normalizer",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "GraphQL Response Normalizer": {
-      "main": [
-        [
-          {
-            "node": "Update Container ID Registry",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Update Container ID Registry": {
-      "main": [
-        [
-          {
-            "node": "Resolve Container ID",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Build Start Mutation": {
-      "main": [
-        [
-          {
-            "node": "Start Container",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Start Error Handler": {
-      "main": [
-        [
-          {
-            "node": "Format Start Result",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Build Stop Mutation": {
-      "main": [
-        [
-          {
-            "node": "Stop Container",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Stop Error Handler": {
       "main": [
         [
           {
@@ -692,51 +388,7 @@
         ]
       ]
     },
-    "Build Stop-for-Restart Mutation": {
+    "Restart Container": {
-      "main": [
-        [
-          {
-            "node": "Stop For Restart",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Stop For Restart": {
-      "main": [
-        [
-          {
-            "node": "Handle Stop-for-Restart Result",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Handle Stop-for-Restart Result": {
-      "main": [
-        [
-          {
-            "node": "Start After Stop",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Start After Stop": {
-      "main": [
-        [
-          {
-            "node": "Restart Error Handler",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Restart Error Handler": {
       "main": [
         [
           {

n8n-batch-ui.json

@@ -218,30 +218,10 @@
     },
     {
       "parameters": {
-        "method": "POST",
+        "url": "http://docker-socket-proxy:2375/containers/json?all=true",
-        "url": "={{ $env.UNRAID_HOST }}/graphql",
-        "authentication": "genericCredentialType",
-        "sendBody": true,
-        "specifyBody": "json",
-        "jsonBody": "{\"query\": \"query { docker { containers { id names state image } } }\"}",
-        "sendHeaders": true,
-        "headerParameters": {
-          "parameters": [
-            {
-              "name": "Content-Type",
-              "value": "application/json"
-            }
-          ]
-        },
         "options": {
-          "timeout": 15000,
+          "timeout": 5000
-          "response": {
-            "response": {
-              "errorHandling": "continueRegularOutput"
         }
-          }
-        },
-        "genericAuthType": "httpHeaderAuth"
       },
       "id": "http-fetch-containers-mode",
       "name": "Fetch Containers For Mode",
@@ -250,13 +230,7 @@
       "position": [
         680,
         100
-      ],
+      ]
-      "credentials": {
-        "httpHeaderAuth": {
-          "id": "unraid-api-key-credential-id",
-          "name": "Unraid API Key"
-        }
-      }
     },
     {
       "parameters": {
@@ -317,30 +291,10 @@
     },
     {
       "parameters": {
-        "method": "POST",
+        "url": "http://docker-socket-proxy:2375/containers/json?all=true",
-        "url": "={{ $env.UNRAID_HOST }}/graphql",
-        "authentication": "genericCredentialType",
-        "sendBody": true,
-        "specifyBody": "json",
-        "jsonBody": "{\"query\": \"query { docker { containers { id names state image } } }\"}",
-        "sendHeaders": true,
-        "headerParameters": {
-          "parameters": [
-            {
-              "name": "Content-Type",
-              "value": "application/json"
-            }
-          ]
-        },
         "options": {
-          "timeout": 15000,
+          "timeout": 5000
-          "response": {
-            "response": {
-              "errorHandling": "continueRegularOutput"
         }
-          }
-        },
-        "genericAuthType": "httpHeaderAuth"
       },
       "id": "http-fetch-containers-toggle",
       "name": "Fetch Containers For Update",
@@ -349,13 +303,7 @@
       "position": [
         1120,
         100
-      ],
+      ]
-      "credentials": {
-        "httpHeaderAuth": {
-          "id": "unraid-api-key-credential-id",
-          "name": "Unraid API Key"
-        }
-      }
     },
     {
       "parameters": {
@@ -372,30 +320,10 @@
     },
     {
       "parameters": {
-        "method": "POST",
+        "url": "http://docker-socket-proxy:2375/containers/json?all=true",
-        "url": "={{ $env.UNRAID_HOST }}/graphql",
-        "authentication": "genericCredentialType",
-        "sendBody": true,
-        "specifyBody": "json",
-        "jsonBody": "{\"query\": \"query { docker { containers { id names state image } } }\"}",
-        "sendHeaders": true,
-        "headerParameters": {
-          "parameters": [
-            {
-              "name": "Content-Type",
-              "value": "application/json"
-            }
-          ]
-        },
         "options": {
-          "timeout": 15000,
+          "timeout": 5000
-          "response": {
-            "response": {
-              "errorHandling": "continueRegularOutput"
         }
-          }
-        },
-        "genericAuthType": "httpHeaderAuth"
       },
       "id": "http-fetch-containers-exec",
       "name": "Fetch Containers For Exec",
@@ -404,13 +332,7 @@
       "position": [
         680,
         400
-      ],
+      ]
-      "credentials": {
-        "httpHeaderAuth": {
-          "id": "unraid-api-key-credential-id",
-          "name": "Unraid API Key"
-        }
-      }
     },
     {
       "parameters": {
@@ -440,30 +362,10 @@
     },
     {
       "parameters": {
-        "method": "POST",
+        "url": "http://docker-socket-proxy:2375/containers/json?all=true",
-        "url": "={{ $env.UNRAID_HOST }}/graphql",
-        "authentication": "genericCredentialType",
-        "sendBody": true,
-        "specifyBody": "json",
-        "jsonBody": "{\"query\": \"query { docker { containers { id names state image } } }\"}",
-        "sendHeaders": true,
-        "headerParameters": {
-          "parameters": [
-            {
-              "name": "Content-Type",
-              "value": "application/json"
-            }
-          ]
-        },
         "options": {
-          "timeout": 15000,
+          "timeout": 5000
-          "response": {
-            "response": {
-              "errorHandling": "continueRegularOutput"
         }
-          }
-        },
-        "genericAuthType": "httpHeaderAuth"
       },
       "id": "http-fetch-containers-nav",
       "name": "Fetch Containers For Nav",
@@ -472,13 +374,7 @@
       "position": [
         900,
         300
-      ],
+      ]
-      "credentials": {
-        "httpHeaderAuth": {
-          "id": "unraid-api-key-credential-id",
-          "name": "Unraid API Key"
-        }
-      }
     },
     {
       "parameters": {
@@ -508,30 +404,10 @@
     },
     {
       "parameters": {
-        "method": "POST",
+        "url": "http://docker-socket-proxy:2375/containers/json?all=true",
-        "url": "={{ $env.UNRAID_HOST }}/graphql",
-        "authentication": "genericCredentialType",
-        "sendBody": true,
-        "specifyBody": "json",
-        "jsonBody": "{\"query\": \"query { docker { containers { id names state image } } }\"}",
-        "sendHeaders": true,
-        "headerParameters": {
-          "parameters": [
-            {
-              "name": "Content-Type",
-              "value": "application/json"
-            }
-          ]
-        },
         "options": {
-          "timeout": 15000,
+          "timeout": 5000
-          "response": {
-            "response": {
-              "errorHandling": "continueRegularOutput"
         }
-          }
-        },
-        "genericAuthType": "httpHeaderAuth"
       },
       "id": "http-fetch-containers-clear",
       "name": "Fetch Containers For Clear",
@@ -540,13 +416,7 @@
       "position": [
         900,
         500
-      ],
+      ]
-      "credentials": {
-        "httpHeaderAuth": {
-          "id": "unraid-api-key-credential-id",
-          "name": "Unraid API Key"
-        }
-      }
     },
     {
       "parameters": {
@@ -573,71 +443,6 @@
         680,
         600
       ]
-    },
-    {
-      "parameters": {
-        "jsCode": "// GraphQL Response Normalizer - Transform Unraid GraphQL to Docker API contract\n// Input: $input.item.json = raw GraphQL response\n// Output: Array of normalized containers\n\nconst response = $input.item.json;\n\n// Validation: Check for GraphQL errors\nif (response.errors && response.errors.length > 0) {\n  const messages = response.errors.map(e => e.message).join('; ');\n  throw new Error(`GraphQL error: ${messages}`);\n}\n\n// Validation: Check response structure\nif (!response.data?.docker?.containers) {\n  throw new Error('Invalid GraphQL response structure: missing data.docker.containers');\n}\n\n// State mapping: Unraid UPPERCASE -> Docker lowercase\nconst stateMap = {\n  'RUNNING': 'running',\n  'STOPPED': 'exited',  // Docker convention: stopped = exited\n  'PAUSED': 'paused'\n};\n\nfunction normalizeState(unraidState) {\n  return stateMap[unraidState] || unraidState.toLowerCase();\n}\n\n// Transform each container\nconst containers = response.data.docker.containers;\nconst normalized = containers.map(container => {\n  const dockerState = normalizeState(container.state);\n  \n  return {\n    // Core fields matching Docker API contract\n    Id: container.id,                    // Keep full PrefixedID (registry handles translation)\n    Names: container.names,               // Already has '/' prefix (Phase 14 verified)\n    State: dockerState,                   // Normalized lowercase state\n    Status: dockerState,                  // Docker has separate Status field\n    Image: '',                            // Not available in basic query\n    \n    // Debug field: preserve original Unraid ID\n    _unraidId: container.id\n  };\n});\n\n// Return as array of items (n8n multi-item output format)\nreturn normalized.map(container => ({ json: container }));"
-      },
-      "id": "code-normalizer-mode",
-      "name": "Normalize GraphQL Response (Mode)",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        790,
-        100
-      ]
-    },
-    {
-      "parameters": {
-        "jsCode": "// GraphQL Response Normalizer - Transform Unraid GraphQL to Docker API contract\n// Input: $input.item.json = raw GraphQL response\n// Output: Array of normalized containers\n\nconst response = $input.item.json;\n\n// Validation: Check for GraphQL errors\nif (response.errors && response.errors.length > 0) {\n  const messages = response.errors.map(e => e.message).join('; ');\n  throw new Error(`GraphQL error: ${messages}`);\n}\n\n// Validation: Check response structure\nif (!response.data?.docker?.containers) {\n  throw new Error('Invalid GraphQL response structure: missing data.docker.containers');\n}\n\n// State mapping: Unraid UPPERCASE -> Docker lowercase\nconst stateMap = {\n  'RUNNING': 'running',\n  'STOPPED': 'exited',  // Docker convention: stopped = exited\n  'PAUSED': 'paused'\n};\n\nfunction normalizeState(unraidState) {\n  return stateMap[unraidState] || unraidState.toLowerCase();\n}\n\n// Transform each container\nconst containers = response.data.docker.containers;\nconst normalized = containers.map(container => {\n  const dockerState = normalizeState(container.state);\n  \n  return {\n    // Core fields matching Docker API contract\n    Id: container.id,                    // Keep full PrefixedID (registry handles translation)\n    Names: container.names,               // Already has '/' prefix (Phase 14 verified)\n    State: dockerState,                   // Normalized lowercase state\n    Status: dockerState,                  // Docker has separate Status field\n    Image: '',                            // Not available in basic query\n    \n    // Debug field: preserve original Unraid ID\n    _unraidId: container.id\n  };\n});\n\n// Return as array of items (n8n multi-item output format)\nreturn normalized.map(container => ({ json: container }));"
-      },
-      "id": "code-normalizer-toggle",
-      "name": "Normalize GraphQL Response (Toggle)",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        1230,
-        100
-      ]
-    },
-    {
-      "parameters": {
-        "jsCode": "// GraphQL Response Normalizer - Transform Unraid GraphQL to Docker API contract\n// Input: $input.item.json = raw GraphQL response\n// Output: Array of normalized containers\n\nconst response = $input.item.json;\n\n// Validation: Check for GraphQL errors\nif (response.errors && response.errors.length > 0) {\n  const messages = response.errors.map(e => e.message).join('; ');\n  throw new Error(`GraphQL error: ${messages}`);\n}\n\n// Validation: Check response structure\nif (!response.data?.docker?.containers) {\n  throw new Error('Invalid GraphQL response structure: missing data.docker.containers');\n}\n\n// State mapping: Unraid UPPERCASE -> Docker lowercase\nconst stateMap = {\n  'RUNNING': 'running',\n  'STOPPED': 'exited',  // Docker convention: stopped = exited\n  'PAUSED': 'paused'\n};\n\nfunction normalizeState(unraidState) {\n  return stateMap[unraidState] || unraidState.toLowerCase();\n}\n\n// Transform each container\nconst containers = response.data.docker.containers;\nconst normalized = containers.map(container => {\n  const dockerState = normalizeState(container.state);\n  \n  return {\n    // Core fields matching Docker API contract\n    Id: container.id,                    // Keep full PrefixedID (registry handles translation)\n    Names: container.names,               // Already has '/' prefix (Phase 14 verified)\n    State: dockerState,                   // Normalized lowercase state\n    Status: dockerState,                  // Docker has separate Status field\n    Image: '',                            // Not available in basic query\n    \n    // Debug field: preserve original Unraid ID\n    _unraidId: container.id\n  };\n});\n\n// Return as array of items (n8n multi-item output format)\nreturn normalized.map(container => ({ json: container }));"
-      },
-      "id": "code-normalizer-exec",
-      "name": "Normalize GraphQL Response (Exec)",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        790,
-        400
-      ]
-    },
-    {
-      "parameters": {
-        "jsCode": "// GraphQL Response Normalizer - Transform Unraid GraphQL to Docker API contract\n// Input: $input.item.json = raw GraphQL response\n// Output: Array of normalized containers\n\nconst response = $input.item.json;\n\n// Validation: Check for GraphQL errors\nif (response.errors && response.errors.length > 0) {\n  const messages = response.errors.map(e => e.message).join('; ');\n  throw new Error(`GraphQL error: ${messages}`);\n}\n\n// Validation: Check response structure\nif (!response.data?.docker?.containers) {\n  throw new Error('Invalid GraphQL response structure: missing data.docker.containers');\n}\n\n// State mapping: Unraid UPPERCASE -> Docker lowercase\nconst stateMap = {\n  'RUNNING': 'running',\n  'STOPPED': 'exited',  // Docker convention: stopped = exited\n  'PAUSED': 'paused'\n};\n\nfunction normalizeState(unraidState) {\n  return stateMap[unraidState] || unraidState.toLowerCase();\n}\n\n// Transform each container\nconst containers = response.data.docker.containers;\nconst normalized = containers.map(container => {\n  const dockerState = normalizeState(container.state);\n  \n  return {\n    // Core fields matching Docker API contract\n    Id: container.id,                    // Keep full PrefixedID (registry handles translation)\n    Names: container.names,               // Already has '/' prefix (Phase 14 verified)\n    State: dockerState,                   // Normalized lowercase state\n    Status: dockerState,                  // Docker has separate Status field\n    Image: '',                            // Not available in basic query\n    \n    // Debug field: preserve original Unraid ID\n    _unraidId: container.id\n  };\n});\n\n// Return as array of items (n8n multi-item output format)\nreturn normalized.map(container => ({ json: container }));"
-      },
-      "id": "code-normalizer-nav",
-      "name": "Normalize GraphQL Response (Nav)",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        1010,
-        300
-      ]
-    },
-    {
-      "parameters": {
-        "jsCode": "// GraphQL Response Normalizer - Transform Unraid GraphQL to Docker API contract\n// Input: $input.item.json = raw GraphQL response\n// Output: Array of normalized containers\n\nconst response = $input.item.json;\n\n// Validation: Check for GraphQL errors\nif (response.errors && response.errors.length > 0) {\n  const messages = response.errors.map(e => e.message).join('; ');\n  throw new Error(`GraphQL error: ${messages}`);\n}\n\n// Validation: Check response structure\nif (!response.data?.docker?.containers) {\n  throw new Error('Invalid GraphQL response structure: missing data.docker.containers');\n}\n\n// State mapping: Unraid UPPERCASE -> Docker lowercase\nconst stateMap = {\n  'RUNNING': 'running',\n  'STOPPED': 'exited',  // Docker convention: stopped = exited\n  'PAUSED': 'paused'\n};\n\nfunction normalizeState(unraidState) {\n  return stateMap[unraidState] || unraidState.toLowerCase();\n}\n\n// Transform each container\nconst containers = response.data.docker.containers;\nconst normalized = containers.map(container => {\n  const dockerState = normalizeState(container.state);\n  \n  return {\n    // Core fields matching Docker API contract\n    Id: container.id,                    // Keep full PrefixedID (registry handles translation)\n    Names: container.names,               // Already has '/' prefix (Phase 14 verified)\n    State: dockerState,                   // Normalized lowercase state\n    Status: dockerState,                  // Docker has separate Status field\n    Image: '',                            // Not available in basic query\n    \n    // Debug field: preserve original Unraid ID\n    _unraidId: container.id\n  };\n});\n\n// Return as array of items (n8n multi-item output format)\nreturn normalized.map(container => ({ json: container }));"
-      },
-      "id": "code-normalizer-clear",
-      "name": "Normalize GraphQL Response (Clear)",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        1010,
-        500
-      ]
     }
   ],
   "connections": {
@@ -702,7 +507,7 @@
       "main": [
         [
           {
-            "node": "Normalize GraphQL Response (Mode)",
+            "node": "Build Batch Keyboard",
             "type": "main",
             "index": 0
           }
@@ -735,7 +540,7 @@
       "main": [
         [
           {
-            "node": "Normalize GraphQL Response (Toggle)",
+            "node": "Rebuild Keyboard After Toggle",
             "type": "main",
             "index": 0
           }
@@ -746,7 +551,7 @@
       "main": [
         [
           {
-            "node": "Normalize GraphQL Response (Exec)",
+            "node": "Handle Exec",
             "type": "main",
             "index": 0
           }
@@ -768,7 +573,7 @@
       "main": [
         [
           {
-            "node": "Normalize GraphQL Response (Nav)",
+            "node": "Rebuild Keyboard For Nav",
             "type": "main",
             "index": 0
           }
@@ -787,61 +592,6 @@
       ]
     },
     "Fetch Containers For Clear": {
-      "main": [
-        [
-          {
-            "node": "Normalize GraphQL Response (Clear)",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Normalize GraphQL Response (Mode)": {
-      "main": [
-        [
-          {
-            "node": "Build Batch Keyboard",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Normalize GraphQL Response (Toggle)": {
-      "main": [
-        [
-          {
-            "node": "Rebuild Keyboard After Toggle",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Normalize GraphQL Response (Exec)": {
-      "main": [
-        [
-          {
-            "node": "Handle Exec",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Normalize GraphQL Response (Nav)": {
-      "main": [
-        [
-          {
-            "node": "Rebuild Keyboard For Nav",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Normalize GraphQL Response (Clear)": {
       "main": [
         [
           {

n8n-status.json

@@ -158,39 +158,18 @@
     },
     {
       "parameters": {
-        "method": "POST",
+        "method": "GET",
-        "url": "={{ $env.UNRAID_HOST }}/graphql",
+        "url": "=http://docker-socket-proxy:2375/containers/json?all=true",
-        "authentication": "genericCredentialType",
+        "options": {}
-        "genericAuthType": "httpHeaderAuth",
-        "sendBody": true,
-        "bodyParameters": {
-          "parameters": []
-        },
-        "specifyBody": "json",
-        "jsonBody": "{\"query\": \"query {\\n  docker {\\n    containers {\\n      id\\n      names\\n      state\\n      image\\n      status\\n    }\\n  }\\n}\"}",
-        "options": {
-          "timeout": 15000,
-          "response": {
-            "response": {
-              "fullResponse": false
-            }
-          }
-        }
       },
       "id": "status-docker-list",
-      "name": "Query Containers",
+      "name": "Docker List Containers",
       "type": "n8n-nodes-base.httpRequest",
       "typeVersion": 4.2,
       "position": [
         900,
         200
-      ],
+      ]
-      "credentials": {
-        "httpHeaderAuth": {
-          "id": "unraid-api-key-credential-id",
-          "name": "Unraid API Key"
-        }
-      }
     },
     {
       "parameters": {
@@ -220,39 +199,18 @@
     },
     {
       "parameters": {
-        "method": "POST",
+        "method": "GET",
-        "url": "={{ $env.UNRAID_HOST }}/graphql",
+        "url": "=http://docker-socket-proxy:2375/containers/json?all=true",
-        "authentication": "genericCredentialType",
+        "options": {}
-        "genericAuthType": "httpHeaderAuth",
-        "sendBody": true,
-        "bodyParameters": {
-          "parameters": []
-        },
-        "specifyBody": "json",
-        "jsonBody": "{\"query\": \"query {\\n  docker {\\n    containers {\\n      id\\n      names\\n      state\\n      image\\n      status\\n    }\\n  }\\n}\"}",
-        "options": {
-          "timeout": 15000,
-          "response": {
-            "response": {
-              "fullResponse": false
-            }
-          }
-        }
       },
       "id": "status-docker-single",
-      "name": "Query Container Status",
+      "name": "Docker Get Container",
       "type": "n8n-nodes-base.httpRequest",
       "typeVersion": 4.2,
       "position": [
         900,
         300
-      ],
+      ]
-      "credentials": {
-        "httpHeaderAuth": {
-          "id": "unraid-api-key-credential-id",
-          "name": "Unraid API Key"
-        }
-      }
     },
     {
       "parameters": {
@@ -282,39 +240,18 @@
     },
     {
       "parameters": {
-        "method": "POST",
+        "method": "GET",
-        "url": "={{ $env.UNRAID_HOST }}/graphql",
+        "url": "=http://docker-socket-proxy:2375/containers/json?all=true",
-        "authentication": "genericCredentialType",
+        "options": {}
-        "genericAuthType": "httpHeaderAuth",
-        "sendBody": true,
-        "bodyParameters": {
-          "parameters": []
-        },
-        "specifyBody": "json",
-        "jsonBody": "{\"query\": \"query {\\n  docker {\\n    containers {\\n      id\\n      names\\n      state\\n      image\\n      status\\n    }\\n  }\\n}\"}",
-        "options": {
-          "timeout": 15000,
-          "response": {
-            "response": {
-              "fullResponse": false
-            }
-          }
-        }
       },
       "id": "status-docker-paginate",
-      "name": "Query Containers For Paginate",
+      "name": "Docker List For Paginate",
       "type": "n8n-nodes-base.httpRequest",
       "typeVersion": 4.2,
       "position": [
         900,
         400
-      ],
+      ]
-      "credentials": {
-        "httpHeaderAuth": {
-          "id": "unraid-api-key-credential-id",
-          "name": "Unraid API Key"
-        }
-      }
     },
     {
       "parameters": {
@@ -328,84 +265,6 @@
         1120,
         400
       ]
-    },
-    {
-      "parameters": {
-        "jsCode": "// GraphQL Response Normalizer - Transform Unraid GraphQL to Docker API contract\n// Input: $input.item.json = raw GraphQL response\n// Output: Array of normalized containers\n\nconst response = $input.item.json;\n\n// Validation: Check for GraphQL errors\nif (response.errors && response.errors.length > 0) {\n  const messages = response.errors.map(e => e.message).join('; ');\n  throw new Error(`GraphQL error: ${messages}`);\n}\n\n// Validation: Check response structure\nif (!response.data?.docker?.containers) {\n  throw new Error('Invalid GraphQL response structure: missing data.docker.containers');\n}\n\n// State mapping: Unraid UPPERCASE -> Docker lowercase\nconst stateMap = {\n  'RUNNING': 'running',\n  'STOPPED': 'exited',  // Docker convention: stopped = exited\n  'PAUSED': 'paused'\n};\n\nfunction normalizeState(unraidState) {\n  return stateMap[unraidState] || unraidState.toLowerCase();\n}\n\n// Transform each container\nconst containers = response.data.docker.containers;\nconst normalized = containers.map(container => {\n  const dockerState = normalizeState(container.state);\n  \n  return {\n    // Core fields matching Docker API contract\n    Id: container.id,                    // Keep full PrefixedID (registry handles translation)\n    Names: container.names,               // Already has '/' prefix (Phase 14 verified)\n    State: dockerState,                   // Normalized lowercase state\n    Status: container.status || dockerState,  // Use Unraid status field or fallback to state\n    Image: container.image || '',         // Unraid provides image field\n    \n    // Debug field: preserve original Unraid ID\n    _unraidId: container.id\n  };\n});\n\n// Return as array of items (n8n multi-item output format)\nreturn normalized.map(container => ({ json: container }));"
-      },
-      "id": "status-normalizer-list",
-      "name": "Normalize GraphQL Response (List)",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        1000,
-        200
-      ]
-    },
-    {
-      "parameters": {
-        "jsCode": "// GraphQL Response Normalizer - Transform Unraid GraphQL to Docker API contract\n// Input: $input.item.json = raw GraphQL response\n// Output: Array of normalized containers\n\nconst response = $input.item.json;\n\n// Validation: Check for GraphQL errors\nif (response.errors && response.errors.length > 0) {\n  const messages = response.errors.map(e => e.message).join('; ');\n  throw new Error(`GraphQL error: ${messages}`);\n}\n\n// Validation: Check response structure\nif (!response.data?.docker?.containers) {\n  throw new Error('Invalid GraphQL response structure: missing data.docker.containers');\n}\n\n// State mapping: Unraid UPPERCASE -> Docker lowercase\nconst stateMap = {\n  'RUNNING': 'running',\n  'STOPPED': 'exited',  // Docker convention: stopped = exited\n  'PAUSED': 'paused'\n};\n\nfunction normalizeState(unraidState) {\n  return stateMap[unraidState] || unraidState.toLowerCase();\n}\n\n// Transform each container\nconst containers = response.data.docker.containers;\nconst normalized = containers.map(container => {\n  const dockerState = normalizeState(container.state);\n  \n  return {\n    // Core fields matching Docker API contract\n    Id: container.id,                    // Keep full PrefixedID (registry handles translation)\n    Names: container.names,               // Already has '/' prefix (Phase 14 verified)\n    State: dockerState,                   // Normalized lowercase state\n    Status: container.status || dockerState,  // Use Unraid status field or fallback to state\n    Image: container.image || '',         // Unraid provides image field\n    \n    // Debug field: preserve original Unraid ID\n    _unraidId: container.id\n  };\n});\n\n// Return as array of items (n8n multi-item output format)\nreturn normalized.map(container => ({ json: container }));"
-      },
-      "id": "status-normalizer-status",
-      "name": "Normalize GraphQL Response (Status)",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        1000,
-        300
-      ]
-    },
-    {
-      "parameters": {
-        "jsCode": "// GraphQL Response Normalizer - Transform Unraid GraphQL to Docker API contract\n// Input: $input.item.json = raw GraphQL response\n// Output: Array of normalized containers\n\nconst response = $input.item.json;\n\n// Validation: Check for GraphQL errors\nif (response.errors && response.errors.length > 0) {\n  const messages = response.errors.map(e => e.message).join('; ');\n  throw new Error(`GraphQL error: ${messages}`);\n}\n\n// Validation: Check response structure\nif (!response.data?.docker?.containers) {\n  throw new Error('Invalid GraphQL response structure: missing data.docker.containers');\n}\n\n// State mapping: Unraid UPPERCASE -> Docker lowercase\nconst stateMap = {\n  'RUNNING': 'running',\n  'STOPPED': 'exited',  // Docker convention: stopped = exited\n  'PAUSED': 'paused'\n};\n\nfunction normalizeState(unraidState) {\n  return stateMap[unraidState] || unraidState.toLowerCase();\n}\n\n// Transform each container\nconst containers = response.data.docker.containers;\nconst normalized = containers.map(container => {\n  const dockerState = normalizeState(container.state);\n  \n  return {\n    // Core fields matching Docker API contract\n    Id: container.id,                    // Keep full PrefixedID (registry handles translation)\n    Names: container.names,               // Already has '/' prefix (Phase 14 verified)\n    State: dockerState,                   // Normalized lowercase state\n    Status: container.status || dockerState,  // Use Unraid status field or fallback to state\n    Image: container.image || '',         // Unraid provides image field\n    \n    // Debug field: preserve original Unraid ID\n    _unraidId: container.id\n  };\n});\n\n// Return as array of items (n8n multi-item output format)\nreturn normalized.map(container => ({ json: container }));"
-      },
-      "id": "status-normalizer-paginate",
-      "name": "Normalize GraphQL Response (Paginate)",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        1000,
-        400
-      ]
-    },
-    {
-      "parameters": {
-        "jsCode": "// Update Container ID Registry with fresh container data\nconst containers = $input.all().map(item => item.json);\n\n// Initialize registry using static data with JSON serialization pattern\nconst registry = $getWorkflowStaticData('global');\nif (!registry._containerIdMap) {\n  registry._containerIdMap = JSON.stringify({});\n}\n\nconst newMap = {};\n\nfor (const container of containers) {\n  // Extract container name: strip leading '/', lowercase\n  const rawName = container.Names[0];\n  const name = rawName.startsWith('/') ? rawName.substring(1).toLowerCase() : rawName.toLowerCase();\n  \n  // Map name -> {name, unraidId}\n  newMap[name] = {\n    name: name,\n    unraidId: container.Id  // Full PrefixedID from normalized data\n  };\n}\n\n// Store timestamp\nregistry._lastRefresh = Date.now();\n\n// Serialize (top-level assignment - this is what n8n persists)\nregistry._containerIdMap = JSON.stringify(newMap);\n\n// Pass through all containers unchanged\nreturn $input.all();"
-      },
-      "id": "status-registry-list",
-      "name": "Update Container Registry (List)",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        1060,
-        200
-      ]
-    },
-    {
-      "parameters": {
-        "jsCode": "// Update Container ID Registry with fresh container data\nconst containers = $input.all().map(item => item.json);\n\n// Initialize registry using static data with JSON serialization pattern\nconst registry = $getWorkflowStaticData('global');\nif (!registry._containerIdMap) {\n  registry._containerIdMap = JSON.stringify({});\n}\n\nconst newMap = {};\n\nfor (const container of containers) {\n  // Extract container name: strip leading '/', lowercase\n  const rawName = container.Names[0];\n  const name = rawName.startsWith('/') ? rawName.substring(1).toLowerCase() : rawName.toLowerCase();\n  \n  // Map name -> {name, unraidId}\n  newMap[name] = {\n    name: name,\n    unraidId: container.Id  // Full PrefixedID from normalized data\n  };\n}\n\n// Store timestamp\nregistry._lastRefresh = Date.now();\n\n// Serialize (top-level assignment - this is what n8n persists)\nregistry._containerIdMap = JSON.stringify(newMap);\n\n// Pass through all containers unchanged\nreturn $input.all();"
-      },
-      "id": "status-registry-status",
-      "name": "Update Container Registry (Status)",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        1060,
-        300
-      ]
-    },
-    {
-      "parameters": {
-        "jsCode": "// Update Container ID Registry with fresh container data\nconst containers = $input.all().map(item => item.json);\n\n// Initialize registry using static data with JSON serialization pattern\nconst registry = $getWorkflowStaticData('global');\nif (!registry._containerIdMap) {\n  registry._containerIdMap = JSON.stringify({});\n}\n\nconst newMap = {};\n\nfor (const container of containers) {\n  // Extract container name: strip leading '/', lowercase\n  const rawName = container.Names[0];\n  const name = rawName.startsWith('/') ? rawName.substring(1).toLowerCase() : rawName.toLowerCase();\n  \n  // Map name -> {name, unraidId}\n  newMap[name] = {\n    name: name,\n    unraidId: container.Id  // Full PrefixedID from normalized data\n  };\n}\n\n// Store timestamp\nregistry._lastRefresh = Date.now();\n\n// Serialize (top-level assignment - this is what n8n persists)\nregistry._containerIdMap = JSON.stringify(newMap);\n\n// Pass through all containers unchanged\nreturn $input.all();"
-      },
-      "id": "status-registry-paginate",
-      "name": "Update Container Registry (Paginate)",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        1060,
-        400
-      ]
     }
   ],
   "connections": {
@@ -449,36 +308,14 @@
       "main": [
         [
           {
-            "node": "Query Containers",
+            "node": "Docker List Containers",
             "type": "main",
             "index": 0
           }
         ]
       ]
     },
-    "Query Containers": {
+    "Docker List Containers": {
-      "main": [
-        [
-          {
-            "node": "Normalize GraphQL Response (List)",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Normalize GraphQL Response (List)": {
-      "main": [
-        [
-          {
-            "node": "Update Container Registry (List)",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Update Container Registry (List)": {
       "main": [
         [
           {
@@ -493,36 +330,14 @@
       "main": [
         [
           {
-            "node": "Query Container Status",
+            "node": "Docker Get Container",
             "type": "main",
             "index": 0
           }
         ]
       ]
     },
-    "Query Container Status": {
+    "Docker Get Container": {
-      "main": [
-        [
-          {
-            "node": "Normalize GraphQL Response (Status)",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Normalize GraphQL Response (Status)": {
-      "main": [
-        [
-          {
-            "node": "Update Container Registry (Status)",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Update Container Registry (Status)": {
       "main": [
         [
           {
@@ -537,36 +352,14 @@
       "main": [
         [
           {
-            "node": "Query Containers For Paginate",
+            "node": "Docker List For Paginate",
             "type": "main",
             "index": 0
           }
         ]
       ]
     },
-    "Query Containers For Paginate": {
+    "Docker List For Paginate": {
-      "main": [
-        [
-          {
-            "node": "Normalize GraphQL Response (Paginate)",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Normalize GraphQL Response (Paginate)": {
-      "main": [
-        [
-          {
-            "node": "Update Container Registry (Paginate)",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Update Container Registry (Paginate)": {
       "main": [
         [
           {

n8n-update.json

@@ -75,152 +75,85 @@
     },
     {
       "parameters": {
-        "method": "POST",
+        "url": "http://docker-socket-proxy:2375/v1.47/containers/json?all=true",
-        "url": "={{ $env.UNRAID_HOST }}/graphql",
-        "authentication": "genericCredentialType",
-        "sendHeaders": true,
-        "headerParameters": {
-          "parameters": [
-            {
-              "name": "Content-Type",
-              "value": "application/json"
-            }
-          ]
-        },
-        "sendBody": true,
-        "specifyBody": "json",
-        "jsonBody": "={\"query\": \"query { docker { containers { id names state image imageId } } }\"}",
         "options": {
-          "timeout": 15000
+          "timeout": 5000
+        }
       },
-        "genericAuthType": "httpHeaderAuth"
+      "id": "http-get-containers",
-      },
+      "name": "Get All Containers",
-      "id": "http-query-containers",
-      "name": "Query All Containers",
       "type": "n8n-nodes-base.httpRequest",
       "typeVersion": 4.2,
       "position": [
         560,
         400
-      ],
-      "onError": "continueRegularOutput",
-      "credentials": {
-        "httpHeaderAuth": {
-          "id": "unraid-api-key-credential-id",
-          "name": "Unraid API Key"
-        }
-      }
-    },
-    {
-      "parameters": {
-        "jsCode": "// GraphQL Response Normalizer - Transform Unraid GraphQL to Docker API contract\n// Input: $input.item.json = raw GraphQL response\n// Output: Array of normalized containers\n\nconst response = $input.item.json;\n\n// Validation: Check for GraphQL errors\nif (response.errors && response.errors.length > 0) {\n  const messages = response.errors.map(e => e.message).join('; ');\n  throw new Error(`GraphQL error: ${messages}`);\n}\n\n// Validation: Check response structure\nif (!response.data?.docker?.containers) {\n  throw new Error('Invalid GraphQL response structure: missing data.docker.containers');\n}\n\n// State mapping: Unraid UPPERCASE -> Docker lowercase\nconst stateMap = {\n  'RUNNING': 'running',\n  'STOPPED': 'exited',  // Docker convention: stopped = exited\n  'PAUSED': 'paused'\n};\n\nfunction normalizeState(unraidState) {\n  return stateMap[unraidState] || unraidState.toLowerCase();\n}\n\n// Transform each container\nconst containers = response.data.docker.containers;\nconst normalized = containers.map(container => {\n  const dockerState = normalizeState(container.state);\n  \n  return {\n    // Core fields matching Docker API contract\n    Id: container.id,                    // Keep full PrefixedID (registry handles translation)\n    Names: container.names,               // Already has '/' prefix (Phase 14 verified)\n    State: dockerState,                   // Normalized lowercase state\n    Status: dockerState,                  // Docker has separate Status field\n    Image: '',                            // Not available in basic query\n    \n    // Debug field: preserve original Unraid ID\n    _unraidId: container.id\n  };\n});\n\n// Return as array of items (n8n multi-item output format)\nreturn normalized.map(container => ({ json: container }));\n"
-      },
-      "id": "code-normalize-response",
-      "name": "Normalize GraphQL Response",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        720,
-        400
       ]
     },
     {
-      "id": "code-update-registry",
-      "name": "Update Container ID Registry",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        880,
-        400
-      ],
       "parameters": {
-        "mode": "runOnceForAllItems",
+        "jsCode": "// Find container by name and resolve ID\nconst triggerData = $('When executed by another workflow').item.json;\nconst containerName = triggerData.containerName;\nconst containers = $input.all();\n\n// Normalize function to strip leading slash\nconst normalizeName = (name) => name.replace(/^\\//, '').toLowerCase();\nconst searchName = normalizeName(containerName);\n\n// Find matching container\nlet matched = null;\nfor (const item of containers) {\n  const c = item.json;\n  if (c.Names && c.Names.length > 0) {\n    const cName = normalizeName(c.Names[0]);\n    if (cName === searchName || cName.includes(searchName)) {\n      matched = c;\n      break;\n    }\n  }\n}\n\nif (!matched) {\n  throw new Error(`Container '${containerName}' not found`);\n}\n\nreturn {\n  json: {\n    ...triggerData,\n    containerId: matched.Id\n  }\n};"
-        "jsCode": "// Container ID Registry - Update action only\nconst registry = $getWorkflowStaticData('global');\nif (!registry._containerIdMap) {\n  registry._containerIdMap = JSON.stringify({});\n}\n\nconst containers = $input.all().map(item => item.json);\nconst containerMap = JSON.parse(registry._containerIdMap);\n\n// Update map from normalized containers\nfor (const container of containers) {\n  const name = (container.Names?.[0] || '').replace(/^\\//, '').toLowerCase();\n  if (name && container.Id) {\n    containerMap[name] = {\n      name: name,\n      unraidId: container.Id,\n      timestamp: Date.now()\n    };\n  }\n}\n\nregistry._containerIdMap = JSON.stringify(containerMap);\nregistry._lastRefresh = Date.now();\n\n// Pass through all containers\nreturn containers.map(c => ({ json: c }));\n"
-      }
-    },
-    {
-      "parameters": {
-        "jsCode": "// Find container by name and resolve ID\nconst triggerData = $('When executed by another workflow').item.json;\nconst containerName = triggerData.containerName;\nconst containers = $input.all();\n\n// Normalize function to strip leading slash\nconst normalizeName = (name) => name.replace(/^\\//, '').toLowerCase();\nconst searchName = normalizeName(containerName);\n\n// Find matching container\nlet matched = null;\nfor (const item of containers) {\n  const c = item.json;\n  if (c.Names && c.Names.length > 0) {\n    const cName = normalizeName(c.Names[0]);\n    if (cName === searchName || cName.includes(searchName)) {\n      matched = c;\n      break;\n    }\n  }\n}\n\nif (!matched) {\n  throw new Error(`Container '${containerName}' not found`);\n}\n\nreturn {\n  json: {\n    ...triggerData,\n    containerId: matched.Id,\n    unraidId: matched.Id,  // Full PrefixedID for GraphQL mutation\n    currentImageId: matched.imageId || '',  // For later comparison\n    currentImage: matched.image || ''\n  }\n};\n"
       },
       "id": "code-resolve-id",
       "name": "Resolve Container ID",
       "type": "n8n-nodes-base.code",
       "typeVersion": 2,
       "position": [
-        1040,
+        720,
         400
       ]
     },
     {
       "parameters": {
-        "method": "POST",
+        "method": "GET",
-        "url": "={{ $env.UNRAID_HOST }}/graphql",
+        "url": "=http://docker-socket-proxy:2375/containers/{{ $json.containerId }}/json",
-        "authentication": "genericCredentialType",
-        "sendHeaders": true,
-        "headerParameters": {
-          "parameters": [
-            {
-              "name": "Content-Type",
-              "value": "application/json"
-            }
-          ]
-        },
-        "sendBody": true,
-        "specifyBody": "json",
-        "jsonBody": "={\"query\": \"query { docker { containers { id names state image imageId } } }\"}",
         "options": {
-          "timeout": 15000
+          "timeout": 5000
+        }
       },
-        "genericAuthType": "httpHeaderAuth"
+      "id": "http-inspect-container",
-      },
+      "name": "Inspect Container",
-      "id": "http-query-single",
-      "name": "Query Single Container",
       "type": "n8n-nodes-base.httpRequest",
       "typeVersion": 4.2,
       "position": [
-        560,
+        460,
-        300
-      ],
-      "onError": "continueRegularOutput",
-      "credentials": {
-        "httpHeaderAuth": {
-          "id": "unraid-api-key-credential-id",
-          "name": "Unraid API Key"
-        }
-      }
-    },
-    {
-      "parameters": {
-        "jsCode": "// GraphQL Response Normalizer - Find and normalize single container by ID\n// Input: $input.item.json = raw GraphQL response (all containers)\n// Uses: trigger data containerId to filter to the target container\n\nconst response = $input.item.json;\nconst triggerData = $('When executed by another workflow').item.json;\nconst targetId = triggerData.containerId;\n\n// Validation: Check for GraphQL errors\nif (response.errors && response.errors.length > 0) {\n  const messages = response.errors.map(e => e.message).join('; ');\n  throw new Error(`GraphQL error: ${messages}`);\n}\n\n// Validation: Check response structure\nif (!response.data?.docker?.containers) {\n  throw new Error('Invalid GraphQL response structure: missing data.docker.containers');\n}\n\n// State mapping: Unraid UPPERCASE -> Docker lowercase\nconst stateMap = {\n  'RUNNING': 'running',\n  'STOPPED': 'exited',\n  'PAUSED': 'paused'\n};\n\nfunction normalizeState(unraidState) {\n  return stateMap[unraidState] || unraidState.toLowerCase();\n}\n\n// Find the target container by ID\nconst allContainers = response.data.docker.containers;\nconst matched = allContainers.find(c => c.id === targetId);\n\nif (!matched) {\n  throw new Error(`Container with ID '${targetId}' not found among ${allContainers.length} containers`);\n}\n\nconst dockerState = normalizeState(matched.state);\nreturn [{\n  json: {\n    Id: matched.id,\n    Names: matched.names,\n    State: dockerState,\n    Status: dockerState,\n    Image: matched.image || '',\n    imageId: matched.imageId || '',\n    _unraidId: matched.id\n  }\n}];\n"
-      },
-      "id": "code-normalize-single",
-      "name": "Normalize Single Container",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        720,
         300
       ]
     },
     {
       "parameters": {
-        "jsCode": "// Capture pre-update state from input\nconst data = $input.item.json;\nconst triggerData = $('When executed by another workflow').item.json;\n\n// Check if we have container data already (from Resolve path) or need to extract (from direct ID path)\nlet unraidId, containerName, currentImageId, currentImage;\n\nif (data.unraidId) {\n  // From Resolve Container ID path\n  unraidId = data.unraidId;\n  containerName = data.containerName;\n  currentImageId = data.currentImageId;\n  currentImage = data.currentImage;\n} else if (data.Id) {\n  // From Query Single Container path (normalized)\n  unraidId = data.Id;\n  containerName = (data.Names?.[0] || '').replace(/^\\//,  '');\n  currentImageId = data.imageId || '';\n  currentImage = data.Image || '';\n} else {\n  throw new Error('No container data found');\n}\n\nreturn {\n  json: {\n    unraidId,\n    containerName,\n    currentImageId,\n    currentImage,\n    chatId: triggerData.chatId,\n    messageId: triggerData.messageId,\n    responseMode: triggerData.responseMode,\n    correlationId: triggerData.correlationId || ''\n  }\n};\n"
+        "jsCode": "// Parse container config and prepare for pull\nconst inspectData = $input.item.json;\nconst triggerData = $('When executed by another workflow').item.json;\nconst containerId = triggerData.containerId;\nconst containerName = triggerData.containerName;\nconst chatId = triggerData.chatId;\nconst messageId = triggerData.messageId;\nconst responseMode = triggerData.responseMode;\nconst correlationId = triggerData.correlationId || '';\n\n// Extract image info\nlet imageName = inspectData.Config.Image;\nconst currentImageId = inspectData.Image;\n\n// CRITICAL: Ensure image has a tag, otherwise Docker pulls ALL tags!\nif (imageName && !imageName.includes(':') && !imageName.includes('@')) {\n  imageName = imageName + ':latest';\n}\n\n// Extract config for recreation\nconst containerConfig = inspectData.Config;\nconst hostConfig = inspectData.HostConfig;\nconst networkSettings = inspectData.NetworkSettings;\n\n// Get current version from labels or image digest\nconst labels = containerConfig.Labels || {};\nconst currentVersion = labels['org.opencontainers.image.version']\n  || labels['version']\n  || currentImageId.substring(7, 19);\n\nreturn {\n  json: {\n    containerId,\n    containerName,\n    chatId,\n    messageId,\n    responseMode,\n    imageName,\n    currentImageId,\n    currentVersion,\n    containerConfig,\n    hostConfig,\n    networkSettings,\n    correlationId\n  }\n};"
       },
-      "id": "code-capture-state",
+      "id": "code-parse-config",
-      "name": "Capture Pre-Update State",
+      "name": "Parse Container Config",
       "type": "n8n-nodes-base.code",
       "typeVersion": 2,
       "position": [
-        920,
+        680,
         300
       ]
     },
     {
       "parameters": {
-        "jsCode": "// Build GraphQL updateContainer mutation\nconst data = $input.item.json;\nreturn {\n  json: {\n    ...data,\n    query: `mutation { docker { updateContainer(id: \"${data.unraidId}\") { id state image imageId } } }`\n  }\n};\n"
+        "command": "=curl -s --max-time 600 -X POST 'http://docker-socket-proxy:2375/v1.47/images/create?fromImage={{ encodeURIComponent($json.imageName) }}' | tail -c 10000",
+        "options": {
+          "timeout": 660
+        }
       },
-      "id": "code-build-mutation",
+      "id": "exec-pull-image",
-      "name": "Build Update Mutation",
+      "name": "Pull Image",
+      "type": "n8n-nodes-base.executeCommand",
+      "typeVersion": 1,
+      "position": [
+        900,
+        300
+      ]
+    },
+    {
+      "parameters": {
+        "jsCode": "// Check pull response for errors\nconst stdout = $input.item.json.stdout || '';\nconst prevData = $('Parse Container Config').item.json;\n\n// Docker pull streams JSON objects, check for error messages\nif (stdout.includes('\"message\"') && (stdout.includes('toomanyrequests') || stdout.includes('error') || stdout.includes('denied'))) {\n  // Extract error message\n  let errorMsg = 'Pull failed';\n  try {\n    const match = stdout.match(/\"message\"\\s*:\\s*\"([^\"]+)\"/);\n    if (match) errorMsg = match[1];\n  } catch (e) {}\n  \n  return {\n    json: {\n      pullError: true,\n      errorMessage: errorMsg.substring(0, 100),\n      ...prevData\n    }\n  };\n}\n\n// Success - pass through data\nreturn {\n  json: {\n    pullError: false,\n    ...prevData\n  }\n};"
+      },
+      "id": "code-check-pull",
+      "name": "Check Pull Response",
       "type": "n8n-nodes-base.code",
       "typeVersion": 2,
       "position": [
@@ -228,57 +161,6 @@
         300
       ]
     },
-    {
-      "parameters": {
-        "method": "POST",
-        "url": "={{ $env.UNRAID_HOST }}/graphql",
-        "authentication": "genericCredentialType",
-        "sendHeaders": true,
-        "headerParameters": {
-          "parameters": [
-            {
-              "name": "Content-Type",
-              "value": "application/json"
-            }
-          ]
-        },
-        "sendBody": true,
-        "specifyBody": "json",
-        "jsonBody": "={{ {\"query\": $json.query} }}",
-        "options": {
-          "timeout": 60000
-        },
-        "genericAuthType": "httpHeaderAuth"
-      },
-      "id": "http-update-container",
-      "name": "Update Container",
-      "type": "n8n-nodes-base.httpRequest",
-      "typeVersion": 4.2,
-      "position": [
-        1320,
-        300
-      ],
-      "onError": "continueRegularOutput",
-      "credentials": {
-        "httpHeaderAuth": {
-          "id": "unraid-api-key-credential-id",
-          "name": "Unraid API Key"
-        }
-      }
-    },
-    {
-      "parameters": {
-        "jsCode": "// Handle updateContainer mutation response\nconst response = $input.item.json;\nconst prevData = $('Capture Pre-Update State').item.json;\n\n// Check for GraphQL errors\nif (response.errors) {\n  const error = response.errors[0];\n  return {\n    json: {\n      success: false,\n      error: true,\n      errorMessage: error.message || 'Update failed',\n      ...prevData\n    }\n  };\n}\n\n// Extract updated container from response\nconst updated = response.data?.docker?.updateContainer;\nif (!updated) {\n  return {\n    json: {\n      success: false,\n      error: true,\n      errorMessage: 'No response from update mutation',\n      ...prevData\n    }\n  };\n}\n\n// Compare imageId to determine if update happened\nconst newImageId = updated.imageId || '';\nconst oldImageId = prevData.currentImageId || '';\nconst wasUpdated = (newImageId !== oldImageId);\n\nreturn {\n  json: {\n    success: true,\n    needsUpdate: wasUpdated,\n    updated: wasUpdated,\n    containerName: prevData.containerName,\n    currentVersion: prevData.currentImage,\n    newVersion: updated.image,\n    currentImageId: oldImageId,\n    newImageId: newImageId,\n    chatId: prevData.chatId,\n    messageId: prevData.messageId,\n    responseMode: prevData.responseMode,\n    correlationId: prevData.correlationId\n  }\n};\n"
-      },
-      "id": "code-handle-response",
-      "name": "Handle Update Response",
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        1520,
-        300
-      ]
-    },
     {
       "parameters": {
         "conditions": {
@@ -289,12 +171,12 @@
           },
           "conditions": [
             {
-              "id": "is-success",
+              "id": "pull-success",
-              "leftValue": "={{ $json.error }}",
+              "leftValue": "={{ $json.pullError }}",
-              "rightValue": true,
+              "rightValue": false,
               "operator": {
                 "type": "boolean",
-                "operation": "notEquals"
+                "operation": "equals"
               }
             }
           ],
@@ -302,15 +184,45 @@
         },
         "options": {}
       },
-      "id": "if-update-success",
+      "id": "if-pull-success",
-      "name": "Check Update Success",
+      "name": "Check Pull Success",
       "type": "n8n-nodes-base.if",
       "typeVersion": 2,
       "position": [
-        1720,
+        1340,
         300
       ]
     },
+    {
+      "parameters": {
+        "method": "GET",
+        "url": "=http://docker-socket-proxy:2375/v1.47/images/{{ encodeURIComponent($json.imageName) }}/json",
+        "options": {
+          "timeout": 5000
+        }
+      },
+      "id": "http-inspect-new-image",
+      "name": "Inspect New Image",
+      "type": "n8n-nodes-base.httpRequest",
+      "typeVersion": 4.2,
+      "position": [
+        1560,
+        200
+      ]
+    },
+    {
+      "parameters": {
+        "jsCode": "// Compare old and new image IDs\nconst newImage = $input.item.json;\nconst prevData = $('Check Pull Success').item.json;\nconst currentImageId = prevData.currentImageId;\n\nconst newImageId = newImage.Id;\n\nif (currentImageId === newImageId) {\n  // No update needed\n  return {\n    json: {\n      needsUpdate: false,\n      ...prevData\n    }\n  };\n}\n\n// Extract new version from labels\nconst labels = newImage.Config?.Labels || {};\nconst newVersion = labels['org.opencontainers.image.version']\n  || labels['version']\n  || newImageId.substring(7, 19);\n\nreturn {\n  json: {\n    needsUpdate: true,\n    newImageId,\n    newVersion,\n    ...prevData\n  }\n};"
+      },
+      "id": "code-compare-digests",
+      "name": "Compare Digests",
+      "type": "n8n-nodes-base.code",
+      "typeVersion": 2,
+      "position": [
+        1780,
+        200
+      ]
+    },
     {
       "parameters": {
         "conditions": {
@@ -321,7 +233,7 @@
           },
           "conditions": [
             {
-              "id": "was-updated",
+              "id": "needs-update",
               "leftValue": "={{ $json.needsUpdate }}",
               "rightValue": true,
               "operator": {
@@ -334,26 +246,126 @@
         },
         "options": {}
       },
-      "id": "if-was-updated",
+      "id": "if-needs-update",
-      "name": "Check If Updated",
+      "name": "Check If Update Needed",
       "type": "n8n-nodes-base.if",
       "typeVersion": 2,
       "position": [
-        1920,
+        2000,
         200
       ]
     },
     {
       "parameters": {
-        "jsCode": "// Format update success result\nconst data = $('Handle Update Response').item.json;\nconst containerName = data.containerName;\nconst currentVersion = data.currentVersion;\nconst newVersion = data.newVersion;\n\nconst message = `<b>${containerName}</b> updated: ${currentVersion} \\u2192 ${newVersion}`;\n\nreturn {\n  json: {\n    success: true,\n    updated: true,\n    message,\n    oldDigest: currentVersion,\n    newDigest: newVersion,\n    chatId: data.chatId,\n    messageId: data.messageId,\n    responseMode: data.responseMode,\n    containerName: containerName,\n    correlationId: data.correlationId || ''\n  }\n};\n"
+        "method": "POST",
+        "url": "=http://docker-socket-proxy:2375/v1.47/containers/{{ $json.containerId }}/stop?t=10",
+        "options": {
+          "timeout": 15000
+        }
+      },
+      "id": "http-stop-container",
+      "name": "Stop Container",
+      "type": "n8n-nodes-base.httpRequest",
+      "typeVersion": 4.2,
+      "position": [
+        2220,
+        100
+      ],
+      "onError": "continueRegularOutput"
+    },
+    {
+      "parameters": {
+        "method": "DELETE",
+        "url": "=http://docker-socket-proxy:2375/v1.47/containers/{{ $('Check If Update Needed').item.json.containerId }}",
+        "options": {
+          "timeout": 5000
+        }
+      },
+      "id": "http-remove-container",
+      "name": "Remove Container",
+      "type": "n8n-nodes-base.httpRequest",
+      "typeVersion": 4.2,
+      "position": [
+        2440,
+        100
+      ],
+      "onError": "continueRegularOutput"
+    },
+    {
+      "parameters": {
+        "jsCode": "// Build container create request body from saved config\nconst prevData = $('Check If Update Needed').item.json;\nconst config = prevData.containerConfig;\nconst hostConfig = prevData.hostConfig;\nconst networkSettings = prevData.networkSettings;\nconst containerName = prevData.containerName;\n\n// Build NetworkingConfig from NetworkSettings\nconst networks = {};\nfor (const [name, netConfig] of Object.entries(networkSettings.Networks || {})) {\n  networks[name] = {\n    IPAMConfig: netConfig.IPAMConfig,\n    Links: netConfig.Links,\n    Aliases: netConfig.Aliases\n  };\n}\n\nconst createBody = {\n  ...config,\n  HostConfig: hostConfig,\n  NetworkingConfig: {\n    EndpointsConfig: networks\n  }\n};\n\n// Remove fields that shouldn't be in create request\ndelete createBody.Hostname;\ndelete createBody.Domainname;\n\nreturn {\n  json: {\n    createBody,\n    containerName,\n    ...prevData\n  }\n};"
+      },
+      "id": "code-build-create-body",
+      "name": "Build Create Body",
+      "type": "n8n-nodes-base.code",
+      "typeVersion": 2,
+      "position": [
+        2660,
+        100
+      ]
+    },
+    {
+      "parameters": {
+        "method": "POST",
+        "url": "=http://docker-socket-proxy:2375/v1.47/containers/create?name={{ encodeURIComponent($json.containerName) }}",
+        "sendBody": true,
+        "specifyBody": "json",
+        "jsonBody": "={{ JSON.stringify($json.createBody) }}",
+        "options": {
+          "timeout": 5000
+        }
+      },
+      "id": "http-create-container",
+      "name": "Create Container",
+      "type": "n8n-nodes-base.httpRequest",
+      "typeVersion": 4.2,
+      "position": [
+        2880,
+        100
+      ]
+    },
+    {
+      "parameters": {
+        "jsCode": "// Parse create response and extract new container ID\nconst response = $input.item.json;\nconst prevData = $('Build Create Body').item.json;\n\nif (response.message) {\n  // Error response from Docker\n  return {\n    json: {\n      createError: true,\n      errorMessage: response.message,\n      ...prevData\n    }\n  };\n}\n\nreturn {\n  json: {\n    createError: false,\n    newContainerId: response.Id,\n    ...prevData\n  }\n};"
+      },
+      "id": "code-parse-create",
+      "name": "Parse Create Response",
+      "type": "n8n-nodes-base.code",
+      "typeVersion": 2,
+      "position": [
+        3100,
+        100
+      ]
+    },
+    {
+      "parameters": {
+        "method": "POST",
+        "url": "=http://docker-socket-proxy:2375/v1.47/containers/{{ $json.newContainerId }}/start",
+        "options": {
+          "timeout": 5000
+        }
+      },
+      "id": "http-start-container",
+      "name": "Start Container",
+      "type": "n8n-nodes-base.httpRequest",
+      "typeVersion": 4.2,
+      "position": [
+        3320,
+        100
+      ],
+      "onError": "continueRegularOutput"
+    },
+    {
+      "parameters": {
+        "jsCode": "// Format update success result and clean up old image\nconst prevData = $('Parse Create Response').item.json;\nconst containerName = prevData.containerName;\nconst currentVersion = prevData.currentVersion;\nconst newVersion = prevData.newVersion;\nconst currentImageId = prevData.currentImageId;\nconst chatId = prevData.chatId;\nconst messageId = prevData.messageId;\nconst responseMode = prevData.responseMode;\nconst correlationId = prevData.correlationId || '';\n\nconst message = `<b>${containerName}</b> updated: ${currentVersion} \\u2192 ${newVersion}`;\n\nreturn {\n  json: {\n    success: true,\n    updated: true,\n    message,\n    oldDigest: currentVersion,\n    newDigest: newVersion,\n    currentImageId,\n    chatId,\n    messageId,\n    responseMode,\n    containerName,\n    correlationId\n  }\n};"
       },
       "id": "code-format-success",
       "name": "Format Update Success",
       "type": "n8n-nodes-base.code",
       "typeVersion": 2,
       "position": [
-        1960,
+        3540,
-        200
+        100
       ]
     },
     {
@@ -417,8 +429,8 @@
       "type": "n8n-nodes-base.switch",
       "typeVersion": 3.2,
       "position": [
-        2180,
+        3760,
-        200
+        100
       ]
     },
     {
@@ -435,8 +447,8 @@
       "type": "n8n-nodes-base.httpRequest",
       "typeVersion": 4.2,
       "position": [
-        2400,
+        3980,
-        100
+        0
       ]
     },
     {
@@ -454,8 +466,8 @@
       "type": "n8n-nodes-base.telegram",
       "typeVersion": 1.2,
       "position": [
-        2400,
+        3980,
-        300
+        200
       ],
       "credentials": {
         "telegramApi": {
@@ -464,6 +476,24 @@
         }
       }
     },
+    {
+      "parameters": {
+        "method": "DELETE",
+        "url": "=http://docker-socket-proxy:2375/v1.47/images/{{ $('Format Update Success').item.json.currentImageId }}?force=false",
+        "options": {
+          "timeout": 5000
+        }
+      },
+      "id": "http-remove-old-image-success",
+      "name": "Remove Old Image (Success)",
+      "type": "n8n-nodes-base.httpRequest",
+      "typeVersion": 4.2,
+      "position": [
+        4200,
+        100
+      ],
+      "onError": "continueRegularOutput"
+    },
     {
       "parameters": {
         "jsCode": "// Return final success result\nconst data = $('Format Update Success').item.json;\nreturn {\n  json: {\n    success: true,\n    updated: true,\n    message: data.message,\n    oldDigest: data.oldDigest,\n    newDigest: data.newDigest,\n    correlationId: data.correlationId || ''\n  }\n};"
@@ -473,21 +503,21 @@
       "type": "n8n-nodes-base.code",
       "typeVersion": 2,
       "position": [
-        2620,
+        4420,
-        200
+        100
       ]
     },
     {
       "parameters": {
-        "jsCode": "// Format 'already up to date' result\nconst data = $('Handle Update Response').item.json;\nconst containerName = data.containerName;\n\nconst message = `<b>${containerName}</b> is already up to date`;\n\nreturn {\n  json: {\n    success: true,\n    updated: false,\n    message,\n    chatId: data.chatId,\n    messageId: data.messageId,\n    responseMode: data.responseMode,\n    containerName: containerName,\n    correlationId: data.correlationId || ''\n  }\n};\n"
+        "jsCode": "// Format 'already up to date' result\nconst prevData = $('Check If Update Needed').item.json;\nconst containerName = prevData.containerName;\nconst chatId = prevData.chatId;\nconst messageId = prevData.messageId;\nconst responseMode = prevData.responseMode;\nconst correlationId = prevData.correlationId || '';\n\nconst message = `<b>${containerName}</b> is already up to date`;\n\nreturn {\n  json: {\n    success: true,\n    updated: false,\n    message,\n    chatId,\n    messageId,\n    responseMode,\n    containerName,\n    correlationId\n  }\n};"
       },
       "id": "code-format-no-update",
       "name": "Format No Update Needed",
       "type": "n8n-nodes-base.code",
       "typeVersion": 2,
       "position": [
-        1960,
+        2220,
-        400
+        300
       ]
     },
     {
@@ -551,8 +581,8 @@
       "type": "n8n-nodes-base.switch",
       "typeVersion": 3.2,
       "position": [
-        2180,
+        2440,
-        400
+        300
       ]
     },
     {
@@ -569,8 +599,8 @@
       "type": "n8n-nodes-base.httpRequest",
       "typeVersion": 4.2,
       "position": [
-        2400,
+        2660,
-        400
+        200
       ]
     },
     {
@@ -588,8 +618,8 @@
       "type": "n8n-nodes-base.telegram",
       "typeVersion": 1.2,
       "position": [
-        2400,
+        2660,
-        500
+        400
       ],
       "credentials": {
         "telegramApi": {
@@ -607,21 +637,21 @@
       "type": "n8n-nodes-base.code",
       "typeVersion": 2,
       "position": [
-        2620,
+        2880,
-        400
+        300
       ]
     },
     {
       "parameters": {
-        "jsCode": "// Format update error result\nconst data = $('Handle Update Response').item.json;\nconst containerName = data.containerName;\nconst errorMessage = data.errorMessage;\n\nconst message = `Failed to update <b>${containerName}</b>: ${errorMessage}`;\n\nreturn {\n  json: {\n    success: false,\n    updated: false,\n    message,\n    error: {\n      workflow: 'n8n-update',\n      node: 'Update Container',\n      message: errorMessage,\n      httpCode: null,\n      rawResponse: errorMessage\n    },\n    correlationId: data.correlationId || '',\n    chatId: data.chatId,\n    messageId: data.messageId,\n    responseMode: data.responseMode,\n    containerName: containerName\n  }\n};\n"
+        "jsCode": "// Format pull error result\nconst prevData = $('Check Pull Success').item.json;\nconst containerName = prevData.containerName;\nconst errorMessage = prevData.errorMessage;\nconst chatId = prevData.chatId;\nconst messageId = prevData.messageId;\nconst responseMode = prevData.responseMode;\nconst correlationId = prevData.correlationId || '';\n\nconst message = `Failed to update <b>${containerName}</b>: ${errorMessage}`;\n\nreturn {\n  json: {\n    success: false,\n    updated: false,\n    message,\n    error: {\n      workflow: 'n8n-update',\n      node: 'Pull Image',\n      message: errorMessage,\n      httpCode: null,\n      rawResponse: errorMessage\n    },\n    correlationId,\n    chatId,\n    messageId,\n    responseMode,\n    containerName\n  }\n};"
       },
       "id": "code-format-pull-error",
-      "name": "Format Update Error",
+      "name": "Format Pull Error",
       "type": "n8n-nodes-base.code",
       "typeVersion": 2,
       "position": [
-        1540,
+        1560,
-        500
+        400
       ]
     },
     {
@@ -685,8 +715,8 @@
       "type": "n8n-nodes-base.switch",
       "typeVersion": 3.2,
       "position": [
-        1760,
+        1780,
-        500
+        400
       ]
     },
     {
@@ -703,8 +733,8 @@
       "type": "n8n-nodes-base.httpRequest",
       "typeVersion": 4.2,
       "position": [
-        1980,
+        2000,
-        500
+        300
       ]
     },
     {
@@ -722,8 +752,8 @@
       "type": "n8n-nodes-base.telegram",
       "typeVersion": 1.2,
       "position": [
-        1980,
+        2000,
-        600
+        500
       ],
       "credentials": {
         "telegramApi": {
@@ -734,15 +764,15 @@
     },
     {
       "parameters": {
-        "jsCode": "// Return error result\nconst data = $('Format Update Error').item.json;\nreturn {\n  json: {\n    success: false,\n    updated: false,\n    message: data.message\n  }\n};"
+        "jsCode": "// Return error result\nconst data = $('Format Pull Error').item.json;\nreturn {\n  json: {\n    success: false,\n    updated: false,\n    message: data.message\n  }\n};"
       },
       "id": "code-return-error",
       "name": "Return Error",
       "type": "n8n-nodes-base.code",
       "typeVersion": 2,
       "position": [
-        2200,
+        2220,
-        500
+        400
       ]
     }
   ],
@@ -762,65 +792,21 @@
       "main": [
         [
           {
-            "node": "Query Single Container",
+            "node": "Inspect Container",
             "type": "main",
             "index": 0
           }
         ],
         [
           {
-            "node": "Query All Containers",
+            "node": "Get All Containers",
             "type": "main",
             "index": 0
           }
         ]
       ]
     },
-    "Query Single Container": {
+    "Get All Containers": {
-      "main": [
-        [
-          {
-            "node": "Normalize Single Container",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Normalize Single Container": {
-      "main": [
-        [
-          {
-            "node": "Capture Pre-Update State",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Query All Containers": {
-      "main": [
-        [
-          {
-            "node": "Normalize GraphQL Response",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Normalize GraphQL Response": {
-      "main": [
-        [
-          {
-            "node": "Update Container ID Registry",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Update Container ID Registry": {
       "main": [
         [
           {
@@ -835,62 +821,102 @@
       "main": [
         [
           {
-            "node": "Capture Pre-Update State",
+            "node": "Inspect Container",
             "type": "main",
             "index": 0
           }
         ]
       ]
     },
-    "Capture Pre-Update State": {
+    "Inspect Container": {
       "main": [
         [
           {
-            "node": "Build Update Mutation",
+            "node": "Parse Container Config",
             "type": "main",
             "index": 0
           }
         ]
       ]
     },
-    "Build Update Mutation": {
+    "Parse Container Config": {
       "main": [
         [
           {
-            "node": "Update Container",
+            "node": "Pull Image",
             "type": "main",
             "index": 0
           }
         ]
       ]
     },
-    "Update Container": {
+    "Pull Image": {
       "main": [
         [
           {
-            "node": "Handle Update Response",
+            "node": "Check Pull Response",
             "type": "main",
             "index": 0
           }
         ]
       ]
     },
-    "Handle Update Response": {
+    "Check Pull Response": {
       "main": [
         [
           {
-            "node": "Check Update Success",
+            "node": "Check Pull Success",
             "type": "main",
             "index": 0
           }
         ]
       ]
     },
-    "Check If Updated": {
+    "Check Pull Success": {
       "main": [
         [
           {
-            "node": "Format Update Success",
+            "node": "Inspect New Image",
+            "type": "main",
+            "index": 0
+          }
+        ],
+        [
+          {
+            "node": "Format Pull Error",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Inspect New Image": {
+      "main": [
+        [
+          {
+            "node": "Compare Digests",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Compare Digests": {
+      "main": [
+        [
+          {
+            "node": "Check If Update Needed",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Check If Update Needed": {
+      "main": [
+        [
+          {
+            "node": "Stop Container",
             "type": "main",
             "index": 0
           }
@@ -904,6 +930,72 @@
         ]
       ]
     },
+    "Stop Container": {
+      "main": [
+        [
+          {
+            "node": "Remove Container",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Remove Container": {
+      "main": [
+        [
+          {
+            "node": "Build Create Body",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Build Create Body": {
+      "main": [
+        [
+          {
+            "node": "Create Container",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Create Container": {
+      "main": [
+        [
+          {
+            "node": "Parse Create Response",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Parse Create Response": {
+      "main": [
+        [
+          {
+            "node": "Start Container",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Start Container": {
+      "main": [
+        [
+          {
+            "node": "Format Update Success",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
     "Format Update Success": {
       "main": [
         [
@@ -926,7 +1018,7 @@
         ],
         [
           {
-            "node": "Return Success",
+            "node": "Remove Old Image (Success)",
             "type": "main",
             "index": 0
           }
@@ -944,7 +1036,7 @@
       "main": [
         [
           {
-            "node": "Return Success",
+            "node": "Remove Old Image (Success)",
             "type": "main",
             "index": 0
           }
@@ -952,6 +1044,17 @@
       ]
     },
     "Send Text Success": {
+      "main": [
+        [
+          {
+            "node": "Remove Old Image (Success)",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Remove Old Image (Success)": {
       "main": [
         [
           {
@@ -1020,7 +1123,7 @@
         ]
       ]
     },
-    "Format Update Error": {
+    "Format Pull Error": {
       "main": [
         [
           {
@@ -1077,24 +1180,6 @@
           }
         ]
       ]
-    },
-    "Check Update Success": {
-      "main": [
-        [
-          {
-            "node": "Check If Updated",
-            "type": "main",
-            "index": 0
-          }
-        ],
-        [
-          {
-            "node": "Format Update Error",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
     }
   },
   "settings": {