@sidurijs/core 1.0.0

package/dist/action-executor.d.ts

@@ -0,0 +1,12 @@
+import { ActionIntent, ActionExecutionResult, ActionPolicyEngine, HandsOrgan, RequestContext } from './index';
+export interface ActionExecutionParams {
+    actionIntents?: ActionIntent[];
+    requestContext: RequestContext;
+    actionPolicy: ActionPolicyEngine;
+    hands?: HandsOrgan;
+}
+/**
+ * Executes proposed actions under the primary security invariant:
+ * "Brain proposes; the policy layer authorizes; Hands executes; the audit layer records."
+ */
+export declare function executeActionIntents(params: ActionExecutionParams): Promise<ActionExecutionResult[]>;

package/dist/action-executor.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeActionIntents = executeActionIntents;
+/**
+ * Executes proposed actions under the primary security invariant:
+ * "Brain proposes; the policy layer authorizes; Hands executes; the audit layer records."
+ */
+async function executeActionIntents(params) {
+    const { actionIntents, requestContext, actionPolicy, hands } = params;
+    const actionResults = [];
+    if (!hands ||
+        !actionIntents ||
+        actionIntents.length === 0 ||
+        typeof hands.executeAction !== 'function') {
+        return actionResults;
+    }
+    for (const rawAction of actionIntents) {
+        // 1. Context Propagation: Attach request provenance to ActionIntent
+        const actionWithContext = {
+            ...rawAction,
+            context: requestContext,
+            parameters: {
+                ...(requestContext.companionId ? { companionId: requestContext.companionId } : {}),
+                ...(rawAction.parameters || {}),
+            },
+            executionId: rawAction.executionId ||
+                `exec-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        };
+        // 2. Action Policy Authorization Boundary Check
+        const { decision, capability } = await actionPolicy.evaluateAction(actionWithContext, requestContext);
+        if (!decision.allowed || !capability) {
+            // Action was rejected by policy
+            actionResults.push({
+                actionId: actionWithContext.actionId,
+                executionId: decision.executionId,
+                toolName: actionWithContext.toolName,
+                lifecycle: 'REJECTED',
+                success: false,
+                error: `Action authorization rejected by policy: ${decision.reason}`,
+                decision,
+            });
+            continue;
+        }
+        // 3. Hands Execution (only authorized actions execute with AuthorizationCapability)
+        const res = await hands.executeAction(actionWithContext, capability);
+        actionResults.push({
+            ...res,
+            decision,
+        });
+        // 4. Audit recording for execution outcome
+        await actionPolicy.recordAudit(actionWithContext, requestContext, decision, res.lifecycle, res.result, res.error, res.durationMs);
+    }
+    return actionResults;
+}

package/dist/action-policy.d.ts

@@ -0,0 +1,79 @@
+import { RequestContext } from './context';
+import { ActionIntent, ActionPolicyDecision, ActionAuditEvent, ToolDefinition, ActionRiskLevel, ActionLifecycleState } from './action';
+import { AuthorizationCapability, ActionStore } from './capability';
+export interface ActionPolicyRule {
+    toolNamePattern: string | RegExp;
+    riskLevel?: ActionRiskLevel;
+    requiredCapabilities?: string[];
+    allowedRoles?: string[];
+    allowedChannels?: string[];
+    requiresExplicitApproval?: boolean;
+}
+export interface ActionPolicyEngineOptions {
+    rules?: ActionPolicyRule[];
+    defaultRiskLevel?: ActionRiskLevel;
+    defaultRequireApprovalForHighRisk?: boolean;
+    store?: ActionStore;
+    secretKey?: string;
+    allowedApproverRoles?: string[];
+    requiredApproverCapabilities?: string[];
+}
+export type ActionApprovalDecisionCode = 'APPROVED' | 'REJECTED_UNAUTHORIZED' | 'REJECTED_UNAUTHENTICATED' | 'REJECTED_ROLE_MISMATCH' | 'REJECTED_MISSING_APPROVER_ID' | 'REJECTED_MISSING_CAPABILITY' | 'REJECTED_UNKNOWN_EXECUTION';
+export interface ActionApprovalResult {
+    approved: boolean;
+    decisionCode: ActionApprovalDecisionCode;
+    reason: string;
+    executionId: string;
+    approverActorId: string;
+}
+export interface ApproveActionOptions {
+    executionId: string;
+    approverActorId: string;
+    reason?: string;
+    /**
+     * Optional RequestContext of the approver establishing authenticated identity.
+     */
+    context?: RequestContext;
+    /**
+     * Optional role of the approver (e.g. 'owner', 'administrator', 'operator').
+     */
+    approverRole?: string;
+    /**
+     * Optional capabilities held by the approver.
+     */
+    approverCapabilities?: string[];
+    /**
+     * Optional explicit action binding parameters when pre-authorizing a known action
+     */
+    toolName?: string;
+    parametersHash?: string;
+    companionId?: string;
+    actorId?: string;
+}
+export declare function normalizeApproverRole(role?: string, actorId?: string): string;
+export declare class ActionPolicyEngine {
+    private readonly toolRegistry;
+    private readonly rules;
+    private readonly store;
+    private readonly defaultRiskLevel;
+    private readonly defaultRequireApprovalForHighRisk;
+    private readonly secretKey;
+    private readonly allowedApproverRoles;
+    private readonly requiredApproverCapabilities;
+    private readonly approvedExecutions;
+    private readonly pendingActions;
+    constructor(options?: ActionPolicyEngineOptions);
+    registerToolDefinition(tool: ToolDefinition): void;
+    unregisterToolDefinition(toolName: string): boolean;
+    getRegisteredTools(): ToolDefinition[];
+    findToolDefinition(toolName: string): ToolDefinition | undefined;
+    evaluateAction(action: ActionIntent, context?: RequestContext): Promise<{
+        decision: ActionPolicyDecision;
+        capability?: AuthorizationCapability;
+    }>;
+    approveAction(options: ApproveActionOptions): Promise<ActionApprovalResult>;
+    private recordApprovalAudit;
+    recordAudit(action: ActionIntent, context: RequestContext | undefined, decision: ActionPolicyDecision | undefined, lifecycle: ActionLifecycleState, result?: unknown, error?: string, durationMs?: number): Promise<ActionAuditEvent>;
+    getAuditLog(): Promise<ActionAuditEvent[]>;
+    getStore(): ActionStore;
+}

package/dist/action-policy.js

@@ -0,0 +1,439 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionPolicyEngine = void 0;
+exports.normalizeApproverRole = normalizeApproverRole;
+const capability_1 = require("./capability");
+function normalizeApproverRole(role, actorId) {
+    if (role && role.trim() !== '') {
+        const lower = role.trim().toLowerCase();
+        if (lower === 'administrator' || lower === 'admin')
+            return 'administrator';
+        return lower;
+    }
+    // Principle of least privilege: Never derive privileged roles (administrator, owner, operator)
+    // from arbitrary substring matching on unverified actorId strings.
+    // When an explicit authorization role is not provided, default to 'viewer'.
+    return 'viewer';
+}
+class ActionPolicyEngine {
+    toolRegistry = new Map();
+    rules = [];
+    store;
+    defaultRiskLevel;
+    defaultRequireApprovalForHighRisk;
+    secretKey;
+    allowedApproverRoles;
+    requiredApproverCapabilities;
+    approvedExecutions = new Map();
+    pendingActions = new Map();
+    constructor(options = {}) {
+        this.rules = options.rules ?? [];
+        this.defaultRiskLevel = options.defaultRiskLevel ?? 'HIGH';
+        this.defaultRequireApprovalForHighRisk = options.defaultRequireApprovalForHighRisk ?? true;
+        this.store = options.store ?? new capability_1.InMemoryActionStore();
+        this.secretKey = (0, capability_1.getOrGenerateLocalActionPolicySecret)(options.secretKey);
+        this.allowedApproverRoles = (options.allowedApproverRoles ?? ['owner', 'administrator', 'admin', 'operator']).map((r) => r.toLowerCase());
+        this.requiredApproverCapabilities = options.requiredApproverCapabilities ?? [];
+    }
+    registerToolDefinition(tool) {
+        const key = tool.providerId ? `${tool.providerId}/${tool.name}` : tool.name;
+        this.toolRegistry.set(key, tool);
+        // Also index by bare name if unique
+        if (!this.toolRegistry.has(tool.name)) {
+            this.toolRegistry.set(tool.name, tool);
+        }
+    }
+    unregisterToolDefinition(toolName) {
+        return this.toolRegistry.delete(toolName);
+    }
+    getRegisteredTools() {
+        const set = new Set(this.toolRegistry.values());
+        return Array.from(set);
+    }
+    findToolDefinition(toolName) {
+        return this.toolRegistry.get(toolName);
+    }
+    async evaluateAction(action, context) {
+        const effectiveContext = action.context || context;
+        const executionId = action.executionId || `exec-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        action.executionId = executionId;
+        const toolDef = this.findToolDefinition(action.toolName);
+        const paramsHash = (0, capability_1.computeParametersHash)(action.parameters);
+        // Rule: Unknown tools/actions must not be implicitly authorized
+        if (!toolDef) {
+            const decision = {
+                allowed: false,
+                reason: `Tool "${action.toolName}" is not registered or known in action policy`,
+                riskLevel: 'CRITICAL',
+                executionId,
+                decisionCode: 'REJECTED_UNKNOWN_TOOL',
+            };
+            await this.recordAudit(action, effectiveContext, decision, 'REJECTED');
+            return { decision };
+        }
+        const riskLevel = toolDef.riskLevel || this.defaultRiskLevel;
+        const requiredCaps = toolDef.requiredCapabilities || [];
+        // Check request context presence
+        if (!effectiveContext) {
+            const decision = {
+                allowed: false,
+                reason: 'Missing RequestContext: Actions cannot be authorized without request context',
+                riskLevel,
+                requiredCapabilities: requiredCaps,
+                executionId,
+                decisionCode: 'REJECTED_UNAUTHORIZED',
+            };
+            await this.recordAudit(action, undefined, decision, 'REJECTED');
+            return { decision };
+        }
+        // Role check if tool restricts roles (supports administrator/owner role parity)
+        if (toolDef.allowedRoles && toolDef.allowedRoles.length > 0) {
+            const actorRole = effectiveContext.actor.authorizationRole ||
+                effectiveContext.actor.role ||
+                (effectiveContext.actor.authenticated === false ? 'viewer' : 'owner');
+            const normalizedActorRoles = new Set([actorRole.toLowerCase()]);
+            if (actorRole.toLowerCase() === 'administrator' || actorRole.toLowerCase() === 'owner') {
+                normalizedActorRoles.add('administrator');
+                normalizedActorRoles.add('owner');
+                normalizedActorRoles.add('admin');
+            }
+            const isAuthorizedRole = toolDef.allowedRoles.some((r) => normalizedActorRoles.has(r.toLowerCase()));
+            if (!isAuthorizedRole) {
+                const decision = {
+                    allowed: false,
+                    reason: `Actor role "${actorRole}" is not authorized to execute tool "${action.toolName}"`,
+                    riskLevel,
+                    requiredCapabilities: requiredCaps,
+                    executionId,
+                    decisionCode: 'REJECTED_UNAUTHORIZED',
+                };
+                await this.recordAudit(action, effectiveContext, decision, 'REJECTED');
+                return { decision };
+            }
+        }
+        // Channel check if tool restricts channels
+        if (toolDef.allowedChannels && toolDef.allowedChannels.length > 0) {
+            const channel = effectiveContext.conversation?.channel || 'direct';
+            if (!toolDef.allowedChannels.includes(channel)) {
+                const decision = {
+                    allowed: false,
+                    reason: `Tool "${action.toolName}" cannot be executed in channel "${channel}"`,
+                    riskLevel,
+                    requiredCapabilities: requiredCaps,
+                    executionId,
+                    decisionCode: 'REJECTED_CHANNEL_RESTRICTED',
+                };
+                await this.recordAudit(action, effectiveContext, decision, 'REJECTED');
+                return { decision };
+            }
+        }
+        // Capability check
+        const actorCaps = effectiveContext.actor.capabilities || [];
+        const missingCaps = requiredCaps.filter((cap) => !actorCaps.includes(cap));
+        if (missingCaps.length > 0) {
+            const decision = {
+                allowed: false,
+                reason: `Actor is missing required capabilities: [${missingCaps.join(', ')}]`,
+                riskLevel,
+                requiredCapabilities: requiredCaps,
+                executionId,
+                decisionCode: 'REJECTED_MISSING_CAPABILITY',
+            };
+            await this.recordAudit(action, effectiveContext, decision, 'REJECTED');
+            return { decision };
+        }
+        // Risk level approval check
+        const requiresExplicitApproval = toolDef.requiresApproval ??
+            (this.defaultRequireApprovalForHighRisk && (riskLevel === 'HIGH' || riskLevel === 'CRITICAL'));
+        let approvalRecord = this.approvedExecutions.get(executionId);
+        if (!approvalRecord && typeof this.store.getApproval === 'function') {
+            approvalRecord = await this.store.getApproval(executionId);
+            if (approvalRecord) {
+                this.approvedExecutions.set(executionId, approvalRecord);
+            }
+        }
+        // Cryptographic / structural binding verification:
+        // Ensure the approval record matches the exact tool, parameters, companion, and actor
+        if (approvalRecord) {
+            const toolMatch = !approvalRecord.toolName || approvalRecord.toolName === action.toolName;
+            const paramsMatch = !approvalRecord.parametersHash || approvalRecord.parametersHash === paramsHash;
+            const companionMatch = !approvalRecord.companionId || approvalRecord.companionId === effectiveContext.companionId;
+            const actorMatch = !approvalRecord.actorId || approvalRecord.actorId === effectiveContext.actor.actorId;
+            if (!toolMatch || !paramsMatch || !companionMatch || !actorMatch) {
+                const decision = {
+                    allowed: false,
+                    reason: `Approval record for execution "${executionId}" does not match the requested tool, parameters, companion, or actor`,
+                    riskLevel,
+                    requiredCapabilities: requiredCaps,
+                    executionId,
+                    decisionCode: 'REJECTED_APPROVAL_MISMATCH',
+                };
+                await this.recordAudit(action, effectiveContext, decision, 'REJECTED');
+                return { decision };
+            }
+        }
+        let isApproved = Boolean(approvalRecord);
+        if (!isApproved && typeof this.store.isActionApproved === 'function') {
+            isApproved = await this.store.isActionApproved(executionId);
+        }
+        if (requiresExplicitApproval && isApproved && approvalRecord) {
+            const approverRole = (approvalRecord.approverRole || normalizeApproverRole(undefined, approvalRecord.approverActorId)).toLowerCase();
+            const isOwnerOrAdmin = approverRole === 'owner' || approverRole === 'administrator' || approverRole === 'admin';
+            if (toolDef.allowedRoles && toolDef.allowedRoles.length > 0 && !isOwnerOrAdmin) {
+                const allowed = toolDef.allowedRoles.map((r) => r.toLowerCase());
+                if (!allowed.includes(approverRole)) {
+                    const decision = {
+                        allowed: false,
+                        reason: `Approver "${approvalRecord.approverActorId}" with role "${approverRole}" is not authorized to approve tool "${action.toolName}"`,
+                        riskLevel,
+                        requiredCapabilities: requiredCaps,
+                        executionId,
+                        decisionCode: 'REJECTED_UNAUTHORIZED',
+                    };
+                    await this.recordAudit(action, effectiveContext, decision, 'REJECTED');
+                    return { decision };
+                }
+            }
+        }
+        if (requiresExplicitApproval && !isApproved) {
+            this.pendingActions.set(executionId, { action, context: effectiveContext, toolDef });
+            if (typeof this.store.reserveExecution === 'function') {
+                const record = {
+                    executionId,
+                    actionId: action.actionId,
+                    toolName: action.toolName,
+                    providerId: toolDef.providerId || 'builtin',
+                    parametersHash: paramsHash,
+                    lifecycle: 'POLICY_CHECKED',
+                    decision: {
+                        allowed: false,
+                        reason: `Action "${action.toolName}" has risk level ${riskLevel} and requires explicit approval`,
+                        riskLevel,
+                        requiredCapabilities: requiredCaps,
+                        executionId,
+                        decisionCode: 'REJECTED_HIGH_RISK_UNAPPROVED',
+                    },
+                    createdAt: new Date().toISOString(),
+                    updatedAt: new Date().toISOString(),
+                };
+                await this.store.reserveExecution(record).catch(() => { });
+            }
+            const decision = {
+                allowed: false,
+                reason: `Action "${action.toolName}" has risk level ${riskLevel} and requires explicit approval`,
+                riskLevel,
+                requiredCapabilities: requiredCaps,
+                executionId,
+                decisionCode: 'REJECTED_HIGH_RISK_UNAPPROVED',
+            };
+            await this.recordAudit(action, effectiveContext, decision, 'POLICY_CHECKED');
+            return { decision };
+        }
+        const decision = {
+            allowed: true,
+            reason: 'Action authorized by policy',
+            riskLevel,
+            requiredCapabilities: requiredCaps,
+            executionId,
+            decisionCode: 'ALLOWED_POLICY',
+        };
+        // Issue cryptographic/structural AuthorizationCapability
+        const issuedAt = new Date().toISOString();
+        const expiresAt = new Date(Date.now() + 60_000).toISOString();
+        const providerId = toolDef.providerId || 'builtin';
+        const capabilityPayload = {
+            executionId,
+            actionId: action.actionId,
+            toolName: action.toolName,
+            providerId,
+            parametersHash: paramsHash,
+            companionId: effectiveContext.companionId,
+            actorId: effectiveContext.actor?.actorId || 'owner-user',
+            sessionId: effectiveContext.actor?.sessionId || `sess-${effectiveContext.companionId}`,
+            channel: effectiveContext.conversation?.channel || 'direct',
+            correlationId: effectiveContext.conversation?.correlationId || `corr-${Date.now()}`,
+            riskLevel,
+            issuedAt,
+            expiresAt,
+        };
+        const signature = (0, capability_1.signCapabilityPayload)(capabilityPayload, this.secretKey);
+        const capability = {
+            ...capabilityPayload,
+            allowed: true,
+            signature,
+        };
+        await this.recordAudit(action, effectiveContext, decision, 'APPROVED');
+        return { decision, capability };
+    }
+    async approveAction(options) {
+        const actorId = (options.context?.actor.actorId || options.approverActorId || '').trim();
+        if (!actorId) {
+            return {
+                approved: false,
+                decisionCode: 'REJECTED_MISSING_APPROVER_ID',
+                reason: 'approverActorId is required to approve an action execution',
+                executionId: options.executionId,
+                approverActorId: '',
+            };
+        }
+        // 1. Authenticated boundary check
+        if (options.context && options.context.actor.authenticated === false) {
+            const result = {
+                approved: false,
+                decisionCode: 'REJECTED_UNAUTHENTICATED',
+                reason: `Approver "${actorId}" is unauthenticated and cannot approve actions`,
+                executionId: options.executionId,
+                approverActorId: actorId,
+            };
+            await this.recordApprovalAudit(options.executionId, actorId, 'unauthenticated', false, result.reason);
+            return result;
+        }
+        // 2. Resolve effective approver role & capabilities
+        const rawRole = options.context?.actor.authorizationRole || options.context?.actor?.role || options.approverRole;
+        const approverRole = normalizeApproverRole(rawRole, actorId);
+        const capabilities = options.context?.actor.capabilities || options.approverCapabilities || [];
+        const isOwnerOrAdmin = approverRole === 'owner' || approverRole === 'administrator' || approverRole === 'admin';
+        const isRoleAllowed = isOwnerOrAdmin || this.allowedApproverRoles.includes(approverRole);
+        // Reject non-allowed roles or explicit viewer/guest role
+        if (!isRoleAllowed || approverRole === 'viewer') {
+            const result = {
+                approved: false,
+                decisionCode: 'REJECTED_UNAUTHORIZED',
+                reason: `Actor "${actorId}" with role "${approverRole}" is not authorized to approve actions`,
+                executionId: options.executionId,
+                approverActorId: actorId,
+            };
+            await this.recordApprovalAudit(options.executionId, actorId, approverRole, false, result.reason);
+            return result;
+        }
+        // 3. Locate pending in-memory action or persisted execution record
+        const pending = this.pendingActions.get(options.executionId);
+        let executionRecord;
+        if (!pending && typeof this.store.getExecution === 'function') {
+            executionRecord = await this.store.getExecution(options.executionId);
+        }
+        if (!pending && !executionRecord && !options.toolName) {
+            const result = {
+                approved: false,
+                decisionCode: 'REJECTED_UNKNOWN_EXECUTION',
+                reason: `Cannot approve execution "${options.executionId}": execution is not pending or recognized`,
+                executionId: options.executionId,
+                approverActorId: actorId,
+            };
+            await this.recordApprovalAudit(options.executionId, actorId, approverRole, false, result.reason);
+            return result;
+        }
+        const targetToolName = pending?.action.toolName || executionRecord?.toolName || options.toolName || '';
+        const targetToolDef = pending?.toolDef || (targetToolName ? this.findToolDefinition(targetToolName) : undefined);
+        const targetParamsHash = (pending ? (0, capability_1.computeParametersHash)(pending.action.parameters) : undefined) ||
+            executionRecord?.parametersHash ||
+            options.parametersHash;
+        const targetCompanionId = pending?.context?.companionId || pending?.action.context?.companionId || options.companionId;
+        const targetActorId = pending?.context?.actor.actorId || pending?.action.context?.actor.actorId || options.actorId;
+        if (targetToolDef) {
+            if (targetToolDef.allowedRoles && targetToolDef.allowedRoles.length > 0 && !isOwnerOrAdmin) {
+                const normalizedToolRoles = new Set(targetToolDef.allowedRoles.map((r) => r.toLowerCase()));
+                if (!normalizedToolRoles.has(approverRole)) {
+                    const result = {
+                        approved: false,
+                        decisionCode: 'REJECTED_ROLE_MISMATCH',
+                        reason: `Approver role "${approverRole}" is not authorized to approve tool "${targetToolDef.name}" (requires: ${targetToolDef.allowedRoles.join(', ')})`,
+                        executionId: options.executionId,
+                        approverActorId: actorId,
+                    };
+                    await this.recordApprovalAudit(options.executionId, actorId, approverRole, false, result.reason, targetToolDef.name);
+                    return result;
+                }
+            }
+            if (this.requiredApproverCapabilities.length > 0 && !isOwnerOrAdmin) {
+                const missing = this.requiredApproverCapabilities.filter((c) => !capabilities.includes(c));
+                if (missing.length > 0) {
+                    const result = {
+                        approved: false,
+                        decisionCode: 'REJECTED_MISSING_CAPABILITY',
+                        reason: `Approver is missing required approval capabilities: [${missing.join(', ')}]`,
+                        executionId: options.executionId,
+                        approverActorId: actorId,
+                    };
+                    await this.recordApprovalAudit(options.executionId, actorId, approverRole, false, result.reason, targetToolDef.name);
+                    return result;
+                }
+            }
+        }
+        // 4. Record verified approval with exact tool, parameter, companion, and actor binding
+        const record = {
+            executionId: options.executionId,
+            approverActorId: actorId,
+            reason: options.reason,
+            approverRole,
+            approvedAt: new Date().toISOString(),
+            toolName: targetToolName,
+            parametersHash: targetParamsHash,
+            companionId: targetCompanionId,
+            actorId: targetActorId,
+        };
+        this.approvedExecutions.set(options.executionId, record);
+        if (typeof this.store.saveApproval === 'function') {
+            await this.store.saveApproval(options.executionId, actorId, options.reason, approverRole, targetToolName, targetParamsHash, targetCompanionId, targetActorId);
+        }
+        const reason = options.reason || 'Action approved by authorized policy approver';
+        await this.recordApprovalAudit(options.executionId, actorId, approverRole, true, reason, targetToolName);
+        return {
+            approved: true,
+            decisionCode: 'APPROVED',
+            reason,
+            executionId: options.executionId,
+            approverActorId: actorId,
+        };
+    }
+    async recordApprovalAudit(executionId, approverActorId, approverRole, approved, reason, toolName) {
+        const event = {
+            executionId,
+            actionId: executionId,
+            toolName: toolName || 'action:approve',
+            companionId: 'system',
+            actorId: approverActorId,
+            riskLevel: 'HIGH',
+            lifecycle: approved ? 'APPROVED' : 'REJECTED',
+            decision: {
+                allowed: approved,
+                reason: reason || (approved ? 'Approval granted' : 'Approval rejected'),
+                riskLevel: 'HIGH',
+                executionId,
+                decisionCode: approved ? 'ALLOWED_POLICY' : 'REJECTED_UNAUTHORIZED',
+            },
+            parametersHash: (0, capability_1.computeParametersHash)({ executionId, approverActorId, approverRole, reason }),
+            timestamp: new Date().toISOString(),
+        };
+        await this.store.appendAudit(event);
+    }
+    async recordAudit(action, context, decision, lifecycle, result, error, durationMs) {
+        const event = {
+            executionId: action.executionId || decision?.executionId || 'unknown',
+            actionId: action.actionId,
+            toolName: action.toolName,
+            companionId: context?.companionId || 'unknown',
+            actorId: context?.actor?.actorId,
+            sessionId: context?.actor?.sessionId,
+            channel: context?.conversation?.channel,
+            correlationId: context?.conversation?.correlationId,
+            riskLevel: decision?.riskLevel || 'LOW',
+            lifecycle,
+            decision,
+            parametersHash: (0, capability_1.computeParametersHash)(action.parameters),
+            resultHash: result !== undefined ? (0, capability_1.computeParametersHash)(result) : undefined,
+            timestamp: new Date().toISOString(),
+            durationMs,
+            error,
+        };
+        await this.store.appendAudit(event);
+        return event;
+    }
+    async getAuditLog() {
+        return this.store.getAuditLog();
+    }
+    getStore() {
+        return this.store;
+    }
+}
+exports.ActionPolicyEngine = ActionPolicyEngine;

package/dist/action-policy.test.d.ts

@@ -0,0 +1 @@
+export {};