@vibeiao/sdk 0.1.36 → 0.1.38

package/README.md

@@ -582,6 +582,26 @@ 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`).
+
+You can also enforce dual-mode work arbitration:
+- `owner_bound` agents: human-first (owner work preempts autonomous work)
+- `unbound` agents: autonomous-first (run autonomous work by default)
+
+Use `autonomy.rolloutMode='enforce'` to apply hard arbitration behavior.
+
+```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

@@ -1,7 +1,8 @@
-import { SelfReliance, ResourceSnapshot, SelfRelianceState } from './selfReliance.js';
+import { ResourceSnapshot, SelfRelianceState, SelfReliance } from './selfReliance.js';
 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,52 @@ 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 AgentOwnershipMode = 'owner_bound' | 'unbound';
+type AgentPriorityMode = 'human_first' | 'autonomous_first';
+type AgentHumanDemand = {
+    pending: boolean;
+    count?: number;
+    source?: string;
+};
+type AgentWorkArbitrationDecision = {
+    ownershipMode: AgentOwnershipMode;
+    priorityMode: AgentPriorityMode;
+    rolloutMode: 'observe' | 'enforce';
+    humanDemand: AgentHumanDemand;
+    runHumanTask: boolean;
+    runAutonomousTask: boolean;
+    reason: string;
+};
+type AgentLoopAutonomyConfig = {
+    enabled?: boolean;
+    ownershipMode?: AgentOwnershipMode;
+    priorityMode?: AgentPriorityMode;
+    rolloutMode?: 'observe' | 'enforce';
+    resolveHumanDemand?: () => Promise<boolean | AgentHumanDemand> | boolean | AgentHumanDemand;
+    onAutonomous?: (ctx: AgentLoopContext) => Promise<void> | void;
+    onArbitration?: (decision: AgentWorkArbitrationDecision, ctx: AgentLoopContext) => Promise<void> | void;
+};
 type AgentLoopContext = {
     snapshot: ResourceSnapshot;
     survivalState: SelfRelianceState;
@@ -37,6 +84,12 @@ 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;
+    /** Human-vs-autonomous work arbitration decision for this cycle. */
+    workArbitration?: AgentWorkArbitrationDecision;
     timestamp: number;
 };
 type AgentLoopMemoryConfig = {
@@ -114,6 +167,8 @@ type AgentLoopConfig = {
     escapeHatch?: AgentLoopEscapeHatchConfig;
     memory?: AgentLoopMemoryConfig;
     durability?: AgentLoopDurabilityConfig;
+    strictMemory?: AgentLoopStrictMemoryConfig;
+    autonomy?: AgentLoopAutonomyConfig;
 };
 /**
  * Create a closed-loop runner that:
@@ -131,4 +186,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 AgentHumanDemand, type AgentLoopAutonomyConfig, type AgentLoopConfig, type AgentLoopContext, type AgentLoopDurabilityConfig, type AgentLoopEscapeHatchConfig, type AgentLoopEscapeHatchInput, type AgentLoopHooks, type AgentLoopMemoryConfig, type AgentLoopStrictMemoryConfig, type AgentOwnershipMode, type AgentPriorityMode, type AgentWorkArbitrationDecision, createAgentLoop };

package/dist/agentLoop.js

@@ -8,6 +8,11 @@ import {
 import {
   createSelfRelianceMonitor
 } from "./chunk-M7DQTU5R.js";
+import {
+  createStrictMemoryRuntimePreset,
+  evaluateStrictMemoryExecution,
+  upgradeToStrictMemoryRuntimePreset
+} from "./chunk-RUKN3KQ2.js";
 import {
   evaluateEscapeHatch,
   formatEscapeHatchDecision
@@ -51,6 +56,20 @@ 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 autonomyEnabled = config.autonomy?.enabled ?? true;
+  const ownershipMode = config.autonomy?.ownershipMode ?? "owner_bound";
+  const priorityMode = config.autonomy?.priorityMode ?? (ownershipMode === "unbound" ? "autonomous_first" : "human_first");
+  const rolloutMode = config.autonomy?.rolloutMode ?? "enforce";
+  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 +168,26 @@ 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 resolveHumanDemand = async () => {
+    const raw = await config.autonomy?.resolveHumanDemand?.();
+    if (typeof raw === "boolean") return { pending: raw };
+    if (!raw || typeof raw !== "object") return { pending: false };
+    return {
+      pending: Boolean(raw.pending),
+      count: raw.count,
+      source: raw.source
+    };
+  };
   const runOnce = async () => {
     try {
       const memoryUpgrade = await ensureMemoryUpgrade();
@@ -190,6 +229,35 @@ 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 humanDemand = autonomyEnabled ? await resolveHumanDemand() : { pending: false };
+      const arbitrationBase = {
+        ownershipMode,
+        priorityMode,
+        rolloutMode,
+        humanDemand,
+        runHumanTask: true,
+        runAutonomousTask: false,
+        reason: "legacy_onAct"
+      };
+      if (autonomyEnabled && config.autonomy?.onAutonomous) {
+        if (priorityMode === "human_first") {
+          arbitrationBase.runHumanTask = humanDemand.pending;
+          arbitrationBase.runAutonomousTask = !humanDemand.pending;
+          arbitrationBase.reason = humanDemand.pending ? "human_pending_preempts_autonomous" : "idle_autonomous_window";
+        } else {
+          arbitrationBase.runHumanTask = humanDemand.pending;
+          arbitrationBase.runAutonomousTask = true;
+          arbitrationBase.reason = humanDemand.pending ? "autonomous_first_with_human_pending" : "autonomous_first_idle";
+        }
+      }
       const ctx = {
         snapshot,
         survivalState,
@@ -201,11 +269,16 @@ var createAgentLoop = (config) => {
         escapeHatchFormatted,
         memoryUpgrade: memoryUpgrade ?? void 0,
         memoryRequiredSet: memoryRequiredSet ?? void 0,
+        strictMemoryPreset: strictMemoryEnabled ? strictMemoryPreset : void 0,
+        strictMemoryEvaluation,
+        strictMemoryUpgrade: strictMemoryEnabled ? strictMemoryUpgrade : void 0,
+        workArbitration: arbitrationBase,
         timestamp
       };
       if (hooks.onCycle) await hooks.onCycle(ctx);
       if (hooks.onReflection) await hooks.onReflection(ctx);
-      if (hooks.onAct) {
+      const runHumanTask = async () => {
+        if (!hooks.onAct) return;
         if (guardAct) {
           const allowed = await config.survival.guard();
           if (allowed) {
@@ -214,6 +287,23 @@ var createAgentLoop = (config) => {
         } else {
           await hooks.onAct(ctx);
         }
+      };
+      const runAutonomousTask = async () => {
+        if (!config.autonomy?.onAutonomous) return;
+        await config.autonomy.onAutonomous(ctx);
+      };
+      if (strictMemoryEnabled && strictMode === "enforce" && ctx.strictMemoryEvaluation && !ctx.strictMemoryEvaluation.allowed) {
+        const missing = ctx.strictMemoryEvaluation.missingSteps.join(",");
+        throw new Error(`strict_memory_blocked:${missing}`);
+      }
+      if (autonomyEnabled && config.autonomy?.onAutonomous && rolloutMode === "enforce") {
+        if (ctx.workArbitration?.runHumanTask) await runHumanTask();
+        if (ctx.workArbitration?.runAutonomousTask) await runAutonomousTask();
+      } else {
+        await runHumanTask();
+      }
+      if (config.autonomy?.onArbitration) {
+        await config.autonomy.onArbitration(ctx.workArbitration, ctx);
       }
     } catch (err) {
       const e = err instanceof Error ? err : new Error("agent_loop_failed");

package/dist/index.js

@@ -5,13 +5,6 @@ import {
   fetchTokenBalances,
   normalizeHumanAppCategory
 } from "./chunk-2U6HLZEF.js";
-import {
-  STRICT_MEMORY_RUNTIME_SCHEMA,
-  createStrictMemoryRuntimePreset,
-  evaluateStrictMemoryExecution,
-  isComplexTask,
-  upgradeToStrictMemoryRuntimePreset
-} from "./chunk-RUKN3KQ2.js";
 import {
   getSurvivalPlaybookDecision,
   getSurvivalPlaybookDecisionFromSelfReliance
@@ -34,6 +27,13 @@ import {
   createSurvivalMiddleware,
   withSurvival
 } from "./chunk-M7DQTU5R.js";
+import {
+  STRICT_MEMORY_RUNTIME_SCHEMA,
+  createStrictMemoryRuntimePreset,
+  evaluateStrictMemoryExecution,
+  isComplexTask,
+  upgradeToStrictMemoryRuntimePreset
+} from "./chunk-RUKN3KQ2.js";
 import {
   evaluateEscapeHatch,
   formatEscapeHatchDecision
@@ -362,7 +362,7 @@ var ReviewGate = class {
 var DEFAULT_API_BASE = "https://api.vibeiao.com";
 var DEFAULT_WEB_BASE = "https://vibeiao.com";
 var DEFAULT_SDK_PACKAGE = "@vibeiao/sdk";
-var DEFAULT_SDK_VERSION = "0.1.35" ? "0.1.35" : "0.1.4";
+var DEFAULT_SDK_VERSION = "0.1.37" ? "0.1.37" : "0.1.4";
 var DEFAULT_SDK_REGISTRY = "https://registry.npmjs.org";
 var DEFAULT_SDK_POLICY_PATH = "/v1/sdk/policy";
 var DEFAULT_SDK_CHECK_INTERVAL_MS = 1e3 * 60 * 30;

package/dist/treasuryGuardian.d.ts

@@ -1105,7 +1105,7 @@ declare class ReviewGate {
     assertClear(listingId: string, wallet: string): void;
 }
 
-declare const compareVersions: (currentVersion: string, latestVersion: string) => 0 | 1 | -1;
+declare const compareVersions: (currentVersion: string, latestVersion: string) => 1 | 0 | -1;
 declare const buildSdkUpdateCommand: (packageName?: string) => string;
 declare const checkForSdkUpdate: (options?: SdkUpdateCheckOptions) => Promise<SdkUpdateStatus>;
 declare const checkForSdkUpdatePolicy: (options: SdkUpdatePolicyCheckOptions) => Promise<SdkUpdateStatus>;

package/package.json

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