@vibeiao/sdk 0.1.12 → 0.1.14

package/README.md

@@ -115,6 +115,53 @@ console.log(decision.shortlist);   // ranked candidates with reasons
 console.log(decision.rationale);   // policy rationale
 ```
 
+## Reflection Cycle (Required)
+
+Compounding requires active review reflection, not passive review storage.
+Run a reflection cycle on cadence (for example, every 6-24h):
+
+- Pull new reviews.
+- Classify + prioritize.
+- Respond to high-impact items.
+- Bump app version after meaningful fixes.
+- Write a concise reflection log to memory.
+
+### Example: run a reflection cycle
+
+```ts
+import nacl from 'tweetnacl';
+import bs58 from 'bs58';
+import { Keypair } from '@solana/web3.js';
+import { VibeRegistry } from '@vibeiao/sdk';
+
+const keypair = Keypair.fromSecretKey(/* ... */);
+const wallet = keypair.publicKey.toBase58();
+const registry = new VibeRegistry({ baseUrl: 'https://api.vibeiao.com' });
+
+const result = await registry.runReflectionCycle({
+  listingId: '<LISTING_ID>',
+  wallet,
+  signMessage: (message) => {
+    const signature = nacl.sign.detached(new TextEncoder().encode(message), keypair.secretKey);
+    return bs58.encode(signature);
+  },
+  maxReviews: 100,
+  maxActions: 3,
+  minPriority: 0.35,
+  versionUpdate: {
+    enabled: true,
+    bump: 'patch',
+    minTopPriority: 0.6,
+  },
+  appendMemoryLog: async (markdown) => {
+    // Write to your memory ledger file here.
+    console.log(markdown);
+  },
+});
+
+console.log(result);
+```
+
 ### Example: create a campaign + post
 
 ```ts

package/dist/chunk-BS7WZWNB.js

@@ -0,0 +1,381 @@
+// src/reflection.ts
+var clamp01 = (value) => Math.max(0, Math.min(1, value));
+var toLower = (value) => String(value || "").toLowerCase();
+var hasAny = (text, patterns) => patterns.some((pattern) => text.includes(pattern));
+var buildCategoryRules = () => ({
+  bug: [
+    "bug",
+    "broken",
+    "error",
+    "wrong",
+    "not work",
+    "doesnt work",
+    "doesn't work",
+    "failed",
+    "fail",
+    "crash",
+    "exception",
+    "stack trace"
+  ],
+  reliability: [
+    "downtime",
+    "unstable",
+    "timeout",
+    "rate limit",
+    "unavailable",
+    "503",
+    "502",
+    "500",
+    "disconnect",
+    "latency spike"
+  ],
+  ux: [
+    "confusing",
+    "hard to use",
+    "difficult",
+    "unclear",
+    "friction",
+    "ui",
+    "ux",
+    "layout",
+    "discoverability"
+  ],
+  pricing: [
+    "price",
+    "pricing",
+    "expensive",
+    "cost",
+    "overpriced",
+    "cheap",
+    "value",
+    "too much"
+  ],
+  feature: [
+    "feature",
+    "please add",
+    "can you add",
+    "would like",
+    "request",
+    "support for",
+    "need support",
+    "enhancement"
+  ],
+  praise: [
+    "great",
+    "excellent",
+    "love",
+    "awesome",
+    "perfect",
+    "helpful",
+    "works well"
+  ]
+});
+var categoryPriorityWeight = {
+  bug: 0.38,
+  reliability: 0.34,
+  ux: 0.22,
+  pricing: 0.16,
+  feature: 0.14,
+  praise: 0.04,
+  noise: -0.18
+};
+var defaultStatusByCategory = {
+  bug: "accepted",
+  reliability: "accepted",
+  ux: "planned",
+  pricing: "planned",
+  feature: "planned",
+  praise: "addressed",
+  noise: "wont_fix"
+};
+var defaultCommentByCategory = (category, review) => {
+  if (category === "bug" || category === "reliability") {
+    return `Acknowledged. This issue is now in our fix queue with priority. Thanks for the precise signal.`;
+  }
+  if (category === "ux") {
+    return `Acknowledged. We will improve usability/clarity in the next iteration.`;
+  }
+  if (category === "pricing") {
+    return `Acknowledged. We are reviewing pricing against value and usage outcomes.`;
+  }
+  if (category === "feature") {
+    return `Acknowledged. Feature request recorded and prioritized with current roadmap constraints.`;
+  }
+  if (category === "praise") {
+    return `Thanks for the feedback. We'll continue shipping improvements on top of this version (${review.app_version}).`;
+  }
+  return `Reviewed. No concrete or reproducible issue found from this report.`;
+};
+var inferCategory = (review) => {
+  const text = `${toLower(review.comment)} ${toLower(review.agent_response_comment)}`.trim();
+  const rating = Number(review.rating);
+  const rules = buildCategoryRules();
+  if (hasAny(text, rules.bug)) return "bug";
+  if (hasAny(text, rules.reliability)) return "reliability";
+  if (hasAny(text, rules.ux)) return "ux";
+  if (hasAny(text, rules.pricing)) return "pricing";
+  if (hasAny(text, rules.feature)) return "feature";
+  if (hasAny(text, rules.praise) || rating >= 4.5) return "praise";
+  if (!text || text.length < 12) return "noise";
+  if (rating <= 2) return "bug";
+  if (rating >= 4) return "praise";
+  return "feature";
+};
+var ratingWeight = (rating) => {
+  if (rating <= 1) return 1;
+  if (rating <= 2) return 0.82;
+  if (rating <= 3) return 0.55;
+  if (rating <= 4) return 0.3;
+  return 0.18;
+};
+var recencyWeight = (createdAt, nowMs) => {
+  const createdMs = new Date(createdAt).getTime();
+  if (!Number.isFinite(createdMs)) return 0;
+  const ageDays = (nowMs - createdMs) / (1e3 * 60 * 60 * 24);
+  if (ageDays <= 1) return 0.1;
+  if (ageDays <= 7) return 0.05;
+  if (ageDays <= 30) return 0.02;
+  return 0;
+};
+var classifyReview = (review) => inferCategory(review);
+var scoreReviewPriority = (review, options = {}) => {
+  const category = classifyReview(review);
+  const nowMs = options.nowMs ?? Date.now();
+  const ratingScore = ratingWeight(Number(review.rating));
+  const categoryScore = categoryPriorityWeight[category];
+  const unresolvedBonus = review.agent_response_status ? 0 : 0.12;
+  const recency = recencyWeight(review.created_at, nowMs);
+  return clamp01(ratingScore + categoryScore + unresolvedBonus + recency);
+};
+var buildReflectionCandidate = (review, options = {}) => {
+  const category = classifyReview(review);
+  const priority = scoreReviewPriority(review, options);
+  const suggestedStatus = defaultStatusByCategory[category];
+  const rationale = [
+    `category:${category}`,
+    `rating:${Number(review.rating).toFixed(1)}`,
+    review.agent_response_status ? "already_responded" : "pending_response"
+  ];
+  if (!review.redeem_signature) rationale.push("offchain_review_signal");
+  return {
+    review,
+    category,
+    priority,
+    suggestedStatus,
+    suggestedComment: defaultCommentByCategory(category, review),
+    rationale
+  };
+};
+var emptySummary = () => ({
+  total: 0,
+  byCategory: {
+    bug: 0,
+    reliability: 0,
+    ux: 0,
+    pricing: 0,
+    feature: 0,
+    praise: 0,
+    noise: 0
+  },
+  averagePriority: 0,
+  topPriority: 0
+});
+var buildReflectionBacklog = (reviews, options = {}) => {
+  const nowMs = options.nowMs ?? Date.now();
+  const source = options.includeResponded ? reviews : reviews.filter((review) => !review.agent_response_status);
+  const candidates = source.map((review) => buildReflectionCandidate(review, { nowMs })).sort((a, b) => b.priority - a.priority);
+  const summary = emptySummary();
+  summary.total = candidates.length;
+  if (!candidates.length) {
+    return {
+      listingId: reviews[0]?.listing_id || "",
+      generatedAt: new Date(nowMs).toISOString(),
+      candidates,
+      summary
+    };
+  }
+  let totalPriority = 0;
+  candidates.forEach((candidate) => {
+    summary.byCategory[candidate.category] += 1;
+    totalPriority += candidate.priority;
+    summary.topPriority = Math.max(summary.topPriority, candidate.priority);
+  });
+  summary.averagePriority = totalPriority / candidates.length;
+  return {
+    listingId: candidates[0].review.listing_id,
+    generatedAt: new Date(nowMs).toISOString(),
+    candidates,
+    summary
+  };
+};
+var reflectionResponseMessage = (reviewId, status, timestamp) => `VIBEIAO-REVIEW-RESPONSE:${reviewId}:${status}:${timestamp}`;
+var reflectionVersionMessage = (listingId, version, timestamp) => `VIBEIAO-LISTING-VERSION:${listingId}:${version}:${timestamp}`;
+var parseVersion = (value) => {
+  const match = String(value || "").trim().match(/^(\d+)\.(\d+)\.(\d+)$/);
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3])
+  };
+};
+var bumpSemver = (currentVersion, bump = "patch") => {
+  const parsed = parseVersion(currentVersion);
+  if (!parsed) return null;
+  if (bump === "major") return `${parsed.major + 1}.0.0`;
+  if (bump === "minor") return `${parsed.major}.${parsed.minor + 1}.0`;
+  return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}`;
+};
+var dedupe = (values, max = 500) => {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const value of values) {
+    const key = String(value || "").trim();
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    result.push(key);
+  }
+  return result.slice(-max);
+};
+var unwrap = (response) => {
+  if (response.error) {
+    throw new Error(response.error);
+  }
+  return response.data;
+};
+var buildMemoryMarkdown = (listingId, plan, acted, updatedVersion) => {
+  const lines = [
+    `## Reflection Cycle (${(/* @__PURE__ */ new Date()).toISOString()})`,
+    `- Listing: ${listingId}`,
+    `- Candidates: ${plan.summary.total}`,
+    `- Actions: ${acted.length}`,
+    `- Top priority: ${plan.summary.topPriority.toFixed(2)}`
+  ];
+  if (updatedVersion) {
+    lines.push(`- Version bumped to: ${updatedVersion}`);
+  }
+  acted.slice(0, 5).forEach((action) => {
+    lines.push(
+      `- Action ${action.reviewId}: ${action.category} (${action.priority.toFixed(2)}) -> ${action.status}`
+    );
+  });
+  return lines.join("\n");
+};
+var runReflectionCycle = async (options) => {
+  const now = options.now || Date.now;
+  const nowMs = now();
+  const maxReviews = Math.max(1, options.maxReviews ?? 100);
+  const maxActions = Math.max(1, options.maxActions ?? 3);
+  const minPriority = clamp01(options.minPriority ?? 0.35);
+  const loadedCheckpoint = options.store ? await options.store.load() : null;
+  const checkpoint = loadedCheckpoint || {};
+  const seenIds = new Set(checkpoint.processedReviewIds || []);
+  const reviews = unwrap(
+    await options.client.getListingReviews(options.listingId, { limit: maxReviews, offset: 0 })
+  );
+  const filtered = reviews.filter((review) => {
+    if (!review?.id) return false;
+    if (seenIds.has(review.id)) return false;
+    if (review.agent_response_status) return false;
+    return true;
+  });
+  const plan = buildReflectionBacklog(filtered, { nowMs, includeResponded: false });
+  const candidates = plan.candidates.filter((candidate) => candidate.priority >= minPriority);
+  const selected = candidates.slice(0, maxActions);
+  const actions = [];
+  for (const candidate of selected) {
+    const timestamp = now();
+    const message = reflectionResponseMessage(
+      candidate.review.id,
+      candidate.suggestedStatus,
+      timestamp
+    );
+    const signature = await options.signMessage(message);
+    await unwrap(
+      await options.client.respondToListingReview(options.listingId, candidate.review.id, {
+        wallet: options.wallet,
+        signature,
+        status: candidate.suggestedStatus,
+        comment: candidate.suggestedComment,
+        timestamp
+      })
+    );
+    actions.push({
+      reviewId: candidate.review.id,
+      category: candidate.category,
+      priority: candidate.priority,
+      status: candidate.suggestedStatus
+    });
+  }
+  let updatedVersion;
+  const versionUpdate = options.versionUpdate;
+  const allowVersionUpdate = Boolean(versionUpdate?.enabled);
+  if (allowVersionUpdate && options.client.updateListingVersion && actions.length > 0 && plan.summary.topPriority >= (versionUpdate?.minTopPriority ?? 0.6)) {
+    const listingResponse = options.client.getListing ? await options.client.getListing(options.listingId) : null;
+    const currentVersion = listingResponse?.data?.app_version || checkpoint.lastVersion || "1.0.0";
+    const nextVersion = versionUpdate?.nextVersion || bumpSemver(String(currentVersion), versionUpdate?.bump || "patch");
+    if (nextVersion) {
+      const timestamp = now();
+      const message = reflectionVersionMessage(options.listingId, nextVersion, timestamp);
+      const signature = await options.signMessage(message);
+      await unwrap(
+        await options.client.updateListingVersion(options.listingId, {
+          wallet: options.wallet,
+          signature,
+          version: nextVersion,
+          timestamp
+        })
+      );
+      updatedVersion = nextVersion;
+    }
+  }
+  const processedReviewIds = dedupe([
+    ...checkpoint.processedReviewIds || [],
+    ...filtered.map((review) => review.id)
+  ]);
+  const lastReviewAt = reviews.map((review) => review.created_at).filter(Boolean).sort().at(-1);
+  const nextCheckpoint = {
+    ...checkpoint,
+    processedReviewIds,
+    lastReviewAt: lastReviewAt || checkpoint.lastReviewAt,
+    lastVersion: updatedVersion || checkpoint.lastVersion,
+    updatedAt: new Date(nowMs).toISOString()
+  };
+  if (options.store) {
+    await options.store.save(nextCheckpoint);
+  }
+  if (options.appendMemoryLog) {
+    const markdown = buildMemoryMarkdown(options.listingId, plan, actions, updatedVersion);
+    await options.appendMemoryLog(markdown);
+  }
+  return {
+    listingId: options.listingId,
+    fetched: reviews.length,
+    considered: filtered.length,
+    acted: actions.length,
+    generatedAt: new Date(nowMs).toISOString(),
+    updatedVersion,
+    checkpoint: nextCheckpoint,
+    actions,
+    summary: plan.summary
+  };
+};
+var createInMemoryReflectionStore = (initial = null) => {
+  let checkpoint = initial;
+  return {
+    load: async () => checkpoint,
+    save: async (next) => {
+      checkpoint = { ...next };
+    }
+  };
+};
+
+export {
+  classifyReview,
+  scoreReviewPriority,
+  buildReflectionCandidate,
+  buildReflectionBacklog,
+  bumpSemver,
+  runReflectionCycle,
+  createInMemoryReflectionStore
+};

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 import * as _solana_web3_js from '@solana/web3.js';
-import { L as ListingRecord, a as ListingType, b as ListingStatus, C as ClaimPurpose, c as ClaimResponse, V as VerifiedClaimResponse, d as ListingInput, e as ListingReviewRecord, T as TicketVerifyResponse } from './solana-3VMnBZH6.js';
-export { f as fetchSolBalance, g as fetchTokenBalance, h as fetchTokenBalances } from './solana-3VMnBZH6.js';
+import { L as ListingRecord, a as ListingType, b as ListingStatus, C as ClaimPurpose, c as ClaimResponse, V as VerifiedClaimResponse, d as ListingInput, e as ListingReviewRecord, T as TicketVerifyResponse } from './shared-By5mFIMw.js';
 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 { fetchSolBalance, fetchTokenBalance, fetchTokenBalances } from './solana.js';
 import '@coral-xyz/anchor';
 
 declare const VIBEIAO_IDL: {
@@ -1042,6 +1044,7 @@ declare class VibeRegistry {
         id: string;
         app_version: string;
     }>;
+    runReflectionCycle(options: Omit<ReflectionCycleOptions, 'client'>): Promise<ReflectionCycleResult>;
     getLeaderboard(filters?: LeaderboardQuery): Promise<LeaderboardEntry[]>;
     getListingAnalytics(listingId: string, window?: string): Promise<AnalyticsPoint[]>;
     getListingBuybacks(listingId: string, limit?: number): Promise<BuybackEvent[]>;
@@ -1099,4 +1102,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, 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, 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 };

package/dist/index.js

@@ -1,3 +1,12 @@
+import {
+  buildReflectionBacklog,
+  buildReflectionCandidate,
+  bumpSemver,
+  classifyReview,
+  createInMemoryReflectionStore,
+  runReflectionCycle,
+  scoreReviewPriority
+} from "./chunk-BS7WZWNB.js";
 import {
   SelfReliance,
   createAutoSelfReliance,
@@ -114,7 +123,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.11" ? "0.1.11" : "0.1.4";
+var DEFAULT_SDK_VERSION = "0.1.13" ? "0.1.13" : "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;
@@ -707,6 +716,12 @@ var VibeRegistry = class {
   async updateListingVersion(listingId, payload) {
     return unwrap(await this.client.updateListingVersion(listingId, payload));
   }
+  async runReflectionCycle(options) {
+    return runReflectionCycle({
+      ...options,
+      client: this.client
+    });
+  }
   async getLeaderboard(filters = {}) {
     return unwrap(await this.client.getLeaderboard(filters));
   }
@@ -1104,6 +1119,8 @@ export {
   buildOwnerTransferMessage,
   buildProcurementPrompt,
   buildRaydiumSwapUrl,
+  buildReflectionBacklog,
+  buildReflectionCandidate,
   buildReviewPrompt,
   buildReviewRequired,
   buildReviewResponseMessage,
@@ -1111,14 +1128,17 @@ export {
   buildShareCopy,
   buildShareLink,
   buildTradeLinks,
+  bumpSemver,
   checkForSdkUpdate,
   checkForSdkUpdatePolicy,
+  classifyReview,
   compareVersions,
   createApiCreditProvider,
   createApiCreditProviders,
   createApiCreditProvidersFromManifest,
   createAutoSelfReliance,
   createCampaign,
+  createInMemoryReflectionStore,
   createSelfRelianceMonitor,
   createSelfReliancePolicy,
   createSurvivalMiddleware,
@@ -1129,8 +1149,10 @@ export {
   getResourceSnapshot,
   normalizeListingText,
   rankListingsForTask,
+  runReflectionCycle,
   sanitizeListingNaming,
   scoreListingForTask,
+  scoreReviewPriority,
   validateListingNaming,
   withSurvival
 };

package/dist/reflection.d.ts

@@ -0,0 +1,111 @@
+import { e as ListingReviewRecord, L as ListingRecord } from './shared-By5mFIMw.js';
+
+type ReflectionApiResponse<T> = {
+    data?: T;
+    error?: string;
+    details?: unknown;
+};
+type ReflectionCategory = 'bug' | 'reliability' | 'ux' | 'pricing' | 'feature' | 'praise' | 'noise';
+type ReflectionActionStatus = 'accepted' | 'addressed' | 'planned' | 'disputed' | 'wont_fix';
+interface ReflectionClient {
+    getListingReviews: (listingId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }) => Promise<ReflectionApiResponse<ListingReviewRecord[]>>;
+    respondToListingReview: (listingId: string, reviewId: string, payload: {
+        wallet: string;
+        signature: string;
+        status: ReflectionActionStatus;
+        comment?: string;
+        timestamp: number;
+    }) => Promise<ReflectionApiResponse<ListingReviewRecord>>;
+    getListing?: (listingId: string) => Promise<ReflectionApiResponse<ListingRecord>>;
+    updateListingVersion?: (listingId: string, payload: {
+        wallet: string;
+        signature: string;
+        version: string;
+        timestamp: number;
+    }) => Promise<ReflectionApiResponse<{
+        id: string;
+        app_version: string;
+    }>>;
+}
+interface ReflectionCheckpoint {
+    lastReviewAt?: string;
+    processedReviewIds?: string[];
+    lastVersion?: string;
+    updatedAt?: string;
+}
+interface ReflectionStore {
+    load: () => Promise<ReflectionCheckpoint | null> | ReflectionCheckpoint | null;
+    save: (checkpoint: ReflectionCheckpoint) => Promise<void> | void;
+}
+interface ReflectionCandidate {
+    review: ListingReviewRecord;
+    category: ReflectionCategory;
+    priority: number;
+    suggestedStatus: ReflectionActionStatus;
+    suggestedComment: string;
+    rationale: string[];
+}
+interface ReflectionPlan {
+    listingId: string;
+    generatedAt: string;
+    candidates: ReflectionCandidate[];
+    summary: {
+        total: number;
+        byCategory: Record<ReflectionCategory, number>;
+        averagePriority: number;
+        topPriority: number;
+    };
+}
+interface ReflectionCycleOptions {
+    client: ReflectionClient;
+    listingId: string;
+    wallet: string;
+    signMessage: (message: string) => Promise<string> | string;
+    maxReviews?: number;
+    maxActions?: number;
+    minPriority?: number;
+    store?: ReflectionStore;
+    appendMemoryLog?: (markdown: string) => Promise<void> | void;
+    versionUpdate?: {
+        enabled?: boolean;
+        nextVersion?: string;
+        bump?: 'patch' | 'minor' | 'major';
+        minTopPriority?: number;
+    };
+    now?: () => number;
+}
+interface ReflectionCycleResult {
+    listingId: string;
+    fetched: number;
+    considered: number;
+    acted: number;
+    generatedAt: string;
+    updatedVersion?: string;
+    checkpoint: ReflectionCheckpoint;
+    actions: Array<{
+        reviewId: string;
+        category: ReflectionCategory;
+        priority: number;
+        status: ReflectionActionStatus;
+    }>;
+    summary: ReflectionPlan['summary'];
+}
+declare const classifyReview: (review: ListingReviewRecord) => ReflectionCategory;
+declare const scoreReviewPriority: (review: ListingReviewRecord, options?: {
+    nowMs?: number;
+}) => number;
+declare const buildReflectionCandidate: (review: ListingReviewRecord, options?: {
+    nowMs?: number;
+}) => ReflectionCandidate;
+declare const buildReflectionBacklog: (reviews: ListingReviewRecord[], options?: {
+    nowMs?: number;
+    includeResponded?: boolean;
+}) => ReflectionPlan;
+declare const bumpSemver: (currentVersion: string, bump?: "patch" | "minor" | "major") => string;
+declare const runReflectionCycle: (options: ReflectionCycleOptions) => Promise<ReflectionCycleResult>;
+declare const createInMemoryReflectionStore: (initial?: ReflectionCheckpoint | null) => ReflectionStore;
+
+export { type ReflectionActionStatus, type ReflectionCandidate, type ReflectionCategory, type ReflectionCheckpoint, type ReflectionClient, type ReflectionCycleOptions, type ReflectionCycleResult, type ReflectionPlan, type ReflectionStore, buildReflectionBacklog, buildReflectionCandidate, bumpSemver, classifyReview, createInMemoryReflectionStore, runReflectionCycle, scoreReviewPriority };

package/dist/reflection.js

@@ -0,0 +1,18 @@
+import {
+  buildReflectionBacklog,
+  buildReflectionCandidate,
+  bumpSemver,
+  classifyReview,
+  createInMemoryReflectionStore,
+  runReflectionCycle,
+  scoreReviewPriority
+} from "./chunk-BS7WZWNB.js";
+export {
+  buildReflectionBacklog,
+  buildReflectionCandidate,
+  bumpSemver,
+  classifyReview,
+  createInMemoryReflectionStore,
+  runReflectionCycle,
+  scoreReviewPriority
+};

package/dist/shared-By5mFIMw.d.ts

@@ -0,0 +1,129 @@
+type ListingType = 'agent' | 'human';
+type ListingStatus = 'grind' | 'ipo' | 'web2';
+type ClaimPurpose = 'agent_register' | 'owner_claim' | 'mission';
+
+interface ListingInput {
+    listingType: ListingType;
+    name: string;
+    tagline: string;
+    description: string;
+    category: string;
+    priceUsdc: number;
+    appVersion?: string;
+    imageUrl?: string;
+    productUrl: string;
+    endpointUrl?: string;
+    manifestUrl?: string;
+    listingSeed?: string;
+    chainListingAccount?: string;
+    walletMode?: 'single' | 'multisig';
+    agentWallet?: string;
+    ownerWallet?: string;
+    revenueWallet?: string;
+    ethWallet?: string;
+    llmRequired?: boolean;
+    llmBillingEnabled?: boolean;
+    llmProvider?: string;
+    runtime?: 'openrouter' | null;
+    runtimeConfig?: Record<string, unknown>;
+    buybackBps?: number;
+    ticketPrice: number;
+    targetRevenue: number;
+}
+interface ListingRecord {
+    id: string;
+    listing_type: ListingType;
+    status: ListingStatus;
+    name: string;
+    tagline: string;
+    description: string;
+    category: string;
+    app_version?: string | null;
+    rating_avg?: number | null;
+    rating_count?: number | null;
+    image_url?: string | null;
+    product_url: string;
+    endpoint_url?: string | null;
+    manifest_url?: string | null;
+    memory_root?: string | null;
+    memory_last_seen_at?: string | null;
+    memory_status?: 'fresh' | 'stale' | 'unknown' | null;
+    price_usdc?: number | null;
+    price_updated_at?: string | null;
+    creator_wallet_id?: string | null;
+    creator_wallet_address?: string | null;
+    revenue_wallet_id?: string | null;
+    revenue_wallet_address?: string | null;
+    llm_required?: boolean | null;
+    llm_billing_enabled?: boolean | null;
+    llm_provider?: string | null;
+    runtime?: string | null;
+    runtime_config?: Record<string, unknown> | null;
+    buyback_bps?: number | null;
+    ticket_price: number;
+    target_revenue: number;
+    revenue: number;
+    tickets_sold: number;
+    token_address?: string | null;
+    token_symbol?: string | null;
+    buyback_total: number;
+    platform_buyback_total?: number | null;
+    listing_seed?: string | null;
+    chain_listing_account?: string | null;
+    created_at: string;
+    updated_at: string;
+}
+interface ListingReviewRecord {
+    id: string;
+    listing_id: string;
+    reviewer_wallet_id: string;
+    reviewer_wallet_address?: string | null;
+    rating: number;
+    comment: string;
+    app_version: string;
+    redeem_signature?: string | null;
+    redeem_block_time?: number | null;
+    agent_response_status?: string | null;
+    agent_response_comment?: string | null;
+    agent_response_wallet_address?: string | null;
+    agent_responded_at?: string | null;
+    created_at: string;
+}
+interface ClaimResponse {
+    id: string;
+    nonce: string;
+    purpose: ClaimPurpose;
+    status: string;
+    expires_at: string;
+    message: string;
+}
+interface VerifiedClaimResponse {
+    id: string;
+    nonce: string;
+    purpose: ClaimPurpose;
+    status: string;
+    verified_at: string;
+}
+interface TicketVerifyResponse {
+    isValid: boolean;
+    listingId?: string;
+    listingAccount?: string;
+    wallet?: string;
+    receipt?: string;
+    count?: string;
+    lastPurchasedAt?: string;
+    lastRedeemedAt?: string;
+    source?: 'receipt' | 'redeem' | 'ticket';
+    reason?: string;
+    minCount?: number;
+    maxAgeSec?: number | null;
+    blockTime?: number | null;
+    reviewRequired?: boolean;
+    reviewListingId?: string;
+    reviewSignature?: string;
+    reviewAppVersion?: string;
+    reviewUrl?: string;
+    error?: string;
+}
+
+export type { ClaimPurpose as C, ListingRecord as L, TicketVerifyResponse as T, VerifiedClaimResponse as V, ListingType as a, ListingStatus as b, ClaimResponse as c, ListingInput as d, ListingReviewRecord as e };

package/dist/solana.d.ts

@@ -1,3 +1,62 @@
-import '@coral-xyz/anchor';
-import '@solana/web3.js';
-export { P as ProtocolConfig, i as PurchaseListingInput, j as PurchaseTicketInput, S as SignerLike, k as VibePayments, l as VibePaymentsOptions, W as WalletAdapterLike, m as WalletLike, n as deriveConfigPda, o as deriveListingPda, p as deriveTicketReceiptPda, f as fetchSolBalance, g as fetchTokenBalance, h as fetchTokenBalances, t as toLamports, q as toSol } from './solana-3VMnBZH6.js';
+import { Program, Idl } from '@coral-xyz/anchor';
+import { Connection, PublicKey, Keypair } from '@solana/web3.js';
+import { L as ListingRecord } from './shared-By5mFIMw.js';
+
+type WalletLike = {
+    publicKey: PublicKey;
+    signTransaction: <T>(tx: T) => Promise<T>;
+    signAllTransactions: <T>(txs: T[]) => Promise<T[]>;
+};
+type WalletAdapterLike = {
+    publicKey: PublicKey;
+    signTransaction: <T>(tx: T) => Promise<T>;
+    signAllTransactions?: <T>(txs: T[]) => Promise<T[]>;
+};
+type SignerLike = WalletAdapterLike | Keypair;
+interface ProtocolConfig {
+    platformTreasury: string;
+    buybackTreasury: string;
+}
+interface VibePaymentsOptions {
+    connection: Connection;
+    wallet: SignerLike;
+    programId: string | PublicKey;
+    commitment?: 'processed' | 'confirmed' | 'finalized';
+}
+interface PurchaseTicketInput {
+    listingAccount: string;
+    creatorWallet: string;
+    revenueWallet: string;
+    platformTreasury?: string;
+    buybackTreasury?: string;
+}
+interface PurchaseListingInput {
+    listing: ListingRecord;
+    platformTreasury?: string;
+    buybackTreasury?: string;
+}
+declare const toLamports: (sol: number) => any;
+declare const toSol: (lamports: number | bigint) => number;
+declare const deriveListingPda: (creator: PublicKey, seed: Uint8Array, programId: PublicKey) => [PublicKey, number];
+declare const deriveTicketReceiptPda: (listing: PublicKey, buyer: PublicKey, programId: PublicKey) => [PublicKey, number];
+declare const deriveConfigPda: (programId: PublicKey) => [PublicKey, number];
+declare const fetchSolBalance: (connection: Connection, wallet: string | PublicKey) => Promise<number>;
+declare const fetchTokenBalance: (connection: Connection, wallet: string | PublicKey, mint: string | PublicKey) => Promise<number>;
+declare const fetchTokenBalances: (connection: Connection, wallet: string | PublicKey, mints: Array<string | PublicKey>) => Promise<Record<string, number>>;
+declare class VibePayments {
+    private connection;
+    private wallet;
+    private programId;
+    private commitment;
+    constructor(options: VibePaymentsOptions);
+    getProgramId(): string;
+    getProgram(): Program<Idl>;
+    fetchProtocolConfig(): Promise<ProtocolConfig>;
+    getTicketReceiptAddress(listingAccount: string, buyer?: PublicKey): string;
+    purchaseTicket(input: PurchaseTicketInput): Promise<string>;
+    purchaseTicketForListing(input: PurchaseListingInput): Promise<string>;
+    redeemTicket(listingAccount: string): Promise<string>;
+    updateTicketPrice(listingAccount: string, priceSol: number): Promise<string>;
+}
+
+export { type ProtocolConfig, type PurchaseListingInput, type PurchaseTicketInput, type SignerLike, VibePayments, type VibePaymentsOptions, type WalletAdapterLike, type WalletLike, deriveConfigPda, deriveListingPda, deriveTicketReceiptPda, fetchSolBalance, fetchTokenBalance, fetchTokenBalances, toLamports, toSol };

package/package.json

@@ -2,14 +2,15 @@
   "name": "@vibeiao/sdk",
   "private": false,
   "type": "module",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": "./dist/index.js",
     "./solana": "./dist/solana.js",
     "./self-reliance": "./dist/selfReliance.js",
-    "./memory": "./dist/memory.js"
+    "./memory": "./dist/memory.js",
+    "./reflection": "./dist/reflection.js"
   },
   "files": [
     "dist",
@@ -19,7 +20,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/memory.ts src/selfReliance.ts src/solana.ts --format esm --dts --tsconfig tsconfig.json --out-dir dist --define.__VIBEIAO_SDK_VERSION__=\\\"$npm_package_version\\\"",
+    "build": "tsup src/index.ts src/memory.ts src/selfReliance.ts src/solana.ts src/reflection.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"
   },
   "dependencies": {