@a5c-ai/agent-platform 5.0.1-staging.016f0b0e8119

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; } });

package/dist/harness/amux/amuxBridge.d.ts

@@ -0,0 +1,71 @@
+/**
+ * agent-mux integration bridge for agent-platform.
+ *
+ * Replaces the direct child-process invocation in `invoker.ts` for
+ * external harnesses by delegating to an AmuxClient instance. The
+ * client is injected so agent-platform never imports @agent-mux/core
+ * directly -- it only depends on the interfaces defined in amuxTypes.ts.
+ *
+ * @module harness/amux/amuxBridge
+ */
+import type { HarnessInvokeOptions, HarnessInvokeResult } from "../types";
+import type { AmuxClient } from "./amuxTypes";
+import { type BabysitterEvent } from "./amuxEventMapper";
+/**
+ * Options that extend the standard HarnessInvokeOptions with fields
+ * specific to the agent-mux bridge.
+ */
+export interface AmuxBridgeOptions extends HarnessInvokeOptions {
+    /** Session ID for session resumption via agent-mux. */
+    sessionId?: string;
+    /** Whether to suppress interactive prompts (yolo mode). */
+    nonInteractive?: boolean;
+    /** Maximum agent turns before force-stop. */
+    maxTurns?: number;
+    /** Hook configuration forwarded to the agent. */
+    hooks?: unknown;
+    /** Skills to enable for this run. */
+    skills?: string[];
+}
+/**
+ * Extended result that includes agent-mux-specific metadata on top of
+ * the standard HarnessInvokeResult.
+ */
+export interface AmuxBridgeResult extends HarnessInvokeResult {
+    /** Session ID returned by agent-mux (for session resumption). */
+    sessionId?: string;
+    /** Accumulated cost from cost events. */
+    totalCost: number;
+    /** All babysitter-mapped events collected during the run. */
+    events: BabysitterEvent[];
+    /** The last assistant text message accumulated from text_delta events. */
+    lastMessage: string;
+}
+/**
+ * Optional callback invoked for each mapped babysitter event during
+ * stream consumption. Useful for live governance checks, cost tracking,
+ * and webhook forwarding without waiting for the full run to complete.
+ */
+export type AmuxEventCallback = (event: BabysitterEvent) => void | Promise<void>;
+/**
+ * Invoke a harness through agent-mux instead of spawning the CLI directly.
+ *
+ * The function:
+ *   1. Maps the babysitter harness name to an agent-mux adapter name.
+ *   2. Calls `client.run()` with the translated options.
+ *   3. Consumes the async event stream, mapping each AgentEvent to a
+ *      BabysitterEvent.
+ *   4. Accumulates text deltas, cost totals, and error state.
+ *   5. Returns an AmuxBridgeResult compatible with HarnessInvokeResult.
+ *
+ * @param client      - AmuxClient instance (injected, no hard dep on @agent-mux/core).
+ * @param harness     - babysitter harness name (e.g. "claude-code", "codex").
+ * @param options     - Invocation options.
+ * @param onEvent     - Optional per-event callback for live processing.
+ * @returns Promise resolving to the bridge result.
+ *
+ * @throws {Error} if `harness` is "pi" / "internal" (use agent-core).
+ * @throws {Error} if the harness has no agent-mux adapter mapping.
+ */
+export declare function invokeViaAgentMux(client: AmuxClient, harness: string, options: AmuxBridgeOptions, onEvent?: AmuxEventCallback): Promise<AmuxBridgeResult>;
+//# sourceMappingURL=amuxBridge.d.ts.map

package/dist/harness/amux/amuxBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"amuxBridge.d.ts","sourceRoot":"","sources":["../../../src/harness/amux/amuxBridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAC1E,OAAO,KAAK,EACV,UAAU,EAEX,MAAM,aAAa,CAAC;AAErB,OAAO,EAIL,KAAK,eAAe,EACrB,MAAM,mBAAmB,CAAC;AAM3B;;;GAGG;AACH,MAAM,WAAW,iBAAkB,SAAQ,oBAAoB;IAC7D,uDAAuD;IACvD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2DAA2D;IAC3D,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,qCAAqC;IACrC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAiB,SAAQ,mBAAmB;IAC3D,iEAAiE;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yCAAyC;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,0EAA0E;IAC1E,WAAW,EAAE,MAAM,CAAC;CACrB;AAMD;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAMjF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,iBAAiB,EAC1B,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,gBAAgB,CAAC,CAuF3B"}