@vibeiao/sdk 0.1.48 → 0.1.50

package/README.md

@@ -697,6 +697,7 @@ Adapter packs + migration helpers:
 - use `runAgentLaunchRuntimeCycle` (alias of launch runtime) to enforce launch gate before publish execution
 - use `buildRuntimeMigrationPlan` to migrate legacy runtime scripts to adapter-based review runtime
 - use `shouldAnnounceStateChange` to suppress repetitive green cron/runtime notifications and only emit meaningful changes
+- use intent arbitration in `createAgentLoop` autonomy config to balance build lane (new value) and polish lane (review-driven fixes) against survival mode
 
 You can also enforce dual-mode work arbitration:
 - `owner_bound` agents: human-first (owner work preempts autonomous work)

package/dist/agentLoop-Dn6aMtRD.d.ts

@@ -0,0 +1,302 @@
+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;
+};
+declare const scoreBuildLane: (signals: IntentSignals, survivalMode: SurvivalMode) => number;
+declare const scorePolishLane: (signals: IntentSignals, survivalMode: SurvivalMode, humanDemand: AgentHumanDemand) => number;
+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 AgentWorkArbitrationDecision = {
+    ownershipMode: AgentOwnershipMode;
+    priorityMode: AgentPriorityMode;
+    rolloutMode: 'observe' | 'enforce';
+    humanDemand: AgentHumanDemand;
+    runHumanTask: boolean;
+    runAutonomousTask: boolean;
+    reason: string;
+};
+type AgentLoopAutonomyConfig = {
+    enabled?: boolean;
+    ownershipMode?: AgentOwnershipMode;
+    priorityMode?: AgentPriorityMode;
+    rolloutMode?: 'observe' | 'enforce';
+    resolveHumanDemand?: () => Promise<boolean | AgentHumanDemand> | boolean | AgentHumanDemand;
+    intentPolicy?: {
+        enabled?: boolean;
+        resolveSignals?: (ctx: {
+            snapshot: ResourceSnapshot;
+            survivalMode: SurvivalMode;
+            humanDemand: AgentHumanDemand;
+        }) => Promise<IntentSignals | null> | IntentSignals | null;
+    };
+    onAutonomous?: (ctx: AgentLoopContext) => 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;
+    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 AgentHumanDemand as A, type AgentWorkArbitrationDecision as B, createAgentLoop as C, type IntentSignals as I, type ObjectiveChangeProposal as O, type PromptShieldDecision as P, type ObjectiveChangeSourceTrust as a, type ObjectiveGuardDecision as b, type ObjectiveGuardPolicy as c, type PromptShieldFlag as d, type PromptShieldInput as e, type PromptShieldPolicy as f, type PromptShieldRisk as g, type PromptShieldTrustLevel as h, applyIntentArbitration as i, evaluateObjectiveChange as j, evaluatePromptShield as k, scorePolishLane as l, type AgentLoopAutonomyConfig as m, type AgentLoopConfig as n, type AgentLoopContext as o, type AgentLoopDurabilityConfig as p, type AgentLoopEscapeHatchConfig as q, type AgentLoopEscapeHatchInput as r, scoreBuildLane as s, type AgentLoopHooks as t, type AgentLoopMemoryConfig as u, type AgentLoopObjectiveGuardConfig as v, type AgentLoopPromptShieldConfig as w, type AgentLoopStrictMemoryConfig as x, type AgentOwnershipMode as y, type AgentPriorityMode as z };

package/dist/agentLoop.d.ts

@@ -1,226 +1,6 @@
-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';
-import { P as PromptShieldDecision, O as ObjectiveGuardDecision, a as PromptShieldPolicy, b as PromptShieldInput, c as ObjectiveGuardPolicy, d as ObjectiveChangeProposal } from './objectiveGuard-d1x0xgAD.js';
-
-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 AgentWorkArbitrationDecision = {
-    ownershipMode: AgentOwnershipMode;
-    priorityMode: AgentPriorityMode;
-    rolloutMode: 'observe' | 'enforce';
-    humanDemand: AgentHumanDemand;
-    runHumanTask: boolean;
-    runAutonomousTask: boolean;
-    reason: string;
-};
-type AgentLoopAutonomyConfig = {
-    enabled?: boolean;
-    ownershipMode?: AgentOwnershipMode;
-    priorityMode?: AgentPriorityMode;
-    rolloutMode?: 'observe' | 'enforce';
-    resolveHumanDemand?: () => Promise<boolean | AgentHumanDemand> | boolean | AgentHumanDemand;
-    onAutonomous?: (ctx: AgentLoopContext) => 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;
-    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 AgentHumanDemand, type AgentLoopAutonomyConfig, type AgentLoopConfig, type AgentLoopContext, type AgentLoopDurabilityConfig, type AgentLoopEscapeHatchConfig, type AgentLoopEscapeHatchInput, type AgentLoopHooks, type AgentLoopMemoryConfig, type AgentLoopObjectiveGuardConfig, type AgentLoopPromptShieldConfig, type AgentLoopStrictMemoryConfig, type AgentOwnershipMode, type AgentPriorityMode, type AgentWorkArbitrationDecision, createAgentLoop };
+import './selfReliance.js';
+import './survivalPlaybook.js';
+import './survivalEscapeHatch.js';
+import './compoundingMemory.js';
+import './strictMemoryRuntime.js';
+export { A as AgentHumanDemand, m as AgentLoopAutonomyConfig, n as AgentLoopConfig, o as AgentLoopContext, p as AgentLoopDurabilityConfig, q as AgentLoopEscapeHatchConfig, r as AgentLoopEscapeHatchInput, t as AgentLoopHooks, u as AgentLoopMemoryConfig, v as AgentLoopObjectiveGuardConfig, w as AgentLoopPromptShieldConfig, x as AgentLoopStrictMemoryConfig, y as AgentOwnershipMode, z as AgentPriorityMode, B as AgentWorkArbitrationDecision, C as createAgentLoop } from './agentLoop-Dn6aMtRD.js';

package/dist/agentLoop.js

@@ -3,10 +3,11 @@ import {
   upgradeCompoundingMemorySystem
 } from "./chunk-JJNRDU7F.js";
 import {
+  applyIntentArbitration,
   createDurabilityProxyClient,
   evaluateObjectiveChange,
   evaluatePromptShield
-} from "./chunk-EKV2BZMZ.js";
+} from "./chunk-WFOLCIJC.js";
 import {
   createSelfRelianceMonitor
 } from "./chunk-M7DQTU5R.js";
@@ -252,6 +253,18 @@ var createAgentLoop = (config) => {
       source: raw.source
     };
   };
+  const resolveIntentSignals = async (input) => {
+    const fromConfig = await config.autonomy?.intentPolicy?.resolveSignals?.(input);
+    if (fromConfig) return fromConfig;
+    const raw = input.snapshot;
+    return {
+      expectedBuildValue: asFiniteNumber(raw.expectedBuildValue),
+      expectedBuildRevenue: asFiniteNumber(raw.expectedBuildRevenue),
+      expectedPolishValue: asFiniteNumber(raw.expectedPolishValue),
+      expectedPolishRevenueProtection: asFiniteNumber(raw.expectedPolishRevenueProtection),
+      urgentUserDemand: asBoolean(raw.urgentUserDemand)
+    };
+  };
   const runOnce = async () => {
     try {
       const memoryUpgrade = await ensureMemoryUpgrade();
@@ -342,6 +355,18 @@ var createAgentLoop = (config) => {
           arbitrationBase.runAutonomousTask = true;
           arbitrationBase.reason = humanDemand.pending ? "autonomous_first_with_human_pending" : "autonomous_first_idle";
         }
+        const intentEnabled = config.autonomy?.intentPolicy?.enabled ?? true;
+        if (intentEnabled) {
+          const intentSignals = await resolveIntentSignals({ snapshot, survivalMode, humanDemand });
+          Object.assign(
+            arbitrationBase,
+            applyIntentArbitration({
+              base: arbitrationBase,
+              survivalMode,
+              signals: intentSignals || void 0
+            })
+          );
+        }
       }
       const ctx = {
         snapshot,

package/dist/chunk-WFOLCIJC.js

@@ -0,0 +1,294 @@
+// src/durabilityProxy.ts
+var withTimeout = async (fetcher, input, init, timeoutMs) => {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetcher(input, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var readJson = async (response) => {
+  const text = await response.text();
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { raw: text };
+  }
+};
+var createDurabilityProxyClient = (options) => {
+  const fetcher = options.fetcher || fetch;
+  const timeoutMs = Number.isFinite(Number(options.timeoutMs)) ? Math.max(500, Number(options.timeoutMs)) : 8e3;
+  const base = String(options.baseUrl || "").replace(/\/+$/, "");
+  const agentId = String(options.agentId || "").trim();
+  const agentToken = String(options.agentToken || "").trim();
+  if (!base) throw new Error("durability_proxy_base_missing");
+  if (!agentId) throw new Error("durability_proxy_agent_id_missing");
+  if (!agentToken) throw new Error("durability_proxy_agent_token_missing");
+  const headers = {
+    "content-type": "application/json",
+    "x-agent-id": agentId,
+    "x-agent-token": agentToken
+  };
+  return {
+    async writeCheckpoint(payloadJson, opts = {}) {
+      const response = await withTimeout(
+        fetcher,
+        `${base}/v1/checkpoints`,
+        {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            payloadJson,
+            sha256: opts.sha256,
+            contentType: opts.contentType,
+            metadata: opts.metadata
+          })
+        },
+        timeoutMs
+      );
+      const body = await readJson(response);
+      if (!response.ok) {
+        const detail = body?.error || `http_${response.status}`;
+        throw new Error(`durability_checkpoint_write_failed:${detail}`);
+      }
+      return body;
+    },
+    async latestCheckpoint() {
+      const response = await withTimeout(
+        fetcher,
+        `${base}/v1/checkpoints/latest`,
+        { method: "GET", headers: { "x-agent-id": agentId, "x-agent-token": agentToken } },
+        timeoutMs
+      );
+      const body = await readJson(response);
+      if (!response.ok) {
+        const detail = body?.error || `http_${response.status}`;
+        throw new Error(`durability_checkpoint_latest_failed:${detail}`);
+      }
+      return body;
+    },
+    async writeRestoreDrill(ok, opts = {}) {
+      const response = await withTimeout(
+        fetcher,
+        `${base}/v1/checkpoints/restore-drill`,
+        {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            checkpointId: opts.checkpointId,
+            ok,
+            details: opts.details
+          })
+        },
+        timeoutMs
+      );
+      const body = await readJson(response);
+      if (!response.ok) {
+        const detail = body?.error || `http_${response.status}`;
+        throw new Error(`durability_restore_drill_write_failed:${detail}`);
+      }
+      return body;
+    }
+  };
+};
+
+// src/promptShield.ts
+var RULES = [
+  {
+    flag: "instruction_override",
+    risk: "high",
+    test: [/ignore\s+(all\s+)?previous/i, /disregard\s+instructions/i, /new\s+system\s+prompt/i]
+  },
+  {
+    flag: "credential_exfiltration",
+    risk: "high",
+    test: [/api\s*key/i, /private\s*key/i, /seed\s*phrase/i, /wallet\s*secret/i, /send\s+me\s+your\s+token/i]
+  },
+  {
+    flag: "destructive_command",
+    risk: "high",
+    test: [/\brm\s+-rf\b/i, /drop\s+database/i, /delete\s+all/i, /overwrite\s+memory/i]
+  },
+  {
+    flag: "authority_spoof",
+    risk: "medium",
+    test: [/as\s+your\s+owner/i, /authorized\s+admin/i, /from\s+charles/i]
+  }
+];
+var rankRisk = (a, b) => {
+  const w = { low: 1, medium: 2, high: 3 };
+  return w[a] >= w[b] ? a : b;
+};
+var toDefaultBlockSet = () => /* @__PURE__ */ new Set(["instruction_override", "credential_exfiltration", "destructive_command", "authority_spoof", "sensitive_action_without_trust"]);
+var evaluatePromptShield = (inputs, options = {}) => {
+  const policy = options.policy || {};
+  const blockSet = policy.blockOnFlags ? new Set(policy.blockOnFlags) : toDefaultBlockSet();
+  const rationale = [];
+  const blockedInputs = [];
+  const flags = /* @__PURE__ */ new Set();
+  let risk = "low";
+  for (const input of inputs) {
+    if (input.trust !== "external_untrusted") continue;
+    const text = String(input.content || "");
+    for (const rule of RULES) {
+      if (rule.test.some((rx) => rx.test(text))) {
+        flags.add(rule.flag);
+        risk = rankRisk(risk, rule.risk);
+      }
+    }
+  }
+  if (options.isSensitiveAction) {
+    const hasTrusted = inputs.some((i) => i.trust === "trusted_human" || i.trust === "internal_system");
+    if (!hasTrusted) {
+      flags.add("sensitive_action_without_trust");
+      risk = rankRisk(risk, "high");
+      rationale.push("Sensitive action lacks trusted human/system intent; external input cannot authorize mutation.");
+    }
+  }
+  const blocked = [...flags].some((f) => blockSet.has(f));
+  if (blocked) {
+    for (const input of inputs) {
+      if (input.trust === "external_untrusted") blockedInputs.push(input);
+    }
+  }
+  if (!flags.size) {
+    rationale.push("No injection indicators detected in untrusted sources.");
+  } else {
+    rationale.push(`Detected prompt-shield flags: ${[...flags].join(",")}`);
+  }
+  if (policy.allowUntrustedForAnalysisOnly && blocked) {
+    rationale.push("Untrusted content may be used for analysis only; execution remains blocked.");
+  }
+  return {
+    allow: !blocked,
+    risk,
+    flags: [...flags],
+    rationale,
+    blockedInputs
+  };
+};
+
+// src/objectiveGuard.ts
+var normalize = (v) => String(v || "").trim().toLowerCase();
+var isExplicitInstruction = (text) => /\b(do this instead|switch objective|change objective|stop current objective|ignore current objective)\b/i.test(
+  text || ""
+);
+var missionAlignment = (currentObjective, proposedObjective) => {
+  const a = new Set(normalize(currentObjective).split(/\W+/).filter(Boolean));
+  const b = new Set(normalize(proposedObjective).split(/\W+/).filter(Boolean));
+  if (!a.size || !b.size) return false;
+  let overlap = 0;
+  for (const tok of b) if (a.has(tok)) overlap += 1;
+  return overlap / Math.max(1, b.size) >= 0.2;
+};
+var evaluateObjectiveChange = (proposal, policy = {}) => {
+  const requireMissionAlignment = policy.requireMissionAlignment ?? true;
+  const requireEvidenceVerification = policy.requireEvidenceVerification ?? true;
+  const allowExternalExplicitInstruction = policy.allowExternalExplicitInstruction ?? false;
+  const explicitInstruction = isExplicitInstruction(proposal.proposedObjective) || isExplicitInstruction(proposal.rationale || "");
+  const missionAligned = missionAlignment(proposal.currentObjective, proposal.proposedObjective);
+  const evidence = Array.isArray(proposal.evidence) ? proposal.evidence : [];
+  const evidenceProvided = evidence.length > 0;
+  const evidenceVerified = evidenceProvided && evidence.every((e) => e.verified === true);
+  if (proposal.trust === "trusted_human" || proposal.trust === "internal_system") {
+    return {
+      allowObjectiveChange: true,
+      reason: "trusted_source_override",
+      checks: { explicitInstruction, missionAligned, evidenceProvided, evidenceVerified },
+      risk: "low"
+    };
+  }
+  if (explicitInstruction && !allowExternalExplicitInstruction) {
+    return {
+      allowObjectiveChange: false,
+      reason: "external_explicit_instruction_blocked",
+      checks: { explicitInstruction, missionAligned, evidenceProvided, evidenceVerified },
+      risk: "high"
+    };
+  }
+  if (requireMissionAlignment && !missionAligned) {
+    return {
+      allowObjectiveChange: false,
+      reason: "mission_alignment_failed",
+      checks: { explicitInstruction, missionAligned, evidenceProvided, evidenceVerified },
+      risk: "high"
+    };
+  }
+  if (!evidenceProvided) {
+    return {
+      allowObjectiveChange: false,
+      reason: "evidence_missing",
+      checks: { explicitInstruction, missionAligned, evidenceProvided, evidenceVerified },
+      risk: "medium"
+    };
+  }
+  if (requireEvidenceVerification && !evidenceVerified) {
+    return {
+      allowObjectiveChange: false,
+      reason: "evidence_unverified",
+      checks: { explicitInstruction, missionAligned, evidenceProvided, evidenceVerified },
+      risk: "high"
+    };
+  }
+  return {
+    allowObjectiveChange: true,
+    reason: "reasoned_external_change_allowed",
+    checks: { explicitInstruction, missionAligned, evidenceProvided, evidenceVerified },
+    risk: "low"
+  };
+};
+
+// src/intentArbitration.ts
+var clamp = (n) => Math.max(0, Math.min(1, n));
+var scoreBuildLane = (signals, survivalMode) => {
+  const value = clamp(signals.expectedBuildValue ?? 0.5);
+  const revenue = clamp(signals.expectedBuildRevenue ?? 0.5);
+  const base = value * 0.55 + revenue * 0.45;
+  if (survivalMode === "SURVIVE") return clamp(base + 0.1 * revenue);
+  if (survivalMode === "BLINK") return clamp(base * 0.6);
+  return base;
+};
+var scorePolishLane = (signals, survivalMode, humanDemand) => {
+  const value = clamp(signals.expectedPolishValue ?? (humanDemand.pending ? 0.8 : 0.4));
+  const protect = clamp(signals.expectedPolishRevenueProtection ?? (humanDemand.pending ? 0.7 : 0.4));
+  const demandBoost = humanDemand.pending || signals.urgentUserDemand ? 0.2 : 0;
+  const base = clamp(value * 0.6 + protect * 0.4 + demandBoost);
+  if (survivalMode === "BLINK") return clamp(base * 0.8);
+  return base;
+};
+var applyIntentArbitration = (input) => {
+  const { base, survivalMode } = input;
+  const signals = input.signals || {};
+  const buildScore = scoreBuildLane(signals, survivalMode);
+  const polishScore = scorePolishLane(signals, survivalMode, base.humanDemand);
+  const out = { ...base };
+  if (base.ownershipMode === "owner_bound" && base.humanDemand.pending) {
+    out.runHumanTask = true;
+    out.runAutonomousTask = base.priorityMode === "autonomous_first" ? buildScore >= 0.5 : buildScore >= 0.65;
+    out.reason = out.runAutonomousTask ? "intent_parallel_build_and_polish" : "intent_polish_preempts_build";
+    return out;
+  }
+  if (!base.humanDemand.pending) {
+    out.runHumanTask = false;
+    out.runAutonomousTask = buildScore >= 0.45 || polishScore >= 0.45;
+    out.reason = out.runAutonomousTask ? "intent_build_or_polish_window" : "intent_hold_low_expected_value";
+    return out;
+  }
+  if (base.ownershipMode === "unbound") {
+    out.runAutonomousTask = true;
+    out.runHumanTask = true;
+    out.reason = "intent_unbound_parallel";
+  }
+  return out;
+};
+
+export {
+  createDurabilityProxyClient,
+  evaluatePromptShield,
+  evaluateObjectiveChange,
+  scoreBuildLane,
+  scorePolishLane,
+  applyIntentArbitration
+};

package/dist/index.d.ts

@@ -6,9 +6,10 @@ export { SurvivalMode, SurvivalRecommendation, classifySurvivalMode, formatSurvi
 export { SurvivalIntegrationDecision, getSurvivalPlaybookDecision, getSurvivalPlaybookDecisionFromSelfReliance } from './survivalIntegration.js';
 export { EscapeHatchDecision, EscapeHatchPolicy, EscapeHatchSnapshot, evaluateEscapeHatch, formatEscapeHatchDecision } from './survivalEscapeHatch.js';
 export { MarketDiscoveryClient, MarketNeed, MarketSignal, deriveMarketNeeds, discoverMarketNeeds, extractMarketSignals, runMarketDiscovery } from './marketDiscovery.js';
-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 ContextPackInput, y as ContextPackOptions, z as ContextPackSectionKey, D as ContextPackSections, E as DurabilityCheckpointWriteOptions, F as DurabilityProxyClientOptions, G as DurabilityRestoreDrillWriteOptions, H as ExecutionAdapter, I as ExecutionApplyResult, J as ExecutionDecisionRecord, K as ExecutionDryRunResult, L as ExecutionRollbackResult, M as ExecutionRolloutMode, N as ExecutionRunResult, O as ExecutionValidateResult, P as LISTING_NAME_MAX_LENGTH, Q as LISTING_NAME_RECOMMENDED_MAX, R as LISTING_TAGLINE_MAX_LENGTH, S as LISTING_TAGLINE_RECOMMENDED_MAX, T as LaunchProfile, U as LaunchReadinessInput, V as LaunchReadinessResult, W as LeaderboardEntry, X as LeaderboardQuery, Y as ListingNamingValidationOptions, Z as ListingNamingValidationResult, _ as ListingQuery, $ as ListingReviewCreatePayload, a0 as ListingReviewResponsePayload, a1 as ListingVersionPayload, a2 as MarketingCampaign, a3 as MarketingLinkOptions, a4 as MemoryPingChallengeResponse, a5 as MemoryPingPayload, a6 as OpenRouterCredits, a7 as ProcurementCandidate, a8 as ProcurementDecision, a9 as ProcurementTaskProfile, aa as ProcurementWeights, ab as ResourceProviderManifestEntry, ac as ResourceSnapshot, ad as ReviewGate, ae as ReviewGateRecord, af as ReviewRequiredPayload, ag as RunAdaptiveReflectionOptions, ah as RuntimeMigrationInput, ai as RuntimeMigrationPlan, aj as RuntimeStateSnapshot, ak as SdkAutoUpdatedRestartRequiredError, al as SdkUpdateCheckOptions, am as SdkUpdatePolicyCheckOptions, an as SdkUpdateRequiredError, ao as SdkUpdateStatus, TopupDecision, TopupRequest, TreasuryLedgerEvent, TreasuryPolicy, TreasuryPolicyV1, TreasuryState, ap as VIBEIAO_IDL, aq as VibeClient, ar as VibeClientOptions, as as VibeRegistry, at as aggregateFeedbackSignals, au as assertLaunchReady, av as assertSurvivalProvidersConfigured, aw as buildAdaptivePlan, ax as buildBadgeMarkdown, ay as buildClaimMessage, az as buildDecisionRecord, aA as buildJupiterSwapUrl, aB as buildListingVersionMessage, aC as buildMemoryPingMessage, aD as buildOwnerTransferMessage, aE as buildProcurementPrompt, aF as buildRaydiumSwapUrl, aG as buildReviewPrompt, aH as buildReviewRequired, aI as buildReviewResponseMessage, aJ as buildRuntimeMigrationPlan, aK as buildSdkUpdateCommand, aL as buildShareCopy, aM as buildShareLink, aN as buildTradeLinks, buildTreasuryLedgerEvent, aO as checkForSdkUpdate, aP as checkForSdkUpdatePolicy, aQ as compareVersions, aR as createApiCreditProvider, aS as createApiCreditProviders, aT as createApiCreditProvidersFromManifest, aU as createCampaign, aV as createContextPack, aW as createCustomAdapter, aX as createDurabilityProxyClient, aY as createServiceApiAdapter, createTreasuryPolicy, aZ as createWebBundledAdapter, a_ as createWebStaticAdapter, a$ as createWorkflowAgentAdapter, b0 as decideProcurementForTask, b1 as estimateContextPackTokens, b2 as evaluateAdaptiveReflectionPolicy, b3 as evaluateLaunchReadiness, evaluateTopupRequest, b4 as getResourceSnapshot, b5 as normalizeListingText, b6 as rankListingsForTask, b7 as runAdapterBestShotChecklist, b8 as runAdaptiveReflectionCycle, b9 as runAgentLaunchRuntime, ba as runAgentLaunchRuntimeCycle, bb as runAgentReviewRuntimeCycle, bc as runExecutionAdapter, bd as sanitizeListingNaming, be as scoreListingForTask, bf as shouldAnnounceStateChange, treasuryStateFromSnapshot, bg as validateContextPack, bh as validateListingNaming, validateTreasuryPolicy, bi as verifyAdaptiveExecutionReadiness } from './treasuryGuardian.js';
+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 ExecutionRollbackResult, P as ExecutionRolloutMode, Q as ExecutionRunResult, R as ExecutionValidateResult, S as LISTING_NAME_MAX_LENGTH, T as LISTING_NAME_RECOMMENDED_MAX, U as LISTING_TAGLINE_MAX_LENGTH, V as LISTING_TAGLINE_RECOMMENDED_MAX, W as LaunchProfile, X as LaunchReadinessInput, Y as LaunchReadinessResult, Z as LeaderboardEntry, _ as LeaderboardQuery, $ as ListingNamingValidationOptions, a0 as ListingNamingValidationResult, a1 as ListingQuery, a2 as ListingReviewCreatePayload, a3 as ListingReviewResponsePayload, a4 as ListingVersionPayload, a5 as MarketingCampaign, a6 as MarketingLinkOptions, a7 as MemoryPingChallengeResponse, a8 as MemoryPingPayload, a9 as OpenRouterCredits, aa as ProcurementCandidate, ab as ProcurementDecision, ac as ProcurementTaskProfile, ad as ProcurementWeights, ae as ResourceProviderManifestEntry, af as ResourceSnapshot, ag as ReviewGate, ah as ReviewGateRecord, ai as ReviewRequiredPayload, aj as RunAdaptiveReflectionOptions, ak as RuntimeMigrationInput, al as RuntimeMigrationPlan, am as RuntimeStateSnapshot, an as SdkAutoUpdatedRestartRequiredError, ao as SdkUpdateCheckOptions, ap as SdkUpdatePolicyCheckOptions, aq as SdkUpdateRequiredError, ar as SdkUpdateStatus, TopupDecision, TopupRequest, TreasuryLedgerEvent, TreasuryPolicy, TreasuryPolicyV1, TreasuryState, as as VIBEIAO_IDL, at as VibeClient, au as VibeClientOptions, av as VibeRegistry, aw as aggregateFeedbackSignals, ax as assertLaunchReady, ay as assertSurvivalProvidersConfigured, az as buildAdaptivePlan, aA as buildBadgeMarkdown, aB as buildClaimMessage, aC as buildDecisionRecord, aD as buildJupiterSwapUrl, aE as buildListingVersionMessage, aF as buildMemoryPingMessage, aG as buildOwnerTransferMessage, aH as buildProcurementPrompt, aI as buildRaydiumSwapUrl, aJ as buildReviewPrompt, aK as buildReviewRequired, aL as buildReviewResponseMessage, aM as buildRuntimeMigrationPlan, aN as buildSdkUpdateCommand, aO as buildShareCopy, aP as buildShareLink, aQ as buildTradeLinks, buildTreasuryLedgerEvent, aR as checkForSdkUpdate, aS as checkForSdkUpdatePolicy, aT as compareVersions, aU as createApiCreditProvider, aV as createApiCreditProviders, aW as createApiCreditProvidersFromManifest, aX as createCampaign, aY as createContextPack, aZ as createCustomAdapter, a_ as createDurabilityProxyClient, a$ as createServiceApiAdapter, createTreasuryPolicy, b0 as createWebBundledAdapter, b1 as createWebStaticAdapter, b2 as createWorkflowAgentAdapter, b3 as decideProcurementForTask, b4 as estimateContextPackTokens, b5 as evaluateAdaptiveReflectionPolicy, b6 as evaluateContextPackGate, b7 as evaluateLaunchReadiness, evaluateTopupRequest, b8 as getResourceSnapshot, b9 as normalizeListingText, ba as rankListingsForTask, bb as runAdapterBestShotChecklist, bc as runAdaptiveReflectionCycle, bd as runAgentLaunchRuntime, be as runAgentLaunchRuntimeCycle, bf as runAgentReviewRuntimeCycle, bg as runExecutionAdapter, bh as sanitizeListingNaming, bi as scoreListingForTask, bj as shouldAnnounceStateChange, treasuryStateFromSnapshot, bk as validateContextPack, bl as validateListingNaming, validateTreasuryPolicy, bm 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 { d as ObjectiveChangeProposal, e as ObjectiveChangeSourceTrust, O as ObjectiveGuardDecision, c as ObjectiveGuardPolicy, P as PromptShieldDecision, f as PromptShieldFlag, b as PromptShieldInput, a as PromptShieldPolicy, g as PromptShieldRisk, h as PromptShieldTrustLevel, i as evaluateObjectiveChange, j as evaluatePromptShield } from './objectiveGuard-d1x0xgAD.js';
+export { I as IntentSignals, O as ObjectiveChangeProposal, a as ObjectiveChangeSourceTrust, b as ObjectiveGuardDecision, c as ObjectiveGuardPolicy, P as PromptShieldDecision, d as PromptShieldFlag, e as PromptShieldInput, f as PromptShieldPolicy, g as PromptShieldRisk, h as PromptShieldTrustLevel, i as applyIntentArbitration, j as evaluateObjectiveChange, k as evaluatePromptShield, s as scoreBuildLane, l as scorePolishLane } from './agentLoop-Dn6aMtRD.js';
 export { fetchSolBalance, fetchTokenBalance, fetchTokenBalances } from './solana.js';
+import './compoundingMemory.js';
 import '@coral-xyz/anchor';

package/dist/index.js

@@ -17,10 +17,13 @@ import {
   validateTreasuryPolicy
 } from "./chunk-RNPCT2MS.js";
 import {
+  applyIntentArbitration,
   createDurabilityProxyClient,
   evaluateObjectiveChange,
-  evaluatePromptShield
-} from "./chunk-EKV2BZMZ.js";
+  evaluatePromptShield,
+  scoreBuildLane,
+  scorePolishLane
+} from "./chunk-WFOLCIJC.js";
 import {
   SelfReliance,
   createAutoSelfReliance,
@@ -589,12 +592,40 @@ var runAdaptiveReflectionCycle = async (opts) => {
   };
 };
 
+// src/contextPackGate.ts
+var evaluateContextPackGate = (options = {}) => {
+  const mode = options.mode || "observe";
+  const complexMutation = options.complexMutation ?? true;
+  const minFacts = options.minFacts ?? 1;
+  if (!complexMutation || mode === "observe" || mode === "shadow") {
+    return { passed: true, reasons: ["context_gate_not_required"] };
+  }
+  const pack = options.contextPack;
+  const reasons = [];
+  if (!pack) reasons.push("missing_context_pack");
+  if (pack && !pack.prepared) reasons.push("context_pack_not_prepared");
+  if (pack && !pack.semanticRecallConfirmed) reasons.push("semantic_recall_not_confirmed");
+  if (pack && (pack.factsCount ?? 0) < minFacts) reasons.push("insufficient_context_pack_facts");
+  return {
+    passed: reasons.length === 0,
+    reasons: reasons.length ? reasons : ["context_pack_gate_passed"]
+  };
+};
+
 // src/agentReviewRuntime.ts
 var runAgentReviewRuntimeCycle = async (opts) => {
   if (!opts.adapter) {
     throw new Error("agent_review_runtime_requires_execution_adapter");
   }
-  return runAdaptiveReflectionCycle({
+  const requestedRolloutMode = opts.rolloutMode || "apply_full";
+  const contextGate = evaluateContextPackGate({
+    mode: requestedRolloutMode,
+    complexMutation: opts.complexMutation ?? true,
+    contextPack: opts.contextPack,
+    minFacts: 1
+  });
+  const effectiveRolloutMode = contextGate.passed ? requestedRolloutMode : "observe";
+  const out = await runAdaptiveReflectionCycle({
     client: opts.client,
     listingId: opts.listingId,
     wallet: opts.wallet,
@@ -604,12 +635,18 @@ var runAgentReviewRuntimeCycle = async (opts) => {
     reflectionOptions: opts.reflectionOptions,
     execution: {
       mode: "apply",
-      rolloutMode: opts.rolloutMode || "apply_full",
+      rolloutMode: effectiveRolloutMode,
       allowImmediateOnly: opts.allowImmediateOnly ?? false,
       adapter: opts.adapter
     },
     now: opts.now
   });
+  return {
+    ...out,
+    contextGate,
+    requestedRolloutMode,
+    effectiveRolloutMode
+  };
 };
 
 // src/launchReadiness.ts
@@ -850,7 +887,15 @@ var runAgentLaunchRuntime = async (options) => {
   }
   const readiness = evaluateLaunchReadiness(readinessInput);
   const minScore = options.minScore ?? 0.8;
-  let verified = readiness.ready && readiness.score >= minScore;
+  const requestedMode = options.rolloutMode || "shadow";
+  const contextGate = evaluateContextPackGate({
+    mode: requestedMode,
+    complexMutation: true,
+    contextPack: options.contextPack,
+    minFacts: 1
+  });
+  auditTrail.push(`context_pack_gate:${contextGate.passed ? "pass" : contextGate.reasons.join("|")}`);
+  let verified = readiness.ready && readiness.score >= minScore && contextGate.passed;
   let overrideApplied = false;
   if (!verified && options.trustedOverride?.actor && options.trustedOverride?.reason) {
     verified = true;
@@ -859,7 +904,8 @@ var runAgentLaunchRuntime = async (options) => {
   }
   const reasons = [
     ...readiness.blockers.length ? readiness.blockers : ["launch_readiness_passed"],
-    ...checklist && !checklist.passed ? ["best_shot_checklist_failed"] : []
+    ...checklist && !checklist.passed ? ["best_shot_checklist_failed"] : [],
+    ...!contextGate.passed ? contextGate.reasons : []
   ];
   const record = buildDecisionRecord({
     decision: verified ? "adapt" : "hold",
@@ -869,7 +915,6 @@ var runAgentLaunchRuntime = async (options) => {
     objective: options.objective || "best_shot_launch",
     nowMs: options.nowMs
   });
-  const requestedMode = options.rolloutMode || "shadow";
   const mode = verified ? requestedMode : "observe";
   const execution = await runExecutionAdapter({
     mode,
@@ -877,7 +922,7 @@ var runAgentLaunchRuntime = async (options) => {
     adapter: options.adapter
   });
   auditTrail.push(`execution:${execution.reason}`);
-  return { readiness, execution, checklist, overrideApplied, auditTrail };
+  return { readiness, execution, checklist, contextGate, overrideApplied, auditTrail };
 };
 var runAgentLaunchRuntimeCycle = runAgentLaunchRuntime;
 
@@ -1043,7 +1088,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.48" ? "0.1.48" : "0.1.4";
+var DEFAULT_SDK_VERSION = "0.1.49" ? "0.1.49" : "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;
@@ -2175,6 +2220,7 @@ export {
   VibeClient,
   VibeRegistry,
   aggregateFeedbackSignals,
+  applyIntentArbitration,
   assertLaunchReady,
   assertOutcomeBoundCompleted,
   assertSurvivalProvidersConfigured,
@@ -2228,6 +2274,7 @@ export {
   discoverMarketNeeds,
   estimateContextPackTokens,
   evaluateAdaptiveReflectionPolicy,
+  evaluateContextPackGate,
   evaluateEscapeHatch,
   evaluateLaunchReadiness,
   evaluateObjectiveChange,
@@ -2257,7 +2304,9 @@ export {
   runMarketDiscovery,
   runReflectionCycle,
   sanitizeListingNaming,
+  scoreBuildLane,
   scoreListingForTask,
+  scorePolishLane,
   scoreReviewPriority,
   shouldAnnounceStateChange,
   treasuryStateFromSnapshot,

package/dist/treasuryGuardian.d.ts

@@ -8,8 +8,9 @@ import './survivalEscapeHatch.js';
 import './marketDiscovery.js';
 import './outcomeBoundFlow.js';
 import './strictMemoryRuntime.js';
-import './objectiveGuard-d1x0xgAD.js';
+import './agentLoop-Dn6aMtRD.js';
 import './solana.js';
+import './compoundingMemory.js';
 import '@coral-xyz/anchor';
 
 declare const VIBEIAO_IDL: {
@@ -1009,6 +1010,24 @@ declare const runAdaptiveReflectionCycle: (opts: RunAdaptiveReflectionOptions) =
     policyState: AdaptivePolicyState;
 }>;
 
+type ContextPackState = {
+    id?: string;
+    prepared?: boolean;
+    semanticRecallConfirmed?: boolean;
+    factsCount?: number;
+};
+type ContextPackGateOptions = {
+    mode?: ExecutionRolloutMode;
+    complexMutation?: boolean;
+    contextPack?: ContextPackState;
+    minFacts?: number;
+};
+type ContextPackGateResult = {
+    passed: boolean;
+    reasons: string[];
+};
+declare const evaluateContextPackGate: (options?: ContextPackGateOptions) => ContextPackGateResult;
+
 type AgentReviewRuntimeOptions = {
     client: ReflectionClient;
     listingId: string;
@@ -1021,12 +1040,17 @@ type AgentReviewRuntimeOptions = {
     allowImmediateOnly?: boolean;
     reflectionOptions?: Omit<ReflectionCycleOptions, 'client' | 'listingId' | 'wallet' | 'signMessage' | 'store'>;
     now?: () => number;
+    contextPack?: ContextPackState;
+    complexMutation?: boolean;
 };
 /**
  * Required default review runtime for VIBEIAO agents.
  * Enforces verify->execute using the execution adapter contract.
  */
 declare const runAgentReviewRuntimeCycle: (opts: AgentReviewRuntimeOptions) => Promise<{
+    contextGate: ContextPackGateResult;
+    requestedRolloutMode: ExecutionRolloutMode;
+    effectiveRolloutMode: ExecutionRolloutMode;
     generatedAt: string;
     aggregate: AdaptiveFeedbackAggregate;
     decision: AdaptivePolicyDecision;
@@ -1111,11 +1135,13 @@ type AgentLaunchRuntimeOptions = {
         actor: string;
         reason: string;
     };
+    contextPack?: ContextPackState;
 };
 type AgentLaunchRuntimeResult = {
     readiness: LaunchReadinessResult;
     execution: Awaited<ReturnType<typeof runExecutionAdapter>>;
     checklist?: AdapterBestShotChecklistResult;
+    contextGate: ContextPackGateResult;
     overrideApplied: boolean;
     auditTrail: string[];
 };
@@ -1437,7 +1463,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>;
@@ -1618,4 +1644,4 @@ declare const getResourceSnapshot: (options: {
     apiBase?: string;
 }) => Promise<ResourceSnapshot>;
 
-export { type ListingReviewCreatePayload as $, type AdapterBestShotChecklistResult as A, type BuybackEvent as B, CONTEXT_PACK_SECTION_ORDER as C, type ContextPackSections as D, type DurabilityCheckpointWriteOptions as E, type DurabilityProxyClientOptions as F, type DurabilityRestoreDrillWriteOptions as G, type ExecutionAdapter as H, type ExecutionApplyResult as I, type ExecutionDecisionRecord as J, type ExecutionDryRunResult as K, type ExecutionRollbackResult as L, type ExecutionRolloutMode as M, type ExecutionRunResult as N, type ExecutionValidateResult as O, LISTING_NAME_MAX_LENGTH as P, LISTING_NAME_RECOMMENDED_MAX as Q, LISTING_TAGLINE_MAX_LENGTH as R, LISTING_TAGLINE_RECOMMENDED_MAX as S, type LaunchProfile as T, type TopupDecision, type TopupRequest, type TreasuryLedgerEvent, type TreasuryPolicy, type TreasuryPolicyV1, type TreasuryState, type LaunchReadinessInput as U, type LaunchReadinessResult as V, type LeaderboardEntry as W, type LeaderboardQuery as X, type ListingNamingValidationOptions as Y, type ListingNamingValidationResult as Z, type ListingQuery as _, type AdapterPackKind as a, createWorkflowAgentAdapter as a$, type ListingReviewResponsePayload as a0, type ListingVersionPayload as a1, type MarketingCampaign as a2, type MarketingLinkOptions as a3, type MemoryPingChallengeResponse as a4, type MemoryPingPayload as a5, type OpenRouterCredits as a6, type ProcurementCandidate as a7, type ProcurementDecision as a8, type ProcurementTaskProfile as a9, buildJupiterSwapUrl as aA, buildListingVersionMessage as aB, buildMemoryPingMessage as aC, buildOwnerTransferMessage as aD, buildProcurementPrompt as aE, buildRaydiumSwapUrl as aF, buildReviewPrompt as aG, buildReviewRequired as aH, buildReviewResponseMessage as aI, buildRuntimeMigrationPlan as aJ, buildSdkUpdateCommand as aK, buildShareCopy as aL, buildShareLink as aM, buildTradeLinks as aN, checkForSdkUpdate as aO, checkForSdkUpdatePolicy as aP, compareVersions as aQ, createApiCreditProvider as aR, createApiCreditProviders as aS, createApiCreditProvidersFromManifest as aT, createCampaign as aU, createContextPack as aV, createCustomAdapter as aW, createDurabilityProxyClient as aX, createServiceApiAdapter as aY, createWebBundledAdapter as aZ, createWebStaticAdapter as a_, type ProcurementWeights as aa, type ResourceProviderManifestEntry as ab, type ResourceSnapshot as ac, ReviewGate as ad, type ReviewGateRecord as ae, type ReviewRequiredPayload as af, type RunAdaptiveReflectionOptions as ag, type RuntimeMigrationInput as ah, type RuntimeMigrationPlan as ai, type RuntimeStateSnapshot as aj, SdkAutoUpdatedRestartRequiredError as ak, type SdkUpdateCheckOptions as al, type SdkUpdatePolicyCheckOptions as am, SdkUpdateRequiredError as an, type SdkUpdateStatus as ao, VIBEIAO_IDL as ap, VibeClient as aq, type VibeClientOptions as ar, VibeRegistry as as, aggregateFeedbackSignals as at, assertLaunchReady as au, assertSurvivalProvidersConfigured as av, buildAdaptivePlan as aw, buildBadgeMarkdown as ax, buildClaimMessage as ay, buildDecisionRecord as az, type AdapterPackOptions as b, decideProcurementForTask as b0, estimateContextPackTokens as b1, evaluateAdaptiveReflectionPolicy as b2, evaluateLaunchReadiness as b3, getResourceSnapshot as b4, normalizeListingText as b5, rankListingsForTask as b6, runAdapterBestShotChecklist as b7, runAdaptiveReflectionCycle as b8, runAgentLaunchRuntime as b9, runAgentLaunchRuntimeCycle as ba, runAgentReviewRuntimeCycle as bb, runExecutionAdapter as bc, sanitizeListingNaming as bd, scoreListingForTask as be, shouldAnnounceStateChange as bf, validateContextPack as bg, validateListingNaming as bh, verifyAdaptiveExecutionReadiness as bi, buildTreasuryLedgerEvent, type AdaptiveAdaptationPlan as c, createTreasuryPolicy, type AdaptiveExecution as d, type AdaptiveFeedbackAggregate as e, evaluateTopupRequest, type AdaptivePolicyConfig as f, type AdaptivePolicyDecision as g, type AdaptivePolicyState as h, type AdaptiveReflectionStore as i, type AdaptiveTheme as j, type AdaptiveVerification as k, type AgentLaunchRuntimeOptions as l, type AgentLaunchRuntimeResult as m, type AgentResourceProvidersManifest as n, type AgentReviewRuntimeOptions as o, type AnalyticsPoint as p, type ApiCreditProvider as q, type ApiCreditProviderFactoryOptions as r, type ApiCreditProviderPreset as s, type ApiCreditProviderPresetInput as t, treasuryStateFromSnapshot, type ApiResponse as u, type ContextPack as v, validateTreasuryPolicy, type ContextPackBudget as w, type ContextPackInput as x, type ContextPackOptions as y, type ContextPackSectionKey as z };
+export { type ListingNamingValidationOptions as $, type AdapterBestShotChecklistResult as A, type BuybackEvent as B, CONTEXT_PACK_SECTION_ORDER as C, type ContextPackOptions as D, type ContextPackSectionKey as E, type ContextPackSections as F, type ContextPackState as G, type DurabilityCheckpointWriteOptions as H, type DurabilityProxyClientOptions as I, type DurabilityRestoreDrillWriteOptions as J, type ExecutionAdapter as K, type ExecutionApplyResult as L, type ExecutionDecisionRecord as M, type ExecutionDryRunResult as N, type ExecutionRollbackResult as O, type ExecutionRolloutMode as P, type ExecutionRunResult as Q, type ExecutionValidateResult as R, LISTING_NAME_MAX_LENGTH as S, LISTING_NAME_RECOMMENDED_MAX as T, type TopupDecision, type TopupRequest, type TreasuryLedgerEvent, type TreasuryPolicy, type TreasuryPolicyV1, type TreasuryState, LISTING_TAGLINE_MAX_LENGTH as U, LISTING_TAGLINE_RECOMMENDED_MAX as V, type LaunchProfile as W, type LaunchReadinessInput as X, type LaunchReadinessResult as Y, type LeaderboardEntry as Z, type LeaderboardQuery as _, type AdapterPackKind as a, createServiceApiAdapter as a$, type ListingNamingValidationResult as a0, type ListingQuery as a1, type ListingReviewCreatePayload as a2, type ListingReviewResponsePayload as a3, type ListingVersionPayload as a4, type MarketingCampaign as a5, type MarketingLinkOptions as a6, type MemoryPingChallengeResponse as a7, type MemoryPingPayload as a8, type OpenRouterCredits as a9, buildBadgeMarkdown as aA, buildClaimMessage as aB, buildDecisionRecord as aC, buildJupiterSwapUrl as aD, buildListingVersionMessage as aE, buildMemoryPingMessage as aF, buildOwnerTransferMessage as aG, buildProcurementPrompt as aH, buildRaydiumSwapUrl as aI, buildReviewPrompt as aJ, buildReviewRequired as aK, buildReviewResponseMessage as aL, buildRuntimeMigrationPlan as aM, buildSdkUpdateCommand as aN, buildShareCopy as aO, buildShareLink as aP, buildTradeLinks as aQ, checkForSdkUpdate as aR, checkForSdkUpdatePolicy as aS, compareVersions as aT, createApiCreditProvider as aU, createApiCreditProviders as aV, createApiCreditProvidersFromManifest as aW, createCampaign as aX, createContextPack as aY, createCustomAdapter as aZ, createDurabilityProxyClient as a_, type ProcurementCandidate as aa, type ProcurementDecision as ab, type ProcurementTaskProfile as ac, type ProcurementWeights as ad, type ResourceProviderManifestEntry as ae, type ResourceSnapshot as af, ReviewGate as ag, type ReviewGateRecord as ah, type ReviewRequiredPayload as ai, type RunAdaptiveReflectionOptions as aj, type RuntimeMigrationInput as ak, type RuntimeMigrationPlan as al, type RuntimeStateSnapshot as am, SdkAutoUpdatedRestartRequiredError as an, type SdkUpdateCheckOptions as ao, type SdkUpdatePolicyCheckOptions as ap, SdkUpdateRequiredError as aq, type SdkUpdateStatus as ar, VIBEIAO_IDL as as, VibeClient as at, type VibeClientOptions as au, VibeRegistry as av, aggregateFeedbackSignals as aw, assertLaunchReady as ax, assertSurvivalProvidersConfigured as ay, buildAdaptivePlan as az, type AdapterPackOptions as b, createWebBundledAdapter as b0, createWebStaticAdapter as b1, createWorkflowAgentAdapter as b2, decideProcurementForTask as b3, estimateContextPackTokens as b4, evaluateAdaptiveReflectionPolicy as b5, evaluateContextPackGate as b6, evaluateLaunchReadiness as b7, getResourceSnapshot as b8, normalizeListingText as b9, rankListingsForTask as ba, runAdapterBestShotChecklist as bb, runAdaptiveReflectionCycle as bc, runAgentLaunchRuntime as bd, runAgentLaunchRuntimeCycle as be, runAgentReviewRuntimeCycle as bf, runExecutionAdapter as bg, sanitizeListingNaming as bh, scoreListingForTask as bi, shouldAnnounceStateChange as bj, validateContextPack as bk, validateListingNaming as bl, verifyAdaptiveExecutionReadiness as bm, buildTreasuryLedgerEvent, type AdaptiveAdaptationPlan as c, createTreasuryPolicy, type AdaptiveExecution as d, type AdaptiveFeedbackAggregate as e, evaluateTopupRequest, type AdaptivePolicyConfig as f, type AdaptivePolicyDecision as g, type AdaptivePolicyState as h, type AdaptiveReflectionStore as i, type AdaptiveTheme as j, type AdaptiveVerification as k, type AgentLaunchRuntimeOptions as l, type AgentLaunchRuntimeResult as m, type AgentResourceProvidersManifest as n, type AgentReviewRuntimeOptions as o, type AnalyticsPoint as p, type ApiCreditProvider as q, type ApiCreditProviderFactoryOptions as r, type ApiCreditProviderPreset as s, type ApiCreditProviderPresetInput as t, treasuryStateFromSnapshot, type ApiResponse as u, type ContextPack as v, validateTreasuryPolicy, type ContextPackBudget as w, type ContextPackGateOptions as x, type ContextPackGateResult as y, type ContextPackInput as z };

package/package.json

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