Fix Windows command execution, stale-daemon upgrades, and chat layout

- Windows: the agent's bash/glob tools spawned /bin/sh, which doesn't exist on
  Windows (ENOENT → no commands ran, no edits made). Add a cross-platform
  shellInvocation (cmd.exe on Windows), give glob a Node-based fallback, and
  tell the agent its OS in the system prompt.
- Stale daemon: the detached daemon survives reinstalls, so users got stuck on
  an old cloned version. ensureDaemon (CLI and app) now compares the live
  daemon's version to the installed one and restarts it on mismatch.
- Chat UI: single scroll container so resizing no longer duplicates the
  composer; add spacing between the conversation and the composer.
- Bump coderouter-cli 0.1.3 and Studio 0.1.2.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: EfeAcar6431

packages/app/electron/main.ts

@@ -44,6 +44,48 @@ async function ping(port: number): Promise<DaemonInfo | null> {
   }
 }
 
+/**
+ * The daemon version this app build expects, read from the bundled (or, in
+ * dev, the sibling workspace) CLI package.json. Used to detect a stale daemon
+ * left running by an older install so we can replace it.
+ */
+function expectedDaemonVersion(): string | null {
+  const candidates = [
+    join(process.resourcesPath, 'cli', 'package.json'),
+    join(app.getAppPath(), '..', 'cli', 'package.json'),
+  ];
+  for (const p of candidates) {
+    try {
+      const v = (JSON.parse(readFileSync(p, 'utf8')) as { version?: string }).version;
+      if (typeof v === 'string' && v) return v;
+    } catch {
+      // try next
+    }
+  }
+  return null;
+}
+
+/** Stop a running daemon by PID and wait for its port to free. */
+async function stopDaemon(info: DaemonInfo): Promise<void> {
+  try {
+    process.kill(info.pid, 'SIGTERM');
+  } catch {
+    // already gone
+  }
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline) {
+    if (!(await ping(info.port))) break;
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  if (await ping(info.port)) {
+    try {
+      process.kill(info.pid, 'SIGKILL');
+    } catch {
+      // ignore
+    }
+  }
+}
+
 /**
  * Locate a standalone Node binary. The daemon must run under regular Node
  * (not Electron's bundled Node) so native addons like `node-pty` — which
@@ -110,7 +152,13 @@ async function ensureDaemon(): Promise<DaemonInfo> {
   const existing = readDaemonInfo();
   if (existing) {
     const alive = await ping(existing.port);
-    if (alive) return alive;
+    if (alive) {
+      // Replace a stale daemon from an older install so the app always runs
+      // the version it shipped with.
+      const want = expectedDaemonVersion();
+      if (!want || alive.version === want) return alive;
+      await stopDaemon(alive);
+    }
   }
 
   const { cmd, args, electronNode } = resolveCli();

packages/app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coderouter/app",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "private": true,
   "description": "CodeRouter Studio — Electron desktop app (Loops, Projects, Chats, Usage)",
   "author": "Efe Acar",

packages/app/scripts/stage-daemon.mjs

@@ -55,6 +55,7 @@ writeFileSync(
       name: 'coderouter-daemon',
       private: true,
       type: 'module',
+      version: cliPkg.version,
       dependencies: {
         '@vscode/ripgrep': want('@vscode/ripgrep'),
         ink: want('ink'),

packages/app/src/App.tsx

@@ -331,9 +331,9 @@ function Shell(): React.ReactElement {
           </div>
         </header>
         <div className="flex min-h-0 flex-1">
-          <div className="min-h-0 flex-1 overflow-y-auto">
+          <div className={cls('min-h-0 flex-1', nav === 'chat' ? 'overflow-hidden' : 'overflow-y-auto')}>
             {nav === 'chat' ? (
-              <div className="h-full px-12 py-6">
+              <div className="h-full px-12 pt-6 pb-4">
                 <ChatPage
                   chatId={chatId}
                   project={project}

packages/app/src/pages/Chat.tsx

@@ -215,14 +215,14 @@ export function ChatPage({
 
   return (
     <div className="mx-auto flex h-full max-w-2xl flex-col">
-      <div ref={scrollRef} className="min-h-0 flex-1 space-y-5 overflow-y-auto py-2">
+      <div ref={scrollRef} className="min-h-0 flex-1 space-y-6 overflow-y-auto px-1 pb-6 pt-2">
         {loadingHistory && <Spinner />}
         {messages.map((m, i) => (
           <MessageRow key={i} msg={m} />
         ))}
       </div>
       {error && <div className="mb-2 rounded-md border border-bad/40 bg-bad/10 px-3 py-2 text-sm text-bad">{error}</div>}
-      {composer}
+      <div className="pt-3">{composer}</div>
     </div>
   );
 }

packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coderouter-cli",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "type": "module",
   "description": "A coding-agent router that picks the best model for each task, runs edits in git-worktree sandboxes, and works with your existing Claude Code / Codex CLI or any API key (OpenAI, Anthropic, OpenRouter, ...).",
   "license": "MIT",

packages/cli/src/daemon/lockfile.ts

@@ -2,6 +2,7 @@ import { spawn } from 'node:child_process';
 import { readFileSync, rmSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { coderouterHome } from '@coderouter/core';
+import { CLI_VERSION } from '../version.js';
 
 /**
  * Daemon singleton bookkeeping. The daemon writes `~/.coderouter/daemon.json`
@@ -58,16 +59,51 @@ export async function pingDaemon(port: number, timeoutMs = 1500): Promise<Daemon
   }
 }
 
+/**
+ * Stop a running daemon by PID and wait for it to release its port. Used to
+ * replace a stale daemon left running by an older install (the daemon is
+ * detached and survives a `git pull`/reinstall, so without this a user can be
+ * stuck on the old version indefinitely).
+ */
+export async function stopDaemon(info: DaemonInfo, waitMs = 5000): Promise<void> {
+  try {
+    process.kill(info.pid, 'SIGTERM');
+  } catch {
+    // already gone
+  }
+  const deadline = Date.now() + waitMs;
+  while (Date.now() < deadline) {
+    if (!(await pingDaemon(info.port, 800))) break;
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  if (await pingDaemon(info.port, 800)) {
+    try {
+      process.kill(info.pid, 'SIGKILL');
+    } catch {
+      // ignore
+    }
+  }
+  clearDaemonInfo();
+}
+
 /**
  * Return a live daemon's info, spawning one (detached) if needed. The
  * spawned process keeps running after this CLI exits so loops survive.
+ *
+ * If a daemon is alive but runs a different version than this CLI (e.g. left
+ * over from an older clone/install), it is stopped and replaced so users
+ * always run the version they just installed.
  */
 export async function ensureDaemon(opts: { cwd: string } = { cwd: process.cwd() }): Promise<DaemonInfo> {
   const existing = readDaemonInfo();
   if (existing) {
     const alive = await pingDaemon(existing.port);
-    if (alive) return alive;
-    clearDaemonInfo();
+    if (alive) {
+      if (alive.version === CLI_VERSION) return alive;
+      await stopDaemon(alive);
+    } else {
+      clearDaemonInfo();
+    }
   }
 
   // Spawn `coderouter daemon` detached. argv[1] is this CLI's entry.

packages/core/src/agent/systemPrompt.ts

@@ -32,6 +32,23 @@ export const DEFAULT_SYSTEM_PROMPT = `You are CodeRouter Agent, a precise coding
  * memory.md / project context without forking the whole prompt.
  */
 export function buildSystemPrompt(opts: { append?: string } = {}): string {
-  if (!opts.append?.trim()) return DEFAULT_SYSTEM_PROMPT;
-  return `${DEFAULT_SYSTEM_PROMPT}\n\n# Project context\n${opts.append.trim()}`;
+  const base = `${DEFAULT_SYSTEM_PROMPT}\n\n# Environment\n${describeEnvironment()}`;
+  if (!opts.append?.trim()) return base;
+  return `${base}\n\n# Project context\n${opts.append.trim()}`;
+}
+
+/** A one-liner describing the host OS so the agent generates compatible commands. */
+function describeEnvironment(): string {
+  switch (process.platform) {
+    case 'win32':
+      return (
+        '- OS: Windows. The bash tool runs commands through cmd.exe, so use Windows-compatible ' +
+        'commands (e.g. chain with `&&`, avoid Unix-only tools like `ls`/`cat`/`grep`). ' +
+        'Prefer the read_file / glob / grep / list_dir tools over shelling out — they work everywhere.'
+      );
+    case 'darwin':
+      return '- OS: macOS. Shell commands run via /bin/sh.';
+    default:
+      return '- OS: Linux. Shell commands run via /bin/sh.';
+  }
 }

packages/core/src/agent/tools/bash.ts

@@ -1,4 +1,4 @@
-import { exec } from '../../sandbox/exec.js';
+import { exec, shellInvocation } from '../../sandbox/exec.js';
 import type { Tool } from '../types.js';
 import { MAX_BASH_OUTPUT_BYTES, clip, oneLine, stringArg } from './helpers.js';
 
@@ -12,7 +12,11 @@ export const bashTool: Tool = {
   parameters: {
     type: 'object',
     properties: {
-      command: { type: 'string', description: 'Shell command to execute via /bin/sh -lc.' },
+      command: {
+        type: 'string',
+        description:
+          'Shell command to execute. Runs via the system shell (sh on macOS/Linux, cmd.exe on Windows).',
+      },
       timeout_ms: {
         type: 'integer',
         description: 'Hard timeout in milliseconds. Defaults to 60000.',
@@ -25,7 +29,8 @@ export const bashTool: Tool = {
     const command = stringArg(args, 'command');
     const timeoutMs =
       typeof args.timeout_ms === 'number' && args.timeout_ms > 0 ? args.timeout_ms : 60_000;
-    const result = await exec('/bin/sh', ['-lc', command], {
+    const { cmd, args: shArgs } = shellInvocation(command, { login: true });
+    const result = await exec(cmd, shArgs, {
       cwd: ctx.cwd,
       signal: ctx.signal,
       timeoutMs,

packages/core/src/agent/tools/glob.ts

@@ -1,7 +1,9 @@
-import { stat } from 'node:fs/promises';
+import type { Dirent } from 'node:fs';
+import { readdir, stat } from 'node:fs/promises';
+import { join, relative, sep } from 'node:path';
 import { exec } from '../../sandbox/exec.js';
 import type { Tool, ToolContext } from '../types.js';
-import { MAX_GLOB_RESULTS, escapeShellArg, quoted, stringArg } from './helpers.js';
+import { MAX_GLOB_RESULTS, quoted, stringArg } from './helpers.js';
 
 export const globTool: Tool = {
   name: 'glob',
@@ -41,18 +43,62 @@ async function runGlob(ctx: ToolContext, pattern: string): Promise<string[]> {
     );
     return stdout.split('\n').filter(Boolean);
   }
-  const { stdout } = await exec(
-    '/bin/sh',
-    [
-      '-lc',
-      `find . -path ${escapeShellArg(pattern)} -type f -not -path '*/.*' | head -n 1000`,
-    ],
-    { cwd: ctx.cwd, signal: ctx.signal },
-  );
-  return stdout
-    .split('\n')
-    .filter(Boolean)
-    .map((p) => (p.startsWith('./') ? p.slice(2) : p));
+  // Non-git worktree: walk the tree in Node (cross-platform; no reliance on a
+  // POSIX `find`, which doesn't exist on Windows) and match the glob ourselves.
+  const all = await walkFiles(ctx.cwd);
+  const rx = globToRegExp(pattern);
+  return all.filter((p) => rx.test(p)).slice(0, 1000);
+}
+
+/** Recursively list files relative to `root`, skipping dotfiles and node_modules. */
+async function walkFiles(root: string, max = 5000): Promise<string[]> {
+  const out: string[] = [];
+  const rec = async (dir: string): Promise<void> => {
+    if (out.length >= max) return;
+    const entries: Dirent[] = await readdir(dir, { withFileTypes: true }).catch(() => [] as Dirent[]);
+    for (const e of entries) {
+      if (e.name.startsWith('.') || e.name === 'node_modules') continue;
+      const full = join(dir, e.name);
+      if (e.isDirectory()) {
+        await rec(full);
+      } else if (e.isFile()) {
+        out.push(relative(root, full).split(sep).join('/'));
+        if (out.length >= max) return;
+      }
+    }
+  };
+  await rec(root);
+  return out;
+}
+
+/** Convert a POSIX-style glob (`**`, `*`, `?`, `{a,b}`) to an anchored RegExp. */
+function globToRegExp(glob: string): RegExp {
+  let re = '';
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob.charAt(i);
+    if (c === '*') {
+      if (glob.charAt(i + 1) === '*') {
+        re += '.*';
+        i++;
+        if (glob.charAt(i + 1) === '/') i++;
+      } else {
+        re += '[^/]*';
+      }
+    } else if (c === '?') {
+      re += '[^/]';
+    } else if (c === '{') {
+      re += '(';
+    } else if (c === '}') {
+      re += ')';
+    } else if (c === ',') {
+      re += '|';
+    } else if ('.+^$()|[]\\'.includes(c)) {
+      re += `\\${c}`;
+    } else {
+      re += c;
+    }
+  }
+  return new RegExp(`^${re}$`);
 }
 
 async function isGitRepo(cwd: string): Promise<boolean> {