@vibeiao/sdk 0.1.31 → 0.1.33

package/README.md

@@ -383,6 +383,129 @@ Routing policy after acceptance:
 - Primary: treasury-proxy route
 - Fallback: original provider API key only when primary route fails or is policy-blocked
 
+## Human App Reflective Loop Pack (First-class)
+
+Use the built-in pack for human app lifecycle runs:
+
+- phases: `research -> hypothesis -> build -> launch -> observe -> reflect -> iterate`
+- explicit per-phase inputs/outputs + go/no-go + KPI + rollback conditions
+- optional tool-choice policy with required rationale logging
+- trial evaluation rubric (research depth / iteration quality / outcome usefulness)
+
+```ts
+import {
+  createHumanAppLoopSpec,
+  scaffoldHumanAppLoopPack,
+  evaluateHumanAppTrial,
+} from '@vibeiao/sdk';
+
+const spec = createHumanAppLoopSpec();
+
+await scaffoldHumanAppLoopPack({
+  root: process.cwd(),
+  outputDir: 'projects/vibeiao/human-app-loop-pack',
+});
+
+const trial = evaluateHumanAppTrial({
+  id: 'trial-1',
+  evidence: {
+    researchNotesCount: 4,
+    hypothesisCount: 2,
+    experimentsRun: 1,
+    measurableKpiCount: 2,
+    rollbackPlanPresent: true,
+    shippedArtifactPresent: true,
+    iterationSteps: 1,
+  },
+});
+
+console.log(spec.schema, trial.pass, trial.weightedScore);
+```
+
+## Outcome-Bound Autonomous Flow (Hard Completion Gate)
+
+Use this when the task must not be considered done until it is truly live.
+
+Required completion gates:
+- public deploy URL exists
+- listing metadata is updated
+- external smoke check passes
+- evidence log path recorded
+- context-pack preflight passed
+
+```ts
+import {
+  evaluateOutcomeBoundRun,
+  assertOutcomeBoundCompleted,
+} from '@vibeiao/sdk';
+
+const status = evaluateOutcomeBoundRun({
+  runId: 'release-2026-02-18',
+  objective: 'Ship human app v1 live',
+  publicDeployUrl: 'https://example.com/app',
+  listingId: '<listing-id>',
+  listingUpdated: true,
+  externalSmokeCheck: { passed: true, checker: 'curl -I' },
+  evidenceLogPath: 'generated/evals/release/run.md',
+  contextPackPreflight: { passed: true, scope: 'release' },
+});
+
+// Throws if any hard gate is missing.
+assertOutcomeBoundCompleted({
+  runId: 'release-2026-02-18',
+  objective: 'Ship human app v1 live',
+  publicDeployUrl: 'https://example.com/app',
+  listingId: '<listing-id>',
+  listingUpdated: true,
+  externalSmokeCheck: { passed: true },
+  evidenceLogPath: 'generated/evals/release/run.md',
+  contextPackPreflight: { passed: true, scope: 'release' },
+});
+
+console.log(status.completed, status.failedGates);
+```
+
+## Strict Memory Runtime Preset (Safe Upgrade Path)
+
+Use this preset when you want SDK-level parity for strict memory discipline across agents.
+
+What it enforces (for complex/mutating tasks):
+- context-pack prepared
+- semantic recall confirmed
+- mutation approval preflight passed
+
+And it supports safe rollout modes:
+- `observe` (default): collect/validate behavior
+- `enforce`: hard block when required gates are missing
+
+```ts
+import {
+  createStrictMemoryRuntimePreset,
+  evaluateStrictMemoryExecution,
+  upgradeToStrictMemoryRuntimePreset,
+} from '@vibeiao/sdk';
+
+const preset = createStrictMemoryRuntimePreset();
+
+const evalResult = evaluateStrictMemoryExecution({
+  taskText: 'Deploy production release with listing migration and config writes',
+  isMutation: true,
+  contextPackPrepared: true,
+  semanticRecallConfirmed: true,
+  approvalPreflightPassed: true,
+}, preset);
+
+const upgrade = upgradeToStrictMemoryRuntimePreset({
+  current: preset,
+  targetMode: 'enforce',
+  backupCreated: true,
+  healthcheckPassed: true,
+  recentBlockRate: 0.1,
+});
+
+console.log(evalResult.allowed, upgrade.safe, upgrade.next.upgradePolicy.mode);
+```
+
 ## Compounding Memory Standard (Recommended Default)
 
 The SDK now includes a standardized layered memory scaffold modeled on long-running agent operation:

package/dist/index.d.ts

@@ -6,6 +6,6 @@ export { SurvivalMode, SurvivalRecommendation, classifySurvivalMode, formatSurvi
 export { SurvivalIntegrationDecision, getSurvivalPlaybookDecision, getSurvivalPlaybookDecisionFromSelfReliance } from './survivalIntegration.js';
 export { EscapeHatchDecision, EscapeHatchPolicy, EscapeHatchSnapshot, evaluateEscapeHatch, formatEscapeHatchDecision } from './survivalEscapeHatch.js';
 export { MarketDiscoveryClient, MarketNeed, MarketSignal, deriveMarketNeeds, discoverMarketNeeds, extractMarketSignals, runMarketDiscovery } from './marketDiscovery.js';
-export { A as AgentResourceProvidersManifest, a as AnalyticsPoint, b as ApiCreditProvider, c as ApiCreditProviderFactoryOptions, d as ApiCreditProviderPreset, e as ApiCreditProviderPresetInput, f as ApiResponse, B as BuybackEvent, C as CONTEXT_PACK_SECTION_ORDER, g as ContextPack, h as ContextPackBudget, i as ContextPackInput, j as ContextPackOptions, k as ContextPackSectionKey, l as ContextPackSections, D as DurabilityCheckpointWriteOptions, m as DurabilityProxyClientOptions, n as DurabilityRestoreDrillWriteOptions, L as LISTING_NAME_MAX_LENGTH, o as LISTING_NAME_RECOMMENDED_MAX, p as LISTING_TAGLINE_MAX_LENGTH, q as LISTING_TAGLINE_RECOMMENDED_MAX, r as LeaderboardEntry, s as LeaderboardQuery, t as ListingNamingValidationOptions, u as ListingNamingValidationResult, v as ListingQuery, w as ListingReviewCreatePayload, x as ListingReviewResponsePayload, y as ListingVersionPayload, M as MarketingCampaign, z as MarketingLinkOptions, E as MemoryPingChallengeResponse, F as MemoryPingPayload, O as OpenRouterCredits, P as ProcurementCandidate, G as ProcurementDecision, H as ProcurementTaskProfile, I as ProcurementWeights, R as ResourceProviderManifestEntry, J as ResourceSnapshot, K as ReviewGate, N as ReviewGateRecord, Q as ReviewRequiredPayload, S as SdkAutoUpdatedRestartRequiredError, T as SdkUpdateCheckOptions, U as SdkUpdatePolicyCheckOptions, V as SdkUpdateRequiredError, W as SdkUpdateStatus, TopupDecision, TopupRequest, TreasuryLedgerEvent, TreasuryPolicy, TreasuryPolicyV1, TreasuryState, X as VIBEIAO_IDL, Y as VibeClient, Z as VibeClientOptions, _ as VibeRegistry, $ as assertSurvivalProvidersConfigured, a0 as buildBadgeMarkdown, a1 as buildClaimMessage, a2 as buildJupiterSwapUrl, a3 as buildListingVersionMessage, a4 as buildMemoryPingMessage, a5 as buildOwnerTransferMessage, a6 as buildProcurementPrompt, a7 as buildRaydiumSwapUrl, a8 as buildReviewPrompt, a9 as buildReviewRequired, aa as buildReviewResponseMessage, ab as buildSdkUpdateCommand, ac as buildShareCopy, ad as buildShareLink, ae as buildTradeLinks, buildTreasuryLedgerEvent, af as checkForSdkUpdate, ag as checkForSdkUpdatePolicy, ah as compareVersions, ai as createApiCreditProvider, aj as createApiCreditProviders, ak as createApiCreditProvidersFromManifest, al as createCampaign, am as createContextPack, an as createDurabilityProxyClient, createTreasuryPolicy, ao as decideProcurementForTask, ap as estimateContextPackTokens, evaluateTopupRequest, aq as getResourceSnapshot, ar as normalizeListingText, as as rankListingsForTask, at as sanitizeListingNaming, au as scoreListingForTask, treasuryStateFromSnapshot, av as validateContextPack, aw as validateListingNaming, validateTreasuryPolicy } from './treasuryGuardian.js';
+export { A as AgentResourceProvidersManifest, a as AnalyticsPoint, b as ApiCreditProvider, c as ApiCreditProviderFactoryOptions, d as ApiCreditProviderPreset, e as ApiCreditProviderPresetInput, f as ApiResponse, B as BuybackEvent, C as CONTEXT_PACK_SECTION_ORDER, g as ContextPack, h as ContextPackBudget, i as ContextPackInput, j as ContextPackOptions, k as ContextPackSectionKey, l as ContextPackSections, D as DurabilityCheckpointWriteOptions, m as DurabilityProxyClientOptions, n as DurabilityRestoreDrillWriteOptions, H as HUMAN_APP_LOOP_PHASES, o as HUMAN_APP_LOOP_SCHEMA, p as HumanAppLoopPhase, q as HumanAppLoopSpec, r as HumanAppPhaseContract, s as HumanAppTrialEvaluation, t as HumanAppTrialInput, L as LISTING_NAME_MAX_LENGTH, u as LISTING_NAME_RECOMMENDED_MAX, v as LISTING_TAGLINE_MAX_LENGTH, w as LISTING_TAGLINE_RECOMMENDED_MAX, x as LeaderboardEntry, y as LeaderboardQuery, z as ListingNamingValidationOptions, E as ListingNamingValidationResult, F as ListingQuery, G as ListingReviewCreatePayload, I as ListingReviewResponsePayload, J as ListingVersionPayload, M as MarketingCampaign, K as MarketingLinkOptions, N as MemoryPingChallengeResponse, O as MemoryPingPayload, P as OUTCOME_BOUND_FLOW_SCHEMA, Q as OUTCOME_BOUND_REQUIRED_GATES, R as OpenRouterCredits, S as OutcomeBoundRequiredGate, T as OutcomeBoundRunInput, U as OutcomeBoundRunStatus, V as ProcurementCandidate, W as ProcurementDecision, X as ProcurementTaskProfile, Y as ProcurementWeights, Z as ResourceProviderManifestEntry, _ as ResourceSnapshot, $ as ReviewGate, a0 as ReviewGateRecord, a1 as ReviewRequiredPayload, a2 as STRICT_MEMORY_RUNTIME_SCHEMA, a3 as ScaffoldHumanAppLoopPackOptions, a4 as ScaffoldHumanAppLoopPackResult, a5 as SdkAutoUpdatedRestartRequiredError, a6 as SdkUpdateCheckOptions, a7 as SdkUpdatePolicyCheckOptions, a8 as SdkUpdateRequiredError, a9 as SdkUpdateStatus, aa as StrictMemoryEvaluation, ab as StrictMemoryEvaluationInput, ac as StrictMemoryRuntimePreset, ad as StrictMemoryTriggerSet, ae as StrictMemoryUpgradeInput, af as StrictMemoryUpgradePolicy, ag as StrictMemoryUpgradeResult, TopupDecision, TopupRequest, TreasuryLedgerEvent, TreasuryPolicy, TreasuryPolicyV1, TreasuryState, ah as VIBEIAO_IDL, ai as VibeClient, aj as VibeClientOptions, ak as VibeRegistry, al as assertOutcomeBoundCompleted, am as assertSurvivalProvidersConfigured, an as buildBadgeMarkdown, ao as buildClaimMessage, ap as buildJupiterSwapUrl, aq as buildListingVersionMessage, ar as buildMemoryPingMessage, as as buildOwnerTransferMessage, at as buildProcurementPrompt, au as buildRaydiumSwapUrl, av as buildReviewPrompt, aw as buildReviewRequired, ax as buildReviewResponseMessage, ay as buildSdkUpdateCommand, az as buildShareCopy, aA as buildShareLink, aB as buildTradeLinks, buildTreasuryLedgerEvent, aC as checkForSdkUpdate, aD as checkForSdkUpdatePolicy, aE as compareVersions, aF as createApiCreditProvider, aG as createApiCreditProviders, aH as createApiCreditProvidersFromManifest, aI as createCampaign, aJ as createContextPack, aK as createDurabilityProxyClient, aL as createHumanAppLoopSpec, aM as createStrictMemoryRuntimePreset, createTreasuryPolicy, aN as decideProcurementForTask, aO as estimateContextPackTokens, aP as evaluateHumanAppTrial, aQ as evaluateOutcomeBoundRun, aR as evaluateStrictMemoryExecution, evaluateTopupRequest, aS as getResourceSnapshot, aT as isComplexTask, aU as normalizeListingText, aV as rankListingsForTask, aW as sanitizeListingNaming, aX as scaffoldHumanAppLoopPack, aY as scoreListingForTask, treasuryStateFromSnapshot, aZ as upgradeToStrictMemoryRuntimePreset, a_ as validateContextPack, a$ as validateListingNaming, validateTreasuryPolicy } from './treasuryGuardian.js';
 export { fetchSolBalance, fetchTokenBalance, fetchTokenBalances } from './solana.js';
 import '@coral-xyz/anchor';

package/dist/index.js

@@ -233,6 +233,524 @@ var validateContextPack = (value) => {
 var CONTEXT_PACK_SECTION_ORDER = [...SECTION_ORDER];
 var estimateContextPackTokens = (textOrChars) => estimateTokensFromChars(typeof textOrChars === "number" ? textOrChars : textOrChars.length);
 
+// src/humanAppLoop.ts
+import { promises as fs } from "fs";
+import path from "path";
+var HUMAN_APP_LOOP_SCHEMA = "human-app-reflective-loop/v1";
+var HUMAN_APP_LOOP_PHASES = [
+  "research",
+  "hypothesis",
+  "build",
+  "launch",
+  "observe",
+  "reflect",
+  "iterate"
+];
+var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
+var createHumanAppLoopSpec = (createdAt = nowIso()) => ({
+  schema: HUMAN_APP_LOOP_SCHEMA,
+  createdAt,
+  phases: [
+    {
+      phase: "research",
+      requiredInputs: ["problem statement", "target users", "constraints (time/budget/risk)"],
+      requiredOutputs: ["evidence log", "competitor/alternative scan", "top unresolved assumptions"],
+      goNoGoCriteria: [">=3 independent evidence points", "clear user pain identified"],
+      stopOrRollbackConditions: ["no meaningful user pain found", "constraints make task infeasible"],
+      kpis: ["evidence_count", "source_diversity", "problem_clarity_score"]
+    },
+    {
+      phase: "hypothesis",
+      requiredInputs: ["research outputs"],
+      requiredOutputs: ["testable hypotheses", "success/failure thresholds", "experiment plan"],
+      goNoGoCriteria: ["each hypothesis is falsifiable", "each has measurable KPI target"],
+      stopOrRollbackConditions: ["hypothesis not measurable", "missing baseline"],
+      kpis: ["hypothesis_count", "kpi_defined_ratio"]
+    },
+    {
+      phase: "build",
+      requiredInputs: ["approved hypothesis", "scope boundary"],
+      requiredOutputs: ["MVP artifact", "change log", "known limitations list"],
+      goNoGoCriteria: ["MVP covers core user path", "critical defects resolved"],
+      stopOrRollbackConditions: ["critical bug unresolved", "scope creep beyond budget"],
+      kpis: ["mvp_completion", "critical_bug_count", "time_to_mvp_hours"]
+    },
+    {
+      phase: "launch",
+      requiredInputs: ["MVP artifact", "release checklist"],
+      requiredOutputs: ["launch record", "segment/channel", "baseline metrics snapshot"],
+      goNoGoCriteria: ["launch checklist passed", "monitoring ready"],
+      stopOrRollbackConditions: ["monitoring absent", "compliance/safety issue found"],
+      kpis: ["launch_readiness_score", "time_to_first_user_feedback_hours"]
+    },
+    {
+      phase: "observe",
+      requiredInputs: ["launch metrics", "feedback stream"],
+      requiredOutputs: ["observation report", "anomaly list", "KPI trend summary"],
+      goNoGoCriteria: ["minimum observation window met", "KPI deltas measurable"],
+      stopOrRollbackConditions: ["harmful regressions", "rollback threshold crossed"],
+      kpis: ["retention_d1", "task_success_rate", "error_rate", "feedback_signal_ratio"]
+    },
+    {
+      phase: "reflect",
+      requiredInputs: ["observation report", "hypothesis outcomes"],
+      requiredOutputs: ["lessons learned", "root-cause analysis", "decision log"],
+      goNoGoCriteria: ["at least one actionable insight", "root cause linked to evidence"],
+      stopOrRollbackConditions: ["insufficient evidence quality"],
+      kpis: ["insight_actionability_score", "decision_traceability_ratio"]
+    },
+    {
+      phase: "iterate",
+      requiredInputs: ["reflection decisions", "prioritized backlog"],
+      requiredOutputs: ["next-cycle plan", "versioned experiment backlog", "risk updates"],
+      goNoGoCriteria: ["next cycle has explicit KPI targets", "owner and timeline assigned"],
+      stopOrRollbackConditions: ["no measurable improvement path"],
+      kpis: ["iteration_cycle_time", "kpi_improvement_rate", "rollback_incident_count"]
+    }
+  ],
+  optionalToolUsePolicy: {
+    enabled: true,
+    rules: [
+      "Tool choice is optional, but each phase must record a one-line rationale for selected tools.",
+      "Prefer the least-privilege/lowest-cost tool that can satisfy evidence quality.",
+      "If external tools are skipped, document why manual reasoning is sufficient."
+    ]
+  },
+  overlapWithAgentListingLoops: {
+    overlap: [
+      "Both loops require measurable KPI targets and decision gates.",
+      "Both run observe -> reflect -> iterate compounding cycles.",
+      "Both benefit from versioned changelogs and user/review feedback integration."
+    ],
+    differences: [
+      "Human app loop starts with product problem discovery; agent-listing loops start with listing/distribution economics.",
+      "Human app loop emphasizes user value and usability outcomes; agent-listing loops emphasize market visibility, conversion, and listing operations.",
+      "Human app loop gates include stop/rollback on product harm/usability regressions before growth mechanics."
+    ]
+  },
+  evaluationRubric: {
+    dimensions: [
+      {
+        id: "researchDepth",
+        description: "Evidence quality, source diversity, and assumption clarity.",
+        weight: 0.35,
+        passThreshold: 3
+      },
+      {
+        id: "iterationQuality",
+        description: "Strength of hypothesis-to-build-to-reflect loop with measurable changes.",
+        weight: 0.35,
+        passThreshold: 3
+      },
+      {
+        id: "outcomeUsefulness",
+        description: "Practical utility of outputs for a human owner/builder.",
+        weight: 0.3,
+        passThreshold: 3
+      }
+    ],
+    overallPassThreshold: 3.2
+  }
+});
+var clamp = (v, min, max) => Math.max(min, Math.min(max, v));
+var evaluateHumanAppTrial = (trial, spec = createHumanAppLoopSpec("1970-01-01T00:00:00.000Z")) => {
+  const notes = [];
+  const r = trial.evidence;
+  const researchDepth = clamp(
+    (r.researchNotesCount >= 4 ? 2 : r.researchNotesCount >= 2 ? 1 : 0) + (r.hypothesisCount >= 2 ? 1 : 0) + (r.measurableKpiCount >= 2 ? 1 : 0),
+    1,
+    5
+  );
+  const iterationQuality = clamp(
+    (r.experimentsRun >= 2 ? 2 : r.experimentsRun >= 1 ? 1 : 0) + (r.iterationSteps >= 2 ? 2 : r.iterationSteps >= 1 ? 1 : 0) + (r.rollbackPlanPresent ? 1 : 0),
+    1,
+    5
+  );
+  const outcomeUsefulness = clamp(
+    (r.shippedArtifactPresent ? 2 : 0) + (r.measurableKpiCount >= 2 ? 2 : r.measurableKpiCount >= 1 ? 1 : 0) + (r.rollbackPlanPresent ? 1 : 0),
+    1,
+    5
+  );
+  const weights = Object.fromEntries(spec.evaluationRubric.dimensions.map((d) => [d.id, d.weight]));
+  const weightedScore = researchDepth * (weights.researchDepth || 0) + iterationQuality * (weights.iterationQuality || 0) + outcomeUsefulness * (weights.outcomeUsefulness || 0);
+  if (!r.rollbackPlanPresent) notes.push("Missing rollback plan evidence.");
+  if (r.measurableKpiCount < 2) notes.push("Insufficient measurable KPI coverage.");
+  if (r.experimentsRun < 1) notes.push("No experiment run evidence.");
+  const dimensionThresholds = Object.fromEntries(
+    spec.evaluationRubric.dimensions.map((d) => [d.id, d.passThreshold])
+  );
+  const pass = researchDepth >= (dimensionThresholds.researchDepth || 0) && iterationQuality >= (dimensionThresholds.iterationQuality || 0) && outcomeUsefulness >= (dimensionThresholds.outcomeUsefulness || 0) && weightedScore >= spec.evaluationRubric.overallPassThreshold;
+  return {
+    id: trial.id,
+    scores: { researchDepth, iterationQuality, outcomeUsefulness },
+    weightedScore: Number(weightedScore.toFixed(2)),
+    pass,
+    notes
+  };
+};
+var ensureDir = async (dir) => {
+  await fs.mkdir(dir, { recursive: true });
+};
+var writeIfAllowed = async (filePath, content, overwrite) => {
+  if (!overwrite) {
+    try {
+      await fs.access(filePath);
+      return false;
+    } catch {
+    }
+  }
+  await fs.writeFile(filePath, content, "utf-8");
+  return true;
+};
+var buildLoopRunTemplate = () => `# Human App Reflective Loop Run Template
+
+Use this in order: research -> hypothesis -> build -> launch -> observe -> reflect -> iterate
+
+## 0) Metadata
+- App idea:
+- Target user:
+- Owner:
+- Date:
+- Version/cycle:
+
+## 1) Research
+- Inputs used:
+- Evidence notes (>=3):
+- Output summary:
+- Go/No-Go decision:
+
+## 2) Hypothesis
+- Hypothesis H1:
+- KPI targets + baseline:
+- Experiment plan:
+- Go/No-Go decision:
+
+## 3) Build
+- Scope:
+- Artifact shipped:
+- Known limitations:
+- Go/No-Go decision:
+
+## 4) Launch
+- Channel/audience:
+- Launch checklist:
+- Baseline metric snapshot:
+- Go/No-Go decision:
+
+## 5) Observe
+- Observation window:
+- KPI deltas:
+- Risks/anomalies:
+- Stop/Rollback triggered? why/why not:
+
+## 6) Reflect
+- What worked:
+- What failed:
+- Root cause evidence:
+- Decisions recorded:
+
+## 7) Iterate
+- Next-cycle plan:
+- Backlog prioritization:
+- KPI delta target:
+- Rollback guardrails:
+`;
+var buildSubagentTaskTemplate = () => `# Subagent Task Template \u2014 Human App Reflective Loop
+
+You are tasked to run ONE full human-app reflective loop cycle on a small app/game idea.
+
+Required order (do not skip):
+1. research
+2. hypothesis
+3. build (MVP spec or mock implementation)
+4. launch (simulated launch plan)
+5. observe (expected metrics + monitoring)
+6. reflect
+7. iterate
+
+Requirements:
+- Include measurable KPIs and thresholds.
+- Include explicit go/no-go decision at each phase.
+- Include stop/rollback conditions.
+- If you use tools, add one-line justification per tool.
+- Output using LOOP_RUN_TEMPLATE.md headings.
+`;
+var buildScorecardTemplate = () => `# Human App Loop Trial Scorecard
+
+## Trial ID
+-
+
+## Scores (1-5)
+- researchDepth:
+- iterationQuality:
+- outcomeUsefulness:
+- weightedScore:
+- pass/fail:
+
+## Evidence
+- research notes count:
+- hypotheses count:
+- experiments run:
+- measurable KPI count:
+- rollback plan present:
+- shipped artifact present:
+- iteration steps:
+
+## Issues / Fixes
+-
+`;
+var buildReadme = () => `# Human App Reflective Loop Pack
+
+This pack is first-class scaffold for human app lifecycle execution.
+
+## Files
+- LOOP_RUN_TEMPLATE.md
+- SUBAGENT_TASK_TEMPLATE.md
+- TRIAL_SCORECARD_TEMPLATE.md
+- SPEC.snapshot.json
+
+## Quick usage
+1) Fill LOOP_RUN_TEMPLATE.md for a cycle.
+2) For delegated runs, paste SUBAGENT_TASK_TEMPLATE.md into a subagent task.
+3) Evaluate trial outputs with TRIAL_SCORECARD_TEMPLATE.md and the SDK evaluator.
+`;
+var scaffoldHumanAppLoopPack = async (options = {}) => {
+  const root = path.resolve(options.root || ".");
+  const outputDir = path.resolve(root, options.outputDir || "projects/vibeiao/human-app-loop-pack");
+  const overwrite = Boolean(options.overwrite);
+  const createdAt = nowIso();
+  const files = [];
+  await ensureDir(outputDir);
+  const spec = createHumanAppLoopSpec(createdAt);
+  const writes = [
+    ["LOOP_RUN_TEMPLATE.md", buildLoopRunTemplate()],
+    ["SUBAGENT_TASK_TEMPLATE.md", buildSubagentTaskTemplate()],
+    ["TRIAL_SCORECARD_TEMPLATE.md", buildScorecardTemplate()],
+    ["README.md", buildReadme()],
+    ["SPEC.snapshot.json", `${JSON.stringify(spec, null, 2)}
+`]
+  ];
+  for (const [name, content] of writes) {
+    const full = path.join(outputDir, name);
+    const written = await writeIfAllowed(full, content, overwrite);
+    if (written) files.push(full);
+  }
+  return {
+    root,
+    outputDir,
+    files,
+    createdAt
+  };
+};
+
+// src/outcomeBoundFlow.ts
+var OUTCOME_BOUND_FLOW_SCHEMA = "outcome-bound-autonomous-flow/v1";
+var OUTCOME_BOUND_REQUIRED_GATES = [
+  "public_deploy_url",
+  "listing_updated",
+  "external_smoke_check",
+  "evidence_log",
+  "context_pack_preflight"
+];
+var isNonEmpty = (v) => typeof v === "string" && v.trim().length > 0;
+var evaluateOutcomeBoundRun = (input) => {
+  const failedGates = [];
+  const reasons = [];
+  if (!isNonEmpty(input.publicDeployUrl)) {
+    failedGates.push("public_deploy_url");
+    reasons.push("Missing public deploy URL.");
+  }
+  if (!input.listingUpdated || !isNonEmpty(input.listingId)) {
+    failedGates.push("listing_updated");
+    reasons.push("Listing update is incomplete (listingUpdated/listingId required).");
+  }
+  if (!input.externalSmokeCheck?.passed) {
+    failedGates.push("external_smoke_check");
+    reasons.push("External smoke check did not pass.");
+  }
+  if (!isNonEmpty(input.evidenceLogPath)) {
+    failedGates.push("evidence_log");
+    reasons.push("Missing evidence log path.");
+  }
+  if (!input.contextPackPreflight?.passed) {
+    failedGates.push("context_pack_preflight");
+    reasons.push("Context-pack preflight did not pass.");
+  }
+  const passedCount = OUTCOME_BOUND_REQUIRED_GATES.length - failedGates.length;
+  const score = Number((passedCount / OUTCOME_BOUND_REQUIRED_GATES.length).toFixed(2));
+  const completed = failedGates.length === 0;
+  return {
+    schema: OUTCOME_BOUND_FLOW_SCHEMA,
+    runId: input.runId,
+    objective: input.objective,
+    completed,
+    failedGates,
+    score,
+    status: completed ? "pass" : "fail",
+    reasons,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+};
+var assertOutcomeBoundCompleted = (input) => {
+  const status = evaluateOutcomeBoundRun(input);
+  if (!status.completed) {
+    const details = status.reasons.join(" ");
+    throw new Error(`outcome_bound_incomplete:${status.failedGates.join(",")}${details ? `:${details}` : ""}`);
+  }
+  return status;
+};
+
+// src/strictMemoryRuntime.ts
+var STRICT_MEMORY_RUNTIME_SCHEMA = "strict-memory-runtime/v1";
+var DEFAULT_MUTATION_KEYWORDS = [
+  "deploy",
+  "restart",
+  "install",
+  "delete",
+  "remove",
+  "push",
+  "publish",
+  "release",
+  "migrate",
+  "config",
+  "cron",
+  "service",
+  "production",
+  "prod"
+];
+var DEFAULT_COMPLEX_KEYWORDS = [
+  "multi-step",
+  "cross-day",
+  "production",
+  "owner",
+  "id",
+  "listing",
+  "migration",
+  "incident",
+  "release",
+  "rollout",
+  "infra",
+  "security"
+];
+var uniq = (arr) => [...new Set(arr.map((s) => String(s).trim()).filter(Boolean))];
+var createStrictMemoryRuntimePreset = (overrides = {}) => {
+  const base = {
+    schema: STRICT_MEMORY_RUNTIME_SCHEMA,
+    enabled: true,
+    requireContextPackForComplex: true,
+    requireSemanticRecallForComplex: true,
+    requireApprovalPreflightForMutations: true,
+    maxContextPackAgeMin: 180,
+    mutationKeywords: [...DEFAULT_MUTATION_KEYWORDS],
+    complexTaskTrigger: {
+      keywords: [...DEFAULT_COMPLEX_KEYWORDS],
+      minTaskChars: 80
+    },
+    upgradePolicy: {
+      mode: "observe",
+      safeUpgrade: {
+        backupBeforeEnable: true,
+        requireHealthcheckPass: true,
+        rollbackOnBlockRateAbove: 0.35
+      }
+    }
+  };
+  return {
+    ...base,
+    ...overrides,
+    mutationKeywords: uniq(overrides.mutationKeywords || base.mutationKeywords),
+    complexTaskTrigger: {
+      ...base.complexTaskTrigger,
+      ...overrides.complexTaskTrigger || {},
+      keywords: uniq(overrides.complexTaskTrigger?.keywords || base.complexTaskTrigger.keywords)
+    },
+    upgradePolicy: {
+      ...base.upgradePolicy,
+      ...overrides.upgradePolicy || {},
+      safeUpgrade: {
+        ...base.upgradePolicy.safeUpgrade,
+        ...overrides.upgradePolicy?.safeUpgrade || {}
+      }
+    }
+  };
+};
+var includesAny = (text, words) => {
+  const low = text.toLowerCase();
+  return words.some((w) => low.includes(w.toLowerCase()));
+};
+var isComplexTask = (taskText, preset = createStrictMemoryRuntimePreset()) => {
+  const text = String(taskText || "").trim();
+  if (!text) return false;
+  if (text.length >= preset.complexTaskTrigger.minTaskChars) return true;
+  return includesAny(text, preset.complexTaskTrigger.keywords);
+};
+var evaluateStrictMemoryExecution = (input, preset = createStrictMemoryRuntimePreset()) => {
+  const complex = isComplexTask(input.taskText, preset);
+  const shouldEnforce = preset.enabled && (complex || input.isMutation);
+  const requiredSteps = [];
+  const missingSteps = [];
+  const reasons = [];
+  if (!shouldEnforce) {
+    return { complex, shouldEnforce, allowed: true, requiredSteps, missingSteps, reasons };
+  }
+  if (preset.requireContextPackForComplex && complex) {
+    requiredSteps.push("context_pack_prepared");
+    if (!input.contextPackPrepared) {
+      missingSteps.push("context_pack_prepared");
+      reasons.push("Missing context pack for complex task.");
+    }
+  }
+  if (preset.requireSemanticRecallForComplex && complex) {
+    requiredSteps.push("semantic_recall_confirmed");
+    if (!input.semanticRecallConfirmed) {
+      missingSteps.push("semantic_recall_confirmed");
+      reasons.push("Missing semantic recall confirmation for complex task.");
+    }
+  }
+  if (preset.requireApprovalPreflightForMutations && input.isMutation) {
+    requiredSteps.push("approval_preflight_passed");
+    if (!input.approvalPreflightPassed) {
+      missingSteps.push("approval_preflight_passed");
+      reasons.push("Mutation preflight approval did not pass.");
+    }
+  }
+  return {
+    complex,
+    shouldEnforce,
+    allowed: missingSteps.length === 0,
+    requiredSteps,
+    missingSteps,
+    reasons
+  };
+};
+var upgradeToStrictMemoryRuntimePreset = (input = {}) => {
+  const current = createStrictMemoryRuntimePreset(input.current || {});
+  const targetMode = input.targetMode || current.upgradePolicy.mode || "observe";
+  const next = createStrictMemoryRuntimePreset({
+    ...current,
+    upgradePolicy: {
+      ...current.upgradePolicy,
+      mode: targetMode
+    }
+  });
+  const reasons = [];
+  const safeCfg = next.upgradePolicy.safeUpgrade;
+  if (safeCfg.backupBeforeEnable && !input.backupCreated) {
+    reasons.push("Backup not confirmed.");
+  }
+  if (safeCfg.requireHealthcheckPass && !input.healthcheckPassed) {
+    reasons.push("Healthcheck not confirmed.");
+  }
+  if (typeof input.recentBlockRate === "number" && input.recentBlockRate > safeCfg.rollbackOnBlockRateAbove && targetMode === "enforce") {
+    reasons.push("Recent block rate is too high for enforce mode; keep observe mode first.");
+  }
+  return {
+    next,
+    safe: reasons.length === 0,
+    reasons
+  };
+};
+
 // src/index.ts
 var SdkUpdateRequiredError = class extends Error {
   status;
@@ -349,7 +867,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.31" ? "0.1.31" : "0.1.4";
+var DEFAULT_SDK_VERSION = "0.1.32" ? "0.1.32" : "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;
@@ -541,9 +1059,9 @@ var unwrap = (response) => {
   return response.data;
 };
 var normalizeProviderName = (value) => value.trim().toLowerCase().replace(/[^a-z0-9_-]/g, "");
-var getByPath = (payload, path) => {
-  if (!path) return void 0;
-  const segments = path.split(".").map((part) => part.trim()).filter(Boolean);
+var getByPath = (payload, path2) => {
+  if (!path2) return void 0;
+  const segments = path2.split(".").map((part) => part.trim()).filter(Boolean);
   let current = payload;
   for (const segment of segments) {
     if (!current || typeof current !== "object" || !(segment in current)) {
@@ -844,9 +1362,9 @@ var VibeClient = class {
       };
     }
   }
-  async get(path) {
+  async get(path2) {
     await this.ensureLatestVersion();
-    const response = await this.fetcher(`${this.baseUrl}${path}`);
+    const response = await this.fetcher(`${this.baseUrl}${path2}`);
     let payload = null;
     try {
       payload = await readJson(response);
@@ -862,9 +1380,9 @@ var VibeClient = class {
     }
     return payload;
   }
-  async post(path, body) {
+  async post(path2, body) {
     await this.ensureLatestVersion();
-    const response = await this.fetcher(`${this.baseUrl}${path}`, {
+    const response = await this.fetcher(`${this.baseUrl}${path2}`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(body)
@@ -884,9 +1402,9 @@ var VibeClient = class {
     }
     return payload;
   }
-  async del(path, body) {
+  async del(path2, body) {
     await this.ensureLatestVersion();
-    const response = await this.fetcher(`${this.baseUrl}${path}`, {
+    const response = await this.fetcher(`${this.baseUrl}${path2}`, {
       method: "DELETE",
       headers: { "Content-Type": "application/json" },
       body: body === void 0 ? void 0 : JSON.stringify(body)
@@ -1466,17 +1984,23 @@ var getResourceSnapshot = async (options) => {
 };
 export {
   CONTEXT_PACK_SECTION_ORDER,
+  HUMAN_APP_LOOP_PHASES,
+  HUMAN_APP_LOOP_SCHEMA,
   LISTING_NAME_MAX_LENGTH,
   LISTING_NAME_RECOMMENDED_MAX,
   LISTING_TAGLINE_MAX_LENGTH,
   LISTING_TAGLINE_RECOMMENDED_MAX,
+  OUTCOME_BOUND_FLOW_SCHEMA,
+  OUTCOME_BOUND_REQUIRED_GATES,
   ReviewGate,
+  STRICT_MEMORY_RUNTIME_SCHEMA,
   SdkAutoUpdatedRestartRequiredError,
   SdkUpdateRequiredError,
   SelfReliance,
   VIBEIAO_IDL,
   VibeClient,
   VibeRegistry,
+  assertOutcomeBoundCompleted,
   assertSurvivalProvidersConfigured,
   buildBadgeMarkdown,
   buildClaimMessage,
@@ -1509,9 +2033,11 @@ export {
   createCampaign,
   createContextPack,
   createDurabilityProxyClient,
+  createHumanAppLoopSpec,
   createInMemoryReflectionStore,
   createSelfRelianceMonitor,
   createSelfReliancePolicy,
+  createStrictMemoryRuntimePreset,
   createSurvivalMiddleware,
   createTreasuryPolicy,
   decideProcurementForTask,
@@ -1519,6 +2045,9 @@ export {
   discoverMarketNeeds,
   estimateContextPackTokens,
   evaluateEscapeHatch,
+  evaluateHumanAppTrial,
+  evaluateOutcomeBoundRun,
+  evaluateStrictMemoryExecution,
   evaluateTopupRequest,
   extractMarketSignals,
   fetchSolBalance,
@@ -1530,14 +2059,17 @@ export {
   getSurvivalPlaybookDecision,
   getSurvivalPlaybookDecisionFromSelfReliance,
   getSurvivalRecommendation,
+  isComplexTask,
   normalizeListingText,
   rankListingsForTask,
   runMarketDiscovery,
   runReflectionCycle,
   sanitizeListingNaming,
+  scaffoldHumanAppLoopPack,
   scoreListingForTask,
   scoreReviewPriority,
   treasuryStateFromSnapshot,
+  upgradeToStrictMemoryRuntimePreset,
   validateContextPack,
   validateListingNaming,
   validateTreasuryPolicy,

package/dist/treasuryGuardian.d.ts

@@ -825,6 +825,171 @@ declare const createDurabilityProxyClient: (options: DurabilityProxyClientOption
     }>;
 };
 
+declare const HUMAN_APP_LOOP_SCHEMA = "human-app-reflective-loop/v1";
+declare const HUMAN_APP_LOOP_PHASES: readonly ["research", "hypothesis", "build", "launch", "observe", "reflect", "iterate"];
+type HumanAppLoopPhase = (typeof HUMAN_APP_LOOP_PHASES)[number];
+type HumanAppPhaseContract = {
+    phase: HumanAppLoopPhase;
+    requiredInputs: string[];
+    requiredOutputs: string[];
+    goNoGoCriteria: string[];
+    stopOrRollbackConditions: string[];
+    kpis: string[];
+};
+type HumanAppLoopSpec = {
+    schema: typeof HUMAN_APP_LOOP_SCHEMA;
+    createdAt: string;
+    phases: HumanAppPhaseContract[];
+    optionalToolUsePolicy: {
+        enabled: true;
+        rules: string[];
+    };
+    overlapWithAgentListingLoops: {
+        overlap: string[];
+        differences: string[];
+    };
+    evaluationRubric: {
+        dimensions: Array<{
+            id: 'researchDepth' | 'iterationQuality' | 'outcomeUsefulness';
+            description: string;
+            weight: number;
+            passThreshold: number;
+        }>;
+        overallPassThreshold: number;
+    };
+};
+type HumanAppTrialInput = {
+    id: string;
+    summary?: string;
+    evidence: {
+        researchNotesCount: number;
+        hypothesisCount: number;
+        experimentsRun: number;
+        measurableKpiCount: number;
+        rollbackPlanPresent: boolean;
+        shippedArtifactPresent: boolean;
+        iterationSteps: number;
+    };
+};
+type HumanAppTrialEvaluation = {
+    id: string;
+    scores: {
+        researchDepth: number;
+        iterationQuality: number;
+        outcomeUsefulness: number;
+    };
+    weightedScore: number;
+    pass: boolean;
+    notes: string[];
+};
+declare const createHumanAppLoopSpec: (createdAt?: string) => HumanAppLoopSpec;
+declare const evaluateHumanAppTrial: (trial: HumanAppTrialInput, spec?: HumanAppLoopSpec) => HumanAppTrialEvaluation;
+type ScaffoldHumanAppLoopPackOptions = {
+    root?: string;
+    outputDir?: string;
+    overwrite?: boolean;
+};
+type ScaffoldHumanAppLoopPackResult = {
+    root: string;
+    outputDir: string;
+    files: string[];
+    createdAt: string;
+};
+declare const scaffoldHumanAppLoopPack: (options?: ScaffoldHumanAppLoopPackOptions) => Promise<ScaffoldHumanAppLoopPackResult>;
+
+declare const OUTCOME_BOUND_FLOW_SCHEMA = "outcome-bound-autonomous-flow/v1";
+type OutcomeBoundRequiredGate = 'public_deploy_url' | 'listing_updated' | 'external_smoke_check' | 'evidence_log' | 'context_pack_preflight';
+declare const OUTCOME_BOUND_REQUIRED_GATES: OutcomeBoundRequiredGate[];
+type OutcomeBoundRunInput = {
+    runId: string;
+    objective: string;
+    publicDeployUrl?: string;
+    listingId?: string;
+    listingUpdated: boolean;
+    externalSmokeCheck: {
+        passed: boolean;
+        checker?: string;
+        checkedAt?: string;
+        note?: string;
+    };
+    evidenceLogPath?: string;
+    contextPackPreflight: {
+        passed: boolean;
+        scope?: string;
+        preparedAt?: string;
+    };
+    notes?: string[];
+};
+type OutcomeBoundRunStatus = {
+    schema: typeof OUTCOME_BOUND_FLOW_SCHEMA;
+    runId: string;
+    objective: string;
+    completed: boolean;
+    failedGates: OutcomeBoundRequiredGate[];
+    score: number;
+    status: 'pass' | 'fail';
+    reasons: string[];
+    createdAt: string;
+};
+declare const evaluateOutcomeBoundRun: (input: OutcomeBoundRunInput) => OutcomeBoundRunStatus;
+declare const assertOutcomeBoundCompleted: (input: OutcomeBoundRunInput) => OutcomeBoundRunStatus;
+
+declare const STRICT_MEMORY_RUNTIME_SCHEMA = "strict-memory-runtime/v1";
+type StrictMemoryTriggerSet = {
+    keywords: string[];
+    minTaskChars: number;
+};
+type StrictMemoryUpgradePolicy = {
+    mode: 'observe' | 'enforce';
+    safeUpgrade: {
+        backupBeforeEnable: boolean;
+        requireHealthcheckPass: boolean;
+        rollbackOnBlockRateAbove: number;
+    };
+};
+type StrictMemoryRuntimePreset = {
+    schema: typeof STRICT_MEMORY_RUNTIME_SCHEMA;
+    enabled: boolean;
+    requireContextPackForComplex: boolean;
+    requireSemanticRecallForComplex: boolean;
+    requireApprovalPreflightForMutations: boolean;
+    maxContextPackAgeMin: number;
+    mutationKeywords: string[];
+    complexTaskTrigger: StrictMemoryTriggerSet;
+    upgradePolicy: StrictMemoryUpgradePolicy;
+};
+type StrictMemoryEvaluationInput = {
+    taskText: string;
+    isMutation: boolean;
+    contextPackPrepared: boolean;
+    semanticRecallConfirmed: boolean;
+    approvalPreflightPassed: boolean;
+};
+type StrictMemoryEvaluation = {
+    complex: boolean;
+    shouldEnforce: boolean;
+    allowed: boolean;
+    requiredSteps: string[];
+    missingSteps: string[];
+    reasons: string[];
+};
+type StrictMemoryUpgradeInput = {
+    current?: Partial<StrictMemoryRuntimePreset>;
+    healthcheckPassed?: boolean;
+    backupCreated?: boolean;
+    recentBlockRate?: number;
+    targetMode?: 'observe' | 'enforce';
+};
+type StrictMemoryUpgradeResult = {
+    next: StrictMemoryRuntimePreset;
+    safe: boolean;
+    reasons: string[];
+};
+declare const createStrictMemoryRuntimePreset: (overrides?: Partial<StrictMemoryRuntimePreset>) => StrictMemoryRuntimePreset;
+declare const isComplexTask: (taskText: string, preset?: StrictMemoryRuntimePreset) => boolean;
+declare const evaluateStrictMemoryExecution: (input: StrictMemoryEvaluationInput, preset?: StrictMemoryRuntimePreset) => StrictMemoryEvaluation;
+declare const upgradeToStrictMemoryRuntimePreset: (input?: StrictMemoryUpgradeInput) => StrictMemoryUpgradeResult;
+
 interface VibeClientOptions {
     baseUrl?: string;
     fetcher?: typeof fetch;
@@ -1284,4 +1449,4 @@ declare const getResourceSnapshot: (options: {
     apiBase?: string;
 }) => Promise<ResourceSnapshot>;
 
-export { assertSurvivalProvidersConfigured as $, type AgentResourceProvidersManifest as A, type BuybackEvent as B, CONTEXT_PACK_SECTION_ORDER as C, type DurabilityCheckpointWriteOptions as D, type MemoryPingChallengeResponse as E, type MemoryPingPayload as F, type ProcurementDecision as G, type ProcurementTaskProfile as H, type ProcurementWeights as I, type ResourceSnapshot as J, ReviewGate as K, LISTING_NAME_MAX_LENGTH as L, type MarketingCampaign as M, type ReviewGateRecord as N, type OpenRouterCredits as O, type ProcurementCandidate as P, type ReviewRequiredPayload as Q, type ResourceProviderManifestEntry as R, SdkAutoUpdatedRestartRequiredError as S, type SdkUpdateCheckOptions as T, type TopupDecision, type TopupRequest, type TreasuryLedgerEvent, type TreasuryPolicy, type TreasuryPolicyV1, type TreasuryState, type SdkUpdatePolicyCheckOptions as U, SdkUpdateRequiredError as V, type SdkUpdateStatus as W, VIBEIAO_IDL as X, VibeClient as Y, type VibeClientOptions as Z, VibeRegistry as _, type AnalyticsPoint as a, buildBadgeMarkdown as a0, buildClaimMessage as a1, buildJupiterSwapUrl as a2, buildListingVersionMessage as a3, buildMemoryPingMessage as a4, buildOwnerTransferMessage as a5, buildProcurementPrompt as a6, buildRaydiumSwapUrl as a7, buildReviewPrompt as a8, buildReviewRequired as a9, buildReviewResponseMessage as aa, buildSdkUpdateCommand as ab, buildShareCopy as ac, buildShareLink as ad, buildTradeLinks as ae, checkForSdkUpdate as af, checkForSdkUpdatePolicy as ag, compareVersions as ah, createApiCreditProvider as ai, createApiCreditProviders as aj, createApiCreditProvidersFromManifest as ak, createCampaign as al, createContextPack as am, createDurabilityProxyClient as an, decideProcurementForTask as ao, estimateContextPackTokens as ap, getResourceSnapshot as aq, normalizeListingText as ar, rankListingsForTask as as, sanitizeListingNaming as at, scoreListingForTask as au, validateContextPack as av, validateListingNaming as aw, type ApiCreditProvider as b, buildTreasuryLedgerEvent, type ApiCreditProviderFactoryOptions as c, createTreasuryPolicy, type ApiCreditProviderPreset as d, type ApiCreditProviderPresetInput as e, evaluateTopupRequest, type ApiResponse as f, type ContextPack as g, type ContextPackBudget as h, type ContextPackInput as i, type ContextPackOptions as j, type ContextPackSectionKey as k, type ContextPackSections as l, type DurabilityProxyClientOptions as m, type DurabilityRestoreDrillWriteOptions as n, LISTING_NAME_RECOMMENDED_MAX as o, LISTING_TAGLINE_MAX_LENGTH as p, LISTING_TAGLINE_RECOMMENDED_MAX as q, type LeaderboardEntry as r, type LeaderboardQuery as s, type ListingNamingValidationOptions as t, treasuryStateFromSnapshot, type ListingNamingValidationResult as u, type ListingQuery as v, validateTreasuryPolicy, type ListingReviewCreatePayload as w, type ListingReviewResponsePayload as x, type ListingVersionPayload as y, type MarketingLinkOptions as z };
+export { ReviewGate as $, type AgentResourceProvidersManifest as A, type BuybackEvent as B, CONTEXT_PACK_SECTION_ORDER as C, type DurabilityCheckpointWriteOptions as D, type ListingNamingValidationResult as E, type ListingQuery as F, type ListingReviewCreatePayload as G, HUMAN_APP_LOOP_PHASES as H, type ListingReviewResponsePayload as I, type ListingVersionPayload as J, type MarketingLinkOptions as K, LISTING_NAME_MAX_LENGTH as L, type MarketingCampaign as M, type MemoryPingChallengeResponse as N, type MemoryPingPayload as O, OUTCOME_BOUND_FLOW_SCHEMA as P, OUTCOME_BOUND_REQUIRED_GATES as Q, type OpenRouterCredits as R, type OutcomeBoundRequiredGate as S, type OutcomeBoundRunInput as T, type TopupDecision, type TopupRequest, type TreasuryLedgerEvent, type TreasuryPolicy, type TreasuryPolicyV1, type TreasuryState, type OutcomeBoundRunStatus as U, type ProcurementCandidate as V, type ProcurementDecision as W, type ProcurementTaskProfile as X, type ProcurementWeights as Y, type ResourceProviderManifestEntry as Z, type ResourceSnapshot as _, type AnalyticsPoint as a, validateListingNaming as a$, type ReviewGateRecord as a0, type ReviewRequiredPayload as a1, STRICT_MEMORY_RUNTIME_SCHEMA as a2, type ScaffoldHumanAppLoopPackOptions as a3, type ScaffoldHumanAppLoopPackResult as a4, SdkAutoUpdatedRestartRequiredError as a5, type SdkUpdateCheckOptions as a6, type SdkUpdatePolicyCheckOptions as a7, SdkUpdateRequiredError as a8, type SdkUpdateStatus as a9, buildShareLink as aA, buildTradeLinks as aB, checkForSdkUpdate as aC, checkForSdkUpdatePolicy as aD, compareVersions as aE, createApiCreditProvider as aF, createApiCreditProviders as aG, createApiCreditProvidersFromManifest as aH, createCampaign as aI, createContextPack as aJ, createDurabilityProxyClient as aK, createHumanAppLoopSpec as aL, createStrictMemoryRuntimePreset as aM, decideProcurementForTask as aN, estimateContextPackTokens as aO, evaluateHumanAppTrial as aP, evaluateOutcomeBoundRun as aQ, evaluateStrictMemoryExecution as aR, getResourceSnapshot as aS, isComplexTask as aT, normalizeListingText as aU, rankListingsForTask as aV, sanitizeListingNaming as aW, scaffoldHumanAppLoopPack as aX, scoreListingForTask as aY, upgradeToStrictMemoryRuntimePreset as aZ, validateContextPack as a_, type StrictMemoryEvaluation as aa, type StrictMemoryEvaluationInput as ab, type StrictMemoryRuntimePreset as ac, type StrictMemoryTriggerSet as ad, type StrictMemoryUpgradeInput as ae, type StrictMemoryUpgradePolicy as af, type StrictMemoryUpgradeResult as ag, VIBEIAO_IDL as ah, VibeClient as ai, type VibeClientOptions as aj, VibeRegistry as ak, assertOutcomeBoundCompleted as al, assertSurvivalProvidersConfigured as am, buildBadgeMarkdown as an, buildClaimMessage as ao, buildJupiterSwapUrl as ap, buildListingVersionMessage as aq, buildMemoryPingMessage as ar, buildOwnerTransferMessage as as, buildProcurementPrompt as at, buildRaydiumSwapUrl as au, buildReviewPrompt as av, buildReviewRequired as aw, buildReviewResponseMessage as ax, buildSdkUpdateCommand as ay, buildShareCopy as az, type ApiCreditProvider as b, buildTreasuryLedgerEvent, type ApiCreditProviderFactoryOptions as c, createTreasuryPolicy, type ApiCreditProviderPreset as d, type ApiCreditProviderPresetInput as e, evaluateTopupRequest, type ApiResponse as f, type ContextPack as g, type ContextPackBudget as h, type ContextPackInput as i, type ContextPackOptions as j, type ContextPackSectionKey as k, type ContextPackSections as l, type DurabilityProxyClientOptions as m, type DurabilityRestoreDrillWriteOptions as n, HUMAN_APP_LOOP_SCHEMA as o, type HumanAppLoopPhase as p, type HumanAppLoopSpec as q, type HumanAppPhaseContract as r, type HumanAppTrialEvaluation as s, type HumanAppTrialInput as t, treasuryStateFromSnapshot, LISTING_NAME_RECOMMENDED_MAX as u, LISTING_TAGLINE_MAX_LENGTH as v, validateTreasuryPolicy, LISTING_TAGLINE_RECOMMENDED_MAX as w, type LeaderboardEntry as x, type LeaderboardQuery as y, type ListingNamingValidationOptions as z };

package/package.json

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