@pheem49/mint 1.15.0 → 1.16.0

package/src/bin/measure-effects.mjs

@@ -0,0 +1,53 @@
+// Measures actual orb GPU commands via Chrome CDP; start npm run dev:web first.
+import { spawn } from 'node:child_process';
+import { mkdtemp, rm } from 'node:fs/promises';
+const profile = await mkdtemp('/tmp/mint-effects-chrome-');
+const chrome = spawn('google-chrome', ['--headless=new','--enable-gpu','--use-angle=gl','--no-sandbox','--disable-dev-shm-usage','--remote-debugging-port=0',`--user-data-dir=${profile}`,'about:blank'], {stdio:['ignore','ignore','pipe']});
+let stderr = '';
+chrome.stderr.on('data', data => { stderr += data; });
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+let ws;
+try {
+  for (let i = 0; i < 100 && !stderr.includes('DevTools listening on'); i++) await sleep(100);
+  const match = stderr.match(/DevTools listening on (ws:\/\/[^\s]+)/);
+  if (!match) throw Error('Chrome did not start: ' + stderr.slice(-1000));
+  const origin = 'http://' + new URL(match[1]).host;
+  const pages = await (await fetch(origin + '/json/list')).json();
+  ws = new WebSocket(pages.find(page => page.type === 'page').webSocketDebuggerUrl);
+  await new Promise((resolve,reject) => { ws.onopen=resolve; ws.onerror=reject; });
+  let sequence = 0; const pending = new Map();
+  ws.onmessage = event => { const message=JSON.parse(event.data); if(message.id) { const waiter=pending.get(message.id); pending.delete(message.id); message.error ? waiter.reject(message.error) : waiter.resolve(message.result); } };
+  const send = (method,params={}) => new Promise((resolve,reject)=> { const id=++sequence; pending.set(id,{resolve,reject}); ws.send(JSON.stringify({id,method,params})); });
+  await send('Runtime.enable');
+  await send('Page.enable');
+  await send('Page.addScriptToEvaluateOnNewDocument', {source: `window.orbDraws=0;window.gpuSamples=[];window.gpuDisjoint=0;const queues=new Map();for(const C of [WebGLRenderingContext,WebGL2RenderingContext]){const draw=C.prototype.drawArrays;C.prototype.drawArrays=function(...args){window.orbDraws++;const ext=this.getExtension('EXT_disjoint_timer_query_webgl2');if(!ext)return draw.apply(this,args);const q=this.createQuery();this.beginQuery(ext.TIME_ELAPSED_EXT,q);const result=draw.apply(this,args);this.endQuery(ext.TIME_ELAPSED_EXT);if(!queues.has(this))queues.set(this,[]);queues.get(this).push(q);return result}}setInterval(()=>{for(const [gl,qs] of queues){const ext=gl.getExtension('EXT_disjoint_timer_query_webgl2');if(gl.getParameter(ext.GPU_DISJOINT_EXT)){window.gpuDisjoint++;qs.splice(0).forEach(q=>gl.deleteQuery(q));window.gpuSamples=[];continue}while(qs.length&&gl.getQueryParameter(qs[0],gl.QUERY_RESULT_AVAILABLE)){const q=qs.shift();window.gpuSamples.push(gl.getQueryParameter(q,gl.QUERY_RESULT)/1e6);gl.deleteQuery(q)}}},50)`});
+  await send('Page.navigate',{url:process.argv[2] || 'http://127.0.0.1:9000/tests/effectsPerformance.browser.html'});
+  await sleep(2500);
+  const evaluate=async expression=>(await send('Runtime.evaluate',{expression,returnByValue:true})).result.value;
+  console.log('GPU',await evaluate(`(()=>{const c=document.querySelector('canvas');const gl=c.getContext('webgl2')||c.getContext('webgl');const ext=gl.getExtension('WEBGL_debug_renderer_info');return {renderer:ext?gl.getParameter(ext.UNMASKED_RENDERER_WEBGL):gl.getParameter(gl.RENDERER),gpuTimer:!!(gl.getExtension('EXT_disjoint_timer_query_webgl2')||gl.getExtension('EXT_disjoint_timer_query'))}})()`));
+  for(const mode of ['normal','reduced-motion','reduced-effects']){
+    await send('Emulation.setEmulatedMedia',{features:[{name:'prefers-reduced-motion',value:mode==='reduced-motion'?'reduce':'no-preference'}]});
+    await evaluate(`document.documentElement.setAttribute('data-reduced-effects','${mode==='reduced-effects'}')`);
+    await sleep(300);
+    await sleep(200);
+    await evaluate('window.gpuSamples=[]');
+    const before=await evaluate('window.orbDraws');await sleep(5000);const after=await evaluate('window.orbDraws');
+    console.log(mode,JSON.stringify({drawsIn5s:after-before,gpu:await evaluate(`(()=>{const xs=window.gpuSamples.slice().sort((a,b)=>a-b);return {samples:xs.length,medianMs:xs.length?xs[Math.floor(xs.length/2)]:null,p95Ms:xs.length?xs[Math.floor(xs.length*.95)]:null,totalMs:xs.reduce((a,b)=>a+b,0),disjoint:window.gpuDisjoint}})()`),backgroundAnimation:await evaluate(`getComputedStyle(document.querySelector('.assistant-workspace'),'::before').animationName`)}));
+  }
+
+  await evaluate(`document.querySelector('#root').style.width='350px'`);await sleep(300);
+  const resizeDraws=await evaluate('window.orbDraws');await sleep(1000);
+  console.log('settled after resize',{drawsIn1s:(await evaluate('window.orbDraws'))-resizeDraws});
+  await evaluate(`window.setOrb({hue:120})`);await sleep(300);
+  console.log('hue change',{additionalDraws:(await evaluate('window.orbDraws'))-resizeDraws});
+  await evaluate(`document.documentElement.setAttribute('data-reduced-effects','false');document.querySelector('#root').style.transform='translateY(2000px)'`);await sleep(300);
+  const offscreen=await evaluate('window.orbDraws');await sleep(1000);
+  console.log('offscreen',{drawsIn1s:(await evaluate('window.orbDraws'))-offscreen});
+  await evaluate(`document.querySelector('#root').style.transform=''`);await sleep(300);
+  const resumed=await evaluate('window.orbDraws');await sleep(1000);
+  console.log('resumed',{drawsIn1s:(await evaluate('window.orbDraws'))-resumed});
+  await evaluate(`window.setOrb({animate:false})`);await sleep(300);
+  const paused=await evaluate('window.orbDraws');await sleep(1000);
+  console.log('paused',{drawsIn1s:(await evaluate('window.orbDraws'))-paused});
+
+} finally { ws?.close(); chrome.kill(); if (chrome.exitCode === null) await new Promise(resolve=>chrome.once('exit',resolve)); await rm(profile,{recursive:true,force:true,maxRetries:5,retryDelay:100}).catch(()=>{}); }

package/src/bin/package.test.js

@@ -0,0 +1,28 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+test('npm CLI package resolves every Cargo workspace member without shipping Live2D', t => {
+  const root = path.resolve(__dirname, '../..');
+  const temporary = fs.mkdtempSync(path.join(os.tmpdir(), 'mint-package-test-'));
+  t.after(() => fs.rmSync(temporary, { recursive: true, force: true }));
+  const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  const packed = spawnSync(npm, ['pack', '--dry-run', '--ignore-scripts', '--json', '--cache', path.join(temporary, 'cache')], { cwd: root, encoding: 'utf8', shell: process.platform === 'win32' });
+  assert.equal(packed.status, 0, packed.stderr);
+  const files = JSON.parse(packed.stdout)[0].files;
+  assert.ok(files.some(file => file.path === 'docs/mods/AUTHORING.md'), 'Agent authoring guide must ship because mint-core includes it at compile time');
+  assert.equal(files.some(file => /Live2DCubismCore|models\/Shiroko_Model/.test(file.path)), false, 'CLI npm package should leave character assets in the Companion installer');
+  const extracted = path.join(temporary, 'package');
+  for (const { path: name } of files) {
+    const destination = path.join(extracted, name);
+    fs.mkdirSync(path.dirname(destination), { recursive: true });
+    fs.copyFileSync(path.join(root, name), destination);
+  }
+  const metadata = spawnSync('cargo', ['metadata', '--locked', '--offline', '--no-deps', '--format-version', '1', '--manifest-path', path.join(extracted, 'Cargo.toml')], { encoding: 'utf8' });
+  assert.equal(metadata.status, 0, metadata.stderr);
+  const packages = JSON.parse(metadata.stdout).packages.map(pkg => pkg.name);
+  for (const name of ['mint-cli', 'mint-core', 'mint-mod-runtime', 'mint-desktop', 'mint-companion', 'mint-companion-protocol']) assert.ok(packages.includes(name), `${name} manifest missing from the installed package`);
+});

package/src/bin/release-notes.test.js

@@ -0,0 +1,84 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+// Compile the actual build script and reader in an isolated, dependency-free
+// crate so this catches Cargo invalidation as well as the returned text.
+function fixture(t, checkout) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'mint-release-notes-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  const crate = path.join(root, 'crates/mint-core');
+  fs.mkdirSync(crate, { recursive: true });
+  if (checkout) fs.mkdirSync(path.join(root, '.git'));
+  const repo = path.resolve(__dirname, '../..');
+  fs.copyFileSync(path.join(repo, 'crates/mint-core/build.rs'), path.join(crate, 'build.rs'));
+  fs.copyFileSync(path.join(repo, 'crates/mint-core/src/system/release_notes.rs'), path.join(crate, 'release_notes.rs'));
+  fs.writeFileSync(path.join(crate, 'Cargo.toml'), '[package]\nname="notes-fixture"\nversion="0.1.0"\nedition="2024"\n[[bin]]\nname="notes-fixture"\npath="main.rs"\n');
+  fs.writeFileSync(path.join(crate, 'main.rs'), 'mod release_notes; fn main() { print!("{}", release_notes::text()); }');
+  const env = { ...process.env, CARGO_TARGET_DIR: path.join(root, 'target') };
+  delete env.MINT_BUNDLE_RELEASE_NOTES;
+  const binary = path.join(root, 'target/debug', process.platform === 'win32' ? 'notes-fixture.exe' : 'notes-fixture');
+  const notes = path.join(root, 'Release_Note.md');
+  const caller = path.join(root, 'unrelated-workspace');
+  fs.mkdirSync(caller);
+  fs.writeFileSync(path.join(caller, 'Release_Note.md'), 'unrelated workspace notes');
+  const build = (bundle = false) => {
+    const result = spawnSync('cargo', ['run', '--quiet', '--offline', '--manifest-path', path.join(crate, 'Cargo.toml')], {
+      env: { ...env, ...(bundle ? { MINT_BUNDLE_RELEASE_NOTES: '1' } : {}) }, encoding: 'utf8',
+    });
+    assert.equal(result.status, 0, result.stderr);
+    return result.stdout;
+  };
+  const run = () => {
+    const result = spawnSync(binary, [], { cwd: caller, encoding: 'utf8' });
+    assert.equal(result.status, 0, result.stderr);
+    return result.stdout;
+  };
+  return { root, notes, build, run };
+}
+
+test('checkout reads live notes without rebuilding and retains its embedded fallback', t => {
+  const f = fixture(t, true);
+  fs.writeFileSync(f.notes, 'first snapshot');
+  assert.equal(f.build(), 'first snapshot');
+  fs.writeFileSync(f.notes, 'latest development notes');
+  assert.equal(f.run(), 'latest development notes');
+  assert.equal(f.build(), 'latest development notes');
+  fs.writeFileSync(f.notes, '   ');
+  assert.equal(f.run(), 'first snapshot');
+  fs.writeFileSync(f.notes, Buffer.from([255]));
+  assert.equal(f.run(), 'first snapshot');
+  fs.unlinkSync(f.notes);
+  // Cargo must not rerun the build script for a dev note edit/deletion.
+  assert.equal(f.build(), 'first snapshot');
+});
+
+test('bundled builds refresh embedded notes and ignore runtime checkout edits', t => {
+  const f = fixture(t, true);
+  fs.writeFileSync(f.notes, 'release one');
+  assert.equal(f.build(true), 'release one');
+  fs.writeFileSync(f.notes, 'runtime edits');
+  assert.equal(f.run(), 'release one');
+  assert.equal(f.build(true), 'runtime edits');
+  fs.unlinkSync(f.notes);
+  assert.equal(f.run(), 'runtime edits');
+  // Switching back to dev mode refreshes the live reader even in the same target.
+  fs.writeFileSync(f.notes, 'back to development');
+  assert.equal(f.build(), 'back to development');
+  fs.writeFileSync(f.notes, 'live again');
+  assert.equal(f.run(), 'live again');
+});
+
+test('source packages without git bundle current notes for standalone use', t => {
+  const f = fixture(t, false);
+  fs.writeFileSync(f.notes, 'npm release notes');
+  assert.equal(f.build(), 'npm release notes');
+  fs.writeFileSync(f.notes, 'new package notes');
+  assert.equal(f.run(), 'npm release notes');
+  assert.equal(f.build(), 'new package notes');
+  fs.unlinkSync(f.notes);
+  assert.equal(f.run(), 'new package notes');
+});

package/src/bin/styles.test.js

@@ -0,0 +1,20 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const postcss = require('postcss');
+
+for (const surface of ['src', 'src-web']) {
+  test(`${surface} sidebar keeps clear/settings button styles after removing Live2D`, () => {
+    const file = path.resolve(__dirname, `../renderer/${surface}/css/sidebar-workspace.css`);
+    const css = postcss.parse(fs.readFileSync(file, 'utf8'), { from: file });
+    for (const selector of ['.clear-btn', '.settings-btn']) {
+      const declarations = {};
+      css.walkRules(rule => {
+        if (rule.selectors.includes(selector)) rule.walkDecls(decl => { declarations[decl.prop] = decl.value; });
+      });
+      assert.equal(declarations.height, '28px', `${selector} should retain its hit area`);
+      assert.equal(declarations['border-radius'], 'var(--radius-sm)', `${selector} should retain its button appearance`);
+    }
+  });
+}

package/src/bin/web.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+// Reuse Mint's native binary discovery, argument forwarding, and exit handling.
+process.argv.splice(2, 0, 'web');
+require('./index.js');

package/src/bin/web.test.js

@@ -0,0 +1,39 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+function runLauncher(t, launcher, args, exitCode = 0) {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'mint-web-launcher-'));
+  t.after(() => fs.rmSync(directory, { recursive: true, force: true }));
+  const binary = path.join(directory, 'mint');
+  fs.writeFileSync(binary, '#!/usr/bin/env node\nconsole.log(JSON.stringify(process.argv.slice(2)));\nprocess.exit(Number(process.env.MINT_TEST_EXIT));\n');
+  fs.chmodSync(binary, 0o755);
+  return spawnSync(process.execPath, [launcher, ...args], {
+    encoding: 'utf8',
+    env: { ...process.env, MINT_BIN: binary, MINT_TEST_EXIT: String(exitCode) },
+  });
+}
+
+test('mint-web launches the web command and forwards arguments without shell expansion', (t) => {
+  const result = runLauncher(t, path.join(__dirname, 'web.js'), ['--dev', 'a b', '$(echo unexpected)']);
+  assert.equal(result.status, 0, result.stderr);
+  assert.deepEqual(JSON.parse(result.stdout), ['web', '--dev', 'a b', '$(echo unexpected)']);
+});
+
+test('the registered mint-web executable preserves the native exit code', (t) => {
+  const packageRoot = path.join(__dirname, '../..');
+  const packageConfig = require(path.join(packageRoot, 'package.json'));
+  const launcher = path.resolve(packageRoot, packageConfig.bin['mint-web'] || 'missing-mint-web');
+  const result = runLauncher(t, launcher, ['--help'], 7);
+  assert.equal(result.status, 7, result.stderr);
+  assert.deepEqual(JSON.parse(result.stdout), ['web', '--help']);
+});
+
+test('mint still forwards commands without adding web', (t) => {
+  const result = runLauncher(t, path.join(__dirname, 'index.js'), ['--resume', 'cli']);
+  assert.equal(result.status, 0, result.stderr);
+  assert.deepEqual(JSON.parse(result.stdout), ['--resume', 'cli']);
+});

package/src/renderer/index.html

@@ -6,8 +6,6 @@
   <title>Mint Agent</title>
   <link rel="icon" type="image/png" href="./assets/icon.png">
   <!-- Fonts are self-hosted through src/renderer/shared/fonts.ts for offline use. -->
-  <!-- Cubism must be available before the Live2D module is imported. -->
-  <script src="./Live2DCubismCore.js"></script>
 </head>
 <body>
   <div id="root"></div>

package/src/renderer/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -1 +1 @@
-{"version":"5.0.1","results":[[":shared/conversation/coordinator.test.ts",{"duration":8.497275000000002,"failed":false}],[":shared/platform.test.ts",{"duration":8.952371999999968,"failed":false}],[":shared/utils/uiGridJson.test.ts",{"duration":5.111367000000001,"failed":false}],[":shared/utils/cardJson.test.ts",{"duration":9.444902000000013,"failed":false}],[":shared/conversation/syncView.test.ts",{"duration":8.363666000000023,"failed":false}],[":shared/utils/markdown.webImages.test.tsx",{"duration":43.41150799999991,"failed":false}],[":src/components/liveTranslateFrames.test.ts",{"duration":6.5746560000000045,"failed":false}]]}
+{"version":"5.0.1","results":[[":shared/conversation/coordinator.test.ts",{"duration":10.89286999999996,"failed":false}],[":shared/platform.test.ts",{"duration":72.04032499999994,"failed":false}],[":shared/utils/uiGridJson.test.ts",{"duration":5.111367000000001,"failed":false}],[":shared/utils/cardJson.test.ts",{"duration":9.830214000000012,"failed":false}],[":shared/conversation/syncView.test.ts",{"duration":5.9297109999999975,"failed":false}],[":shared/utils/markdown.webImages.test.tsx",{"duration":35.845084999999926,"failed":false}],[":src/components/liveTranslateFrames.test.ts",{"duration":9.610723000000007,"failed":false}],[":shared/components/CliSessionsView.test.tsx",{"duration":63.182182000000466,"failed":false}],[":shared/components/Settings/MemoryTab.test.tsx",{"duration":24.459806999999955,"failed":false}],[":shared/theme/themeManager.test.ts",{"duration":9.833846000000051,"failed":false}],[":shared/utils/agentActivity.test.ts",{"duration":23.357340000000022,"failed":false}],[":shared/utils/contextCompaction.test.tsx",{"duration":19.515645000000063,"failed":false}],[":shared/components/SelectField.test.tsx",{"duration":15.430547999999817,"failed":false}],[":shared/utils/nativeRecordingSession.test.ts",{"duration":11.566851000000042,"failed":false}],[":shared/components/VoicePill.test.tsx",{"duration":17.43754600000011,"failed":false}],[":shared/components/GeminiLiveOverlay.test.tsx",{"duration":69.66832999999997,"failed":false}],[":shared/utils/mcpResults.test.tsx",{"duration":41.969848999999954,"failed":false}],[":shared/utils/notifications.test.ts",{"duration":19.051680000000033,"failed":false}],[":shared/utils/notificationSettings.test.ts",{"duration":7.376431999999994,"failed":false}],[":shared/components/Settings/NotificationsTab.test.tsx",{"duration":34.57106799999997,"failed":false}],[":shared/conversation/projectNavigation.test.ts",{"duration":13.245730000000037,"failed":false}],[":shared/components/WorkspacePreviewActions.test.tsx",{"duration":39.68878799999993,"failed":false}],[":shared/utils/workspacePreview.test.ts",{"duration":8.175780999999915,"failed":false}],[":shared/utils/artifactBrowser.test.ts",{"duration":21.136622999999986,"failed":false}],[":shared/utils/workspacePane.test.ts",{"duration":12.73853200000002,"failed":false}],[":shared/utils/workspaceSnapshot.test.ts",{"duration":13.065396000000021,"failed":false}],[":shared/utils/syntaxHighlight.test.tsx",{"duration":28.49105499999996,"failed":false}],[":shared/utils/progressCache.test.ts",{"duration":22.560924999999997,"failed":false}],[":shared/components/ChatMessageItem.test.tsx",{"duration":192.35519799999975,"failed":false}],[":shared/components/ApprovalCard.test.tsx",{"duration":21.503017999999997,"failed":false}],[":shared/conversation/lifecycle.test.ts",{"duration":44.59034600000018,"failed":false}],[":shared/conversation/transport.test.ts",{"duration":116.55244699999992,"failed":false}],[":shared/components/ModUi.test.tsx",{"duration":34.022662999999966,"failed":false}],[":shared/utils/pastedText.test.ts",{"duration":7.892500000000041,"failed":false}],[":shared/components/SlashSuggestions.test.tsx",{"duration":100.10946100000001,"failed":false}],[":shared/components/ToolSurfacePage.test.tsx",{"duration":19.68710800000008,"failed":false}],[":shared/utils/sessionSources.test.ts",{"duration":38.150642999999945,"failed":false}],[":shared/library/controller.test.ts",{"duration":17.544545000000028,"failed":false}],[":shared/library/transport.test.ts",{"duration":41.47815700000001,"failed":false}],[":shared/components/ChatPanel.test.tsx",{"duration":36.37873500000023,"failed":false}]]}

package/src/renderer/shared/agentProgress.ts

@@ -6,6 +6,9 @@
 import type { AgentProgress, InteractionMemory, DiffHunk, FileChange } from './types'
 export type { AgentProgress, InteractionMemory }
 
+export const EMPTY_AGENT_PROGRESS: AgentProgress[] = []
+const fileChangesCache = new WeakMap<AgentProgress[], { length: number; changes: FileChange[] }>()
+
 export function isInternalCot(text: string): boolean {
   const trimmed = text.trim()
   if (trimmed.startsWith('<think>') || trimmed.includes('</think>')) {
@@ -62,6 +65,8 @@ export function trimAgentProgress(progress: AgentProgress[], maxNonThought = 20)
   )
   return progress.filter(
     (event) =>
+      event.type === 'ToolArtifacts' || event.type === 'DeviceState' || event.type === 'ToolDiscovery' ||
+      ((event.type === 'ToolStart' || event.type === 'ToolEnd') && ['mcp_tool', 'view_image'].includes(event.data.action)) ||
       event.type === 'Thought' ||
       event.type === 'ThinkingDelta' ||
       event.type === 'ExtendedThinking' ||
@@ -74,6 +79,19 @@ export function reduceLiveAgentProgress(
   current: AgentProgress[],
   event: AgentProgress,
 ): AgentProgress[] {
+  if (event.type === 'DeviceState' && event.data.update.state !== 'accepted') {
+    const index = current.findIndex(item => item.type === 'DeviceState' && item.data.callId === event.data.callId && item.data.update.state !== 'accepted')
+    if (index >= 0) { const next=current.slice(); next[index]=event; return next }
+  }
+  if (event.type === 'ToolDiscovery') {
+    const index=current.findIndex(item=>item.type==='ToolDiscovery' && item.data.server===event.data.server && item.data.tool===event.data.tool)
+    if(index>=0) {const next=current.slice(); next[index]=event;return next}
+  }
+  if (event.type === 'ToolProgress') {
+    const index = current.findIndex(item => item.type === 'ToolProgress' && item.data.callId === event.data.callId)
+    if (index >= 0) { const next = current.slice(); next[index] = event; return next }
+  }
+
   if (event.type === 'ThinkingDelta') {
     const index = current.findIndex(
       (item) => item.type === 'ThinkingDelta' && item.data.id === event.data.id,
@@ -122,7 +140,14 @@ export function compactAgentProgressForPersistence(progress: AgentProgress[]): A
   )
   const result: AgentProgress[] = []
   const interrupted = new Map<string, Extract<AgentProgress, { type: 'ThinkingDelta' }>>()
+  const latestProgress = new Map<string, AgentProgress>()
   for (const event of progress) {
+    if (event.type === 'ToolProgress') latestProgress.set(event.data.callId, event)
+    if (event.type === 'DeviceState' && event.data.update.state !== 'accepted') latestProgress.set(`device:${event.data.callId}`,event)
+  }
+  for (const event of progress) {
+    if (event.type === 'ToolProgress' && latestProgress.get(event.data.callId) !== event) continue
+    if(event.type==='DeviceState' && event.data.update.state!=='accepted' && latestProgress.get(`device:${event.data.callId}`)!==event) continue
     if (event.type === 'ThinkingDelta') {
       if (!completedIds.has(event.data.id)) {
         const previous = interrupted.get(event.data.id)
@@ -178,6 +203,14 @@ export function parseAgentActivity(value: unknown): AgentProgress[] | undefined
 }
 
 export function parseFileChangesFromProgress(progress: AgentProgress[]): FileChange[] {
+  const cached = fileChangesCache.get(progress)
+  if (cached?.length === progress.length) return cached.changes
+  const changes = deriveFileChangesFromProgress(progress)
+  fileChangesCache.set(progress, { length: progress.length, changes })
+  return changes
+}
+
+function deriveFileChangesFromProgress(progress: AgentProgress[]): FileChange[] {
   const changes = new Map<string, FileChange>()
   let activeEdit: { action: string; path: string; created: boolean; additions: number; deletions: number; hunks: DiffHunk[] } | null = null
 

package/src/renderer/shared/components/AgentActivityDrawer.tsx

@@ -4,6 +4,7 @@
  * Shared by both Desktop and Web ChatPanel — do NOT duplicate this.
  */
 import React, { useState } from 'react'
+import { ChevronDown } from 'lucide-react'
 import type { AgentProgress, ActivePlan, RunTelemetrySummary } from '../types'
 import type { AgentActivityView } from '../utils/agentActivity'
 import { AgentActivityTable } from './AgentActivityTable'
@@ -165,7 +166,7 @@ export function AgentActivityDrawer({
           onClick={onToggle}
         >
           <span>{displaySummary}</span>
-          <span aria-hidden="true">{isOpen ? '^' : '>'}</span>
+          <ChevronDown size={13} className={`agent-activity-toggle-chevron${isOpen ? ' is-open' : ''}`} aria-hidden="true" />
         </button>
         {isOpen && (
           <div className="agent-activity-card agent-activity-card-history">
@@ -189,7 +190,7 @@ export function AgentActivityDrawer({
             >
               {pendingApproval ? 'Waiting for approval' : latestRunSummary ? 'Completed' : 'Working'}
             </span>
-            <span aria-hidden="true">{isOpen ? '^' : '>'}</span>
+            <ChevronDown size={13} className={`agent-activity-toggle-chevron${isOpen ? ' is-open' : ''}`} aria-hidden="true" />
           </div>
         </div>
         {isOpen && (

package/src/renderer/shared/components/AgentActivityTable.tsx

@@ -54,7 +54,7 @@ function renderActivityIcon(kind: AgentActivity['kind'], target: string, action?
 }
 
 function extractResultPreview(action: string | undefined, result: string | undefined): string | null {
-  if (!result || !result.trim()) return null
+  if (!result || !result.trim() || action === 'view_image') return null
   const firstLine = result.trim().split('\n')[0].trim()
   if (action === 'calculation') {
     const eqIdx = firstLine.indexOf('=')

package/src/renderer/shared/components/ApprovalCard.test.tsx

@@ -0,0 +1,24 @@
+import React from 'react'
+import { renderToStaticMarkup } from 'react-dom/server'
+import { describe, expect, it } from 'vitest'
+import { ApprovalCard } from './ApprovalCard'
+import { requiresExplicitApproval } from '../utils/approval'
+
+describe('skill approval', () => {
+  it('excludes skill proposals from session auto approval while keeping ordinary tool permissions', () => {
+    expect(requiresExplicitApproval({ SkillWrite: { path: 'SKILL.md' } })).toBe(true)
+    expect(requiresExplicitApproval({ WriteFile: { path: 'app.ts' } })).toBe(false)
+    expect(requiresExplicitApproval(undefined)).toBe(false)
+  })
+  it('shows the proposed skill and diff review without offering session permission', () => {
+    const html = renderToStaticMarkup(<ApprovalCard
+      pendingApproval={{ approval: { SkillWrite: { path: '.agents/skills/build/SKILL.md', diff: '+Use the build command', content: 'Use the build command' } } }}
+      onApproval={() => {}}
+    />)
+    expect(html).toContain('.agents/skills/build/SKILL.md')
+    expect(html).toContain('Review')
+    expect(html).toContain('Allow once')
+    expect(html).toContain('Reject')
+    expect(html).not.toContain('Always allow for this session')
+  })
+})

package/src/renderer/shared/components/ApprovalCard.tsx

@@ -27,9 +27,10 @@ export function ApprovalCard({ pendingApproval, onApproval }: Props) {
   const details = renderApprovalDetails(pendingApproval.approval)
   const writeFile = pendingApproval.approval?.WriteFile
   const applyPatch = pendingApproval.approval?.ApplyPatch
+  const skillWrite = pendingApproval.approval?.SkillWrite
   const runShell = pendingApproval.approval?.RunShell
-  const targetFilePath = writeFile?.path || applyPatch?.path || 'Code Change'
-  const diffText = writeFile?.diff || applyPatch?.diff
+  const targetFilePath = skillWrite?.path || writeFile?.path || applyPatch?.path || 'Code Change'
+  const diffText = skillWrite?.diff || writeFile?.diff || applyPatch?.diff
   const isAskUser = !!pendingApproval.approval?.AskUser
   const mcpTool = pendingApproval.approval?.McpTool
   const MCP_ALLOW_ALL_SENTINEL = '__mcp_allow_all__'
@@ -57,6 +58,7 @@ export function ApprovalCard({ pendingApproval, onApproval }: Props) {
 
   // Get badge label based on action type
   const getToolMeta = () => {
+    if (skillWrite) return { badge: 'Skill Change', badgeClass: 'edit' }
     if (runShell) return { badge: 'Run Command', badgeClass: details.isDangerous ? 'dangerous' : 'command' }
     if (writeFile || applyPatch) return { badge: 'File Edit', badgeClass: 'edit' }
     if (mcpTool) return { badge: `MCP: ${mcpTool.server}`, badgeClass: 'mcp' }
@@ -67,7 +69,12 @@ export function ApprovalCard({ pendingApproval, onApproval }: Props) {
   const toolMeta = getToolMeta()
 
   // Standard non-AskUser choices
-  const actionChoices = mcpTool
+  const actionChoices = skillWrite
+    ? [
+        { key: '1', title: 'Allow once', variant: 'approve', action: () => onApproval(true, false) },
+        { key: '2', title: 'Reject', variant: 'cancel', action: () => onApproval(false) },
+      ]
+    : mcpTool
     ? [
         {
           key: '1',