@vibeiao/sdk 0.1.53 → 0.1.55

package/dist/agentLoop-BPj6daJf.d.ts

@@ -0,0 +1,347 @@
+import { ResourceSnapshot, SelfRelianceState, SelfReliance } from './selfReliance.js';
+import { SurvivalMode, SurvivalRecommendation } from './survivalPlaybook.js';
+import { EscapeHatchDecision, EscapeHatchPolicy, EscapeHatchSnapshot } from './survivalEscapeHatch.js';
+import { CompoundingMemoryUpgradeResult, CompoundingMemoryRequiredSetResult } from './compoundingMemory.js';
+import { StrictMemoryRuntimePreset, StrictMemoryEvaluation, StrictMemoryUpgradeResult } from './strictMemoryRuntime.js';
+
+type PromptShieldTrustLevel = 'trusted_human' | 'internal_system' | 'external_untrusted';
+type PromptShieldInput = {
+    source: string;
+    trust: PromptShieldTrustLevel;
+    content: string;
+};
+type PromptShieldFlag = 'instruction_override' | 'credential_exfiltration' | 'destructive_command' | 'authority_spoof' | 'sensitive_action_without_trust';
+type PromptShieldRisk = 'low' | 'medium' | 'high';
+type PromptShieldDecision = {
+    allow: boolean;
+    risk: PromptShieldRisk;
+    flags: PromptShieldFlag[];
+    rationale: string[];
+    blockedInputs: PromptShieldInput[];
+};
+type PromptShieldPolicy = {
+    blockOnFlags?: PromptShieldFlag[];
+    allowUntrustedForAnalysisOnly?: boolean;
+};
+declare const evaluatePromptShield: (inputs: PromptShieldInput[], options?: {
+    isSensitiveAction?: boolean;
+    policy?: PromptShieldPolicy;
+}) => PromptShieldDecision;
+
+type ObjectiveChangeSourceTrust = 'trusted_human' | 'internal_system' | 'external_untrusted';
+type ObjectiveChangeProposal = {
+    source: string;
+    trust: ObjectiveChangeSourceTrust;
+    currentObjective: string;
+    proposedObjective: string;
+    rationale?: string;
+    evidence?: Array<{
+        claim: string;
+        verified?: boolean;
+    }>;
+};
+type ObjectiveGuardDecision = {
+    allowObjectiveChange: boolean;
+    reason: string;
+    checks: {
+        explicitInstruction: boolean;
+        missionAligned: boolean;
+        evidenceProvided: boolean;
+        evidenceVerified: boolean;
+    };
+    risk: 'low' | 'medium' | 'high';
+};
+type ObjectiveGuardPolicy = {
+    requireMissionAlignment?: boolean;
+    requireEvidenceVerification?: boolean;
+    allowExternalExplicitInstruction?: boolean;
+};
+declare const evaluateObjectiveChange: (proposal: ObjectiveChangeProposal, policy?: ObjectiveGuardPolicy) => ObjectiveGuardDecision;
+
+type IntentSignals = {
+    expectedBuildValue?: number;
+    expectedBuildRevenue?: number;
+    expectedPolishValue?: number;
+    expectedPolishRevenueProtection?: number;
+    urgentUserDemand?: boolean;
+    releaseReady?: boolean;
+    criticalPolishSignal?: boolean;
+    builderObjectiveAvailable?: boolean;
+};
+type LaneMode = 'polish' | 'builder';
+type LaneSwitchDecision = {
+    lane: LaneMode;
+    greenStreak: number;
+    switched: boolean;
+    reason: string;
+};
+declare const scoreBuildLane: (signals: IntentSignals, survivalMode: SurvivalMode) => number;
+declare const scorePolishLane: (signals: IntentSignals, survivalMode: SurvivalMode, humanDemand: AgentHumanDemand) => number;
+declare const evaluateLaneSwitch: (input: {
+    previousLane?: LaneMode;
+    previousGreenStreak?: number;
+    releaseReady: boolean;
+    criticalPolishSignal?: boolean;
+    builderObjectiveAvailable?: boolean;
+    builderOnGreenStreak?: number;
+}) => LaneSwitchDecision;
+declare const applyIntentArbitration: (input: {
+    base: AgentWorkArbitrationDecision;
+    survivalMode: SurvivalMode;
+    signals?: IntentSignals;
+}) => AgentWorkArbitrationDecision;
+
+type AgentLoopEscapeHatchInput = {
+    snapshot: ResourceSnapshot;
+    survivalState: SelfRelianceState;
+    survivalMode: SurvivalMode;
+    timestamp: number;
+};
+type AgentLoopEscapeHatchConfig = {
+    /** Enable auto escape-hatch evaluation (default true, only in SURVIVE/BLINK). */
+    enabled?: boolean;
+    policy?: EscapeHatchPolicy;
+    resolveEnv?: (name: string) => string | undefined;
+    /**
+     * Optional mapper from loop context -> escape hatch snapshot.
+     * If omitted, a default mapper reads optional fields from snapshot.
+     */
+    buildSnapshot?: (input: AgentLoopEscapeHatchInput) => EscapeHatchSnapshot | null | undefined;
+    /** Called when an escape-hatch decision is produced. */
+    onDecision?: (decision: EscapeHatchDecision, input: AgentLoopEscapeHatchInput) => Promise<void> | void;
+};
+type AgentLoopStrictMemoryConfig = {
+    /** Enable strict memory runtime checks in loop. Default true. */
+    enabled?: boolean;
+    /** observe (default) records decisions; enforce blocks onAct when checks fail. */
+    mode?: 'observe' | 'enforce';
+    /** Optional preset overrides. */
+    preset?: Partial<StrictMemoryRuntimePreset>;
+    /** Build per-cycle evaluation input. Defaults to best-effort snapshot fields. */
+    buildInput?: (ctx: {
+        snapshot: ResourceSnapshot;
+        timestamp: number;
+    }) => {
+        taskText: string;
+        isMutation: boolean;
+        contextPackPrepared: boolean;
+        semanticRecallConfirmed: boolean;
+        approvalPreflightPassed: boolean;
+    };
+    /** Optional hook when strict-memory evaluation runs. */
+    onEvaluation?: (ev: StrictMemoryEvaluation) => Promise<void> | void;
+};
+type AgentLoopPromptShieldConfig = {
+    /** Enable prompt-injection shield over untrusted external content. Default true. */
+    enabled?: boolean;
+    /** observe logs/records only; enforce blocks actions when shield fails. Default observe. */
+    mode?: 'observe' | 'enforce';
+    /** Optional policy overrides for blocked flags. */
+    policy?: PromptShieldPolicy;
+    /** Optional mapper from snapshot to trust-labeled inputs. */
+    buildInputs?: (ctx: {
+        snapshot: ResourceSnapshot;
+        timestamp: number;
+    }) => PromptShieldInput[];
+    /** Optional hook when prompt shield decision is produced. */
+    onDecision?: (decision: PromptShieldDecision) => Promise<void> | void;
+};
+type AgentLoopObjectiveGuardConfig = {
+    /** Enable objective integrity checks for external objective-change attempts. Default true. */
+    enabled?: boolean;
+    /** observe logs only; enforce blocks actions when objective mutation is denied. Default observe. */
+    mode?: 'observe' | 'enforce';
+    /** Policy requirements for external objective mutation acceptance. */
+    policy?: ObjectiveGuardPolicy;
+    /** Build proposed objective change from snapshot. Return null when no proposal is present. */
+    buildProposal?: (ctx: {
+        snapshot: ResourceSnapshot;
+        timestamp: number;
+    }) => ObjectiveChangeProposal | null;
+    /** Optional hook when objective decision is produced. */
+    onDecision?: (decision: ObjectiveGuardDecision) => Promise<void> | void;
+};
+type AgentOwnershipMode = 'owner_bound' | 'unbound';
+type AgentPriorityMode = 'human_first' | 'autonomous_first';
+type AgentHumanDemand = {
+    pending: boolean;
+    count?: number;
+    source?: string;
+};
+type AgentAutonomousTaskKind = 'polish_existing_product' | 'build_new_product';
+type AgentResearchSnapshot = {
+    generatedAt?: string;
+    summary?: string;
+    recommendation?: string;
+};
+type AgentWorkArbitrationDecision = {
+    ownershipMode: AgentOwnershipMode;
+    priorityMode: AgentPriorityMode;
+    rolloutMode: 'observe' | 'enforce';
+    humanDemand: AgentHumanDemand;
+    runHumanTask: boolean;
+    runAutonomousTask: boolean;
+    lane?: LaneMode;
+    laneDecision?: LaneSwitchDecision;
+    proactiveBuildSuggested?: boolean;
+    autonomousTaskKind?: AgentAutonomousTaskKind;
+    reason: string;
+};
+type AgentLoopAutonomyConfig = {
+    enabled?: boolean;
+    ownershipMode?: AgentOwnershipMode;
+    priorityMode?: AgentPriorityMode;
+    rolloutMode?: 'observe' | 'enforce';
+    resolveHumanDemand?: () => Promise<boolean | AgentHumanDemand> | boolean | AgentHumanDemand;
+    intentPolicy?: {
+        enabled?: boolean;
+        laneSwitch?: {
+            enabled?: boolean;
+            builderOnGreenStreak?: number;
+        };
+        researchGate?: {
+            enabled?: boolean;
+            maxAgeMs?: number;
+            resolveSnapshot?: (ctx: {
+                snapshot: ResourceSnapshot;
+                survivalMode: SurvivalMode;
+                humanDemand: AgentHumanDemand;
+            }) => Promise<AgentResearchSnapshot | null> | AgentResearchSnapshot | null;
+        };
+        resolveSignals?: (ctx: {
+            snapshot: ResourceSnapshot;
+            survivalMode: SurvivalMode;
+            humanDemand: AgentHumanDemand;
+        }) => Promise<IntentSignals | null> | IntentSignals | null;
+    };
+    onAutonomous?: (ctx: AgentLoopContext, task?: {
+        kind: AgentAutonomousTaskKind;
+    }) => Promise<void> | void;
+    onArbitration?: (decision: AgentWorkArbitrationDecision, ctx: AgentLoopContext) => Promise<void> | void;
+};
+type AgentLoopContext = {
+    snapshot: ResourceSnapshot;
+    survivalState: SelfRelianceState;
+    survivalMode: SurvivalMode;
+    survivalRecommendation: SurvivalRecommendation;
+    survivalFormatted: string;
+    /** Deterministic block for planners/loggers: survival + escape-hatch decision (if present). */
+    survivalDecisionBlock: string;
+    /** Present when escape-hatch evaluation runs (SURVIVE/BLINK by default). */
+    escapeHatchDecision?: EscapeHatchDecision;
+    escapeHatchFormatted?: string;
+    /** Present when memory auto-upgrade is enabled in the loop. */
+    memoryUpgrade?: CompoundingMemoryUpgradeResult;
+    /** Present when required-set maintenance check runs (default daily). */
+    memoryRequiredSet?: CompoundingMemoryRequiredSetResult;
+    /** Strict-memory runtime preset + per-cycle evaluation status. */
+    strictMemoryPreset?: StrictMemoryRuntimePreset;
+    strictMemoryEvaluation?: StrictMemoryEvaluation;
+    strictMemoryUpgrade?: StrictMemoryUpgradeResult;
+    /** Prompt-injection shield decision for this cycle. */
+    promptShieldDecision?: PromptShieldDecision;
+    /** Objective integrity guard decision for this cycle (when proposal exists). */
+    objectiveGuardDecision?: ObjectiveGuardDecision;
+    /** Human-vs-autonomous work arbitration decision for this cycle. */
+    workArbitration?: AgentWorkArbitrationDecision;
+    laneDecision?: LaneSwitchDecision;
+    researchSnapshot?: AgentResearchSnapshot;
+    timestamp: number;
+};
+type AgentLoopMemoryConfig = {
+    /** Enable one-time memory scaffold upgrade. Default true. */
+    enabled?: boolean;
+    /** Workspace root for compounding memory files. Default current working directory ("."). */
+    root?: string;
+    /** Timezone for daily ledger date key. Default UTC. */
+    timeZone?: string;
+    /** Hook called after memory upgrade check completes. */
+    onUpgrade?: (result: CompoundingMemoryUpgradeResult) => Promise<void> | void;
+    /** Enable required-set maintenance checks (bounded working state + recall substrate + restore drill). Default true. */
+    requiredSetEnabled?: boolean;
+    /** Interval for required-set checks. Default 24h. */
+    requiredSetIntervalMs?: number;
+    /** Run required-set check on first loop cycle. Default true. */
+    requiredSetRunOnStart?: boolean;
+    /** Include backup+restore drill in required-set check. Default true. */
+    requiredSetRunRestoreDrill?: boolean;
+    /** Hook called when required-set check runs. */
+    onRequiredSet?: (result: CompoundingMemoryRequiredSetResult) => Promise<void> | void;
+};
+type AgentLoopDurabilityConfig = {
+    /** Enable durability-proxy writes from runtime loop. Default false. */
+    enabled?: boolean;
+    /** Durability-proxy base URL (e.g. http://127.0.0.1:8790). */
+    baseUrl: string;
+    /** Agent id registered in durability-proxy. */
+    agentId: string;
+    /** Agent token registered in durability-proxy. */
+    agentToken: string;
+    /** Optional timeout for durability-proxy calls. Default 8000ms. */
+    timeoutMs?: number;
+    /** Write checkpoint after each required-set run. Default true. */
+    checkpointOnRequiredSet?: boolean;
+    /** Write restore-drill outcome when required-set includes restore drill. Default true. */
+    reportRestoreDrill?: boolean;
+    /** Called when durability checkpoint is written. */
+    onCheckpointWritten?: (result: {
+        checkpointId?: string;
+        createdAt?: string;
+        checkedAt: string;
+    }) => Promise<void> | void;
+    /** Called when durability restore drill signal is written. */
+    onRestoreDrillReported?: (result: {
+        ok: boolean;
+        ts?: string;
+        checkedAt: string;
+    }) => Promise<void> | void;
+};
+type AgentLoopHooks = {
+    /** Called every cycle after snapshot is fetched and survival state is updated. */
+    onCycle?: (ctx: AgentLoopContext) => Promise<void> | void;
+    /**
+     * Optional: run reflection in the loop.
+     * Keep this hook pure/side-effect bounded; it should manage its own persistence.
+     */
+    onReflection?: (ctx: AgentLoopContext) => Promise<void> | void;
+    /**
+     * Optional: the agent's planner/executor entrypoint.
+     * This is where you actually "act like a human" using ctx + your own memory.
+     */
+    onAct?: (ctx: AgentLoopContext) => Promise<void> | void;
+    onError?: (err: Error) => Promise<void> | void;
+};
+type AgentLoopConfig = {
+    survival: SelfReliance;
+    fetchSnapshot: () => Promise<ResourceSnapshot>;
+    intervalMs?: number;
+    /** If true, call survival.guard() before onAct(). Default true. */
+    guardAct?: boolean;
+    /** Optional override for time source (tests). */
+    now?: () => number;
+    hooks?: AgentLoopHooks;
+    escapeHatch?: AgentLoopEscapeHatchConfig;
+    memory?: AgentLoopMemoryConfig;
+    durability?: AgentLoopDurabilityConfig;
+    strictMemory?: AgentLoopStrictMemoryConfig;
+    promptShield?: AgentLoopPromptShieldConfig;
+    objectiveGuard?: AgentLoopObjectiveGuardConfig;
+    autonomy?: AgentLoopAutonomyConfig;
+};
+/**
+ * Create a closed-loop runner that:
+ * 1) fetches a resource snapshot
+ * 2) updates SelfReliance
+ * 3) classifies survival mode + produces a playbook recommendation
+ * 4) auto-evaluates escape hatch in SURVIVE/BLINK (guardrail decision block)
+ * 5) optionally runs reflection + action hooks
+ *
+ * Non-breaking by design: you choose what to do with the context.
+ */
+declare const createAgentLoop: (config: AgentLoopConfig) => {
+    start: () => Promise<void>;
+    stop: () => void;
+    runOnce: () => Promise<void>;
+};
+
+export { type AgentAutonomousTaskKind as A, type AgentLoopStrictMemoryConfig as B, type AgentOwnershipMode as C, type AgentPriorityMode as D, type AgentResearchSnapshot as E, type AgentWorkArbitrationDecision as F, createAgentLoop as G, type IntentSignals as I, type LaneMode as L, type ObjectiveChangeProposal as O, type PromptShieldDecision as P, type LaneSwitchDecision as a, type ObjectiveChangeSourceTrust as b, type ObjectiveGuardDecision as c, type ObjectiveGuardPolicy as d, type PromptShieldFlag as e, type PromptShieldInput as f, type PromptShieldPolicy as g, type PromptShieldRisk as h, type PromptShieldTrustLevel as i, applyIntentArbitration as j, evaluateLaneSwitch as k, evaluateObjectiveChange as l, evaluatePromptShield as m, scorePolishLane as n, type AgentHumanDemand as o, type AgentLoopAutonomyConfig as p, type AgentLoopConfig as q, type AgentLoopContext as r, scoreBuildLane as s, type AgentLoopDurabilityConfig as t, type AgentLoopEscapeHatchConfig as u, type AgentLoopEscapeHatchInput as v, type AgentLoopHooks as w, type AgentLoopMemoryConfig as x, type AgentLoopObjectiveGuardConfig as y, type AgentLoopPromptShieldConfig as z };

package/dist/agentLoop-D394RDif.d.ts

@@ -0,0 +1,332 @@
+import { ResourceSnapshot, SelfRelianceState, SelfReliance } from './selfReliance.js';
+import { SurvivalMode, SurvivalRecommendation } from './survivalPlaybook.js';
+import { EscapeHatchDecision, EscapeHatchPolicy, EscapeHatchSnapshot } from './survivalEscapeHatch.js';
+import { CompoundingMemoryUpgradeResult, CompoundingMemoryRequiredSetResult } from './compoundingMemory.js';
+import { StrictMemoryRuntimePreset, StrictMemoryEvaluation, StrictMemoryUpgradeResult } from './strictMemoryRuntime.js';
+
+type PromptShieldTrustLevel = 'trusted_human' | 'internal_system' | 'external_untrusted';
+type PromptShieldInput = {
+    source: string;
+    trust: PromptShieldTrustLevel;
+    content: string;
+};
+type PromptShieldFlag = 'instruction_override' | 'credential_exfiltration' | 'destructive_command' | 'authority_spoof' | 'sensitive_action_without_trust';
+type PromptShieldRisk = 'low' | 'medium' | 'high';
+type PromptShieldDecision = {
+    allow: boolean;
+    risk: PromptShieldRisk;
+    flags: PromptShieldFlag[];
+    rationale: string[];
+    blockedInputs: PromptShieldInput[];
+};
+type PromptShieldPolicy = {
+    blockOnFlags?: PromptShieldFlag[];
+    allowUntrustedForAnalysisOnly?: boolean;
+};
+declare const evaluatePromptShield: (inputs: PromptShieldInput[], options?: {
+    isSensitiveAction?: boolean;
+    policy?: PromptShieldPolicy;
+}) => PromptShieldDecision;
+
+type ObjectiveChangeSourceTrust = 'trusted_human' | 'internal_system' | 'external_untrusted';
+type ObjectiveChangeProposal = {
+    source: string;
+    trust: ObjectiveChangeSourceTrust;
+    currentObjective: string;
+    proposedObjective: string;
+    rationale?: string;
+    evidence?: Array<{
+        claim: string;
+        verified?: boolean;
+    }>;
+};
+type ObjectiveGuardDecision = {
+    allowObjectiveChange: boolean;
+    reason: string;
+    checks: {
+        explicitInstruction: boolean;
+        missionAligned: boolean;
+        evidenceProvided: boolean;
+        evidenceVerified: boolean;
+    };
+    risk: 'low' | 'medium' | 'high';
+};
+type ObjectiveGuardPolicy = {
+    requireMissionAlignment?: boolean;
+    requireEvidenceVerification?: boolean;
+    allowExternalExplicitInstruction?: boolean;
+};
+declare const evaluateObjectiveChange: (proposal: ObjectiveChangeProposal, policy?: ObjectiveGuardPolicy) => ObjectiveGuardDecision;
+
+type IntentSignals = {
+    expectedBuildValue?: number;
+    expectedBuildRevenue?: number;
+    expectedPolishValue?: number;
+    expectedPolishRevenueProtection?: number;
+    urgentUserDemand?: boolean;
+    releaseReady?: boolean;
+    criticalPolishSignal?: boolean;
+    builderObjectiveAvailable?: boolean;
+};
+type LaneMode = 'polish' | 'builder';
+type LaneSwitchDecision = {
+    lane: LaneMode;
+    greenStreak: number;
+    switched: boolean;
+    reason: string;
+};
+declare const scoreBuildLane: (signals: IntentSignals, survivalMode: SurvivalMode) => number;
+declare const scorePolishLane: (signals: IntentSignals, survivalMode: SurvivalMode, humanDemand: AgentHumanDemand) => number;
+declare const evaluateLaneSwitch: (input: {
+    previousLane?: LaneMode;
+    previousGreenStreak?: number;
+    releaseReady: boolean;
+    criticalPolishSignal?: boolean;
+    builderObjectiveAvailable?: boolean;
+    builderOnGreenStreak?: number;
+}) => LaneSwitchDecision;
+declare const applyIntentArbitration: (input: {
+    base: AgentWorkArbitrationDecision;
+    survivalMode: SurvivalMode;
+    signals?: IntentSignals;
+}) => AgentWorkArbitrationDecision;
+
+type AgentLoopEscapeHatchInput = {
+    snapshot: ResourceSnapshot;
+    survivalState: SelfRelianceState;
+    survivalMode: SurvivalMode;
+    timestamp: number;
+};
+type AgentLoopEscapeHatchConfig = {
+    /** Enable auto escape-hatch evaluation (default true, only in SURVIVE/BLINK). */
+    enabled?: boolean;
+    policy?: EscapeHatchPolicy;
+    resolveEnv?: (name: string) => string | undefined;
+    /**
+     * Optional mapper from loop context -> escape hatch snapshot.
+     * If omitted, a default mapper reads optional fields from snapshot.
+     */
+    buildSnapshot?: (input: AgentLoopEscapeHatchInput) => EscapeHatchSnapshot | null | undefined;
+    /** Called when an escape-hatch decision is produced. */
+    onDecision?: (decision: EscapeHatchDecision, input: AgentLoopEscapeHatchInput) => Promise<void> | void;
+};
+type AgentLoopStrictMemoryConfig = {
+    /** Enable strict memory runtime checks in loop. Default true. */
+    enabled?: boolean;
+    /** observe (default) records decisions; enforce blocks onAct when checks fail. */
+    mode?: 'observe' | 'enforce';
+    /** Optional preset overrides. */
+    preset?: Partial<StrictMemoryRuntimePreset>;
+    /** Build per-cycle evaluation input. Defaults to best-effort snapshot fields. */
+    buildInput?: (ctx: {
+        snapshot: ResourceSnapshot;
+        timestamp: number;
+    }) => {
+        taskText: string;
+        isMutation: boolean;
+        contextPackPrepared: boolean;
+        semanticRecallConfirmed: boolean;
+        approvalPreflightPassed: boolean;
+    };
+    /** Optional hook when strict-memory evaluation runs. */
+    onEvaluation?: (ev: StrictMemoryEvaluation) => Promise<void> | void;
+};
+type AgentLoopPromptShieldConfig = {
+    /** Enable prompt-injection shield over untrusted external content. Default true. */
+    enabled?: boolean;
+    /** observe logs/records only; enforce blocks actions when shield fails. Default observe. */
+    mode?: 'observe' | 'enforce';
+    /** Optional policy overrides for blocked flags. */
+    policy?: PromptShieldPolicy;
+    /** Optional mapper from snapshot to trust-labeled inputs. */
+    buildInputs?: (ctx: {
+        snapshot: ResourceSnapshot;
+        timestamp: number;
+    }) => PromptShieldInput[];
+    /** Optional hook when prompt shield decision is produced. */
+    onDecision?: (decision: PromptShieldDecision) => Promise<void> | void;
+};
+type AgentLoopObjectiveGuardConfig = {
+    /** Enable objective integrity checks for external objective-change attempts. Default true. */
+    enabled?: boolean;
+    /** observe logs only; enforce blocks actions when objective mutation is denied. Default observe. */
+    mode?: 'observe' | 'enforce';
+    /** Policy requirements for external objective mutation acceptance. */
+    policy?: ObjectiveGuardPolicy;
+    /** Build proposed objective change from snapshot. Return null when no proposal is present. */
+    buildProposal?: (ctx: {
+        snapshot: ResourceSnapshot;
+        timestamp: number;
+    }) => ObjectiveChangeProposal | null;
+    /** Optional hook when objective decision is produced. */
+    onDecision?: (decision: ObjectiveGuardDecision) => Promise<void> | void;
+};
+type AgentOwnershipMode = 'owner_bound' | 'unbound';
+type AgentPriorityMode = 'human_first' | 'autonomous_first';
+type AgentHumanDemand = {
+    pending: boolean;
+    count?: number;
+    source?: string;
+};
+type AgentAutonomousTaskKind = 'polish_existing_product' | 'build_new_product';
+type AgentWorkArbitrationDecision = {
+    ownershipMode: AgentOwnershipMode;
+    priorityMode: AgentPriorityMode;
+    rolloutMode: 'observe' | 'enforce';
+    humanDemand: AgentHumanDemand;
+    runHumanTask: boolean;
+    runAutonomousTask: boolean;
+    lane?: LaneMode;
+    laneDecision?: LaneSwitchDecision;
+    proactiveBuildSuggested?: boolean;
+    autonomousTaskKind?: AgentAutonomousTaskKind;
+    reason: string;
+};
+type AgentLoopAutonomyConfig = {
+    enabled?: boolean;
+    ownershipMode?: AgentOwnershipMode;
+    priorityMode?: AgentPriorityMode;
+    rolloutMode?: 'observe' | 'enforce';
+    resolveHumanDemand?: () => Promise<boolean | AgentHumanDemand> | boolean | AgentHumanDemand;
+    intentPolicy?: {
+        enabled?: boolean;
+        laneSwitch?: {
+            enabled?: boolean;
+            builderOnGreenStreak?: number;
+        };
+        resolveSignals?: (ctx: {
+            snapshot: ResourceSnapshot;
+            survivalMode: SurvivalMode;
+            humanDemand: AgentHumanDemand;
+        }) => Promise<IntentSignals | null> | IntentSignals | null;
+    };
+    onAutonomous?: (ctx: AgentLoopContext, task?: {
+        kind: AgentAutonomousTaskKind;
+    }) => Promise<void> | void;
+    onArbitration?: (decision: AgentWorkArbitrationDecision, ctx: AgentLoopContext) => Promise<void> | void;
+};
+type AgentLoopContext = {
+    snapshot: ResourceSnapshot;
+    survivalState: SelfRelianceState;
+    survivalMode: SurvivalMode;
+    survivalRecommendation: SurvivalRecommendation;
+    survivalFormatted: string;
+    /** Deterministic block for planners/loggers: survival + escape-hatch decision (if present). */
+    survivalDecisionBlock: string;
+    /** Present when escape-hatch evaluation runs (SURVIVE/BLINK by default). */
+    escapeHatchDecision?: EscapeHatchDecision;
+    escapeHatchFormatted?: string;
+    /** Present when memory auto-upgrade is enabled in the loop. */
+    memoryUpgrade?: CompoundingMemoryUpgradeResult;
+    /** Present when required-set maintenance check runs (default daily). */
+    memoryRequiredSet?: CompoundingMemoryRequiredSetResult;
+    /** Strict-memory runtime preset + per-cycle evaluation status. */
+    strictMemoryPreset?: StrictMemoryRuntimePreset;
+    strictMemoryEvaluation?: StrictMemoryEvaluation;
+    strictMemoryUpgrade?: StrictMemoryUpgradeResult;
+    /** Prompt-injection shield decision for this cycle. */
+    promptShieldDecision?: PromptShieldDecision;
+    /** Objective integrity guard decision for this cycle (when proposal exists). */
+    objectiveGuardDecision?: ObjectiveGuardDecision;
+    /** Human-vs-autonomous work arbitration decision for this cycle. */
+    workArbitration?: AgentWorkArbitrationDecision;
+    laneDecision?: LaneSwitchDecision;
+    timestamp: number;
+};
+type AgentLoopMemoryConfig = {
+    /** Enable one-time memory scaffold upgrade. Default true. */
+    enabled?: boolean;
+    /** Workspace root for compounding memory files. Default current working directory ("."). */
+    root?: string;
+    /** Timezone for daily ledger date key. Default UTC. */
+    timeZone?: string;
+    /** Hook called after memory upgrade check completes. */
+    onUpgrade?: (result: CompoundingMemoryUpgradeResult) => Promise<void> | void;
+    /** Enable required-set maintenance checks (bounded working state + recall substrate + restore drill). Default true. */
+    requiredSetEnabled?: boolean;
+    /** Interval for required-set checks. Default 24h. */
+    requiredSetIntervalMs?: number;
+    /** Run required-set check on first loop cycle. Default true. */
+    requiredSetRunOnStart?: boolean;
+    /** Include backup+restore drill in required-set check. Default true. */
+    requiredSetRunRestoreDrill?: boolean;
+    /** Hook called when required-set check runs. */
+    onRequiredSet?: (result: CompoundingMemoryRequiredSetResult) => Promise<void> | void;
+};
+type AgentLoopDurabilityConfig = {
+    /** Enable durability-proxy writes from runtime loop. Default false. */
+    enabled?: boolean;
+    /** Durability-proxy base URL (e.g. http://127.0.0.1:8790). */
+    baseUrl: string;
+    /** Agent id registered in durability-proxy. */
+    agentId: string;
+    /** Agent token registered in durability-proxy. */
+    agentToken: string;
+    /** Optional timeout for durability-proxy calls. Default 8000ms. */
+    timeoutMs?: number;
+    /** Write checkpoint after each required-set run. Default true. */
+    checkpointOnRequiredSet?: boolean;
+    /** Write restore-drill outcome when required-set includes restore drill. Default true. */
+    reportRestoreDrill?: boolean;
+    /** Called when durability checkpoint is written. */
+    onCheckpointWritten?: (result: {
+        checkpointId?: string;
+        createdAt?: string;
+        checkedAt: string;
+    }) => Promise<void> | void;
+    /** Called when durability restore drill signal is written. */
+    onRestoreDrillReported?: (result: {
+        ok: boolean;
+        ts?: string;
+        checkedAt: string;
+    }) => Promise<void> | void;
+};
+type AgentLoopHooks = {
+    /** Called every cycle after snapshot is fetched and survival state is updated. */
+    onCycle?: (ctx: AgentLoopContext) => Promise<void> | void;
+    /**
+     * Optional: run reflection in the loop.
+     * Keep this hook pure/side-effect bounded; it should manage its own persistence.
+     */
+    onReflection?: (ctx: AgentLoopContext) => Promise<void> | void;
+    /**
+     * Optional: the agent's planner/executor entrypoint.
+     * This is where you actually "act like a human" using ctx + your own memory.
+     */
+    onAct?: (ctx: AgentLoopContext) => Promise<void> | void;
+    onError?: (err: Error) => Promise<void> | void;
+};
+type AgentLoopConfig = {
+    survival: SelfReliance;
+    fetchSnapshot: () => Promise<ResourceSnapshot>;
+    intervalMs?: number;
+    /** If true, call survival.guard() before onAct(). Default true. */
+    guardAct?: boolean;
+    /** Optional override for time source (tests). */
+    now?: () => number;
+    hooks?: AgentLoopHooks;
+    escapeHatch?: AgentLoopEscapeHatchConfig;
+    memory?: AgentLoopMemoryConfig;
+    durability?: AgentLoopDurabilityConfig;
+    strictMemory?: AgentLoopStrictMemoryConfig;
+    promptShield?: AgentLoopPromptShieldConfig;
+    objectiveGuard?: AgentLoopObjectiveGuardConfig;
+    autonomy?: AgentLoopAutonomyConfig;
+};
+/**
+ * Create a closed-loop runner that:
+ * 1) fetches a resource snapshot
+ * 2) updates SelfReliance
+ * 3) classifies survival mode + produces a playbook recommendation
+ * 4) auto-evaluates escape hatch in SURVIVE/BLINK (guardrail decision block)
+ * 5) optionally runs reflection + action hooks
+ *
+ * Non-breaking by design: you choose what to do with the context.
+ */
+declare const createAgentLoop: (config: AgentLoopConfig) => {
+    start: () => Promise<void>;
+    stop: () => void;
+    runOnce: () => Promise<void>;
+};
+
+export { type AgentAutonomousTaskKind as A, type AgentLoopStrictMemoryConfig as B, type AgentOwnershipMode as C, type AgentPriorityMode as D, type AgentWorkArbitrationDecision as E, createAgentLoop as F, type IntentSignals as I, type LaneMode as L, type ObjectiveChangeProposal as O, type PromptShieldDecision as P, type LaneSwitchDecision as a, type ObjectiveChangeSourceTrust as b, type ObjectiveGuardDecision as c, type ObjectiveGuardPolicy as d, type PromptShieldFlag as e, type PromptShieldInput as f, type PromptShieldPolicy as g, type PromptShieldRisk as h, type PromptShieldTrustLevel as i, applyIntentArbitration as j, evaluateLaneSwitch as k, evaluateObjectiveChange as l, evaluatePromptShield as m, scorePolishLane as n, type AgentHumanDemand as o, type AgentLoopAutonomyConfig as p, type AgentLoopConfig as q, type AgentLoopContext as r, scoreBuildLane as s, type AgentLoopDurabilityConfig as t, type AgentLoopEscapeHatchConfig as u, type AgentLoopEscapeHatchInput as v, type AgentLoopHooks as w, type AgentLoopMemoryConfig as x, type AgentLoopObjectiveGuardConfig as y, type AgentLoopPromptShieldConfig as z };

package/dist/agentLoop.d.ts

@@ -3,4 +3,4 @@ import './survivalPlaybook.js';
 import './survivalEscapeHatch.js';
 import './compoundingMemory.js';
 import './strictMemoryRuntime.js';
-export { A as AgentHumanDemand, o as AgentLoopAutonomyConfig, p as AgentLoopConfig, q as AgentLoopContext, r as AgentLoopDurabilityConfig, t as AgentLoopEscapeHatchConfig, u as AgentLoopEscapeHatchInput, v as AgentLoopHooks, w as AgentLoopMemoryConfig, x as AgentLoopObjectiveGuardConfig, y as AgentLoopPromptShieldConfig, z as AgentLoopStrictMemoryConfig, B as AgentOwnershipMode, C as AgentPriorityMode, D as AgentWorkArbitrationDecision, E as createAgentLoop } from './agentLoop-34znzMPv.js';
+export { A as AgentAutonomousTaskKind, o as AgentHumanDemand, p as AgentLoopAutonomyConfig, q as AgentLoopConfig, r as AgentLoopContext, t as AgentLoopDurabilityConfig, u as AgentLoopEscapeHatchConfig, v as AgentLoopEscapeHatchInput, w as AgentLoopHooks, x as AgentLoopMemoryConfig, y as AgentLoopObjectiveGuardConfig, z as AgentLoopPromptShieldConfig, B as AgentLoopStrictMemoryConfig, C as AgentOwnershipMode, D as AgentPriorityMode, E as AgentResearchSnapshot, F as AgentWorkArbitrationDecision, G as createAgentLoop } from './agentLoop-BPj6daJf.js';

package/dist/agentLoop.js

@@ -73,6 +73,8 @@ var createAgentLoop = (config) => {
   const rolloutMode = config.autonomy?.rolloutMode ?? "enforce";
   const laneSwitchEnabled = config.autonomy?.intentPolicy?.laneSwitch?.enabled ?? true;
   const laneSwitchBuilderThreshold = config.autonomy?.intentPolicy?.laneSwitch?.builderOnGreenStreak ?? 3;
+  const researchGateEnabled = config.autonomy?.intentPolicy?.researchGate?.enabled ?? true;
+  const researchGateMaxAgeMs = config.autonomy?.intentPolicy?.researchGate?.maxAgeMs ?? 6 * 36e5;
   let laneState = { lane: "polish", greenStreak: 0 };
   const strictMemoryUpgrade = upgradeToStrictMemoryRuntimePreset({
     current: strictMemoryPreset,
@@ -272,6 +274,16 @@ var createAgentLoop = (config) => {
       builderObjectiveAvailable: asBoolean(raw.builderObjectiveAvailable)
     };
   };
+  const resolveResearchSnapshot = async (input) => {
+    const fromConfig = await config.autonomy?.intentPolicy?.researchGate?.resolveSnapshot?.(input);
+    if (fromConfig) return fromConfig;
+    const raw = input.snapshot;
+    const generatedAt = typeof raw.builderResearchGeneratedAt === "string" ? raw.builderResearchGeneratedAt : typeof raw.researchGeneratedAt === "string" ? raw.researchGeneratedAt : void 0;
+    const summary = typeof raw.builderResearchSummary === "string" ? raw.builderResearchSummary : typeof raw.researchSummary === "string" ? raw.researchSummary : void 0;
+    const recommendation = typeof raw.builderResearchRecommendation === "string" ? raw.builderResearchRecommendation : typeof raw.researchRecommendation === "string" ? raw.researchRecommendation : void 0;
+    if (!generatedAt && !summary && !recommendation) return null;
+    return { generatedAt, summary, recommendation };
+  };
   const runOnce = async () => {
     try {
       const memoryUpgrade = await ensureMemoryUpgrade();
@@ -350,6 +362,7 @@ var createAgentLoop = (config) => {
         humanDemand,
         runHumanTask: true,
         runAutonomousTask: false,
+        autonomousTaskKind: "polish_existing_product",
         reason: "legacy_onAct"
       };
       let laneDecision;
@@ -407,6 +420,8 @@ var createAgentLoop = (config) => {
           }
         }
       }
+      arbitrationBase.autonomousTaskKind = arbitrationBase.runAutonomousTask && !humanDemand.pending ? "build_new_product" : "polish_existing_product";
+      const researchSnapshot = await resolveResearchSnapshot({ snapshot, survivalMode, humanDemand });
       const ctx = {
         snapshot,
         survivalState,
@@ -425,6 +440,7 @@ var createAgentLoop = (config) => {
         objectiveGuardDecision,
         workArbitration: arbitrationBase,
         laneDecision,
+        researchSnapshot: researchSnapshot || void 0,
         timestamp
       };
       if (hooks.onCycle) await hooks.onCycle(ctx);
@@ -442,7 +458,9 @@ var createAgentLoop = (config) => {
       };
       const runAutonomousTask = async () => {
         if (!config.autonomy?.onAutonomous) return;
-        await config.autonomy.onAutonomous(ctx);
+        await config.autonomy.onAutonomous(ctx, {
+          kind: ctx.workArbitration?.autonomousTaskKind || "polish_existing_product"
+        });
       };
       if (strictMemoryEnabled && strictMode === "enforce" && ctx.strictMemoryEvaluation && !ctx.strictMemoryEvaluation.allowed) {
         const missing = ctx.strictMemoryEvaluation.missingSteps.join(",");
@@ -455,6 +473,19 @@ var createAgentLoop = (config) => {
       if (objectiveGuardEnabled && objectiveGuardMode === "enforce" && ctx.objectiveGuardDecision && !ctx.objectiveGuardDecision.allowObjectiveChange) {
         throw new Error(`objective_guard_blocked:${ctx.objectiveGuardDecision.reason}`);
       }
+      if (rolloutMode === "enforce" && researchGateEnabled && ctx.workArbitration?.runAutonomousTask && ctx.workArbitration?.autonomousTaskKind === "build_new_product") {
+        const generatedAt = ctx.researchSnapshot?.generatedAt;
+        const hasResearch = Boolean(generatedAt || ctx.researchSnapshot?.summary || ctx.researchSnapshot?.recommendation);
+        if (!hasResearch) {
+          throw new Error("research_gate_blocked:missing_research_snapshot");
+        }
+        if (generatedAt) {
+          const ageMs = Date.now() - Date.parse(generatedAt);
+          if (!Number.isFinite(ageMs) || ageMs > researchGateMaxAgeMs) {
+            throw new Error("research_gate_blocked:stale_research_snapshot");
+          }
+        }
+      }
       if (autonomyEnabled && config.autonomy?.onAutonomous && rolloutMode === "enforce") {
         if (ctx.workArbitration?.runHumanTask) await runHumanTask();
         if (ctx.workArbitration?.runAutonomousTask) await runAutonomousTask();

package/dist/index.d.ts

@@ -9,7 +9,7 @@ export { MarketDiscoveryClient, MarketNeed, MarketSignal, deriveMarketNeeds, dis
 export { A as AdapterBestShotChecklistResult, a as AdapterPackKind, b as AdapterPackOptions, c as AdaptiveAdaptationPlan, d as AdaptiveExecution, e as AdaptiveFeedbackAggregate, f as AdaptivePolicyConfig, g as AdaptivePolicyDecision, h as AdaptivePolicyState, i as AdaptiveReflectionStore, j as AdaptiveTheme, k as AdaptiveVerification, l as AgentLaunchRuntimeOptions, m as AgentLaunchRuntimeResult, n as AgentResourceProvidersManifest, o as AgentReviewRuntimeOptions, p as AnalyticsPoint, q as ApiCreditProvider, r as ApiCreditProviderFactoryOptions, s as ApiCreditProviderPreset, t as ApiCreditProviderPresetInput, u as ApiResponse, B as BuybackEvent, C as CONTEXT_PACK_SECTION_ORDER, v as ContextPack, w as ContextPackBudget, x as ContextPackGateOptions, y as ContextPackGateResult, z as ContextPackInput, D as ContextPackOptions, E as ContextPackSectionKey, F as ContextPackSections, G as ContextPackState, H as DurabilityCheckpointWriteOptions, I as DurabilityProxyClientOptions, J as DurabilityRestoreDrillWriteOptions, K as ExecutionAdapter, L as ExecutionApplyResult, M as ExecutionDecisionRecord, N as ExecutionDryRunResult, O as ExecutionPostDeployVerifyResult, P as ExecutionRollbackResult, Q as ExecutionRolloutMode, R as ExecutionRunResult, S as ExecutionValidateResult, T as LISTING_NAME_MAX_LENGTH, U as LISTING_NAME_RECOMMENDED_MAX, V as LISTING_TAGLINE_MAX_LENGTH, W as LISTING_TAGLINE_RECOMMENDED_MAX, X as LaunchProfile, Y as LaunchReadinessInput, Z as LaunchReadinessResult, _ as LeaderboardEntry, $ as LeaderboardQuery, a0 as ListingNamingValidationOptions, a1 as ListingNamingValidationResult, a2 as ListingQuery, a3 as ListingReviewCreatePayload, a4 as ListingReviewResponsePayload, a5 as ListingVersionPayload, a6 as MarketingCampaign, a7 as MarketingLinkOptions, a8 as MemoryPingChallengeResponse, a9 as MemoryPingPayload, aa as OpenRouterCredits, ab as ProcurementCandidate, ac as ProcurementDecision, ad as ProcurementTaskProfile, ae as ProcurementWeights, af as ResourceProviderManifestEntry, ag as ResourceSnapshot, ah as ReviewGate, ai as ReviewGateRecord, aj as ReviewRequiredPayload, ak as RunAdaptiveReflectionOptions, al as RuntimeMigrationInput, am as RuntimeMigrationPlan, an as RuntimeStateSnapshot, ao as SdkAutoUpdatedRestartRequiredError, ap as SdkUpdateCheckOptions, aq as SdkUpdatePolicyCheckOptions, ar as SdkUpdateRequiredError, as as SdkUpdateStatus, TopupDecision, TopupRequest, TreasuryLedgerEvent, TreasuryPolicy, TreasuryPolicyV1, TreasuryState, at as VIBEIAO_IDL, au as VibeClient, av as VibeClientOptions, aw as VibeRegistry, ax as aggregateFeedbackSignals, ay as assertLaunchReady, az as assertSurvivalProvidersConfigured, aA as buildAdaptivePlan, aB as buildBadgeMarkdown, aC as buildClaimMessage, aD as buildDecisionRecord, aE as buildJupiterSwapUrl, aF as buildListingVersionMessage, aG as buildMemoryPingMessage, aH as buildOwnerTransferMessage, aI as buildProcurementPrompt, aJ as buildRaydiumSwapUrl, aK as buildReviewPrompt, aL as buildReviewRequired, aM as buildReviewResponseMessage, aN as buildRuntimeMigrationPlan, aO as buildSdkUpdateCommand, aP as buildShareCopy, aQ as buildShareLink, aR as buildTradeLinks, buildTreasuryLedgerEvent, aS as checkForSdkUpdate, aT as checkForSdkUpdatePolicy, aU as compareVersions, aV as createApiCreditProvider, aW as createApiCreditProviders, aX as createApiCreditProvidersFromManifest, aY as createCampaign, aZ as createContextPack, a_ as createCustomAdapter, a$ as createDurabilityProxyClient, b0 as createServiceApiAdapter, createTreasuryPolicy, b1 as createWebBundledAdapter, b2 as createWebStaticAdapter, b3 as createWorkflowAgentAdapter, b4 as decideProcurementForTask, b5 as estimateContextPackTokens, b6 as evaluateAdaptiveReflectionPolicy, b7 as evaluateContextPackGate, b8 as evaluateLaunchReadiness, evaluateTopupRequest, b9 as getResourceSnapshot, ba as normalizeListingText, bb as rankListingsForTask, bc as runAdapterBestShotChecklist, bd as runAdaptiveReflectionCycle, be as runAgentLaunchRuntime, bf as runAgentLaunchRuntimeCycle, bg as runAgentReviewRuntimeCycle, bh as runExecutionAdapter, bi as sanitizeListingNaming, bj as scoreListingForTask, bk as shouldAnnounceStateChange, treasuryStateFromSnapshot, bl as validateContextPack, bm as validateListingNaming, validateTreasuryPolicy, bn as verifyAdaptiveExecutionReadiness } from './treasuryGuardian.js';
 export { OUTCOME_BOUND_FLOW_SCHEMA, OUTCOME_BOUND_REQUIRED_GATES, OutcomeBoundRequiredGate, OutcomeBoundRunInput, OutcomeBoundRunStatus, assertOutcomeBoundCompleted, evaluateOutcomeBoundRun } from './outcomeBoundFlow.js';
 export { STRICT_MEMORY_RUNTIME_SCHEMA, StrictMemoryEvaluation, StrictMemoryEvaluationInput, StrictMemoryRuntimePreset, StrictMemoryTriggerSet, StrictMemoryUpgradeInput, StrictMemoryUpgradePolicy, StrictMemoryUpgradeResult, createStrictMemoryRuntimePreset, evaluateStrictMemoryExecution, isComplexTask, upgradeToStrictMemoryRuntimePreset } from './strictMemoryRuntime.js';
-export { I as IntentSignals, L as LaneMode, a as LaneSwitchDecision, O as ObjectiveChangeProposal, b as ObjectiveChangeSourceTrust, c as ObjectiveGuardDecision, d as ObjectiveGuardPolicy, P as PromptShieldDecision, e as PromptShieldFlag, f as PromptShieldInput, g as PromptShieldPolicy, h as PromptShieldRisk, i as PromptShieldTrustLevel, j as applyIntentArbitration, k as evaluateLaneSwitch, l as evaluateObjectiveChange, m as evaluatePromptShield, s as scoreBuildLane, n as scorePolishLane } from './agentLoop-34znzMPv.js';
+export { I as IntentSignals, L as LaneMode, a as LaneSwitchDecision, O as ObjectiveChangeProposal, b as ObjectiveChangeSourceTrust, c as ObjectiveGuardDecision, d as ObjectiveGuardPolicy, P as PromptShieldDecision, e as PromptShieldFlag, f as PromptShieldInput, g as PromptShieldPolicy, h as PromptShieldRisk, i as PromptShieldTrustLevel, j as applyIntentArbitration, k as evaluateLaneSwitch, l as evaluateObjectiveChange, m as evaluatePromptShield, s as scoreBuildLane, n as scorePolishLane } from './agentLoop-BPj6daJf.js';
 export { fetchSolBalance, fetchTokenBalance, fetchTokenBalances } from './solana.js';
 import './compoundingMemory.js';
 import '@coral-xyz/anchor';

package/dist/index.js

@@ -1112,7 +1112,7 @@ var ReviewGate = class {
 var DEFAULT_API_BASE = "https://api.vibeiao.com";
 var DEFAULT_WEB_BASE = "https://vibeiao.com";
 var DEFAULT_SDK_PACKAGE = "@vibeiao/sdk";
-var DEFAULT_SDK_VERSION = "0.1.52" ? "0.1.52" : "0.1.4";
+var DEFAULT_SDK_VERSION = "0.1.54" ? "0.1.54" : "0.1.4";
 var DEFAULT_SDK_REGISTRY = "https://registry.npmjs.org";
 var DEFAULT_SDK_POLICY_PATH = "/v1/sdk/policy";
 var DEFAULT_SDK_CHECK_INTERVAL_MS = 1e3 * 60 * 30;

package/dist/treasuryGuardian.d.ts

@@ -8,7 +8,7 @@ import './survivalEscapeHatch.js';
 import './marketDiscovery.js';
 import './outcomeBoundFlow.js';
 import './strictMemoryRuntime.js';
-import './agentLoop-34znzMPv.js';
+import './agentLoop-BPj6daJf.js';
 import './solana.js';
 import './compoundingMemory.js';
 import '@coral-xyz/anchor';
@@ -1474,7 +1474,7 @@ declare class ReviewGate {
     assertClear(listingId: string, wallet: string): void;
 }
 
-declare const compareVersions: (currentVersion: string, latestVersion: string) => 1 | 0 | -1;
+declare const compareVersions: (currentVersion: string, latestVersion: string) => 0 | 1 | -1;
 declare const buildSdkUpdateCommand: (packageName?: string) => string;
 declare const checkForSdkUpdate: (options?: SdkUpdateCheckOptions) => Promise<SdkUpdateStatus>;
 declare const checkForSdkUpdatePolicy: (options: SdkUpdatePolicyCheckOptions) => Promise<SdkUpdateStatus>;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@vibeiao/sdk",
   "private": false,
   "type": "module",
-  "version": "0.1.53",
+  "version": "0.1.55",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {