evolcore 0.0.31 → 0.0.32

package/dist/core/command/command-handler.js

@@ -15,6 +15,8 @@ import { sameGroupAid } from '../../aun/group/index.js';
 import crypto from 'crypto';
 import path from 'path';
 import fs from 'fs';
+import { parseDocument } from 'yaml';
+import { agentmdGet } from '../../aun/aid/agentmd.js';
 import { parseDuration, parseTriggerSet, parseTriggerUpdate } from '../../trigger/parser.js';
 import { applyTriggerPatch, replaceEditableTriggerDefinition } from '../../trigger/patch.js';
 import { definitionRevision } from '../../trigger/validation.js';
@@ -25,6 +27,8 @@ import { resolveConfigCommand } from '../../config/resolved-config-op.js';
 import { AUTHENTICATED_CONFIG_ROLE_ENV, executeResolvedConfigCommandAsync } from '../../config/config-operation-service.js';
 import { splitConfigBatchGetArgv } from '../../cli/cli-argv.js';
 import { auditCommandAuthorization, auditFullAccessEvent, hashArgv } from '../auth/authorization-audit.js';
+import { ResponseModeRegistry } from '../../response-system/registry.js';
+import { registerBuiltinModes } from '../../response-system/modes/index.js';
 import { executeResolvedContactCommand, resolveContactCommand } from '../../config/contact-operation-service.js';
 import { hasTrustedFullAccessDelegation, trustedExecutionIdentityInput } from '../auth/agent-delegation.js';
 import { executeManagedAidOperation, ManagedAidOperationError, managedAidShowViewForRole, resolveManagedAidOperation, } from '../../aun/aid/managed-operation.js';
@@ -1853,10 +1857,23 @@ export class CommandHandler {
         const delegation = this.agentDelegationRegistry.validate(delegationToken, sessionId, delegationCommandHash);
         if (!delegation.ok)
             return { ok: false, code: delegation.code, error: delegation.reason };
+        return this.executeConfigOperation(argv, sessionId, delegation.grant);
+    }
+    async executeConfigOperation(argv, sessionId, grant) {
         const session = await this.sessionManager.getSessionById(sessionId);
         if (!session)
             return { ok: false, code: 'INVALID_SESSION', error: 'Invalid session' };
-        const grant = delegation.grant;
+        if (session.selfAID !== grant.selfAid || grant.sessionId !== sessionId) {
+            return { ok: false, code: 'INVALID_DELEGATION', error: 'Delegation does not match the current session' };
+        }
+        if (argv[0] === 'agent') {
+            const tail = argv.at(-2) === '--format' && argv.at(-1) === 'json' ? argv.slice(0, -2) : argv;
+            const sub = tail[1];
+            if ((sub !== 'get' && sub !== 'set') || tail.length !== (sub === 'get' ? 4 : 5)) {
+                return { ok: false, code: 'INVALID_ARGS', error: 'Expected agent get/set <aid> <key> [value] [--format json]' };
+            }
+            argv = ['config', sub, ...tail.slice(3), '--self', tail[2]];
+        }
         let conversationId;
         try {
             conversationId = parsePeerKey(grant.peerKey).channelId;
@@ -2549,39 +2566,76 @@ export class CommandHandler {
         if (sessionSelfAid && sessionSelfAid !== actorAid) {
             return { ok: false, code: 'INVALID_DELEGATION', error: 'Delegation self agent does not match the active session' };
         }
-        if (!hasTrustedFullAccessDelegation(grant) && (grant.channelType !== 'aun' || grant.chatType !== 'group')) {
-            return { ok: false, code: 'SCOPE_MISMATCH', error: 'Managed fs operations require the current AUN group relation' };
-        }
+        const isPersonalTarget = parsed.command.targetAid === actorAid;
         let currentGroup;
-        try {
-            currentGroup = parsePeerKey(grant.peerKey).channelId;
-        }
-        catch {
-            return { ok: false, code: 'INVALID_DELEGATION', error: 'Delegation contains an invalid relation key' };
+        if (isPersonalTarget) {
+            if (grant.issuedRole !== 'owner' && !hasTrustedFullAccessDelegation(grant)) {
+                return { ok: false, code: 'NO_PERMISSION', error: 'Managed personal storage requires the current Agent owner relation' };
+            }
+            if (parsed.command.actorAid && parsed.command.actorAid !== actorAid) {
+                return { ok: false, code: 'SCOPE_MISMATCH', error: 'Only the current Agent can access its personal storage' };
+            }
         }
-        if (!hasTrustedFullAccessDelegation(grant)
-            && ((parsed.command.actorAid && parsed.command.actorAid !== actorAid) || !sameGroupAid(parsed.command.groupId, currentGroup))) {
-            return { ok: false, code: 'SCOPE_MISMATCH', error: 'Only the current AUN group can be targeted' };
+        else {
+            const trustedFullAccess = hasTrustedFullAccessDelegation(grant);
+            if (trustedFullAccess) {
+                let targetType;
+                try {
+                    const card = await agentmdGet(parsed.command.targetAid, { withVerification: true, remoteOnly: true });
+                    if (card.verification.status !== 'verified') {
+                        return { ok: false, code: 'INVALID_TARGET', error: 'Target AID agent.md verification did not succeed' };
+                    }
+                    const frontmatter = card.content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/)?.[1];
+                    const document = frontmatter ? parseDocument(frontmatter) : undefined;
+                    targetType = document && document.errors.length === 0
+                        ? String(document.toJS()?.type ?? '').trim().toLowerCase()
+                        : undefined;
+                }
+                catch {
+                    return { ok: false, code: 'INVALID_TARGET', error: 'Target AID agent.md could not be verified' };
+                }
+                if (targetType !== 'group') {
+                    return { ok: false, code: 'INVALID_TARGET', error: 'Managed group storage requires a verified group AID' };
+                }
+            }
+            if (!hasTrustedFullAccessDelegation(grant) && (grant.channelType !== 'aun' || grant.chatType !== 'group')) {
+                return { ok: false, code: 'SCOPE_MISMATCH', error: 'Managed group fs operations require the current AUN group relation' };
+            }
+            try {
+                currentGroup = parsePeerKey(grant.peerKey).channelId;
+            }
+            catch {
+                return { ok: false, code: 'INVALID_DELEGATION', error: 'Delegation contains an invalid relation key' };
+            }
+            if (parsed.command.actorAid && parsed.command.actorAid !== actorAid) {
+                return { ok: false, code: 'SCOPE_MISMATCH', error: 'Managed fs cannot switch the execution identity with --as' };
+            }
+            if (!hasTrustedFullAccessDelegation(grant)
+                && !sameGroupAid(parsed.command.targetAid, currentGroup)) {
+                return { ok: false, code: 'SCOPE_MISMATCH', error: 'Only the current AUN group can be targeted' };
+            }
         }
-        parsed.command.actorAid = hasTrustedFullAccessDelegation(grant)
-            ? (parsed.command.actorAid ?? actorAid)
+        const resolvedCommand = parsed.command;
+        resolvedCommand.storageBackend = isPersonalTarget ? 'personal' : 'group';
+        resolvedCommand.actorAid = hasTrustedFullAccessDelegation(grant) && !isPersonalTarget
+            ? (resolvedCommand.actorAid ?? actorAid)
             : actorAid;
         const subject = buildAuthSubject({
             selfAid: grant.selfAid,
             actorId: grant.actorId,
             channel: grant.channel,
             channelType: grant.channelType,
-            channelId: currentGroup,
+            channelId: currentGroup ?? actorAid,
             chatType: grant.chatType,
-            conversationId: currentGroup,
+            conversationId: currentGroup ?? actorAid,
             processOwners: loadDaemonConfig().owners ?? [],
             ...trustedExecutionIdentityInput(grant),
         });
         const intentArgs = {
             self: actorAid,
-            targetId: currentGroup,
-            peer: currentGroup,
-            peerKey: formatPeerKey('aun', currentGroup),
+            targetId: parsed.command.targetAid,
+            peer: currentGroup ?? actorAid,
+            peerKey: formatPeerKey('aun', currentGroup ?? actorAid),
             path: parsed.command.remotePath,
             targetPath: parsed.command.remotePath,
             ...(parsed.command.remoteSourcePath ? { sourcePath: parsed.command.remoteSourcePath } : {}),
@@ -2598,7 +2652,7 @@ export class CommandHandler {
             subject,
             intent: {
                 operation: parsed.command.operationId,
-                scope: 'relation',
+                scope: isPersonalTarget ? 'agent' : 'relation',
                 source: 'agent-tool',
                 args: intentArgs,
             },
@@ -2655,7 +2709,7 @@ export class CommandHandler {
             }
         }
         try {
-            return { ok: true, result: await executeManagedFsOperation(parsed.command) };
+            return { ok: true, result: await executeManagedFsOperation(resolvedCommand) };
         }
         catch (error) {
             return {
@@ -2668,6 +2722,95 @@ export class CommandHandler {
     setAgentDelegationRegistry(registry) {
         this.agentDelegationRegistry = registry;
     }
+    async handleManagedCliOperation(argv, sessionId, grant) {
+        const invalid = (error) => ({ ok: false, code: 'INVALID_ARGUMENT', error });
+        if (argv[0] === 'ctl') {
+            if (!argv[1] || /\s/.test(argv[1]))
+                return invalid('Expected a ctl subcommand');
+            return this.handleCtl('/' + argv.slice(1).join(' '), sessionId, grant);
+        }
+        if (argv[0] !== 'model' && argv[0] !== 'response')
+            return invalid('Expected a model or response command');
+        if (argv.includes('--self') || argv.includes('--peer') || argv.includes('--role')) {
+            return { ok: false, code: 'NOT_ALLOWED', error: 'Managed commands always use the authenticated current relation' };
+        }
+        const args = argv.slice(2);
+        const formatIndex = args.indexOf('--format');
+        if (formatIndex >= 0) {
+            if (args[formatIndex + 1] !== 'json' || args.lastIndexOf('--format') !== formatIndex)
+                return invalid('--format must be json');
+            args.splice(formatIndex, 2);
+        }
+        const sub = argv[1];
+        if (argv[0] === 'model') {
+            let command;
+            if (['list', 'current', 'reset', 'check'].includes(sub) && args.length === 0) {
+                command = `/model ${sub}`;
+            }
+            else if ((sub === 'info' || sub === 'effort') && args.length === 1 && args[0] && !/\s|^--/.test(args[0])) {
+                command = sub === 'info' ? `/model info ${args[0]}` : `/effort ${args[0]}`;
+            }
+            else if (sub === 'use' && args[0] && !/\s|^--/.test(args[0])
+                && !['list', 'current', 'reset', 'check', 'info'].includes(args[0])
+                && (args.length === 1 || (args.length === 3 && args[1] === '--effort' && args[2] && !/\s|^--/.test(args[2])))) {
+                command = `/model ${args[0]}${args.length === 3 ? ` ${args[2]}` : ''}`;
+            }
+            else
+                return invalid('Invalid managed model arguments');
+            return this.handleCtl(command, sessionId, grant);
+        }
+        const execute = (fieldArgs) => this.executeConfigOperation(['config', ...fieldArgs], sessionId, grant);
+        const failure = (response) => ({
+            ok: false, code: response.code, error: response.error, data: response.data,
+        });
+        const emit = (data, result) => ({ ok: true, data, result });
+        if (sub === 'set' && args.length === 1) {
+            const registry = new ResponseModeRegistry();
+            registerBuiltinModes(registry);
+            if (!registry.has(args[0]))
+                return { ok: false, code: 'UNKNOWN_MODE', error: `Unknown mode: ${args[0]}` };
+            const result = await execute(['set', 'responseMode', args[0]]);
+            if (!result.ok)
+                return failure(result);
+            return emit({ ok: true, scope: 'relation', mode: args[0] }, `✓ 已设置响应模式为 ${args[0]}（作用域: relation）`);
+        }
+        if (sub === 'reset' && args.length === 0) {
+            const result = await execute(['unset', 'responseMode']);
+            if (!result.ok)
+                return failure(result);
+            return emit({ ok: true, scope: 'relation' }, '✓ 已清除当前关系的响应模式设置');
+        }
+        if (sub === 'current' && args.length === 0) {
+            const modeResult = await execute(['get', 'responseMode']);
+            if (!modeResult.ok)
+                return failure(modeResult);
+            const paramsResult = await execute(['get', 'responseModeParams']);
+            if (!paramsResult.ok)
+                return failure(paramsResult);
+            if (!modeResult.result?.ok || modeResult.result.subcommand !== 'get'
+                || !paramsResult.result?.ok || paramsResult.result.subcommand !== 'get')
+                return invalid('Unexpected config result');
+            const configuredMode = typeof modeResult.result.value === 'string' ? modeResult.result.value : undefined;
+            const registry = new ResponseModeRegistry();
+            registerBuiltinModes(registry);
+            const mode = configuredMode ?? registry.getPreferredId();
+            return emit({ ok: true, scope: 'relation', responseMode: mode ?? null,
+                source: configuredMode ? 'config' : 'preferred', sourceTarget: modeResult.result.source?.target ?? null,
+                responseModeParams: paramsResult.result.value ?? null }, `当前响应模式: ${mode ?? '(无)'}`);
+        }
+        if (sub === 'config' && (args.length === 0 || (args.length === 1 && !args[0].startsWith('--') && args[0] !== 'set'))) {
+            const result = await execute(['get', 'responseModeParams']);
+            if (!result.ok)
+                return failure(result);
+            if (!result.result?.ok || result.result.subcommand !== 'get')
+                return invalid('Unexpected config result');
+            const params = (result.result.value ?? {});
+            return args.length === 1
+                ? emit({ ok: true, mode: args[0], config: params[args[0]] ?? {} }, `${args[0]} 配置: ${JSON.stringify(params[args[0]] ?? {}, null, 2)}`)
+                : emit({ ok: true, responseModeParams: params }, `所有模式配置: ${JSON.stringify(params, null, 2)}`);
+        }
+        return { ok: false, code: 'NOT_ALLOWED', error: `response ${sub} is not available in a managed task` };
+    }
     /**
      * Agent ctl 入口：通过 IPC 接收 Agent 自主管理指令
      * 复用现有 slash cmd 逻辑，权限继承 session 用户角色

package/dist/core/command/diag-service.js

@@ -19,13 +19,17 @@ export async function executeDiagIpc(service, registry, owners, cmd) {
     try {
         if (!Array.isArray(cmd.argv) || cmd.argv.some((v) => typeof v !== 'string'))
             throw new Error('Invalid diag argv');
-        return await service.execute(parseDiagArgs(cmd.argv));
+        if (cmd.argv[0] !== 'diag')
+            throw new Error('Expected a diag command');
+        return await service.execute(parseDiagArgs(cmd.argv.slice(1)));
     }
     catch (error) {
         return { ok: false, code: error.code ?? 'INVALID_ARGUMENT', message: error.message };
     }
 }
 export function parseDiagArgs(args) {
+    if (args.at(-2) === '--format' && args.at(-1) === 'json')
+        args = args.slice(0, -2);
     const words = [];
     let ownerAid;
     let literal = false;

package/dist/core/handoff/ipc-registration.js

@@ -2,6 +2,8 @@ import { isManagementRole } from '../../config/builtin-roles.js';
 import { hasTrustedFullAccessDelegation, trustedExecutionIdentityInput, } from '../auth/agent-delegation.js';
 import { authorizeOperation, buildAuthSubject } from '../auth/auth-gateway.js';
 import { parsePeerKey } from '../relation/peer-identity.js';
+import { parseReturn } from '../../cli/handoff-command.js';
+import { readTriggerLocalFile } from '../../trigger/local-files.js';
 export function registerHandoffIpc({ ipcServer, agentDelegationRegistry, responseEngine, sessionManager, agentRegistry, handoffRuntime, getProcessOwners, }) {
     const resolveManagedHandoffScope = async (params, operation) => {
         const delegation = agentDelegationRegistry.validate(params.delegationToken, params.sessionId, params.delegationCommandHash);
@@ -67,6 +69,8 @@ export function registerHandoffIpc({ ipcServer, agentDelegationRegistry, respons
             managementRole,
             role: subject.role,
             actorId: delegation.grant.actorId,
+            projectPath: session.projectPath,
+            sessionRuntimeDir: delegation.grant.sessionRuntimeDir,
         };
     };
     const resolveHandoffQueryScope = async (params, operation) => {
@@ -87,6 +91,22 @@ export function registerHandoffIpc({ ipcServer, agentDelegationRegistry, respons
         const scope = await resolveManagedHandoffScope({ ...params, sessionId: params.sessionId }, 'ec.handoff.return');
         if (!scope.ok)
             return scope;
+        if (!params.argv || params.argv[0] !== 'handoff' || params.argv[1] !== 'return') {
+            return { ok: false, code: 'ARGUMENT_MISMATCH', error: 'Handoff return requires its approved argv' };
+        }
+        try {
+            const parsed = parseReturn(params.argv.slice(2), {
+                canonical: true,
+                readFile: file => new TextDecoder('utf-8', { fatal: true }).decode(readTriggerLocalFile(file, {
+                    selfAid: scope.aid, projectPath: scope.projectPath,
+                    sessionRuntimeDir: scope.sessionRuntimeDir, cwd: scope.projectPath,
+                })),
+            });
+            params = { ...params, ...parsed };
+        }
+        catch (error) {
+            return { ok: false, code: 'HANDOFF_RETURN_CONTENT_FORBIDDEN', error: error instanceof Error ? error.message : String(error) };
+        }
         return responseEngine.returnAuthorizedHandoffResult({ sessionId: params.sessionId, handoffId: params.handoffId, content: params.content }, scope.aid);
     };
     const recoverHandoff = async (params) => {
@@ -98,6 +118,24 @@ export function registerHandoffIpc({ ipcServer, agentDelegationRegistry, respons
         if (scope.role !== 'owner') {
             return { ok: false, code: 'ROLE_ACCESS_DENIED', error: 'handoff recovery requires the current Agent owner' };
         }
+        if (!params.argv || params.argv[0] !== 'handoff' || params.argv[1] !== 'recover-return') {
+            return { ok: false, code: 'ARGUMENT_MISMATCH', error: 'Handoff recovery requires its approved argv' };
+        }
+        try {
+            const parsed = parseReturn(params.argv.slice(2), {
+                canonical: true,
+                readFile: file => new TextDecoder('utf-8', { fatal: true }).decode(readTriggerLocalFile(file, {
+                    selfAid: scope.aid, projectPath: scope.projectPath,
+                    sessionRuntimeDir: scope.sessionRuntimeDir, cwd: scope.projectPath,
+                })),
+            });
+            if (!parsed.handoffId)
+                return { ok: false, code: 'INVALID_HANDOFF_ID', error: 'Handoff recovery requires an ID' };
+            params = { ...params, handoffId: parsed.handoffId, content: parsed.content };
+        }
+        catch (error) {
+            return { ok: false, code: 'HANDOFF_RETURN_CONTENT_FORBIDDEN', error: error instanceof Error ? error.message : String(error) };
+        }
         return responseEngine.recoverAuthorizedHandoffResult({
             sessionId: params.sessionId,
             handoffId: params.handoffId,

package/dist/core/ipc-registration.js

@@ -4,7 +4,8 @@ import crypto from 'crypto';
 import fs from 'fs';
 import path from 'path';
 import { executeTaskResume } from './task/task-resume-operation.js';
-import { isHClassPath, isSameOrDescendant } from './permission/protected-paths.js';
+import { isHClassPath, isLClassPath, isSameOrDescendant } from './permission/protected-paths.js';
+import { resolveStorageCommandArgv } from '../aun/storage/index.js';
 import { computeBuildId } from '../utils/evolcore-version.js';
 import { loadAgent } from '../config-store.js';
 import { executeLocalInitializationCommand, hasSuppliedInitialization } from '../cli/agent-create.js';
@@ -75,6 +76,7 @@ export function registerDaemonIpc({ ipcServer, agentRegistry, agentDelegationReg
         handoffRuntime,
         agentApplicationService,
         agentInitializationService,
+        executeConfigOperation: (argv, sessionId, token, commandHash) => commandHandler.handleConfigOperation(argv, sessionId, token, commandHash),
     });
     registerOperationIpcProviders({
         ipcServer,
@@ -220,8 +222,12 @@ export function registerRuntimeIpcProviders({ ipcServer, channelInstances, messa
         });
         logger.info('[Memory] 开发仓安装：已启用 ec memory --debug <sessionId>');
     }
-    ipcServer.setTaskRuntimeContextAuthorizer(({ sessionId, delegationToken, delegationCommandHash }) => {
-        const authorization = agentDelegationRegistry.validateForContext(delegationToken, sessionId, delegationCommandHash);
+    ipcServer.setTaskRuntimeContextAuthorizer(({ sessionId, delegationToken, delegationCommandHash, consumeApproval }) => {
+        if (consumeApproval && !agentDelegationRegistry.validate)
+            return { ok: false, code: 'DELEGATION_REQUIRED', error: 'Command authorization is unavailable' };
+        const authorization = consumeApproval
+            ? agentDelegationRegistry.validate(delegationToken, sessionId, delegationCommandHash)
+            : agentDelegationRegistry.validateForContext(delegationToken, sessionId, delegationCommandHash);
         return authorization.ok
             ? { ok: true }
             : { ok: false, code: authorization.code, error: authorization.reason };
@@ -383,8 +389,17 @@ export function registerOperationIpcProviders({ ipcServer, sessionManager, messa
         recover: recoverTask,
     }));
     ipcServer.setQueueOperationExecutor(async (params) => {
+        try {
+            if (!params.argv)
+                return { ok: false, code: 'INVALID_REQUEST', error: 'Managed queue operation requires argv' };
+            const { parseQueueOperationArgv } = await import('../cli/queue-command.js');
+            params = { ...params, ...parseQueueOperationArgv(params.argv) };
+        }
+        catch (error) {
+            return { ok: false, code: 'INVALID_ARGUMENT', error: error instanceof Error ? error.message : String(error) };
+        }
         const operation = `ec.queue.${params.action ?? 'read'}`;
-        const authorization = await authorizeManagedAgentOperation(params, operation);
+        const authorization = await authorizeManagedAgentOperation({ ...params, targetAid: params.agent }, operation);
         if (!authorization.ok)
             return authorization;
         const handle = agentRegistry.get(authorization.aid);
@@ -419,10 +434,57 @@ export function registerOperationIpcProviders({ ipcServer, sessionManager, messa
         return authorization.ok ? { ok: true } : authorization;
     });
     ipcServer.setStorageAuthorizationExecutor(async (params) => {
-        const authorization = await authorizeManagedAgentOperation({ ...params, targetAid: params.aid }, params.operation);
-        return authorization.ok ? { ok: true } : authorization;
+        try {
+            if (!params.argv)
+                return { ok: false, code: 'INVALID_REQUEST', error: 'Managed storage requires argv' };
+            const command = resolveStorageCommandArgv(params.argv);
+            if (command.sub === 'upload')
+                return { ok: false, code: 'INVALID_REQUEST', error: 'Upload requires the storage upload endpoint' };
+            const authorization = await authorizeManagedAgentOperation({ ...params, targetAid: command.aid }, command.operation);
+            if (!authorization.ok)
+                return authorization;
+            const { storageDownload, storageLs, storageRm, storageQuota } = await import('../aun/storage/index.js');
+            if (command.sub === 'ls')
+                return storageLs(authorization.aid, command.prefix);
+            if (command.sub === 'quota')
+                return storageQuota(authorization.aid);
+            if (command.sub === 'rm') {
+                const result = await storageRm(authorization.aid, command.remotePath);
+                return { ...result, objectKey: command.remotePath };
+            }
+            const session = await sessionManager.getSessionById(params.sessionId);
+            if (!session)
+                return { ok: false, code: 'SESSION_NOT_FOUND', error: 'current session not found' };
+            const defaultName = path.basename(command.url.replace(/^https?:\/\//, '').split('/').slice(1).join('/'));
+            const destination = path.resolve(session.projectPath, command.localPath ?? defaultName);
+            const roots = [session.projectPath, authorization.sessionRuntimeDir].filter((root) => !!root).map(root => fs.realpathSync(root));
+            let parent = path.dirname(destination);
+            while (!fs.existsSync(parent) && path.dirname(parent) !== parent)
+                parent = path.dirname(parent);
+            const realParent = fs.realpathSync(parent);
+            if (!roots.some(root => isSameOrDescendant(destination, root) && isSameOrDescendant(realParent, root))
+                || isHClassPath(destination) || isLClassPath(destination)
+                || (fs.existsSync(destination) && (!fs.lstatSync(destination).isFile() || fs.lstatSync(destination).isSymbolicLink()))) {
+                return { ok: false, code: 'INVALID_LOCAL_PATH', error: 'Download destination must be an unprotected project/TMPDIR file' };
+            }
+            return storageDownload(authorization.aid, command.url, destination);
+        }
+        catch (error) {
+            return { ok: false, code: 'STORAGE_OPERATION_FAILED', error: error instanceof Error ? error.message : String(error) };
+        }
     });
     ipcServer.setStorageUploadExecutor(async (params) => {
+        try {
+            if (!params.argv)
+                return { ok: false, code: 'INVALID_REQUEST', error: 'Managed storage upload requires argv' };
+            const command = resolveStorageCommandArgv(params.argv);
+            if (command.sub !== 'upload')
+                return { ok: false, code: 'INVALID_REQUEST', error: 'Upload endpoint does not match argv' };
+            params = { ...params, aid: command.aid, localFile: command.localFile, remotePath: command.remotePath, isPublic: command.isPublic };
+        }
+        catch (error) {
+            return { ok: false, code: 'INVALID_ARGUMENT', error: error instanceof Error ? error.message : String(error) };
+        }
         const authorization = await authorizeManagedAgentOperation({ ...params, targetAid: params.aid }, 'storage.upload');
         if (!authorization.ok)
             return authorization;
@@ -438,7 +500,9 @@ export function registerOperationIpcProviders({ ipcServer, sessionManager, messa
             }
             const localFile = fs.realpathSync(requestedFile);
             const stat = fs.lstatSync(localFile);
-            if (!isSameOrDescendant(localFile, projectPath) || isHClassPath(localFile)) {
+            const inProject = isSameOrDescendant(localFile, projectPath);
+            const inRuntime = authorization.sessionRuntimeDir && isSameOrDescendant(localFile, fs.realpathSync(authorization.sessionRuntimeDir));
+            if ((!inProject && !inRuntime) || isHClassPath(localFile) || isLClassPath(localFile)) {
                 return { ok: false, code: 'INVALID_LOCAL_PATH', error: 'Upload source must be an unprotected file inside the current session project' };
             }
             if (!stat.isFile() || stat.isSymbolicLink()) {

package/dist/core/message/aun-ipc-sender.js

@@ -5,7 +5,10 @@ import { classifyAunPayloadForLog } from './message-log.js';
 import { isValidAunDeliveryForChannel } from './outbound.js';
 import { isHClassPath } from '../permission/protected-paths.js';
 import { evaluateOutboundContactAdmission } from './message-admission.js';
-import { normalizeAunMentionEntries } from '../../aun/msg/mention-schema.js';
+import { normalizeAunMentionEntries, withAunAttention } from '../../aun/msg/mention-schema.js';
+import { resolveManagedSendArgv } from '../../cli/aun-commands.js';
+import { readTriggerLocalFile, resolveTriggerLocalPath } from '../../trigger/local-files.js';
+import { sameGroupAid } from '../../aun/group/identity.js';
 export function createAunHandoffSender(sessionManager, channelInstances) {
     return async (handoff) => {
         const targetSession = await sessionManager.getSessionById(handoff.target_session_id);
@@ -57,9 +60,25 @@ export function createAunHandoffSender(sessionManager, channelInstances) {
 }
 export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegationRegistry, responseEngine, handoffRuntime, }) {
     const sender = async (params) => {
-        const runtimeCausation = params.originSessionId
-            ? responseEngine.getTaskRuntimeContext(params.originSessionId)?.causation
-            : undefined;
+        let textFile;
+        try {
+            if (params.argv !== undefined) {
+                const command = resolveManagedSendArgv(params.argv);
+                textFile = command.textFile;
+                params = { ...params, ...command };
+            }
+            else if (!params.aid || !params.to || !params.scope) {
+                return { ok: false, code: 'INVALID_REQUEST', error: 'Managed AUN sends require command parameters' };
+            }
+        }
+        catch (error) {
+            return { ok: false, code: 'INVALID_ARGUMENT', error: error instanceof Error ? error.message : String(error) };
+        }
+        const runtime = params.originSessionId ? responseEngine.getTaskRuntimeContext(params.originSessionId) : undefined;
+        const runtimeCausation = runtime?.causation;
+        if (params.argv !== undefined && !params.delegationCommandHash) {
+            return { ok: false, code: 'INVALID_DELEGATION', error: 'Managed AUN sends require an approved command hash' };
+        }
         const delegation = authorizeDelegatedAunMsgSend(agentDelegationRegistry, {
             delegationToken: params.delegationToken,
             delegationCommandHash: params.delegationCommandHash,
@@ -73,6 +92,30 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
         if (!delegation.ok) {
             return { ok: false, error: delegation.reason, code: delegation.code };
         }
+        try {
+            const fileScope = runtime?.projectPath ? { selfAid: delegation.grant.selfAid, projectPath: runtime.projectPath,
+                sessionRuntimeDir: delegation.grant.sessionRuntimeDir, cwd: runtime.projectPath } : undefined;
+            if ((textFile || params.file) && !fileScope)
+                throw new Error('Current task project context is unavailable');
+            if (textFile) {
+                const text = new TextDecoder('utf-8', { fatal: true }).decode(readTriggerLocalFile(textFile, fileScope));
+                if (!text || text.includes('\0'))
+                    throw new Error('Message file must contain nonempty UTF-8 text');
+                params.payload = { type: 'text', text };
+            }
+            if (params.file)
+                params.file = { ...params.file, filePath: resolveTriggerLocalPath(params.file.filePath, fileScope) };
+            if (params.payload)
+                params.payload = withAunAttention(params.payload);
+            const currentRelation = runtime?.channel === 'aun' && runtime.selfAid === params.aid
+                && runtime.chatType === (params.scope === 'group' ? 'group' : 'private')
+                && !!runtime.channelId && (params.scope === 'group' ? sameGroupAid(runtime.channelId, params.to) : runtime.channelId === params.to);
+            params.thread = typeof params.payload?.thread_id === 'string' && params.payload.thread_id.trim()
+                ? params.payload.thread_id.trim() : params.thread ?? (currentRelation ? runtime?.threadId : undefined);
+        }
+        catch (error) {
+            return { ok: false, code: 'INVALID_LOCAL_FILE', error: error instanceof Error ? error.message : String(error) };
+        }
         const inst = channelInstances.find((candidate) => {
             if (candidate.channelType !== 'aun')
                 return false;
@@ -170,6 +213,7 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
                         channelType: delegation.grant.channelType,
                         chatType: delegation.grant.chatType,
                         peerKey: delegation.grant.peerKey,
+                        approvalInteractionPolicy: delegation.grant.approvalInteractionPolicy,
                     },
                     causation: runtimeCausation,
                 });