@design.estate/dees-catalog 11.2.1 → 12.0.0

package/readme.md

@@ -165,6 +165,7 @@ task guide and examples deliberately; the generated table does not replace them.
 | `dees-harness-chat` | harness | [DeesHarnessChat](#deesharnesschat) | [Source](ts_web/elements/00group-harness/dees-harness-chat/dees-harness-chat.ts) |
 | `dees-harness-composer` | harness | [DeesHarnessComposer](#deesharnesscomposer) | [Source](ts_web/elements/00group-harness/dees-harness-composer/dees-harness-composer.ts) |
 | `dees-harness-content-blocks` | harness | [DeesHarnessContentBlocks](#deesharnesscontentblocks) | [Source](ts_web/elements/00group-harness/dees-harness-content-blocks/dees-harness-content-blocks.ts) |
+| `dees-harness-conversation-picker` | harness | [DeesHarnessConversationPicker](#deesharnessconversationpicker) | [Source](ts_web/elements/00group-harness/dees-harness-conversation-picker/dees-harness-conversation-picker.ts) |
 | `dees-harness-message` | harness | [DeesHarnessMessage](#deesharnessmessage) | [Source](ts_web/elements/00group-harness/dees-harness-message/dees-harness-message.ts) |
 | `dees-harness-message-list` | harness | [DeesHarnessMessageList](#deesharnessmessagelist) | [Source](ts_web/elements/00group-harness/dees-harness-message-list/dees-harness-message-list.ts) |
 | `dees-harness-overflow-text` | harness | [DeesHarnessOverflowText](#deesharnessoverflowtext) | [Source](ts_web/elements/00group-harness/dees-harness-overflow-text.ts) |
@@ -2640,7 +2641,7 @@ Scrollable streaming-safe log. Up to 40 canonical entries (`messages` + `permiss
 
 `refreshMessages(ids?)` reconciles in-place host mutations without replacing canonical objects. With IDs, it refreshes only matching message rows that are currently mounted; matching offscreen rows remain unmounted and use the mutated canonical objects when later mounted. With IDs omitted, it rebuilds structural transcript state and refreshes all mounted rows. `[]` is a no-op.
 
-Producers with authoritative source chronology can set `IHarnessMessage.order` to `{ messageIndex, partIndex }`; explicitly ordered messages retain that relative order while timestamps continue to place legacy messages and ancillary cards. Consecutive tool calls use one generic responsive-grid pipeline at their chronological position, partitioned by descriptor layout: compact tools share rows with compact tools, subagents share rows only with subagents, and terminal plus file-write cards span a whole row. Consecutive same-layout runs are always capped at four cards per group row, even when their tool kinds differ. Columns respond to the row's own width rather than the viewport, and status changes never regroup cards. Because a compact group sits inside the content measure, its column count is bounded by that measure — two columns at the 820px default; the wider three- and four-column steps apply when a host widens `--dees-harness-content-width`. Rows are held to a reading measure — `--dees-harness-content-width`, default `820px`, capped at the available width — while terminal and file-write rows keep the full pane, so prose stays readable and diffs and command output get the room they need. A subagent group takes the pane only from three cards upward; one or two stay on the measure. A terminal or file-write card keeps the pane only while it is open: once collapsed it returns to the reading measure, because a one-line header does not need the room its output did. This holds for every card in a terminal/file-write group, not only a lone one — those cards span all the columns of their row and stack vertically, so each follows its own disclosure and a collapsed command can sit above an open diff. The row itself still spans the pane; the card centres inside it and animates between the two widths with the standard disclosure timing. The genuinely side-by-side grids — compact tools and subagents — are never offered this width and keep their cell width in both states. The list publishes the collapsed width to its terminal/file-write rows as `--dees-harness-collapsed-tool-width`, derived from `--dees-harness-content-width`; a host can set it on a row to widen those cards, or set `100%` to keep collapsed cards full-bleed; setting it on the chat or the list also reaches compact and subagent cells, so prefer row-level overrides. The docked composer keeps its full-bleed bar and insets its content to the same measure, so the prompt lines up with the messages above it. The status line under the transcript sits on that measure too, so the working indicator starts where the messages start rather than at the pane edge. Set the custom property on the chat or the list to widen or disable the column; it is read when rows are measured, so change it at mount rather than while a virtualized transcript is scrolled. Untouched projected subtask cards collapse individually on completion with the normal disclosure animation; other cards retain their descriptor or user-selected disclosure state. Auto-follow responds to streamed growth but does not repeatedly repin while a disclosure shrinks. Permission requests, questions, and nested-stream limits behave as before. Props: `messages`, `permissions`/`permissionsBusy`, `questions`, `status`, `viewState`, `transcriptKey`, `hasEarlierMessages`, `loadingEarlier`, `autoFollow`, `hideScrollbar`, `fadeScrollEdges`, `showRoles`, `showTimestamps`, `allowSubtaskStreams`, `markdownWhileStreaming` (default `true`), `emptyTitle`/`emptyText` (+ `slot="empty"`). Native browser find and selection cover the mounted window; hosts that require complete-history search or copy should operate on their canonical `messages`, `permissions`, and `questions` models.
+Producers with authoritative source chronology can set `IHarnessMessage.order` to `{ messageIndex, partIndex }`; explicitly ordered messages retain that relative order while timestamps continue to place legacy messages and ancillary cards. Consecutive tool calls use one generic responsive-grid pipeline at their chronological position, partitioned by descriptor layout: compact tools share rows with compact tools, subagents share rows only with subagents, and terminal plus file-write cards span a whole row. Consecutive same-layout runs are always capped at four cards per group row, even when their tool kinds differ. Columns respond to the row's own width rather than the viewport, and status changes never regroup cards. Because a compact group sits inside the content measure, its column count is bounded by that measure — two columns at the 820px default; the wider three- and four-column steps apply when a host widens `--dees-harness-content-width`. Rows are held to a reading measure — `--dees-harness-content-width`, default `820px`, capped at the available width — while terminal and file-write rows keep the full pane, so prose stays readable and diffs and command output get the room they need. A subagent group takes the pane only from three cards upward; one or two stay on the measure. A terminal or file-write card keeps the pane only while it is open: once collapsed it returns to the reading measure, because a one-line header does not need the room its output did. This holds for every card in a terminal/file-write group, not only a lone one — those cards span all the columns of their row and stack vertically, so each follows its own disclosure and a collapsed command can sit above an open diff. The row itself still spans the pane; the card surface centres inside it and interpolates between the two widths on the standard disclosure timing, in step with the body height and the outcome line, so a toggle never snaps at either end. A card that mounts collapsed is already at its measure and does not animate into it. The genuinely side-by-side grids — compact tools and subagents — are never offered this width and keep their cell width in both states. The list publishes the collapsed width to its terminal/file-write rows as `--dees-harness-collapsed-tool-width`, derived from `--dees-harness-content-width`; a host can set it on a row to widen those cards, or set `100%` to keep collapsed cards full-bleed; setting it on the chat or the list also reaches compact and subagent cells, so prefer row-level overrides. The docked composer keeps its full-bleed bar and insets its content to the same measure, so the prompt lines up with the messages above it. The status line under the transcript sits on that measure too, so the working indicator starts where the messages start rather than at the pane edge. Set the custom property on the chat or the list to widen or disable the column; it is read when rows are measured, so change it at mount rather than while a virtualized transcript is scrolled. Untouched projected subtask cards collapse individually on completion with the normal disclosure animation; other cards retain their descriptor or user-selected disclosure state. Auto-follow responds to streamed growth but does not repeatedly repin while a disclosure shrinks. Permission requests, questions, and nested-stream limits behave as before. Props: `messages`, `permissions`/`permissionsBusy`, `questions`, `status`, `viewState`, `transcriptKey`, `hasEarlierMessages`, `loadingEarlier`, `autoFollow`, `hideScrollbar`, `fadeScrollEdges`, `showRoles`, `showTimestamps`, `allowSubtaskStreams`, `markdownWhileStreaming` (default `true`), `emptyTitle`/`emptyText` (+ `slot="empty"`). Native browser find and selection cover the mounted window; hosts that require complete-history search or copy should operate on their canonical `messages`, `permissions`, and `questions` models.
 
 #### `DeesHarnessMessage`
 
@@ -2654,7 +2655,7 @@ One message: role accent, markdown (assistant default, `message.markdown` overri
 
 #### `DeesHarnessToolCard`
 
-Tool-call card: shared chrome (icon, label, subtitle, status pill, duration, MCP badges) with a per-kind body. Kind resolution goes through `DeesHarnessToolRegistry` (see below); bodies for the seeded kinds — terminal, file-read, file-write (renders a before/after diff via `dees-dataview-codebox` when the input carries previous content), file-delete, dir-list, browser (inline screenshots), http, json, search, subtask, project-task, todo, mcp, unknown — live in `renderers.ts`. File-write cards retain the user's inline/split choice while the same call updates. Numeric patch hunks preserve their source line numbers; patches and replacement snippets without coordinates hide gutters rather than presenting fabricated positions. A producer-supplied `IHarnessToolCall.title` leads the subtitle when present — a harness's own one-line description of the call, such as `Read SKILL.md` for a shell invocation — and the descriptor-derived line stays reachable as the hover tooltip; a blank title falls back to the derived line. Overflowing subtitles use a 40px right-edge fade and reveal the full line on hover plus once after a two-second initial delay. Expand/collapse always uses a smooth disclosure transition. Initially closed bodies mount lazily on first expansion, then retain the same DOM and become inert plus `aria-hidden` while closed. A closed card also reflects `data-collapsed` on its host and honours `--dees-harness-collapsed-tool-width` as its own `max-width`, so a transcript row can hold a collapsed card to a narrower measure than an open one; unset — a direct tool-card host, a grid cell — the card fills its row in both states. Long outputs truncate at 6,000 chars with a "Show all" expander. Terminal and error cards open by default, and a terminal card collapses itself again once its command has finished without reporting a failure. A producer whose failed commands come back as `completed` with the failure only in the output must signal it through `exitCode`, `isError` or `status: 'error'`, or the card collapses behind its one-line outcome. A missing exit code is not a failure — most harnesses never send one — so a completed command collapses whether or not it reported `exitCode: 0`. A non-zero exit, an error status, `isError`, and a stopped command all keep their output on screen. A collapsed terminal shows a one-line outcome (exit code when the call carried one, line count or `no output`, and the last meaningful line) beneath the command; an exit code is never invented for a call that did not report one. It is derived from the call's own output rather than from any producer-supplied description, so it is present for every producer. An explicit expand or collapse by the user always wins and is never overridden when the call settles. Descriptors opt in through `collapseWhenFinished` and supply the line through `summary`. Terminal output uses a black inner log surface and follows the live tail after reaching the card-height cap. Scrolling upward detaches the tail; leaving the card returns to the bottom after five seconds, while re-entering cancels that pending return. Terminal calls may provide `exitCode` separately when `output` is one combined process stream; the renderer retains support for `{ stdout, stderr, exitCode }` output objects. A subagent card is capped by `--dees-harness-active-subtask-height` (default `320px`) rather than fixed to it: a settled agent whose brief and result fit sizes to its own text, and only content past the cap hands the overflow to the panels, which scroll with a hidden scrollbar and a fade mask at the clipped edge. Both the Agent Brief and the Result carry that affordance, and the drill-in action stays pinned at the bottom of the card. A live child keeps the full window so its streaming transcript has a stable area to scroll in.
+Tool-call card: shared chrome (icon, label, subtitle, status pill, duration, MCP badges) with a per-kind body. Kind resolution goes through `DeesHarnessToolRegistry` (see below); bodies for the seeded kinds — terminal, file-read, file-write (renders a before/after diff via `dees-dataview-codebox` when the input carries previous content), file-delete, dir-list, browser (inline screenshots), http, json, search, subtask, project-task, todo, mcp, unknown — live in `renderers.ts`. File-write cards retain the user's inline/split choice while the same call updates. Numeric patch hunks preserve their source line numbers; patches and replacement snippets without coordinates hide gutters rather than presenting fabricated positions. A producer-supplied `IHarnessToolCall.title` leads the subtitle when present — a harness's own one-line description of the call, such as `Read SKILL.md` for a shell invocation — and the descriptor-derived line stays reachable as the hover tooltip; a blank title falls back to the derived line. Overflowing subtitles use a 40px right-edge fade and reveal the full line on hover plus once after a two-second initial delay. Expand/collapse always uses a smooth disclosure transition: the card surface width, the body height and the collapsed outcome line all run on `--dees-transition-default` with `--dees-ease-standard`, started by the same update, and all three stop together under `prefers-reduced-motion: reduce`. Width is constrained on the card surface rather than the host, because the shared default stylesheet applies a universal background/colour transition to every element and that rule reaches this element from its parent's tree, where it outranks any host-scoped rule. Initially closed bodies mount lazily on first expansion, then retain the same DOM and become inert plus `aria-hidden` while closed; the outcome line likewise stays mounted and is hidden from assistive technology while the card is open. A closed card also reflects `data-collapsed` on its host and honours `--dees-harness-collapsed-tool-width` as its own `max-width`, so a transcript row can hold a collapsed card to a narrower measure than an open one; unset — a direct tool-card host, a grid cell — the card fills its row in both states. Long outputs truncate at 6,000 chars with a "Show all" expander. Terminal and error cards open by default, and a terminal card collapses itself again once its command has finished without reporting a failure. A producer whose failed commands come back as `completed` with the failure only in the output must signal it through `exitCode`, `isError` or `status: 'error'`, or the card collapses behind its one-line outcome. A missing exit code is not a failure — most harnesses never send one — so a completed command collapses whether or not it reported `exitCode: 0`. A non-zero exit, an error status, `isError`, and a stopped command all keep their output on screen. A collapsed terminal shows a one-line outcome (exit code when the call carried one, line count or `no output`, and the last meaningful line) beneath the command, which opens and closes with the same timing as the body so the header never steps by a line; an exit code is never invented for a call that did not report one. It is derived from the call's own output rather than from any producer-supplied description, so it is present for every producer. An explicit expand or collapse by the user always wins and is never overridden when the call settles. Descriptors opt in through `collapseWhenFinished` and supply the line through `summary`. Terminal output uses a black inner log surface and follows the live tail after reaching the card-height cap. Scrolling upward detaches the tail; leaving the card returns to the bottom after five seconds, while re-entering cancels that pending return. Terminal calls may provide `exitCode` separately when `output` is one combined process stream; the renderer retains support for `{ stdout, stderr, exitCode }` output objects. A subagent card is capped by `--dees-harness-active-subtask-height` (default `320px`) rather than fixed to it: a settled agent whose brief and result fit sizes to its own text, and only content past the cap hands the overflow to the panels, which scroll with a hidden scrollbar and a fade mask at the clipped edge. Both the Agent Brief and the Result carry that affordance, and the drill-in action stays pinned at the bottom of the card. A live child keeps the full window so its streaming transcript has a stable area to scroll in.
 
 After mutating a canonical tool call in place, call `refreshCall()`. It refreshes the mounted card, any mounted nested subtask transcript, and any open fullscreen card while retaining the same canonical call and nested-message object references; it does not clone or replace them.
 
@@ -2767,6 +2768,25 @@ Scratchpad edits emit `harness-scratchpad-save` with `{ text, expectedRevision }
 
 Direct sidebar hosts can set `intelligenceAvailabilityStatus`, `intelligenceUnavailableReason`, and `intelligenceHeading`; `intelligenceEnabled` still controls whether the section exists. The properties default to `available`, an empty reason, and `Session Intelligence`. A blank heading falls back to `Session Intelligence`, and unavailable state without a reason renders `<heading> is unavailable.` Only `available` permits `harness-session-intelligence-ask`; checking and unavailable states retain history and expose accessible status text. The availability union is exported as `THarnessIntelligenceAvailabilityStatus`.
 
+#### `DeesHarnessConversationPicker`
+
+Keyboard-first picker for one conversation, or one attachable resource, used wherever a menu would otherwise list every possible target. It is presentation only: it never mutates a session, a resource, or an association — it resolves one choice and leaves the change to the host.
+
+Set `.sessions`, `.groups` and `.resources` to the same models the list renders. `.excludeTargets` removes targets that would be a no-op (a resource's existing attachments), and `.eligibleTargets` restricts the offer to a host-declared allow-list; absent means unrestricted. Typing filters on title, project label and group name — the same fields the session list searches. Up/Down move the active row, Enter picks it, Escape cancels. `harness-picker-choose` carries `{ target: IHarnessSessionListItemRef }`; `harness-picker-cancel` carries nothing.
+
+`DeesHarnessConversationPicker.pick(options)` is the one-call form: it opens the picker inside `DeesModal`, resolves with the chosen ref or `null` on cancel, closes the modal, and returns focus to whatever had it before. Reuse it for disambiguation as well — pass a resource's current attachments as `eligibleTargets` to ask which attachment a Move or Detach applies to.
+
+```typescript
+const target = await DeesHarnessConversationPicker.pick({
+  sessions: list.sessions,
+  groups: list.groups,
+  excludeTargets: currentTargets,
+  eligibleTargets: list.eligibleTargetsByResourceId[resource.id],
+  heading: `Attach ${resource.title} to…`,
+});
+if (target) detail.requestAssociation(target, currentTargets.length ? 'attach-additional' : 'attach');
+```
+
 #### `DeesHarnessSessionList`
 
 Searchable, card-based conversation column for sidebars or a `DeesModal` (`harness-session-select` on click, `harness-session-open` on double-click/Enter). Cards stay collapsed until their independent accessible expansion control is used. Selection and working-state changes do not affect expansion.
@@ -2785,22 +2805,29 @@ The compact **New group** button sits beside search whenever `enableGrouping` is
 
 The Sessions demo pairs the list with a selected-session workspace. Its controls step through starting, working, feedback, approval, completion and failure without timers or backend operations. Question and permission responses update the selected session; declining approval pauses it. The narrow layout switches between the preserved list and detail panes with an **All sessions** control that restores row focus.
 
-Generic host resources use the exported `IHarnessResourceMeta` and `IHarnessResourceAssociation` contracts. Set `.resources`, `.resourceAssociations`, `.selectedResourceId`, and `.eligibleTargetsByResourceId`. Resource rows render as top-level rows in the ordered list, never as children of a session. Optional `projectLabel` renders on the resource metadata line after the kind and is searched like the title and preview. Resource metadata is presentation-only: the list never mounts a terminal, browser, file viewer, or other runtime.
+Generic host resources use the exported `IHarnessResourceMeta` and `IHarnessResourceAssociation` contracts. Set `.resources`, `.resourceAssociations`, `.selectedResourceId`, and `.eligibleTargetsByResourceId`. Resource rows render as top-level rows in the ordered list, never as children of a session. Optional `projectLabel` renders on the resource metadata line after the kind and is searched like the title and preview. A resource can be attached to several items at once: `IHarnessResourceAssociation.targets` is a set of refs, de-duplicated on projection, and the row shows one marker per attachment — two by name, the rest as a `+N` count with every name in the row's title. `IHarnessResourceEventDetail.targets` carries the same set on select, open and context events. Resource metadata is presentation-only: the list never mounts a terminal, browser, file viewer, or other runtime.
 
-**Attaching is a separate explicit action, not a drop.** An association is an access grant: it shows as a decorative marker on the resource row (a link icon plus the target's title, resolved from `sessions` or `resources` regardless of search or collapse) and never moves the row. Dropping is purely positional and never attaches. The association stays single-valued — a resource has at most one target — and the target is any other item, so a resource may be attached to a session **or** to another resource such as a terminal:
+**Attaching is a deliberate gesture, never an accident of reordering.** An association is an access grant: it shows as a decorative marker on the resource row (a link icon plus each target's title, resolved from `sessions` or `resources` regardless of search or collapse) and never moves the row. A resource dropped on the **centre half of a row** attaches to it; the outer quarters of that same row, and every gap between rows, stay purely positional. The row being targeted shows a ring, a tint and a link badge, and no insertion gap opens while it does. A drag attaches an unattached resource and moves a singly attached one. A resource attached to several conversations is only repositioned by drag — it offers no attach affordance on any row, because a drag cannot say which of its attachments was meant; use **Move to…** for that. Keyboard moves stay positional; attaching by keyboard goes through the host's menu. The target is any other item, so a resource may be attached to a session **or** to another resource such as a terminal, and to several at once:
 
 ```typescript
 list.resourceAssociations = [
-  { resourceId: 'file:notes', target: { kind: 'resource', id: 'terminal:build' } },
+  { resourceId: 'file:notes', targets: [{ kind: 'resource', id: 'terminal:build' }] },
+  {
+    resourceId: 'terminal:build',
+    targets: [{ kind: 'session', id: 's-4' }, { kind: 'session', id: 's-0' }],
+  },
 ];
 ```
 
-Association records are projected only when the resource exists, the target exists, the target is not the resource itself, and no earlier record claimed that resource. `eligibleTargetsByResourceId` restricts attach/reassign targets for host menus: a missing entry leaves the resource unrestricted, an empty array means no eligible target. Which resource kinds may host an attachment is the host's rule, not the component's.
+Targets are projected only when the resource exists, the target exists, the target is not the resource itself, and no earlier target in the same record already claimed it. `eligibleTargetsByResourceId` restricts targets for both the host menu and the drop affordance: a missing entry leaves the resource unrestricted, an empty array means no eligible target, and an ineligible row offers no attach affordance and commits nothing. Which resource kinds may host an attachment is the host's rule, not the component's.
+
+`requestResourceAssociation(resourceId, toTarget, source?, mode?, fromTarget?)` and the context detail's `requestAssociation(toTarget, mode?, fromTarget?)` emit `harness-resource-associate` with `THarnessResourceAssociateDetail`: `mode` is `attach`, `attach-additional`, `move` or `detach`, and `fromTarget` names the single attachment being replaced or removed. With no mode, an unattached resource attaches and a singly attached one moves; a resource with several attachments is refused, because only the host knows which one the user meant — pass a mode and a `fromTarget`, or ask with `DeesHarnessConversationPicker`.
 
 ```typescript
-import type {
-  IHarnessResourceContextDetail,
-  THarnessResourceAssociationRequestDetail,
+import {
+  DeesHarnessConversationPicker,
+  type IHarnessResourceContextDetail,
+  type THarnessResourceAssociateDetail,
 } from '@design.estate/dees-catalog';
 
 const list = document.querySelector('dees-harness-session-list')!;
@@ -2810,37 +2837,42 @@ list.resources = [
   { id: 'file:notes', kind: 'file', title: 'Release notes', preview: '6.7.0 draft' },
 ];
 list.resourceAssociations = [
-  { resourceId: 'shell:build', target: { kind: 'session', id: 'session-1' } },
+  { resourceId: 'shell:build', targets: [{ kind: 'session', id: 'session-1' }] },
 ];
 list.eligibleTargetsByResourceId = {
   'shell:build': [{ kind: 'session', id: 'session-1' }, { kind: 'session', id: 'session-2' }],
   'file:notes': [{ kind: 'session', id: 'session-2' }, { kind: 'resource', id: 'shell:build' }],
 };
 
-list.addEventListener('harness-resource-association-request', async (event) => {
-  const resourceEvent = event as CustomEvent<THarnessResourceAssociationRequestDetail>;
-  const { resource, toTarget } = resourceEvent.detail;
-  await persistAssociation(resource.id, toTarget);
+list.addEventListener('harness-resource-associate', async (event) => {
+  const resourceEvent = event as CustomEvent<THarnessResourceAssociateDetail>;
+  const { resource, mode, fromTarget, toTarget } = resourceEvent.detail;
+  await persistAssociation(resource.id, { mode, fromTarget, toTarget });
   list.resourceAssociations = await loadAssociations();
 });
 
-list.addEventListener('harness-resource-context', (event) => {
+list.addEventListener('harness-resource-context', async (event) => {
   const resourceEvent = event as CustomEvent<IHarnessResourceContextDetail>;
-  openHostMenu({
-    x: resourceEvent.detail.clientX,
-    y: resourceEvent.detail.clientY,
-    attach: (target) => resourceEvent.detail.requestAssociation(target),
-    detach: () => resourceEvent.detail.requestAssociation(null),
-    onClose: resourceEvent.detail.close,
+  const { resource, targets } = resourceEvent.detail;
+  resourceEvent.detail.close();
+  const target = await DeesHarnessConversationPicker.pick({
+    sessions: list.sessions,
+    groups: list.groups,
+    excludeTargets: targets,
+    eligibleTargets: list.eligibleTargetsByResourceId[resource.id],
+    heading: `Attach ${resource.title} to…`,
   });
+  if (target) {
+    resourceEvent.detail.requestAssociation(target, targets.length ? 'attach-additional' : 'attach');
+  }
 });
 ```
 
-`harness-resource-select` and `harness-resource-open` carry `{ resource, target }`, where `target` is the controlled association ref or null. `harness-resource-context` adds viewport coordinates, the pointer/Actions/keyboard source, the original event, `requestAssociation(toTarget)`, and `close()` for focus restoration. The visible Actions button has menu disclosure semantics; native `ContextMenu` and `Shift+F10` invoke the same host-owned path. The component does not require `DeesContextmenu` and does not own menu choices.
+`harness-resource-select` and `harness-resource-open` carry `{ resource, targets }`, where `targets` is the controlled set of association refs and is empty for an unattached resource. `harness-resource-context` adds viewport coordinates, the pointer/Actions/keyboard source, the original event, `requestAssociation(toTarget, mode?, fromTarget?)`, and `close()` for focus restoration. The visible Actions button has menu disclosure semantics; native `ContextMenu` and `Shift+F10` invoke the same host-owned path. The component does not require `DeesContextmenu` and does not own menu choices.
 
-All component-originated association request paths converge on the public `requestResourceAssociation(resourceId, toTarget, source?)` method. A valid change emits one bubbling/composed `harness-resource-association-request` discriminated by `intent: 'attach' | 'detach' | 'reassign'` and carrying `resource`, `fromTarget`, `toTarget`, and `source: 'action' | 'keyboard'`. The method returns `false` and emits nothing for unknown resources, unknown or ineligible targets, a target that is the resource itself, detach from an unattached resource, or the current target. It never mutates resources, associations, selection, groups, or order.
+All component-originated association paths converge on the public `requestResourceAssociation(resourceId, toTarget, source?, mode?, fromTarget?)` method. A valid change emits one bubbling/composed `harness-resource-associate` discriminated by `mode: 'attach' | 'attach-additional' | 'move' | 'detach'` and carrying `resource`, `fromTarget`, `toTarget`, and `source: 'action' | 'keyboard' | 'pointer'`. The method returns `false` and emits nothing for unknown resources, unknown or ineligible targets, a target that is the resource itself, a target already in the set, a `move`/`detach` whose `fromTarget` is not in the set, an `attach` on an already attached resource, an `attach-additional` on an unattached one, or an ambiguous request with no mode. It never mutates resources, associations, selection, groups, or order.
 
-Association projection is deterministic and non-destructive: resource records without a non-empty ID, kind, or title, unknown resource/target references, self-targets, and later duplicate records for a resource are ignored; the first valid association wins. Duplicate resource metadata IDs likewise use the first resource. Eligibility does not hide an existing authoritative association, which remains visible and detachable. Requested changes are announced separately from completion; completion is announced only after the controlled association input reflects the requested target.
+Association projection is deterministic and non-destructive: resource records without a non-empty ID, kind, or title, unknown resource/target references, self-targets, and repeated targets are ignored; several records for one resource merge into one de-duplicated set. Duplicate resource metadata IDs likewise use the first resource. Eligibility does not hide an existing authoritative association, which remains visible and detachable. Requested changes are announced separately from completion; completion is announced only after the controlled association input reflects the requested set.
 
 Search covers resource ID, kind, title, and preview, and matches sessions and resources as peers — a matching session no longer reveals its attached resources, and a matching resource no longer reveals its target. Resources render with zero sessions. Resource dragging edge-scrolls the list exactly like session dragging and emits only `harness-item-move`. Use the Actions/context path for keyboard and mobile association workflows; coarse-pointer grip and Actions targets are at least 44px.
 

package/ts_web/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@design.estate/dees-catalog',
-  version: '11.2.1',
+  version: '12.0.0',
   description: 'A comprehensive library that provides dynamic web components for building sophisticated and modern web applications using JavaScript and TypeScript.'
 }

package/ts_web/elements/00group-harness/dees-harness-conversation-picker/dees-harness-conversation-picker.demo.ts

@@ -0,0 +1,46 @@
+import { html } from '@design.estate/dees-element';
+import { demoPage } from '../../../demos/templates.js';
+import type { IHarnessSessionGroup, IHarnessSessionMeta, IHarnessResourceMeta } from '../interfaces.js';
+
+const demoSessions: IHarnessSessionMeta[] = [
+  { id: 's1', title: 'Fix sitemap cache key', projectLabel: 'storefront', updatedAt: Date.now() - 1_000 },
+  { id: 's2', title: 'Investigate model rate limits', projectLabel: 'gateway', updatedAt: Date.now() - 2_000 },
+  { id: 's3', title: 'Prepare the catalog release', projectLabel: 'catalog', updatedAt: Date.now() - 3_000 },
+  { id: 's4', title: 'Improve agent onboarding', updatedAt: Date.now() - 4_000 },
+];
+
+const demoResources: IHarnessResourceMeta[] = [
+  { id: 'terminal:build', kind: 'terminal', title: 'Build shell', icon: 'lucide:Terminal', projectLabel: 'storefront' },
+];
+
+const demoGroups: IHarnessSessionGroup[] = [
+  { id: 'active', name: 'Workspace', itemIds: [{ kind: 'session', id: 's1' }, { kind: 'session', id: 's2' }] },
+  { id: 'review', name: 'Review', itemIds: [{ kind: 'session', id: 's3' }] },
+];
+
+export const demoFunc = () => demoPage(
+  'Conversation picker',
+  'Keyboard-first target picker: type to filter on title, project label or group, Enter picks, Escape cancels.',
+  html`
+    <style>
+      .pickerDemo {
+        max-width: 420px;
+        padding: 16px;
+        border: 1px solid var(--dees-color-border-subtle);
+        border-radius: var(--dees-radius-xl);
+        background: var(--dees-color-bg-secondary);
+      }
+    </style>
+    <div class="pickerDemo">
+      <dees-harness-conversation-picker
+        heading="Attach Build shell to…"
+        .sessions=${demoSessions}
+        .groups=${demoGroups}
+        .resources=${demoResources}
+        .excludeTargets=${[{ kind: 'session' as const, id: 's4' }]}
+        @harness-picker-choose=${(event: CustomEvent) => console.log('picked', event.detail.target)}
+        @harness-picker-cancel=${() => console.log('cancelled')}
+      ></dees-harness-conversation-picker>
+    </div>
+  `,
+);