maka-agent 0.2.0-dev.76.20261009 → 0.2.0-dev.78.20261010

package/node_modules/@maka/runtime/dist/tool-runtime.js

@@ -23,7 +23,7 @@ import { resolveCollaborationPermissionMode } from '@maka/core/collaboration';
 import { serializedByteLength } from '@maka/core/serialized-byte-length';
 import { encodeToolStepProgress, ToolOutcomeUnknownError } from '@maka/core/events';
 import { isInteractionAnswerValidForRequest, projectInteractionFormRequest, } from '@maka/core/interaction';
-import { computerUseModelCallArgs } from '@maka/core/computer-use';
+import { buildToolCallArgs, snapshotToolArgs } from './tool-call-snapshot.js';
 import { redactSecrets } from '@maka/core/redaction';
 import { TOOL_BOUNDARY_PROTOCOL_V1 } from '@maka/core/runtime-event';
 import { recordToolArtifactsSafely } from './tool-artifacts.js';
@@ -544,36 +544,30 @@ export class ToolRuntime {
             ? `Tool ${tool.name} is direct-only and cannot run inside exec.`
             : undefined;
         const admissionFailure = directOnlyFailure ?? this.admitToolForStep(tool, stepId);
-        let permissionArgs = executionArgs;
-        let permissionArgsError;
-        if (directOnlyFailure === undefined) {
-            try {
-                // An unavailable sandbox-boundary surface rejects the expansion before
-                // interpreting it, including legacy shapes whose validation stays deferred.
-                const sandboxBoundaryUnavailable = tool.name === 'request_sandbox_boundary' &&
-                    !this.interactionRun() &&
-                    (!this.input.createSandboxBoundaryRequest || !this.input.settleSandboxBoundaryRequest);
-                if (!sandboxBoundaryUnavailable) {
-                    await validateDeclaredToolArgs(tool.parameters, executionArgs);
-                }
-                permissionArgs = tool.permissionArgs
-                    ? snapshotToolArgs(tool.permissionArgs(structuredClone(executionArgs), {
-                        sessionId: this.input.sessionId,
-                        turnId,
-                        toolCallId: toolUseId,
-                    }))
-                    : executionArgs;
-            }
-            catch (error) {
-                permissionArgsError = error;
-            }
-        }
-        // Permission args are a policy/UI projection. Persistence and model replay
-        // share one canonical tool-dialect projection; Computer Use also strips
-        // screen-derived and user-typed values at this boundary.
-        const persistedArgs = tool.categoryHint === 'computer_use'
-            ? snapshotToolArgs(computerUseModelCallArgs(permissionArgs))
-            : permissionArgs;
+        // An unavailable sandbox-boundary surface cannot carry the expansion the
+        // tool requests, and that availability contract holds even when an older
+        // caller sends a legacy shape — validation stays deferred for it.
+        const sandboxBoundaryUnavailable = tool.name === 'request_sandbox_boundary' &&
+            !this.interactionRun() &&
+            (!this.input.createSandboxBoundaryRequest || !this.input.settleSandboxBoundaryRequest);
+        const callArgs = await buildToolCallArgs({
+            toolName: tool.name,
+            parameters: tool.parameters,
+            categoryHint: tool.categoryHint,
+            permissionArgs: tool.permissionArgs,
+            // Upstream renamed rawExecutionArgs to executionArgs after this
+            // refactor; buildToolCallArgs passes it through unchanged, and the
+            // entry snapshot above already holds that same value.
+            executionArgs,
+            sessionId: this.input.sessionId,
+            turnId,
+            toolCallId: toolUseId,
+            directOnlyRejected: directOnlyFailure !== undefined,
+            validationDeferred: sandboxBoundaryUnavailable,
+        });
+        const permissionArgs = callArgs.permissionArgs;
+        const persistedArgs = callArgs.persistedArgs;
+        const permissionArgsError = callArgs.permissionArgsError;
         const now = this.input.now();
         const trace = this.input.getRunTrace?.() ?? null;
         const runId = this.input.runId;
@@ -2068,36 +2062,6 @@ export class ToolRuntime {
         });
     }
 }
-async function validateDeclaredToolArgs(parameters, args) {
-    if (!parameters || (typeof parameters !== 'object' && typeof parameters !== 'function')) {
-        return;
-    }
-    const schema = parameters;
-    if (typeof schema.safeParseAsync === 'function') {
-        const parsed = await schema.safeParseAsync(args);
-        if (parsed.success)
-            return;
-        throw parsed.error;
-    }
-    if (typeof schema.safeParse === 'function') {
-        const parsed = schema.safeParse(args);
-        if (parsed.success)
-            return;
-        throw parsed.error;
-    }
-    if (typeof schema.validate === 'function') {
-        const parsed = await schema.validate(args);
-        if (parsed.success)
-            return;
-        throw parsed.error;
-    }
-    if (typeof schema['~standard']?.validate === 'function') {
-        const parsed = await schema['~standard'].validate(args);
-        if ('value' in parsed)
-            return;
-        throw new Error('Tool arguments failed declared schema validation', { cause: parsed.issues });
-    }
-}
 function isInteractionControlError(error) {
     return (error instanceof RuntimeInteractionAdmissionRejectedError ||
         error instanceof RuntimeInteractionClosedError ||
@@ -2152,7 +2116,8 @@ function racePromiseWithAbort(promise, signal) {
  */
 export function formatDeferredNotLoadedText(toolName) {
     return (`Tool "${toolName}" is available but not loaded yet. ` +
-        `Call tool_search to activate it first, then call "${toolName}" on a later step.`);
+        `Call tool_search with query "${toolName}" to activate it first, ` +
+        `then call "${toolName}" on a later step.`);
 }
 /**
  * Canonical key for a tool call's args; order-independent so identical calls
@@ -2597,25 +2562,3 @@ function byteLength(value) {
     const text = typeof value === 'string' ? value : JSON.stringify(value ?? null);
     return Buffer.byteLength(text, 'utf8');
 }
-function snapshotToolArgs(value) {
-    return snapshotJsonValue(value, new WeakSet());
-}
-function snapshotJsonValue(value, seen) {
-    if (value === null || typeof value !== 'object')
-        return value;
-    if (seen.has(value))
-        throw new Error('Tool arguments must not contain cycles');
-    seen.add(value);
-    if (Array.isArray(value)) {
-        return Object.freeze(value.map((entry) => snapshotJsonValue(entry, seen)));
-    }
-    const output = {};
-    for (const key of Object.keys(value)) {
-        const descriptor = Object.getOwnPropertyDescriptor(value, key);
-        if (!descriptor || !('value' in descriptor)) {
-            throw new Error(`Tool argument ${key} must be a plain data property`);
-        }
-        output[key] = snapshotJsonValue(descriptor.value, seen);
-    }
-    return Object.freeze(output);
-}

package/node_modules/@maka/runtime/dist/workers/{filesystem-worker.js → filesystem-worker.mjs}

@@ -24203,9 +24203,20 @@ async function openExistingNoTruncate(path2) {
   }
 }
 async function writeThroughHandle(handle, content) {
+  const bytes = Buffer.from(content, "utf8");
   try {
     await handle.truncate(0);
-    await handle.write(content, 0, "utf8");
+    let offset = 0;
+    while (offset < bytes.length) {
+      const { bytesWritten } = await handle.write(bytes, offset, bytes.length - offset, offset);
+      if (bytesWritten <= 0) {
+        throw new StableWriteFailure(
+          "outcome_unknown",
+          "The write stopped making progress; the file may be truncated. Re-read the file before writing to it again."
+        );
+      }
+      offset += bytesWritten;
+    }
   } catch (error62) {
     const code = error62.code;
     if (code === "ENOSPC" || code === "EIO" || code === "EDQUOT" || code === "EFBIG") {

package/node_modules/@maka/runtime-host/dist/client/connect-or-spawn.js

@@ -30,7 +30,7 @@ import { abortable, waitForRuntimeHostReady } from './wait-for-ready.js';
 // Candidate readiness includes the Windows named-pipe ACL helper, whose
 // fail-closed ceiling is 60s. Leave enough room for election and connection
 // bookkeeping after that helper returns.
-const DEFAULT_ELECTION_DEADLINE_MS = 75_000;
+export const DEFAULT_ELECTION_DEADLINE_MS = 75_000;
 const DEFAULT_BACKOFF_MIN_MS = 20;
 const DEFAULT_BACKOFF_MAX_MS = 250;
 const MIN_CANDIDATE_INTERVAL_MS = 250;
@@ -251,10 +251,24 @@ export async function connectOrSpawnRuntimeHostWithDependencies(input, dependenc
                 return result;
             }
             if (isPermanentCandidateStartupFailure(startupFailure) && pendingCandidateReports === 0) {
-                const selectedFailure = startupFailure;
-                electionSettled = true;
-                await selectCandidateStartupDiagnostic(capability.rootId, selectedFailure.startupAttemptId).catch(() => undefined);
-                return { kind: 'failed', reason: selectedFailure.reason };
+                if (isLaunchElectionLoss(startupFailure)) {
+                    // Losing the launch election is not a Host failure. It is proof that
+                    // another candidate holds this root and is still coming up, so the
+                    // only honest reading is "keep waiting for the one that won".
+                    // Returning here is what made a slow first startup look permanently
+                    // unavailable: the desktop saw a failure a second after it asked,
+                    // while the candidate that owned the root was still loading its
+                    // transcript store, and every retry looked the same (issue #5843).
+                    // The loser's startup diagnostic stays on disk, because that trace is
+                    // what made the storm visible at all; it is simply no longer terminal.
+                    startupFailure = undefined;
+                }
+                else {
+                    const selectedFailure = startupFailure;
+                    electionSettled = true;
+                    await selectCandidateStartupDiagnostic(capability.rootId, selectedFailure.startupAttemptId).catch(() => undefined);
+                    return { kind: 'failed', reason: selectedFailure.reason };
+                }
             }
             const now = performance.now();
             if (shouldLaunchCandidate(result) &&
@@ -362,7 +376,7 @@ export async function connectOrSpawnRuntimeHostWithDependencies(input, dependenc
             await sleep(Math.min(remaining, Math.max(1, Math.round(backoffMs * jitter))), input.signal);
             backoffMs = Math.min(DEFAULT_BACKOFF_MAX_MS, backoffMs * 2);
         }
-        if (startupFailure) {
+        if (startupFailure && !isLaunchElectionLoss(startupFailure)) {
             const selectedFailure = startupFailure;
             electionSettled = true;
             await selectCandidateStartupDiagnostic(capability.rootId, selectedFailure.startupAttemptId).catch(() => undefined);
@@ -387,6 +401,16 @@ export async function connectOrSpawnRuntimeHostWithDependencies(input, dependenc
         electionSettled = true;
     }
 }
+/**
+ * A Candidate that lost the launch election is evidence about *another*
+ * Candidate - it holds the root and is still coming up - so the loss must never
+ * decide how this election ends, whether the loop breaks on it or the window
+ * simply runs out. Failing on it made a slow first startup look like a
+ * permanently unavailable Host (issue #5843).
+ */
+function isLaunchElectionLoss(failure) {
+    return failure?.reason === 'launch_election_lost';
+}
 function recordElectionResult(result, observations) {
     observations.totalResults += 1;
     const registration = 'registration' in result ? result.registration : undefined;

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

@@ -34,7 +34,7 @@ export { RuntimeHostSubscriptionError, SessionRemovedSubscriptionError, subscrip
 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';
-export { IDLE_GRACE_MS_ENV_VAR, connectOrSpawnRuntimeHost, } from './connect-or-spawn.js';
+export { DEFAULT_ELECTION_DEADLINE_MS, ELECTION_DEADLINE_MS_ENV_VAR, IDLE_GRACE_MS_ENV_VAR, connectOrSpawnRuntimeHost, electionDeadlineMsFromEnvironment, } from './connect-or-spawn.js';
 export { abortable, waitForRuntimeHostReady } from './wait-for-ready.js';
 export { createRuntimeHostCandidateLaunchBarrier, } from './candidate-launch-barrier.js';
 export { runHostedExecution } from './hosted-execution.js';

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

@@ -63,6 +63,7 @@ class RuntimeHostReconnectLifecycleImpl {
     #closed = false;
     #quiesced = false;
     #terminalError;
+    #startTask;
     #reconnectTask;
     #reconnectAbort;
     #discardTask = Promise.resolve();
@@ -96,10 +97,22 @@ class RuntimeHostReconnectLifecycleImpl {
     get current() {
         return this.#current;
     }
-    async start() {
+    start() {
+        if (this.#closed)
+            return Promise.reject(new Error('Runtime Host reconnect lifecycle is closed'));
+        if (this.#startTask)
+            return this.#startTask;
+        const task = deferredTask();
+        this.#startTask = task.promise;
+        void this.#start().then(task.resolve, task.reject);
+        return task.promise;
+    }
+    async #start() {
         try {
-            if (this.#initial) {
-                this.#install(this.#initial);
+            const initial = this.#initial;
+            this.#initial = undefined;
+            if (initial) {
+                this.#install(initial);
                 return;
             }
             this.#initialSignal?.throwIfAborted();
@@ -109,6 +122,8 @@ class RuntimeHostReconnectLifecycleImpl {
             this.#install(await this.#connect(signal));
         }
         catch (error) {
+            if (this.#closed)
+                throw error;
             const failure = asError(error);
             if ((typeof this.#retryInitialFailure === 'function'
                 ? this.#retryInitialFailure(failure)
@@ -198,8 +213,12 @@ class RuntimeHostReconnectLifecycleImpl {
         return this.#suspension(current);
     }
     close() {
-        this.#closeTask ??= this.#close();
-        return this.#closeTask;
+        if (this.#closeTask)
+            return this.#closeTask;
+        const task = deferredTask();
+        this.#closeTask = task.promise;
+        void this.#close().then(task.resolve, task.reject);
+        return task.promise;
     }
     async #close() {
         if (this.#closed)
@@ -210,9 +229,11 @@ class RuntimeHostReconnectLifecycleImpl {
         this.#abort.abort();
         const error = new Error('Runtime Host reconnect lifecycle is closed');
         this.#rejectWaiters(error);
-        const current = this.#current;
+        const current = this.#current ?? this.#initial;
+        this.#initial = undefined;
         this.#setCurrent(undefined);
         await current?.close().catch(() => undefined);
+        await this.#startTask?.catch(() => undefined);
         await this.#reconnectTask?.catch(() => undefined);
         await this.#discardTask;
         this.#resolveClosed();
@@ -248,17 +269,18 @@ class RuntimeHostReconnectLifecycleImpl {
             this.#reconnectTask)
             return;
         const reconnectAbort = new AbortController();
-        const task = this.#reconnect(AbortSignal.any([this.#abort.signal, reconnectAbort.signal]));
+        const task = deferredTask();
         this.#reconnectAbort = reconnectAbort;
-        this.#reconnectTask = task;
+        this.#reconnectTask = task.promise;
+        void this.#reconnect(AbortSignal.any([this.#abort.signal, reconnectAbort.signal])).then(task.resolve, task.reject);
         const finalize = () => {
-            if (this.#reconnectTask === task) {
+            if (this.#reconnectTask === task.promise) {
                 this.#reconnectTask = undefined;
                 this.#reconnectAbort = undefined;
             }
             this.#scheduleReconnect();
         };
-        void task.then(finalize, finalize);
+        void task.promise.then(finalize, finalize);
     }
     async #reconnect(signal) {
         let attemptedWakeGeneration = this.#wakeGeneration;
@@ -348,13 +370,13 @@ class RuntimeHostReconnectLifecycleImpl {
         }
     }
     #failPermanently(error) {
-        if (this.#terminalError)
+        if (this.#closed || this.#terminalError)
             return;
         this.#terminalError = error;
-        this.#abort.abort();
         this.#rejectWaiters(error);
+        // Acquisition tasks must settle before close can finish joining them.
+        void this.close();
         notifyError(this.#onFatalError, error);
-        this.#resolveClosed();
     }
     #rejectWaiters(error) {
         for (const waiter of this.#waiters) {
@@ -364,6 +386,15 @@ class RuntimeHostReconnectLifecycleImpl {
         this.#waiters.clear();
     }
 }
+function deferredTask() {
+    let resolve;
+    let reject;
+    const promise = new Promise((resolveTask, rejectTask) => {
+        resolve = resolveTask;
+        reject = rejectTask;
+    });
+    return { promise, resolve, reject };
+}
 function notifyError(listener, error) {
     try {
         listener?.(error);

package/node_modules/@maka/runtime-host/dist/client/session-catalog-summary.js

@@ -35,6 +35,12 @@ export function projectSessionCatalogSummary(session) {
             ? {}
             : { lastMessagePreview: session.lastMessagePreview }),
         status: session.status,
+        ...(session.backgroundActivity === undefined
+            ? {}
+            : { backgroundActivity: session.backgroundActivity }),
+        ...(session.backgroundActivityVersion === undefined
+            ? {}
+            : { backgroundActivityVersion: session.backgroundActivityVersion }),
         ...(session.blockedReason === undefined ? {} : { blockedReason: session.blockedReason }),
         ...(session.statusUpdatedAt === undefined ? {} : { statusUpdatedAt: session.statusUpdatedAt }),
         ...(session.liveRunState === undefined

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

@@ -112,6 +112,10 @@ class WslProcessByteStream {
     }
     onError(listener) {
         this.child.once('error', listener);
+        // Pipe errors are emitted independently of the write callback and the
+        // ChildProcess error event. Route them through the transport failure fence.
+        this.child.stdin.on('error', listener);
+        this.child.stdout.on('error', listener);
     }
     write(chunk) {
         return new Promise((resolve, reject) => {

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

@@ -65,7 +65,11 @@ export const RUNTIME_HOST_REGISTRATION_SCHEMA_VERSION = 1;
 export const RUNTIME_HOST_PROTOCOL_VERSION = 0;
 // Increment when the same protocol version no longer guarantees safe Client-Host
 // interoperability. Mismatches are rejected before domain commands are admitted.
-export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 208;
+export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 215;
+// 215: WorkHub coordination uses canonical configuration and scoped delegated permissions.
+// 212: Session catalogs carry `backgroundActivity` and `backgroundActivityVersion`
+// for Host-owned activity and generation-scoped ordering independent of Session
+// revisions and Turn epochs. Older closed decoders reject these fields.
 // 208: Usage queries filter by model call kind. Epoch-207 peers reject the
 // filter or ignore it.
 // 206: `storage.retention.query` and `storage.retention.set` read and change the

package/node_modules/@maka/runtime-host/dist/protocol/message.js

@@ -17,7 +17,7 @@
  * under the License.
  */
 import { invalidProtocolFrame } from './errors.js';
-import { assertExactKeys, requireCount, requireEntityId, requireExactRecord, requireId, requireRecord, requireShapedRecord, } from './codec.js';
+import { assertExactKeys, requireCount, requireEncodedByteLimit, requireEntityId, requireExactRecord, requireId, requireRecord, requireShapedRecord, } from './codec.js';
 import { defineOperation } from './operation-spec.js';
 import { decodeMessageAdmissionContent, decodeSkillIds, decodeTurnOrchestration, decodeTurnSnapshot, } from './turn.js';
 import { decodeSkillInvocationResult } from '@maka/core/skill-invocation';
@@ -377,15 +377,3 @@ function assertUniqueQueueEntries(entries, label) {
         messageIds.add(entry.messageId);
     }
 }
-function requireEncodedByteLimit(value, label, maxBytes) {
-    let encoded;
-    try {
-        encoded = JSON.stringify(value);
-    }
-    catch {
-        throw invalidProtocolFrame(`Invalid ${label}`);
-    }
-    if (encoded === undefined || Buffer.byteLength(encoded, 'utf8') > maxBytes) {
-        throw invalidProtocolFrame(`Invalid ${label}`);
-    }
-}

package/node_modules/@maka/runtime-host/dist/protocol/session-catalog.js

@@ -101,6 +101,8 @@ const PROJECTION_FIELDS = [
     'thinkingLevel',
     'lastReadMessageId',
     'liveRunState',
+    'backgroundActivity',
+    'backgroundActivityVersion',
 ];
 export const SESSION_CATALOG_OPERATION_SPECS = {
     'session.shared.query': defineOperation({
@@ -176,7 +178,15 @@ function decodeSharedSessionCatalogQueryResult(value) {
     return { session };
 }
 export function decodeSharedSessionCatalogProjection(value) {
-    const exact = requireShapedRecord(value, 'shared Session catalog projection', ['kind', 'id', 'revision', 'createdAt', 'activityAt', 'name', 'status'], ['lastMessageAt', 'lastMessagePreview', 'liveRunState', 'blockedReason', 'statusUpdatedAt']);
+    const exact = requireShapedRecord(value, 'shared Session catalog projection', ['kind', 'id', 'revision', 'createdAt', 'activityAt', 'name', 'status'], [
+        'lastMessageAt',
+        'lastMessagePreview',
+        'liveRunState',
+        'backgroundActivity',
+        'backgroundActivityVersion',
+        'blockedReason',
+        'statusUpdatedAt',
+    ]);
     if (exact.kind !== 'shared_session')
         throw invalidProtocolFrame('Invalid shared Session kind');
     return {
@@ -190,6 +200,7 @@ export function decodeSharedSessionCatalogProjection(value) {
         ...optionalText(exact, 'lastMessagePreview', SESSION_CATALOG_PREVIEW_MAX_BYTES),
         status: decodeSessionStatus(exact.status),
         ...optionalLiveRunState(exact),
+        ...optionalBackgroundActivity(exact),
         ...optionalBlockedReason(exact),
         ...optionalTimestamp(exact, 'statusUpdatedAt'),
     };
@@ -518,6 +529,7 @@ export function decodeSessionCatalogProjection(value) {
         ...optionalText(record, 'lastMessagePreview', SESSION_CATALOG_PREVIEW_MAX_BYTES),
         status: decodeSessionStatus(record.status),
         ...optionalLiveRunState(record),
+        ...optionalBackgroundActivity(record),
         ...optionalBlockedReason(record),
         ...optionalTimestamp(record, 'statusUpdatedAt'),
         ...optionalEntityId(record, 'parentSessionId'),
@@ -640,6 +652,29 @@ function optionalBlockedReason(record) {
     }
     return { blockedReason: record.blockedReason };
 }
+function optionalBackgroundActivity(record) {
+    const activity = record.backgroundActivity;
+    if (activity === undefined) {
+        if (record.backgroundActivityVersion !== undefined)
+            throw invalidProtocolFrame('Session background activity version requires activity');
+        return {};
+    }
+    if (activity !== 'idle' &&
+        activity !== 'running' &&
+        activity !== 'waiting_for_user' &&
+        activity !== 'blocked')
+        throw invalidProtocolFrame('Invalid Session background activity');
+    if (record.backgroundActivityVersion === undefined)
+        return { backgroundActivity: activity };
+    const version = requireExactRecord(record.backgroundActivityVersion, 'Session background activity version', ['hostGeneration', 'revision']);
+    return {
+        backgroundActivity: activity,
+        backgroundActivityVersion: {
+            hostGeneration: decodeHostGeneration(version.hostGeneration),
+            revision: requireCount(version.revision, 'Session background activity revision'),
+        },
+    };
+}
 function optionalLiveRunState(record) {
     if (record.liveRunState === undefined)
         return {};
@@ -671,13 +706,6 @@ function optionalLiveRunState(record) {
             liveRunState.runEpoch < 0)) {
         throw invalidProtocolFrame('Invalid Session catalog run epoch');
     }
-    if (liveRunState.hostGeneration !== undefined &&
-        (typeof liveRunState.hostGeneration !== 'string' ||
-            liveRunState.hostGeneration.length === 0 ||
-            liveRunState.hostGeneration.length > SESSION_CATALOG_HOST_GENERATION_MAX_CHARS ||
-            /[\u0000-\u001f\u007f]/.test(liveRunState.hostGeneration))) {
-        throw invalidProtocolFrame('Invalid Session catalog host generation');
-    }
     return {
         liveRunState: {
             schemaVersion: SESSION_CATALOG_LIVE_RUN_STATE_SCHEMA_VERSION,
@@ -685,10 +713,19 @@ function optionalLiveRunState(record) {
             ...(liveRunState.runEpoch === undefined ? {} : { runEpoch: liveRunState.runEpoch }),
             ...(liveRunState.hostGeneration === undefined
                 ? {}
-                : { hostGeneration: liveRunState.hostGeneration }),
+                : { hostGeneration: decodeHostGeneration(liveRunState.hostGeneration) }),
         },
     };
 }
+function decodeHostGeneration(value) {
+    if (typeof value !== 'string' ||
+        value.length === 0 ||
+        value.length > SESSION_CATALOG_HOST_GENERATION_MAX_CHARS ||
+        /[\u0000-\u001f\u007f]/.test(value)) {
+        throw invalidProtocolFrame('Invalid Session catalog host generation');
+    }
+    return value;
+}
 function optionalSubagent(record) {
     if (!Object.hasOwn(record, 'subagent'))
         return {};

package/node_modules/@maka/runtime-host/dist/protocol/session-continuity.js

@@ -18,7 +18,7 @@
  */
 import { TOOL_ACTIVITY_KINDS, TOOL_OUTPUT_DELTA_MAX_CHARS } from '@maka/core/events';
 import { decodeToolResultPreviewContent } from '@maka/core/tool-result-preview';
-import { assertExactKeys, requireCount, requireEntityId, requireExactRecord, requireId, requireOpaqueIdentity, requireRecord, } from './codec.js';
+import { assertExactKeys, requireCount, requireEncodedByteLimit, requireEntityId, requireExactRecord, requireId, requireOpaqueIdentity, requireRecord, } from './codec.js';
 import { invalidProtocolFrame } from './errors.js';
 import { decodeSessionStatus } from './session-status.js';
 import { decodeSessionInteractionProjection, } from './interaction.js';
@@ -773,18 +773,6 @@ function requireUtf8BoundedString(value, label, maxBytes) {
     }
     return value;
 }
-function requireEncodedByteLimit(value, label, maxBytes) {
-    let encoded;
-    try {
-        encoded = JSON.stringify(value);
-    }
-    catch {
-        throw invalidProtocolFrame(`Invalid ${label}`);
-    }
-    if (encoded === undefined || Buffer.byteLength(encoded, 'utf8') > maxBytes) {
-        throw invalidProtocolFrame(`Invalid ${label}`);
-    }
-}
 /**
  * Read against the one list rather than a copy of it.
  *

package/node_modules/@maka/runtime-host/dist/protocol/turn.js

@@ -22,7 +22,7 @@ import { isOrchestrationMode, isTurnOrchestrationSource, } from '@maka/core/orch
 import { decodeSkillInvocationResult, } from '@maka/core/skill-invocation';
 import { decodeTurnOrigin } from '@maka/core/turn-origin';
 import { invalidProtocolFrame } from './errors.js';
-import { assertExactKeys, requireCount, requireEntityId, requireExactRecord, requireShapedRecord, requireId, requireRecord, requireString, } from './codec.js';
+import { assertExactKeys, requireCount, requireEncodedByteLimit, requireEntityId, requireExactRecord, requireShapedRecord, requireId, requireRecord, requireString, } from './codec.js';
 import { defineOperation } from './operation-spec.js';
 import { decodeTurnProviderRetry } from './turn-provider-retry.js';
 export { decodeTurnProviderRetry } from './turn-provider-retry.js';
@@ -281,18 +281,6 @@ function requireUtf8String(value, label, maxBytes, allowEmpty) {
     }
     return value;
 }
-function requireEncodedByteLimit(value, label, maxBytes) {
-    let encoded;
-    try {
-        encoded = JSON.stringify(value);
-    }
-    catch {
-        throw invalidProtocolFrame(`Invalid ${label}`);
-    }
-    if (encoded === undefined || Buffer.byteLength(encoded, 'utf8') > maxBytes) {
-        throw invalidProtocolFrame(`Invalid ${label}`);
-    }
-}
 function decodeTurnQueryInput(value) {
     const record = requireExactRecord(value, 'turn.query input', ['sessionId', 'turnId']);
     return {

package/node_modules/@maka/runtime-host/dist/protocol/workhub-coordination.js

@@ -190,13 +190,7 @@ export function decodeWorkHubCoordinationCandidatesResult(value) {
     };
 }
 export function decodeWorkHubCoordinationSelectAndDelegateInput(value) {
-    const input = requireExactRecord(value, 'WorkHub selection input', [
-        'turnId',
-        'actionId',
-        'candidateSetId',
-        'candidateRefs',
-        'delegationText',
-    ]);
+    const input = requireShapedRecord(value, 'WorkHub selection input', ['turnId', 'actionId', 'candidateSetId', 'candidateRefs', 'delegationText'], ['create']);
     if (!Array.isArray(input.candidateRefs) ||
         input.candidateRefs.length < 1 ||
         input.candidateRefs.length > WORKHUB_COORDINATION_CANDIDATE_MAX_ITEMS) {
@@ -206,6 +200,9 @@ export function decodeWorkHubCoordinationSelectAndDelegateInput(value) {
     if (new Set(candidateRefs).size !== candidateRefs.length)
         throw invalidProtocolFrame('Duplicate WorkHub selection candidates');
     return {
+        ...(input.create !== undefined
+            ? { create: decodeWorkHubCoordinationCreateContext(input.create) }
+            : {}),
         turnId: requireEntityId(input.turnId, 'WorkHub Coordination Turn id'),
         actionId: requireEntityId(input.actionId, 'WorkHub action id'),
         candidateSetId: requireUtf8String(input.candidateSetId, 'WorkHub candidate set', 256),