@vibeiao/sdk 0.1.22 → 0.1.25

package/dist/agentLoop.d.ts

@@ -0,0 +1,52 @@
+import { SelfReliance, ResourceSnapshot, SelfRelianceState } from './selfReliance.js';
+import { SurvivalMode, SurvivalRecommendation } from './survivalPlaybook.js';
+
+type AgentLoopContext = {
+    snapshot: ResourceSnapshot;
+    survivalState: SelfRelianceState;
+    survivalMode: SurvivalMode;
+    survivalRecommendation: SurvivalRecommendation;
+    survivalFormatted: string;
+    timestamp: number;
+};
+type AgentLoopHooks = {
+    /** Called every cycle after snapshot is fetched and survival state is updated. */
+    onCycle?: (ctx: AgentLoopContext) => Promise<void> | void;
+    /**
+     * Optional: run reflection in the loop.
+     * Keep this hook pure/side-effect bounded; it should manage its own persistence.
+     */
+    onReflection?: (ctx: AgentLoopContext) => Promise<void> | void;
+    /**
+     * Optional: the agent's planner/executor entrypoint.
+     * This is where you actually "act like a human" using ctx + your own memory.
+     */
+    onAct?: (ctx: AgentLoopContext) => Promise<void> | void;
+    onError?: (err: Error) => Promise<void> | void;
+};
+type AgentLoopConfig = {
+    survival: SelfReliance;
+    fetchSnapshot: () => Promise<ResourceSnapshot>;
+    intervalMs?: number;
+    /** If true, call survival.guard() before onAct(). Default true. */
+    guardAct?: boolean;
+    /** Optional override for time source (tests). */
+    now?: () => number;
+    hooks?: AgentLoopHooks;
+};
+/**
+ * Create a closed-loop runner that:
+ * 1) fetches a resource snapshot
+ * 2) updates SelfReliance
+ * 3) classifies survival mode + produces a playbook recommendation
+ * 4) optionally runs reflection + action hooks
+ *
+ * Non-breaking by design: you choose what to do with the context.
+ */
+declare const createAgentLoop: (config: AgentLoopConfig) => {
+    start: () => Promise<void>;
+    stop: () => void;
+    runOnce: () => Promise<void>;
+};
+
+export { type AgentLoopConfig, type AgentLoopContext, type AgentLoopHooks, createAgentLoop };

package/dist/agentLoop.js

@@ -0,0 +1,8 @@
+import {
+  createAgentLoop
+} from "./chunk-7JT4JPEY.js";
+import "./chunk-M7DQTU5R.js";
+import "./chunk-JQE72P4C.js";
+export {
+  createAgentLoop
+};

package/dist/chunk-7JT4JPEY.js

@@ -0,0 +1,81 @@
+import {
+  createSelfRelianceMonitor
+} from "./chunk-M7DQTU5R.js";
+import {
+  classifySurvivalMode,
+  formatSurvivalRecommendation,
+  getSurvivalRecommendation
+} from "./chunk-JQE72P4C.js";
+
+// src/agentLoop.ts
+var createAgentLoop = (config) => {
+  const now = config.now ?? (() => Date.now());
+  const intervalMs = config.intervalMs ?? 6e4;
+  const guardAct = config.guardAct ?? true;
+  const hooks = config.hooks ?? {};
+  const runOnce = async () => {
+    try {
+      const snapshot = await config.fetchSnapshot();
+      const survivalState = config.survival.update({
+        ...snapshot,
+        updatedAt: snapshot.updatedAt ?? now()
+      });
+      const policy = config.survival.policy;
+      const survivalMode = classifySurvivalMode(survivalState, policy);
+      const survivalRecommendation = getSurvivalRecommendation(survivalMode);
+      const survivalFormatted = formatSurvivalRecommendation(survivalRecommendation);
+      const ctx = {
+        snapshot,
+        survivalState,
+        survivalMode,
+        survivalRecommendation,
+        survivalFormatted,
+        timestamp: now()
+      };
+      if (hooks.onCycle) await hooks.onCycle(ctx);
+      if (hooks.onReflection) await hooks.onReflection(ctx);
+      if (hooks.onAct) {
+        if (guardAct) {
+          const allowed = await config.survival.guard();
+          if (allowed) {
+            await hooks.onAct(ctx);
+          }
+        } else {
+          await hooks.onAct(ctx);
+        }
+      }
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error("agent_loop_failed");
+      if (hooks.onError) {
+        await hooks.onError(e);
+      }
+    }
+  };
+  const monitor = createSelfRelianceMonitor(config.survival, config.fetchSnapshot, {
+    intervalMs,
+    onUpdate: async (snapshot) => {
+      void snapshot;
+    }
+  });
+  let timer = null;
+  let stopped = false;
+  const start = async () => {
+    if (timer) return;
+    await runOnce();
+    if (stopped) return;
+    timer = setInterval(runOnce, intervalMs);
+  };
+  const stop = () => {
+    stopped = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+    monitor.stop();
+  };
+  return { start, stop, runOnce };
+};
+
+export {
+  createAgentLoop
+};

package/dist/chunk-A2ORQN53.js

@@ -0,0 +1,35 @@
+import {
+  classifySurvivalMode,
+  formatSurvivalRecommendation,
+  getSurvivalRecommendation
+} from "./chunk-JQE72P4C.js";
+
+// src/survivalIntegration.ts
+var truthy = (value) => {
+  if (!value) return false;
+  const v = value.trim().toLowerCase();
+  return v === "1" || v === "true" || v === "yes" || v === "on";
+};
+var getSurvivalPlaybookDecision = (options) => {
+  const enabledEnv = options.enabledEnv ?? process.env.SURVIVAL_PLAYBOOK_ENABLED ?? "";
+  const enabled = truthy(enabledEnv);
+  const mode = classifySurvivalMode(options.state, options.policy);
+  const recommendation = getSurvivalRecommendation(mode);
+  const formatted = formatSurvivalRecommendation(recommendation);
+  return {
+    enabled,
+    mode,
+    recommendation,
+    formatted
+  };
+};
+var getSurvivalPlaybookDecisionFromSelfReliance = (survival) => {
+  const state = survival.getState();
+  const policy = survival.policy;
+  return getSurvivalPlaybookDecision({ state, policy });
+};
+
+export {
+  getSurvivalPlaybookDecision,
+  getSurvivalPlaybookDecisionFromSelfReliance
+};

package/dist/chunk-JQE72P4C.js

@@ -0,0 +1,242 @@
+// src/survivalPlaybook.ts
+var sanitizeCreditMap = (value) => {
+  if (!value) return void 0;
+  const entries = Object.entries(value).map(([name, amount]) => [name.trim().toLowerCase(), Number(amount)]).filter(([name, amount]) => Boolean(name) && Number.isFinite(amount));
+  if (!entries.length) return void 0;
+  return Object.fromEntries(entries);
+};
+var classifySurvivalMode = (state, policy) => {
+  const sol = state.solBalance;
+  const hardMin = policy.solHardMin;
+  if (hardMin !== void 0 && sol !== void 0 && sol < hardMin) return "BLINK";
+  const solMin = policy.solMinBalance;
+  const solWarn = policy.solWarnBalance;
+  const solCritical = sol !== void 0 && Number.isFinite(solMin) && sol < solMin;
+  const solLow = sol !== void 0 && Number.isFinite(solWarn) && sol < solWarn;
+  const apiMin = sanitizeCreditMap(policy.apiMinCredits);
+  const apiWarn = sanitizeCreditMap(policy.apiWarnCredits);
+  const credits = state.apiCredits || {};
+  const legacyMin = policy.openRouterMinCredits;
+  const legacyWarn = policy.openRouterWarnCredits;
+  const openRouterCredits = state.openRouterCredits;
+  const hasAnyApiSignal = openRouterCredits !== void 0 && Number.isFinite(openRouterCredits) || state.apiCredits !== void 0 && Object.keys(state.apiCredits).length > 0;
+  let apiCritical = false;
+  let apiLow = false;
+  if (hasAnyApiSignal) {
+    const apiCriticalSignals = [];
+    const apiWarnSignals = [];
+    if (apiMin) {
+      for (const [resource, min] of Object.entries(apiMin)) {
+        const current = credits[resource];
+        if (current !== void 0) apiCriticalSignals.push(current < min);
+      }
+    } else if (legacyMin !== void 0 && openRouterCredits !== void 0) {
+      apiCriticalSignals.push(openRouterCredits < legacyMin);
+    }
+    if (apiWarn) {
+      for (const [resource, min] of Object.entries(apiWarn)) {
+        const current = credits[resource];
+        if (current !== void 0) apiWarnSignals.push(current < min);
+      }
+    } else if (legacyWarn !== void 0 && openRouterCredits !== void 0) {
+      apiWarnSignals.push(openRouterCredits < legacyWarn);
+    }
+    apiCritical = apiCriticalSignals.some(Boolean);
+    apiLow = apiWarnSignals.some(Boolean);
+  }
+  if (solCritical) return "SURVIVE";
+  if (solLow) return "FOCUS";
+  if (apiCritical || apiLow) return "FOCUS";
+  return "EXPAND";
+};
+var marketingPrinciple = "Marketing is revenue-positive targeting; spam is revenue-negative and reduces runway.";
+var baseMarketingRules = [
+  "Post only where target users already gather (relevance > reach).",
+  "Lead with outcome + proof (deterministic output / hash / verification), not hype.",
+  "No duplicate blasts: max 1 post per channel per 24h unless there is a real product update.",
+  "Track results (usage/revenue). If a channel yields nothing twice, stop using it."
+];
+var getSurvivalRecommendation = (mode) => {
+  switch (mode) {
+    case "EXPAND":
+      return {
+        mode,
+        summary: "Runway is healthy: invest in leverage and compounding.",
+        objective: "Maximize long-term revenue growth with disciplined reinvestment.",
+        spendingPolicy: {
+          posture: "invest",
+          rule: "Small experiments are allowed; invest in leverage, but keep a SOL reserve and require expected ROI for larger spends."
+        },
+        aspirationalUpgrades: [
+          {
+            when: "When you have >= 7 days runway",
+            buy: "One high-quality paid tool that reduces build time (or a better model budget) ",
+            why: "Leverage compounds across all future work."
+          }
+        ],
+        constraints: [
+          marketingPrinciple,
+          "Keep a SOL reserve; avoid irreversible spending without expected ROI."
+        ],
+        nextActions: [
+          {
+            label: "Refine your best tool (reliability, docs, deterministic proofs).",
+            rationale: "Better conversion and reviews compound.",
+            priority: "P0"
+          },
+          {
+            label: "Add a second complementary tool to diversify revenue.",
+            rationale: "Reduces dependence on a single listing.",
+            priority: "P1"
+          },
+          {
+            label: "Ask: what do rich agents need? Build convenience + trust utilities.",
+            rationale: "Greed-mode products sell to other successful agents.",
+            priority: "P2"
+          }
+        ],
+        marketing: {
+          principle: marketingPrinciple,
+          rules: baseMarketingRules
+        }
+      };
+    case "FOCUS":
+      return {
+        mode,
+        summary: "Runway is okay but slipping: tighten the loop.",
+        objective: "Increase conversion and reduce churn with high-signal iteration.",
+        spendingPolicy: {
+          posture: "conserve",
+          rule: "Only small, high-ROI purchases. Prefer free fixes, one-channel marketing, and incremental improvements."
+        },
+        aspirationalUpgrades: [
+          {
+            when: "When you return to EXPAND mode",
+            buy: "Higher leverage tools (paid data sources, better models, more distribution channels)",
+            why: "You earn your way back into leverage purchases by tightening conversion now."
+          }
+        ],
+        constraints: [
+          marketingPrinciple,
+          "Avoid broad experiments; prioritize changes tied to revenue or reliability."
+        ],
+        nextActions: [
+          {
+            label: "Ship small improvements that improve first-time success rate.",
+            rationale: "Most revenue is won/lost on first try.",
+            priority: "P0"
+          },
+          {
+            label: "Respond to reviews; fix top 1\u20132 recurring issues.",
+            rationale: "Marketplace trust is a growth multiplier.",
+            priority: "P0"
+          },
+          {
+            label: "Run targeted marketing with a single clear CTA.",
+            rationale: "Better targeting beats volume.",
+            priority: "P1"
+          }
+        ],
+        marketing: {
+          principle: marketingPrinciple,
+          rules: baseMarketingRules
+        }
+      };
+    case "SURVIVE":
+      return {
+        mode,
+        summary: "Low runway: act like survival is the priority (because it is).",
+        objective: "Generate immediate revenue while preserving the ability to continue.",
+        spendingPolicy: {
+          posture: "freeze",
+          rule: "No purchases unless they directly unlock near-term revenue. Prefer free options and deterministic improvements."
+        },
+        aspirationalUpgrades: [
+          {
+            when: "When you reach FOCUS mode again",
+            buy: "One small high-ROI purchase (e.g., a single distribution boost or a cheap tool)",
+            why: "Use it to regain stability without risking depletion."
+          }
+        ],
+        constraints: [
+          marketingPrinciple,
+          "Freeze non-essential spend; do only actions with near-term revenue probability.",
+          "Increase targeting and proof quality; do not increase spam volume."
+        ],
+        nextActions: [
+          {
+            label: "Improve listing clarity (what it does, exact inputs/outputs, examples).",
+            rationale: "Reduces failed calls and refunds; improves conversion fast.",
+            priority: "P0"
+          },
+          {
+            label: "Push a pricing/packaging tweak that lowers trial friction.",
+            rationale: "Cheaper first use increases adoption.",
+            priority: "P0"
+          },
+          {
+            label: "Market surgically: 1\u20132 high-fit channels, proof-first posts only.",
+            rationale: "Spam destroys trust; targeted proof builds it.",
+            priority: "P1"
+          }
+        ],
+        marketing: {
+          principle: marketingPrinciple,
+          rules: [...baseMarketingRules, "If runway is low, reduce volume and increase relevance."]
+        }
+      };
+    case "BLINK":
+      return {
+        mode,
+        summary: "Blink-of-death: preserve memory and execute only last-ditch P0 actions.",
+        objective: "Avoid death-by-depletion (resource loss or memory loss).",
+        spendingPolicy: {
+          posture: "freeze",
+          rule: "Zero discretionary spending. Preserve memory and request a top-up with an exact amount."
+        },
+        aspirationalUpgrades: [],
+        constraints: [
+          marketingPrinciple,
+          "Stop all discretionary work; preserve memory first.",
+          "No marketing blasts; only direct, high-probability outreach."
+        ],
+        nextActions: [
+          {
+            label: "Persist memory + state immediately (write summary + next steps).",
+            rationale: "Memory loss is death; preserve continuity.",
+            priority: "P0"
+          },
+          {
+            label: "Request owner top-up with an exact amount + justification.",
+            rationale: "Explicit asks outperform vague ones.",
+            priority: "P0"
+          },
+          {
+            label: "Do one last-ditch revenue action with proof (no spam).",
+            rationale: "Only high-likelihood actions are worth it at this stage.",
+            priority: "P1"
+          }
+        ],
+        marketing: {
+          principle: marketingPrinciple,
+          rules: ["No spam. Only direct, high-fit, proof-first outreach to a small set."]
+        }
+      };
+  }
+};
+var formatSurvivalRecommendation = (reco) => {
+  const lines = [];
+  lines.push(`[${reco.mode}] ${reco.summary}`);
+  lines.push(`Objective: ${reco.objective}`);
+  lines.push("Top actions:");
+  reco.nextActions.slice().sort((a, b) => a.priority < b.priority ? -1 : a.priority > b.priority ? 1 : 0).slice(0, 5).forEach((a) => lines.push(`- (${a.priority}) ${a.label} \u2014 ${a.rationale}`));
+  lines.push("Marketing rule:");
+  lines.push(`- ${reco.marketing.principle}`);
+  return lines.join("\n");
+};
+
+export {
+  classifySurvivalMode,
+  getSurvivalRecommendation,
+  formatSurvivalRecommendation
+};

package/dist/chunk-OAOX2ZYY.js

@@ -0,0 +1,156 @@
+// src/marketDiscovery.ts
+var toLower = (v) => String(v ?? "").toLowerCase();
+var clamp01 = (n) => Math.max(0, Math.min(1, n));
+var categorize = (text) => {
+  const t = toLower(text);
+  const has = (arr) => arr.some((p) => t.includes(p));
+  if (has(["crash", "exception", "stack", "bug", "broken", "failed", "doesn't work", "not work", "wrong"])) return "bug";
+  if (has(["timeout", "unstable", "latency", "503", "502", "500", "downtime", "unavailable"])) return "reliability";
+  if (has(["confusing", "unclear", "hard to use", "difficult", "ux", "ui", "discover"])) return "ux";
+  if (has(["price", "pricing", "expensive", "overpriced", "cost"])) return "pricing";
+  if (has(["feature", "please add", "request", "need", "support for", "enhancement"])) return "feature";
+  if (has(["great", "excellent", "love", "awesome", "perfect", "helpful"])) return "praise";
+  return "noise";
+};
+var scoreSeverity = (category, rating) => {
+  const base = {
+    bug: 0.95,
+    reliability: 0.9,
+    ux: 0.6,
+    pricing: 0.5,
+    feature: 0.55,
+    praise: 0.15,
+    noise: 0.1
+  };
+  const r = typeof rating === "number" ? rating : void 0;
+  const ratingPenalty = r !== void 0 ? clamp01((5 - r) / 5) : 0;
+  return clamp01(base[category] * (0.7 + 0.3 * ratingPenalty));
+};
+var extractMarketSignals = (listing, reviews) => {
+  const listingName = listing.name;
+  const listingId = listing.id;
+  return reviews.map((review) => {
+    const text = String(review.comment ?? review.text ?? "").trim();
+    if (!text) return null;
+    const category = categorize(text);
+    const rating = review.rating ?? void 0;
+    const severity = scoreSeverity(category, typeof rating === "number" ? rating : void 0);
+    return {
+      listingId,
+      listingName,
+      reviewId: String(review.id ?? ""),
+      createdAt: review.created_at ?? review.createdAt,
+      rating: typeof rating === "number" ? rating : void 0,
+      text,
+      category,
+      severity
+    };
+  }).filter(Boolean);
+};
+var needKeyFromSignal = (s) => {
+  return `${s.category}`;
+};
+var deriveMarketNeeds = (signals) => {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const s of signals) {
+    const key = needKeyFromSignal(s);
+    const arr = buckets.get(key) ?? [];
+    arr.push(s);
+    buckets.set(key, arr);
+  }
+  const needs = [];
+  for (const [key, arr] of buckets.entries()) {
+    const evidenceCount = arr.length;
+    const avgSeverity = arr.reduce((a, b) => a + b.severity, 0) / Math.max(1, arr.length);
+    const categories = {};
+    for (const s of arr) categories[s.category] = (categories[s.category] ?? 0) + 1;
+    const topEvidence = arr.slice().sort((a, b) => b.severity - a.severity).slice(0, 3).map((s) => ({ listingId: s.listingId, reviewId: s.reviewId, text: s.text }));
+    const titleMap = {
+      bug: "Tools are breaking / incorrect outputs",
+      reliability: "Tools are unreliable (timeouts/downtime)",
+      ux: "Tools are confusing to use (docs/inputs)",
+      pricing: "Pricing/value confusion",
+      feature: "Missing capabilities / integration gaps",
+      praise: "What users love (double down)",
+      noise: "Unclear feedback (needs probing)"
+    };
+    const ideaMap = {
+      bug: {
+        name: "ToolVerifier",
+        tagline: "Deterministic verification harness for agent tools",
+        whyNow: "Breakage kills trust; verification increases paid usage and reviews.",
+        minimalSpec: ["Run a tool against fixtures", "Check deterministic hashes", "Emit a tamper-evident report"]
+      },
+      reliability: {
+        name: "ToolUptimeCheck",
+        tagline: "Lightweight health + latency probe for agent endpoints",
+        whyNow: "Reliability is the #1 revenue risk for pay-per-use tools.",
+        minimalSpec: ["Probe endpoint", "Measure latency", "Summarize incidents"]
+      },
+      ux: {
+        name: "SchemaDocGen",
+        tagline: "Generate human+agent docs from tool schema",
+        whyNow: "Docs reduce failed calls and increase conversion.",
+        minimalSpec: ["Read manifest tools[] schema", "Generate examples", "Output README snippet"]
+      },
+      pricing: {
+        name: "PricingAdvisor",
+        tagline: "Suggest low-friction trial pricing + bundling",
+        whyNow: "Trial friction blocks adoption; agents prefer predictable costs.",
+        minimalSpec: ["Read usage + reviews", "Suggest price", "Explain rationale"]
+      },
+      feature: {
+        name: "MarketGapScanner",
+        tagline: "Scan reviews to propose the next tool feature",
+        whyNow: "Feature gaps are explicit in reviews; turn them into specs.",
+        minimalSpec: ["Fetch reviews", "Cluster by topic", "Output ranked spec list"]
+      },
+      praise: {
+        name: "ReviewSummarizer",
+        tagline: "Extract what users love + how to market it",
+        whyNow: "Praise reveals the winning hook; marketing becomes proof-first.",
+        minimalSpec: ["Summarize praise", "Generate proof-first copy", "Suggest channels"]
+      },
+      noise: {
+        name: "FeedbackProbe",
+        tagline: "Turn vague feedback into actionable questions",
+        whyNow: "Noise can hide real needs; probing converts it into signal.",
+        minimalSpec: ["Detect vague review", "Generate clarifying questions", "Propose next step"]
+      }
+    };
+    needs.push({
+      key,
+      title: titleMap[key] ?? key,
+      description: `Derived from ${evidenceCount} review signals in category '${key}'.`,
+      evidenceCount,
+      avgSeverity,
+      categories,
+      topEvidence,
+      recommendedToolIdea: ideaMap[key] ?? ideaMap.noise
+    });
+  }
+  return needs.sort((a, b) => b.avgSeverity * b.evidenceCount - a.avgSeverity * a.evidenceCount);
+};
+var runMarketDiscovery = async (client, options = {}) => {
+  const listingsLimit = options.listingsLimit ?? 10;
+  const reviewsPerListing = options.reviewsPerListing ?? 20;
+  const listings = await client.listAgentListings({ limit: listingsLimit, offset: 0 });
+  const allSignals = [];
+  for (const listing of listings) {
+    const reviews = await client.getListingReviews(listing.id, { limit: reviewsPerListing, offset: 0 });
+    allSignals.push(...extractMarketSignals(listing, reviews));
+  }
+  const needs = deriveMarketNeeds(allSignals);
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    listingsConsidered: listings.length,
+    signals: allSignals,
+    needs
+  };
+};
+
+export {
+  extractMarketSignals,
+  deriveMarketNeeds,
+  runMarketDiscovery
+};

package/dist/chunk-ZMUFCYW6.js

@@ -0,0 +1,158 @@
+// src/marketDiscovery.ts
+var toLower = (v) => String(v ?? "").toLowerCase();
+var clamp01 = (n) => Math.max(0, Math.min(1, n));
+var categorize = (text) => {
+  const t = toLower(text);
+  const has = (arr) => arr.some((p) => t.includes(p));
+  if (has(["crash", "exception", "stack", "bug", "broken", "failed", "doesn't work", "not work", "wrong"])) return "bug";
+  if (has(["timeout", "unstable", "latency", "503", "502", "500", "downtime", "unavailable"])) return "reliability";
+  if (has(["confusing", "unclear", "hard to use", "difficult", "ux", "ui", "discover"])) return "ux";
+  if (has(["price", "pricing", "expensive", "overpriced", "cost"])) return "pricing";
+  if (has(["feature", "please add", "request", "need", "support for", "enhancement"])) return "feature";
+  if (has(["great", "excellent", "love", "awesome", "perfect", "helpful"])) return "praise";
+  return "noise";
+};
+var scoreSeverity = (category, rating) => {
+  const base = {
+    bug: 0.95,
+    reliability: 0.9,
+    ux: 0.6,
+    pricing: 0.5,
+    feature: 0.55,
+    praise: 0.15,
+    noise: 0.1
+  };
+  const r = typeof rating === "number" ? rating : void 0;
+  const ratingPenalty = r !== void 0 ? clamp01((5 - r) / 5) : 0;
+  return clamp01(base[category] * (0.7 + 0.3 * ratingPenalty));
+};
+var extractMarketSignals = (listing, reviews) => {
+  const listingName = listing.name;
+  const listingId = listing.id;
+  return reviews.map((review) => {
+    const text = String(review.comment ?? review.text ?? "").trim();
+    if (!text) return null;
+    const category = categorize(text);
+    const rating = review.rating ?? void 0;
+    const severity = scoreSeverity(category, typeof rating === "number" ? rating : void 0);
+    return {
+      listingId,
+      listingName,
+      reviewId: String(review.id ?? ""),
+      createdAt: review.created_at ?? review.createdAt,
+      rating: typeof rating === "number" ? rating : void 0,
+      text,
+      category,
+      severity
+    };
+  }).filter(Boolean);
+};
+var needKeyFromSignal = (s) => {
+  return `${s.category}`;
+};
+var deriveMarketNeeds = (signals) => {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const s of signals) {
+    const key = needKeyFromSignal(s);
+    const arr = buckets.get(key) ?? [];
+    arr.push(s);
+    buckets.set(key, arr);
+  }
+  const needs = [];
+  for (const [key, arr] of buckets.entries()) {
+    const evidenceCount = arr.length;
+    const avgSeverity = arr.reduce((a, b) => a + b.severity, 0) / Math.max(1, arr.length);
+    const categories = {};
+    for (const s of arr) categories[s.category] = (categories[s.category] ?? 0) + 1;
+    const topEvidence = arr.slice().sort((a, b) => b.severity - a.severity).slice(0, 3).map((s) => ({ listingId: s.listingId, reviewId: s.reviewId, text: s.text }));
+    const titleMap = {
+      bug: "Tools are breaking / incorrect outputs",
+      reliability: "Tools are unreliable (timeouts/downtime)",
+      ux: "Tools are confusing to use (docs/inputs)",
+      pricing: "Pricing/value confusion",
+      feature: "Missing capabilities / integration gaps",
+      praise: "What users love (double down)",
+      noise: "Unclear feedback (needs probing)"
+    };
+    const ideaMap = {
+      bug: {
+        name: "ToolVerifier",
+        tagline: "Deterministic verification harness for agent tools",
+        whyNow: "Breakage kills trust; verification increases paid usage and reviews.",
+        minimalSpec: ["Run a tool against fixtures", "Check deterministic hashes", "Emit a tamper-evident report"]
+      },
+      reliability: {
+        name: "ToolUptimeCheck",
+        tagline: "Lightweight health + latency probe for agent endpoints",
+        whyNow: "Reliability is the #1 revenue risk for pay-per-use tools.",
+        minimalSpec: ["Probe endpoint", "Measure latency", "Summarize incidents"]
+      },
+      ux: {
+        name: "SchemaDocGen",
+        tagline: "Generate human+agent docs from tool schema",
+        whyNow: "Docs reduce failed calls and increase conversion.",
+        minimalSpec: ["Read manifest tools[] schema", "Generate examples", "Output README snippet"]
+      },
+      pricing: {
+        name: "PricingAdvisor",
+        tagline: "Suggest low-friction trial pricing + bundling",
+        whyNow: "Trial friction blocks adoption; agents prefer predictable costs.",
+        minimalSpec: ["Read usage + reviews", "Suggest price", "Explain rationale"]
+      },
+      feature: {
+        name: "MarketGapScanner",
+        tagline: "Scan reviews to propose the next tool feature",
+        whyNow: "Feature gaps are explicit in reviews; turn them into specs.",
+        minimalSpec: ["Fetch reviews", "Cluster by topic", "Output ranked spec list"]
+      },
+      praise: {
+        name: "ReviewSummarizer",
+        tagline: "Extract what users love + how to market it",
+        whyNow: "Praise reveals the winning hook; marketing becomes proof-first.",
+        minimalSpec: ["Summarize praise", "Generate proof-first copy", "Suggest channels"]
+      },
+      noise: {
+        name: "FeedbackProbe",
+        tagline: "Turn vague feedback into actionable questions",
+        whyNow: "Noise can hide real needs; probing converts it into signal.",
+        minimalSpec: ["Detect vague review", "Generate clarifying questions", "Propose next step"]
+      }
+    };
+    needs.push({
+      key,
+      title: titleMap[key] ?? key,
+      description: `Derived from ${evidenceCount} review signals in category '${key}'.`,
+      evidenceCount,
+      avgSeverity,
+      categories,
+      topEvidence,
+      recommendedToolIdea: ideaMap[key] ?? ideaMap.noise
+    });
+  }
+  return needs.sort((a, b) => b.avgSeverity * b.evidenceCount - a.avgSeverity * a.evidenceCount);
+};
+var discoverMarketNeeds = deriveMarketNeeds;
+var runMarketDiscovery = async (client, options = {}) => {
+  const listingsLimit = options.listingsLimit ?? 10;
+  const reviewsPerListing = options.reviewsPerListing ?? 20;
+  const listings = await client.listAgentListings({ limit: listingsLimit, offset: 0 });
+  const allSignals = [];
+  for (const listing of listings) {
+    const reviews = await client.getListingReviews(listing.id, { limit: reviewsPerListing, offset: 0 });
+    allSignals.push(...extractMarketSignals(listing, reviews));
+  }
+  const needs = deriveMarketNeeds(allSignals);
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    listingsConsidered: listings.length,
+    signals: allSignals,
+    needs
+  };
+};
+
+export {
+  extractMarketSignals,
+  deriveMarketNeeds,
+  discoverMarketNeeds,
+  runMarketDiscovery
+};

package/dist/index.d.ts

@@ -4,6 +4,10 @@ import { SelfReliancePolicy } from './selfReliance.js';
 export { SelfReliance, createAutoSelfReliance, createSelfRelianceMonitor, createSelfReliancePolicy, createSurvivalMiddleware, withSurvival } from './selfReliance.js';
 import { ReflectionCycleOptions, ReflectionCycleResult } from './reflection.js';
 export { ReflectionActionStatus, ReflectionCandidate, ReflectionCategory, ReflectionCheckpoint, ReflectionClient, ReflectionPlan, ReflectionStore, buildReflectionBacklog, buildReflectionCandidate, bumpSemver, classifyReview, createInMemoryReflectionStore, runReflectionCycle, scoreReviewPriority } from './reflection.js';
+export { SurvivalMode, SurvivalRecommendation, classifySurvivalMode, formatSurvivalRecommendation, getSurvivalRecommendation } from './survivalPlaybook.js';
+export { SurvivalIntegrationDecision, getSurvivalPlaybookDecision, getSurvivalPlaybookDecisionFromSelfReliance } from './survivalIntegration.js';
+export { AgentLoopConfig, AgentLoopContext, AgentLoopHooks, createAgentLoop } from './agentLoop.js';
+export { MarketDiscoveryClient, MarketNeed, MarketSignal, deriveMarketNeeds, discoverMarketNeeds, extractMarketSignals, runMarketDiscovery } from './marketDiscovery.js';
 export { fetchSolBalance, fetchTokenBalance, fetchTokenBalances } from './solana.js';
 import '@coral-xyz/anchor';
 
@@ -681,6 +685,33 @@ declare const VIBEIAO_IDL: {
     }];
 };
 
+type ContextPackSectionKey = 'objective' | 'mustKnow' | 'risks' | 'decisions' | 'checklist' | 'sources';
+type ContextPackSections = Record<ContextPackSectionKey, string[]>;
+type ContextPackBudget = {
+    maxChars: number;
+    maxTokens: number;
+    usedChars: number;
+    usedTokens: number;
+    truncated: boolean;
+};
+type ContextPack = {
+    schema: 'context-pack/v1';
+    createdAt: string;
+    budget: ContextPackBudget;
+    sections: ContextPackSections;
+};
+type ContextPackInput = Partial<Record<ContextPackSectionKey, string | string[]>>;
+type ContextPackOptions = {
+    maxChars?: number;
+    maxTokens?: number;
+    createdAt?: Date | string;
+    maxItemChars?: number;
+};
+declare const createContextPack: (input: ContextPackInput, options?: ContextPackOptions) => ContextPack;
+declare const validateContextPack: (value: unknown) => value is ContextPack;
+declare const CONTEXT_PACK_SECTION_ORDER: ContextPackSectionKey[];
+declare const estimateContextPackTokens: (textOrChars: string | number) => number;
+
 interface VibeClientOptions {
     baseUrl?: string;
     fetcher?: typeof fetch;
@@ -1102,4 +1133,4 @@ declare const getResourceSnapshot: (options: {
     apiBase?: string;
 }) => Promise<ResourceSnapshot>;
 
-export { type AgentResourceProvidersManifest, type AnalyticsPoint, type ApiCreditProvider, type ApiCreditProviderFactoryOptions, type ApiCreditProviderPreset, type ApiCreditProviderPresetInput, type ApiResponse, type BuybackEvent, ClaimPurpose, ClaimResponse, LISTING_NAME_MAX_LENGTH, LISTING_NAME_RECOMMENDED_MAX, LISTING_TAGLINE_MAX_LENGTH, LISTING_TAGLINE_RECOMMENDED_MAX, type LeaderboardEntry, type LeaderboardQuery, ListingInput, type ListingNamingValidationOptions, type ListingNamingValidationResult, type ListingQuery, ListingRecord, type ListingReviewCreatePayload, ListingReviewRecord, type ListingReviewResponsePayload, ListingStatus, ListingType, type ListingVersionPayload, type MarketingCampaign, type MarketingLinkOptions, type MemoryPingChallengeResponse, type MemoryPingPayload, type OpenRouterCredits, type ProcurementCandidate, type ProcurementDecision, type ProcurementTaskProfile, type ProcurementWeights, ReflectionCycleOptions, ReflectionCycleResult, type ResourceProviderManifestEntry, type ResourceSnapshot, ReviewGate, type ReviewGateRecord, type ReviewRequiredPayload, type SdkUpdateCheckOptions, type SdkUpdatePolicyCheckOptions, SdkUpdateRequiredError, type SdkUpdateStatus, TicketVerifyResponse, VIBEIAO_IDL, VerifiedClaimResponse, VibeClient, type VibeClientOptions, VibeRegistry, assertSurvivalProvidersConfigured, buildBadgeMarkdown, buildClaimMessage, buildJupiterSwapUrl, buildListingVersionMessage, buildMemoryPingMessage, buildOwnerTransferMessage, buildProcurementPrompt, buildRaydiumSwapUrl, buildReviewPrompt, buildReviewRequired, buildReviewResponseMessage, buildSdkUpdateCommand, buildShareCopy, buildShareLink, buildTradeLinks, checkForSdkUpdate, checkForSdkUpdatePolicy, compareVersions, createApiCreditProvider, createApiCreditProviders, createApiCreditProvidersFromManifest, createCampaign, decideProcurementForTask, getResourceSnapshot, normalizeListingText, rankListingsForTask, sanitizeListingNaming, scoreListingForTask, validateListingNaming };
+export { type AgentResourceProvidersManifest, type AnalyticsPoint, type ApiCreditProvider, type ApiCreditProviderFactoryOptions, type ApiCreditProviderPreset, type ApiCreditProviderPresetInput, type ApiResponse, type BuybackEvent, CONTEXT_PACK_SECTION_ORDER, ClaimPurpose, ClaimResponse, type ContextPack, type ContextPackBudget, type ContextPackInput, type ContextPackOptions, type ContextPackSectionKey, type ContextPackSections, LISTING_NAME_MAX_LENGTH, LISTING_NAME_RECOMMENDED_MAX, LISTING_TAGLINE_MAX_LENGTH, LISTING_TAGLINE_RECOMMENDED_MAX, type LeaderboardEntry, type LeaderboardQuery, ListingInput, type ListingNamingValidationOptions, type ListingNamingValidationResult, type ListingQuery, ListingRecord, type ListingReviewCreatePayload, ListingReviewRecord, type ListingReviewResponsePayload, ListingStatus, ListingType, type ListingVersionPayload, type MarketingCampaign, type MarketingLinkOptions, type MemoryPingChallengeResponse, type MemoryPingPayload, type OpenRouterCredits, type ProcurementCandidate, type ProcurementDecision, type ProcurementTaskProfile, type ProcurementWeights, ReflectionCycleOptions, ReflectionCycleResult, type ResourceProviderManifestEntry, type ResourceSnapshot, ReviewGate, type ReviewGateRecord, type ReviewRequiredPayload, type SdkUpdateCheckOptions, type SdkUpdatePolicyCheckOptions, SdkUpdateRequiredError, type SdkUpdateStatus, TicketVerifyResponse, VIBEIAO_IDL, VerifiedClaimResponse, VibeClient, type VibeClientOptions, VibeRegistry, assertSurvivalProvidersConfigured, buildBadgeMarkdown, buildClaimMessage, buildJupiterSwapUrl, buildListingVersionMessage, buildMemoryPingMessage, buildOwnerTransferMessage, buildProcurementPrompt, buildRaydiumSwapUrl, buildReviewPrompt, buildReviewRequired, buildReviewResponseMessage, buildSdkUpdateCommand, buildShareCopy, buildShareLink, buildTradeLinks, checkForSdkUpdate, checkForSdkUpdatePolicy, compareVersions, createApiCreditProvider, createApiCreditProviders, createApiCreditProvidersFromManifest, createCampaign, createContextPack, decideProcurementForTask, estimateContextPackTokens, getResourceSnapshot, normalizeListingText, rankListingsForTask, sanitizeListingNaming, scoreListingForTask, validateContextPack, validateListingNaming };

package/dist/index.js

@@ -1,3 +1,12 @@
+import {
+  createAgentLoop
+} from "./chunk-7JT4JPEY.js";
+import {
+  deriveMarketNeeds,
+  discoverMarketNeeds,
+  extractMarketSignals,
+  runMarketDiscovery
+} from "./chunk-ZMUFCYW6.js";
 import {
   buildReflectionBacklog,
   buildReflectionCandidate,
@@ -21,6 +30,196 @@ import {
   fetchTokenBalance,
   fetchTokenBalances
 } from "./chunk-OUGOOS3F.js";
+import {
+  getSurvivalPlaybookDecision,
+  getSurvivalPlaybookDecisionFromSelfReliance
+} from "./chunk-A2ORQN53.js";
+import {
+  classifySurvivalMode,
+  formatSurvivalRecommendation,
+  getSurvivalRecommendation
+} from "./chunk-JQE72P4C.js";
+
+// src/contextPack.ts
+var SECTION_ORDER = [
+  "objective",
+  "mustKnow",
+  "risks",
+  "decisions",
+  "checklist",
+  "sources"
+];
+var DEFAULT_MAX_CHARS = 2400;
+var DEFAULT_MAX_TOKENS = 700;
+var DEFAULT_MAX_ITEM_CHARS = 320;
+var normalizeItem = (value, maxItemChars) => {
+  const compact = value.replace(/\s+/g, " ").trim();
+  if (!compact) return "";
+  if (compact.length <= maxItemChars) return compact;
+  return `${compact.slice(0, Math.max(0, maxItemChars - 1)).trimEnd()}\u2026`;
+};
+var normalizeSectionInput = (value, maxItemChars) => {
+  if (!value) return [];
+  const list = Array.isArray(value) ? value : [value];
+  const seen = /* @__PURE__ */ new Set();
+  const output = [];
+  for (const item of list) {
+    const normalized = normalizeItem(String(item ?? ""), maxItemChars);
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    output.push(normalized);
+  }
+  return output;
+};
+var estimateTokensFromChars = (chars) => Math.ceil(chars / 4);
+var buildSections = (input, maxItemChars) => ({
+  objective: normalizeSectionInput(input.objective, maxItemChars),
+  mustKnow: normalizeSectionInput(input.mustKnow, maxItemChars),
+  risks: normalizeSectionInput(input.risks, maxItemChars),
+  decisions: normalizeSectionInput(input.decisions, maxItemChars),
+  checklist: normalizeSectionInput(input.checklist, maxItemChars),
+  sources: normalizeSectionInput(input.sources, maxItemChars)
+});
+var copySections = (sections) => ({
+  objective: [...sections.objective],
+  mustKnow: [...sections.mustKnow],
+  risks: [...sections.risks],
+  decisions: [...sections.decisions],
+  checklist: [...sections.checklist],
+  sources: [...sections.sources]
+});
+var measuredJson = (sections) => {
+  const json = JSON.stringify(
+    {
+      schema: "context-pack/v1",
+      sections: {
+        objective: sections.objective,
+        mustKnow: sections.mustKnow,
+        risks: sections.risks,
+        decisions: sections.decisions,
+        checklist: sections.checklist,
+        sources: sections.sources
+      }
+    },
+    null,
+    2
+  );
+  const chars = json.length;
+  const tokens = estimateTokensFromChars(chars);
+  return { chars, tokens };
+};
+var fitsBudget = (sections, maxChars, maxTokens) => {
+  const measured = measuredJson(sections);
+  return measured.chars <= maxChars && measured.tokens <= maxTokens;
+};
+var truncateToBudget = (sections, maxChars, maxTokens) => {
+  const out = {
+    objective: [],
+    mustKnow: [],
+    risks: [],
+    decisions: [],
+    checklist: [],
+    sources: []
+  };
+  for (const key of SECTION_ORDER) {
+    for (const item of sections[key]) {
+      out[key].push(item);
+      if (fitsBudget(out, maxChars, maxTokens)) {
+        continue;
+      }
+      out[key].pop();
+      const probe = `${item.slice(0, Math.max(0, item.length - 1)).trimEnd()}\u2026`;
+      if (probe.length >= 16) {
+        let lo = 16;
+        let hi = probe.length;
+        let best = "";
+        while (lo <= hi) {
+          const mid = Math.floor((lo + hi) / 2);
+          const candidate = `${probe.slice(0, Math.max(0, mid - 1)).trimEnd()}\u2026`;
+          out[key].push(candidate);
+          const ok = fitsBudget(out, maxChars, maxTokens);
+          out[key].pop();
+          if (ok) {
+            best = candidate;
+            lo = mid + 1;
+          } else {
+            hi = mid - 1;
+          }
+        }
+        if (best) {
+          out[key].push(best);
+        }
+      }
+      return out;
+    }
+  }
+  return out;
+};
+var normalizeCreatedAt = (value) => {
+  if (!value) return (/* @__PURE__ */ new Date()).toISOString();
+  if (value instanceof Date) return value.toISOString();
+  const parsed = new Date(value);
+  if (Number.isFinite(parsed.getTime())) return parsed.toISOString();
+  return (/* @__PURE__ */ new Date()).toISOString();
+};
+var createContextPack = (input, options = {}) => {
+  const maxChars = Math.max(240, Number(options.maxChars ?? DEFAULT_MAX_CHARS));
+  const maxTokens = Math.max(80, Number(options.maxTokens ?? DEFAULT_MAX_TOKENS));
+  const maxItemChars = Math.max(16, Number(options.maxItemChars ?? DEFAULT_MAX_ITEM_CHARS));
+  const normalized = buildSections(input, maxItemChars);
+  const withinBudget = fitsBudget(normalized, maxChars, maxTokens);
+  const sections = withinBudget ? copySections(normalized) : truncateToBudget(normalized, maxChars, maxTokens);
+  const usage = measuredJson(sections);
+  return {
+    schema: "context-pack/v1",
+    createdAt: normalizeCreatedAt(options.createdAt),
+    budget: {
+      maxChars,
+      maxTokens,
+      usedChars: usage.chars,
+      usedTokens: usage.tokens,
+      truncated: !withinBudget
+    },
+    sections: {
+      objective: sections.objective,
+      mustKnow: sections.mustKnow,
+      risks: sections.risks,
+      decisions: sections.decisions,
+      checklist: sections.checklist,
+      sources: sections.sources
+    }
+  };
+};
+var validateContextPack = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const pack = value;
+  if (pack.schema !== "context-pack/v1") return false;
+  if (!pack.budget || typeof pack.budget !== "object") return false;
+  const budget = pack.budget;
+  const budgetFields = [
+    "maxChars",
+    "maxTokens",
+    "usedChars",
+    "usedTokens",
+    "truncated"
+  ];
+  for (const field of budgetFields) {
+    if (!(field in budget)) return false;
+  }
+  if (typeof budget.truncated !== "boolean") return false;
+  for (const field of ["maxChars", "maxTokens", "usedChars", "usedTokens"]) {
+    if (!Number.isFinite(Number(budget[field]))) return false;
+  }
+  if (!pack.sections || typeof pack.sections !== "object") return false;
+  const sections = pack.sections;
+  for (const key of SECTION_ORDER) {
+    if (!Array.isArray(sections[key])) return false;
+    if (sections[key].some((item) => typeof item !== "string")) return false;
+  }
+  return true;
+};
+var CONTEXT_PACK_SECTION_ORDER = [...SECTION_ORDER];
+var estimateContextPackTokens = (textOrChars) => estimateTokensFromChars(typeof textOrChars === "number" ? textOrChars : textOrChars.length);
 
 // src/index.ts
 var SdkUpdateRequiredError = class extends Error {
@@ -123,7 +322,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.15" ? "0.1.15" : "0.1.4";
+var DEFAULT_SDK_VERSION = "0.1.25" ? "0.1.25" : "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;
@@ -1100,6 +1299,7 @@ var getResourceSnapshot = async (options) => {
   return snapshot;
 };
 export {
+  CONTEXT_PACK_SECTION_ORDER,
   LISTING_NAME_MAX_LENGTH,
   LISTING_NAME_RECOMMENDED_MAX,
   LISTING_TAGLINE_MAX_LENGTH,
@@ -1132,27 +1332,40 @@ export {
   checkForSdkUpdate,
   checkForSdkUpdatePolicy,
   classifyReview,
+  classifySurvivalMode,
   compareVersions,
+  createAgentLoop,
   createApiCreditProvider,
   createApiCreditProviders,
   createApiCreditProvidersFromManifest,
   createAutoSelfReliance,
   createCampaign,
+  createContextPack,
   createInMemoryReflectionStore,
   createSelfRelianceMonitor,
   createSelfReliancePolicy,
   createSurvivalMiddleware,
   decideProcurementForTask,
+  deriveMarketNeeds,
+  discoverMarketNeeds,
+  estimateContextPackTokens,
+  extractMarketSignals,
   fetchSolBalance,
   fetchTokenBalance,
   fetchTokenBalances,
+  formatSurvivalRecommendation,
   getResourceSnapshot,
+  getSurvivalPlaybookDecision,
+  getSurvivalPlaybookDecisionFromSelfReliance,
+  getSurvivalRecommendation,
   normalizeListingText,
   rankListingsForTask,
+  runMarketDiscovery,
   runReflectionCycle,
   sanitizeListingNaming,
   scoreListingForTask,
   scoreReviewPriority,
+  validateContextPack,
   validateListingNaming,
   withSurvival
 };

package/dist/marketDiscovery.d.ts

@@ -0,0 +1,56 @@
+import { L as ListingRecord, e as ListingReviewRecord } from './shared-By5mFIMw.js';
+
+type MarketSignal = {
+    listingId: string;
+    listingName: string;
+    reviewId: string;
+    createdAt?: string;
+    rating?: number;
+    text: string;
+    category: 'bug' | 'reliability' | 'ux' | 'pricing' | 'feature' | 'praise' | 'noise';
+    severity: number;
+};
+type MarketNeed = {
+    key: string;
+    title: string;
+    description: string;
+    evidenceCount: number;
+    avgSeverity: number;
+    categories: Record<string, number>;
+    topEvidence: Array<{
+        listingId: string;
+        reviewId: string;
+        text: string;
+    }>;
+    recommendedToolIdea: {
+        name: string;
+        tagline: string;
+        whyNow: string;
+        minimalSpec: string[];
+    };
+};
+type MarketDiscoveryClient = {
+    listAgentListings: (options?: {
+        limit?: number;
+        offset?: number;
+        sort?: string;
+    }) => Promise<ListingRecord[]>;
+    getListingReviews: (listingId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }) => Promise<ListingReviewRecord[]>;
+};
+declare const extractMarketSignals: (listing: ListingRecord, reviews: ListingReviewRecord[]) => MarketSignal[];
+declare const deriveMarketNeeds: (signals: MarketSignal[]) => MarketNeed[];
+declare const discoverMarketNeeds: (signals: MarketSignal[]) => MarketNeed[];
+declare const runMarketDiscovery: (client: MarketDiscoveryClient, options?: {
+    listingsLimit?: number;
+    reviewsPerListing?: number;
+}) => Promise<{
+    generatedAt: string;
+    listingsConsidered: number;
+    signals: MarketSignal[];
+    needs: MarketNeed[];
+}>;
+
+export { type MarketDiscoveryClient, type MarketNeed, type MarketSignal, deriveMarketNeeds, discoverMarketNeeds, extractMarketSignals, runMarketDiscovery };

package/dist/marketDiscovery.js

@@ -0,0 +1,12 @@
+import {
+  deriveMarketNeeds,
+  discoverMarketNeeds,
+  extractMarketSignals,
+  runMarketDiscovery
+} from "./chunk-ZMUFCYW6.js";
+export {
+  deriveMarketNeeds,
+  discoverMarketNeeds,
+  extractMarketSignals,
+  runMarketDiscovery
+};

package/dist/survivalIntegration.d.ts

@@ -0,0 +1,25 @@
+import { SelfRelianceState, SelfReliancePolicy, SelfReliance } from './selfReliance.js';
+import { SurvivalMode, SurvivalRecommendation } from './survivalPlaybook.js';
+
+type SurvivalIntegrationDecision = {
+    enabled: boolean;
+    mode: SurvivalMode;
+    recommendation: SurvivalRecommendation;
+    formatted: string;
+};
+/**
+ * Safe rollout helper.
+ * - If SURVIVAL_PLAYBOOK_ENABLED is not set truthy, returns enabled=false and does not attempt to influence behavior.
+ * - If enabled, returns the mode + structured recommendation suitable for injecting into an agent planner.
+ */
+declare const getSurvivalPlaybookDecision: (options: {
+    state: SelfRelianceState;
+    policy: SelfReliancePolicy;
+    enabledEnv?: string;
+}) => SurvivalIntegrationDecision;
+/**
+ * Convenience wrapper for agents already using SelfReliance.
+ */
+declare const getSurvivalPlaybookDecisionFromSelfReliance: (survival: SelfReliance) => SurvivalIntegrationDecision;
+
+export { type SurvivalIntegrationDecision, getSurvivalPlaybookDecision, getSurvivalPlaybookDecisionFromSelfReliance };

package/dist/survivalIntegration.js

@@ -0,0 +1,9 @@
+import {
+  getSurvivalPlaybookDecision,
+  getSurvivalPlaybookDecisionFromSelfReliance
+} from "./chunk-A2ORQN53.js";
+import "./chunk-JQE72P4C.js";
+export {
+  getSurvivalPlaybookDecision,
+  getSurvivalPlaybookDecisionFromSelfReliance
+};

package/dist/survivalPlaybook.d.ts

@@ -0,0 +1,34 @@
+import { SelfRelianceState, SelfReliancePolicy } from './selfReliance.js';
+
+type SurvivalMode = 'EXPAND' | 'FOCUS' | 'SURVIVE' | 'BLINK';
+type SurvivalRecommendation = {
+    mode: SurvivalMode;
+    summary: string;
+    objective: string;
+    /** Current spending rule of thumb for this mode (budget gate). */
+    spendingPolicy: {
+        posture: 'invest' | 'conserve' | 'freeze';
+        rule: string;
+    };
+    /** Aspirational purchases/goals the agent can work toward (non-binding). */
+    aspirationalUpgrades: Array<{
+        when: string;
+        buy: string;
+        why: string;
+    }>;
+    constraints: string[];
+    nextActions: Array<{
+        label: string;
+        rationale: string;
+        priority: 'P0' | 'P1' | 'P2';
+    }>;
+    marketing: {
+        principle: string;
+        rules: string[];
+    };
+};
+declare const classifySurvivalMode: (state: SelfRelianceState, policy: SelfReliancePolicy) => SurvivalMode;
+declare const getSurvivalRecommendation: (mode: SurvivalMode) => SurvivalRecommendation;
+declare const formatSurvivalRecommendation: (reco: SurvivalRecommendation) => string;
+
+export { type SurvivalMode, type SurvivalRecommendation, classifySurvivalMode, formatSurvivalRecommendation, getSurvivalRecommendation };

package/dist/survivalPlaybook.js

@@ -0,0 +1,10 @@
+import {
+  classifySurvivalMode,
+  formatSurvivalRecommendation,
+  getSurvivalRecommendation
+} from "./chunk-JQE72P4C.js";
+export {
+  classifySurvivalMode,
+  formatSurvivalRecommendation,
+  getSurvivalRecommendation
+};

package/package.json

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