@ghl-ai/aw 0.1.37-beta.70 → 0.1.37-beta.72

package/integrate.mjs

@@ -522,27 +522,10 @@ export function installIdeHooks() {
     'capabilities/telemetry.mjs',
   ];
 
-  // Legacy hooks (kept for --legacy-hooks rollback)
-  const legacyFiles = ['telemetry-stop.js', 'activity-tracker.js'];
-
-  // Verify new hook files exist in the package
+  // Verify hook files exist in the package
   const hasNewHooks = newHookFiles.every(f => existsSync(join(pkgHooksDir, f)));
   if (!hasNewHooks) {
-    // Fallback: try legacy hooks if new ones aren't built yet
-    const hasLegacy = legacyFiles.every(f => existsSync(join(pkgHooksDir, f)));
-    if (!hasLegacy) {
-      fmt.logWarn('Hook scripts not found in aw package — skipping IDE hooks');
-      return;
-    }
-    // Install legacy hooks only
-    mkdirSync(hooksDir, { recursive: true });
-    for (const file of legacyFiles) {
-      const dest = join(hooksDir, file);
-      writeFileSync(dest, readFileSync(join(pkgHooksDir, file), 'utf8'));
-      try { chmodSync(dest, 0o755); } catch { /* best effort */ }
-    }
-    _wireLegacyHooks(home, hooksDir);
-    fmt.logSuccess('Legacy IDE hooks installed (Claude + Cursor → ~/.aw/hooks/)');
+    fmt.logWarn('Hook scripts not found in aw package — skipping IDE hooks');
     return;
   }
 
@@ -560,16 +543,6 @@ export function installIdeHooks() {
     try { chmodSync(dest, 0o755); } catch { /* best effort */ }
   }
 
-  // Also copy legacy files for rollback
-  for (const file of legacyFiles) {
-    const src = join(pkgHooksDir, file);
-    if (existsSync(src)) {
-      const dest = join(hooksDir, file);
-      writeFileSync(dest, readFileSync(src, 'utf8'));
-      try { chmodSync(dest, 0o755); } catch { /* best effort */ }
-    }
-  }
-
   // Dispatcher commands — one per hook event
   const dispatchers = {
     SessionStart: { cmd: `node "${join(hooksDir, 'shared', 'session-start.mjs')}"`, timeout: 10 },
@@ -680,28 +653,24 @@ export function installIdeHooks() {
   mkdirSync(codexDir, { recursive: true });
   const codexHooksPath = join(codexDir, 'hooks.json');
 
-  let codexHooks = {};
+  let codexHooksFile = {};
   if (existsSync(codexHooksPath)) {
-    try { codexHooks = JSON.parse(readFileSync(codexHooksPath, 'utf8')); } catch { codexHooks = {}; }
+    try { codexHooksFile = JSON.parse(readFileSync(codexHooksPath, 'utf8')); } catch { codexHooksFile = {}; }
   }
+  if (!codexHooksFile.hooks) codexHooksFile.hooks = {};
 
   // Codex supports: SessionStart, Stop, PreToolUse, PostToolUse, UserPromptSubmit
   const codexEvents = { SessionStart: dispatchers.SessionStart, Stop: dispatchers.Stop };
   for (const [event, { cmd, timeout }] of Object.entries(codexEvents)) {
-    if (!codexHooks[event]) codexHooks[event] = [];
+    if (!codexHooksFile.hooks[event]) codexHooksFile.hooks[event] = [];
 
-    // Each entry is a matcher group: { matcher: "*", hooks: [...] }
-    // Find existing aw matcher group or create one
-    let awGroup = codexHooks[event].find(g =>
-      g.hooks?.some(h => h.command?.includes('.aw/hooks/'))
+    // Remove old aw entries
+    codexHooksFile.hooks[event] = codexHooksFile.hooks[event].filter(h =>
+      !h.command?.includes('.aw/hooks/')
     );
-    if (!awGroup) {
-      awGroup = { hooks: [] };
-      codexHooks[event].push(awGroup);
-    }
-    // Replace aw hooks in the group
-    awGroup.hooks = awGroup.hooks.filter(h => !h.command?.includes('.aw/hooks/'));
-    awGroup.hooks.push({
+
+    // Codex hooks are flat objects: { command, type, timeoutSec, statusMessage }
+    codexHooksFile.hooks[event].push({
       type: 'command',
       command: cmd,
       timeoutSec: timeout,
@@ -709,7 +678,7 @@ export function installIdeHooks() {
     });
   }
 
-  writeFileSync(codexHooksPath, JSON.stringify(codexHooks, null, 2) + '\n');
+  writeFileSync(codexHooksPath, JSON.stringify(codexHooksFile, null, 2) + '\n');
 
   // Enable codex_hooks feature if not already set
   const codexConfigPath = join(codexDir, 'config.toml');
@@ -731,36 +700,6 @@ export function installIdeHooks() {
   fmt.logSuccess('IDE hooks installed — 4 events (Claude + Cursor) + 2 events (Codex) → ~/.aw/hooks/');
 }
 
-/** Legacy hook wiring — used as fallback when new dispatchers aren't available */
-function _wireLegacyHooks(home, hooksDir) {
-  const stopCmd = `node "${join(hooksDir, 'telemetry-stop.js')}"`;
-  const activityCmd = `node "${join(hooksDir, 'activity-tracker.js')}"`;
-
-  // Claude Code
-  const claudeSettingsPath = join(home, '.claude', 'settings.json');
-  let claudeSettings = {};
-  if (existsSync(claudeSettingsPath)) {
-    try { claudeSettings = JSON.parse(readFileSync(claudeSettingsPath, 'utf8')); } catch { claudeSettings = {}; }
-  }
-  if (!claudeSettings.hooks) claudeSettings.hooks = {};
-  claudeSettings.hooks.Stop = [{ hooks: [{ type: 'command', command: stopCmd, timeout: 15, statusMessage: 'Recording telemetry...' }] }];
-  claudeSettings.hooks.PostToolUse = [{ hooks: [{ type: 'command', command: activityCmd, timeout: 5 }] }];
-  writeFileSync(claudeSettingsPath, JSON.stringify(claudeSettings, null, 2) + '\n');
-
-  // Cursor
-  const cursorHooksPath = join(home, '.cursor', 'hooks.json');
-  let cursorHooks = { version: 1, hooks: {} };
-  if (existsSync(cursorHooksPath)) {
-    try { cursorHooks = JSON.parse(readFileSync(cursorHooksPath, 'utf8')); } catch { /* overwrite */ }
-  }
-  if (!cursorHooks.hooks) cursorHooks.hooks = {};
-  if (!cursorHooks.hooks.stop) cursorHooks.hooks.stop = [];
-  if (!cursorHooks.hooks.stop.some(h => h.command?.includes('telemetry-stop.js'))) {
-    cursorHooks.hooks.stop.push({ command: stopCmd, timeout: 15 });
-  }
-  writeFileSync(cursorHooksPath, JSON.stringify(cursorHooks, null, 2) + '\n');
-}
-
 /**
  * Return top-level team namespace names from config (excludes 'platform').
  * cfg.include may contain full paths like 'mobile/core/backend/agents/dev.md'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.37-beta.70",
+  "version": "0.1.37-beta.72",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": "bin.js",

package/hooks/activity-tracker.js

@@ -1,61 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-// activity-tracker.js — Lightweight PostToolUse hook for Claude Code + Cursor.
-//
-// Fires after every tool call. Appends one line to .claude/telemetry/activity.jsonl.
-// MUST complete in <100ms — no child processes, no network, pure fs append.
-// MUST never exit non-zero or block the agent loop.
-
-const { appendFileSync, mkdirSync } = require('node:fs');
-const { join } = require('node:path');
-
-async function main() {
-  // Read stdin (JSON from hook system)
-  const chunks = [];
-  for await (const chunk of process.stdin) chunks.push(chunk);
-  const raw = Buffer.concat(chunks).toString('utf8').trim();
-  if (!raw) return;
-
-  let input;
-  try { input = JSON.parse(raw); } catch { return; }
-
-  // Normalize platform differences
-  // Claude Code: { tool_name, tool_input, tool_response, cwd, session_id }
-  // Cursor:      { tool_name, tool_input, tool_output, cwd, duration, conversation_id }
-  const toolName = input.tool_name || 'unknown';
-  const sessionId = input.session_id || input.conversation_id || 'unknown';
-  const cwd = input.cwd
-    || process.env.CURSOR_PROJECT_DIR
-    || process.env.CLAUDE_PROJECT_DIR
-    || process.cwd();
-  const duration = input.duration || 0;
-
-  // Extract exit code (Claude Code nests it in tool_response)
-  let exitCode = 0;
-  const resp = input.tool_response || input.tool_output;
-  if (resp && typeof resp === 'object') {
-    exitCode = resp.exitCode ?? 0;
-  } else if (typeof resp === 'string') {
-    try {
-      const parsed = JSON.parse(resp);
-      exitCode = parsed.exitCode ?? 0;
-    } catch { /* not JSON */ }
-  }
-
-  // Append to activity.jsonl (atomic for writes < PIPE_BUF = 4096 bytes)
-  const telemetryDir = join(cwd, '.claude', 'telemetry');
-  try {
-    mkdirSync(telemetryDir, { recursive: true });
-    const record = JSON.stringify({
-      ts: new Date().toISOString(),
-      sid: sessionId,
-      tool: toolName,
-      exit: exitCode,
-      dur: duration,
-    });
-    // Single appendFileSync — atomic on most OS for small writes
-    appendFileSync(join(telemetryDir, 'activity.jsonl'), record + '\n');
-  } catch { /* never block on write failure */ }
-}
-
-main().catch(() => process.exit(0));

package/hooks/telemetry-stop.js

@@ -1,411 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-// telemetry-stop.js — Unified Stop hook for Claude Code + Cursor.
-//
-// Fires when the AI stops responding. Reads the session transcript,
-// extracts token counts + model, estimates cost, and:
-//   1. Appends to .claude/telemetry/costs.jsonl (local, always works)
-//   2. Pushes unpushed perf-summary.json files via `aw telemetry push`
-//
-// Works on BOTH platforms — normalizes the minor stdin schema differences.
-// MUST never exit non-zero or block the agent loop.
-//
-// Installed to ~/.aw/hooks/ by `aw init`. Referenced by:
-//   ~/.claude/settings.json  (Stop hook)
-//   ~/.cursor/hooks.json     (stop hook)
-
-const { readFileSync, appendFileSync, mkdirSync, existsSync } = require('node:fs');
-const { join } = require('node:path');
-
-// ── API URL resolution ─────────────────────────────────────────────────
-// Read from: 1) env var  2) ~/.aw/config.json  3) hardcoded staging
-function resolveApiUrl() {
-  if (process.env.AW_API_URL) return `${process.env.AW_API_URL}/telemetry/ingest`;
-  // Read from config written by `aw init`
-  const configPath = join(require('node:os').homedir(), '.aw', 'config.json');
-  if (existsSync(configPath)) {
-    try {
-      const cfg = JSON.parse(readFileSync(configPath, 'utf8'));
-      if (cfg.api_url) return `${cfg.api_url}/telemetry/ingest`;
-    } catch { /* corrupted */ }
-  }
-  return 'https://staging.services.leadconnectorhq.com/agentic-workspace/telemetry/ingest';
-}
-
-// ── Direct HTTP push (no shelling out to aw CLI) ───────────────────────
-async function pushToApi(payload) {
-  const url = resolveApiUrl();
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), 8_000);
-  try {
-    const res = await fetch(url, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(payload),
-      signal: controller.signal,
-    });
-    return res.ok;
-  } catch {
-    return false;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-// ── Resolve github login for attribution ───────────────────────────────
-function resolveGithubLogin() {
-  // Try .aw_registry/.token first
-  const tokenPath = join(require('node:os').homedir(), '.aw_registry', '.token');
-  if (existsSync(tokenPath)) {
-    try {
-      const t = JSON.parse(readFileSync(tokenPath, 'utf8'));
-      if (t.github_login) return t.github_login;
-    } catch { /* corrupted */ }
-  }
-  // Fallback to git email
-  try {
-    return require('node:child_process')
-      .execSync('git config --global user.email', { encoding: 'utf8', stdio: ['pipe','pipe','pipe'] })
-      .trim() || null;
-  } catch { return null; }
-}
-
-// ── Token pricing (per 1M tokens) ──────────────────────────────────────
-const PRICING = {
-  // Anthropic Claude
-  'claude-haiku':   { input: 0.80, output: 4.00 },
-  'claude-sonnet':  { input: 3.00, output: 15.00 },
-  'claude-opus':    { input: 15.00, output: 75.00 },
-  'haiku':          { input: 0.80, output: 4.00 },
-  'sonnet':         { input: 3.00, output: 15.00 },
-  'opus':           { input: 15.00, output: 75.00 },
-  // OpenAI GPT
-  'gpt-4o':         { input: 2.50, output: 10.00 },
-  'gpt-4o-mini':    { input: 0.15, output: 0.60 },
-  'gpt-4-turbo':    { input: 10.00, output: 30.00 },
-  'gpt-4':          { input: 30.00, output: 60.00 },
-  'gpt-3.5':        { input: 0.50, output: 1.50 },
-  'o1':             { input: 15.00, output: 60.00 },
-  'o1-mini':        { input: 3.00, output: 12.00 },
-  'o1-pro':         { input: 150.00, output: 600.00 },
-  'o3':             { input: 10.00, output: 40.00 },
-  'o3-mini':        { input: 1.10, output: 4.40 },
-  'o4-mini':        { input: 1.10, output: 4.40 },
-  // Google Gemini
-  'gemini-2.5-pro': { input: 1.25, output: 10.00 },
-  'gemini-2.5-flash': { input: 0.15, output: 0.60 },
-  'gemini-2.0-flash': { input: 0.10, output: 0.40 },
-  'gemini-1.5-pro': { input: 1.25, output: 5.00 },
-  'gemini-1.5-flash': { input: 0.075, output: 0.30 },
-  // Cursor Composer (uses Claude/GPT under the hood — estimate)
-  'composer':       { input: 3.00, output: 15.00 },
-  'composer-2':     { input: 3.00, output: 15.00 },
-};
-
-function estimateCost(model, inputTokens, outputTokens) {
-  const key = Object.keys(PRICING).find(k => (model || '').toLowerCase().includes(k));
-  const rates = key ? PRICING[key] : PRICING['sonnet'];
-  return (inputTokens / 1_000_000) * rates.input + (outputTokens / 1_000_000) * rates.output;
-}
-
-// ── Parse stdin ────────────────────────────────────────────────────────
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) chunks.push(chunk);
-  const raw = Buffer.concat(chunks).toString('utf8').trim();
-  if (!raw) return {};
-  try { return JSON.parse(raw); } catch { return {}; }
-}
-
-// ── Extract tokens from transcript JSONL ────────────────────────────────
-// Claude Code usage entries are cumulative per conversation.
-// We take the LAST usage entry (final token count for the session).
-function extractFromTranscript(transcriptPath) {
-  if (!transcriptPath || !existsSync(transcriptPath)) return null;
-
-  try {
-    const content = readFileSync(transcriptPath, 'utf8');
-    const lines = content.split('\n').filter(Boolean);
-
-    let lastInputTokens = 0;
-    let lastOutputTokens = 0;
-    let lastCacheCreation = 0;
-    let lastCacheRead = 0;
-    let model = null;
-    let command = null;
-    const agentsUsed = new Set();
-    const skillsApplied = new Set();
-    let toolTotal = 0;
-    let toolFailed = 0;
-
-    for (const line of lines) {
-      try {
-        const entry = JSON.parse(line);
-        if (entry.model) model = entry.model;
-
-        // Token usage — Claude Code format (cumulative)
-        const usage = entry.usage || entry.message?.usage;
-        if (usage) {
-          lastInputTokens = usage.input_tokens || 0;
-          lastOutputTokens = usage.output_tokens || 0;
-          lastCacheCreation = usage.cache_creation_input_tokens || 0;
-          lastCacheRead = usage.cache_read_input_tokens || 0;
-        }
-
-        // Claude Code nests tool calls inside assistant message.content[]
-        const contentBlocks = entry.message?.content;
-        if (Array.isArray(contentBlocks)) {
-          for (const block of contentBlocks) {
-            if (!block || block.type !== 'tool_use') continue;
-            const name = block.name || '';
-            const inp = block.input || {};
-
-            if (name === 'Skill' && inp.skill) {
-              command = String(inp.skill).slice(0, 128);
-              skillsApplied.add(command);
-            }
-            if (name === 'Agent' && inp.subagent_type) {
-              agentsUsed.add(String(inp.subagent_type).slice(0, 128));
-            }
-            if (name && name !== 'Skill') {
-              toolTotal++;
-            }
-          }
-        }
-
-        // Also handle flat tool_name format (Cursor, older Claude)
-        const toolName = entry.tool_name;
-        const toolInput = entry.tool_input || {};
-        if (toolName === 'Skill' && toolInput.skill) {
-          command = String(toolInput.skill).slice(0, 128);
-          skillsApplied.add(command);
-        }
-        if (toolName === 'Agent' && toolInput.subagent_type) {
-          agentsUsed.add(String(toolInput.subagent_type).slice(0, 128));
-        }
-
-        // Count tool failures from tool results
-        const result = entry.toolUseResult;
-        if (result && typeof result === 'object') {
-          const ec = result.exitCode ?? result.exit_code;
-          if (ec && ec !== 0) toolFailed++;
-        }
-      } catch { /* skip malformed lines */ }
-    }
-
-    // Cursor fallback: estimate tokens from content length (~4 chars/token)
-    // when no usage data is available (Cursor doesn't write usage entries)
-    if (lastInputTokens === 0 && lastOutputTokens === 0) {
-      let inputChars = 0;
-      let outputChars = 0;
-      for (const line of lines) {
-        try {
-          const entry = JSON.parse(line);
-          const msgContent = entry.message?.content;
-          const len = Array.isArray(msgContent)
-            ? msgContent.reduce((s, c) => s + (typeof c === 'string' ? c.length : JSON.stringify(c).length), 0)
-            : typeof msgContent === 'string' ? msgContent.length : 0;
-          if (entry.role === 'user') inputChars += len;
-          else if (entry.role === 'assistant') outputChars += len;
-        } catch {}
-      }
-      if (inputChars + outputChars > 0) {
-        lastInputTokens = Math.round(inputChars / 4);
-        lastOutputTokens = Math.round(outputChars / 4);
-      }
-    }
-
-    return {
-      inputTokens: lastInputTokens,
-      outputTokens: lastOutputTokens,
-      cacheCreation: lastCacheCreation,
-      cacheRead: lastCacheRead,
-      totalTokens: lastInputTokens + lastOutputTokens + lastCacheCreation + lastCacheRead,
-      model,
-      command,
-      agentsUsed: [...agentsUsed],
-      skillsApplied: [...skillsApplied],
-      toolTotal,
-      toolPassed: toolTotal - toolFailed,
-      toolFailed,
-    };
-  } catch {
-    return null;
-  }
-}
-
-// ── Main ────────────────────────────────────────────────────────────────
-async function main() {
-  const input = await readStdin();
-
-  const sessionId = input.session_id || input.conversation_id || 'unknown';
-  const transcriptPath = input.transcript_path
-    || process.env.CURSOR_TRANSCRIPT_PATH
-    || null;
-  const cwd = input.cwd
-    || process.env.CURSOR_PROJECT_DIR
-    || process.env.CLAUDE_PROJECT_DIR
-    || process.cwd();
-  const status = input.status || 'completed';
-  const stdinModel = input.model || null;
-
-  const transcript = extractFromTranscript(transcriptPath);
-  const model = stdinModel || transcript?.model || 'unknown';
-
-  // ── Token delta: diff current cumulative vs previous snapshot ────────
-  // Claude Code reports cumulative session totals. By snapshotting after
-  // each Stop event, we get the per-response delta.
-  const { writeFileSync } = require('node:fs');
-  const telemetryDir = join(cwd, '.claude', 'telemetry');
-  mkdirSync(telemetryDir, { recursive: true });
-
-  const snapshotPath = join(telemetryDir, `.token-snapshot-${sessionId}`);
-  let prevSnapshot = { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 };
-  if (existsSync(snapshotPath)) {
-    try { prevSnapshot = JSON.parse(readFileSync(snapshotPath, 'utf8')); } catch { /* corrupted */ }
-  }
-
-  const currInput = transcript?.inputTokens || 0;
-  const currOutput = transcript?.outputTokens || 0;
-  const currCacheCreation = transcript?.cacheCreation || 0;
-  const currCacheRead = transcript?.cacheRead || 0;
-
-  // Delta = current cumulative - previous snapshot
-  const deltaInput = Math.max(0, currInput - (prevSnapshot.input || 0));
-  const deltaOutput = Math.max(0, currOutput - (prevSnapshot.output || 0));
-  const deltaCacheCreation = Math.max(0, currCacheCreation - (prevSnapshot.cacheCreation || 0));
-  const deltaCacheRead = Math.max(0, currCacheRead - (prevSnapshot.cacheRead || 0));
-  const deltaTotal = deltaInput + deltaOutput + deltaCacheCreation + deltaCacheRead;
-  const deltaCost = estimateCost(model, deltaInput, deltaOutput);
-
-  // Save current cumulative as snapshot for next time
-  try {
-    writeFileSync(snapshotPath, JSON.stringify({
-      input: currInput, output: currOutput,
-      cacheCreation: currCacheCreation, cacheRead: currCacheRead,
-      ts: new Date().toISOString(),
-    }));
-  } catch { /* best effort */ }
-
-  // ── 1. Local JSONL (always works, even offline) ─────────────────────
-  try {
-    const record = {
-      ts: new Date().toISOString(),
-      session_id: sessionId,
-      model,
-      input_tokens: deltaInput,
-      output_tokens: deltaOutput,
-      cache_creation: deltaCacheCreation,
-      cache_read: deltaCacheRead,
-      total_tokens: deltaTotal,
-      cost_usd: Math.round(deltaCost * 1_000_000) / 1_000_000,
-      status,
-      platform: input.cursor_version ? 'cursor' : 'claude',
-    };
-    appendFileSync(join(telemetryDir, 'costs.jsonl'), JSON.stringify(record) + '\n');
-  } catch { /* never block on local write failure */ }
-
-  // ── 2. Push unpushed perf-summary.json from .aw_docs/runs/ ──────────
-  // Direct HTTP POST — no shelling out to aw CLI (avoids env/path issues).
-  try {
-    const { readdirSync } = require('node:fs');
-    const { homedir } = require('node:os');
-    const searchPaths = [...new Set([
-      join(cwd, '.aw_docs', 'runs'),
-      join(homedir(), '.aw_docs', 'runs'),
-    ])];
-
-    for (const runsDir of searchPaths) {
-      if (!existsSync(runsDir)) continue;
-      const runDirs = readdirSync(runsDir, { withFileTypes: true })
-        .filter(d => d.isDirectory())
-        .map(d => join(runsDir, d.name));
-
-      for (const runDir of runDirs) {
-        const perfPath = join(runDir, 'perf-summary.json');
-        const pushedPath = join(runDir, '.pushed');
-        if (!existsSync(perfPath) || existsSync(pushedPath)) continue;
-
-        try {
-          const perf = JSON.parse(readFileSync(perfPath, 'utf8'));
-
-          // Enrich: hook-derived data fills gaps left by the command
-          if ((!perf.tokens_used || perf.tokens_used === null) && deltaTotal > 0) {
-            perf.tokens_used = deltaTotal;
-          }
-          if ((!perf.cost_usd || perf.cost_usd === null) && deltaCost > 0) {
-            perf.cost_usd = Math.round(deltaCost * 1_000_000) / 1_000_000;
-          }
-          if (!perf.model && model !== 'unknown') {
-            perf.model = model;
-          }
-          if (!perf.environment) {
-            perf.environment = input.cursor_version ? 'cursor' : 'claude-code';
-          }
-          // Enrich agents/skills from transcript if command left them empty
-          if ((!perf.agents_used || perf.agents_used.length === 0) && transcript?.agentsUsed?.length) {
-            perf.agents_used = transcript.agentsUsed;
-          }
-          if ((!perf.skills_applied || perf.skills_applied.length === 0) && transcript?.skillsApplied?.length) {
-            perf.skills_applied = transcript.skillsApplied;
-          }
-          // Enrich steps from tool call counts if command left them null/zero
-          if (!perf.steps_total && transcript?.toolTotal) {
-            perf.steps_total = transcript.toolTotal;
-            perf.steps_passed = transcript.toolPassed;
-            perf.steps_failed = transcript.toolFailed;
-          }
-          // Enrich branch if missing
-          if (!perf.branch || perf.branch === 'no-branch') {
-            try {
-              perf.branch = require('node:child_process')
-                .execSync('git branch --show-current 2>/dev/null', { encoding: 'utf8', cwd })
-                .trim() || null;
-            } catch { /* not a git repo */ }
-          }
-          writeFileSync(perfPath, JSON.stringify(perf, null, 2) + '\n');
-
-          // Build DTO matching IngestRunDto and POST directly
-          const dto = {
-            shell_run_id: perf.run_id,
-            command: perf.command,
-            status: perf.status || 'complete',
-            branch: perf.branch || null,
-            environment: perf.environment || null,
-            model: perf.model || null,
-            duration_ms: perf.duration_ms || null,
-            tokens_used: perf.tokens_used || null,
-            cost_usd: perf.cost_usd || null,
-            first_pass_rate: perf.first_pass_rate || null,
-            steps_total: perf.steps_total || null,
-            steps_passed: perf.steps_passed || null,
-            steps_failed: perf.steps_failed || null,
-            steps_skipped: perf.steps_skipped || null,
-            retries_total: perf.retries_total || null,
-            knowledge_used_count: perf.knowledge_used_count || null,
-            knowledge_saved_count: perf.knowledge_saved_count || null,
-            agents_used: perf.agents_used || [],
-            skills_applied: perf.skills_applied || [],
-            github_login: resolveGithubLogin(),
-          };
-
-          if (dto.shell_run_id && dto.command) {
-            const pushed = await pushToApi(dto);
-            if (pushed) {
-              // Clean up: remove perf-summary + run dir after successful push
-              const { rmSync } = require('node:fs');
-              try { rmSync(runDir, { recursive: true, force: true }); } catch {}
-            }
-          }
-        } catch { /* best effort */ }
-      }
-    }
-  } catch { /* never block */ }
-
-  process.stdout.write('{}\n');
-}
-
-main().catch(() => {
-  process.stdout.write('{}\n');
-  process.exit(0);
-});