mixdog 0.9.3 → 0.9.4

package/src/standalone/channel-worker.mjs

@@ -9,15 +9,12 @@ import { appendBuffered } from '../runtime/shared/buffered-appender.mjs';
 const CHANNEL_TOOLS = new Set([
   'reply',
   'fetch',
-  'react',
-  'edit_message',
-  'download_attachment',
-  'schedule_status',
-  'trigger_schedule',
-  'schedule_control',
+  // activate_channel_bridge/reload_config are NOT model-facing tools (no
+  // TOOL_DEFS entry) but stay in the allow-set: mixdog-session-runtime.mjs
+  // calls channels.execute() with these names directly as internal
+  // Lead-only runtime plumbing (bridge-claim on start, config hot-reload).
   'activate_channel_bridge',
   'reload_config',
-  'inject_command',
 ]);
 
 const WORKER_PRELOAD = fileURLToPath(new URL('./channel-worker-preload.cjs', import.meta.url));

package/src/standalone/explore-tool.mjs

@@ -1,4 +1,5 @@
 import { isAbsolute, resolve } from 'node:path';
+import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { makeAgentDispatch } from '../runtime/agent/orchestrator/agent-runtime/agent-dispatch.mjs';
 import { loadConfig } from '../runtime/agent/orchestrator/config.mjs';
@@ -80,11 +81,11 @@ function resolveExploreCwd(input, callerCwd) {
   return base;
 }
 
-function settledExplorerResult(result) {
+function settledExplorerResult(result, cwd = null) {
   if (result?.status !== 'fulfilled') {
     return { ok: false, text: `[explorer error] ${result?.reason?.message || String(result?.reason)}` };
   }
-  const text = cleanExplorerText(typeof result.value === 'string' ? result.value : responseText(result.value));
+  const text = cleanExplorerText(typeof result.value === 'string' ? result.value : responseText(result.value), cwd);
   if (!text) return { ok: false, text: '[explorer error] empty response' };
   return { ok: true, text };
 }
@@ -106,10 +107,10 @@ function fatalExploreError(settled) {
   return (settled || []).find((r) => r?.status === 'rejected' && isFatalExploreError(r.reason))?.reason || null;
 }
 
-function mergeSettled(settled, queries) {
+function mergeSettled(settled, queries, cwd = null) {
   const single = queries.length === 1;
   if (single) {
-    const { text: body } = settledExplorerResult(settled[0]);
+    const { text: body } = settledExplorerResult(settled[0], cwd);
     return body.length > EXPLORE_OUTPUT_CHAR_CAP
       ? body.slice(0, EXPLORE_OUTPUT_CHAR_CAP) + EXPLORE_TRUNCATION_MARKER
       : body;
@@ -120,7 +121,7 @@ function mergeSettled(settled, queries) {
   let truncated = false;
   for (let i = 0; i < settled.length; i++) {
     const header = `Q${i + 1}: ${String(queries[i] ?? '').replace(/\s+/g, ' ').slice(0, 60)}`;
-    const { text: body } = settledExplorerResult(settled[i]);
+    const { text: body } = settledExplorerResult(settled[i], cwd);
     const piece = `${header}\n${body}`;
     const addLen = (parts.length === 0 ? 0 : sep.length) + piece.length;
     if (total + addLen > EXPLORE_OUTPUT_CHAR_CAP) {
@@ -247,6 +248,7 @@ function responseText(response) {
 }
 
 const ANCHOR_LINE_RE = /(?:^|\s)(?:[A-Za-z]:[\\/][^:\n]+|\.{0,2}[\\/][^:\n]+|src[\\/][^:\n]+|[\w.-]+[\\/][^:\n]+):\d+\b/;
+const ANCHOR_PATH_CAPTURE_RE = /(?:^|\s)((?:[A-Za-z]:[\\/][^:\n]+|\.{0,2}[\\/][^:\n]+|src[\\/][^:\n]+|[\w.-]+[\\/][^:\n]+)):\d+\b/;
 const FAILED_RE = /\b(?:EXPLORATION_FAILED|exploration failed|no credible (?:anchor|location)|no relevant (?:anchor|location)|not found|could(?: not|n't) find)\b/i;
 
 function normalizeExplorerLine(line) {
@@ -260,7 +262,16 @@ function normalizeExplorerLine(line) {
     .trim();
 }
 
-function cleanExplorerText(text) {
+// Anchor existence filter: a locator answer citing a file that does not exist
+// is a hallucination — drop the line. Only enforced when cwd is known.
+function anchorLineExists(line, cwd) {
+  const m = line.match(ANCHOR_PATH_CAPTURE_RE);
+  if (!m) return true;
+  const p = m[1].trim();
+  try { return existsSync(isAbsolute(p) ? p : resolve(cwd, p)); } catch { return true; }
+}
+
+function cleanExplorerText(text, cwd = null) {
   const raw = String(text || '').trim();
   if (!raw) return '';
   const anchors = [];
@@ -270,7 +281,12 @@ function cleanExplorerText(text) {
     if (/^EXPLORATION_FAILED\b/i.test(line)) return 'EXPLORATION_FAILED';
     if (ANCHOR_LINE_RE.test(line)) anchors.push(line);
   }
-  if (anchors.length) return anchors.join('\n');
+  if (anchors.length) {
+    const real = cwd ? anchors.filter((l) => anchorLineExists(l, cwd)) : anchors;
+    // All anchors pointed at nonexistent paths: fail harmlessly instead of
+    // forwarding hallucinated locations.
+    return real.length ? real.join('\n') : 'EXPLORATION_FAILED';
+  }
   if (FAILED_RE.test(raw)) return 'EXPLORATION_FAILED';
   return raw;
 }
@@ -311,10 +327,15 @@ async function runExploreSync(args = {}, ctx = {}) {
   const presetName = (route && typeof route === 'object')
     ? `${clean(route.provider)}/${clean(route.model)}`
     : (route || '');
+  // Explorer is a one-shot locator (one grep+code_graph turn, answer, stop —
+  // rules/agent/30-explorer.md). Pin a low hard cap so a drifting explorer
+  // cannot run an 11-call research loop; 3 leaves room for one lookup turn,
+  // one recovery turn, and the answer.
   const llm = makeAgentDispatch({
     agent: 'explorer',
     cwd: resolvedCwd,
     brief: true,
+    maxLoopIterations: 3,
     parentSessionId: ctx.callerSessionId || null,
     clientHostPid: ctx.clientHostPid || null,
     config,
@@ -328,8 +349,8 @@ async function runExploreSync(args = {}, ctx = {}) {
   const fatal = fatalExploreError(settled);
   if (fatal) return fail(presentErrorText(fatal, { surface: 'explore' }));
 
-  const merged = mergeSettled(settled, working);
-  const allFailed = settled.every((r) => !settledExplorerResult(r).ok);
+  const merged = mergeSettled(settled, working, resolvedCwd);
+  const allFailed = settled.every((r) => !settledExplorerResult(r, resolvedCwd).ok);
   const out = capNotice + merged;
   return allFailed ? fail(out) : ok(out);
 }

package/src/standalone/hook-bus/config.mjs

@@ -0,0 +1,207 @@
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { listRegisteredPlugins } from '../plugin-admin.mjs';
+import { NO_MATCHER_EVENTS } from './constants.mjs';
+
+export function hookRulesPath(dataDir) {
+  if (process.env.MIXDOG_HOOKS_FILE) return resolve(process.env.MIXDOG_HOOKS_FILE);
+  return dataDir ? join(dataDir, 'hooks.json') : null;
+}
+
+export function normalizeRules(raw) {
+  if (Array.isArray(raw)) return raw;
+  if (Array.isArray(raw?.toolBefore)) return raw.toolBefore;
+  if (Array.isArray(raw?.beforeTool)) return raw.beforeTool;
+  if (Array.isArray(raw?.hooks?.toolBefore)) return raw.hooks.toolBefore;
+  return [];
+}
+
+function uniqueHookEntries(entries) {
+  const seen = new Set();
+  const out = [];
+  for (const entry of entries) {
+    if (!entry?.path) continue;
+    const resolved = resolve(entry.path);
+    const key = process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({ ...entry, path: resolved });
+  }
+  return out;
+}
+
+function cleanHookId(value) {
+  return String(value ?? '').trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_.-]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+function pluginHookConfigEntries(dataDir) {
+  if (!dataDir) return [];
+  let plugins = [];
+  try {
+    plugins = listRegisteredPlugins({ dataDir });
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const plugin of plugins || []) {
+    const root = String(plugin?.root || '').trim();
+    if (!root || !existsSync(root)) continue;
+    const id = cleanHookId(plugin.id || plugin.name || plugin.title || root.split(/[\\/]/).pop());
+    const pluginData = join(dataDir, 'plugins', 'data', id || 'plugin');
+    entries.push({
+      path: join(root, 'hooks', 'hooks.json'),
+      pluginRoot: root,
+      pluginData,
+      sourceType: 'plugin',
+    });
+    entries.push({
+      path: join(root, '.mixdog', 'hooks.json'),
+      pluginRoot: root,
+      pluginData,
+      sourceType: 'plugin',
+    });
+  }
+  return entries;
+}
+
+export function hookConfigEntries(dataDir, cwd) {
+  if (process.env.MIXDOG_HOOKS_FILE) {
+    return uniqueHookEntries([{ path: process.env.MIXDOG_HOOKS_FILE, sourceType: 'env' }]);
+  }
+  const projectDir = cwd ? resolve(cwd) : process.cwd();
+  return uniqueHookEntries([
+    projectDir ? { path: join(projectDir, '.mixdog', 'hooks.json'), sourceType: 'project' } : null,
+    projectDir ? { path: join(projectDir, '.mixdog', 'hooks', 'hooks.json'), sourceType: 'project' } : null,
+    dataDir ? { path: join(dataDir, 'hooks.json'), sourceType: 'data' } : null,
+    dataDir ? { path: join(dataDir, 'hooks', 'hooks.json'), sourceType: 'data' } : null,
+    ...pluginHookConfigEntries(dataDir),
+  ]);
+}
+
+export function isStandardConfig(parsed) {
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return false;
+  const hooks = parsed.hooks;
+  if (!hooks || typeof hooks !== 'object' || Array.isArray(hooks)) return false;
+  const values = Object.values(hooks);
+  if (values.length === 0) return false;
+  return values.every((groups) => (
+    Array.isArray(groups)
+    && groups.every((g) => g && typeof g === 'object' && Array.isArray(g.hooks))
+  ));
+}
+
+const SIMPLE_MATCHER_RE = /^[A-Za-z0-9_ ,|]*$/;
+export function matcherFires(matcher, field) {
+  if (matcher == null) return true;
+  const text = String(matcher).trim();
+  if (text === '' || text === '*') return true;
+  const value = String(field ?? '');
+  if (SIMPLE_MATCHER_RE.test(text)) {
+    const items = text.split(/[|,]/).map((s) => s.trim()).filter(Boolean);
+    if (items.length === 0) return true;
+    return items.includes(value);
+  }
+  try {
+    return new RegExp(text).test(value);
+  } catch {
+    return true;
+  }
+}
+
+export function parseStandardConfig(parsed, source, meta = {}) {
+  const events = {};
+  const hooks = parsed.hooks || {};
+  for (const [eventName, groups] of Object.entries(hooks)) {
+    if (!Array.isArray(groups)) continue;
+    const cleanGroups = [];
+    for (const group of groups) {
+      if (!group || typeof group !== 'object') continue;
+      const handlers = Array.isArray(group.hooks)
+        ? group.hooks
+          .filter((h) => h && typeof h === 'object' && h.type)
+          .map((h) => ({
+            ...h,
+            _source: source,
+            ...(meta.pluginRoot ? { _pluginRoot: meta.pluginRoot } : {}),
+            ...(meta.pluginData ? { _pluginData: meta.pluginData } : {}),
+          }))
+        : [];
+      if (handlers.length === 0) continue;
+      cleanGroups.push({ matcher: group.matcher, hooks: handlers, _source: source });
+    }
+    if (cleanGroups.length > 0) events[eventName] = cleanGroups;
+  }
+  return events;
+}
+
+export function mergeEvents(target, source) {
+  for (const [eventName, groups] of Object.entries(source || {})) {
+    if (!Array.isArray(target[eventName])) target[eventName] = [];
+    target[eventName].push(...groups);
+  }
+}
+
+export function buildEventPayload(eventName, input = {}) {
+  const payload = {
+    session_id: input.sessionId ?? input.session_id ?? null,
+    cwd: input.cwd ?? null,
+    hook_event_name: eventName,
+  };
+  if (input.transcriptPath != null || input.transcript_path != null) {
+    payload.transcript_path = input.transcriptPath ?? input.transcript_path;
+  }
+  if (input.permissionMode != null || input.permission_mode != null) {
+    payload.permission_mode = input.permissionMode ?? input.permission_mode;
+  }
+  if (input.effort != null) payload.effort = input.effort;
+  const toolName = input.name ?? input.tool_name;
+  if (toolName != null) payload.tool_name = toolName;
+  const toolInput = input.args ?? input.tool_input;
+  if (toolInput != null) payload.tool_input = toolInput;
+  if (input.toolCallId != null || input.tool_use_id != null) {
+    payload.tool_use_id = input.toolCallId ?? input.tool_use_id;
+  }
+  if (input.toolResponse != null || input.tool_response != null || input.result != null) {
+    payload.tool_response = input.toolResponse ?? input.tool_response ?? input.result;
+  }
+  for (const key of [
+    'prompt',
+    'source',
+    'model',
+    'session_title',
+    'message',
+    'notification_type',
+    'trigger',
+    'load_reason',
+    'file_path',
+    'memory_type',
+    'command_name',
+    'command_args',
+    'command_source',
+    'expansion_type',
+    'stop_reason',
+    'error_type',
+    'agent_type',
+  ]) {
+    if (input[key] != null) payload[key] = input[key];
+  }
+  return payload;
+}
+
+export function matchFieldFor(eventName, payload) {
+  if (NO_MATCHER_EVENTS.has(eventName)) return null;
+  if (eventName === 'SessionStart') return payload.source ?? '';
+  if (eventName === 'Setup') return payload.trigger ?? '';
+  if (eventName === 'SessionEnd') return payload.reason ?? '';
+  if (eventName === 'Notification') return payload.notification_type ?? payload.type ?? '';
+  if (eventName === 'SubagentStart' || eventName === 'SubagentStop') return payload.agent_type ?? '';
+  if (eventName === 'PreCompact' || eventName === 'PostCompact') return payload.trigger ?? '';
+  if (eventName === 'ConfigChange') return payload.source ?? '';
+  if (eventName === 'InstructionsLoaded') return payload.load_reason ?? '';
+  if (eventName === 'UserPromptExpansion') return payload.command_name ?? '';
+  if (eventName === 'StopFailure') return payload.error_type ?? '';
+  return payload.tool_name ?? '';
+}

package/src/standalone/hook-bus/constants.mjs

@@ -0,0 +1,90 @@
+export const DEFAULT_EVENTS = Object.freeze([
+  'runtime:start',
+  'session:create',
+  'turn:start',
+  'turn:end',
+  'turn:error',
+  'tool:planned',
+  'tool:before',
+  'tool:ask',
+  'tool:deny',
+  'tool:modify',
+  'hook:error',
+  'SessionStart',
+  'UserPromptSubmit',
+  'PreToolUse',
+  'PostToolUse',
+  'Stop',
+]);
+
+export const DEFAULT_COMMAND_TIMEOUT_S = 600;
+export const USER_PROMPT_TIMEOUT_S = 30;
+export const MESSAGE_DISPLAY_TIMEOUT_S = 10;
+export const DEFAULT_PROMPT_TIMEOUT_S = 30;
+export const DEFAULT_AGENT_TIMEOUT_S = 60;
+export const MAX_OUTPUT_CHARS = 10_000;
+export const MAX_BUFFER_BYTES = 10 * 1024 * 1024;
+
+export const TOOL_IF_EVENTS = new Set([
+  'PreToolUse',
+  'PostToolUse',
+  'PostToolUseFailure',
+  'PermissionRequest',
+  'PermissionDenied',
+]);
+
+export const NO_MATCHER_EVENTS = new Set([
+  'UserPromptSubmit',
+  'PostToolBatch',
+  'Stop',
+  'TeammateIdle',
+  'TaskCreated',
+  'TaskCompleted',
+  'WorktreeCreate',
+  'WorktreeRemove',
+  'CwdChanged',
+  'MessageDisplay',
+]);
+
+export const EXIT2_BLOCK_EVENTS = new Set([
+  'PreToolUse',
+  'PermissionRequest',
+  'UserPromptSubmit',
+  'UserPromptExpansion',
+  'Stop',
+  'SubagentStop',
+  'TeammateIdle',
+  'TaskCreated',
+  'TaskCompleted',
+  'ConfigChange',
+  'PostToolBatch',
+  'PreCompact',
+  'Elicitation',
+  'ElicitationResult',
+]);
+
+export const TOP_LEVEL_DECISION_EVENTS = new Set([
+  'UserPromptSubmit',
+  'UserPromptExpansion',
+  'PostToolUse',
+  'PostToolUseFailure',
+  'PostToolBatch',
+  'Stop',
+  'SubagentStop',
+  'ConfigChange',
+  'PreCompact',
+]);
+
+export const PLAIN_STDOUT_CONTEXT_EVENTS = new Set([
+  'SessionStart',
+  'UserPromptSubmit',
+  'UserPromptExpansion',
+]);
+
+export const SUPPORTED_HANDLER_TYPES = new Set(['command', 'http', 'mcp_tool', 'prompt']);
+
+export function limitText(text) {
+  const value = String(text || '');
+  if (value.length <= MAX_OUTPUT_CHARS) return value;
+  return `${value.slice(0, MAX_OUTPUT_CHARS)}\n... [hook output truncated; original ${value.length} chars]`;
+}