@huaqiu/dsh-tool-plugin-update 0.6.16 → 0.6.18

package/lib/index.mjs

@@ -35,6 +35,12 @@ function parsePath(req) {
 	if (!pathname.startsWith("/api/v1/huaqiu/plugin-update")) return null;
 	return pathname.slice(28);
 }
+/** The raw `?…` of the incoming request ('' when there is none). */
+function parseQuery(req) {
+	const url = req.url ?? "";
+	const q = url.indexOf("?");
+	return q >= 0 ? url.slice(q) : "";
+}
 /** Read the request body (bounded) as UTF-8 text. */
 function readBody(req) {
 	return new Promise((resolve, reject) => {
@@ -108,6 +114,11 @@ function routeFor(sub, method) {
 		method: "GET",
 		path: "/api/v1/plugin-updates/status"
 	} : null;
+	if (sub === "/activity") return method === "GET" ? {
+		method: "GET",
+		path: "/api/v1/plugin-updates/activity",
+		passQuery: true
+	} : null;
 	const jobId = matchJobStatusPath(sub);
 	if (jobId !== null) return method === "GET" ? {
 		method: "GET",
@@ -163,7 +174,8 @@ const STATIC_SUB_PATHS = /* @__PURE__ */ new Set([
 	"/runtime-request",
 	"/runtime-source",
 	"/plugin-source",
-	"/status"
+	"/status",
+	"/activity"
 ]);
 /**
 * Whether a sub-path names a route this forwarder recognizes at all. A
@@ -206,8 +218,9 @@ function createUpdateForwarder(baseUrlResolver, timeoutMs = DEFAULT_FORWARD_TIME
 		const budget = target.timeoutMs ?? timeoutMs;
 		const controller = new AbortController();
 		const timer = setTimeout(() => controller.abort(), budget);
+		const upstreamUrl = `${base}${target.path}${target.passQuery === true ? parseQuery(req) : ""}`;
 		try {
-			const upstream = await fetch(`${base}${target.path}`, {
+			const upstream = await fetch(upstreamUrl, {
 				method: target.method,
 				headers: {
 					"content-type": "application/json; charset=utf-8",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@huaqiu/dsh-tool-plugin-update",
-  "version": "0.6.16",
+  "version": "0.6.18",
   "type": "module",
   "main": "./lib/index.mjs",
   "types": "./lib/index.d.mts",
@@ -31,8 +31,8 @@
     "@deepseek-ai/dsh-host-webserver": "^0.2.1-rc.2"
   },
   "dependencies": {
-    "@huaqiu/dsh-plugin-log": "0.6.16",
-    "@huaqiu/dsh-sidebar-entry": "0.6.16"
+    "@huaqiu/dsh-sidebar-entry": "0.6.18",
+    "@huaqiu/dsh-plugin-log": "0.6.18"
   },
   "files": [
     "lib",

package/src/client/api.ts

@@ -286,6 +286,28 @@ export interface UpdateJobStatus {
   recentJobs: UpdateJob[]
 }
 
+/**
+ * `GET /activity`: the re-attach snapshot.
+ *
+ * The panel can be updating its own package, which restarts the DSH process
+ * that serves this plugin — the page then has to rebuild its state from
+ * scratch. `bootId` changes when that process is recreated, `stalled` says the
+ * active job has stopped advancing (so the UI must stop animating a progress
+ * bar that will never move), and `setVersion` is what is actually installed.
+ */
+export interface UpdateActivity {
+  bootId: string
+  startedAt: string
+  now: string
+  activeJob: UpdateJob | null
+  /** The job named by `?job=`, settled or not; null when not asked/unknown. */
+  job: UpdateJob | null
+  phaseAgeMs: number
+  stalled: boolean
+  setVersion: string | null
+  actionableCount: number
+}
+
 const PHASE_VALUES: ReadonlySet<string> = new Set<string>([
   'queued',
   'resolving',
@@ -566,3 +588,37 @@ export function fetchJob(id: string): Promise<UpdateJob> {
     return job
   })
 }
+
+/**
+ * Normalize `GET /activity`. Unknown/missing fields degrade to a usable
+ * snapshot: a `bootId` empty string simply never triggers a re-attach, and an
+ * unparseable age reads as 0 rather than "stalled".
+ */
+export function normalizeActivity(raw: unknown): UpdateActivity {
+  const r = (raw !== null && typeof raw === 'object' ? raw : {}) as Record<string, unknown>
+  const str = (v: unknown): string => (typeof v === 'string' ? v : '')
+  const num = (v: unknown): number => (typeof v === 'number' && Number.isFinite(v) ? v : 0)
+  return {
+    bootId: str(r.bootId),
+    startedAt: str(r.startedAt),
+    now: str(r.now),
+    activeJob: normalizeJob(r.activeJob),
+    job: normalizeJob(r.job),
+    phaseAgeMs: Math.max(0, num(r.phaseAgeMs)),
+    stalled: r.stalled === true,
+    setVersion: typeof r.setVersion === 'string' && r.setVersion.length > 0 ? r.setVersion : null,
+    actionableCount: num(r.actionableCount),
+  }
+}
+
+/**
+ * GET the re-attach snapshot, optionally naming the job being watched.
+ *
+ * Used instead of `/status` whenever the panel is following a job it started:
+ * it answers "what happened to MY job" across a DSH restart, and each read lets
+ * hq-edge settle a job that its own process could not finish.
+ */
+export function fetchActivity(jobId?: string): Promise<UpdateActivity> {
+  const query = jobId ? `?job=${encodeURIComponent(jobId)}` : ''
+  return request<unknown>(`/activity${query}`).then(normalizeActivity)
+}

package/src/client/copy.ts

@@ -185,6 +185,7 @@ const zh = {
     ctaNoSet: '暂无可安装的更新',
     footerCount: (n: number) => `准备安装 ${n} 项兼容插件`,
     footerBusy: '后台处理中，请勿关闭 DSH',
+    footerConfirming: '正在确认安装结果…',
     footerFailed: '无法确认插件版本兼容性',
     footerAllGood: '所有插件与运行时均正常',
     footerRuntimeOnly: '运行时更新需在上方单独确认',
@@ -218,6 +219,8 @@ const zh = {
     jobRuntimeTitle: (v: string) => `正在升级 HQ Edge 运行时 (v${v})`,
     jobSteps: ['下载', '校验', '替换', '重启'],
     activeCloseNote: '关闭此面板不会取消更新，完成后将自动重启。',
+    stalledNote: '进度已停止回执，正在向 HQ Edge 确认安装结果…',
+    stalledAction: '立即确认',
     // Runtime result alert
     rollbackTitle: '上次 HQ Edge 运行时更新已自动回滚',
     failedTitle: '上次 HQ Edge 运行时更新失败',
@@ -401,6 +404,7 @@ const en: UpdateCopy = {
     ctaNoSet: 'Nothing to install yet',
     footerCount: (n: number) => `Ready to install ${n} compatible plugin${n === 1 ? '' : 's'}`,
     footerBusy: 'Running in the background — keep DSH open',
+    footerConfirming: 'Confirming the install result…',
     footerFailed: 'Cannot confirm plugin compatibility',
     footerAllGood: 'All plugins and the runtime are current',
     footerRuntimeOnly: 'Confirm the runtime upgrade on its card',
@@ -431,6 +435,8 @@ const en: UpdateCopy = {
     jobRuntimeTitle: (v: string) => `Upgrading HQ Edge runtime (v${v})`,
     jobSteps: ['Download', 'Verify', 'Swap', 'Restart'],
     activeCloseNote: 'Closing this panel does not cancel the update; DSH restarts when it finishes.',
+    stalledNote: 'Progress has stopped reporting — confirming the result with HQ Edge…',
+    stalledAction: 'Check now',
     rollbackTitle: 'Last HQ Edge runtime update rolled back automatically',
     failedTitle: 'Last HQ Edge runtime update failed',
     rollbackBody: (oldVer: string, code: string) =>

package/src/client/index.ts

@@ -30,10 +30,12 @@ import {
 } from '@huaqiu/dsh-sidebar-entry'
 import {
   checkUpdates,
+  fetchActivity,
   fetchJobStatus,
   fetchReport,
   TERMINAL_PHASES,
   type PluginUpdateReport,
+  type UpdateActivity,
   type UpdateJob,
   type UpdateJobStatus,
 } from './api.js'
@@ -1227,6 +1229,45 @@ const VIEW_CSS_TEXT = `
   line-height: 14px;
   color: var(--hq-faint);
 }
+/* A stalled job: the card keeps its shape but stops claiming progress. The
+ * pulse stops, the bar dims, and the note line carries the retry. */
+.hqpu-active[data-stalled='1'] .hqpu-pulse-ring {
+  animation: none;
+  opacity: 0;
+}
+.hqpu-active[data-stalled='1'] .hqpu-pulse-dot::before {
+  background: var(--hq-amber);
+}
+.hqpu-active[data-stalled='1'] .hqpu-active-percent {
+  color: var(--hq-amber-ink);
+}
+.hqpu-active[data-stalled='1'] .hqpu-progress-fill {
+  background: color-mix(in srgb, var(--hq-amber) 55%, var(--hq-border));
+  transition: none;
+}
+/* The active step stops blinking too: nothing is advancing. */
+.hqpu-active[data-stalled='1'] .hqpu-job-step--active {
+  color: var(--hq-amber-ink);
+  animation: none;
+}
+.hqpu-active-stalled {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 8px;
+  padding: 6px 8px;
+  border-radius: 6px;
+  background: color-mix(in srgb, var(--hq-amber) 10%, transparent);
+  font-size: var(--hq-fs-micro);
+  line-height: 14px;
+  color: var(--hq-amber-ink);
+}
+.hqpu-active-stalled .hqpu-link {
+  flex: none;
+  font-size: var(--hq-fs-micro);
+  color: var(--hq-amber-ink);
+  text-decoration: underline;
+}
 .hqpu-job-steps4 {
   display: grid;
   grid-template-columns: repeat(4, 1fr);
@@ -1849,8 +1890,14 @@ export interface ClientContext {
   effect?(fn: () => (() => void) | void, label?: string): void
 }
 
-/** In-memory update-report store shared by the badge and the modal. */
-class UpdateStore implements UpdateStoreLike {
+/**
+ * In-memory update-report store shared by the badge and the modal.
+ *
+ * Exported for tests: the re-attach logic (watch a job by id, notice that the
+ * server was replaced, stop claiming progress) is the part that cannot be
+ * exercised through the view alone.
+ */
+export class UpdateStore implements UpdateStoreLike {
   private current: PluginUpdateReport | null = null
   private installingFlag = false
   /** The durable job the server currently reports as active (resumed across
@@ -1862,6 +1909,12 @@ class UpdateStore implements UpdateStoreLike {
   private pollTimer: number | null = null
   private pollBackoffMs = 1_000
   private pollInFlight = false
+  /** The job this panel started (or adopted) and is following by id. */
+  private watchedJobId: string | null = null
+  /** hq-edge process identity from the last `/activity` read. */
+  private activityBootId: string | null = null
+  private stalledFlag = false
+  private phaseAgeMsValue = 0
 
   report(): PluginUpdateReport | null {
     return this.current
@@ -1879,6 +1932,27 @@ class UpdateStore implements UpdateStoreLike {
     return [...this.recent]
   }
 
+  /** True when the server says the active job stopped advancing. */
+  stalled(): boolean {
+    return this.stalledFlag
+  }
+
+  /** Milliseconds since the active job last advanced (server clock). */
+  phaseAgeMs(): number {
+    return this.phaseAgeMsValue
+  }
+
+  /**
+   * Follow a job by id. The panel calls this with the `jobId` an accept
+   * response handed back, so every later read asks about THAT job — the only
+   * way to learn its outcome when the install replaced this very plugin (the
+   * page comes back to a server that has no "active job" left to report).
+   */
+  watchJob(id: string | null): void {
+    this.watchedJobId = id
+    if (id !== null) this.schedulePoll()
+  }
+
   subscribe(listener: () => void): () => void {
     this.listeners.add(listener)
     return () => {
@@ -1912,37 +1986,98 @@ class UpdateStore implements UpdateStoreLike {
     const wasActive = this.active !== null
     this.active = status.activeJob
     this.recent = status.recentJobs
-    if (wasActive && this.active === null) {
-      // The active job settled (moved to recent/terminal) — the installing
-      // footer state must clear on its own, without the panel's closure.
+    if (this.active !== null) this.watchedJobId = this.active.id
+    if (wasActive && this.active === null) this.observeSettled()
+    this.emit()
+    this.schedulePoll()
+  }
+
+  /**
+   * Adopt a `/activity` snapshot.
+   *
+   * Two things only this read can tell us:
+   *
+   *   - `bootId` changed → hq-edge was recreated underneath the page. That is
+   *     what an install of this plugin's own package looks like from here: the
+   *     DSH process serving this route was replaced. Nothing in memory can be
+   *     trusted, so the installing flag is cleared and the report re-read.
+   *   - `stalled` → the active job has stopped advancing. The progress bar must
+   *     stop pretending; the panel shows a "confirming" note with a retry.
+   */
+  private applyActivity(activity: UpdateActivity): void {
+    const rebooted = this.activityBootId !== null && this.activityBootId !== activity.bootId
+    this.activityBootId = activity.bootId
+    this.stalledFlag = activity.stalled
+    this.phaseAgeMsValue = activity.phaseAgeMs
+
+    const wasActive = this.active !== null
+    this.active = activity.activeJob
+    if (activity.job !== null) this.upsertRecent(activity.job)
+
+    if (rebooted) {
       this.installingFlag = false
-      // …and the report is now stale: it still names the versions this job
-      // just installed. hq-edge refreshes its own copy before it settles the
-      // job, so one cheap read of `/report` is enough to bring the list (and
-      // the badge) down to zero. Without it the badge kept counting updates
-      // that no longer exist until the 60 s idle poll came round.
+      this.stalledFlag = false
+      this.phaseAgeMsValue = 0
       void this.refresh()
     }
+    if (wasActive && this.active === null) this.observeSettled()
     this.emit()
     this.schedulePoll()
   }
 
   /**
-   * Fetch the durable job status. Called on mount, on panel open (BEFORE
+   * The job we were following reached a terminal phase (or vanished from the
+   * active slot). Clear the transient flags and re-read the report — it still
+   * names the versions that job installed.
+   */
+  private observeSettled(): void {
+    this.installingFlag = false
+    this.stalledFlag = false
+    this.phaseAgeMsValue = 0
+    this.watchedJobId = null
+    void this.refresh()
+  }
+
+  /** Keep one job fresh in the local history without duplicating it. */
+  private upsertRecent(job: UpdateJob): void {
+    const rest = this.recent.filter((entry) => entry.id !== job.id)
+    this.recent = [job, ...rest].slice(0, 20)
+  }
+
+  /**
+   * Fetch the durable job state. Called on mount, on panel open (BEFORE
    * discovery) and by the poll loop. A failure (older hq-edge with no
    * `/status`, or a transient HTTP error) is swallowed: the last known job is
    * kept and the poller backs off and retries.
    */
   async fetchStatus(): Promise<void> {
     try {
-      const status = await fetchJobStatus()
+      await this.pollOnce()
       this.pollBackoffMs = 1_000
-      this.applyStatus(status)
     } catch {
       this.schedulePoll()
     }
   }
 
+  /**
+   * One read. While a job is being followed, ask `/activity` about THAT job
+   * (survives the restart an update of this plugin causes); otherwise fall back
+   * to the plain `/status` list. An older hq-edge without `/activity` 404s and
+   * the status read still answers.
+   */
+  private async pollOnce(): Promise<void> {
+    const watched = this.watchedJobId ?? this.active?.id ?? null
+    if (watched !== null) {
+      try {
+        this.applyActivity(await fetchActivity(watched))
+        return
+      } catch {
+        /* fall through to /status: an older hq-edge has no /activity */
+      }
+    }
+    this.applyStatus(await fetchJobStatus())
+  }
+
   /** ~1 s poll while a job is active; stop on terminal; back off on error
    *  without discarding the last known job; never overlap requests. */
   private schedulePoll(): void {
@@ -1967,9 +2102,8 @@ class UpdateStore implements UpdateStoreLike {
     }
     this.pollInFlight = true
     try {
-      const status = await fetchJobStatus()
+      await this.pollOnce()
       this.pollBackoffMs = 1_000
-      this.applyStatus(status)
     } catch {
       this.pollBackoffMs = Math.min(5_000, Math.max(1_000, this.pollBackoffMs * 2))
       this.schedulePoll()

package/src/client/update-view.ts

@@ -81,6 +81,16 @@ export interface UpdateStoreLike {
   check(): Promise<PluginUpdateReport | null>
   /** Re-read `/status` (resume an active job immediately after submitting). */
   fetchStatus(): Promise<void>
+  /**
+   * Follow a job by id after an accept response. Optional so a minimal store
+   * (tests, older hosts) still satisfies the contract; the real store uses it
+   * to keep asking about THIS job across a DSH restart.
+   */
+  watchJob?(id: string | null): void
+  /** Server-reported "the active job stopped advancing". */
+  stalled?(): boolean
+  /** Milliseconds since the active job last advanced (server clock). */
+  phaseAgeMs?(): number
   subscribe(listener: () => void): () => void
 }
 
@@ -438,11 +448,23 @@ function checkBanner(
  * The active job card: title (with the target version) + percent, a
  * determinate bar when the server publishes one, phase + telemetry, the honest
  * "closing does not cancel" note, and the 4-step pipeline.
+ *
+ * `stalled` marks a job the server has stopped advancing. That is the normal
+ * shape of "the set being installed contains this very plugin": activating it
+ * restarts DSH, so the process that owned the job is gone and the last thing
+ * the page saw was 100 % on the final step. Instead of animating a bar that
+ * will never move, the card says it is confirming the outcome and offers a
+ * retry — and the next `/activity` read settles it from the installed set.
  */
-function activeJobView(job: UpdateJob, copy: UpdateCopy): HTMLElement {
+function activeJobView(
+  job: UpdateJob,
+  copy: UpdateCopy,
+  opts: { stalled?: boolean; onRecheck?: () => void } = {},
+): HTMLElement {
   const section = el('section', 'hqpu-group')
   section.dataset.group = 'active-job'
   const card = el('div', 'hqpu-active')
+  if (opts.stalled === true) card.dataset.stalled = '1'
 
   const top = el('div', 'hqpu-active-top')
   const titleWrap = el('div', 'hqpu-active-title')
@@ -508,6 +530,15 @@ function activeJobView(job: UpdateJob, copy: UpdateCopy): HTMLElement {
     ),
   )
 
+  if (opts.stalled === true) {
+    const stalled = el('div', 'hqpu-active-stalled')
+    stalled.append(el('span', '', copy.ui.stalledNote))
+    const recheck = linkButton('hqpu-link', copy.ui.stalledAction, () => opts.onRecheck?.())
+    recheck.setAttribute('data-stalled-recheck', '')
+    stalled.append(recheck)
+    card.append(stalled)
+  }
+
   const current = stepIndex(job.phase)
   const stepsRow = el('div', 'hqpu-job-steps4')
   copy.ui.jobSteps.forEach((label: string, index: number) => {
@@ -1266,6 +1297,9 @@ export function openUpdateView(store: UpdateStoreLike, copy: UpdateCopy): void {
       // relaunch. Latch it, so a store refresh cannot re-offer the button for
       // a server that is already gone.
       runtimeAccepted = true
+      // The runtime swap restarts HQ Edge itself; follow the job it accepted so
+      // the panel can report the outcome after the runtime is back.
+      store.watchJob?.(result.jobId ?? null)
       showToast(copy.runtime.updateAccepted, 'success')
       void store.fetchStatus()
     } catch (err: unknown) {
@@ -1443,7 +1477,14 @@ export function openUpdateView(store: UpdateStoreLike, copy: UpdateCopy): void {
     jobSection.textContent = ''
     const active = store.activeJob()
     if (active !== null && !TERMINAL_PHASES.has(active.phase)) {
-      jobSection.append(activeJobView(active, copy))
+      jobSection.append(
+        activeJobView(active, copy, {
+          stalled: store.stalled?.() === true,
+          onRecheck: () => {
+            void store.fetchStatus()
+          },
+        }),
+      )
     }
   }
 
@@ -1634,7 +1675,11 @@ export function openUpdateView(store: UpdateStoreLike, copy: UpdateCopy): void {
     if (busy) {
       ctaLabel.textContent = copy.ui.ctaInstalling
       cta.disabled = true
-      footCount.textContent = copy.ui.footerBusy
+      // A stalled job is still "busy" — the install may have completed and only
+      // the report is missing — so the footer must not promise progress it
+      // cannot see. The card above carries the retry.
+      footCount.textContent =
+        store.stalled?.() === true ? copy.ui.footerConfirming : copy.ui.footerBusy
     } else if (report === null) {
       ctaLabel.textContent = copy.ui.ctaNoSet
       cta.disabled = true
@@ -1880,8 +1925,11 @@ async function runInstall(
       showToast(`${copy.installError}: ${result.error}`, 'error')
       return
     }
-    // 202 accepted: a durable job now owns the lifecycle. The store's /status
-    // poller renders progress and clears the flag when the job settles.
+    // 202 accepted: a durable job now owns the lifecycle. Follow it BY ID —
+    // that is what survives the restart when this very plugin is in the set
+    // being installed (the server then has no "active job" to hand back, only
+    // the record of the id we asked about).
+    store.watchJob?.(result.jobId ?? null)
     showToast(copy.installSuccess, 'success')
     void store.fetchStatus()
   } catch (err: unknown) {

package/src/routes.ts

@@ -36,12 +36,21 @@
  *   GET  /plugin-update/status   → GET  /api/v1/plugin-updates/status
  *   GET  /plugin-update/status/<id>
  *                                → GET  /api/v1/plugin-updates/status/<id>
+ *   GET  /plugin-update/activity?job=<id>
+ *                                → GET  /api/v1/plugin-updates/activity?job=<id>
  *
  * The status routes expose the durable update-job lifecycle (active job +
  * recent jobs). They are read-only passthroughs: an unknown job id upstream
  * answers `404 { error: 'unknown job' }`, which this forwarder passes through
  * verbatim rather than turning into a plugin-side 500.
  *
+ * `/activity` is the re-attach read: an install that includes this very plugin
+ * restarts DSH, so the browser loses this route for a moment and cannot trust
+ * its in-memory job. The answer carries the hq-edge process identity, the named
+ * job (settled or not), a stall flag and the installed set version, and each
+ * read also settles a job orphaned by that restart. Its `?job=` is the one
+ * query this forwarder passes upstream.
+ *
  * The runtime-update request is user-confirmed in this plugin's review panel:
  * hq-edge validates the version against a fresh manifest, downloads and
  * verifies the bundle, stages it, then hands it to the EDA host and answers
@@ -93,6 +102,13 @@ function parsePath(req: IncomingMessage): string | null {
   return pathname.slice(UPDATE_ROUTE_PREFIX.length)
 }
 
+/** The raw `?…` of the incoming request ('' when there is none). */
+function parseQuery(req: IncomingMessage): string {
+  const url = req.url ?? ''
+  const q = url.indexOf('?')
+  return q >= 0 ? url.slice(q) : ''
+}
+
 /** Read the request body (bounded) as UTF-8 text. */
 function readBody(req: IncomingMessage): Promise<string> {
   return new Promise((resolve, reject) => {
@@ -141,7 +157,7 @@ function matchJobStatusPath(sub: string): string | null {
 function routeFor(
   sub: string,
   method: string,
-): { method: string; path: string; timeoutMs?: number } | null {
+): { method: string; path: string; timeoutMs?: number; passQuery?: boolean } | null {
   if (sub === '/runtime-source') {
     if (method === 'GET') return { method: 'GET', path: '/api/v1/runtime-update/source' }
     if (method === 'POST') return { method: 'POST', path: '/api/v1/runtime-update/source' }
@@ -160,6 +176,15 @@ function routeFor(
       ? { method: 'GET', path: '/api/v1/plugin-updates/status' }
       : null
   }
+  // Re-attach snapshot: process identity + the named job + stall detection.
+  // It is the read the panel uses while updating its OWN package (that install
+  // restarts DSH, so the page loses this forwarder for a moment and must be
+  // able to rebuild its state afterwards).
+  if (sub === '/activity') {
+    return method === 'GET'
+      ? { method: 'GET', path: '/api/v1/plugin-updates/activity', passQuery: true }
+      : null
+  }
   const jobId = matchJobStatusPath(sub)
   if (jobId !== null) {
     return method === 'GET'
@@ -224,6 +249,7 @@ const STATIC_SUB_PATHS = new Set([
   '/runtime-source',
   '/plugin-source',
   '/status',
+  '/activity',
 ])
 
 /**
@@ -280,8 +306,12 @@ export function createUpdateForwarder(
     const budget = target.timeoutMs ?? timeoutMs
     const controller = new AbortController()
     const timer = setTimeout(() => controller.abort(), budget)
+    // Only `/activity` carries a query today (`?job=`). Every other route maps
+    // to a fixed upstream path, so forwarding the query blindly would leak
+    // unrelated client params into hq-edge.
+    const upstreamUrl = `${base}${target.path}${target.passQuery === true ? parseQuery(req) : ''}`
     try {
-      const upstream = await fetch(`${base}${target.path}`, {
+      const upstream = await fetch(upstreamUrl, {
         method: target.method,
         headers: {
           'content-type': 'application/json; charset=utf-8',