@vibeiao/sdk 0.1.35 → 0.1.36

package/dist/agentLoop.js

@@ -5,6 +5,9 @@ import {
 import {
   createDurabilityProxyClient
 } from "./chunk-PVCW4MAY.js";
+import {
+  createSelfRelianceMonitor
+} from "./chunk-M7DQTU5R.js";
 import {
   evaluateEscapeHatch,
   formatEscapeHatchDecision
@@ -14,9 +17,6 @@ import {
   formatSurvivalRecommendation,
   getSurvivalRecommendation
 } from "./chunk-JQE72P4C.js";
-import {
-  createSelfRelianceMonitor
-} from "./chunk-M7DQTU5R.js";
 
 // src/agentLoop.ts
 var asFiniteNumber = (value) => {

package/dist/chunk-BQVU67TR.js

@@ -0,0 +1,63 @@
+// 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;
+};
+
+export {
+  OUTCOME_BOUND_FLOW_SCHEMA,
+  OUTCOME_BOUND_REQUIRED_GATES,
+  evaluateOutcomeBoundRun,
+  assertOutcomeBoundCompleted
+};

package/dist/chunk-RUKN3KQ2.js

@@ -0,0 +1,158 @@
+// 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
+  };
+};
+
+export {
+  STRICT_MEMORY_RUNTIME_SCHEMA,
+  createStrictMemoryRuntimePreset,
+  isComplexTask,
+  evaluateStrictMemoryExecution,
+  upgradeToStrictMemoryRuntimePreset
+};

package/dist/humanAppLoop.d.ts

@@ -0,0 +1,73 @@
+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>;
+
+export { HUMAN_APP_LOOP_PHASES, HUMAN_APP_LOOP_SCHEMA, type HumanAppLoopPhase, type HumanAppLoopSpec, type HumanAppPhaseContract, type HumanAppTrialEvaluation, type HumanAppTrialInput, type ScaffoldHumanAppLoopPackOptions, type ScaffoldHumanAppLoopPackResult, createHumanAppLoopSpec, evaluateHumanAppTrial, scaffoldHumanAppLoopPack };

package/dist/humanAppLoop.js

@@ -0,0 +1,316 @@
+// 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
+  };
+};
+export {
+  HUMAN_APP_LOOP_PHASES,
+  HUMAN_APP_LOOP_SCHEMA,
+  createHumanAppLoopSpec,
+  evaluateHumanAppTrial,
+  scaffoldHumanAppLoopPack
+};

package/dist/index.d.ts

@@ -6,6 +6,8 @@ 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, 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 { 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 { OUTCOME_BOUND_FLOW_SCHEMA, OUTCOME_BOUND_REQUIRED_GATES, OutcomeBoundRequiredGate, OutcomeBoundRunInput, OutcomeBoundRunStatus, assertOutcomeBoundCompleted, evaluateOutcomeBoundRun } from './outcomeBoundFlow.js';
+export { STRICT_MEMORY_RUNTIME_SCHEMA, StrictMemoryEvaluation, StrictMemoryEvaluationInput, StrictMemoryRuntimePreset, StrictMemoryTriggerSet, StrictMemoryUpgradeInput, StrictMemoryUpgradePolicy, StrictMemoryUpgradeResult, createStrictMemoryRuntimePreset, evaluateStrictMemoryExecution, isComplexTask, upgradeToStrictMemoryRuntimePreset } from './strictMemoryRuntime.js';
 export { fetchSolBalance, fetchTokenBalance, fetchTokenBalances } from './solana.js';
 import '@coral-xyz/anchor';