@bahulam/code 0.1.2 → 0.1.4

package/src/permissions/prompt.mjs

@@ -34,12 +34,12 @@ export async function promptPermission(toolName, input, rl) {
  */
 export function formatToolSummary(toolName, input) {
     switch (toolName) {
-        case 'Bash':
-            return `Bash: ${truncate(input.command || '', 60)}`;
-        case 'Edit':
-            return `Edit: ${input.file_path || 'unknown file'}`;
-        case 'Write':
-            return `Write: ${input.file_path || 'unknown file'} (${(input.content || '').length} chars)`;
+        case 'shell':
+            return `shell: ${truncate(input.command || '', 60)}`;
+        case 'edit_file':
+            return `edit_file: ${input.file_path || 'unknown file'}`;
+        case 'write_file':
+            return `write_file: ${input.file_path || 'unknown file'} (${(input.content || '').length} chars)`;
         case 'MultiEdit':
             return `MultiEdit: ${input.file_path || 'unknown file'} (${(input.edits || []).length} edits)`;
         case 'Agent':
@@ -61,7 +61,8 @@ export function formatToolSummary(toolName, input) {
  */
 export function requiresPermission(toolName) {
     const SAFE_TOOLS = new Set([
-        'Read', 'Glob', 'Grep', 'LS', 'ToolSearch',
+        'read_file', 'list_files', 'search_code',
+        'grep', 'search_files', 'LS', 'ToolSearch',
         'AskUser', 'CronList', 'TodoWrite',
     ]);
     return !SAFE_TOOLS.has(toolName);

package/src/terminal/ansi.mjs

@@ -727,9 +727,26 @@ export function table(headers, rows) {
 // ── Elapsed Timer ──
 
 export function formatElapsed(startMs) {
-  const s = Math.floor((Date.now() - startMs) / 1000);
-  if (s < 60) return `${s}s`;
-  return `${Math.floor(s / 60)}m${s % 60}s`;
+  return formatSeconds((Date.now() - startMs) / 1000);
+}
+
+/**
+ * Human-readable duration from a numeric seconds value. Same shape as
+ * formatElapsed (`1h:35m:19s` / `35m:19s` / `19s`) so every duration in
+ * the UI reads the same. Sub-second values fall back to one decimal so
+ * fast tool calls don't collapse to `0s`.
+ */
+export function formatSeconds(seconds) {
+  const s = Number(seconds);
+  if (!Number.isFinite(s) || s < 0) return '0s';
+  if (s < 1) return `${s.toFixed(1)}s`;
+  const whole = Math.floor(s);
+  const h = Math.floor(whole / 3600);
+  const m = Math.floor((whole % 3600) / 60);
+  const sec = whole % 60;
+  if (h > 0) return `${h}h:${m}m:${sec}s`;
+  if (m > 0) return `${m}m:${sec}s`;
+  return `${sec}s`;
 }
 
 // ── Format Cost ──

package/src/terminal/main.mjs

@@ -232,6 +232,14 @@ async function main() {
     bahulam init                   Scaffold .bahulam config, memory, hooks, tasks
     bahulam version                Show version
 
+  \x1b[1mDaemon:\x1b[0m
+    bahulam list               List detached daemon sessions
+    bahulam attach <id>        Attach to a running daemon
+    bahulam stop <id>          Stop a running daemon
+    bahulam pair               Pair a device for remote access
+    bahulam remote enable      Enable relay connection
+    bahulam remote disable     Disable relay connection (kill switch)
+
   \x1b[1mAnalytics:\x1b[0m
     bahulam sessions               List recent local sessions
     bahulam stats                  Show aggregate local session stats
@@ -285,12 +293,98 @@ async function main() {
     return;
   }
 
-  // ── Headless mode (benchmarks, automation) ──
+  // ── Daemon subcommands (daemon) ──
+
+  if (subcommand === 'list') {
+    const { listDaemonSessions } = await import('../daemon/session-list.mjs');
+    await listDaemonSessions();
+    return;
+  }
+
+  if (subcommand === 'attach') {
+    const { attachToSession } = await import('../daemon/attach-client.mjs');
+    await attachToSession(subcommandArgs[0]);
+    return;
+  }
+
+  if (subcommand === 'stop') {
+    const { stopDaemonSession } = await import('../daemon/stop-daemon.mjs');
+    await stopDaemonSession(subcommandArgs[0]);
+    return;
+  }
+
+  if (subcommand === 'pair') {
+    const { runPairCommand } = await import('../commands/pair.mjs');
+    await runPairCommand(subcommandArgs);
+    return;
+  }
+
+  if (subcommand === 'device') {
+    const { runDeviceCommand } = await import('../commands/device.mjs');
+    const code = await runDeviceCommand(subcommandArgs);
+    process.exit(code || 0);
+  }
+
+  if (subcommand === 'remote') {
+    const { runRemoteCommand } = await import('../commands/remote.mjs');
+    await runRemoteCommand(subcommandArgs);
+    return;
+  }
+
+  //  auto-daemon spawn.
+  //   bahulam daemonize [prompt]  → fork a detached bahulam child with
+  //   the socket server up. Parent waits briefly for the child's session
+  //   id to appear, prints it, and exits. Attach later with `bahulam
+  //   attach <sess_id>` or from a paired device via the relay.
+  if (subcommand === 'daemonize') {
+    const { spawnDetachedDaemon } = await import('../daemon/daemonize.mjs');
+    const initialPrompt = subcommandArgs.join(' ').trim();
+    const { pid, waitForSession } = spawnDetachedDaemon({
+      cwd: process.cwd(),
+      prompt: initialPrompt || null,
+    });
+    process.stderr.write(`\x1b[2mdaemon spawned pid=${pid}, waiting for session id…\x1b[0m\n`);
+    const sid = await waitForSession();
+    if (sid) {
+      process.stderr.write(`\x1b[32m✓\x1b[0m ${sid}\n`);
+      process.stderr.write(`  \x1b[2mattach:\x1b[0m bahulam attach ${sid}\n`);
+      process.stderr.write(`  \x1b[2mstop:  \x1b[0m bahulam stop ${sid}\n`);
+      process.exit(0);
+    } else {
+      process.stderr.write(`\x1b[33m! daemon spawned (pid ${pid}) but no session id visible after 15s. Check \`bahulam list\`.\x1b[0m\n`);
+      process.exit(2);
+    }
+  }
+
+  //  auto-attach when a live daemon is bound to this cwd.
+  // Opt-in via BAHULAM_AUTO_ATTACH=1 so existing muscle memory (bahulam →
+  // fresh REPL) isn't disrupted for users who haven't opted into the daemon
+  // model. `bahulam --no-attach` bypasses even with the env var set.
+  const wantsAutoAttach = process.env.BAHULAM_AUTO_ATTACH === '1' && !process.argv.includes('--no-attach');
+  if (wantsAutoAttach && !subcommand) {
+    const { findSessionForCwd } = await import('../daemon/daemonize.mjs');
+    const existing = await findSessionForCwd(process.cwd());
+    if (existing) {
+      process.stderr.write(`\x1b[2mattaching to existing daemon ${existing} (BAHULAM_AUTO_ATTACH)…\x1b[0m\n`);
+      const { attachToSession } = await import('../daemon/attach-client.mjs');
+      const code = await attachToSession(existing);
+      process.exit(code || 0);
+    }
+  }
+
+  // ── Headless mode (benchmarks, automation, daemonize) ──
   const args = parseArgs(process.argv.slice(2));
-  if (args.prompt && (process.argv.includes('--headless') || !process.stdin.isTTY)) {
+  // Slice D: when this process is a spawned daemon (via
+  // `bahulam daemonize`), pull the initial prompt from the env var
+  // rather than argv — child was spawned with stdio: 'ignore' and no
+  // shell args. BAHULAM_DAEMON_SPAWNED=1 is set by daemonize.mjs.
+  const daemonSpawned = process.env.BAHULAM_DAEMON_SPAWNED === '1';
+  const daemonPrompt = daemonSpawned ? (process.env.BAHULAM_DAEMON_INITIAL_PROMPT || '').trim() : '';
+  const effectivePrompt = args.prompt || (daemonSpawned && daemonPrompt) || '';
+  if (effectivePrompt && (daemonSpawned || process.argv.includes('--headless') || !process.stdin.isTTY)) {
     const { runHeadless } = await import('../core/headless.mjs');
     await runHeadless({
-      instruction: args.prompt,
+      instruction: effectivePrompt,
       model: args.model,
       timeout: args.timeout || (args.maxTurns ? args.maxTurns * 60 : 600),
       verbose: args.verbose,

package/src/terminal/repl-render.mjs

@@ -814,12 +814,23 @@ export function renderStagnation(data = {}) {
   const rawMessage = data?.message || '';
   const reason = data?.reason || rawMessage.replace(/^Stagnation:\s*/i, '').trim();
   const tool = data?.tool || data?.tool_name || '';
-  const suggestion = data?.suggestion || data?.recovery_strategy || data?.strategy || '';
-  const message = reason
-    ? `Stagnation${tool ? ` (${tool})` : ''}: ${reason}`
-    : `Stagnation${tool ? ` (${tool})` : ''} detected`;
-  const key = `${message}\n${suggestion}`;
-
+  const count = data?.repeat_count || data?.count || null;
+  // Try to extract a target/path from the reason so we can show a
+  // compact one-liner. Reason shapes we know about from the framework:
+  //   "Repeated overlapping <tool> inspections of '<target>' N times without mutation"
+  //   "..."  (fallback: use reason as-is, trimmed to ~80 chars)
+  const targetMatch = reason.match(/of\s+['"]([^'"]+)['"]/);
+  const target = targetMatch ? targetMatch[1] : '';
+
+  // Compose a compact single-line message:
+  //   ! stagnation · read_file × 3 · v3_sse.py
+  // Falls back to a short slice of the reason when we can't parse it.
+  const parts = ['stagnation'];
+  if (tool) parts.push(`${tool}${count ? ` × ${count}` : ''}`);
+  if (target) parts.push(target);
+  const compact = parts.length > 1 ? parts.join(' · ') : reason.slice(0, 80);
+
+  const key = `${tool}:${target}:${count}`;
   if (session._lastStagnationWarning === key) return;
   session._lastStagnationWarning = key;
 
@@ -827,7 +838,9 @@ export function renderStagnation(data = {}) {
   flushContent();
   flushPendingHead();
   renderBlockBoundary('status', { compactSame: true });
-  process.stderr.write(`  ${c.yellow('!')} ${c.yellow(message)}\n`);
-  if (suggestion) process.stderr.write(`    ${c.dim(suggestion)}\n`);
+  // One line, dim yellow, no follow-up paragraph. The full guidance is
+  // still injected into the LLM context on the backend side — no need
+  // to also spam the operator's terminal with it.
+  process.stderr.write(`  ${c.yellow('!')} ${c.dim(c.yellow(compact))}\n`);
   runtime.lastRenderedBlock = 'status';
 }

package/src/terminal/repl.mjs

@@ -25,7 +25,18 @@ import { calculateCost, formatCostValue, formatTokens, costToCredits, formatCred
 import { TarangStreamClient, EVENT_TYPES } from '../core/stream-client.mjs';
 import { AgentHistoryTurnBuilder } from '../core/agent-history.mjs';
 import { JsonlWriter } from '../core/jsonl-writer.mjs';
+import { tapSseEvent, registerBroadcaster } from '../daemon/event-tap.mjs';
+import { startSocketServer } from '../daemon/socket-server.mjs';
+import { resolvePending, interceptApproval, shutdownAllPending, setTimeoutPolicy } from '../daemon/approval-store.mjs';
+import { wireEmit as wireInputLockEmit, resetInputLock } from '../daemon/input-lock.mjs';
+import { startRelayBridge } from '../daemon/relay-client.mjs';
+import { loadRemoteConfig } from '../commands/remote.mjs';
 import { createToolExecutor } from '../core/tool-executor.mjs';
+// PRD-091 Phase 3 preview: opt-in gateway loop path. Set
+// BAHULAM_USE_GATEWAY_LOOP=1 to route the REPL's turn through
+// /v1/agent/turn instead of the local bundled runtime. Falls back to
+// the existing local-agent path if the flag is unset.
+import { createAgentLoop, createGatewaySession } from '../core/loop.mjs';
 import { buildWorkScope, promptProjectRoots } from '../core/work-scope.mjs';
 import { CheckpointManager } from '../core/checkpoints.mjs';
 import { HookRunner } from '../config/hook-runner.mjs';
@@ -2008,7 +2019,12 @@ function renderEvent(event) {
       flushFoldedSubAgentTools();
       const agentType = data?.type || 'sub-agent';
       const usage = data?.usage || {};
-      const tokens = (usage.input_tokens || 0) + (usage.output_tokens || 0);
+      // Output tokens = generation size. Summing input+output across a
+      // multi-iteration sub-agent double-counts the context re-shipped each
+      // iteration (a 16-iter run can inflate to 600k+ "tokens" of which
+      // ~95% is repeated context) — the resulting number reads as usage but
+      // it's really billing accumulation, not useful signal in the close line.
+      const tokens = usage.output_tokens || 0;
       const costUsd = usage.cost_usd ?? usage.total_cost_usd ?? data?.cost_usd ?? null;
       if (typeof costUsd === 'number') session.savedUsd += costUsd;
       const summary = data?.result_summary
@@ -2048,6 +2064,150 @@ function renderEvent(event) {
         session.id = data.session_id;
         // Track in session manager so conversations save to the right file
         if (sessionMgrRef.current) sessionMgrRef.current.setSessionInfo({ session_id: data.session_id });
+        // Wire socket server for attach clients.
+        // renderEvent() is NOT async, so we can't `await startSocketServer(...)`
+        // directly (that fails at import time — "Unexpected reserved word").
+        // Fire-and-forget IIFE, and guard against re-entry on session_info
+        // repeats (backend can re-emit on reconnect; two listen()s on the
+        // same sock path → EADDRINUSE and both server + tap explode).
+        if (process.env.BAHULAM_DAEMON_EVENTLOG === '1' && !session._prd092SocketStarting && !session._prd092SocketServer) {
+          session._prd092SocketStarting = true;
+          const _sid = session.id;
+          (async () => {
+            try {
+              const server = await startSocketServer({
+                sessionId: _sid,
+                onCommand: {
+                  // Slice E — approve/deny now resolve any pending approval
+                  // registered via interceptApproval(). Returns false if the
+                  // apr_id is unknown or already answered (log-only, not an
+                  // error surfaced to the client — the racy nature of two
+                  // attaches answering is expected).
+                  approve: async (payload, attachId) => {
+                    const ok = resolvePending('approve', payload?.apr_id, attachId, payload?.note);
+                    if (!ok) try { process.stderr.write(`[prd-092] approve for unknown apr_id ${payload?.apr_id}\n`); } catch {}
+                  },
+                  deny: async (payload, attachId) => {
+                    const ok = resolvePending('deny', payload?.apr_id, attachId, payload?.note);
+                    if (!ok) try { process.stderr.write(`[prd-092] deny for unknown apr_id ${payload?.apr_id}\n`); } catch {}
+                  },
+                  // Slice C/E — interrupt from an attach holder cancels the
+                  // current turn. Uses the stream client on the closure
+                  // above (streamClient variable is in scope in this file
+                  // at the outer REPL loop; if unavailable, log and skip).
+                  interrupt: async (_payload, _attachId) => {
+                    try { if (typeof streamClient?.cancel === 'function') streamClient.cancel(); } catch {}
+                  },
+                  send_message: async (_payload, _attachId) => {
+                    // Slice C follow-up. Requires plumbing into the turn
+                    // handler; enqueued as a TODO for the daemon slice.
+                  },
+                }
+              });
+              session._prd092SocketServer = server;
+              session._prd092Unregister = registerBroadcaster(evt => server.broadcastEvent(evt));
+              // Slice E — input-lock changes broadcast via the tap so the
+              // input_lock_changed events flow to attached clients + land
+              // in the event log. Emit under the sessionId in scope.
+              wireInputLockEmit((type, data) => {
+                try { tapSseEvent({ type, data }, { sessionId: _sid }); }
+                catch { /* never blocks a lock transition */ }
+              });
+              // Slice E — apply the timeout policy from env (safe default:
+              // 'hold' = never times out). Explicit opt-in via env var so
+              // running unattended is a conscious choice, not a surprise.
+              //   BAHULAM_APPROVAL_TIMEOUT=hold                (default)
+              //   BAHULAM_APPROVAL_TIMEOUT=deny:300            (auto-deny after 5min)
+              //   BAHULAM_APPROVAL_TIMEOUT=allow:300           (auto-approve; gated behind --dangerously-skip-permissions elsewhere)
+              try {
+                const p = String(process.env.BAHULAM_APPROVAL_TIMEOUT || 'hold').trim();
+                const [mode, secStr] = p.split(':');
+                setTimeoutPolicy({
+                  mode: (mode === 'deny' || mode === 'allow') ? mode : 'hold',
+                  durationSec: Number(secStr) || 0,
+                });
+              } catch { /* stay on hold */ }
+              // Slice E — intercept ApprovalManager.check so every prompt
+              // also emits approval_required to attached clients AND can be
+              // resolved by a remote approve/deny command (racing the local
+              // TTY prompt; first answer wins). Only patch once per session.
+              try {
+                if (approval && !approval._prd092Intercepted) {
+                  const orig = approval.check.bind(approval);
+                  approval.check = (tool, args, req, ctx) => interceptApproval(orig, {
+                    tool, args, req, ctx,
+                    sessionId: _sid,
+                    emit: (type, data) => {
+                      try { tapSseEvent({ type, data }, { sessionId: _sid }); }
+                      catch { /* never blocks approval */ }
+                    },
+                  });
+                  approval._prd092Intercepted = true;
+                }
+              } catch (err) {
+                try { process.stderr.write(`[prd-092] approval intercept: ${err.message}\n`); } catch {}
+              }
+              // Slice H — dial the relay if `bahulam remote enable` set the
+              // flag. Bridge is bidirectional: local events go out as
+              // control-frame envelopes, incoming envelopes dispatch to the
+              // same handlers the local socket-server uses (so approve/deny
+              // from a phone runs the same resolvePending path).
+              try {
+                const remoteCfg = loadRemoteConfig();
+                if (remoteCfg?.enabled) {
+                  const bridge = startRelayBridge({
+                    sessionId: _sid,
+                    remoteConfig: remoteCfg,
+                    registerBroadcaster,
+                    onCommand: {
+                      approve: async (payload, attachId) => resolvePending('approve', payload?.apr_id, attachId, payload?.note),
+                      deny: async (payload, attachId) => resolvePending('deny', payload?.apr_id, attachId, payload?.note),
+                      interrupt: async () => { try { if (typeof streamClient?.cancel === 'function') streamClient.cancel(); } catch {} },
+                      send_message: async (_p, _a) => { /* Slice C follow-up */ },
+                    },
+                  });
+                  session._prd092RelayBridge = bridge;
+                }
+              } catch (err) {
+                try { process.stderr.write(`[prd-092] relay bridge: ${err.message}\n`); } catch {}
+              }
+              // Populate ~/.bahulam/sessions/<id>/meta.json + daemon.pid so
+              // `bahulam list` and `bahulam stop <id>` see this session.
+              // These files are what session-list.mjs / stop-daemon.mjs
+              // read; without them those commands are cosmetic. Fire-and-
+              // forget imports so a write failure never affects the turn.
+              try {
+                const [{ writeSessionMeta }, fs, path, { daemonSessionDir }] = await Promise.all([
+                  import('../core/event-log.mjs'),
+                  import('node:fs'),
+                  import('node:path'),
+                  import('../core/paths.mjs'),
+                ]);
+                await writeSessionMeta({
+                  sessionId: _sid,
+                  meta: {
+                    cwd: process.cwd(),
+                    model: session.model || null,
+                    pid: process.pid,
+                    sock_path: server.sockPath,
+                    opened_at: new Date().toISOString(),
+                  },
+                });
+                fs.writeFileSync(
+                  path.join(daemonSessionDir(_sid), 'daemon.pid'),
+                  String(process.pid),
+                  { mode: 0o600 },
+                );
+              } catch (err) {
+                try { process.stderr.write(`[prd-092] meta/pid write: ${err.message}\n`); } catch {}
+              }
+            } catch (err) {
+              try { process.stderr.write(`[prd-092] socket server: ${err.message}\n`); } catch {}
+            } finally {
+              session._prd092SocketStarting = false;
+            }
+          })();
+        }
       }
       if (data?.model) session.model = data.model;
       if (data?.models?.coder) session.model = data.models.coder;
@@ -5116,8 +5276,47 @@ export async function startTerminalRepl() {
         }
       }
 
-      for await (const event of client.execute(input, execContext, session.agentHistory)) {
+      // PRD-091 Phase 3 preview: BAHULAM_USE_GATEWAY_LOOP=1 routes the
+      // turn through the gateway's /v1/agent/turn (thin CLI loop) instead
+      // of the local bundled runtime. Session is bootstrapped lazily on
+      // first turn and reused across the REPL. Falls through to the
+      // existing local-agent path when the flag is unset (default today).
+      const _useGatewayLoop = process.env.BAHULAM_USE_GATEWAY_LOOP === '1';
+      let _turnIterable;
+      if (_useGatewayLoop) {
+        if (!session.gatewaySession) {
+          try {
+            session.gatewaySession = await createGatewaySession({
+              workspace: process.env.BAHULAM_WORKSPACE || 'kepler-code',
+              model: process.env.BAHULAM_MODEL || undefined,
+            });
+            process.stderr.write(
+              `  ${c.dim(`[gateway] session ${session.gatewaySession.session_id.slice(0, 20)}… ${session.gatewaySession.tool_schemas.length} tools, model=${session.gatewaySession.model}`)}\n`,
+            );
+          } catch (err) {
+            process.stderr.write(`  ${c.warn(`[gateway] session create failed: ${err.message}`)}\n`);
+            process.stderr.write(`  ${c.dim('falling back to local-agent path')}\n`);
+            session.gatewaySession = null;  // don't retry every turn
+          }
+        }
+        if (session.gatewaySession) {
+          _turnIterable = createAgentLoop({
+            session: session.gatewaySession,
+            messages: session.agentHistory,
+            toolExecutor,
+          });
+        }
+      }
+      if (!_turnIterable) {
+        _turnIterable = client.execute(input, execContext, session.agentHistory);
+      }
+      for await (const event of _turnIterable) {
         jsonlWriter.writeKeplerEvent(event);
+        // . daemon event log. Env-var gated (off by default) —
+        // when BAHULAM_DAEMON_EVENTLOG=1, mirror each SSE frame that maps
+        // to a first-class type into ~/.bahulam/sessions/<id>/events.jsonl.
+        // No-op otherwise; zero effect on the render path either way.
+        tapSseEvent(event, { sessionId: session.id });
         if (event.type === 'plan_created' || event.type === 'goal_created') {
           persistProjectArtifacts(
             event.data,

package/src/tools/analyze-code.mjs

@@ -0,0 +1,39 @@
+/**
+ * Analyze Code Tool — AST-based structured code analysis (matches Python schema).
+ */
+import { analyzeCode } from '../context/ast-parser.mjs';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+export const AnalyzeCodeTool = {
+    name: 'analyze_code',
+    description:
+        'Get structured analysis of one specific file: function/class names with LINE NUMBERS, imports, exports. Never pass a directory or project root.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            file_path: { type: 'string', description: 'Path to a specific file to analyze' },
+        },
+        required: ['file_path'],
+    },
+    validateInput(input) {
+        return input.file_path ? [] : ['file_path required'];
+    },
+    async call(input) {
+        const filePath = path.resolve(input.file_path);
+        let stat;
+        try {
+            stat = fs.statSync(filePath);
+        } catch (err) {
+            return `Error: ${err.message}`;
+        }
+        if (stat.isDirectory()) {
+            return `Error: analyze_code expects a file, but got directory: ${filePath}. Use list_files/search_code first, then pass a specific source file.`;
+        }
+        const result = analyzeCode(filePath, {
+            startLine: input.start_line,
+            endLine: input.end_line,
+        });
+        return result.summary;
+    },
+};

package/src/tools/bash.mjs

@@ -20,7 +20,7 @@ const MAX_OUTPUT_BYTES = 1024 * 1024; // 1MB
 const TIMEOUT_TAIL_BYTES = 64 * 1024;
 
 export const BashTool = {
-    name: 'Bash',
+    name: 'shell',
     description: 'Execute a bash command and return its output.',
     inputSchema: {
         type: 'object',

package/src/tools/edit.mjs

@@ -3,7 +3,7 @@
  *
  * Features:
  * - replace_all parameter for global replacement
- * - Verify old_string is unique (error if not)
+ * - Verify search string is unique (error if not)
  * - Require file was Read first (track read files)
  * - Preserve exact indentation
  */
@@ -12,23 +12,23 @@ import path from 'path';
 import { hasBeenRead, markRead } from './read.mjs';
 
 export const EditTool = {
-    name: 'Edit',
+    name: 'edit_file',
     description: 'Performs exact string replacements in files.',
     inputSchema: {
         type: 'object',
         properties: {
             file_path: { type: 'string', description: 'Absolute path to the file' },
-            old_string: { type: 'string', description: 'The text to replace' },
-            new_string: { type: 'string', description: 'The replacement text' },
+            search: { type: 'string', description: 'The text to replace' },
+            replace: { type: 'string', description: 'The replacement text' },
             replace_all: { type: 'boolean', description: 'Replace all occurrences', default: false },
         },
-        required: ['file_path', 'old_string', 'new_string'],
+        required: ['file_path', 'search', 'replace'],
     },
     validateInput(input) {
         const errors = [];
         if (!input.file_path) errors.push('file_path required');
-        if (!input.old_string && input.old_string !== '') errors.push('old_string required');
-        if (input.old_string === input.new_string) errors.push('old_string must differ from new_string');
+        if (!input.search && input.search !== '') errors.push('search is required');
+        if (input.search === input.replace) errors.push('search must differ from replace');
         return errors;
     },
     async call(input) {
@@ -51,23 +51,23 @@ export const EditTool = {
             return `Error: ${e.message}`;
         }
 
-        if (!content.includes(input.old_string)) {
-            return 'Error: old_string not found in file. Make sure the string matches exactly, including whitespace and indentation.';
+        if (!content.includes(input.search)) {
+            return 'Error: search string not found in file. Make sure the string matches exactly, including whitespace and indentation.';
         }
 
         if (input.replace_all) {
             // Replace all occurrences
-            const escaped = input.old_string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-            content = content.replace(new RegExp(escaped, 'g'), input.new_string);
+            const escaped = input.search.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            content = content.replace(new RegExp(escaped, 'g'), input.replace);
         } else {
-            // Check uniqueness: old_string must appear exactly once
-            const firstIdx = content.indexOf(input.old_string);
-            const secondIdx = content.indexOf(input.old_string, firstIdx + 1);
+            // Check uniqueness: search string must appear exactly once
+            const firstIdx = content.indexOf(input.search);
+            const secondIdx = content.indexOf(input.search, firstIdx + 1);
             if (secondIdx !== -1) {
-                const count = content.split(input.old_string).length - 1;
-                return `Error: old_string is not unique in the file (found ${count} occurrences). Provide more context to make it unique, or use replace_all to replace all occurrences.`;
+                const count = content.split(input.search).length - 1;
+                return `Error: search string is not unique in the file (found ${count} occurrences). Provide more context to make it unique, or use replace_all to replace all occurrences.`;
             }
-            content = content.replace(input.old_string, input.new_string);
+            content = content.replace(input.search, input.replace);
         }
 
         try {
@@ -79,4 +79,4 @@ export const EditTool = {
             return `Error writing file: ${e.message}`;
         }
     },
-};
+};

package/src/tools/git-diff.mjs

@@ -0,0 +1,34 @@
+/**
+ * Git Diff Tool — shows unstaged changes (matches Python schema).
+ */
+import { execSync } from 'node:child_process';
+import * as path from 'node:path';
+
+export const GitDiffTool = {
+    name: 'git_diff',
+    description: 'Show git diff of current changes — verify what was modified',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            file_path: { type: 'string', description: 'Specific file to diff (optional, defaults to all changes)' },
+        },
+    },
+    validateInput(input) {
+        return [];
+    },
+    async call(input) {
+        try {
+            const cwd = input._cwd || process.cwd();
+            const fileArg = input.file_path ? ` -- "${input.file_path}"` : '';
+            const output = execSync(`git diff${fileArg}`, {
+                encoding: 'utf-8',
+                timeout: 10_000,
+                cwd,
+                stdio: 'pipe',
+            }).toString().trim();
+            return output || '(no changes)';
+        } catch (err) {
+            return `Error: ${err.message}`;
+        }
+    },
+};

package/src/tools/git-status.mjs

@@ -0,0 +1,30 @@
+/**
+ * Git Status Tool — shows working tree status (matches Python schema).
+ */
+import { execSync } from 'node:child_process';
+
+export const GitStatusTool = {
+    name: 'git_status',
+    description: 'Show git status — list modified, added, deleted files',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+    },
+    validateInput(input) {
+        return [];
+    },
+    async call(input) {
+        try {
+            const cwd = input._cwd || process.cwd();
+            const output = execSync('git status --short', {
+                encoding: 'utf-8',
+                timeout: 10_000,
+                cwd,
+                stdio: 'pipe',
+            }).toString().trim();
+            return output || '(clean)';
+        } catch (err) {
+            return `Error: ${err.message}`;
+        }
+    },
+};