@poetic-ai/poetic 1.42.0

package/integrations/bb-plugin-poetic/README.md

@@ -0,0 +1,362 @@
+# Poetic for BB (local development)
+
+This optional, full-trust BB plugin presents Poetic planning state, backlog items, local Fusion
+and judged competition runs, and tracked backlog execution. Poetic remains the planning,
+orchestration, provider, judge, and result authority. The plugin keeps no backlog database, provider credentials, run
+ledger, daemon, or independent provider execution path.
+
+## Installation and enablement
+
+Prerequisites: BB with plugin SDK `0.4.x`, Poetic `1.x`, and one BB project
+whose local source is the root of an initialized Poetic Git repository.
+
+Poetic alone is the default. The optional visual path reuses the existing
+provider setup surface (no new Poetic command family) and BB's native plugin
+installer:
+
+```bash
+poetic provider setup --bb
+```
+
+That command prints the Poetic plugin version, detected BB version, plugin SDK
+range, and full-trust permission implications before enablement. Missing BB, an
+incompatible BB version, a missing plugin package, or install failure leaves
+standalone Poetic unchanged and prints a recovery path. Provider credentials
+and auth files are never read or copied.
+
+An older local-path registration is not replaced implicitly. After reviewing
+the disclosure, rerun with `--bb --reinstall` to replace it. BB local-path
+replacement is not transactional: a failed explicit replacement reports the
+installed state and leaves BB recovery to the user, while a failed first-time
+registration is removed automatically when Poetic can prove it created it.
+
+When the panel sees exactly one local BB project source it selects it
+automatically; zero or multiple sources require an explicit user choice.
+
+## SDK compatibility and host-test contract
+
+BB's plugin SDK declarations can change while the published SDK version stays
+the same, so semver alone cannot detect the drift that breaks this plugin.
+`types/PROVENANCE.json` records, for every vendored declaration file, the BB
+source commit, the SDK version and range, the generation/vendoring method and
+command, a `sha256` digest, a byte length, and the exports this plugin's compile
+depends on.
+
+`poetic provider setup --bb` compares the shipped declarations against that
+record before contacting BB. A digest, byte-length, missing-export, or
+SDK-range mismatch reports `sdk_declarations_drifted` with the drifted file and
+the re-vendoring command, and BB is never invoked — so drift cannot disturb an
+existing install. The provenance line (SDK version, BB commit, generation
+method) is printed with the version and trust disclosure. This extends the
+existing setup validation; it is not a separate installer or a repository-wide
+gate, and standalone Poetic never runs it.
+
+Regenerate declarations from a BB checkout with the recorded
+`generation.command`, then update `upstream.sourceCommit`, `sha256`, and
+`byteLength` in `types/PROVENANCE.json`.
+
+The focused backend/RPC test loads the real `server.ts` factory directly into
+BB's official `@bb/plugin-sdk/testing` `createFakePluginHost`. Point
+`BB_SOURCE_ROOT` at a checkout of the recorded source commit and run:
+
+```bash
+BB_SOURCE_ROOT=/path/to/bb npx vitest run \
+  --config integrations/bb-plugin-poetic/vitest.host.config.ts
+```
+
+This exercises BB's actual contract registration and strict runtime validation
+without copying its test-host implementation into Poetic. The test-only runtime
+is resolved from the supplied checkout; standalone Poetic and its ordinary test
+suite do not import BB or require BB to be installed.
+
+### Local development
+
+```bash
+cd /absolute/path/to/poetic/integrations/bb-plugin-poetic
+npm install
+bb plugin install /absolute/path/to/poetic/integrations/bb-plugin-poetic
+bb plugin dev /absolute/path/to/poetic/integrations/bb-plugin-poetic
+```
+
+Open the `Poetic` navigation panel and select the BB project source when
+auto-association does not apply. The workbench nav is Overview, Plan, Run, and
+Settings. Backlog list and detail live under Plan (`plan/backlog`); run list and
+detail live under Run (`run`); Settings remounts the former setup workspace
+(`settings`, with `setup` as an alias). Older `backlog` and `runs` paths parse
+to the same kinds. If the BB server does not inherit the shell
+path that contains `poetic`, set the plugin's `Poetic executable` setting to an
+absolute path and reload the plugin.
+
+## Trust and effects
+
+BB plugins execute with full host trust. Every launch confirmation discloses
+that this backend starts the installed `poetic` executable as the current host
+user with the selected canonical repository as `cwd`. It passes an argv array
+with `shell: false`; the RPC contract exposes no arbitrary executable, argv,
+environment, cwd, or file-read method.
+
+Fusion launches `poetic run fusion --json -- <backlog-body>`. That action
+may use the user's native provider authentication and create local worktrees,
+logs, or artifacts. It does not mutate/synchronize Poetic's managed planning
+files and does not push Git changes. The plugin never adds `--allow-main` or
+changes Poetic's consent policy. Protected branches are disclosed; detached
+HEAD, a non-root/wrong repository, an uninitialized Poetic repository, and
+incompatible Poetic or snapshot major versions are blocked explicitly.
+
+Competition launch has its own consent and starts only
+`poetic compete --backlog-item <id> --judge ai --configured-defaults --json`.
+Poetic resolves the configured variants and models, owns judging, and publishes
+the versioned start envelope before BB begins its existing competition-results
+polling. BB adds no provider picker, judge implementation, retry loop, or run
+store. After BB loses its exact child-process handle, the run remains observable
+from Poetic but is not cancellable or automatically restarted.
+
+Tracked execution has a separate RPC and consent schema. It launches only
+`poetic plan backlog execute <id>` from a clean checkout, with no bypass flags.
+The disclosure states that canonical Poetic may create or switch branches,
+synchronize managed planning state, invoke native provider authentication,
+create commits, push changes, and open a PR. BB does not implement any of those
+steps. Finalization wraps the exact
+`poetic plan backlog finalize <id> --pr <n> --commit <sha>` argv under high
+consent; Poetic still owns the lifecycle. BB never invents the PR number or
+commit SHA and never implements `--auto` finalize.
+
+## Planning authoring and sprint composition
+
+BB provides bounded forms over Poetic's existing planning authority. Backlog
+authoring can capture and edit items, mark them reviewed, and set priority;
+custom-task authoring can create or edit an operator-authored task, add or remove
+task dependencies, and link a task to a backlog item. Sprint composition can
+create or rename a sprint, add backlog work as a new task, detach a task without
+deleting it, and migrate a task between sprints while preserving its id and
+resetting its status to `todo`.
+
+Each confirmed action runs once against the selected repository and branch.
+Poetic mints identities, applies mutations, and remains authoritative for
+status, membership, capacity, integrity, and sync evidence; BB displays changed
+facts only after authoritative rereads. The confirmation discloses that
+Poetic's built-in managed sync may commit and push planning changes, and BB does
+not suppress or replace that sync.
+
+This surface wraps one-item finalize and single-sprint close under high consent.
+It still does not defer or archive-backlog, `--force` close, run sprints, refine
+items, or select providers or models. Those remaining concerns stay in their
+existing Poetic-owned workflows.
+
+## Read and polling contract
+
+- The planning workspace reads the versioned projection carried by
+  `poetic plan sprint status --json` when the panel selects a repository. It
+  presents Poetic's sprint, task, dependency, blocker, ownership, active-work,
+  and advisory sync evidence without keeping a planning mirror. Older Poetic
+  versions and malformed or unavailable evidence render as unavailable rather
+  than as an empty or healthy workspace.
+- Planning state is not attached to run polling, the background service, or the
+  30-second watchdog. Selecting or reopening a repository performs one fresh
+  planning read; when a tracked execute card first becomes terminal the panel
+  issues one additional `planningWorkspace` refetch. The adapter does not.
+  No planning poller, cache, heartbeat, or daemon is added.
+- Backlog list/detail comes from `poetic plan backlog list/show --json` on each
+  request. No BB task store is used.
+- Tracked-execution cards also come from that item-specific, kind-tagged
+  operational readback. Branch, workflow, commit, verification, PR, blocker,
+  and finalization evidence is rendered only when Poetic publishes it.
+- Fusion's versioned `poetic.run.started` line supplies the run ID. The plugin
+  never guesses it from directories or prose.
+- BB's background service owns the authoritative cadence: it polls
+  `poetic fusion results <run-id> --json` server-side every 2.5 seconds while any
+  run is non-terminal, and every 30 seconds otherwise. The response carries
+  `RunSnapshotV1` and Poetic's deterministic `runProgressV1` projection. A
+  repository is polled only while a panel has asked about it in the last five
+  minutes; the service's own reads do not extend that window.
+- The frontend keeps connection/watchdog behavior only. It refetches on an
+  ephemeral realtime signal, after the shared connection returns from
+  `reconnecting`, and on a 30-second watchdog floor.
+- Realtime is ephemeral invalidation, not Poetic run-event authority. The signal
+  names the repository to refetch plus advisory counts; it carries no status,
+  phase, progress, verdict, or evidence, and it is published only after the
+  server's authoritative read completes. A dropped signal costs a refresh, never
+  correctness.
+- The same response optionally carries Poetic's read-only `judgeOperationsV1`
+  projection, which the card renders as the judge operations cockpit (see below).
+- Operation handles are bounded, plugin-process-local startup supervision. Run
+  state remains inspectable through the standalone command shown on each card.
+- Evidence entries retain the run ID and canonical repository so commits,
+  branches, changed files, verification, synthesis, and artifacts cannot cross
+  between concurrent cards.
+
+## Judge operations cockpit
+
+Poetic decides every judge outcome; the cockpit only presents what Poetic already
+recorded. A competition launched from a reviewed backlog item or adopted by entering
+a known run ID reuses the existing run-card polling path. BB persists no run state,
+and the standalone authority remains `poetic compete results <run-id> --json`. It adds
+no polling mechanism, persistence, command, or gate, and it never
+recomputes a score, selects or overrides a winner, reruns a judge, adjudicates on
+the host, or approves anything.
+
+- The field is optional. A record that carries no `judgeOperationsV1` — including
+  every record written before the projection existed — renders an unavailable
+  cockpit, and the run card stays valid. A payload with an incompatible major
+  version or another run's id is rejected: unusable evidence is never presented.
+- Evidence Poetic did not publish renders as an explicit `unavailable`. A published
+  empty list renders as `none`; the two are never conflated, and no field is
+  defaulted, clamped, or back-filled.
+- The immutable judge winner has its own row, separate from the synthesized and
+  delivered artifact rows, even when all three agree. When a synthesized or
+  delivered artifact diverges from the winner, that divergence is disclosed and the
+  judge winner is left unchanged.
+- Matrix escalation is presented as an escalated judge verdict with Poetic's own
+  escalation reasons, recorded per-profile disagreements, and human checks labelled
+  `blocking` or `advisory` as Poetic recorded them. It does not change which winner
+  the cockpit shows.
+- Fusion reports `No judge by design` — a complete state, not a pending, degraded,
+  broken, or empty one. Fusion's synthesized and delivered artifacts are still
+  shown, because they are not judge concepts.
+- Tracked backlog execution renders no cockpit: its kind-tagged readback carries no
+  judge, variant, or verdict fields at all. An unreadable observation also renders
+  none rather than replaying stale judge evidence.
+
+## Results explorer, patch preview, defaults, and setup
+
+Poetic remains the execution and result authority. BB only presents and navigates
+what Poetic already published. Competition, Fusion, and tracked backlog execution
+stay kind-specific; sections, references, and standalone commands do not cross kinds.
+Fusion has no Judge winner by design.
+
+- **Results explorer** — one read-only view per run via `readResult`. It reuses
+  Poetic's canonical result readback and adds no winner, score, or verification
+  recomputation. Canonical standalone commands: `poetic compete results <run-id>
+  --json`, `poetic fusion results <run-id> --json`, and
+  `poetic plan backlog show <id> --json` for tracked execution.
+- **Patch preview** — bounded and patch-only. Only a freshly rebound canonical
+  `patch` reference may open content, and only up to a fixed byte ceiling; truncated
+  previews are labelled partial. Non-patch kinds, cross-run or cross-repository
+  identity, unsafe paths, symlinks, binaries, compressed, and missing files are
+  explicit refusals. There is no apply, write, or merge control.
+- **Competition configured-defaults disclosure** — read-only presentation of
+  `poetic config resolved --compete --json` with source attribution. The existing
+  PBB-20 launch remains
+  `poetic compete --backlog-item <id> --judge ai --configured-defaults --json`;
+  disclosure does not change that argv.
+- **Setup and configuration workspace** — read-only status for install readiness,
+  resolved defaults, providers, and copyable guidance. Setup, auth, and config
+  commands are guidance only and are never executed by BB. Deferred or unobserved
+  provider authentication is `unknown` / normal, not a fault or launch gate.
+  Canonical guidance includes `poetic --version`,
+  `poetic config resolved --summary --json`,
+  `poetic config resolved --compete --json`,
+  `poetic config validate --json`, `poetic provider list --json`,
+  `poetic init`, and `poetic provider setup --first-run` (all run outside BB).
+
+## Optional narrated progress
+
+Narration is advisory and requires an active UI subscriber: `pollRuns` schedules a
+model call only when a visible panel sets `narrate`. The background service polls
+with narration off, so the authoritative cadence never issues a model call on its
+own. An already-cached fresh narration still renders, because it costs nothing.
+
+Narration is disabled by default. Enable it in user or project
+`poetic.config.jsonc` with an explicit provider; omit `model` to use that
+provider CLI's configured default:
+
+```jsonc
+{
+  "progressNarration": {
+    "enabled": true,
+    "provider": "codex",
+    "minIntervalMs": 15000,
+    "maxAgeMs": 60000,
+  },
+}
+```
+
+Poetic publishes only a bounded structured-facts envelope alongside
+`runProgressV1`. The plugin invokes the existing `poetic ask --json` surface,
+so it reuses Poetic's provider resolution and the installed CLI's native
+authentication. One request covers all active variants for a run. The plugin
+coalesces overlapping polls, rate-limits requests, keeps its cache in memory,
+and immediately falls back to the deterministic progress line when narration
+is disabled, stale, invalid, terminal, or unavailable. Narration and its
+advisory latency never change run state, cancellation, judging, verification,
+or result evidence.
+
+## Cancel and reconnect
+
+The launch and cancel controls are plugin RPC actions over Poetic's existing behavior. They add
+no public Poetic command, scheduler, retry path, or persistence mechanism.
+
+- `cancelRun` names exactly one operation. It sends the same interrupt a
+  standalone operator would to the exact process this plugin launched. For
+  Fusion it also runs `poetic processes --kill <run-id> --force` for anything
+  Poetic spawned for that run. Sibling runs are untouched.
+- A cancelled card reports `cancelRequested`, but its status and terminal flag
+  stay whatever Poetic reports. The plugin never asserts a terminal state Poetic
+  has not confirmed. Runs that already reached a final state, unknown
+  operations, and operations from another repository are refused explicitly.
+- What could not be cancelled is reported verbatim on the card: an unsignalable
+  process, a Poetic cancel command that failed, Poetic reporting no live
+  processes for the run, or cancellation requested before a run ID existed.
+- `pollRuns` with no `operationIds` is the reconnect path. It combines bounded
+  plugin-local history with task IDs from `poetic processes --json`, accepting a
+  discovered ID only when its Fusion snapshot belongs to the selected repository.
+  Cards are merged without duplication. `Refresh runs` triggers the same poll.
+- Fusion registers its top-level CLI process under the authoritative run ID before
+  publishing the run-start envelope and refreshes that entry for the active
+  lifecycle. A fresh adapter therefore re-adopts active queued, provider, and
+  synthesis work without importing Poetic internals or keeping a second ledger.
+
+### Duplicate-launch refusal
+
+`plan backlog show --json` carries Poetic's kind-tagged tracked-execution
+readback. BB admits at most one tracked launch per repository checkout; the
+reservation is repository-scoped, while Fusion and other repositories remain
+independent. A launch is also refused while readback proves an active execution:
+a non-terminal, non-stale record whose status is `running` or `queued` **and**
+whose recorded process Poetic observed `alive`. Everything weaker
+allows the launch — `gone`, `unobserved`, `stale`, `unknown`, and a missing record
+are not evidence of activity, and `.poetic/provenance` is local-only, so absence
+never proves nothing is running. The evidence is read fresh on every request and
+is never stored in BB, so BB state can neither manufacture a block nor grant
+permission.
+
+### Bounded reference index (BB-launched history only)
+
+Runs this plugin launched get one bounded BB KV row holding **discovery identity
+only**: repository, kind, run id, backlog item id, operation id, and launch time.
+There is deliberately no status, progress, phase, terminal verdict, provider
+output, evidence, or Git result, so a stale reference cannot override Poetic's
+readback — every card is rehydrated from Poetic. The index caps at 50 references
+(oldest launches evicted) and expires entries after 7 days; unparsable,
+foreign-schema, and expired rows are deleted on read. It is BB-launched history,
+not a run ledger or a second store.
+
+### Loss of the local process handle (safe, not seamless)
+
+Fusion is launched as a plain child of the BB server process with
+`stdio: ['ignore', 'pipe', 'pipe']` — not detached, and not `unref`ed. This slice
+does not promise restart recovery; it promises safe behavior when the handle is
+gone.
+
+- Reloading the BB **panel** keeps runs alive and reconnects to them; operation
+  handles live in the plugin's server-side adapter, not in the web view.
+- Restarting the BB **server** or reloading the plugin ends the plugin's direct
+  child supervision. Cards then report `processHandle: 'lost'` and disclose it in
+  plain text. A fresh adapter re-reads Poetic — from its process registry and from
+  the bounded reference index — and reports a supported terminal or live state, or
+  an honest, non-cancellable `unknown`. The identity remains visible so a later
+  Poetic read can recover it without restarting or reconstructing the run.
+- Nothing is automatically restarted, resumed, replayed, or reconstructed. There
+  is no daemon, event journal, general crash-recovery subsystem, or
+  machine-reboot guarantee.
+- Cancellation requires `controlEvidence`: either a `local-process` handle this
+  plugin still owns, or a `poetic-live-process` — a healthy top-level Fusion
+  process Poetic reports for that run in that repository. With neither, the
+  control is disabled and the RPC refuses, rather than claiming control the
+  plugin does not have. Live-process evidence is recomputed on every reconnect, so
+  a run that leaves the registry loses cancellability.
+
+A public Poetic API family, remote repositories, retry/relaunch, seamless process
+reattachment, live-output restoration, live provider-session steering, and
+imperative artifact opening are not part of this slice. Optional enablement is
+available via `poetic provider setup --bb`.

package/integrations/bb-plugin-poetic/app.css

@@ -0,0 +1,341 @@
+.poetic-workbench {
+  display: grid;
+  grid-template-rows: auto auto minmax(0, 1fr);
+  height: 100%;
+  min-width: 0;
+  color: var(--foreground);
+  background: var(--background);
+}
+
+.poetic-content {
+  display: grid;
+  grid-template-rows: auto minmax(0, 1fr);
+  min-height: 0;
+  overflow: hidden;
+}
+
+.poetic-chrome {
+  display: grid;
+  gap: 10px;
+  padding: 12px 16px;
+  border-bottom: 1px solid var(--border);
+  background: var(--background);
+}
+
+.poetic-repository-line,
+.poetic-row-meta,
+.poetic-row-actions,
+.poetic-inline-actions,
+.poetic-summary-metrics {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 6px 12px;
+}
+
+.poetic-repository-line {
+  justify-content: space-between;
+}
+
+.poetic-repository-line label {
+  min-width: min(100%, 320px);
+  flex: 1;
+}
+
+.poetic-repository-line select,
+.poetic-input {
+  width: 100%;
+  min-height: 34px;
+  padding: 6px 9px;
+  color: inherit;
+  background: var(--background);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+}
+
+.poetic-nav {
+  display: flex;
+  gap: 4px;
+  padding: 0 16px;
+  overflow-x: auto;
+  border-bottom: 1px solid var(--border);
+}
+
+.poetic-nav button {
+  padding: 10px 12px 9px;
+  color: var(--muted-foreground);
+  white-space: nowrap;
+  background: transparent;
+  border: 0;
+  border-bottom: 2px solid transparent;
+  cursor: pointer;
+}
+
+.poetic-nav button[aria-current="page"] {
+  color: var(--foreground);
+  border-bottom-color: currentColor;
+  font-weight: 600;
+}
+
+.poetic-page {
+  display: grid;
+  gap: 12px;
+  min-width: 0;
+  padding: 16px;
+  overflow: auto;
+  align-content: start;
+}
+
+.poetic-page-header {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+
+.poetic-page-header h2,
+.poetic-card h3,
+.poetic-card p {
+  margin: 0;
+}
+
+.poetic-card {
+  display: grid;
+  gap: 10px;
+  min-width: 0;
+  padding: 12px;
+  background: var(--card, var(--background));
+  border: 1px solid var(--border);
+  border-radius: 8px;
+}
+
+.poetic-authoring-card {
+  max-width: 28rem;
+}
+
+.poetic-select {
+  display: block;
+  width: max-content;
+  min-width: 12rem;
+  max-width: 100%;
+  min-height: 34px;
+  margin-top: 4px;
+  padding: 6px 9px;
+  color: inherit;
+  background: var(--background);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+}
+
+.poetic-card-muted {
+  background: var(--muted, var(--background));
+}
+
+.poetic-list {
+  display: grid;
+  gap: 8px;
+  padding: 0;
+  margin: 0;
+  list-style: none;
+}
+
+.poetic-row {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 8px 16px;
+  align-items: center;
+  min-width: 0;
+  padding: 10px 12px;
+  border: 1px solid var(--border);
+  border-radius: 7px;
+}
+
+.poetic-row-main {
+  display: grid;
+  gap: 5px;
+  min-width: 0;
+}
+
+.poetic-row-title {
+  overflow-wrap: anywhere;
+  font-weight: 600;
+}
+
+.poetic-row-meta {
+  color: var(--muted-foreground);
+  font-size: 0.82rem;
+}
+
+.poetic-button {
+  display: inline-flex;
+  min-height: 36px;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  padding: 6px 11px;
+  color: var(--foreground);
+  font: inherit;
+  font-size: 0.875rem;
+  font-weight: 500;
+  background: var(--background);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  cursor: pointer;
+}
+
+.poetic-button:hover:not(:disabled) {
+  background: var(--muted, var(--background));
+}
+
+.poetic-button:active:not(:disabled) {
+  transform: translateY(1px);
+}
+
+.poetic-button:focus-visible,
+.poetic-nav button:focus-visible,
+.poetic-input:focus-visible,
+.poetic-repository-line select:focus-visible {
+  outline: 2px solid var(--ring, currentColor);
+  outline-offset: 2px;
+}
+
+.poetic-button:disabled {
+  cursor: not-allowed;
+  opacity: 0.55;
+}
+
+.poetic-button-primary {
+  color: var(--primary-foreground, white);
+  background: var(--primary, #18181b);
+  border-color: var(--primary, #18181b);
+}
+
+.poetic-button-primary:hover:not(:disabled) {
+  color: var(--primary-foreground, white);
+  background: var(--primary, #18181b);
+  opacity: 0.9;
+}
+
+.poetic-button-danger {
+  color: var(--destructive, #991b1b);
+  border-color: var(--destructive, #b91c1c);
+}
+
+.poetic-button-danger:hover:not(:disabled) {
+  color: var(--destructive, #991b1b);
+  background: color-mix(in srgb, var(--destructive, #b91c1c) 9%, transparent);
+}
+
+.poetic-button-danger-confirm {
+  color: var(--destructive-foreground, white);
+  background: var(--destructive, #b91c1c);
+  border-color: var(--destructive, #b91c1c);
+}
+
+.poetic-button-danger-confirm:hover:not(:disabled) {
+  color: var(--destructive-foreground, white);
+  background: var(--destructive, #b91c1c);
+  opacity: 0.9;
+}
+
+.poetic-button-spinner {
+  width: 14px;
+  height: 14px;
+  border: 2px solid currentColor;
+  border-right-color: transparent;
+  border-radius: 50%;
+  animation: poetic-button-spin 0.8s linear infinite;
+}
+
+@keyframes poetic-button-spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+.poetic-badge {
+  display: inline-flex;
+  align-items: center;
+  min-height: 22px;
+  padding: 2px 7px;
+  color: var(--muted-foreground);
+  font-size: 0.75rem;
+  font-weight: 600;
+  line-height: 1;
+  background: var(--muted, transparent);
+  border: 1px solid var(--border);
+  border-radius: 999px;
+}
+
+.poetic-advisory {
+  color: var(--muted-foreground);
+  font-size: 0.84rem;
+}
+
+.poetic-details > summary {
+  cursor: pointer;
+  font-weight: 600;
+}
+
+.poetic-confirmation {
+  border-color: var(--warning-border, #b45309);
+}
+
+.poetic-confirmation-actions {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+  gap: 8px;
+}
+
+.poetic-danger-zone {
+  padding-top: 10px;
+  border-top: 1px solid var(--border);
+}
+
+.poetic-empty {
+  padding: 24px;
+  color: var(--muted-foreground);
+  text-align: center;
+  border: 1px dashed var(--border);
+  border-radius: 8px;
+}
+
+@media (max-width: 720px) {
+  .poetic-row {
+    grid-template-columns: minmax(0, 1fr);
+  }
+
+  .poetic-row-actions,
+  .poetic-inline-actions {
+    width: 100%;
+  }
+
+  .poetic-row-actions .poetic-button,
+  .poetic-inline-actions .poetic-button,
+  .poetic-confirmation-actions .poetic-button {
+    flex: 1;
+  }
+
+  .poetic-confirmation-actions {
+    flex-direction: column;
+  }
+
+  .poetic-confirmation-actions .poetic-button-primary,
+  .poetic-confirmation-actions .poetic-button-danger-confirm {
+    order: -1;
+  }
+}
+
+@media (pointer: coarse) {
+  .poetic-button {
+    min-height: 44px;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .poetic-button-spinner {
+    animation-duration: 1.6s;
+  }
+}