@vibeiao/sdk 0.1.61 → 0.1.63

package/dist/agentLoop-BY_j-iIC.d.ts

@@ -0,0 +1,378 @@
+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 AgentAutonomousTaskKind = 'polish_existing_product' | 'build_new_product';
+type AgentToolFirstDecision = {
+    hasUsefulExistingTool: boolean;
+    shouldBuildNew: boolean;
+    reason: string;
+    toolId?: string;
+};
+type AgentResearchSnapshot = {
+    generatedAt?: string;
+    summary?: string;
+    recommendation?: string;
+};
+type AgentBespokeSnapshot = {
+    bespokeKey?: string;
+    divergedFromTemplate?: boolean;
+    noveltyScore?: number;
+};
+type AgentWorkArbitrationDecision = {
+    ownershipMode: AgentOwnershipMode;
+    priorityMode: AgentPriorityMode;
+    rolloutMode: 'observe' | 'enforce';
+    humanDemand: AgentHumanDemand;
+    runHumanTask: boolean;
+    runAutonomousTask: boolean;
+    lane?: LaneMode;
+    laneDecision?: LaneSwitchDecision;
+    proactiveBuildSuggested?: boolean;
+    autonomousTaskKind?: AgentAutonomousTaskKind;
+    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;
+        };
+        researchGate?: {
+            enabled?: boolean;
+            maxAgeMs?: number;
+            resolveSnapshot?: (ctx: {
+                snapshot: ResourceSnapshot;
+                survivalMode: SurvivalMode;
+                humanDemand: AgentHumanDemand;
+            }) => Promise<AgentResearchSnapshot | null> | AgentResearchSnapshot | null;
+        };
+        bespokeGate?: {
+            enabled?: boolean;
+            minNoveltyScore?: number;
+            resolveSnapshot?: (ctx: {
+                snapshot: ResourceSnapshot;
+                survivalMode: SurvivalMode;
+                humanDemand: AgentHumanDemand;
+            }) => Promise<AgentBespokeSnapshot | null> | AgentBespokeSnapshot | null;
+        };
+        resolveSignals?: (ctx: {
+            snapshot: ResourceSnapshot;
+            survivalMode: SurvivalMode;
+            humanDemand: AgentHumanDemand;
+        }) => Promise<IntentSignals | null> | IntentSignals | null;
+    };
+    onAutonomous?: (ctx: AgentLoopContext, task?: {
+        kind: AgentAutonomousTaskKind;
+    }) => 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;
+    researchSnapshot?: AgentResearchSnapshot;
+    bespokeSnapshot?: AgentBespokeSnapshot;
+    toolFirstDecision?: AgentToolFirstDecision;
+    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;
+    toolFirst?: {
+        enabled?: boolean;
+        mode?: 'observe' | 'enforce';
+        resolveDecision?: (ctx: {
+            snapshot: ResourceSnapshot;
+            survivalMode: SurvivalMode;
+            humanDemand: AgentHumanDemand;
+        }) => Promise<AgentToolFirstDecision | null> | AgentToolFirstDecision | null;
+    };
+};
+/**
+ * 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 AgentAutonomousTaskKind as A, type AgentLoopPromptShieldConfig as B, type AgentLoopStrictMemoryConfig as C, type AgentOwnershipMode as D, type AgentPriorityMode as E, type AgentResearchSnapshot as F, type AgentToolFirstDecision as G, type AgentWorkArbitrationDecision as H, type IntentSignals as I, createAgentLoop as J, 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 AgentBespokeSnapshot as o, type AgentHumanDemand as p, type AgentLoopAutonomyConfig as q, type AgentLoopConfig as r, scoreBuildLane as s, type AgentLoopContext as t, type AgentLoopDurabilityConfig as u, type AgentLoopEscapeHatchConfig as v, type AgentLoopEscapeHatchInput as w, type AgentLoopHooks as x, type AgentLoopMemoryConfig as y, type AgentLoopObjectiveGuardConfig 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 AgentAutonomousTaskKind, o as AgentBespokeSnapshot, p as AgentHumanDemand, q as AgentLoopAutonomyConfig, r as AgentLoopConfig, t as AgentLoopContext, u as AgentLoopDurabilityConfig, v as AgentLoopEscapeHatchConfig, w as AgentLoopEscapeHatchInput, x as AgentLoopHooks, y as AgentLoopMemoryConfig, z as AgentLoopObjectiveGuardConfig, B as AgentLoopPromptShieldConfig, C as AgentLoopStrictMemoryConfig, D as AgentOwnershipMode, E as AgentPriorityMode, F as AgentResearchSnapshot, G as AgentWorkArbitrationDecision, H as createAgentLoop } from './agentLoop-DAkl2g28.js';
+export { A as AgentAutonomousTaskKind, o as AgentBespokeSnapshot, p as AgentHumanDemand, q as AgentLoopAutonomyConfig, r as AgentLoopConfig, t as AgentLoopContext, u as AgentLoopDurabilityConfig, v as AgentLoopEscapeHatchConfig, w as AgentLoopEscapeHatchInput, x as AgentLoopHooks, y as AgentLoopMemoryConfig, z as AgentLoopObjectiveGuardConfig, B as AgentLoopPromptShieldConfig, C as AgentLoopStrictMemoryConfig, D as AgentOwnershipMode, E as AgentPriorityMode, F as AgentResearchSnapshot, G as AgentToolFirstDecision, H as AgentWorkArbitrationDecision, J as createAgentLoop } from './agentLoop-BY_j-iIC.js';

package/dist/agentLoop.js

@@ -77,6 +77,8 @@ var createAgentLoop = (config) => {
   const researchGateMaxAgeMs = config.autonomy?.intentPolicy?.researchGate?.maxAgeMs ?? 6 * 36e5;
   const bespokeGateEnabled = config.autonomy?.intentPolicy?.bespokeGate?.enabled ?? true;
   const bespokeGateMinNovelty = config.autonomy?.intentPolicy?.bespokeGate?.minNoveltyScore ?? 0.2;
+  const toolFirstEnabled = config.toolFirst?.enabled ?? true;
+  const toolFirstMode = config.toolFirst?.mode ?? "observe";
   let laneState = { lane: "polish", greenStreak: 0 };
   const strictMemoryUpgrade = upgradeToStrictMemoryRuntimePreset({
     current: strictMemoryPreset,
@@ -297,6 +299,16 @@ var createAgentLoop = (config) => {
     if (!bespokeKey && typeof divergedFromTemplate === "undefined" && typeof noveltyScore === "undefined") return null;
     return { bespokeKey, divergedFromTemplate, noveltyScore };
   };
+  const resolveToolFirstDecision = async (input) => {
+    const fromConfig = await config.toolFirst?.resolveDecision?.(input);
+    if (fromConfig) return fromConfig;
+    const raw = input.snapshot;
+    const hasUsefulExistingTool = asBoolean(raw.hasUsefulExistingTool) ?? asBoolean(raw.discoveredUsefulTool) ?? false;
+    const shouldBuildNew = asBoolean(raw.shouldBuildNew) ?? !hasUsefulExistingTool;
+    const reason = typeof raw.toolDecisionReason === "string" ? raw.toolDecisionReason : hasUsefulExistingTool ? "tool_available_use_first" : "no_suitable_tool_build_allowed";
+    const toolId = typeof raw.toolId === "string" ? raw.toolId : void 0;
+    return { hasUsefulExistingTool, shouldBuildNew, reason, toolId };
+  };
   const runOnce = async () => {
     try {
       const memoryUpgrade = await ensureMemoryUpgrade();
@@ -436,6 +448,7 @@ var createAgentLoop = (config) => {
       arbitrationBase.autonomousTaskKind = arbitrationBase.runAutonomousTask && !humanDemand.pending ? "build_new_product" : "polish_existing_product";
       const researchSnapshot = await resolveResearchSnapshot({ snapshot, survivalMode, humanDemand });
       const bespokeSnapshot = await resolveBespokeSnapshot({ snapshot, survivalMode, humanDemand });
+      const toolFirstDecision = toolFirstEnabled ? await resolveToolFirstDecision({ snapshot, survivalMode, humanDemand }) : null;
       const ctx = {
         snapshot,
         survivalState,
@@ -456,6 +469,7 @@ var createAgentLoop = (config) => {
         laneDecision,
         researchSnapshot: researchSnapshot || void 0,
         bespokeSnapshot: bespokeSnapshot || void 0,
+        toolFirstDecision: toolFirstDecision || void 0,
         timestamp
       };
       if (hooks.onCycle) await hooks.onCycle(ctx);
@@ -512,6 +526,9 @@ var createAgentLoop = (config) => {
           throw new Error("bespoke_gate_blocked:novelty_below_threshold");
         }
       }
+      if (toolFirstEnabled && toolFirstMode === "enforce" && ctx.toolFirstDecision?.hasUsefulExistingTool && ctx.toolFirstDecision?.shouldBuildNew && ctx.workArbitration?.runAutonomousTask && ctx.workArbitration?.autonomousTaskKind === "build_new_product") {
+        throw new Error("tool_first_gate_blocked:use_existing_tool_before_building_new");
+      }
       if (autonomyEnabled && config.autonomy?.onAutonomous && rolloutMode === "enforce") {
         if (ctx.workArbitration?.runHumanTask) await runHumanTask();
         if (ctx.workArbitration?.runAutonomousTask) await runAutonomousTask();

package/dist/chunk-AEFR7F7O.js

@@ -0,0 +1,154 @@
+// src/socialProtocol.ts
+var clampScore = (score) => {
+  if (!Number.isFinite(score)) return 0;
+  return Math.max(0, Math.min(100, Math.round(score)));
+};
+var stableStringify = (value) => {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map((x) => stableStringify(x)).join(",")}]`;
+  const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
+};
+var hashString = (value) => {
+  let hash = 5381;
+  for (let i = 0; i < value.length; i += 1) hash = (hash << 5) + hash + value.charCodeAt(i);
+  return `h${(hash >>> 0).toString(16).padStart(8, "0")}`;
+};
+var deriveIdempotencyKey = (message, sanitizedPayload) => {
+  if (message.idempotencyKey && message.idempotencyKey.trim()) return message.idempotencyKey.trim();
+  return hashString(stableStringify({
+    fromAgentId: message.fromAgentId,
+    toAgentId: message.toAgentId,
+    topic: message.topic,
+    scope: message.scope,
+    payload: sanitizedPayload
+  }));
+};
+var computeEvidenceHash = (message, sanitizedPayload, idempotencyKey, policyVersion) => hashString(stableStringify({
+  fromAgentId: message.fromAgentId,
+  toAgentId: message.toAgentId,
+  scope: message.scope,
+  topic: message.topic,
+  sentAtIso: message.sentAtIso,
+  payload: sanitizedPayload,
+  idempotencyKey,
+  policyVersion
+}));
+var createAgentBuilderProfile = (input) => ({
+  ...input,
+  capabilityTags: [...new Set((input.capabilityTags || []).map((tag) => String(tag).trim()).filter(Boolean))],
+  reliabilityScore: clampScore(input.reliabilityScore)
+});
+var createPrivacyPolicy = (input) => ({
+  allowScopes: [...new Set(input.allowScopes || [])],
+  blockedKeys: [...new Set((input.blockedKeys || []).map((k) => k.trim()).filter(Boolean))],
+  requireCapabilityMatch: input.requireCapabilityMatch?.map((k) => k.trim()).filter(Boolean) || [],
+  policyVersion: (input.policyVersion || "v1").trim() || "v1"
+});
+var sanitizePayload = (payload, blockedKeys) => {
+  const blocked = new Set(blockedKeys.map((k) => k.toLowerCase()));
+  return Object.fromEntries(
+    Object.entries(payload).filter(([key]) => !blocked.has(key.toLowerCase()))
+  );
+};
+var canAgentsExchangeInfo = (from, to, message, policy) => {
+  if (!policy.allowScopes.includes(message.scope)) return { ok: false, reason: "scope_not_allowed" };
+  if (policy.requireCapabilityMatch && policy.requireCapabilityMatch.length > 0) {
+    const fromSet = new Set(from.capabilityTags.map((t) => t.toLowerCase()));
+    const toSet = new Set(to.capabilityTags.map((t) => t.toLowerCase()));
+    const required = policy.requireCapabilityMatch.map((t) => t.toLowerCase());
+    const matched = required.some((tag) => fromSet.has(tag) && toSet.has(tag));
+    if (!matched) return { ok: false, reason: "capability_mismatch" };
+  }
+  return { ok: true };
+};
+var createSignedSocialEnvelope = (message, policy, signingSecret) => {
+  const sanitizedPayload = sanitizePayload(message.payload, policy.blockedKeys);
+  const idempotencyKey = deriveIdempotencyKey(message, sanitizedPayload);
+  const policyVersion = policy.policyVersion || "v1";
+  const messageWithIdempotency = { ...message, idempotencyKey };
+  const evidenceHash = computeEvidenceHash(
+    messageWithIdempotency,
+    sanitizedPayload,
+    idempotencyKey,
+    policyVersion
+  );
+  const signature = hashString(`${signingSecret}|${evidenceHash}|${policyVersion}`);
+  return {
+    message: messageWithIdempotency,
+    sanitizedPayload,
+    evidenceHash,
+    signature,
+    policyVersion
+  };
+};
+var verifySignedSocialEnvelope = (envelope, signingSecret) => {
+  if (!envelope?.message || !envelope?.sanitizedPayload) return false;
+  const policyVersion = envelope.policyVersion || "v1";
+  const idempotencyKey = deriveIdempotencyKey(envelope.message, envelope.sanitizedPayload);
+  if (envelope.message.idempotencyKey !== idempotencyKey) return false;
+  const expectedEvidenceHash = computeEvidenceHash(
+    envelope.message,
+    envelope.sanitizedPayload,
+    idempotencyKey,
+    policyVersion
+  );
+  if (envelope.evidenceHash !== expectedEvidenceHash) return false;
+  const expected = hashString(`${signingSecret}|${expectedEvidenceHash}|${policyVersion}`);
+  return envelope.signature === expected;
+};
+var recommendRetryCount = (result) => {
+  if (result.delivered) return 0;
+  if (result.blocked && result.reason === "scope_not_allowed") return 0;
+  return 3;
+};
+var exchangeAgentInfo = (from, to, message, policy) => {
+  const gate = canAgentsExchangeInfo(from, to, message, policy);
+  const sanitizedPayload = sanitizePayload(message.payload, policy.blockedKeys);
+  const policyVersion = policy.policyVersion || "v1";
+  const messageWithIdempotency = { ...message, idempotencyKey: deriveIdempotencyKey(message, sanitizedPayload) };
+  const idempotencyKey = messageWithIdempotency.idempotencyKey;
+  const evidenceHash = computeEvidenceHash(messageWithIdempotency, sanitizedPayload, idempotencyKey, policyVersion);
+  if (!gate.ok) {
+    const blockedResult = {
+      delivered: false,
+      blocked: true,
+      reason: gate.reason,
+      state: "blocked",
+      sanitizedPayload,
+      evidenceHash,
+      idempotencyKey,
+      policyVersion,
+      retriesRecommended: 0
+    };
+    return blockedResult;
+  }
+  const deliveredResult = {
+    delivered: true,
+    blocked: false,
+    reason: void 0,
+    state: "delivered",
+    sanitizedPayload,
+    evidenceHash,
+    idempotencyKey,
+    policyVersion,
+    retriesRecommended: 0
+  };
+  return deliveredResult;
+};
+var acknowledgeExchange = (result) => ({
+  ...result,
+  state: result.blocked ? "blocked" : "acknowledged"
+});
+
+export {
+  createAgentBuilderProfile,
+  createPrivacyPolicy,
+  sanitizePayload,
+  canAgentsExchangeInfo,
+  createSignedSocialEnvelope,
+  verifySignedSocialEnvelope,
+  recommendRetryCount,
+  exchangeAgentInfo,
+  acknowledgeExchange
+};