@vibeiao/sdk 0.1.41 → 0.1.43

package/README.md

@@ -279,6 +279,23 @@ const result = await registry.runReflectionCycle({
 console.log(result);
 ```
 
+You can also enable revenue-movement reflection in the same loop:
+
+```ts
+const result = await registry.runReflectionCycle({
+  // ...review reflection options
+  revenueReflection: {
+    enabled: true,
+    minAbsoluteDelta: 1,   // trigger at >= +1/-1 revenue move
+    minRelativeDelta: 0.05, // or >= 5% move
+    minRelativeBaselineRevenue: 1, // disable % trigger below baseline to avoid tiny-denominator noise
+    onSignal: async (signal) => {
+      console.log('Revenue movement signal:', signal);
+    },
+  },
+});
+```
+
 ### Example: create a campaign + post
 
 ```ts

package/dist/chunk-YJ7FO5ZB.js

@@ -0,0 +1,479 @@
+// 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 toFiniteNumber = (value) => {
+  const n = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(n) ? n : null;
+};
+var buildRevenueSnapshot = (listing, nowMs) => {
+  const revenue = toFiniteNumber(listing.revenue);
+  if (revenue === null) return null;
+  const targetRevenue = toFiniteNumber(listing.target_revenue ?? listing.targetRevenue) ?? void 0;
+  const tickets = toFiniteNumber(listing.tickets) ?? void 0;
+  return {
+    revenue,
+    targetRevenue,
+    tickets,
+    capturedAt: new Date(nowMs).toISOString()
+  };
+};
+var evaluateRevenueMovement = (previous, current, options) => {
+  const minAbsoluteDelta = Math.max(0, options?.minAbsoluteDelta ?? 0.5);
+  const minRelativeDelta = Math.max(0, options?.minRelativeDelta ?? 0.03);
+  const minRelativeBaselineRevenue = Math.max(0, options?.minRelativeBaselineRevenue ?? 1);
+  const flatBand = Math.max(0, options?.flatBand ?? 5e-3);
+  const deltaAbsolute = current.revenue - previous.revenue;
+  const baseline = Math.max(Math.abs(previous.revenue), 1e-9);
+  const allowRelative = baseline >= minRelativeBaselineRevenue;
+  const deltaRelativeRaw = allowRelative ? deltaAbsolute / baseline : null;
+  const deltaRelative = deltaRelativeRaw !== null && Number.isFinite(deltaRelativeRaw) ? deltaRelativeRaw : null;
+  let direction = "flat";
+  if (Math.abs(deltaAbsolute) > flatBand) direction = deltaAbsolute > 0 ? "up" : "down";
+  const absTriggered = Math.abs(deltaAbsolute) >= minAbsoluteDelta;
+  const relTriggered = deltaRelative !== null && Math.abs(deltaRelative) >= minRelativeDelta;
+  const thresholdTriggered = absTriggered || relTriggered;
+  const reasonParts = [
+    `delta=${deltaAbsolute.toFixed(4)}`,
+    deltaRelative === null ? "deltaPct=n/a" : `deltaPct=${(deltaRelative * 100).toFixed(2)}%`,
+    `thresholdAbs>=${minAbsoluteDelta}`,
+    `thresholdPct>=${(minRelativeDelta * 100).toFixed(2)}%`,
+    `relativeBaseline>=${minRelativeBaselineRevenue}`
+  ];
+  return {
+    direction,
+    deltaAbsolute,
+    deltaRelative,
+    previousRevenue: previous.revenue,
+    currentRevenue: current.revenue,
+    thresholdTriggered,
+    reason: reasonParts.join(", "),
+    capturedAt: current.capturedAt
+  };
+};
+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, revenueSignal) => {
+  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}`);
+  }
+  if (revenueSignal) {
+    const pct = revenueSignal.deltaRelative === null ? "n/a" : `${(revenueSignal.deltaRelative * 100).toFixed(2)}%`;
+    lines.push(
+      `- Revenue movement: ${revenueSignal.direction} (\u0394 ${revenueSignal.deltaAbsolute.toFixed(4)}, ${pct}) [triggered=${revenueSignal.thresholdTriggered}]`
+    );
+  }
+  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 revenueReflectionEnabled = options.revenueReflection?.enabled ?? false;
+  let revenueSnapshot;
+  let revenueSignal;
+  let revenueObserved = false;
+  let revenueTriggered = false;
+  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);
+  if (revenueReflectionEnabled && options.client.getListing) {
+    try {
+      const listingResponse = await options.client.getListing(options.listingId);
+      const listing = unwrap(listingResponse);
+      const snapshot = buildRevenueSnapshot(listing, nowMs);
+      if (snapshot) {
+        revenueObserved = true;
+        revenueSnapshot = snapshot;
+        if (checkpoint.lastRevenueSnapshot) {
+          const signal = evaluateRevenueMovement(
+            checkpoint.lastRevenueSnapshot,
+            snapshot,
+            options.revenueReflection
+          );
+          revenueSignal = signal;
+          revenueTriggered = signal.thresholdTriggered;
+          if (signal.thresholdTriggered && options.revenueReflection?.onSignal) {
+            await options.revenueReflection.onSignal(signal);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  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,
+    lastRevenueSnapshot: revenueSnapshot || checkpoint.lastRevenueSnapshot,
+    updatedAt: new Date(nowMs).toISOString()
+  };
+  if (options.store) {
+    await options.store.save(nextCheckpoint);
+  }
+  if (options.appendMemoryLog) {
+    const includeRevenue = options.revenueReflection?.includeInMemoryLog ?? true;
+    const markdown = buildMemoryMarkdown(
+      options.listingId,
+      plan,
+      actions,
+      updatedVersion,
+      includeRevenue ? revenueSignal : void 0
+    );
+    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,
+    revenueReflection: {
+      observed: revenueObserved,
+      triggered: revenueTriggered,
+      signal: revenueSignal,
+      snapshot: revenueSnapshot
+    }
+  };
+};
+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,7 +1,7 @@
 import '@solana/web3.js';
 export { C as ClaimPurpose, c as ClaimResponse, H as HumanAppCategory, d as ListingInput, L as ListingRecord, e as ListingReviewRecord, b as ListingStatus, a as ListingType, T as TicketVerifyResponse, V as VerifiedClaimResponse } from './shared-djjMij1F.js';
 export { SelfReliance, createAutoSelfReliance, createSelfRelianceMonitor, createSelfReliancePolicy, createSurvivalMiddleware, withSurvival } from './selfReliance.js';
-export { ReflectionActionStatus, ReflectionCandidate, ReflectionCategory, ReflectionCheckpoint, ReflectionClient, ReflectionCycleOptions, ReflectionCycleResult, ReflectionPlan, ReflectionStore, buildReflectionBacklog, buildReflectionCandidate, bumpSemver, classifyReview, createInMemoryReflectionStore, runReflectionCycle, scoreReviewPriority } from './reflection.js';
+export { ReflectionActionStatus, ReflectionCandidate, ReflectionCategory, ReflectionCheckpoint, ReflectionClient, ReflectionCycleOptions, ReflectionCycleResult, ReflectionPlan, ReflectionStore, RevenueMovementSignal, RevenueSnapshot, 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 { EscapeHatchDecision, EscapeHatchPolicy, EscapeHatchSnapshot, evaluateEscapeHatch, formatEscapeHatchDecision } from './survivalEscapeHatch.js';

package/dist/index.js

@@ -63,7 +63,7 @@ import {
   createInMemoryReflectionStore,
   runReflectionCycle,
   scoreReviewPriority
-} from "./chunk-BS7WZWNB.js";
+} from "./chunk-YJ7FO5ZB.js";
 
 // src/contextPack.ts
 var SECTION_ORDER = [
@@ -362,7 +362,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.40" ? "0.1.40" : "0.1.4";
+var DEFAULT_SDK_VERSION = "0.1.42" ? "0.1.42" : "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;

package/dist/reflection.d.ts

@@ -35,6 +35,7 @@ interface ReflectionCheckpoint {
     processedReviewIds?: string[];
     lastVersion?: string;
     updatedAt?: string;
+    lastRevenueSnapshot?: RevenueSnapshot;
 }
 interface ReflectionStore {
     load: () => Promise<ReflectionCheckpoint | null> | ReflectionCheckpoint | null;
@@ -59,6 +60,22 @@ interface ReflectionPlan {
         topPriority: number;
     };
 }
+interface RevenueSnapshot {
+    revenue: number;
+    targetRevenue?: number;
+    tickets?: number;
+    capturedAt: string;
+}
+interface RevenueMovementSignal {
+    direction: 'up' | 'down' | 'flat';
+    deltaAbsolute: number;
+    deltaRelative: number | null;
+    previousRevenue: number;
+    currentRevenue: number;
+    thresholdTriggered: boolean;
+    reason: string;
+    capturedAt: string;
+}
 interface ReflectionCycleOptions {
     client: ReflectionClient;
     listingId: string;
@@ -75,6 +92,15 @@ interface ReflectionCycleOptions {
         bump?: 'patch' | 'minor' | 'major';
         minTopPriority?: number;
     };
+    revenueReflection?: {
+        enabled?: boolean;
+        minAbsoluteDelta?: number;
+        minRelativeDelta?: number;
+        minRelativeBaselineRevenue?: number;
+        flatBand?: number;
+        includeInMemoryLog?: boolean;
+        onSignal?: (signal: RevenueMovementSignal) => Promise<void> | void;
+    };
     now?: () => number;
 }
 interface ReflectionCycleResult {
@@ -92,6 +118,12 @@ interface ReflectionCycleResult {
         status: ReflectionActionStatus;
     }>;
     summary: ReflectionPlan['summary'];
+    revenueReflection?: {
+        observed: boolean;
+        triggered: boolean;
+        signal?: RevenueMovementSignal;
+        snapshot?: RevenueSnapshot;
+    };
 }
 declare const classifyReview: (review: ListingReviewRecord) => ReflectionCategory;
 declare const scoreReviewPriority: (review: ListingReviewRecord, options?: {
@@ -108,4 +140,4 @@ declare const bumpSemver: (currentVersion: string, bump?: "patch" | "minor" | "m
 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 };
+export { type ReflectionActionStatus, type ReflectionCandidate, type ReflectionCategory, type ReflectionCheckpoint, type ReflectionClient, type ReflectionCycleOptions, type ReflectionCycleResult, type ReflectionPlan, type ReflectionStore, type RevenueMovementSignal, type RevenueSnapshot, buildReflectionBacklog, buildReflectionCandidate, bumpSemver, classifyReview, createInMemoryReflectionStore, runReflectionCycle, scoreReviewPriority };

package/dist/reflection.js

@@ -6,7 +6,7 @@ import {
   createInMemoryReflectionStore,
   runReflectionCycle,
   scoreReviewPriority
-} from "./chunk-BS7WZWNB.js";
+} from "./chunk-YJ7FO5ZB.js";
 export {
   buildReflectionBacklog,
   buildReflectionCandidate,

package/dist/treasuryGuardian.d.ts

@@ -1105,7 +1105,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>;

package/package.json

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