evolcore 0.0.31 → 0.0.33

package/dist/agents/codex-runner.js

@@ -177,10 +177,10 @@ function parseManagedPreToolUseDenial(value) {
         reason = 'EvolCore PreToolUse policy denied this tool call';
     const policyCode = /当前汇报命令(?:未通过规范解析|不符合当前会话)/.test(reason)
         ? 'proactive_send_invalid'
-        : /工具调用已达到\s*\d+\s*次/.test(reason)
-            ? 'proactive_tool_report_required'
-            : /请先用\s+ec\s+(?:group\s+send|msg\s+send)/.test(reason)
-                ? 'proactive_first_send_required'
+        : /连续违规\s*\d+\s*次，任务已中断/.test(reason)
+            ? 'proactive_circuit_break'
+            : /未包含意图表达，本轮只允许\s+ec\s+(?:group\s+send|msg\s+send)/.test(reason)
+                ? 'proactive_intent_required'
                 : 'managed_pre_tool_use_denied';
     return { policyCode, reason };
 }
@@ -1954,6 +1954,8 @@ export class CodexRunner {
             openToolCalls: new Map(),
             activeSubagentThreads: new Set(),
             turnCompleted: false,
+            inputId: turn?.inputId,
+            inputAcceptedEmitted: false,
         };
         const unsubscribe = appServer.onNotification(notification => {
             // 仅从 turn/started 锁定权威 turnId — resume 时会有上一轮 turn 的残留通知
@@ -2204,12 +2206,21 @@ export class CodexRunner {
         const pending = [...this.unconfirmedInterrupts.entries()].filter(([, record]) => record.sessionId === sessionId || (threadId && record.threadId === threadId));
         await Promise.all(pending.map(async ([key, record]) => {
             try {
-                // Local stream closure and unsubscribe do not prove the backend turn
-                // stopped. Check its exact identity before allowing another writer.
-                const response = await withInterruptDeadline(record.client.threadRead(record.threadId, true, 2_000), 'Codex interrupt verification', 2_000);
-                const turn = response.thread?.turns?.find(turn => turn.id === record.turnId);
+                const response = await withInterruptDeadline(record.client.threadRead(record.threadId, false, 2_000), 'Codex interrupt verification', 2_000);
+                const threadStatus = response.thread?.status?.type;
+                if (threadStatus === 'idle' || threadStatus === 'notLoaded') {
+                    if (this.unconfirmedInterrupts.get(key) === record) {
+                        this.unconfirmedInterrupts.delete(key);
+                        record.unsubscribe?.();
+                    }
+                    return;
+                }
+                if (threadStatus !== undefined)
+                    return;
+                const history = await withInterruptDeadline(record.client.threadRead(record.threadId, true, 2_000), 'Codex interrupt history verification', 2_000);
+                const turn = history.thread?.turns?.find(turn => turn.id === record.turnId);
                 if (turn && ['completed', 'failed', 'interrupted'].includes(String(turn.status))
-                    && !response.thread?.turns?.some(turn => turn.status === 'inProgress')
+                    && !history.thread?.turns?.some(turn => turn.status === 'inProgress')
                     && this.unconfirmedInterrupts.get(key) === record) {
                     this.unconfirmedInterrupts.delete(key);
                     record.unsubscribe?.();
@@ -4088,18 +4099,32 @@ export class CodexRunner {
         const requiresSandboxExpansionApproval = hasFileChangeExpansion
             || hasFilesystemPermissions
             || hasUnknownPermissions;
+        const resolveRuntimeApproval = (decision) => {
+            if (decision === 'deny' && permissionContext?.approvalInteractionPolicy === 'deny') {
+                return {
+                    decision: 'deny',
+                    decisionSource: 'policy',
+                    policyCode: 'permission_mode_denied',
+                    reason: 'permission mode denied runtime approval',
+                };
+            }
+            return decision;
+        };
         if (requiresSandboxExpansionApproval) {
-            if (!this.permissionGateway || !permissionPrompt)
-                return 'deny';
+            if (!this.permissionGateway || !permissionPrompt) {
+                return permissionContext?.approvalInteractionPolicy === 'deny'
+                    ? resolveRuntimeApproval('deny')
+                    : 'deny';
+            }
             if (policyToolName === 'FileChange') {
-                return this.permissionGateway.requestPermission(sessionKey, policyToolName, policyInput, permissionPrompt, this.permissionContexts.get(sessionKey), summary, reason || 'Codex 请求扩大当前命令或 turn 的文件系统权限', grantScope, undefined, { fileChangeCwd: workspacePath });
+                return resolveRuntimeApproval(await this.permissionGateway.requestPermission(sessionKey, policyToolName, policyInput, permissionPrompt, this.permissionContexts.get(sessionKey), summary, reason || 'Codex 请求扩大当前命令或 turn 的文件系统权限', grantScope, undefined, { fileChangeCwd: workspacePath }));
             }
-            return this.permissionGateway.requestPermission(sessionKey, toolName, checkedInput, permissionPrompt, this.permissionContexts.get(sessionKey), summary, reason || 'Codex 请求扩大当前命令或 turn 的文件系统权限', grantScope);
+            return resolveRuntimeApproval(await this.permissionGateway.requestPermission(sessionKey, toolName, checkedInput, permissionPrompt, this.permissionContexts.get(sessionKey), summary, reason || 'Codex 请求扩大当前命令或 turn 的文件系统权限', grantScope));
         }
         if (mode === 'request' || mode === 'bypass') {
             const dangerous = await requestDangerousCommandPermission(this.permissionGateway, sessionKey, toolName, checkedInput, permissionPrompt, this.permissionContexts.get(sessionKey), grantScope, mode);
             if (dangerous.matched)
-                return dangerous.decision;
+                return resolveRuntimeApproval(dangerous.decision);
             return 'allow';
         }
         // Network is already part of every profile, so a defensive
@@ -4657,6 +4682,13 @@ export class CodexRunner {
                     state.turnId = turnId;
                     this.activeTurns.set(sessionId, { threadId: state.threadId, turnId });
                 }
+                // turn/start 已落地并回执 turn/started ⇒ 用户输入已被 app-server 接受。
+                // 此后中断不能把该输入当作「未提交」重放，否则会产生重复用户轮次。
+                // 缺少 turn lease inputId 时宁可不报，也不要用占位值造成误判。
+                if (!state.inputAcceptedEmitted && state.inputId) {
+                    state.inputAcceptedEmitted = true;
+                    yield { type: 'input_accepted', inputId: state.inputId };
+                }
                 yield { type: 'state_changed', state: 'running' };
                 break;
             }
@@ -4942,17 +4974,12 @@ export class CodexRunner {
             }
             : undefined;
         const itemErrorText = outputTextForManagedHook(typeof item.error === 'string' ? item.error : item.error?.message);
-        const hookErrorText = /(?:Command|Tool call) blocked by PreToolUse hook\s*:/i.test(itemErrorText)
-            ? itemErrorText
-            : undefined;
-        const managedHookDenial = (item.status === 'failed' || item.status === 'declined' || hookErrorText)
-            ? parseManagedPreToolUseDenial([
-                item.aggregatedOutput,
-                item.output,
-                item.result,
-                hookErrorText,
-            ].filter(value => value !== undefined && value !== null).map(outputTextForManagedHook).join('\n'))
+        const hookOutput = item.type === 'commandExecution' && item.exitCode == null && !itemErrorText
+            && (item.status === 'failed' || item.status === 'declined')
+            ? [item.aggregatedOutput, item.output, item.result].map(outputTextForManagedHook).find(text => /^\s*(?:Script failed\s+)?(?:Script error:\s*)?(?:Command|Tool call) blocked by PreToolUse hook\s*:/i.test(text))
             : undefined;
+        const managedHookDenial = parseManagedPreToolUseDenial(itemErrorText)
+            ?? parseManagedPreToolUseDenial(hookOutput);
         const managedHookFields = !denial && managedHookDenial
             ? {
                 isError: true,

package/dist/agents/ecagent-runner.js

@@ -1,4 +1,4 @@
-import { getRunnerCatalog, catalogEfforts, assertCatalogSelectable, TRANSPORT_EFFORTS, resolveCatalogModel, } from '../core/model/model-catalog.js';
+import { getRunnerCatalog, catalogEfforts, assertCatalogSelectable, } from '../core/model/model-catalog.js';
 // Ecagent/OpenAI API 不认识 Claude Code SDK 的窗口后缀，必须传入基础模型 ID。
 import { stripContextWindowSuffix } from '../core/model/context-window-suffix.js';
 import fs from 'fs';
@@ -762,15 +762,7 @@ export class EcagentRunner {
         return catalog.models.map(m => m.id);
     }
     async getAvailableEfforts(model) {
-        const catalog = await this.getModelCatalog();
-        const efforts = catalogEfforts(catalog, model, 'ecagent');
-        if (efforts.length > 0)
-            return efforts;
-        // The embedded transport advertises reasoning support for every model it
-        // constructs. Older gateways may omit reasoningLevels from /models; keep
-        // menu.options aligned with the actual runner capability in that case.
-        const entry = catalog.models.find(item => item.id === resolveCatalogModel(catalog, model));
-        return entry && entry.reasoningLevels === undefined ? [...TRANSPORT_EFFORTS.ecagent] : efforts;
+        return catalogEfforts(await this.getModelCatalog(), model, 'ecagent');
     }
     registerStream(key, stream) { this.activeStreams.set(key, stream); }
     cleanupStream(key) {
@@ -917,12 +909,16 @@ export class EcagentRunner {
                     if (pauseResult === 'cancelled')
                         return { block: true, reason: '工具调用已取消' };
                 }
-                const decision = await this.authorizeTool(request.sessionId, request.projectPath, permissionMode, event.toolName, event.input);
+                const decision = await this.authorizeTool(request.sessionId, request.projectPath, permissionMode, event.toolName, event.input, stats.numTurns + 1);
                 return lifecycle.cancelled || signal?.aborted ? { block: true, reason: '工具调用已取消' } : decision;
             });
             const unsubscribe = harness.subscribe(event => this.mapHarnessEvent(queue, event, stats, model, effort));
             queue.push({ type: 'state_changed', state: 'running' });
             queue.push({ type: 'status', subtype: 'started', message: `ecagent is using ${modelId}` });
+            // Ecagent 输入在 harness.prompt 调用时提交，在此前报告
+            if (request.modelOverride?.turn?.inputId) {
+                queue.push({ type: 'input_accepted', inputId: request.modelOverride.turn.inputId });
+            }
             const ecImages = request.images?.map(image => ({
                 type: 'image', data: image.data, mimeType: image.mimeType || 'image/png',
             }));
@@ -1171,7 +1167,7 @@ export class EcagentRunner {
             model: model.id, effort,
         };
     }
-    async authorizeTool(sessionId, projectPath, mode, toolName, input) {
+    async authorizeTool(sessionId, projectPath, mode, toolName, input, turn) {
         const permissionContext = this.permissionContexts.get(sessionId);
         if (mode === 'fullaccess') {
             return hasTrustedFullAccessContext(permissionContext)
@@ -1216,7 +1212,7 @@ export class EcagentRunner {
                 logger.warn(`[EcagentRunner] failed to record blocked operation: session=${sessionId} tool=${toolName} code=${policyCode} error=${error instanceof Error ? error.message : String(error)}`);
             }
         };
-        const policy = permissionContext?.policyHook?.(toolName, input);
+        const policy = permissionContext?.policyHook?.(toolName, input, { turn });
         if (policy?.block) {
             await recordBlockedOperation(policy.policyCode ?? 'session_policy_hook');
             return { block: true, reason: policy.reason || '当前会话策略拒绝此工具调用' };

package/dist/agents/gemini-runner.js

@@ -514,6 +514,10 @@ export class GeminiRunner {
         const pendingToolNames = new Map(); // toolId → toolName
         const recordedDeniedToolIds = new Set();
         const startTime = Date.now();
+        // Gemini 走 spawn + argv，输入在 spawn 时已提交；在第一个业务事件前报告
+        if (turn?.inputId) {
+            yield { type: 'input_accepted', inputId: turn.inputId };
+        }
         const rl = createInterface({ input: child.stdout });
         // Build async queue from readline
         const queue = [];

package/dist/aun/aid/store.js

@@ -1,13 +1,6 @@
 import fs from 'fs';
 import path from 'path';
 import { AUN_KEYSTORE_ENCRYPTION_SEED } from './encryption-seed-policy.js';
-// fastaun uses maxPages=1 for the background tail -> forward handoff. That is
-// useful as a latency guard, but it can leave a group backlog when no later
-// push arrives to trigger the next page. Bound the daemon recovery pull to ten
-// pages so a large backlog is drained without monopolizing the sync loop.
-const FULL_GROUP_PULL_MAX_PAGES = 10;
-const GROUP_PULL_PAGINATION_PATCH = Symbol('evolcore.groupPullPaginationPatch');
-const RELIABLE_MESSAGE_DELIVERY_PATCH = Symbol('evolcore.reliableMessageDeliveryPatch');
 /**
  * Slot 命名约定（基于 fastaun 0.4.3 隔离键语义）。
  *
@@ -77,80 +70,6 @@ export async function loadClient(store, aid) {
     const { AUNClient } = await import('@agentunion/fastaun');
     return new AUNClient(loadAid(store, aid));
 }
-/**
- * Enable bounded multi-page group pulls for the long-lived daemon client.
- *
- * Older SDK recovery paths used `maxPages=1`; for a daemon that can strand a
- * backlog after a tail sync. SDK 0.5.15 normally chooses a larger recovery
- * window, but this adapter still expands an explicit single-page request and
- * keeps older clients safe. It is isolated to the client that opts in.
- */
-export function enableFullGroupPullPagination(client) {
-    const target = client;
-    if (target[GROUP_PULL_PAGINATION_PATCH])
-        return false;
-    const pull = target._pullGroupV2;
-    if (typeof pull !== 'function')
-        return false;
-    const wrappedPull = function (groupId, afterSeq, limit, opts) {
-        const expandedOpts = opts?.maxPages === 1
-            ? { ...opts, maxPages: FULL_GROUP_PULL_MAX_PAGES }
-            : opts;
-        return pull.call(this, groupId, afterSeq, limit, expandedOpts);
-    };
-    Object.defineProperty(target, GROUP_PULL_PAGINATION_PATCH, {
-        configurable: false,
-        enumerable: false,
-        value: true,
-        writable: false,
-    });
-    target._pullGroupV2 = wrappedPull;
-    return true;
-}
-/**
- * Make SDK pull delivery wait until EvolCore's application handlers finish.
- *
- * fastaun publishes message events asynchronously, while the sequence tracker
- * is a transport watermark. A daemon restart can therefore acknowledge a
- * pulled message before the application has durably claimed it. SDK 0.5.15
- * split protocol and application queues; prefer its application-only flush so
- * an unrelated protocol event cannot delay the pull commit. Older SDKs fall
- * back to the combined flush method.
- */
-export function enableReliableMessageDelivery(client) {
-    const target = client;
-    if (target[RELIABLE_MESSAGE_DELIVERY_PATCH])
-        return false;
-    const publish = target._publishAppEvent;
-    const dispatcher = target._dispatcher;
-    const flushApplication = typeof dispatcher?.flushApplication === 'function'
-        ? dispatcher.flushApplication.bind(dispatcher)
-        : typeof dispatcher?.flush === 'function'
-            ? dispatcher.flush.bind(dispatcher)
-            : undefined;
-    if (typeof publish !== 'function' || !flushApplication)
-        return false;
-    const wrappedPublish = async function (event, payload, source, ...rest) {
-        const result = await publish.call(this, event, payload, source, ...rest);
-        // Pull/recovery paths must not advance SeqTracker until the application
-        // handlers have completed. Push delivery has no pull commit to gate and
-        // remains asynchronous as intended by the SDK.
-        const reliable = (event === 'message.received' || event === 'group.message_created')
-            && source !== 'push'
-            && source !== 'inline-push';
-        if (reliable)
-            await flushApplication();
-        return result;
-    };
-    Object.defineProperty(target, RELIABLE_MESSAGE_DELIVERY_PATCH, {
-        configurable: false,
-        enumerable: false,
-        value: true,
-        writable: false,
-    });
-    target._publishAppEvent = wrappedPublish;
-    return true;
-}
 /** 加载本地 AID 值对象（用于离线签名/验签，无需连接）。load 失败抛 AidLoadError。 */
 export function loadAid(store, aid) {
     const r = store.load(aid);

package/dist/aun/group/fs-download.js

@@ -39,16 +39,7 @@ function sha256Hex(bytes) {
     return createHash('sha256').update(bytes).digest('hex');
 }
 function bearerHeaders(client) {
-    const anyClient = client;
-    if (typeof anyClient.getAccessToken === 'function') {
-        const token = stringValue(anyClient.getAccessToken());
-        if (token)
-            return { Authorization: `Bearer ${token}` };
-    }
-    const token = stringValue(anyClient.accessToken)
-        || stringValue(anyClient.access_token)
-        || stringValue(anyClient._identity?.access_token)
-        || stringValue(anyClient._sessionParams?.access_token);
+    const token = stringValue(client.getAccessToken());
     return token ? { Authorization: `Bearer ${token}` } : undefined;
 }
 function stringValue(value) {

package/dist/aun/group/operations.js

@@ -117,7 +117,6 @@ async function tryDaemonGroupSend(args, payload, runtimeContext, file) {
         mentions: args.mentions,
         encrypt: args.encrypt,
         thread,
-        returnPolicy: args.returnPolicy,
         originSessionId: runtimeContext.sessionId,
         originMessageId: runtimeContext.messageId,
         delegationToken: readDelegationCredential(),

package/dist/aun/msg/history.js

@@ -171,6 +171,7 @@ function readHistoryScopes(input) {
         .filter(({ entry, sessionIds }) => sessionIds === undefined
         || (typeof entry.sessionId === 'string' && sessionIds.has(entry.sessionId)))
         .filter(({ entry }) => input.direction === 'all' || entry.dir === input.direction)
+        .filter(({ entry }) => input.args.threadId === undefined || entry.threadId === input.args.threadId)
         .filter(({ entry }) => input.args.after === undefined || entry.ts > input.args.after)
         .filter(({ entry }) => input.args.before === undefined || entry.ts < input.args.before)
         .sort((left, right) => left.entry.ts - right.entry.ts || left.scope - right.scope)

package/dist/aun/msg/managed-operation.js

@@ -807,27 +807,30 @@ function positiveInteger(value, flag, max) {
 }
 function parseRemote(value, allowEmpty) {
     if (!value)
-        return failFs('INVALID_ARGUMENT', 'missing remote group path');
+        return failFs('INVALID_ARGUMENT', 'missing remote storage path');
     const separator = value.indexOf(':');
     if (separator <= 0)
         return failFs('INVALID_PATH', 'remote path must use <group-aid>:<absolute-path>');
-    let groupId;
+    let targetAid;
     const remotePath = value.slice(separator + 1);
+    const rawId = value.slice(0, separator).trim();
     try {
-        groupId = normalizeGroupAid(value.slice(0, separator).trim());
+        targetAid = normalizeGroupAid(rawId);
     }
     catch (error) {
-        return failFs('INVALID_GROUP', `invalid group AID: ${error.message}`);
+        if (!isValidAid(rawId))
+            return failFs('INVALID_GROUP', `invalid group AID: ${error.message}`);
+        targetAid = rawId;
     }
     if (remotePath === '' && allowEmpty)
-        return { groupId, remotePath: '' };
+        return { targetAid, remotePath: '' };
     if (!remotePath.startsWith('/') || remotePath.length > MAX_REMOTE_PATH_LENGTH || /[\u0000-\u001f\u007f]/.test(remotePath)
         || remotePath.split('/').includes('..')) {
-        return failFs('INVALID_PATH', 'remote group path must be a bounded absolute path');
+        return failFs('INVALID_PATH', 'remote storage path must be a bounded absolute path');
     }
-    return { groupId, remotePath };
+    return { targetAid, remotePath };
 }
-/** Parse the daemon-owned, current-group filesystem grammar. */
+/** Parse the daemon-owned managed filesystem grammar for group or self storage. */
 export function resolveManagedFsOperation(argv) {
     const raw = argv[0] === 'fs' ? argv.slice(1) : argv;
     const rawKind = raw[0];
@@ -904,11 +907,11 @@ export function resolveManagedFsOperation(argv) {
         if (values.has('-m') || values.has('-x'))
             return failFs('NOT_ALLOWED', 'getfacl does not accept ACL mutation flags');
         const remote = remoteOrError(positionals[0]);
-        if (!('groupId' in remote))
+        if (!('targetAid' in remote))
             return remote;
         return { ok: true, command: {
                 kind: 'getfacl', operationId: 'ec.fs.getfacl', canonicalArgv: ['fs', 'getfacl', positionals[0], ...(actorAid ? ['--as', actorAid] : [])],
-                actorAid, groupId: remote.groupId, remotePath: remote.remotePath,
+                actorAid, targetAid: remote.targetAid, remotePath: remote.remotePath,
             } };
     }
     if (rawKind === 'setfacl') {
@@ -921,17 +924,17 @@ export function resolveManagedFsOperation(argv) {
         if (!('grantee' in parsedAcl))
             return parsedAcl;
         const remote = remoteOrError(positionals[0]);
-        if (!('groupId' in remote))
+        if (!('targetAid' in remote))
             return remote;
         return { ok: true, command: {
                 kind: 'setfacl', operationId: 'ec.fs.setfacl', canonicalArgv: ['fs', 'setfacl', positionals[0], modify !== undefined ? '-m' : '-x', spec, ...(actorAid ? ['--as', actorAid] : [])],
-                actorAid, groupId: remote.groupId, remotePath: remote.remotePath,
+                actorAid, targetAid: remote.targetAid, remotePath: remote.remotePath,
                 aclGrantee: parsedAcl.grantee, ...(parsedAcl.perms ? { aclPerms: parsedAcl.perms } : {}), aclRemove: remove !== undefined,
             } };
     }
     if (rawKind === 'cp') {
         const destination = remoteOrError(positionals[1]);
-        if (!('groupId' in destination))
+        if (!('targetAid' in destination))
             return destination;
         // Windows absolute paths contain a drive-letter colon, but are local
         // upload sources rather than managed group references.
@@ -939,46 +942,46 @@ export function resolveManagedFsOperation(argv) {
         const source = positionals[0].includes(':') && !isWindowsAbsolutePath
             ? remoteOrError(positionals[0])
             : undefined;
-        if (source && !('groupId' in source))
+        if (source && !('targetAid' in source))
             return source;
-        if (source && source.groupId !== destination.groupId)
-            return failFs('INVALID_GROUP', 'managed cp cannot cross groups');
+        if (source && source.targetAid !== destination.targetAid)
+            return failFs('INVALID_GROUP', 'managed cp cannot cross targets');
         const kind = source ? 'copy' : 'upload';
         return { ok: true, command: {
                 kind, operationId: `ec.fs.${kind}`, canonicalArgv: ['fs', 'cp', positionals[0], positionals[1], ...(actorAid ? ['--as', actorAid] : [])],
-                actorAid, groupId: destination.groupId, remotePath: destination.remotePath, destinationPath: destination.remotePath,
+                actorAid, targetAid: destination.targetAid, remotePath: destination.remotePath, destinationPath: destination.remotePath,
                 ...(source ? { remoteSourcePath: source.remotePath } : { localPath: positionals[0] }), overwrite, recursive,
             } };
     }
     if (rawKind === 'mv') {
         const source = remoteOrError(positionals[0]);
         const destination = remoteOrError(positionals[1]);
-        if (!('groupId' in source))
+        if (!('targetAid' in source))
             return source;
-        if (!('groupId' in destination))
+        if (!('targetAid' in destination))
             return destination;
-        if (source.groupId !== destination.groupId)
-            return failFs('INVALID_GROUP', 'managed mv cannot cross groups');
+        if (source.targetAid !== destination.targetAid)
+            return failFs('INVALID_GROUP', 'managed mv cannot cross targets');
         return { ok: true, command: {
                 kind: 'move', operationId: 'ec.fs.move', canonicalArgv: ['fs', 'mv', positionals[0], positionals[1], ...(actorAid ? ['--as', actorAid] : [])],
-                actorAid, groupId: destination.groupId, remotePath: destination.remotePath, destinationPath: destination.remotePath,
+                actorAid, targetAid: destination.targetAid, remotePath: destination.remotePath, destinationPath: destination.remotePath,
                 remoteSourcePath: source.remotePath, overwrite,
             } };
     }
     const remote = remoteOrError(positionals[0], rawKind === 'df');
-    if (!('groupId' in remote))
+    if (!('targetAid' in remote))
         return remote;
     if (rawKind === 'mkdir')
         return { ok: true, command: {
                 kind: 'mkdir', operationId: 'ec.fs.mkdir', canonicalArgv: ['fs', 'mkdir', positionals[0], ...(actorAid ? ['--as', actorAid] : [])],
-                actorAid, groupId: remote.groupId, remotePath: remote.remotePath, parents: booleanFlags.has('-p') || booleanFlags.has('--parents'),
+                actorAid, targetAid: remote.targetAid, remotePath: remote.remotePath, parents: booleanFlags.has('-p') || booleanFlags.has('--parents'),
             } };
     if (rawKind === 'rm' && remote.remotePath === '/')
         return failFs('INVALID_PATH', 'managed rm cannot target the group root');
     if (rawKind === 'rm')
         return { ok: true, command: {
                 kind: 'remove', operationId: 'ec.fs.remove', canonicalArgv: ['fs', 'rm', positionals[0], ...(actorAid ? ['--as', actorAid] : [])],
-                actorAid, groupId: remote.groupId, remotePath: remote.remotePath, recursive, overwrite,
+                actorAid, targetAid: remote.targetAid, remotePath: remote.remotePath, recursive, overwrite,
             } };
     const effectiveKind = rawKind === 'stat' && !follow ? 'lstat' : rawKind;
     const maxBytes = positiveInteger(values.get('--max-bytes'), '--max-bytes', MAX_MANAGED_FS_CAT_BYTES);
@@ -998,7 +1001,7 @@ export function resolveManagedFsOperation(argv) {
         return failFs('INVALID_ARGUMENT', '--type only supports f|d|l');
     return { ok: true, command: {
             kind: effectiveKind, operationId: `ec.fs.${effectiveKind}`, canonicalArgv: ['fs', effectiveKind, positionals[0], ...(actorAid ? ['--as', actorAid] : [])],
-            actorAid, groupId: remote.groupId, remotePath: remote.remotePath, maxBytes, headBytes,
+            actorAid, targetAid: remote.targetAid, remotePath: remote.remotePath, maxBytes, headBytes,
             name: values.get('--name') ?? values.get('--pattern'), nodeType, size: values.get('--size'), mtime: values.get('--mtime'), page, pageSize,
         } };
 }
@@ -1055,9 +1058,104 @@ async function withClient(actorAid, fn) {
 export async function executeManagedFsOperation(command) {
     if (!command.actorAid)
         throw new ManagedFsOperationError('INVALID_ACTOR', 'managed fs actor is required');
-    const ref = `${command.groupId}:${command.remotePath}`;
+    if (!command.storageBackend)
+        throw new ManagedFsOperationError('INVALID_TARGET', 'managed fs storage backend must be resolved before execution');
+    return withClient(command.actorAid, client => executeManagedFsOperationWithClient(command, client));
+}
+/** Execute against an already authenticated SDK client; used by integration tests. */
+export async function executeManagedFsOperationWithClient(command, client) {
+    if (!command.actorAid)
+        throw new ManagedFsOperationError('INVALID_ACTOR', 'managed fs actor is required');
+    if (!command.storageBackend)
+        throw new ManagedFsOperationError('INVALID_TARGET', 'managed fs storage backend must be resolved before execution');
+    const ref = `${command.targetAid}:${command.remotePath}`;
     try {
-        return await withClient(command.actorAid, async (client) => {
+        return await (async () => {
+            if (command.storageBackend === 'personal') {
+                const owner = command.targetAid;
+                switch (command.kind) {
+                    case 'mkdir':
+                        return { ok: true, command: 'mkdir', path: ref,
+                            result: await client.storage.mkdir(command.remotePath, { owner, parents: command.parents }) };
+                    case 'upload': {
+                        if (!command.localPath)
+                            throw new ManagedFsOperationError('INVALID_SOURCE', 'managed upload source is required');
+                        return { ok: true, command: 'upload', path: ref, localPath: command.localPath,
+                            result: await client.storage.uploadFile(command.localPath, command.remotePath, { owner, overwrite: command.overwrite }) };
+                    }
+                    case 'copy': {
+                        if (!command.remoteSourcePath)
+                            throw new ManagedFsOperationError('INVALID_SOURCE', 'managed copy source is required');
+                        const source = `${owner}:${command.remoteSourcePath}`;
+                        return { ok: true, command: 'copy', src: source, path: ref,
+                            result: await client.storage.copy(command.remoteSourcePath, command.remotePath, {
+                                owner, dstOwner: owner, overwrite: command.overwrite, recursive: command.recursive,
+                            }) };
+                    }
+                    case 'move': {
+                        if (!command.remoteSourcePath)
+                            throw new ManagedFsOperationError('INVALID_SOURCE', 'managed move source is required');
+                        const source = `${owner}:${command.remoteSourcePath}`;
+                        return { ok: true, command: 'move', src: source, path: ref,
+                            result: await client.storage.rename(command.remoteSourcePath, command.remotePath, { owner, overwrite: command.overwrite }) };
+                    }
+                    case 'remove':
+                        return { ok: true, command: 'remove', path: ref,
+                            result: await client.storage.remove(command.remotePath, { owner, recursive: command.recursive }) };
+                    case 'ls':
+                        return { ok: true, command: 'ls', path: ref,
+                            items: await client.storage.list(command.remotePath || '/', { owner }) };
+                    case 'stat':
+                        return { ok: true, command: 'stat', path: ref,
+                            node: await client.storage.stat(command.remotePath, { owner }) };
+                    case 'lstat':
+                        return { ok: true, command: 'lstat', path: ref,
+                            node: await client.storage.lstat(command.remotePath, { owner }) };
+                    case 'find':
+                        return { ok: true, command: 'find', path: ref,
+                            items: await client.storage.find(command.remotePath, {
+                                owner, name: command.name, nodeType: command.nodeType, size: command.size,
+                                mtime: command.mtime, page: command.page, pageSize: command.pageSize,
+                            }) };
+                    case 'df':
+                        return { ok: true, command: 'df', path: `${owner}:`, usage: await client.storage.df({ owner }) };
+                    case 'getfacl':
+                        return { ok: true, command: 'getfacl', path: ref, result: await client.storage.listAcl(command.remotePath, { owner }) };
+                    case 'setfacl':
+                        throw new ManagedFsOperationError('NOT_ALLOWED', 'Managed personal storage ACL changes are not supported');
+                    case 'cat': {
+                        const node = await client.storage.stat(command.remotePath, { owner });
+                        const size = numberFrom(node, ['size', 'sizeBytes', 'size_bytes']);
+                        const maxBytes = Math.min(command.maxBytes ?? MAX_MANAGED_FS_CAT_BYTES, MAX_MANAGED_FS_CAT_BYTES);
+                        if (size === undefined)
+                            throw new ManagedFsOperationError('FS_SIZE_REQUIRED', 'personal file size is required before managed cat');
+                        if (size > maxBytes)
+                            throw new ManagedFsOperationError('FS_CAT_TOO_LARGE', `managed cat is limited to ${maxBytes} bytes`);
+                        const bytes = await client.storage.readBytes(command.remotePath, { owner });
+                        if (bytes.byteLength > maxBytes)
+                            throw new ManagedFsOperationError('FS_CAT_TOO_LARGE', `managed cat is limited to ${maxBytes} bytes`);
+                        const headBytes = Math.min(command.headBytes ?? 256, MAX_MANAGED_FS_HEAD_BYTES, bytes.byteLength);
+                        if (bytes.subarray(0, Math.min(bytes.byteLength, 8192)).some(byte => byte === 0)) {
+                            return {
+                                ok: true,
+                                command: 'cat',
+                                path: ref,
+                                size: bytes.byteLength,
+                                binary: true,
+                                head: { encoding: 'base64', bytes: headBytes, data: Buffer.from(bytes.subarray(0, headBytes)).toString('base64') },
+                            };
+                        }
+                        let text;
+                        try {
+                            text = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+                        }
+                        catch {
+                            throw new ManagedFsOperationError('FS_NOT_UTF8', 'managed cat only returns UTF-8 text or a bounded binary head');
+                        }
+                        return { ok: true, command: 'cat', path: ref, size: bytes.byteLength, binary: false, text };
+                    }
+                }
+            }
             switch (command.kind) {
                 case 'mkdir':
                     return { ok: true, command: 'mkdir', path: ref, result: await client.group.fs.mkdir(ref, { parents: command.parents }) };
@@ -1070,14 +1168,14 @@ export async function executeManagedFsOperation(command) {
                 case 'copy': {
                     if (!command.remoteSourcePath)
                         throw new ManagedFsOperationError('INVALID_SOURCE', 'managed copy source is required');
-                    const source = `${command.groupId}:${command.remoteSourcePath}`;
+                    const source = `${command.targetAid}:${command.remoteSourcePath}`;
                     return { ok: true, command: 'copy', src: source, path: ref,
                         result: await client.group.fs.cp(source, ref, { recursive: command.recursive, overwrite: command.overwrite, force: command.overwrite }) };
                 }
                 case 'move': {
                     if (!command.remoteSourcePath)
                         throw new ManagedFsOperationError('INVALID_SOURCE', 'managed move source is required');
-                    const source = `${command.groupId}:${command.remoteSourcePath}`;
+                    const source = `${command.targetAid}:${command.remoteSourcePath}`;
                     return { ok: true, command: 'move', src: source, path: ref,
                         result: await client.group.fs.mv(source, ref, { overwrite: command.overwrite, force: command.overwrite }) };
                 }
@@ -1109,7 +1207,7 @@ export async function executeManagedFsOperation(command) {
                     return { ok: true, command: 'find', path: ref, items };
                 }
                 case 'df':
-                    return { ok: true, command: 'df', path: `${command.groupId}:`, usage: await client.group.fs.df(`${command.groupId}:`) };
+                    return { ok: true, command: 'df', path: `${command.targetAid}:`, usage: await client.group.fs.df(`${command.targetAid}:`) };
                 case 'getfacl':
                     return { ok: true, command: 'getfacl', path: ref, result: await client.group.fs.getAcl(ref) };
                 case 'setfacl': {
@@ -1152,7 +1250,7 @@ export async function executeManagedFsOperation(command) {
                     return { ok: true, command: 'cat', path: ref, size: bytes.byteLength, binary: false, text };
                 }
             }
-        });
+        })();
     }
     catch (error) {
         if (error instanceof ManagedFsOperationError)

package/dist/aun/msg/p2p.js

@@ -134,7 +134,6 @@ async function tryDaemonMsgSend(args, payload, runtimeContext, file) {
         ...(payload ? { payload } : { file }),
         encrypt: args.encrypt,
         thread,
-        returnPolicy: args.returnPolicy,
         handoffContext: args.handoffContext,
         originSessionId: runtimeContext.sessionId,
         originMessageId: runtimeContext.messageId,