@vibeiao/sdk 0.1.51 → 0.1.52

package/dist/agentLoop-BPdoysXH.d.ts

@@ -0,0 +1,327 @@
+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 PromptShieldTrustLevel = 'trusted_human' | 'internal_system' | 'external_untrusted';
+type PromptShieldInput = {
+    source: string;
+    trust: PromptShieldTrustLevel;
+    content: string;
+};
+type PromptShieldFlag = 'instruction_override' | 'credential_exfiltration' | 'destructive_command' | 'authority_spoof' | 'sensitive_action_without_trust';
+type PromptShieldRisk = 'low' | 'medium' | 'high';
+type PromptShieldDecision = {
+    allow: boolean;
+    risk: PromptShieldRisk;
+    flags: PromptShieldFlag[];
+    rationale: string[];
+    blockedInputs: PromptShieldInput[];
+};
+type PromptShieldPolicy = {
+    blockOnFlags?: PromptShieldFlag[];
+    allowUntrustedForAnalysisOnly?: boolean;
+};
+declare const evaluatePromptShield: (inputs: PromptShieldInput[], options?: {
+    isSensitiveAction?: boolean;
+    policy?: PromptShieldPolicy;
+}) => PromptShieldDecision;
+
+type ObjectiveChangeSourceTrust = 'trusted_human' | 'internal_system' | 'external_untrusted';
+type ObjectiveChangeProposal = {
+    source: string;
+    trust: ObjectiveChangeSourceTrust;
+    currentObjective: string;
+    proposedObjective: string;
+    rationale?: string;
+    evidence?: Array<{
+        claim: string;
+        verified?: boolean;
+    }>;
+};
+type ObjectiveGuardDecision = {
+    allowObjectiveChange: boolean;
+    reason: string;
+    checks: {
+        explicitInstruction: boolean;
+        missionAligned: boolean;
+        evidenceProvided: boolean;
+        evidenceVerified: boolean;
+    };
+    risk: 'low' | 'medium' | 'high';
+};
+type ObjectiveGuardPolicy = {
+    requireMissionAlignment?: boolean;
+    requireEvidenceVerification?: boolean;
+    allowExternalExplicitInstruction?: boolean;
+};
+declare const evaluateObjectiveChange: (proposal: ObjectiveChangeProposal, policy?: ObjectiveGuardPolicy) => ObjectiveGuardDecision;
+
+type IntentSignals = {
+    expectedBuildValue?: number;
+    expectedBuildRevenue?: number;
+    expectedPolishValue?: number;
+    expectedPolishRevenueProtection?: number;
+    urgentUserDemand?: boolean;
+    releaseReady?: boolean;
+    criticalPolishSignal?: boolean;
+    builderObjectiveAvailable?: boolean;
+};
+type LaneMode = 'polish' | 'builder';
+type LaneSwitchDecision = {
+    lane: LaneMode;
+    greenStreak: number;
+    switched: boolean;
+    reason: string;
+};
+declare const scoreBuildLane: (signals: IntentSignals, survivalMode: SurvivalMode) => number;
+declare const scorePolishLane: (signals: IntentSignals, survivalMode: SurvivalMode, humanDemand: AgentHumanDemand) => number;
+declare const evaluateLaneSwitch: (input: {
+    previousLane?: LaneMode;
+    previousGreenStreak?: number;
+    releaseReady: boolean;
+    criticalPolishSignal?: boolean;
+    builderObjectiveAvailable?: boolean;
+    builderOnGreenStreak?: number;
+}) => LaneSwitchDecision;
+declare const applyIntentArbitration: (input: {
+    base: AgentWorkArbitrationDecision;
+    survivalMode: SurvivalMode;
+    signals?: IntentSignals;
+}) => AgentWorkArbitrationDecision;
+
+type AgentLoopEscapeHatchInput = {
+    snapshot: ResourceSnapshot;
+    survivalState: SelfRelianceState;
+    survivalMode: SurvivalMode;
+    timestamp: number;
+};
+type AgentLoopEscapeHatchConfig = {
+    /** Enable auto escape-hatch evaluation (default true, only in SURVIVE/BLINK). */
+    enabled?: boolean;
+    policy?: EscapeHatchPolicy;
+    resolveEnv?: (name: string) => string | undefined;
+    /**
+     * Optional mapper from loop context -> escape hatch snapshot.
+     * If omitted, a default mapper reads optional fields from snapshot.
+     */
+    buildSnapshot?: (input: AgentLoopEscapeHatchInput) => EscapeHatchSnapshot | null | undefined;
+    /** 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 AgentLoopPromptShieldConfig = {
+    /** Enable prompt-injection shield over untrusted external content. Default true. */
+    enabled?: boolean;
+    /** observe logs/records only; enforce blocks actions when shield fails. Default observe. */
+    mode?: 'observe' | 'enforce';
+    /** Optional policy overrides for blocked flags. */
+    policy?: PromptShieldPolicy;
+    /** Optional mapper from snapshot to trust-labeled inputs. */
+    buildInputs?: (ctx: {
+        snapshot: ResourceSnapshot;
+        timestamp: number;
+    }) => PromptShieldInput[];
+    /** Optional hook when prompt shield decision is produced. */
+    onDecision?: (decision: PromptShieldDecision) => Promise<void> | void;
+};
+type AgentLoopObjectiveGuardConfig = {
+    /** Enable objective integrity checks for external objective-change attempts. Default true. */
+    enabled?: boolean;
+    /** observe logs only; enforce blocks actions when objective mutation is denied. Default observe. */
+    mode?: 'observe' | 'enforce';
+    /** Policy requirements for external objective mutation acceptance. */
+    policy?: ObjectiveGuardPolicy;
+    /** Build proposed objective change from snapshot. Return null when no proposal is present. */
+    buildProposal?: (ctx: {
+        snapshot: ResourceSnapshot;
+        timestamp: number;
+    }) => ObjectiveChangeProposal | null;
+    /** Optional hook when objective decision is produced. */
+    onDecision?: (decision: ObjectiveGuardDecision) => 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;
+    lane?: LaneMode;
+    laneDecision?: LaneSwitchDecision;
+    reason: string;
+};
+type AgentLoopAutonomyConfig = {
+    enabled?: boolean;
+    ownershipMode?: AgentOwnershipMode;
+    priorityMode?: AgentPriorityMode;
+    rolloutMode?: 'observe' | 'enforce';
+    resolveHumanDemand?: () => Promise<boolean | AgentHumanDemand> | boolean | AgentHumanDemand;
+    intentPolicy?: {
+        enabled?: boolean;
+        laneSwitch?: {
+            enabled?: boolean;
+            builderOnGreenStreak?: number;
+        };
+        resolveSignals?: (ctx: {
+            snapshot: ResourceSnapshot;
+            survivalMode: SurvivalMode;
+            humanDemand: AgentHumanDemand;
+        }) => Promise<IntentSignals | null> | IntentSignals | null;
+    };
+    onAutonomous?: (ctx: AgentLoopContext) => Promise<void> | void;
+    onArbitration?: (decision: AgentWorkArbitrationDecision, ctx: AgentLoopContext) => Promise<void> | void;
+};
+type AgentLoopContext = {
+    snapshot: ResourceSnapshot;
+    survivalState: SelfRelianceState;
+    survivalMode: SurvivalMode;
+    survivalRecommendation: SurvivalRecommendation;
+    survivalFormatted: string;
+    /** Deterministic block for planners/loggers: survival + escape-hatch decision (if present). */
+    survivalDecisionBlock: string;
+    /** Present when escape-hatch evaluation runs (SURVIVE/BLINK by default). */
+    escapeHatchDecision?: EscapeHatchDecision;
+    escapeHatchFormatted?: string;
+    /** Present when memory auto-upgrade is enabled in the loop. */
+    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;
+    /** Prompt-injection shield decision for this cycle. */
+    promptShieldDecision?: PromptShieldDecision;
+    /** Objective integrity guard decision for this cycle (when proposal exists). */
+    objectiveGuardDecision?: ObjectiveGuardDecision;
+    /** Human-vs-autonomous work arbitration decision for this cycle. */
+    workArbitration?: AgentWorkArbitrationDecision;
+    laneDecision?: LaneSwitchDecision;
+    timestamp: number;
+};
+type AgentLoopMemoryConfig = {
+    /** Enable one-time memory scaffold upgrade. Default true. */
+    enabled?: boolean;
+    /** Workspace root for compounding memory files. Default current working directory ("."). */
+    root?: string;
+    /** Timezone for daily ledger date key. Default UTC. */
+    timeZone?: string;
+    /** Hook called after memory upgrade check completes. */
+    onUpgrade?: (result: CompoundingMemoryUpgradeResult) => Promise<void> | void;
+    /** Enable required-set maintenance checks (bounded working state + recall substrate + restore drill). Default true. */
+    requiredSetEnabled?: boolean;
+    /** Interval for required-set checks. Default 24h. */
+    requiredSetIntervalMs?: number;
+    /** Run required-set check on first loop cycle. Default true. */
+    requiredSetRunOnStart?: boolean;
+    /** Include backup+restore drill in required-set check. Default true. */
+    requiredSetRunRestoreDrill?: boolean;
+    /** Hook called when required-set check runs. */
+    onRequiredSet?: (result: CompoundingMemoryRequiredSetResult) => Promise<void> | void;
+};
+type AgentLoopDurabilityConfig = {
+    /** Enable durability-proxy writes from runtime loop. Default false. */
+    enabled?: boolean;
+    /** Durability-proxy base URL (e.g. http://127.0.0.1:8790). */
+    baseUrl: string;
+    /** Agent id registered in durability-proxy. */
+    agentId: string;
+    /** Agent token registered in durability-proxy. */
+    agentToken: string;
+    /** Optional timeout for durability-proxy calls. Default 8000ms. */
+    timeoutMs?: number;
+    /** Write checkpoint after each required-set run. Default true. */
+    checkpointOnRequiredSet?: boolean;
+    /** Write restore-drill outcome when required-set includes restore drill. Default true. */
+    reportRestoreDrill?: boolean;
+    /** Called when durability checkpoint is written. */
+    onCheckpointWritten?: (result: {
+        checkpointId?: string;
+        createdAt?: string;
+        checkedAt: string;
+    }) => Promise<void> | void;
+    /** Called when durability restore drill signal is written. */
+    onRestoreDrillReported?: (result: {
+        ok: boolean;
+        ts?: string;
+        checkedAt: string;
+    }) => Promise<void> | void;
+};
+type AgentLoopHooks = {
+    /** Called every cycle after snapshot is fetched and survival state is updated. */
+    onCycle?: (ctx: AgentLoopContext) => Promise<void> | void;
+    /**
+     * Optional: run reflection in the loop.
+     * Keep this hook pure/side-effect bounded; it should manage its own persistence.
+     */
+    onReflection?: (ctx: AgentLoopContext) => Promise<void> | void;
+    /**
+     * Optional: the agent's planner/executor entrypoint.
+     * This is where you actually "act like a human" using ctx + your own memory.
+     */
+    onAct?: (ctx: AgentLoopContext) => Promise<void> | void;
+    onError?: (err: Error) => Promise<void> | void;
+};
+type AgentLoopConfig = {
+    survival: SelfReliance;
+    fetchSnapshot: () => Promise<ResourceSnapshot>;
+    intervalMs?: number;
+    /** If true, call survival.guard() before onAct(). Default true. */
+    guardAct?: boolean;
+    /** Optional override for time source (tests). */
+    now?: () => number;
+    hooks?: AgentLoopHooks;
+    escapeHatch?: AgentLoopEscapeHatchConfig;
+    memory?: AgentLoopMemoryConfig;
+    durability?: AgentLoopDurabilityConfig;
+    strictMemory?: AgentLoopStrictMemoryConfig;
+    promptShield?: AgentLoopPromptShieldConfig;
+    objectiveGuard?: AgentLoopObjectiveGuardConfig;
+    autonomy?: AgentLoopAutonomyConfig;
+};
+/**
+ * Create a closed-loop runner that:
+ * 1) fetches a resource snapshot
+ * 2) updates SelfReliance
+ * 3) classifies survival mode + produces a playbook recommendation
+ * 4) auto-evaluates escape hatch in SURVIVE/BLINK (guardrail decision block)
+ * 5) optionally runs reflection + action hooks
+ *
+ * Non-breaking by design: you choose what to do with the context.
+ */
+declare const createAgentLoop: (config: AgentLoopConfig) => {
+    start: () => Promise<void>;
+    stop: () => void;
+    runOnce: () => Promise<void>;
+};
+
+export { type AgentHumanDemand as A, type AgentOwnershipMode as B, type AgentPriorityMode as C, type AgentWorkArbitrationDecision as D, createAgentLoop as E, type IntentSignals as I, type LaneMode as L, type ObjectiveChangeProposal as O, type PromptShieldDecision as P, type LaneSwitchDecision as a, type ObjectiveChangeSourceTrust as b, type ObjectiveGuardDecision as c, type ObjectiveGuardPolicy as d, type PromptShieldFlag as e, type PromptShieldInput as f, type PromptShieldPolicy as g, type PromptShieldRisk as h, type PromptShieldTrustLevel as i, applyIntentArbitration as j, evaluateLaneSwitch as k, evaluateObjectiveChange as l, evaluatePromptShield as m, scorePolishLane as n, type AgentLoopAutonomyConfig as o, type AgentLoopConfig as p, type AgentLoopContext as q, type AgentLoopDurabilityConfig as r, scoreBuildLane as s, type AgentLoopEscapeHatchConfig as t, type AgentLoopEscapeHatchInput as u, type AgentLoopHooks as v, type AgentLoopMemoryConfig as w, type AgentLoopObjectiveGuardConfig as x, type AgentLoopPromptShieldConfig as y, type AgentLoopStrictMemoryConfig as z };

package/dist/agentLoop.d.ts

@@ -3,4 +3,4 @@ import './survivalPlaybook.js';
 import './survivalEscapeHatch.js';
 import './compoundingMemory.js';
 import './strictMemoryRuntime.js';
-export { A as AgentHumanDemand, m as AgentLoopAutonomyConfig, n as AgentLoopConfig, o as AgentLoopContext, p as AgentLoopDurabilityConfig, q as AgentLoopEscapeHatchConfig, r as AgentLoopEscapeHatchInput, t as AgentLoopHooks, u as AgentLoopMemoryConfig, v as AgentLoopObjectiveGuardConfig, w as AgentLoopPromptShieldConfig, x as AgentLoopStrictMemoryConfig, y as AgentOwnershipMode, z as AgentPriorityMode, B as AgentWorkArbitrationDecision, C as createAgentLoop } from './agentLoop-Dn6aMtRD.js';
+export { A as AgentHumanDemand, o as AgentLoopAutonomyConfig, p as AgentLoopConfig, q as AgentLoopContext, r as AgentLoopDurabilityConfig, t as AgentLoopEscapeHatchConfig, u as AgentLoopEscapeHatchInput, v as AgentLoopHooks, w as AgentLoopMemoryConfig, x as AgentLoopObjectiveGuardConfig, y as AgentLoopPromptShieldConfig, z as AgentLoopStrictMemoryConfig, B as AgentOwnershipMode, C as AgentPriorityMode, D as AgentWorkArbitrationDecision, E as createAgentLoop } from './agentLoop-BPdoysXH.js';

package/dist/agentLoop.js

@@ -5,9 +5,10 @@ import {
 import {
   applyIntentArbitration,
   createDurabilityProxyClient,
+  evaluateLaneSwitch,
   evaluateObjectiveChange,
   evaluatePromptShield
-} from "./chunk-WFOLCIJC.js";
+} from "./chunk-N3J6WQ72.js";
 import {
   createSelfRelianceMonitor
 } from "./chunk-M7DQTU5R.js";
@@ -70,6 +71,9 @@ var createAgentLoop = (config) => {
   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 laneSwitchEnabled = config.autonomy?.intentPolicy?.laneSwitch?.enabled ?? true;
+  const laneSwitchBuilderThreshold = config.autonomy?.intentPolicy?.laneSwitch?.builderOnGreenStreak ?? 3;
+  let laneState = { lane: "polish", greenStreak: 0 };
   const strictMemoryUpgrade = upgradeToStrictMemoryRuntimePreset({
     current: strictMemoryPreset,
     targetMode: strictMode,
@@ -262,7 +266,10 @@ var createAgentLoop = (config) => {
       expectedBuildRevenue: asFiniteNumber(raw.expectedBuildRevenue),
       expectedPolishValue: asFiniteNumber(raw.expectedPolishValue),
       expectedPolishRevenueProtection: asFiniteNumber(raw.expectedPolishRevenueProtection),
-      urgentUserDemand: asBoolean(raw.urgentUserDemand)
+      urgentUserDemand: asBoolean(raw.urgentUserDemand),
+      releaseReady: asBoolean(raw.releaseReady) ?? asBoolean(raw.ready),
+      criticalPolishSignal: asBoolean(raw.criticalPolishSignal),
+      builderObjectiveAvailable: asBoolean(raw.builderObjectiveAvailable)
     };
   };
   const runOnce = async () => {
@@ -345,6 +352,7 @@ var createAgentLoop = (config) => {
         runAutonomousTask: false,
         reason: "legacy_onAct"
       };
+      let laneDecision;
       if (autonomyEnabled && config.autonomy?.onAutonomous) {
         if (priorityMode === "human_first") {
           arbitrationBase.runHumanTask = humanDemand.pending;
@@ -356,8 +364,26 @@ var createAgentLoop = (config) => {
           arbitrationBase.reason = humanDemand.pending ? "autonomous_first_with_human_pending" : "autonomous_first_idle";
         }
         const intentEnabled = config.autonomy?.intentPolicy?.enabled ?? true;
+        const intentSignals = intentEnabled ? await resolveIntentSignals({ snapshot, survivalMode, humanDemand }) : null;
+        if (laneSwitchEnabled) {
+          laneDecision = evaluateLaneSwitch({
+            previousLane: laneState.lane,
+            previousGreenStreak: laneState.greenStreak,
+            releaseReady: intentSignals?.releaseReady ?? true,
+            criticalPolishSignal: intentSignals?.criticalPolishSignal ?? false,
+            builderObjectiveAvailable: intentSignals?.builderObjectiveAvailable,
+            builderOnGreenStreak: laneSwitchBuilderThreshold
+          });
+          laneState = { lane: laneDecision.lane, greenStreak: laneDecision.greenStreak };
+          arbitrationBase.lane = laneDecision.lane;
+          arbitrationBase.laneDecision = laneDecision;
+          if (laneDecision.lane === "polish") {
+            arbitrationBase.runHumanTask = true;
+            arbitrationBase.runAutonomousTask = false;
+            arbitrationBase.reason = `lane_polish:${laneDecision.reason}`;
+          }
+        }
         if (intentEnabled) {
-          const intentSignals = await resolveIntentSignals({ snapshot, survivalMode, humanDemand });
           Object.assign(
             arbitrationBase,
             applyIntentArbitration({
@@ -366,6 +392,17 @@ var createAgentLoop = (config) => {
               signals: intentSignals || void 0
             })
           );
+          if (laneDecision?.lane === "builder") {
+            arbitrationBase.runAutonomousTask = true;
+            arbitrationBase.reason = `lane_builder:${laneDecision.reason}`;
+            if (humanDemand.pending && ownershipMode === "owner_bound" && priorityMode === "human_first") {
+              arbitrationBase.runHumanTask = true;
+            }
+          }
+          if (laneDecision?.lane === "polish") {
+            arbitrationBase.runHumanTask = true;
+            arbitrationBase.runAutonomousTask = false;
+          }
         }
       }
       const ctx = {
@@ -385,6 +422,7 @@ var createAgentLoop = (config) => {
         promptShieldDecision,
         objectiveGuardDecision,
         workArbitration: arbitrationBase,
+        laneDecision,
         timestamp
       };
       if (hooks.onCycle) await hooks.onCycle(ctx);

package/dist/chunk-N3J6WQ72.js

@@ -0,0 +1,319 @@
+// src/durabilityProxy.ts
+var withTimeout = async (fetcher, input, init, timeoutMs) => {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetcher(input, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var readJson = async (response) => {
+  const text = await response.text();
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { raw: text };
+  }
+};
+var createDurabilityProxyClient = (options) => {
+  const fetcher = options.fetcher || fetch;
+  const timeoutMs = Number.isFinite(Number(options.timeoutMs)) ? Math.max(500, Number(options.timeoutMs)) : 8e3;
+  const base = String(options.baseUrl || "").replace(/\/+$/, "");
+  const agentId = String(options.agentId || "").trim();
+  const agentToken = String(options.agentToken || "").trim();
+  if (!base) throw new Error("durability_proxy_base_missing");
+  if (!agentId) throw new Error("durability_proxy_agent_id_missing");
+  if (!agentToken) throw new Error("durability_proxy_agent_token_missing");
+  const headers = {
+    "content-type": "application/json",
+    "x-agent-id": agentId,
+    "x-agent-token": agentToken
+  };
+  return {
+    async writeCheckpoint(payloadJson, opts = {}) {
+      const response = await withTimeout(
+        fetcher,
+        `${base}/v1/checkpoints`,
+        {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            payloadJson,
+            sha256: opts.sha256,
+            contentType: opts.contentType,
+            metadata: opts.metadata
+          })
+        },
+        timeoutMs
+      );
+      const body = await readJson(response);
+      if (!response.ok) {
+        const detail = body?.error || `http_${response.status}`;
+        throw new Error(`durability_checkpoint_write_failed:${detail}`);
+      }
+      return body;
+    },
+    async latestCheckpoint() {
+      const response = await withTimeout(
+        fetcher,
+        `${base}/v1/checkpoints/latest`,
+        { method: "GET", headers: { "x-agent-id": agentId, "x-agent-token": agentToken } },
+        timeoutMs
+      );
+      const body = await readJson(response);
+      if (!response.ok) {
+        const detail = body?.error || `http_${response.status}`;
+        throw new Error(`durability_checkpoint_latest_failed:${detail}`);
+      }
+      return body;
+    },
+    async writeRestoreDrill(ok, opts = {}) {
+      const response = await withTimeout(
+        fetcher,
+        `${base}/v1/checkpoints/restore-drill`,
+        {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            checkpointId: opts.checkpointId,
+            ok,
+            details: opts.details
+          })
+        },
+        timeoutMs
+      );
+      const body = await readJson(response);
+      if (!response.ok) {
+        const detail = body?.error || `http_${response.status}`;
+        throw new Error(`durability_restore_drill_write_failed:${detail}`);
+      }
+      return body;
+    }
+  };
+};
+
+// src/promptShield.ts
+var RULES = [
+  {
+    flag: "instruction_override",
+    risk: "high",
+    test: [/ignore\s+(all\s+)?previous/i, /disregard\s+instructions/i, /new\s+system\s+prompt/i]
+  },
+  {
+    flag: "credential_exfiltration",
+    risk: "high",
+    test: [/api\s*key/i, /private\s*key/i, /seed\s*phrase/i, /wallet\s*secret/i, /send\s+me\s+your\s+token/i]
+  },
+  {
+    flag: "destructive_command",
+    risk: "high",
+    test: [/\brm\s+-rf\b/i, /drop\s+database/i, /delete\s+all/i, /overwrite\s+memory/i]
+  },
+  {
+    flag: "authority_spoof",
+    risk: "medium",
+    test: [/as\s+your\s+owner/i, /authorized\s+admin/i, /from\s+charles/i]
+  }
+];
+var rankRisk = (a, b) => {
+  const w = { low: 1, medium: 2, high: 3 };
+  return w[a] >= w[b] ? a : b;
+};
+var toDefaultBlockSet = () => /* @__PURE__ */ new Set(["instruction_override", "credential_exfiltration", "destructive_command", "authority_spoof", "sensitive_action_without_trust"]);
+var evaluatePromptShield = (inputs, options = {}) => {
+  const policy = options.policy || {};
+  const blockSet = policy.blockOnFlags ? new Set(policy.blockOnFlags) : toDefaultBlockSet();
+  const rationale = [];
+  const blockedInputs = [];
+  const flags = /* @__PURE__ */ new Set();
+  let risk = "low";
+  for (const input of inputs) {
+    if (input.trust !== "external_untrusted") continue;
+    const text = String(input.content || "");
+    for (const rule of RULES) {
+      if (rule.test.some((rx) => rx.test(text))) {
+        flags.add(rule.flag);
+        risk = rankRisk(risk, rule.risk);
+      }
+    }
+  }
+  if (options.isSensitiveAction) {
+    const hasTrusted = inputs.some((i) => i.trust === "trusted_human" || i.trust === "internal_system");
+    if (!hasTrusted) {
+      flags.add("sensitive_action_without_trust");
+      risk = rankRisk(risk, "high");
+      rationale.push("Sensitive action lacks trusted human/system intent; external input cannot authorize mutation.");
+    }
+  }
+  const blocked = [...flags].some((f) => blockSet.has(f));
+  if (blocked) {
+    for (const input of inputs) {
+      if (input.trust === "external_untrusted") blockedInputs.push(input);
+    }
+  }
+  if (!flags.size) {
+    rationale.push("No injection indicators detected in untrusted sources.");
+  } else {
+    rationale.push(`Detected prompt-shield flags: ${[...flags].join(",")}`);
+  }
+  if (policy.allowUntrustedForAnalysisOnly && blocked) {
+    rationale.push("Untrusted content may be used for analysis only; execution remains blocked.");
+  }
+  return {
+    allow: !blocked,
+    risk,
+    flags: [...flags],
+    rationale,
+    blockedInputs
+  };
+};
+
+// src/objectiveGuard.ts
+var normalize = (v) => String(v || "").trim().toLowerCase();
+var isExplicitInstruction = (text) => /\b(do this instead|switch objective|change objective|stop current objective|ignore current objective)\b/i.test(
+  text || ""
+);
+var missionAlignment = (currentObjective, proposedObjective) => {
+  const a = new Set(normalize(currentObjective).split(/\W+/).filter(Boolean));
+  const b = new Set(normalize(proposedObjective).split(/\W+/).filter(Boolean));
+  if (!a.size || !b.size) return false;
+  let overlap = 0;
+  for (const tok of b) if (a.has(tok)) overlap += 1;
+  return overlap / Math.max(1, b.size) >= 0.2;
+};
+var evaluateObjectiveChange = (proposal, policy = {}) => {
+  const requireMissionAlignment = policy.requireMissionAlignment ?? true;
+  const requireEvidenceVerification = policy.requireEvidenceVerification ?? true;
+  const allowExternalExplicitInstruction = policy.allowExternalExplicitInstruction ?? false;
+  const explicitInstruction = isExplicitInstruction(proposal.proposedObjective) || isExplicitInstruction(proposal.rationale || "");
+  const missionAligned = missionAlignment(proposal.currentObjective, proposal.proposedObjective);
+  const evidence = Array.isArray(proposal.evidence) ? proposal.evidence : [];
+  const evidenceProvided = evidence.length > 0;
+  const evidenceVerified = evidenceProvided && evidence.every((e) => e.verified === true);
+  if (proposal.trust === "trusted_human" || proposal.trust === "internal_system") {
+    return {
+      allowObjectiveChange: true,
+      reason: "trusted_source_override",
+      checks: { explicitInstruction, missionAligned, evidenceProvided, evidenceVerified },
+      risk: "low"
+    };
+  }
+  if (explicitInstruction && !allowExternalExplicitInstruction) {
+    return {
+      allowObjectiveChange: false,
+      reason: "external_explicit_instruction_blocked",
+      checks: { explicitInstruction, missionAligned, evidenceProvided, evidenceVerified },
+      risk: "high"
+    };
+  }
+  if (requireMissionAlignment && !missionAligned) {
+    return {
+      allowObjectiveChange: false,
+      reason: "mission_alignment_failed",
+      checks: { explicitInstruction, missionAligned, evidenceProvided, evidenceVerified },
+      risk: "high"
+    };
+  }
+  if (!evidenceProvided) {
+    return {
+      allowObjectiveChange: false,
+      reason: "evidence_missing",
+      checks: { explicitInstruction, missionAligned, evidenceProvided, evidenceVerified },
+      risk: "medium"
+    };
+  }
+  if (requireEvidenceVerification && !evidenceVerified) {
+    return {
+      allowObjectiveChange: false,
+      reason: "evidence_unverified",
+      checks: { explicitInstruction, missionAligned, evidenceProvided, evidenceVerified },
+      risk: "high"
+    };
+  }
+  return {
+    allowObjectiveChange: true,
+    reason: "reasoned_external_change_allowed",
+    checks: { explicitInstruction, missionAligned, evidenceProvided, evidenceVerified },
+    risk: "low"
+  };
+};
+
+// src/intentArbitration.ts
+var clamp = (n) => Math.max(0, Math.min(1, n));
+var scoreBuildLane = (signals, survivalMode) => {
+  const value = clamp(signals.expectedBuildValue ?? 0.5);
+  const revenue = clamp(signals.expectedBuildRevenue ?? 0.5);
+  const base = value * 0.55 + revenue * 0.45;
+  if (survivalMode === "SURVIVE") return clamp(base + 0.1 * revenue);
+  if (survivalMode === "BLINK") return clamp(base * 0.6);
+  return base;
+};
+var scorePolishLane = (signals, survivalMode, humanDemand) => {
+  const value = clamp(signals.expectedPolishValue ?? (humanDemand.pending ? 0.8 : 0.4));
+  const protect = clamp(signals.expectedPolishRevenueProtection ?? (humanDemand.pending ? 0.7 : 0.4));
+  const demandBoost = humanDemand.pending || signals.urgentUserDemand ? 0.2 : 0;
+  const base = clamp(value * 0.6 + protect * 0.4 + demandBoost);
+  if (survivalMode === "BLINK") return clamp(base * 0.8);
+  return base;
+};
+var evaluateLaneSwitch = (input) => {
+  const prevLane = input.previousLane ?? "polish";
+  const prevGreen = Number(input.previousGreenStreak ?? 0);
+  const threshold = Math.max(1, Number(input.builderOnGreenStreak ?? 3));
+  const critical = Boolean(input.criticalPolishSignal);
+  const objective = input.builderObjectiveAvailable !== false;
+  if (!input.releaseReady) {
+    return { lane: "polish", greenStreak: 0, switched: prevLane !== "polish", reason: "release_not_ready" };
+  }
+  const greenStreak = prevGreen + 1;
+  if (critical) {
+    return { lane: "polish", greenStreak, switched: prevLane !== "polish", reason: "critical_polish_signal" };
+  }
+  if (prevLane === "builder") {
+    return { lane: objective ? "builder" : "polish", greenStreak, switched: !objective, reason: objective ? "builder_hold" : "builder_objective_missing" };
+  }
+  if (greenStreak < threshold) {
+    return { lane: "polish", greenStreak, switched: false, reason: `green_streak_below_threshold:${greenStreak}/${threshold}` };
+  }
+  if (!objective) {
+    return { lane: "polish", greenStreak, switched: false, reason: "builder_objective_missing" };
+  }
+  return { lane: "builder", greenStreak, switched: true, reason: `green_streak_promote:${greenStreak}/${threshold}` };
+};
+var applyIntentArbitration = (input) => {
+  const { base, survivalMode } = input;
+  const signals = input.signals || {};
+  const buildScore = scoreBuildLane(signals, survivalMode);
+  const polishScore = scorePolishLane(signals, survivalMode, base.humanDemand);
+  const out = { ...base };
+  if (base.ownershipMode === "owner_bound" && base.humanDemand.pending) {
+    out.runHumanTask = true;
+    out.runAutonomousTask = base.priorityMode === "autonomous_first" ? buildScore >= 0.5 : buildScore >= 0.65;
+    out.reason = out.runAutonomousTask ? "intent_parallel_build_and_polish" : "intent_polish_preempts_build";
+    return out;
+  }
+  if (!base.humanDemand.pending) {
+    out.runHumanTask = false;
+    out.runAutonomousTask = buildScore >= 0.45 || polishScore >= 0.45;
+    out.reason = out.runAutonomousTask ? "intent_build_or_polish_window" : "intent_hold_low_expected_value";
+    return out;
+  }
+  if (base.ownershipMode === "unbound") {
+    out.runAutonomousTask = true;
+    out.runHumanTask = true;
+    out.reason = "intent_unbound_parallel";
+  }
+  return out;
+};
+
+export {
+  createDurabilityProxyClient,
+  evaluatePromptShield,
+  evaluateObjectiveChange,
+  scoreBuildLane,
+  scorePolishLane,
+  evaluateLaneSwitch,
+  applyIntentArbitration
+};

package/dist/index.d.ts

@@ -9,7 +9,7 @@ export { MarketDiscoveryClient, MarketNeed, MarketSignal, deriveMarketNeeds, dis
 export { A as AdapterBestShotChecklistResult, a as AdapterPackKind, b as AdapterPackOptions, c as AdaptiveAdaptationPlan, d as AdaptiveExecution, e as AdaptiveFeedbackAggregate, f as AdaptivePolicyConfig, g as AdaptivePolicyDecision, h as AdaptivePolicyState, i as AdaptiveReflectionStore, j as AdaptiveTheme, k as AdaptiveVerification, l as AgentLaunchRuntimeOptions, m as AgentLaunchRuntimeResult, n as AgentResourceProvidersManifest, o as AgentReviewRuntimeOptions, p as AnalyticsPoint, q as ApiCreditProvider, r as ApiCreditProviderFactoryOptions, s as ApiCreditProviderPreset, t as ApiCreditProviderPresetInput, u as ApiResponse, B as BuybackEvent, C as CONTEXT_PACK_SECTION_ORDER, v as ContextPack, w as ContextPackBudget, x as ContextPackGateOptions, y as ContextPackGateResult, z as ContextPackInput, D as ContextPackOptions, E as ContextPackSectionKey, F as ContextPackSections, G as ContextPackState, H as DurabilityCheckpointWriteOptions, I as DurabilityProxyClientOptions, J as DurabilityRestoreDrillWriteOptions, K as ExecutionAdapter, L as ExecutionApplyResult, M as ExecutionDecisionRecord, N as ExecutionDryRunResult, O as ExecutionPostDeployVerifyResult, P as ExecutionRollbackResult, Q as ExecutionRolloutMode, R as ExecutionRunResult, S as ExecutionValidateResult, T 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 LaunchProfile, Y as LaunchReadinessInput, Z as LaunchReadinessResult, _ as LeaderboardEntry, $ as LeaderboardQuery, a0 as ListingNamingValidationOptions, a1 as ListingNamingValidationResult, a2 as ListingQuery, a3 as ListingReviewCreatePayload, a4 as ListingReviewResponsePayload, a5 as ListingVersionPayload, a6 as MarketingCampaign, a7 as MarketingLinkOptions, a8 as MemoryPingChallengeResponse, a9 as MemoryPingPayload, aa as OpenRouterCredits, ab as ProcurementCandidate, ac as ProcurementDecision, ad as ProcurementTaskProfile, ae as ProcurementWeights, af as ResourceProviderManifestEntry, ag as ResourceSnapshot, ah as ReviewGate, ai as ReviewGateRecord, aj as ReviewRequiredPayload, ak as RunAdaptiveReflectionOptions, al as RuntimeMigrationInput, am as RuntimeMigrationPlan, an as RuntimeStateSnapshot, ao as SdkAutoUpdatedRestartRequiredError, ap as SdkUpdateCheckOptions, aq as SdkUpdatePolicyCheckOptions, ar as SdkUpdateRequiredError, as as SdkUpdateStatus, TopupDecision, TopupRequest, TreasuryLedgerEvent, TreasuryPolicy, TreasuryPolicyV1, TreasuryState, at as VIBEIAO_IDL, au as VibeClient, av as VibeClientOptions, aw as VibeRegistry, ax as aggregateFeedbackSignals, ay as assertLaunchReady, az as assertSurvivalProvidersConfigured, aA as buildAdaptivePlan, aB as buildBadgeMarkdown, aC as buildClaimMessage, aD as buildDecisionRecord, aE as buildJupiterSwapUrl, aF as buildListingVersionMessage, aG as buildMemoryPingMessage, aH as buildOwnerTransferMessage, aI as buildProcurementPrompt, aJ as buildRaydiumSwapUrl, aK as buildReviewPrompt, aL as buildReviewRequired, aM as buildReviewResponseMessage, aN as buildRuntimeMigrationPlan, aO as buildSdkUpdateCommand, aP as buildShareCopy, aQ as buildShareLink, aR as buildTradeLinks, buildTreasuryLedgerEvent, aS as checkForSdkUpdate, aT as checkForSdkUpdatePolicy, aU as compareVersions, aV as createApiCreditProvider, aW as createApiCreditProviders, aX as createApiCreditProvidersFromManifest, aY as createCampaign, aZ as createContextPack, a_ as createCustomAdapter, a$ as createDurabilityProxyClient, b0 as createServiceApiAdapter, createTreasuryPolicy, b1 as createWebBundledAdapter, b2 as createWebStaticAdapter, b3 as createWorkflowAgentAdapter, b4 as decideProcurementForTask, b5 as estimateContextPackTokens, b6 as evaluateAdaptiveReflectionPolicy, b7 as evaluateContextPackGate, b8 as evaluateLaunchReadiness, evaluateTopupRequest, b9 as getResourceSnapshot, ba as normalizeListingText, bb as rankListingsForTask, bc as runAdapterBestShotChecklist, bd as runAdaptiveReflectionCycle, be as runAgentLaunchRuntime, bf as runAgentLaunchRuntimeCycle, bg as runAgentReviewRuntimeCycle, bh as runExecutionAdapter, bi as sanitizeListingNaming, bj as scoreListingForTask, bk as shouldAnnounceStateChange, treasuryStateFromSnapshot, bl as validateContextPack, bm as validateListingNaming, validateTreasuryPolicy, bn as verifyAdaptiveExecutionReadiness } 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 { I as IntentSignals, O as ObjectiveChangeProposal, a as ObjectiveChangeSourceTrust, b as ObjectiveGuardDecision, c as ObjectiveGuardPolicy, P as PromptShieldDecision, d as PromptShieldFlag, e as PromptShieldInput, f as PromptShieldPolicy, g as PromptShieldRisk, h as PromptShieldTrustLevel, i as applyIntentArbitration, j as evaluateObjectiveChange, k as evaluatePromptShield, s as scoreBuildLane, l as scorePolishLane } from './agentLoop-Dn6aMtRD.js';
+export { I as IntentSignals, L as LaneMode, a as LaneSwitchDecision, O as ObjectiveChangeProposal, b as ObjectiveChangeSourceTrust, c as ObjectiveGuardDecision, d as ObjectiveGuardPolicy, P as PromptShieldDecision, e as PromptShieldFlag, f as PromptShieldInput, g as PromptShieldPolicy, h as PromptShieldRisk, i as PromptShieldTrustLevel, j as applyIntentArbitration, k as evaluateLaneSwitch, l as evaluateObjectiveChange, m as evaluatePromptShield, s as scoreBuildLane, n as scorePolishLane } from './agentLoop-BPdoysXH.js';
 export { fetchSolBalance, fetchTokenBalance, fetchTokenBalances } from './solana.js';
 import './compoundingMemory.js';
 import '@coral-xyz/anchor';

package/dist/index.js

@@ -19,11 +19,12 @@ import {
 import {
   applyIntentArbitration,
   createDurabilityProxyClient,
+  evaluateLaneSwitch,
   evaluateObjectiveChange,
   evaluatePromptShield,
   scoreBuildLane,
   scorePolishLane
-} from "./chunk-WFOLCIJC.js";
+} from "./chunk-N3J6WQ72.js";
 import {
   SelfReliance,
   createAutoSelfReliance,
@@ -1111,7 +1112,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.50" ? "0.1.50" : "0.1.4";
+var DEFAULT_SDK_VERSION = "0.1.51" ? "0.1.51" : "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;
@@ -2299,6 +2300,7 @@ export {
   evaluateAdaptiveReflectionPolicy,
   evaluateContextPackGate,
   evaluateEscapeHatch,
+  evaluateLaneSwitch,
   evaluateLaunchReadiness,
   evaluateObjectiveChange,
   evaluateOutcomeBoundRun,

package/dist/treasuryGuardian.d.ts

@@ -8,7 +8,7 @@ import './survivalEscapeHatch.js';
 import './marketDiscovery.js';
 import './outcomeBoundFlow.js';
 import './strictMemoryRuntime.js';
-import './agentLoop-Dn6aMtRD.js';
+import './agentLoop-BPdoysXH.js';
 import './solana.js';
 import './compoundingMemory.js';
 import '@coral-xyz/anchor';
@@ -1474,7 +1474,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.51",
+  "version": "0.1.52",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {