mstro-app 0.2.0 → 0.3.0

package/bin/mstro.js

@@ -8,8 +8,8 @@
  * Main entry point for the Mstro AI assistant.
  *
  * Usage:
- *   mstro                     # Start Mstro (auto-finds available port)
- *   mstro login               # Authenticate this device
+ *   mstro                     # Start Mstro (logs in automatically if needed)
+ *   mstro login               # Re-authenticate this device
  *   mstro logout              # Sign out
  *   mstro whoami              # Show current user
  *   mstro status              # Show connection status
@@ -35,10 +35,27 @@ const CLIENT_ROOT = resolve(__dirname, '..');
 const pkg = JSON.parse(readFileSync(join(CLIENT_ROOT, 'package.json'), 'utf-8'));
 
 // Check for updates (runs async in background, notifies on next run)
+// update-notifier initializes lastUpdateCheck to Date.now(), which means the
+// first check won't happen until 24h after install. We detect first-run by
+// checking if the configstore has never stored an update result, and if so
+// reset the timestamp to force an immediate background check.
 const notifier = updateNotifier({
   pkg,
   updateCheckInterval: 1000 * 60 * 60 * 24  // Check daily
 });
+try {
+  if (notifier.config && !notifier.config.has('update') && !notifier.update) {
+    const lastCheck = notifier.config.get('lastUpdateCheck');
+    // If lastUpdateCheck was just set (within the last 30s), this is a fresh
+    // configstore — reset it to 0 so the library spawns a check immediately.
+    if (lastCheck && (Date.now() - lastCheck) < 30_000) {
+      notifier.config.set('lastUpdateCheck', 0);
+      notifier.check();
+    }
+  }
+} catch {
+  // Non-critical — don't let update check logic crash the CLI
+}
 
 // Capture the user's original working directory before any cwd changes
 const USER_CWD = process.cwd();
@@ -49,6 +66,7 @@ const MSTRO_FIRST_RUN_FLAG = join(MSTRO_CONFIG_DIR, '.configured');
 const CLAUDE_SETTINGS_FILE = join(homedir(), '.claude', 'settings.json');
 const CLAUDE_HOOKS_DIR = join(homedir(), '.claude', 'hooks');
 const BOUNCER_HOOK_FILE = join(CLAUDE_HOOKS_DIR, 'bouncer.sh');
+const PTY_SETUP_DISMISSED_FLAG = join(MSTRO_CONFIG_DIR, '.pty-setup-dismissed');
 
 /**
  * Mark Mstro as configured by writing the first-run flag file
@@ -193,18 +211,163 @@ async function promptBouncerSetup() {
   }
 }
 
+/**
+ * Check if node-pty native module is loadable
+ */
+async function isNodePtyAvailable() {
+  try {
+    await import('node-pty');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if user has dismissed the pty setup prompt
+ */
+function hasUserDismissedPtySetup() {
+  return existsSync(PTY_SETUP_DISMISSED_FLAG);
+}
+
+/**
+ * Mark pty setup prompt as dismissed
+ */
+function markPtySetupDismissed() {
+  if (!existsSync(MSTRO_CONFIG_DIR)) {
+    mkdirSync(MSTRO_CONFIG_DIR, { recursive: true, mode: 0o700 });
+  }
+  writeFileSync(PTY_SETUP_DISMISSED_FLAG, new Date().toISOString());
+}
+
+/**
+ * Show a one-line warning that node-pty is not available
+ */
+function showPtyWarning() {
+  log('  Terminal support not available. Run: mstro setup-terminal', colors.dim);
+}
+
+/**
+ * Get platform-specific build tool instructions
+ */
+function getPtyBuildInstructions() {
+  const os = process.platform;
+  if (os === 'darwin') {
+    return '    Install Xcode Command Line Tools: xcode-select --install';
+  }
+  if (os === 'win32') {
+    return '    Install Windows Build Tools: npm install -g windows-build-tools';
+  }
+  return '    Debian/Ubuntu: sudo apt install build-essential python3\n' +
+         '    Fedora/RHEL:   sudo dnf install gcc-c++ make python3\n' +
+         '    Arch:          sudo pacman -S base-devel python';
+}
+
+/**
+ * Attempt to rebuild/install node-pty from CLIENT_ROOT
+ * Returns true if npm command succeeded, false otherwise
+ */
+function attemptPtyRebuild() {
+  return new Promise((resolve) => {
+    const nodePtyDir = join(CLIENT_ROOT, 'node_modules', 'node-pty');
+    const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const command = existsSync(nodePtyDir) ? 'rebuild' : 'install';
+    const args = command === 'rebuild'
+      ? ['rebuild', 'node-pty']
+      : ['install', 'node-pty', '--no-save'];
+
+    log(`\n  ${command === 'rebuild' ? 'Rebuilding' : 'Installing'} node-pty...`, colors.dim);
+
+    const child = spawn(npmCmd, args, {
+      cwd: CLIENT_ROOT,
+      stdio: 'inherit',
+    });
+
+    child.on('error', (err) => {
+      log(`  Error: ${err.message}`, colors.red);
+      resolve(false);
+    });
+
+    child.on('exit', (code) => {
+      resolve(code === 0);
+    });
+  });
+}
+
+/**
+ * Prompt user to set up node-pty for terminal support
+ * Returns: 'configure' | 'skip' | 'never'
+ */
+async function promptPtySetup() {
+  log('\n  Terminal Support\n', colors.bold + colors.cyan);
+  log('  Mstro includes a web terminal that lets you open a shell', colors.dim);
+  log('  directly in your browser. This requires compiling a native module (node-pty).\n', colors.dim);
+
+  const isInteractive = process.stdin.isTTY;
+
+  if (!isInteractive) {
+    log('  Non-interactive mode: skipping terminal setup.', colors.yellow);
+    log('  Run "mstro setup-terminal" to enable terminal support.\n', colors.dim);
+    return 'skip';
+  }
+
+  log('  Set up terminal support now?', colors.bold);
+  log('    [Y] Yes, compile now (requires build tools)', colors.dim);
+  log('    [n] Not now (ask again next time)', colors.dim);
+  log('    [d] Don\'t show this again\n', colors.dim);
+
+  const answer = await prompt('  Your choice [Y/n/d]: ');
+  const choice = answer.toLowerCase();
+
+  if (choice === '' || choice === 'y' || choice === 'yes') {
+    return 'configure';
+  }
+  if (choice === 'd' || choice === 'dont' || choice === "don't") {
+    log('\n  Got it! You can set up later with: mstro setup-terminal\n', colors.dim);
+    markPtySetupDismissed();
+    return 'never';
+  }
+  log('\n  Skipping for now. Will ask again next time.', colors.yellow);
+  log('  You can also set up with: mstro setup-terminal\n', colors.dim);
+  return 'skip';
+}
+
+/**
+ * Run the pty rebuild and show results
+ */
+async function runPtySetup() {
+  const success = await attemptPtyRebuild();
+
+  if (success) {
+    const available = await isNodePtyAvailable();
+    if (available) {
+      log('\n  Terminal support enabled successfully!\n', colors.bold + colors.green);
+      return true;
+    }
+    log('\n  node-pty installed but failed to load.', colors.red);
+  }
+
+  log('\n  Could not compile node-pty automatically.\n', colors.yellow);
+  log('  You may need to install build tools first:\n', colors.bold);
+  log(getPtyBuildInstructions(), colors.dim);
+  log('');
+  log('  After installing build tools, run: mstro setup-terminal\n', colors.dim);
+  return false;
+}
+
 function showHelp() {
-  log('\n  Mstro - No-code AI Workspace\n', colors.bold + colors.cyan);
-  log('  Run Claude Code workflows from your laptop, cloud VM, or any machine.\n', colors.dim);
+  log('\n  Mstro - Run Claude Code from any browser\n', colors.bold + colors.cyan);
+  log('  Streams live Claude Code sessions from your machine to mstro.app.\n', colors.dim);
   log('  Usage:', colors.bold);
-  log('    mstro                       Start Mstro (auto-finds available port)', colors.dim);
-  log('    mstro login                 Authenticate this device with mstro.app', colors.dim);
+  log('    mstro                       Start Mstro (logs in automatically if needed)', colors.dim);
+  log('    mstro login                 Re-authenticate this device with mstro.app', colors.dim);
   log('    mstro logout                Sign out of mstro.app', colors.dim);
   log('    mstro whoami                Show current user and device info', colors.dim);
   log('    mstro status                Show connection and auth status', colors.dim);
   log('    mstro telemetry [on|off]    Enable/disable anonymous telemetry', colors.dim);
   log('    mstro -p 4105               Start on specific port (overrides auto port)', colors.dim);
   log('    mstro configure-hooks       Configure Claude Code security hooks', colors.dim);
+  log('    mstro setup-terminal        Enable web terminal (compiles native module)', colors.dim);
   log('    mstro --version             Show version number', colors.dim);
   log('    mstro --help                Show this help message', colors.dim);
   log('');
@@ -214,7 +377,7 @@ function showHelp() {
   log('    --verbose, -v               Enable verbose output', colors.dim);
   log('');
   log('  Authentication:', colors.bold);
-  log('    Run "mstro login" to connect this device to your mstro.app account.', colors.dim);
+  log('    Running "mstro" will prompt you to log in automatically if needed.', colors.dim);
   log('    Once logged in, machines sync automatically with your web dashboard.', colors.dim);
   log('');
   log('  Security:', colors.bold);
@@ -321,14 +484,18 @@ function parsePort(args) {
  * Show update notification if available
  */
 function showUpdateNotification() {
-  if (notifier.update && semverGt(notifier.update.latest, notifier.update.current)) {
-    const { current, latest, type } = notifier.update;
-    const updateCmd = 'npm i -g mstro@latest';
-
-    log('');
-    log(`  ${colors.yellow}Update available:${colors.reset} ${colors.dim}${current}${colors.reset} → ${colors.green}${latest}${colors.reset} ${colors.dim}(${type})${colors.reset}`);
-    log(`  Run: ${colors.cyan}${updateCmd}${colors.reset}`);
-    log('');
+  try {
+    if (notifier.update && semverGt(notifier.update.latest, notifier.update.current)) {
+      const { current, latest, type } = notifier.update;
+      const updateCmd = `npm i -g ${pkg.name}`;
+
+      log('');
+      log(`  ${colors.yellow}Update available:${colors.reset} ${colors.dim}${current}${colors.reset} → ${colors.green}${latest}${colors.reset} ${colors.dim}(${type})${colors.reset}`);
+      log(`  Run: ${colors.cyan}${updateCmd}${colors.reset}`);
+      log('');
+    }
+  } catch {
+    // Don't let a corrupted cache or invalid semver crash the CLI
   }
 }
 
@@ -349,36 +516,61 @@ function isLoggedIn() {
 }
 
 /**
- * Show login required message
+ * Auto-login if not authenticated. Exits on failure.
  */
-function showLoginRequired() {
-  log('\n  Authentication required', colors.bold + colors.yellow);
-  log('');
-  log('  You must be logged in to use mstro.', colors.dim);
-  log('  Run "mstro login" to authenticate this device.', colors.dim);
-  log('');
+async function ensureLoggedIn() {
+  if (isLoggedIn()) return;
+  log('\n  Not logged in — starting authentication...\n', colors.bold + colors.cyan);
+  try {
+    const { login } = await import('./commands/login.js');
+    await login(args, { inline: true });
+  } catch (err) {
+    log(`\n  Login failed: ${err.message}`, colors.red);
+    log('  Run "mstro login" to try again.\n', colors.dim);
+    process.exit(1);
+  }
 }
 
 /**
- * Check if node-pty is loadable (native module compiled correctly)
+ * Prompt for bouncer setup if not configured
+ * Returns true if runConfigureHooks was called (async exit path)
  */
-async function startServer(envOverrides) {
-  if (!isLoggedIn()) {
-    showLoginRequired();
-    process.exit(1);
+async function ensureBouncerSetup() {
+  if (isBouncerConfigured()) return false;
+  if (hasUserDismissedSetup()) {
+    showBouncerWarning();
+    return false;
   }
+  const choice = await promptBouncerSetup();
+  if (choice === 'configure') {
+    runConfigureHooks(true);
+    return true;
+  }
+  return false;
+}
 
-  if (!isBouncerConfigured()) {
-    if (hasUserDismissedSetup()) {
-      showBouncerWarning();
-    } else {
-      const choice = await promptBouncerSetup();
-      if (choice === 'configure') {
-        runConfigureHooks(true);
-        return;
-      }
-    }
+/**
+ * Prompt for node-pty setup if not available
+ */
+async function ensurePtySetup() {
+  const ptyAvailable = await isNodePtyAvailable();
+  if (ptyAvailable) return;
+  if (hasUserDismissedPtySetup()) {
+    showPtyWarning();
+    return;
+  }
+  const choice = await promptPtySetup();
+  if (choice === 'configure') {
+    await runPtySetup();
   }
+}
+
+async function startServer(envOverrides) {
+  await ensureLoggedIn();
+
+  if (await ensureBouncerSetup()) return;
+
+  await ensurePtySetup();
 
   showUpdateNotification();
   runNpmScript('start', [], envOverrides);
@@ -417,6 +609,16 @@ async function main() {
       await telemetry(args.slice(args.indexOf('telemetry') + 1));
     }],
     ['configure-hooks', () => runConfigureHooks(false)],
+    ['setup-terminal', async () => {
+      log('\n  Mstro Terminal Setup\n', colors.bold + colors.cyan);
+      const alreadyAvailable = await isNodePtyAvailable();
+      if (alreadyAvailable) {
+        log('  node-pty is already available. Terminal support is enabled!\n', colors.green);
+        return;
+      }
+      const success = await runPtySetup();
+      process.exit(success ? 0 : 1);
+    }],
   ]);
 
   // Flag-based commands
@@ -441,6 +643,7 @@ async function main() {
   const handler = subcommand ? commands.get(subcommand) : undefined;
   if (handler) {
     await handler();
+    showUpdateNotification();
     return;
   }
 

package/dist/server/cli/headless/claude-invoker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"claude-invoker.d.ts","sourceRoot":"","sources":["../../../../server/cli/headless/claude-invoker.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,YAAY,EAAS,MAAM,oBAAoB,CAAC;AAO9D,OAAO,KAAK,EACV,eAAe,EACf,sBAAsB,EAGvB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,sBAAsB,CAAC;IAC/B,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;CAC7C;AAm5BD;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,eAAe,CAAC,CA0I1B"}
+{"version":3,"file":"claude-invoker.d.ts","sourceRoot":"","sources":["../../../../server/cli/headless/claude-invoker.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,YAAY,EAAS,MAAM,oBAAoB,CAAC;AAO9D,OAAO,KAAK,EACV,eAAe,EACf,sBAAsB,EAGvB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,sBAAsB,CAAC;IAC/B,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;CAC7C;AAmgCD;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,eAAe,CAAC,CA0H1B"}

package/dist/server/cli/headless/claude-invoker.js

@@ -12,6 +12,15 @@ import { detectErrorInStderr, } from './output-utils.js';
 import { buildMultimodalMessage } from './prompt-utils.js';
 import { assessStall, assessToolTimeout, classifyError } from './stall-assessor.js';
 import { ToolWatchdog } from './tool-watchdog.js';
+// ========== Signal Helpers ==========
+/** Map a Node.js signal name to its numeric value for exit code computation */
+function signalToNumber(signal) {
+    const map = {
+        SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGABRT: 6,
+        SIGKILL: 9, SIGTERM: 15, SIGUSR1: 10, SIGUSR2: 12,
+    };
+    return map[signal];
+}
 // ========== Stall Detection Helpers ==========
 /** Summarize a tool's input for stall assessment context */
 function summarizeToolInput(input) {
@@ -316,6 +325,8 @@ function handleToolComplete(event, ctx) {
         toolInput: completeInput,
         startTime: toolBuffer.startTime
     });
+    // Clean up the input buffer — it's no longer needed after accumulation
+    ctx.toolInputBuffers.delete(index);
     if (ctx.config.toolUseCallback) {
         ctx.config.toolUseCallback({
             type: 'tool_complete',
@@ -326,6 +337,77 @@ function handleToolComplete(event, ctx) {
         });
     }
 }
+/** Accumulate input tokens from a message_start event. Returns true if any tokens were added. */
+function handleMessageStartTokens(event, ctx) {
+    if (event.type !== 'message_start' || !event.message?.usage)
+        return false;
+    const usage = event.message.usage;
+    ctx.currentStepOutputTokens = 0;
+    let changed = false;
+    if (typeof usage.input_tokens === 'number') {
+        ctx.apiTokenUsage.inputTokens += usage.input_tokens;
+        changed = true;
+    }
+    if (typeof usage.cache_creation_input_tokens === 'number') {
+        ctx.apiTokenUsage.inputTokens += usage.cache_creation_input_tokens;
+        changed = true;
+    }
+    if (typeof usage.cache_read_input_tokens === 'number') {
+        ctx.apiTokenUsage.inputTokens += usage.cache_read_input_tokens;
+        changed = true;
+    }
+    verboseLog(ctx.config.verbose, `[TOKENS] message_start: input=${usage.input_tokens ?? 0} cache_create=${usage.cache_creation_input_tokens ?? 0} cache_read=${usage.cache_read_input_tokens ?? 0} → total_input=${ctx.apiTokenUsage.inputTokens}`);
+    return changed;
+}
+/** Accumulate output tokens from a message_delta event. Returns true if any tokens were added.
+ * message_delta carries CUMULATIVE output token count for the current step.
+ * Per Anthropic docs: "The token counts shown in the usage field of the
+ * message_delta event are cumulative" and there can be "one or more message_delta
+ * events" per message. We track the delta from the previous value to avoid
+ * double-counting when multiple message_delta events fire per step. */
+function handleMessageDeltaTokens(event, ctx) {
+    if (event.type !== 'message_delta' || !event.usage)
+        return false;
+    if (typeof event.usage.output_tokens !== 'number')
+        return false;
+    const increment = event.usage.output_tokens - ctx.currentStepOutputTokens;
+    verboseLog(ctx.config.verbose, `[TOKENS] message_delta: output=${event.usage.output_tokens} (step_prev=${ctx.currentStepOutputTokens} increment=${increment}) → total_output=${ctx.apiTokenUsage.outputTokens + Math.max(increment, 0)}`);
+    if (increment <= 0)
+        return false;
+    ctx.apiTokenUsage.outputTokens += increment;
+    ctx.currentStepOutputTokens = event.usage.output_tokens;
+    return true;
+}
+function handleTokenUsage(event, ctx) {
+    const changed = handleMessageStartTokens(event, ctx) || handleMessageDeltaTokens(event, ctx);
+    if (changed) {
+        ctx.lastTokenActivityTime = Date.now();
+        ctx.config.tokenUsageCallback?.({ ...ctx.apiTokenUsage });
+    }
+}
+/**
+ * Extract definitive token usage from the result event emitted at the end of a Claude session.
+ * The result event's `usage` field contains the authoritative total — it overrides any
+ * accumulated stream-based counts which may be incomplete (e.g., when extended thinking
+ * suppresses stream_event emissions).
+ */
+function handleResultTokenUsage(parsed, ctx) {
+    if (!parsed.usage)
+        return;
+    const u = parsed.usage;
+    const input = (typeof u.input_tokens === 'number' ? u.input_tokens : 0)
+        + (typeof u.cache_creation_input_tokens === 'number' ? u.cache_creation_input_tokens : 0)
+        + (typeof u.cache_read_input_tokens === 'number' ? u.cache_read_input_tokens : 0);
+    const output = typeof u.output_tokens === 'number' ? u.output_tokens : 0;
+    if (input > 0 || output > 0) {
+        verboseLog(ctx.config.verbose, `[TOKENS] Result event usage: input=${input} output=${output} ` +
+            `(stream accumulated: input=${ctx.apiTokenUsage.inputTokens} output=${ctx.apiTokenUsage.outputTokens})`);
+        // Replace with authoritative counts from the result event
+        ctx.apiTokenUsage = { inputTokens: input, outputTokens: output };
+        ctx.lastTokenActivityTime = Date.now();
+        ctx.config.tokenUsageCallback?.({ ...ctx.apiTokenUsage });
+    }
+}
 function handleToolResult(parsed, ctx) {
     if (parsed.type !== 'user' || !parsed.message?.content) {
         return;
@@ -373,11 +455,14 @@ function processStreamEvent(parsed, ctx) {
         ctx.config.outputCallback?.(`\n[[MSTRO_ERROR:CLAUDE_ERROR]] ${errorMessage}\n`);
         return;
     }
-    // Handle result events that contain error info
-    if (parsed.type === 'result' && parsed.is_error) {
-        const errorMessage = parsed.error || parsed.result || 'Unknown error in result';
-        ctx.config.outputCallback?.(`\n[[MSTRO_ERROR:CLAUDE_RESULT_ERROR]] ${errorMessage}\n`);
-        return;
+    // Handle result events — extract definitive token usage and surface errors
+    if (parsed.type === 'result') {
+        handleResultTokenUsage(parsed, ctx);
+        if (parsed.is_error) {
+            const errorMessage = parsed.error || parsed.result || 'Unknown error in result';
+            ctx.config.outputCallback?.(`\n[[MSTRO_ERROR:CLAUDE_RESULT_ERROR]] ${errorMessage}\n`);
+            return;
+        }
     }
     if (parsed.type === 'stream_event' && parsed.event) {
         const event = parsed.event;
@@ -386,6 +471,7 @@ function processStreamEvent(parsed, ctx) {
         handleToolStart(event, ctx);
         handleToolInputDelta(event, ctx);
         handleToolComplete(event, ctx);
+        handleTokenUsage(event, ctx);
     }
     handleToolResult(parsed, ctx);
 }
@@ -489,10 +575,17 @@ async function runStallCheckTick(state, opts) {
     const now = Date.now();
     const silenceMs = now - state.lastActivityTime;
     const totalElapsed = now - opts.perfStart;
+    const tokenSilenceMs = now - opts.lastTokenActivityTime;
     if (totalElapsed >= opts.stallHardCapMs) {
         terminateStallProcess(opts.claudeProcess, opts.stallCheckInterval, opts.config, `\n[[MSTRO_ERROR:EXECUTION_STALLED]] Hard time limit reached (${Math.round(opts.stallHardCapMs / 60000)} min total). Terminating process.\n`);
         return;
     }
+    // Token activity pushes the kill deadline forward — tokens flowing means
+    // the process is alive even if stdout is silent (e.g. silent thinking).
+    if (tokenSilenceMs < 60_000 && now < state.currentKillDeadline) {
+        const killMs = opts.config.stallKillMs ?? 1_800_000;
+        state.currentKillDeadline = Math.max(state.currentKillDeadline, now + killMs);
+    }
     if (now >= state.currentKillDeadline) {
         terminateStallProcess(opts.claudeProcess, opts.stallCheckInterval, opts.config, `\n[[MSTRO_ERROR:EXECUTION_STALLED]] No output for ${Math.round(silenceMs / 60_000)} minutes. Terminating process.\n`);
         return;
@@ -508,6 +601,7 @@ async function runStallCheckTick(state, opts) {
         pendingToolNames: new Set(opts.pendingTools.values()),
         totalToolCalls: opts.totalToolCalls,
         elapsedTotalMs: totalElapsed,
+        tokenSilenceMs,
     };
     if (opts.stallAssessEnabled && state.extensionsGranted < opts.maxExtensions) {
         state.assessmentInProgress = true;
@@ -597,8 +691,12 @@ function setupToolTracking(config, stallState, ctx, sessionCapture, prompt, perf
         ? new ToolWatchdog({
             profiles: config.toolTimeoutProfiles,
             verbose: config.verbose,
-            onTiebreaker: async (toolName, toolInput, elapsedMs) => {
-                return assessToolTimeout(toolName, toolInput, elapsedMs, config.claudeCommand, config.verbose);
+            onTiebreaker: async (toolName, toolInput, elapsedMs, tokenSilenceMs) => {
+                return assessToolTimeout(toolName, toolInput, elapsedMs, config.claudeCommand, config.verbose, tokenSilenceMs);
+            },
+            getTokenSilenceMs: () => {
+                const last = ctx.lastTokenActivityTime;
+                return last > 0 ? Date.now() - last : undefined;
             },
         })
         : null;
@@ -694,6 +792,9 @@ export async function executeClaudeCommand(prompt, _movementId, _sessionNumber,
         nativeTimeoutDetector: new NativeTimeoutDetector(),
         resumeAssessmentActive: isResumeMode,
         resumeAssessmentBuffer: '',
+        apiTokenUsage: { inputTokens: 0, outputTokens: 0 },
+        currentStepOutputTokens: 0,
+        lastTokenActivityTime: Date.now(),
     };
     // Stall detection state (mutable object shared with runStallCheckTick)
     const stallState = {
@@ -750,42 +851,47 @@ export async function executeClaudeCommand(prompt, _movementId, _sessionNumber,
         runStallCheckTick(stallState, {
             perfStart, stallWarningMs, stallHardCapMs, maxExtensions, stallAssessEnabled,
             toolWatchdogActive, prompt, pendingTools, lastToolInputSummary: toolCounters.lastToolInputSummary, totalToolCalls: toolCounters.totalToolCalls,
-            claudeProcess, stallCheckInterval, config,
+            claudeProcess, stallCheckInterval, config, lastTokenActivityTime: ctx.lastTokenActivityTime,
         });
     }, 10_000);
     // Wire up the kill context now that stallCheckInterval exists
     toolTracking.setKillContext(claudeProcess, stallCheckInterval);
     return new Promise((resolve, reject) => {
-        claudeProcess.on('close', async (code) => {
+        claudeProcess.on('close', async (code, signal) => {
             clearInterval(stallCheckInterval);
             watchdog?.clearAll();
-            const postTimeout = flushNativeTimeoutBuffers(ctx);
             await classifyUnmatchedStderr(stderr, errorAlreadySurfaced, code, config);
-            const resumeBuffered = ctx.resumeAssessmentActive ? (ctx.resumeAssessmentBuffer || undefined) : undefined;
-            if (claudeProcess.pid) {
+            if (claudeProcess.pid)
                 runningProcesses.delete(claudeProcess.pid);
-            }
-            resolve({
-                output: stdout,
-                error: stderr || undefined,
-                exitCode: code || 0,
-                assistantResponse: ctx.accumulatedAssistantResponse || undefined,
-                thinkingOutput: ctx.accumulatedThinking || undefined,
-                toolUseHistory: ctx.accumulatedToolUse.length > 0 ? ctx.accumulatedToolUse : undefined,
-                claudeSessionId: sessionCapture.claudeSessionId,
-                nativeTimeoutCount: ctx.nativeTimeoutDetector.timeoutCount || undefined,
-                postTimeoutOutput: postTimeout,
-                resumeBufferedOutput: resumeBuffered,
-            });
+            resolve(buildCloseResult(ctx, stdout, stderr, code, signal, sessionCapture));
         });
         claudeProcess.on('error', (error) => {
             clearInterval(stallCheckInterval);
             watchdog?.clearAll();
-            if (claudeProcess.pid) {
+            if (claudeProcess.pid)
                 runningProcesses.delete(claudeProcess.pid);
-            }
             handleSpawnError(error, config, reject);
         });
     });
 }
+function buildCloseResult(ctx, stdout, stderr, code, signal, sessionCapture) {
+    const postTimeout = flushNativeTimeoutBuffers(ctx);
+    const resumeBuffered = ctx.resumeAssessmentActive ? (ctx.resumeAssessmentBuffer || undefined) : undefined;
+    const exitCode = code ?? (signal ? 128 + (signalToNumber(signal) ?? 0) : 0);
+    const hasTokenUsage = ctx.apiTokenUsage.inputTokens > 0 || ctx.apiTokenUsage.outputTokens > 0;
+    return {
+        output: stdout,
+        error: stderr || undefined,
+        exitCode,
+        signalName: signal || undefined,
+        assistantResponse: ctx.accumulatedAssistantResponse || undefined,
+        thinkingOutput: ctx.accumulatedThinking || undefined,
+        toolUseHistory: ctx.accumulatedToolUse.length > 0 ? ctx.accumulatedToolUse : undefined,
+        claudeSessionId: sessionCapture.claudeSessionId,
+        nativeTimeoutCount: ctx.nativeTimeoutDetector.timeoutCount || undefined,
+        postTimeoutOutput: postTimeout,
+        resumeBufferedOutput: resumeBuffered,
+        apiTokenUsage: hasTokenUsage ? { ...ctx.apiTokenUsage } : undefined,
+    };
+}
 //# sourceMappingURL=claude-invoker.js.map