arcane-os 0.37.0 → 0.39.0

package/docs/reference/runtime-components.md

@@ -82,7 +82,7 @@ appropriate.
 | [`modal.html`](#modalhtml) | Generic modal with population, configurable user dismissal, actions, and concurrent task execution. | `configure()`<br>`populate()`<br>`open()`<br>`close()`<br>`runTasks()`<br>`destroy()`<br>`running`<br>`opened` | `modal-ready`<br>`modal-opened`<br>`modal-closed`<br>`modal-action` | Modal state normalized; injected task results mixed |
 | [`output-panel.html`](#output-panelhtml) | Presents status, output, body, coverage, actions, pending, error, and cleared states. | `configure()`<br>`setOutput()`<br>`setBody()`<br>`setCoverage()`<br>`setActions()`<br>`setPending()`<br>`setStatus()`<br>`setError()`<br>`clear()`<br>`destroy()` | `output-panel-ready`<br>`output-panel-state`<br>`output-panel-change`<br>`output-panel-action`<br>`output-panel-error`<br>`output-panel-cleared` | DOM-normalized |
 | [`preferences-form.html`](#preferences-formhtml) | Builds a schema-driven preferences form with submit, reset, busy, and status behavior. | `configure()`<br>`getValues()`<br>`setValues()`<br>`setBusy()`<br>`setStatus()`<br>`destroy()` | `preferences-form-ready`<br>`preferences-change`<br>`preferences-submit`<br>`preferences-reset` | Normalized form values |
-| [`pwa-install.html`](#pwa-installhtml) | Presents a dismissible browser installation action with floating or inline placement. | `configure()`<br>`install()`<br>`dismiss()`<br>`destroy()`<br>`state`<br>`ready` | `pwa-install-ready`<br>`pwa-install-change`<br>`pwa-install-dismissed` | Browser install availability and outcome supplied by the shared PWA owner |
+| [`pwa-install.html`](#pwa-installhtml) | Presents independent installation and explicit update/reload actions with floating or inline placement. | `configure()`<br>`install()`<br>`dismiss()`<br>`update()`<br>`dismissUpdate()`<br>`destroy()`<br>`state`<br>`ready` | `pwa-install-ready`<br>`pwa-install-change`<br>`pwa-install-dismissed` | Complete labels and independent installation/update state; native unload cancellation leaves Update available |
 | [`record-timeline.html`](#record-timelinehtml) | Displays complete chronological records/evidence and emits open actions. | `setItems()`<br>`populate()`<br>`destroy()` | `record-timeline-ready`<br>`record-timeline-open` | Complete item fields and inventories preserved |
 | [`relationship-board.html`](#relationship-boardhtml) | Displays complete normalized relationship nodes/edges in graph and list forms. | `setGraph()`<br>`populate()`<br>`destroy()` | `relationship-board-ready`<br>`relationship-node-open`<br>`relationship-edge-open` | Complete graph inventories and fields preserved |
 | [`screen-capture.html`](#screen-capturehtml) | Presents image, video, or GIF display-capture workflow. | `capture` (`ScreenCapture` instance)<br>`destroy()` | `screen-capture-ready`<br>`screen-capture-result` | State/result normalized; media permission/codec failures mixed |
@@ -351,6 +351,15 @@ restored or new message uses a separate semantic `<time>` element at the card's
 lower-right with an ISO `datetime`, full local title, and local 24-hour `HH:MM`
 text.
 
+Restored assistant cards use the record's exact nonblank string `name`, or
+`AI` when absent. The current profile/model/voice name never renames older
+messages. For live session replies, the card starts with `session.aiName`
+when nonblank, otherwise the existing `host.aiName` display value; the terminal
+result aligns it with the name captured by the session for that operation.
+Set the session/entity name as well as the live component label when the
+application intends new saved turns to retain that attribution. The shared
+component does not persist the profile name or choose a naming policy.
+
 Assistant structural calls render their nonempty `function.arguments.message`
 as ordinary visible progress. The exact call name and argument string are
 retained inside a collapsed `Tool call details` inspection surface. Displaying
@@ -844,7 +853,11 @@ Each descriptor accepts an optional `title`. Supported shapes are:
 | `image`, `audio`, `pdf`, `download` | `content`: a `Blob` or `File`, or a function receiving `{signal}` and resolving to one |
 
 Conversation `role` and complete Markdown `content` are strings. Optional
-`name` and `status` are displayed alongside the role and time. Valid supplied
+assistant `name` is displayed exactly when it is a nonblank string; otherwise
+the assistant label is `AI`, without a role suffix. User and other role labels
+retain their supplied name alongside the role. User and assistant cards use
+distinct shared-theme backgrounds, and each card retains its original
+`data-role`. Optional `status` is displayed beside the time. Valid supplied
 timestamps are displayed in local time with their real ISO datetime; absent
 timestamps display `Time unavailable`, and an unrecognized supplied timestamp
 is displayed as supplied. No timestamp is invented.
@@ -1253,9 +1266,10 @@ Events: `preferences-form-ready`, `preferences-change`, `preferences-submit`, `p
 
 ### Overview
 
-A compact installation suggestion using the shared [PWA installation owner](pwa.md).
-The default floating panel appears near the top right only when the browser offers
-installation. It has an Install action and an explicit close button, takes no
+A compact installation and update suggestion using the shared [PWA owner](pwa.md).
+The default floating panel appears near the top right when the browser offers
+installation or a completed resource refresh establishes an update. It has an
+Install or Update action and an explicit close button, takes no
 focus automatically, and has no dismissal timer. It uses the Arcane theme and
 primitives, wraps complete labels and errors, and scrolls its own content when
 the available height is limited. The parent page loads `ThemeBootstrap.js` to
@@ -1264,7 +1278,8 @@ apply the user's appearance preferences.
 ### Public surface
 
 `configure({appName, installLabel, closeLabel, promptingLabel, description,
-presentation})` updates display configuration and returns its current record.
+updateTitle, updateLabel, updateDescription, updateCloseLabel, presentation})`
+updates display configuration and returns its current record.
 Labels remain complete strings. `appName` initially uses `data-app-name` or
 `this app`; the default button label is `Install`. `presentation` is `floating`
 by default or `inline`, initially read from `data-presentation`. Inline placement
@@ -1278,6 +1293,20 @@ An explicit request's complete failure message remains visible until dismissed;
 the method rejects with the same error. The browser controls actual installation.
 Acceptance hides the suggestion without claiming installation has completed.
 
+When an update is available, the same panel shows `Update available`, `Update`,
+`Reload this page to use the updated app.`, and the close label `Close update
+suggestion`. Each string has its matching configuration key. This presentation
+takes precedence over installation, including for installed/running apps and
+previously dismissed installation suggestions.
+
+`update()` calls the shared owner's ordinary `location.reload()` synchronously,
+returning true when available and false when unavailable or destroyed. It leaves
+availability intact if a native unload handler cancels navigation. Native reload
+errors propagate; the button observes them through developer diagnostics. There
+is no automatic reload, extra SDK confirmation, cache reset, or guarantee of
+preserving transient application state. `dismissUpdate()` hides only the update
+suggestion for this page owner and returns true, or false after destruction.
+
 `dismiss()` closes the component. Floating dismissal also uses the owner's
 session dismissal; an explicit inline component ignores that shared dismissal
 and closes only its own instance. Closing retains any unused native prompt at
@@ -1286,22 +1315,28 @@ disposes its event source, hides its host, and marks `ready` false; it does not
 dispose the shared owner or change browser installation state. Both methods
 return true while active and false after destruction; `destroy()` is idempotent.
 
-The readonly `state` property returns the shared owner's current install-state
+The readonly `state` property returns the shared owner's current install/update-state
 record; `ready` becomes true after methods and the state subscription are attached.
 `pwa-install-ready` carries `{ready, state}`; `pwa-install-change` carries
 `{state, visible}` for each observed owner update; `pwa-install-dismissed` carries
-`{presentation, state}`. These follow the canonical event projection contract.
+`{presentation, state}`, with `kind: 'update'` for update dismissal. These follow
+the canonical event projection contract.
 
 ### Availability and normalization
 
 The component requires HTMLImport and a DOM renderer. Native installation
 availability comes from the browser's `beforeinstallprompt` event through
-`getPwaInstall()`. Without an available event, the suggestion stays hidden;
+`getPwaInstall()`. Without an available event, the installation suggestion stays hidden;
 absence does not identify why installation is unavailable. Installed-app events,
 accepted prompts, and an already running installed display mode hide it.
 The shared SDK owner persists browser-reported installation in app-scoped
 DBOPFS. Both floating and inline controls stay hidden while that record is
 loading and remain hidden on later visits when installation is remembered.
+Those installation conditions do not hide an available update. Update state
+comes from the existing page-scoped registration owner, including a current-state
+read when the prompt is created after the refresh. A new page does not replay a
+completed update from an earlier page. Update dismissal is independent of saved
+installation state and performs no durable write.
 Acceptance alone does not save installation. The component's `ready` means
 its methods and subscription are attached; storage completion belongs to the
 shared owner's `ready` promise and does not delay page rendering.

package/docs/reference/runtime-entities.md

@@ -78,8 +78,9 @@ call and its matching results remain raw only through their one active provider
 continuation. Once that continuation settles, `messages` replaces the protocol
 with complete ordinary visible call, public result, and assistant content.
 `transcript` returns the narrow human-readable projection owned by the durable
-storage boundary. User and assistant records contain only role, complete
-visible content, and their real timestamp. A visible tool record may
+storage boundary. User and assistant records contain role, complete
+visible content, and their real timestamp. An assistant record may also carry
+its application-owned display `name`. A visible tool record may
 additionally carry its public name and plain result status, while its `content`
 comes only from the tool call's required user-facing `message`. System prompts,
 reasoning, provider-extension fields, memory flags, raw tool calls, call IDs,
@@ -90,6 +91,15 @@ One complete nonblank assistant record is also a durable conversation entry, so
 a model-authored opening can be stored and survive maintenance before the first
 ordinary user turn. No synthetic user record is required or written.
 
+`aiName` defaults to an empty string. `addAIMessage(text,{name=chat.aiName,...})`
+and `addTurn({name=chat.aiName,...})` capture that application-owned name on the
+new assistant record. A nonblank string is preserved exactly; blank or
+nonstring names are omitted. Provider `message.name` never establishes that
+display attribution. The name is transcript-only metadata: `messages` and
+memory extraction omit it, including during a pending tool continuation.
+Changing `aiName` affects later messages only; loading existing records does
+not rename or rewrite them.
+
 An assistant record may open an ordered array of structural calls with unique
 IDs in transient provider state. Until every pending ID receives exactly one
 matching nonblank `role:'tool'` result in the same active session, another
@@ -274,6 +284,29 @@ Owns persisted user preference/profile fields, explicit-preference updates,
 fresh reads, saves, and JSON projection. It installs `window.user` after its
 DBLS/DBOPFS lifecycle and emits `user-entity-loaded`.
 
+### AI_name
+
+Saved AI-name preference alongside `AI_personality`. It is a string with an
+empty-string default and preserves the complete supplied text, including
+Unicode, whitespace, and an explicitly empty value. The property setter follows
+the same persistence setting as `AI_personality`; non-string assignments throw
+`Error('AI_name must be string')`.
+
+`explicit`, `toJSON()`, `load()`, `refresh()`, and `updateExplicit()` include
+this field through the existing profile schema. Loading an older record that
+omits it leaves a new entity's empty default in memory and does not rewrite the
+stored record. Partial updates that omit it retain the current value.
+
+```javascript
+await user.updateExplicit(
+    {AI_name: 'Captain Moonboots'}
+);
+```
+
+The application owns naming choices and any mapping to its AI display name;
+this preference changes neither the human `username` nor chat history. No
+automatic migration or naming policy runs when it is loaded or saved.
+
 ### updateExplicit(update)
 
 Accepts an ordinary partial profile object, a JSON string, or a function

package/docs/reference/runtime-modules.md

@@ -125,8 +125,9 @@ own asynchronous work, cancellation, and backpressure.
 | [`SystemToolRegistry.js`](#systemtoolregistryjs) | esm | Registers validated command builders and constructs command strings without executing them. | Cross-host | Fully normalized definitions/quoting. |
 | [`TerminalClient.js`](#terminalclientjs) | esm | Maps native terminal sessions and Arcane events into an EventTarget client. | Native bridge | Client events/state normalized; native result/error mixed. |
 | [`TerminalCommandRegistry.js`](#terminalcommandregistryjs) | esm | Routes parsed command lines to injected handlers and provides definitions/completions. | Cross-host | Parsing/routing normalized; handler result/error preserved. |
-| [`ThemeBootstrap.js`](#themebootstrapjs) | esm | Performs import-time Arcane theme loading and subscribes to native appearance changes. | Browser/native hybrid | Theme state normalized; storage/native errors mixed. |
+| [`ThemeBootstrap.js`](#themebootstrapjs) | esm | Loads authoritative appearance preferences and observes existing User readiness without blocking rendering. | Browser/native hybrid | Theme state normalized; storage/native errors mixed. |
 | [`ThemeManager.js`](#thememanagerjs) | esm | Loads, applies, previews, saves, resets, and synchronizes semantic Arcane themes. | Browser/native hybrid | Theme values/events normalized; storage/native failures mixed. |
+| [`ThemePresentation.js`](#themepresentationjs) | classic-script | Restores app-scoped presentation before CSS and owns complete skin-class application. | Browser / native WebView classic script | Synchronous presentation only; saved profile and preferences remain authoritative. |
 | [`TimeGuard.js`](#timeguardjs) | esm | Persists and evaluates clock rollback and grace-period state. | Browser / native WebView | Time decisions normalized; storage lifecycle mixed. |
 | [`ToolCallRouter.js`](#toolcallrouterjs) | esm | Parses OpenAI-style tool calls and dispatches complete or streamed calls to injected handlers. | Cross-host | Argument records validated; handler results returned or all-settled. |
 | [`uPlot.iife.min.js`](#uplotiifeminjs) | classic-script | Vendored uPlot chart constructor and rendering runtime. | Browser vendor script | Vendor-native. |
@@ -3013,13 +3014,24 @@ semantics; it does not define a new storage protocol.
 Exact exports: `PersistentAIChatSession`, `createPersistentAIChatSession`, and
 `default`.
 
-Constructor and factory options are `{ai,chat,chatEntity,chatFileName,
+Constructor and factory options are `{ai,aiName,chat,chatEntity,chatFileName,
 contextBuilder,loadExisting,memory,request,responseLength,systemPrompt}`. Public members are
 static `create()`, getters `ai`, `chatEntity`, and `fileName`, and `ready()`,
 `history()`, `transcript()`, `settleMemory()`, `open(input)`, `send(input)`, and
 `stream(input,handlers)`.
 `ready()` waits for initialization and resolves the same session instance.
 
+Optional `aiName` is an application-owned string, also exposed through the
+session's getter/setter. `open()`, `send()`, and `stream()` capture it at operation
+entry before awaiting readiness, memory, or the provider, so later name changes
+apply only to subsequent operations. A nonblank name is preserved exactly on
+the copied terminal `message.name` and the retained assistant transcript record;
+the terminal copy carries the assistant record's real timestamp when one exists.
+Empty or whitespace-only names omit this display field. The complete raw
+`providerResponse` stays unchanged. Configured model context and memory inputs
+omit the application display name. Existing stored history is never renamed or
+rewritten when `aiName` changes; `persist:false` remains operation-only.
+
 `open({message:{content,persist:false?},request?,signal?})` performs one
 application-authored bootstrap request only when the retained conversation is
 otherwise empty. The bootstrap is never committed. After a complete nonblank
@@ -3049,8 +3061,9 @@ system prompt and every complete ordinary visible committed turn. Only a
 currently unresolved structural-call tail remains raw for its matching active
 continuation. `transcript()` returns the sanitized human-readable ChatEntity
 projection.
-User and assistant records retain only role, complete visible content, and the
-real timestamp. Tool records retain only role, the required user-facing
+User and assistant records retain role, complete visible content, and the
+real timestamp, with an optional exact nonblank application display name on
+assistant records. Tool records retain only role, the required user-facing
 `message` as content, and optional public `name` and result `status`.
 
 `stream()` accepts the same input as `send()` and optional
@@ -3755,7 +3768,12 @@ console.log(Object.keys(module));
 
 ### Overview
 
-Performs import-time Arcane theme loading and subscribes to native appearance changes.
+Performs import-time Arcane theme loading, reuses the shared presentation
+owner, and subscribes to native appearance changes and
+the canonical user's readiness event. Rendering does not wait for profile
+loading. A ready user is replayed immediately; its saved skin supersedes the
+presentation cache. Bootstrap observes the existing User lifecycle rather than
+creating a profile or migrating saved data.
 
 ### Public surface
 
@@ -3764,6 +3782,16 @@ Performs import-time Arcane theme loading and subscribes to native appearance ch
 Exact exports: `arcaneThemeReady`, `bootstrapArcaneTheme`, `default`, and
 `disposeArcaneThemeBootstrap`.
 
+`disposeArcaneThemeBootstrap()` removes both bootstrap-owned subscriptions.
+The cache is a presentation hint, not the authority for preferences or user
+data. Preference loading and User readiness independently reconcile it; cache
+failures are logged without blocking the page.
+
+Module evaluation follows its import graph, so importing ThemeBootstrap alone
+does not establish restoration before the first paint. Use the classic
+[ThemePresentation head entry](#themepresentationjs) before CSS for that early
+restoration. Neither entry imports User or starts its storage lifecycle.
+
 ### Availability and normalization
 
 **Browser/native hybrid.** Theme state normalized; storage/native errors mixed. Transport: ThemeManager + Arcane.events. [Deep protocol details](protocols.md).
@@ -3784,9 +3812,56 @@ Loads, applies, previews, saves, resets, and synchronizes semantic Arcane themes
 
 ### Public surface
 
-default `ThemeManager`, `loadAndApplyTheme()`; scheme/custom/system APIs and `arcane-theme-change`.
-
-Exact exports: `default`, `loadAndApplyTheme`.
+default `ThemeManager`, `loadAndApplyTheme()`, `applyUserSkin()`;
+scheme/custom/system APIs and `arcane-theme-change`.
+
+Exact exports: `default`, `loadAndApplyTheme`, `applyUserSkin`.
+
+`applyUserSkin(skin,{root?,body?,cache=true}={})` synchronously applies the
+application's saved skin classes without replacing unrelated body classes.
+The default root is the current document element; the default body belongs to
+that root's document. It accepts the
+existing string/number skin values and whitespace-separated class lists;
+unknown application classes remain usable. It selects the shared named
+palette on the root through `data-user-skin`, returning its name or `null`
+when there is no applicable skin/root. The palette selection does not rewrite
+the supplied skin or save a User record. Set `cache:false` for a presentation
+that should not be remembered across navigation.
+This export delegates to the same owner installed by `ThemePresentation.js`.
+Falsy skin values retain the current presentation. Complete supplied strings
+remain exact in the presentation cache; numbers use their complete class-text
+representation, leaving the profile value unchanged. If the body does not yet
+exist, root selection happens immediately and the latest complete class list
+is applied once the body is available.
+
+The shared `theme.css` owns the default, warm, curious, hopeful, harmony, and
+warrior palettes. Each works with explicit light/dark or system appearance.
+`layout.css` imports that same owner. Explicit custom themes retain precedence
+through `data-arcane-skin="custom"` and their inline tokens.
+The bare root retains the generic neutral light/dark baseline; the prior
+layout default palette is selected explicitly through `data-user-skin="default"`,
+`body.default` compatibility, or the default swatch.
+
+A scoped `data-arcane-palette="warm"` element exposes the same palette variables
+for a chooser preview without changing the page's selection. Use any of the
+six named palettes and paint the preview with ordinary shared variables such
+as `--background`, `--text-color`, and `--primary-color`; applications need no
+copied palette values. The scoped preview follows the page's appearance scheme.
+Set `data-color-scheme="light"` or `data-color-scheme="dark"` on that same
+`data-arcane-palette` element to preview either variant independently of the
+page scheme. Leaving it unset follows the page. Applications own preview order,
+layout, and any toggle; the scoped attribute leaves the page mode unchanged.
+
+`loadAndApplyTheme()` restores the last app-scoped presentation before its
+asynchronous preference loads. The complete saved skin and applied
+appearance/custom presentation are cached by `ThemePresentation` only as
+nonauthoritative UI state;
+User and preference stores retain ownership of saved settings. No page hiding,
+profile-read barrier, polling, or history migration is involved.
+`apply()` remembers only its applied appearance attributes and the custom CSS
+properties owned by Theme's existing token list. `preview()` remains transient.
+The module's side-effect import also installs the presentation owner when no
+classic head script was selected; it does not provide a first-paint guarantee.
 
 ### Availability and normalization
 
@@ -3795,9 +3870,75 @@ Exact exports: `default`, `loadAndApplyTheme`.
 ### Example
 
 ```javascript
-import * as module from '/arcane/modules/ThemeManager.js';
+import {applyUserSkin} from '/arcane/modules/ThemeManager.js';
 
-console.log(Object.keys(module));
+applyUserSkin('warm dragon-observatory');
+```
+
+## ThemePresentation.js
+
+### Overview
+
+A dependency-free classic head entry restores the last application-scoped
+presentation synchronously, before following stylesheets are loaded. It
+does not import modules, User, OPFS, or a model, hide the page, or wait for
+profile or preference readiness. ThemeManager reuses the same per-realm owner.
+
+### Public surface
+
+No ESM exports. The first evaluation installs
+`globalThis.arcaneThemePresentation` and calls `restore()`; later evaluations
+reuse the installed object.
+
+- `applyUserSkin(skin,{root?,body?,cache=true}={})` is the same synchronous skin
+  operation exported through ThemeManager. It preserves independently owned
+  body classes, selects `data-user-skin`, and returns the selected palette name
+  or `null` for a falsy skin or missing root. Numeric presentation is cached as
+  its complete class text; supplied strings remain exact.
+- `remember(fields,root=document.documentElement)` merges the supplied
+  presentation fields with the current cache and returns whether the write
+  succeeded. The SDK supplies `skin`, `palette`,
+  `appearance:{colorScheme,density,reduceMotion,fontSize}`, and
+  `customProperties` (the applied Theme-owned CSS property map, or `null`).
+- `restore(root=document.documentElement)` applies cached root appearance and
+  owned custom properties plus the complete skin classes. It returns the
+  cached record, an empty record on a cache miss, or `null` when restoration
+  is unavailable or fails. If the body is still absent, one DOMContentLoaded
+  callback applies the latest class list; root colors are already selected.
+- `reportError(message,error)` initially forwards the complete Error to
+  `console.warn`; ThemeManager connects it to `arcaneLogging.warn` when its
+  module evaluates.
+
+The cache key is `arcane.apps.<application-id>:arcane.theme.presentation`, using
+the existing `arcane-app-id` meta declaration or `data-arcane-app-id` on the
+document root. Missing identity or storage skips caching. Conflicting identity,
+storage failures, and malformed JSON are logged without stopping rendering.
+Malformed JSON does not prevent a later authoritative presentation write.
+Only presentation is remembered; no User record, unrelated inline style,
+profile snapshot, model state, or history is captured or migrated.
+
+Canonical already-ready User state and later `user-entity-loaded` events
+reconcile the cached skin through ThemeBootstrap; loaded appearance/custom
+preferences remain authoritative through ThemeManager. A cache miss cannot
+know an unloaded saved profile skin, and a module-only import may evaluate
+after first paint.
+
+### Availability and normalization
+
+**Browser / native WebView classic script.** DOM and optional application-scoped
+localStorage only. No native capability is required.
+
+### Example
+
+Place the ordinary classic script after the existing app-id declaration and
+before theme/layout styles. Do not use `type="module"`, `async`, or `defer` on
+this early entry; retain the application's normal ThemeBootstrap module use.
+
+```html
+<meta name="arcane-app-id" content="dragon-observatory">
+<script src="/arcane/modules/ThemePresentation.js"></script>
+<link rel="stylesheet" href="/arcane/css/theme.css">
+<script type="module" src="/arcane/modules/ThemeBootstrap.js"></script>
 ```
 
 ## TimeGuard.js

package/docs/reference/sdk-api.md

@@ -6407,8 +6407,8 @@ console.log(deviceClass); // mobile or desktop
 
 ### Overview
 
-The event name `arcane.pwa.state` identifies PWA registration and native worker
-lifecycle state published through the existing Arcane event owner.
+The event name `arcane.pwa.state` identifies PWA registration, native worker
+lifecycle and page-local update availability published through the existing Arcane event owner.
 
 ### Example
 
@@ -6434,7 +6434,15 @@ It stores one `lastChecked` timestamp per app/cache in DBOPFS, advancing it only
 after the full resource check succeeds, and revalidates on page load after
 120 seconds in development or 15 minutes in packaged delivery. Complete
 responses remain cached without SDK expiration; `304` retains the response
-and a successful replacement updates it. See the [PWA guide](pwa.md).
+and a successful replacement updates it. A complete successful refresh latches
+`state.updateAvailable` when parseable old/new `Last-Modified` dates differ or
+a successfully checked resource was absent from the prior durable inventory.
+Initial population, eviction repair, `304`, and unknown/equal modification
+dates do not announce updates. Partial-change evidence survives worker restart
+until complete success; existing scoped window clients receive the completed
+signal. The state replays to subscribers and remains true for this page owner.
+The registration owner's `update()` only requests a native worker update check;
+it does not reload the page. See the [PWA guide](pwa.md).
 
 ### Example
 
@@ -6456,7 +6464,7 @@ entry point and must observe its `ready` rejection.
 ### Overview
 
 The exact event name `arcane.pwa.install.state` identifies native installation
-availability and choice state through the existing Arcane event owner. It is
+availability, choice and shared update-prompt state through the existing Arcane event owner. It is
 separate from service-worker registration state. Importing it starts no
 observation or installation.
 
@@ -6475,16 +6483,17 @@ payload and current-state subscription behavior.
 ### Overview
 
 `getPwaInstall()` returns one synchronous page owner exposing `state`, `ready`,
-`subscribe`, `prompt`, `dismiss` and `dispose`. It captures the browser's
+`subscribe`, `prompt`, `dismiss`, `update`, `dismissUpdate` and `dispose`. It captures the browser's
 `beforeinstallprompt` event and observes `appinstalled` and app display-mode
 changes. A missing event leaves installation availability unknown and the owner
 waiting; it does not prove browser incompatibility.
 
-State contains `status`, `available`, `installed`, `dismissed`, `outcome`,
+State contains `status`, `available`, `installed`, `dismissed`, `updateAvailable`,
+`updateDismissed`, `outcome`,
 `error` and `storageError`. The owner restores `pwa/installed.json` through the
 app-scoped DBOPFS singleton and saves `{installed: true}` after `appinstalled`
 or an installed-app launch. Remembered installation suppresses both floating
-and inline controls on later visits. Acceptance alone and ordinary fullscreen
+and inline installation controls on later visits. Acceptance alone and ordinary fullscreen
 do not record installation.
 
 `ready` resolves to the state once the initial read settles. Native events are
@@ -6498,6 +6507,18 @@ consumes the event once and returns the browser choice, resolves to `null` when
 unavailable, or rejects with the actual error. `dismiss()` remembers the
 session's floating-suggestion dismissal without consuming a retained event.
 
+The generated bootstrap starts this owner before worker registration, so it
+observes the current page scope's `arcane.pwa.state` update signal while the
+component loads. A late-created prompt also reads current state from live
+registration owners. `updateAvailable` remains true for the page owner;
+`updateDismissed` is a separate page-local choice. An explicit `update()` calls
+ordinary `location.reload()` synchronously and returns true, or false when
+unavailable/disposed; native errors propagate. It preserves native unload
+handling and application draft ownership without promising transient-state
+survival. `dismissUpdate()` returns the current state and writes no durable
+record. Installed/running state or installation dismissal does not suppress
+the update suggestion. A fresh page does not replay an old completed update.
+
 ### Example
 
 ```javascript
@@ -6537,7 +6558,9 @@ supplies the initial app name.
 The generated PWA bootstrap calls this automatically with the manifest name.
 Component mounting and worker registration run independently, and application
 rendering must not await them. The floating component offers Install and a
-manual close control; an application can also place the same component inline.
+manual close control, or Update available with an explicit Update action after
+a completed changed refresh. Update dismissal is separate from installation
+dismissal. An application can also place the same component inline.
 
 ### Example
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcane-os",
-  "version": "0.37.0",
+  "version": "0.39.0",
   "description": "Arcane OS JavaScript SDK, project-local CLI, browser runtime, and repository-portable application packager.",
   "type": "module",
   "main": "./src/index.mjs",

package/runtime/arcane/components/chat.html

@@ -1576,7 +1576,9 @@
                         :'Tool'
                     :message.role==='system'
                     ?'System'
-                    :host.aiName;
+                    :is.string(message.name)&&message.name.trim()
+                        ?message.name
+                        :'AI';
                 item=createTranscriptMessage(message.role,message.content,name,{
                     timestamp:message.timestamp,
                     toolCalls:calls,
@@ -3245,6 +3247,9 @@
         const previousPendingToolCalls=[...pendingStructuralToolCalls];
         const streamedStructuralToolCalls=[];
         const messageId=`session-${++sessionMessageSequence}`;
+        const responseName=is.string(session.aiName)&&session.aiName.trim()
+            ?session.aiName
+            :host.aiName;
         const sessionMessageToken=Symbol(messageId);
         const transientCards=retainTurn?[]:[...requestMessages];
         function removeTransientSessionCards(){
@@ -3259,7 +3264,7 @@
         applyAIAvailability(host.aiAvailability);
         setSessionStatus('sending','AI is responding…');
         try{
-            const responseCard=receivedMessage(host.aiName, '', messageId);
+            const responseCard=receivedMessage(responseName, '', messageId);
             if(!retainTurn) transientCards.push(responseCard);
             await streamMessage('',messageId,true);
             setMessageProgress(
@@ -3344,6 +3349,10 @@
                 result.message.content,
                 committedTurn?.response?.timestamp??result.message.timestamp
             );
+            const assistantName=committedTurn?.response?.name??result.message.name;
+            if(is.string(assistantName)&&assistantName.trim()){
+                message.querySelector('.message_header strong').textContent=assistantName;
+            }
             for(const [index,requestMessage] of requestMessages.entries()){
                 setTranscriptMessageTimestamp(
                     requestMessage,

package/runtime/arcane/components/file-manager.html

@@ -387,6 +387,21 @@
         background:var(--background);
     }
 
+    .file-preview-message[data-role="user"]{
+        background:var(--arcane-action,var(--primary-color));
+        color:var(--arcane-action-text,var(--button-text-color,var(--text-color)));
+        border-color:var(--arcane-action,var(--primary-color));
+    }
+
+    .file-preview-message[data-role="user"] a{
+        color:inherit;
+    }
+
+    .file-preview-message[data-role="assistant"]{
+        background:var(--arcane-surface,var(--background));
+        color:var(--text-color);
+    }
+
     .file-preview-message header,
     .file-preview-message footer{
         display:flex;
@@ -1740,9 +1755,15 @@
                         const time=document.createElement('time');
                         article.className='file-preview-message';
                         article.dataset.role=message.role;
-                        speaker.textContent=message.name===undefined
-                            ?message.role
-                            :`${message.name} · ${message.role}`;
+                        if(message.role==='assistant'){
+                            speaker.textContent=is.string(message.name)&&message.name.trim()
+                                ?message.name
+                                :'AI';
+                        }else{
+                            speaker.textContent=message.name===undefined
+                                ?message.role
+                                :`${message.name} · ${message.role}`;
+                        }
                         header.append(speaker);
                         if(message.timestamp===undefined||message.timestamp===null){
                             time.textContent='Time unavailable';

package/runtime/arcane/components/header.html

@@ -78,12 +78,14 @@
 </header>
 
 <script type="module">
-    const {arcaneLogging}=await import('arcane-os/logging');
+    const [{arcaneLogging},{applyUserSkin}]=await Promise.all([
+        import('arcane-os/logging'),
+        import('../modules/ThemeManager.js')
+    ]);
 
     import('../entities/User.js');
     
     const host=this;
-    const appliedSkinClasses=new Set();
 
     window.addEventListener('user-entity-loaded', setSkin);
     window.addEventListener('online', checkInternet);
@@ -124,22 +126,7 @@
         try {
             const skin = window.user?.skin;
             if (skin) {
-                const nextClasses=new Set(String(skin).match(/[^\t\n\f\r ]+/gu)||[]);
-                const classes=document.body.classList;
-                // Only replace classes added by this header; application layout
-                // and independently owned theme classes stay with their owners.
-                for(const name of appliedSkinClasses){
-                    if(!nextClasses.has(name)){
-                        classes.remove(name);
-                        appliedSkinClasses.delete(name);
-                    }
-                }
-                for(const name of nextClasses){
-                    if(!classes.contains(name)){
-                        classes.add(name);
-                        appliedSkinClasses.add(name);
-                    }
-                }
+                applyUserSkin(skin);
             } else {
                 arcaneLogging.log('No saved skin found. Using default.');
             }