@kortix/ui 0.14.11 → 0.14.13

package/dist/session/composer/composer.js

@@ -5,7 +5,8 @@ import { useUiHostConfig } from '../../providers/ui-provider.js';
 import { useTranslations } from '../../i18n/index.js';
 import { cn } from '../../lib/utils.js';
 import { isImageFile } from '../../internal/lib/utils/file-utils.js';
-import { usePromptAttachments, useRuntimeSessions } from '@kortix/sdk/react';
+import { useProjectConfig, usePromptAttachments, useRuntimeSessions } from '@kortix/sdk/react';
+import { useActiveSpace } from '../../internal/stores/active-space-store.js';
 import { newPastedContentId, splitPastedContent, trimPastedText } from '../../_vendor/kortix-shared.js';
 import { memo, useCallback, useEffect, useId, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore, } from 'react';
 import { extractClipboardFiles } from './clipboard-files.js';
@@ -16,7 +17,6 @@ import { isModelRequiredButUnavailable, NO_MODEL_AVAILABLE_ACTION_MESSAGE, NO_MO
 import { useModelConnectionGate } from '../models/use-model-connection-gate.js';
 import { NO_AGENT_ACCESS_HINT, NO_AGENT_ACCESS_LABEL } from './composer-agent-access.js';
 import { useComposerDropZone } from './composer-drop-zone.js';
-import { useComposerEscapeStop } from './hooks/use-composer-escape-stop.js';
 import { finishedDraftUploads, keepUnsentUploadFile, restoreDraftUploads } from './draft/draft-uploads.js';
 import { useComposerDraft } from './draft/use-composer-draft.js';
 import { commandBlocker, sendBlocker, sendBlockerMessage } from './send-blockers.js';
@@ -110,7 +110,7 @@ function setDocumentWithoutStealingFocus(handle, doc) {
     }
 }
 function ComposerImpl(props) {
-    const { onSend, promptAttachments: hostPromptAttachments, isBusy = false, sessionWorking, runtimeReady = true, onStop, stopDisabled = false, canStop = true, isSending = false, rewind, agents = EMPTY_AGENTS, selectedAgent = null, onAgentChange, noAccessibleAgents = false, commands: runtimeCommands = EMPTY_COMMANDS, 
+    const { onSend, promptAttachments: hostPromptAttachments, isBusy = false, sessionWorking, runtimeReady = true, onStop, stopDisabled = false, isSending = false, rewind, agents = EMPTY_AGENTS, selectedAgent = null, onAgentChange, noAccessibleAgents = false, commands: runtimeCommands = EMPTY_COMMANDS, 
     /** Whether the live command list has EVER resolved — see `planUnresolvedCommandChip`. */
     commandsResolved = false, slashFiles = EMPTY_SLASH_FILES, onCommand, onHoldCommand, models = EMPTY_MODELS, selectedModel = null, onModelChange, modelDefaultControls, variants = EMPTY_VARIANTS, selectedVariant = null, onVariantChange, messages, sessionId, projectId, draftScope = null, draftActive = true, disabled = false, notice = null, onNoticeRetry, clearOnSend = true, modelRequired = false, modelsLoading = false, autoFocus, placeholder = 'Ask anything…', hint, onArrowUpAtStart, prefill = null, onPrefillApplied, attachRequestId = null, providers, onContextClick, onCompactClick, inputSlot, toolbarSlot, underbarPlacement = 'below', slashMenuPlacement = 'above', cardClassName, quoteRequests = NO_QUOTE_REQUESTS, onQuoteRequestsApplied, lockForQuestion = false, lockForApproval = false, onCustomAnswer, questionButtonLabel = null, questionCanAct = true, onQuestionAction, escCount = 0, parentClassName, } = props;
     const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
@@ -317,7 +317,19 @@ function ComposerImpl(props) {
         handleDocChange(doc, isEmpty);
     }, [handleDocChange]);
     const { data: allSessions } = useRuntimeSessions();
-    const primaryAgents = useMemo(() => agents.filter((a) => !a.hidden && a.mode !== 'subagent'), [agents]);
+    // Scope the startable agents to the active space (the sidebar's Spaces
+    // selection): in a space you start only that space's agents. The current
+    // agent is always kept so a session's own agent never disappears while you
+    // are viewing another space. No space selected = every agent, as before.
+    const [activeSpace] = useActiveSpace(projectId ?? '');
+    const scopeConfig = useProjectConfig(projectId);
+    const primaryAgents = useMemo(() => {
+        const base = agents.filter((a) => !a.hidden && a.mode !== 'subagent');
+        if (!activeSpace || !scopeConfig)
+            return base;
+        const spaceByName = new Map(scopeConfig.agents.map((a) => [a.name, a.space ?? null]));
+        return base.filter((a) => spaceByName.get(a.name) === activeSpace || a.name === selectedAgent);
+    }, [agents, activeSpace, scopeConfig, selectedAgent]);
     const editorDisabled = disabled || lockForApproval;
     const appendAttachedFiles = useCallback((files) => {
         // The host keeps files in its own store: they go there, not to the session.
@@ -676,12 +688,6 @@ function ComposerImpl(props) {
     const canSubmit = !isEmpty ||
         attachedFiles.length > 0 ||
         (!lockForQuestion && (quotes.length > 0 || pastes.length > 0));
-    useComposerEscapeStop({
-        editorElement,
-        enabled: isBusy && canStop && !stopDisabled && !isSending && !lockForQuestion && !props.submitLabel,
-        hasDraft: canSubmit,
-        onStop,
-    });
     /**
      * No agent may run this prompt. Refused here rather than at the server:
      * `lockForQuestion` is exempt because answering an open question is not a new

package/dist/session/composer/editor/composer-editor.js

@@ -1,9 +1,9 @@
 'use client';
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useTranslations } from '../../../i18n/index.js';
 import { cn } from '../../../lib/utils.js';
 import { EditorContent, useEditor } from '@tiptap/react';
-import { forwardRef, useEffect, useImperativeHandle, useMemo, useRef } from 'react';
+import { forwardRef, useEffect, useImperativeHandle, useMemo, useRef, useState } from 'react';
 import { textToParagraphs } from '../composer-logic.js';
 import { COMPOSER_TEXT_METRICS } from '../composer-text-metrics.js';
 import { useLatestRef } from '../hooks/use-latest-ref.js';
@@ -15,6 +15,7 @@ import { isCursorOnFirstVisualLine } from './first-visual-line.js';
 import { MentionNode } from './mention-node.js';
 import { serializeDocument } from './serialize.js';
 import { createSuggestionExtension } from './suggestion.js';
+import { UltracodeHighlight } from './ultracode.js';
 /**
  * Wraps `onEmptyChange` so it fires ONLY on the empty<->non-empty boundary.
  * Exported (rather than kept as an inline `useEditor({ onUpdate })` closure)
@@ -161,8 +162,16 @@ export function insertTextAtCursor(editor, text) {
         return;
     editor.commands.insertContent(content);
 }
+/** The dismiss shortcut as the person's keyboard prints it. */
+function dismissKeyLabel() {
+    const platform = typeof navigator !== 'undefined' ? navigator.platform || navigator.userAgent : '';
+    return /Mac|iPhone|iPad/.test(platform) ? '⌥W' : 'Alt+W';
+}
 export const ComposerEditor = forwardRef(function ComposerEditor({ placeholder, disabled, autoFocus = false, onSubmit, onArrowUpAtStart, onEmptyChange, onDocChange, agents, sessions, currentSessionId, commands, onSelectCommand, onSelectAction, actions, files, slashDockSelector, onMenuOpenChange, }, ref) {
     const t = useTranslations('threads');
+    const tUltracode = useTranslations('multiAgent.ultracode');
+    // A marked `ultracode` keyword: the one-line hint under the text says what it does.
+    const [ultracodeActive, setUltracodeActive] = useState(false);
     const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
     const defaultActions = useMemo(() => localizedSlashActions(tI18nComplete), [tI18nComplete]);
     // Mirrors use-composer-focus.ts's onTypeAheadRef: @tiptap/react only
@@ -277,6 +286,8 @@ export const ComposerEditor = forwardRef(function ComposerEditor({ placeholder,
         extensions: [
             ...baseExtensions(() => placeholderRef.current),
             MentionNode,
+            // `setUltracodeActive` is a state setter: stable, so freezing it at construction is safe.
+            UltracodeHighlight.configure({ onActiveChange: setUltracodeActive }),
             // The one `@tiptap/suggestion` code path both `@` and `/` register
             // through (editor/suggestion.ts's `createSuggestionExtension`).
             // Built fresh every render like every extension above, but only the
@@ -427,10 +438,10 @@ export const ComposerEditor = forwardRef(function ComposerEditor({ placeholder,
         isEmpty: () => editor?.isEmpty ?? true,
         getElement: () => (editor && !editor.isDestroyed ? editor.view.dom : null),
     }), [editor]);
-    return (_jsx(EditorContent, { editor: editor, className: cn(
-        // `text-base` (16px) on mobile, NOT 15px: iOS Safari force-zooms the
-        // page on focus for any input under 16px, and the composer is the one
-        // field on the screen. `sm:text-sm` above 640px, which is the size
-        // `styles/components.css`'s slash-trigger rule already documents.
-        'kortix-composer-editor w-full text-sm', disabled && 'opacity-50') }));
+    return (_jsxs(_Fragment, { children: [_jsx(EditorContent, { editor: editor, className: cn(
+                // `text-base` (16px) on mobile, NOT 15px: iOS Safari force-zooms the
+                // page on focus for any input under 16px, and the composer is the one
+                // field on the screen. `sm:text-sm` above 640px, which is the size
+                // `styles/components.css`'s slash-trigger rule already documents.
+                'kortix-composer-editor w-full text-sm', disabled && 'opacity-50') }), ultracodeActive ? (_jsxs("p", { "data-slot": "ultracode-hint", className: "text-muted-foreground mt-1 truncate text-xs", children: [tUltracode('hint'), _jsx("span", { "aria-hidden": true, className: "px-1", children: "\u00B7" }), tUltracode('dismiss', { key: dismissKeyLabel() })] })) : null] }));
 });

package/dist/session/composer/editor/ultracode.d.ts

@@ -0,0 +1,34 @@
+import { Extension } from '@tiptap/core';
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model';
+import { PluginKey, type EditorState, type Transaction } from '@tiptap/pm/state';
+import { DecorationSet } from '@tiptap/pm/view';
+/** The utility classes of a marked keyword: the mention chip's tint, no padding (the caret must not jump). */
+export declare const ULTRACODE_MARK_CLASS = "kortix-ultracode rounded-sm bg-primary/[0.08] font-medium text-foreground";
+export interface UltracodeRange {
+    from: number;
+    to: number;
+}
+/** Every occurrence of the keyword in a document, as document positions. */
+export declare function findUltracodeRanges(doc: ProseMirrorNode): UltracodeRange[];
+/** True for a plain-text keyword check (the sent prompt, a test). Same rule as the editor mark. */
+export declare function hasUltracodeKeyword(text: string): boolean;
+export interface UltracodeState {
+    /** The person dismissed the keyword for this prompt. */
+    dismissed: boolean;
+    ranges: UltracodeRange[];
+    /** At least one marked keyword: the host shows the hint. */
+    active: boolean;
+    decorations: DecorationSet;
+}
+export declare const ultracodePluginKey: PluginKey<UltracodeState>;
+/** The next state after a transaction: a dismiss meta sets it, an empty document resets it. */
+export declare function nextUltracodeState(tr: Transaction, previous: UltracodeState, state: EditorState): UltracodeState;
+/** Dismiss the keyword for this prompt. Returns false when nothing is marked. */
+export declare function dismissUltracode(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;
+/** Alt+W anywhere, or Backspace with the caret right after a marked keyword. */
+export declare function isUltracodeDismissKey(event: Pick<KeyboardEvent, 'key' | 'code' | 'altKey' | 'ctrlKey' | 'metaKey' | 'shiftKey'>, state: EditorState): boolean;
+export interface UltracodeOptions {
+    /** Fires when the hint should appear or go: a marked keyword exists, or none does. */
+    onActiveChange?: (active: boolean) => void;
+}
+export declare const UltracodeHighlight: Extension<UltracodeOptions, any>;

package/dist/session/composer/editor/ultracode.js

@@ -0,0 +1,127 @@
+import { Extension } from '@tiptap/core';
+import { Plugin, PluginKey } from '@tiptap/pm/state';
+import { Decoration, DecorationSet } from '@tiptap/pm/view';
+/**
+ * The `ultracode` keyword, as Claude Code's dynamic workflows treat it: a
+ * prompt that holds the word runs as a workflow of agents. The composer marks
+ * each occurrence in place and the host shows a one-line hint, so the person
+ * sees the opt-in before they send. The prompt text never changes: the word
+ * is sent as typed, and the agent reads it.
+ *
+ * Alt+W (Option+W on a Mac), or Backspace right after a marked word, dismisses
+ * the mark and the hint for this prompt. A dismissed prompt stays dismissed
+ * while the person keeps typing; an empty composer (the prompt was sent or
+ * cleared) arms the keyword again.
+ */
+/** Whole word, any case. `\b` keeps `ultracoder` and `myultracode` plain text. */
+const KEYWORD = /\bultracode\b/gi;
+/** The utility classes of a marked keyword: the mention chip's tint, no padding (the caret must not jump). */
+export const ULTRACODE_MARK_CLASS = 'kortix-ultracode rounded-sm bg-primary/[0.08] font-medium text-foreground';
+/** Every occurrence of the keyword in a document, as document positions. */
+export function findUltracodeRanges(doc) {
+    const ranges = [];
+    doc.descendants((node, pos) => {
+        if (!node.isText || !node.text)
+            return;
+        for (const match of node.text.matchAll(KEYWORD)) {
+            const from = pos + (match.index ?? 0);
+            ranges.push({ from, to: from + match[0].length });
+        }
+    });
+    return ranges;
+}
+/** True for a plain-text keyword check (the sent prompt, a test). Same rule as the editor mark. */
+export function hasUltracodeKeyword(text) {
+    KEYWORD.lastIndex = 0;
+    const found = KEYWORD.test(text);
+    KEYWORD.lastIndex = 0;
+    return found;
+}
+export const ultracodePluginKey = new PluginKey('ultracode');
+const isBlank = (doc) => doc.textContent.trim().length === 0;
+function stateFor(doc, dismissed) {
+    const ranges = dismissed ? [] : findUltracodeRanges(doc);
+    return {
+        dismissed,
+        ranges,
+        active: ranges.length > 0,
+        decorations: ranges.length
+            ? DecorationSet.create(doc, ranges.map(({ from, to }) => Decoration.inline(from, to, { class: ULTRACODE_MARK_CLASS, 'data-ultracode': '' })))
+            : DecorationSet.empty,
+    };
+}
+/** The next state after a transaction: a dismiss meta sets it, an empty document resets it. */
+export function nextUltracodeState(tr, previous, state) {
+    const meta = tr.getMeta(ultracodePluginKey);
+    let dismissed = meta?.dismiss ? true : previous.dismissed;
+    if (dismissed && isBlank(state.doc))
+        dismissed = false;
+    if (!tr.docChanged && dismissed === previous.dismissed)
+        return previous;
+    return stateFor(state.doc, dismissed);
+}
+/** Dismiss the keyword for this prompt. Returns false when nothing is marked. */
+export function dismissUltracode(state, dispatch) {
+    if (!ultracodePluginKey.getState(state)?.active)
+        return false;
+    dispatch?.(state.tr.setMeta(ultracodePluginKey, { dismiss: true }));
+    return true;
+}
+/** Alt+W anywhere, or Backspace with the caret right after a marked keyword. */
+export function isUltracodeDismissKey(event, state) {
+    const plugin = ultracodePluginKey.getState(state);
+    if (!plugin?.active)
+        return false;
+    // `code`, not `key`: Option+W on a Mac types `∑`.
+    if (event.altKey && !event.ctrlKey && !event.metaKey && event.code === 'KeyW')
+        return true;
+    if (event.key !== 'Backspace' || event.altKey || event.ctrlKey || event.metaKey || event.shiftKey)
+        return false;
+    const { empty, from } = state.selection;
+    return empty && plugin.ranges.some((range) => range.to === from);
+}
+export const UltracodeHighlight = Extension.create({
+    name: 'ultracodeHighlight',
+    addOptions() {
+        return { onActiveChange: undefined };
+    },
+    addProseMirrorPlugins() {
+        const options = this.options;
+        return [
+            new Plugin({
+                key: ultracodePluginKey,
+                state: {
+                    init: (_config, state) => stateFor(state.doc, false),
+                    apply: (tr, previous, _old, state) => nextUltracodeState(tr, previous, state),
+                },
+                props: {
+                    decorations: (state) => ultracodePluginKey.getState(state)?.decorations ?? DecorationSet.empty,
+                    handleKeyDown: (view, event) => {
+                        if (!isUltracodeDismissKey(event, view.state))
+                            return false;
+                        event.preventDefault();
+                        return dismissUltracode(view.state, view.dispatch);
+                    },
+                },
+                view: (view) => {
+                    let reported = ultracodePluginKey.getState(view.state)?.active ?? false;
+                    if (reported)
+                        options.onActiveChange?.(true);
+                    return {
+                        update: (next) => {
+                            const active = ultracodePluginKey.getState(next.state)?.active ?? false;
+                            if (active === reported)
+                                return;
+                            reported = active;
+                            options.onActiveChange?.(active);
+                        },
+                        destroy: () => {
+                            if (reported)
+                                options.onActiveChange?.(false);
+                        },
+                    };
+                },
+            }),
+        ];
+    },
+});

package/dist/session/composer/index.d.ts

@@ -15,6 +15,7 @@ export { type DraftScope } from './draft/composer-draft.js';
 export { ComposerEditor, type ComposerEditorHandle } from './editor/composer-editor.js';
 export { baseExtensions } from './editor/extensions.js';
 export { MentionNode } from './editor/mention-node.js';
+export { MentionChip } from '../thread/mention-chip.js';
 export { baseSuggestion, type MenuController } from './editor/suggestion.js';
 export { ReasoningEffortSelector } from './reasoning-effort-selector.js';
 export { SessionChatInput, type SessionChatInputProps } from './session-chat-input.js';

package/dist/session/composer/index.js

@@ -14,6 +14,7 @@ export { ComposerUnderbar } from './composer-underbar.js';
 export { ComposerEditor } from './editor/composer-editor.js';
 export { baseExtensions } from './editor/extensions.js';
 export { MentionNode } from './editor/mention-node.js';
+export { MentionChip } from '../thread/mention-chip.js';
 export { baseSuggestion } from './editor/suggestion.js';
 export { ReasoningEffortSelector } from './reasoning-effort-selector.js';
 export { SessionChatInput } from './session-chat-input.js';

package/dist/session/composer/send-blockers.d.ts

@@ -26,17 +26,7 @@ import type { UiTranslator } from '../../i18n/index.js';
  *
  * Two gates from the old set are deliberately NOT here:
  *
- *   - `revertStaged`. It blocked the auto-drain from firing into a trajectory
- *     the user had asked to discard. There is no auto-drain, and a staged
- *     revert is precisely the state in which the user types their REPLACEMENT
- *     prompt — refusing it would make edit-and-resend impossible. The
- *     replacement prompt IS what commits the revert: OpenCode truncates on the
- *     next delivery, from any producer. The server's own guard
- *     (`queuedContinueHasStagedRevert`,
- *     `apps/api/src/projects/session-lifecycle/engine.ts`) lets a prompt that
- *     never waited commit the revert for that reason, and refuses the rows that
- *     queued BEFORE it — for every client, which a gate in this tab could never
- *     do.
+ *   - `revertStaged`. No runtime stages a revert: pi answers rewind `501`.
  *   - `isServerBusy`, for a PROMPT. That is the inbox's decision now.
  *   - `runtimeReady`, for a PROMPT. A prompt typed at a sleeping box becomes an
  *     inbox row and is delivered when the box answers. A COMMAND cannot: see

package/dist/session/composer/send-blockers.js

@@ -25,17 +25,7 @@
  *
  * Two gates from the old set are deliberately NOT here:
  *
- *   - `revertStaged`. It blocked the auto-drain from firing into a trajectory
- *     the user had asked to discard. There is no auto-drain, and a staged
- *     revert is precisely the state in which the user types their REPLACEMENT
- *     prompt — refusing it would make edit-and-resend impossible. The
- *     replacement prompt IS what commits the revert: OpenCode truncates on the
- *     next delivery, from any producer. The server's own guard
- *     (`queuedContinueHasStagedRevert`,
- *     `apps/api/src/projects/session-lifecycle/engine.ts`) lets a prompt that
- *     never waited commit the revert for that reason, and refuses the rows that
- *     queued BEFORE it — for every client, which a gate in this tab could never
- *     do.
+ *   - `revertStaged`. No runtime stages a revert: pi answers rewind `501`.
  *   - `isServerBusy`, for a PROMPT. That is the inbox's decision now.
  *   - `runtimeReady`, for a PROMPT. A prompt typed at a sleeping box becomes an
  *     inbox row and is delivered when the box answers. A COMMAND cannot: see

package/dist/session/composer/session-composer-readiness.d.ts

@@ -26,7 +26,6 @@
  * — the composer stays usable, and this module's job shrinks to one thing:
  * saying what is going on.
  */
-import { type SessionConnection } from '@kortix/sdk';
 export interface SessionComposerReadiness {
     /** The runtime is up. False means a submit becomes a queued inbox row rather
      *  than a delivery. */
@@ -86,11 +85,6 @@ export declare function serverHoldsOpenTurn(working: {
 }): boolean;
 export declare function sessionComposerReadiness(input: {
     runtimeReady: boolean;
-    /** A prompt sent from this page is waiting for the computer. Its turn
-     *  already shows it working; do not ask for another message. */
-    pendingPrompt?: boolean;
-    /** A queued status already describes this send; do not ask for another. */
-    pendingDelivery?: boolean;
     /**
      * The CONTROL PLANE holds an open turn for this session right now — pass
      * `serverHoldsOpenTurn(working)`, never `working.source === 'server'`.
@@ -115,27 +109,6 @@ export declare function sessionComposerReadiness(input: {
      * "indistinguishable from stuck" failure this module exists to prevent.
      */
     stalled?: boolean;
-    /**
-     * This page's own `/start` is bringing the computer up: its stage is
-     * `provisioning` or `starting`, or it has not answered yet. A stopped
-     * computer is then WAKING, not idle, and the composer must not claim the
-     * next message is what wakes it.
-     */
-    starting?: boolean;
-    /**
-     * The shared connection projection (`projectSessionConnection`).
-     *
-     * This is what replaced a settle TIMER here. The timer was the same mistake
-     * this module keeps having to unlearn: it guessed how long to stay quiet
-     * instead of asking whether anything was actually wrong, so it was always
-     * either too short (the notice flashed over a live session) or too long (a
-     * genuinely parked box announced itself late).
-     *
-     * `unknown` and `connecting` are WAITS. Only `waking` with no wake under
-     * way — the control plane saying the box is down, and nothing bringing it
-     * up — earns a notice: the asleep one.
-     */
-    connection?: SessionConnection;
 }): SessionComposerReadiness;
 /**
  * The last turn's shimmer, decided once in `SessionChat` and passed down to
@@ -145,7 +118,7 @@ export declare function sessionComposerReadiness(input: {
  * `GET .../turn`), already delay-hidden 300ms by the caller — never the raw
  * SSE slot, which this tab can miss frames from: a dropped end-of-turn frame
  * latched the slot busy and shimmered a finished answer until reload. A
- * transient sub-session (`sub-session-modal.tsx` mounts `SessionChat` with no
+ * transient sub-session (`legacy-subagent-chat.tsx` mounts `SessionChat` with no
  * `projectSessionId`) has no Kortix session row for `/turn` to answer about,
  * so it keeps the raw slot — the same split `session-layout.tsx` makes for
  * its busy indicator. A non-last turn is NEVER working: that is a fact about

package/dist/session/composer/session-composer-readiness.js

@@ -92,22 +92,11 @@ export function sessionComposerReadiness(input) {
             retryable: true,
         };
     }
-    if (input.connection === 'waking') {
-        // A PARKED / idle box: the control plane says the sandbox is not up, and
-        // nothing is actively booting — a genuine boot-stall is caught by `stalled`
-        // above, and the SDK no longer arms the stall clock for a parked box
-        // (`setOpenCodeHealth({ parked })`), so this never escalates to an infinite
-        // "taking longer than usual" spinner. The box resumes on the next SEND, so
-        // say exactly that: an honest idle state (RC-3). A wake already under way
-        // says nothing: opening the session wakes its computer in the background,
-        // and a send goes out as soon as it is up.
-        const waking = input.pendingPrompt || input.pendingDelivery || input.starting;
-        return { ready: false, notice: waking ? null : SESSION_NOTICE.idle, retryable: false };
-    }
-    // A wait is not a fault, and a routine wake is silent: `unknown` means
+    // A wait is not a fault, and sleep and wake are silent: `unknown` means
     // nothing has answered, `connecting` that the box is up and the runtime has
-    // not reached us yet, and a waking box comes up in the background while a
-    // send queues. A wake that goes wrong speaks through `stalled` or
+    // not reached us yet, and `waking` that the box is parked or coming up. A
+    // parked box wakes on the next send, so the user never needs to know it
+    // slept. A wake that goes wrong speaks through `stalled` or
     // `unreachable` above.
     return { ready: false, notice: null, retryable: false };
 }
@@ -119,7 +108,7 @@ export function sessionComposerReadiness(input) {
  * `GET .../turn`), already delay-hidden 300ms by the caller — never the raw
  * SSE slot, which this tab can miss frames from: a dropped end-of-turn frame
  * latched the slot busy and shimmered a finished answer until reload. A
- * transient sub-session (`sub-session-modal.tsx` mounts `SessionChat` with no
+ * transient sub-session (`legacy-subagent-chat.tsx` mounts `SessionChat` with no
  * `projectSessionId`) has no Kortix session row for `/turn` to answer about,
  * so it keeps the raw slot — the same split `session-layout.tsx` makes for
  * its busy indicator. A non-last turn is NEVER working: that is a fact about

package/dist/session/header/reminder-parts.d.ts

@@ -22,7 +22,7 @@ export declare function useReminderView(now: number): (reminder: SessionReminder
     nextAt: number;
     countdown: [string, string | null];
     share: number | null;
-    tone: "purple" | "red";
+    tone: "red" | "purple";
     pauseLabel: string;
     schedule: string;
     meta: string;

package/dist/session/header/session-site-header.js

@@ -25,7 +25,8 @@ import { SessionPendingApprovalsIndicator } from './session-pending-approvals-in
 import { SessionGoalIndicator } from './session-goal-indicator.js';
 import { SessionRemindersIndicator } from './session-reminders-indicator.js';
 import { SessionTitleInput } from './session-title-input.js';
-import { SubagentHoverCard, subagentTitle } from './subagent-hover-card.js';
+import { subagentTitle } from '../agents/agent-model.js';
+import { SubagentHoverCard } from './subagent-hover-card.js';
 import { Copy } from '../../icons/copy.js';
 import { Home } from '../../internal/icons/home.js';
 import { openSessionQuickView } from '../panel/open-session-quick-view.js';
@@ -41,7 +42,7 @@ import { cn } from '../../lib/utils.js';
 import { useSessionHistoryViewStore } from '../../internal/stores/session-history-view-store.js';
 import { useIsActionPanelOpen, useReadyChip, useToggleActionPanel, } from '../../internal/stores/kortix-computer-store.js';
 import { createProjectSession, directSubsessions, restartProjectSession, stopProjectSession } from '@kortix/sdk';
-import { qk, useProjectSession, useRuntimeSupports, useSessionParticipants, useSessionWatch, } from '@kortix/sdk/react';
+import { qk, useHasSessionDesktop, useProjectSession, useRuntimeSupports, useSessionParticipants, useSessionWatch, } from '@kortix/sdk/react';
 import { ArchiveIcon, ArrowsClockwiseIcon, BellIcon, BellSlashIcon, CaretDoubleLeftIcon, GitForkIcon, LinkSimpleIcon, CaretDownIcon, CodeSimpleIcon as Code2, FileArrowDownIcon as FileDown, FolderSimpleIcon, GlobeSimpleIcon, MonitorIcon, StackIcon as Layers, PencilSimpleIcon, PushPinIcon, PushPinSlashIcon, ArrowCounterClockwiseIcon as RotateCcw, ShareIcon as Share, SquareIcon as Square, TerminalIcon, TrashIcon, } from '@phosphor-icons/react';
 import { useMutation, useQueryClient } from '@tanstack/react-query';
 import { useMemo, useRef, useState } from 'react';
@@ -64,7 +65,9 @@ export function SessionSiteHeader({ sessionId, sessionTitle, isMobileView, leadi
     const localizedDevTools = useLocalizedUiCatalog(DEV_TOOLS);
     // A host that cannot reach the pty WebSocket turns the terminal off (`config.terminalEnabled`).
     const { terminalEnabled } = useUiHostConfig();
-    const devTools = useMemo(() => (terminalEnabled ? localizedDevTools : localizedDevTools.filter((tool) => tool.view !== 'terminal')), [localizedDevTools, terminalEnabled]);
+    // A template on a base other than Ubuntu 24.04, or an old image, has no desktop.
+    const hasDesktop = useHasSessionDesktop() === true;
+    const devTools = useMemo(() => localizedDevTools.filter((tool) => (tool.view !== 'terminal' || terminalEnabled) && (tool.view !== 'desktop' || hasDesktop)), [localizedDevTools, terminalEnabled, hasDesktop]);
     const router = useUiRouter();
     const pathname = useUiPathname();
     const queryClient = useQueryClient();

package/dist/session/header/subagent-hover-card.d.ts

@@ -1,7 +1,5 @@
 import type { ProjectRuntimeSession } from '@kortix/sdk';
 import { type ReactElement } from 'react';
-/** A subsession's own title, without OpenCode's "(@general subagent)" suffix. */
-export declare function subagentTitle(title: string): string;
 /**
  * The parent session's title, on hover: the subagent sessions it spawned.
  *

package/dist/session/header/subagent-hover-card.js

@@ -9,11 +9,8 @@ import { shortRelative } from '../actions/project-session-list-helpers.js';
 import { useTranslations } from '../../i18n/index.js';
 import { formatDistanceToNowStrict } from 'date-fns';
 import { useState } from 'react';
+import { subagentTitle } from '../agents/agent-model.js';
 import { childSessionHref } from '../tool/tools/session-spawn-urls.js';
-/** A subsession's own title, without OpenCode's "(@general subagent)" suffix. */
-export function subagentTitle(title) {
-    return title.replace(/\s*\(@[^)]*subagent\)$/, '');
-}
 /**
  * The parent session's title, on hover: the subagent sessions it spawned.
  *

package/dist/session/models/claude-connection-slot.d.ts

@@ -0,0 +1,11 @@
+/** Which Claude fix a failed turn needs, from the error text, if any. */
+export declare function claudeConnectionAction(text: string | null | undefined): 'connect' | 'reconnect' | null;
+/**
+ * The fix for a turn that failed on the viewer's Claude login: the provider
+ * list (Customize → Models → Providers), where Anthropic signs in with Claude,
+ * as every other subscription does. Renders on a project route only.
+ */
+export declare function ClaudeConnectionSlot({ action, className }: {
+    action: 'connect' | 'reconnect';
+    className?: string;
+}): import("react").JSX.Element | null;

package/dist/session/models/claude-connection-slot.js

@@ -0,0 +1,30 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button } from '../../primitives/button.js';
+import { useTranslations } from '../../i18n/index.js';
+import { useModelConnectionGate } from './use-model-connection-gate.js';
+/** The turn error kortixd writes when the session user has no Claude login (`CLAUDE_CONNECT_MESSAGE`). */
+const CLAUDE_CONNECT_MESSAGE = 'Connect your Claude subscription to use Claude models.';
+/** The turn error kortixd writes when Anthropic refused the stored login (`CLAUDE_RECONNECT_MESSAGE`). */
+const CLAUDE_RECONNECT_MESSAGE = 'Your Claude subscription login stopped working. Reconnect Claude to continue.';
+/** Which Claude fix a failed turn needs, from the error text, if any. */
+export function claudeConnectionAction(text) {
+    const value = (text ?? '').trim();
+    if (value.includes(CLAUDE_CONNECT_MESSAGE))
+        return 'connect';
+    if (value.includes(CLAUDE_RECONNECT_MESSAGE))
+        return 'reconnect';
+    return null;
+}
+/**
+ * The fix for a turn that failed on the viewer's Claude login: the provider
+ * list (Customize → Models → Providers), where Anthropic signs in with Claude,
+ * as every other subscription does. Renders on a project route only.
+ */
+export function ClaudeConnectionSlot({ action, className = 'mt-2 pl-7' }) {
+    const t = useTranslations('claudeSubscription');
+    const { canConnectProvider, openConnectProvider, modal } = useModelConnectionGate();
+    if (!canConnectProvider)
+        return null;
+    return (_jsxs("div", { className: className, children: [modal, _jsx(Button, { size: "sm", className: "active:scale-[0.96]", onClick: () => openConnectProvider('providers'), children: t(action === 'reconnect' ? 'reconnectClaude' : 'connectClaude') })] }));
+}

package/dist/session/models/model-availability.d.ts

@@ -21,9 +21,11 @@ export declare function unavailableModelConnection(model: {
     enabled?: boolean;
     available?: boolean;
     availability?: 'login' | 'provider';
+    providerID?: string;
+    provider?: string | null;
 }, options: {
     chatGptAvailable: boolean;
-}): 'chatgpt' | 'provider' | null;
+}): 'chatgpt' | 'claude' | 'provider' | null;
 export declare function resolveAvailableSelectedModel(selectedModel: ModelKey | null | undefined, isSelectableModel: (model: ModelKey) => boolean): ModelKey | null;
 /**
  * The name of the selected model when it cannot read an attached image, else null.

package/dist/session/models/model-availability.js

@@ -18,6 +18,9 @@ export function isRunnableModel(model) {
 export function unavailableModelConnection(model, options) {
     if (model.available !== false)
         return null;
+    // A Claude subscription model needs the caller's own Claude login, never a project provider.
+    if (model.providerID === 'claude-agent' || model.provider === 'claude-agent')
+        return 'claude';
     return model.availability === 'login' && options.chatGptAvailable ? 'chatgpt' : 'provider';
 }
 export function resolveAvailableSelectedModel(selectedModel, isSelectableModel) {