@vibeiao/sdk 0.1.46 → 0.1.48

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 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 { 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 { 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,6 +589,344 @@ var runAdaptiveReflectionCycle = async (opts) => {
   };
 };
 
+// src/agentReviewRuntime.ts
+var runAgentReviewRuntimeCycle = async (opts) => {
+  if (!opts.adapter) {
+    throw new Error("agent_review_runtime_requires_execution_adapter");
+  }
+  return runAdaptiveReflectionCycle({
+    client: opts.client,
+    listingId: opts.listingId,
+    wallet: opts.wallet,
+    signMessage: opts.signMessage,
+    reflectionStore: opts.reflectionStore,
+    policy: opts.policy,
+    reflectionOptions: opts.reflectionOptions,
+    execution: {
+      mode: "apply",
+      rolloutMode: opts.rolloutMode || "apply_full",
+      allowImmediateOnly: opts.allowImmediateOnly ?? false,
+      adapter: opts.adapter
+    },
+    now: opts.now
+  });
+};
+
+// 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;
+  let verified = readiness.ready && readiness.score >= minScore;
+  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"] : []
+  ];
+  const record = buildDecisionRecord({
+    decision: verified ? "adapt" : "hold",
+    confidence: readiness.score,
+    verified,
+    reasons,
+    objective: options.objective || "best_shot_launch",
+    nowMs: options.nowMs
+  });
+  const requestedMode = options.rolloutMode || "shadow";
+  const mode = verified ? requestedMode : "observe";
+  const execution = await runExecutionAdapter({
+    mode,
+    record,
+    adapter: options.adapter
+  });
+  auditTrail.push(`execution:${execution.reason}`);
+  return { readiness, execution, checklist, 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
 var SdkUpdateRequiredError = class extends Error {
   status;
@@ -705,7 +1043,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.45" ? "0.1.45" : "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;
@@ -897,9 +1235,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)) {
@@ -1200,9 +1538,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);
@@ -1218,9 +1556,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)
@@ -1240,9 +1578,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)
@@ -1837,6 +2175,7 @@ export {
   VibeClient,
   VibeRegistry,
   aggregateFeedbackSignals,
+  assertLaunchReady,
   assertOutcomeBoundCompleted,
   assertSurvivalProvidersConfigured,
   buildAdaptivePlan,
@@ -1854,6 +2193,7 @@ export {
   buildReviewPrompt,
   buildReviewRequired,
   buildReviewResponseMessage,
+  buildRuntimeMigrationPlan,
   buildSdkUpdateCommand,
   buildShareCopy,
   buildShareLink,
@@ -1871,19 +2211,25 @@ export {
   createAutoSelfReliance,
   createCampaign,
   createContextPack,
+  createCustomAdapter,
   createDurabilityProxyClient,
   createInMemoryReflectionStore,
   createSelfRelianceMonitor,
   createSelfReliancePolicy,
+  createServiceApiAdapter,
   createStrictMemoryRuntimePreset,
   createSurvivalMiddleware,
   createTreasuryPolicy,
+  createWebBundledAdapter,
+  createWebStaticAdapter,
+  createWorkflowAgentAdapter,
   decideProcurementForTask,
   deriveMarketNeeds,
   discoverMarketNeeds,
   estimateContextPackTokens,
   evaluateAdaptiveReflectionPolicy,
   evaluateEscapeHatch,
+  evaluateLaunchReadiness,
   evaluateObjectiveChange,
   evaluateOutcomeBoundRun,
   evaluatePromptShield,
@@ -1902,13 +2248,18 @@ export {
   isComplexTask,
   normalizeListingText,
   rankListingsForTask,
+  runAdapterBestShotChecklist,
   runAdaptiveReflectionCycle,
+  runAgentLaunchRuntime,
+  runAgentLaunchRuntimeCycle,
+  runAgentReviewRuntimeCycle,
   runExecutionAdapter,
   runMarketDiscovery,
   runReflectionCycle,
   sanitizeListingNaming,
   scoreListingForTask,
   scoreReviewPriority,
+  shouldAnnounceStateChange,
   treasuryStateFromSnapshot,
   upgradeToStrictMemoryRuntimePreset,
   validateContextPack,

package/dist/treasuryGuardian.d.ts

@@ -1009,6 +1009,156 @@ declare const runAdaptiveReflectionCycle: (opts: RunAdaptiveReflectionOptions) =
     policyState: AdaptivePolicyState;
 }>;
 
+type AgentReviewRuntimeOptions = {
+    client: ReflectionClient;
+    listingId: string;
+    wallet: string;
+    signMessage: ReflectionCycleOptions['signMessage'];
+    reflectionStore?: AdaptiveReflectionStore;
+    policy?: AdaptivePolicyConfig;
+    rolloutMode?: ExecutionRolloutMode;
+    adapter: ExecutionAdapter;
+    allowImmediateOnly?: boolean;
+    reflectionOptions?: Omit<ReflectionCycleOptions, 'client' | 'listingId' | 'wallet' | 'signMessage' | 'store'>;
+    now?: () => number;
+};
+/**
+ * Required default review runtime for VIBEIAO agents.
+ * Enforces verify->execute using the execution adapter contract.
+ */
+declare const runAgentReviewRuntimeCycle: (opts: AgentReviewRuntimeOptions) => Promise<{
+    generatedAt: string;
+    aggregate: AdaptiveFeedbackAggregate;
+    decision: AdaptivePolicyDecision;
+    verification: AdaptiveVerification;
+    execution: AdaptiveExecution;
+    plan: AdaptiveAdaptationPlan;
+    reflection: ReflectionCycleResult;
+    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;
+    };
+};
+type AgentLaunchRuntimeResult = {
+    readiness: LaunchReadinessResult;
+    execution: Awaited<ReturnType<typeof runExecutionAdapter>>;
+    checklist?: AdapterBestShotChecklistResult;
+    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;
@@ -1287,7 +1437,7 @@ declare class ReviewGate {
     assertClear(listingId: string, wallet: string): void;
 }
 
-declare const compareVersions: (currentVersion: string, latestVersion: string) => 0 | 1 | -1;
+declare const compareVersions: (currentVersion: string, latestVersion: string) => 1 | 0 | -1;
 declare const buildSdkUpdateCommand: (packageName?: string) => string;
 declare const checkForSdkUpdate: (options?: SdkUpdateCheckOptions) => Promise<SdkUpdateStatus>;
 declare const checkForSdkUpdatePolicy: (options: SdkUpdatePolicyCheckOptions) => Promise<SdkUpdateStatus>;
@@ -1468,4 +1618,4 @@ declare const getResourceSnapshot: (options: {
     apiBase?: string;
 }) => Promise<ResourceSnapshot>;
 
-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 };
+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 };

package/package.json

@@ -2,7 +2,7 @@
   "name": "@vibeiao/sdk",
   "private": false,
   "type": "module",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "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",