hydra-nano 0.2.0 → 0.3.0

package/README.md

@@ -86,6 +86,18 @@ Through MCP, Hydra offers the three where it pays most: `hydra_git`, `hydra_run`
 
 Receipts: [model card](https://huggingface.co/rahul05ranjan/hydra-nano-git) and [`evals/results`](https://github.com/rahul05ranjan/hydra/tree/main/evals/results).
 
+<!-- usage-stats:begin (written by evals/usage/readme_stats.mjs) -->
+**In real use.** Since 2026-10-17, Hydra has handled **118 calls** in **9 coding sessions** across **3 projects** on the maintainer's machine. Of **~375,638 tokens** of command output, **~18,781** reached the agent: **95% kept out of context**.
+
+| Work | Calls | Output read locally | Reached the agent | Kept out |
+|---|---|---|---|---|
+| Test and build runs | 112 | ~374,873 | ~18,199 | **95%** |
+| File slices | 1 | ~508 | ~283 | **44%** |
+| Git questions | 5 | ~257 | ~299 | **-16%** |
+
+<sub>From Hydra's local ledger; tokens are estimates (characters / 4). Updated 2026-10-20.</sub>
+<!-- usage-stats:end -->
+
 **Where Hydra does not help, measured.** In a controlled trial of 36 Claude Code sessions extracting functions from real source code, forcing that work through Hydra used **72% more tokens** than the agent's own tools. So Hydra leaves source reading and search to the agent, and routes only the noisy work: test and build logs, git history, system inspection. Full method and numbers in [evaluations](https://github.com/rahul05ranjan/hydra/blob/main/docs/evaluations.md).
 
 ## Commands
@@ -95,6 +107,9 @@ hydra ask "which branch am I on and what changed?"   # git, files or os, routed
 hydra run -- pytest -q                               # a test or build run, digested
 hydra os "what is using port 8080?"                  # read-only system inspection
 hydra read src/app.py create_app                     # one symbol, a line range or an outline
+hydra smell src/                                     # detect Refactoring.Guru code smells (or --diff / --staged)
+hydra refactor src/app.py process_order              # actionable step-by-step refactoring recipe
+hydra design "need flexible algorithms at runtime"   # GoF design pattern advisor & architecture guide
 hydra stats                                          # tokens kept out of context
 hydra improve --since 2026-10-17                     # what the local telemetry says to improve
 hydra agents status                                  # Hydra in each coding tool

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hydra-nano",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Small local models that take the noisy work off your coding agent: git history, test and build digests and OS inspection run on your machine, and only the lines that matter reach Claude Code, Codex, Cursor, OpenCode, Gemini CLI or Antigravity. Skill, MCP server and hooks.",
   "keywords": [
     "claude-code",
@@ -52,7 +52,8 @@
     "eval:frontier": "node evals/trial/frontier_trial.mjs --run",
     "eval:real:prepare": "node evals/trial/real_repo_trial.mjs",
     "eval:real": "node evals/trial/real_repo_trial.mjs --run",
-    "dashboard": "node dashboard/server.mjs"
+    "dashboard": "node dashboard/server.mjs",
+    "stats:readme": "node evals/usage/readme_stats.mjs"
   },
   "engines": {
     "node": ">=18"

package/skills/hydra/SKILL.md

@@ -1,41 +1,35 @@
 ---
 name: hydra
-description: Hand a read-only git question (repo state, history, blame), a where-is-it code search, targeted file slicing instead of whole-file reads, test/build failure digests, or system/OS inspections (ports, processes, disk) to hydra locally. Use before running git status, log, diff, show, blame, broad searches, whole file reads, ps/lsof dumps, or test/build commands where noisy output would flood your context.
+description: Run test and build commands, git history/diff/blame questions, and machine inspections (ports, processes, disk) through hydra, a local model that returns only the lines that matter. Use before running npm test, pytest, cargo test, tsc or a build, before reading git log, diff, show or blame output, and before ps, lsof or df dumps.
 ---
 
 # Hydra
 
-`hydra` runs read-only commands for repo questions, file slicing, test/build runs, and system inspections on a small local model and prints the lines that answer it. The raw output stays on this machine instead of entering your context.
+`hydra` runs a noisy read-only command on this machine and prints only the lines that answer the question; the raw output stays out of your context. It pays off where output is long and mostly noise: test and build logs, git history and diffs, process and port listings.
 
 ## Call it
 
-From the repository the question is about, naming the head that fits:
+From the repository the question is about:
 
 ```
+node scripts/hydra.mjs run -- <test or build command...>
 node scripts/hydra.mjs ask --head git "<question>"
-node scripts/hydra.mjs ask --head files "<question>"
-node scripts/hydra.mjs ask --head read "<question>"
-node scripts/hydra.mjs ask --head test "<question>"
-node scripts/hydra.mjs ask --head os "<question>"
-node scripts/hydra.mjs search <term...>
-node scripts/hydra.mjs read <file> [symbol|--lines <start-end>|--outline]
-node scripts/hydra.mjs run -- <command...>
 node scripts/hydra.mjs os [question...]
 ```
 
-`scripts/` is in this skill's directory. Ask one full question per call and name the file, branch, commit or author when you know it: the model may only use a path, revision or name that appears in your question.
-- For finding definitions & files: use `hydra search <term>` to get definition-ranked matches without noise or raw grep dumps.
-- For reading code: use `hydra read <file> [symbol|--lines]` instead of reading multi-thousand-line files. It returns the exact symbol or slice, or a structural outline of symbols.
-- For tests and builds: run `hydra run -- <command...>` to execute the command locally and get the failure evidence with its exit code.
-- For system and environment: use `hydra os` or `--head os` to inspect listening ports, top processes, disk space, and system info without dumping 500 lines of terminal output into context.
+`scripts/` is in this skill's directory.
+
+- **Tests and builds:** `run --` executes the command and returns the failing tests, assertion diffs and source locations with the exit code, or a short pass summary. A run you already cut to a few lines yourself (`| tail -n 20`) gains nothing from Hydra.
+- **Git:** ask one full question per call and name the file, branch, commit or author when you know it; the model may only use a path, revision or name that appears in your question. A short check such as `git status --short` is cheaper to run yourself.
+- **Machine:** ports, processes, disk, memory, system info and environment variable names, with secrets withheld.
+
+Read and search source files with your own tools: a measured trial found routing that work through Hydra cost 72% more tokens. Hydra also has `search`, `read`, `smell`, `refactor` and `design` commands (`node scripts/hydra.mjs` with no arguments lists them) for when the user asks for them.
 
 ## What it answers
 
+- **test**: test and build output (`npm test`, `pytest`, `cargo test`, `go test`, `tsc` and others). On failure, the failing test name, assertion diff and the user's own file:line, with node_modules and framework frames dropped.
 - **git**: current branch and sync state, uncommitted and staged changes, commit history, what this branch adds over a base branch, one commit's patch, blame, branches, worktrees, remotes, stashes, tags.
-- **files**: where a name is defined or used, and which files are named like it.
-- **read**: extracts symbol definitions (functions, classes, methods), line ranges (`--lines 10-50`), or structural definition outlines across TypeScript, JavaScript, Python, Rust, and Go without dumping whole files into context.
-- **test**: runs and parses test and build outputs (`npm test`, `pytest`, `cargo test`, `tsc`). If tests fail, extracts the failing test name, assertion diff, and exact user file:line location, stripping node_modules and framework traces.
-- **os**: inspects listening ports (`lsof`), running processes / CPU consumers (`ps`), disk space (`df -h`), and system info (`uptime`, `uname`) while strictly guarding against printing secrets.
+- **os**: listening ports, running processes and CPU consumers, disk space, memory, system info, environment variable names, never their values.
 
 Changes to the repository, and questions that need reasoning about what code does, stay with you.
 

package/skills/hydra/scripts/hooks/route-tests.mjs

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 // Shell-command hook: a test or build run goes through `hydra run --` (or the hydra_run MCP tool),
 // whose digest keeps failing test names, assertion diffs and source locations and drops the rest.
-// Prefix a command with HYDRA_RAW=1 when the raw log is really needed.
+// A run already cut to a few lines by its own pipeline (| tail -n 15, | grep -c) passes: Hydra would
+// save little and a retry costs more. Prefix a command with HYDRA_RAW=1 when the raw log is really needed.
 // --format picks the tool's hook protocol:
 //   claude, codex  PreToolUse; command at tool_input.command; deny via hookSpecificOutput.
 //   gemini         BeforeTool on run_shell_command; deny via {"decision": "deny", "reason"}.
@@ -10,7 +11,7 @@
 // that simply passes is recorded without its text.
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { rawBypass, testRun } from '../lib/claude_hooks.mjs';
+import { rawBypass, testRun, trimmedRun } from '../lib/claude_hooks.mjs';
 import { record } from '../lib/ledger.mjs';
 
 const hydra = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'hydra.mjs');
@@ -40,7 +41,7 @@ process.stdin.on('data', chunk => { input += chunk; }).on('end', () => {
     ...(session ? { session } : {}), hookMs: Math.round(process.uptime() * 1000) });
   const run = testRun(command);
   if (!run) {
-    record(rawBypass(command) ? event('raw') : event('pass', false));
+    record(rawBypass(command) ? event('raw') : trimmedRun(command) ? event('trimmed') : event('pass', false));
     if (answer.pass) process.stdout.write(JSON.stringify(answer.pass));
     return;
   }
@@ -48,5 +49,6 @@ process.stdin.on('data', chunk => { input += chunk; }).on('end', () => {
   process.stdout.write(JSON.stringify(answer.deny(`Test/build runs go through Hydra so the full log stays out of context. Run it as:\n` +
     `  node "${hydra}" run -- ${run}\n${format === 'claude' ? '' : 'or call the hydra_run tool with that command. '}` +
     `(Keep any cd or env prefix before it.) Hydra returns the failing tests, assertion diffs and source locations ` +
-    `verbatim, or a short pass summary. If you truly need the raw log, prefix the original command with HYDRA_RAW=1.`)));
+    `verbatim, or a short pass summary. A run you cut to a few lines yourself (| tail -n 40 or less, or | grep ... | head -40) also passes. ` +
+    `If you truly need the raw log, prefix the original command with HYDRA_RAW=1.`)));
 });

package/skills/hydra/scripts/hydra.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync, statSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -16,6 +16,7 @@ import { route } from './lib/route.mjs';
 import { stopLocal } from './lib/local.mjs';
 import { hookStatus, installHooks, removeHooks } from './lib/claude_hooks.mjs';
 import * as integrations from './lib/integrations.mjs';
+import * as refactor from './lib/refactor.mjs';
 
 const HEADS = { git, files, test: test_logs, read, os: osHead };
 
@@ -23,6 +24,9 @@ const USAGE = `usage:
   hydra ask "<question>" [--head git|files|test|read|os] answer a question about the repo or system
   hydra search <term...>                               search codebase with definition ranking
   hydra read <file> [symbol|--lines <start-end>]       slice a file, symbol, or show outline
+  hydra smell [file|dir|--diff|--staged]               detect Refactoring.Guru code smells & anti-patterns
+  hydra refactor <file> [symbol|--lines <start-end>]   step-by-step refactoring recipe for a function or range
+  hydra design [pattern|query] [--file <file>]         GoF design pattern advisor & architecture guide
   hydra run [--head test] -- <command...>              run a command and digest test/build output
   hydra os [question...]                               inspect ports, processes, disk, system
   hydra stats                                          token accounting for past calls
@@ -32,7 +36,7 @@ const USAGE = `usage:
   hydra stop                                           stop Hydra's managed llama-server
   hydra hooks install|remove|status                    Claude Code hooks that route tests and git questions here
   hydra agents install|remove|status [tool...]         Hydra's MCP server and hooks in codex, cursor, opencode,
-                                                       gemini-cli and antigravity (default: every tool found)
+                                                       gemini-cli, antigravity and antigravity-ide (default: every tool found)
   hydra mcp                                            run the MCP server on stdio`;
 
 function fail(code, message) {
@@ -40,6 +44,11 @@ function fail(code, message) {
   process.exit(code);
 }
 
+// The footer reports a saving; when there is none (short output passed through whole) it is pure cost.
+function withFooter(text, head, raw, returned, seconds) {
+  return returned < raw ? `${text}\n\n[hydra ${head} · read ~${raw} tok locally, returned ~${returned} tok · ${seconds}s]` : text;
+}
+
 async function ask(args) {
   const flag = args.indexOf('--head');
   const forced = flag >= 0 ? args.splice(flag, 2)[1] : undefined;
@@ -60,7 +69,7 @@ async function ask(args) {
   const seconds = Number(((Date.now() - started) / 1000).toFixed(1));
 
   record({ ts: new Date().toISOString(), head, question, raw, returned, seconds, modelCalls: meter.modelCalls, modelSeconds: meter.modelSeconds });
-  console.log(`${text}\n\n[hydra ${head} · read ~${raw} tok locally, returned ~${returned} tok · ${seconds}s]`);
+  console.log(withFooter(text, head, raw, returned, seconds));
 }
 
 async function runCommand(args) {
@@ -78,7 +87,7 @@ async function runCommand(args) {
         const returned = tokens(text.length);
         const seconds = Number(((Date.now() - started) / 1000).toFixed(1));
         record({ ts: new Date().toISOString(), head: 'test', question: 'pipe', raw, returned, seconds, modelCalls: meter.modelCalls, modelSeconds: meter.modelSeconds });
-        console.log(`${text}\n\n[hydra test · read ~${raw} tok locally, returned ~${returned} tok · ${seconds}s]`);
+        console.log(withFooter(text, 'test', raw, returned, seconds));
         if (exitCode !== 0) process.exit(exitCode);
         return;
       }
@@ -103,7 +112,7 @@ async function runCommand(args) {
   const seconds = Number(((Date.now() - started) / 1000).toFixed(1));
   record({ ts: new Date().toISOString(), head: 'test', question: cmdArgs.join(' '), raw, returned, seconds,
     commandSeconds, exit: exitCode, modelCalls: meter.modelCalls, modelSeconds: meter.modelSeconds });
-  console.log(`${text}\n\n[hydra test · read ~${raw} tok locally, returned ~${returned} tok · ${seconds}s]`);
+  console.log(withFooter(text, 'test', raw, returned, seconds));
   if (exitCode !== 0) process.exit(exitCode);
 }
 
@@ -154,7 +163,7 @@ async function readCommand(args) {
     seconds,
   });
 
-  console.log(`${res.text}\n\n[hydra read · read ~${raw} tok locally, returned ~${returned} tok · ${seconds}s]`);
+  console.log(withFooter(res.text, 'read', raw, returned, seconds));
 }
 
 async function osCommand(args) {
@@ -168,7 +177,7 @@ async function osCommand(args) {
   const seconds = Number(((Date.now() - started) / 1000).toFixed(1));
 
   record({ ts: new Date().toISOString(), head: 'os', question, raw, returned, seconds, modelCalls: meter.modelCalls, modelSeconds: meter.modelSeconds });
-  console.log(`${text}\n\n[hydra os · read ~${raw} tok locally, returned ~${returned} tok · ${seconds}s]`);
+  console.log(withFooter(text, 'os', raw, returned, seconds));
 }
 
 async function searchCommand(args) {
@@ -208,7 +217,7 @@ async function searchCommand(args) {
     seconds,
   });
 
-  console.log(`${text}\n\n[hydra files · read ~${raw} tok locally, returned ~${returned} tok · ${seconds}s]`);
+  console.log(withFooter(text, 'files', raw, returned, seconds));
 }
 
 function showStats() {
@@ -240,10 +249,10 @@ function improve(args) {
   for (const [agent, a] of Object.entries(report.agents)) {
     lines.push(`agent  ${agent}: ${a.calls} calls (${a.viaMcp} through MCP), ${a.denials} runs turned back, ${a.sessions} sessions started`);
   }
-  const { denials, followedByHydra, rawBypasses } = report.hooks;
+  const { denials, followedByHydra, trimmed, rawBypasses } = report.hooks;
   const { decisions, p50Ms, p90Ms } = report.hooks;
   lines.push(`hooks  ${decisions} Bash calls checked (p50 ${p50Ms} ms, p90 ${p90Ms} ms); ${denials} test/build runs turned back, ` +
-    `${followedByHydra} followed by a Hydra run within 5 minutes`);
+    `${followedByHydra} followed by a Hydra run within 5 minutes; ${trimmed} let through already cut short (| tail -n N)`);
   for (const command of rawBypasses) lines.push(`         HYDRA_RAW=1 bypass (check for a false match): ${command.slice(0, 100)}`);
   for (const error of report.errors) lines.push(`error  ${error.ts} ${error.command}: ${error.error}`);
   console.log(lines.join('\n'));
@@ -289,6 +298,180 @@ This command prints instructions only; it does not install, download or launch a
   }
 }
 
+async function smellCommand(args) {
+  const isJson = args.includes('--json');
+  const isDiff = args.includes('--diff');
+  const isStaged = args.includes('--staged');
+  const target = args.filter(a => !a.startsWith('--'))[0] || (isDiff || isStaged ? '.' : process.cwd());
+
+  const started = Date.now();
+  let text = '';
+  let rawChars = 0;
+
+  if (isDiff || isStaged) {
+    const gitArgs = ['diff'];
+    if (isStaged) gitArgs.push('--staged');
+    const diffRes = await run('git', gitArgs, process.cwd());
+    const diffOutput = diffRes.out || '';
+    rawChars = diffOutput.length;
+    const diffReport = refactor.scanDiff(diffOutput);
+    if (isJson) {
+      text = JSON.stringify(diffReport, null, 2);
+    } else {
+      if (!diffReport.filesWithSmells) {
+        text = '✔ No code smells introduced in this diff.';
+      } else {
+        text = `[hydra smell] ${diffReport.filesWithSmells} changed files with smells:\n\n` +
+          diffReport.reports.map(r => refactor.formatSmellReport(r)).join('\n\n');
+      }
+    }
+  } else {
+    const resolved = path.resolve(target);
+    if (!existsSync(resolved)) fail(1, `hydra smell: path not found: ${target}`);
+    const isDir = statSync(resolved).isDirectory();
+    if (isDir) {
+      const dirReport = refactor.scanDirectory(resolved);
+      rawChars = dirReport.reports.reduce((s, r) => s + r.totalLines * 30, 100);
+      if (isJson) {
+        text = JSON.stringify(dirReport, null, 2);
+      } else {
+        if (!dirReport.filesWithSmells) {
+          text = `✔ ${target}: No code smells detected across scanned files.`;
+        } else {
+          text = `[hydra smell] ${dirReport.totalSmells} smells across ${dirReport.filesWithSmells} files in ${target}:\n\n` +
+            dirReport.reports.map(r => refactor.formatSmellReport(r)).join('\n\n');
+        }
+      }
+    } else {
+      const report = refactor.scanFile(resolved);
+      rawChars = report.totalLines * 35;
+      text = isJson ? JSON.stringify(report, null, 2) : refactor.formatSmellReport(report);
+    }
+  }
+
+  const raw = tokens(rawChars);
+  const returned = tokens(text.length);
+  const seconds = Number(((Date.now() - started) / 1000).toFixed(2));
+
+  record({
+    ts: new Date().toISOString(),
+    head: 'refactor',
+    question: `smell ${args.join(' ')}`,
+    raw,
+    returned,
+    seconds,
+  });
+
+  console.log(withFooter(text, 'smell', raw, returned, seconds));
+}
+
+async function refactorCommand(args) {
+  const isJson = args.includes('--json');
+  const cleanArgs = args.filter(a => a !== '--json');
+  if (cleanArgs.length === 0) fail(1, 'usage: hydra refactor <file> [symbol|--lines <start-end>]');
+
+  let fileArg = null;
+  let symbol = null;
+  let lines = null;
+
+  for (let i = 0; i < cleanArgs.length; i++) {
+    const arg = cleanArgs[i];
+    if (arg === '--lines' && i + 1 < cleanArgs.length) {
+      lines = cleanArgs[++i];
+    } else if (arg.startsWith('--lines=')) {
+      lines = arg.slice('--lines='.length);
+    } else if (/^\d+[:-]\d+$/.test(arg)) {
+      lines = arg;
+    } else if (!fileArg) {
+      fileArg = arg;
+    } else if (!symbol) {
+      symbol = arg;
+    }
+  }
+
+  if (!fileArg) fail(1, 'usage: hydra refactor <file> [symbol|--lines <start-end>]');
+  const resolved = path.resolve(fileArg);
+  if (!existsSync(resolved) || statSync(resolved).isDirectory()) {
+    fail(1, `hydra refactor: file not found: ${fileArg}`);
+  }
+
+  const started = Date.now();
+  const content = readFileSync(resolved, 'utf8');
+
+  let startLine, endLine;
+  if (lines) {
+    const [s, e] = lines.split(/[:-]/).map(Number);
+    startLine = s;
+    endLine = e;
+  }
+
+  const recipe = refactor.generateRecipe(content, { symbol, startLine, endLine });
+  const rawChars = content.length;
+  const text = isJson ? JSON.stringify(recipe, null, 2) : refactor.formatRecipe(recipe);
+
+  const raw = tokens(rawChars);
+  const returned = tokens(text.length);
+  const seconds = Number(((Date.now() - started) / 1000).toFixed(2));
+
+  record({
+    ts: new Date().toISOString(),
+    head: 'refactor',
+    question: `refactor ${fileArg}${symbol ? ` ${symbol}` : ''}`,
+    raw,
+    returned,
+    seconds,
+  });
+
+  console.log(withFooter(text, 'refactor', raw, returned, seconds));
+}
+
+async function designCommand(args) {
+  const isJson = args.includes('--json');
+  let fileArg = null;
+  const words = [];
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--json') continue;
+    if (arg === '--file' && i + 1 < args.length) {
+      fileArg = args[++i];
+    } else if (arg.startsWith('--file=')) {
+      fileArg = arg.slice('--file='.length);
+    } else {
+      words.push(arg);
+    }
+  }
+
+  const query = words.join(' ').trim();
+  let codeSnippet = '';
+  if (fileArg) {
+    const resolved = path.resolve(fileArg);
+    if (existsSync(resolved) && !statSync(resolved).isDirectory()) {
+      codeSnippet = readFileSync(resolved, 'utf8').slice(0, 5000);
+    }
+  }
+
+  const started = Date.now();
+  const adv = refactor.advisePattern(query, codeSnippet);
+  const text = isJson ? JSON.stringify(adv, null, 2) : refactor.formatPattern(adv);
+
+  const seconds = Number(((Date.now() - started) / 1000).toFixed(2));
+
+  // A pattern lookup replaces no command output, so it has no raw baseline: it counts as neither a
+  // saving nor a cost, and its size is kept apart.
+  record({
+    ts: new Date().toISOString(),
+    head: 'refactor',
+    question: `design ${query}`,
+    raw: 0,
+    returned: 0,
+    replyTokens: tokens(text.length),
+    seconds,
+  });
+
+  console.log(text);
+}
+
 const [command, ...rest] = process.argv.slice(2);
 const commands = {
   ask: () => ask(rest),
@@ -297,6 +480,9 @@ const commands = {
   run: () => runCommand(rest),
   test: () => runCommand(rest),
   read: () => readCommand(rest),
+  smell: () => smellCommand(rest),
+  refactor: () => refactorCommand(rest),
+  design: () => designCommand(rest),
   os: () => osCommand(rest),
   stats: showStats,
   improve: () => improve(rest),
@@ -313,16 +499,16 @@ function agentsCommand(args) {
   const ids = words.filter(word => !word.startsWith('--'));
   if (action === 'status') {
     for (const row of integrations.status()) {
-      console.log(`${row.id.padEnd(12)} ${row.present ? 'found    ' : 'not found'}  mcp ${row.mcp ? 'yes' : 'no '}${'hooks' in row ? `  hooks ${row.hooks ? 'yes' : 'no'}` : ''}`);
+      console.log(`${row.id.padEnd(15)} ${row.present ? 'found    ' : 'not found'}  mcp ${row.mcp ? 'yes' : 'no '}${'hooks' in row ? `  hooks ${row.hooks ? 'yes' : 'no'}` : ''}${'skill' in row ? `  skill ${row.skill ? 'yes' : 'no'}` : ''}`);
     }
-    console.log(`claude-code  ${hookStatus().length ? 'hooks yes' : 'hooks no'} (skill and hooks; see hydra hooks status)`);
+    console.log(`claude-code     ${hookStatus().length ? 'hooks yes' : 'hooks no'} (skill and hooks; see hydra hooks status)`);
     return;
   }
-  if (!['install', 'remove'].includes(action)) fail(1, 'usage: hydra agents install|remove|status [codex cursor opencode gemini-cli antigravity] [--no-hooks]');
+  if (!['install', 'remove'].includes(action)) fail(1, 'usage: hydra agents install|remove|status [codex cursor opencode gemini-cli antigravity antigravity-ide] [--no-hooks]');
   const scripts = action === 'install'
     ? integrations.installSharedScripts(path.dirname(fileURLToPath(import.meta.url))) : integrations.sharedScripts();
   const targets = ids.length ? ids : action === 'install' ? integrations.detected(scripts) : Object.keys(integrations.tools(scripts));
-  if (!targets.length) return console.log('No supported coding tool found (codex, cursor, opencode, gemini-cli, antigravity).');
+  if (!targets.length) return console.log('No supported coding tool found (codex, cursor, opencode, gemini-cli, antigravity, antigravity-ide).');
   for (const result of integrations.apply(targets, action, { scripts, hooks: !words.includes('--no-hooks') })) {
     if (result.error) { console.log(`${result.id}: ${result.error}`); continue; }
     console.log(`${result.id}: ${result.changes.length ? result.changes.join('; ') : action === 'install' ? 'nothing changed' : 'nothing to remove'}`);

package/skills/hydra/scripts/lib/claude_hooks.mjs

@@ -31,8 +31,9 @@ export const settingsFile = () => path.join(claudeDir(), 'settings.json');
 
 /** The simple commands of a shell line: split on &&, ||, ;, | and newlines outside quotes, so a
  * quoted grep pattern such as "test\|pytest" is never mistaken for a command of its own. A heredoc
- * body (<<EOF ... EOF) is data, not commands, and is skipped whole. */
-export function simpleCommands(command) {
+ * body (<<EOF ... EOF) is data, not commands, and is skipped whole. With pipes false, a pipeline
+ * (a | b) stays one piece. */
+export function simpleCommands(command, { pipes = true } = {}) {
   const parts = [];
   let current = '';
   let quote = null;
@@ -71,6 +72,8 @@ export function simpleCommands(command) {
       parts.push(current);
       current = '';
       i++;
+    } else if (c === '|' && !pipes) {
+      current += c;
     } else if (c === ';' || c === '|' || c === '\n') {
       parts.push(current);
       current = '';
@@ -84,22 +87,58 @@ export function simpleCommands(command) {
 
 const ownRun = command => /hydra(?:\.mjs)?"?\s+(?:run|test)\b/.test(command);
 
-function runnerIn(command) {
-  const run = simpleCommands(command).map(part => part.replace(/^(?:\w+=\S*\s+)+/, ''))
-    .find(part => RUNNERS.some(re => re.test(part)));
-  return run ? run.replace(/\s+2>&1\s*$/, '') : null;
+// A later pipeline stage that keeps at most this many lines leaves little for Hydra to save.
+const FEW_LINES = 40;
+
+/** A pipeline stage that cuts its input to a few lines or a count: tail/head of at most FEW_LINES
+ * lines (10 when not given), grep -c, or wc. tail -f and tail -n +N can return everything. */
+function cutsShort(stage) {
+  const [name, ...args] = stage.split(/\s+/);
+  if (name === 'wc') return true;
+  if (name === 'grep' || name === 'rg') return args.some(arg => /^-[a-zA-Z]*c[a-zA-Z]*$/.test(arg) || arg === '--count');
+  if (name !== 'tail' && name !== 'head') return false;
+  let lines = 10;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (/^-[a-zA-Z]*[fF]/.test(arg) || arg.startsWith('--follow')) return false;
+    const value = /^-\d+$/.test(arg) ? arg.slice(1) : arg === '-n' || arg === '--lines' ? args[++i]
+      : /^-n./.test(arg) ? arg.slice(2) : arg.startsWith('--lines=') ? arg.slice(8) : null;
+    if (value === null) continue;
+    if (!/^\d+$/.test(value ?? '')) return false;
+    lines = Number(value);
+  }
+  return lines <= FEW_LINES;
+}
+
+/** Each test/build run in a shell line, and whether its own pipeline cuts the output short. */
+function runsIn(command) {
+  return simpleCommands(command, { pipes: false }).flatMap(pipeline => {
+    const stages = simpleCommands(pipeline).map(part => part.replace(/^(?:\w+=\S*\s+)+/, ''));
+    const at = stages.findIndex(part => RUNNERS.some(re => re.test(part)));
+    return at < 0 ? [] : [{ run: stages[at].replace(/\s+2>&1\s*$/, ''), cut: stages.slice(at + 1).some(cutsShort) }];
+  });
 }
 
-/** The test/build run inside a shell command, or null. Hydra's own runs and HYDRA_RAW=1 pass. */
+const passesAnyway = command => !command || ownRun(command) || /\bHYDRA_RAW=1\b/.test(command);
+
+/** The test/build run inside a shell command that would put its whole log in context, or null.
+ * Hydra's own runs, HYDRA_RAW=1 and runs already cut to a few lines (| tail -n 15) pass. */
 export function testRun(command) {
-  if (!command || ownRun(command) || /\bHYDRA_RAW=1\b/.test(command)) return null;
-  return runnerIn(command);
+  if (passesAnyway(command)) return null;
+  return runsIn(command).find(run => !run.cut)?.run ?? null;
+}
+
+/** A command whose every test/build run is already cut to a few lines by its own pipeline. */
+export function trimmedRun(command) {
+  if (passesAnyway(command)) return false;
+  const runs = runsIn(command);
+  return runs.length > 0 && runs.every(run => run.cut);
 }
 
 /** A test/build run let through by HYDRA_RAW=1: the agent wanted more than Hydra's digest. */
 export function rawBypass(command) {
   return Boolean(command) && /\bHYDRA_RAW=1\b/.test(command) && !ownRun(command)
-    && runnerIn(command.replace(/\bHYDRA_RAW=1\s+/g, '')) !== null;
+    && runsIn(command.replace(/\bHYDRA_RAW=1\s+/g, '')).length > 0;
 }
 
 function load(file) {

package/skills/hydra/scripts/lib/integrations.mjs

@@ -8,6 +8,10 @@
 //   opencode     ~/.config/opencode/opencode.json(c) mcp.hydra ~/.config/opencode/plugins/hydra.js tool.execute.before
 //   gemini-cli   ~/.gemini/settings.json mcpServers.hydra     same file, hooks.BeforeTool on run_shell_command
 //   antigravity  ~/.gemini/antigravity/mcp_config.json        none known; the MCP server's instructions guide it
+//   antigravity-ide ~/.gemini/config/mcp_config.json          none known; the skill in ~/.gemini/config/skills/hydra guides it
+//
+// Antigravity IDE (com.google.antigravity-ide, data in ~/.gemini/antigravity-ide) is a different app from
+// the older Antigravity (~/.gemini/antigravity): it reads MCP servers and skills from ~/.gemini/config.
 //
 // Every file Hydra edits is backed up once as <file>.before-hydra, written atomically, and only
 // Hydra's own entries are added or removed. A file Hydra cannot edit safely (JSON with comments, or
@@ -24,7 +28,8 @@ const END = '# <<< hydra <<<';
 /** Hydra's own copy of its scripts, which every tool's MCP entry and hook points at. */
 export const sharedScripts = () => path.join(process.env.HYDRA_HOME ?? path.join(os.homedir(), '.hydra'), 'scripts');
 
-/** Copy the skill's scripts to sharedScripts(), so registrations never point into an npx cache. */
+/** Copy the skill's scripts to sharedScripts(), so registrations never point into an npx cache.
+ * Its SKILL.md goes beside them, for tools that load skills from a folder of their own. */
 export function installSharedScripts(from) {
   const target = sharedScripts();
   if (path.resolve(from) === path.resolve(target)) return target; // Already running from the shared copy.
@@ -33,6 +38,8 @@ export function installSharedScripts(from) {
   cpSync(from, `${target}.hydra-tmp`, { recursive: true });
   rmSync(target, { recursive: true, force: true });
   renameSync(`${target}.hydra-tmp`, target);
+  const skill = path.join(from, '..', 'SKILL.md');
+  if (existsSync(skill)) copyFileSync(skill, path.join(path.dirname(target), 'SKILL.md'));
   return target;
 }
 
@@ -186,6 +193,33 @@ export const Hydra = async () => ({
   };
 }
 
+/** The hydra skill folder (SKILL.md and the scripts it names) in a tool's own skills folder.
+ * An older hydra skill there is replaced; a folder that is not the hydra skill is left alone. */
+function skillFolder(dir, scripts) {
+  const skillFile = path.join(dir, 'SKILL.md');
+  const ours = () => existsSync(skillFile) && /^name:\s*hydra\s*$/m.test(readFileSync(skillFile, 'utf8'));
+  return {
+    install() {
+      const source = path.join(path.dirname(scripts), 'SKILL.md');
+      if (!existsSync(source)) throw new Manual(dir, 'npx github:rahul05ranjan/hydra', `needs the hydra skill, but ${source} is missing; run the installer again`);
+      if (existsSync(dir) && !ours()) throw new Manual(dir, `the hydra skill folder (SKILL.md and scripts/) from ${path.dirname(scripts)}`, 'exists and is not the hydra skill');
+      rmSync(`${dir}.hydra-tmp`, { recursive: true, force: true });
+      mkdirSync(`${dir}.hydra-tmp`, { recursive: true });
+      copyFileSync(source, path.join(`${dir}.hydra-tmp`, 'SKILL.md'));
+      cpSync(scripts, path.join(`${dir}.hydra-tmp`, 'scripts'), { recursive: true });
+      rmSync(dir, { recursive: true, force: true });
+      renameSync(`${dir}.hydra-tmp`, dir);
+      return `${dir}: skill`;
+    },
+    remove() {
+      if (!ours()) return null;
+      rmSync(dir, { recursive: true, force: true });
+      return `${dir}: skill`;
+    },
+    status: () => ours() && existsSync(path.join(dir, 'scripts', 'hydra.mjs')),
+  };
+}
+
 const opencodeConfig = dir => ['opencode.json', 'opencode.jsonc'].map(name => path.join(dir, name)).find(existsSync) ?? path.join(dir, 'opencode.json');
 
 /** Every tool Hydra can join, with where it lives and what Hydra registers there. */
@@ -217,6 +251,9 @@ export function tools(scripts = sharedScripts()) {
         BeforeTool: [{ matcher: 'run_shell_command', hooks: [{ name: 'hydra', type: 'command', command: hookCommand(scripts, 'route-tests.mjs', 'gemini'), timeout: 10_000 }] }] }) } },
     antigravity: { dir: path.join(gemini, 'antigravity'), parts: {
       mcp: jsonServer(path.join(gemini, 'antigravity', 'mcp_config.json'), 'mcpServers', mcp) } },
+    'antigravity-ide': { dir: path.join(gemini, 'antigravity-ide'), parts: {
+      mcp: jsonServer(path.join(gemini, 'config', 'mcp_config.json'), 'mcpServers', mcp),
+      skill: skillFolder(path.join(gemini, 'config', 'skills', 'hydra'), scripts) } },
   };
 }