@a5c-ai/genty-platform 5.1.1-staging.00ceebd28cf2

package/dist/governance/permissionEvents.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * Permission event creation, aggregation, and filtering for the governance layer.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPermissionEvent = createPermissionEvent;
+exports.aggregateChainEvents = aggregateChainEvents;
+exports.filterEvents = filterEvents;
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+function createPermissionEvent(options) {
+    return {
+        kind: options.kind,
+        operation: options.operation,
+        decision: options.decision,
+        timestamp: options.timestamp ?? new Date().toISOString(),
+        source: options.source,
+        ...(options.mandateId !== undefined ? { mandateId: options.mandateId } : {}),
+        ...(options.chainId !== undefined ? { chainId: options.chainId } : {}),
+    };
+}
+// ---------------------------------------------------------------------------
+// Aggregation
+// ---------------------------------------------------------------------------
+/**
+ * Flatten multiple event arrays (from parent/child runs), filter by chainId,
+ * and sort chronologically.
+ */
+function aggregateChainEvents(chainId, eventArrays) {
+    const all = [];
+    for (const arr of eventArrays) {
+        for (const ev of arr) {
+            if (ev.chainId === chainId) {
+                all.push(ev);
+            }
+        }
+    }
+    all.sort((a, b) => (a.timestamp < b.timestamp ? -1 : a.timestamp > b.timestamp ? 1 : 0));
+    return all;
+}
+function filterEvents(events, criteria) {
+    return events.filter((ev) => {
+        if (criteria.source !== undefined && ev.source !== criteria.source)
+            return false;
+        if (criteria.action !== undefined && ev.decision.action !== criteria.action)
+            return false;
+        if (criteria.kind !== undefined && ev.kind !== criteria.kind)
+            return false;
+        return true;
+    });
+}

package/dist/governance/permissionPropagation.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Permission event propagation: formatting for different output targets
+ * and configuration for which event kinds propagate to which targets.
+ */
+import type { PermissionEvent } from './permissionEvents';
+export interface PropagationTarget {
+    name: string;
+    kinds: string[];
+}
+export interface PropagationConfig {
+    targets: PropagationTarget[];
+}
+export declare function formatPermissionForTui(event: PermissionEvent): string;
+export declare function formatPermissionForJsonStream(event: PermissionEvent): PermissionEvent;
+export declare function formatPermissionForCli(event: PermissionEvent): string;
+export declare function createPropagationConfig(targets: PropagationTarget[]): PropagationConfig;
+export declare function shouldPropagate(event: PermissionEvent, targetName: string, config: PropagationConfig): boolean;
+//# sourceMappingURL=permissionPropagation.d.ts.map

package/dist/governance/permissionPropagation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissionPropagation.d.ts","sourceRoot":"","sources":["../../src/governance/permissionPropagation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAM1D,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,iBAAiB,EAAE,CAAC;CAC9B;AA4BD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAIrE;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,eAAe,GAAG,eAAe,CAGrF;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAGrE;AAMD,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,iBAAiB,EAAE,GAAG,iBAAiB,CAEvF;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,eAAe,EACtB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,iBAAiB,GACxB,OAAO,CAIT"}

package/dist/governance/permissionPropagation.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Permission event propagation: formatting for different output targets
+ * and configuration for which event kinds propagate to which targets.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPermissionForTui = formatPermissionForTui;
+exports.formatPermissionForJsonStream = formatPermissionForJsonStream;
+exports.formatPermissionForCli = formatPermissionForCli;
+exports.createPropagationConfig = createPropagationConfig;
+exports.shouldPropagate = shouldPropagate;
+// ---------------------------------------------------------------------------
+// ANSI helpers
+// ---------------------------------------------------------------------------
+const RESET = '\x1b[0m';
+const RED = '\x1b[31m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+function colorForAction(action) {
+    switch (action) {
+        case 'block':
+            return RED;
+        case 'allow':
+            return GREEN;
+        case 'prompt':
+            return YELLOW;
+        default:
+            return '';
+    }
+}
+// ---------------------------------------------------------------------------
+// Formatters
+// ---------------------------------------------------------------------------
+function formatPermissionForTui(event) {
+    const color = colorForAction(event.decision.action);
+    const target = event.operation.target ?? '';
+    return `${color}[${event.decision.action}]${RESET} ${event.kind} ${target}`;
+}
+function formatPermissionForJsonStream(event) {
+    // Return a clean copy with all fields — already JSON-serializable
+    return { ...event };
+}
+function formatPermissionForCli(event) {
+    const target = event.operation.target ?? '';
+    return `${event.decision.action} ${event.kind} ${target}`;
+}
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+function createPropagationConfig(targets) {
+    return { targets };
+}
+function shouldPropagate(event, targetName, config) {
+    const target = config.targets.find((t) => t.name === targetName);
+    if (!target)
+        return false;
+    return target.kinds.includes(event.kind);
+}

package/dist/governance/postureBridge.d.ts

@@ -0,0 +1,17 @@
+/**
+ * GAP-SEC: Posture-to-Policy Bridge.
+ *
+ * Converts breakpoint approval postures into governance PolicyRule[] so they
+ * can be evaluated by the unified policy engine.
+ */
+import type { ActionCategory, ApprovalPosture } from "@a5c-ai/babysitter-sdk";
+import type { PolicyRule } from './types';
+/**
+ * Convert a single posture for a given action category into PolicyRule[].
+ */
+export declare function postureToPolicyRules(category: ActionCategory, posture: ApprovalPosture): PolicyRule[];
+/**
+ * Convert all DEFAULT_POSTURES (optionally overridden) into a sorted PolicyRule[].
+ */
+export declare function allPosturesToPolicies(overrides?: Partial<Record<ActionCategory, Partial<ApprovalPosture>>>): PolicyRule[];
+//# sourceMappingURL=postureBridge.d.ts.map

package/dist/governance/postureBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postureBridge.d.ts","sourceRoot":"","sources":["../../src/governance/postureBridge.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAqB1C;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,cAAc,EACxB,OAAO,EAAE,eAAe,GACvB,UAAU,EAAE,CAwEd;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,GACpE,UAAU,EAAE,CAed"}

package/dist/governance/postureBridge.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * GAP-SEC: Posture-to-Policy Bridge.
+ *
+ * Converts breakpoint approval postures into governance PolicyRule[] so they
+ * can be evaluated by the unified policy engine.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postureToPolicyRules = postureToPolicyRules;
+exports.allPosturesToPolicies = allPosturesToPolicies;
+const postures_1 = require("../breakpoints/postures");
+// ---------------------------------------------------------------------------
+// Priority map by posture name
+// ---------------------------------------------------------------------------
+const POSTURE_PRIORITY = {
+    locked: 200,
+    guarded: 150,
+    cautious: 100,
+    permissive: 50,
+};
+function priorityForPosture(posture) {
+    return POSTURE_PRIORITY[posture.name] ?? 75;
+}
+// ---------------------------------------------------------------------------
+// Core functions
+// ---------------------------------------------------------------------------
+/**
+ * Convert a single posture for a given action category into PolicyRule[].
+ */
+function postureToPolicyRules(category, posture) {
+    const rules = [];
+    const basePriority = priorityForPosture(posture);
+    if (!posture.allowAutoApprove) {
+        // Locked: deny auto-approval entirely
+        rules.push({
+            id: `posture:${category}:deny-auto-approve`,
+            kind: 'permission',
+            condition: { field: 'labels', op: 'contains', value: category },
+            action: 'deny',
+            priority: basePriority,
+            metadata: {
+                source: 'posture-bridge',
+                category,
+                postureName: posture.name,
+                requiredApproverLevel: posture.requiredApproverLevel ?? 'any',
+                minConsecutiveApprovals: String(posture.minConsecutiveApprovalsForAutoN),
+            },
+        });
+    }
+    else if (posture.requireExplicitRule) {
+        // Guarded: warn (require explicit rule)
+        rules.push({
+            id: `posture:${category}:require-explicit-rule`,
+            kind: 'permission',
+            condition: { field: 'labels', op: 'contains', value: category },
+            action: 'warn',
+            priority: basePriority,
+            metadata: {
+                source: 'posture-bridge',
+                category,
+                postureName: posture.name,
+                requireExplicitRule: 'true',
+                minConsecutiveApprovals: String(posture.minConsecutiveApprovalsForAutoN),
+            },
+        });
+    }
+    else {
+        // Cautious or permissive: allow
+        rules.push({
+            id: `posture:${category}:allow-auto-approve`,
+            kind: 'permission',
+            condition: { field: 'labels', op: 'contains', value: category },
+            action: 'allow',
+            priority: basePriority,
+            metadata: {
+                source: 'posture-bridge',
+                category,
+                postureName: posture.name,
+                minConsecutiveApprovals: String(posture.minConsecutiveApprovalsForAutoN),
+            },
+        });
+    }
+    // If the posture has minConsecutiveApprovalsForAutoN > 0 and allows auto-approve,
+    // add an advisory warn rule for the threshold
+    if (posture.allowAutoApprove && posture.minConsecutiveApprovalsForAutoN > 0) {
+        rules.push({
+            id: `posture:${category}:consecutive-threshold`,
+            kind: 'resource-limit',
+            condition: { field: 'labels', op: 'contains', value: category },
+            action: 'warn',
+            priority: basePriority - 1,
+            metadata: {
+                source: 'posture-bridge',
+                category,
+                postureName: posture.name,
+                minConsecutiveApprovals: String(posture.minConsecutiveApprovalsForAutoN),
+            },
+        });
+    }
+    return rules;
+}
+/**
+ * Convert all DEFAULT_POSTURES (optionally overridden) into a sorted PolicyRule[].
+ */
+function allPosturesToPolicies(overrides) {
+    const categories = ['read', 'write', 'execute', 'destroy', 'network', 'auth'];
+    const allRules = [];
+    for (const category of categories) {
+        const base = postures_1.DEFAULT_POSTURES[category];
+        const categoryOverrides = overrides?.[category];
+        const posture = categoryOverrides ? { ...base, ...categoryOverrides } : base;
+        allRules.push(...postureToPolicyRules(category, posture));
+    }
+    // Sort by priority descending
+    allRules.sort((a, b) => b.priority - a.priority);
+    return allRules;
+}

package/dist/governance/privacySettings.d.ts

@@ -0,0 +1,31 @@
+/**
+ * GAP-SEC-007: Privacy Settings.
+ *
+ * Defines privacy levels and filtering logic for controlling what
+ * telemetry, log data, and file contents are collected or shared.
+ */
+export type PrivacyLevel = 'full' | 'redacted' | 'anonymous' | 'off';
+export interface PrivacySettings {
+    /** Level of telemetry data collection. */
+    telemetryLevel: PrivacyLevel;
+    /** Level of log data retention. */
+    logLevel: PrivacyLevel;
+    /** Whether file contents may be included in telemetry/logs. */
+    includeFileContents: boolean;
+    /** Whether file paths may be included. */
+    includePaths: boolean;
+    /** Whether session data may be shared externally. */
+    shareSessionData: boolean;
+}
+export declare const DEFAULT_PRIVACY_SETTINGS: Readonly<PrivacySettings>;
+/**
+ * Apply privacy filtering to a data object.
+ * Returns a new object with sensitive fields redacted according to settings.
+ */
+export declare function applyPrivacyFilter(data: Record<string, unknown>, settings: PrivacySettings): Record<string, unknown>;
+/**
+ * Determine whether a telemetry/log event should be collected
+ * given the current privacy settings.
+ */
+export declare function shouldCollect(eventType: string, settings: PrivacySettings): boolean;
+//# sourceMappingURL=privacySettings.d.ts.map

package/dist/governance/privacySettings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"privacySettings.d.ts","sourceRoot":"","sources":["../../src/governance/privacySettings.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,KAAK,CAAC;AAErE,MAAM,WAAW,eAAe;IAC9B,0CAA0C;IAC1C,cAAc,EAAE,YAAY,CAAC;IAC7B,mCAAmC;IACnC,QAAQ,EAAE,YAAY,CAAC;IACvB,+DAA+D;IAC/D,mBAAmB,EAAE,OAAO,CAAC;IAC7B,0CAA0C;IAC1C,YAAY,EAAE,OAAO,CAAC;IACtB,qDAAqD;IACrD,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAMD,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,eAAe,CAM7D,CAAC;AAuBH;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,QAAQ,EAAE,eAAe,GACxB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAiDzB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,eAAe,GACxB,OAAO,CAUT"}

package/dist/governance/privacySettings.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * GAP-SEC-007: Privacy Settings.
+ *
+ * Defines privacy levels and filtering logic for controlling what
+ * telemetry, log data, and file contents are collected or shared.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PRIVACY_SETTINGS = void 0;
+exports.applyPrivacyFilter = applyPrivacyFilter;
+exports.shouldCollect = shouldCollect;
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+exports.DEFAULT_PRIVACY_SETTINGS = Object.freeze({
+    telemetryLevel: 'redacted',
+    logLevel: 'redacted',
+    includeFileContents: false,
+    includePaths: true,
+    shareSessionData: false,
+});
+// ---------------------------------------------------------------------------
+// Sensitive field patterns
+// ---------------------------------------------------------------------------
+const SENSITIVE_KEYS = new Set([
+    'password', 'secret', 'token', 'apiKey', 'api_key',
+    'accessToken', 'access_token', 'refreshToken', 'refresh_token',
+    'authorization', 'credentials', 'private_key', 'privateKey',
+    'cookie', 'session_id', 'sessionId', 'ssn', 'credit_card',
+]);
+function isSensitiveKey(key) {
+    return SENSITIVE_KEYS.has(key) ||
+        SENSITIVE_KEYS.has(key.toLowerCase()) ||
+        /password|secret|token|key|credential/i.test(key);
+}
+// ---------------------------------------------------------------------------
+// Functions
+// ---------------------------------------------------------------------------
+/**
+ * Apply privacy filtering to a data object.
+ * Returns a new object with sensitive fields redacted according to settings.
+ */
+function applyPrivacyFilter(data, settings) {
+    if (settings.telemetryLevel === 'off') {
+        return {};
+    }
+    if (settings.telemetryLevel === 'full') {
+        return { ...data };
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+        // Redact sensitive keys
+        if (isSensitiveKey(key)) {
+            if (settings.telemetryLevel === 'anonymous') {
+                continue; // drop entirely
+            }
+            result[key] = '[REDACTED]';
+            continue;
+        }
+        // Handle file paths
+        if (!settings.includePaths && typeof value === 'string' && looksLikePath(value)) {
+            result[key] = '[PATH_REDACTED]';
+            continue;
+        }
+        // Handle file contents
+        if (!settings.includeFileContents && key === 'fileContents') {
+            result[key] = '[CONTENT_REDACTED]';
+            continue;
+        }
+        // Recurse into nested objects
+        if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+            result[key] = applyPrivacyFilter(value, settings);
+            continue;
+        }
+        // In anonymous mode, strip string values that might contain PII
+        if (settings.telemetryLevel === 'anonymous' && typeof value === 'string') {
+            result[key] = '[ANONYMOUS]';
+            continue;
+        }
+        result[key] = value;
+    }
+    return result;
+}
+/**
+ * Determine whether a telemetry/log event should be collected
+ * given the current privacy settings.
+ */
+function shouldCollect(eventType, settings) {
+    if (settings.telemetryLevel === 'off')
+        return false;
+    // Session sharing events require explicit opt-in
+    if (eventType === 'session_share' && !settings.shareSessionData)
+        return false;
+    // File content events require includeFileContents
+    if (eventType === 'file_content' && !settings.includeFileContents)
+        return false;
+    return true;
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function looksLikePath(value) {
+    return /^(\/|[A-Z]:\\|~\/)/.test(value) || /\.(ts|js|json|md|py|go|rs)$/.test(value);
+}

package/dist/governance/sandboxBridge.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Sandbox-to-governance bridge (GAP-SEC-002).
+ * Converts sandbox decisions into interaction requests and governance events,
+ * and derives child sandbox policies from mandate scopes.
+ */
+import type { SandboxDecision, SandboxOperation, SandboxPolicy } from './sandboxPolicy';
+export interface SandboxEvent {
+    kind: string;
+    operation: SandboxOperation;
+    decision: SandboxDecision;
+    timestamp: string;
+    source: string;
+    mandateId?: string;
+}
+export interface SandboxInteraction {
+    kind: 'approval';
+    operationKind?: string;
+    operationTarget?: string;
+    reason?: string;
+}
+interface BuildSandboxEventOptions {
+    mandateId?: string;
+    source?: string;
+}
+interface MandateScopeLike {
+    allowedEffectKinds: string[];
+    maxIterations: number;
+    maxConcurrentTasks: number;
+    timeoutMs: number;
+}
+/**
+ * Convert a sandbox decision to an interaction request.
+ * Returns null for allow/block (no human input needed), returns an approval
+ * interaction for prompt decisions.
+ */
+export declare function sandboxDecisionToInteraction(decision: SandboxDecision, operation?: SandboxOperation): SandboxInteraction | null;
+/**
+ * Build a SandboxEvent with auto-timestamp and default source.
+ */
+export declare function buildSandboxEvent(operation: SandboxOperation, decision: SandboxDecision, options?: BuildSandboxEventOptions): SandboxEvent;
+/**
+ * Derive a child sandbox policy from a parent policy respecting mandate scope.
+ * - All parent block rules are always inherited.
+ * - Allow/prompt rules are only inherited if their kind is within the mandate's
+ *   allowedEffectKinds (or if allowedEffectKinds contains '*').
+ */
+export declare function inheritSandboxPolicy(parentPolicy: SandboxPolicy, mandateScope: MandateScopeLike): SandboxPolicy;
+export {};
+//# sourceMappingURL=sandboxBridge.d.ts.map

package/dist/governance/sandboxBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandboxBridge.d.ts","sourceRoot":"","sources":["../../src/governance/sandboxBridge.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EAChB,aAAa,EAEd,MAAM,iBAAiB,CAAC;AAMzB,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,gBAAgB,CAAC;IAC5B,QAAQ,EAAE,eAAe,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,UAAU,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,wBAAwB;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,gBAAgB;IACxB,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;CACnB;AAMD;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,eAAe,EACzB,SAAS,CAAC,EAAE,gBAAgB,GAC3B,kBAAkB,GAAG,IAAI,CAmB3B;AAMD;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,gBAAgB,EAC3B,QAAQ,EAAE,eAAe,EACzB,OAAO,CAAC,EAAE,wBAAwB,GACjC,YAAY,CASd;AAMD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,aAAa,EAC3B,YAAY,EAAE,gBAAgB,GAC7B,aAAa,CAmBf"}

package/dist/governance/sandboxBridge.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Sandbox-to-governance bridge (GAP-SEC-002).
+ * Converts sandbox decisions into interaction requests and governance events,
+ * and derives child sandbox policies from mandate scopes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sandboxDecisionToInteraction = sandboxDecisionToInteraction;
+exports.buildSandboxEvent = buildSandboxEvent;
+exports.inheritSandboxPolicy = inheritSandboxPolicy;
+// ---------------------------------------------------------------------------
+// Decision → Interaction
+// ---------------------------------------------------------------------------
+/**
+ * Convert a sandbox decision to an interaction request.
+ * Returns null for allow/block (no human input needed), returns an approval
+ * interaction for prompt decisions.
+ */
+function sandboxDecisionToInteraction(decision, operation) {
+    if (decision.action !== 'prompt') {
+        return null;
+    }
+    const interaction = {
+        kind: 'approval',
+    };
+    if (operation) {
+        interaction.operationKind = operation.kind;
+        interaction.operationTarget = operation.target;
+    }
+    if (decision.reason) {
+        interaction.reason = decision.reason;
+    }
+    return interaction;
+}
+// ---------------------------------------------------------------------------
+// Event factory
+// ---------------------------------------------------------------------------
+/**
+ * Build a SandboxEvent with auto-timestamp and default source.
+ */
+function buildSandboxEvent(operation, decision, options) {
+    return {
+        kind: `sandbox.${operation.kind}`,
+        operation,
+        decision,
+        timestamp: new Date().toISOString(),
+        source: options?.source ?? 'sandbox',
+        ...(options?.mandateId ? { mandateId: options.mandateId } : {}),
+    };
+}
+// ---------------------------------------------------------------------------
+// Policy inheritance from mandate scope
+// ---------------------------------------------------------------------------
+/**
+ * Derive a child sandbox policy from a parent policy respecting mandate scope.
+ * - All parent block rules are always inherited.
+ * - Allow/prompt rules are only inherited if their kind is within the mandate's
+ *   allowedEffectKinds (or if allowedEffectKinds contains '*').
+ */
+function inheritSandboxPolicy(parentPolicy, mandateScope) {
+    const allowAll = mandateScope.allowedEffectKinds.includes('*');
+    const childRules = [];
+    for (const rule of parentPolicy.rules) {
+        if (rule.action === 'block') {
+            // Always inherit blocks
+            childRules.push({ ...rule });
+        }
+        else if (allowAll || mandateScope.allowedEffectKinds.includes(rule.kind)) {
+            // Only inherit allow/prompt if mandate permits this kind
+            childRules.push({ ...rule });
+        }
+    }
+    return {
+        rules: childRules,
+        defaultAction: parentPolicy.defaultAction,
+    };
+}

package/dist/governance/sandboxPolicy.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Sandbox policy evaluation for tool/operation sandboxing (GAP-SEC-002).
+ * Provides glob-based rule matching, policy composition with deny-overrides,
+ * and policy attenuation for child scopes.
+ */
+export type SandboxOperationKind = 'fs.read' | 'fs.write' | 'fs.delete' | 'net.outbound' | 'net.inbound' | 'exec.shell' | 'exec.process';
+export interface SandboxRule {
+    kind: SandboxOperationKind;
+    pattern: string;
+    action: 'allow' | 'block' | 'prompt';
+    priority: number;
+}
+export interface SandboxPolicy {
+    rules: SandboxRule[];
+    defaultAction: 'allow' | 'block' | 'prompt';
+}
+export interface SandboxDecision {
+    action: 'allow' | 'block' | 'prompt';
+    matchedRule?: SandboxRule;
+    reason: string;
+}
+export interface SandboxOperation {
+    kind: SandboxOperationKind;
+    target: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Simple glob matching supporting:
+ * - `*` matches any characters within a single path segment (no `/`)
+ * - `**` matches any characters including `/` (recursive)
+ * - Exact match
+ */
+export declare function matchesPattern(pattern: string, target: string): boolean;
+/**
+ * Evaluate a sandbox operation against a policy.
+ * Matches rules by operation kind, selects highest-priority match,
+ * falls back to defaultAction.
+ */
+export declare function evaluateSandboxAccess(policy: SandboxPolicy, operation: SandboxOperation): SandboxDecision;
+/**
+ * Compose multiple sandbox policies with deny-overrides semantics.
+ * Block rules from any policy take precedence. Empty input yields default-deny.
+ */
+export declare function composeSandboxPolicies(policies: SandboxPolicy[]): SandboxPolicy;
+/**
+ * Attenuate a parent policy with child constraints.
+ * The child can only narrow permissions: block additions are kept,
+ * allow rules that conflict with parent blocks are dropped.
+ */
+export declare function attenuateSandboxPolicy(parent: SandboxPolicy, childConstraints: SandboxPolicy): SandboxPolicy;
+//# sourceMappingURL=sandboxPolicy.d.ts.map

package/dist/governance/sandboxPolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandboxPolicy.d.ts","sourceRoot":"","sources":["../../src/governance/sandboxPolicy.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,MAAM,MAAM,oBAAoB,GAC5B,SAAS,GACT,UAAU,GACV,WAAW,GACX,cAAc,GACd,aAAa,GACb,YAAY,GACZ,cAAc,CAAC;AAEnB,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,oBAAoB,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,OAAO,GAAG,OAAO,GAAG,QAAQ,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,aAAa,EAAE,OAAO,GAAG,OAAO,GAAG,QAAQ,CAAC;CAC7C;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,OAAO,GAAG,OAAO,GAAG,QAAQ,CAAC;IACrC,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,oBAAoB,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAMD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CA8BvE;AAMD;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,aAAa,EACrB,SAAS,EAAE,gBAAgB,GAC1B,eAAe,CAyBjB;AAMD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,aAAa,CAiD/E;AAMD;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,aAAa,EACrB,gBAAgB,EAAE,aAAa,GAC9B,aAAa,CAoCf"}