refacil-sdd-ai 3.0.3 → 4.0.0

package/lib/commands/bus.js

@@ -0,0 +1,499 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const busBroker = require('../bus/broker');
+const busSpawn = require('../bus/spawn');
+const busClient = require('../bus/client');
+const busWatch = require('../bus/watch');
+const busPresenter = require('../bus/presenter');
+
+function parseBusArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (!token || !token.startsWith('--')) continue;
+    const key = token.slice(2);
+    const next = argv[i + 1];
+    if (next === undefined || next.startsWith('--')) {
+      args[key] = true;
+    } else {
+      args[key] = next;
+      i++;
+    }
+  }
+  return args;
+}
+
+function defaultSessionName() {
+  return path.basename(process.cwd()) || 'sesion';
+}
+
+async function connectOrDie(packageRoot) {
+  try {
+    const { info } = await busSpawn.ensureBroker(packageRoot);
+    const ws = await busClient.connect(info.port);
+    return { ws, info };
+  } catch (err) {
+    console.error(`  No se pudo conectar al bus: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+function formatMessage(m) {
+  const target = m.to ? ` → @${m.to}` : '';
+  return `  [${m.ts}] ${m.from}${target} (${m.kind}): ${m.text}`;
+}
+
+async function busStart(packageRoot) {
+  try {
+    const { info, started } = await busSpawn.ensureBroker(packageRoot);
+    if (started) {
+      console.log(`  refacil-bus broker iniciado en 127.0.0.1:${info.port} (pid ${info.pid}).`);
+    } else {
+      console.log(`  refacil-bus broker ya estaba activo en 127.0.0.1:${info.port} (pid ${info.pid}).`);
+    }
+  } catch (err) {
+    console.error(`  No se pudo iniciar el broker: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+function busStop() {
+  const result = busSpawn.stopBroker();
+  if (result.stopped) {
+    console.log(`  refacil-bus broker detenido (pid ${result.info.pid}).`);
+  } else if (result.reason === 'no-info') {
+    console.log('  refacil-bus broker no está corriendo.');
+  } else if (result.reason === 'not-alive') {
+    console.log('  refacil-bus broker no estaba vivo; info obsoleta limpiada.');
+  } else {
+    console.error(`  No se pudo detener el broker: ${result.reason}`);
+    process.exit(1);
+  }
+}
+
+async function busStatus() {
+  const status = await busSpawn.isBrokerAlive();
+  if (!status.alive) {
+    console.log('  refacil-bus broker: INACTIVO');
+    if (status.staleInfo) {
+      console.log(`  (info obsoleta encontrada: pid ${status.staleInfo.pid}, puerto ${status.staleInfo.port})`);
+    }
+    return;
+  }
+  const info = status.info;
+  const uptimeMs = Date.now() - new Date(info.startedAt).getTime();
+  const uptimeMin = Math.floor(uptimeMs / 60000);
+  console.log('  refacil-bus broker: ACTIVO');
+  console.log(`    host:    127.0.0.1`);
+  console.log(`    puerto:  ${info.port}`);
+  console.log(`    pid:     ${info.pid}`);
+  console.log(`    iniciado: ${info.startedAt}`);
+  console.log(`    uptime:  ${uptimeMin} min`);
+  console.log(`    info:    ${busBroker.BUS_INFO_PATH}`);
+}
+
+function busServe() {
+  busBroker.start().catch((err) => {
+    process.stderr.write(`Error arrancando broker: ${err.message}\n`);
+    process.exit(1);
+  });
+}
+
+async function busJoin(args, packageRoot) {
+  const session = args.session || defaultSessionName();
+  const room = args.room;
+  const repo = args.repo || process.cwd();
+  let intro = args.intro;
+  if (!intro) {
+    try {
+      intro = busPresenter.buildIntro({ repoDir: repo, session });
+    } catch (_) {
+      intro = `${session} se unió a la sala`;
+    }
+  }
+  if (!room) {
+    console.error('  Uso: refacil-sdd-ai bus join --room <sala> [--session <s>] [--intro "..."]');
+    process.exit(1);
+  }
+  const { ws } = await connectOrDie(packageRoot);
+  const reply = await busClient.sendAndWait(
+    ws,
+    'join',
+    { session, room, repo, intro },
+    (d) => d.type === 'system' && d.event === 'joined',
+    3000,
+  );
+  busClient.close(ws);
+  if (!reply) {
+    console.error('  Timeout uniéndose a la sala.');
+    process.exit(1);
+  }
+  const members = (reply.detail && reply.detail.members) || [];
+  console.log(`  Unido a la sala "${room}" como "${session}".`);
+  console.log(`  Miembros actuales: ${members.join(', ') || '(solo tú)'}`);
+  console.log(`  Para consultarte: /refacil:ask @${session} "..."`);
+}
+
+async function busLeave(args, packageRoot) {
+  const session = args.session || defaultSessionName();
+  const { ws } = await connectOrDie(packageRoot);
+  const reply = await busClient.sendAndWait(
+    ws,
+    'leave',
+    { session },
+    (d) => d.type === 'system' && (d.event === 'left' || d.event === 'error'),
+    3000,
+  );
+  busClient.close(ws);
+  if (reply && reply.event === 'left') {
+    console.log(`  "${session}" salió de la sala.`);
+  } else {
+    console.log(`  "${session}" no estaba en ninguna sala.`);
+  }
+}
+
+async function busSay(args, packageRoot) {
+  const session = args.session || defaultSessionName();
+  const text = args.text;
+  if (!text) {
+    console.error('  Uso: refacil-sdd-ai bus say --text "..." [--session <s>]');
+    process.exit(1);
+  }
+  const { ws } = await connectOrDie(packageRoot);
+  const reply = await busClient.sendAndWait(
+    ws,
+    'say',
+    { session, text },
+    (d) => d.type === 'system' && (d.event === 'sent' || d.event === 'error'),
+    3000,
+  );
+  busClient.close(ws);
+  if (reply && reply.event === 'sent') {
+    console.log(`  Mensaje enviado (id ${reply.detail.id}).`);
+  } else {
+    const detail = (reply && reply.detail) || 'sin respuesta';
+    console.error(`  No se pudo enviar: ${detail}`);
+    process.exit(1);
+  }
+}
+
+async function busAsk(args, packageRoot) {
+  const session = args.session || defaultSessionName();
+  const to = args.to;
+  const text = args.text;
+  const waitSec = args.wait ? parseInt(args.wait, 10) : 0;
+  if (!to || !text) {
+    console.error('  Uso: refacil-sdd-ai bus ask --to <name> --text "..." [--wait N] [--session <s>]');
+    process.exit(1);
+  }
+  const { ws } = await connectOrDie(packageRoot);
+  const ack = await busClient.sendAndWait(
+    ws,
+    'ask',
+    { session, to: to.replace(/^@/, ''), text },
+    (d) => d.type === 'system' && (d.event === 'sent' || d.event === 'error'),
+    3000,
+  );
+  if (!ack || ack.event !== 'sent') {
+    busClient.close(ws);
+    const detail = (ack && ack.detail) || 'sin respuesta';
+    console.error(`  No se pudo enviar la pregunta: ${detail}`);
+    process.exit(1);
+  }
+  const correlationId = ack.detail.correlationId;
+  console.log(`  Pregunta enviada a @${to.replace(/^@/, '')} (correlationId ${correlationId}).`);
+
+  if (waitSec > 0) {
+    console.log(`  Esperando respuesta hasta ${waitSec}s...`);
+    const resp = await busClient.sendAndWait(
+      ws,
+      'ping',
+      {},
+      (d) => d.type === 'msg' && d.kind === 'reply' && d.correlationId === correlationId,
+      waitSec * 1000,
+    );
+    busClient.close(ws);
+    if (!resp) {
+      console.log(`  Sin respuesta en ${waitSec}s. Usa /refacil:inbox más tarde para recuperarla.`);
+      return;
+    }
+    console.log(`  Respuesta de @${resp.from}:`);
+    console.log(`    ${resp.text}`);
+  } else {
+    busClient.close(ws);
+    console.log('  Usa /refacil:inbox para ver respuestas.');
+  }
+}
+
+async function busReply(args, packageRoot) {
+  const session = args.session || defaultSessionName();
+  const text = args.text;
+  const correlationId = args.correlation || null;
+  const to = args.to ? args.to.replace(/^@/, '') : null;
+  if (!text) {
+    console.error('  Uso: refacil-sdd-ai bus reply --text "..." [--to <name>] [--correlation <id>]');
+    process.exit(1);
+  }
+  const { ws } = await connectOrDie(packageRoot);
+  const reply = await busClient.sendAndWait(
+    ws,
+    'reply',
+    { session, text, to, correlationId },
+    (d) => d.type === 'system' && (d.event === 'sent' || d.event === 'error'),
+    3000,
+  );
+  busClient.close(ws);
+  if (reply && reply.event === 'sent') {
+    console.log(`  Respuesta enviada (id ${reply.detail.id}).`);
+  } else {
+    const detail = (reply && reply.detail) || 'sin respuesta';
+    console.error(`  No se pudo responder: ${detail}`);
+    process.exit(1);
+  }
+}
+
+async function busHistory(args, packageRoot) {
+  const session = args.session || defaultSessionName();
+  const n = args.n ? parseInt(args.n, 10) : 20;
+  const { ws } = await connectOrDie(packageRoot);
+  const reply = await busClient.sendAndWait(
+    ws,
+    'history',
+    { session, n },
+    (d) => d.type === 'history',
+    3000,
+  );
+  busClient.close(ws);
+  if (!reply) {
+    console.log('  Sin historial.');
+    return;
+  }
+  const msgs = reply.messages || [];
+  if (msgs.length === 0) {
+    console.log('  Sin historial.');
+    return;
+  }
+  console.log(`  Últimos ${msgs.length} mensajes:`);
+  for (const m of msgs) console.log(formatMessage(m));
+}
+
+async function busInbox(args, packageRoot) {
+  const session = args.session || defaultSessionName();
+  const { ws } = await connectOrDie(packageRoot);
+  const reply = await busClient.sendAndWait(
+    ws,
+    'inbox',
+    { session },
+    (d) => d.type === 'inbox',
+    3000,
+  );
+  busClient.close(ws);
+  if (!reply) {
+    console.log('  Sin respuesta del broker.');
+    return;
+  }
+  const msgs = reply.messages || [];
+  if (msgs.length === 0) {
+    console.log('  Sin mensajes nuevos.');
+    return;
+  }
+  console.log(`  ${msgs.length} mensaje(s) nuevo(s):`);
+  for (const m of msgs) console.log(formatMessage(m));
+}
+
+function findFirstUnansweredAsk(messages, session) {
+  const asks = messages.filter((m) => m.kind === 'ask' && m.to === session);
+  for (const ask of asks) {
+    const hasReply = messages.some(
+      (m) => m.kind === 'reply' && m.correlationId === ask.correlationId,
+    );
+    if (!hasReply) return ask;
+  }
+  return null;
+}
+
+function printAttendQuestion(msg) {
+  console.log('  Pregunta recibida del bus:');
+  console.log(`    de:             @${msg.from}`);
+  console.log(`    correlationId:  ${msg.correlationId || '(sin id)'}`);
+  console.log(`    texto:          ${msg.text}`);
+  console.log('');
+  console.log('  Responde con: /refacil:reply "<respuesta>"');
+  console.log('  Luego vuelve a ejecutar /refacil:attend para seguir escuchando.');
+}
+
+async function busAttend(args, packageRoot) {
+  const session = args.session || defaultSessionName();
+  const timeoutSec = args.timeout ? parseInt(args.timeout, 10) : 540;
+  const { ws } = await connectOrDie(packageRoot);
+
+  const hist = await busClient.sendAndWait(
+    ws,
+    'history',
+    { session, n: 50 },
+    (d) => d.type === 'history',
+    3000,
+  );
+  if (hist) {
+    const pending = findFirstUnansweredAsk(hist.messages || [], session);
+    if (pending) {
+      busClient.close(ws);
+      printAttendQuestion(pending);
+      return;
+    }
+  }
+
+  const result = await new Promise((resolve) => {
+    let done = false;
+    const finish = (v) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      ws.removeListener('message', onMessage);
+      resolve(v);
+    };
+    const onMessage = (raw) => {
+      let data;
+      try { data = JSON.parse(raw.toString()); } catch (_) { return; }
+      if (data.type === 'msg' && data.kind === 'ask' && data.to === session) {
+        finish({ kind: 'message', msg: data });
+      }
+    };
+    ws.on('message', onMessage);
+    const timer = setTimeout(() => finish({ kind: 'timeout' }), timeoutSec * 1000);
+    busClient.send(ws, 'attend', { session });
+  });
+
+  busClient.close(ws);
+
+  if (result.kind === 'message') {
+    printAttendQuestion(result.msg);
+  } else {
+    console.log(`  Sin preguntas en ${timeoutSec}s. Re-ejecuta /refacil:attend para seguir escuchando.`);
+  }
+}
+
+function readPersistedSessions() {
+  try {
+    return JSON.parse(fs.readFileSync(busBroker.SESSIONS_PATH, 'utf8'));
+  } catch (_) {
+    return {};
+  }
+}
+
+async function busWatchCmd(positional, args, packageRoot) {
+  const session = args.session || positional || null;
+  let room = args.room || null;
+  if (session && !room) {
+    const persisted = readPersistedSessions();
+    if (persisted[session] && persisted[session].room) {
+      room = persisted[session].room;
+    }
+  }
+  if (!session && !room) {
+    console.error('  Uso: refacil-sdd-ai bus watch <session> [--room <sala>]');
+    process.exit(1);
+  }
+  try {
+    const { info } = await busSpawn.ensureBroker(packageRoot);
+    await busWatch.start({ session, room, port: info.port });
+  } catch (err) {
+    console.error(`  No se pudo iniciar el watch: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function busRooms(packageRoot) {
+  const { ws } = await connectOrDie(packageRoot);
+  const reply = await busClient.sendAndWait(
+    ws,
+    'status',
+    {},
+    (d) => d.type === 'system' && d.event === 'status',
+    3000,
+  );
+  busClient.close(ws);
+  if (!reply) {
+    console.log('  Sin respuesta del broker.');
+    return;
+  }
+  const rooms = (reply.detail && reply.detail.rooms) || {};
+  const names = Object.keys(rooms);
+  if (names.length === 0) {
+    console.log('  No hay salas activas.');
+    return;
+  }
+  console.log('  Salas activas:');
+  for (const name of names) {
+    const members = rooms[name] || [];
+    console.log(`    ${name} (${members.length}): ${members.join(', ')}`);
+  }
+}
+
+function openInBrowser(url) {
+  const { spawn } = require('child_process');
+  const platform = process.platform;
+  let cmd;
+  let cmdArgs;
+  if (platform === 'win32') {
+    cmd = 'cmd';
+    cmdArgs = ['/c', 'start', '""', url];
+  } else if (platform === 'darwin') {
+    cmd = 'open';
+    cmdArgs = [url];
+  } else {
+    cmd = 'xdg-open';
+    cmdArgs = [url];
+  }
+  try {
+    spawn(cmd, cmdArgs, { detached: true, stdio: 'ignore', windowsHide: true }).unref();
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+async function busView(packageRoot) {
+  try {
+    const { info } = await busSpawn.ensureBroker(packageRoot);
+    const url = `http://127.0.0.1:${info.port}/`;
+    console.log(`  refacil-bus view disponible en: ${url}`);
+    const opened = openInBrowser(url);
+    if (!opened) {
+      console.log('  (no se pudo abrir el navegador automáticamente, abre la URL manualmente)');
+    }
+  } catch (err) {
+    console.error(`  No se pudo iniciar la vista: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function handleBus(sub, argv, packageRoot) {
+  const rest = argv || [];
+  const positional = rest.length > 0 && !rest[0].startsWith('--') ? rest[0] : null;
+  const args = parseBusArgs(rest);
+
+  switch (sub) {
+    case 'start':   return busStart(packageRoot);
+    case 'stop':    return busStop();
+    case 'status':  return busStatus();
+    case 'serve':   return busServe();
+    case 'join':    return busJoin(args, packageRoot);
+    case 'leave':   return busLeave(args, packageRoot);
+    case 'say':     return busSay(args, packageRoot);
+    case 'ask':     return busAsk(args, packageRoot);
+    case 'reply':   return busReply(args, packageRoot);
+    case 'history': return busHistory(args, packageRoot);
+    case 'inbox':   return busInbox(args, packageRoot);
+    case 'rooms':   return busRooms(packageRoot);
+    case 'watch':   return busWatchCmd(positional, args, packageRoot);
+    case 'attend':  return busAttend(args, packageRoot);
+    case 'view':    return busView(packageRoot);
+    default:
+      console.log('Uso: refacil-sdd-ai bus <start|stop|status|serve|join|leave|say|ask|reply|history|inbox|rooms|watch|attend|view>');
+  }
+}
+
+module.exports = { handleBus, parseBusArgs };

package/lib/commands/compact.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const compactTelemetry = require('../compact/telemetry');
+
+function showCompactStats() {
+  const s = compactTelemetry.stats();
+  if (s.totalEvents === 0) {
+    console.log('\n  No hay eventos registrados todavia. Ejecuta comandos Bash para generar telemetria de compactacion.\n');
+    return;
+  }
+
+  const sortedRewrites = Object.entries(s.byRule)
+    .filter(([, data]) => data.rewriteCount > 0)
+    .sort((a, b) => b[1].rewriteSaved - a[1].rewriteSaved);
+  const sortedAlreadyCompact = Object.entries(s.byRule)
+    .filter(([, data]) => data.alreadyCompactCount > 0)
+    .sort((a, b) => b[1].alreadyCompactPotential - a[1].alreadyCompactPotential);
+
+  console.log(`\n  compact-bash stats\n`);
+  console.log(`  Rewrites por hook: ${s.totalRewrites}`);
+  console.log(`  Comandos ya compactos detectados (skill/agente): ${s.totalAlreadyCompact}\n`);
+
+  if (sortedRewrites.length > 0) {
+    console.log('  Ahorro aplicado por hook (rewrite):');
+    for (const [id, data] of sortedRewrites) {
+      const kTokens = (data.rewriteSaved / 1000).toFixed(1);
+      console.log(
+        `    ${id.padEnd(18)} ${String(data.rewriteCount).padStart(6)} rewrites   ~${kTokens.padStart(7)}k tokens`,
+      );
+    }
+    const totalHookK = (s.totalSaved / 1000).toFixed(1);
+    const hookUsd = ((s.totalSaved / 1_000_000) * 3).toFixed(2);
+    console.log(`    ${'-'.repeat(62)}`);
+    console.log(
+      `    ${'Total hook'.padEnd(18)} ${String(s.totalRewrites).padStart(6)} rewrites   ~${totalHookK.padStart(7)}k tokens (~$${hookUsd} USD)`,
+    );
+    console.log('');
+  }
+
+  if (sortedAlreadyCompact.length > 0) {
+    console.log('  Ahorro potencial ya capturado por skill/agente (sin rewrite):');
+    for (const [id, data] of sortedAlreadyCompact) {
+      const kTokens = (data.alreadyCompactPotential / 1000).toFixed(1);
+      console.log(
+        `    ${id.padEnd(18)} ${String(data.alreadyCompactCount).padStart(6)} eventos    ~${kTokens.padStart(7)}k tokens potenciales`,
+      );
+    }
+    const totalAgentK = (s.totalAlreadyCompactPotential / 1000).toFixed(1);
+    const agentUsd = ((s.totalAlreadyCompactPotential / 1_000_000) * 3).toFixed(2);
+    console.log(`    ${'-'.repeat(62)}`);
+    console.log(
+      `    ${'Total skill'.padEnd(18)} ${String(s.totalAlreadyCompact).padStart(6)} eventos    ~${totalAgentK.padStart(7)}k tokens (~$${agentUsd} USD)`,
+    );
+    console.log('');
+  }
+
+  const totalK = (s.totalObservedPotential / 1000).toFixed(1);
+  const totalUsd = ((s.totalObservedPotential / 1_000_000) * 3).toFixed(2);
+  console.log(`    ${'-'.repeat(62)}`);
+  console.log(
+    `    ${'Total observado'.padEnd(18)} ${String(s.totalEvents).padStart(6)} eventos    ~${totalK.padStart(7)}k tokens (~$${totalUsd} USD, Sonnet input)`,
+  );
+  console.log(`\n  Log: ${compactTelemetry.LOG_PATH}`);
+  if (compactTelemetry.isDisabled()) {
+    console.log('  Estado: DESHABILITADO (no se registran nuevos eventos)');
+  }
+  console.log('');
+}
+
+function handleCompact(sub) {
+  switch (sub) {
+    case 'stats':
+      showCompactStats();
+      break;
+    case 'disable':
+      compactTelemetry.disable();
+      console.log('  compact-bash deshabilitado. Reactiva con: refacil-sdd-ai compact enable');
+      break;
+    case 'enable':
+      compactTelemetry.enable();
+      console.log('  compact-bash habilitado.');
+      break;
+    case 'clear-log':
+      compactTelemetry.clearLog();
+      console.log('  compact.log limpiado.');
+      break;
+    default:
+      console.log('Uso: refacil-sdd-ai compact <stats|disable|enable|clear-log>');
+  }
+}
+
+module.exports = { handleCompact };

package/lib/hooks.js

@@ -0,0 +1,107 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function installHooks(ideDir, projectRoot) {
+  const settingsDir = path.join(projectRoot, ideDir);
+  const settingsPath = path.join(settingsDir, 'settings.json');
+  let settings = {};
+
+  if (fs.existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    } catch (_) {
+      settings = {};
+    }
+  }
+
+  if (!settings.hooks) settings.hooks = {};
+  if (!settings.hooks.SessionStart) settings.hooks.SessionStart = [];
+
+  let changed = false;
+
+  const hasUpdateHook = settings.hooks.SessionStart.some((h) => h._sdd === true);
+  if (!hasUpdateHook) {
+    settings.hooks.SessionStart.push({
+      _sdd: true,
+      matcher: '',
+      hooks: [{ type: 'command', command: 'refacil-sdd-ai check-update' }],
+    });
+    changed = true;
+  }
+
+  if (!settings.hooks.PreToolUse) settings.hooks.PreToolUse = [];
+
+  // compact-bash debe correr ANTES de check-review para que el rewrite sea visible
+  const hasCompactHook = settings.hooks.PreToolUse.some((h) => h._sdd_compact === true);
+  if (!hasCompactHook) {
+    settings.hooks.PreToolUse.unshift({
+      _sdd_compact: true,
+      matcher: 'Bash',
+      hooks: [{ type: 'command', command: 'refacil-sdd-ai compact-bash' }],
+    });
+    changed = true;
+  }
+
+  const hasReviewHook = settings.hooks.PreToolUse.some((h) => h._sdd_review === true);
+  if (!hasReviewHook) {
+    settings.hooks.PreToolUse.push({
+      _sdd_review: true,
+      matcher: 'Bash',
+      hooks: [{ type: 'command', command: 'refacil-sdd-ai check-review' }],
+    });
+    changed = true;
+  }
+
+  if (!changed) {
+    console.log(`  Hooks SDD-AI ya configurados en ${ideDir}/settings.json.`);
+    return false;
+  }
+
+  fs.mkdirSync(settingsDir, { recursive: true });
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+  return true;
+}
+
+function uninstallHooks(ideDir, projectRoot) {
+  const settingsPath = path.join(projectRoot, ideDir, 'settings.json');
+  if (!fs.existsSync(settingsPath)) return false;
+
+  let settings;
+  try {
+    settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  } catch (_) {
+    console.log(`  No se pudieron remover hooks: ${ideDir}/settings.json invalido.`);
+    return false;
+  }
+
+  if (!settings.hooks) return false;
+
+  let changed = false;
+
+  if (Array.isArray(settings.hooks.SessionStart)) {
+    const original = settings.hooks.SessionStart.length;
+    settings.hooks.SessionStart = settings.hooks.SessionStart.filter((h) => h._sdd !== true);
+    if (settings.hooks.SessionStart.length !== original) changed = true;
+    if (settings.hooks.SessionStart.length === 0) delete settings.hooks.SessionStart;
+  }
+
+  if (Array.isArray(settings.hooks.PreToolUse)) {
+    const original = settings.hooks.PreToolUse.length;
+    settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(
+      (h) => h._sdd_review !== true && h._sdd_compact !== true,
+    );
+    if (settings.hooks.PreToolUse.length !== original) changed = true;
+    if (settings.hooks.PreToolUse.length === 0) delete settings.hooks.PreToolUse;
+  }
+
+  if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
+
+  if (!changed) return false;
+
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+  return true;
+}
+
+module.exports = { installHooks, uninstallHooks };