claude-code-session-manager 0.46.0 → 0.47.0

package/dist/index.html

@@ -7,10 +7,10 @@
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=Newsreader:ital,opsz,wght@0,6..72,400;0,6..72,500;0,6..72,600;0,6..72,700;1,6..72,400&family=Geist:wght@300;400;500;600;700&family=IBM+Plex+Mono:wght@400;500;600&display=swap" rel="stylesheet">
-    <script type="module" crossorigin src="./assets/index-DCjBivhu.js"></script>
+    <script type="module" crossorigin src="./assets/index-Jb71TRGj.js"></script>
     <link rel="modulepreload" crossorigin href="./assets/monaco-editor-BW5C4Iv1.js">
     <link rel="stylesheet" crossorigin href="./assets/monaco-editor-BTnBOi8r.css">
-    <link rel="stylesheet" crossorigin href="./assets/index-DoZZVoph.css">
+    <link rel="stylesheet" crossorigin href="./assets/index-B6DLwpeA.css">
   </head>
   <body class="bg-bg text-fg font-sans antialiased">
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-session-manager",
-  "version": "0.46.0",
+  "version": "0.47.0",
   "description": "Local cockpit for the Claude Code CLI — multi-tab terminal, full config surface, scheduler, voice dictation, and live observability.",
   "type": "module",
   "main": "src/main/index.cjs",

package/plugins/session-manager-dev/skills/develop/SKILL.md

@@ -37,6 +37,16 @@ one it had to guess at. Before doing anything else:
    inside that Epic. Do not mint one yourself, do not fall back to writing an epicless PRD, and
    do not proceed with authoring.
 
+**Tag-aware default (2026-08-01).** The Epic's own intent tag (`feature` / `bug` /
+`discussion` — CLAUDE.md's domain model) sets how eagerly this skill should fire, not just
+what to write once it does:
+- **`feature` / `bug`** — decomposition into PRDs is the expected default path for these once
+  scope is reasonably clear. Reach for `/develop` proactively; don't wait to be re-asked.
+- **`discussion`** — whether development is even warranted is often still the open question.
+  `/develop` stays fully available inside a Discussion Epic (a discussion can conclude "yes,
+  build this"), but never assume it's the next step — don't jump straight to decomposing PRDs
+  just because the conversation is active. Keep exploring/deciding until that's actually settled.
+
 **Never** hand-implement the work inline in chat, and never restate rules that live elsewhere:
 the engineering rules belong to `standards.md`. Reference it; don't fork it.
 

package/src/main/lib/__tests__/toolUseClassify.test.cjs

@@ -0,0 +1,53 @@
+/**
+ * toolUseClassify.test.cjs — unit tests for src/main/lib/toolUseClassify.cjs.
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/toolUseClassify.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+
+const { classifyToolUse, MAX_DIFF_STR } = require('../toolUseClassify.cjs');
+
+test('Edit tool_use produces a diff payload with filePath/oldText/newText', () => {
+  const block = {
+    name: 'Edit',
+    input: { file_path: '/tmp/foo.js', old_string: 'a', new_string: 'b' },
+  };
+  const result = classifyToolUse(block);
+  expect(result.kind).toBe('tool');
+  expect(result.diff).toEqual({ filePath: '/tmp/foo.js', oldText: 'a', newText: 'b' });
+});
+
+test('Write tool_use produces a diff payload with filePath/newText only', () => {
+  const block = { name: 'Write', input: { file_path: '/tmp/bar.js', content: 'hello' } };
+  const result = classifyToolUse(block);
+  expect(result.diff).toEqual({ filePath: '/tmp/bar.js', newText: 'hello' });
+});
+
+test('non-Edit/Write tool_use has no diff field', () => {
+  const block = { name: 'Bash', input: { command: 'ls' } };
+  const result = classifyToolUse(block);
+  expect(result.diff).toBeUndefined();
+  expect('diff' in result).toBe(false);
+});
+
+test('Skill/mcp tool_use never get a diff field', () => {
+  expect(classifyToolUse({ name: 'Skill', input: { skill: 'x' } }).diff).toBeUndefined();
+  expect(classifyToolUse({ name: 'mcp__foo__bar', input: {} }).diff).toBeUndefined();
+});
+
+test('oversized Edit strings are capped at MAX_DIFF_STR', () => {
+  const big = 'x'.repeat(MAX_DIFF_STR + 100);
+  const block = { name: 'Edit', input: { file_path: '/tmp/foo.js', old_string: big, new_string: big } };
+  const result = classifyToolUse(block);
+  expect(result.diff.oldText.length).toBe(MAX_DIFF_STR + 1); // + ellipsis char
+  expect(result.diff.oldText.endsWith('…')).toBe(true);
+});
+
+test('Edit block missing file_path yields no diff', () => {
+  const block = { name: 'Edit', input: { old_string: 'a', new_string: 'b' } };
+  const result = classifyToolUse(block);
+  expect(result.diff).toBeUndefined();
+});

package/src/main/lib/toolUseClassify.cjs

@@ -1,10 +1,46 @@
 'use strict';
 
+// Same cap classifyTranscriptLine.cjs uses (MAX_RAW_STR) for raw tool_use
+// content — reused here so a large Edit/Write payload can't bloat the
+// in-memory ChatTurn / localStorage-persisted chat state.
+const MAX_DIFF_STR = 4096;
+
+function capStr(s) {
+  if (typeof s !== 'string') return s;
+  return s.length > MAX_DIFF_STR ? `${s.slice(0, MAX_DIFF_STR)}…` : s;
+}
+
+/**
+ * Pull a diff payload out of an Edit/Write tool_use block's `input`.
+ * Returns undefined for any other tool (including malformed Edit/Write
+ * blocks missing `file_path`).
+ * @param {{name: string, input?: Record<string, unknown>}} block
+ * @returns {{ filePath: string, oldText?: string, newText?: string } | undefined}
+ */
+function extractDiff(block) {
+  const input = block?.input;
+  if (!input || typeof input !== 'object' || typeof input.file_path !== 'string') return undefined;
+  if (block.name === 'Edit') {
+    return {
+      filePath: input.file_path,
+      oldText: capStr(input.old_string),
+      newText: capStr(input.new_string),
+    };
+  }
+  if (block.name === 'Write') {
+    return {
+      filePath: input.file_path,
+      newText: capStr(input.content),
+    };
+  }
+  return undefined;
+}
+
 /**
  * Classify a single stream-json tool_use block into a UI-facing kind.
  * O(1) — no loops, pure string/prefix checks.
  * @param {{name: string, input?: Record<string, unknown>}} block
- * @returns {{ kind: 'skill' | 'mcp' | 'tool', label: string }}
+ * @returns {{ kind: 'skill' | 'mcp' | 'tool', label: string, diff?: { filePath: string, oldText?: string, newText?: string } }}
  */
 function classifyToolUse(block) {
   if (block.name === 'Skill') {
@@ -13,7 +49,8 @@ function classifyToolUse(block) {
   if (block.name.startsWith('mcp__')) {
     return { kind: 'mcp', label: block.name.replace(/^mcp__/, '') };
   }
-  return { kind: 'tool', label: block.name };
+  const diff = extractDiff(block);
+  return diff ? { kind: 'tool', label: block.name, diff } : { kind: 'tool', label: block.name };
 }
 
-module.exports = { classifyToolUse };
+module.exports = { classifyToolUse, extractDiff, MAX_DIFF_STR };

package/src/preload/api.d.ts

@@ -1121,6 +1121,8 @@ export interface ChatRunToolUseEvent {
   id: string;
   kind: 'skill' | 'mcp' | 'tool';
   label: string;
+  /** Populated only for Edit/Write tool_use blocks; undefined for every other kind. */
+  diff?: { filePath: string; oldText?: string; newText?: string };
 }
 
 export interface ChatRunNeedsInputEvent {