npm - @echomem/mcp - Versions diffs - 1.4.9 → 1.4.10 - Mend

@echomem/mcp 1.4.9 → 1.4.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (48) hide show

package/assets/hud/github.svg +1 -0
package/dist/city/README.md +9 -0
package/dist/city/echo-ai-city-only.html +54 -93
package/dist/context-analysis/claude-canonical-adapter.js +315 -0
package/dist/context-analysis/claude-native-canonical.js +35 -12
package/dist/context-metrics/calculate.js +2 -15
package/dist/context-metrics/estimator.js +45 -0
package/dist/context-metrics/ledger.js +507 -0
package/dist/context-metrics/parse-claude.js +227 -0
package/dist/context-metrics/parse-codex.js +276 -0
package/dist/hud/adapters.js +69 -198
package/dist/hud/cli.js +0 -0
package/dist/hud/efficiency.js +447 -0
package/dist/hud/electron-main.js +3 -2
package/dist/hud/fs.js +14 -0
package/dist/hud/metric.js +4 -98
package/dist/hud/monitor.js +1 -12
package/dist/hud/render.js +4 -3
package/dist/hud/server.js +30 -0
package/dist/hud/web.js +409 -186
package/dist/index.js +0 -0
package/dist/setup-page/client-core.js +475 -0
package/dist/setup-page/client-extraction.js +550 -0
package/dist/setup-page/client-lifecycle.js +116 -0
package/dist/setup-page/client-report-audit.js +818 -0
package/dist/setup-page/client-report-city.js +204 -0
package/dist/setup-page/client-report.js +6 -0
package/dist/setup-page/client.js +15 -0
package/dist/setup-page/document.js +37 -0
package/dist/setup-page/styles-city-report.js +880 -0
package/dist/setup-page/styles-context-audit.js +470 -0
package/dist/setup-page/styles-extraction.js +821 -0
package/dist/setup-page/styles-foundation.js +231 -0
package/dist/setup-page/styles.js +11 -0
package/dist/setup-page.js +6 -5623
package/dist/setup.js +24 -10
package/package.json +4 -4
package/dist/city/10-problems-report.html +0 -649
package/dist/city/_live.html +0 -37
package/dist/city/_serve.mjs +0 -45
package/dist/city/card-data.json +0 -15
package/dist/city/chaos-to-clarity-pencil.html +0 -582
package/dist/city/city-data.json +0 -248
package/dist/city/echo-ai-city-only.template.html +0 -2271
package/dist/city/generate-echo-city-only.mjs +0 -112
package/dist/city/pencil-pie-generator.html +0 -883
package/dist/city/pencil-webgl-landscape.html +0 -1239
package/dist/city/spatial-fan-story.html +0 -479

package/assets/hud/github.svg ADDED Viewed

@@ -0,0 +1 @@

+ <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" width="16" height="16"><path fill="#24292f" d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.01 8.01 0 0 0 16 8c0-4.42-3.58-8-8-8z"/></svg>

package/dist/city/README.md ADDED Viewed

@@ -0,0 +1,9 @@
+# Runtime City Assets
+Only these files are part of setup runtime:
+- `echo-ai-city-only.html` - pre-auth Agent Doctor City.
+- `echo-extraction-plate.html` - post-auth extraction progress plate.
+- `vendor/`, `personality_stickers/`, and `echo-face-cutout.png` - assets loaded by those pages.
+Everything under `archive/` is historical reference. It is excluded from the published package and rejected by the localhost City asset server.

package/dist/city/echo-ai-city-only.html CHANGED Viewed

@@ -1,4 +1,9 @@
 <!DOCTYPE html>
+<!--
+  Runtime City source. The setup parent loads this file into an iframe and sends each local scan
+  report with postMessage. Do not generate user-specific HTML files: this renderer updates in place.
+  The retired static share-card template pipeline lives in artifacts/archive/.
+-->
 <html lang="en">
 <head>
 <meta charset="UTF-8" />
@@ -1085,6 +1090,7 @@ async function loadSetupReport(){
        typeof envelope.scanId!=='string' || !envelope.scanId.trim()){
       return {kind:'invalid', code:'REPORT_ENVELOPE_INVALID'};
     }
+    if(envelope.kind==='scanning') return {kind:'scanning', progress:envelope.progress||{}};
     if(envelope.kind==='empty') return {kind:'empty'};
     if(envelope.kind==='failed'){
       const error=envelope.error && typeof envelope.error==='object' ? envelope.error : {};
@@ -1102,105 +1108,60 @@ async function loadSetupReport(){
     setLoadState('failed', 'Your local report could not be shown', 'REPORT_NONCE_MISSING: Rerun Echo setup to open a verified local scan.');
     return new Promise(()=>{});
   }
-  let cleanupParentListener=()=>{};
-  let readyTimer=null;
-  const parentEnvelope=new Promise((resolve)=>{
-    const postReady=()=>{ try{ window.parent?.postMessage({type:'echomem:city-ready', nonce}, location.origin); }catch(_){} };
+  const renderScanProgress=(progress)=>{
+    const scanned=Number(progress?.scanned||0);
+    const total=Number(progress?.total||0);
+    const elapsed=Number(progress?.stageElapsedMs||0)>0 ? ' · '+Math.round(Number(progress.stageElapsedMs)/1000)+'s' : '';
+    if(total>0){
+      const detail=progress?.stage==='classifying-repeated-context'
+        ? (progress.label || 'classifying repeated context')+' '+scanned.toLocaleString()+' / '+total.toLocaleString()+elapsed
+        : (progress?.stage && progress.stage!=='reading-transcripts'
+            ? (progress.label || 'building report')+elapsed
+            : 'read '+scanned.toLocaleString()+' / '+total.toLocaleString()+' transcript files');
+      setLoadState('running', 'Reading your local history', detail);
+    }
+  };
+  // The parent owns /report polling and validation. The city only renders the
+  // parent-provided state, keeping loading, failure, and ready state in one place.
+  return await new Promise((resolve)=>{
+    let closed=false;
+    const close=()=>{
+      if(closed) return;
+      closed=true;
+      window.removeEventListener('message', onMessage);
+    };
+    const stop=(kind, code, message)=>{
+      close();
+      if(kind==='empty'){
+        setLoadState('empty', 'No local workspace data found', 'No demo data was substituted.');
+      }else{
+        setLoadState('failed', 'Your local report could not be shown', String(code||'REPORT_BUILD_FAILED')+': '+(message||'Rerun Echo setup to try again.'));
+      }
+      // Keep the city on its terminal loading/error surface instead of drawing a city without a report.
+    };
     const onMessage=(event)=>{
       if(event.origin!==location.origin) return;
       const data=event.data||{};
-      if(data.type==='echomem:setup-report' && data.nonce===nonce && Object.prototype.hasOwnProperty.call(data,'envelope')){
-        resolve({source:'parent', envelope:data.envelope});
-      }
-    };
-    cleanupParentListener=()=>{ window.removeEventListener('message', onMessage); if(readyTimer) window.clearInterval(readyTimer); };
-    window.addEventListener('message', onMessage);
-    postReady();
-    readyTimer=window.setInterval(postReady, 500);
-  });
-  const sleep=(ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
-  const fetchOnce=async()=>{
-    // A design-preview iframe may consume only its explicit parent envelope. It must
-    // never race the production /report endpoint and accidentally display local data.
-    if(previewMode) return null;
-    const controller=typeof AbortController!=='undefined' ? new AbortController() : null;
-    const timer=controller ? window.setTimeout(()=>controller.abort(), 3500) : null;
-    try{
-      const res=await fetch(`/report?nonce=${encodeURIComponent(nonce)}`, {credentials:'omit', cache:'no-store', signal:controller?.signal});
-      if(res.status===200){
-        try{ return {source:'server', envelope:await res.json()}; }
-        catch(_){ return {source:'failure', code:'REPORT_RESPONSE_INVALID', message:'The local scanner returned an unreadable report.'}; }
+      if(data.type!=='echomem:setup-report' || data.nonce!==nonce || !Object.prototype.hasOwnProperty.call(data,'envelope')) return;
+      const classified=classifyEnvelope(data.envelope);
+      if(classified.kind==='scanning'){
+        renderScanProgress(classified.progress);
+        return;
       }
-      if(res.status!==202){
-        let payload=null;
-        try{ payload=await res.json(); }catch(_){}
-        if(payload && payload.kind==='failed') return {source:'server', envelope:payload};
-        const error=payload?.error && typeof payload.error==='object' ? payload.error : {};
-        return {
-          source:'failure',
-          code:String(error.code||`REPORT_HTTP_${res.status}`),
-          message:String(error.message||'The local scanner could not provide this report.'),
-        };
-      }
-      // 202 = still scanning. This is a file-processing counter; final session totals are
-      // deduplicated separately once the report has finished parsing.
-      try{
-        const p=await res.json();
-        if(p && p.kind==='failed') return {source:'server', envelope:p};
-        const progress=p?.progress || p;
-        if(countEl && progress && Number(progress.total)>0){
-          const scanned=Number(progress.scanned||0);
-          const total=Number(progress.total||0);
-          const elapsed=Number(progress.stageElapsedMs||0)>0 ? ` · ${Math.round(Number(progress.stageElapsedMs)/1000)}s` : '';
-          if(progress.stage && progress.stage!=='reading-transcripts'){
-            countEl.textContent=progress.stage==='classifying-repeated-context'
-              ? `${progress.label || 'classifying repeated context'} ${scanned.toLocaleString()} / ${total.toLocaleString()}${elapsed}`
-              : `${progress.label || 'building report'}${elapsed}`;
-          }else{
-            countEl.textContent=`read ${scanned.toLocaleString()} / ${total.toLocaleString()} transcript files`;
-          }
-        }
-      }catch(_){ return {source:'failure', code:'REPORT_PROGRESS_INVALID', message:'The local scanner returned an unreadable progress update.'}; }
-      return null;
-    }catch(error){
-      if(error?.name!=='AbortError') setLoadState('running', 'Reading your local history', 'Local scanner connection interrupted · retrying');
-      return null;
-    }finally{
-      if(timer) window.clearTimeout(timer);
-    }
-  };
-  const stopClosed=(kind, code, message)=>{
-    cleanupParentListener();
-    if(kind==='empty'){
-      setLoadState('empty', 'No local workspace data found', 'No demo data was substituted.');
-    }else{
-      setLoadState('failed', 'Your local report could not be shown', `${code}: ${message||'Rerun Echo setup to try again.'}`);
-    }
-    return new Promise(()=>{});
-  };
-  while(true){
-    const result=await Promise.race([parentEnvelope, fetchOnce()]);
-    if(result){
-      if(result.source==='failure') return stopClosed('failed', result.code, result.message);
-      const classified=classifyEnvelope(result.envelope);
       if(classified.kind==='ready'){
-        cleanupParentListener();
-        return result.envelope;
+        close();
+        resolve(data.envelope);
+        return;
       }
-      if(classified.kind==='empty') return stopClosed('empty');
-      return stopClosed('failed', classified.code, classified.message || 'The report failed provenance or structure validation.');
-    }
-    const duringSleep=await Promise.race([parentEnvelope, sleep(500).then(()=>null)]);
-    if(duringSleep){
-      const classified=classifyEnvelope(duringSleep.envelope);
-      if(classified.kind==='ready'){
-        cleanupParentListener();
-        return duringSleep.envelope;
+      if(classified.kind==='empty'){
+        stop('empty');
+        return;
       }
-      if(classified.kind==='empty') return stopClosed('empty');
-      return stopClosed('failed', classified.code, classified.message || 'The report failed provenance or structure validation.');
-    }
-  }
+      stop('failed', classified.code, classified.message || 'The report failed provenance or structure validation.');
+    };
+    window.addEventListener('message', onMessage);
+    try{ window.parent?.postMessage({type:'echomem:city-ready', nonce}, location.origin); }catch(_){}
+  });
 }
 let signpostTokens=setupMode?'—':'7.49B';
 let signpostHours=setupMode?'—':'191.1h';
@@ -1339,7 +1300,7 @@ const POSTER_REPOS=[
   {name:'Daimler Engineering', x:-168,z:160, tool:'codex',  tokens:4439902,   cost:15,   days:0, hours:0.2, sessions:2},
 ];
 let REPOS=setupMode ? [] : POSTER_REPOS;
-// per-repo codex/claude split (frozen poster values from city-data.json) → drives the stacked two-colour buildings
+// Per-repo Codex/Claude split for the retired standalone poster fallback.
 const REPO_SPLIT={'WebPageReactVersion':[31,69],'EchoMem-Chrome':[19,81],'echo-design-system':[44,56],'sleepy-merkle-3d0470':[0,100],'DG-Web':[0,100],'Kobe Life':[100,0],'public':[0,100],'EchoMemory_log':[63,37],'production-prompt':[0,100],'brands':[0,100],'components':[0,100],'dist':[0,100],'Daimler Engineering':[100,0]};
 for(const o of REPOS){ const s=REPO_SPLIT[o.name]; if(s){ o.codexPct=s[0]; o.claudePct=s[1]; } else { o.codexPct=o.tool==='codex'?100:0; o.claudePct=100-o.codexPct; } }
 if(setupMode){

package/dist/context-analysis/claude-canonical-adapter.js ADDED Viewed

@@ -0,0 +1,315 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Convert a Claude Code transcript into the event vocabulary consumed by the
+ * vendored canonical scorer. The scorer itself remains provider-independent:
+ * this adapter is the only place where Claude's JSONL shape is interpreted.
+ */
+export function normalizeClaudeSessionForCanonical(file) {
+    const rows = readRows(file);
+    const sessionId = firstString(rows, "sessionId") || path.basename(file, ".jsonl");
+    const cwd = firstString(rows, "cwd");
+    const dynamicTools = collectToolNames(rows).map((name) => ({ name }));
+    const inferredOverheadTokens = inferClaudeOverheadTokens(rows);
+    const toolTokens = Math.round(JSON.stringify(dynamicTools).length / 3.3);
+    const instructionTokens = Math.max(0, inferredOverheadTokens - toolTokens);
+    const records = [codexRecord("session_meta", {
+            type: "session_meta",
+            id: sessionId,
+            cwd,
+            base_instructions: { text: "x".repeat(instructionTokens * 4) },
+            dynamic_tools: dynamicTools,
+        }, firstTimestamp(rows))];
+    const calls = new Map();
+    let hasUserTurn = false;
+    for (const row of rows) {
+        const timestamp = stringValue(row.timestamp) || firstTimestamp(rows);
+        const type = stringValue(row.type);
+        if (type === "user") {
+            const message = recordValue(row.message);
+            const content = message.content;
+            if (isToolResultContent(content)) {
+                if (!hasUserTurn)
+                    continue;
+                for (const block of arrayValue(content)) {
+                    if (!isRecord(block) || block.type !== "tool_result")
+                        continue;
+                    const callId = stringValue(block.tool_use_id);
+                    const call = calls.get(callId);
+                    if (!call || call.mode === "write")
+                        continue;
+                    records.push(codexRecord("response_item", {
+                        type: "function_call_output",
+                        call_id: callId,
+                        output: normalizeToolResult(block.content),
+                    }, timestamp));
+                }
+                continue;
+            }
+            const messageText = extractText(content);
+            const imageCount = countImages(content);
+            records.push(codexRecord("event_msg", {
+                type: "user_message",
+                message: messageText,
+                ...(imageCount > 0 ? { images: Array.from({ length: imageCount }, () => ({ type: "input_image" })) } : {}),
+            }, timestamp));
+            hasUserTurn = true;
+            continue;
+        }
+        if (type === "system" && hasUserTurn && (row.subtype === "compact_boundary" || row.subtype === "context_compacted")) {
+            records.push(codexRecord("event_msg", { type: "context_compacted" }, timestamp));
+            continue;
+        }
+        if (type !== "assistant" || !hasUserTurn)
+            continue;
+        const message = recordValue(row.message);
+        const usage = recordValue(message.usage);
+        const inputTokens = claudeOfficialInputTokens(usage);
+        if (inputTokens > 0) {
+            records.push(codexRecord("event_msg", {
+                type: "token_count",
+                info: {
+                    last_token_usage: {
+                        input_tokens: inputTokens,
+                        cached_input_tokens: numberValue(usage.cache_read_input_tokens),
+                        output_tokens: numberValue(usage.output_tokens),
+                    },
+                },
+            }, timestamp));
+        }
+        for (const block of arrayValue(message.content)) {
+            if (!isRecord(block))
+                continue;
+            if (block.type === "thinking") {
+                records.push(codexRecord("response_item", { type: "reasoning" }, timestamp));
+                continue;
+            }
+            if (block.type === "text") {
+                const text = stringValue(block.text);
+                if (text)
+                    records.push(codexRecord("event_msg", { type: "agent_message", message: text }, timestamp));
+                continue;
+            }
+            if (block.type !== "tool_use")
+                continue;
+            const normalized = normalizeToolUse(block);
+            if (!normalized)
+                continue;
+            calls.set(normalized.call.callId, normalized.call);
+            records.push(...normalized.records.map((record) => ({ ...record, timestamp })));
+        }
+    }
+    return {
+        jsonl: `${records.map((record) => JSON.stringify(record)).join("\n")}\n`,
+        sessionId,
+        cwd,
+        inferredOverheadTokens,
+    };
+}
+function normalizeToolUse(block) {
+    const name = stringValue(block.name);
+    const callId = stringValue(block.id);
+    if (!name || !callId)
+        return null;
+    const input = recordValue(block.input);
+    if (/^(Write|Edit|MultiEdit|NotebookEdit)$/i.test(name)) {
+        const file = stringValue(input.file_path) || stringValue(input.notebook_path) || stringValue(input.path) || "unknown";
+        const patch = syntheticPatch(name, file, input);
+        return {
+            call: { mode: "write", callId },
+            records: [
+                codexRecord("response_item", { type: "custom_tool_call", name: "apply_patch", call_id: callId, input: patch }, ""),
+                codexRecord("event_msg", { type: "patch_apply_end", changes: { [file]: { kind: /^Write$/i.test(name) ? "added" : "modified" } } }, ""),
+            ],
+        };
+    }
+    const command = commandForClaudeTool(name, input);
+    if (command) {
+        return {
+            call: { mode: "function", callId },
+            records: [codexRecord("response_item", {
+                    type: "function_call",
+                    name: "exec_command",
+                    call_id: callId,
+                    arguments: JSON.stringify({ cmd: command }),
+                }, "")],
+        };
+    }
+    return {
+        call: { mode: "function", callId },
+        records: [codexRecord("response_item", {
+                type: "function_call",
+                name: visualToolName(name) ? "view_image" : name,
+                call_id: callId,
+                arguments: JSON.stringify(input),
+            }, "")],
+    };
+}
+function commandForClaudeTool(name, input) {
+    if (/^Bash$/i.test(name))
+        return stringValue(input.command) || "bash";
+    if (/^(Read|NotebookRead)$/i.test(name)) {
+        const file = stringValue(input.file_path) || stringValue(input.notebook_path) || stringValue(input.path) || "unknown";
+        const offset = Math.max(1, numberValue(input.offset) || 1);
+        const limit = Math.max(1, numberValue(input.limit) || 2000);
+        return `sed -n '${offset},${offset + limit - 1}p' ${quoteArg(file)}`;
+    }
+    if (/^Grep$/i.test(name)) {
+        const pattern = stringValue(input.pattern) || stringValue(input.query) || "unknown";
+        const target = stringValue(input.path) || ".";
+        return `rg -n ${quoteArg(pattern)} ${quoteArg(target)}`;
+    }
+    if (/^Glob$/i.test(name))
+        return `rg --files ${quoteArg(stringValue(input.path) || ".")}`;
+    if (/^(LS|ListFiles)$/i.test(name))
+        return `ls ${quoteArg(stringValue(input.path) || ".")}`;
+    if (/^(WebSearch|WebFetch)$/i.test(name)) {
+        const query = stringValue(input.query) || stringValue(input.url) || "web";
+        return `rg ${quoteArg(`web:${query}`)} web`;
+    }
+    return null;
+}
+function syntheticPatch(name, file, input) {
+    const chunks = [];
+    const content = stringValue(input.content) || stringValue(input.new_string) || stringValue(input.new_source);
+    if (content)
+        chunks.push(content);
+    for (const edit of arrayValue(input.edits)) {
+        if (!isRecord(edit))
+            continue;
+        const value = stringValue(edit.new_string) || stringValue(edit.new_source) || stringValue(edit.content);
+        if (value)
+            chunks.push(value);
+    }
+    const body = chunks.join("\n") || `${name} ${file}`;
+    return `*** Begin Patch\n*** ${/^Write$/i.test(name) ? "Add" : "Update"} File: ${file}\n@@\n${body}\n*** End Patch\n`;
+}
+function inferClaudeOverheadTokens(rows) {
+    let firstUserTokens = 0;
+    let firstUserImages = 0;
+    let awaitingUsage = false;
+    for (const row of rows) {
+        const type = stringValue(row.type);
+        if (type === "user" && !isToolResultContent(recordValue(row.message).content)) {
+            if (!awaitingUsage) {
+                const content = recordValue(row.message).content;
+                firstUserTokens = Math.round(extractText(content).length / 4);
+                firstUserImages = countImages(content);
+                awaitingUsage = true;
+            }
+            continue;
+        }
+        if (type !== "assistant" || !awaitingUsage)
+            continue;
+        const total = claudeOfficialInputTokens(recordValue(recordValue(row.message).usage));
+        if (total <= 0)
+            continue;
+        const structureFloor = Math.round(total * 0.03);
+        return Math.max(0, total - firstUserTokens - firstUserImages * 4000 - structureFloor);
+    }
+    return 0;
+}
+function claudeOfficialInputTokens(usage) {
+    return numberValue(usage.input_tokens)
+        + numberValue(usage.cache_read_input_tokens)
+        + numberValue(usage.cache_creation_input_tokens);
+}
+function normalizeToolResult(value) {
+    if (typeof value === "string")
+        return value;
+    const output = [];
+    for (const block of arrayValue(value)) {
+        if (!isRecord(block))
+            continue;
+        if (block.type === "text" && typeof block.text === "string")
+            output.push(block.text);
+        else if (block.type === "image")
+            output.push({ type: "input_image" });
+        else
+            output.push(block);
+    }
+    return output.length === 1 ? output[0] : output;
+}
+function extractText(value) {
+    if (typeof value === "string")
+        return value;
+    return arrayValue(value).map((block) => {
+        if (!isRecord(block))
+            return "";
+        if (typeof block.text === "string")
+            return block.text;
+        return "";
+    }).filter(Boolean).join("\n");
+}
+function countImages(value) {
+    if (!value)
+        return 0;
+    if (Array.isArray(value))
+        return value.reduce((sum, item) => sum + countImages(item), 0);
+    if (!isRecord(value))
+        return 0;
+    const own = value.type === "image" || value.type === "input_image" ? 1 : 0;
+    return own + Object.values(value).reduce((sum, item) => sum + countImages(item), 0);
+}
+function collectToolNames(rows) {
+    const names = new Set();
+    for (const row of rows) {
+        for (const block of arrayValue(recordValue(row.message).content)) {
+            if (isRecord(block) && block.type === "tool_use" && typeof block.name === "string")
+                names.add(block.name);
+        }
+    }
+    return [...names].sort();
+}
+function readRows(file) {
+    const rows = [];
+    for (const line of fs.readFileSync(file, "utf8").split(/\n/)) {
+        if (!line.trim())
+            continue;
+        try {
+            const value = JSON.parse(line);
+            if (isRecord(value))
+                rows.push(value);
+        }
+        catch {
+            // Claude may leave a partial final line while a session is active.
+        }
+    }
+    return rows;
+}
+function firstString(rows, key) {
+    for (const row of rows)
+        if (typeof row[key] === "string" && row[key])
+            return row[key];
+    return null;
+}
+function firstTimestamp(rows) {
+    return firstString(rows, "timestamp") || new Date(0).toISOString();
+}
+function codexRecord(type, payload, timestamp) {
+    return { timestamp, type, payload };
+}
+function isToolResultContent(value) {
+    return arrayValue(value).some((block) => isRecord(block) && block.type === "tool_result");
+}
+function visualToolName(name) {
+    return /screenshot|image|browser|playwright/i.test(name);
+}
+function quoteArg(value) {
+    return `"${value.replace(/["\\]/g, "_")}"`;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function recordValue(value) {
+    return isRecord(value) ? value : {};
+}
+function arrayValue(value) {
+    return Array.isArray(value) ? value : [];
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : "";
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}

package/dist/context-analysis/claude-native-canonical.js CHANGED Viewed

@@ -61,7 +61,7 @@ function parseClaudeNativeSession(file) {
     const requests = new Map();
     const pendingTools = new Map();
     for (const row of rows) {
-        if (typeof row.sessionId === "string")
+        if (!session && typeof row.sessionId === "string")
             session = row.sessionId;
         if (!cwd && typeof row.cwd === "string")
             cwd = row.cwd;
@@ -832,6 +832,7 @@ function isVerificationCommand(command) {
     return /\b(?:test|build|tsc|lint|typecheck|check)\b/.test(normalizeCommand(command));
 }
 function aggregateClaudeNative(sessions) {
+    const uniqueSessionIds = new Set(sessions.map((session) => session.session));
     const summary = sessions.reduce((sum, session) => {
         sum.input += session.officialInputTokens;
         sum.useful += session.usefulTokens;
@@ -845,26 +846,43 @@ function aggregateClaudeNative(sessions) {
     const buckets = { duplicate: 0, refind: 0, dead: 0, unattributed: 0 };
     const rawBuckets = { keep_oh: 0, keep_prod: 0, opt_dup: 0, opt_refind: 0, opt_dead: 0 };
     const repos = new Map();
+    const sessionRows = new Map();
     const problemRows = new Map();
     for (const id of PROBLEM_IDS)
-        problemRows.set(id, { tokens: 0, count: 0, pressure: 0, sessions: 0, examples: [] });
+        problemRows.set(id, { tokens: 0, count: 0, pressure: 0, sessionIds: new Set(), examples: [] });
     for (const session of sessions) {
         for (const key of Object.keys(buckets))
             buckets[key] += session.buckets[key] || 0;
         for (const key of Object.keys(rawBuckets))
             rawBuckets[key] += session.rawBuckets[key] || 0;
-        const repo = repos.get(session.repo) || { sessions: 0, officialInputTokens: 0, wasteTokens: 0 };
-        repo.sessions += 1;
+        const repo = repos.get(session.repo) || { sessionIds: new Set(), officialInputTokens: 0, wasteTokens: 0 };
+        repo.sessionIds.add(session.session);
         repo.officialInputTokens += session.officialInputTokens;
         repo.wasteTokens += session.wasteTokens;
         repos.set(session.repo, repo);
+        const sessionRow = sessionRows.get(session.session) || {
+            session: session.session,
+            repo: session.repo,
+            turns: 0,
+            officialInputTokens: 0,
+            wasteTokens: 0,
+            problems: new Map(),
+        };
+        sessionRow.turns += session.turns;
+        sessionRow.officialInputTokens += session.officialInputTokens;
+        sessionRow.wasteTokens += session.wasteTokens;
+        if (sessionRow.repo === "home" && session.repo !== "home")
+            sessionRow.repo = session.repo;
+        sessionRows.set(session.session, sessionRow);
         for (const [id, stats] of session.problems) {
             const row = problemRows.get(id);
             row.tokens += stats.tokens;
             row.count += stats.count;
             row.pressure += stats.pressure;
-            if (stats.tokens > 0)
-                row.sessions += 1;
+            if (stats.tokens > 0) {
+                row.sessionIds.add(session.session);
+                sessionRow.problems.set(id, (sessionRow.problems.get(id) || 0) + stats.tokens);
+            }
             row.examples.push(...stats.examples);
             row.examples.sort((left, right) => (right.tokens || 0) - (left.tokens || 0));
             row.examples.splice(1);
@@ -880,7 +898,7 @@ function aggregateClaudeNative(sessions) {
             category: meta.category,
             confidence: meta.confidence,
             count: row.count,
-            sessions: row.sessions,
+            sessions: row.sessionIds.size,
             allocatedWasteTokens: Math.round(row.tokens),
             qualifiedTokenPressure: Math.round(row.pressure),
             severity: summary.waste ? (row.tokens / summary.waste) * 100 : 0,
@@ -897,7 +915,7 @@ function aggregateClaudeNative(sessions) {
             note: "Claude Code sessions are scored natively from JSONL requestIds and toolUseResult objects. For each human turn, the terminal unique provider request by request sequence is selected as the retained context-window proxy; episode-aware evidence determines raw useful/residue for each selected turn request. Raw residue is counted as waste, while P01-P13 explain the attributable portion and remaining unlabeled residue stays included in headline waste.",
         },
         summary: {
-            sessionsAnalyzed: sessions.length,
+            sessionsAnalyzed: uniqueSessionIds.size,
             reposAnalyzed: repos.size,
             turnsAnalyzed: summary.turns,
             officialInputTokens: Math.round(summary.input),
@@ -914,18 +932,23 @@ function aggregateClaudeNative(sessions) {
         buckets: mapBucketValues(buckets),
         rawBuckets: mapBucketValues(rawBuckets),
         problems,
-        sessions: sessions.map((session) => {
-            const top = [...session.problems.entries()].sort((a, b) => b[1].tokens - a[1].tokens)[0];
+        sessions: [...sessionRows.values()].map((session) => {
+            const top = [...session.problems.entries()].sort((a, b) => b[1] - a[1])[0];
             return {
                 session: session.session,
                 repo: session.repo,
                 turns: session.turns,
                 officialInputTokens: Math.round(session.officialInputTokens),
                 wasteTokens: Math.round(session.wasteTokens),
-                topProblemId: top && top[1].tokens > 0 ? top[0] : null,
+                topProblemId: top && top[1] > 0 ? top[0] : null,
             };
         }).sort((a, b) => b.wasteTokens - a.wasteTokens).slice(0, 8),
-        repos: [...repos.entries()].map(([repo, value]) => ({ repo, ...mapBucketValues(value) }))
+        repos: [...repos.entries()].map(([repo, value]) => ({
+            repo,
+            sessions: value.sessionIds.size,
+            officialInputTokens: Math.round(value.officialInputTokens),
+            wasteTokens: Math.round(value.wasteTokens),
+        }))
             .sort((a, b) => b.wasteTokens - a.wasteTokens).slice(0, 8),
         episodes: sessions.flatMap((session) => session.episodes).sort((a, b) => b.wasteTokens - a.wasteTokens).slice(0, 8),
     };

package/dist/context-metrics/calculate.js CHANGED Viewed

@@ -11,11 +11,7 @@ export function calculateContextMetrics(input) {
     const projectedNextFullnessPct = modelContextLimitTokens && newOutputThisTurnTokens !== undefined
         ? (latestInputTokens + newOutputThisTurnTokens) / modelContextLimitTokens
         : undefined;
-    const healthScorePct = calculateHealthScorePct({
-        noisePct,
-        contextFullnessPct,
-        projectedNextFullnessPct,
-    });
+    const healthScorePct = calculateHealthScorePct({ noisePct });
     return {
         latestInputTokens,
         modelContextLimitTokens,
@@ -32,13 +28,7 @@ export function calculateContextMetrics(input) {
     };
 }
 function calculateHealthScorePct(input) {
-    const pressurePct = Math.max(input.contextFullnessPct ?? 0, input.projectedNextFullnessPct ?? 0);
-    // Noise is a direct quality loss. Fullness becomes a separate pressure penalty after 70% because
-    // clean-but-nearly-full sessions still become slow, brittle, or compaction-prone.
-    const fullnessPenaltyPct = pressurePct > 0.7
-        ? clamp01((pressurePct - 0.7) / 0.3) * 35
-        : 0;
-    return Math.max(0, Math.min(100, Math.round(100 - input.noisePct * 100 - fullnessPenaltyPct)));
+    return Math.max(0, Math.min(100, Math.round(100 - input.noisePct * 100)));
 }
 function nonNegative(value) {
     return Number.isFinite(value) ? Math.max(0, Math.round(value)) : 0;
@@ -51,6 +41,3 @@ function optionalPositive(value) {
         return null;
     return Math.round(value);
 }
-function clamp01(value) {
-    return Math.max(0, Math.min(1, value));
-}