evolcore 0.0.12 → 0.0.13

package/dist/config/access-policy.js

@@ -1,6 +1,5 @@
 import crypto from 'crypto';
-import { ConfigError, ConfigTarget, mutateConfig, read, validateConfig, } from './config-manager.js';
-import { validAgentOwnerIds, validateAccessPolicyDomain, } from './access-policy-domain.js';
+import { ConfigError, ConfigTarget, mutateConfig, read, validateConfig, validAgentOwnerIds, validateAccessPolicyDomain, } from './config-manager.js';
 export class AccessPolicyError extends Error {
     code;
     data;

package/dist/config/builtin-roles.js

@@ -44,6 +44,11 @@ export function getManagementCommandPermissions(role) {
         'role.policy.write': { allow: true, dangerous: true, scopes: ['agent'], constraints: { requireAgentAdmin: true } },
         'ec.aid.show': { allow: true, dangerous: true, scopes: ['agent'], constraints: { targetCurrentAgentOnly: true, requireAgentAdmin: true } },
         'ec.aid.agentmd.put': { allow: true, dangerous: true, scopes: ['agent'], constraints: { targetCurrentAgentOnly: true, requireAgentAdmin: true } },
+        'ec.fs.mkdir': { allow: true, permissionMode: 'auto', scopes: ['relation'], constraints: { groupOnly: true, currentRelationOnly: true, targetCurrentAgentOnly: true } },
+        'ec.fs.upload': { allow: true, permissionMode: 'auto', scopes: ['relation'], constraints: { groupOnly: true, currentRelationOnly: true, targetCurrentAgentOnly: true } },
+        'ec.fs.copy': { allow: true, permissionMode: 'auto', scopes: ['relation'], constraints: { groupOnly: true, currentRelationOnly: true, targetCurrentAgentOnly: true } },
+        'ec.fs.move': { allow: true, permissionMode: 'auto', scopes: ['relation'], constraints: { groupOnly: true, currentRelationOnly: true, targetCurrentAgentOnly: true } },
+        'ec.fs.remove': { allow: true, permissionMode: 'auto', scopes: ['relation'], constraints: { groupOnly: true, currentRelationOnly: true, targetCurrentAgentOnly: true } },
         '*': { allow: true },
         // Reload is valid from an Agent's own channel and the daemon control plane.
         // The control-channel gate still requires a daemon owner for cross-Agent reloads.

package/dist/config/config-manager.js

@@ -28,7 +28,27 @@ import { clearRoleStoreCache, isRoleName } from './role-store.js';
 import { writeRoleDefinition, writeRoleRegistry } from './role-service.js';
 import { mutateContactBookTransactionSync } from './contact-book-store.js';
 import { DAEMON_SCHEMA_NAME } from '../product.js';
-import { validateAccessPolicyDomain } from './access-policy-domain.js';
+export function shouldFailFastForMissingOwners(env = process.env) {
+    const value = (env.EVOLCORE_REQUIRE_OWNERS || '').trim().toLowerCase();
+    return value === '1' || value === 'true' || value === 'yes';
+}
+export function validAgentOwnerIds(agent) {
+    return [...new Set((agent?.owners ?? [])
+            .map(value => String(value || '').trim())
+            .filter(isValidAid))];
+}
+export function validateAccessPolicyDomain(selfAid, agent) {
+    const access = agent.access;
+    if (!access)
+        return undefined;
+    if (access.policyMode !== 'open' && validAgentOwnerIds(agent).length === 0) {
+        return {
+            code: 'restricted_mode_without_owner',
+            message: `Agent ${selfAid} cannot use ${access.policyMode} without an Owner`,
+        };
+    }
+    return undefined;
+}
 export var ConfigTarget;
 (function (ConfigTarget) {
     ConfigTarget["Process"] = "process";

package/dist/config/peer-role-resolver.js

@@ -123,8 +123,12 @@ export function resolvePeerRoleDetail(ctx) {
     const winner = selectHighestRank(candidates, ctx.selfAid);
     if (winner)
         return resultFor(winner.role, winner.source, actor, ctx.selfAid);
-    return roleRegistryExists(ctx.selfAid) && roleExists('visitor', ctx.selfAid)
-        ? resultFor('visitor', 'builtin-fallback', actor, ctx.selfAid)
+    // Group members get the normal interactive member policy when no explicit
+    // group/actor/default assignment exists. Private conversations retain the
+    // read-only visitor fallback.
+    const fallbackRole = ctx.chatType === 'group' ? 'member' : 'visitor';
+    return roleRegistryExists(ctx.selfAid) && roleExists(fallbackRole, ctx.selfAid)
+        ? resultFor(fallbackRole, 'builtin-fallback', actor, ctx.selfAid)
         : resultFor(null, 'none', actor, ctx.selfAid);
 }
 export function roleToSessionIdentity(role) {

package/dist/config/role-migration-startup.js

@@ -0,0 +1,53 @@
+import path from 'path';
+import { pathToFileURL } from 'url';
+import { getPackageRoot, resolvePaths } from '../paths.js';
+import { assertRoleConfigV4Ready, assertRoleConfigV5Ready, ConfigError } from './config-manager.js';
+/** Apply the one-off v4 role config migration before daemon startup. */
+export async function ensureRoleConfigV4OnStartup() {
+    try {
+        assertRoleConfigV4Ready();
+        return null;
+    }
+    catch (error) {
+        if (!(error instanceof ConfigError) || error.code !== 'ROLE_CONFIG_MIGRATION_REQUIRED')
+            throw error;
+    }
+    const home = resolvePaths().root;
+    const script = path.join(getPackageRoot(), 'kits', 'migrations', 'migrate-role-config-v4.mjs');
+    try {
+        const migration = await import(pathToFileURL(script).href);
+        const result = migration.runMigration({ home, apply: true });
+        assertRoleConfigV4Ready();
+        return result;
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new ConfigError('ROLE_CONFIG_MIGRATION_FAILED', `Automatic role config v4 migration failed: ${detail}\n` +
+            `Fix the reported config or run manually:\n` +
+            `node kits/migrations/migrate-role-config-v4.mjs --apply --home ${JSON.stringify(home)}`, { cause: error });
+    }
+}
+/** Apply the standalone v5 role registry migration before daemon startup. */
+export async function ensureRoleConfigV5OnStartup() {
+    try {
+        assertRoleConfigV5Ready();
+        return null;
+    }
+    catch (error) {
+        if (!(error instanceof ConfigError) || error.code !== 'ROLE_CONFIG_V5_MIGRATION_REQUIRED')
+            throw error;
+    }
+    const home = resolvePaths().root;
+    const script = path.join(getPackageRoot(), 'kits', 'migrations', 'migrate-role-config-v5.mjs');
+    try {
+        const migration = await import(pathToFileURL(script).href);
+        const result = migration.runMigration({ home, apply: true });
+        assertRoleConfigV5Ready();
+        return result;
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new ConfigError('ROLE_CONFIG_V5_MIGRATION_FAILED', `Automatic standalone role migration failed: ${detail}\n` +
+            `node kits/migrations/migrate-role-config-v5.mjs --apply --home ${JSON.stringify(home)}`, { cause: error });
+    }
+}

package/dist/config/role-store.js

@@ -113,7 +113,7 @@ function readRegistry(selfAid, diagnostics) {
                     code: 'INVALID_ROLE_ASSIGNMENT',
                     roleId: selected,
                     file: path.relative(resolvePaths().root, file),
-                    message: `defaultRoles.${scene} references invalid or unregistered role ${selected}; using visitor fallback`,
+                    message: `defaultRoles.${scene} references invalid or unregistered role ${selected}; using ${scene === 'group' ? 'member' : 'visitor'} fallback`,
                 });
                 defaultRoles[scene] = null;
             }

package/dist/core/auth/agent-delegation.js

@@ -2,7 +2,7 @@ import crypto from 'crypto';
 import { authorizeOperation, buildAuthSubject } from './auth-gateway.js';
 import { formatPeerKey, parsePeerKey } from '../relation/peer-identity.js';
 export const AGENT_DELEGATION_TOKEN_ENV = 'EVOLCORE_DELEGATION_TOKEN';
-export const AGENT_DELEGATION_COMMAND_TTL_MS = 60_000;
+export const AGENT_DELEGATION_COMMAND_TTL_MS = 5 * 60_000;
 export class AgentDelegationRegistry {
     grantsByHash = new Map();
     activeHashBySession = new Map();

package/dist/core/auth/auth-gateway.js

@@ -4,6 +4,22 @@ import { formatPeerKey } from '../relation/peer-identity.js';
 import { authorizeCommand, authorizeResolvedConfigCommand } from './operation-authorizer.js';
 import { auditCommandAuthorization } from './authorization-audit.js';
 import { hasTrustedPrincipal } from './authenticated-actor.js';
+import { resolveRuntimePermissionMode } from '../role/runtime-policy.js';
+const CROSS_AGENT_READ_OPERATIONS = new Set([
+    'trigger.list',
+    'trigger.show',
+    'trigger.history',
+]);
+export function isCrossAgentTriggerOperationAllowed(input) {
+    if (input.control || input.taskAgentAid === input.targetAgentAid)
+        return true;
+    if (!input.taskAgentAid || !input.targetManagement)
+        return false;
+    return CROSS_AGENT_READ_OPERATIONS.has(input.operation);
+}
+export function isCrossAgentTriggerReadOperation(operation) {
+    return CROSS_AGENT_READ_OPERATIONS.has(operation);
+}
 export function buildAuthSubject(input) {
     const chatType = input.chatType === 'group' ? 'group' : 'private';
     const actorId = input.actorId;
@@ -27,6 +43,8 @@ export function buildAuthSubject(input) {
     return {
         selfAid: input.selfAid,
         actorId,
+        requestId: input.requestId,
+        sessionId: input.sessionId,
         channel: input.channel,
         channelType: input.channelType,
         channelId: input.channelId,
@@ -41,6 +59,8 @@ export function buildAuthSubject(input) {
         allowAccess: isDaemonOwner || (suppliedRole
             ? checkRoleAccess(suppliedRole, input.selfAid)
             : roleDetail.allowAccess && checkRoleAccess(role, input.selfAid)),
+        permissionMode: input.permissionMode
+            ?? resolveRuntimePermissionMode({ selfAid: input.selfAid, role }).effectiveValue,
     };
 }
 function isProcessOwner(input) {
@@ -144,6 +164,15 @@ function resolveRoleDetail(input) {
 function auditDecision(params, decision) {
     auditCommandAuthorization({
         ts: Date.now(),
+        ...params.auditMetadata,
+        requestId: params.auditMetadata?.requestId ?? params.subject.requestId,
+        sessionId: params.auditMetadata?.sessionId ?? params.subject.sessionId,
+        agentAid: params.auditMetadata?.agentAid ?? params.subject.selfAid,
+        permissionMode: params.auditMetadata?.permissionMode
+            ?? (decision.allow ? decision.permissionMode ?? params.subject.permissionMode : params.subject.permissionMode),
+        toolName: params.auditMetadata?.toolName,
+        policyCode: params.auditMetadata?.policyCode ?? (decision.allow ? undefined : decision.code),
+        decisionSource: params.auditMetadata?.decisionSource ?? (decision.allow ? 'command' : 'policy'),
         source: params.source,
         operation: params.intent.operation,
         scope: params.intent.scope,
@@ -161,6 +190,5 @@ function auditDecision(params, decision) {
         reason: decision.allow ? undefined : decision.reason,
         matchedRule: decision.matchedRule,
         argsSummary: params.intent.args,
-        ...params.auditMetadata,
     });
 }

package/dist/core/auth/authorization-audit.js

@@ -17,6 +17,13 @@ export function auditCommandAuthorization(event) {
 function buildAuditRecord(event) {
     return {
         ts: event.ts,
+        requestId: event.requestId,
+        sessionId: event.sessionId,
+        agentAid: redactIdentifier(event.agentAid ?? event.selfAid),
+        permissionMode: event.permissionMode,
+        toolName: event.toolName,
+        policyCode: event.policyCode ?? event.code,
+        decisionSource: event.decisionSource,
         source: event.source,
         operation: event.operation,
         scope: event.scope,
@@ -71,6 +78,13 @@ function logAuditEvent(record) {
         `actor=${record.actorId || 'unknown'}`,
         record.taskId ? `task=${record.taskId}` : null,
         record.messageId ? `message=${record.messageId}` : null,
+        record.requestId ? `request=${record.requestId}` : null,
+        record.sessionId ? `session=${record.sessionId}` : null,
+        record.agentAid ? `agent=${record.agentAid}` : null,
+        record.permissionMode ? `permissionMode=${record.permissionMode}` : null,
+        record.toolName ? `tool=${record.toolName}` : null,
+        record.policyCode ? `policy=${record.policyCode}` : null,
+        record.decisionSource ? `decisionSource=${record.decisionSource}` : null,
         record.code ? `code=${record.code}` : null,
         record.matchedRule ? `rule=${record.matchedRule}` : null,
         record.dangerous ? 'dangerous=true' : null,
@@ -78,6 +92,7 @@ function logAuditEvent(record) {
         .filter(Boolean)
         .join(' ');
     logger[level](message);
+    logger[level](`[CommandAuditRecord] ${JSON.stringify(record)}`);
     if (record.reason)
         logger[level](`  reason: ${record.reason}`);
     if (record.argvHash)

package/dist/core/auth/operation-authorizer.js

@@ -170,6 +170,7 @@ function authorizeCommandInternal(ctx, resolvedConfigCommand) {
         dangerous: opMeta.dangerous,
         matchedRule,
         constraints: permission.constraints,
+        permissionMode: permission.permissionMode,
     };
 }
 function matchCommandPermission(operation, category, commandPerms, isDangerous) {

package/dist/core/auth/operation-catalog.js

@@ -73,6 +73,14 @@ const GROUP_FS_READ_OPERATIONS = ['ls', 'stat', 'lstat', 'cat', 'find', 'df'].ma
     description: `Read current group filesystem (${kind})`,
     sources: ['agent-tool'],
 }));
+const GROUP_FS_WRITE_OPERATIONS = ['mkdir', 'upload', 'copy', 'move', 'remove'].map(kind => ({
+    id: `ec.fs.${kind}`,
+    category: 'write-own',
+    dangerous: false,
+    defaultScopes: ['relation'],
+    description: `Write current group filesystem (${kind})`,
+    sources: ['agent-tool'],
+}));
 const HANDOFF_READ_OPERATIONS = ['status', 'list', 'trace'].map(kind => ({
     id: `ec.handoff.${kind}`,
     category: 'read',
@@ -856,6 +864,7 @@ const OPERATIONS = [
     ...GROUP_MANAGEMENT_OPERATIONS,
     ...MSG_READ_OPERATIONS,
     ...GROUP_FS_READ_OPERATIONS,
+    ...GROUP_FS_WRITE_OPERATIONS,
     ...HANDOFF_READ_OPERATIONS,
     ...HANDOFF_WRITE_OPERATIONS,
     ...QUEUE_OPERATIONS,

package/dist/core/bootstrap-messages.js

@@ -31,14 +31,21 @@ export function preparePostBootstrapWelcomeOutbox(aid, owner, ownerName) {
     const chatDir = chatDirPath(resolvePaths().sessionsDir, 'aun', owner, aid);
     if (hasMessageLogOperation(chatDir, operationId))
         return;
+    const existing = outbox.findByDedupeKey(aid, operationId);
+    if (existing?.delivery?.chatType === 'private' && existing.channelId === owner)
+        return;
+    if (existing)
+        outbox.remove(aid, existing.id);
     outbox.enqueue(aid, {
         channelId: owner,
+        delivery: { chatType: 'private' },
         dedupeKey: operationId,
         critical: true,
         type: 'text',
         text: renderPostBootstrapWelcome(aid, owner, ownerName),
         ttl: BOOTSTRAP_MESSAGE_TTL_MS,
         context: {
+            delivery: { chatType: 'private' },
             metadata: {
                 source: 'daemon',
                 chatmode: 'interactive',
@@ -49,12 +56,12 @@ export function preparePostBootstrapWelcomeOutbox(aid, owner, ownerName) {
     });
 }
 export function hasPendingPostBootstrapWelcomeOutbox(aid) {
-    return !!outbox.findByDedupeKey(aid, postBootstrapWelcomeOperationId(aid));
+    return outbox.findByDedupeKey(aid, postBootstrapWelcomeOperationId(aid))?.delivery?.chatType === 'private';
 }
 /** Bind the durable completion welcome to the fresh post-bootstrap session. */
 export function bindPostBootstrapWelcomeOutboxSession(aid, sessionId) {
     const entry = outbox.findByDedupeKey(aid, postBootstrapWelcomeOperationId(aid));
-    if (!entry)
+    if (!entry || entry.delivery?.chatType !== 'private')
         return false;
     if (entry.context?.sessionId === sessionId)
         return true;

package/dist/core/bootstrap-service.js

@@ -166,6 +166,7 @@ export class BootstrapService {
                 channelId,
                 agentName: aid,
                 replyContext: {
+                    delivery: { chatType: 'private' },
                     metadata: {
                         source: 'daemon',
                         persistRequired: true,