@a5c-ai/agent-platform 5.0.1-staging.b436b3b3e611

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/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"}

package/dist/governance/sandboxPolicy.js

@@ -0,0 +1,177 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesPattern = matchesPattern;
+exports.evaluateSandboxAccess = evaluateSandboxAccess;
+exports.composeSandboxPolicies = composeSandboxPolicies;
+exports.attenuateSandboxPolicy = attenuateSandboxPolicy;
+// ---------------------------------------------------------------------------
+// Pattern matching
+// ---------------------------------------------------------------------------
+/**
+ * Simple glob matching supporting:
+ * - `*` matches any characters within a single path segment (no `/`)
+ * - `**` matches any characters including `/` (recursive)
+ * - Exact match
+ */
+function matchesPattern(pattern, target) {
+    // Convert glob pattern to regex
+    let regex = '';
+    let i = 0;
+    while (i < pattern.length) {
+        if (pattern[i] === '*' && pattern[i + 1] === '*') {
+            // ** matches everything including path separators
+            regex += '.*';
+            i += 2;
+            // Skip trailing slash after **
+            if (pattern[i] === '/') {
+                i++;
+            }
+        }
+        else if (pattern[i] === '*') {
+            // * matches anything except path separator
+            regex += '[^/]*';
+            i++;
+        }
+        else if (pattern[i] === '?') {
+            regex += '[^/]';
+            i++;
+        }
+        else if ('.+^${}()|[]\\'.includes(pattern[i])) {
+            regex += '\\' + pattern[i];
+            i++;
+        }
+        else {
+            regex += pattern[i];
+            i++;
+        }
+    }
+    return new RegExp('^' + regex + '$').test(target);
+}
+// ---------------------------------------------------------------------------
+// Evaluation
+// ---------------------------------------------------------------------------
+/**
+ * Evaluate a sandbox operation against a policy.
+ * Matches rules by operation kind, selects highest-priority match,
+ * falls back to defaultAction.
+ */
+function evaluateSandboxAccess(policy, operation) {
+    const matching = [];
+    for (const rule of policy.rules) {
+        if (rule.kind === operation.kind && matchesPattern(rule.pattern, operation.target)) {
+            matching.push(rule);
+        }
+    }
+    if (matching.length === 0) {
+        return {
+            action: policy.defaultAction,
+            reason: `No matching rule; default action: ${policy.defaultAction}`,
+        };
+    }
+    // Highest priority wins
+    matching.sort((a, b) => b.priority - a.priority);
+    const winner = matching[0];
+    return {
+        action: winner.action,
+        matchedRule: winner,
+        reason: `Matched rule: ${winner.kind} ${winner.pattern} → ${winner.action} (priority ${winner.priority})`,
+    };
+}
+// ---------------------------------------------------------------------------
+// Composition
+// ---------------------------------------------------------------------------
+/**
+ * Compose multiple sandbox policies with deny-overrides semantics.
+ * Block rules from any policy take precedence. Empty input yields default-deny.
+ */
+function composeSandboxPolicies(policies) {
+    if (policies.length === 0) {
+        return { rules: [], defaultAction: 'block' };
+    }
+    const allRules = [];
+    for (const policy of policies) {
+        allRules.push(...policy.rules);
+    }
+    // Deny-overrides: for rules with the same kind+pattern, if any is 'block', elevate block priority
+    const ruleKey = (r) => `${r.kind}::${r.pattern}`;
+    const grouped = new Map();
+    for (const rule of allRules) {
+        const key = ruleKey(rule);
+        const group = grouped.get(key) ?? [];
+        group.push(rule);
+        grouped.set(key, group);
+    }
+    const mergedRules = [];
+    for (const [_key, group] of grouped) {
+        const hasBlock = group.some(r => r.action === 'block');
+        if (hasBlock) {
+            // Find highest-priority block rule, or promote one
+            const blockRules = group.filter(r => r.action === 'block');
+            const maxPriority = Math.max(...group.map(r => r.priority));
+            const bestBlock = blockRules.sort((a, b) => b.priority - a.priority)[0];
+            mergedRules.push({ ...bestBlock, priority: Math.max(bestBlock.priority, maxPriority) });
+        }
+        else {
+            // No block — keep highest priority rule
+            const best = group.sort((a, b) => b.priority - a.priority)[0];
+            mergedRules.push(best);
+        }
+    }
+    // Default action: most restrictive wins
+    let defaultAction = 'allow';
+    for (const policy of policies) {
+        if (policy.defaultAction === 'block') {
+            defaultAction = 'block';
+            break;
+        }
+        if (policy.defaultAction === 'prompt') {
+            defaultAction = 'prompt';
+        }
+    }
+    return { rules: mergedRules, defaultAction };
+}
+// ---------------------------------------------------------------------------
+// Attenuation
+// ---------------------------------------------------------------------------
+/**
+ * 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.
+ */
+function attenuateSandboxPolicy(parent, childConstraints) {
+    const ruleKey = (r) => `${r.kind}::${r.pattern}`;
+    // Index parent blocks
+    const parentBlocks = new Set();
+    for (const rule of parent.rules) {
+        if (rule.action === 'block') {
+            parentBlocks.add(ruleKey(rule));
+        }
+    }
+    // Start with all parent rules
+    const resultRules = [...parent.rules];
+    for (const childRule of childConstraints.rules) {
+        const key = ruleKey(childRule);
+        if (childRule.action === 'allow' && parentBlocks.has(key)) {
+            // Child cannot expand parent blocks to allows — skip
+            continue;
+        }
+        if (childRule.action === 'block') {
+            // Child can always add or strengthen blocks
+            // Check if parent already has this block
+            const existing = resultRules.find(r => ruleKey(r) === key && r.action === 'block');
+            if (!existing) {
+                resultRules.push(childRule);
+            }
+            else if (childRule.priority > existing.priority) {
+                existing.priority = childRule.priority;
+            }
+        }
+    }
+    // Apply deny-overrides on the combined set
+    return composeSandboxPolicies([{ rules: resultRules, defaultAction: parent.defaultAction }]);
+}

package/dist/governance/types.d.ts

@@ -0,0 +1,3 @@
+export type { PolicyRuleKind, PolicyConditionOp, PolicyAction, PolicyCondition, PolicyRule, StatefulPolicyRule, PolicyEvaluationContext, PolicyDecision, PolicyDecisionLog, PolicyEngine, } from "@a5c-ai/babysitter-sdk";
+export { isStatefulRule } from "@a5c-ai/babysitter-sdk";
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/governance/types.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,cAAc,EACd,iBAAiB,EACjB,YAAY,EACZ,eAAe,EACf,UAAU,EACV,kBAAkB,EAClB,uBAAuB,EACvB,cAAc,EACd,iBAAiB,EACjB,YAAY,GACb,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/governance/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStatefulRule = void 0;
+var babysitter_sdk_1 = require("@a5c-ai/babysitter-sdk");
+Object.defineProperty(exports, "isStatefulRule", { enumerable: true, get: function () { return babysitter_sdk_1.isStatefulRule; } });