@vibeiao/sdk 0.1.44 → 0.1.46

package/README.md

@@ -689,6 +689,7 @@ Adaptive reflection policy is available for cadence-based adaptation (not per-re
 - aggregate feedback over time windows and score recurring themes
 - evaluate thresholds + cooldown + daily adaptation caps
 - output `hold|observe|adapt` decision and optional bounded adaptation plan
+- enforce `verify -> execute` sequencing in apply mode (no verify pass => no execution)
 
 You can also enforce dual-mode work arbitration:
 - `owner_bound` agents: human-first (owner work preempts autonomous work)

package/dist/index.d.ts

@@ -6,7 +6,7 @@ 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 AdaptiveAdaptationPlan, a as AdaptiveFeedbackAggregate, b as AdaptivePolicyConfig, c as AdaptivePolicyDecision, d as AdaptivePolicyState, e as AdaptiveReflectionStore, f as AdaptiveTheme, g as AgentResourceProvidersManifest, h as AnalyticsPoint, i as ApiCreditProvider, j as ApiCreditProviderFactoryOptions, k as ApiCreditProviderPreset, l as ApiCreditProviderPresetInput, m as ApiResponse, B as BuybackEvent, C as CONTEXT_PACK_SECTION_ORDER, n as ContextPack, o as ContextPackBudget, p as ContextPackInput, q as ContextPackOptions, r as ContextPackSectionKey, s as ContextPackSections, D as DurabilityCheckpointWriteOptions, t as DurabilityProxyClientOptions, u as DurabilityRestoreDrillWriteOptions, L as LISTING_NAME_MAX_LENGTH, v as LISTING_NAME_RECOMMENDED_MAX, w as LISTING_TAGLINE_MAX_LENGTH, x as LISTING_TAGLINE_RECOMMENDED_MAX, y as LeaderboardEntry, z as LeaderboardQuery, E as ListingNamingValidationOptions, F as ListingNamingValidationResult, G as ListingQuery, H as ListingReviewCreatePayload, I as ListingReviewResponsePayload, J as ListingVersionPayload, M as MarketingCampaign, K as MarketingLinkOptions, N as MemoryPingChallengeResponse, O as MemoryPingPayload, P as OpenRouterCredits, Q as ProcurementCandidate, R as ProcurementDecision, S as ProcurementTaskProfile, T as ProcurementWeights, U as ResourceProviderManifestEntry, V as ResourceSnapshot, W as ReviewGate, X as ReviewGateRecord, Y as ReviewRequiredPayload, Z as RunAdaptiveReflectionOptions, _ as SdkAutoUpdatedRestartRequiredError, $ as SdkUpdateCheckOptions, a0 as SdkUpdatePolicyCheckOptions, a1 as SdkUpdateRequiredError, a2 as SdkUpdateStatus, TopupDecision, TopupRequest, TreasuryLedgerEvent, TreasuryPolicy, TreasuryPolicyV1, TreasuryState, a3 as VIBEIAO_IDL, a4 as VibeClient, a5 as VibeClientOptions, a6 as VibeRegistry, a7 as aggregateFeedbackSignals, a8 as assertSurvivalProvidersConfigured, a9 as buildAdaptivePlan, aa as buildBadgeMarkdown, ab as buildClaimMessage, ac as buildJupiterSwapUrl, ad as buildListingVersionMessage, ae as buildMemoryPingMessage, af as buildOwnerTransferMessage, ag as buildProcurementPrompt, ah as buildRaydiumSwapUrl, ai as buildReviewPrompt, aj as buildReviewRequired, ak as buildReviewResponseMessage, al as buildSdkUpdateCommand, am as buildShareCopy, an as buildShareLink, ao as buildTradeLinks, buildTreasuryLedgerEvent, ap as checkForSdkUpdate, aq as checkForSdkUpdatePolicy, ar as compareVersions, as as createApiCreditProvider, at as createApiCreditProviders, au as createApiCreditProvidersFromManifest, av as createCampaign, aw as createContextPack, ax as createDurabilityProxyClient, createTreasuryPolicy, ay as decideProcurementForTask, az as estimateContextPackTokens, aA as evaluateAdaptiveReflectionPolicy, evaluateTopupRequest, aB as getResourceSnapshot, aC as normalizeListingText, aD as rankListingsForTask, aE as runAdaptiveReflectionCycle, aF as sanitizeListingNaming, aG as scoreListingForTask, treasuryStateFromSnapshot, aH as validateContextPack, aI as validateListingNaming, validateTreasuryPolicy } from './treasuryGuardian.js';
+export { A as AdaptiveAdaptationPlan, a as AdaptiveExecution, b as AdaptiveFeedbackAggregate, c as AdaptivePolicyConfig, d as AdaptivePolicyDecision, e as AdaptivePolicyState, f as AdaptiveReflectionStore, g as AdaptiveTheme, h as AdaptiveVerification, i as AgentResourceProvidersManifest, j as AnalyticsPoint, k as ApiCreditProvider, l as ApiCreditProviderFactoryOptions, m as ApiCreditProviderPreset, n as ApiCreditProviderPresetInput, o as ApiResponse, B as BuybackEvent, C as CONTEXT_PACK_SECTION_ORDER, p as ContextPack, q as ContextPackBudget, r as ContextPackInput, s as ContextPackOptions, t as ContextPackSectionKey, u as ContextPackSections, D as DurabilityCheckpointWriteOptions, v as DurabilityProxyClientOptions, w as DurabilityRestoreDrillWriteOptions, E as ExecutionAdapter, x as ExecutionApplyResult, y as ExecutionDecisionRecord, z as ExecutionDryRunResult, F as ExecutionRollbackResult, G as ExecutionRolloutMode, H as ExecutionRunResult, I as ExecutionValidateResult, L as LISTING_NAME_MAX_LENGTH, J as LISTING_NAME_RECOMMENDED_MAX, K as LISTING_TAGLINE_MAX_LENGTH, M as LISTING_TAGLINE_RECOMMENDED_MAX, N as LeaderboardEntry, O as LeaderboardQuery, P as ListingNamingValidationOptions, Q as ListingNamingValidationResult, R as ListingQuery, S as ListingReviewCreatePayload, T as ListingReviewResponsePayload, U as ListingVersionPayload, V as MarketingCampaign, W as MarketingLinkOptions, X as MemoryPingChallengeResponse, Y as MemoryPingPayload, Z as OpenRouterCredits, _ as ProcurementCandidate, $ as ProcurementDecision, a0 as ProcurementTaskProfile, a1 as ProcurementWeights, a2 as ResourceProviderManifestEntry, a3 as ResourceSnapshot, a4 as ReviewGate, a5 as ReviewGateRecord, a6 as ReviewRequiredPayload, a7 as RunAdaptiveReflectionOptions, a8 as SdkAutoUpdatedRestartRequiredError, a9 as SdkUpdateCheckOptions, aa as SdkUpdatePolicyCheckOptions, ab as SdkUpdateRequiredError, ac as SdkUpdateStatus, TopupDecision, TopupRequest, TreasuryLedgerEvent, TreasuryPolicy, TreasuryPolicyV1, TreasuryState, ad as VIBEIAO_IDL, ae as VibeClient, af as VibeClientOptions, ag as VibeRegistry, ah as aggregateFeedbackSignals, ai as assertSurvivalProvidersConfigured, aj as buildAdaptivePlan, ak as buildBadgeMarkdown, al as buildClaimMessage, am as buildDecisionRecord, an as buildJupiterSwapUrl, ao as buildListingVersionMessage, ap as buildMemoryPingMessage, aq as buildOwnerTransferMessage, ar as buildProcurementPrompt, as as buildRaydiumSwapUrl, at as buildReviewPrompt, au as buildReviewRequired, av as buildReviewResponseMessage, aw as buildSdkUpdateCommand, ax as buildShareCopy, ay as buildShareLink, az as buildTradeLinks, buildTreasuryLedgerEvent, aA as checkForSdkUpdate, aB as checkForSdkUpdatePolicy, aC as compareVersions, aD as createApiCreditProvider, aE as createApiCreditProviders, aF as createApiCreditProvidersFromManifest, aG as createCampaign, aH as createContextPack, aI as createDurabilityProxyClient, createTreasuryPolicy, aJ as decideProcurementForTask, aK as estimateContextPackTokens, aL as evaluateAdaptiveReflectionPolicy, evaluateTopupRequest, aM as getResourceSnapshot, aN as normalizeListingText, aO as rankListingsForTask, aP as runAdaptiveReflectionCycle, aQ as runExecutionAdapter, aR as sanitizeListingNaming, aS as scoreListingForTask, treasuryStateFromSnapshot, aT as validateContextPack, aU as validateListingNaming, validateTreasuryPolicy, aV 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';

package/dist/index.js

@@ -248,6 +248,63 @@ var validateContextPack = (value) => {
 var CONTEXT_PACK_SECTION_ORDER = [...SECTION_ORDER];
 var estimateContextPackTokens = (textOrChars) => estimateTokensFromChars(typeof textOrChars === "number" ? textOrChars : textOrChars.length);
 
+// src/executionAdapter.ts
+var buildDecisionRecord = (input) => {
+  const nowMs = input.nowMs ?? Date.now();
+  return {
+    id: `decision-${nowMs}-${Math.random().toString(36).slice(2, 8)}`,
+    createdAt: new Date(nowMs).toISOString(),
+    decision: input.decision,
+    confidence: input.confidence,
+    verified: input.verified,
+    reasons: input.reasons,
+    objective: input.objective
+  };
+};
+var runExecutionAdapter = async (input) => {
+  const { mode, record, adapter } = input;
+  if (mode === "observe") {
+    return { mode, attempted: false, applied: false, validated: false, rolledBack: false, reason: "observe_mode" };
+  }
+  if (!adapter) {
+    return { mode, attempted: false, applied: false, validated: false, rolledBack: false, reason: "no_adapter" };
+  }
+  const dryRun = await adapter.dryRun({ record });
+  if (!dryRun.feasible) {
+    return { mode, attempted: false, applied: false, validated: false, rolledBack: false, reason: `dry_run_failed:${dryRun.reasons.join(",")}`, dryRun };
+  }
+  if (mode === "shadow") {
+    return { mode, attempted: true, applied: false, validated: false, rolledBack: false, reason: "shadow_mode", dryRun };
+  }
+  if (mode === "apply_limited" && record.confidence < 0.85) {
+    return { mode, attempted: true, applied: false, validated: false, rolledBack: false, reason: "limited_mode_confidence_gate", dryRun };
+  }
+  const apply = await adapter.apply({ record });
+  if (!apply.applied) {
+    return { mode, attempted: true, applied: false, validated: false, rolledBack: false, reason: apply.reason || "apply_not_applied", dryRun, apply };
+  }
+  const validate = await adapter.validate({ record, apply });
+  if (validate.passed) {
+    return { mode, attempted: true, applied: true, validated: true, rolledBack: false, reason: "applied_and_validated", dryRun, apply, validate };
+  }
+  if (adapter.rollback) {
+    const rollback = await adapter.rollback({ record, apply, validate });
+    return {
+      mode,
+      attempted: true,
+      applied: true,
+      validated: false,
+      rolledBack: rollback.rolledBack,
+      reason: rollback.rolledBack ? "rolled_back_after_validation_fail" : "validation_fail_rollback_failed",
+      dryRun,
+      apply,
+      validate,
+      rollback
+    };
+  }
+  return { mode, attempted: true, applied: true, validated: false, rolledBack: false, reason: "validation_failed_no_rollback", dryRun, apply, validate };
+};
+
 // src/adaptiveReflection.ts
 var clamp01 = (n) => Math.max(0, Math.min(1, n));
 var recencyWeight = (createdAt, nowMs) => {
@@ -262,14 +319,29 @@ var recencyWeight = (createdAt, nowMs) => {
 };
 var inferTheme = (r) => {
   const t = `${String(r.comment || "")} ${String(r.agent_response_comment || "")}`.toLowerCase();
-  if (/bug|broken|error|crash|fail/.test(t)) return "bug";
+  const rating = Number(r.rating);
+  if (/bug|broken|error|crash|fail|trash|awful|terrible|unplayable|unusable|only a page of code|only code|don\'t see any game|dont see any game|no game/.test(t)) return "bug";
   if (/downtime|timeout|unavailable|latency|disconnect/.test(t)) return "reliability";
   if (/confusing|hard|ux|ui|friction/.test(t)) return "ux";
   if (/price|expensive|cost|value/.test(t)) return "pricing";
   if (/feature|add|request|support/.test(t)) return "feature";
   if (/great|love|awesome|excellent/.test(t)) return "praise";
+  if (Number.isFinite(rating) && rating <= 2) return "bug";
   return "noise";
 };
+var classifyIssueSignal = (r) => {
+  const text = `${String(r.comment || "")} ${String(r.agent_response_comment || "")}`.toLowerCase();
+  const rating = Number(r.rating);
+  const criticalHint = /crash|broken|error|fail|trash|awful|terrible|unplayable|unusable|cannot|can't|doesn't work|not work|timeout|data loss|only a page of code|only code|don\'t see any game|dont see any game|no game/.test(text);
+  const prefHint = /prefer|would like|i wish|could you|nice to have|personally|for me/.test(text);
+  if (criticalHint || Number.isFinite(rating) && rating <= 2 && /bug|reliability|ux|pricing|feature/.test(inferTheme(r))) {
+    return "critical_issue";
+  }
+  if (prefHint || inferTheme(r) === "feature" || inferTheme(r) === "praise" || inferTheme(r) === "noise") {
+    return "preference";
+  }
+  return "other";
+};
 var themeBaseWeight = {
   bug: 1,
   reliability: 0.95,
@@ -293,9 +365,12 @@ var aggregateFeedbackSignals = (reviews, options = {}) => {
     const rating = Number(r.rating);
     const severity = Number.isFinite(rating) ? clamp01((5 - Math.max(1, Math.min(5, rating))) / 4) : 0.4;
     const score = themeBaseWeight[theme] * (0.5 + severity) * recencyWeight(r.created_at, nowMs);
-    const prev = bucket.get(theme) || { count: 0, weightedScore: 0 };
+    const prev = bucket.get(theme) || { count: 0, weightedScore: 0, criticalCount: 0, preferenceCount: 0 };
     prev.count += 1;
     prev.weightedScore += score;
+    const signalKind = classifyIssueSignal(r);
+    if (signalKind === "critical_issue") prev.criticalCount += 1;
+    if (signalKind === "preference") prev.preferenceCount += 1;
     bucket.set(theme, prev);
   }
   const themes = [...bucket.entries()].map(([theme, v]) => ({ theme, ...v })).sort((a, b) => b.weightedScore - a.weightedScore);
@@ -318,27 +393,30 @@ var evaluateAdaptiveReflectionPolicy = (aggregate, state, policy = {}, nowMs = D
   const rationale = [];
   if (state.lastEvaluatedAt && nowMs - state.lastEvaluatedAt < evalIntervalMs) {
     rationale.push("evaluation_interval_not_reached");
-    return { decision: "hold", rationale, confidence: 0.9, topTheme: aggregate.topTheme, topScore: aggregate.topScore };
+    return { decision: "hold", immediate: false, rationale, confidence: 0.9, topTheme: aggregate.topTheme, topScore: aggregate.topScore };
   }
   if (aggregate.totalReviews < minReviewsForAdaptation) {
     rationale.push("insufficient_review_volume");
-    return { decision: "observe", rationale, confidence: 0.65, topTheme: aggregate.topTheme, topScore: aggregate.topScore };
+    return { decision: "observe", immediate: false, rationale, confidence: 0.65, topTheme: aggregate.topTheme, topScore: aggregate.topScore };
   }
   if (aggregate.topScore < minTopScore || !aggregate.topTheme) {
     rationale.push("signal_below_threshold");
-    return { decision: "observe", rationale, confidence: 0.6, topTheme: aggregate.topTheme, topScore: aggregate.topScore };
+    return { decision: "observe", immediate: false, rationale, confidence: 0.6, topTheme: aggregate.topTheme, topScore: aggregate.topScore };
   }
   const lastThemeTs = state.lastAdaptedAtByTheme?.[aggregate.topTheme] || 0;
   if (lastThemeTs && nowMs - lastThemeTs < themeCooldownMs) {
     rationale.push("theme_cooldown_active");
-    return { decision: "hold", rationale, confidence: 0.85, topTheme: aggregate.topTheme, topScore: aggregate.topScore };
+    return { decision: "hold", immediate: false, rationale, confidence: 0.85, topTheme: aggregate.topTheme, topScore: aggregate.topScore };
   }
   if (adaptationsInLastDay(state, nowMs) >= maxAdaptationsPerDay) {
     rationale.push("daily_adaptation_limit_reached");
-    return { decision: "hold", rationale, confidence: 0.85, topTheme: aggregate.topTheme, topScore: aggregate.topScore };
+    return { decision: "hold", immediate: false, rationale, confidence: 0.85, topTheme: aggregate.topTheme, topScore: aggregate.topScore };
   }
+  const top = aggregate.themes.find((t) => t.theme === aggregate.topTheme);
+  const immediate = Boolean(top && (top.theme === "bug" || top.theme === "reliability") && top.criticalCount >= 1 && top.weightedScore >= Math.max(2.2, minTopScore));
+  if (immediate) rationale.push("immediate_fix_recommended");
   rationale.push("aggregate_signal_passed");
-  return { decision: "adapt", rationale, confidence: 0.8, topTheme: aggregate.topTheme, topScore: aggregate.topScore };
+  return { decision: "adapt", immediate, rationale, confidence: immediate ? 0.9 : 0.8, topTheme: aggregate.topTheme, topScore: aggregate.topScore };
 };
 var buildAdaptivePlan = (decision) => {
   if (decision.decision !== "adapt" || !decision.topTheme) return null;
@@ -387,7 +465,33 @@ var buildAdaptivePlan = (decision) => {
       rollbackCriteria: "N/A"
     }
   };
-  return { id, theme: decision.topTheme, ...byTheme[decision.topTheme] };
+  return { id, theme: decision.topTheme, ...byTheme[decision.topTheme], urgency: decision.immediate ? "immediate" : "normal" };
+};
+var verifyAdaptiveExecutionReadiness = (input, options = {}) => {
+  const minConfidence = options.minConfidence ?? 0.75;
+  const reasons = [];
+  const hasPlan = Boolean(input.plan);
+  if (!hasPlan) reasons.push("missing_plan");
+  const confidenceOk = input.decision.confidence >= minConfidence;
+  if (!confidenceOk) reasons.push("confidence_below_threshold");
+  const notNoiseTheme = input.decision.topTheme !== "noise";
+  if (!notNoiseTheme) reasons.push("noise_theme_blocked");
+  const policyAllowsAdapt = input.decision.decision === "adapt";
+  if (!policyAllowsAdapt) reasons.push("policy_not_adapt");
+  const allowImmediateOnly = options.allowImmediateOnly ?? false;
+  const urgencyAllowed = !allowImmediateOnly || Boolean(input.decision.immediate);
+  if (!urgencyAllowed) reasons.push("immediate_required");
+  return {
+    passed: hasPlan && confidenceOk && notNoiseTheme && policyAllowsAdapt && urgencyAllowed,
+    checks: {
+      hasPlan,
+      confidenceOk,
+      notNoiseTheme,
+      policyAllowsAdapt,
+      urgencyAllowed
+    },
+    reasons
+  };
 };
 var runAdaptiveReflectionCycle = async (opts) => {
   const now = opts.now || (() => Date.now());
@@ -401,6 +505,13 @@ var runAdaptiveReflectionCycle = async (opts) => {
   });
   const decision = evaluateAdaptiveReflectionPolicy(aggregate, state, opts.policy, nowMs);
   const plan = buildAdaptivePlan(decision);
+  const verification = verifyAdaptiveExecutionReadiness(
+    { decision, plan },
+    {
+      minConfidence: 0.75,
+      allowImmediateOnly: opts.execution?.allowImmediateOnly ?? false
+    }
+  );
   const reflection = await runReflectionCycle({
     client: opts.client,
     listingId: opts.listingId,
@@ -409,11 +520,57 @@ var runAdaptiveReflectionCycle = async (opts) => {
     store: opts.reflectionStore,
     ...opts.reflectionOptions || {}
   });
+  const mode = opts.execution?.mode ?? "observe";
+  const rolloutMode = opts.execution?.rolloutMode || (mode === "apply" ? "apply_full" : "observe");
+  let execution = {
+    attempted: false,
+    applied: false,
+    mode,
+    reason: mode === "apply" ? "awaiting_verification" : "observe_mode"
+  };
+  if (mode === "apply") {
+    if (!verification.passed) {
+      execution = {
+        attempted: false,
+        applied: false,
+        mode,
+        reason: `verify_failed:${verification.reasons.join(",")}`
+      };
+    } else if (opts.execution?.adapter && plan) {
+      const record = buildDecisionRecord({
+        decision: decision.decision,
+        confidence: decision.confidence,
+        verified: verification.passed,
+        reasons: verification.reasons,
+        objective: plan.objectiveDelta,
+        nowMs
+      });
+      const run = await runExecutionAdapter({
+        mode: rolloutMode,
+        record,
+        adapter: opts.execution.adapter
+      });
+      execution = {
+        attempted: run.attempted,
+        applied: run.applied,
+        mode,
+        reason: run.reason
+      };
+    } else {
+      execution = {
+        attempted: false,
+        applied: false,
+        mode,
+        reason: "no_execution_adapter"
+      };
+    }
+  }
   const next = {
     ...state,
     lastEvaluatedAt: nowMs
   };
-  if (decision.decision === "adapt" && plan) {
+  const adaptationCounted = decision.decision === "adapt" && plan && (mode === "observe" || execution.applied);
+  if (adaptationCounted) {
     next.lastAdaptedAtByTheme = { ...state.lastAdaptedAtByTheme || {}, [plan.theme]: nowMs };
     next.adaptationEvents = [...state.adaptationEvents || [], { ts: nowMs, theme: plan.theme, actionId: plan.id }].slice(-500);
   }
@@ -424,6 +581,8 @@ var runAdaptiveReflectionCycle = async (opts) => {
     generatedAt: new Date(nowMs).toISOString(),
     aggregate,
     decision,
+    verification,
+    execution,
     plan,
     reflection,
     policyState: next
@@ -546,7 +705,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.43" ? "0.1.43" : "0.1.4";
+var DEFAULT_SDK_VERSION = "0.1.45" ? "0.1.45" : "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;
@@ -1683,6 +1842,7 @@ export {
   buildAdaptivePlan,
   buildBadgeMarkdown,
   buildClaimMessage,
+  buildDecisionRecord,
   buildJupiterSwapUrl,
   buildListingVersionMessage,
   buildMemoryPingMessage,
@@ -1743,6 +1903,7 @@ export {
   normalizeListingText,
   rankListingsForTask,
   runAdaptiveReflectionCycle,
+  runExecutionAdapter,
   runMarketDiscovery,
   runReflectionCycle,
   sanitizeListingNaming,
@@ -1753,5 +1914,6 @@ export {
   validateContextPack,
   validateListingNaming,
   validateTreasuryPolicy,
+  verifyAdaptiveExecutionReadiness,
   withSurvival
 };

package/dist/treasuryGuardian.d.ts

@@ -828,6 +828,77 @@ declare const createDurabilityProxyClient: (options: DurabilityProxyClientOption
     }>;
 };
 
+type ExecutionRolloutMode = 'observe' | 'shadow' | 'apply_limited' | 'apply_full';
+type ExecutionDecisionRecord = {
+    id: string;
+    createdAt: string;
+    decision: 'hold' | 'observe' | 'adapt';
+    confidence: number;
+    verified: boolean;
+    reasons: string[];
+    objective?: string;
+};
+type ExecutionDryRunResult = {
+    feasible: boolean;
+    reasons: string[];
+};
+type ExecutionApplyResult = {
+    applied: boolean;
+    evidence?: string;
+    reason?: string;
+};
+type ExecutionValidateResult = {
+    passed: boolean;
+    metrics?: Record<string, number | string | boolean>;
+    reason?: string;
+};
+type ExecutionRollbackResult = {
+    rolledBack: boolean;
+    reason?: string;
+};
+interface ExecutionAdapter {
+    dryRun: (input: {
+        record: ExecutionDecisionRecord;
+    }) => Promise<ExecutionDryRunResult> | ExecutionDryRunResult;
+    apply: (input: {
+        record: ExecutionDecisionRecord;
+    }) => Promise<ExecutionApplyResult> | ExecutionApplyResult;
+    validate: (input: {
+        record: ExecutionDecisionRecord;
+        apply: ExecutionApplyResult;
+    }) => Promise<ExecutionValidateResult> | ExecutionValidateResult;
+    rollback?: (input: {
+        record: ExecutionDecisionRecord;
+        apply: ExecutionApplyResult;
+        validate: ExecutionValidateResult;
+    }) => Promise<ExecutionRollbackResult> | ExecutionRollbackResult;
+}
+type ExecutionRunResult = {
+    mode: ExecutionRolloutMode;
+    attempted: boolean;
+    applied: boolean;
+    validated: boolean;
+    rolledBack: boolean;
+    reason: string;
+    dryRun?: ExecutionDryRunResult;
+    apply?: ExecutionApplyResult;
+    validate?: ExecutionValidateResult;
+    rollback?: ExecutionRollbackResult;
+};
+declare const buildDecisionRecord: (input: {
+    decision: "hold" | "observe" | "adapt";
+    confidence: number;
+    verified: boolean;
+    reasons: string[];
+    objective?: string;
+    nowMs?: number;
+}) => ExecutionDecisionRecord;
+declare const runExecutionAdapter: (input: {
+    mode: ExecutionRolloutMode;
+    record: ExecutionDecisionRecord;
+    adapter?: ExecutionAdapter;
+}) => Promise<ExecutionRunResult>;
+
 type AdaptiveTheme = 'bug' | 'reliability' | 'ux' | 'pricing' | 'feature' | 'praise' | 'noise';
 type AdaptiveFeedbackAggregate = {
     generatedAt: string;
@@ -837,6 +908,8 @@ type AdaptiveFeedbackAggregate = {
         theme: AdaptiveTheme;
         count: number;
         weightedScore: number;
+        criticalCount: number;
+        preferenceCount: number;
     }>;
     topTheme?: AdaptiveTheme;
     topScore: number;
@@ -860,6 +933,7 @@ type AdaptivePolicyState = {
 };
 type AdaptivePolicyDecision = {
     decision: 'hold' | 'observe' | 'adapt';
+    immediate: boolean;
     rationale: string[];
     confidence: number;
     topTheme?: AdaptiveTheme;
@@ -872,6 +946,24 @@ type AdaptiveAdaptationPlan = {
     expectedImpact: string;
     risk: 'low' | 'medium' | 'high';
     rollbackCriteria: string;
+    urgency?: 'normal' | 'immediate';
+};
+type AdaptiveVerification = {
+    passed: boolean;
+    checks: {
+        hasPlan: boolean;
+        confidenceOk: boolean;
+        notNoiseTheme: boolean;
+        policyAllowsAdapt: boolean;
+        urgencyAllowed: boolean;
+    };
+    reasons: string[];
+};
+type AdaptiveExecution = {
+    attempted: boolean;
+    applied: boolean;
+    mode: 'observe' | 'apply';
+    reason: string;
 };
 type AdaptiveReflectionStore = ReflectionStore & {
     loadPolicyState?: () => Promise<AdaptivePolicyState | null> | AdaptivePolicyState | null;
@@ -885,6 +977,12 @@ type RunAdaptiveReflectionOptions = {
     reflectionStore?: AdaptiveReflectionStore;
     reflectionOptions?: Omit<ReflectionCycleOptions, 'client' | 'listingId' | 'wallet' | 'signMessage' | 'store'>;
     policy?: AdaptivePolicyConfig;
+    execution?: {
+        mode?: 'observe' | 'apply';
+        rolloutMode?: ExecutionRolloutMode;
+        allowImmediateOnly?: boolean;
+        adapter?: ExecutionAdapter;
+    };
     now?: () => number;
 };
 declare const aggregateFeedbackSignals: (reviews: ListingReviewRecord[], options?: {
@@ -893,10 +991,19 @@ declare const aggregateFeedbackSignals: (reviews: ListingReviewRecord[], options
 }) => AdaptiveFeedbackAggregate;
 declare const evaluateAdaptiveReflectionPolicy: (aggregate: AdaptiveFeedbackAggregate, state: AdaptivePolicyState, policy?: AdaptivePolicyConfig, nowMs?: number) => AdaptivePolicyDecision;
 declare const buildAdaptivePlan: (decision: AdaptivePolicyDecision) => AdaptiveAdaptationPlan | null;
+declare const verifyAdaptiveExecutionReadiness: (input: {
+    decision: AdaptivePolicyDecision;
+    plan: AdaptiveAdaptationPlan | null;
+}, options?: {
+    minConfidence?: number;
+    allowImmediateOnly?: boolean;
+}) => AdaptiveVerification;
 declare const runAdaptiveReflectionCycle: (opts: RunAdaptiveReflectionOptions) => Promise<{
     generatedAt: string;
     aggregate: AdaptiveFeedbackAggregate;
     decision: AdaptivePolicyDecision;
+    verification: AdaptiveVerification;
+    execution: AdaptiveExecution;
     plan: AdaptiveAdaptationPlan;
     reflection: ReflectionCycleResult;
     policyState: AdaptivePolicyState;
@@ -1180,7 +1287,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>;
@@ -1361,4 +1468,4 @@ declare const getResourceSnapshot: (options: {
     apiBase?: string;
 }) => Promise<ResourceSnapshot>;
 
-export { type SdkUpdateCheckOptions as $, type AdaptiveAdaptationPlan as A, type BuybackEvent as B, CONTEXT_PACK_SECTION_ORDER as C, type DurabilityCheckpointWriteOptions as D, type ListingNamingValidationOptions as E, type ListingNamingValidationResult as F, type ListingQuery as G, type ListingReviewCreatePayload as H, type ListingReviewResponsePayload as I, type ListingVersionPayload as J, type MarketingLinkOptions as K, LISTING_NAME_MAX_LENGTH as L, type MarketingCampaign as M, type MemoryPingChallengeResponse as N, type MemoryPingPayload as O, type OpenRouterCredits as P, type ProcurementCandidate as Q, type ProcurementDecision as R, type ProcurementTaskProfile as S, type ProcurementWeights as T, type TopupDecision, type TopupRequest, type TreasuryLedgerEvent, type TreasuryPolicy, type TreasuryPolicyV1, type TreasuryState, type ResourceProviderManifestEntry as U, type ResourceSnapshot as V, ReviewGate as W, type ReviewGateRecord as X, type ReviewRequiredPayload as Y, type RunAdaptiveReflectionOptions as Z, SdkAutoUpdatedRestartRequiredError as _, type AdaptiveFeedbackAggregate as a, type SdkUpdatePolicyCheckOptions as a0, SdkUpdateRequiredError as a1, type SdkUpdateStatus as a2, VIBEIAO_IDL as a3, VibeClient as a4, type VibeClientOptions as a5, VibeRegistry as a6, aggregateFeedbackSignals as a7, assertSurvivalProvidersConfigured as a8, buildAdaptivePlan as a9, evaluateAdaptiveReflectionPolicy as aA, getResourceSnapshot as aB, normalizeListingText as aC, rankListingsForTask as aD, runAdaptiveReflectionCycle as aE, sanitizeListingNaming as aF, scoreListingForTask as aG, validateContextPack as aH, validateListingNaming as aI, buildBadgeMarkdown as aa, buildClaimMessage as ab, buildJupiterSwapUrl as ac, buildListingVersionMessage as ad, buildMemoryPingMessage as ae, buildOwnerTransferMessage as af, buildProcurementPrompt as ag, buildRaydiumSwapUrl as ah, buildReviewPrompt as ai, buildReviewRequired as aj, buildReviewResponseMessage as ak, buildSdkUpdateCommand as al, buildShareCopy as am, buildShareLink as an, buildTradeLinks as ao, checkForSdkUpdate as ap, checkForSdkUpdatePolicy as aq, compareVersions as ar, createApiCreditProvider as as, createApiCreditProviders as at, createApiCreditProvidersFromManifest as au, createCampaign as av, createContextPack as aw, createDurabilityProxyClient as ax, decideProcurementForTask as ay, estimateContextPackTokens as az, type AdaptivePolicyConfig as b, buildTreasuryLedgerEvent, type AdaptivePolicyDecision as c, createTreasuryPolicy, type AdaptivePolicyState as d, type AdaptiveReflectionStore as e, evaluateTopupRequest, type AdaptiveTheme as f, type AgentResourceProvidersManifest as g, type AnalyticsPoint as h, type ApiCreditProvider as i, type ApiCreditProviderFactoryOptions as j, type ApiCreditProviderPreset as k, type ApiCreditProviderPresetInput as l, type ApiResponse as m, type ContextPack as n, type ContextPackBudget as o, type ContextPackInput as p, type ContextPackOptions as q, type ContextPackSectionKey as r, type ContextPackSections as s, type DurabilityProxyClientOptions as t, treasuryStateFromSnapshot, type DurabilityRestoreDrillWriteOptions as u, LISTING_NAME_RECOMMENDED_MAX as v, validateTreasuryPolicy, LISTING_TAGLINE_MAX_LENGTH as w, LISTING_TAGLINE_RECOMMENDED_MAX as x, type LeaderboardEntry as y, type LeaderboardQuery as z };
+export { type ProcurementDecision as $, type AdaptiveAdaptationPlan as A, type BuybackEvent as B, CONTEXT_PACK_SECTION_ORDER as C, type DurabilityCheckpointWriteOptions as D, type ExecutionAdapter as E, type ExecutionRollbackResult as F, type ExecutionRolloutMode as G, type ExecutionRunResult as H, type ExecutionValidateResult as I, LISTING_NAME_RECOMMENDED_MAX as J, LISTING_TAGLINE_MAX_LENGTH as K, LISTING_NAME_MAX_LENGTH as L, LISTING_TAGLINE_RECOMMENDED_MAX as M, type LeaderboardEntry as N, type LeaderboardQuery as O, type ListingNamingValidationOptions as P, type ListingNamingValidationResult as Q, type ListingQuery as R, type ListingReviewCreatePayload as S, type ListingReviewResponsePayload as T, type TopupDecision, type TopupRequest, type TreasuryLedgerEvent, type TreasuryPolicy, type TreasuryPolicyV1, type TreasuryState, type ListingVersionPayload as U, type MarketingCampaign as V, type MarketingLinkOptions as W, type MemoryPingChallengeResponse as X, type MemoryPingPayload as Y, type OpenRouterCredits as Z, type ProcurementCandidate as _, type AdaptiveExecution as a, type ProcurementTaskProfile as a0, type ProcurementWeights as a1, type ResourceProviderManifestEntry as a2, type ResourceSnapshot as a3, ReviewGate as a4, type ReviewGateRecord as a5, type ReviewRequiredPayload as a6, type RunAdaptiveReflectionOptions as a7, SdkAutoUpdatedRestartRequiredError as a8, type SdkUpdateCheckOptions as a9, checkForSdkUpdate as aA, checkForSdkUpdatePolicy as aB, compareVersions as aC, createApiCreditProvider as aD, createApiCreditProviders as aE, createApiCreditProvidersFromManifest as aF, createCampaign as aG, createContextPack as aH, createDurabilityProxyClient as aI, decideProcurementForTask as aJ, estimateContextPackTokens as aK, evaluateAdaptiveReflectionPolicy as aL, getResourceSnapshot as aM, normalizeListingText as aN, rankListingsForTask as aO, runAdaptiveReflectionCycle as aP, runExecutionAdapter as aQ, sanitizeListingNaming as aR, scoreListingForTask as aS, validateContextPack as aT, validateListingNaming as aU, verifyAdaptiveExecutionReadiness as aV, type SdkUpdatePolicyCheckOptions as aa, SdkUpdateRequiredError as ab, type SdkUpdateStatus as ac, VIBEIAO_IDL as ad, VibeClient as ae, type VibeClientOptions as af, VibeRegistry as ag, aggregateFeedbackSignals as ah, assertSurvivalProvidersConfigured as ai, buildAdaptivePlan as aj, buildBadgeMarkdown as ak, buildClaimMessage as al, buildDecisionRecord as am, buildJupiterSwapUrl as an, buildListingVersionMessage as ao, buildMemoryPingMessage as ap, buildOwnerTransferMessage as aq, buildProcurementPrompt as ar, buildRaydiumSwapUrl as as, buildReviewPrompt as at, buildReviewRequired as au, buildReviewResponseMessage as av, buildSdkUpdateCommand as aw, buildShareCopy as ax, buildShareLink as ay, buildTradeLinks as az, type AdaptiveFeedbackAggregate as b, buildTreasuryLedgerEvent, type AdaptivePolicyConfig as c, createTreasuryPolicy, type AdaptivePolicyDecision as d, type AdaptivePolicyState as e, evaluateTopupRequest, type AdaptiveReflectionStore as f, type AdaptiveTheme as g, type AdaptiveVerification as h, type AgentResourceProvidersManifest as i, type AnalyticsPoint as j, type ApiCreditProvider as k, type ApiCreditProviderFactoryOptions as l, type ApiCreditProviderPreset as m, type ApiCreditProviderPresetInput as n, type ApiResponse as o, type ContextPack as p, type ContextPackBudget as q, type ContextPackInput as r, type ContextPackOptions as s, type ContextPackSectionKey as t, treasuryStateFromSnapshot, type ContextPackSections as u, type DurabilityProxyClientOptions as v, validateTreasuryPolicy, type DurabilityRestoreDrillWriteOptions as w, type ExecutionApplyResult as x, type ExecutionDecisionRecord as y, type ExecutionDryRunResult as z };

package/package.json

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