entroly-wasm 1.0.78 → 1.0.80

package/data/tuning_defaults.json

@@ -1,24 +1,24 @@
 {
   "_comment": "Shipped baseline scoring config applied by the engine on startup across pip / MCP / npm. Runtime self-improvement (PRISM online + task-profile feedback journal) adapts from here per session. Maintainers regenerate these values with `entroly autotune` and commit them so the improvement reaches all installed users on the next release. (Distinct from the gitignored, locally-mutated bench/tuning_config.json.)",
   "weights": {
-    "recency": 0.30,
+    "recency": 0.3,
     "frequency": 0.25,
     "semantic_sim": 0.25,
-    "entropy": 0.20
+    "entropy": 0.2
   },
   "decay": {
     "half_life_turns": 15,
     "min_relevance_threshold": 0.05
   },
   "knapsack": {
-    "exploration_rate": 0.10
+    "exploration_rate": 0.0
   },
   "dedup": {
     "hamming_threshold": 3
   },
   "ios": {
-    "skeleton_info_factor": 0.70,
+    "skeleton_info_factor": 0.7,
     "reference_info_factor": 0.15,
-    "diversity_floor": 0.10
+    "diversity_floor": 0.1
   }
 }

package/index.d.ts

@@ -121,3 +121,11 @@ export function createContextReceipt(
 
 export function renderContextReceipt(receipt: Record<string, unknown>): string;
 export function explainReceiptOmission(receipt: Record<string, unknown>, chunkId: string): string;
+
+export * from "./js/trust_engine";
+export * from "./js/work_graph";
+export * from "./js/work_graph_repo";
+export * from "./js/work_graph_store";
+export * from "./js/work_context_snapshot_store";
+export * from "./js/work_graph_continuity";
+export * from "./js/continuity_contracts";

package/index.js

@@ -11,13 +11,19 @@
 //   npx entroly-wasm serve
 
 let WasmEntrolyEngine;
+let WasmWorkGraph;
+let WasmTrustEngine;
 let classifyQueryTransitionRust;
 let rewardWeightedOptimizeRust;
 let optimizeTaskProfilesRust;
 let classifyLearningQueryRust;
+let wasmExports = {};
 function bindWasmExports(mod) {
+  wasmExports = mod;
   ({
     WasmEntrolyEngine,
+    WasmWorkGraph,
+    WasmTrustEngine,
     classify_query_transition: classifyQueryTransitionRust,
     reward_weighted_optimize: rewardWeightedOptimizeRust,
     optimize_task_profiles: optimizeTaskProfilesRust,
@@ -39,11 +45,24 @@ function buildAndBindWasm() {
 try {
   bindWasmExports(require('./pkg/entroly_wasm'));
   if (
+    !WasmWorkGraph ||
+    !WasmTrustEngine ||
     !classifyQueryTransitionRust ||
     !rewardWeightedOptimizeRust ||
     !optimizeTaskProfilesRust ||
-    !classifyLearningQueryRust
+    !classifyLearningQueryRust ||
+    !wasmExports.contextReceiptBuildJSON ||
+    !wasmExports.verifiedContextSnapshotVerifyBytes ||
+    !wasmExports.recoveryHandleBuildJSON ||
+    !wasmExports.memoryRecordBuildJSON ||
+    !wasmExports.routingDecisionBuildJSON ||
+    !wasmExports.modelExecutionOutcomeBuildJSON ||
+    !wasmExports.verificationRecordBuildJSON ||
+    !wasmExports.workContinuationProofBuildJSON
   ) {
+    // A source checkout can contain an older generated pkg/ directory. Treat
+    // a missing Work Graph export exactly like any other stale native surface
+    // and rebuild before loading the high-level JS wrapper.
     buildAndBindWasm();
   }
 } catch (err) {
@@ -65,6 +84,34 @@ const { ValueTracker, EVOLUTION_TAX_RATE, estimateCost } = require('./js/value_t
 const { exportPromoted: exportAgentSkills } = require('./js/agentskills_export');
 const { TelegramGateway, DiscordGateway, SlackGateway } = require('./js/gateways');
 const { VaultObserver } = require('./js/vault_observer');
+const { TrustEngine } = require('./js/trust_engine');
+const {
+  WorkGraph,
+  RepositoryDiscoveryError,
+  discoverRepositoryIdentity,
+  discoverRepositoryObservation,
+} = require('./js/work_graph');
+const {
+  WorkGraphLockTimeout,
+  WorkGraphStateError,
+  WorkGraphStore,
+  WorkGraphStoreError,
+} = require('./js/work_graph_store');
+const {
+  CONTEXT_SNAPSHOT_TOKEN_PREFIX,
+  DEFAULT_MAX_CONTEXT_BYTES,
+  DEFAULT_MAX_SNAPSHOTS,
+  DEFAULT_MAX_TOTAL_BYTES,
+  WorkContextSnapshotError,
+  WorkContextSnapshotStore,
+  verifyCanonicalSnapshotBytes,
+} = require('./js/work_context_snapshot_store');
+const {
+  MAX_RESUME_EVIDENCE,
+  handoffRepository,
+  handoffRepositoryWithProof,
+  resumeRepository,
+} = require('./js/work_graph_continuity');
 const {
   createContextReceipt,
   explainReceiptOmission,
@@ -72,6 +119,13 @@ const {
   renderContextReceipt,
   selectReceiptContext,
 } = require('./js/context_receipts');
+const {
+  continuationProofState,
+  createModelExecutionOutcome,
+  createRoutingDecision,
+  createVerificationRecord,
+  verificationFreshness,
+} = require('./js/continuity_contracts');
 const {
   createEntrolyMiddleware,
   optimizeAnthropicParams,
@@ -114,6 +168,10 @@ function classifyLearningQuery(...args) {
 }
 
 module.exports = {
+  // The TypeScript surface re-exports the generated bindings. Mirror that at
+  // runtime so package-root imports and `index.d.ts` describe the same API.
+  ...wasmExports,
+
   // Core engine (wasm)
   EntrolyEngine: WasmEntrolyEngine,
   WasmEntrolyEngine,
@@ -122,6 +180,30 @@ module.exports = {
   optimizeTaskProfiles,
   classifyLearningQuery,
 
+  // Shared Rust evidence-bounded Trust Engine.
+  TrustEngine,
+
+  // Shared Rust AI Work Graph with Node-only repository/persistence glue.
+  WorkGraph,
+  RepositoryDiscoveryError,
+  discoverRepositoryIdentity,
+  discoverRepositoryObservation,
+  WorkGraphStore,
+  WorkGraphStoreError,
+  WorkGraphLockTimeout,
+  WorkGraphStateError,
+  WorkContextSnapshotStore,
+  WorkContextSnapshotError,
+  verifyCanonicalSnapshotBytes,
+  CONTEXT_SNAPSHOT_TOKEN_PREFIX,
+  DEFAULT_MAX_CONTEXT_BYTES,
+  DEFAULT_MAX_SNAPSHOTS,
+  DEFAULT_MAX_TOTAL_BYTES,
+  MAX_RESUME_EVIDENCE,
+  handoffRepository,
+  handoffRepositoryWithProof,
+  resumeRepository,
+
   // Configuration
   EntrolyConfig,
 
@@ -179,4 +261,11 @@ module.exports = {
   createContextReceipt,
   renderContextReceipt,
   explainReceiptOmission,
+
+  // Canonical evidence-backed execution and continuation contracts.
+  continuationProofState,
+  createModelExecutionOutcome,
+  createRoutingDecision,
+  createVerificationRecord,
+  verificationFreshness,
 };

package/js/continuity_contracts.d.ts

@@ -0,0 +1,86 @@
+export interface RoutingDecisionInput {
+  repository_id: string;
+  task_id: string;
+  workstream_id: string;
+  provider: string;
+  model: string;
+  runtime: string;
+  context_budget_tokens: number;
+  policy_version: string;
+  reason_codes?: string[];
+  feature_commitments?: string[];
+  fallback_route_ids?: string[];
+  receipt_id?: string;
+  evidence_ids?: string[];
+  decided_at_ms: number;
+}
+
+export type RoutingDecision = RoutingDecisionInput & {
+  schema_version: number;
+  routing_id: string;
+  decision_commitment: string;
+};
+
+export interface ModelExecutionOutcomeInput {
+  routing_id: string;
+  repository_id: string;
+  task_id: string;
+  workstream_id: string;
+  provider: string;
+  model: string;
+  runtime: string;
+  receipt_id?: string;
+  request_commitment?: string;
+  response_commitment?: string;
+  state: "succeeded" | "failed" | "cancelled" | "unknown";
+  verification_state: "passed" | "failed" | "skipped" | "unknown" | "stale";
+  latency_ms?: number;
+  input_tokens?: number;
+  output_tokens?: number;
+  cost_micro_usd?: number;
+  error_code?: string;
+  evidence_ids?: string[];
+  completed_at_ms: number;
+}
+
+export type ModelExecutionOutcome = ModelExecutionOutcomeInput & {
+  schema_version: number;
+  outcome_id: string;
+  outcome_commitment: string;
+};
+
+export interface VerificationRecordInput {
+  repository_id: string;
+  subject_id: string;
+  subject_commitment: string;
+  verified_repository_commitment: string;
+  verdict: "passed" | "failed" | "skipped" | "unknown";
+  evidence_ids?: string[];
+  dependency_commitments?: string[];
+  observed_at_ms: number;
+  valid_until_ms?: number;
+}
+
+export type VerificationRecord = VerificationRecordInput & {
+  schema_version: number;
+  verification_id: string;
+  record_commitment: string;
+};
+
+export function createRoutingDecision(input: RoutingDecisionInput): RoutingDecision;
+export function createModelExecutionOutcome(
+  input: ModelExecutionOutcomeInput,
+): ModelExecutionOutcome;
+export function createVerificationRecord(input: VerificationRecordInput): VerificationRecord;
+export function verificationFreshness(
+  record: VerificationRecord | string,
+  currentRepositoryCommitment: string,
+  nowMs: number,
+  invalidatedCommitments?: string[],
+): "current" | "stale" | "invalidated" | "unknown";
+export function continuationProofState(
+  proof: Record<string, unknown> | string,
+  repositoryId: string,
+  graphRevision: number,
+  graphCommitment: string,
+): "valid" | "stale" | "invalid";

package/js/continuity_contracts.js

@@ -0,0 +1,81 @@
+'use strict';
+
+// Ergonomic Node facade over the canonical Rust continuity contracts. This
+// module performs transport conversion and JavaScript safe-integer checks only;
+// identity, commitments, cross-field validation and freshness remain in Rust.
+
+function native() {
+  return require('../pkg/entroly_wasm');
+}
+
+function asObject(value) {
+  return typeof value === 'string' ? JSON.parse(value) : value;
+}
+
+function checkedInput(input, integerFields) {
+  const value = { ...(input || {}) };
+  for (const field of integerFields) {
+    if (value[field] == null) continue;
+    const number = Number(value[field]);
+    if (!Number.isSafeInteger(number) || number < 0) {
+      throw new TypeError(`${field} must be a JavaScript-safe integer >= 0`);
+    }
+    value[field] = number;
+  }
+  return JSON.stringify(value);
+}
+
+function createRoutingDecision(input) {
+  return JSON.parse(native().routingDecisionBuildJSON(checkedInput(input, [
+    'context_budget_tokens', 'decided_at_ms',
+  ])));
+}
+
+function createModelExecutionOutcome(input) {
+  return JSON.parse(native().modelExecutionOutcomeBuildJSON(checkedInput(input, [
+    'latency_ms', 'input_tokens', 'output_tokens', 'cost_micro_usd', 'completed_at_ms',
+  ])));
+}
+
+function createVerificationRecord(input) {
+  return JSON.parse(native().verificationRecordBuildJSON(checkedInput(input, [
+    'observed_at_ms', 'valid_until_ms',
+  ])));
+}
+
+function verificationFreshness(
+  record,
+  currentRepositoryCommitment,
+  nowMs,
+  invalidatedCommitments = [],
+) {
+  if (!Number.isSafeInteger(nowMs) || nowMs < 0) {
+    throw new TypeError('nowMs must be a JavaScript-safe integer >= 0');
+  }
+  return native().verificationRecordFreshness(
+    JSON.stringify(asObject(record)),
+    String(currentRepositoryCommitment),
+    nowMs,
+    JSON.stringify(invalidatedCommitments),
+  );
+}
+
+function continuationProofState(proof, repositoryId, graphRevision, graphCommitment) {
+  if (!Number.isSafeInteger(graphRevision) || graphRevision < 0) {
+    throw new TypeError('graphRevision must be a JavaScript-safe integer >= 0');
+  }
+  return native().workContinuationProofState(
+    JSON.stringify(asObject(proof)),
+    String(repositoryId),
+    graphRevision,
+    String(graphCommitment),
+  );
+}
+
+module.exports = {
+  continuationProofState,
+  createModelExecutionOutcome,
+  createRoutingDecision,
+  createVerificationRecord,
+  verificationFreshness,
+};

package/js/trust_engine.d.ts

@@ -0,0 +1,18 @@
+export type EvidenceSupportStatus = "supported" | "unsupported" | "unknown";
+
+export interface ClaimEvidenceAssessment {
+  status: EvidenceSupportStatus;
+  support_density: number;
+  unsupported_fraction: number;
+  contradiction_fraction: number;
+  evidence_commitment: string;
+}
+
+export type FileCriticality = "normal" | "important" | "critical" | "safety";
+
+export class TrustEngine {
+  constructor(profile?: "rag" | "qa" | "summarization" | "dialogue" | "fact_check" | "default" | string);
+  assessClaim(evidence: string, claim: string): ClaimEvidenceAssessment;
+  fileCriticality(path: string): FileCriticality;
+  hasSafetySignal(content: string): boolean;
+}

package/js/trust_engine.js

@@ -0,0 +1,31 @@
+'use strict';
+
+// Thin Node transport over the shared Rust/WASM Trust Engine. All profile,
+// scoring, commitment, and guardrail semantics stay in entroly-engine.
+function wasmTrustEngine() {
+  const { WasmTrustEngine } = require('../pkg/entroly_wasm');
+  if (!WasmTrustEngine) {
+    throw new Error('Rust Trust Engine is unavailable; rebuild entroly-wasm');
+  }
+  return WasmTrustEngine;
+}
+
+class TrustEngine {
+  constructor(profile = 'rag') {
+    this._inner = new (wasmTrustEngine())(String(profile));
+  }
+
+  assessClaim(evidence, claim) {
+    return JSON.parse(this._inner.assessClaimJSON(String(evidence), String(claim)));
+  }
+
+  fileCriticality(path) {
+    return this._inner.fileCriticality(String(path));
+  }
+
+  hasSafetySignal(content) {
+    return Boolean(this._inner.hasSafetySignal(String(content)));
+  }
+}
+
+module.exports = { TrustEngine };

package/js/work_context_snapshot_store.d.ts

@@ -0,0 +1,43 @@
+import { WorkGraphStore } from "./work_graph_store";
+
+export interface WorkContextSnapshotStoreOptions {
+  maxContextBytes?: number;
+  maxSnapshots?: number;
+  maxTotalBytes?: number;
+}
+
+export interface VerifiedContextSnapshotBytes {
+  payload: Record<string, unknown>;
+  commitment: string;
+  bytes: Uint8Array;
+}
+
+export class WorkContextSnapshotError extends Error {}
+
+export function verifyCanonicalSnapshotBytes(
+  value: Uint8Array | string,
+  expectedCommitment?: string | null,
+  maxBytes?: number,
+): VerifiedContextSnapshotBytes;
+
+export class WorkContextSnapshotStore {
+  constructor(graphStore: WorkGraphStore, options?: WorkContextSnapshotStoreOptions);
+
+  readonly graphStore: WorkGraphStore;
+  readonly maxContextBytes: number;
+  readonly maxSnapshots: number;
+  readonly maxTotalBytes: number;
+  readonly contextDir: string;
+
+  static tokenForCommitment(commitment: string): string;
+  static digestFromToken(token: string): string;
+
+  putCanonicalBytes(value: Uint8Array | string, expectedCommitment: string): string;
+  getCanonicalBytes(token: string): Uint8Array;
+  getJSON(token: string): Record<string, unknown>;
+}
+
+export const CONTEXT_SNAPSHOT_TOKEN_PREFIX: "wctx1.";
+export const DEFAULT_MAX_CONTEXT_BYTES: number;
+export const DEFAULT_MAX_SNAPSHOTS: number;
+export const DEFAULT_MAX_TOTAL_BYTES: number;