maka-agent 0.2.1-dev.91.20261018 → 0.2.2-dev.97.20261024

package/node_modules/@maka/runtime-host/dist/assistant/proactive-matters/tools.js

@@ -16,8 +16,10 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { conditionInput, normalizeCondition, } from './condition.js';
 import { z } from 'zod';
 import { MatterReviewInvalidated } from './review.js';
+import { isPendingActivationTurnId } from './matter.js';
 export function buildMatterTools(deps) {
     const own = (ctx) => {
         deps.authorize?.(ctx);
@@ -35,10 +37,42 @@ export function buildMatterTools(deps) {
         kind: z.literal('at'),
         at: z.number().describe('Future absolute Unix milliseconds'),
     });
+    const progressSummary = z
+        .string()
+        .trim()
+        .min(1)
+        .refine((value) => Array.from(value).length <= 30, 'Progress summary must be at most 30 characters')
+        .describe('用不超过30字概括当前进展，供用户在任务列表查看。由你概括，不要截断正文。');
     return [
+        {
+            name: 'MatterConditionTest',
+            discovery: 'direct',
+            description: 'Test and save a read-only JavaScript condition checker against real data. Inspect the returned result and fix/retest until it matches the intended condition. Testing does not register a wait. Pass checkerId to MatterSettle wait with an absolute fallback time in wakes. Code/parameters are immutable for that ID; changed code must be tested again. Background checks use the same read-only capabilities and current source permissions, without a model. A trigger, repeated failure or fallback time wakes this task once.',
+            parameters: conditionInput,
+            categoryHint: 'file_write',
+            executionSemantics: 'exclusive_step',
+            impl: async (input, ctx) => {
+                const o = own(ctx);
+                deps.store.assertActive(o.id, o.activationId);
+                if (!deps.testCondition)
+                    throw new Error('Condition execution is unavailable');
+                const definition = normalizeCondition(input);
+                const result = await deps.testCondition(definition, ctx);
+                ctx.abortSignal.throwIfAborted();
+                deps.store.assertActive(o.id, o.activationId);
+                const saved = deps.store.conditions.saveTest(o.id, definition, result);
+                return {
+                    checkerId: saved.id,
+                    testedAt: saved.testedAt,
+                    result: saved.result,
+                    waiting: false,
+                };
+            },
+        },
         {
             name: 'MatterRead',
-            description: 'Refresh file paths, revision and current time. This writes observation state and may bind a queued activation; it is not read-only. Read request.md, state.md and inbox.json with MatterReadFile; their contents are not returned here. Call alone.',
+            discovery: 'direct',
+            description: 'Refresh file paths, revision and current time. This writes observation state and may bind a queued activation; it is not read-only. Use only when you need task files/history; not required before settlement. Call alone.',
             parameters: z.object({
                 activationId: z
                     .string()
@@ -54,17 +88,24 @@ export function buildMatterTools(deps) {
                     m &&
                     m.activation &&
                     m.activation.id === input.activationId &&
-                    m.activation.turnId.startsWith('pending:'))
+                    isPendingActivationTurnId(m.activation.turnId))
                     deps.store.bindTurn(m.id, input.activationId, ctx.turnId);
                 const o = own(ctx);
                 deps.store.observe(o.id, o.activationId);
-                return deps.store.workspace(o.id, o.activationId);
+                const snapshot = deps.store.get(o.id);
+                return {
+                    ...deps.store.workspace(o.id, o.activationId),
+                    request: snapshot.matter.request,
+                    note: snapshot.matter.stateText,
+                    events: snapshot.events,
+                };
             },
         },
         {
             name: 'MatterCheckpoint',
             description: 'Save current working state after meaningful progress. Does not end this run or change the user objective.',
             parameters: z.object({
+                progressSummary,
                 expectedRevision: z.number().int().positive(),
                 stateFile: z
                     .string()
@@ -74,21 +115,33 @@ export function buildMatterTools(deps) {
             executionSemantics: 'exclusive_step',
             impl: (input, ctx) => {
                 const o = own(ctx);
-                const result = deps.store.checkpoint(o.id, o.activationId, input.expectedRevision, deps.store.readDraft(o.id, o.activationId, input.stateFile), operation(ctx));
+                const result = deps.store.checkpoint(o.id, o.activationId, input.expectedRevision, deps.store.readDraft(o.id, o.activationId, input.stateFile), operation(ctx), input.progressSummary);
                 deps.changed();
                 return deps.store.workspace(result.id, o.activationId);
             },
         },
         {
             name: 'MatterSettle',
-            description: 'Commit state and finish this activation: continue immediately, wait for a specific external condition, or complete the original objective. No business tools may execute after success.',
+            discovery: 'direct',
+            description: 'Submit your result directly (optional note, no draft file required) and finish this activation: continue immediately, wait for a specific external condition, or complete the original objective. Continue commits without model review; wait and complete are reviewed for premature exit or missed requirements, not for reprinting historical evidence. No business tools may execute after success.',
             parameters: z.object({
-                expectedRevision: z.number().int().positive(),
-                stateFile: z
+                note: z
                     .string()
-                    .describe('Absolute path to this activation’s draft.md, edited with MatterWriteFile before submitting'),
+                    .max(24000)
+                    .optional()
+                    .describe('Optional working note to retain for future activations. Omit to keep the previous note; no draft file is needed.'),
+                progressSummary,
                 disposition: z.enum(['continue', 'wait', 'complete']),
                 wakes: z.array(wake).max(10).optional(),
+                condition: z
+                    .object({
+                    checkerId: z
+                        .string()
+                        .describe('ID returned by a successful MatterConditionTest in this task'),
+                    intervalMs: z.number().int().min(1000).max(86400000).default(60000),
+                })
+                    .optional()
+                    .describe('Optional tested condition for wait. wakes must still include an absolute fallback time; the first trigger or fallback wins. Testing alone does not wait.'),
                 waitingFor: z
                     .string()
                     .trim()
@@ -96,18 +149,11 @@ export function buildMatterTools(deps) {
                     .max(1000)
                     .optional()
                     .describe('For wait only: the concrete condition that prevents useful work now. A wake time is only when to check it.'),
-                reason: z.string().min(1).max(2000),
                 summary: z
                     .string()
                     .min(1)
                     .max(4000)
-                    .describe('What this activation actually did and found. The host appends this to history with a timestamp.'),
-                next: z
-                    .string()
-                    .min(1)
-                    .max(2000)
-                    .optional()
-                    .describe('Possible next actions, based on the current judgment; future activations must reassess them.'),
+                    .describe('What you did and found, and why continuing, waiting or completing is appropriate. The host saves this with a timestamp.'),
                 update: z
                     .string()
                     .max(2000)
@@ -118,13 +164,37 @@ export function buildMatterTools(deps) {
             executionSemantics: 'exclusive_step',
             impl: async (input, ctx) => {
                 const o = own(ctx);
-                const { stateFile, ...commit } = input;
-                const submission = {
-                    ...commit,
-                    stateText: deps.store.readDraft(o.id, o.activationId, stateFile),
-                };
                 try {
-                    const review = deps.store.beginReview(o.id, o.activationId, submission, operation(ctx), stateFile);
+                    const { note, ...commit } = input;
+                    const previous = deps.store.submittedInput(operation(ctx));
+                    let revision;
+                    let state;
+                    if (previous) {
+                        revision = previous.expectedRevision;
+                        state = previous.stateText;
+                    }
+                    else {
+                        const delivered = await deps.deliveredInput?.(ctx);
+                        if (!delivered || delivered.activationId !== o.activationId)
+                            throw new MatterReviewInvalidated();
+                        const m = deps.store.adoptDeliveredInput(o.id, o.activationId, delivered.basis, delivered.eventCursor);
+                        revision = m.revision;
+                        state = m.stateText;
+                    }
+                    const submission = {
+                        ...commit,
+                        expectedRevision: revision,
+                        stateText: note ?? state,
+                        reason: commit.summary.slice(0, 2000),
+                    };
+                    deps.store.saveSubmission(operation(ctx), submission);
+                    if (submission.disposition === 'continue') {
+                        ctx.abortSignal.throwIfAborted();
+                        const result = deps.store.settle(o.id, o.activationId, submission, operation(ctx));
+                        deps.changed();
+                        return deps.store.workspace(result.id, o.activationId);
+                    }
+                    const review = deps.store.beginReview(o.id, o.activationId, submission, operation(ctx));
                     const verdict = review.committed ? review.verdict : await deps.review(review);
                     ctx.abortSignal.throwIfAborted();
                     if (!review.verdict)
@@ -158,7 +228,7 @@ export function buildMatterTools(deps) {
         },
         {
             name: 'MatterWriteFile',
-            description: 'Write the entire draft.md file for this activation. This edits a working file only; publish it with MatterCheckpoint or MatterSettle. Other matter files are host-owned.',
+            description: 'Optional legacy draft editor for this activation. Publish this file with MatterCheckpoint. MatterSettle accepts an inline note instead and does not read the draft. Other matter files are host-owned.',
             parameters: z.object({ path: z.string(), content: z.string() }),
             categoryHint: 'file_write',
             executionSemantics: 'exclusive_step',

package/node_modules/@maka/runtime-host/dist/assistant/service.js

@@ -30,7 +30,28 @@ class AssistantRuntime {
     directory;
     dependencies;
     tools = [];
+    internalTools = [];
+    toolFilters = [];
     bot = new AssistantBotBridge();
+    backgroundSessions = [];
+    sessionAccess = [];
+    hasSessionAccess(sessionId) {
+        return (this.bot.isConversation(sessionId) ||
+            this.bot.isWorker(sessionId) ||
+            this.backgroundSessions.some((read) => read().includes(sessionId)) ||
+            this.sessionAccess.some((allows) => allows(sessionId)));
+    }
+    /**
+     * The only visibility policy. Catalogs and execution both use it, so a tool hidden
+     * from a Session cannot run in that Session either.
+     */
+    visibleTools(sessionId, tools) {
+        const nativeNames = new Set(this.tools.map((tool) => tool.name));
+        const allowed = this.hasSessionAccess(sessionId)
+            ? tools
+            : tools.filter((tool) => !nativeNames.has(tool.name));
+        return this.toolFilters.reduce((current, filter) => filter(sessionId, current), allowed);
+    }
     sections = [];
     contexts = [];
     checks = [];
@@ -53,18 +74,19 @@ class AssistantRuntime {
         if (this.initialized)
             throw Error('Personal assistant already initialized');
         const settings = await this.loadSettings(legacy, entries);
-        const backgroundSessions = [];
         const services = {
             bot: this.bot,
-            backgroundSessions: { register: (read) => backgroundSessions.push(read) },
+            backgroundSessions: { register: (read) => this.backgroundSessions.push(read) },
             ...this.dependencies,
             onClose: (dispose) => this.disposers.push(dispose),
             onStart: (start) => this.starters.push(start),
             tools: {
+                filter: (filter) => this.toolFilters.push(filter),
+                registerSessionAccess: (allows) => this.sessionAccess.push(allows),
                 register: (tool) => {
                     if (this.tools.some((t) => t.name === tool.name))
                         throw Error(`Duplicate assistant tool: ${tool.name}`);
-                    this.tools.push({
+                    const internalTool = {
                         ...tool,
                         impl: (input, call) => {
                             if (this.closing)
@@ -84,9 +106,26 @@ class AssistantRuntime {
                                 return this.dependencies.agents.withInvocation(scoped, () => tool.impl(input, scoped));
                             });
                         },
+                    };
+                    this.internalTools.push(internalTool);
+                    this.tools.push({
+                        ...internalTool,
+                        impl: (input, call) => {
+                            if (this.closing)
+                                throw Error('Personal assistant is shutting down');
+                            if (!this.hasSessionAccess(call.sessionId))
+                                throw Error('Personal assistant tools are unavailable in this session');
+                            if (!this.visibleTools(call.sessionId, [tool]).length)
+                                throw Error('Personal assistant tool is unavailable in this session');
+                            return internalTool.impl(input, call);
+                        },
                     });
                 },
-                resolve: (sessionId) => sessionId ? this.dependencies.resolveTools(sessionId, this.tools) : { tools: this.tools },
+                // Only Host module APIs use this resolver. They retain the caller's source
+                // permissions (e.g. ordinary-chat original links) without exposing model tools.
+                resolve: (sessionId) => sessionId
+                    ? this.dependencies.resolveTools(sessionId, this.internalTools)
+                    : { tools: this.internalTools },
             },
             systemPrompt: {
                 section: (value) => this.sections.push(value),
@@ -114,7 +153,7 @@ class AssistantRuntime {
             ])
                 await initialize(services, settings[name].directory, settings[name].config);
             await this.dependencies.markBackgroundSessions([
-                ...new Set(backgroundSessions.flatMap((read) => read())),
+                ...new Set(this.backgroundSessions.flatMap((read) => read())),
             ]);
             this.initialized = true;
         }
@@ -275,7 +314,7 @@ class AssistantRuntime {
         return settings;
     }
 }
-/** Host-owned opt-in. Disabled Hosts do not load modules, open their databases or start timers. */
+/** Host-owned enablement, on by default. Disabled Hosts do not load modules, open their databases or start timers. */
 export class PersonalAssistantService {
     directory;
     dependencies;
@@ -288,6 +327,7 @@ export class PersonalAssistantService {
     transition = Promise.resolve();
     shutdown;
     stoppingError;
+    initializationError;
     constructor(directory, dependencies) {
         this.directory = directory;
         this.dependencies = dependencies;
@@ -303,19 +343,26 @@ export class PersonalAssistantService {
             throw Error('Personal assistant already initialized');
         this.legacy = legacy;
         this.entries = entries;
-        let enabled = false;
         try {
-            const saved = JSON.parse(await readFile(join(this.directory, 'enablement.json'), 'utf8'));
-            if (typeof saved.enabled !== 'boolean')
-                throw Error('Invalid personal assistant enablement');
-            enabled = saved.enabled;
+            let enabled = true;
+            try {
+                const saved = JSON.parse(await readFile(join(this.directory, 'enablement.json'), 'utf8'));
+                if (typeof saved.enabled !== 'boolean')
+                    throw Error('Invalid personal assistant enablement');
+                enabled = saved.enabled;
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+            if (enabled)
+                this.runtime = await this.initialize();
         }
         catch (error) {
-            if (error.code !== 'ENOENT')
-                throw error;
+            // Optional assistant recovery must not prevent ordinary Host sessions from starting.
+            // Keep persisted preferences/data intact so Settings can retry after repair.
+            this.initializationError = error instanceof Error ? error.message : String(error);
         }
-        if (enabled)
-            this.runtime = await this.initialize();
         this.recovered = true;
     }
     async initialize() {
@@ -348,7 +395,10 @@ export class PersonalAssistantService {
         if (!this.started || this.draining)
             throw Error('Personal assistant is not ready');
         if (method === 'assistant.enablement')
-            return { enabled: this.enabled };
+            return {
+                enabled: this.enabled,
+                ...(this.initializationError ? { error: this.initializationError } : {}),
+            };
         if (method === 'assistant.set-enabled') {
             if (!input ||
                 typeof input !== 'object' ||
@@ -375,6 +425,7 @@ export class PersonalAssistantService {
                             throw Error('Personal assistant is shutting down');
                         this.runtime = runtime;
                         runtime.start();
+                        this.initializationError = undefined;
                     }
                     catch (error) {
                         this.runtime = undefined;
@@ -415,6 +466,11 @@ export class PersonalAssistantService {
     hasInboxMessage(sessionId, id) {
         return this.enabled && this.runtime.bot.hasUserMessage(sessionId, id);
     }
+    filterTools(sessionId, tools) {
+        if (!this.enabled)
+            return tools;
+        return this.runtime.visibleTools(sessionId, tools);
+    }
     toolCeiling(sessionId) {
         return this.enabled && this.runtime.bot.isWorker(sessionId)
             ? this.runtime.tools.filter((tool) => BOT_TOOLS.has(tool.name))

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

@@ -60,7 +60,14 @@ export function sameResolvedRuntimeHostProfileTarget(left, right) {
     if (left.profile.kind === 'local' || right.profile.kind === 'local')
         return true;
     if (left.profile.kind === 'environment' || right.profile.kind === 'environment') {
-        return profileTargetBinding(left.profile) === profileTargetBinding(right.profile);
+        if (left.profile.kind !== 'environment' || right.profile.kind !== 'environment')
+            return false;
+        const a = left.profile.operator;
+        const b = right.profile.operator;
+        return (sameEnvironmentRuntimeHostDeployment(left.profile, right.profile) &&
+            (a.kind === 'node' && b.kind === 'node'
+                ? a.modulePath === b.modulePath
+                : operatorTargetBinding(a) === operatorTargetBinding(b)));
     }
     return (left.profile.id === right.profile.id &&
         profileCredentialBinding(left.profile) === profileCredentialBinding(right.profile) &&
@@ -746,6 +753,28 @@ class FileRuntimeHostProfileCatalog {
             return { rebound: true, document: next };
         });
     }
+    updateEnvironmentOperatorIfCurrent(expected, operator) {
+        const source = decodeEnvironmentRuntimeHostProfile(expected);
+        const replacement = decodeRuntimeHostPosixOperatorCommand(operator);
+        if (source.operator.kind !== 'node' ||
+            replacement.kind !== 'node' ||
+            source.operator.modulePath !== replacement.modulePath)
+            throw new Error('WSL recovery must retain its operator module');
+        return this.#exclusive(async () => {
+            const current = await this.#readSnapshot();
+            const profile = current.profiles.find((p) => p.id === source.id && p.kind === 'environment');
+            if (!profile ||
+                !sameEnvironmentRuntimeHostDeployment(profile, source) ||
+                operatorTargetBinding(profile.operator) !== operatorTargetBinding(source.operator))
+                return false;
+            const updated = decodeEnvironmentRuntimeHostProfile({ ...profile, operator: replacement });
+            await writeProfileDocument(this.path, decodeRuntimeHostProfileDocument({
+                schemaVersion: PROFILE_SCHEMA_VERSION,
+                profiles: current.profiles.map((p) => (p.id === profile.id ? updated : p)),
+            }));
+            return true;
+        });
+    }
     updateRemoteProfileIfCurrent(target, update) {
         const expectedProfile = decodeRemoteRuntimeHostProfile(target.profile);
         const expectedIncarnationId = requireProfileIncarnationId(target.profileIncarnationId);

package/node_modules/@maka/runtime-host/dist/client/ssh-operator-activation.js

@@ -96,23 +96,30 @@ export function runtimeHostSshOperatorRemoteCommand(operator, args, environment
     if (operator.kind !== 'node')
         throw new Error('Windows Runtime Host operator must use Node');
     const payload = Buffer.from(JSON.stringify({
-        ...invocation,
+        executable: invocation.executable,
+        // ProcessStartInfo bypasses Windows PowerShell 5.1's lossy native argument
+        // binder. Encode the argv using the Windows C runtime quoting rules.
+        argumentLine: invocation.args.map(quoteWindowsArgument).join(' '),
         environment,
         modulePath: operator.modulePath,
         deploymentRoot: win32.dirname(operator.modulePath),
         missingOperatorIsSuccess: options.missingOperatorIsSuccess === true,
     }), 'utf8').toString('base64');
     const script = [
+        `$ProgressPreference='SilentlyContinue'`,
         `$p=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${payload}'))|ConvertFrom-Json`,
         `if($p.missingOperatorIsSuccess -and -not (Test-Path -LiteralPath $p.modulePath -PathType Leaf)){if(-not (Test-Path -LiteralPath $p.deploymentRoot)){exit 0}else{exit 1}}`,
         `foreach($e in $p.environment.psobject.Properties){[Environment]::SetEnvironmentVariable($e.Name,[string]$e.Value,'Process')}`,
         `$code=1`,
-        `try{& ([string]$p.executable) @($p.args|ForEach-Object {[string]$_});$code=if($null -eq $LASTEXITCODE){1}else{$LASTEXITCODE}}catch{$code=1}`,
+        `try{$start=New-Object System.Diagnostics.ProcessStartInfo;$start.FileName=[string]$p.executable;$start.Arguments=[string]$p.argumentLine;$start.UseShellExecute=$false;$child=[System.Diagnostics.Process]::Start($start);try{$child.WaitForExit();$code=$child.ExitCode}finally{$child.Dispose()}}catch{$code=1}`,
         `exit $code`,
     ].join(';');
     const encoded = Buffer.from(script, 'utf16le').toString('base64');
     return `powershell.exe -NoLogo -NoProfile -NonInteractive -EncodedCommand ${encoded}`;
 }
+function quoteWindowsArgument(value) {
+    return `"${value.replace(/(\\*)"/gu, '$1$1\\"').replace(/(\\+)$/u, '$1$1')}"`;
+}
 async function waitForActivation(child, input, timeoutMs) {
     let stdout = Buffer.alloc(0);
     let overflow = false;

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

@@ -20,7 +20,12 @@ import { GOAL_CONDITION_TEXT_LIMIT, GOAL_MAX_ITERATIONS_LIMIT, GOAL_REASON_TEXT_
 import { requireCount, requireEncodedByteLimit, requireEntityId, requireExactRecord, requireUtf8String, } from './codec.js';
 import { invalidProtocolFrame } from './errors.js';
 import { defineOperation } from './operation-spec.js';
-export const GOAL_RESULT_MAX_BYTES = 8 * 1024;
+export const GOAL_RESULT_MAX_BYTES = 16 * 1024;
+/** Display bounds; canonical ShellRun references fit in full. */
+export const GOAL_EVENT_WAIT_SUMMARY_LIMITS = Object.freeze({
+    resourceIdBytes: 512,
+    reasonCodeBytes: 128,
+});
 const QUERY_ERRORS = [
     'host_not_ready',
     'host_draining',
@@ -31,6 +36,17 @@ const QUERY_ERRORS = [
 const CONTROL_ERRORS = [...QUERY_ERRORS, 'session_archived', 'operation_conflict'];
 const ARM_ERRORS = CONTROL_ERRORS;
 export const GOAL_OPERATION_SPECS = {
+    'goal.event-wait.cancel': defineOperation({
+        mode: 'control',
+        availability: 'ready',
+        errors: CONTROL_ERRORS,
+        decodeInput: decodeGoalEventWaitCancelInput,
+        decodeOutput: decodeGoalEventWaitCancelResult,
+        assertOutputForInput(input, output) {
+            if (input.sessionId !== output.sessionId)
+                throw invalidProtocolFrame('Wait cancellation belongs to another Session');
+        },
+    }),
     'goal.query': defineOperation({
         mode: 'query',
         availability: 'ready',
@@ -85,6 +101,7 @@ export function decodeGoalProjection(value) {
         'lastReason',
         'achievedAt',
         'pausedAt',
+        'eventWait',
     ]);
     const condition = requireUtf8String(record.condition, 'Goal condition', GOAL_CONDITION_TEXT_LIMIT.utf8Bytes);
     if (condition.length > GOAL_CONDITION_TEXT_LIMIT.codeUnits) {
@@ -107,6 +124,7 @@ export function decodeGoalProjection(value) {
         lastReason,
         achievedAt: requireNullableCount(record.achievedAt, 'Goal achievedAt'),
         pausedAt: requireNullableCount(record.pausedAt, 'Goal pausedAt'),
+        eventWait: record.eventWait === null ? null : decodeGoalEventWaitProjection(record.eventWait),
     };
 }
 function decodeGoalQueryInput(value) {
@@ -220,3 +238,103 @@ function requireNullableCount(value, label) {
         return null;
     return requireCount(value, label);
 }
+export function decodeGoalEventWaitProjection(value) {
+    const r = requireExactRecord(value, 'Goal event wait', [
+        'waitId',
+        'controlGeneration',
+        'waitRevision',
+        'resource',
+        'reason',
+        'deadlineAt',
+        'phase',
+        'observation',
+        'outcome',
+    ]);
+    const resource = requireExactRecord(r.resource, 'Wait resource', [
+        'providerId',
+        'resourceType',
+        'resourceId',
+    ]);
+    if (r.phase !== 'observing' && r.phase !== 'awaiting_admission')
+        throw invalidProtocolFrame('Invalid wait phase');
+    if (r.outcome !== null &&
+        r.outcome !== 'satisfied' &&
+        r.outcome !== 'invalidated' &&
+        r.outcome !== 'source_unavailable' &&
+        r.outcome !== 'expired')
+        throw invalidProtocolFrame('Invalid wait outcome');
+    let observation = null;
+    if (r.observation !== null) {
+        const o = requireExactRecord(r.observation, 'Wait observation', [
+            'state',
+            'lastObservedAt',
+            'reasonCode',
+        ]);
+        if (o.state !== 'checking' && o.state !== 'pending' && o.state !== 'unknown')
+            throw invalidProtocolFrame('Invalid observation state');
+        observation = {
+            state: o.state,
+            lastObservedAt: requireNullableCount(o.lastObservedAt, 'Observation time'),
+            reasonCode: o.reasonCode === null
+                ? null
+                : requireUtf8String(o.reasonCode, 'Observation reason', GOAL_EVENT_WAIT_SUMMARY_LIMITS.reasonCodeBytes),
+        };
+    }
+    if ((r.phase === 'observing' && (observation === null || r.outcome !== null)) ||
+        (r.phase === 'awaiting_admission' && (observation !== null || r.outcome === null)))
+        throw invalidProtocolFrame('Inconsistent wait phase');
+    const reason = requireNullableGoalReason(r.reason);
+    if (reason === null)
+        throw invalidProtocolFrame('Invalid wait reason');
+    return {
+        waitId: requireEntityId(r.waitId, 'waitId'),
+        controlGeneration: requireCount(r.controlGeneration, 'Control generation'),
+        waitRevision: requireCount(r.waitRevision, 'Wait revision'),
+        resource: {
+            providerId: requireWaitTypeId(resource.providerId, 'Wait provider'),
+            resourceType: requireWaitTypeId(resource.resourceType, 'Wait resource type'),
+            resourceId: requireUtf8String(resource.resourceId, 'Wait reference', GOAL_EVENT_WAIT_SUMMARY_LIMITS.resourceIdBytes),
+        },
+        reason,
+        deadlineAt: requireCount(r.deadlineAt, 'Wait deadline'),
+        phase: r.phase,
+        observation,
+        outcome: r.outcome,
+    };
+}
+function decodeGoalEventWaitCancelInput(value) {
+    const r = requireExactRecord(value, 'Wait cancellation', [
+        'sessionId',
+        'goalId',
+        'controlGeneration',
+        'waitId',
+        'expectedGoalRevision',
+    ]);
+    return {
+        sessionId: requireEntityId(r.sessionId, 'sessionId'),
+        goalId: requireEntityId(r.goalId, 'goalId'),
+        waitId: requireEntityId(r.waitId, 'waitId'),
+        controlGeneration: requireCount(r.controlGeneration, 'Control generation'),
+        expectedGoalRevision: requireCount(r.expectedGoalRevision, 'Goal revision'),
+    };
+}
+function decodeGoalEventWaitCancelResult(value) {
+    requireEncodedByteLimit(value, 'Wait cancellation result', GOAL_RESULT_MAX_BYTES);
+    const r = requireExactRecord(value, 'Wait cancellation result', ['sessionId', 'outcome', 'goal']);
+    if (r.outcome !== 'cancelled' &&
+        r.outcome !== 'already_cancelled' &&
+        r.outcome !== 'already_admitted' &&
+        r.outcome !== 'conflict')
+        throw invalidProtocolFrame('Invalid cancellation outcome');
+    const sessionId = requireEntityId(r.sessionId, 'sessionId');
+    const goal = r.goal === null ? null : decodeGoalProjection(r.goal);
+    if (goal && goal.sessionId !== sessionId)
+        throw invalidProtocolFrame('Wait cancellation Goal belongs to another Session');
+    return { sessionId, outcome: r.outcome, goal };
+}
+function requireWaitTypeId(value, label) {
+    const id = requireUtf8String(value, label, 128);
+    if (!/^[A-Za-z0-9_.-]{1,128}$/.test(id))
+        throw invalidProtocolFrame(`Invalid ${label}`);
+    return id;
+}

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

@@ -68,13 +68,20 @@ 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.
+// Re-check against main before merging; sibling PRs may use the same next epoch.
+export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 229;
+// 229: Session check-in proposes cards for unfinished work across Sessions.
+// 228: Executor catalog queries support per-agent filtering and process-free inventory.
+// Older peers reject the executorId and listOnly fields in the strict query decoder.
+// 227: Goal projections carry eventWait and support goal.event-wait.cancel.
+// Older peers cannot decode the wait summary or cancel a specific wait.
+// 226: assistant.allocate-workspace allocates a Host-owned fallback for projectless assistants.
+// 225: Goal successor transcript origins carry typed event-wait provenance.
+// Older peers reject the additional field in the strict stored-message decoder.
 // 224: Assistant conversation admission supports Inbox receipts without a model Turn,
 // inbox execution-query resolutions, external connector provenance and message summaries.
 // Existing bot turn.start producers also carry strict external_connector provenance.
 // Also adds assistant.avatar/assistant.avatar-image and the bot block on assistant.binding.
-// 223 is used by the distinct protocol changes in open PRs #6115 and #6091;
-// re-check against main at merge time (the protocol epoch gate remains authoritative).
-export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 224;
 // 222: Built-in personal assistant operations and the Host-owned default-off
 // master switch require matching Client and Host support.
 // 221: Epoch-220 peers do not support `artifact.image.resolve` or its image