entroly-wasm 1.0.86 → 1.0.87

package/js/auto_index.js

@@ -47,6 +47,7 @@ const SUPPORTED_EXTENSIONS = new Set([
 const SKIP_PATTERNS = new Set([
   'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'Cargo.lock',
   'poetry.lock', 'Pipfile.lock', 'composer.lock', 'Gemfile.lock',
+  'bun.lock', 'bun.lockb',
   '.DS_Store', 'thumbs.db',
 ]);
 
@@ -59,7 +60,7 @@ const BINARY_EXTENSIONS = new Set([
   '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
   '.ttf', '.otf', '.woff', '.woff2', '.eot',
   '.db', '.sqlite', '.sqlite3',
-  '.dat', '.pak', '.map',
+  '.dat', '.pak', '.map', '.lockb',
 ]);
 
 const MAX_FILE_BYTES = 50 * 1024;

package/js/cli.js

@@ -46,6 +46,16 @@ function banner() {
   return `${C.CYAN}${C.BOLD}  Entroly${C.RESET} v${VERSION} — information-theoretic context optimization`;
 }
 
+function detectRunner() {
+  const isBun = Boolean(process.versions && process.versions.bun);
+  return {
+    isBun,
+    runner: isBun ? 'bunx' : 'npx',
+    runnerPrefix: isBun ? 'bunx --bun' : 'npx',
+    runnerArgs: isBun ? ['--bun', 'entroly-wasm', '--serve'] : ['-y', 'entroly-wasm', '--serve'],
+  };
+}
+
 // ── Commands ──
 
 function cmdServe() {
@@ -151,18 +161,20 @@ function cmdInit() {
   console.log(banner());
   console.log();
 
+  const { isBun, runner, runnerPrefix, runnerArgs } = detectRunner();
+
   // Detect IDE
   const cwd = process.cwd();
   const cursorDir = path.join(cwd, '.cursor');
   const vscodeDir = path.join(cwd, '.vscode');
 
   if (fs.existsSync(cursorDir) || fs.existsSync(path.join(os.homedir(), '.cursor'))) {
-    console.log(`${C.GREEN}✓${C.RESET} Detected: ${C.BOLD}Cursor${C.RESET}`);
+    console.log(`${C.GREEN}✓${C.RESET} Detected: ${C.BOLD}Cursor${C.RESET}${isBun ? ` ${C.CYAN}(using bunx)${C.RESET}` : ''}`);
     const mcpConfig = {
       mcpServers: {
         entroly: {
-          command: 'npx',
-          args: ['-y', 'entroly-wasm', '--serve'],
+          command: runner,
+          args: runnerArgs,
         },
       },
     };
@@ -186,19 +198,19 @@ function cmdInit() {
     }
     console.log(`${C.GREEN}✓${C.RESET} Written MCP config to ${C.CYAN}${configPath}${C.RESET}`);
   } else if (fs.existsSync(vscodeDir)) {
-    console.log(`${C.GREEN}✓${C.RESET} Detected: ${C.BOLD}VS Code${C.RESET}`);
+    console.log(`${C.GREEN}✓${C.RESET} Detected: ${C.BOLD}VS Code${C.RESET}${isBun ? ` ${C.CYAN}(using bunx)${C.RESET}` : ''}`);
     console.log(`  Add to your MCP settings:`);
-    console.log(`  ${C.CYAN}"entroly": { "command": "npx", "args": ["-y", "entroly-wasm", "--serve"] }${C.RESET}`);
+    console.log(`  ${C.CYAN}"entroly": { "command": "${runner}", "args": ${JSON.stringify(runnerArgs)} }${C.RESET}`);
   } else {
     console.log(`  No IDE detected. To use Entroly as an MCP server, run:`);
-    console.log(`  ${C.CYAN}npx entroly-wasm --serve${C.RESET}`);
+    console.log(`  ${C.CYAN}${runner} ${runnerArgs.join(' ')}${C.RESET}`);
   }
 
   console.log();
   console.log(`  ${C.BOLD}Quick start:${C.RESET}`);
-  console.log(`    ${C.CYAN}npx entroly-wasm optimize 8000 "fix the auth bug"${C.RESET}`);
-  console.log(`    ${C.CYAN}npx entroly-wasm health${C.RESET}`);
-  console.log(`    ${C.CYAN}npx entroly-wasm demo${C.RESET}`);
+  console.log(`    ${C.CYAN}${runnerPrefix} entroly-wasm optimize 8000 "fix the auth bug"${C.RESET}`);
+  console.log(`    ${C.CYAN}${runnerPrefix} entroly-wasm health${C.RESET}`);
+  console.log(`    ${C.CYAN}${runnerPrefix} entroly-wasm demo${C.RESET}`);
 }
 
 function cmdDemo() {
@@ -288,8 +300,12 @@ function cmdStatus() {
   const config = new EntrolyConfig();
   const indexPath = path.join(config.checkpointDir, 'index.json.gz');
   const hasIndex = fs.existsSync(indexPath);
+  const runtime = (process.versions && process.versions.bun)
+    ? `Bun v${process.versions.bun}`
+    : `Node.js ${process.version}`;
   console.log(`${C.BOLD}Entroly Status${C.RESET}`);
   console.log(`  Version:    ${VERSION}`);
+  console.log(`  Runtime:    ${runtime}`);
   console.log(`  Engine:     Wasm (standalone)`);
   console.log(`  Index:      ${hasIndex ? C.GREEN + '✓ persistent index found' + C.RESET : C.YELLOW + '⚠ no index (run optimize first)' + C.RESET}`);
   console.log(`  Checkpoint: ${config.checkpointDir}`);
@@ -354,6 +370,7 @@ function cmdActivation(args) {
 }
 
 function cmdHelp() {
+  const { runnerPrefix } = detectRunner();
   console.log(banner());
   console.log();
   console.log(`  ${C.BOLD}Usage:${C.RESET} entroly-wasm [command] [options]`);
@@ -374,10 +391,10 @@ function cmdHelp() {
   console.log(`    ${C.CYAN}clean${C.RESET}      Clear cached state`);
   console.log();
   console.log(`  ${C.BOLD}Examples:${C.RESET}`);
-  console.log(`    ${C.GRAY}npx entroly-wasm${C.RESET}                              ${C.GRAY}# auto-detect + start${C.RESET}`);
-  console.log(`    ${C.GRAY}npx entroly-wasm optimize 8000 "fix the auth bug"${C.RESET}`);
-  console.log(`    ${C.GRAY}npx entroly-wasm health${C.RESET}`);
-  console.log(`    ${C.GRAY}npx entroly-wasm gateways${C.RESET}`);
+  console.log(`    ${C.GRAY}${runnerPrefix} entroly-wasm${C.RESET}                              ${C.GRAY}# auto-detect + start${C.RESET}`);
+  console.log(`    ${C.GRAY}${runnerPrefix} entroly-wasm optimize 8000 "fix the auth bug"${C.RESET}`);
+  console.log(`    ${C.GRAY}${runnerPrefix} entroly-wasm health${C.RESET}`);
+  console.log(`    ${C.GRAY}${runnerPrefix} entroly-wasm gateways${C.RESET}`);
 }
 
 // ── Main ──

package/js/server.js

@@ -16,9 +16,23 @@ const { WorkspaceChangeListener } = require('./workspace');
 const { SkillEngine } = require('./skills');
 const { buildRepoMap, renderRepoMapMarkdown } = require('./repo_map');
 const { ingestDiff, ingestDiagram, ingestVoice } = require('./multimodal');
+const { discoverRepositoryIdentity } = require('./work_graph_repo');
+const { WorkGraphStore } = require('./work_graph_store');
+const { handoffRepositoryWithProof, resumeRepository, currentWorkspaceCommitment,
+  continuationOutstandingRefs } = require('./work_graph_continuity');
+const { recordReview, reviews } = require('./work_graph_review');
+const { pendingHandoffs, saveHandoff } = require('./work_graph_inbox');
+const { acknowledge: acknowledgeRecovery, arm: armRecovery, requireAcknowledged } = require('./work_graph_recovery_ack');
 const path = require('path');
 const fs = require('fs');
 
+const PUBLIC_TOOLS = new Set([
+  'checkpoint_state', 'get_stats', 'optimize_context', 'recall_relevant',
+  'remember_fragment', 'resume_state', 'verify_response',
+  'work_capabilities', 'work_state', 'work_claim', 'work_resume', 'work_acknowledge_recovery',
+  'work_handoff', 'work_pending_handoffs', 'work_record_review', 'work_reviews',
+]);
+
 function resolveProjectDirectory(root, candidate = '.') {
   try {
     const realRoot = fs.realpathSync(root);
@@ -161,9 +175,19 @@ class EntrolyMCPServer {
     return resolved;
   }
 
-  // ── MCP Tool Definitions (36 tools — full parity with pip) ──
+  // ── MCP Tool Definitions ──
   get tools() {
-    return [
+    const all = [
+      // Work Graph uses the existing Rust-backed store; no second graph.
+      { name: 'work_capabilities', description: 'Check the active repository and local Work Graph review capability.', inputSchema: { type: 'object', properties: { project: { type: 'string', default: '' } } } },
+      { name: 'work_state', description: 'Inspect persisted work state without a model-generated summary.', inputSchema: { type: 'object', properties: { project: { type: 'string', default: '' } } } },
+      { name: 'work_claim', description: 'Claim an explicit task and bounded scope.', inputSchema: { type: 'object', properties: { agent_id: { type: 'string' }, task_title: { type: 'string' }, task_id: { type: 'string', default: '' }, session_id: { type: 'string', default: '' }, scope_paths: { type: 'array', items: { type: 'string' }, default: [] }, project: { type: 'string', default: '' } }, required: ['agent_id', 'task_title'] } },
+      { name: 'work_resume', description: 'Recover durable repository work and exact changed-file identities, optionally with a no-handoff proof.', inputSchema: { type: 'object', properties: { project: { type: 'string', default: '' }, workstream_id: { type: 'string', default: '' }, max_evidence: { type: 'integer', default: 128 }, to_agent: { type: 'string', default: '' } } } },
+      { name: 'work_acknowledge_recovery', description: 'Accept responsibility for one recovered work state before claiming work.', inputSchema: { type: 'object', properties: { token: { type: 'string' }, project: { type: 'string', default: '' } }, required: ['token'] } },
+      { name: 'work_handoff', description: 'Seal a graph-bound cross-agent handoff and continuation proof.', inputSchema: { type: 'object', properties: { from_agent: { type: 'string' }, to_agent: { type: 'string' }, workstream_id: { type: 'string' }, project: { type: 'string', default: '' } }, required: ['from_agent', 'to_agent', 'workstream_id'] } },
+      { name: 'work_pending_handoffs', description: 'Find compact local handoffs addressed to one agent and check source freshness.', inputSchema: { type: 'object', properties: { to_agent: { type: 'string' }, project: { type: 'string', default: '' } }, required: ['to_agent'] } },
+      { name: 'work_record_review', description: 'Record a reviewer verdict, findings, and caller-observed checks tied to the exact handoff and source state. Verdict remains an agent statement.', inputSchema: { type: 'object', properties: { handoff: { type: 'object' }, reviewer_id: { type: 'string' }, verdict: { type: 'string', enum: ['approve', 'changes_requested', 'comment'] }, findings: { type: 'array', items: { type: 'object' } }, summary: { type: 'string' }, checks: { type: 'array', items: { type: 'object' }, default: [] }, project: { type: 'string', default: '' } }, required: ['handoff', 'reviewer_id', 'verdict', 'findings', 'summary'] } },
+      { name: 'work_reviews', description: 'List recorded reviews and whether their source state is still current.', inputSchema: { type: 'object', properties: { project: { type: 'string', default: '' }, workstream_id: { type: 'string', default: '' } } } },
       // ── Core Engine Tools (12) ──
       { name: 'remember_fragment', description: 'Store a context fragment with automatic dedup and entropy scoring.', inputSchema: { type: 'object', properties: { content: { type: 'string', description: 'Text content to store' }, source: { type: 'string', description: 'Origin label (e.g. file:utils.py)', default: '' }, token_count: { type: 'integer', description: 'Token count (auto if 0)', default: 0 }, is_pinned: { type: 'boolean', description: 'Always include in optimized context', default: false } }, required: ['content'] } },
       { name: 'optimize_context', description: 'Select the optimal context subset for a token budget. Uses IOS + PRISM RL + Channel Coding.', inputSchema: { type: 'object', properties: { token_budget: { type: 'integer', description: 'Max tokens (default 128K)', default: 128000 }, query: { type: 'string', description: 'Current task/query for semantic scoring', default: '' } } } },
@@ -210,10 +234,16 @@ class EntrolyMCPServer {
       // ── Hallucination Detection Tool ──
       { name: 'verify_response', description: 'Verify an AI-generated response for hallucination. Computes entity coverage gap, hedging curvature, and entropy consistency. Returns fused_risk [0.0=safe, 1.0=hallucinated], verdict (pass/warn/flag), and flagged claims. All local — zero LLM calls.', inputSchema: { type: 'object', properties: { response: { type: 'string', description: 'The AI-generated text to verify' }, context: { type: 'string', description: 'Source context provided to the AI', default: '' }, prompt: { type: 'string', description: 'Original user prompt', default: '' } }, required: ['response'] } },
     ];
+    return process.env.ENTROLY_MCP_PROFILE === 'public'
+      ? all.filter((tool) => PUBLIC_TOOLS.has(tool.name)) : all;
   }
 
   // ── Tool Handlers (36 tools) ──
   handleTool(name, args) {
+    if (!this.tools.some((tool) => tool.name === name)) {
+      throw new Error(`Tool unavailable in this MCP profile: ${name}`);
+    }
+    if (name.startsWith('work_')) return this._handleWorkTool(name, args || {});
     this._ensureWarm(); // lazy one-time index load; instant no-op once warm
     switch (name) {
       // ── Core Engine Tools ──
@@ -555,6 +585,70 @@ class EntrolyMCPServer {
     }
   }
 
+  _handleWorkTool(name, args) {
+    const repo = this._projectDir(args.project || '');
+    switch (name) {
+      case 'work_capabilities': {
+        const identity = discoverRepositoryIdentity(repo);
+        return { status: 'ok', kind: name, runtime: 'wasm', project_root: identity.root,
+          repo_id: identity.repo_id, review_schema: 1, storage: 'local_work_graph' };
+      }
+      case 'work_state': {
+        const store = WorkGraphStore.forRepository(repo);
+        const graph = store.load();
+        return { status: 'ok', kind: name, trust: 'untrusted_recovered_work_state',
+          summary: graph.summary(), unfinished: graph.unfinished(), coordination: graph.coordination(Date.now()) };
+      }
+      case 'work_claim': {
+        const store = WorkGraphStore.forRepository(repo);
+        requireAcknowledged(store);
+        const { graph, leaseId } = store.claimWork(repo, {
+          agentId: args.agent_id, taskTitle: args.task_title, taskId: args.task_id,
+          sessionId: args.session_id, scopePaths: args.scope_paths,
+        });
+        return { status: 'ok', kind: name, lease_id: leaseId, summary: graph.summary() };
+      }
+      case 'work_resume': {
+        const target = args.to_agent == null ? '' : String(args.to_agent).trim();
+        if (target.length > 512 || target.includes('\0')) throw new Error('invalid to_agent');
+        const view = resumeRepository(repo, {
+            workstreamId: args.workstream_id, maxEvidence: args.max_evidence,
+          });
+        const store = WorkGraphStore.forRepository(repo);
+        const acknowledgement = armRecovery(store, view);
+        const continuation_proof = target ? store.reconstructedContinuationProof(
+          view.selected_workstream.node_id, target, {
+            outstanding_work_refs: continuationOutstandingRefs(view),
+            created_at_ms: Date.now(),
+          }) : undefined;
+        return { status: 'ok', kind: name, trust: 'untrusted_recovered_work_state',
+          resume: view, acknowledgement, ...(continuation_proof ? { continuation_proof } : {}) };
+      }
+      case 'work_acknowledge_recovery':
+        return { status: 'ok', kind: name,
+          ...acknowledgeRecovery(WorkGraphStore.forRepository(repo), args.token,
+            currentWorkspaceCommitment(repo)) };
+      case 'work_handoff': {
+        const bundle = handoffRepositoryWithProof(repo, {
+          fromAgent: args.from_agent, toAgent: args.to_agent, workstreamId: args.workstream_id,
+        });
+        const ref = saveHandoff(WorkGraphStore.forRepository(repo), bundle.handoff, bundle.continuation_proof);
+        return { status: 'ok', kind: name, ...bundle, handoff_ref: ref };
+      }
+      case 'work_pending_handoffs':
+        return pendingHandoffs(repo, WorkGraphStore.forRepository(repo), args.to_agent);
+      case 'work_record_review':
+        return recordReview(repo, {
+          handoff: args.handoff, reviewerId: args.reviewer_id, verdict: args.verdict,
+          findings: args.findings, summary: args.summary, checks: args.checks,
+        });
+      case 'work_reviews':
+        return reviews(repo, { workstreamId: args.workstream_id });
+      default:
+        throw new Error(`Unknown Work Graph tool: ${name}`);
+    }
+  }
+
   // ── JSON-RPC stdio transport ──
   async run() {
     this._log(`Starting Entroly MCP server v${this.config.serverVersion} (Wasm engine)`);

package/js/work_graph_continuity.js

@@ -4,6 +4,7 @@
 // Repository observation and persistence happen here; all work-state meaning
 // remains in shared Rust.
 const { enrichWorktreeContentDigests } = require('./work_graph_content_digest');
+const crypto = require('crypto');
 const { discoverRepositoryObservation } = require('./work_graph_repo');
 const { WorkGraphStateError, WorkGraphStore } = require('./work_graph_store');
 
@@ -47,6 +48,47 @@ function passiveObservation(repoPath, repositoryOptions) {
   return enrichWorktreeContentDigests(repoPath, observation);
 }
 
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function workspaceCommitment(observation) {
+  const stable = {
+    repo_id: observation.repo_id ?? null,
+    branch: observation.branch ?? null,
+    changes: observation.changes ?? null,
+    path_disclosure: observation.path_disclosure ?? null,
+  };
+  return `workspace:${crypto.createHash('sha256').update(canonical(stable), 'utf8').digest('hex')}`;
+}
+
+function currentWorkspaceCommitment(repoPath) {
+  return workspaceCommitment(passiveObservation(repoPath, {}));
+}
+
+function resumableWorkstreamId(store) {
+  const unfinished = store.load().unfinished();
+  const content = ['remaining_work', 'decision_ids', 'verification_ids', 'failure_ids', 'agent_ids'];
+  const selected = unfinished.find((item) => content.some((field) => Array.isArray(item[field]) && item[field].length))
+    || unfinished[0];
+  return selected ? selected.node_id : null;
+}
+
+function attachCurrentWorktreeChanges(view, observation, maxPaths) {
+  const paths = [...new Set((observation.changes || []).map((item) => item.path).filter(Boolean))].sort();
+  return {
+    ...view,
+    current_worktree_changed_paths: paths.slice(0, maxPaths),
+    current_worktree_change_count: paths.length,
+    current_worktree_changes_truncated: paths.length > maxPaths,
+    current_workspace_commitment: workspaceCommitment(observation),
+  };
+}
+
 function resumeRepository(repoPath = '.', options = {}) {
   // Validate before constructing the store or observing Git. Invalid recovery
   // requests must not mutate shared state.
@@ -56,8 +98,10 @@ function resumeRepository(repoPath = '.', options = {}) {
   const repositoryOptions = options.repositoryOptions || {};
 
   const store = WorkGraphStore.forRepository(repoPath, storeOptions);
-  store.submitObservation(passiveObservation(repoPath, repositoryOptions));
-  return store.resume(workstreamId, maxEvidence);
+  const observation = passiveObservation(repoPath, repositoryOptions);
+  store.submitObservation(observation);
+  const selected = workstreamId || resumableWorkstreamId(store);
+  return attachCurrentWorktreeChanges(store.resume(selected, maxEvidence), observation, maxEvidence);
 }
 
 function handoffRepository(repoPath = '.', options = {}) {
@@ -85,6 +129,8 @@ function continuationOutstandingRefs(view) {
     ? safeView.selected_workstream
     : {};
   const values = [
+    ...(Array.isArray(safeView.outstanding_work) ? safeView.outstanding_work : []),
+    ...(Array.isArray(safeView.current_worktree_changed_paths) ? safeView.current_worktree_changed_paths : []),
     ...(Array.isArray(safeView.changed_paths) ? safeView.changed_paths : []),
     ...(Array.isArray(safeView.failures) ? safeView.failures : []),
     ...(Array.isArray(selected.task_ids) ? selected.task_ids : []),
@@ -125,4 +171,6 @@ module.exports = {
   handoffRepository,
   handoffRepositoryWithProof,
   resumeRepository,
+  currentWorkspaceCommitment,
+  continuationOutstandingRefs,
 };

package/js/work_graph_inbox.js

@@ -0,0 +1,81 @@
+'use strict';
+
+// Process-local host handoff transport. Work semantics stay in the Rust graph.
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { enrichWorktreeContentDigests } = require('./work_graph_content_digest');
+const { discoverRepositoryObservation } = require('./work_graph_repo');
+const { graphSourceState, handoffGraph, sourceState } = require('./work_graph_review');
+const { WorkGraphStateError } = require('./work_graph_store');
+
+const MAX_HANDOFF_BYTES = 256 * 1024;
+const MAX_INBOX_ITEMS = 128;
+
+function inbox(store) {
+  const folder = path.join(store.repoDir, 'handoffs');
+  fs.mkdirSync(folder, { recursive: true, mode: 0o700 });
+  const stat = fs.lstatSync(folder);
+  if (stat.isSymbolicLink() || !stat.isDirectory()) {
+    throw new WorkGraphStateError('unsafe Work Graph handoff inbox');
+  }
+  if (process.platform !== 'win32') fs.chmodSync(folder, 0o700);
+  return folder;
+}
+
+function saveHandoff(store, handoff, continuationProof) {
+  if (!store.load().verifyHandoff(handoff)) {
+    throw new WorkGraphStateError('cannot save a handoff that does not match the current graph');
+  }
+  const payload = { schema_version: 1, handoff, continuation_proof: continuationProof };
+  const encoded = Buffer.from(JSON.stringify(payload));
+  if (encoded.length > MAX_HANDOFF_BYTES) {
+    throw new WorkGraphStateError('handoff exceeds local inbox size limit');
+  }
+  const name = crypto.createHash('sha256').update(String(handoff.payload_commitment)).digest('hex');
+  const folder = inbox(store);
+  const target = path.join(folder, `${name}.json`);
+  const temporary = path.join(folder, `.${name}.${crypto.randomUUID().replace(/-/g, '')}.tmp`);
+  try {
+    const fd = fs.openSync(temporary, 'wx', 0o600);
+    try { fs.writeSync(fd, encoded); fs.fsyncSync(fd); }
+    finally { fs.closeSync(fd); }
+    fs.renameSync(temporary, target);
+  } finally {
+    try { fs.unlinkSync(temporary); } catch (_) {}
+  }
+  return `handoff:${name}`;
+}
+
+function pendingHandoffs(root, store, toAgent) {
+  if (typeof toAgent !== 'string' || !toAgent.trim() || toAgent.length > 512 || toAgent.includes('\0')) {
+    throw new WorkGraphStateError('to_agent must be a bounded agent identifier');
+  }
+  const folder = inbox(store);
+  const files = fs.readdirSync(folder).filter((name) => /^[a-f0-9]{64}\.json$/.test(name))
+    .map((name) => ({ name, stat: fs.lstatSync(path.join(folder, name)) }))
+    .filter(({ stat }) => stat.isFile() && !stat.isSymbolicLink() && stat.size <= MAX_HANDOFF_BYTES)
+    .sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs).slice(0, MAX_INBOX_ITEMS);
+  const graph = store.load();
+  const current = sourceState(store.repoId,
+    enrichWorktreeContentDigests(root, discoverRepositoryObservation(root)));
+  const entries = [];
+  for (const { name } of files) {
+    try {
+      const payload = JSON.parse(fs.readFileSync(path.join(folder, name), 'utf8'));
+      const handoff = payload.handoff;
+      if (payload.schema_version !== 1 || handoff.to_agent !== toAgent) continue;
+      let valid = false;
+      try { valid = current === graphSourceState(handoffGraph(graph, handoff), store.repoId); }
+      catch (_) { /* invalid receipts stay visible as stale */ }
+      entries.push({
+        ref: `handoff:${name.slice(0, -5)}`,
+        current: valid,
+        handoff, continuation_proof: payload.continuation_proof,
+      });
+    } catch (_) { /* unreadable or invalid records are not agent instructions */ }
+  }
+  return { status: 'ok', kind: 'work_pending_handoffs', to_agent: toAgent, handoffs: entries };
+}
+
+module.exports = { pendingHandoffs, saveHandoff };

package/js/work_graph_recovery_ack.js

@@ -0,0 +1,81 @@
+'use strict';
+
+// Same local recovery marker contract as entroly/work_graph_recovery_ack.py.
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { WorkGraphStateError } = require('./work_graph_store');
+
+const MARKER = 'pending-recovery-ack.json';
+const TRUST = 'untrusted_recovered_work_state';
+
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function token(view) {
+  return `recovery:${crypto.createHash('sha256').update(canonical(view), 'utf8').digest('hex').slice(0, 32)}`;
+}
+
+function markerPath(store) { return path.join(store.repoDir, MARKER); }
+
+function pending(store) {
+  let raw;
+  try { raw = fs.readFileSync(markerPath(store), 'utf8'); }
+  catch (error) {
+    if (error.code === 'ENOENT') return null;
+    return { token: '', trust: TRUST, unknowns: ['unknown:gate-unreadable'] };
+  }
+  try {
+    const record = JSON.parse(raw);
+    if (record && typeof record === 'object' && typeof record.token === 'string') return record;
+  } catch (_) { /* malformed markers remain armed */ }
+  return { token: '', trust: TRUST, unknowns: ['unknown:gate-corrupt'] };
+}
+
+function requireAcknowledged(store) {
+  if (pending(store) !== null) {
+    throw new WorkGraphStateError('recovered work state has not been acknowledged; call work_acknowledge_recovery');
+  }
+}
+
+function arm(store, view) {
+  const value = token(view);
+  const unknowns = [...new Set([
+    'unknown:previous-agent-intent',
+    ...(Array.isArray(view.unknowns) ? view.unknowns : []),
+    ...(view.current_worktree_changes_truncated ? ['unknown:current-worktree-changes-truncated'] : []),
+  ])].sort();
+  const record = { token: value, trust: TRUST, unknowns,
+    workspace_commitment: view.current_workspace_commitment };
+  fs.mkdirSync(store.repoDir, { recursive: true, mode: 0o700 });
+  const temporary = path.join(store.repoDir, `.ack-${crypto.randomUUID()}.tmp`);
+  try {
+    const fd = fs.openSync(temporary, 'wx', 0o600);
+    try { fs.writeSync(fd, Buffer.from(JSON.stringify(record))); fs.fsyncSync(fd); }
+    finally { fs.closeSync(fd); }
+    fs.renameSync(temporary, markerPath(store));
+  } finally {
+    try { fs.unlinkSync(temporary); } catch (_) {}
+  }
+  return { ...record, required: true };
+}
+
+function acknowledge(store, supplied, workspaceCommitment) {
+  const record = pending(store);
+  if (record === null) return { acknowledged: true, already_clear: true };
+  if (!record.token || typeof supplied !== 'string' || supplied.trim() !== record.token) {
+    throw new WorkGraphStateError('acknowledgement token does not match recovered state; call work_resume again');
+  }
+  if (record.workspace_commitment && workspaceCommitment !== record.workspace_commitment) {
+    throw new WorkGraphStateError('repository changed after recovery; call work_resume again');
+  }
+  fs.unlinkSync(markerPath(store));
+  return { acknowledged: true, token: record.token, trust: TRUST, unknowns: record.unknowns };
+}
+
+module.exports = { acknowledge, arm, pending, requireAcknowledged };

package/js/work_graph_review.js

@@ -0,0 +1,222 @@
+'use strict';
+
+// Compact review records use the same Rust Work Graph event log as Python.
+// Reviewer verdicts remain untrusted agent statements.
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { enrichWorktreeContentDigests } = require('./work_graph_content_digest');
+const { discoverRepositoryIdentity, discoverRepositoryObservation } = require('./work_graph_repo');
+const { WorkGraphStore, WorkGraphStateError } = require('./work_graph_store');
+const { WorkGraph } = require('./work_graph');
+const { workGraphNodeId, workGraphEdgeId } = require('../pkg/entroly_wasm');
+
+const MAX_FINDINGS = 32;
+const MAX_FILE_BYTES = 4 * 1024 * 1024;
+const VERDICTS = new Set(['approve', 'changes_requested', 'comment']);
+const SEVERITIES = new Set(['critical', 'high', 'medium', 'low', 'note']);
+
+function bounded(value, name, limit = 1024) {
+  if (typeof value !== 'string' || !value.trim() || value.length > limit || value.includes('\0')) {
+    throw new WorkGraphStateError(`${name} must be nonempty text of at most ${limit} characters`);
+  }
+  return value.trim();
+}
+
+function observation(root) {
+  return enrichWorktreeContentDigests(root, discoverRepositoryObservation(root));
+}
+
+function sourceState(repoId, observed) {
+  const branch = observed.branch;
+  const changes = new Map((observed.changes || []).map((change) => [
+    String(change.path || ''), String(change.content_digest || ''),
+  ]));
+  return sourceStateParts(repoId, branch.name || '', branch.head_sha || '', changes);
+}
+
+function sourceStateParts(repoId, branch, head, changes) {
+  const lines = [repoId, String(branch), String(head)];
+  for (const [file, digest] of [...changes].sort(([a], [b]) => Buffer.compare(Buffer.from(a), Buffer.from(b)))) {
+    lines.push(`${file}\t${digest}`);
+  }
+  return `sha256:${crypto.createHash('sha256').update(lines.join('\n'), 'utf8').digest('hex')}`;
+}
+
+function graphSourceState(graph, repoId) {
+  for (const event of [...graph.exportState().events].reverse()) {
+    const operations = event.operations || [];
+    const repository = operations.find((op) => op.op === 'upsert_node' && op.node
+      && op.node.kind === 'repository' && Object.hasOwn(op.node.attributes || {}, 'head_sha'));
+    if (!repository) continue;
+    const changes = new Map();
+    for (const op of operations) {
+      if (op.op === 'add_evidence' && op.evidence && op.evidence.kind === 'git_status') {
+        changes.set(String(op.evidence.locator), String(op.evidence.digest || ''));
+      }
+    }
+    return sourceStateParts(repoId, repository.node.attributes.branch || '',
+      repository.node.attributes.head_sha || '', changes);
+  }
+  throw new WorkGraphStateError('handoff graph contains no repository observation');
+}
+
+function handoffGraph(graph, handoff) {
+  const revision = handoff && handoff.graph_revision;
+  if (!Number.isSafeInteger(revision) || revision < 1 || revision > graph.revision) {
+    throw new WorkGraphStateError('handoff is stale or has an invalid graph revision');
+  }
+  const historical = revision === graph.revision ? graph : new WorkGraph(graph.repoId);
+  if (historical !== graph) {
+    for (const event of graph.exportState().events.slice(0, revision)) historical.applyEvent(event);
+  }
+  if (!historical.verifyHandoff(handoff)) {
+    throw new WorkGraphStateError('handoff is stale or fails graph integrity verification');
+  }
+  return historical;
+}
+
+function checkedFindings(root, values) {
+  if (!Array.isArray(values) || values.length > MAX_FINDINGS) {
+    throw new WorkGraphStateError(`findings must be a list of at most ${MAX_FINDINGS} items`);
+  }
+  return values.map((item, index) => {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) {
+      throw new WorkGraphStateError(`findings[${index}] must be an object`);
+    }
+    const rel = bounded(item.path, 'finding path', 4096).replace(/\\/g, '/');
+    const candidate = path.resolve(root, rel);
+    const real = fs.realpathSync(candidate);
+    const inside = path.relative(root, real);
+    if (!inside || inside === '..' || inside.startsWith(`..${path.sep}`) || path.isAbsolute(inside) || fs.lstatSync(candidate).isSymbolicLink()) {
+      throw new WorkGraphStateError('finding path must be a regular file inside the repository');
+    }
+    const stat = fs.statSync(real);
+    if (!stat.isFile() || stat.size > MAX_FILE_BYTES) {
+      throw new WorkGraphStateError('finding path must be a readable file of at most 4 MiB');
+    }
+    if (!Number.isSafeInteger(item.line) || item.line < 1) {
+      throw new WorkGraphStateError('finding line must be a positive integer');
+    }
+    const content = fs.readFileSync(real);
+    const text = content.toString('utf8');
+    const lineCount = text.length ? text.split(/\r\n|\n|\r/).length - (/[\r\n]$/.test(text) ? 1 : 0) : 0;
+    if (item.line > lineCount) throw new WorkGraphStateError('finding line is outside the current file');
+    const severity = bounded(item.severity, 'finding severity', 16);
+    if (!SEVERITIES.has(severity)) throw new WorkGraphStateError('finding severity is invalid');
+    return {
+      path: inside.split(path.sep).join('/'),
+      line: item.line,
+      severity,
+      message: bounded(item.message, 'finding message'),
+      source_digest: `sha256:${crypto.createHash('sha256').update(content).digest('hex')}`,
+    };
+  });
+}
+
+function checkedChecks(values) {
+  if (values == null) return [];
+  if (!Array.isArray(values) || values.length > 16) {
+    throw new WorkGraphStateError('checks must be a list of at most 16 items');
+  }
+  return values.map((item, index) => {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) {
+      throw new WorkGraphStateError(`checks[${index}] must be an object`);
+    }
+    if (!Number.isSafeInteger(item.exit_code) || item.exit_code < -255 || item.exit_code > 255) {
+      throw new WorkGraphStateError('check exit_code must be an integer between -255 and 255');
+    }
+    return { name: bounded(item.name, 'check name', 256), exit_code: item.exit_code };
+  });
+}
+
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function recordReview(repoPath, { handoff, reviewerId, verdict, findings, summary, checks, storeOptions = {} }) {
+  const reviewer = bounded(reviewerId, 'reviewer_id', 512);
+  const choice = bounded(verdict, 'verdict', 32);
+  if (!VERDICTS.has(choice)) throw new WorkGraphStateError('invalid review verdict');
+  if (!handoff || typeof handoff !== 'object' || handoff.to_agent !== reviewer) {
+    throw new WorkGraphStateError('handoff must target the reviewer');
+  }
+  if (handoff.from_agent === reviewer) throw new WorkGraphStateError('writer and reviewer must differ');
+  const root = discoverRepositoryIdentity(repoPath).root;
+  const store = WorkGraphStore.forRepository(root, storeOptions);
+  const summaryText = bounded(summary, 'summary');
+  const validatedChecks = checkedChecks(checks);
+  const { result } = store.mutate((graph) => {
+    const sealed = handoffGraph(graph, handoff);
+    const observed = observation(root);
+    const state = sourceState(store.repoId, observed);
+    if (state !== graphSourceState(sealed, store.repoId)) {
+      throw new WorkGraphStateError('handoff is stale against current repository source');
+    }
+    const checked = checkedFindings(root, findings);
+    if (sourceState(store.repoId, observation(root)) !== state) {
+      throw new WorkGraphStateError('repository source changed while recording review');
+    }
+    if (choice === 'approve' && checked.some((finding) => ['critical', 'high'].includes(finding.severity))) {
+      throw new WorkGraphStateError('approve conflicts with blocking findings');
+    }
+    const payload = {
+      schema_version: 1,
+      record_kind: 'agent_review',
+      repo_id: store.repoId,
+      workstream_id: handoff.workstream_id,
+      handoff_commitment: handoff.payload_commitment,
+      writer_id: handoff.from_agent,
+      reviewer_id: reviewer,
+      source_state: state,
+      verdict: choice,
+      summary: summaryText,
+      findings: checked,
+      checks: validatedChecks,
+      trust_boundary: 'agent_statement; source digests observed; verdict unverified',
+    };
+    const reviewKey = `agent-review:${crypto.createHash('sha256').update(canonical(payload), 'utf8').digest('hex')}`;
+    const reviewId = workGraphNodeId('decision', store.repoId, reviewKey);
+    const now = Date.now();
+    graph.applyEvent({
+      observed_at_ms: now,
+      source_kind: 'agent_statement',
+      source_ref: reviewId,
+      actor_id: reviewer,
+      operations: [{
+        op: 'upsert_node',
+        node: {
+          node_id: reviewId, kind: 'decision', label: 'agent review recorded',
+          trust: 'untrusted', status: 'completed', status_trust: 'untrusted',
+          attributes: payload, updated_at_ms: now,
+        },
+      }, {
+        op: 'upsert_edge',
+        edge: {
+          edge_id: workGraphEdgeId(reviewId, 'part_of', handoff.workstream_id),
+          from_node: reviewId, to_node: handoff.workstream_id,
+          kind: 'part_of', trust: 'untrusted', updated_at_ms: now,
+        },
+      }],
+    });
+    return { review_id: reviewId, ...payload };
+  });
+  return { status: 'ok', kind: 'work_record_review', review: result };
+}
+
+function reviews(repoPath, { workstreamId = '', storeOptions = {} } = {}) {
+  const root = discoverRepositoryIdentity(repoPath).root;
+  const store = WorkGraphStore.forRepository(root, storeOptions);
+  const current = sourceState(store.repoId, observation(root));
+  const records = store.load().snapshot().nodes
+    .filter((node) => node.attributes && node.attributes.record_kind === 'agent_review')
+    .filter((node) => !workstreamId || node.attributes.workstream_id === workstreamId)
+    .map((node) => ({ review_id: node.node_id, current: node.attributes.source_state === current, ...node.attributes }));
+  return { status: 'ok', kind: 'work_reviews', reviews: records };
+}
+
+module.exports = { graphSourceState, handoffGraph, recordReview, reviews, sourceState };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "entroly-wasm",
-  "version": "1.0.86",
+  "version": "1.0.87",
   "description": "WebAssembly Context Assurance for AI agents: reduce avoidable token usage with local evidence selection, receipts, exact recovery, and verification.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -53,7 +53,10 @@
     "js/work_context_snapshot_store.d.ts",
     "js/work_graph_content_digest.js",
     "js/work_graph_continuity.js",
-    "js/work_graph_continuity.d.ts"
+    "js/work_graph_continuity.d.ts",
+    "js/work_graph_review.js",
+    "js/work_graph_recovery_ack.js",
+    "js/work_graph_inbox.js"
   ],
   "scripts": {
     "build": "wasm-pack build --target nodejs --out-dir pkg",
@@ -64,10 +67,13 @@
     "health": "node js/cli.js health",
     "demo": "node js/cli.js demo",
     "autotune": "node js/cli.js autotune",
-    "test": "node test_wasm_e2e.js && node test_activation.js && node test_work_graph.js && node test_work_graph_repo.js && node test_work_graph_store.js && node test_work_graph_content_digest.js && node test_work_graph_continuity.js && node test_context_trust_delivery.js && node test_work_graph_performance.js && node test_work_graph_root_exports.js && node test_context_receipt_parity.js"
+    "test": "node test_wasm_e2e.js && node test_activation.js && node test_work_graph.js && node test_work_graph_repo.js && node test_work_graph_store.js && node test_work_graph_content_digest.js && node test_work_graph_continuity.js && node test_work_graph_review.js && node test_context_trust_delivery.js && node test_work_graph_performance.js && node test_work_graph_root_exports.js && node test_context_receipt_parity.js && node test_bun_compat.js",
+    "test:bun": "bun test_wasm_e2e.js && bun test_activation.js && bun test_work_graph.js && bun test_work_graph_repo.js && bun test_work_graph_store.js && bun test_work_graph_content_digest.js && bun test_work_graph_continuity.js && bun test_work_graph_review.js && bun test_context_trust_delivery.js && bun test_work_graph_performance.js && bun test_work_graph_root_exports.js && bun test_context_receipt_parity.js && bun test_bun_compat.js"
   },
   "keywords": [
     "entroly",
+    "bun",
+    "bunx",
     "ai-agents",
     "ai-coding-agents",
     "context-assurance",
@@ -110,6 +116,7 @@
   "author": "entroly",
   "license": "Apache-2.0",
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=16.0.0",
+    "bun": ">=1.4.0"
   }
 }