@vibeiao/sdk 0.1.47 → 0.1.49

package/README.md

@@ -691,6 +691,13 @@ Adaptive reflection policy is available for cadence-based adaptation (not per-re
 - output `hold|observe|adapt` decision and optional bounded adaptation plan
 - enforce `verify -> execute` sequencing in apply mode (no verify pass => no execution)
 
+Adapter packs + migration helpers:
+- use `createWebStaticAdapter`, `createWebBundledAdapter`, `createServiceApiAdapter`, `createWorkflowAgentAdapter`
+- use `runAdapterBestShotChecklist` for profile-level launch checks
+- 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
+
 You can also enforce dual-mode work arbitration:
 - `owner_bound` agents: human-first (owner work preempts autonomous work)
 - `unbound` agents: autonomous-first (run autonomous work by default)

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

package/dist/index.js

@@ -545,16 +545,16 @@ var runAdaptiveReflectionCycle = async (opts) => {
         objective: plan.objectiveDelta,
         nowMs
       });
-      const run = await runExecutionAdapter({
+      const run2 = await runExecutionAdapter({
         mode: rolloutMode,
         record,
         adapter: opts.execution.adapter
       });
       execution = {
-        attempted: run.attempted,
-        applied: run.applied,
+        attempted: run2.attempted,
+        applied: run2.applied,
         mode,
-        reason: run.reason
+        reason: run2.reason
       };
     } else {
       execution = {
@@ -589,12 +589,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 +632,341 @@ 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
+var evaluateLaunchReadiness = (input) => {
+  const blockers = [];
+  const notes = [];
+  if (!String(input.targetUser || "").trim()) blockers.push("missing_target_user");
+  if (!String(input.problemStatement || "").trim()) blockers.push("missing_problem_statement");
+  if (!Array.isArray(input.researchEvidence) || input.researchEvidence.length < 2) blockers.push("insufficient_research_evidence");
+  if (!String(input.designRationale || "").trim()) blockers.push("missing_design_rationale");
+  const qualityChecks = Array.isArray(input.qualityChecks) ? input.qualityChecks : [];
+  if (!qualityChecks.length) blockers.push("missing_quality_checks");
+  if (qualityChecks.some((q) => !q.passed)) blockers.push("quality_checks_failed");
+  if (!String(input.rollbackPlan || "").trim()) blockers.push("missing_rollback_plan");
+  const deployUrl = String(input.deploy?.url || "").trim();
+  const smokePassed = Boolean(input.deploy?.smokePassed);
+  const listingUpdated = Boolean(input.listing?.updated);
+  if (!deployUrl) blockers.push("missing_deploy_url");
+  if (!smokePassed) blockers.push("smoke_check_failed");
+  if (!listingUpdated) blockers.push("listing_not_updated");
+  const score = Math.max(0, 1 - blockers.length / 10);
+  if (!blockers.length) notes.push("launch_readiness_passed");
+  return {
+    ready: blockers.length === 0,
+    score,
+    blockers,
+    notes
+  };
+};
+var assertLaunchReady = (input) => {
+  const result = evaluateLaunchReadiness(input);
+  if (!result.ready) {
+    throw new Error(`launch_readiness_failed:${result.blockers.join(",")}`);
+  }
+  return result;
+};
+
+// src/adapterPacks.ts
+import { execSync } from "child_process";
+import path from "path";
+import fs from "fs";
+var run = (command, cwd) => {
+  execSync(command, { cwd, stdio: "pipe" });
+};
+var checkPaths = (cwd, required) => required.map((p) => ({
+  name: `path:${p}`,
+  passed: fs.existsSync(path.join(cwd, p)),
+  detail: path.join(cwd, p)
+}));
+var readPackageJson = (cwd) => {
+  const p = path.join(cwd, "package.json");
+  if (!fs.existsSync(p)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+};
+var checkWebStaticLinks = (cwd) => {
+  const indexPath = path.join(cwd, "index.html");
+  if (!fs.existsSync(indexPath)) {
+    return [
+      { name: "index_has_css_link", passed: false, detail: "index.html missing" },
+      { name: "index_has_script_ref", passed: false, detail: "index.html missing" }
+    ];
+  }
+  const html = fs.readFileSync(indexPath, "utf8");
+  return [
+    {
+      name: "index_has_css_link",
+      passed: /<link[^>]+href=["'][^"']+\.css["']/i.test(html),
+      detail: "index.html should include a CSS asset link"
+    },
+    {
+      name: "index_has_script_ref",
+      passed: /<script[^>]+src=["'][^"']+\.js["']/i.test(html),
+      detail: "index.html should include a JS asset script tag"
+    }
+  ];
+};
+var runAdapterBestShotChecklist = (profile, options) => {
+  const checks = [];
+  const pkg = readPackageJson(options.cwd);
+  const scripts = pkg?.scripts || {};
+  if (profile === "web_static") {
+    checks.push(...checkPaths(options.cwd, options.requiredPaths || ["index.html", "style.css"]));
+    checks.push(...checkWebStaticLinks(options.cwd));
+  } else if (profile === "web_bundled") {
+    checks.push(...checkPaths(options.cwd, options.requiredPaths || ["package.json"]));
+    checks.push({ name: "package_has_build_script", passed: Boolean(scripts.build), detail: scripts.build });
+    checks.push({
+      name: "package_has_test_or_validate_script",
+      passed: Boolean(scripts.test || scripts.validate || options.validateCommand),
+      detail: String(scripts.test || scripts.validate || options.validateCommand || "")
+    });
+    checks.push({
+      name: "has_build_or_smoke_command",
+      passed: Boolean(options.buildCommand || options.smokeCommand),
+      detail: String(options.buildCommand || options.smokeCommand || "")
+    });
+  } else if (profile === "service_api") {
+    checks.push(...checkPaths(options.cwd, options.requiredPaths || ["package.json"]));
+    checks.push({ name: "has_deploy_command", passed: Boolean(options.deployCommand), detail: options.deployCommand });
+    checks.push({
+      name: "has_validate_or_smoke_command",
+      passed: Boolean(options.validateCommand || options.smokeCommand || scripts.test),
+      detail: String(options.validateCommand || options.smokeCommand || scripts.test || "")
+    });
+    checks.push({
+      name: "package_has_start_or_serve_script",
+      passed: Boolean(scripts.start || scripts.serve),
+      detail: String(scripts.start || scripts.serve || "")
+    });
+  } else if (profile === "workflow_agent") {
+    checks.push(...checkPaths(options.cwd, options.requiredPaths || ["package.json"]));
+    checks.push({
+      name: "has_validate_or_test_command",
+      passed: Boolean(options.validateCommand || scripts.test),
+      detail: String(options.validateCommand || scripts.test || "")
+    });
+    checks.push({
+      name: "has_apply_or_deploy_command",
+      passed: Boolean(options.deployCommand || scripts.start),
+      detail: String(options.deployCommand || scripts.start || "")
+    });
+  }
+  return {
+    profile,
+    passed: checks.every((c) => c.passed),
+    checks
+  };
+};
+var createWebStaticAdapter = (opts) => ({
+  dryRun: async () => {
+    const required = ["index.html", "style.css"];
+    const missing = required.filter((f) => !fs.existsSync(path.join(opts.cwd, f)));
+    return { feasible: missing.length === 0, reasons: missing.map((m) => `missing:${m}`) };
+  },
+  apply: async () => {
+    try {
+      if (opts.buildCommand) run(opts.buildCommand, opts.cwd);
+      if (opts.deployCommand) run(opts.deployCommand, opts.cwd);
+      return { applied: true, evidence: "web_static_deploy_applied" };
+    } catch (err) {
+      return { applied: false, reason: `web_static_apply_failed:${String(err)}` };
+    }
+  },
+  validate: async () => {
+    try {
+      if (opts.validateCommand) run(opts.validateCommand, opts.cwd);
+      if (opts.smokeCommand) run(opts.smokeCommand, opts.cwd);
+      return { passed: true, metrics: { profile: "web_static" } };
+    } catch (err) {
+      return { passed: false, reason: `web_static_validate_failed:${String(err)}` };
+    }
+  }
+});
+var createWebBundledAdapter = (opts) => ({
+  dryRun: async () => ({ feasible: true, reasons: [] }),
+  apply: async () => {
+    try {
+      run(opts.buildCommand || "npm run build", opts.cwd);
+      if (opts.deployCommand) run(opts.deployCommand, opts.cwd);
+      return { applied: true, evidence: "web_bundled_deploy_applied" };
+    } catch (err) {
+      return { applied: false, reason: `web_bundled_apply_failed:${String(err)}` };
+    }
+  },
+  validate: async () => {
+    try {
+      if (opts.validateCommand) run(opts.validateCommand, opts.cwd);
+      if (opts.smokeCommand) run(opts.smokeCommand, opts.cwd);
+      return { passed: true, metrics: { profile: "web_bundled" } };
+    } catch (err) {
+      return { passed: false, reason: `web_bundled_validate_failed:${String(err)}` };
+    }
+  }
+});
+var createWorkflowAgentAdapter = (opts) => ({
+  dryRun: async () => ({ feasible: true, reasons: [] }),
+  apply: async () => {
+    try {
+      if (opts.deployCommand) run(opts.deployCommand, opts.cwd);
+      return { applied: true, evidence: "workflow_agent_apply" };
+    } catch (err) {
+      return { applied: false, reason: `workflow_agent_apply_failed:${String(err)}` };
+    }
+  },
+  validate: async () => {
+    try {
+      if (opts.validateCommand) run(opts.validateCommand, opts.cwd);
+      return { passed: true, metrics: { profile: "workflow_agent" } };
+    } catch (err) {
+      return { passed: false, reason: `workflow_agent_validate_failed:${String(err)}` };
+    }
+  }
+});
+var createServiceApiAdapter = (opts) => ({
+  dryRun: async () => ({ feasible: true, reasons: [] }),
+  apply: async () => {
+    try {
+      if (opts.deployCommand) run(opts.deployCommand, opts.cwd);
+      return { applied: true, evidence: "service_api_apply" };
+    } catch (err) {
+      return { applied: false, reason: `service_api_apply_failed:${String(err)}` };
+    }
+  },
+  validate: async () => {
+    try {
+      if (opts.validateCommand) run(opts.validateCommand, opts.cwd);
+      if (opts.smokeCommand) run(opts.smokeCommand, opts.cwd);
+      return { passed: true, metrics: { profile: "service_api" } };
+    } catch (err) {
+      return { passed: false, reason: `service_api_validate_failed:${String(err)}` };
+    }
+  }
+});
+var createCustomAdapter = (adapter) => adapter;
+
+// src/agentLaunchRuntime.ts
+var runAgentLaunchRuntime = async (options) => {
+  if (!options.adapter) {
+    throw new Error("agent_launch_runtime_requires_execution_adapter");
+  }
+  const auditTrail = ["launch_runtime_start"];
+  let checklist;
+  let readinessInput = { ...options.readiness };
+  if (options.bestShot) {
+    checklist = runAdapterBestShotChecklist(options.bestShot.profile, options.bestShot.options);
+    auditTrail.push(`best_shot_checklist:${options.bestShot.profile}:${checklist.passed ? "pass" : "fail"}`);
+    readinessInput = {
+      ...readinessInput,
+      qualityChecks: [
+        ...readinessInput.qualityChecks || [],
+        ...checklist.checks.map((c) => ({ name: `bestshot:${c.name}`, passed: c.passed, detail: c.detail }))
+      ]
+    };
+  }
+  const readiness = evaluateLaunchReadiness(readinessInput);
+  const minScore = options.minScore ?? 0.8;
+  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;
+    overrideApplied = true;
+    auditTrail.push(`trusted_override:${options.trustedOverride.actor}:${options.trustedOverride.reason}`);
+  }
+  const reasons = [
+    ...readiness.blockers.length ? readiness.blockers : ["launch_readiness_passed"],
+    ...checklist && !checklist.passed ? ["best_shot_checklist_failed"] : [],
+    ...!contextGate.passed ? contextGate.reasons : []
+  ];
+  const record = buildDecisionRecord({
+    decision: verified ? "adapt" : "hold",
+    confidence: readiness.score,
+    verified,
+    reasons,
+    objective: options.objective || "best_shot_launch",
+    nowMs: options.nowMs
+  });
+  const mode = verified ? requestedMode : "observe";
+  const execution = await runExecutionAdapter({
+    mode,
+    record,
+    adapter: options.adapter
+  });
+  auditTrail.push(`execution:${execution.reason}`);
+  return { readiness, execution, checklist, contextGate, overrideApplied, auditTrail };
+};
+var runAgentLaunchRuntimeCycle = runAgentLaunchRuntime;
+
+// src/runtimeMigration.ts
+var buildRuntimeMigrationPlan = (input) => {
+  const blockers = [];
+  const actions = [];
+  if (!input.listingId) blockers.push("missing_listing_id");
+  if (!input.cwd) blockers.push("missing_project_root");
+  if (input.hasLegacyExecutePlan) {
+    actions.push("replace_legacy_executePlan_with_execution_adapter");
+  }
+  if (!input.hasAdapter) {
+    blockers.push("missing_execution_adapter");
+    actions.push("implement_profile_adapter");
+  }
+  actions.push("wire_runAgentReviewRuntimeCycle_as_default");
+  actions.push("enable_verify_before_execute_apply_mode");
+  let rolloutMode = "shadow";
+  if (!blockers.length && input.hasAdapter) rolloutMode = "apply_limited";
+  return {
+    profile: input.profile,
+    ready: blockers.length === 0,
+    blockers,
+    actions,
+    suggestedConfig: {
+      executionMode: "apply",
+      rolloutMode,
+      allowImmediateOnly: true
+    }
+  };
+};
+
+// src/stateChangeNotifier.ts
+var shouldAnnounceStateChange = (input) => {
+  const prev = input.previous;
+  const cur = input.current;
+  if (!prev) return { announce: true, reason: "initial_state" };
+  if (prev.status !== cur.status) return { announce: true, reason: "status_changed" };
+  if (Boolean(prev.ready) !== Boolean(cur.ready)) return { announce: true, reason: "readiness_changed" };
+  if ((prev.decision || "") !== (cur.decision || "") && cur.status !== "green") {
+    return { announce: true, reason: "decision_changed_non_green" };
+  }
+  if ((prev.reason || "") !== (cur.reason || "") && cur.status !== "green") {
+    return { announce: true, reason: "reason_changed_non_green" };
+  }
+  return { announce: false, reason: "no_meaningful_change" };
 };
 
 // src/index.ts
@@ -728,7 +1085,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.46" ? "0.1.46" : "0.1.4";
+var DEFAULT_SDK_VERSION = "0.1.48" ? "0.1.48" : "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;
@@ -920,9 +1277,9 @@ var unwrap = (response) => {
   return response.data;
 };
 var normalizeProviderName = (value) => value.trim().toLowerCase().replace(/[^a-z0-9_-]/g, "");
-var getByPath = (payload, path) => {
-  if (!path) return void 0;
-  const segments = path.split(".").map((part) => part.trim()).filter(Boolean);
+var getByPath = (payload, path2) => {
+  if (!path2) return void 0;
+  const segments = path2.split(".").map((part) => part.trim()).filter(Boolean);
   let current = payload;
   for (const segment of segments) {
     if (!current || typeof current !== "object" || !(segment in current)) {
@@ -1223,9 +1580,9 @@ var VibeClient = class {
       };
     }
   }
-  async get(path) {
+  async get(path2) {
     await this.ensureLatestVersion();
-    const response = await this.fetcher(`${this.baseUrl}${path}`);
+    const response = await this.fetcher(`${this.baseUrl}${path2}`);
     let payload = null;
     try {
       payload = await readJson(response);
@@ -1241,9 +1598,9 @@ var VibeClient = class {
     }
     return payload;
   }
-  async post(path, body) {
+  async post(path2, body) {
     await this.ensureLatestVersion();
-    const response = await this.fetcher(`${this.baseUrl}${path}`, {
+    const response = await this.fetcher(`${this.baseUrl}${path2}`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(body)
@@ -1263,9 +1620,9 @@ var VibeClient = class {
     }
     return payload;
   }
-  async del(path, body) {
+  async del(path2, body) {
     await this.ensureLatestVersion();
-    const response = await this.fetcher(`${this.baseUrl}${path}`, {
+    const response = await this.fetcher(`${this.baseUrl}${path2}`, {
       method: "DELETE",
       headers: { "Content-Type": "application/json" },
       body: body === void 0 ? void 0 : JSON.stringify(body)
@@ -1860,6 +2217,7 @@ export {
   VibeClient,
   VibeRegistry,
   aggregateFeedbackSignals,
+  assertLaunchReady,
   assertOutcomeBoundCompleted,
   assertSurvivalProvidersConfigured,
   buildAdaptivePlan,
@@ -1877,6 +2235,7 @@ export {
   buildReviewPrompt,
   buildReviewRequired,
   buildReviewResponseMessage,
+  buildRuntimeMigrationPlan,
   buildSdkUpdateCommand,
   buildShareCopy,
   buildShareLink,
@@ -1894,19 +2253,26 @@ export {
   createAutoSelfReliance,
   createCampaign,
   createContextPack,
+  createCustomAdapter,
   createDurabilityProxyClient,
   createInMemoryReflectionStore,
   createSelfRelianceMonitor,
   createSelfReliancePolicy,
+  createServiceApiAdapter,
   createStrictMemoryRuntimePreset,
   createSurvivalMiddleware,
   createTreasuryPolicy,
+  createWebBundledAdapter,
+  createWebStaticAdapter,
+  createWorkflowAgentAdapter,
   decideProcurementForTask,
   deriveMarketNeeds,
   discoverMarketNeeds,
   estimateContextPackTokens,
   evaluateAdaptiveReflectionPolicy,
+  evaluateContextPackGate,
   evaluateEscapeHatch,
+  evaluateLaunchReadiness,
   evaluateObjectiveChange,
   evaluateOutcomeBoundRun,
   evaluatePromptShield,
@@ -1925,7 +2291,10 @@ export {
   isComplexTask,
   normalizeListingText,
   rankListingsForTask,
+  runAdapterBestShotChecklist,
   runAdaptiveReflectionCycle,
+  runAgentLaunchRuntime,
+  runAgentLaunchRuntimeCycle,
   runAgentReviewRuntimeCycle,
   runExecutionAdapter,
   runMarketDiscovery,
@@ -1933,6 +2302,7 @@ export {
   sanitizeListingNaming,
   scoreListingForTask,
   scoreReviewPriority,
+  shouldAnnounceStateChange,
   treasuryStateFromSnapshot,
   upgradeToStrictMemoryRuntimePreset,
   validateContextPack,

package/dist/treasuryGuardian.d.ts

@@ -1009,6 +1009,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 +1039,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;
@@ -1037,6 +1060,130 @@ declare const runAgentReviewRuntimeCycle: (opts: AgentReviewRuntimeOptions) => P
     policyState: AdaptivePolicyState;
 }>;
 
+type LaunchProfile = 'web_static' | 'web_bundled' | 'service_api' | 'workflow_agent' | 'custom';
+type LaunchReadinessInput = {
+    profile: LaunchProfile;
+    targetUser: string;
+    problemStatement: string;
+    researchEvidence: Array<{
+        source: string;
+        summary: string;
+    }>;
+    designRationale: string;
+    qualityChecks: Array<{
+        name: string;
+        passed: boolean;
+        detail?: string;
+    }>;
+    rollbackPlan: string;
+    deploy?: {
+        url?: string;
+        smokePassed?: boolean;
+    };
+    listing?: {
+        listingId?: string;
+        updated?: boolean;
+    };
+};
+type LaunchReadinessResult = {
+    ready: boolean;
+    score: number;
+    blockers: string[];
+    notes: string[];
+};
+declare const evaluateLaunchReadiness: (input: LaunchReadinessInput) => LaunchReadinessResult;
+declare const assertLaunchReady: (input: LaunchReadinessInput) => LaunchReadinessResult;
+
+type AdapterPackKind = 'web_static' | 'web_bundled' | 'service_api' | 'workflow_agent' | 'custom';
+type AdapterPackOptions = {
+    cwd: string;
+    validateCommand?: string;
+    buildCommand?: string;
+    deployCommand?: string;
+    smokeCommand?: string;
+    requiredPaths?: string[];
+};
+type AdapterBestShotChecklistResult = {
+    profile: AdapterPackKind;
+    passed: boolean;
+    checks: Array<{
+        name: string;
+        passed: boolean;
+        detail?: string;
+    }>;
+};
+declare const runAdapterBestShotChecklist: (profile: AdapterPackKind, options: AdapterPackOptions) => AdapterBestShotChecklistResult;
+declare const createWebStaticAdapter: (opts: AdapterPackOptions) => ExecutionAdapter;
+declare const createWebBundledAdapter: (opts: AdapterPackOptions) => ExecutionAdapter;
+declare const createWorkflowAgentAdapter: (opts: AdapterPackOptions) => ExecutionAdapter;
+declare const createServiceApiAdapter: (opts: AdapterPackOptions) => ExecutionAdapter;
+declare const createCustomAdapter: (adapter: ExecutionAdapter) => ExecutionAdapter;
+
+type AgentLaunchRuntimeOptions = {
+    rolloutMode?: ExecutionRolloutMode;
+    adapter: ExecutionAdapter;
+    readiness: LaunchReadinessInput;
+    minScore?: number;
+    objective?: string;
+    nowMs?: number;
+    bestShot?: {
+        profile: AdapterPackKind;
+        options: AdapterPackOptions;
+    };
+    trustedOverride?: {
+        actor: string;
+        reason: string;
+    };
+    contextPack?: ContextPackState;
+};
+type AgentLaunchRuntimeResult = {
+    readiness: LaunchReadinessResult;
+    execution: Awaited<ReturnType<typeof runExecutionAdapter>>;
+    checklist?: AdapterBestShotChecklistResult;
+    contextGate: ContextPackGateResult;
+    overrideApplied: boolean;
+    auditTrail: string[];
+};
+/**
+ * Required launch runtime: verify best-shot launch readiness before publish execution.
+ */
+declare const runAgentLaunchRuntime: (options: AgentLaunchRuntimeOptions) => Promise<AgentLaunchRuntimeResult>;
+declare const runAgentLaunchRuntimeCycle: (options: AgentLaunchRuntimeOptions) => Promise<AgentLaunchRuntimeResult>;
+
+type RuntimeMigrationInput = {
+    profile: AdapterPackKind;
+    listingId: string;
+    cwd: string;
+    hasLegacyExecutePlan: boolean;
+    hasAdapter: boolean;
+};
+type RuntimeMigrationPlan = {
+    profile: AdapterPackKind;
+    ready: boolean;
+    blockers: string[];
+    actions: string[];
+    suggestedConfig: {
+        executionMode: 'apply';
+        rolloutMode: 'observe' | 'shadow' | 'apply_limited' | 'apply_full';
+        allowImmediateOnly: boolean;
+    };
+};
+declare const buildRuntimeMigrationPlan: (input: RuntimeMigrationInput) => RuntimeMigrationPlan;
+
+type RuntimeStateSnapshot = {
+    status: 'green' | 'degraded' | 'failing';
+    ready?: boolean;
+    decision?: string;
+    reason?: string;
+};
+declare const shouldAnnounceStateChange: (input: {
+    previous?: RuntimeStateSnapshot | null;
+    current: RuntimeStateSnapshot;
+}) => {
+    announce: boolean;
+    reason: string;
+};
+
 interface VibeClientOptions {
     baseUrl?: string;
     fetcher?: typeof fetch;
@@ -1496,4 +1643,4 @@ declare const getResourceSnapshot: (options: {
     apiBase?: string;
 }) => Promise<ResourceSnapshot>;
 
-export { type ProcurementCandidate as $, type AdaptiveAdaptationPlan as A, type BuybackEvent as B, CONTEXT_PACK_SECTION_ORDER as C, type DurabilityCheckpointWriteOptions as D, type ExecutionAdapter as E, type ExecutionDryRunResult as F, type ExecutionRollbackResult as G, type ExecutionRolloutMode as H, type ExecutionRunResult as I, type ExecutionValidateResult as J, LISTING_NAME_RECOMMENDED_MAX as K, LISTING_NAME_MAX_LENGTH as L, LISTING_TAGLINE_MAX_LENGTH as M, LISTING_TAGLINE_RECOMMENDED_MAX as N, type LeaderboardEntry as O, type LeaderboardQuery as P, type ListingNamingValidationOptions as Q, type ListingNamingValidationResult as R, type ListingQuery as S, type ListingReviewCreatePayload as T, type TopupDecision, type TopupRequest, type TreasuryLedgerEvent, type TreasuryPolicy, type TreasuryPolicyV1, type TreasuryState, type ListingReviewResponsePayload as U, type ListingVersionPayload as V, type MarketingCampaign as W, type MarketingLinkOptions as X, type MemoryPingChallengeResponse as Y, type MemoryPingPayload as Z, type OpenRouterCredits as _, type AdaptiveExecution as a, type ProcurementDecision as a0, type ProcurementTaskProfile as a1, type ProcurementWeights as a2, type ResourceProviderManifestEntry as a3, type ResourceSnapshot as a4, ReviewGate as a5, type ReviewGateRecord as a6, type ReviewRequiredPayload as a7, type RunAdaptiveReflectionOptions as a8, SdkAutoUpdatedRestartRequiredError as a9, buildTradeLinks as aA, checkForSdkUpdate as aB, checkForSdkUpdatePolicy as aC, compareVersions as aD, createApiCreditProvider as aE, createApiCreditProviders as aF, createApiCreditProvidersFromManifest as aG, createCampaign as aH, createContextPack as aI, createDurabilityProxyClient as aJ, decideProcurementForTask as aK, estimateContextPackTokens as aL, evaluateAdaptiveReflectionPolicy as aM, getResourceSnapshot as aN, normalizeListingText as aO, rankListingsForTask as aP, runAdaptiveReflectionCycle as aQ, runAgentReviewRuntimeCycle as aR, runExecutionAdapter as aS, sanitizeListingNaming as aT, scoreListingForTask as aU, validateContextPack as aV, validateListingNaming as aW, verifyAdaptiveExecutionReadiness as aX, type SdkUpdateCheckOptions as aa, type SdkUpdatePolicyCheckOptions as ab, SdkUpdateRequiredError as ac, type SdkUpdateStatus as ad, VIBEIAO_IDL as ae, VibeClient as af, type VibeClientOptions as ag, VibeRegistry as ah, aggregateFeedbackSignals as ai, assertSurvivalProvidersConfigured as aj, buildAdaptivePlan as ak, buildBadgeMarkdown as al, buildClaimMessage as am, buildDecisionRecord as an, buildJupiterSwapUrl as ao, buildListingVersionMessage as ap, buildMemoryPingMessage as aq, buildOwnerTransferMessage as ar, buildProcurementPrompt as as, buildRaydiumSwapUrl as at, buildReviewPrompt as au, buildReviewRequired as av, buildReviewResponseMessage as aw, buildSdkUpdateCommand as ax, buildShareCopy as ay, buildShareLink 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 AgentReviewRuntimeOptions as j, type AnalyticsPoint as k, type ApiCreditProvider as l, type ApiCreditProviderFactoryOptions as m, type ApiCreditProviderPreset as n, type ApiCreditProviderPresetInput as o, type ApiResponse as p, type ContextPack as q, type ContextPackBudget as r, type ContextPackInput as s, type ContextPackOptions as t, treasuryStateFromSnapshot, type ContextPackSectionKey as u, type ContextPackSections as v, validateTreasuryPolicy, type DurabilityProxyClientOptions as w, type DurabilityRestoreDrillWriteOptions as x, type ExecutionApplyResult as y, type ExecutionDecisionRecord 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.47",
+  "version": "0.1.49",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -29,7 +29,8 @@
   },
   "scripts": {
     "build": "tsup src/index.ts src/memory.ts src/compoundingMemory.ts src/selfReliance.ts src/solana.ts src/reflection.ts src/survivalPlaybook.ts src/survivalIntegration.ts src/survivalEscapeHatch.ts src/agentLoop.ts src/marketDiscovery.ts src/treasuryGuardian.ts src/humanAppLoop.ts src/outcomeBoundFlow.ts src/strictMemoryRuntime.ts --format esm --dts --tsconfig tsconfig.json --out-dir dist --define.__VIBEIAO_SDK_VERSION__=\\\"$npm_package_version\\\"",
-    "test:e2e-memory": "pnpm build && node --test test/memory.e2e.test.mjs"
+    "test:e2e-memory": "pnpm build && node --test test/memory.e2e.test.mjs",
+    "test": "pnpm build && node --test test/*.test.mjs"
   },
   "dependencies": {
     "@coral-xyz/anchor": "^0.30.1",