Feature: Transcript and extraction improvements

docs/architecture/chrome-and-panels.md

@@ -206,6 +206,18 @@ Four rules, each of which was broken by at least one panel before the fragment e
 - **One padding.** `300`, which `panelShell` applies. Panels share edges, and two paddings read as a
   wobble.
 
+**A panel explains itself behind a glyph, not in its body.** `help` on either fragment puts an info
+glyph against the name; pointing at it (or focusing it) shows two to four sentences on how the panel
+works. The extraction panel used to say all of that in its body — a lead-in above the chips, a
+footnote under the button — and it was read once and then furniture, in a docked panel with no room
+to spare. Prose about _how something works_ goes in `help`; prose about _the current state_ (why a
+control is disabled, what a pass found) stays in the body, because it is news rather than a manual.
+Not every panel wants one: a glyph on every header is noise of its own.
+
+```ts
+panelShell({ title: 'Extraction', help: 'A model reads the transcript and writes what it finds …', children });
+```
+
 TSX panels cannot call a schema fragment, so they spread `PANEL_TITLE_PROPS` onto a `we-text` —
 one definition, two languages.
 

packages/ai-context/src/fragments/rules.ts

@@ -22,7 +22,7 @@ export const rules = `
 - For icon-only buttons, nest a \`we-icon\` child inside \`we-button\` rather than using a \`text\` prop with a Unicode character. **Omit the \`size\` prop on \`we-icon\` when nesting inside sized primitives** (\`we-button\`, \`we-input\`, \`we-badge\`, \`we-textarea\`) — these components auto-size nested icons via \`--we-context-icon-size\` (xs→12px, sm→16px, md→24px, lg→32px, xl→40px). Only set an explicit icon \`size\` if you need to override the automatic sizing. Example: \`{ type: 'we-button', props: { variant: 'ghost', size: 'sm' }, children: [{ type: 'we-icon', props: { name: 'x' } }] }\`.
 - NEVER pass a bare number like "16" as a size or dimension prop — it is not valid CSS. Always check the component's declared prop type: if it's a string union, use one of the listed values; if it accepts arbitrary strings, include a CSS unit (e.g. "16px", "2rem").
 - For interactive list items and selectable options, use \`we-button\` with variant switching (e.g., \`secondary\` when selected, \`ghost\` when not) instead of manually styling \`Row\` with cursor, bg, and onClick. Buttons provide hover, focus, and active states for free.
-- To make a block of content clickable **without any button appearance**, use \`we-button\` with \`variant: 'bare'\` — never a \`Column\`/\`Row\` with an \`onClick\`. \`bare\` is the appearance-free variant: no background, no hover, no padding, no radius, inherited colour — but still a real \`<button>\`, so it keeps keyboard activation, the \`disabled\` prop, and the accessibility role that a clickable \`Column\` silently loses. Do not use \`ghost\` for this: ghost's hover background is deliberate, and it paints a rectangle over content that supplies its own affordance. Example: \`{ type: 'we-button', props: { variant: 'bare', disabled: { $: 'someStore.busy' }, onClick }, children: [{ type: 'Column', props: { gap: '150', ax: 'center' }, children: [...] }] }\`.
+- To make a block of content clickable **without any button appearance**, use \`we-button\` with \`variant: 'bare'\` — never a \`Column\`/\`Row\` with an \`onClick\`. \`bare\` is the appearance-free variant: no background, no hover, no padding, no radius, inherited colour — but still a real \`<button>\`, so it keeps keyboard activation, the \`disabled\` prop, and the accessibility role that a clickable \`Column\` silently loses. Do not use \`ghost\` for this: ghost's hover background is deliberate, and it paints a rectangle over content that supplies its own affordance. Example: \`{ type: 'we-button', props: { variant: 'bare', disabled: { $: 'someStore.busy' }, onClick }, children: [{ type: 'Column', props: { gap: '100', ax: 'center' }, children: [...] }] }\`.
 - For card-like layouts, compose from \`Column\` with DS props (bg, r, border, p, gap). This gives full control over spacing and appearance.
 - When rendering lists of similar items (posts, cards, users, etc.), ALWAYS use \`$each\` with a single template child — never duplicate the same node structure multiple times. Use literal arrays in \`items\` for static data, or a store read/\`$query\` for dynamic data.
 

packages/ai-context/src/fragments/stores.ts

@@ -347,7 +347,7 @@ export const storeEntries: StoreEntry[] = [
       },
       moduleLaunchers: {
         type: 'array',
-        properties: ['id', 'icon', 'label', 'active'],
+        properties: ['id', 'icon', 'label', 'active', 'busy'],
       },
       taskStates: { type: 'array', properties: ['id', 'name', 'slug', 'semantic', 'color', 'retired', 'defined'] },
       offeredTaskStates: {
@@ -1014,7 +1014,7 @@ export function generateStoresText(entries: StoreEntry[]): string {
         moduleInstallSettings:
           "{ id, name, description, icon, installed, surface, switchable }[] — every registered module and whether this agent wants it anywhere. The global Settings → Modules list, and the only place an 'app' or 'capability' module is decided about: a contribution is gated at the layer where it renders, and only 'chrome' renders inside a space. `surface` is derived from what the module contributes. Its per-space counterpart is `modules` on each spaceList row, which carries enabled/installed/visible/active together and lists chrome modules only",
         moduleLaunchers:
-          '{ id, icon, label, active }[] — launchers for the modules enabled here and available in this space; what the host module rail renders. Pair with { $action: "spaceStore.launchModule", args: [{ $: "mod.id" }] }',
+          '{ id, icon, label, active, busy }[] — launchers for the modules enabled here and available in this space; what the host module rail renders. `active` lights the button while the module reports its surface open; `busy` says the module is working in the background — an extraction pass running — and is independent of `active`, so a rail can show work going on behind a closed panel. Pair with { $action: "spaceStore.launchModule", args: [{ $: "mod.id" }] }',
       },
       actions: {
         moveChild:
@@ -1144,7 +1144,7 @@ export function generateStoresText(entries: StoreEntry[]): string {
         creatableEntities:
           "{ label, value, icon, group }[] — models a person can create an instance of here, ready for a we-select: this space's own models first, then WE's built-in content types. A model appears here by declaring `authoring` in the manifest, or by being a shape this community defined",
         displays:
-          "Record<entity, RecordDisplay> — how to show an instance of each creatable model, keyed by entity name and derived from its declaration: { entity, label, icon, title, summary, media, fields[] }, where title/summary/media name the properties playing those roles ('' when none does) and each field is { name, label, kind, role }. kind is one of text, longText, number, boolean, date, datetime, color, url, image, file, json; role is title, summary, media or detail. Index it by a row's type — { $: 'recordStore.displays[row.type]' } — and render the fields with $each; see \"A record of any type\" in the patterns",
+          "Record<entity, RecordDisplay> — how to show an instance of each creatable model, keyed by entity name and derived from its declaration: { entity, label, icon, title, summary, media, fields[] }, where title/summary/media name the properties playing those roles ('' when none does) and each field is { name, label, kind, role, options }. kind is one of text, longText, number, boolean, date, datetime, color, url, image, file, json; role is title, summary, media or detail. `options` is the values a field is allowed to hold where the model closes the set (a task's status), empty otherwise — count() it to tell a state worth drawing as a we-badge from free text, and map it into a we-select rather than offering a text box that accepts a word the model does not know. Index it by a row's type — { $: 'recordStore.displays[row.type]' } — and render the fields with $each; see \"A record of any type\" in the patterns",
         recordDraft:
           "the open form's draft ({ entity, label, icon, fields[] }) or null while closed — its non-nullness is what mounts the modal. Each field is { name, label, control, required, options, placeholder, value }, derived from the model's own declaration, so a form exists for a model nobody wrote a form for",
         recordDraftDirty:

packages/app-shell/src/frameworks/solid/components/PanelLane.tsx

@@ -166,7 +166,7 @@ function Section(props: { panel: TemplatePanel }) {
           not exist on a touchscreen, and a grip somebody cannot tab to is a control some people
           cannot use. The tooltip carries the verb.
         */}
-        <we-tooltip title="Break out into a panel" placement="left">
+        <we-tooltip content="Break out into a panel" placement="left">
           <we-move-handle
             label={`Break ${props.panel.title ?? props.panel.id} out into a panel`}
             style={{

packages/app-shell/src/frameworks/solid/providers/TemplateProvider.tsx

@@ -1,3 +1,4 @@
+import { datasetAddressedBy } from '@shared/datasetIdentity';
 import { queryIRFlag } from '@shared/queryIRFlag';
 import { provideModuleHostServices } from '@shared/registries/moduleHostServices';
 import { resolveParts, resolvePartsInRoutes } from '@shared/registries/moduleParts';
@@ -149,6 +150,11 @@ export default function TemplateProvider() {
     return getEntity(entity).create(perspective, fields, Object.keys(rest).length ? rest : undefined);
   }
 
+  /** The same, for `record.update` — `recordActions` resolves a store *path*, and a module has a handle. */
+  function updateInDataset(entity: string, id: string, fields: Record<string, unknown>, perspective: DatasetProxy) {
+    return getEntity(entity).update(perspective, id, fields);
+  }
+
   // The same capability schemas get as `record.create`, lent to module stores that must write
   // without a click to hang a schema action on — a transcript appears because somebody spoke.
   onCleanup(
@@ -227,6 +233,16 @@ export default function TemplateProvider() {
         }
         await (add as (v: string) => Promise<void>).call(instance, value);
       },
+
+      // The scalar counterpart of `linkEntity`, resolved the same way `createEntity` is: a module
+      // names a dataset by URI, and an unresolvable name refuses rather than writing to whatever is
+      // on screen. See `ModuleStoreDeps.updateEntity` for why a module needs this when a schema's
+      // `record.update` already exists.
+      updateEntity: async (entity, id, fields, options) => {
+        const p = moduleTarget(options?.dataset);
+        if (!p) return;
+        await updateInDataset(entity, id, fields, p);
+      },
     }),
   );
 
@@ -729,6 +745,28 @@ export default function TemplateProvider() {
     const segments = routeStore.segments();
     if (segments[0] !== 'space' || !segments[1]) return;
 
+    /*
+      Only while the address on screen is about the space these sections belong to.
+
+      Everything below reads the *store's* space — its nav, its enabled sections — and writes the
+      *URL's* space. Those are the same space almost always, and the window where they are not is
+      the one that mattered: `navigateToSpace` switches the dataset first and navigates second, so
+      between the two the stores describe B while the URL still says A. This effect woke in that
+      window, because the template had just been replaced with B's default and the previous one was
+      self-routing — so `hasViewsMarker` went from false to true, on a URL holding a self-routing
+      template's own path, which is a section no space has.
+
+      It then did exactly what it is written to do, to the wrong space: rewrote the URL to
+      `/space/A/<B's first section>`. That is a route change naming A, so the route effect that
+      keeps the dataset in step with the address dutifully switched *back* to A — landing after the
+      switch to B had finished, since it starts later. The reader ended up in space B by every sign
+      the URL and the sidebar could give, reading space A's records.
+
+      The guard is the invariant stated plainly: correct an address only when it is an address about
+      the space you are reading from.
+    */
+    if (!datasetAddressedBy(datasetStore.currentDataset(), segments[1])) return;
+
     /*
       Only for a template whose sections these are.