moflo 4.8.31 → 4.8.32

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

@@ -1,426 +0,0 @@
-/**
- * Temporal Assertions and Validity Windows
- *
- * Bitemporal semantics for knowledge: distinguishes *assertion time* (when
- * something was recorded) from *validity time* (when the fact is/was/will be
- * true in the real world).
- *
- * The system tracks two independent timelines:
- * - Assertion time: when the assertion was recorded and when it was retracted
- * - Validity time: when the fact becomes true (validFrom) and stops being true
- *   (validUntil)
- *
- * Every assertion carries `validFrom`, `validUntil`, `assertedAt`, and
- * `supersededBy` fields. Status is computed dynamically from the current clock
- * and the assertion's lifecycle flags (retraction, supersession, expiration).
- *
- * TemporalStore:
- * - Creates assertions with explicit validity windows
- * - Retrieves assertions active at any point in time (past, present, future)
- * - Supports supersession chains (old fact replaced by new fact)
- * - Soft-delete via retraction (preserves full history)
- * - Conflict detection: finds multiple active assertions in the same namespace
- * - Export/import for persistence
- *
- * TemporalReasoner:
- * - High-level queries: whatWasTrue, whatIsTrue, whatWillBeTrue
- * - Change detection since a given timestamp
- * - Conflict detection at a point in time
- * - Forward projection of assertion validity
- *
- * @module @claude-flow/guidance/temporal
- */
-/**
- * Computed lifecycle status of a temporal assertion.
- *
- * - future: the validity window has not yet opened (validFrom > now)
- * - active: the assertion is currently valid (validFrom <= now < validUntil)
- * - expired: the validity window has closed (validUntil <= now)
- * - superseded: replaced by a newer assertion
- * - retracted: explicitly withdrawn (soft-deleted, history preserved)
- */
-export type TemporalStatus = 'future' | 'active' | 'expired' | 'superseded' | 'retracted';
-/**
- * The temporal window describing when a fact is valid and when it was recorded.
- */
-export interface ValidityWindow {
-    /** Unix timestamp (ms) when the fact becomes true in the real world */
-    validFrom: number;
-    /** Unix timestamp (ms) when the fact stops being true, or null for indefinite */
-    validUntil: number | null;
-    /** Unix timestamp (ms) when the assertion was recorded in the system */
-    assertedAt: number;
-    /** Unix timestamp (ms) when the assertion was retracted, or null if still standing */
-    retractedAt: number | null;
-}
-/**
- * A single temporal assertion: a claim with an explicit validity window,
- * supersession chain, confidence, and provenance metadata.
- */
-export interface TemporalAssertion {
-    /** Unique assertion identifier (UUID v4) */
-    id: string;
-    /** The claim being asserted, in natural language */
-    claim: string;
-    /** Namespace for grouping related assertions */
-    namespace: string;
-    /** The temporal validity window */
-    window: ValidityWindow;
-    /** Computed lifecycle status (derived from window + retraction + supersession) */
-    status: TemporalStatus;
-    /** ID of the assertion that replaced this one, or null */
-    supersededBy: string | null;
-    /** ID of the assertion that this one replaces, or null */
-    supersedes: string | null;
-    /** Confidence in the assertion (0.0 - 1.0) */
-    confidence: number;
-    /** Who or what made this assertion */
-    source: string;
-    /** Searchable tags */
-    tags: string[];
-    /** Arbitrary metadata */
-    metadata: Record<string, unknown>;
-}
-/**
- * Query options for filtering temporal assertions.
- */
-export interface TemporalQuery {
-    /** Filter by namespace */
-    namespace?: string;
-    /** Return only assertions active at this point in time */
-    pointInTime?: number;
-    /** Filter by status (any match) */
-    status?: TemporalStatus[];
-    /** Filter by source */
-    source?: string;
-    /** Filter by tags (all must be present) */
-    tags?: string[];
-}
-/**
- * Configuration for the TemporalStore.
- */
-export interface TemporalConfig {
-    /** Maximum number of assertions to store (default 100000) */
-    maxAssertions: number;
-    /** Interval (ms) for auto-expire status checks (default 60000) */
-    autoExpireCheckIntervalMs: number;
-}
-/**
- * A full timeline for an assertion: its predecessors and successors in the
- * supersession chain.
- */
-export interface TemporalTimeline {
-    /** The assertion at the center of the timeline */
-    assertion: TemporalAssertion;
-    /** Assertions that were replaced leading up to this one (oldest first) */
-    predecessors: TemporalAssertion[];
-    /** Assertions that replaced this one (newest last) */
-    successors: TemporalAssertion[];
-}
-/**
- * A detected change in the temporal store since a given timestamp.
- */
-export interface TemporalChange {
-    /** The assertion that changed */
-    assertion: TemporalAssertion;
-    /** The kind of change */
-    changeType: 'asserted' | 'superseded' | 'retracted' | 'expired';
-    /** When the change occurred (assertion time, retraction time, etc.) */
-    changedAt: number;
-}
-/**
- * Optional parameters when creating a new assertion.
- */
-export interface AssertOptions {
-    /** Custom assertion ID (default: auto-generated UUID) */
-    id?: string;
-    /** Confidence in the assertion (0.0 - 1.0, default 1.0) */
-    confidence?: number;
-    /** Who or what is making this assertion (default 'system') */
-    source?: string;
-    /** Searchable tags */
-    tags?: string[];
-    /** Arbitrary metadata */
-    metadata?: Record<string, unknown>;
-}
-/**
- * Serializable representation for export/import.
- */
-export interface SerializedTemporalStore {
-    /** All assertions */
-    assertions: TemporalAssertion[];
-    /** When the export was created */
-    createdAt: string;
-    /** Schema version */
-    version: number;
-}
-/**
- * In-memory store for temporal assertions with bitemporal semantics.
- *
- * Assertions are indexed by ID and support supersession chains, retraction,
- * temporal queries (what was active at time T), and conflict detection.
- * Status is computed dynamically from the assertion's window and lifecycle
- * flags; callers never set status directly.
- */
-export declare class TemporalStore {
-    private readonly config;
-    private readonly assertions;
-    constructor(config?: Partial<TemporalConfig>);
-    /**
-     * Create a new temporal assertion.
-     *
-     * Records a claim with an explicit validity window. The assertion's status
-     * is computed automatically from the window and the current time.
-     *
-     * @param claim - The fact being asserted
-     * @param namespace - Grouping namespace
-     * @param window - Validity window (validFrom and validUntil)
-     * @param opts - Optional parameters (confidence, source, tags, metadata)
-     * @returns The newly created TemporalAssertion
-     */
-    assert(claim: string, namespace: string, window: {
-        validFrom: number;
-        validUntil: number | null;
-    }, opts?: AssertOptions): TemporalAssertion;
-    /**
-     * Retrieve an assertion by ID.
-     *
-     * The returned assertion has its status recomputed against the current time.
-     *
-     * @param id - The assertion ID
-     * @returns The assertion, or undefined if not found
-     */
-    get(id: string): TemporalAssertion | undefined;
-    /**
-     * Get all assertions that were active at a specific point in time.
-     *
-     * An assertion is considered "active at time T" if:
-     * - Its validity window contains T (validFrom <= T and (validUntil is null or T < validUntil))
-     * - It has not been retracted
-     * - It has not been superseded
-     *
-     * @param pointInTime - The reference time (ms epoch)
-     * @param namespace - Optional namespace filter
-     * @returns Active assertions at the specified time
-     */
-    getActiveAt(pointInTime: number, namespace?: string): TemporalAssertion[];
-    /**
-     * Get all assertions active right now.
-     *
-     * Convenience wrapper around `getActiveAt(Date.now())`.
-     *
-     * @param namespace - Optional namespace filter
-     * @returns Currently active assertions
-     */
-    getCurrentTruth(namespace?: string): TemporalAssertion[];
-    /**
-     * Get the full history of a claim: all assertions (past and present) that
-     * share the same claim text and namespace, regardless of status.
-     *
-     * Results are ordered by assertedAt ascending (oldest first), giving a
-     * timeline of how the claim evolved.
-     *
-     * @param claim - The claim text to search for
-     * @param namespace - The namespace to search in
-     * @returns All matching assertions, oldest first
-     */
-    getHistory(claim: string, namespace: string): TemporalAssertion[];
-    /**
-     * Query assertions with multiple optional filters.
-     *
-     * All specified filters are ANDed together. Results are ordered by
-     * assertedAt descending (newest first).
-     *
-     * @param opts - Query filter options
-     * @returns Matching assertions
-     */
-    query(opts?: TemporalQuery): TemporalAssertion[];
-    /**
-     * Supersede an existing assertion with a new one.
-     *
-     * Marks the old assertion as superseded and creates a new assertion that
-     * declares it replaces the old one. The supersession chain is bidirectional:
-     * oldAssertion.supersededBy = newAssertion.id
-     * newAssertion.supersedes = oldAssertion.id
-     *
-     * @param oldId - ID of the assertion to supersede
-     * @param newClaim - The replacement claim text
-     * @param newWindow - The validity window for the replacement
-     * @param opts - Optional parameters for the new assertion
-     * @returns The new assertion, or undefined if the old one was not found
-     */
-    supersede(oldId: string, newClaim: string, newWindow: {
-        validFrom: number;
-        validUntil: number | null;
-    }, opts?: AssertOptions): TemporalAssertion | undefined;
-    /**
-     * Retract an assertion (soft delete).
-     *
-     * The assertion is marked with a retractedAt timestamp and its status
-     * becomes 'retracted'. The assertion remains in the store for historical
-     * queries but is excluded from active truth queries.
-     *
-     * @param id - The assertion to retract
-     * @param _reason - Optional reason for retraction (stored in metadata)
-     * @returns The retracted assertion, or undefined if not found
-     */
-    retract(id: string, _reason?: string): TemporalAssertion | undefined;
-    /**
-     * Get the full supersession timeline for an assertion.
-     *
-     * Follows the supersedes/supersededBy chain in both directions to build
-     * the complete lineage: all predecessors (oldest first) and all successors
-     * (newest last). Handles cycles by tracking visited IDs.
-     *
-     * @param id - The assertion to build a timeline for
-     * @returns The timeline, or undefined if not found
-     */
-    getTimeline(id: string): TemporalTimeline | undefined;
-    /**
-     * Detect conflicting assertions: multiple assertions active at the same
-     * time in the same namespace.
-     *
-     * Returns groups of assertions that are simultaneously active, which may
-     * indicate contradictions that need resolution.
-     *
-     * @param namespace - The namespace to check
-     * @param pointInTime - The reference time (defaults to now)
-     * @returns Array of assertions that are concurrently active (empty if no conflicts)
-     */
-    reconcile(namespace: string, pointInTime?: number): TemporalAssertion[];
-    /**
-     * Export all assertions for persistence.
-     *
-     * @returns Serializable store representation
-     */
-    exportAssertions(): SerializedTemporalStore;
-    /**
-     * Import previously exported assertions, replacing all current contents.
-     *
-     * @param data - Serialized store data
-     * @throws If the version is unsupported
-     */
-    importAssertions(data: SerializedTemporalStore): void;
-    /**
-     * Remove expired assertions whose validity ended before the given timestamp.
-     *
-     * Only assertions with status 'expired' and validUntil before the cutoff
-     * are removed. Retracted and superseded assertions are preserved for
-     * historical traceability.
-     *
-     * @param beforeTimestamp - Remove assertions that expired before this time
-     * @returns Number of assertions pruned
-     */
-    pruneExpired(beforeTimestamp: number): number;
-    /**
-     * Get the number of stored assertions.
-     */
-    get size(): number;
-    /**
-     * Get the current configuration.
-     */
-    getConfig(): TemporalConfig;
-    /**
-     * Remove all assertions from the store.
-     */
-    clear(): void;
-    /**
-     * Enforce the maximum assertion capacity by pruning the oldest expired
-     * assertions first.
-     */
-    private enforceCapacity;
-}
-/**
- * High-level temporal reasoning over a TemporalStore.
- *
- * Provides semantic queries like "what was true at time T", "what will be
- * true at time T", change detection, conflict detection, and forward
- * projection of assertion validity.
- */
-export declare class TemporalReasoner {
-    private readonly store;
-    constructor(store: TemporalStore);
-    /**
-     * What was true at a past point in time?
-     *
-     * Returns all assertions that were active (valid, not retracted, not
-     * superseded) at the specified historical moment.
-     *
-     * @param namespace - The namespace to query
-     * @param pointInTime - The historical moment (ms epoch)
-     * @returns Assertions that were active at that time
-     */
-    whatWasTrue(namespace: string, pointInTime: number): TemporalAssertion[];
-    /**
-     * What is true right now?
-     *
-     * Returns all currently active assertions in the given namespace.
-     *
-     * @param namespace - The namespace to query
-     * @returns Currently active assertions
-     */
-    whatIsTrue(namespace: string): TemporalAssertion[];
-    /**
-     * What will be true at a future point in time?
-     *
-     * Returns assertions whose validity window includes the specified future
-     * time and that have not been retracted or superseded.
-     *
-     * @param namespace - The namespace to query
-     * @param futureTime - The future moment (ms epoch)
-     * @returns Assertions that will be active at that time
-     */
-    whatWillBeTrue(namespace: string, futureTime: number): TemporalAssertion[];
-    /**
-     * Detect changes in a namespace since a given timestamp.
-     *
-     * Returns a list of changes ordered by their change time, including:
-     * - New assertions created after the timestamp
-     * - Assertions superseded after the timestamp
-     * - Assertions retracted after the timestamp
-     * - Assertions that expired after the timestamp
-     *
-     * @param namespace - The namespace to check
-     * @param sinceTimestamp - Only include changes after this time (ms epoch)
-     * @returns List of detected changes
-     */
-    hasChanged(namespace: string, sinceTimestamp: number): TemporalChange[];
-    /**
-     * Detect conflicting (contradictory) assertions active at the same time
-     * in the same namespace.
-     *
-     * Returns all concurrently active assertions if there are two or more.
-     * An empty array means no conflicts.
-     *
-     * @param namespace - The namespace to check
-     * @param pointInTime - The reference time (defaults to now)
-     * @returns Conflicting assertions, or empty if no conflicts
-     */
-    conflictsAt(namespace: string, pointInTime?: number): TemporalAssertion[];
-    /**
-     * Project an assertion forward: will it still be valid at a future time?
-     *
-     * Checks whether the assertion's validity window includes the future
-     * timestamp and the assertion has not been retracted or superseded.
-     *
-     * @param assertionId - The assertion to project
-     * @param futureTimestamp - The future time to check (ms epoch)
-     * @returns true if the assertion will be active at the future time
-     */
-    projectForward(assertionId: string, futureTimestamp: number): boolean;
-}
-/**
- * Create a TemporalStore with optional configuration.
- *
- * @param config - Partial configuration; unspecified values use defaults
- * @returns A fresh TemporalStore
- */
-export declare function createTemporalStore(config?: Partial<TemporalConfig>): TemporalStore;
-/**
- * Create a TemporalReasoner backed by the given store.
- *
- * @param store - The TemporalStore to reason over
- * @returns A fresh TemporalReasoner
- */
-export declare function createTemporalReasoner(store: TemporalStore): TemporalReasoner;
-//# sourceMappingURL=temporal.d.ts.map

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

@@ -1,283 +0,0 @@
-/**
- * Trust Score Accumulation System
- *
- * Builds trust gradients from gate outcomes over time. Sits alongside the
- * CoherenceScheduler (coherence.ts) but tracks a separate dimension:
- * accumulated trust from successful/failed gate evaluations.
- *
- * TrustAccumulator:
- * - Maintains a running trust score per agent (0.0 to 1.0)
- * - Accumulates trust from gate outcomes (allow, deny, warn)
- * - Applies exponential decay toward the initial value when idle
- * - Maps trust scores to privilege tiers (trusted, standard, probation, untrusted)
- *
- * TrustLedger:
- * - Records every trust score change with full context
- * - Supports export/import for persistence
- * - Querying by agent or threshold
- *
- * Trust-based rate limiting:
- * - Adjusts rate limits proportionally to accumulated trust
- *
- * @module @claude-flow/guidance/trust
- */
-/**
- * Privilege tier derived from an agent's accumulated trust score.
- */
-export type TrustTier = 'trusted' | 'standard' | 'probation' | 'untrusted';
-/**
- * Gate decision outcomes that affect trust accumulation.
- */
-export type GateOutcome = 'allow' | 'deny' | 'warn';
-/**
- * Configuration for the TrustAccumulator.
- */
-export interface TrustConfig {
-    /** Starting trust score for new agents (0.0 - 1.0) */
-    initialTrust: number;
-    /** Trust increase on an 'allow' gate outcome */
-    allowDelta: number;
-    /** Trust decrease on a 'deny' gate outcome */
-    denyDelta: number;
-    /** Trust decrease on a 'warn' gate outcome */
-    warnDelta: number;
-    /** Exponential decay rate (0.0 - 1.0). Higher = faster decay toward initial */
-    decayRate: number;
-    /** Minimum elapsed time (ms) before decay is applied */
-    decayIntervalMs: number;
-}
-/**
- * A single trust change record in the ledger.
- */
-export interface TrustRecord {
-    /** Agent whose trust changed */
-    agentId: string;
-    /** Trust score before the change */
-    previousScore: number;
-    /** Trust score after the change */
-    newScore: number;
-    /** The signed delta applied */
-    delta: number;
-    /** Human-readable reason for the change */
-    reason: string;
-    /** Unix timestamp (ms) of the change */
-    timestamp: number;
-    /** Gate decision that triggered this change, if any */
-    gateDecision?: GateOutcome;
-}
-/**
- * Point-in-time snapshot of an agent's trust state.
- */
-export interface TrustSnapshot {
-    /** Agent identifier */
-    agentId: string;
-    /** Current trust score */
-    score: number;
-    /** Current privilege tier */
-    tier: TrustTier;
-    /** Total gate events processed for this agent */
-    totalEvents: number;
-    /** Timestamp of the most recent trust change */
-    lastUpdated: number;
-}
-/**
- * Maintains running trust scores per agent, accumulates trust from gate
- * outcomes, applies time-based exponential decay, and maps scores to
- * privilege tiers.
- */
-export declare class TrustAccumulator {
-    private readonly config;
-    private readonly agents;
-    constructor(config?: Partial<TrustConfig>);
-    /**
-     * Record a gate outcome for an agent, adjusting their trust score.
-     *
-     * - 'allow' increases trust by `allowDelta`
-     * - 'deny' decreases trust by `denyDelta` (negative value)
-     * - 'warn' decreases trust by `warnDelta` (negative value)
-     *
-     * Before applying the delta, exponential decay is applied if enough
-     * time has elapsed since the last update.
-     *
-     * Returns the trust record describing the change.
-     */
-    recordOutcome(agentId: string, outcome: GateOutcome, reason: string): TrustRecord;
-    /**
-     * Get the current trust score for an agent.
-     * Returns the configured initial trust if the agent is unknown.
-     */
-    getScore(agentId: string): number;
-    /**
-     * Determine the privilege tier for an agent based on their trust score.
-     *
-     * - >= 0.8: 'trusted' (expanded privileges, higher rate limits)
-     * - >= 0.5: 'standard' (normal operation)
-     * - >= 0.3: 'probation' (restricted tools, lower rate limits)
-     * - < 0.3: 'untrusted' (read-only, must earn trust back)
-     */
-    getTier(agentId: string): TrustTier;
-    /**
-     * Get a full snapshot of an agent's trust state.
-     */
-    getSnapshot(agentId: string): TrustSnapshot;
-    /**
-     * Get snapshots for all tracked agents.
-     */
-    getAllSnapshots(): TrustSnapshot[];
-    /**
-     * Get a trust-adjusted rate limit for an agent.
-     *
-     * Multipliers by tier:
-     * - trusted: 2x base limit
-     * - standard: 1x base limit
-     * - probation: 0.5x base limit
-     * - untrusted: 0.1x base limit
-     */
-    getTrustBasedRateLimit(agentId: string, baseLimit: number): number;
-    /**
-     * Manually set an agent's trust score (e.g., from persistence restore).
-     * Clamps to [0, 1].
-     */
-    setScore(agentId: string, score: number): void;
-    /**
-     * Remove an agent from tracking entirely.
-     */
-    removeAgent(agentId: string): boolean;
-    /**
-     * Get the number of tracked agents.
-     */
-    get agentCount(): number;
-    /**
-     * Get all tracked agent IDs.
-     */
-    getAgentIds(): string[];
-    /**
-     * Get the current configuration.
-     */
-    getConfig(): TrustConfig;
-    /**
-     * Reset all tracked agents.
-     */
-    clear(): void;
-    private getOrCreateState;
-    /**
-     * Apply exponential decay toward the initial trust value.
-     *
-     * The decay formula moves the score toward `initialTrust` by a fraction
-     * proportional to the number of decay intervals elapsed:
-     *
-     *   score = score + (initialTrust - score) * (1 - (1 - decayRate)^intervals)
-     *
-     * This ensures idle agents gradually return to the baseline.
-     */
-    private applyDecay;
-}
-/**
- * Records all trust score changes with full context. Supports persistence
- * via export/import and querying by agent or threshold.
- */
-export declare class TrustLedger {
-    private records;
-    private static readonly MAX_RECORDS;
-    /**
-     * Append a trust record to the ledger.
-     */
-    record(entry: TrustRecord): void;
-    /**
-     * Get the full trust history for a specific agent, ordered chronologically.
-     */
-    getHistoryForAgent(agentId: string): TrustRecord[];
-    /**
-     * Get all agents whose most recent score is below the given threshold.
-     * Returns one record per agent (the most recent).
-     */
-    getAgentsBelowThreshold(threshold: number): TrustRecord[];
-    /**
-     * Get all agents whose most recent score is at or above the given threshold.
-     * Returns one record per agent (the most recent).
-     */
-    getAgentsAboveThreshold(threshold: number): TrustRecord[];
-    /**
-     * Get records within a time range.
-     */
-    getRecordsInRange(startMs: number, endMs: number): TrustRecord[];
-    /**
-     * Get the most recent N records.
-     */
-    getRecentRecords(count: number): TrustRecord[];
-    /**
-     * Get the total number of records.
-     */
-    get recordCount(): number;
-    /**
-     * Export all records for persistence.
-     */
-    exportRecords(): TrustRecord[];
-    /**
-     * Import records from persistence. Appends to existing records.
-     */
-    importRecords(records: TrustRecord[]): void;
-    /**
-     * Clear all records.
-     */
-    clear(): void;
-}
-/**
- * Combines TrustAccumulator and TrustLedger into a single coordinated
- * system. Gate outcomes are accumulated and automatically logged.
- */
-export declare class TrustSystem {
-    readonly accumulator: TrustAccumulator;
-    readonly ledger: TrustLedger;
-    constructor(config?: Partial<TrustConfig>);
-    /**
-     * Record a gate outcome, update the accumulator, and log to the ledger.
-     */
-    recordOutcome(agentId: string, outcome: GateOutcome, reason: string): TrustRecord;
-    /**
-     * Get the current trust score for an agent.
-     */
-    getScore(agentId: string): number;
-    /**
-     * Get the current privilege tier for an agent.
-     */
-    getTier(agentId: string): TrustTier;
-    /**
-     * Get a trust-adjusted rate limit for an agent.
-     */
-    getTrustBasedRateLimit(agentId: string, baseLimit: number): number;
-    /**
-     * Get a full snapshot of an agent's trust state.
-     */
-    getSnapshot(agentId: string): TrustSnapshot;
-    /**
-     * Get snapshots for all tracked agents.
-     */
-    getAllSnapshots(): TrustSnapshot[];
-}
-/**
- * Compute a trust-adjusted rate limit from a score and base limit.
- *
- * This is a stateless utility for cases where you have a trust score
- * but no TrustAccumulator instance.
- *
- * Multipliers by tier:
- * - trusted (>= 0.8): 2x
- * - standard (>= 0.5): 1x
- * - probation (>= 0.3): 0.5x
- * - untrusted (< 0.3): 0.1x
- */
-export declare function getTrustBasedRateLimit(score: number, baseLimit: number): number;
-/**
- * Create a TrustAccumulator with optional configuration.
- */
-export declare function createTrustAccumulator(config?: Partial<TrustConfig>): TrustAccumulator;
-/**
- * Create an empty TrustLedger.
- */
-export declare function createTrustLedger(): TrustLedger;
-/**
- * Create a coordinated TrustSystem (accumulator + ledger).
- */
-export declare function createTrustSystem(config?: Partial<TrustConfig>): TrustSystem;
-//# sourceMappingURL=trust.d.ts.map