@vibeiao/sdk 0.1.35 → 0.1.37

package/README.md

@@ -582,6 +582,20 @@ const loop = createAgentLoop({
 });
 ```
 
+By default, `createAgentLoop(...)` also enables strict-memory runtime checks in `observe` mode.
+To make it hard-enforced, set `strictMemory.mode = 'enforce'` and provide snapshot fields for gating (`taskText`, `isMutation`, `contextPackPrepared`, `semanticRecallConfirmed`, `approvalPreflightPassed`).
+
+```ts
+const loop = createAgentLoop({
+  survival,
+  fetchSnapshot,
+  strictMemory: {
+    enabled: true,
+    mode: 'enforce',
+  },
+});
+```
+
 Disable only if you already run an equivalent external memory-control plane:
 
 ```ts

package/dist/agentLoop.d.ts

@@ -2,6 +2,7 @@ import { SelfReliance, ResourceSnapshot, SelfRelianceState } from './selfRelianc
 import { SurvivalMode, SurvivalRecommendation } from './survivalPlaybook.js';
 import { EscapeHatchDecision, EscapeHatchPolicy, EscapeHatchSnapshot } from './survivalEscapeHatch.js';
 import { CompoundingMemoryUpgradeResult, CompoundingMemoryRequiredSetResult } from './compoundingMemory.js';
+import { StrictMemoryRuntimePreset, StrictMemoryEvaluation, StrictMemoryUpgradeResult } from './strictMemoryRuntime.js';
 
 type AgentLoopEscapeHatchInput = {
     snapshot: ResourceSnapshot;
@@ -22,6 +23,27 @@ type AgentLoopEscapeHatchConfig = {
     /** Called when an escape-hatch decision is produced. */
     onDecision?: (decision: EscapeHatchDecision, input: AgentLoopEscapeHatchInput) => Promise<void> | void;
 };
+type AgentLoopStrictMemoryConfig = {
+    /** Enable strict memory runtime checks in loop. Default true. */
+    enabled?: boolean;
+    /** observe (default) records decisions; enforce blocks onAct when checks fail. */
+    mode?: 'observe' | 'enforce';
+    /** Optional preset overrides. */
+    preset?: Partial<StrictMemoryRuntimePreset>;
+    /** Build per-cycle evaluation input. Defaults to best-effort snapshot fields. */
+    buildInput?: (ctx: {
+        snapshot: ResourceSnapshot;
+        timestamp: number;
+    }) => {
+        taskText: string;
+        isMutation: boolean;
+        contextPackPrepared: boolean;
+        semanticRecallConfirmed: boolean;
+        approvalPreflightPassed: boolean;
+    };
+    /** Optional hook when strict-memory evaluation runs. */
+    onEvaluation?: (ev: StrictMemoryEvaluation) => Promise<void> | void;
+};
 type AgentLoopContext = {
     snapshot: ResourceSnapshot;
     survivalState: SelfRelianceState;
@@ -37,6 +59,10 @@ type AgentLoopContext = {
     memoryUpgrade?: CompoundingMemoryUpgradeResult;
     /** Present when required-set maintenance check runs (default daily). */
     memoryRequiredSet?: CompoundingMemoryRequiredSetResult;
+    /** Strict-memory runtime preset + per-cycle evaluation status. */
+    strictMemoryPreset?: StrictMemoryRuntimePreset;
+    strictMemoryEvaluation?: StrictMemoryEvaluation;
+    strictMemoryUpgrade?: StrictMemoryUpgradeResult;
     timestamp: number;
 };
 type AgentLoopMemoryConfig = {
@@ -114,6 +140,7 @@ type AgentLoopConfig = {
     escapeHatch?: AgentLoopEscapeHatchConfig;
     memory?: AgentLoopMemoryConfig;
     durability?: AgentLoopDurabilityConfig;
+    strictMemory?: AgentLoopStrictMemoryConfig;
 };
 /**
  * Create a closed-loop runner that:
@@ -131,4 +158,4 @@ declare const createAgentLoop: (config: AgentLoopConfig) => {
     runOnce: () => Promise<void>;
 };
 
-export { type AgentLoopConfig, type AgentLoopContext, type AgentLoopDurabilityConfig, type AgentLoopEscapeHatchConfig, type AgentLoopEscapeHatchInput, type AgentLoopHooks, type AgentLoopMemoryConfig, createAgentLoop };
+export { type AgentLoopConfig, type AgentLoopContext, type AgentLoopDurabilityConfig, type AgentLoopEscapeHatchConfig, type AgentLoopEscapeHatchInput, type AgentLoopHooks, type AgentLoopMemoryConfig, type AgentLoopStrictMemoryConfig, createAgentLoop };

package/dist/agentLoop.js

@@ -5,6 +5,14 @@ import {
 import {
   createDurabilityProxyClient
 } from "./chunk-PVCW4MAY.js";
+import {
+  createSelfRelianceMonitor
+} from "./chunk-M7DQTU5R.js";
+import {
+  createStrictMemoryRuntimePreset,
+  evaluateStrictMemoryExecution,
+  upgradeToStrictMemoryRuntimePreset
+} from "./chunk-RUKN3KQ2.js";
 import {
   evaluateEscapeHatch,
   formatEscapeHatchDecision
@@ -14,9 +22,6 @@ import {
   formatSurvivalRecommendation,
   getSurvivalRecommendation
 } from "./chunk-JQE72P4C.js";
-import {
-  createSelfRelianceMonitor
-} from "./chunk-M7DQTU5R.js";
 
 // src/agentLoop.ts
 var asFiniteNumber = (value) => {
@@ -51,6 +56,16 @@ var createAgentLoop = (config) => {
   const requiredSetIntervalMs = Math.max(6e4, config.memory?.requiredSetIntervalMs ?? 24 * 60 * 60 * 1e3);
   const requiredSetRunOnStart = config.memory?.requiredSetRunOnStart ?? true;
   const requiredSetRunRestoreDrill = config.memory?.requiredSetRunRestoreDrill ?? true;
+  const strictMemoryEnabled = config.strictMemory?.enabled ?? true;
+  const strictMode = config.strictMemory?.mode ?? "observe";
+  const strictMemoryPreset = createStrictMemoryRuntimePreset(config.strictMemory?.preset || {});
+  const strictMemoryUpgrade = upgradeToStrictMemoryRuntimePreset({
+    current: strictMemoryPreset,
+    targetMode: strictMode,
+    backupCreated: true,
+    healthcheckPassed: true,
+    recentBlockRate: 0
+  });
   const durabilityEnabled = config.durability?.enabled ?? false;
   const durabilityClient = durabilityEnabled ? createDurabilityProxyClient({
     baseUrl: config.durability?.baseUrl || "",
@@ -149,6 +164,16 @@ var createAgentLoop = (config) => {
     }
     lastDurabilitySyncCheckedAt = memoryRequiredSet.checkedAt;
   };
+  const defaultStrictInputBuilder = (ctx) => {
+    const raw = ctx.snapshot;
+    return {
+      taskText: String(raw.taskText || raw.objective || ""),
+      isMutation: Boolean(raw.isMutation),
+      contextPackPrepared: Boolean(raw.contextPackPrepared),
+      semanticRecallConfirmed: Boolean(raw.semanticRecallConfirmed),
+      approvalPreflightPassed: Boolean(raw.approvalPreflightPassed)
+    };
+  };
   const runOnce = async () => {
     try {
       const memoryUpgrade = await ensureMemoryUpgrade();
@@ -190,6 +215,14 @@ var createAgentLoop = (config) => {
         }
       }
       const survivalDecisionBlock = [survivalFormatted, escapeHatchFormatted].filter(Boolean).join("\n\n");
+      let strictMemoryEvaluation;
+      if (strictMemoryEnabled) {
+        const strictInput = (config.strictMemory?.buildInput || defaultStrictInputBuilder)({ snapshot, timestamp });
+        strictMemoryEvaluation = evaluateStrictMemoryExecution(strictInput, strictMemoryPreset);
+        if (config.strictMemory?.onEvaluation) {
+          await config.strictMemory.onEvaluation(strictMemoryEvaluation);
+        }
+      }
       const ctx = {
         snapshot,
         survivalState,
@@ -201,11 +234,18 @@ var createAgentLoop = (config) => {
         escapeHatchFormatted,
         memoryUpgrade: memoryUpgrade ?? void 0,
         memoryRequiredSet: memoryRequiredSet ?? void 0,
+        strictMemoryPreset: strictMemoryEnabled ? strictMemoryPreset : void 0,
+        strictMemoryEvaluation,
+        strictMemoryUpgrade: strictMemoryEnabled ? strictMemoryUpgrade : void 0,
         timestamp
       };
       if (hooks.onCycle) await hooks.onCycle(ctx);
       if (hooks.onReflection) await hooks.onReflection(ctx);
       if (hooks.onAct) {
+        if (strictMemoryEnabled && strictMode === "enforce" && ctx.strictMemoryEvaluation && !ctx.strictMemoryEvaluation.allowed) {
+          const missing = ctx.strictMemoryEvaluation.missingSteps.join(",");
+          throw new Error(`strict_memory_blocked:${missing}`);
+        }
         if (guardAct) {
           const allowed = await config.survival.guard();
           if (allowed) {

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 };