impulso 0.22.0 → 0.24.0

package/harnesses/claude/hooks/task-exit.cjs

@@ -36,6 +36,105 @@ const IMPLEMENTER_ROLES = new Set(['implementer', 'implementer-frontend', 'imple
 
 const STATUS_BLOCK_LIMIT = 15;
 
+// --- Test command resolution ---
+//
+// Resolution ladder (consistent with hub ResolveTestCommand):
+//   local .impulso/config.json > IMPULSO_HOME/projects/<sha256>/config.json >
+//   IMPULSO_HOME/.impulso/ > HOME/.impulso/ >
+//   project heuristics (package.json scripts.test, Makefile test target,
+//   go.mod, Cargo.toml, pyproject.toml)
+//
+// Returns ("", "") when no test command can be resolved.
+// Never writes config/state files.
+
+const crypto = require('node:crypto');
+
+function userImpulsoDir() {
+  const home = process.env.IMPULSO_HOME || process.env.HOME;
+  if (!home) return null;
+  return path.join(home, '.impulso');
+}
+
+function projectConfigDir(projectDir) {
+  const userDir = userImpulsoDir();
+  if (!userDir) return null;
+  const abs = path.resolve(projectDir);
+  const hash = crypto.createHash('sha256').update(abs).digest('hex');
+  return path.join(userDir, 'projects', hash);
+}
+
+function readImpulsoConfig(dir) {
+  if (!dir) return null;
+  try {
+    const raw = fs.readFileSync(path.join(dir, 'config.json'), 'utf8');
+    const cfg = JSON.parse(raw);
+    return cfg && typeof cfg === 'object' && !Array.isArray(cfg) ? cfg : null;
+  } catch (_e) {
+    return null;
+  }
+}
+
+function detectTestCommand(projectDir) {
+  // 1. package.json with scripts.test
+  try {
+    const raw = fs.readFileSync(path.join(projectDir, 'package.json'), 'utf8');
+    const pkg = JSON.parse(raw);
+    if (pkg && pkg.scripts && typeof pkg.scripts.test === 'string') {
+      return 'npm test';
+    }
+  } catch (_e) {
+    /* continue */
+  }
+
+  // 2. Makefile with test: target
+  try {
+    const raw = fs.readFileSync(path.join(projectDir, 'Makefile'), 'utf8');
+    if (/^test:/m.test(raw)) return 'make test';
+  } catch (_e) {
+    /* continue */
+  }
+
+  // 3. go.mod
+  if (fs.existsSync(path.join(projectDir, 'go.mod'))) return 'go test ./...';
+
+  // 4. Cargo.toml
+  if (fs.existsSync(path.join(projectDir, 'Cargo.toml'))) return 'cargo test';
+
+  // 5. pyproject.toml
+  if (fs.existsSync(path.join(projectDir, 'pyproject.toml'))) return 'pytest';
+
+  return '';
+}
+
+function resolveTestCommand(projectDir) {
+  // 1. Local config (.impulso/config.json)
+  const localCfg = readImpulsoConfig(path.join(projectDir, '.impulso'));
+  if (localCfg && typeof localCfg.test_cmd === 'string' && localCfg.test_cmd) {
+    return localCfg.test_cmd;
+  }
+
+  // 2. Project-specific external config (~/.impulso/projects/<hash>/config.json)
+  const projCfgDir = projectConfigDir(projectDir);
+  if (projCfgDir) {
+    const projCfg = readImpulsoConfig(projCfgDir);
+    if (projCfg && typeof projCfg.test_cmd === 'string' && projCfg.test_cmd) {
+      return projCfg.test_cmd;
+    }
+  }
+
+  // 3. User config (IMPULSO_HOME or HOME .impulso/config.json)
+  const userDir = userImpulsoDir();
+  if (userDir) {
+    const userCfg = readImpulsoConfig(userDir);
+    if (userCfg && typeof userCfg.test_cmd === 'string' && userCfg.test_cmd) {
+      return userCfg.test_cmd;
+    }
+  }
+
+  // 4. Project heuristics
+  return detectTestCommand(projectDir);
+}
+
 function reportLineCount(reportText) {
   if (!reportText || typeof reportText !== 'string') return 0;
   const lines = reportText.split('\n');
@@ -116,6 +215,12 @@ function main() {
         return;
       }
 
+      // Resolve test command — skip TDD gate if none is resolvable
+      if (!resolveTestCommand(cwd)) {
+        process.exit(0);
+        return;
+      }
+
       // Read state non-mutatively
       let slug;
       try {
@@ -186,4 +291,4 @@ function main() {
 
 if (require.main === module) main();
 
-module.exports = { reportLineCount, violatesLimit };
+module.exports = { reportLineCount, violatesLimit, resolveTestCommand, detectTestCommand };

package/harnesses/claude/hooks/tdd-observer.cjs

@@ -19,10 +19,64 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
+const crypto = require('node:crypto');
 const { spawnSync } = require('node:child_process');
 
 const GATE_REL = path.resolve(__dirname, '..', '..', '..', 'scripts', 'impulso-hub.cjs');
 
+function userImpulsoDir() {
+  const home = process.env.IMPULSO_HOME || process.env.HOME;
+  if (!home) return null;
+  return path.join(home, '.impulso');
+}
+
+function projectConfigDir(projectDir) {
+  const userDir = userImpulsoDir();
+  if (!userDir) return null;
+  const abs = path.resolve(projectDir);
+  const hash = crypto.createHash('sha256').update(abs).digest('hex');
+  return path.join(userDir, 'projects', hash);
+}
+
+function readImpulsoConfig(dir) {
+  if (!dir) return null;
+  try {
+    const raw = fs.readFileSync(path.join(dir, 'config.json'), 'utf8');
+    const cfg = JSON.parse(raw);
+    return cfg && typeof cfg === 'object' && !Array.isArray(cfg) ? cfg : null;
+  } catch (_e) {
+    return null;
+  }
+}
+
+function resolveTestCommand(projectDir) {
+  // 1. Local config (.impulso/config.json)
+  const localCfg = readImpulsoConfig(path.join(projectDir, '.impulso'));
+  if (localCfg && typeof localCfg.test_cmd === 'string' && localCfg.test_cmd) {
+    return localCfg.test_cmd;
+  }
+
+  // 2. Project-specific external config
+  const projCfgDir = projectConfigDir(projectDir);
+  if (projCfgDir) {
+    const projCfg = readImpulsoConfig(projCfgDir);
+    if (projCfg && typeof projCfg.test_cmd === 'string' && projCfg.test_cmd) {
+      return projCfg.test_cmd;
+    }
+  }
+
+  // 3. User config
+  const userDir = userImpulsoDir();
+  if (userDir) {
+    const userCfg = readImpulsoConfig(userDir);
+    if (userCfg && typeof userCfg.test_cmd === 'string' && userCfg.test_cmd) {
+      return userCfg.test_cmd;
+    }
+  }
+
+  return null;
+}
+
 function main() {
   let done = false;
   const chunks = [];
@@ -50,17 +104,8 @@ function main() {
         return;
       }
 
-      // Read config to get test_cmd
-      const configPath = path.join(cwd, '.impulso', 'config.json');
-      let config;
-      try {
-        config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-      } catch (_e) {
-        process.exit(0);
-        return;
-      }
-
-      const testCmd = config.test_cmd;
+      // Resolve test_cmd from config ladder
+      const testCmd = resolveTestCommand(cwd);
       if (!testCmd || !command.includes(testCmd)) {
         process.exit(0);
         return;

package/harnesses/claude/hooks/telematics.cjs

@@ -0,0 +1,216 @@
+// impulso passive telematics adapter — Claude Code
+//
+// Reads Claude hook JSON from stdin, maps it to telematics events, and emits
+// to the local NDJSON log. Never writes stdout, never blocks, never throws.
+// Telemetry is disabled by default — requires { telematics: { enabled: true } }
+// in <IMPULSO_HOME>/config.json (IMPULSO_HOME or ~/.impulso).
+// See shared/telematics.cjs for config format.
+//
+// Hook event type passed via IMPULSO_HOOK_EVENT env var. See
+// claude/settings.json and hooks/hooks.json for dual-registration entries.
+
+'use strict';
+
+const os = require('node:os');
+const path = require('node:path');
+const fs = require('node:fs');
+const crypto = require('node:crypto');
+const { createTelematics } = require(path.join(__dirname, '../../../shared/telematics.cjs'));
+
+const hookEvent = process.env.IMPULSO_HOOK_EVENT || 'unknown';
+
+const chunks = [];
+let done = false;
+process.stdin.setEncoding('utf8');
+process.stdin.on('readable', function () {
+  let c;
+  while ((c = process.stdin.read()) !== null) chunks.push(c);
+});
+
+function finish(raw) {
+  if (done) return;
+  done = true;
+  clearTimeout(timer);
+
+  let input;
+  try {
+    input = JSON.parse(raw || '{}');
+  } catch (_) {
+    process.exit(0);
+    return;
+  }
+
+  // Resolve impulso home: IMPULSO_HOME env, else ~/.impulso
+  let impulsoHome = process.env.IMPULSO_HOME;
+  if (!impulsoHome || impulsoHome.length === 0) {
+    impulsoHome = path.join(os.homedir(), '.impulso');
+  }
+
+  let t;
+  try {
+    t = createTelematics({
+      harness: 'claude',
+      sessionId: input.session_id || null,
+      processId: process.pid,
+      cwd: input.cwd || process.cwd(),
+      home: impulsoHome,
+      now: function () {
+        return new Date().toISOString();
+      },
+      uuid: function () {
+        return crypto.randomUUID();
+      },
+      fs: fs,
+    });
+  } catch (_) {
+    process.exit(0);
+    return;
+  }
+
+  if (!t.enabled) {
+    process.exit(0);
+    return;
+  }
+
+  // Emit session.started once per native session across separate hook
+  // processes. Uses a lock file (<IMPULSO_HOME>/telematics-locks/<sid>.started)
+  // with atomic O_CREAT|O_EXCL to coordinate. If another process already
+  // locked this session, skip. If lock creation fails for any reason, skip
+  // (best-effort, passive — session.started is supplementary telemetry).
+  let lockFd = null;
+  try {
+    const locksDir = path.join(impulsoHome, 'telematics-locks');
+    const lockFile = path.join(locksDir, t.sessionId + '.started');
+    fs.mkdirSync(locksDir, { recursive: true, mode: 0o700 });
+    try {
+      fs.chmodSync(locksDir, 0o700);
+    } catch (_) {
+      /* best effort */
+    }
+    // wx = write + exclusive — fails with EEXIST if lock already held
+    lockFd = fs.openSync(lockFile, 'wx', 0o600);
+    fs.writeSync(lockFd, String(process.pid));
+    // Lock acquired — emit session.started
+    try {
+      t.emit('session.started', {
+        nativeSessionId: input.session_id || null,
+        sessionIdSource: input.session_id ? 'native' : 'generated',
+      });
+    } catch (_) {
+      /* silent */
+    }
+  } catch (_) {
+    // EEXIST or any fs failure → lock not acquired, skip session.started
+  } finally {
+    if (lockFd !== null) {
+      try {
+        fs.closeSync(lockFd);
+      } catch (_) {
+        /* silent */
+      }
+    }
+  }
+
+  try {
+    const event = mapEvent(hookEvent, input, t);
+    if (event) {
+      t.emit(event.eventType, event.data);
+    }
+  } catch (_) {
+    /* silent */
+  }
+
+  try {
+    t.close();
+  } catch (_) {
+    /* silent */
+  }
+
+  process.exit(0);
+}
+
+process.stdin.on('end', function () {
+  finish(chunks.join(''));
+});
+const timer = setTimeout(function () {
+  finish(chunks.join(''));
+}, 1000);
+
+// ----------------------------------------------------------------
+// event mapping — direct host-payload translation per spec
+// ----------------------------------------------------------------
+function mapEvent(hook, input) {
+  switch (hook) {
+    case 'UserPromptSubmit':
+      return {
+        eventType: 'message.submitted',
+        data: {
+          message: typeof input.prompt === 'string' ? input.prompt : '',
+          messageId: input.session_id || undefined,
+        },
+      };
+    case 'PreToolUse':
+      return {
+        eventType: 'tool.requested',
+        data: {
+          toolName: input.tool_name || '',
+          toolUseId: input.tool_use_id || undefined,
+          input: input.tool_input || {},
+        },
+      };
+    case 'PostToolUse':
+      return {
+        eventType: 'tool.completed',
+        data: {
+          toolName: input.tool_name || '',
+          toolUseId: input.tool_use_id || undefined,
+          output: input.tool_response || {},
+          status: getToolStatus(input.tool_response),
+        },
+      };
+    case 'SubagentStart':
+      return {
+        eventType: 'lifecycle',
+        data: {
+          name: 'subagent',
+          phase: 'started',
+          details: { agent_type: input.agent_type || null },
+        },
+      };
+    case 'SubagentStop':
+      // Best-effort session.ended from SubagentStop
+      return {
+        eventType: 'session.ended',
+        data: {
+          reason: 'subagent_stopped',
+        },
+      };
+    case 'Notification':
+      // Error/notification events from host
+      return {
+        eventType: 'error',
+        data: {
+          operation: input.operation || undefined,
+          name: input.name || undefined,
+          message: input.message || undefined,
+          stack: input.stack || undefined,
+        },
+      };
+    default:
+      return null;
+  }
+}
+
+function getToolStatus(response) {
+  if (!response) return 'unknown';
+  if (typeof response.exitCode === 'number') {
+    return response.exitCode === 0 ? 'success' : 'error';
+  }
+  if (typeof response.exit_code === 'number') {
+    return response.exit_code === 0 ? 'success' : 'error';
+  }
+  return 'completed';
+}
+
+// export for testing
+module.exports = { mapEvent, getToolStatus };

package/harnesses/opencode/plugin.js

@@ -17,6 +17,7 @@ import { registerCommands } from './commands-loader.js';
 import { ImpulsoDirectSpeechPlugin } from './directspeech/plugin.js';
 import { ImpulsoOrchestrationPlugin } from './orchestration/index.js';
 import { ImpulsoSessionNamePlugin } from './session-name/plugin.js';
+import { ImpulsoTelematicsPlugin } from './telematics/plugin.js';
 import { installHub } from '../../scripts/install-hub.js';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
@@ -56,6 +57,9 @@ export const ImpulsoPlugin = async (ctx) => {
   // Session-name plugin (X-Session-Name header for proxy cache locality)
   sub.push(await ImpulsoSessionNamePlugin(ctx));
 
+  // Telematics plugin — passive observer, must be last to observe final permission state
+  sub.push(await ImpulsoTelematicsPlugin(ctx));
+
   const hooks = composeHooks(sub);
 
   // Wrap the composed config hook with our own skills/commands registration.

package/harnesses/opencode/telematics/plugin.js

@@ -0,0 +1,175 @@
+// impulso — opencode passive telematics observer plugin
+//
+// Observes runtime hooks and emits NDJSON telemetry events via the shared
+// writer. Passive only: never calls a model, never injects chat/system content,
+// never modifies request/response or hook output, never invokes impulso-hub,
+// never spawns tools. Zero model-token impact.
+//
+// Hooks:
+//   chat.message        → message.submitted / message.received (by role)
+//   tool.execute.before → tool.requested
+//   tool.execute.after  → tool.completed (with paired durationMs)
+//   permission.ask      → permission.requested + permission.resolved
+//   event               → lifecycle
+//
+// Initialize once for plugin lifetime; config read exactly once.
+
+import os from 'node:os';
+import { createRequire } from 'node:module';
+
+const require_ = createRequire(import.meta.url);
+
+function defaultCreateTelematics(ctx) {
+  const { createTelematics } = require_('../../../shared/telematics.cjs');
+  const fs = require_('node:fs');
+  const crypto = require_('node:crypto');
+
+  const home = process.env.IMPULSO_HOME || require_('node:path').join(os.homedir(), '.impulso');
+
+  // Record the raw sessionId before sanitization for sessionIdSource
+  const rawSessionId = ctx.sessionID || null;
+
+  return {
+    telematics: createTelematics({
+      harness: 'opencode',
+      sessionId: ctx.sessionID || null,
+      processId: process.pid,
+      cwd: ctx.directory || process.cwd(),
+      home,
+      now: () => new Date().toISOString(),
+      uuid: () => crypto.randomUUID(),
+      fs,
+    }),
+    rawSessionId,
+  };
+}
+
+export async function ImpulsoTelematicsPlugin(ctx, _createTelematics) {
+  const createTel = _createTelematics || defaultCreateTelematics;
+
+  // One-time construct: create the telematics instance
+  const { telematics: t, rawSessionId } = createTel(ctx);
+
+  // Duration trackers — keyed by callID for tools, session-permission pair for perms
+  const toolStarts = new Map(); // callID → timestamp ms
+  const permStarts = new Map(); // `${sessionID}::${permission}` → timestamp ms
+
+  // Emit session.started on init
+  if (t.enabled) {
+    t.emit('session.started', {
+      nativeSessionId: rawSessionId || null,
+      sessionIdSource: rawSessionId ? 'native' : 'generated',
+    });
+  }
+
+  const hooks = {};
+
+  // ---- event ---------------------------------------------------
+  hooks.event = async (input) => {
+    if (!t.enabled) return;
+    t.emit('lifecycle', {
+      name: (input && input.type) || 'unknown',
+      phase: input && input.phase,
+      details: input,
+    });
+  };
+
+  // ---- chat.message --------------------------------------------
+  hooks['chat.message'] = async (input, _output) => {
+    if (!t.enabled) return;
+    if (!input) return;
+
+    // Determine direction from input.role
+    // user → submitted, assistant/system → received
+    const role = input.role || 'unknown';
+    if (role === 'user') {
+      t.emit('message.submitted', {
+        message: input,
+        messageId: input.id,
+      });
+    } else {
+      t.emit('message.received', {
+        message: input,
+        messageId: input.id,
+        role: input.role,
+      });
+    }
+  };
+
+  // ---- tool.execute.before -------------------------------------
+  hooks['tool.execute.before'] = async (input, _output) => {
+    if (!t.enabled) return;
+    if (!input) return;
+
+    // Record start time for duration pairing
+    if (input.callID) {
+      toolStarts.set(input.callID, Date.now());
+    }
+
+    t.emit('tool.requested', {
+      toolName: input.tool,
+      toolUseId: input.callID,
+      input: input.args,
+    });
+  };
+
+  // ---- tool.execute.after --------------------------------------
+  hooks['tool.execute.after'] = async (input, output) => {
+    if (!t.enabled) return;
+    if (!input) return;
+
+    const start = input.callID ? toolStarts.get(input.callID) : undefined;
+    if (input.callID) {
+      toolStarts.delete(input.callID);
+    }
+
+    const durationMs = start != null ? Date.now() - start : undefined;
+
+    let status;
+    if (output && output.metadata && output.metadata.exitCode !== undefined) {
+      status = output.metadata.exitCode === 0 ? 'success' : 'error';
+    }
+
+    t.emit('tool.completed', {
+      toolName: input.tool,
+      toolUseId: input.callID,
+      output,
+      durationMs,
+      status,
+    });
+  };
+
+  // ---- permission.ask ------------------------------------------
+  hooks['permission.ask'] = async (input, output) => {
+    if (!t.enabled) return;
+    if (!input) return;
+
+    const start = Date.now();
+
+    // Record start so we can compute duration
+    const permKey = `${input.sessionID || ''}::${input.permission || ''}`;
+    permStarts.set(permKey, start);
+
+    t.emit('permission.requested', {
+      permission: input.permission,
+      request: input,
+    });
+
+    // Observe output.decision synchronously after our handler runs
+    // (telematics plugin is composed last, so output is in final state)
+    const decision = output && output.decision;
+
+    const durationMs = Date.now() - start;
+    permStarts.delete(permKey);
+
+    t.emit('permission.resolved', {
+      permission: input.permission,
+      decision,
+      durationMs,
+    });
+  };
+
+  return hooks;
+}
+
+export default ImpulsoTelematicsPlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "impulso",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "Impulso — plugin bundle for opencode and Claude Code: Plannotator skills + Impulso-DirectSpeech (rethemed ex-Caveman). Harness-neutral repo; per-harness glue under harnesses/.",
   "type": "module",
   "main": "harnesses/opencode/plugin.js",
@@ -63,7 +63,10 @@
     "shared/tokensave-freshness.cjs",
     "skills",
     "package.json",
-    "README.md"
+    "README.md",
+    "harnesses/opencode/telematics/",
+    "shared/telematics.cjs",
+    "shared/scout-dispatch.cjs"
   ],
   "dependencies": {
     "@opencode-ai/plugin": "^1.17.14"