moflo 4.8.30 → 4.8.32

package/src/@claude-flow/guidance/dist/capabilities.d.ts

@@ -1,209 +0,0 @@
-/**
- * Capability Algebra
- *
- * All permissions become typed objects that can be composed, restricted,
- * delegated, revoked, and reasoned about. Supports delegation chains,
- * attestations, constraint evaluation, and set-theoretic composition
- * (intersection for actions, union for constraints).
- *
- * @module @claude-flow/guidance/capabilities
- */
-/**
- * Scope categories for capabilities
- */
-export type CapabilityScope = 'tool' | 'memory' | 'network' | 'file' | 'model' | 'system';
-/**
- * Constraint applied to a capability
- */
-export interface CapabilityConstraint {
-    /** Constraint type */
-    type: 'rate-limit' | 'budget' | 'time-window' | 'condition' | 'scope-restriction';
-    /** Type-specific parameters */
-    params: Record<string, unknown>;
-}
-/**
- * Cryptographic attestation for a capability
- */
-export interface Attestation {
-    /** ID of the attesting agent or authority */
-    attesterId: string;
-    /** When the attestation was made (ms since epoch) */
-    attestedAt: number;
-    /** Claim being attested (e.g., "agent passed security audit") */
-    claim: string;
-    /** Optional evidence supporting the claim */
-    evidence: string | null;
-    /** Signature over the claim (hex-encoded) */
-    signature: string;
-}
-/**
- * A typed permission object representing a granted capability
- */
-export interface Capability {
-    /** Unique capability identifier (UUID) */
-    id: string;
-    /** Scope category */
-    scope: CapabilityScope;
-    /** Target resource (tool name, namespace, path pattern, etc.) */
-    resource: string;
-    /** Allowed actions (e.g., 'read', 'write', 'execute', 'delete') */
-    actions: string[];
-    /** Active constraints on this capability */
-    constraints: CapabilityConstraint[];
-    /** Agent or authority that granted this capability */
-    grantedBy: string;
-    /** Agent this capability is granted to */
-    grantedTo: string;
-    /** When the capability was granted (ms since epoch) */
-    grantedAt: number;
-    /** When the capability expires, or null for no expiry */
-    expiresAt: number | null;
-    /** Whether this capability can be delegated to sub-agents */
-    delegatable: boolean;
-    /** Whether this capability has been revoked */
-    revoked: boolean;
-    /** When the capability was revoked, or null if not revoked */
-    revokedAt: number | null;
-    /** Attestations attached to this capability */
-    attestations: Attestation[];
-    /** Parent capability ID for delegation chains, or null for root grants */
-    parentCapabilityId: string | null;
-}
-/**
- * Result of evaluating a capability check
- */
-export interface CapabilityCheckResult {
-    /** Whether the requested action is allowed */
-    allowed: boolean;
-    /** Capabilities that matched the check criteria */
-    capabilities: Capability[];
-    /** Human-readable reason for the decision */
-    reason: string;
-    /** Active constraints that applied during evaluation */
-    constraints: CapabilityConstraint[];
-}
-/**
- * Capability Algebra
- *
- * Manages the lifecycle of typed capabilities: granting, restricting,
- * delegating, revoking, attesting, checking, and composing permissions.
- * All mutations produce new capability objects; the original is never
- * modified in place (except for revocation which is a state change).
- */
-export declare class CapabilityAlgebra {
-    /** All capabilities indexed by ID */
-    private readonly capabilities;
-    /** Index: agentId -> set of capability IDs */
-    private readonly agentIndex;
-    /** Index: parentCapabilityId -> set of child capability IDs */
-    private readonly delegationIndex;
-    /**
-     * Grant a new root capability.
-     *
-     * Creates a capability with no parent (it is a root grant from an
-     * authority to an agent).
-     */
-    grant(params: {
-        scope: CapabilityScope;
-        resource: string;
-        actions: string[];
-        grantedBy: string;
-        grantedTo: string;
-        constraints?: CapabilityConstraint[];
-        expiresAt?: number | null;
-        delegatable?: boolean;
-    }): Capability;
-    /**
-     * Restrict a capability, producing a new capability with tighter constraints.
-     *
-     * Restrictions can only narrow permissions, never widen them:
-     * - Actions can only be removed, never added
-     * - Constraints can only be added, never removed
-     * - Expiry can only be shortened, never extended
-     * - Delegatable can only be set to false, never promoted to true
-     */
-    restrict(capability: Capability, restrictions: Partial<Capability>): Capability;
-    /**
-     * Delegate a capability to another agent.
-     *
-     * Creates a child capability with the new grantedTo agent. The parent
-     * capability must have delegatable=true. Optional further restrictions
-     * can be applied during delegation.
-     *
-     * @throws Error if the capability is not delegatable
-     */
-    delegate(capability: Capability, toAgentId: string, restrictions?: Partial<Capability>): Capability;
-    /**
-     * Expire a capability immediately by setting expiresAt to now.
-     */
-    expire(capabilityId: string): void;
-    /**
-     * Revoke a capability and cascade revocation to all delegated children.
-     */
-    revoke(capabilityId: string, _reason?: string): void;
-    /**
-     * Add an attestation to a capability.
-     */
-    attest(capabilityId: string, attestation: Omit<Attestation, 'attestedAt'>): void;
-    /**
-     * Check whether an agent is allowed to perform an action on a resource.
-     *
-     * Finds all non-revoked, non-expired capabilities for the agent that
-     * match the requested scope and resource, checks if the requested action
-     * is allowed, and verifies all constraints are satisfied.
-     */
-    check(agentId: string, scope: CapabilityScope, resource: string, action: string, context?: Record<string, unknown>): CapabilityCheckResult;
-    /**
-     * Get all capabilities granted to a specific agent.
-     */
-    getCapabilities(agentId: string): Capability[];
-    /**
-     * Get a capability by ID.
-     */
-    getCapability(id: string): Capability | undefined;
-    /**
-     * Get the full delegation chain from root to the given capability.
-     *
-     * Returns an array ordered from the root ancestor to the given capability.
-     */
-    getDelegationChain(capabilityId: string): Capability[];
-    /**
-     * Compose two capabilities via intersection.
-     *
-     * - Actions = intersection of both action sets
-     * - Constraints = union of both constraint sets
-     * - Expiry = the tighter (earlier) of the two
-     * - Delegatable = true only if both are delegatable
-     * - Scope and resource must match; throws if they differ
-     *
-     * @throws Error if scope or resource do not match
-     */
-    compose(cap1: Capability, cap2: Capability): Capability;
-    /**
-     * Check if inner's permission set is a subset of outer's.
-     *
-     * Returns true if:
-     * - inner.scope === outer.scope
-     * - inner.resource === outer.resource
-     * - Every action in inner is present in outer
-     * - inner.expiresAt is <= outer.expiresAt (or outer has no expiry)
-     */
-    isSubset(inner: Capability, outer: Capability): boolean;
-    /**
-     * Evaluate whether all constraints on a capability are satisfied.
-     */
-    private satisfiesConstraints;
-    /**
-     * Cascade revocation to all delegated children of a capability.
-     */
-    private cascadeRevoke;
-    /**
-     * Store a capability and update indices.
-     */
-    private store;
-}
-/**
- * Create a CapabilityAlgebra instance
- */
-export declare function createCapabilityAlgebra(): CapabilityAlgebra;
-//# sourceMappingURL=capabilities.d.ts.map

package/src/@claude-flow/guidance/dist/coherence.d.ts

@@ -1,233 +0,0 @@
-/**
- * Coherence Scheduler & Economic Governor
- *
- * Detects drift in agent behavior and enforces resource budgets.
- *
- * CoherenceScheduler:
- * - Computes a coherence score from violation rate, rework, and intent drift
- * - Maps scores to privilege levels (full, restricted, read-only, suspended)
- * - Tracks score history and provides human-readable recommendations
- *
- * EconomicGovernor:
- * - Tracks token usage, tool calls, storage, and time
- * - Checks budgets and emits alerts when thresholds are crossed
- * - Estimates remaining capacity and costs
- *
- * @module @claude-flow/guidance/coherence
- */
-import type { RunEvent, OptimizationMetrics } from './types.js';
-/**
- * Coherence score computed from recent run metrics and events
- */
-export interface CoherenceScore {
-    /** Overall coherence (0-1, 1 = perfectly coherent) */
-    overall: number;
-    /** Violation component (0-1, lower violations = higher score) */
-    violationComponent: number;
-    /** Rework component (0-1, lower rework = higher score) */
-    reworkComponent: number;
-    /** Drift component (0-1, consistent intents = higher score) */
-    driftComponent: number;
-    /** Timestamp when this score was computed */
-    timestamp: number;
-    /** Number of events evaluated in the window */
-    windowSize: number;
-}
-/**
- * Thresholds for privilege level determination
- */
-export interface CoherenceThresholds {
-    /** Below this overall score the agent is restricted to read-only */
-    readOnlyThreshold: number;
-    /** Below this overall score warnings are emitted */
-    warningThreshold: number;
-    /** Above this overall score the agent has full privileges */
-    healthyThreshold: number;
-    /** Above this overall score privilege escalation is allowed */
-    privilegeEscalationThreshold: number;
-}
-/**
- * Privilege level derived from a coherence score
- */
-export type PrivilegeLevel = 'full' | 'restricted' | 'read-only' | 'suspended';
-/**
- * Budget usage breakdown across all tracked dimensions
- */
-export interface BudgetUsage {
-    tokens: {
-        used: number;
-        limit: number;
-        percentage: number;
-    };
-    toolCalls: {
-        used: number;
-        limit: number;
-        percentage: number;
-    };
-    storage: {
-        usedBytes: number;
-        limitBytes: number;
-        percentage: number;
-    };
-    time: {
-        usedMs: number;
-        limitMs: number;
-        percentage: number;
-    };
-    cost: {
-        totalUsd: number;
-        limitUsd: number;
-        percentage: number;
-    };
-}
-export interface CoherenceSchedulerConfig {
-    thresholds?: Partial<CoherenceThresholds>;
-    windowSize?: number;
-    checkIntervalMs?: number;
-}
-/**
- * Computes coherence scores from run metrics and events, determines privilege
- * levels, and provides recommendations when drift is detected.
- */
-export declare class CoherenceScheduler {
-    private readonly thresholds;
-    private readonly windowSize;
-    private readonly checkIntervalMs;
-    private readonly scoreHistory;
-    private static readonly MAX_HISTORY;
-    constructor(config?: CoherenceSchedulerConfig);
-    /**
-     * Compute a coherence score from optimization metrics and recent events.
-     *
-     * Components:
-     * - violationComponent: 1 - (violationRate / 10) clamped to [0, 1]
-     * - reworkComponent: 1 - (reworkLines / 100) clamped to [0, 1]
-     * - driftComponent: intent consistency (fewer unique intents relative to window = higher)
-     * - overall: weighted average (0.4 * violation + 0.3 * rework + 0.3 * drift)
-     */
-    computeCoherence(metrics: OptimizationMetrics, recentEvents: RunEvent[]): CoherenceScore;
-    /**
-     * Determine the privilege level from a coherence score.
-     *
-     * - overall >= healthyThreshold (0.7): 'full'
-     * - overall >= warningThreshold (0.5): 'restricted'
-     * - overall >= readOnlyThreshold (0.3): 'read-only'
-     * - below readOnlyThreshold: 'suspended'
-     */
-    getPrivilegeLevel(score: CoherenceScore): PrivilegeLevel;
-    /**
-     * Return the last 100 coherence scores (most recent last).
-     */
-    getScoreHistory(): CoherenceScore[];
-    /**
-     * Whether the score indicates healthy coherence.
-     */
-    isHealthy(score: CoherenceScore): boolean;
-    /**
-     * Whether the score indicates drift (below warning threshold).
-     */
-    isDrifting(score: CoherenceScore): boolean;
-    /**
-     * Whether the score warrants restricting agent actions.
-     */
-    shouldRestrict(score: CoherenceScore): boolean;
-    /**
-     * Produce a human-readable recommendation based on the coherence score.
-     */
-    getRecommendation(score: CoherenceScore): string;
-    /**
-     * Get the configured check interval in milliseconds.
-     */
-    get interval(): number;
-    /**
-     * Get the configured thresholds.
-     */
-    getThresholds(): CoherenceThresholds;
-}
-export interface EconomicGovernorConfig {
-    tokenLimit?: number;
-    toolCallLimit?: number;
-    storageLimit?: number;
-    timeLimit?: number;
-    costPerToken?: number;
-    costPerToolCall?: number;
-    costLimit?: number;
-}
-interface ToolCallRecord {
-    toolName: string;
-    durationMs: number;
-    timestamp: number;
-}
-/**
- * Tracks resource consumption (tokens, tool calls, storage, time, cost)
- * and enforces budget limits with alerts.
- */
-export declare class EconomicGovernor {
-    private readonly config;
-    private tokensUsed;
-    private toolCallsUsed;
-    private storageUsed;
-    private readonly toolCallLog;
-    private readonly startTime;
-    private periodStart;
-    private static readonly ALERT_THRESHOLDS;
-    constructor(config?: EconomicGovernorConfig);
-    /**
-     * Record token consumption.
-     */
-    recordTokenUsage(count: number): void;
-    /**
-     * Record a tool call with its name and duration.
-     */
-    recordToolCall(toolName: string, durationMs: number): void;
-    /**
-     * Record storage usage in bytes.
-     */
-    recordStorageUsage(bytes: number): void;
-    /**
-     * Check whether current usage is within budget limits.
-     * Returns a summary with alerts for any limits that are near or exceeded.
-     */
-    checkBudget(): {
-        withinBudget: boolean;
-        usage: BudgetUsage;
-        alerts: string[];
-    };
-    /**
-     * Get a full usage summary across all tracked dimensions.
-     */
-    getUsageSummary(): BudgetUsage;
-    /**
-     * Reset all counters for a new billing/tracking period.
-     */
-    resetPeriod(): void;
-    /**
-     * Estimate remaining capacity before hitting limits.
-     */
-    estimateRemainingCapacity(): {
-        tokensRemaining: number;
-        callsRemaining: number;
-        timeRemainingMs: number;
-    };
-    /**
-     * Compute a cost estimate with a breakdown by category.
-     */
-    getCostEstimate(): {
-        totalCost: number;
-        breakdown: Record<string, number>;
-    };
-    /**
-     * Get the raw tool call log.
-     */
-    getToolCallLog(): ReadonlyArray<ToolCallRecord>;
-}
-/**
- * Create a CoherenceScheduler with optional configuration.
- */
-export declare function createCoherenceScheduler(config?: CoherenceSchedulerConfig): CoherenceScheduler;
-/**
- * Create an EconomicGovernor with optional configuration.
- */
-export declare function createEconomicGovernor(config?: EconomicGovernorConfig): EconomicGovernor;
-export {};
-//# sourceMappingURL=coherence.d.ts.map

package/src/@claude-flow/guidance/dist/compiler.d.ts

@@ -1,87 +0,0 @@
-/**
- * Guidance Compiler
- *
- * Parses root CLAUDE.md and optional CLAUDE.local.md into a compiled policy bundle:
- * 1. A small always-loaded constitution (first 30-60 lines of invariants)
- * 2. A set of task-scoped rule shards tagged by intent, risk, domain, repo path, tool class
- * 3. A machine-readable manifest with rule IDs, triggers, and verifiers
- *
- * @module @claude-flow/guidance/compiler
- */
-import type { GuidanceRule, PolicyBundle, RiskClass } from './types.js';
-export interface CompilerConfig {
-    /** Maximum lines for constitution */
-    maxConstitutionLines: number;
-    /** Default risk class */
-    defaultRiskClass: RiskClass;
-    /** Default priority */
-    defaultPriority: number;
-    /** Auto-generate rule IDs for untagged rules */
-    autoGenerateIds: boolean;
-}
-export declare class GuidanceCompiler {
-    private config;
-    private nextAutoId;
-    constructor(config?: Partial<CompilerConfig>);
-    /**
-     * Compile guidance files into a policy bundle
-     */
-    compile(rootContent: string, localContent?: string): PolicyBundle;
-    /**
-     * Parse a guidance markdown file into rules
-     */
-    parseGuidanceFile(content: string, source: 'root' | 'local'): GuidanceRule[];
-    /**
-     * Extract rules from a content block
-     */
-    private extractRulesFromBlock;
-    /**
-     * Extract implicit rules from bullet points and paragraphs
-     */
-    private extractImplicitRules;
-    /**
-     * Check if text represents an actionable rule
-     */
-    private isActionableRule;
-    /**
-     * Parse a single rule from its text content
-     */
-    private parseRule;
-    /**
-     * Infer intents from rule text
-     */
-    private inferIntents;
-    /**
-     * Infer domains from rule text
-     */
-    private inferDomains;
-    /**
-     * Merge root and local rules, local overrides root for same ID
-     */
-    private mergeRules;
-    /**
-     * Build the constitution from constitution-class rules
-     */
-    private buildConstitution;
-    /**
-     * Build shards from non-constitution rules
-     */
-    private buildShards;
-    /**
-     * Build compact text for a shard
-     */
-    private buildCompactShardText;
-    /**
-     * Build the manifest
-     */
-    private buildManifest;
-    /**
-     * Hash content for change detection
-     */
-    private hashContent;
-}
-/**
- * Create a compiler instance
- */
-export declare function createCompiler(config?: Partial<CompilerConfig>): GuidanceCompiler;
-//# sourceMappingURL=compiler.d.ts.map