@staff0rd/assist 0.562.0 → 0.563.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.562.0",
+  version: "0.563.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -13393,26 +13393,8 @@ async function web2(options2) {
 import chalk64 from "chalk";
 
 // src/commands/sessions/shared/resolveSessionTranscript.ts
-import * as fs23 from "fs";
-import * as path31 from "path";
-
-// src/commands/sessions/summarise/readTranscriptTail.ts
 import * as fs22 from "fs";
-function readTranscriptTail(filePath, maxBytes = 65536) {
-  let fd;
-  try {
-    const { size } = fs22.statSync(filePath);
-    const start3 = Math.max(0, size - maxBytes);
-    fd = fs22.openSync(filePath, "r");
-    const buf = Buffer.alloc(size - start3);
-    const bytesRead = fs22.readSync(fd, buf, 0, buf.length, start3);
-    return buf.toString("utf8", 0, bytesRead);
-  } catch {
-    return void 0;
-  } finally {
-    if (fd !== void 0) fs22.closeSync(fd);
-  }
-}
+import * as path31 from "path";
 
 // src/commands/sessions/shared/claudeProjectsRoot.ts
 import * as os4 from "os";
@@ -13425,47 +13407,33 @@ function projectSlug(cwd) {
 }
 
 // src/commands/sessions/shared/resolveSessionTranscript.ts
+var MAX_PROMPT_LENGTH = 80;
 function resolveSessionTranscript(sessionId, projectsRoot = claudeProjectsRoot()) {
   const filePath = findTranscriptFile(sessionId, projectsRoot);
   if (!filePath) return void 0;
-  const meta = extractSessionMeta(splitLines(readTranscriptHead(filePath)));
-  return {
-    path: filePath,
-    prompt: meta.name || void 0,
-    firstTimestamp: meta.timestamp || void 0,
-    lastTimestamp: lastTimestamp(splitLines(readTranscriptTail(filePath)))
-  };
+  const head = readTranscriptHead(filePath);
+  const meta = extractSessionMeta(head ? head.split("\n").filter(Boolean) : []);
+  return { path: filePath, prompt: promptOf(meta) };
 }
 function findTranscriptFile(sessionId, projectsRoot) {
   let projectDirs;
   try {
-    projectDirs = fs23.readdirSync(projectsRoot);
+    projectDirs = fs22.readdirSync(projectsRoot);
   } catch {
     return void 0;
   }
   for (const dir of projectDirs) {
     const candidate = path31.join(projectsRoot, dir, `${sessionId}.jsonl`);
-    if (fs23.existsSync(candidate)) return candidate;
+    if (fs22.existsSync(candidate)) return candidate;
   }
   return void 0;
 }
-function splitLines(content) {
-  return content ? content.split("\n").filter(Boolean) : [];
-}
-function lastTimestamp(lines2) {
-  for (const line of lines2.reverse()) {
-    const timestamp6 = timestampOf(line);
-    if (timestamp6) return timestamp6;
-  }
-  return void 0;
-}
-function timestampOf(line) {
-  try {
-    const entry = JSON.parse(line);
-    return typeof entry.timestamp === "string" ? entry.timestamp : void 0;
-  } catch {
-    return void 0;
-  }
+function promptOf(meta) {
+  if (meta.name) return meta.name;
+  if (!meta.commandName) return void 0;
+  const command = `/${meta.commandName}`;
+  const rendered = meta.commandArgs ? `${command} ${meta.commandArgs}` : command;
+  return rendered.slice(0, MAX_PROMPT_LENGTH);
 }
 
 // src/commands/backlog/addActivity.ts
@@ -13506,7 +13474,7 @@ async function addActivity(id, kind, ref, options2) {
 import chalk65 from "chalk";
 
 // src/commands/sessions/shared/resolveCurrentSessionId.ts
-import * as fs24 from "fs";
+import * as fs23 from "fs";
 import * as path32 from "path";
 var SESSION_ID_ENV = "CLAUDE_CODE_SESSION_ID";
 function resolveCurrentSessionId(options2 = {}) {
@@ -13521,7 +13489,7 @@ function resolveCurrentSessionId(options2 = {}) {
 function newestTranscriptId(dir) {
   let entries;
   try {
-    entries = fs24.readdirSync(dir);
+    entries = fs23.readdirSync(dir);
   } catch {
     return void 0;
   }
@@ -13537,7 +13505,7 @@ function newestTranscriptId(dir) {
 }
 function modifiedAtOf(filePath) {
   try {
-    return fs24.statSync(filePath).mtimeMs;
+    return fs23.statSync(filePath).mtimeMs;
   } catch {
     return void 0;
   }
@@ -17579,7 +17547,7 @@ function getPinStatePath(pin) {
 }
 
 // src/commands/codeComment/sweepRestrictedDir.ts
-import { readdirSync as readdirSync5, statSync as statSync7, unlinkSync as unlinkSync7 } from "fs";
+import { readdirSync as readdirSync5, statSync as statSync6, unlinkSync as unlinkSync7 } from "fs";
 import { join as join41 } from "path";
 var STALE_AFTER_MS = 30 * 60 * 1e3;
 function sweepRestrictedDir(dir = getRestrictedDir()) {
@@ -17593,7 +17561,7 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
   for (const entry of entries) {
     const path80 = join41(dir, entry);
     try {
-      if (statSync7(path80).mtimeMs < cutoff) unlinkSync7(path80);
+      if (statSync6(path80).mtimeMs < cutoff) unlinkSync7(path80);
     } catch {
       continue;
     }
@@ -17841,13 +17809,13 @@ import chalk132 from "chalk";
 import chalk125 from "chalk";
 
 // src/commands/complexity/shared/index.ts
-import fs26 from "fs";
+import fs25 from "fs";
 import path34 from "path";
 import chalk124 from "chalk";
 import ts5 from "typescript";
 
 // src/commands/complexity/findSourceFiles.ts
-import fs25 from "fs";
+import fs24 from "fs";
 import path33 from "path";
 import { minimatch as minimatch5 } from "minimatch";
 function applyIgnoreGlobs(files, extraIgnore = []) {
@@ -17856,11 +17824,11 @@ function applyIgnoreGlobs(files, extraIgnore = []) {
   return files.filter((f) => !ignore3.some((glob) => minimatch5(f, glob)));
 }
 function walk2(dir, results) {
-  if (!fs25.existsSync(dir)) {
+  if (!fs24.existsSync(dir)) {
     return;
   }
   const extensions = [".ts", ".tsx"];
-  const entries = fs25.readdirSync(dir, { withFileTypes: true });
+  const entries = fs24.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = path33.join(dir, entry.name);
     if (entry.isDirectory()) {
@@ -17881,10 +17849,10 @@ function findSourceFiles2(pattern2, baseDir = ".", extraIgnore = []) {
       extraIgnore
     );
   }
-  if (fs25.existsSync(pattern2) && fs25.statSync(pattern2).isFile()) {
+  if (fs24.existsSync(pattern2) && fs24.statSync(pattern2).isFile()) {
     return [pattern2];
   }
-  if (fs25.existsSync(pattern2) && fs25.statSync(pattern2).isDirectory()) {
+  if (fs24.existsSync(pattern2) && fs24.statSync(pattern2).isDirectory()) {
     walk2(pattern2, results);
     return applyIgnoreGlobs(results, extraIgnore);
   }
@@ -18082,7 +18050,7 @@ function countSloc(content) {
 
 // src/commands/complexity/shared/index.ts
 function createSourceFromFile(filePath) {
-  const content = fs26.readFileSync(filePath, "utf8");
+  const content = fs25.readFileSync(filePath, "utf8");
   return ts5.createSourceFile(
     path34.basename(filePath),
     content,
@@ -18194,7 +18162,7 @@ function aggregateResults(fileMetrics) {
 }
 
 // src/commands/complexity/maintainability/collectFileMetrics.ts
-import fs27 from "fs";
+import fs26 from "fs";
 
 // src/commands/complexity/maintainability/calculateMaintainabilityIndex.ts
 function calculateMaintainabilityIndex(halsteadVolume, cyclomaticComplexity, sloc2) {
@@ -18209,7 +18177,7 @@ function calculateMaintainabilityIndex(halsteadVolume, cyclomaticComplexity, slo
 function collectFileMetrics(files) {
   const fileMetrics = /* @__PURE__ */ new Map();
   for (const file of files) {
-    const content = fs27.readFileSync(file, "utf8");
+    const content = fs26.readFileSync(file, "utf8");
     fileMetrics.set(file, {
       sloc: countSloc(content),
       functions: [],
@@ -18370,14 +18338,14 @@ async function maintainability(pattern2 = "**/*.ts", options2 = {}) {
 }
 
 // src/commands/complexity/sloc.ts
-import fs28 from "fs";
+import fs27 from "fs";
 import chalk131 from "chalk";
 async function sloc(pattern2 = "**/*.ts", options2 = {}) {
   withSourceFiles(pattern2, (files) => {
     const results = [];
     let hasViolation = false;
     for (const file of files) {
-      const content = fs28.readFileSync(file, "utf8");
+      const content = fs27.readFileSync(file, "utf8");
       const lines2 = countSloc(content);
       results.push({ file, lines: lines2 });
       if (options2.threshold !== void 0 && lines2 > options2.threshold) {
@@ -19443,7 +19411,7 @@ function registerDevlog(program2) {
 }
 
 // src/commands/dotnet/checkBuildLocks.ts
-import { closeSync as closeSync4, openSync as openSync4, readdirSync as readdirSync7 } from "fs";
+import { closeSync as closeSync3, openSync as openSync3, readdirSync as readdirSync7 } from "fs";
 import { join as join47 } from "path";
 import chalk150 from "chalk";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "packages"]);
@@ -19458,8 +19426,8 @@ function isLockedDll(debugDir) {
     if (!file.toLowerCase().endsWith(".dll")) continue;
     const dllPath = join47(debugDir, file);
     try {
-      const fd = openSync4(dllPath, "r+");
-      closeSync4(fd);
+      const fd = openSync3(dllPath, "r+");
+      closeSync3(fd);
     } catch {
       return dllPath;
     }
@@ -19549,7 +19517,7 @@ function collectAllDeps(node) {
 }
 
 // src/commands/dotnet/findContainingSolutions.ts
-import { readdirSync as readdirSync8, readFileSync as readFileSync35, statSync as statSync8 } from "fs";
+import { readdirSync as readdirSync8, readFileSync as readFileSync35, statSync as statSync7 } from "fs";
 import path38 from "path";
 function findSlnFiles(dir, maxDepth, depth = 0) {
   if (depth > maxDepth) return [];
@@ -19565,7 +19533,7 @@ function findSlnFiles(dir, maxDepth, depth = 0) {
       continue;
     const full = path38.join(dir, entry);
     try {
-      const stat4 = statSync8(full);
+      const stat4 = statSync7(full);
       if (stat4.isFile() && entry.endsWith(".sln")) {
         results.push(full);
       } else if (stat4.isDirectory()) {
@@ -20053,7 +20021,7 @@ function registerDotnet(program2) {
 }
 
 // src/commands/editHook/index.ts
-import fs29 from "fs";
+import fs28 from "fs";
 
 // src/commands/editHook/introducedComments.ts
 function introducedComments(added, removed) {
@@ -20300,7 +20268,7 @@ function tryParseInput2(raw) {
 function readExisting(filePath) {
   if (!filePath) return void 0;
   try {
-    return fs29.readFileSync(filePath, "utf8");
+    return fs28.readFileSync(filePath, "utf8");
   } catch {
     return void 0;
   }
@@ -20563,7 +20531,7 @@ import {
   readdirSync as readdirSync10,
   readFileSync as readFileSync37,
   rmSync as rmSync3,
-  statSync as statSync9
+  statSync as statSync8
 } from "fs";
 import { basename as basename14, join as join52 } from "path";
 
@@ -20636,13 +20604,13 @@ async function migrateFile(orm, origin, file, createdAt) {
 async function migrateDiskHandovers(orm, origin, cwd = process.cwd()) {
   let migrated = 0;
   for (const file of collectMarkdown(getHandoversDir(cwd))) {
-    const createdAt = parseArchiveTimestamp(basename14(file)) ?? statSync9(file).mtime;
+    const createdAt = parseArchiveTimestamp(basename14(file)) ?? statSync8(file).mtime;
     await migrateFile(orm, origin, file, createdAt);
     migrated++;
   }
   const handoverPath = getHandoverPath(cwd);
   if (existsSync46(handoverPath)) {
-    await migrateFile(orm, origin, handoverPath, statSync9(handoverPath).mtime);
+    await migrateFile(orm, origin, handoverPath, statSync8(handoverPath).mtime);
     migrated++;
   }
   return migrated;
@@ -24657,17 +24625,17 @@ Refactor check failed:
 
 // src/commands/refactor/check/getViolations/index.ts
 import { execSync as execSync53 } from "child_process";
-import fs31 from "fs";
+import fs30 from "fs";
 import { minimatch as minimatch6 } from "minimatch";
 
 // src/commands/refactor/check/getViolations/getIgnoredFiles.ts
-import fs30 from "fs";
+import fs29 from "fs";
 var REFACTOR_YML_PATH = "refactor.yml";
 function parseRefactorYml() {
-  if (!fs30.existsSync(REFACTOR_YML_PATH)) {
+  if (!fs29.existsSync(REFACTOR_YML_PATH)) {
     return [];
   }
-  const content = fs30.readFileSync(REFACTOR_YML_PATH, "utf8");
+  const content = fs29.readFileSync(REFACTOR_YML_PATH, "utf8");
   const entries = [];
   const lines2 = content.split("\n");
   let currentEntry = {};
@@ -24697,7 +24665,7 @@ function getIgnoredFiles() {
 
 // src/commands/refactor/check/getViolations/index.ts
 function countLines(filePath) {
-  const content = fs31.readFileSync(filePath, "utf8");
+  const content = fs30.readFileSync(filePath, "utf8");
   return content.split("\n").length;
 }
 function getGitFiles(options2) {
@@ -25455,11 +25423,11 @@ import chalk189 from "chalk";
 import { Project as Project4 } from "ts-morph";
 
 // src/commands/refactor/extract/findTsConfig.ts
-import fs33 from "fs";
+import fs32 from "fs";
 import path48 from "path";
 
 // src/commands/refactor/extract/findEnclosingTsConfig.ts
-import fs32 from "fs";
+import fs31 from "fs";
 import path47 from "path";
 
 // src/commands/refactor/extract/projectIncludesFile.ts
@@ -25480,7 +25448,7 @@ function findEnclosingTsConfig(sourcePath, rootDir, tried) {
     const nested = path47.join(dir, "tsconfig.json");
     if (!tried.has(nested)) {
       tried.add(nested);
-      if (fs32.existsSync(nested) && projectIncludesFile(nested, sourcePath)) {
+      if (fs31.existsSync(nested) && projectIncludesFile(nested, sourcePath)) {
         return nested;
       }
     }
@@ -25494,7 +25462,7 @@ function findEnclosingTsConfig(sourcePath, rootDir, tried) {
 // src/commands/refactor/extract/findTsConfig.ts
 function findTsConfig(sourcePath) {
   const rootConfig = path48.resolve("tsconfig.json");
-  if (!fs33.existsSync(rootConfig)) return rootConfig;
+  if (!fs32.existsSync(rootConfig)) return rootConfig;
   const tried = /* @__PURE__ */ new Set();
   const candidates = [rootConfig, ...readReferences(rootConfig)];
   for (const candidate of candidates) {
@@ -25502,7 +25470,7 @@ function findTsConfig(sourcePath) {
     tried.add(candidate);
     if (projectIncludesFile(candidate, sourcePath)) return candidate;
   }
-  const siblings = fs33.readdirSync(path48.dirname(rootConfig)).filter((f) => /^tsconfig.*\.json$/.test(f)).map((f) => path48.resolve(path48.dirname(rootConfig), f));
+  const siblings = fs32.readdirSync(path48.dirname(rootConfig)).filter((f) => /^tsconfig.*\.json$/.test(f)).map((f) => path48.resolve(path48.dirname(rootConfig), f));
   for (const sibling of siblings) {
     if (tried.has(sibling)) continue;
     tried.add(sibling);
@@ -25517,8 +25485,8 @@ function findTsConfig(sourcePath) {
   return rootConfig;
 }
 function readReferences(configPath) {
-  if (!fs33.existsSync(configPath)) return [];
-  const raw = fs33.readFileSync(configPath, "utf8");
+  if (!fs32.existsSync(configPath)) return [];
+  const raw = fs32.readFileSync(configPath, "utf8");
   const stripped = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
   let parsed;
   try {
@@ -25530,8 +25498,8 @@ function readReferences(configPath) {
   const cwd = path48.dirname(configPath);
   return parsed.references.map((ref) => {
     const refPath = path48.resolve(cwd, ref.path);
-    return fs33.statSync(refPath, { throwIfNoEntry: false })?.isDirectory() ? path48.join(refPath, "tsconfig.json") : refPath;
-  }).filter((p) => fs33.existsSync(p));
+    return fs32.statSync(refPath, { throwIfNoEntry: false })?.isDirectory() ? path48.join(refPath, "tsconfig.json") : refPath;
+  }).filter((p) => fs32.existsSync(p));
 }
 
 // src/commands/refactor/extract/loadProjectFile.ts
@@ -25573,25 +25541,25 @@ async function extract(file, functionName, destination, options2 = {}) {
 }
 
 // src/commands/refactor/ignore.ts
-import fs34 from "fs";
+import fs33 from "fs";
 import chalk191 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore2(file) {
-  if (!fs34.existsSync(file)) {
+  if (!fs33.existsSync(file)) {
     console.error(chalk191.red(`Error: File does not exist: ${file}`));
     process.exit(1);
   }
-  const content = fs34.readFileSync(file, "utf8");
+  const content = fs33.readFileSync(file, "utf8");
   const lineCount = content.split("\n").length;
   const maxLines = lineCount + 10;
   const entry = `- file: ${file}
   maxLines: ${maxLines}
 `;
-  if (fs34.existsSync(REFACTOR_YML_PATH2)) {
-    const existing = fs34.readFileSync(REFACTOR_YML_PATH2, "utf8");
-    fs34.writeFileSync(REFACTOR_YML_PATH2, existing + entry);
+  if (fs33.existsSync(REFACTOR_YML_PATH2)) {
+    const existing = fs33.readFileSync(REFACTOR_YML_PATH2, "utf8");
+    fs33.writeFileSync(REFACTOR_YML_PATH2, existing + entry);
   } else {
-    fs34.writeFileSync(REFACTOR_YML_PATH2, entry);
+    fs33.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
     chalk191.green(
@@ -25601,12 +25569,12 @@ function ignore2(file) {
 }
 
 // src/commands/refactor/rename/index.ts
-import fs37 from "fs";
+import fs36 from "fs";
 import path55 from "path";
 import chalk194 from "chalk";
 
 // src/commands/refactor/rename/applyRename.ts
-import fs36 from "fs";
+import fs35 from "fs";
 import path52 from "path";
 import chalk192 from "chalk";
 
@@ -25614,7 +25582,7 @@ import chalk192 from "chalk";
 import path51 from "path";
 
 // src/commands/refactor/restructure/computeRewrites/applyRewrites.ts
-import fs35 from "fs";
+import fs34 from "fs";
 function getOrCreateList(map, key) {
   const list5 = map.get(key) ?? [];
   if (!map.has(key)) map.set(key, list5);
@@ -25633,7 +25601,7 @@ function rewriteSpecifier(content, oldSpecifier, newSpecifier) {
   return content.replace(pattern2, `$1${newSpecifier}$2`);
 }
 function applyFileRewrites(file, fileRewrites) {
-  let content = fs35.readFileSync(file, "utf8");
+  let content = fs34.readFileSync(file, "utf8");
   for (const { oldSpecifier, newSpecifier } of fileRewrites) {
     content = rewriteSpecifier(content, oldSpecifier, newSpecifier);
   }
@@ -25712,12 +25680,12 @@ function computeRewrites(moves, edges, allProjectFiles) {
 function applyRename(rewrites, sourcePath, destPath, cwd) {
   const updatedContents = applyRewrites(rewrites);
   for (const [file, content] of updatedContents) {
-    fs36.writeFileSync(file, content, "utf8");
+    fs35.writeFileSync(file, content, "utf8");
     console.log(chalk192.cyan(`  Updated imports in ${path52.relative(cwd, file)}`));
   }
   const destDir = path52.dirname(destPath);
-  if (!fs36.existsSync(destDir)) fs36.mkdirSync(destDir, { recursive: true });
-  fs36.renameSync(sourcePath, destPath);
+  if (!fs35.existsSync(destDir)) fs35.mkdirSync(destDir, { recursive: true });
+  fs35.renameSync(sourcePath, destPath);
   console.log(
     chalk192.white(
       `  Moved ${path52.relative(cwd, sourcePath)} \u2192 ${path52.relative(cwd, destPath)}`
@@ -25825,11 +25793,11 @@ async function rename(source, destination, options2 = {}) {
   const cwd = process.cwd();
   const relSource = path55.relative(cwd, sourcePath);
   const relDest = path55.relative(cwd, destPath);
-  if (!fs37.existsSync(sourcePath)) {
+  if (!fs36.existsSync(sourcePath)) {
     console.log(chalk194.red(`File not found: ${source}`));
     process.exit(1);
   }
-  if (destPath !== sourcePath && fs37.existsSync(destPath)) {
+  if (destPath !== sourcePath && fs36.existsSync(destPath)) {
     console.log(chalk194.red(`Destination already exists: ${destination}`));
     process.exit(1);
   }
@@ -26054,27 +26022,27 @@ Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports r
 }
 
 // src/commands/refactor/restructure/executePlan.ts
-import fs38 from "fs";
+import fs37 from "fs";
 import path60 from "path";
 import chalk197 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
-    fs38.writeFileSync(file, content, "utf8");
+    fs37.writeFileSync(file, content, "utf8");
     console.log(
       chalk197.cyan(`  Rewrote imports in ${path60.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
-    fs38.mkdirSync(dir, { recursive: true });
+    fs37.mkdirSync(dir, { recursive: true });
     console.log(chalk197.green(`  Created ${path60.relative(process.cwd(), dir)}/`));
   }
   for (const move2 of plan2.moves) {
     const targetDir = path60.dirname(move2.to);
-    if (!fs38.existsSync(targetDir)) {
-      fs38.mkdirSync(targetDir, { recursive: true });
+    if (!fs37.existsSync(targetDir)) {
+      fs37.mkdirSync(targetDir, { recursive: true });
     }
-    fs38.renameSync(move2.from, move2.to);
+    fs37.renameSync(move2.from, move2.to);
     console.log(
       chalk197.white(
         `  Moved ${path60.relative(process.cwd(), move2.from)} \u2192 ${path60.relative(process.cwd(), move2.to)}`
@@ -26086,10 +26054,10 @@ function executePlan(plan2) {
 function removeEmptyDirectories(dirs) {
   const unique = [...new Set(dirs)];
   for (const dir of unique) {
-    if (!fs38.existsSync(dir)) continue;
-    const entries = fs38.readdirSync(dir);
+    if (!fs37.existsSync(dir)) continue;
+    const entries = fs37.readdirSync(dir);
     if (entries.length === 0) {
-      fs38.rmdirSync(dir);
+      fs37.rmdirSync(dir);
       console.log(
         chalk197.dim(
           `  Removed empty directory ${path60.relative(process.cwd(), dir)}`
@@ -26103,18 +26071,18 @@ function removeEmptyDirectories(dirs) {
 import path62 from "path";
 
 // src/commands/refactor/restructure/planFileMoves/shared.ts
-import fs39 from "fs";
+import fs38 from "fs";
 function emptyResult() {
   return { moves: [], directories: [], warnings: [] };
 }
 function checkDirConflict(result, label2, dir) {
-  if (!fs39.existsSync(dir)) return false;
+  if (!fs38.existsSync(dir)) return false;
   result.warnings.push(`Skipping ${label2}: directory ${dir} already exists`);
   return true;
 }
 
 // src/commands/refactor/restructure/planFileMoves/planDirectoryMoves.ts
-import fs40 from "fs";
+import fs39 from "fs";
 import path61 from "path";
 function collectEntry2(results, dir, entry) {
   const full = path61.join(dir, entry.name);
@@ -26122,9 +26090,9 @@ function collectEntry2(results, dir, entry) {
   results.push(...items2);
 }
 function listFilesRecursive(dir) {
-  if (!fs40.existsSync(dir)) return [];
+  if (!fs39.existsSync(dir)) return [];
   const results = [];
-  for (const entry of fs40.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs39.readdirSync(dir, { withFileTypes: true })) {
     collectEntry2(results, dir, entry);
   }
   return results;
@@ -27159,11 +27127,11 @@ function prepareReviewDir(paths, requestBody, force) {
 }
 
 // src/commands/review/cachedReviewerResult.ts
-import { statSync as statSync10 } from "fs";
+import { statSync as statSync9 } from "fs";
 function cachedReviewerResult(name, outputPath) {
   let size;
   try {
-    size = statSync10(outputPath).size;
+    size = statSync9(outputPath).size;
   } catch {
     return null;
   }
@@ -28809,7 +28777,7 @@ function registerSql(program2) {
 }
 
 // src/commands/sync.ts
-import * as fs49 from "fs";
+import * as fs48 from "fs";
 import * as os5 from "os";
 import * as path74 from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
@@ -28818,7 +28786,7 @@ import { fileURLToPath as fileURLToPath7 } from "url";
 import * as path65 from "path";
 
 // src/commands/sync/pruneTarget.ts
-import * as fs41 from "fs";
+import * as fs40 from "fs";
 import * as path64 from "path";
 function pruneTarget(targetDir, keepNames, shape, options2) {
   const result = {
@@ -28827,9 +28795,9 @@ function pruneTarget(targetDir, keepNames, shape, options2) {
     skipped: [],
     unmanaged: []
   };
-  if (!fs41.existsSync(targetDir)) return result;
+  if (!fs40.existsSync(targetDir)) return result;
   const keep = new Set(keepNames);
-  for (const entry of fs41.readdirSync(targetDir, { withFileTypes: true })) {
+  for (const entry of fs40.readdirSync(targetDir, { withFileTypes: true })) {
     const name = shape.nameOf(entry);
     if (name === void 0) {
       result.unmanaged.push(entry.name);
@@ -28844,7 +28812,7 @@ function pruneTarget(targetDir, keepNames, shape, options2) {
       continue;
     }
     if (options2.force) {
-      fs41.rmSync(entryPath, { recursive: true });
+      fs40.rmSync(entryPath, { recursive: true });
       result.removed.push(entry.name);
     }
   }
@@ -28891,15 +28859,15 @@ function reportPrune(label2, result, force) {
 }
 
 // src/commands/sync/syncClaudeMd.ts
-import * as fs42 from "fs";
+import * as fs41 from "fs";
 import * as path66 from "path";
 import chalk213 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
   const source = path66.join(claudeDir, "CLAUDE.md");
   const target = path66.join(targetBase, "CLAUDE.md");
-  const sourceContent = fs42.readFileSync(source, "utf8");
-  if (fs42.existsSync(target)) {
-    const targetContent = fs42.readFileSync(target, "utf8");
+  const sourceContent = fs41.readFileSync(source, "utf8");
+  if (fs41.existsSync(target)) {
+    const targetContent = fs41.readFileSync(target, "utf8");
     if (sourceContent !== targetContent) {
       console.log(
         chalk213.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
@@ -28919,7 +28887,7 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs42.copyFileSync(source, target);
+  fs41.copyFileSync(source, target);
   console.log("Copied CLAUDE.md to ~/.claude/CLAUDE.md");
 }
 
@@ -28927,31 +28895,31 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
 import * as path69 from "path";
 
 // src/commands/sync/installHarnessCommands.ts
-import * as fs43 from "fs";
+import * as fs42 from "fs";
 import * as path67 from "path";
 function installHarnessCommands(claudeDir, harness, transform) {
   const commandsSource = path67.join(claudeDir, "commands");
-  const files = fs43.readdirSync(commandsSource);
+  const files = fs42.readdirSync(commandsSource);
   const names = [];
   let synced = 0;
   for (const file of files) {
     if (!file.endsWith(".md")) continue;
     const name = file.replace(/\.md$/, "");
     names.push(name);
-    const content = fs43.readFileSync(path67.join(commandsSource, file), "utf8");
+    const content = fs42.readFileSync(path67.join(commandsSource, file), "utf8");
     const target = path67.join(harness.homeDir, harness.sync.commandDest(name));
-    fs43.mkdirSync(path67.dirname(target), { recursive: true });
-    fs43.writeFileSync(target, transform(name, content));
+    fs42.mkdirSync(path67.dirname(target), { recursive: true });
+    fs42.writeFileSync(target, transform(name, content));
     synced++;
   }
   const agentsTarget = path67.join(harness.homeDir, harness.sync.agentsFile);
-  fs43.mkdirSync(path67.dirname(agentsTarget), { recursive: true });
-  fs43.copyFileSync(path67.join(claudeDir, "CLAUDE.md"), agentsTarget);
+  fs42.mkdirSync(path67.dirname(agentsTarget), { recursive: true });
+  fs42.copyFileSync(path67.join(claudeDir, "CLAUDE.md"), agentsTarget);
   return { total: files.length, synced, names };
 }
 
 // src/commands/sync/pruneSkills.ts
-import * as fs44 from "fs";
+import * as fs43 from "fs";
 function pruneSkills(targetDir, skillNames, options2) {
   return pruneTarget(
     targetDir,
@@ -28964,14 +28932,14 @@ function pruneSkills(targetDir, skillNames, options2) {
   );
 }
 function unexpectedContent(skillDir) {
-  const entries = fs44.readdirSync(skillDir);
+  const entries = fs43.readdirSync(skillDir);
   const others = entries.filter((entry) => entry !== "SKILL.md");
   if (others.length > 0) return `contains ${others.sort().join(", ")}`;
   return entries.length === 0 ? "no SKILL.md" : void 0;
 }
 
 // src/commands/sync/syncCodexHooks.ts
-import * as fs45 from "fs";
+import * as fs44 from "fs";
 import * as path68 from "path";
 var BEGIN = "# >>> assist codex hooks (managed) \u2014 do not edit >>>";
 var END = "# <<< assist codex hooks (managed) <<<";
@@ -29002,11 +28970,11 @@ ${rest}
 `;
 }
 function syncCodexHooks(sourcePath) {
-  const body = fs45.readFileSync(sourcePath, "utf8");
+  const body = fs44.readFileSync(sourcePath, "utf8");
   const configPath = path68.join(harnesses.codex.homeDir, "config.toml");
-  const existing = fs45.existsSync(configPath) ? fs45.readFileSync(configPath, "utf8") : "";
-  fs45.mkdirSync(path68.dirname(configPath), { recursive: true });
-  fs45.writeFileSync(configPath, upsertManagedBlock(existing, body));
+  const existing = fs44.existsSync(configPath) ? fs44.readFileSync(configPath, "utf8") : "";
+  fs44.mkdirSync(path68.dirname(configPath), { recursive: true });
+  fs44.writeFileSync(configPath, upsertManagedBlock(existing, body));
   console.log(
     "Registered assist codex-hook in ~/.codex/config.toml (UserPromptSubmit, PreToolUse, PostToolUse, PermissionRequest, Stop)"
   );
@@ -29051,21 +29019,21 @@ function syncCodex(claudeDir, options2) {
 }
 
 // src/commands/sync/syncDesign.ts
-import * as fs46 from "fs";
+import * as fs45 from "fs";
 import * as path70 from "path";
 function syncDesign(claudeDir, targetBase) {
   const systemPromptSource = path70.join(claudeDir, "design-system-prompt.md");
   const systemPromptTarget = path70.join(targetBase, "design-system-prompt.md");
-  fs46.copyFileSync(systemPromptSource, systemPromptTarget);
+  fs45.copyFileSync(systemPromptSource, systemPromptTarget);
   console.log(
     "Copied design-system-prompt.md to ~/.claude/design-system-prompt.md"
   );
   const skillsSource = path70.join(claudeDir, "skills");
   const skillsTarget = path70.join(targetBase, "skills");
-  fs46.mkdirSync(skillsTarget, { recursive: true });
-  const files = fs46.readdirSync(skillsSource);
+  fs45.mkdirSync(skillsTarget, { recursive: true });
+  const files = fs45.readdirSync(skillsSource);
   for (const file of files) {
-    fs46.copyFileSync(
+    fs45.copyFileSync(
       path70.join(skillsSource, file),
       path70.join(skillsTarget, file)
     );
@@ -29077,17 +29045,17 @@ function syncDesign(claudeDir, targetBase) {
 import * as path72 from "path";
 
 // src/commands/sync/syncPiHooks.ts
-import * as fs47 from "fs";
+import * as fs46 from "fs";
 import * as path71 from "path";
 function piExtensionsDir() {
   return path71.join(harnesses.pi.homeDir, "extensions");
 }
 function syncPiHooks(sourceDir) {
   const target = piExtensionsDir();
-  fs47.mkdirSync(target, { recursive: true });
-  const files = fs47.readdirSync(sourceDir).filter((f) => f.endsWith(".ts"));
+  fs46.mkdirSync(target, { recursive: true });
+  const files = fs46.readdirSync(sourceDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
-    fs47.copyFileSync(
+    fs46.copyFileSync(
       path71.join(sourceDir, file),
       path71.join(target, `assist-${file}`)
     );
@@ -29140,16 +29108,16 @@ function syncPi(claudeDir, options2) {
 }
 
 // src/commands/sync/syncSettings.ts
-import * as fs48 from "fs";
+import * as fs47 from "fs";
 import * as path73 from "path";
 import chalk214 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
   const source = path73.join(claudeDir, "settings.json");
   const target = path73.join(targetBase, "settings.json");
-  const sourceContent = fs48.readFileSync(source, "utf8");
+  const sourceContent = fs47.readFileSync(source, "utf8");
   const sourceSettings = JSON.parse(sourceContent);
-  const targetExists = fs48.existsSync(target);
-  const targetContent = targetExists ? fs48.readFileSync(target, "utf8") : "";
+  const targetExists = fs47.existsSync(target);
+  const targetContent = targetExists ? fs47.readFileSync(target, "utf8") : "";
   const preservedUserSettings = targetExists ? JSON.parse(targetContent) : {};
   const mergedContent = JSON.stringify(
     { ...preservedUserSettings, ...sourceSettings },
@@ -29179,7 +29147,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs48.writeFileSync(target, mergedContent);
+  fs47.writeFileSync(target, mergedContent);
   console.log("Copied settings.json to ~/.claude/settings.json");
 }
 
@@ -29210,10 +29178,10 @@ async function sync(options2) {
 function syncCommands(claudeDir, targetBase) {
   const sourceDir = path74.join(claudeDir, "commands");
   const targetDir = path74.join(targetBase, "commands");
-  fs49.mkdirSync(targetDir, { recursive: true });
-  const files = fs49.readdirSync(sourceDir);
+  fs48.mkdirSync(targetDir, { recursive: true });
+  const files = fs48.readdirSync(sourceDir);
   for (const file of files) {
-    fs49.copyFileSync(path74.join(sourceDir, file), path74.join(targetDir, file));
+    fs48.copyFileSync(path74.join(sourceDir, file), path74.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -29311,14 +29279,14 @@ async function configure() {
 }
 
 // src/commands/transcript/list.ts
-import { existsSync as existsSync59, readdirSync as readdirSync19, statSync as statSync11 } from "fs";
+import { existsSync as existsSync59, readdirSync as readdirSync19, statSync as statSync10 } from "fs";
 import { join as join76 } from "path";
 function list4() {
   const { vttDir } = getTranscriptConfig();
   if (!existsSync59(vttDir)) return;
   for (const entry of readdirSync19(vttDir)) {
     if (!entry.endsWith(".vtt")) continue;
-    if (statSync11(join76(vttDir, entry)).isDirectory()) continue;
+    if (statSync10(join76(vttDir, entry)).isDirectory()) continue;
     console.log(entry);
   }
 }
@@ -30686,7 +30654,7 @@ async function auth() {
 
 // src/commands/roam/postRoamActivity.ts
 import { execFileSync as execFileSync13 } from "child_process";
-import { readdirSync as readdirSync20, readFileSync as readFileSync52, statSync as statSync12 } from "fs";
+import { readdirSync as readdirSync20, readFileSync as readFileSync52, statSync as statSync11 } from "fs";
 import { join as join85 } from "path";
 function findPortFile(roamDir) {
   let entries;
@@ -30698,7 +30666,7 @@ function findPortFile(roamDir) {
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
     const path80 = join85(roamDir, name);
     try {
-      return { path: path80, mtimeMs: statSync12(path80).mtimeMs };
+      return { path: path80, mtimeMs: statSync11(path80).mtimeMs };
     } catch {
       return void 0;
     }
@@ -31668,7 +31636,7 @@ import { existsSync as existsSync72 } from "fs";
 import * as pty from "node-pty";
 
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
-import { chmodSync, existsSync as existsSync71, statSync as statSync13 } from "fs";
+import { chmodSync, existsSync as existsSync71, statSync as statSync12 } from "fs";
 import { createRequire as createRequire3 } from "module";
 import path75 from "path";
 var require4 = createRequire3(import.meta.url);
@@ -31684,7 +31652,7 @@ function ensureSpawnHelperExecutable() {
     "spawn-helper"
   );
   if (!existsSync71(helper)) return;
-  const mode = statSync13(helper).mode;
+  const mode = statSync12(helper).mode;
   if ((mode & 73) === 0) chmodSync(helper, mode | 493);
 }
 
@@ -31797,7 +31765,7 @@ function serverRunMeta(runName, cwd) {
 }
 
 // src/commands/sessions/daemon/readDesignSystemPrompt.ts
-import * as fs50 from "fs";
+import * as fs49 from "fs";
 import * as path76 from "path";
 import { fileURLToPath as fileURLToPath9 } from "url";
 var __filename5 = fileURLToPath9(import.meta.url);
@@ -31809,7 +31777,7 @@ function readDesignSystemPrompt() {
     "claude",
     "design-system-prompt.md"
   );
-  return fs50.readFileSync(promptPath, "utf8");
+  return fs49.readFileSync(promptPath, "utf8");
 }
 
 // src/commands/sessions/daemon/spawnClaude.ts
@@ -31901,7 +31869,7 @@ import { existsSync as existsSync73 } from "fs";
 import { join as join91 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteTreeDirectly.ts
-import { statSync as statSync14 } from "fs";
+import { statSync as statSync13 } from "fs";
 import { rm as rm2 } from "fs/promises";
 import { join as join90 } from "path";
 async function deleteTreeDirectly(clone, worktreePath, why) {
@@ -31931,7 +31899,7 @@ async function deleteTreeDirectly(clone, worktreePath, why) {
   return { removed: true };
 }
 function holdsAGitDirectoryRatherThanALink(worktreePath) {
-  return statSync14(join90(worktreePath, ".git"), {
+  return statSync13(join90(worktreePath, ".git"), {
     throwIfNoEntry: false
   })?.isDirectory() === true;
 }
@@ -32848,7 +32816,7 @@ function reportSilentFailure(session, clients) {
 }
 
 // src/commands/sessions/shared/codex/resolveCodexSessionId.ts
-import * as fs51 from "fs";
+import * as fs50 from "fs";
 var META_LINES = 5;
 async function resolveCodexSessionId(cwd, sinceMs) {
   if (!cwd) return null;
@@ -32877,7 +32845,7 @@ async function startedIn(file, cwd, sinceMs) {
 }
 async function touchedSince(file, sinceMs) {
   try {
-    return (await fs51.promises.stat(file)).mtimeMs >= sinceMs;
+    return (await fs50.promises.stat(file)).mtimeMs >= sinceMs;
   } catch {
     return false;
   }
@@ -32911,7 +32879,7 @@ function bindCodexSession(session, notify2) {
 import { watch as watch3 } from "fs";
 
 // src/commands/sessions/shared/findTranscriptPathSync.ts
-import * as fs52 from "fs";
+import * as fs51 from "fs";
 import * as path77 from "path";
 function projectDirForCwd(cwd) {
   return path77.join(claudeProjectsRoot(), projectSlug(cwd));
@@ -32921,11 +32889,11 @@ function transcriptPathFor(cwd, claudeSessionId) {
 }
 function findTranscriptPathSync(cwd, claudeSessionId) {
   const direct = transcriptPathFor(cwd, claudeSessionId);
-  if (fs52.existsSync(direct)) return direct;
+  if (fs51.existsSync(direct)) return direct;
   const dir = projectDirForCwd(cwd);
   let files;
   try {
-    files = fs52.readdirSync(dir);
+    files = fs51.readdirSync(dir);
   } catch {
     return null;
   }
@@ -32939,14 +32907,14 @@ function findTranscriptPathSync(cwd, claudeSessionId) {
 function headContainsSessionId(filePath, claudeSessionId) {
   let fd;
   try {
-    fd = fs52.openSync(filePath, "r");
+    fd = fs51.openSync(filePath, "r");
     const buf = Buffer.alloc(16384);
-    const bytesRead = fs52.readSync(fd, buf, 0, buf.length, 0);
+    const bytesRead = fs51.readSync(fd, buf, 0, buf.length, 0);
     return buf.toString("utf8", 0, bytesRead).includes(claudeSessionId);
   } catch {
     return false;
   } finally {
-    if (fd !== void 0) fs52.closeSync(fd);
+    if (fd !== void 0) fs51.closeSync(fd);
   }
 }
 
@@ -33116,7 +33084,7 @@ function asRecord3(value) {
 }
 
 // src/commands/sessions/shared/readTranscriptTail.ts
-import * as fs53 from "fs";
+import * as fs52 from "fs";
 var DEFAULT_MAX_BYTES = 256 * 1024;
 function parseTailEntries(raw) {
   const entries = [];
@@ -33137,10 +33105,10 @@ function dropPartialFirstLine(raw, sliced) {
   const newline = raw.indexOf("\n");
   return newline === -1 ? "" : raw.slice(newline + 1);
 }
-async function readTranscriptTail2(filePath, maxBytes = DEFAULT_MAX_BYTES) {
+async function readTranscriptTail(filePath, maxBytes = DEFAULT_MAX_BYTES) {
   let handle;
   try {
-    handle = await fs53.promises.open(filePath, "r");
+    handle = await fs52.promises.open(filePath, "r");
     const { size } = await handle.stat();
     const start3 = Math.max(0, size - maxBytes);
     const length = size - start3;
@@ -33159,20 +33127,20 @@ async function readTranscriptTail2(filePath, maxBytes = DEFAULT_MAX_BYTES) {
 function readTranscriptTailSync(filePath, maxBytes = DEFAULT_MAX_BYTES) {
   let fd;
   try {
-    fd = fs53.openSync(filePath, "r");
-    const { size } = fs53.fstatSync(fd);
+    fd = fs52.openSync(filePath, "r");
+    const { size } = fs52.fstatSync(fd);
     const start3 = Math.max(0, size - maxBytes);
     const length = size - start3;
     if (length === 0) return [];
     const buf = Buffer.alloc(length);
-    fs53.readSync(fd, buf, 0, length, start3);
+    fs52.readSync(fd, buf, 0, length, start3);
     return parseTailEntries(
       dropPartialFirstLine(buf.toString("utf8"), start3 > 0)
     );
   } catch {
     return [];
   } finally {
-    if (fd !== void 0) fs53.closeSync(fd);
+    if (fd !== void 0) fs52.closeSync(fd);
   }
 }
 
@@ -33213,7 +33181,7 @@ function isFinished(session) {
 async function reconcileTranscriptStatus(session, onStatusChange, notify2) {
   const filePath = await resolveTranscriptPath(session);
   if (!filePath) return;
-  const entries = await readTranscriptTail2(filePath);
+  const entries = await readTranscriptTail(filePath);
   const fingerprint = transcriptTailFingerprint(entries);
   if (fingerprint !== null && fingerprint === session.transcriptFingerprint)
     return;
@@ -33571,7 +33539,7 @@ async function recordWindowTokens(db, window, resetsAt, tokensUp, tokensDown) {
 }
 
 // src/commands/sessions/shared/transcriptUsage.ts
-import * as fs54 from "fs";
+import * as fs53 from "fs";
 function transcriptUsage(lines2) {
   const byId = /* @__PURE__ */ new Map();
   for (const line of lines2) {
@@ -33595,7 +33563,7 @@ function transcriptUsage(lines2) {
   return [...byId.values()];
 }
 async function readTranscriptUsage(transcriptPath2) {
-  const content = await fs54.promises.readFile(transcriptPath2, "utf8");
+  const content = await fs53.promises.readFile(transcriptPath2, "utf8");
   return transcriptUsage(content.split("\n"));
 }
 
@@ -35280,10 +35248,28 @@ function stripOutboundSessionId(data) {
   return stripped;
 }
 
+// src/commands/sessions/daemon/logWindowsForward.ts
+function logWindowsForward(delivered, type, sessionId) {
+  if (!delivered)
+    daemonLog(
+      `windows proxy: DROPPED ${type} for ${sessionId} (windows connection not writable)`
+    );
+  else if (type !== "input")
+    daemonLog(`windows proxy: forwarded ${type} for ${sessionId}`);
+}
+
+// src/commands/sessions/daemon/forwardWindowsIo.ts
+function forwardWindowsIo(conn, data) {
+  const sessionId = stripWindowsSessionId(data.sessionId);
+  const delivered = conn.trySend({ ...data, sessionId });
+  logWindowsForward(delivered, data.type, data.sessionId);
+}
+
 // src/commands/sessions/daemon/WindowsProxyState.ts
 var MAX_SCROLLBACK2 = 256 * 1024;
 var DEFAULT_CREATE_TIMEOUT_MS = 5e3;
-function createState(broadcast2, onSessionsChanged, onVersionMismatch, createTimeoutMs = DEFAULT_CREATE_TIMEOUT_MS) {
+function createState(broadcast2, onSessionsChanged, onVersionMismatch, onVersionOk = () => {
+}, createTimeoutMs = DEFAULT_CREATE_TIMEOUT_MS) {
   return {
     windowsSessions: [],
     scrollback: /* @__PURE__ */ new Map(),
@@ -35291,7 +35277,8 @@ function createState(broadcast2, onSessionsChanged, onVersionMismatch, createTim
     createTimeoutMs,
     broadcast: broadcast2,
     onSessionsChanged,
-    onVersionMismatch
+    onVersionMismatch,
+    onVersionOk
   };
 }
 function resetState(state) {
@@ -35369,7 +35356,11 @@ function windowsVersionCheck() {
 
 // src/commands/sessions/daemon/handleHello.ts
 function handleHello(state, msg) {
-  if (!isHello(msg) || helloCompatible(msg)) return;
+  if (!isHello(msg)) return;
+  if (helloCompatible(msg)) {
+    state.onVersionOk();
+    return;
+  }
   const mode = windowsVersionCheck();
   const mismatch = `windows daemon ${helloMismatchKind(msg)} mismatch`;
   const detail = `protocol ${msg.protocol ?? "legacy"} version ${msg.version} (wsl protocol ${PROTOCOL_VERSION} version ${ASSIST_VERSION})`;
@@ -35505,16 +35496,6 @@ function isWindowsIo(data) {
   return typeof data.sessionId === "string" && isWindowsSessionId(data.sessionId);
 }
 
-// src/commands/sessions/daemon/logWindowsForward.ts
-function logWindowsForward(delivered, type, sessionId) {
-  if (!delivered)
-    daemonLog(
-      `windows proxy: DROPPED ${type} for ${sessionId} (windows connection not writable)`
-    );
-  else if (type !== "input")
-    daemonLog(`windows proxy: forwarded ${type} for ${sessionId}`);
-}
-
 // src/commands/sessions/daemon/WindowsConnection.ts
 import { createInterface as createInterface9 } from "readline";
 
@@ -35641,6 +35622,7 @@ function notifyHealing(state) {
 
 // src/commands/sessions/daemon/WindowsVersionHealer.ts
 var UNRECOVERABLE_MESSAGE = "Windows host is on an incompatible version that auto-update could not resolve; not reconnecting. Update the Windows host manually, then restart.";
+var HEALED_MESSAGE = "Windows host is up to date \u2014 you can reselect the repo now.";
 var WindowsVersionHealer = class {
   constructor(conn, state, heal) {
     this.conn = conn;
@@ -35650,6 +35632,7 @@ var WindowsVersionHealer = class {
   healAttempted = false;
   healing = false;
   unrecoverable = false;
+  awaitingConfirmation = false;
   get blocked() {
     return this.unrecoverable;
   }
@@ -35661,14 +35644,24 @@ var WindowsVersionHealer = class {
     if (this.healAttempted) return this.giveUp(version2);
     this.healing = true;
     this.healAttempted = true;
+    this.awaitingConfirmation = true;
     try {
       await autoHealWindowsDaemon(this.conn, this.state, this.heal, version2);
     } finally {
       this.healing = false;
     }
   }
+  onCompatible() {
+    if (!this.awaitingConfirmation) return;
+    this.awaitingConfirmation = false;
+    daemonLog(
+      "windows proxy: post-heal handshake compatible; windows host is in step"
+    );
+    this.state.broadcast({ type: "notice", message: HEALED_MESSAGE });
+  }
   giveUp(version2) {
     this.unrecoverable = true;
+    this.awaitingConfirmation = false;
     daemonLog(
       `windows proxy: version mismatch ${version2} persists after heal; not reconnecting until the WSL daemon restarts`
     );
@@ -35689,6 +35682,7 @@ var WindowsProxy = class {
       (msg) => broadcast(clients, msg),
       onSessionsChanged,
       (version2) => void this.healer.onMismatch(version2),
+      () => this.healer.onCompatible(),
       createTimeoutMs
     );
     this.conn = new WindowsConnection({
@@ -35713,7 +35707,10 @@ var WindowsProxy = class {
   route(client, data) {
     if (!this.enabled) return false;
     if (isWindowsCreate(data)) return this.routeCreate(client, data);
-    if (isWindowsIo(data)) return this.routeIo(data);
+    if (isWindowsIo(data)) {
+      forwardWindowsIo(this.conn, data);
+      return true;
+    }
     return false;
   }
   routeCreate(client, data) {
@@ -35725,12 +35722,6 @@ var WindowsProxy = class {
     } else void forwardWindowsCreate(this.conn, this.state, client, data);
     return true;
   }
-  routeIo(data) {
-    const sessionId = stripWindowsSessionId(data.sessionId);
-    const delivered = this.conn.trySend({ ...data, sessionId });
-    logWindowsForward(delivered, data.type, data.sessionId);
-    return true;
-  }
   dispose() {
     this.conn.dispose();
   }
@@ -36235,7 +36226,7 @@ function handleSetStatus(client, m, d) {
 }
 
 // src/commands/sessions/shared/parseTranscript.ts
-import * as fs55 from "fs";
+import * as fs54 from "fs";
 
 // src/commands/sessions/shared/codex/findCodexRolloutPath.ts
 import * as path78 from "path";
@@ -36318,7 +36309,7 @@ async function parseTranscript(sessionId) {
 }
 async function readMessages(filePath, parse3) {
   try {
-    const raw = await fs55.promises.readFile(filePath, "utf8");
+    const raw = await fs54.promises.readFile(filePath, "utf8");
     return parse3(raw.split("\n"));
   } catch {
     return [];
@@ -36705,17 +36696,17 @@ function registerSetStatusCommand(cmd) {
 }
 
 // src/commands/sessions/summarise/index.ts
-import * as fs57 from "fs";
+import * as fs56 from "fs";
 import chalk217 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
-import * as fs56 from "fs";
+import * as fs55 from "fs";
 function writeSummary(jsonlPath2, summary) {
-  fs56.writeFileSync(summaryPathFor(jsonlPath2), `${summary.trim()}
+  fs55.writeFileSync(summaryPathFor(jsonlPath2), `${summary.trim()}
 `, "utf8");
 }
 function hasSummary(jsonlPath2) {
-  return fs56.existsSync(summaryPathFor(jsonlPath2));
+  return fs55.existsSync(summaryPathFor(jsonlPath2));
 }
 function summaryPathFor(jsonlPath2) {
   return jsonlPath2.replace(/\.jsonl$/, ".summary");
@@ -36787,7 +36778,7 @@ function selectCandidates(files, options2) {
   const candidates = options2.force ? files : files.filter((f) => !hasSummary(f));
   candidates.sort((a, b) => {
     try {
-      return fs57.statSync(b).mtimeMs - fs57.statSync(a).mtimeMs;
+      return fs56.statSync(b).mtimeMs - fs56.statSync(a).mtimeMs;
     } catch {
       return 0;
     }
@@ -36911,13 +36902,13 @@ function buildLimitsSegment(rateLimits) {
 }
 
 // src/commands/readGitBranch.ts
-import { readFileSync as readFileSync58, statSync as statSync16 } from "fs";
+import { readFileSync as readFileSync58, statSync as statSync15 } from "fs";
 import { isAbsolute as isAbsolute4, join as join94, resolve as resolve22 } from "path";
 function resolveGitDir(cwd) {
   const dotGit = join94(cwd, ".git");
   let stat4;
   try {
-    stat4 = statSync16(dotGit);
+    stat4 = statSync15(dotGit);
   } catch {
     return null;
   }