pinokiod 7.5.13 → 7.5.15

package/test/gpu-target-template-variable.test.js

@@ -0,0 +1,69 @@
+const assert = require('node:assert/strict')
+const fs = require('node:fs/promises')
+const os = require('node:os')
+const path = require('node:path')
+const test = require('node:test')
+
+const Kernel = require('../kernel')
+
+test('Kernel propagates sysinfo gpu_target to template state and public info', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-gpu-target-info-'))
+  const apiRoot = path.join(root, 'api')
+  await fs.mkdir(apiRoot, { recursive: true })
+
+  const templateUpdates = []
+  const kernel = {
+    version: 'test',
+    platform: 'linux',
+    arch: 'x64',
+    homedir: root,
+    shell: { shells: [] },
+    vars: {},
+    memory: {
+      local: {},
+      global: {},
+      key: {},
+      rpc: {},
+      input: {},
+      args: {}
+    },
+    procs: {},
+    api: {
+      running: {},
+      proxies: {},
+      userdir: apiRoot,
+      meta: async () => null
+    },
+    bin: { installed: {} },
+    template: {
+      update: (info) => templateUpdates.push(info)
+    },
+    sys: {
+      info: {
+        gpu: 'amd',
+        gpu_model: 'amd radeon rx 6800 xt',
+        gpu_driver: '31.0.1',
+        gpu_target: 'gfx1030',
+        gpus: [],
+        vram: 16,
+        ram: 64
+      }
+    },
+    path: (...parts) => path.join(root, ...parts),
+    dns: async () => {}
+  }
+
+  try {
+    await Kernel.prototype.update_sysinfo.call(kernel)
+    await Kernel.prototype.getInfo.call(kernel, false)
+
+    assert.equal(kernel.gpu, 'amd')
+    assert.equal(kernel.gpu_model, 'amd radeon rx 6800 xt')
+    assert.equal(kernel.gpu_target, 'gfx1030')
+    assert.equal(templateUpdates.length, 1)
+    assert.equal(templateUpdates[0].gpu_target, 'gfx1030')
+    assert.equal(kernel.i.gpu_target, 'gfx1030')
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})

package/test/logs-ask-ai.test.js

@@ -37,14 +37,24 @@ function createReportFixture() {
 
 function createPluginMenuFixture() {
   return {
-    menu: [{
-      title: "OpenAI Codex Auto",
-      href: "/pinokio/run/plugin/codex-auto/pinokio.js",
-      image: "/pinokio/asset/plugin/codex-auto/openai.webp",
-      category: "cli",
-      categoryTitle: "Terminal Plugin",
-      pluginPath: "/pinokio/run/plugin/codex-auto/pinokio.js"
-    }]
+    menu: [
+      {
+        title: "Claude Desktop",
+        href: "/pinokio/run/plugin/claude-desktop/pinokio.js",
+        image: "/pinokio/asset/plugin/claude-desktop/icon.png",
+        category: "ide",
+        categoryTitle: "Desktop Plugin",
+        pluginPath: "/pinokio/run/plugin/claude-desktop/pinokio.js"
+      },
+      {
+        title: "OpenAI Codex Auto",
+        href: "/pinokio/run/plugin/codex-auto/pinokio.js",
+        image: "/pinokio/asset/plugin/codex-auto/openai.webp",
+        category: "cli",
+        categoryTitle: "Terminal Plugin",
+        pluginPath: "/pinokio/run/plugin/codex-auto/pinokio.js"
+      }
+    ]
   }
 }
 
@@ -165,14 +175,59 @@ test("log Ask AI modal enables Run after assigning the default prompt", async ()
 
   await waitFor(() => document.querySelector(".logs-ask-ai-launcher:not([hidden])"), "Ask AI modal")
   const textarea = document.querySelector(".logs-ask-ai-launcher-textarea")
-  const select = document.querySelector(".logs-ask-ai-tool-select")
+  const trigger = document.querySelector(".logs-ask-ai-tool-trigger")
+  const selectedOption = document.querySelector(".logs-ask-ai-tool-sheet-body .universal-launcher-tool.selected")
   const runButton = document.querySelector(".logs-ask-ai-launcher .universal-launcher-button-primary")
 
   assert.match(textarea.value, /Investigate what went wrong/)
-  assert.equal(select.selectedOptions[0].textContent, "OpenAI Codex Auto (Terminal)")
+  assert.equal(document.querySelector(".logs-ask-ai-tool-select"), null)
+  assert.equal(trigger.querySelector(".universal-launcher-tool-trigger-label").textContent, "OpenAI Codex Auto")
+  assert.equal(trigger.querySelector(".universal-launcher-tool-trigger-meta").textContent, "Terminal")
+  assert.equal(selectedOption.querySelector(".universal-launcher-tool-label").textContent, "OpenAI Codex Auto")
   assert.equal(runButton.disabled, false)
 })
 
+test("log Ask AI modal uses custom plugin sheet and closes it before the modal", async () => {
+  const { dom } = await createLogsDom()
+  const { window } = dom
+  const { document } = window
+
+  document.getElementById("logs-ask-ai").click()
+  await waitFor(() => document.querySelector(".logs-ask-ai-launcher:not([hidden])"), "Ask AI modal")
+
+  const trigger = document.querySelector(".logs-ask-ai-tool-trigger")
+  const sheet = document.querySelector(".logs-ask-ai-tool-sheet-layer")
+  assert.equal(sheet.hidden, true)
+  assert.equal(document.querySelector(".logs-ask-ai-launcher .universal-launcher-button-primary").disabled, true)
+
+  trigger.click()
+  assert.equal(sheet.hidden, false)
+  assert.equal(trigger.getAttribute("aria-expanded"), "true")
+  assert.deepEqual(
+    Array.from(document.querySelectorAll(".logs-ask-ai-tool-sheet-body .universal-launcher-tool-group-title")).map((node) => node.textContent),
+    ["Terminal", "Desktop"]
+  )
+
+  const claudeOption = Array.from(document.querySelectorAll(".logs-ask-ai-tool-sheet-body .universal-launcher-tool"))
+    .find((option) => option.querySelector(".universal-launcher-tool-label").textContent === "Claude Desktop")
+  assert.ok(claudeOption)
+  claudeOption.click()
+
+  assert.equal(sheet.hidden, true)
+  assert.equal(trigger.querySelector(".universal-launcher-tool-trigger-label").textContent, "Claude Desktop")
+  assert.equal(window.localStorage.getItem("pinokio.universalLauncher.tool"), "pinokio/run/plugin/claude-desktop")
+  assert.equal(document.querySelector(".logs-ask-ai-launcher .universal-launcher-button-primary").disabled, false)
+
+  trigger.click()
+  assert.equal(sheet.hidden, false)
+  document.querySelector(".logs-ask-ai-launcher").dispatchEvent(new window.KeyboardEvent("keydown", {
+    key: "Escape",
+    bubbles: true
+  }))
+  assert.equal(sheet.hidden, true)
+  assert.equal(document.querySelector(".logs-ask-ai-launcher").hidden, false)
+})
+
 test("log Ask AI launch calls a same-origin parent drawer before postMessage fallback", async () => {
   const opened = []
   const posted = []

package/test/nvidia-gpu-target.test.js

@@ -0,0 +1,98 @@
+const assert = require('node:assert/strict')
+const childProcess = require('node:child_process')
+const test = require('node:test')
+
+const nvidia = require('../kernel/gpu/nvidia')
+
+test('NVIDIA compute capability parser emits CUDA SM targets', () => {
+  assert.deepEqual(
+    nvidia.parse_nvidia_smi_compute_caps([
+      '00000000:01:00.0, 8.6',
+      '00000000:02:00.0, 8.9',
+      '00000000:03:00.0, 12.0',
+      '00000000:04:00.0, N/A'
+    ].join('\n')),
+    [
+      { pci_bus: '01:00.0', target: 'sm_86' },
+      { pci_bus: '02:00.0', target: 'sm_89' },
+      { pci_bus: '03:00.0', target: 'sm_120' }
+    ]
+  )
+})
+
+test('NVIDIA target selection matches the selected controller by PCI bus', () => {
+  const records = [
+    { pci_bus: '01:00.0', target: 'sm_86' },
+    { pci_bus: '02:00.0', target: 'sm_89' }
+  ]
+
+  assert.equal(nvidia.select_cuda_sm_target({ pciBus: '00000000:02:00.0' }, records), 'sm_89')
+  assert.equal(nvidia.select_cuda_sm_target({ busAddress: '01:00.0' }, records), 'sm_86')
+  assert.equal(nvidia.select_cuda_sm_target({ pciBus: '03:00.0' }, records), null)
+})
+
+test('NVIDIA target selection uses the only record when the controller has no PCI bus', () => {
+  assert.equal(
+    nvidia.select_cuda_sm_target({}, [{ pci_bus: '01:00.0', target: 'sm_86' }]),
+    'sm_86'
+  )
+  assert.equal(
+    nvidia.select_cuda_sm_target({}, [
+      { pci_bus: '01:00.0', target: 'sm_86' },
+      { pci_bus: '02:00.0', target: 'sm_89' }
+    ]),
+    null
+  )
+})
+
+test('NVIDIA nvidia-smi query failure resolves to no targets', async () => {
+  const records = await nvidia.query_cuda_sm_targets((_cmd, _args, _options, done) => {
+    done(new Error('missing nvidia-smi'))
+  })
+
+  assert.deepEqual(records, [])
+})
+
+test('NVIDIA nvidia-smi query uses compute capability command and parses stdout', async () => {
+  const calls = []
+  const records = await nvidia.query_cuda_sm_targets((cmd, args, options, done) => {
+    calls.push({ cmd, args, options })
+    done(null, [
+      '00000000:01:00.0, 8.6',
+      '00000000:02:00.0, 8.9'
+    ].join('\n'))
+  })
+
+  assert.deepEqual(calls, [{
+    cmd: 'nvidia-smi',
+    args: [
+      '--query-gpu=pci.bus_id,compute_cap',
+      '--format=csv,noheader,nounits'
+    ],
+    options: { windowsHide: true, timeout: 5000 }
+  }])
+  assert.deepEqual(records, [
+    { pci_bus: '01:00.0', target: 'sm_86' },
+    { pci_bus: '02:00.0', target: 'sm_89' }
+  ])
+})
+
+test('NVIDIA gpu_target caches the nvidia-smi compute capability query', async (t) => {
+  const modulePath = require.resolve('../kernel/gpu/nvidia')
+  delete require.cache[modulePath]
+
+  let calls = 0
+  t.mock.method(childProcess, 'execFile', (_cmd, _args, _options, done) => {
+    calls += 1
+    done(null, '00000000:01:00.0, 8.6\n')
+  })
+  t.after(() => {
+    delete require.cache[modulePath]
+  })
+
+  const freshNvidia = require('../kernel/gpu/nvidia')
+
+  assert.equal(await freshNvidia.resolve_cuda_sm_target({ pciBus: '00000000:01:00.0' }), 'sm_86')
+  assert.equal(await freshNvidia.resolve_cuda_sm_target({ pciBus: '00000000:01:00.0' }), 'sm_86')
+  assert.equal(calls, 1)
+})

package/test/sysinfo-gpu-driver.test.js

@@ -2,6 +2,7 @@ const assert = require('node:assert/strict')
 const test = require('node:test')
 
 const system = require('systeminformation')
+const nvidia = require('../kernel/gpu/nvidia')
 const Sysinfo = require('../kernel/sysinfo')
 
 test('GPU sysinfo exposes per-controller drivers and primary NVIDIA driver', async (t) => {
@@ -17,11 +18,16 @@ test('GPU sysinfo exposes per-controller drivers and primary NVIDIA driver', asy
         vendor: 'NVIDIA',
         model: 'NVIDIA RTX A4500',
         vram: 20480,
-        driverVersion: '565.90'
+        driverVersion: '565.90',
+        pciBus: '00000000:02:00.0'
       }
     ],
     displays: []
   }))
+  t.mock.method(nvidia, 'resolve_cuda_sm_target', async (controller) => {
+    assert.equal(controller.pciBus, '00000000:02:00.0')
+    return 'sm_86'
+  })
 
   const sys = new Sysinfo()
   sys.info = {}
@@ -31,6 +37,8 @@ test('GPU sysinfo exposes per-controller drivers and primary NVIDIA driver', asy
   assert.equal(sys.info.gpu, 'nvidia')
   assert.equal(sys.info.gpu_model, 'nvidia rtx a4500')
   assert.equal(sys.info.gpu_driver, '565.90')
+  assert.equal(sys.info.gpu_target, 'sm_86')
+  assert.equal(sys.info.vram, 20)
   assert.deepEqual(sys.info.gpus, [
     {
       name: 'intel',
@@ -72,6 +80,8 @@ test('GPU sysinfo uses selected highest-VRAM AMD controller for gpu_driver', asy
   assert.equal(sys.info.gpu, 'amd')
   assert.equal(sys.info.gpu_model, 'amd radeon rx 7900 xtx')
   assert.equal(sys.info.gpu_driver, '31.0.2')
+  assert.equal(sys.info.gpu_target, 'gfx1100')
+  assert.equal(sys.info.vram, 24)
   assert.deepEqual(sys.info.gpus, [
     {
       name: 'advanced micro devices',
@@ -85,3 +95,126 @@ test('GPU sysinfo uses selected highest-VRAM AMD controller for gpu_driver', asy
     }
   ])
 })
+
+test('GPU sysinfo leaves gpu_target null for Intel targets', async (t) => {
+  t.mock.method(system, 'graphics', async () => ({
+    controllers: [
+      {
+        vendor: 'Intel',
+        model: 'Intel Arc A770',
+        vram: 16384,
+        driverVersion: '31.0.101.5590'
+      }
+    ],
+    displays: []
+  }))
+
+  const sys = new Sysinfo()
+  sys.info = {}
+
+  await sys.gpus()
+
+  assert.equal(sys.info.gpu, 'intel')
+  assert.equal(sys.info.gpu_model, 'intel arc a770')
+  assert.equal(sys.info.gpu_driver, '31.0.101.5590')
+  assert.equal(sys.info.gpu_target, null)
+})
+
+test('GPU sysinfo resolves gpu_target for the selected NVIDIA controller when AMD is also present', async (t) => {
+  t.mock.method(system, 'graphics', async () => ({
+    controllers: [
+      {
+        vendor: 'AMD',
+        model: 'AMD Radeon RX 7900 XTX',
+        vram: 24576,
+        driverVersion: '31.0.2'
+      },
+      {
+        vendor: 'NVIDIA',
+        model: 'NVIDIA GeForce RTX 4090',
+        vram: 24576,
+        driverVersion: '565.90',
+        pciBus: '00000000:02:00.0'
+      }
+    ],
+    displays: []
+  }))
+  t.mock.method(nvidia, 'resolve_cuda_sm_target', async (controller) => {
+    assert.equal(controller.model, 'NVIDIA GeForce RTX 4090')
+    return 'sm_89'
+  })
+
+  const sys = new Sysinfo()
+  sys.info = {}
+
+  await sys.gpus()
+
+  assert.equal(sys.info.gpu, 'nvidia')
+  assert.equal(sys.info.gpu_model, 'nvidia geforce rtx 4090')
+  assert.equal(sys.info.gpu_target, 'sm_89')
+})
+
+test('GPU sysinfo leaves gpu_target null for Apple targets', async (t) => {
+  t.mock.method(system, 'graphics', async () => ({
+    controllers: [
+      {
+        vendor: 'Apple',
+        model: 'Apple M3',
+        vram: 0,
+        driverVersion: null
+      }
+    ],
+    displays: []
+  }))
+
+  const sys = new Sysinfo()
+  sys.info = {}
+
+  await sys.gpus()
+
+  assert.equal(sys.info.gpu, 'apple')
+  assert.equal(sys.info.gpu_model, 'apple m3')
+  assert.equal(sys.info.gpu_target, null)
+})
+
+test('GPU sysinfo leaves gpu_target null for unknown GPU vendors', async (t) => {
+  t.mock.method(system, 'graphics', async () => ({
+    controllers: [
+      {
+        vendor: 'Qualcomm',
+        model: 'Adreno X1',
+        vram: 16384,
+        driverVersion: '1.2.3'
+      }
+    ],
+    displays: []
+  }))
+
+  const sys = new Sysinfo()
+  sys.info = {}
+
+  await sys.gpus()
+
+  assert.equal(sys.info.gpu, 'qualcomm')
+  assert.equal(sys.info.gpu_model, 'adreno x1')
+  assert.equal(sys.info.gpu_driver, '1.2.3')
+  assert.equal(sys.info.gpu_target, null)
+})
+
+test('GPU sysinfo leaves gpu_target null when no GPU controller is detected', async (t) => {
+  t.mock.method(system, 'graphics', async () => ({
+    controllers: [],
+    displays: []
+  }))
+
+  const sys = new Sysinfo()
+  sys.info = {}
+
+  await sys.gpus()
+
+  assert.equal(sys.info.gpu, 'none')
+  assert.equal(sys.info.gpu_model, undefined)
+  assert.equal(sys.info.gpu_target, null)
+  assert.deepEqual(sys.info.gpus, [])
+  assert.equal(sys.info.vram, 0)
+})

package/kernel/gpu/apple.js

@@ -1,8 +0,0 @@
-// Apple GPU routes to the built-in PyTorch MPS backend on macOS.
-const supports_torch_backend = (controller, platform) => {
-  return !!controller && platform === "darwin"
-}
-
-module.exports = {
-  supports_torch_backend
-}

package/kernel/gpu/intel.js

@@ -1,47 +0,0 @@
-const { normalize_model } = require("./common")
-
-// Resolve CPU brand lazily so clear GPU model matches do not trigger CPU probing.
-const resolve_cpu_brand = async (cpu_brand) => {
-  if (typeof cpu_brand === "function") {
-    return await cpu_brand()
-  } else {
-    return cpu_brand
-  }
-}
-
-// Match Intel GPU model names that Pinokio should route to PyTorch XPU wheels.
-const matches_xpu_torch_model = (model) => {
-  let normalized = normalize_model(model)
-  return (
-    // Intel Arc A-Series / B-Series, Arc Pro, and Core Ultra iGPUs when the
-    // GPU model itself includes Arc.
-    /\barc\b/.test(normalized) ||
-    // Intel Data Center GPU Max Series. Do not match generic Data Center GPU
-    // names because Data Center GPU Flex is not in current PyTorch XPU docs.
-    /\b(data center gpu max|gpu max|ponte vecchio)\b/.test(normalized)
-  )
-}
-
-// Detect uninformative Intel iGPU names that need CPU-brand fallback matching.
-const is_generic_gpu_model = (model) => {
-  let normalized = normalize_model(model)
-  return /^(intel )?graphics$/.test(normalized)
-}
-
-// Decide Intel XPU install intent, using CPU brand only for generic iGPU names.
-const supports_torch_backend = async (model, cpu_brand) => {
-  if (matches_xpu_torch_model(model)) {
-    return true
-  }
-  if (!is_generic_gpu_model(model)) {
-    return false
-  }
-  let brand = normalize_model(await resolve_cpu_brand(cpu_brand))
-  return /\bcore\s*ultra\b/.test(brand)
-}
-
-module.exports = {
-  is_generic_gpu_model,
-  matches_xpu_torch_model,
-  supports_torch_backend
-}

package/release_notes/8.0.0/ui.md

@@ -1,91 +0,0 @@
-# Pinokio 8.0.0 UI Updates
-
-This release brings Pinokio's main surfaces into a quieter, more consistent workspace: app discovery, app launch controls, logs, tools, plugins, skills, autolaunch, setup, and mobile navigation now share the same visual language and action patterns.
-
-The notes below are grouped by what users will notice, not by commit history. Screenshots were captured from the live local UI after comparing `de83785` to the current `HEAD`.
-
-## Cleaner App Discovery
-
-Pinokio's home screen now behaves more like a compact app manager. The sidebar is unified with the rest of the product, the app list is easier to scan, search and sort stay prominent, and each app row exposes quick actions without forcing users into the full app page first.
-
-![Home app list with unified sidebar](assets/home-sidebar-apps.png)
-
-The new action panel gives installed apps a focused command surface for common launch, install, update, reset, file, and dev actions. Related commands are grouped in one drawer, which reduces row clutter while keeping the next action close to the app.
-
-![Home app action panel](assets/home-app-actions.png)
-
-## App Workspace And Assistance
-
-App pages have been rebuilt around a more durable workspace shell. The page chrome, left command rail, right utility panels, app title area, status indicators, resource labels, and launch actions have been tightened so app-specific work feels connected to the rest of Pinokio.
-
-![App workspace chrome](assets/app-detail-header-actions.png)
-
-Ask AI now opens as an in-app assistance drawer with searchable terminal and desktop agents. Instead of a generic help entry point, users can choose from bundled agents such as Codex, Claude Code, Qwen Code, Antigravity, Cursor, VS Code, and desktop integrations directly inside the app context.
-
-![Ask AI agent drawer](assets/app-ask-ai-drawer.png)
-
-## Plugins, Agents, And Skills
-
-The Plugins page now separates terminal plugins from desktop plugins and shows install/manage affordances in a single list. This makes the new bundled native tools easier to understand: terminal agents launch inside Pinokio, while desktop tools launch externally.
-
-![Plugins and bundled agents](assets/plugins-agent-tools.png)
-
-Pinokio also has a new Skills management surface. Users can see where managed skills are stored, where they sync, whether each skill is valid, and whether it is currently enabled. The page also supports downloading skills from a Git URL.
-
-![Skills management](assets/skills-management.png)
-
-## Startup And Launch Requirements
-
-Autolaunch is now a first-class configuration page. Users can search installed apps, choose which launch script should run at startup, see how many apps are enabled, and toggle startup behavior without digging through app internals.
-
-![Autolaunch and launch script selection](assets/autolaunch-dependencies.png)
-
-Setup and requirements screens now present blocked routes as a clear checklist. When a destination such as Local network needs a package update, Pinokio shows what is installed, what needs attention, and the action required before continuing.
-
-![Network setup requirements](assets/network-phone-access.png)
-
-## Logs, Diagnostics, And Issue Reporting
-
-Logs have been redesigned around a file tree and live reader. Users can inspect logs from the machine, stream a selected file, clear the view, keep auto-scroll on, and generate a diagnostic zip from the same screen.
-
-![Logs file tree and live reader](assets/logs-terminal-reporting.png)
-
-Behind that surface, the issue-reporting flow is more capable: recent logs can be summarized, redacted, copied, handed to Ask AI, or prepared as a registry draft. Those states require an app failure or report context, so they are not shown in this static screenshot set.
-
-## Tools And Runtime Readiness
-
-The Tools page now groups package bundles with readiness counts, per-bundle install state, and package-level status. Users can see which runtime bundles are ready, which need installation, and which package manager modules are present without reading terminal output first.
-
-![Tools and package bundle readiness](assets/tools-runtime-management.png)
-
-## Login And Connected Services
-
-The Hugging Face login flow has been redesigned as a clear device-authorization page. It states the connection state, the credential provider, the reason to log in, and the next action without mixing auth details into unrelated setup UI.
-
-![Hugging Face login](assets/connect-huggingface-login.png)
-
-GitHub and git-related modals also received layout cleanup: modal tabs, footers, repository status controls, checkpoint rows, and history/diff areas were tightened so longer repository workflows fit better in the available space.
-
-## Mobile And Remote Access
-
-Mobile layouts now prioritize the app list and move primary navigation to a bottom bar. Search, sort, app cards, favorites, and action buttons remain reachable on a phone-width viewport without the desktop sidebar competing for space.
-
-![Mobile home and footer navigation](assets/mobile-home-footer-nav.png)
-
-Phone and LAN access also received targeted polish. QR and network access entry points are gated behind setup readiness, install terminals attach correctly over LAN, and the old mobile "Tap to connect" curtain has been replaced with a quieter first-interaction audio primer.
-
-## Smaller Visual Polish
-
-Several changes are intentionally broad but subtle:
-
-- Shared sidebar styling now covers home, app, tools, plugins, skills, logs, settings, setup, network, and auth pages.
-- App navigation is more responsive, especially where action labels previously wrapped or crowded the header.
-- Screenshot/capture modals, footer status indicators, popovers, tabs, and terminal controls use flatter, tighter styling.
-- Checkpoints rows, git history dialogs, network troubleshoot panels, and auth pages were normalized to match the newer page shell.
-- Hidden or unused toolbar buttons were removed from the visible chrome so users see fewer inactive controls.
-
-## Screenshot Coverage Notes
-
-Captured screenshots cover the major visible themes: home discovery, app actions, app workspace chrome, Ask AI, plugins, skills, autolaunch, setup requirements, logs, tools, connected-service login, and mobile navigation.
-
-Some UI states were not practical to screenshot without changing runtime state or forcing failures: failed-terminal fallback, report-draft creation, live dependency orchestration while an app is launching, completed peer-network routing, and git/checkpoint modal edge cases. Those changes are still included above because they are user-visible when the relevant workflow is active.