maka-agent 0.2.0-dev.43.20260919 → 0.2.0-dev.45.20260921

package/node_modules/@maka/runtime/dist/opencode-session-header.js

@@ -17,11 +17,10 @@
  * under the License.
  */
 export const OPENCODE_SESSION_HEADER = 'x-opencode-session';
-/** Adds OpenCode Go/Free session identity without overriding an explicit header. */
+/** Adds OpenCode Go session identity without overriding an explicit header. */
 export function withOpenCodeSessionHeader(providerType, sessionId, headers) {
     const normalizedSessionId = sessionId?.trim();
-    if ((providerType !== 'opencode-go' && providerType !== 'opencode-free') ||
-        !normalizedSessionId) {
+    if (providerType !== 'opencode-go' || !normalizedSessionId) {
         return headers;
     }
     if (Object.keys(headers ?? {}).some((name) => name.toLowerCase() === OPENCODE_SESSION_HEADER)) {

package/node_modules/@maka/runtime/dist/recall-tools.js

@@ -230,6 +230,10 @@ function projectPassage(passage, activeSessionId) {
         title: passage.sessionTitle,
         ...(passage.turnId ? { turn_id: passage.turnId } : {}),
         anchor_message_id: passage.anchorMessageId,
+        // The anchor's index in its Session transcript. Carried for the same
+        // reason a UI needs it: a caller that wants to point at the passage in a
+        // transcript scrolls by sequence, and this spares it a second lookup.
+        sequence: passage.sequence,
         is_current_session: passage.sessionId === activeSessionId,
         ...(passage.lastMessageAt !== undefined ? { last_message_at: passage.lastMessageAt } : {}),
         matched_terms: passage.matchedTerms,

package/node_modules/@maka/runtime/dist/session-manager.js

@@ -20,12 +20,11 @@ import { countRecallSearchableMessages, listRecallCandidateSessions, } from './r
 import { createHash } from 'node:crypto';
 import { isDeepStrictEqual } from 'node:util';
 import { setTimeout as delay } from 'node:timers/promises';
-import { messageContentsEqual, normalizeMessageContent } from '@maka/core/events';
+import { messageContentsEqual } from '@maka/core/events';
 import { isCanonicalReadOnlyPermissionProfile } from '@maka/core/permission-profile';
 import { DEFAULT_TOOL_MODE } from '@maka/core/tool-mode';
 import { PLAN_USER_ABANDON_REASON, PLAN_USER_CANCEL_REASON, PlanConflictError, activePlanExecution, } from '@maka/core/plan';
 import { DEFAULT_SESSION_NAME } from '@maka/core/session-name';
-import { DEEP_RESEARCH_SESSION_LABEL, isDeepResearchSession } from '@maka/core/deep-research';
 import { SUBAGENT_SESSION_RUNTIME_SCHEMA_VERSION, SUBAGENT_SESSION_SPAWN_SCHEMA_VERSION, childSessionsForParent, subagentSessionRuntimeSummary, } from '@maka/core/session';
 import { decodeAgentGraphIntentClaim } from '@maka/core/agent-graph-control';
 import { executionBoundaryContains } from '@maka/core/sandbox-boundary';
@@ -97,14 +96,6 @@ export class SessionConfigurationRevisionConflictError extends Error {
         this.actualRevision = actualRevision;
     }
 }
-export class RuntimeRegenerateTurnError extends Error {
-    code;
-    name = 'RuntimeRegenerateTurnError';
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-    }
-}
 export class BackendRegistry {
     registrations = new Map();
     register(kind, registration) {
@@ -355,11 +346,7 @@ export class SessionManager {
                 throw new SessionConfigurationTransitionError('session_busy', 'Session has a pending Interaction');
             }
             await this.assertCollaborationTransition(current.header, input.configuration.collaborationMode);
-            const leavingDeepResearch = isDeepResearchSession(current.header.labels) &&
-                input.configuration.permissionMode !== 'explore';
-            const labels = leavingDeepResearch
-                ? current.header.labels.filter((label) => label !== DEEP_RESEARCH_SESSION_LABEL)
-                : current.header.labels;
+            const labels = current.header.labels;
             return () => store.updateSessionConfiguration(sessionId, {
                 expectedVersion: input.expectedRevision,
                 configuration: {
@@ -713,15 +700,11 @@ export class SessionManager {
     async setPermissionModeWithLegacyStore(sessionId, mode) {
         const previous = await this.deps.store.readHeader(sessionId);
         const boundary = await this.deps.store.readExecutionBoundary(sessionId);
-        const leavingDeepResearch = isDeepResearchSession(previous.labels) && mode !== 'explore';
         if (previous.permissionMode === mode &&
-            executionBoundaryMatchesPermissionMode(boundary, mode) &&
-            !leavingDeepResearch) {
+            executionBoundaryMatchesPermissionMode(boundary, mode)) {
             return headerToSummary(previous);
         }
-        const labels = leavingDeepResearch
-            ? previous.labels.filter((label) => label !== DEEP_RESEARCH_SESSION_LABEL)
-            : previous.labels;
+        const labels = previous.labels;
         const kind = mode === 'bypass' ? 'bypass' : 'managed';
         await this.commitExecutionBoundaryTransition(sessionId, boundary, mode, async () => {
             const current = await this.deps.store.readHeader(sessionId);
@@ -1463,7 +1446,7 @@ export class SessionManager {
         }
         const resolvedPreset = await this.deps.subagentCatalog.resolve(input.subagentId);
         if (resolvedPreset.profile !== input.agentProfile) {
-            throw new Error(`Subagent preset "${input.subagentId}" profile changed during spawn`);
+            throw new Error(`Subagent preset "${input.subagentId}" profile changed during spawn. Retry the same agent_spawn call.`);
         }
         return { ...input, resolvedPreset };
     }
@@ -2752,41 +2735,6 @@ export class SessionManager {
             ? authority.stopRoot(identity, input)
             : this.runtimeKernel.stopSession(identity.sessionId, input);
     }
-    async *regenerateTurn(sessionId, input) {
-        const execution = this.runtimeKernel.claimExecution(sessionId);
-        try {
-            const source = await this.prepareRegenerateTurn(sessionId, input.sourceTurnId);
-            yield* this.sendMessage(sessionId, {
-                turnId: input.turnId ?? this.deps.newId(),
-                ...source.content,
-                parentTurnId: source.sourceTurnId,
-                regeneratedFromTurnId: source.sourceTurnId,
-            }, { execution });
-        }
-        finally {
-            execution.release();
-        }
-    }
-    async prepareRegenerateTurn(sessionId, sourceTurnId) {
-        const view = await this.getSessionView(sessionId);
-        const source = view.turns.find((candidate) => candidate.turnId === sourceTurnId);
-        if (!source) {
-            throw new RuntimeRegenerateTurnError('not_found', `Cannot regenerate unknown Turn ${sourceTurnId}`);
-        }
-        if (source.status !== 'failed' &&
-            source.status !== 'aborted' &&
-            source.status !== 'completed') {
-            throw new RuntimeRegenerateTurnError('operation_conflict', `Cannot regenerate Turn ${sourceTurnId} while it is ${source.status}`);
-        }
-        const user = view.messages.find((message) => message.type === 'user' && message.turnId === sourceTurnId);
-        if (!user) {
-            throw new RuntimeRegenerateTurnError('operation_conflict', `Turn ${sourceTurnId} has no UserMessage`);
-        }
-        return {
-            sourceTurnId,
-            content: normalizeMessageContent(user),
-        };
-    }
     /** Canonical, repaired source view for a Host-owned cross-Session copy. */
     async readConversationCopySnapshot(sessionId) {
         return this.getSessionView(sessionId);

package/node_modules/@maka/runtime/dist/subagent-tools.js

@@ -46,6 +46,7 @@ const AGENT_LIST_PAGE_SIZE = 8;
 const AGENT_LIST_MAX_RESPONSE_CHARS = 7_000;
 const AGENT_LIST_DESCRIPTION_MAX_CHARS = 240;
 const AGENT_LIST_MODEL_MAX_CHARS = 160;
+const CHILD_EXECUTOR_SELECTION_GUIDANCE = 'Use executor_mode=inherit for the preset or inherited execution route; executor_id is then ignored. Use executor_mode=plugin only for an explicitly selected registered plugin executor. Without executor_mode, omit executor_id to inherit; "default" is not a default selector.';
 /**
  * Which schema fields each `agent_output` locator needs. A rejection that only
  * says "its matching identity fields" leaves the model guessing which of the
@@ -76,22 +77,34 @@ export function buildSubagentSpawnTool(deps = {}) {
     return {
         name: AGENT_SPAWN_TOOL_NAME,
         displayName: 'Agent',
-        description: 'Run one bounded foreground child task. Prefer agent_list, then select the user-approved subagent_id whose description fits the task; profile is retained for legacy callers. If both selectors are present, subagent_id wins and profile is ignored.',
+        description: "Run one bounded foreground child task. Call agent_list and copy an available choice's spawn_args, then add task. target_kind=profile uses profile; target_kind=preset uses subagent_id. The unused selector is ignored. Empty presets does not disable built-in profiles. Without target_kind, subagent_id takes precedence for legacy callers. Independent child tasks may be called together in one parallel batch, including corrected retries after selector errors. " +
+            CHILD_EXECUTOR_SELECTION_GUIDANCE,
         parameters: z.preprocess(cleanSubagentSpawnInput, z
             .object({
-            profile: z.enum(profiles).optional().describe('Legacy child capability profile.'),
+            target_kind: z
+                .enum(['profile', 'preset'])
+                .optional()
+                .describe('Choose profile for legacy_profiles or preset for presets. Only the selected identity field is used; the other is ignored even if populated.'),
+            profile: z
+                .enum(profiles)
+                .optional()
+                .describe('Built-in child capability: copy legacy_profiles[].profile from agent_list.'),
             subagent_id: z
                 .string()
                 .min(1)
                 .max(128)
                 .refine(isSafeSubagentPresetId)
                 .optional()
-                .describe('User-approved subagent preset id from agent_list.'),
+                .describe('For target_kind=preset, copy presets[].subagent_id from agent_list. Ignored for target_kind=profile.'),
+            executor_mode: z
+                .enum(['inherit', 'plugin'])
+                .optional()
+                .describe(CHILD_EXECUTOR_SELECTION_GUIDANCE),
             executor_id: z
                 .string()
                 .refine(isExecutorId)
                 .optional()
-                .describe('Plugin executor id for this child task.'),
+                .describe(CHILD_EXECUTOR_SELECTION_GUIDANCE),
             task: z
                 .string()
                 .min(1)
@@ -108,12 +121,30 @@ export function buildSubagentSpawnTool(deps = {}) {
         })
             .strip()
             .superRefine((input, ctx) => {
-            if (!input.profile && !input.subagent_id) {
+            if (input.executor_mode === 'plugin' && !input.executor_id) {
                 ctx.addIssue({
                     code: z.ZodIssueCode.custom,
-                    message: 'No child selector was provided. Call agent_list and pass a returned subagent_id to agent_spawn, ' +
-                        `or pass one legacy profile: ${profiles.join(', ')}.`,
+                    path: ['executor_id'],
+                    message: 'executor_mode=plugin requires a registered executor_id. Use executor_mode=inherit for normal child execution.',
                 });
+            }
+            if (!input.profile && !input.subagent_id) {
+                if (input.target_kind) {
+                    const selector = input.target_kind === 'profile' ? 'profile' : 'subagent_id';
+                    const catalogSection = input.target_kind === 'profile' ? 'legacy_profiles' : 'presets';
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        path: [selector],
+                        message: `target_kind=${input.target_kind} requires ${selector}. Call agent_list and copy an available ${catalogSection} choice's spawn_args, then add task.`,
+                    });
+                }
+                else {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: 'No child selector was provided. Call agent_list and pass a returned subagent_id to agent_spawn, ' +
+                            `or pass one legacy profile: ${profiles.join(', ')}.`,
+                    });
+                }
                 return;
             }
             if (input.subagent_id)
@@ -185,8 +216,12 @@ function cleanSubagentSpawnInput(input) {
     if (!input || typeof input !== 'object' || Array.isArray(input))
         return input;
     const cleaned = { ...input };
-    if (cleaned.subagent_id !== undefined)
+    if (cleaned.target_kind === 'profile')
+        delete cleaned.subagent_id;
+    else if (cleaned.target_kind === 'preset' || cleaned.subagent_id !== undefined)
         delete cleaned.profile;
+    if (cleaned.executor_mode === 'inherit')
+        delete cleaned.executor_id;
     return cleaned;
 }
 async function resolvePresetDefinition(subagentId, ctx, definitions) {
@@ -205,8 +240,13 @@ async function resolvePresetDefinition(subagentId, ctx, definitions) {
         !Array.isArray(candidate) &&
         candidate.id === subagentId &&
         typeof candidate.profile === 'string');
-    if (!preset)
-        throw new Error(`Unknown subagent_id "${subagentId}". Call agent_list first.`);
+    if (!preset) {
+        const legacy = definitions.find((definition) => definition.profile === subagentId || definition.id === subagentId);
+        const recovery = legacy
+            ? `"${subagentId}" identifies a built-in agent, not a configured preset. Use ${JSON.stringify({ target_kind: 'profile', profile: legacy.profile, executor_mode: 'inherit' })}, keeping your task. The unused subagent_id and executor_id fields are ignored in these modes.`
+            : "Call agent_list and copy an available choice's spawn_args, then add task. presets use subagent_id; legacy_profiles use profile.";
+        throw new Error(`Unknown subagent_id "${subagentId}". No child was started. ${recovery} ${CHILD_EXECUTOR_SELECTION_GUIDANCE}`);
+    }
     if (preset.availability?.status !== 'available') {
         throw new Error(`Subagent preset "${subagentId}" is unavailable.`);
     }
@@ -249,7 +289,7 @@ export function buildSubagentListTool() {
     return {
         name: AGENT_LIST_TOOL_NAME,
         displayName: 'Agent List',
-        description: 'List a compact page of subagents to select. The default selection view returns runnable user-approved subagent_id values first, followed by legacy choices with separate agent_id (Graph) and profile (agent_spawn) selectors. Use view=catalog only to diagnose unavailable routes. Child execution history is intentionally excluded; use refs returned by agent_spawn or asynchronous graph work with agent_output.',
+        description: "List a compact page of subagents to select. Copy an available choice's spawn_args into agent_spawn and add task. presets use subagent_id; legacy_profiles use profile, including when presets is empty. agent_id is for Graph only. Use view=catalog only to diagnose unavailable routes. Child execution history is intentionally excluded; use refs returned by agent_spawn or asynchronous graph work with agent_output.",
         parameters: z
             .object({
             view: z
@@ -309,6 +349,15 @@ function projectAgentList(catalog, input) {
         return [
             {
                 subagent_id: preset.id,
+                ...(availability.status === 'available'
+                    ? {
+                        spawn_args: {
+                            target_kind: 'preset',
+                            subagent_id: preset.id,
+                            executor_mode: 'inherit',
+                        },
+                    }
+                    : {}),
                 name: boundedCatalogText(preset.name, 128),
                 description: boundedCatalogText(preset.description, AGENT_LIST_DESCRIPTION_MAX_CHARS),
                 profile: preset.profile,
@@ -345,6 +394,15 @@ function projectAgentList(catalog, input) {
             {
                 agent_id: definition.id,
                 profile: definition.profile,
+                ...(availability.status === 'available'
+                    ? {
+                        spawn_args: {
+                            target_kind: 'profile',
+                            profile: definition.profile,
+                            executor_mode: 'inherit',
+                        },
+                    }
+                    : {}),
                 name: boundedCatalogText(definition.name, 128),
                 description: boundedCatalogText(definition.description, AGENT_LIST_DESCRIPTION_MAX_CHARS),
                 ...(typeof contract?.workspace === 'string'

package/node_modules/@maka/runtime/dist/test-connection.js

@@ -17,12 +17,11 @@
  * under the License.
  */
 import { randomUUID } from 'node:crypto';
-import { buildCommandCodeCliRequest, commandCodeCliGenerateUrl, commandCodeCliHeaders, summarizeCommandCodeCliStream, } from './commandcode-cli-language-model.js';
 import { PROVIDER_REGISTRY, effectiveBaseUrl, providerDefaultsOf, providerFallbackModelIds, connectionModelsEnumerateAccount, connectionEnabledModelIds, } from '@maka/core/llm-connections';
 import { openResponsesUrl } from './provider-urls.js';
 import { resolveModelRuntime } from './model-runtime.js';
 import { fetchGitHubCopilotModels } from './model-fetcher.js';
-import { CONNECTION_EFFECT_ERROR_BODY_MAX_BYTES, CONNECTION_EFFECT_JSON_BODY_MAX_BYTES, ConnectionEffectFetchError, fetchForConnectionEffect, } from './connection-effect-fetch.js';
+import { CONNECTION_EFFECT_ERROR_BODY_MAX_BYTES, ConnectionEffectFetchError, fetchForConnectionEffect, } from './connection-effect-fetch.js';
 import { ConnectionEffectHttpError, ConnectionEffectInvalidResponseError, classifyConnectionEffectStatus, } from './connection-effect-outcome.js';
 import { withOpenCodeSessionHeader } from './opencode-session-header.js';
 const CONNECTION_TEST_TIMEOUT_MS = 15_000;
@@ -106,47 +105,15 @@ async function testConnectionStrict(connection, apiKey, model, fetchFn, t0, time
     if (!defaults) {
         return { ok: false, errorMessage: `Unknown provider type "${connection.providerType}"` };
     }
-    const sessionId = connection.providerType === 'opencode-go' || connection.providerType === 'opencode-free'
-        ? randomUUID()
-        : undefined;
+    if (defaults.retired)
+        return retiredProviderTestResult(connection.providerType);
+    const sessionId = connection.providerType === 'opencode-go' ? randomUUID() : undefined;
     const auth = defaults.authKind;
     const secret = auth === 'none' ? '' : apiKey;
     const testModel = resolveConnectionTestModel(connection, model, providerFallbackModelIds(defaults));
     if (!testModel) {
         return { ok: false, errorMessage: 'No model to test' };
     }
-    if (connection.providerType === 'opencode-free' && !model?.trim()) {
-        const brokenModelIds = new Set(defaults.brokenModelIds ?? []);
-        const candidates = [
-            ...new Set([
-                ...connectionEnabledModelIds(connection).filter((id) => !brokenModelIds.has(id)),
-                ...providerFallbackModelIds(defaults),
-            ]),
-        ];
-        if (candidates.length === 0) {
-            return { ok: false, errorMessage: 'No model to test' };
-        }
-        let lastFailure;
-        for (let index = 0; index < candidates.length; index += 1) {
-            const candidate = candidates[index];
-            const remainingMs = timeoutMs - (Date.now() - t0);
-            if (remainingMs <= 0) {
-                return connectionTestFailure(new ConnectionEffectFetchError('timeout'), t0);
-            }
-            const remainingCandidates = candidates.length - index;
-            const attemptTimeoutMs = Math.max(1, Math.floor(remainingMs / remainingCandidates));
-            try {
-                const result = await testConnectionModel(connection, secret, candidate, fetchFn, t0, attemptTimeoutMs, sessionId);
-                if (result.ok)
-                    return result;
-                lastFailure = result;
-            }
-            catch (error) {
-                lastFailure = connectionTestFailure(error, t0, true);
-            }
-        }
-        return lastFailure ?? connectionTestFailure(new ConnectionEffectFetchError('timeout'), t0);
-    }
     return await testConnectionModel(connection, secret, testModel, fetchFn, t0, timeoutMs, sessionId);
 }
 async function testConnectionModel(connection, secret, testModel, fetchFn, t0, timeoutMs = CONNECTION_TEST_TIMEOUT_MS, sessionId) {
@@ -179,54 +146,8 @@ async function testConnectionModel(connection, secret, testModel, fetchFn, t0, t
             return await probeGoogle(baseUrl, secret, testModel, t0, adapter.normalizeBaseUrl !== false, fetchFn);
         case 'cohere':
             return await probeCohere(baseUrl, secret, testModel, t0, fetchFn);
-        case 'commandcode-cli':
-            return await probeCommandCodeCli(baseUrl, secret, testModel, t0, fetchFn, requestHeaders);
     }
 }
-async function probeCommandCodeCli(baseUrl, apiKey, model, t0, fetchFn, requestHeaders) {
-    const { body } = buildCommandCodeCliRequest({ prompt: [{ role: 'user', content: [{ type: 'text', text: 'Hi' }] }], maxOutputTokens: 16 }, { modelId: model });
-    const r = await fetchForConnectionEffect(fetchFn, commandCodeCliGenerateUrl(baseUrl), {
-        method: 'POST',
-        headers: { ...commandCodeCliHeaders(apiKey, 'maka'), ...(requestHeaders ?? {}) },
-        body: JSON.stringify(body),
-        timeoutMs: CONNECTION_TEST_TIMEOUT_MS,
-    });
-    if (!r.ok)
-        return httpFailure(r, t0);
-    // HTTP 200 is only the handshake on this wire. The generation adapter fails
-    // the send on an in-band `error` event and on a stream that ends without a
-    // `finish`, so a probe that stopped at the status would store a connection
-    // as verified whose very next send is rejected.
-    const outcome = summarizeCommandCodeCliStream(await r.readText(CONNECTION_EFFECT_JSON_BODY_MAX_BYTES));
-    const latencyMs = Date.now() - t0;
-    if (outcome.error) {
-        const { message, statusCode } = outcome.error;
-        return {
-            ok: false,
-            latencyMs,
-            errorMessage: message.slice(0, 200),
-            ...(statusCode === undefined ? {} : { statusCode }),
-            errorClass: commandCodeCliStreamErrorClass(statusCode),
-        };
-    }
-    if (!outcome.finished) {
-        return {
-            ok: false,
-            latencyMs,
-            errorMessage: 'The Command Code GO stream ended before the turn finished',
-            errorClass: 'network',
-        };
-    }
-    return { ok: true, latencyMs, modelTested: model };
-}
-function commandCodeCliStreamErrorClass(statusCode) {
-    if (statusCode === 401 || statusCode === 403)
-        return 'auth';
-    if (statusCode === 429 || (statusCode !== undefined && statusCode >= 500)) {
-        return 'provider_unavailable';
-    }
-    return 'unknown';
-}
 async function probeGitHubCopilot(baseUrl, apiKey, model, t0, fetchFn) {
     const models = await fetchGitHubCopilotModels(baseUrl, apiKey, fetchFn);
     if (!models.some(({ id }) => id === model)) {
@@ -332,40 +253,9 @@ async function probeOpenAI(connection, baseUrl, apiKey, model, t0, fetchFn, time
     });
     if (!r.ok)
         return httpFailure(r, t0);
-    if (connection.providerType === 'opencode-free') {
-        const body = await r.readJson();
-        if (!isOpenAIChatCompletion(body)) {
-            return {
-                ok: false,
-                errorMessage: 'OpenCode Free returned no valid chat completion',
-                errorClass: 'provider_unavailable',
-                latencyMs: Date.now() - t0,
-                modelTested: model,
-            };
-        }
-        return { ok: true, latencyMs: Date.now() - t0, modelTested: model };
-    }
     await r.cancel();
     return { ok: true, latencyMs: Date.now() - t0, modelTested: model };
 }
-function isOpenAIChatCompletion(value) {
-    if (!value || typeof value !== 'object')
-        return false;
-    const choices = value.choices;
-    return (Array.isArray(choices) &&
-        choices.some((choice) => {
-            if (!choice || typeof choice !== 'object')
-                return false;
-            const message = choice.message;
-            if (!message || typeof message !== 'object')
-                return false;
-            const completion = message;
-            return (typeof completion.content === 'string' ||
-                typeof completion.reasoning === 'string' ||
-                typeof completion.reasoning_content === 'string' ||
-                (Array.isArray(completion.tool_calls) && completion.tool_calls.length > 0));
-        }));
-}
 async function probeGoogle(baseUrl, apiKey, model, t0, normalizeBaseUrl, fetchFn) {
     const url = `${stripTrailing(baseUrl)}/models/${encodeURIComponent(model)}:generateContent${normalizeBaseUrl ? `?key=${encodeURIComponent(apiKey)}` : ''}`;
     const r = await fetchForConnectionEffect(fetchFn, url, {

package/node_modules/@maka/runtime/package.json

@@ -13,7 +13,6 @@
     "./shell-tools": "./dist/shell-tools.js",
     "./shell-run-manager": "./dist/shell-run-manager.js",
     "./background-task-health-tool": "./dist/background-task-health-tool.js",
-    "./deep-research-tools": "./dist/deep-research-tools.js",
     "./durable-tool-result-projection": "./dist/durable-tool-result-projection.js",
     "./tool-artifacts": "./dist/tool-artifacts.js",
     "./model-factory": "./dist/model-factory.js",

package/node_modules/@maka/runtime-host/dist/client/client-capability-channel.js

@@ -17,7 +17,7 @@
  * under the License.
  */
 import { randomUUID } from 'node:crypto';
-import { CLIENT_CAPABILITY_MAX_RESULT_BYTES, CLIENT_CAPABILITY_RESULT_CHUNK_MAX_BYTES, decodeClientCapabilityClientFrame, decodeClientCapabilityReplaceInput, decodeClientCapabilityResult, } from '../protocol/index.js';
+import { CLIENT_CAPABILITY_MAX_PROGRESS_TOTAL, CLIENT_CAPABILITY_MAX_RESULT_BYTES, CLIENT_CAPABILITY_RESULT_CHUNK_MAX_BYTES, decodeClientCapabilityClientFrame, decodeClientCapabilityReplaceInput, decodeClientCapabilityResult, } from '../protocol/index.js';
 /** Client-owned registration, reverse invocation, and teardown lifecycle. */
 export class ClientCapabilityChannel {
     #options;
@@ -247,6 +247,40 @@ export class ClientCapabilityChannel {
             });
             return accepting;
         };
+        let pendingProgress;
+        let progressWriting = false;
+        let progressWrite = Promise.resolve();
+        const scheduleProgressWrite = () => {
+            if (progressWriting)
+                return;
+            progressWriting = true;
+            progressWrite = (async () => {
+                while (pendingProgress) {
+                    const next = pendingProgress;
+                    pendingProgress = undefined;
+                    try {
+                        await this.#options.write({
+                            kind: 'client.capability.progress',
+                            invocationId,
+                            current: next.current,
+                            total: next.total,
+                        });
+                    }
+                    catch {
+                        // Progress is advisory: a failed write must not fail the invocation.
+                        return;
+                    }
+                }
+            })().finally(() => {
+                progressWriting = false;
+            });
+        };
+        const flushProgress = async () => {
+            do {
+                scheduleProgressWrite();
+                await progressWrite;
+            } while (pendingProgress);
+        };
         try {
             const progress = (current, total) => {
                 if (!accepted ||
@@ -255,17 +289,17 @@ export class ClientCapabilityChannel {
                     !Number.isInteger(total) ||
                     current < 0 ||
                     total < 1 ||
+                    total > CLIENT_CAPABILITY_MAX_PROGRESS_TOTAL ||
                     current > total) {
                     return;
                 }
-                void this.#options
-                    .write({
-                    kind: 'client.capability.progress',
-                    invocationId,
-                    current,
-                    total,
-                })
-                    .catch((error) => this.#options.onFailure(asError(error)));
+                const previous = invocation.progress;
+                if (previous && (previous.total !== total || current <= previous.current)) {
+                    return;
+                }
+                invocation.progress = { current, total };
+                pendingProgress = { current, total };
+                scheduleProgressWrite();
             };
             const requestInteraction = async (request) => {
                 if (!accepted) {
@@ -315,6 +349,7 @@ export class ClientCapabilityChannel {
                 throw new Error('Client Capability provider returned with a pending interaction');
             }
             await accept({ kind: 'none' });
+            await flushProgress();
             await this.#sendResult(invocationId, result, invocation);
         }
         catch (error) {

package/node_modules/@maka/runtime-host/dist/client/host-handoff-copy.js

@@ -186,6 +186,25 @@ const COPY = {
 /** Shared consequence-oriented copy, not a second lifecycle policy. */
 export function formatHostHandoff(view, locale) {
     const copy = COPY[locale];
+    const labels = {
+        cancel: copy.labels.cancel,
+        retry: view.manualRecheck ? copy.labels.recheck : copy.labels.retry,
+        replace: copy.labels.replace,
+        interrupt: view.manualRecheck
+            ? copy.labels.interruptRecheck
+            : view.operation === 'repair'
+                ? copy.labels.interruptRepair
+                : copy.labels.interrupt,
+    };
+    const actions = view.actions.map((action) => ({ action, label: labels[action] }));
+    if (view.state === 'progress') {
+        return {
+            title: copy.progressTitle,
+            description: copy.phases[view.phase],
+            detail: copy.progressDetail,
+            actions,
+        };
+    }
     let title = copy.titles[view.reason];
     let description = copy.descriptions(view.target.name)[view.reason];
     if (view.recoveryBlocker && view.reason === 'operator_required') {
@@ -215,24 +234,12 @@ export function formatHostHandoff(view, locale) {
             ? copy.waiting.natural
             : copy.waiting.blocked;
     const repairNotice = view.operation === 'repair' ? copy.repairNotice : '';
-    const labels = {
-        cancel: copy.labels.cancel,
-        retry: view.manualRecheck ? copy.labels.recheck : copy.labels.retry,
-        replace: copy.labels.replace,
-        interrupt: view.manualRecheck
-            ? copy.labels.interruptRecheck
-            : view.operation === 'repair'
-                ? copy.labels.interruptRepair
-                : copy.labels.interrupt,
-    };
     return {
-        title: view.state === 'progress' ? copy.progressTitle : title,
-        description: view.state === 'progress' ? copy.phases[view.phase ?? 'checking'] : description,
-        detail: view.state === 'progress'
-            ? copy.progressDetail
-            : [packageChange, facts, backgroundFacts, waiting, repairNotice, view.operatorStep]
-                .filter(Boolean)
-                .join('\n'),
-        actions: view.actions.map((action) => ({ action, label: labels[action] })),
+        title,
+        description,
+        detail: [packageChange, facts, backgroundFacts, waiting, repairNotice, view.operatorStep]
+            .filter(Boolean)
+            .join('\n'),
+        actions,
     };
 }

package/node_modules/@maka/runtime-host/dist/client/host-handoff.js

@@ -172,11 +172,13 @@ export async function runHostHandoff(input) {
                     ? AbortSignal.any([input.signal, attemptAbort.signal])
                     : attemptAbort.signal;
                 const progress = (phase) => publish({
-                    ...current,
                     revision: randomUUID(),
+                    target: current.target,
                     state: 'progress',
                     phase: cooperative && !interrupt && phase === 'retiring' ? 'pausing' : phase,
                     actions: cancelled ? [] : ['cancel'],
+                    defaultAction: 'cancel',
+                    mayExitNaturally: false,
                 });
                 if (input.openSurface)
                     surface ??= input.openSurface(submit);

package/node_modules/@maka/runtime-host/dist/client/index.js

@@ -30,7 +30,7 @@ export { RuntimeHostSshOperatorActivationError, activateRuntimeHostSshOperator,
 export { normalizeRuntimeHostSshDestination, openRuntimeHostSshTunnel, } from './ssh-tunnel.js';
 export { RuntimeHostPermanentReconnectError, startRuntimeHostReconnectLifecycle, } from './reconnect-lifecycle.js';
 export { RUNTIME_HOST_REMOTE_INCOMPATIBLE_CODE, RuntimeHostRemoteCompatibilityError, } from './remote-compatibility-error.js';
-export { RuntimeHostSubscriptionError, } from './session-subscription.js';
+export { RuntimeHostSubscriptionError, SessionRemovedSubscriptionError, subscriptionClosedError, } from './session-subscription.js';
 export { RuntimeHostStartupError, runtimeHostStartupError, } from './startup-error.js';
 export { connectRuntimeHostWslEnvironment, listRuntimeHostWslDistributions, normalizeRuntimeHostWslDistribution, resolveSystemRuntimeHostWslExecutable, } from './wsl-environment.js';
 export { RuntimeHostCatalogReadError, RuntimeHostSessionCatalogRevisionChangedError, readRuntimeHostConnectionCatalog, readRuntimeHostInvocableSkills, readRuntimeHostProjectDetails, readRuntimeHostResources, readRuntimeHostProjects, readRuntimeHostSessionCatalogPage, readRuntimeHostSessions, readRuntimeHostSkillCatalog, } from './catalog-reader.js';