@sigrun/tui 0.7.0 → 0.9.0

package/CHANGELOG.md

@@ -6,6 +6,19 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 
+## [0.9.0] - 2026-11-05
+
+- Decline on declinable interaction cards (`alt+s` in answer mode; `alt+d` is the
+  notices dismiss), the armed-hint chord, and the stepper review fixes (answer
+  labels, "Not answered yet" naming, Enter guard).
+
+## [0.8.0] - 2026-11-04
+
+- Notices: an inline line for the current conversation's newest notice (a key dismisses
+  it), `notices:N` in the status bar, and an overlay listing all notices with the
+  buttons (extension actions run, `open` prints the URL, navigate routes); ambient
+  navigate/open are wired. No peek — the count is the announcement.
+
 ## [0.7.0] - 2026-11-04
 
 - The 401 auth notice dedupes across streams and survives conversation switches; SSE

package/dist/actions.d.ts

@@ -63,6 +63,12 @@ export type Action = {
     readonly reverse: boolean;
 } | {
     readonly type: "answer-interaction";
+}
+/** Ask-user Task 5 (spec §5.2): decline the armed interaction record
+ *  (alt+s in every keymap — alt+d is the notices dismiss). Acts ONLY
+ *  in answer mode on a declinable record. */
+ | {
+    readonly type: "decline-interaction";
 } | {
     readonly type: "cancel-run";
 } | {
@@ -112,6 +118,14 @@ export type Action = {
 /** Return the calendar range to today (t). */
  | {
     readonly type: "blocks.today";
+}
+/** Open the notices overlay. */
+ | {
+    readonly type: "notices.open";
+}
+/** Dismiss the newest notice (the inline line's notice). */
+ | {
+    readonly type: "notices.dismissNewest";
 };
 /** The dispatch surface {@link TuiApp} implements. */
 export interface ActionHost {

package/dist/api.d.ts

@@ -17,16 +17,18 @@
  * silent `undefined` the UI could misrender as empty state.
  */
 import type { CommandRunResponse, CommandsResponse } from "@sigrun/shared/commands";
+import type { NoticeActionResponse, NoticesResponse } from "@sigrun/shared/notices";
 import type { JobsResponse, JobRunResponse } from "@sigrun/shared/views";
 import type { JobRevisionWire, JobRunWire } from "@sigrun/shared/jobs";
 import type { SessionMeta, SessionMetaPatch } from "@sigrun/shared/session-meta";
-import type { AbortResponse, AmbientList, CompactResponse, ConfigureResponse, ConversationCreateResponse, ConversationForkResponse, ConversationList, ConversationViewWire, InteractionAnswered, InteractionList, InteractionWire, MetaResponse, ModelsResponse, SettingsResponse, SettingsSectionsResponse, SubmissionResponse, WhoamiResponse } from "@sigrun/shared/views";
-export type { AbortResponse, AmbientList, AmbientWire, CompactResponse, ConfigureResponse, ConversationCreateResponse, ConversationForkResponse, ConversationList, ConversationSummary, ConversationViewWire, InteractionAnswered, InteractionList, InteractionWire, MetaResponse, ModelEntry, ModelsResponse, SettingsResponse, SettingsSectionsResponse, SettingsSectionEntry, SettingsSectionIndexEntry, SubmissionResponse, WhoamiResponse, } from "@sigrun/shared/views";
+import type { AbortResponse, AmbientList, CompactResponse, ConfigureResponse, ConversationCreateResponse, ConversationForkResponse, ConversationList, ConversationViewWire, InteractionAnswered, InteractionDeclined, InteractionList, InteractionWire, MetaResponse, ModelsResponse, SettingsResponse, SettingsSectionsResponse, SubmissionResponse, WhoamiResponse } from "@sigrun/shared/views";
+export type { AbortResponse, AmbientList, AmbientWire, CompactResponse, ConfigureResponse, ConversationCreateResponse, ConversationForkResponse, ConversationList, ConversationSummary, ConversationViewWire, InteractionAnswered, InteractionDeclined, InteractionList, InteractionWire, MetaResponse, ModelEntry, ModelsResponse, SettingsResponse, SettingsSectionsResponse, SettingsSectionEntry, SettingsSectionIndexEntry, SubmissionResponse, WhoamiResponse, } from "@sigrun/shared/views";
 export type { CommandRunResponse, CommandsResponse, SlashCommand } from "@sigrun/shared/commands";
 export type { JobSpec, JobSchedule, JobAction, JobWire, JobRunWire, JobRevisionWire, } from "@sigrun/shared/jobs";
 export type { JobsResponse, JobRunResponse } from "@sigrun/shared/views";
 export type { ExtensionsResponse, ExtensionInfo, ExtensionSurfaceInfo } from "@sigrun/shared/views";
 export type { SessionMeta, SessionMetaPatch } from "@sigrun/shared/session-meta";
+export type { UserNotice, UserNoticeAction, NoticesResponse, NoticeActionResponse, } from "@sigrun/shared/notices";
 /**
  * One answer to a pending interaction (the ONE generic route's body).
  * U6 Task 2 (ruling 20): `{values}` ONLY — every field's value under
@@ -149,6 +151,12 @@ export declare class SigrunClient {
     getInteraction(id: number, callId: string): Promise<InteractionWire>;
     /** `POST .../interactions/:callId/answer` — the ONE generic answer route. */
     answerInteraction(id: number, callId: string, answer: InteractionAnswerInput): Promise<InteractionAnswered>;
+    /** `POST .../interactions/:callId/decline` — decline a pending
+     *  declinable record (ask-user spec §5.2; settles `skipped` with
+     *  `declinedVia: "button"`). A 404 `not_pending` means the record
+     *  settled under the user's fingers — the caller refetches through
+     *  {@link getInteraction} (the mid-stepper settle path). */
+    declineInteraction(id: number, callId: string): Promise<InteractionDeclined>;
     /** `GET /v1/conversations/:id/ambient`. */
     getAmbient(id: number): Promise<AmbientList>;
     /** `GET /v1/commands` — the slash-command catalog (a boot constant). */
@@ -206,4 +214,12 @@ export declare class SigrunClient {
     listJobRuns(id: string, limit?: number): Promise<JobRunsResponse>;
     /** `GET /v1/jobs/:id/revisions` — the job's revisions, newest first. */
     listJobRevisions(id: string): Promise<JobRevisionsResponse>;
+    /** `GET /v1/notices` — the caller's notices, newest first (notices Task 8). */
+    listNotices(): Promise<NoticesResponse>;
+    /** `POST /v1/notices/:id/dismiss` — 204; a stale id 404s (callers refetch). */
+    dismissNotice(id: string): Promise<void>;
+    /** `POST /v1/notices/dismiss-all` — clear the caller's pile (204). */
+    dismissAllNotices(): Promise<void>;
+    /** `POST /v1/notices/:id/actions/:actionId` — run an extension action. */
+    runNoticeAction(id: string, actionId: string): Promise<NoticeActionResponse>;
 }

package/dist/api.js

@@ -181,6 +181,14 @@ export class SigrunClient {
     answerInteraction(id, callId, answer) {
         return this.#send("POST", `/v1/conversations/${id}/interactions/${encodeURIComponent(callId)}/answer`, answer);
     }
+    /** `POST .../interactions/:callId/decline` — decline a pending
+     *  declinable record (ask-user spec §5.2; settles `skipped` with
+     *  `declinedVia: "button"`). A 404 `not_pending` means the record
+     *  settled under the user's fingers — the caller refetches through
+     *  {@link getInteraction} (the mid-stepper settle path). */
+    declineInteraction(id, callId) {
+        return this.#send("POST", `/v1/conversations/${id}/interactions/${encodeURIComponent(callId)}/decline`, {});
+    }
     /** `GET /v1/conversations/:id/ambient`. */
     getAmbient(id) {
         return this.#get(`/v1/conversations/${id}/ambient`);
@@ -279,4 +287,20 @@ export class SigrunClient {
     listJobRevisions(id) {
         return this.#get(`/v1/jobs/${encodeURIComponent(id)}/revisions`);
     }
+    /** `GET /v1/notices` — the caller's notices, newest first (notices Task 8). */
+    listNotices() {
+        return this.#get("/v1/notices");
+    }
+    /** `POST /v1/notices/:id/dismiss` — 204; a stale id 404s (callers refetch). */
+    dismissNotice(id) {
+        return this.#send("POST", `/v1/notices/${encodeURIComponent(id)}/dismiss`, {});
+    }
+    /** `POST /v1/notices/dismiss-all` — clear the caller's pile (204). */
+    dismissAllNotices() {
+        return this.#send("POST", "/v1/notices/dismiss-all", {});
+    }
+    /** `POST /v1/notices/:id/actions/:actionId` — run an extension action. */
+    runNoticeAction(id, actionId) {
+        return this.#send("POST", `/v1/notices/${encodeURIComponent(id)}/actions/${encodeURIComponent(actionId)}`, {});
+    }
 }

package/dist/blocks/form/form.js

@@ -60,6 +60,21 @@ export function stepperSections(block, interaction) {
         child.type === "choice"));
     return allChoice ? sections : null;
 }
+/** The unanswered REQUIRED choices of the stepper (the review names
+ *  them and holds the submit — §7.2 of the ask-user design). Answered
+ *  means choiceValueText yields text (absent/""/[]/{other: ""} do not
+ *  count). */
+function unansweredSections(sections, ctx, values) {
+    return sections.filter((section) => {
+        for (const field of sectionFields(section)) {
+            if (field.type !== "choice" || field.required !== true)
+                continue;
+            if (choiceValueText(field, ctx, values[field.name] ?? null) === "")
+                return true;
+        }
+        return false;
+    });
+}
 /** The answerable fields of a stepper section (every field the review
  *  summarizes — §9.1's review step covers ALL of a section's fields,
  *  not only the choice). */
@@ -310,6 +325,9 @@ export class FormComponent {
                 const summary = answers.filter((text) => text !== "").join(", ");
                 lines.push(truncate(`  ${title}: ${summary}`, width));
             });
+            for (const section of unansweredSections(sections, this.#ctx, this.#values)) {
+                lines.push(truncate(`Not answered yet: ${bindText(section.title, this.#ctx)}`, width));
+            }
             if (!this.#readOnly && !this.#submitted) {
                 lines.push(truncate(`> [ ${this.#submitLabel} ]`, width));
             }
@@ -435,6 +453,10 @@ export class FormComponent {
                 return;
             }
             if (data === "\r" && !this.#submitted) {
+                // The review holds the submit while a required question is
+                // unanswered (§7.2) — Enter is ignored, not an error.
+                if (unansweredSections(sections, this.#ctx, this.#values).length > 0)
+                    return;
                 if (this.#submit())
                     this.#submitted = true;
             }

package/dist/keymaps/emacs.js

@@ -32,8 +32,11 @@ const BINDINGS = [
     { keys: "C-n / C-p", action: "move down / up" },
     { keys: "enter", action: "open / fold" },
     { keys: "C-o", action: "answer interaction" },
+    { keys: "M-s", action: "decline interaction (answer mode)" },
     { keys: "C-l", action: "redraw" },
     { keys: "C-h", action: "key reference" },
+    { keys: "M-N", action: "notices" },
+    { keys: "M-d", action: "dismiss newest notice" },
     { keys: "M-m", action: "pick up (block surface)" },
     { keys: "enter", action: "drop (block surface)" },
     { keys: "C-g", action: "cancel move (block surface)" },
@@ -145,10 +148,21 @@ export function createEmacsKeymap() {
                 return { type: "prompt-jump", delta: 1 };
             if (data === "\x0f")
                 return { type: "answer-interaction" };
+            // Ask-user Task 5: M-s declines the armed interaction (M-d stays
+            // the notices dismiss; the app gates decline to answer mode).
+            if (data === "\x1bs")
+                return { type: "decline-interaction" };
             if (data === "\x0c")
                 return { type: "redraw" };
             if (data === "\x08")
                 return { type: "help" };
+            // Notices Task 8: M-N / M-d are the notice surface in every
+            // focus — the emacs dismiss keys are upper/lower meta-letters
+            // readline never sends (C-g stays the cancel key).
+            if (data === "\x1bN")
+                return { type: "notices.open" };
+            if (data === "\x1bd")
+                return { type: "notices.dismissNewest" };
             if (ctx.focus === "composer")
                 return "pass";
             // Outside the composer: the transcript/list actions.

package/dist/keymaps/standard.js

@@ -21,6 +21,9 @@ const BINDINGS = [
     { keys: "ctrl+n", action: "new conversation" },
     { keys: "ctrl+t", action: "cycle thinking" },
     { keys: "ctrl+o", action: "answer interaction" },
+    { keys: "alt+s", action: "decline interaction (answer mode)" },
+    { keys: "ctrl+g", action: "notices" },
+    { keys: "alt+d", action: "dismiss newest notice" },
     { keys: "ctrl+l", action: "redraw" },
     { keys: "ctrl+c", action: "quit" },
     { keys: "tab / shift+tab", action: "cycle focus" },
@@ -58,6 +61,18 @@ export function createStandardKeymap() {
             return { type: "cycle-thinking" };
         if (matchesKey(data, Key.ctrl("o")))
             return { type: "answer-interaction" };
+        // Ask-user Task 5: alt+s declines the armed interaction (answer
+        // mode only — the app gates the action; outside answer mode this
+        // falls through as a no-op). alt+d stays the notices dismiss.
+        if (matchesKey(data, Key.alt("s")))
+            return { type: "decline-interaction" };
+        // Notices Task 8: ctrl+g (the notices overlay — a control code,
+        // never typed text) and alt+d (dismiss the inline notice; M-d is
+        // readline's kill-word, a chord reserved readline never sends).
+        if (matchesKey(data, Key.ctrl("g")))
+            return { type: "notices.open" };
+        if (data === "\x1bd")
+            return { type: "notices.dismissNewest" };
         if (matchesKey(data, Key.ctrl("l")))
             return { type: "redraw" };
         if (matchesKey(data, Key.ctrl("c")))

package/dist/keymaps/vim.js

@@ -47,9 +47,12 @@ const BINDINGS = [
     { keys: ":", action: "command line" },
     { keys: "ctrl+p", action: "conversation picker" },
     { keys: "ctrl+o", action: "answer interaction" },
+    { keys: "alt+s", action: "decline interaction (answer mode)" },
     { keys: "ctrl+l", action: "redraw" },
     { keys: "ctrl+c", action: "abort run (busy)" },
     { keys: "g?", action: "key reference" },
+    { keys: "gN", action: "notices" },
+    { keys: "gx", action: "dismiss newest notice" },
     { keys: "ZZ / :q", action: "quit" },
     { keys: "m", action: "pick up (block surface)" },
     { keys: "enter", action: "drop (block surface)" },
@@ -95,6 +98,13 @@ export function createVimKeymap(options) {
                 // g? is vim normal's help key — "?" stays search-backward.
                 if (prefix.key === "g" && data === "?")
                     return { type: "help" };
+                // Notices Task 8: gN / gx are the notice surface (vim's own
+                // gx open-under-cursor doesn't exist here — the TUI has no
+                // browser; the notice dismiss claims the key).
+                if (prefix.key === "g" && data === "N")
+                    return { type: "notices.open" };
+                if (prefix.key === "g" && data === "x")
+                    return { type: "notices.dismissNewest" };
                 if (prefix.key === "Z" && data === "Z")
                     return { type: "quit" };
                 if (prefix.key === "z" && data === "a")
@@ -123,6 +133,10 @@ export function createVimKeymap(options) {
         }
         if (matchesKey(data, Key.ctrl("o")))
             return { type: "answer-interaction" };
+        // Ask-user Task 5: alt+s declines the armed interaction (the app
+        // gates the action to answer mode + a declinable record).
+        if (matchesKey(data, Key.alt("s")))
+            return { type: "decline-interaction" };
         return "pass";
     };
     /** Block-surface keys (spec §12.4): NORMAL mode over a `surface`

package/dist/launch.js

@@ -220,6 +220,7 @@ export async function launchTuiShell(options) {
         { component: body, grow: 1 },
         { component: app.interactions, basis: "auto" },
         { component: app.ambient, basis: "auto" },
+        { component: app.notices, basis: "auto" },
         { component: app.editor, basis: "auto" },
         { component: statusBar, basis: 1 },
     ]);
@@ -248,6 +249,10 @@ export async function launchTuiShell(options) {
             else if (event.type === "ambient.changed") {
                 app.ambient.kick(event.conversationId);
             }
+            else if (event.type === "notice.changed") {
+                // Notices Task 8: the user-only notice feed refetches the pile.
+                app.notices.kick();
+            }
             else if (event.type === "surface.changed") {
                 // U3 Task 5: fan the EXT surface event out to the open view's
                 // transport (the hub matches slug+id+k). The CHAT shape (U5
@@ -267,7 +272,12 @@ export async function launchTuiShell(options) {
         // entry's stream — open ext-view transports send it as
         // X-Sigrun-Stream. A reconnect's new id re-registers on the
         // next fetch.
-        onHello: (streamId) => app.setEventsStreamId(streamId),
+        onHello: (streamId) => {
+            app.setEventsStreamId(streamId);
+            // Notices Task 8: a reconnect heals the pile (the hello
+            // refetch — same posture as the webui's refetch token).
+            app.notices.kick();
+        },
     }, {
         baseUrl: options.baseUrl,
         ...(options.user === undefined ? {} : { user: options.user }),

package/dist/ui/ambient.d.ts

@@ -35,12 +35,25 @@
  * has a live run ({@link setBusy}, driven by the stream's `steer.busy`).
  */
 import type { Component } from "@earendil-works/pi-tui";
+import type { Action as BlockAction, CoreTarget } from "@sigrun/shared/blocks";
 import type { AmbientWire, SigrunClient } from "../api.js";
 import { type TuiTheme } from "../theme.js";
 export declare class AmbientChrome implements Component {
     #private;
     /** Rendered-state changes (the app requests a repaint). */
     onChanged?: () => void;
+    /** A `navigate` action's core target (the app routes it — notices
+     *  Task 8: ambient navigate actions route like notice actions). */
+    onNavigate?: (target: CoreTarget) => void;
+    /** An `open` action's URL (the app prints it — the TUI has no browser). */
+    onOpenUrl?: (url: string) => void;
+    /**
+     * Route an ambient block action (notices Task 8): `navigate` and
+     * `open` are client-side actions the read-only render context cannot
+     * answer, so the app dispatches them here. Every other action is a
+     * no-op (ambient surfaces are read-only).
+     */
+    dispatchAmbientAction(action: BlockAction): void;
     constructor(client: SigrunClient, options?: {
         theme?: TuiTheme;
     });

package/dist/ui/ambient.js

@@ -66,6 +66,28 @@ export class AmbientChrome {
     #busy = false;
     /** Rendered-state changes (the app requests a repaint). */
     onChanged;
+    /** A `navigate` action's core target (the app routes it — notices
+     *  Task 8: ambient navigate actions route like notice actions). */
+    onNavigate;
+    /** An `open` action's URL (the app prints it — the TUI has no browser). */
+    onOpenUrl;
+    /**
+     * Route an ambient block action (notices Task 8): `navigate` and
+     * `open` are client-side actions the read-only render context cannot
+     * answer, so the app dispatches them here. Every other action is a
+     * no-op (ambient surfaces are read-only).
+     */
+    dispatchAmbientAction(action) {
+        if (action.type === "navigate") {
+            if (action.target !== undefined)
+                this.onNavigate?.(action.target);
+            return;
+        }
+        if (action.type === "open") {
+            this.onOpenUrl?.(action.url);
+            return;
+        }
+    }
     constructor(client, options = {}) {
         this.#client = client;
         this.#theme = options.theme ?? plainTuiTheme();

package/dist/ui/app.d.ts

@@ -48,11 +48,12 @@
  */
 import { Editor, type Component, type TUI } from "@earendil-works/pi-tui";
 import type { SigrunClient } from "../api.js";
-import type { JsonObject } from "@sigrun/shared/blocks";
+import type { CoreTarget, JsonObject } from "@sigrun/shared/blocks";
 import { type Unwatch, type WatchHandlers, type WatchOptions } from "../sse.js";
 import { type TuiTheme } from "../theme.js";
 import type { Action, ActionHost, Focus } from "../actions.js";
 import { AmbientChrome } from "./ambient.js";
+import { NoticeChrome } from "./notices.js";
 import { ConversationPane } from "./conversation-pane.js";
 import { InteractionPrompter } from "./interactions.js";
 import { SettingsView } from "./settings.js";
@@ -126,6 +127,8 @@ export declare class TuiApp implements Component, ActionHost {
     readonly interactions: InteractionPrompter;
     /** The ambient seam's chrome zones (Task 8; zero height when empty). */
     readonly ambient: AmbientChrome;
+    /** The user-notice surface (notices Task 8; zero height when empty). */
+    readonly notices: NoticeChrome;
     /** The main column's slot: renders the conversation pane normally,
      *  the open settings view while one is up (U4 Task 4 round-2 — the
      *  settings view renders IN the body slot; the launcher's root
@@ -197,6 +200,11 @@ export declare class TuiApp implements Component, ActionHost {
     get overlayOpen(): boolean;
     /** The last frame's `steer.busy` (the keymap's abort gate). */
     get busy(): boolean;
+    /** Route a core navigation target (notices Task 8): a notice or
+     *  ambient action's `navigate` — conversations select, settings
+     *  opens the view, views open the ext surface, jobs flash (the TUI
+     *  has no job page). Failures land as pane errors. */
+    navigateCoreTarget(target: CoreTarget): Promise<void>;
     /**
      * The launcher's sink: the status bar it mounted (flashes, help, and
      * the search overlay render through it). `set` also snapshots the

package/dist/ui/app.js

@@ -57,6 +57,7 @@ import { editInVim, resolveVimEditor } from "../editor-launch.js";
 import { copyToTerminal } from "../clipboard.js";
 import { commandInsertText, describeCommandError, isSkillCommandName, parseSlashInput, SlashCatalog, } from "./composer.js";
 import { AmbientChrome } from "./ambient.js";
+import { NoticeChrome } from "./notices.js";
 import { ConversationPane } from "./conversation-pane.js";
 import { InteractionPrompter } from "./interactions.js";
 import { SettingsView } from "./settings.js";
@@ -152,6 +153,8 @@ export class TuiApp {
     interactions;
     /** The ambient seam's chrome zones (Task 8; zero height when empty). */
     ambient;
+    /** The user-notice surface (notices Task 8; zero height when empty). */
+    notices;
     #body = new HStack();
     #layout = new VStack();
     /** The main column's slot: renders the conversation pane normally,
@@ -225,6 +228,7 @@ export class TuiApp {
         this.editor = new Editor(options.tui, plainEditorTheme());
         this.interactions = new InteractionPrompter(client, theme === undefined ? undefined : { theme });
         this.ambient = new AmbientChrome(client, theme === undefined ? undefined : { theme });
+        this.notices = new NoticeChrome(client, theme === undefined ? undefined : { theme });
         this.#body.addChild(this.sidebar, {
             basis: options.sidebarWidth ?? 24,
             shrink: 1,
@@ -239,12 +243,26 @@ export class TuiApp {
         this.#layout.addChild(this.#body, { basis: "auto" });
         this.#layout.addChild(this.interactions, { basis: "auto" });
         this.#layout.addChild(this.ambient, { basis: "auto" });
+        this.#layout.addChild(this.notices, { basis: "auto" });
         // Seam state changes repaint; answer failures are user-initiated,
         // so they land as pane error lines (background polls fail quiet).
         const repaint = () => options.tui.requestRender();
         this.interactions.onChanged = repaint;
         this.ambient.onChanged = repaint;
         this.interactions.onError = (message) => this.pane.showError(message);
+        // Notices Task 8: list changes repaint AND update the status-bar
+        // count; action results print as pane notices; `open` prints the
+        // URL (the TUI has no browser); navigate routes through the app's
+        // core-target router (shared with ambient actions).
+        this.notices.onChanged = () => {
+            this.#paintNoticeCount();
+            repaint();
+        };
+        this.notices.onResult = (text) => this.pane.showNotice(text);
+        this.notices.onOpenUrl = (url) => this.pane.showNotice(url);
+        this.notices.onNavigate = (target) => void this.navigateCoreTarget(target);
+        this.ambient.onNavigate = (target) => void this.navigateCoreTarget(target);
+        this.ambient.onOpenUrl = (url) => this.pane.showNotice(url);
         this.sidebar.onSelect = (selection) => {
             if (selection === "new") {
                 void this.createAndSelect();
@@ -396,6 +414,37 @@ export class TuiApp {
     get busy() {
         return this.#busy;
     }
+    /** Route a core navigation target (notices Task 8): a notice or
+     *  ambient action's `navigate` — conversations select, settings
+     *  opens the view, views open the ext surface, jobs flash (the TUI
+     *  has no job page). Failures land as pane errors. */
+    async navigateCoreTarget(target) {
+        try {
+            if ("conversation" in target) {
+                await this.selectConversation(target.conversation);
+            }
+            else if ("settings" in target) {
+                await this.openSettings();
+            }
+            else if ("view" in target) {
+                await this.openExtView(target.view.extension, target.view.id, target.view.params);
+            }
+            else if ("job" in target) {
+                this.pane.showNotice(`job: ${target.job}`);
+            }
+        }
+        catch (error) {
+            this.pane.showError(describeCommandError("navigate", error));
+        }
+    }
+    /** Feed the notice count to the status bar's `notices:N` segment,
+     *  merged into the steady snapshot (a flash preserves it). */
+    #paintNoticeCount() {
+        const base = this.#statusSnapshot;
+        if (this.#statusBar === undefined || base === undefined)
+            return;
+        this.#statusBar.set({ ...base, notices: this.notices.notices.length });
+    }
     /**
      * The launcher's sink: the status bar it mounted (flashes, help, and
      * the search overlay render through it). `set` also snapshots the
@@ -466,6 +515,9 @@ export class TuiApp {
      */
     async refresh() {
         await this.sidebar.refresh();
+        // Notices Task 8: the count rides the boot refresh too (quiet —
+        // the chrome keeps its last list on a fetch failure).
+        void this.notices.refresh().catch(() => { });
         if (this.#activeId === undefined) {
             const first = this.sidebar.rows[0];
             if (first !== undefined) {
@@ -547,6 +599,7 @@ export class TuiApp {
             }, this.#watchOptions);
             this.interactions.setConversation(id);
             this.ambient.setConversation(id);
+            this.notices.setConversation(id);
         }
         finally {
             this.editor.disableSubmit = false;
@@ -1096,6 +1149,10 @@ export class TuiApp {
                 if (!this.interactions.answerMode)
                     this.interactions.beginAnswer();
                 return;
+            case "decline-interaction":
+                // Gated inside: answer mode + a declinable record only.
+                await this.interactions.decline();
+                return;
             case "cancel-run":
                 this.#abortActive();
                 return;
@@ -1109,6 +1166,20 @@ export class TuiApp {
             case "help":
                 this.#openHelp();
                 return;
+            case "notices.open": {
+                if (this.#overlayOpen)
+                    return;
+                this.#overlayOpen = true;
+                this.notices.openOverlay(this.#tui, {
+                    onClose: () => {
+                        this.#overlayOpen = false;
+                    },
+                });
+                return;
+            }
+            case "notices.dismissNewest":
+                await this.notices.dismissNewest();
+                return;
             case "command-line":
                 this.editor.setText("/");
                 return;

package/dist/ui/interactions.d.ts

@@ -79,6 +79,18 @@ export declare class InteractionPrompter implements Component {
      * keep typing while a prompt waits).
      */
     handleKey(data: string): boolean;
+    /**
+     * Decline the armed interaction (ask-user spec §5.2 — the keymap's
+     *  `decline-interaction` action routes here). Gated exactly like the
+     *  affordance: answer mode armed on the top record, and the record is
+     *  declinable. Success exits answer mode (the list poll drops the
+     *  settled record). A 404 `not_pending` — the record settled under
+     *  the user's fingers — refetches through
+     *  {@link SigrunClient.getInteraction} and swaps the settled envelope
+     *  in read-only (the mid-edit settle path); any other failure reports
+     *  loud and keeps the card writable.
+     */
+    decline(): Promise<void>;
     /** Detach (the app calls this on dispose): stale fetches never land. */
     dispose(): void;
     /**

package/dist/ui/interactions.js

@@ -174,6 +174,13 @@ export class InteractionPrompter {
             this.#changed();
             return true;
         }
+        // The decline chord is the KEYMAP's (decline-interaction action,
+        // dispatched by the launcher): pass it through so the keymap sees
+        // it — the surface fall-through below would swallow it and the
+        // chord would never fire (review fix; the same ownership rule as
+        // the prompt's other action keys).
+        if (matchesKey(data, Key.alt("s")))
+            return false;
         this.#ensureSurface(top);
         if (this.#surface === undefined) {
             this.#exitAnswer();
@@ -332,6 +339,67 @@ export class InteractionPrompter {
         this.#answerMode = false;
         this.#answerCallId = undefined;
     }
+    /**
+     * Decline the armed interaction (ask-user spec §5.2 — the keymap's
+     *  `decline-interaction` action routes here). Gated exactly like the
+     *  affordance: answer mode armed on the top record, and the record is
+     *  declinable. Success exits answer mode (the list poll drops the
+     *  settled record). A 404 `not_pending` — the record settled under
+     *  the user's fingers — refetches through
+     *  {@link SigrunClient.getInteraction} and swaps the settled envelope
+     *  in read-only (the mid-edit settle path); any other failure reports
+     *  loud and keeps the card writable.
+     */
+    async decline() {
+        const top = this.#pending[0];
+        if (!this.#answerMode || top === undefined)
+            return;
+        if (this.#answerCallId !== top.callId)
+            return;
+        if (top.declinable !== true)
+            return;
+        const id = this.#conversationId;
+        if (id === undefined)
+            return;
+        try {
+            await this.#client.declineInteraction(id, top.callId);
+        }
+        catch (cause) {
+            const isNotPending = typeof cause === "object" &&
+                cause !== null &&
+                cause.status === 404;
+            if (!isNotPending) {
+                this.onError?.(describeCommandError("decline", cause));
+                this.#changed();
+                return;
+            }
+            // 404 not_pending: the settle raced the user. Refetch; a still-
+            // pending record must NOT wedge the card read-only.
+            try {
+                const fresh = await this.#client.getInteraction(id, top.callId);
+                if (this.#surface?.record.callId !== top.callId)
+                    return;
+                if (fresh.status === "pending") {
+                    this.onError?.(describeCommandError("decline", cause));
+                    this.#changed();
+                    return;
+                }
+                this.#surface =
+                    this.#surface === undefined
+                        ? undefined
+                        : { ...this.#surface, settled: fresh, access: "read" };
+                this.#surface?.state.setAccess("read");
+            }
+            catch {
+                this.onError?.(describeCommandError("decline", cause));
+                this.#changed();
+                return;
+            }
+        }
+        this.#exitAnswer();
+        void this.#refresh();
+        this.#changed();
+    }
     /** Generation-guarded, coalesced fetch of the pending list. */
     async #refresh() {
         const id = this.#conversationId;
@@ -408,11 +476,18 @@ export class InteractionPrompter {
             return [];
         const lines = [];
         const shown = this.#surface?.settled ?? top;
+        // Settled declines name their outcome (spec §5.2's "declined" /
+        // "declined — replied in chat"), never the raw 'skipped'.
+        const statusText = shown.status === "skipped" && shown.declinedVia !== undefined
+            ? shown.declinedVia === "message"
+                ? "declined — replied in chat"
+                : "declined"
+            : shown.status;
         const suffix = this.#answerMode
             ? " — answering"
             : shown.status === "pending"
                 ? ""
-                : ` — ${shown.status}`;
+                : ` — ${statusText}`;
         lines.push(`[interaction] ${shown.kind}${suffix}`);
         if (top.body !== undefined) {
             this.#ensureSurface(top);
@@ -428,7 +503,9 @@ export class InteractionPrompter {
         }
         if (top.body !== undefined) {
             lines.push(this.#answerMode
-                ? "1-9 answer · Tab next · esc cancel"
+                ? top.declinable === true
+                    ? "1-9 answer · alt+s decline · Tab next · esc cancel"
+                    : "1-9 answer · Tab next · esc cancel"
                 : "ctrl+o to answer");
         }
         return lines;

package/dist/ui/notices.d.ts

@@ -0,0 +1,77 @@
+/**
+ * The user notices surface (notices Task 8): the per-user notice list in
+ * the TUI — an inline line between the ambient chrome and the composer,
+ * and a centred overlay with the full pile.
+ *
+ * - The INLINE LINE shows the current conversation's newest notice
+ *   (a notice carrying this conversationId), falling back to the newest
+ *   app-wide notice (no conversationId). Zero height when empty.
+ * - The OVERLAY lists every notice as a plain-text card: tone marker,
+ *   title, body, buttons, age (no emoji — the TUI avoids double-width
+ *   glyphs). Arrows move over the action rows, Enter runs the selected
+ *   action, `d` dismisses its notice, Esc/q/C-g closes.
+ *
+ * Action semantics mirror the webui's `useNotices.run`: `navigate`
+ * routes through {@link NoticeChrome.onNavigate} then dismisses, `open`
+ * prints the URL through {@link NoticeChrome.onOpenUrl} (the TUI cannot
+ * open a browser — the URL is the hand-off) then dismisses, and
+ * `extension` POSTs the action route and surfaces the response's
+ * `message`/`error` through {@link NoticeChrome.onResult}.
+ *
+ * Freshness (W3 Task 4's idiom): the app kicks on `notice.changed`
+ * host events and on the events-stream hello (a reconnect heals the
+ * list). Fetch failures are QUIET (best-effort chrome).
+ */
+import { type Component, type TUI } from "@earendil-works/pi-tui";
+import type { CoreTarget } from "@sigrun/shared/blocks";
+import type { SigrunClient, UserNotice, UserNoticeAction } from "../api.js";
+import { type TuiTheme } from "../theme.js";
+/** A compact relative age ("2 min", "1 h", "just now"). */
+export declare function relativeAge(at: string, now?: number): string;
+export interface NoticeOverlayOptions {
+    /** Fires on close so the app can clear its overlayOpen flag. */
+    readonly onClose?: () => void;
+}
+export declare class NoticeChrome implements Component {
+    #private;
+    /** Rendered-state changes (the app repaints + repaints the count). */
+    onChanged?: () => void;
+    /** An action result's text (the app shows it as a pane notice). */
+    onResult?: (text: string) => void;
+    /** An `open` action's URL (the app prints it — the TUI has no browser). */
+    onOpenUrl?: (url: string) => void;
+    /** A `navigate` action's core target (the app routes it). */
+    onNavigate?: (target: CoreTarget) => void;
+    constructor(client: SigrunClient, options?: {
+        theme?: TuiTheme;
+    });
+    /** The latest served notices (newest first). */
+    get notices(): readonly UserNotice[];
+    /**
+     * The inline line's notice: the newest notice scoped to the current
+     * conversation, else the newest app-wide notice, else undefined.
+     */
+    inlineNotice(): UserNotice | undefined;
+    /** The current conversation (the inline line's scope). */
+    setConversation(id: number | undefined): void;
+    /** Refetch (`notice.changed`, a reconnect hello). Quiet on failure. */
+    kick(): void;
+    /** The list GET (quiet: a failed fetch keeps the last list). */
+    refresh(): Promise<void>;
+    /** Dismiss one notice (204); the list refetches after the write. */
+    dismiss(id: string): Promise<void>;
+    /** Dismiss the inline line's notice (the dismiss key). */
+    dismissNewest(): Promise<void>;
+    /**
+     * Run one notice action (the webui's `useNotices.run` semantics):
+     * `navigate` routes then dismisses; `open` prints the URL then
+     * dismisses; `extension` POSTs the action route, surfaces the
+     * result text, and refetches (a server-side clear is then visible).
+     */
+    run(notice: UserNotice, action: UserNoticeAction): Promise<void>;
+    /** Open the centred overlay (Enter runs, d dismisses, Esc closes). */
+    openOverlay(tui: TUI, options?: NoticeOverlayOptions): void;
+    /** The inline line: one row, or zero height without an inline notice. */
+    render(width: number): string[];
+    invalidate(): void;
+}

package/dist/ui/notices.js

@@ -0,0 +1,290 @@
+/**
+ * The user notices surface (notices Task 8): the per-user notice list in
+ * the TUI — an inline line between the ambient chrome and the composer,
+ * and a centred overlay with the full pile.
+ *
+ * - The INLINE LINE shows the current conversation's newest notice
+ *   (a notice carrying this conversationId), falling back to the newest
+ *   app-wide notice (no conversationId). Zero height when empty.
+ * - The OVERLAY lists every notice as a plain-text card: tone marker,
+ *   title, body, buttons, age (no emoji — the TUI avoids double-width
+ *   glyphs). Arrows move over the action rows, Enter runs the selected
+ *   action, `d` dismisses its notice, Esc/q/C-g closes.
+ *
+ * Action semantics mirror the webui's `useNotices.run`: `navigate`
+ * routes through {@link NoticeChrome.onNavigate} then dismisses, `open`
+ * prints the URL through {@link NoticeChrome.onOpenUrl} (the TUI cannot
+ * open a browser — the URL is the hand-off) then dismisses, and
+ * `extension` POSTs the action route and surfaces the response's
+ * `message`/`error` through {@link NoticeChrome.onResult}.
+ *
+ * Freshness (W3 Task 4's idiom): the app kicks on `notice.changed`
+ * host events and on the events-stream hello (a reconnect heals the
+ * list). Fetch failures are QUIET (best-effort chrome).
+ */
+import { Key, matchesKey } from "@earendil-works/pi-tui";
+import { truncate } from "../blocks/width.js";
+import { plainTuiTheme } from "../theme.js";
+/** A compact relative age ("2 min", "1 h", "just now"). */
+export function relativeAge(at, now = Date.now()) {
+    const then = Date.parse(at);
+    if (Number.isNaN(then))
+        return "";
+    const seconds = Math.max(0, Math.floor((now - then) / 1000));
+    if (seconds < 45)
+        return "just now";
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes} min`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 48)
+        return `${hours} h`;
+    return `${Math.floor(hours / 24)} d`;
+}
+/** The plain-text tone marker (ASCII only — no double-width glyphs). */
+function toneMark(tone) {
+    switch (tone) {
+        case "bad":
+            return "[!]";
+        case "warn":
+            return "[?]";
+        case "good":
+            return "[+]";
+        case "info":
+            return "[i]";
+        case "accent":
+            return "[*]";
+        default:
+            return "[-]";
+    }
+}
+/** The overlay component (mounted through `tui.showOverlay`). */
+class NoticesOverlay {
+    #chrome;
+    #options;
+    #overlay;
+    /** The selected row index into {@link rows}. */
+    #index = 0;
+    constructor(chrome, options) {
+        this.#chrome = chrome;
+        this.#options = options;
+    }
+    setOverlay(overlay) {
+        this.#overlay = overlay;
+    }
+    /** The flattened action rows (the chrome's list, newest first). */
+    get rows() {
+        const rows = [];
+        for (const notice of this.#chrome.notices) {
+            const actions = notice.actions ?? [];
+            if (actions.length === 0) {
+                rows.push({ notice, action: undefined });
+            }
+            else {
+                for (const action of actions)
+                    rows.push({ notice, action });
+            }
+        }
+        return rows;
+    }
+    #close() {
+        this.#overlay?.hide();
+        this.#options.onClose?.();
+    }
+    #runSelected() {
+        const row = this.rows[this.#index];
+        if (row === undefined || row.action === undefined)
+            return;
+        void this.#chrome.run(row.notice, row.action);
+    }
+    #dismissSelected() {
+        const row = this.rows[this.#index];
+        if (row === undefined)
+            return;
+        void this.#chrome.dismiss(row.notice.id);
+        if (this.#index > 0)
+            this.#index -= 1;
+    }
+    handleInput(data) {
+        if (matchesKey(data, Key.escape) || data === "q" || data === "\x07") {
+            this.#close();
+            return;
+        }
+        if (matchesKey(data, Key.up) || matchesKey(data, "up")) {
+            this.#index = Math.max(0, this.#index - 1);
+            return;
+        }
+        if (matchesKey(data, Key.down) || matchesKey(data, "down")) {
+            this.#index = Math.min(this.rows.length - 1, this.#index + 1);
+            return;
+        }
+        if (matchesKey(data, Key.enter) || data === "\r") {
+            this.#runSelected();
+            return;
+        }
+        if (data === "d") {
+            this.#dismissSelected();
+            return;
+        }
+        // Every other key is consumed: the overlay is modal.
+    }
+    render(width) {
+        const lines = [];
+        const rows = this.rows;
+        let rowIndex = 0;
+        lines.push(`notices (${rows.length}) — enter run · d dismiss · esc close`);
+        for (const notice of this.#chrome.notices) {
+            const age = relativeAge(notice.at);
+            lines.push(`${toneMark(notice.tone)} ${notice.title}${age === "" ? "" : ` · ${age}`}`);
+            if (notice.body !== undefined && notice.body !== "") {
+                lines.push(`  ${notice.body}`);
+            }
+            const actions = notice.actions ?? [];
+            if (actions.length === 0) {
+                lines.push(`${rowIndex === this.#index ? "> " : "  "}(dismiss)`);
+                rowIndex += 1;
+            }
+            else {
+                for (const action of actions) {
+                    lines.push(`${rowIndex === this.#index ? "> " : "  "}${action.label}`);
+                    rowIndex += 1;
+                }
+            }
+        }
+        if (this.#chrome.notices.length === 0)
+            lines.push("no notices");
+        return lines.map((line) => truncate(line, width));
+    }
+    invalidate() { }
+}
+export class NoticeChrome {
+    #client;
+    #theme;
+    #notices = [];
+    #conversationId;
+    /** Monotonic fetch generation: a stale fetch never lands. */
+    #gen = 0;
+    /** Rendered-state changes (the app repaints + repaints the count). */
+    onChanged;
+    /** An action result's text (the app shows it as a pane notice). */
+    onResult;
+    /** An `open` action's URL (the app prints it — the TUI has no browser). */
+    onOpenUrl;
+    /** A `navigate` action's core target (the app routes it). */
+    onNavigate;
+    constructor(client, options = {}) {
+        this.#client = client;
+        this.#theme = options.theme ?? plainTuiTheme();
+    }
+    /** The latest served notices (newest first). */
+    get notices() {
+        return this.#notices;
+    }
+    /**
+     * The inline line's notice: the newest notice scoped to the current
+     * conversation, else the newest app-wide notice, else undefined.
+     */
+    inlineNotice() {
+        const scoped = this.#notices.find((one) => one.conversationId !== undefined && one.conversationId === this.#conversationId);
+        if (scoped !== undefined)
+            return scoped;
+        return this.#notices.find((one) => one.conversationId === undefined);
+    }
+    /** The current conversation (the inline line's scope). */
+    setConversation(id) {
+        if (id === this.#conversationId)
+            return;
+        this.#conversationId = id;
+        this.#changed();
+    }
+    /** Refetch (`notice.changed`, a reconnect hello). Quiet on failure. */
+    kick() {
+        void this.refresh();
+    }
+    /** The list GET (quiet: a failed fetch keeps the last list). */
+    async refresh() {
+        const gen = ++this.#gen;
+        let list;
+        try {
+            list = await this.#client.listNotices();
+        }
+        catch {
+            return; // quiet: keep the last pile
+        }
+        if (gen !== this.#gen)
+            return; // stale
+        this.#notices = list.notices;
+        this.#changed();
+    }
+    /** Dismiss one notice (204); the list refetches after the write. */
+    async dismiss(id) {
+        await this.#client.dismissNotice(id).catch(() => undefined);
+        await this.refresh();
+    }
+    /** Dismiss the inline line's notice (the dismiss key). */
+    async dismissNewest() {
+        const newest = this.inlineNotice();
+        if (newest === undefined)
+            return;
+        await this.dismiss(newest.id);
+    }
+    /**
+     * Run one notice action (the webui's `useNotices.run` semantics):
+     * `navigate` routes then dismisses; `open` prints the URL then
+     * dismisses; `extension` POSTs the action route, surfaces the
+     * result text, and refetches (a server-side clear is then visible).
+     */
+    async run(notice, action) {
+        if (action.kind === "navigate") {
+            this.onNavigate?.(action.target);
+            await this.dismiss(notice.id);
+            return;
+        }
+        if (action.kind === "open") {
+            this.onOpenUrl?.(action.url);
+            await this.dismiss(notice.id);
+            return;
+        }
+        try {
+            const response = await this.#client.runNoticeAction(notice.id, action.id);
+            if (response.ok && response.navigate !== undefined) {
+                this.onNavigate?.(response.navigate);
+            }
+            const text = response.ok ? response.message : response.error.message;
+            if (text !== undefined)
+                this.onResult?.(text);
+        }
+        catch (cause) {
+            // A rejected POST (404 stale card, 409 unavailable, network) is a
+            // user-facing outcome: the notice stays on the server; the pile
+            // heals to the truth on the refetch below.
+            this.onResult?.(cause instanceof Error ? cause.message : String(cause));
+        }
+        await this.refresh();
+    }
+    /** Open the centred overlay (Enter runs, d dismisses, Esc closes). */
+    openOverlay(tui, options = {}) {
+        const overlay = new NoticesOverlay(this, options);
+        const handle = tui.showOverlay(overlay, {
+            anchor: "center",
+            width: "60%",
+            maxHeight: "60%",
+        });
+        overlay.setOverlay(handle);
+    }
+    #changed() {
+        this.onChanged?.();
+    }
+    /** The inline line: one row, or zero height without an inline notice. */
+    render(width) {
+        const newest = this.inlineNotice();
+        if (newest === undefined)
+            return [];
+        const age = relativeAge(newest.at);
+        const line = `${toneMark(newest.tone)} ${newest.title}${age === "" ? "" : ` · ${age}`}`;
+        return [truncate(this.#theme.fg("muted")(line), width)];
+    }
+    invalidate() {
+        // Stateless render: the line assembles from the current list.
+    }
+}

package/dist/ui/status-bar.d.ts

@@ -27,6 +27,8 @@ export interface StatusBarState {
     readonly thinking?: string;
     /** 0-100; absent → no ctx segment. */
     readonly contextPct?: number;
+    /** The caller's notice count (notices Task 8); absent → no segment. */
+    readonly notices?: number;
     readonly hints: readonly string[];
     /** Transient notice; replaces the hints for 4 s. */
     readonly message?: string;

package/dist/ui/status-bar.js

@@ -28,6 +28,8 @@ function rightCluster(state) {
         parts.push(state.thinking);
     if (state.contextPct !== undefined)
         parts.push(`ctx ${Math.round(state.contextPct)}%`);
+    if (state.notices !== undefined && state.notices > 0)
+        parts.push(`notices:${state.notices}`);
     const head = parts.join(SEPARATOR);
     const tail = state.commandLine ?? state.message ?? state.hints.join(" ");
     return tail === "" ? head : `${head}${SEPARATOR}${tail}`;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sigrun/tui",
-	"version": "0.7.0",
+	"version": "0.9.0",
 	"description": "sigrun terminal client (pi-tui based) over the \u00a75 API \u2014 spawned by the sigrun CLI, or standalone against a server URL",
 	"type": "module",
 	"bin": {
@@ -21,7 +21,7 @@
 	},
 	"dependencies": {
 		"@earendil-works/pi-tui": "^1.3.0",
-		"@sigrun/shared": "0.7.0"
+		"@sigrun/shared": "0.9.0"
 	},
 	"devDependencies": {
 		"typescript": "^7.0.2",