chainlesschain 0.47.2 → 0.47.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chainlesschain",
-  "version": "0.47.2",
+  "version": "0.47.5",
   "description": "CLI for ChainlessChain - install, configure, and manage your personal AI management system",
   "type": "module",
   "bin": {

package/src/commands/hook.js

@@ -16,6 +16,12 @@ import {
   executeHooks,
   getHookStats,
 } from "../lib/hook-manager.js";
+import {
+  SESSION_HOOK_EVENTS,
+  fireSessionHook,
+  fireUserPromptSubmit,
+  fireAssistantResponse,
+} from "../lib/session-hooks.js";
 
 export function registerHookCommand(program) {
   const hook = program.command("hook").description("Lifecycle hook management");
@@ -210,6 +216,77 @@ export function registerHookCommand(program) {
       }
     });
 
+  // hook fire — session-aware trigger that honors rewrite/abort/suppress
+  // directives (vs. `hook run` which just dumps raw results).
+  hook
+    .command("fire")
+    .description(
+      "Fire a session-level hook (SessionStart/UserPromptSubmit/AssistantResponse/SessionEnd) and honor stdout JSON directives",
+    )
+    .argument("<event>", `One of: ${SESSION_HOOK_EVENTS.join(", ")}`)
+    .option(
+      "--prompt <text>",
+      "Prompt text (UserPromptSubmit only) — used as input to rewrite/abort",
+    )
+    .option(
+      "--response <text>",
+      "Response text (AssistantResponse only) — used as input to rewrite/suppress",
+    )
+    .option("--context <json>", "Extra JSON context", "{}")
+    .option("--json", "Emit machine-readable JSON output")
+    .action(async (event, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+
+        let extra = {};
+        try {
+          extra = JSON.parse(options.context);
+        } catch (_e) {
+          logger.warn("Invalid JSON --context, using empty object");
+        }
+
+        let out;
+        if (event === HookEvents.UserPromptSubmit) {
+          out = await fireUserPromptSubmit(db, options.prompt || "", extra);
+        } else if (event === HookEvents.AssistantResponse) {
+          out = await fireAssistantResponse(db, options.response || "", extra);
+        } else {
+          const results = await fireSessionHook(db, event, extra);
+          out = { results };
+        }
+
+        if (options.json) {
+          logger.log(JSON.stringify(out, null, 2));
+        } else if (event === HookEvents.UserPromptSubmit) {
+          if (out.abort) {
+            logger.log(chalk.yellow(`[abort] ${out.reason || "no reason"}`));
+          } else {
+            logger.log(chalk.cyan("prompt:"), out.prompt);
+          }
+          logger.log(chalk.gray(`(${out.results.length} hook(s) fired)`));
+        } else if (event === HookEvents.AssistantResponse) {
+          if (out.suppress) {
+            logger.log(chalk.yellow(`[suppress] ${out.reason || "no reason"}`));
+          } else {
+            logger.log(chalk.cyan("response:"), out.response);
+          }
+          logger.log(chalk.gray(`(${out.results.length} hook(s) fired)`));
+        } else {
+          logger.log(chalk.gray(`(${out.results.length} hook(s) fired)`));
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
   // hook stats
   hook
     .command("stats")

package/src/lib/agent-core.js

@@ -23,4 +23,5 @@ export {
   chatWithTools,
   agentLoop,
   formatToolArgs,
+  getActiveMcpServers,
 } from "../runtime/agent-core.js";

package/src/lib/session-hooks.js

@@ -12,9 +12,13 @@
  *
  * Semantics (matches existing PreToolUse convention):
  *   - Fire-and-forget by default: hook failures NEVER break the host flow
- *   - `fireSessionHookWithRewrite` opt-in: lets a UserPromptSubmit hook
- *     return `{ rewrittenPrompt }` or `{ abort: true }` via stdout JSON
+ *   - `fireUserPromptSubmit` / `fireAssistantResponse` are opt-in helpers
+ *     that parse stdout JSON directives ({rewrittenPrompt,abort} /
+ *     {rewrittenResponse,suppress}) for callers that want control flow
  *   - No-op when hookDb is null (REPL without DB)
+ *   - Helper-side timeout protects against runaway hooks even if
+ *     hook-manager's per-hook timeout is misconfigured
+ *   - Swallowed errors are persisted to hook_execution_log when possible
  */
 
 import { executeHooks, HookEvents } from "./hook-manager.js";
@@ -30,6 +34,45 @@ export const SESSION_HOOK_EVENTS = Object.freeze([
   HookEvents.SessionEnd,
 ]);
 
+/**
+ * Helper-side wall-clock cap. Per-hook timeout still lives in the
+ * registered hook row; this is a belt-and-suspenders bound so a
+ * misconfigured hook can never wedge the REPL.
+ */
+const HELPER_TIMEOUT_MS = Number(
+  process.env.CC_SESSION_HOOK_TIMEOUT_MS || 15000,
+);
+
+/**
+ * Internal deps — exposed for tests via `_deps` injection.
+ * Keeping this mutable lets vitest swap out timer/log writers without
+ * resorting to vi.mock (which doesn't intercept inlined CJS).
+ */
+export const _deps = {
+  executeHooks,
+  now: () => Date.now(),
+  logFailure: (hookDb, eventName, err) => {
+    // Best-effort persistence to hook_execution_log; never throws.
+    if (!hookDb || typeof hookDb.prepare !== "function") return;
+    try {
+      const stmt = hookDb.prepare(
+        `INSERT INTO hook_execution_log
+           (hook_id, event, success, error, executed_at)
+         VALUES (?, ?, ?, ?, ?)`,
+      );
+      stmt.run(
+        null,
+        eventName,
+        0,
+        String(err && err.message ? err.message : err),
+        new Date().toISOString(),
+      );
+    } catch {
+      /* table may not exist yet — silent */
+    }
+  },
+};
+
 /**
  * Fire a session-level hook. Returns the raw results from executeHooks
  * (array of {hookId, hookName, success, ...}) or an empty array if
@@ -54,9 +97,14 @@ export async function fireSessionHook(hookDb, eventName, context = {}) {
       timestamp: new Date().toISOString(),
       ...context,
     };
-    return await executeHooks(hookDb, eventName, enriched);
-  } catch (_err) {
-    // Hook failures must never break the REPL
+    return await withTimeout(
+      _deps.executeHooks(hookDb, eventName, enriched),
+      HELPER_TIMEOUT_MS,
+      `${eventName} session hook`,
+    );
+  } catch (err) {
+    // Hook failures must never break the REPL — but we record them
+    _deps.logFailure(hookDb, eventName, err);
     return [];
   }
 }
@@ -108,6 +156,53 @@ export async function fireUserPromptSubmit(
   return { prompt, abort, reason, results };
 }
 
+/**
+ * Fire AssistantResponse with rewrite/suppress support.
+ *
+ * Symmetric to fireUserPromptSubmit but on the way out. A hook may emit:
+ *   {"rewrittenResponse": "..."} — replace the response shown to the user
+ *   {"suppress": true, "reason": "..."} — drop the response entirely
+ *
+ * Common use: PII / secret scrubbing, watermark injection, profanity
+ * filter on the model's final string before it reaches the terminal.
+ *
+ * @returns {Promise<{response: string, suppress: boolean, reason?: string, results: Array}>}
+ */
+export async function fireAssistantResponse(
+  hookDb,
+  originalResponse,
+  context = {},
+) {
+  const results = await fireSessionHook(hookDb, HookEvents.AssistantResponse, {
+    ...context,
+    response: originalResponse,
+  });
+
+  let response = originalResponse;
+  let suppress = false;
+  let reason;
+
+  for (const r of results) {
+    if (!r || !r.success) continue;
+    const directive = extractDirective(r);
+    if (!directive) continue;
+    if (directive.suppress) {
+      suppress = true;
+      reason = directive.reason;
+      break;
+    }
+    if (
+      typeof directive.rewrittenResponse === "string" &&
+      directive.rewrittenResponse.length > 0
+    ) {
+      response = directive.rewrittenResponse;
+      break;
+    }
+  }
+
+  return { response, suppress, reason, results };
+}
+
 function extractDirective(result) {
   const raw = result.stdout ?? result.output ?? result.result;
   if (raw == null) return null;
@@ -121,3 +216,16 @@ function extractDirective(result) {
     return null;
   }
 }
+
+function withTimeout(promise, ms, label) {
+  if (!ms || ms <= 0) return promise;
+  let t;
+  const timeout = new Promise((_, reject) => {
+    t = setTimeout(
+      () => reject(new Error(`${label} exceeded ${ms}ms helper timeout`)),
+      ms,
+    );
+    if (typeof t.unref === "function") t.unref();
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(t));
+}

package/src/repl/agent-repl.js

@@ -50,7 +50,11 @@ import { CLIAutonomousAgent, GoalStatus } from "../lib/autonomous-agent.js";
 import { PromptCompressor } from "../harness/prompt-compressor.js";
 import { feature } from "../lib/feature-flags.js";
 import { recordCompressionMetric } from "../lib/compression-telemetry.js";
-import { fireSessionHook, fireUserPromptSubmit } from "../lib/session-hooks.js";
+import {
+  fireSessionHook,
+  fireUserPromptSubmit,
+  fireAssistantResponse,
+} from "../lib/session-hooks.js";
 import { HookEvents } from "../lib/hook-manager.js";
 import { IterationBudget } from "../lib/iteration-budget.js";
 import {
@@ -1243,21 +1247,34 @@ export async function startAgentRepl(options = {}) {
         prepareCall: defaultPrepareCall,
       });
 
-      if (response) {
-        process.stdout.write(`\n${response}\n\n`);
-        messages.push({ role: "assistant", content: response });
-      } else {
-        process.stdout.write("\n");
+      // Fire AssistantResponse hook with rewrite/suppress support
+      const responseDirective = await fireAssistantResponse(
+        _hookDb,
+        response || "",
+        {
+          sessionId,
+          messageCount: messages.length,
+          provider,
+          model: activeModel,
+        },
+      );
+
+      let effectiveResponse = response;
+      if (responseDirective.suppress) {
+        process.stdout.write(
+          `\n[hook suppress] ${responseDirective.reason || "response suppressed"}\n\n`,
+        );
+        effectiveResponse = "";
+      } else if (responseDirective.response !== (response || "")) {
+        effectiveResponse = responseDirective.response;
       }
 
-      // Fire AssistantResponse hook (fire-and-forget; observational only)
-      await fireSessionHook(_hookDb, HookEvents.AssistantResponse, {
-        sessionId,
-        response: response || "",
-        messageCount: messages.length,
-        provider,
-        model: activeModel,
-      });
+      if (effectiveResponse) {
+        process.stdout.write(`\n${effectiveResponse}\n\n`);
+        messages.push({ role: "assistant", content: effectiveResponse });
+      } else if (!responseDirective.suppress) {
+        process.stdout.write("\n");
+      }
 
       // Auto-save session
       if (sessionId) {
@@ -1265,8 +1282,8 @@ export async function startAgentRepl(options = {}) {
           if (useJsonl) {
             // Append incremental events (user + assistant)
             appendUserMessage(sessionId, effectivePrompt);
-            if (response) {
-              appendAssistantMessage(sessionId, response);
+            if (effectiveResponse) {
+              appendAssistantMessage(sessionId, effectiveResponse);
             }
           } else if (db) {
             saveMessages(db, sessionId, messages);

package/src/runtime/agent-core.js

@@ -48,6 +48,18 @@ import {
   unmountSkillMcpServers,
 } from "../lib/skill-mcp.js";
 
+/**
+ * Names of MCP servers currently mounted by an in-flight run_skill call.
+ * Populated by run_skill before invoking the handler and cleared in
+ * the finally block. Exposed via getActiveMcpServers() so external
+ * observers (web panel, future LLM prompt builders) can render only
+ * the tools that are actually live for this session.
+ */
+const _activeMcpServers = new Set();
+export function getActiveMcpServers() {
+  return new Set(_activeMcpServers);
+}
+
 const { isReadOnlyGitCommand, normalizeGitCommand } = sharedCodingAgentPolicy;
 const { evaluateShellCommandPolicy } = sharedShellPolicy;
 
@@ -1001,6 +1013,9 @@ async function executeToolInner(
             },
           });
           mountedMcpServers = mountResult.mounted;
+          for (const s of mountedMcpServers) {
+            _activeMcpServers.add(typeof s === "string" ? s : s.name);
+          }
         } catch (err) {
           return attachDescriptor({
             error: `Skill MCP mount failed: ${err.message}`,
@@ -1042,6 +1057,9 @@ async function executeToolInner(
           } catch (_err) {
             // Non-critical — mount/unmount errors don't fail the skill
           }
+          for (const s of mountedMcpServers) {
+            _activeMcpServers.delete(typeof s === "string" ? s : s.name);
+          }
         }
       }
     }