@shendeguize/dsh-agent-sidecar 0.1.0

package/src/client/analysis/AnalysisPanel.tsx

@@ -0,0 +1,191 @@
+/**
+ * AI bypass-analysis panel (T5.10b, design §4.e.3 / §5.1 view 2): fully
+ * controlled presentation over an {@link AnalysisGlueState} — the owner
+ * (detail view) holds the AnalysisStore and passes state + intents down.
+ *
+ * Honesty posture (§5.3): the engine disclaimer (fallback copy when a
+ * settle never happened) renders with every result, truncation is called
+ * out per exchange, terminal errors carry the vocabulary code, and the
+ * capability-off state explains where to enable analysis instead of
+ * hiding the entry. Strings ride the main locale table (`analysis.*`).
+ *
+ * @module
+ */
+
+import { useState } from 'react'
+import type { ReactElement } from 'react'
+import { t } from '../locales/index.ts'
+import type { AnalysisExchange, AnalysisGlueState } from '../analysis-glue.ts'
+import css from './analysis.module.css'
+
+export interface AnalysisPanelProps {
+  /** Live `analysis.enabled` bit (settings scope); false disables intents. */
+  enabled: boolean
+  state: AnalysisGlueState
+  onStart: () => void
+  onFollowup: (question: string) => void
+  onStop: () => void
+  onClose: () => void
+}
+
+/** Terminal failure code → locale key ('' falls back to the generic). */
+const ERROR_KEYS: Record<string, Parameters<typeof t>[0]> = {
+  analysis_disabled: 'analysis.errDisabled',
+  analysis_unavailable: 'analysis.errUnavailable',
+  target_not_found: 'analysis.errTargetNotFound',
+  too_many_active: 'analysis.errTooManyActive',
+  timeout: 'analysis.errTimeout',
+  create_failed: 'analysis.errCreateFailed',
+  cancelled: 'analysis.errCancelled',
+  network_error: 'analysis.errNetwork',
+  request_timeout: 'analysis.errNetwork',
+}
+
+function errorText(code: string): string {
+  const key = ERROR_KEYS[code]
+  return key !== undefined ? t(key) : t('analysis.errGeneric', { code })
+}
+
+/** Retryable notice code → copy. */
+function noticeText(code: string): string {
+  if (code === 'timeout') return t('analysis.noticeTimeout')
+  if (code === 'cancel_failed') return t('analysis.noticeCancelFailed')
+  return t('analysis.noticeNetwork')
+}
+
+function Exchange(props: { exchange: AnalysisExchange }): ReactElement {
+  const { exchange } = props
+  return (
+    <div className={css['exchange']} data-testid="agent-sidecar-analysis-exchange">
+      <span className={css['exchangeLabel']}>
+        {exchange.question === null ? t('analysis.exchangeInitial') : t('analysis.followupLabel')}
+      </span>
+      {exchange.question !== null && <div className={css['question']}>{exchange.question}</div>}
+      <pre className={css['summary']}>
+        {exchange.summary === '' ? t('analysis.emptySummary') : exchange.summary}
+      </pre>
+      {exchange.truncated && (
+        <span className={css['truncated']}>{t('analysis.truncatedNotice')}</span>
+      )}
+    </div>
+  )
+}
+
+/** The analysis panel. Pure render over props (state machine lives in glue). */
+export function AnalysisPanel(props: AnalysisPanelProps): ReactElement {
+  const { enabled, state } = props
+  const [question, setQuestion] = useState('')
+
+  const conversationLive = state.phase === 'ready' || state.phase === 'answering'
+  const showStart = state.phase === 'idle' || state.phase === 'failed' || state.phase === 'stopped'
+
+  const submitFollowup = (): void => {
+    const q = question.trim()
+    if (q === '' || state.phase !== 'ready') return
+    setQuestion('')
+    props.onFollowup(q)
+  }
+
+  return (
+    <section className={css['panel']} data-testid="agent-sidecar-analysis">
+      <div className={css['head']}>
+        <span className={css['title']}>{t('analysis.title')}</span>
+        <span className={css['spacer']} />
+        {conversationLive && (
+          <button
+            type="button"
+            className={css['textButton']}
+            disabled={!enabled}
+            onClick={props.onStop}
+            data-testid="agent-sidecar-analysis-stop"
+          >
+            {t('analysis.stop')}
+          </button>
+        )}
+        <button type="button" className={css['closeButton']} onClick={props.onClose}>
+          {t('analysis.close')}
+        </button>
+      </div>
+
+      {!enabled && (
+        <div className={css['noteCard']} data-testid="agent-sidecar-analysis-disabled">
+          {t('analysis.disabledNote')}
+        </div>
+      )}
+
+      {state.exchanges.map((exchange, index) => (
+        <Exchange key={index} exchange={exchange} />
+      ))}
+
+      {state.phase === 'failed' && state.errorCode !== null && (
+        <div className={css['errorCard']} data-testid="agent-sidecar-analysis-error">
+          {errorText(state.errorCode)}
+        </div>
+      )}
+      {state.phase === 'stopped' && (
+        <div className={css['noteCard']}>{t('analysis.stopped')}</div>
+      )}
+      {state.noticeCode !== null && (
+        <div className={css['noticeBar']} data-testid="agent-sidecar-analysis-notice">
+          {noticeText(state.noticeCode)}
+        </div>
+      )}
+
+      {enabled && showStart && (
+        <>
+          {state.phase === 'idle' && (
+            <div className={css['mutedLine']}>{t('analysis.idleHint')}</div>
+          )}
+          <button
+            type="button"
+            className={css['primaryButton']}
+            onClick={props.onStart}
+            data-testid="agent-sidecar-analysis-start"
+          >
+            {state.phase === 'idle' ? t('analysis.start') : t('analysis.restart')}
+          </button>
+        </>
+      )}
+
+      {state.phase === 'requesting' && (
+        <div className={css['mutedLine']}>{t('analysis.requesting')}</div>
+      )}
+      {state.phase === 'answering' && (
+        <div className={css['mutedLine']}>{t('analysis.answering')}</div>
+      )}
+
+      {conversationLive && (
+        <div className={css['followupForm']}>
+          <input
+            className={css['followupInput']}
+            value={question}
+            placeholder={t('analysis.followupPlaceholder')}
+            disabled={!enabled || state.phase !== 'ready'}
+            onChange={(event) => {
+              setQuestion(event.currentTarget.value)
+            }}
+            onKeyDown={(event) => {
+              if (event.key === 'Enter') submitFollowup()
+            }}
+            data-testid="agent-sidecar-analysis-question"
+          />
+          <button
+            type="button"
+            className={css['textButton']}
+            disabled={!enabled || state.phase !== 'ready' || question.trim() === ''}
+            onClick={submitFollowup}
+            data-testid="agent-sidecar-analysis-followup"
+          >
+            {t('analysis.followupSubmit')}
+          </button>
+        </div>
+      )}
+
+      {(conversationLive || state.exchanges.length > 0) && (
+        <div className={css['disclaimer']} data-testid="agent-sidecar-analysis-disclaimer">
+          {state.disclaimer ?? t('analysis.disclaimerFallback')}
+        </div>
+      )}
+    </section>
+  )
+}

package/src/client/analysis/analysis.module.css

@@ -0,0 +1,183 @@
+/*
+ * AI bypass-analysis panel styles (design §4.e.3 / §5.1 view 2): every
+ * color rides a --dsw-alias-* design token with a neutral fallback — no
+ * theme colors are hardcoded as the only value. Same posture as
+ * dsh-tools.module.css.
+ */
+
+.panel {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  min-width: 0;
+  padding: 10px 12px;
+  border-radius: 10px;
+  border: 1px solid var(--dsw-alias-border-l2, rgba(0, 0, 0, 0.12));
+  background: var(--dsw-alias-bg-layer-1, rgba(0, 0, 0, 0.02));
+  color: var(--dsw-alias-label-primary, #1f2328);
+}
+
+.head {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  min-width: 0;
+}
+
+.title {
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--dsw-alias-label-primary, #1f2328);
+}
+
+.spacer {
+  flex: 1;
+}
+
+.closeButton,
+.textButton {
+  flex: none;
+  font-size: 12px;
+  padding: 2px 8px;
+  border-radius: 6px;
+  border: 1px solid var(--dsw-alias-border-l2, rgba(0, 0, 0, 0.12));
+  background: transparent;
+  color: var(--dsw-alias-label-secondary, #57606a);
+  cursor: pointer;
+}
+
+.closeButton:hover,
+.textButton:hover {
+  background: var(--dsw-alias-bg-layer-2, rgba(0, 0, 0, 0.04));
+}
+
+.primaryButton {
+  align-self: flex-start;
+  font-size: 12px;
+  font-weight: 600;
+  padding: 4px 12px;
+  border-radius: 6px;
+  border: 1px solid var(--dsw-alias-border-l2, rgba(0, 0, 0, 0.12));
+  background: var(--dsw-alias-bg-layer-2, rgba(0, 0, 0, 0.04));
+  color: var(--dsw-alias-label-primary, #1f2328);
+  cursor: pointer;
+}
+
+.primaryButton:disabled,
+.textButton:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.mutedLine {
+  font-size: 12px;
+  line-height: 18px;
+  color: var(--dsw-alias-label-secondary, #57606a);
+}
+
+/* Capability-off / terminal-error note. */
+.noteCard {
+  font-size: 12px;
+  line-height: 18px;
+  padding: 8px 10px;
+  border-radius: 8px;
+  border: 1px dashed var(--dsw-alias-border-l2, rgba(0, 0, 0, 0.12));
+  background: var(--dsw-alias-bg-layer-1, rgba(0, 0, 0, 0.02));
+  color: var(--dsw-alias-label-secondary, #57606a);
+}
+
+.errorCard {
+  font-size: 12px;
+  line-height: 18px;
+  padding: 8px 10px;
+  border-radius: 8px;
+  color: var(--dsw-alias-state-error-primary, #cf222e);
+  background: var(--dsw-alias-state-error-secondary, rgba(207, 34, 46, 0.08));
+  border: 1px solid var(--dsw-alias-state-error-secondary, rgba(207, 34, 46, 0.24));
+}
+
+/* Non-terminal retryable notice. */
+.noticeBar {
+  font-size: 12px;
+  line-height: 18px;
+  padding: 6px 10px;
+  border-radius: 8px;
+  color: var(--dsw-alias-state-warning-primary, #9a6700);
+  background: var(--dsw-alias-state-warning-secondary, rgba(154, 103, 0, 0.1));
+  border: 1px solid var(--dsw-alias-state-warning-secondary, rgba(154, 103, 0, 0.28));
+}
+
+.exchange {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.exchangeLabel {
+  font-size: 11px;
+  font-weight: 600;
+  color: var(--dsw-alias-label-secondary, #57606a);
+}
+
+.question {
+  font-size: 12px;
+  line-height: 18px;
+  padding: 6px 10px;
+  border-radius: 8px;
+  background: var(--dsw-alias-bg-layer-2, rgba(0, 0, 0, 0.04));
+  color: var(--dsw-alias-label-primary, #1f2328);
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+.summary {
+  margin: 0;
+  font-size: 12px;
+  line-height: 18px;
+  padding: 8px 10px;
+  border-radius: 8px;
+  background: var(--dsw-alias-bg-layer-1, rgba(0, 0, 0, 0.02));
+  border: 1px solid var(--dsw-alias-border-l2, rgba(0, 0, 0, 0.12));
+  color: var(--dsw-alias-label-primary, #1f2328);
+  white-space: pre-wrap;
+  word-break: break-word;
+  font-family: inherit;
+  max-height: 320px;
+  overflow: auto;
+}
+
+.truncated {
+  font-size: 11px;
+  color: var(--dsw-alias-state-warning-primary, #9a6700);
+}
+
+/* The §5.3 honesty line — always visible with results. */
+.disclaimer {
+  font-size: 11px;
+  line-height: 16px;
+  color: var(--dsw-alias-label-secondary, #57606a);
+  border-top: 1px solid var(--dsw-alias-border-l2, rgba(0, 0, 0, 0.08));
+  padding-top: 6px;
+}
+
+.followupForm {
+  display: flex;
+  gap: 6px;
+}
+
+.followupInput {
+  flex: 1;
+  min-width: 0;
+  font-size: 12px;
+  padding: 4px 8px;
+  border-radius: 6px;
+  border: 1px solid var(--dsw-alias-border-l2, rgba(0, 0, 0, 0.16));
+  background: var(--dsw-alias-bg-layer-0, #fff);
+  color: var(--dsw-alias-label-primary, #1f2328);
+}
+
+.actionsRow {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}

package/src/client/analysis-glue.ts

@@ -0,0 +1,331 @@
+/**
+ * AI bypass-analysis data glue (T5.10b, design §4.e.3 / §5.1): a
+ * framework-free store per analysis conversation, driving the controlled
+ * AnalysisPanel over the `POST action` `analysis.*` trio (host contract:
+ * routes.ts handleAnalysis* over analysis.ts AnalysisEngine).
+ *
+ * Wire semantics this store encodes:
+ * - a settled engine result comes back with the HTTP status derived from
+ *   its `errorCode` (timeout→504, too_many_active→429, create_failed→502,
+ *   cancelled→200); api.ts postAction folds non-200 bodies into ApiError
+ *   with `reason` = that code — so failures arrive here as ApiError and
+ *   the cancelled-terminal arrives as a 200 body;
+ * - the write gate answers 403 `analysis_disabled` (fail-closed), an
+ *   agents-less composition answers 501 `analysis_unavailable`, and a
+ *   pre-analysis host answers 400 `unknown_action` (mapped to the same
+ *   honest "unavailable" terminal);
+ * - a request timeout DISPOSES the engine session (terminal), a followup
+ *   timeout KEEPS it (non-terminal notice; analysis.ts contract).
+ *
+ * Token honesty: this store dials analysis turns only on explicit user
+ * intent (start / followup / stop) — never automatically. The one
+ * automatic call is dispose()'s fire-and-forget cancel, which spends no
+ * tokens and only releases the engine session slot (F2).
+ *
+ * @module
+ */
+
+import {
+  isApiError,
+  postAction,
+  type AnalysisTargetKind,
+  type RequestOptions,
+} from './api.ts'
+
+// ---------------------------------------------------------------------------
+// Wire mirror (host: analysis.ts AnalysisResult; hand-written, client
+// program cannot import host modules).
+// ---------------------------------------------------------------------------
+
+/** Terminal fact about one analysis turn (host: analysis.ts). */
+export type AnalysisOutcomeWire = 'completed' | 'failed' | 'cancelled' | 'timeout'
+
+/** Body of a settled `analysis.request` / `analysis.followup` action. */
+export interface AnalysisResultWire {
+  outcome: AnalysisOutcomeWire
+  analysisSessionId?: string
+  summary?: string
+  truncated: boolean
+  tokensHint?: number
+  errorCode?: string
+  detail?: string
+  disclaimer: string
+}
+
+/** Analysis target selector (mirrors routes.ts AnalysisTargetRequest). */
+export interface AnalysisTarget {
+  targetKind: AnalysisTargetKind
+  targetId?: string
+  question?: string
+}
+
+// ---------------------------------------------------------------------------
+// Envelope builders (exported pure for tests).
+// ---------------------------------------------------------------------------
+
+export function analysisRequestEnvelope(target: AnalysisTarget): {
+  type: 'analysis.request'
+  targetKind: AnalysisTargetKind
+  targetId?: string
+  question?: string
+} {
+  return {
+    type: 'analysis.request',
+    targetKind: target.targetKind,
+    ...(target.targetId !== undefined ? { targetId: target.targetId } : {}),
+    ...(target.question !== undefined && target.question.trim() !== ''
+      ? { question: target.question }
+      : {}),
+  }
+}
+
+export function analysisFollowupEnvelope(analysisSessionId: string, question: string): {
+  type: 'analysis.followup'
+  analysisSessionId: string
+  question: string
+} {
+  return { type: 'analysis.followup', analysisSessionId, question }
+}
+
+export function analysisCancelEnvelope(analysisSessionId: string): {
+  type: 'analysis.cancel'
+  analysisSessionId: string
+} {
+  return { type: 'analysis.cancel', analysisSessionId }
+}
+
+// ---------------------------------------------------------------------------
+// State shapes.
+// ---------------------------------------------------------------------------
+
+/**
+ * Conversation phases. `failed` is terminal for the conversation (restart
+ * mints a new engine session); `stopped` is the user-cancelled terminal.
+ */
+export type AnalysisPhase =
+  | 'idle'
+  | 'requesting'
+  | 'ready'
+  | 'answering'
+  | 'stopped'
+  | 'failed'
+
+/** One settled turn: the initial summary (question null) or a follow-up. */
+export interface AnalysisExchange {
+  question: string | null
+  summary: string
+  truncated: boolean
+  tokensHint: number | null
+}
+
+export interface AnalysisGlueState {
+  phase: AnalysisPhase
+  analysisSessionId: string | null
+  exchanges: AnalysisExchange[]
+  /** Engine disclaimer verbatim; null before the first settle. */
+  disclaimer: string | null
+  /** Terminal failure code (phase 'failed'), else null. */
+  errorCode: string | null
+  /** Non-terminal notice code (kept session; retryable), else null. */
+  noticeCode: string | null
+}
+
+const INITIAL_STATE: AnalysisGlueState = {
+  phase: 'idle',
+  analysisSessionId: null,
+  exchanges: [],
+  disclaimer: null,
+  errorCode: null,
+  noticeCode: null,
+}
+
+/**
+ * The action deadline: the engine bounds one turn at ~60s (analysis.ts
+ * `turnTimeoutMs`), so the transport must outlive it to receive the
+ * engine's own timeout verdict instead of racing it.
+ */
+export const ANALYSIS_POST_TIMEOUT_MS = 75_000
+
+/** ApiError reason codes that keep a live followup session usable. */
+const RETRYABLE_FOLLOWUP_CODES = new Set([
+  'timeout', // engine turn timeout: session kept by contract
+  'request_timeout',
+  'network_error',
+])
+
+function failureCode(err: unknown): string {
+  if (isApiError(err)) {
+    // A pre-analysis host rejects the envelope as unknown_action — same
+    // honest terminal as an assembled-but-agents-less host.
+    return err.reason === 'unknown_action' ? 'analysis_unavailable' : err.reason
+  }
+  return 'network_error'
+}
+
+// ---------------------------------------------------------------------------
+// The store.
+// ---------------------------------------------------------------------------
+
+export interface AnalysisStoreOptions {
+  postActionFn?: typeof postAction
+  timeoutMs?: number
+}
+
+export class AnalysisStore {
+  private state: AnalysisGlueState = INITIAL_STATE
+  private readonly listeners = new Set<() => void>()
+  private readonly postActionFn: typeof postAction
+  private readonly timeoutMs: number
+  private disposed = false
+
+  constructor(options: AnalysisStoreOptions = {}) {
+    this.postActionFn = options.postActionFn ?? postAction
+    this.timeoutMs = options.timeoutMs ?? ANALYSIS_POST_TIMEOUT_MS
+  }
+
+  subscribe = (fn: () => void): (() => void) => {
+    this.listeners.add(fn)
+    return () => { this.listeners.delete(fn) }
+  }
+
+  getState = (): AnalysisGlueState => this.state
+
+  private setState(patch: Partial<AnalysisGlueState>): void {
+    if (this.disposed) return
+    this.state = { ...this.state, ...patch }
+    for (const fn of [...this.listeners]) fn()
+  }
+
+  private post(body: Parameters<typeof postAction>[0]): Promise<unknown> {
+    const opts: RequestOptions = { timeoutMs: this.timeoutMs }
+    return this.postActionFn(body, opts)
+  }
+
+  /** Start one analysis (allowed from idle and from the terminal phases). */
+  async start(target: AnalysisTarget): Promise<void> {
+    const { phase } = this.state
+    if (this.disposed || phase === 'requesting' || phase === 'ready' || phase === 'answering') {
+      return
+    }
+    this.setState({ ...INITIAL_STATE, phase: 'requesting' })
+    try {
+      const result = (await this.post(analysisRequestEnvelope(target))) as AnalysisResultWire
+      if (this.disposed) {
+        // The view unmounted while the request was in flight: the engine
+        // session it just created has no owner left — release it so it
+        // cannot strand one of the engine's bounded session slots (F2).
+        const id = result?.analysisSessionId
+        if (result?.outcome === 'completed' && typeof id === 'string' && id !== '') {
+          this.fireCancel(id)
+        }
+        return
+      }
+      if (this.state.phase !== 'requesting') return
+      this.adoptResult(null, result)
+    } catch (err) {
+      if (this.disposed || this.state.phase !== 'requesting') return
+      // Request-path failures are all terminal: either the engine session
+      // was never created, or (engine timeout) it was already disposed.
+      this.setState({ phase: 'failed', errorCode: failureCode(err) })
+    }
+  }
+
+  /** Ask a follow-up in the live analysis session. */
+  async followup(question: string): Promise<void> {
+    const id = this.state.analysisSessionId
+    const q = question.trim()
+    if (this.disposed || this.state.phase !== 'ready' || id === null || q === '') return
+    this.setState({ phase: 'answering', noticeCode: null })
+    // Widened re-reads: setState/stop() move the phase between awaits, and
+    // TS's property narrowing from the entry guard would misjudge that.
+    const phaseNow = (): AnalysisPhase => this.state.phase
+    try {
+      const result = (await this.post(analysisFollowupEnvelope(id, q))) as AnalysisResultWire
+      if (this.disposed || phaseNow() !== 'answering') return
+      this.adoptResult(q, result)
+    } catch (err) {
+      if (this.disposed || phaseNow() !== 'answering') return
+      const code = failureCode(err)
+      if (RETRYABLE_FOLLOWUP_CODES.has(code)) {
+        // The engine keeps the session on a turn timeout; transport-level
+        // failures are unknowable, so stay usable and let the user retry.
+        this.setState({ phase: 'ready', noticeCode: code })
+      } else {
+        this.setState({ phase: 'failed', errorCode: code })
+      }
+    }
+  }
+
+  /** Release the analysis session (idempotent on the engine side). */
+  async stop(): Promise<void> {
+    const id = this.state.analysisSessionId
+    const { phase } = this.state
+    if (this.disposed || id === null || (phase !== 'ready' && phase !== 'answering')) return
+    try {
+      await this.post(analysisCancelEnvelope(id))
+      if (this.disposed) return
+      // An in-flight followup now settles against a stopped phase and is
+      // dropped by the phase recheck above.
+      this.setState({ phase: 'stopped', noticeCode: null })
+    } catch {
+      if (this.disposed) return
+      this.setState({ noticeCode: 'cancel_failed' })
+    }
+  }
+
+  /** Fold one settled 200 result into the conversation. */
+  private adoptResult(question: string | null, result: AnalysisResultWire): void {
+    if (result.outcome === 'completed') {
+      this.setState({
+        phase: 'ready',
+        analysisSessionId: result.analysisSessionId ?? this.state.analysisSessionId,
+        exchanges: [
+          ...this.state.exchanges,
+          {
+            question,
+            summary: result.summary ?? '',
+            truncated: result.truncated,
+            tokensHint: result.tokensHint ?? null,
+          },
+        ],
+        disclaimer: result.disclaimer,
+        errorCode: null,
+        noticeCode: null,
+      })
+      return
+    }
+    // A 200 non-completed result is the engine's `cancelled` verdict (all
+    // other failure codes ride non-200 statuses); treat unknown shapes as
+    // terminal too — never invent a usable session.
+    this.setState({
+      phase: result.errorCode === 'cancelled' || result.outcome === 'cancelled'
+        ? 'stopped'
+        : 'failed',
+      errorCode: result.errorCode ?? result.outcome,
+      disclaimer: result.disclaimer,
+    })
+  }
+
+  /**
+   * Late settlements become no-ops; subscribers are dropped. Idempotent.
+   * A live engine session is released with a fire-and-forget cancel so
+   * unmount / session-switch remounts cannot strand `maxActiveSessions`
+   * slots until plugin unload (F2). Cancel is idempotent on the engine
+   * side; a transport failure is silently ignored (nothing to surface —
+   * the store is gone).
+   */
+  dispose(): void {
+    if (this.disposed) return
+    const { analysisSessionId, phase } = this.state
+    this.disposed = true
+    this.listeners.clear()
+    if (analysisSessionId !== null && (phase === 'ready' || phase === 'answering')) {
+      this.fireCancel(analysisSessionId)
+    }
+  }
+
+  /** Fire-and-forget analysis.cancel (failures are deliberately silent). */
+  private fireCancel(analysisSessionId: string): void {
+    void this.post(analysisCancelEnvelope(analysisSessionId)).catch(() => {})
+  }
+}