maka-agent 0.2.0-dev.24.20260907 → 0.2.0-dev.26.20260909

package/dist/pi-tui-transcript-viewer.js

@@ -16,8 +16,9 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { Key, matchesKey, truncateToWidth, visibleWidth, } from '@earendil-works/pi-tui';
-import { ansi } from './tui-ansi.js';
+import { Key, Input, isKeyRelease, isKeyRepeat, matchesKey, truncateToWidth, visibleWidth, } from '@earendil-works/pi-tui';
+import { ansi, stripAnsi } from './tui-ansi.js';
+import { TUI_COPY_RESOURCES } from './tui-copy-catalog.js';
 const VIEWER_CHROME_ROWS = 2;
 /**
  * Full-screen, read-only navigation over the CLI transcript projection.
@@ -28,19 +29,100 @@ const VIEWER_CHROME_ROWS = 2;
  */
 export class TranscriptViewerOverlay {
     input;
+    focused = false;
     top = 0;
     documentRows = 0;
     bodyRows = 0;
     followsEnd = true;
+    document = { lines: [], anchors: [] };
+    expanded = true;
+    anchor;
+    search = new Input();
+    searching = false;
+    query = '';
+    matches = [];
+    searchOrigin;
+    matchedLine;
     constructor(input) {
         this.input = input;
     }
     invalidate() { }
     handleInput(data) {
+        if (isKeyRelease(data))
+            return;
+        if (matchesKey(data, Key.ctrl('o'))) {
+            if (!isKeyRepeat(data))
+                this.input.onClose();
+            return;
+        }
+        if (this.searching) {
+            if (matchesKey(data, Key.escape)) {
+                this.searching = false;
+                this.query = '';
+                this.matches = [];
+                if (this.searchOrigin)
+                    Object.assign(this, this.searchOrigin);
+                this.input.onChange();
+                return;
+            }
+            if (matchesKey(data, Key.enter)) {
+                this.searching = false;
+                this.input.onChange();
+                return;
+            }
+            if (matchesKey(data, Key.up) || matchesKey(data, Key.down)) {
+                this.nextMatch(matchesKey(data, Key.up) ? -1 : 1);
+                return;
+            }
+            this.search.handleInput(data);
+            const query = this.search.getValue().trim().toLocaleLowerCase();
+            if (query !== this.query) {
+                this.query = query;
+                this.findMatches();
+                const target = this.matches.find((line) => line >= (this.searchOrigin?.top ?? 0)) ?? this.matches[0];
+                if (target !== undefined)
+                    this.goToMatch(target);
+            }
+            this.input.onChange();
+            return;
+        }
+        if (matchesKey(data, Key.escape) && this.query) {
+            this.query = '';
+            this.matches = [];
+            if (this.searchOrigin)
+                Object.assign(this, this.searchOrigin);
+            this.input.onChange();
+            return;
+        }
         if (matchesKey(data, Key.escape) || matchesKey(data, 'q')) {
             this.input.onClose();
             return;
         }
+        if (matchesKey(data, '/')) {
+            this.searchOrigin = {
+                top: this.top,
+                followsEnd: this.followsEnd,
+                anchor: this.anchor ? { ...this.anchor } : undefined,
+            };
+            this.search.setValue(this.query);
+            this.searching = true;
+            this.input.onChange();
+            return;
+        }
+        if (this.query && (matchesKey(data, 'n') || matchesKey(data, Key.shift('n')))) {
+            this.nextMatch(matchesKey(data, Key.shift('n')) ? -1 : 1);
+            return;
+        }
+        if (matchesKey(data, Key.ctrl('e'))) {
+            if (!isKeyRepeat(data)) {
+                this.expanded = !this.expanded;
+                // A detail that disappears on collapse returns to its own heading.
+                if (!this.expanded && this.anchor)
+                    this.anchor.offset = 0;
+                this.input.onChange();
+            }
+            return;
+        }
         if (matchesKey(data, Key.up)) {
             this.scrollBy(-1);
             return;
@@ -60,12 +142,14 @@ export class TranscriptViewerOverlay {
         if (matchesKey(data, Key.home)) {
             this.followsEnd = false;
             this.top = 0;
+            this.captureAnchor();
             this.input.onChange();
             return;
         }
         if (matchesKey(data, Key.end)) {
             this.followsEnd = true;
             this.top = this.maxTop();
+            this.captureAnchor();
             this.input.onChange();
         }
     }
@@ -76,31 +160,74 @@ export class TranscriptViewerOverlay {
         // navigation chrome only. The footer appears once header + body + footer fit.
         const showFooter = viewportRows > 2;
         this.bodyRows = Math.max(0, viewportRows - (showFooter ? VIEWER_CHROME_ROWS : 1));
-        const document = [...this.input.renderTranscript(safeWidth)];
+        this.document = this.input.renderTranscript(safeWidth, this.expanded);
+        const document = this.document.lines;
         this.documentRows = document.length;
+        if (!this.followsEnd && this.anchor) {
+            const index = this.document.anchors.findIndex((entry) => entry.id === this.anchor.id);
+            if (index >= 0) {
+                const entry = this.document.anchors[index];
+                const end = this.document.anchors[index + 1]?.line ?? document.length;
+                this.top = entry.line + Math.min(this.anchor.offset, Math.max(0, end - entry.line - 1));
+            }
+        }
         const maxTop = this.maxTop();
         this.top = this.followsEnd ? maxTop : clamp(this.top, 0, maxTop);
-        this.followsEnd = this.top === maxTop;
+        this.captureAnchor();
+        this.findMatches();
         const visible = document.slice(this.top, this.top + this.bodyRows);
         const start = visible.length === 0 ? 0 : this.top + 1;
         const end = visible.length === 0 ? 0 : this.top + visible.length;
-        const header = padLine(`${ansi.bold('TRANSCRIPT')} ${ansi.dim(`${start}-${end} of ${document.length}`)}`, safeWidth);
+        const copy = TUI_COPY_RESOURCES['transcript-reader'][this.input.locale ?? 'en'];
+        const header = padLine(`${ansi.bold(copy.title)} ${ansi.dim(`${start}-${end}/${document.length} · ${copy.scope}`)}`, safeWidth);
+        const matchingLines = new Set(this.matches);
         const body = [
-            ...visible.map((line) => padLine(line, safeWidth)),
+            ...visible.map((line, index) => padLine(matchingLines.has(this.top + index) ? ansi.reverse(stripAnsi(line)) : line, safeWidth)),
             ...Array.from({ length: Math.max(0, this.bodyRows - visible.length) }, () => ' '.repeat(safeWidth)),
         ];
         if (!showFooter)
             return [header, ...body];
-        const footer = padLine(ansi.dim('↑/↓ scroll · PgUp/PgDn page · Home/End jump · q/Esc close'), safeWidth);
+        this.search.focused = this.focused && this.searching;
+        const footer = padLine(this.searching
+            ? `/ ${this.search.render(Math.max(1, safeWidth - 3))[0] ?? ''}`
+            : ansi.dim(this.query
+                ? `${this.matches.length} ${copy.matches} · n/N · Esc ${copy.back}`
+                : copy.hint), safeWidth);
         return [header, ...body, footer];
     }
     scrollBy(delta) {
+        this.matchedLine = undefined;
         const maxTop = this.maxTop();
         this.top = clamp(this.top + delta, 0, maxTop);
         // Follow the tail whenever the clamped position is the end, including the
         // no-op case where a short transcript cannot move at all: a stray Up key
         // must not pin the viewer at the head once the transcript grows.
         this.followsEnd = this.top === maxTop;
+        this.captureAnchor();
+        this.input.onChange();
+    }
+    captureAnchor() {
+        const entry = [...this.document.anchors].reverse().find((entry) => entry.line <= this.top);
+        this.anchor = entry ? { id: entry.id, offset: this.top - entry.line } : undefined;
+    }
+    findMatches() {
+        this.matches = this.query
+            ? this.document.lines.flatMap((line, index) => stripAnsi(line).toLocaleLowerCase().includes(this.query) ? [index] : [])
+            : [];
+    }
+    goToMatch(line) {
+        this.matchedLine = line;
+        this.top = clamp(line, 0, this.maxTop());
+        this.followsEnd = false;
+        this.captureAnchor();
+    }
+    nextMatch(direction) {
+        const current = this.matchedLine ?? this.top;
+        const line = direction > 0
+            ? (this.matches.find((line) => line > current) ?? this.matches[0])
+            : ([...this.matches].reverse().find((line) => line < current) ?? this.matches.at(-1));
+        if (line !== undefined)
+            this.goToMatch(line);
         this.input.onChange();
     }
     maxTop() {

package/dist/runtime-host-cli-context.js

@@ -20,8 +20,8 @@ import { activateLocalManagedRuntimeHost } from './runtime-host-local-managed-ac
 import { randomUUID } from 'node:crypto';
 import { join } from 'node:path';
 import { NO_REAL_CONNECTION_CODE } from '@maka/core/connection-error-copy';
-import { connectOrSpawnRuntimeHost, connectRuntimeHost, connectRuntimeHostProfile, createClientRuntimeHostProfileCatalog, createRuntimeHostPeerClientFromEnvironment, createRuntimeHostReconnectingConnection, loadOrCreateRuntimeHostClientInstanceId, LOCAL_RUNTIME_HOST_PROFILE, readRuntimeHostConnectionCatalog, RuntimeHostPermanentReconnectError, RuntimeHostRemoteCompatibilityError, runHostHandoff, runtimeHostStartupError, } from '@maka/runtime-host/client';
-import { INTERACTIVE_RUNTIME_HOST_COMPOSITION_ID, RUNTIME_HOST_PROTOCOL_VERSION, } from '@maka/runtime-host/protocol';
+import { connectOrSpawnRuntimeHost, forceTerminateObservedRegisteredRuntimeHost, connectRuntimeHost, connectRuntimeHostProfile, createClientRuntimeHostProfileCatalog, createRuntimeHostPeerClientFromEnvironment, createRuntimeHostReconnectingConnection, loadOrCreateRuntimeHostClientInstanceId, LOCAL_RUNTIME_HOST_PROFILE, readRuntimeHostConnectionCatalog, RuntimeHostPermanentReconnectError, RuntimeHostRemoteCompatibilityError, runHostHandoff, runtimeHostStartupError, } from '@maka/runtime-host/client';
+import { INTERACTIVE_RUNTIME_HOST_COMPOSITION_ID, RUNTIME_HOST_PROTOCOL_VERSION, RUNTIME_HOST_COMPATIBILITY_EPOCH, } from '@maka/runtime-host/protocol';
 import { readLocalHostDeploymentRecord, resolveRuntimeHostManagedDeploymentAuthority, } from '@maka/runtime-host/operator';
 import { resolveMakaClientDataRoot } from '@maka/storage/workspace-root';
 import { isTemporaryNpxInstallation, resolveRuntimeHostNpmGlobalInstallation, } from './runtime-host-cli-installation.js';
@@ -70,6 +70,7 @@ export async function connectRuntimeHostCliConnection(input, overrides = {}) {
         createPeerClient: createRuntimeHostPeerClientFromEnvironment,
         resolveInstallation: resolveRuntimeHostNpmGlobalInstallation,
         isTemporaryNpxInstallation,
+        terminateObservedHost: forceTerminateObservedRegisteredRuntimeHost,
         restartDeployment: restartRuntimeHostNpmGlobalDeployment,
         sourceRetirementAvailable: runtimeHostNpmGlobalSourceRetirementAvailable,
         ...overrides,
@@ -157,6 +158,7 @@ export async function connectRuntimeHostCliConnection(input, overrides = {}) {
                     : await deps.readDeploymentRecord(connected.registration.rootId);
                 let replacement;
                 let installation;
+                let installationFailure;
                 // On-demand managed Hosts are also ephemeral processes. Their durable
                 // operator authority, not the process lifetime label, decides who may
                 // replace them (including when the Host was already running).
@@ -164,8 +166,8 @@ export async function connectRuntimeHostCliConnection(input, overrides = {}) {
                     try {
                         installation = await deps.resolveInstallation();
                     }
-                    catch {
-                        /* No persistent installation authority. */
+                    catch (error) {
+                        installationFailure = error instanceof Error ? error.message : String(error);
                     }
                     const owner = record?.state.kind === 'handoff' ? record.state.from : record?.state.owner;
                     if (installation &&
@@ -173,15 +175,16 @@ export async function connectRuntimeHostCliConnection(input, overrides = {}) {
                             (owner.kind === installation.owner.kind &&
                                 owner.installationId === installation.owner.installationId))) {
                         const expectedInstallation = installation;
-                        const canInterrupt = record
-                            ? await deps
-                                .sourceRetirementAvailable({
-                                rootId: connected.registration.rootId,
-                                owner: installation.owner,
-                                source: record.state.selected,
-                            })
-                                .catch(() => false)
-                            : false;
+                        const canInterrupt = connected.processIdentity !== undefined ||
+                            (record
+                                ? await deps
+                                    .sourceRetirementAvailable({
+                                    rootId: connected.registration.rootId,
+                                    owner: installation.owner,
+                                    source: record.state.selected,
+                                })
+                                    .catch(() => false)
+                                : false);
                         replacement = {
                             kind: record?.state.kind === 'handoff' ? 'repair' : 'replace',
                             canReplaceIdle: true,
@@ -190,6 +193,9 @@ export async function connectRuntimeHostCliConnection(input, overrides = {}) {
                                 const result = await deps.restartDeployment({
                                     rootPath: input.rootPath,
                                     registration: connected.registration,
+                                    ...(connected.processIdentity
+                                        ? { processIdentity: connected.processIdentity }
+                                        : {}),
                                     activeWorkPolicy,
                                     expectedInstallation,
                                     ...(attemptSignal ? { signal: attemptSignal } : {}),
@@ -210,11 +216,45 @@ export async function connectRuntimeHostCliConnection(input, overrides = {}) {
                         };
                     }
                 }
+                // The same observed-process recovery used by Desktop is available to
+                // persistent local invocations without a deployment owner. This is an
+                // explicit interruption, never an idle inference or an installation claim.
+                const processIdentity = connected.processIdentity;
+                if (!replacement &&
+                    !managed &&
+                    !record &&
+                    !invocationOwned &&
+                    connected.registration.lifecycleMode === 'ephemeral' &&
+                    processIdentity) {
+                    const registration = connected.registration;
+                    replacement = {
+                        kind: 'replace',
+                        canReplaceIdle: false,
+                        canInterrupt: true,
+                        execute: async (policy, progress, consent, attemptSignal) => {
+                            if (policy !== 'interrupt_active_work' || consent !== 'explicit') {
+                                return { kind: 'active_work' };
+                            }
+                            attemptSignal?.throwIfAborted();
+                            if ((await deps.resolveManagedAuthority(registration.rootId)) ||
+                                (await deps.readDeploymentRecord(registration.rootId)))
+                                return { kind: 'changed' };
+                            attemptSignal?.throwIfAborted();
+                            progress('retiring');
+                            const stopped = await deps.terminateObservedHost({ rootPath: input.rootPath, registration }, { processIdentity, isCurrent: () => !signal?.aborted && !attemptSignal?.aborted });
+                            if (!stopped)
+                                return { kind: 'changed' };
+                            progress('verifying');
+                            return { kind: 'completed' };
+                        },
+                    };
+                }
                 return {
                     kind: 'blocked',
                     blocker: {
                         identity: JSON.stringify([
                             connected.registration,
+                            processIdentity,
                             managed?.record,
                             record,
                             installation,
@@ -226,6 +266,23 @@ export async function connectRuntimeHostCliConnection(input, overrides = {}) {
                             hostEpoch: connected.registration.hostEpoch,
                         },
                         reason: record?.state.kind === 'handoff' ? 'repair' : 'upgrade',
+                        ...(!replacement
+                            ? {
+                                recoveryBlocker: managed || connected.registration.lifecycleMode === 'service'
+                                    ? 'managed'
+                                    : record
+                                        ? 'owner'
+                                        : invocationOwned
+                                            ? 'installation'
+                                            : 'identity',
+                                diagnostic: [
+                                    `Host compatibility: ${connected.registration.compatibilityEpoch}; client: ${RUNTIME_HOST_COMPATIBILITY_EPOCH}.`,
+                                    installationFailure,
+                                ]
+                                    .filter(Boolean)
+                                    .join('\n'),
+                            }
+                            : {}),
                         ...(connected.handshake?.activity ? { activity: connected.handshake.activity } : {}),
                         mayExitNaturally: !managed &&
                             connected.registration.lifecycleMode === 'ephemeral' &&

package/dist/runtime-host-handoff-surface.js

@@ -16,37 +16,25 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { createInterface } from 'node:readline';
+import { clearLine, createInterface, cursorTo } from 'node:readline';
 import { stripVTControlCharacters } from 'node:util';
 import { formatHostHandoff, } from '@maka/runtime-host/client';
-/** One readline lifetime renders the shared decision; it never selects replacement policy. */
+/** The surface owns terminal input; replacement policy stays in the shared handoff. */
 export function createCliHostHandoffSurface(locale, input = process.stdin, output = process.stderr) {
     return (submit) => {
-        const readline = createInterface({ input, output, terminal: output.isTTY === true });
+        let readline;
         let current;
         let closed = false;
         let ended = false;
+        const releaseReader = () => {
+            const previous = readline;
+            readline = undefined;
+            previous?.close();
+        };
         const cancel = () => {
             if (current)
                 submit(current.revision, 'cancel');
         };
-        readline.on('SIGINT', cancel);
-        readline.on('close', () => {
-            ended = true;
-            if (!closed)
-                cancel();
-        });
-        readline.on('line', (line) => {
-            if (!current)
-                return;
-            const answer = line.trim().toLowerCase();
-            const action = answer === 'r' ? 'retry' : answer === 'stop' ? 'interrupt' : 'cancel';
-            if (!current.actions.includes(action)) {
-                readline.prompt();
-                return;
-            }
-            submit(current.revision, action);
-        });
         return {
             update(view) {
                 if (closed || current?.revision === view.revision)
@@ -56,9 +44,13 @@ export function createCliHostHandoffSurface(locale, input = process.stdin, outpu
                     cancel();
                     return;
                 }
-                // Discard partially typed consent when the observed target/consequences change.
-                if (output.isTTY)
-                    readline.write(null, { ctrl: true, name: 'u' });
+                // A new observation gets a new input buffer. Ctrl+U leaves text after
+                // the cursor intact and is ignored by readline in TERM=dumb.
+                releaseReader();
+                if (output.isTTY) {
+                    clearLine(output, 0);
+                    cursorTo(output, 0);
+                }
                 const copy = formatHostHandoff(view, locale);
                 const text = [copy.title, copy.description, copy.detail, view.diagnostic]
                     .filter(Boolean)
@@ -69,12 +61,45 @@ export function createCliHostHandoffSurface(locale, input = process.stdin, outpu
                 if (view.actions.length === 0)
                     return;
                 const options = copy.actions.map(({ action, label }) => `${action === 'interrupt' ? 'stop' : action === 'retry' ? 'r' : 'Enter'}: ${label}`);
-                readline.setPrompt(options.join(' · ') + ' > ');
-                readline.prompt();
+                // Create the reader only after the explanation is visible, with the
+                // final action prompt already installed. Never draw readline's default >.
+                const reader = createInterface({
+                    input,
+                    output,
+                    terminal: output.isTTY === true,
+                    prompt: options.join(' · ') + ' > ',
+                });
+                readline = reader;
+                reader.on('SIGINT', cancel);
+                reader.on('close', () => {
+                    if (readline !== reader)
+                        return;
+                    ended = true;
+                    if (!closed)
+                        cancel();
+                });
+                reader.on('line', (line) => {
+                    if (readline !== reader || current?.revision !== view.revision)
+                        return;
+                    const answer = line.trim().toLowerCase();
+                    const action = answer === 'r'
+                        ? 'retry'
+                        : answer === 'stop'
+                            ? 'interrupt'
+                            : answer === ''
+                                ? 'cancel'
+                                : undefined;
+                    if (!action || !view.actions.includes(action)) {
+                        reader.prompt();
+                        return;
+                    }
+                    submit(view.revision, action);
+                });
+                reader.prompt();
             },
             close() {
                 closed = true;
-                readline.close();
+                releaseReader();
             },
         };
     };

package/dist/runtime-host-local-handoff.js

@@ -23,7 +23,7 @@ import { dirname, join, posix, resolve, win32 } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import { claimLocalHostProcessDeployment, handoffLocalHostProcessDeployment, readLocalHostDeploymentRecord, resolveRuntimeHostManagedDeploymentAuthority, } from '@maka/runtime-host/operator';
 import { compareProductReleaseVersions } from '@maka/runtime-host/operator/update-package-evidence';
-import { connectExistingRuntimeHost } from '@maka/runtime-host/client';
+import { connectExistingRuntimeHost, forceTerminateObservedRegisteredRuntimeHost, } from '@maka/runtime-host/client';
 import { INTERACTIVE_RUNTIME_HOST_COMPOSITION_ID, RUNTIME_HOST_PROTOCOL_VERSION, } from '@maka/runtime-host/protocol';
 import { resolveRuntimeHostNpmGlobalInstallation, } from './runtime-host-cli-installation.js';
 import { openRuntimeHostPackageDeployment, prepareRuntimeHostPackageDeployment, resolveRuntimeHostPackageCliPath, } from './runtime-host-package-deployment.js';
@@ -73,6 +73,7 @@ export async function restartRuntimeHostNpmGlobalDeployment(input, authorityOpti
         connectExisting: connectExistingRuntimeHost,
         activateTarget: launchRuntimeHostTargetActivator,
         retireSource: launchRuntimeHostLocalSourceRetirement,
+        terminateObservedHost: forceTerminateObservedRegisteredRuntimeHost,
         ...overrides,
     };
     if (await deps.resolveManagedAuthority(input.registration.rootId)) {
@@ -205,6 +206,15 @@ export async function restartRuntimeHostNpmGlobalDeployment(input, authorityOpti
             }
             return { kind: 'target_present' };
         }
+        // Older source packages cannot negotiate retirement. Explicit consent may
+        // use Desktop's exact-process recovery, inside this existing deployment
+        // transaction and only after staging the verified successor.
+        if (activeWorkPolicy === 'interrupt_active_work' && input.processIdentity) {
+            input.signal?.throwIfAborted();
+            const stopped = await deps.terminateObservedHost({ rootPath: input.rootPath, registration: input.registration }, { processIdentity: input.processIdentity, isCurrent: () => !input.signal?.aborted });
+            if (!stopped)
+                throw new Error('The observed Runtime Host changed before it could be stopped safely');
+        }
         const activated = await activateExactTarget(rootId, stagedTarget, inheritableAuthorityLeaseFd, registration.hostEpoch);
         if (activated === 'active_work')
             return { kind: 'active_work' };

package/dist/runtime-host-service-manager.js

@@ -670,9 +670,6 @@ async function normalizeStateRoot(requestedRoot) {
         throw new RuntimeHostServiceManagerError('invalid_config', `Invalid Runtime Host State Root: ${requestedRoot}`, { cause: error });
     }
 }
-export async function resolveRuntimeHostManagedStateRoot(requestedRoot) {
-    return normalizeStateRoot(requestedRoot);
-}
 async function normalizeProjectDirectoryRoots(roots) {
     let canonicalRoots;
     try {

package/dist/runtime-host-session-channel.js

@@ -37,6 +37,7 @@ export class RuntimeHostSessionChannel {
     #now;
     #onTurnStarted;
     #onRuntimeResourceChanged;
+    #onSessionDomainChanged;
     #onInteractionPending;
     #onInteractionResolved;
     #onTranscriptSettlement;
@@ -71,6 +72,7 @@ export class RuntimeHostSessionChannel {
         this.#now = options.now;
         this.#onTurnStarted = options.onTurnStarted;
         this.#onRuntimeResourceChanged = options.onRuntimeResourceChanged;
+        this.#onSessionDomainChanged = options.onSessionDomainChanged;
         this.#onInteractionPending = options.onInteractionPending;
         this.#onInteractionResolved = options.onInteractionResolved;
         this.#onTranscriptSettlement = options.onTranscriptSettlement;
@@ -79,6 +81,16 @@ export class RuntimeHostSessionChannel {
         this.#onSnapshotChanged = options.onSnapshotChanged;
         this.#onFailed = options.onFailed;
         this.#onRecovered = options.onRecovered;
+        this.#subscribeSessionDomainChanges(subscription);
+    }
+    #subscribeSessionDomainChanges(subscription) {
+        if (!this.#onSessionDomainChanged)
+            return;
+        subscription.subscribeSessionDomainChanges((frame) => {
+            if (!this.#closing && this.#subscription === subscription) {
+                this.#onSessionDomainChanged?.(frame);
+            }
+        });
     }
     static async open(options) {
         const subscription = await options.connection.openSessionSubscription({
@@ -343,6 +355,7 @@ export class RuntimeHostSessionChannel {
                 return;
             }
             this.#subscription = replacement;
+            this.#subscribeSessionDomainChanges(replacement);
             this.#ready = false;
             this.#pendingFrames.length = 0;
             void this.#pump(replacement);

package/dist/runtime-host-session-driver.js

@@ -20,6 +20,7 @@ import { randomUUID } from 'node:crypto';
 import { join } from 'node:path';
 import { DEFAULT_SESSION_NAME } from '@maka/core/session-name';
 import { decodeStoredMessage as decodePersistedStoredMessage, deriveTurnRecords, userFacingText, } from '@maka/core/session';
+import { projectSessionTodoItemsForDisplay } from '@maka/core/session-todo';
 import { markPersisted } from '@maka/core/persisted-value';
 import { isSideConversationSession } from '@maka/core/side-conversation';
 import { createSessionCopyCleanupAuthority, } from '@maka/storage/session-copy-cleanup';
@@ -88,6 +89,7 @@ class RuntimeHostMakaSessionDriverImpl {
     #transcriptRefreshSequence = 0;
     #startedTurnListeners = new Set();
     #goalListeners = new Set();
+    #todoChangeListeners = new Set();
     #pendingInteractionListeners = new Set();
     #claimedTurnIds = new Set();
     #shellRunListeners = new Set();
@@ -381,6 +383,22 @@ class RuntimeHostMakaSessionDriverImpl {
         const sessionId = await this.#ensureSession();
         return this.#request('turn.message.query', { sessionId, messageIds });
     }
+    async queryTodo(sessionId) {
+        const currentSessionId = this.#requireSession('query Todo');
+        if (sessionId !== currentSessionId) {
+            throw new Error(`Cannot query Todo for a non-current Session: ${sessionId}`);
+        }
+        const sessionGeneration = this.#sessionGeneration;
+        const result = await this.#request('session.todo.query', { sessionId });
+        this.#assertCurrentSession(sessionId, sessionGeneration);
+        if (result.sessionId !== sessionId) {
+            throw new Error(`Runtime Host returned Todo for an unexpected Session: ${result.sessionId}`);
+        }
+        return {
+            sessionId,
+            items: projectSessionTodoItemsForDisplay(result.items),
+        };
+    }
     async retractQueued() {
         if (!this.#sessionId)
             return { text: '', messageIds: [] };
@@ -856,6 +874,10 @@ class RuntimeHostMakaSessionDriverImpl {
         this.#goalListeners.add(listener);
         return () => this.#goalListeners.delete(listener);
     }
+    subscribeTodoChanges(listener) {
+        this.#todoChangeListeners.add(listener);
+        return () => this.#todoChangeListeners.delete(listener);
+    }
     async controlGoal(action) {
         const sessionId = this.#sessionId;
         if (!sessionId)
@@ -1246,6 +1268,7 @@ class RuntimeHostMakaSessionDriverImpl {
             now: this.#now,
             onTurnStarted: (turn) => this.#publishStartedTurn(turn, sessionGeneration),
             onRuntimeResourceChanged: (sourceSessionId, ref) => this.#publishRuntimeResource(sourceSessionId, ref),
+            onSessionDomainChanged: (frame) => this.#publishSessionDomainChanged(frame, sessionId, sessionGeneration),
             onInteractionPending: (pending) => {
                 for (const listener of this.#pendingInteractionListeners)
                     listener(pending);
@@ -1261,9 +1284,27 @@ class RuntimeHostMakaSessionDriverImpl {
                 for (const listener of this.#goalListeners)
                     listener(goal);
             },
-            onRecovered: () => this.#refreshRuntimeResources(sessionId),
+            onRecovered: () => {
+                this.#refreshRuntimeResources(sessionId);
+                this.#publishTodoChanged(sessionId, sessionGeneration);
+            },
         });
     }
+    #publishSessionDomainChanged(frame, sessionId, sessionGeneration) {
+        if (frame.domain !== 'todo' ||
+            frame.sessionId !== sessionId ||
+            this.#sessionId !== sessionId ||
+            this.#sessionGeneration !== sessionGeneration) {
+            return;
+        }
+        this.#publishTodoChanged(sessionId, sessionGeneration);
+    }
+    #publishTodoChanged(sessionId, sessionGeneration) {
+        if (this.#sessionId !== sessionId || this.#sessionGeneration !== sessionGeneration)
+            return;
+        for (const listener of this.#todoChangeListeners)
+            listener(sessionId);
+    }
     #publishRuntimeResource(sourceSessionId, ref) {
         void this.#request('runtime.resource.query', {
             kind: 'get',

package/dist/tui-autocomplete-layout.js

@@ -17,6 +17,7 @@
  * under the License.
  */
 import { selectListTheme, stripAnsi } from './tui-ansi.js';
+import { stripUnfocusedCursorStyle } from './tui-editor-render.js';
 export function arrangeAutocompleteAboveEditor(input) {
     if (!input.autocompleteShowing) {
         return { lines: input.lines, autocompleteSlotRows: 0, editorRows: input.lines.length };
@@ -72,7 +73,8 @@ export class MakaAutocompleteAboveEditorComponent {
         this.editor.handleInput(data);
     }
     render(width) {
-        const lines = this.editor.render(width);
+        const renderedLines = this.editor.render(width);
+        const lines = stripUnfocusedCursorStyle(renderedLines, this.editor.focused);
         const result = arrangeAutocompleteAboveEditor({
             lines,
             autocompleteShowing: this.editor.isShowingAutocomplete(),