deadbyte-mcp 0.12.0 → 0.13.0

package/src/autonomous-runtime.mjs

@@ -360,20 +360,24 @@ function configuredCapabilityManifest({machineFsRuntime,observationRuntime,proce
     entries:Object.freeze(entries)});
 }
 
-async function plannerView(goal, state, events, codingRuntime, capabilityManifest, desktopMemoryProvider=null) {
+async function plannerView(goal, state, events, codingRuntime, capabilityManifest, desktopMemoryProvider=null,memoryProvider=null) {
   const tree = await codingRuntime.tree({ rootId:goal.root_id, path:'.', maxDepth:4, maxEntries:600 });
   const memory=deriveAgentMemory(events,{maxArchival:24});
   const desktopMemory=desktopMemoryProvider?await desktopMemoryProvider.plannerContext():null;
+  const codingAuthority=memoryProvider?await codingRuntime.sessionStatus():null;
+  const longTerm=memoryProvider?await memoryProvider.refresh({goal,events,currentPlan:state.active_plan,currentFiles:[],currentSymbols:[],
+    currentAuthority:{coding:{armed:codingAuthority.armed,reason:codingAuthority.reason}}}):null;
   return { mutation_epoch:state.mutation_epoch, planner_round:state.planner_round, tree:tree.entries,
     contexts:state.contexts.slice(-16), observations:state.observations.slice(-24), active_plan:state.active_plan,
     capabilities:capabilityManifest, project_memory:memory, desktop_memory:desktopMemory,
+    long_term_memory:longTerm?.planner_context??null,memory_evidence:longTerm,
     recent_decisions:state.decisions.slice(-8).map(item => ({ planner_round:item.planner_round,
       action:item.decision?.action, summary:item.decision?.summary })) };
 }
 function requestIdFor(goalId, plannerRound, journalHead) {
   return sha256Object({ schema:'deadbyte.autonomous-planner-request.v1', goal_id:goalId, planner_round:plannerRound, journal_head_sha256:journalHead });
 }
-async function requestPlanner(ctx, goal, events, state, policy, codingRuntime, capabilityManifest, desktopMemoryProvider, signingKeyPath) {
+async function requestPlanner(ctx, goal, events, state, policy, codingRuntime, capabilityManifest, desktopMemoryProvider,memoryProvider, signingKeyPath) {
   if (state.pending_request) return state.pending_request;
   const round = state.planner_round + 1;
   if (round > goal.max_iterations) {
@@ -384,7 +388,7 @@ async function requestPlanner(ctx, goal, events, state, policy, codingRuntime, c
     await appendEvent(ctx,events,signingKeyPath,'goal_paused',{ reason:'wall_time_limit', max_wall_ms:policy.limits.max_wall_ms });
     return null;
   }
-  const view = await plannerView(goal,state,events,codingRuntime,capabilityManifest,desktopMemoryProvider);
+  const view = await plannerView(goal,state,events,codingRuntime,capabilityManifest,desktopMemoryProvider,memoryProvider);
   let prompt = buildPlannerPrompt({ goal:{ title:goal.title, goal:goal.goal, acceptance:goal.acceptance }, policy, view });
   const repair = [...(state.planner_rejections ?? [])].reverse().find(item => item.planner_round === round) ?? null;
   if (repair) {
@@ -397,6 +401,14 @@ Repair only the decision contract. Return one corrected strict JSON decision; do
   const requestId = requestIdFor(goal.goal_id,round,state.journal_head_sha256);
   const payload = { request_id:requestId, planner_round:round, mutation_epoch:state.mutation_epoch,
     prompt, prompt_sha256:sha256Bytes(Buffer.from(prompt,'utf8')), backend:policy.planner.backend,
+    ...(view.memory_evidence?{
+      working_memory_sha256:view.memory_evidence.working_memory_sha256,
+      memory_snapshot_sha256:view.memory_evidence.snapshot_sha256,
+      memory_index_sha256:view.memory_evidence.index_sha256,
+      historical_archive_sha256:view.memory_evidence.historical_archive_sha256,
+      historical_index_sha256:view.memory_evidence.historical_index_sha256,
+      memory_source_release_manifest:view.memory_evidence.source_release_manifest
+    }:{}),
     ...(repair ? { repair_of_request_id:repair.request_id, rejection_event_sha256:repair.event_sha256 } : {}) };
   await appendEvent(ctx,events,signingKeyPath,'planner_requested',payload);
   return payload;
@@ -524,9 +536,9 @@ async function requestProviderWithCircuit({ctx,events,goal,policy,pending,signin
     throw error;
   }
 }
-async function acceptPlannerDecision({ ctx, events, goal, state, policy, codingRuntime, capabilityManifest, desktopMemoryProvider, signingKeyPath, plannerResponse }) {
+async function acceptPlannerDecision({ ctx, events, goal, state, policy, codingRuntime, capabilityManifest, desktopMemoryProvider,memoryProvider, signingKeyPath, plannerResponse }) {
   let currentState = state;
-  let pending = currentState.pending_request ?? await requestPlanner(ctx,goal,events,currentState,policy,codingRuntime,capabilityManifest,desktopMemoryProvider,signingKeyPath);
+  let pending = currentState.pending_request ?? await requestPlanner(ctx,goal,events,currentState,policy,codingRuntime,capabilityManifest,desktopMemoryProvider,memoryProvider,signingKeyPath);
   if (!pending) return null;
   let suppliedResponse = plannerResponse;
   while (pending) {
@@ -565,7 +577,7 @@ async function acceptPlannerDecision({ ctx, events, goal, state, policy, codingR
         return { needs_planner:false, rejected:true, paused:true };
       }
       currentState = deriveState(goal,events);
-      pending = await requestPlanner(ctx,goal,events,currentState,policy,codingRuntime,capabilityManifest,desktopMemoryProvider,signingKeyPath);
+      pending = await requestPlanner(ctx,goal,events,currentState,policy,codingRuntime,capabilityManifest,desktopMemoryProvider,memoryProvider,signingKeyPath);
       if (!pending) return null;
       if (policy.planner.backend === 'client_sampling') return { needs_planner:true, request:pending };
       continue;
@@ -573,6 +585,12 @@ async function acceptPlannerDecision({ ctx, events, goal, state, policy, codingR
     const event = await appendEvent(ctx,events,signingKeyPath,'planner_decision',{
       request_id:pending.request_id, planner_round:pending.planner_round, mutation_epoch:pending.mutation_epoch,
       backend:response.backend, model:response.model ?? 'unknown', response_sha256:sha256Bytes(Buffer.from(response.raw_text,'utf8')),
+      ...(pending.working_memory_sha256?{
+        working_memory_sha256:pending.working_memory_sha256,memory_snapshot_sha256:pending.memory_snapshot_sha256,
+        memory_index_sha256:pending.memory_index_sha256,
+        historical_archive_sha256:pending.historical_archive_sha256,historical_index_sha256:pending.historical_index_sha256,
+        memory_source_release_manifest:pending.memory_source_release_manifest
+      }:{}),
       decision
     });
     return { needs_planner:false, event, decision };
@@ -1678,7 +1696,7 @@ function isAuthorityUnavailable(error) {
 
 export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRuntime, machineFsRuntime = null,
   observationRuntime = null, processRuntime = null, semanticRuntime = null, desktopRuntime = null,
-  desktopMemoryProvider = null, signingKeyPath, verifyKeyPath }) {
+  desktopMemoryProvider = null,memoryProvider=null, signingKeyPath, verifyKeyPath }) {
   if (!policy || !codingRuntime || !nativeDiffRuntime) throw new Error('autonomous runtime requires policy/coding/native-diff runtimes');
   if (!signingKeyPath || !verifyKeyPath) throw new Error('autonomous runtime requires trust keys');
   const capabilityManifest=configuredCapabilityManifest({machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,desktopRuntime});
@@ -1732,7 +1750,8 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
     const journal = [];
     await appendEvent(ctx,journal,signingKeyPath,'goal_created',{
       submission_id:submissionId, root_id:rootId, title, goal_sha256:normalized.goal_sha256,
-      max_iterations:normalized.max_iterations
+      max_iterations:normalized.max_iterations,
+      ...(memoryProvider?{source_release_manifest:memoryProvider.source_release_manifest}:{})
     });
     return { status:'accepted', goal_id:goalId, goal_sha256:normalized.goal_sha256, state:'pending' };
   }
@@ -1927,7 +1946,7 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
           continue;
         }
         const accepted = await acceptPlannerDecision({ ctx,events:journal,goal,state,policy,codingRuntime,capabilityManifest,
-          desktopMemoryProvider,signingKeyPath,plannerResponse:suppliedResponse });
+          desktopMemoryProvider,memoryProvider,signingKeyPath,plannerResponse:suppliedResponse });
         suppliedResponse = null;
         if (accepted?.needs_planner) {
           state = deriveState(goal,journal);

package/src/mcp-server.mjs

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import { access, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
@@ -37,6 +38,7 @@ import { createNativeDesktopInputProvider } from './desktop-input-r40.mjs';
 import { createNativeDesktopGrounder } from './desktop-uia-r40.mjs';
 import { createDesktopRuntime } from './desktop-runtime-r40.mjs';
 import { createDesktopMemoryProvider } from './desktop-memory-r40.mjs';
+import { createR41MemoryProvider } from './memory-r41.mjs';
 import { registerDesktopTools } from './desktop-mcp-tools-r40.mjs';
 import { loadAutonomousPolicy } from './autonomous-policy.mjs';
 import { createNativeDiffRuntime } from './native-diff.mjs';
@@ -61,6 +63,7 @@ import {
 } from './output-contracts.mjs';
 
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const packageManifestSha256=createHash('sha256').update(await readFile(path.join(packageRoot,'MANIFEST.SHA256'))).digest('hex');
 const workspaceRoot = path.resolve(process.env.DEADBYTE_WORKSPACE_ROOT ?? path.join(packageRoot, 'workspaces'));
 const signingKeyPath = process.env.DEADBYTE_SIGNING_KEY ?? defaultPrivateKeyPath();
 const verifyKeyPath = process.env.DEADBYTE_VERIFY_KEY ?? defaultPublicKeyPath();
@@ -187,8 +190,18 @@ if (autonomousRuntimeMode === '1' && !autonomousPolicyPath) throw new Error('DEA
 const autonomousPolicy = autonomousRuntimeMode === '1' ? await loadAutonomousPolicy(autonomousPolicyPath,codingPolicy) : null;
 const nativeDiffRuntime = autonomousPolicy ? createNativeDiffRuntime({ policy:autonomousPolicy,codingRuntime,machineFsRuntime,signingKeyPath,verifyKeyPath }) : null;
 semanticRuntime = codingRuntime ? createSemanticCodeRuntime({ codingRuntime, backends: semanticLsp.backends, nativeDiffRuntime }) : null;
+const autonomousMemorySigningKey=autonomousPolicy?await loadPrivateSigningKey(signingKeyPath):null;
+const autonomousMemoryVerifyKey=autonomousPolicy?await loadPublicVerifyKey(verifyKeyPath):null;
+if(autonomousPolicy&&autonomousMemorySigningKey.keyId!==autonomousMemoryVerifyKey.keyId) throw new Error('R41 memory signing/verify key mismatch');
+const memoryProvider=autonomousPolicy?createR41MemoryProvider({
+  memoryRoot:path.join(autonomousPolicy.evidence_dir,'memory-r41',packageManifestSha256),sourceReleaseManifest:packageManifestSha256,
+  journalRoot:path.join(autonomousPolicy.evidence_dir,'goals'),
+  writerVersion:DEADBYTE_VERSION,privateKey:autonomousMemorySigningKey.privateKey,
+  publicKey:autonomousMemoryVerifyKey.publicKey,keyId:autonomousMemorySigningKey.keyId,
+  byteBudget:Math.min(262144,Math.max(65536,Math.floor(autonomousPolicy.limits.max_context_bytes/2))),semantic:{enabled:false}
+}):null;
 const autonomousRuntime = autonomousPolicy ? createAutonomousRuntime({ policy:autonomousPolicy,codingRuntime,nativeDiffRuntime,
-  machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,desktopRuntime,desktopMemoryProvider,signingKeyPath,verifyKeyPath }) : null;
+  machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,desktopRuntime,desktopMemoryProvider,memoryProvider,signingKeyPath,verifyKeyPath }) : null;
 const autonomousSupervisor = autonomousRuntime && autonomousPolicy.planner.backend === 'openai_compatible' &&
   autonomousSupervisorMode === 'in_process'
   ? startAutonomousSupervisor({ runtime: autonomousRuntime, policy: autonomousPolicy })