@oddessentials/agent-guild 0.10.0 → 0.12.0

package/src/report/hooks.mjs

@@ -1,21 +1,16 @@
 // Translate a coding tool's hook event into Agent Guild reports.
 //
-// Claude Code, Codex CLI, Gemini CLI and Grok Build all run hook commands
-// with one JSON event on stdin. They spell the event name and the sub-agent
-// and model fields differently, so every spelling is accepted here.
+// Claude Code, Codex CLI, Antigravity CLI and Grok Build all run hook
+// commands with one JSON event on stdin. They spell the event name and the
+// sub-agent and model fields differently, so every spelling is accepted here.
 //
 // Sub-agents come from:
 // - SubagentStart / SubagentStop (Claude Code, Codex CLI, Grok Build).
-// - A tool call that runs a sub-agent: Gemini CLI's `invoke_agent`
-//   (BeforeTool / AfterTool), which returns when the agent is finished, and
-//   Claude Code's "Agent" tool (formerly "Task") on PreToolUse / PostToolUse
+// - Claude Code's "Agent" tool (formerly "Task") on PreToolUse / PostToolUse
 //   for versions without the sub-agent events. A launch marked as background
 //   returns immediately, so its PostToolUse says nothing about when the
 //   agent finishes; those launches are skipped. Configure one style, not
-//   both, or each sub-agent appears twice. Gemini's call is a foreground
-//   agent: the parent waits for it, and when its end event never comes (a
-//   cancelled or denied call) it is closed at the next turn boundary of the
-//   main session.
+//   both, or each sub-agent appears twice.
 // - Codex CLI ends every turn of a sub-agent with SubagentStop; a follow-up
 //   turn of the same agent starts with a UserPromptSubmit inside it, or,
 //   with Codex's multi_agent_v2 tools, straight with tool calls, which
@@ -27,25 +22,61 @@
 import path from 'node:path';
 import crypto from 'node:crypto';
 
-const SUBAGENT_TOOLS = new Set(['Task', 'Agent', 'invoke_agent']);
-const TOOL_START_EVENTS = new Set(['PreToolUse', 'BeforeTool']);
-const TOOL_END_EVENTS = new Set(['PostToolUse', 'PostToolUseFailure', 'AfterTool']);
-const TURN_BOUNDARY_EVENTS = new Set(['BeforeAgent', 'AfterAgent', 'UserPromptSubmit', 'Stop']);
+const SUBAGENT_TOOLS = new Set(['Task', 'Agent']);
+const SHELL_TOOLS = new Set(['Bash', 'PowerShell', 'run_terminal_command']);
+const TOOL_START_EVENTS = new Set(['PreToolUse']);
+const TOOL_END_EVENTS = new Set(['PostToolUse', 'PostToolUseFailure']);
+const TURN_BOUNDARY_EVENTS = new Set(['UserPromptSubmit', 'Stop', 'Interrupt']);
 const MAX_DETAIL = 200;
 
+const FINISHED_TASKS = new Set(['completed', 'failed', 'killed']);
+const LIVE_TASKS = new Set(['pending', 'running', 'paused']);
+const MAX_RUNNING_TASKS = 256;
+
 const text = (...values) => values.find((v) => typeof v === 'string' && v.trim())?.trim() ?? null;
 
+function commandHash(command) {
+  return crypto.createHash('sha256').update(command.replace(/\s+/g, ' ').trim()).digest('hex').slice(0, 32);
+}
+
+function shellReport(event, input, subagentId) {
+  const toolInput = input.tool_input || input.toolInput || {};
+  const id = text(input.tool_use_id, input.toolUseId);
+  const agent = subagentId ? { agentId: `hook-${subagentId}` } : {};
+  const match = typeof toolInput.command === 'string' ? { match: commandHash(toolInput.command) } : {};
+  // Codex CLI (its events carry turn_id) keeps a command running past its turn, and reports no end for one it refused.
+  const codex = Boolean(text(input.turn_id));
+  if (event === 'PermissionRequest') return { shell: codex ? 'asked' : 'waiting', ...agent, ...match };
+  if (!id) return null;
+  const key = id.slice(0, 128);
+  if (TOOL_START_EVENTS.has(event)) return { shell: 'start', key, ...agent, ...match, ...(codex ? { persist: true } : {}) };
+  const response = input.tool_response ?? input.toolResponse;
+  const task = text(response?.backgroundTaskId);
+  if (task) return { shell: 'background', key, task: task.slice(0, 128), ...(response.backgroundEndsWithFinalResponse === true ? { endsWithAgent: true } : {}) };
+  return { shell: 'end', key };
+}
+
+// Claude Code reports a background task ending as a prompt of <task-notification> blocks.
+function taskNotifications(prompt) {
+  if (typeof prompt !== 'string' || !/^\s*<task-notification>/.test(prompt)) return null;
+  return [...prompt.matchAll(/<task-notification>([\s\S]*?)<\/task-notification>/g)].map(([, body]) => {
+    const tag = (name) => body.match(new RegExp(`<${name}>([^<]*)</${name}>`))?.[1].trim() || null;
+    return { taskId: tag('task-id'), toolUseId: tag('tool-use-id'), status: tag('status') };
+  });
+}
+
+function runningShells(tasks) {
+  const ids = tasks.filter((task) => task?.type === 'shell' && !FINISHED_TASKS.has(task.status)).map((task) => text(task.id)).filter(Boolean);
+  return { shell: 'running', tasks: ids.slice(0, MAX_RUNNING_TASKS).map((id) => id.slice(0, 128)) };
+}
+
 /** "subagent_start", "subagentStart" and "SubagentStart" all become "SubagentStart". */
 function eventName(input) {
   const raw = text(input.hook_event_name, input.hookEventName) || '';
   return raw.replace(/(?:^|[_-])([a-z])/g, (_m, c) => c.toUpperCase());
 }
 
-/**
- * Reports for one hook event: an agent report (has agentId) when a
- * sub-agent starts or stops, and a model report (has model) when the event
- * names the main model. Empty for events that carry neither.
- */
+/** Reports for one hook event: its sub-agents, shell commands, model and the tool's own session id. */
 export function hookToReports(input) {
   if (!input || typeof input !== 'object') return [];
   const event = eventName(input);
@@ -69,6 +100,19 @@ export function hookToReports(input) {
       if (detail) report.detail = detail.slice(0, MAX_DETAIL);
       reports.push(report);
     }
+    if (Array.isArray(input.background_tasks)) reports.push(runningShells(input.background_tasks));
+    return reports;
+  }
+
+  if (event === 'UserPromptSubmit' && !text(input.turn_id)) {
+    // Claude Code (turn_id is Codex's) fires this for a prompt typed while a turn runs, too, so it is no turn boundary.
+    // It also brings each background task's end; a sub-agent's task id is its agent id, and one stopped with TaskStop
+    // gets no SubagentStop.
+    for (const { taskId, toolUseId, status } of taskNotifications(input.prompt) ?? []) {
+      if (!taskId || LIVE_TASKS.has(status)) continue;
+      reports.push({ shell: 'end', task: taskId.slice(0, 128), ...(toolUseId ? { key: toolUseId.slice(0, 128) } : {}) });
+      if (FINISHED_TASKS.has(status)) reports.push({ agentId: `hook-${taskId}`, status: 'done' });
+    }
     return reports;
   }
 
@@ -79,26 +123,29 @@ export function hookToReports(input) {
     const childType = text(input.subagent_type, input.subagentType);
     const childId = text(input.session_id, input.sessionId);
     if (childType && childId) reports.push({ agentId: `hook-${childId}`, name: childType, kind: 'subagent', status: 'done' });
+    else if (event === 'SessionEnd') reports.push({ shell: 'reset' });
     return reports;
   }
 
   const toolName = text(input.tool_name, input.toolName);
-  if ((TOOL_START_EVENTS.has(event) || TOOL_END_EVENTS.has(event)) && SUBAGENT_TOOLS.has(toolName)) {
+  const toolEvent = TOOL_START_EVENTS.has(event) || TOOL_END_EVENTS.has(event);
+  const shell = (toolEvent || event === 'PermissionRequest') && SHELL_TOOLS.has(toolName) ? shellReport(event, input, subagentId) : null;
+  if (shell) reports.push(shell);
+  if (event === 'PostToolUse' && toolName === 'TaskStop') {
     const toolInput = input.tool_input || input.toolInput || {};
-    if (toolInput.run_in_background !== true) {
-      // tool_use_id links the start and end events; fall back to hashing the
-      // identical tool_input both events carry (Gemini CLI sends no id).
-      const key = text(input.tool_use_id, input.toolUseId) ||
-        crypto.createHash('sha1').update(JSON.stringify(toolInput)).digest('hex').slice(0, 16);
+    const task = text(toolInput.task_id, toolInput.shell_id);
+    if (task) reports.push({ shell: 'end', task: task.slice(0, 128) }, { agentId: `hook-${task}`, status: 'done' });
+  }
+  if (toolEvent && SUBAGENT_TOOLS.has(toolName)) {
+    const toolInput = input.tool_input || input.toolInput || {};
+    const key = text(input.tool_use_id, input.toolUseId);
+    if (key && toolInput.run_in_background !== true) {
       reports.push({
         agentId: `hook-task-${key}`,
         name: text(toolInput.subagent_type, toolInput.agent_name) || 'subagent',
         kind: 'subagent',
         detail: (text(toolInput.description, toolInput.prompt) || '').slice(0, MAX_DETAIL),
         status: TOOL_START_EVENTS.has(event) ? 'working' : 'done',
-        // Gemini CLI's call returns when the agent is finished, so the
-        // parent waits: a model reported meanwhile is the sub-agent's.
-        foreground: toolName === 'invoke_agent',
       });
     }
   }
@@ -115,24 +162,26 @@ export function hookToReports(input) {
   // agent_id, Grok Build by subagentType); its model is not the session's.
   const insideSubagent = Boolean(subagentId || text(input.subagent_type, input.subagentType));
 
-  // Gemini CLI skips AfterTool for an invoke_agent call that was cancelled
-  // or denied. A turn boundary of the main session (BeforeAgent and
-  // AfterAgent in Gemini CLI; a main-thread prompt or Stop elsewhere) cannot
-  // happen while the parent waits for a foreground agent, so one still
-  // working then has been orphaned.
+  if (event === 'Stop' && Array.isArray(input.background_tasks)) reports.push(runningShells(input.background_tasks));
   if (!insideSubagent && TURN_BOUNDARY_EVENTS.has(event)) reports.push({ finishForeground: true });
 
-  const model = insideSubagent ? null : event === 'PostModelSwitch'
+  const model = insideSubagent || toolEvent ? null : event === 'PostModelSwitch'
     ? text(input.to_model)
-    : text(input.model, input.modelId, input.llm_request?.model);
+    : text(input.model, input.modelId, input.modelName);
   if (model) reports.push({ model });
 
-  // Gemini CLI has no session-start event; its turn start stands in.
-  const toolSessionId = insideSubagent ? null : text(input.session_id, input.sessionId);
-  if (toolSessionId && (event === 'SessionStart' || event === 'BeforeAgent')) reports.push({ toolSessionId });
+  if (!insideSubagent && event === 'SessionStart') reports.push({ hello: true });
+
+  const toolSessionId = insideSubagent ? null : text(input.session_id, input.sessionId, input.conversationId);
+  if (toolSessionId && (event === 'SessionStart' || event === 'PreInvocation')) reports.push({ toolSessionId });
   return reports;
 }
 
+/** Whether an Antigravity CLI conversation starts with the user's own request; a sub-agent's starts with its parent's message. */
+export function antigravityUserConversation(firstRecord) {
+  return firstRecord?.type === 'USER_INPUT' && firstRecord.source === 'USER_EXPLICIT';
+}
+
 /** Model report from the JSON Claude Code feeds to a status line command. */
 export function claudeStatuslineToReport(input) {
   const id = input?.model?.id;

package/web/app.js

@@ -354,23 +354,69 @@ function paintProviderIcon(el, provider) {
 
 const FAMILIARS = ['flame', 'leaf', 'night', 'aether'];
 
-function renderAgents(container, agents) {
+const REPORTING_TEXT = {
+  pending: 'waiting for hooks',
+  unavailable: 'no reports yet',
+  setup_required: 'reporting off',
+  unsupported: 'not supported',
+};
+
+function paintReporting(row, s) {
+  const reporting = s.status === 'running' ? s.reporting : null;
+  const agents = row.querySelector('.agents');
+  agents.dataset.empty = REPORTING_TEXT[reporting?.state] || 'none reported';
+  agents.classList.toggle('reporting-attention', ['unavailable', 'setup_required', 'unsupported'].includes(reporting?.state));
+  const why = row.querySelector('.reporting-why');
+  const reason = reporting?.state !== 'active' ? reporting?.reason || '' : '';
+  why.hidden = !reason;
+  why.title = reason;
+  why.setAttribute('aria-label', `Why agent reporting says ${agents.dataset.empty}: ${reason}`);
+  why.onclick = () => toast(reason, 12000);
+}
+
+const MAX_SHELLS_SHOWN = 16;
+
+function renderAgents(container, agents, shells = []) {
   const known = container.dataset.rendered ? new Set([...container.children].map((el) => el.dataset.agent)) : null;
   container.dataset.rendered = 'true';
-  container.replaceChildren(...agents.map((agent) => {
+  const familiar = (id, name, hue) => {
     const el = document.createElement('span');
-    el.className = `agent ${agent.status}`;
-    el.dataset.agent = agent.id;
-    if (known && !known.has(agent.id)) el.classList.add('summon');
-    el.style.setProperty('--c', `hsl(${hueFor(agent.name)} 65% 50%)`);
-    el.dataset.familiar = FAMILIARS[hueFor(agent.name) % FAMILIARS.length];
+    el.dataset.agent = id;
+    if (known && !known.has(id)) el.classList.add('summon');
+    el.style.setProperty('--c', `hsl(${hue} 65% 50%)`);
+    el.dataset.familiar = FAMILIARS[hue % FAMILIARS.length];
+    el.setAttribute('role', 'img');
+    return el;
+  };
+  const agentEls = agents.map((agent) => {
+    const el = familiar(agent.id, agent.name, hueFor(agent.name));
+    el.classList.add('agent', agent.status);
     el.textContent = (agent.name || '?').charAt(0).toUpperCase();
     const detail = agent.detail ? ` — ${agent.detail}` : '';
     el.title = `${agent.name} (${agent.status})${detail}`;
-    el.setAttribute('role', 'img');
     el.setAttribute('aria-label', el.title);
     return el;
-  }));
+  });
+  const shellEls = shells.slice(0, MAX_SHELLS_SHOWN).map((shell) => {
+    const el = familiar(shell.id, 'Shell', hueFor(shell.id));
+    el.classList.add('agent', 'working', 'shell');
+    el.textContent = '>';
+    el.title = 'Shell command (running)';
+    el.setAttribute('aria-label', el.title);
+    return el;
+  });
+  if (shells.length > MAX_SHELLS_SHOWN) {
+    const more = document.createElement('span');
+    const hidden = shells.length - MAX_SHELLS_SHOWN;
+    more.className = 'agent-overflow';
+    more.dataset.agent = 'shell-overflow';
+    more.textContent = `+${hidden}`;
+    more.title = `${shells.length} shell commands running; ${hidden} more not drawn`;
+    more.setAttribute('role', 'img');
+    more.setAttribute('aria-label', more.title);
+    shellEls.push(more);
+  }
+  container.replaceChildren(...agentEls, ...shellEls);
 }
 
 // ---- API ------------------------------------------------------------------
@@ -431,6 +477,7 @@ function renderAccounts(card, provider) {
         selectAccount(provider, account.id);
         renderAccounts(card, provider);
         renderUsage(card, provider);
+        renderReportingSetup(card, provider);
       });
       return chip;
     }));
@@ -444,6 +491,31 @@ function renderAccounts(card, provider) {
   });
 }
 
+function renderReportingSetup(card, provider) {
+  const row = card.querySelector('.reporting-row');
+  row.hidden = !provider.available || typeof provider.reportingEnabled !== 'boolean';
+  if (row.hidden) return;
+  const on = provider.reportingEnabled;
+  row.querySelector('.reporting-text').textContent = `Agent reporting ${on ? 'on' : 'off'}`;
+  const button = row.querySelector('.reporting-toggle');
+  button.textContent = on ? 'Turn off' : 'Turn on';
+  button.title = on
+    ? `Remove the Agent Guild plugin from ${provider.tool}. New sessions stop reporting their model.`
+    : `Install the Agent Guild plugin into ${provider.tool} with "${provider.command} plugin install", so new sessions show their model and can be resumed. It does nothing in sessions started outside Agent Guild.`;
+  button.onclick = async () => {
+    button.disabled = true;
+    try {
+      await api('POST', `/providers/${provider.id}/reporting`, { enabled: !on });
+      toast(on ? `Agent reporting is off for ${provider.tool}.` : `Agent reporting is on for ${provider.tool}. It applies to new sessions.`);
+    } catch (err) {
+      if (err instanceof AuthError) return showAuth(err.message);
+      toast(err.message, 10000);
+    } finally {
+      button.disabled = false;
+    }
+  };
+}
+
 let dealt = false;
 
 function renderProviders() {
@@ -487,6 +559,7 @@ function renderProviders() {
     renderConsoleLinks(node, provider);
     renderAccounts(node, provider);
     renderUsage(node, provider);
+    renderReportingSetup(node, provider);
     renderModelStats(node, provider);
     return node;
   }));
@@ -1619,7 +1692,7 @@ async function installProvider(provider, card, { force = false } = {}) {
 
 /**
  * Start a session. A resumed session starts in the folder its transcript
- * names, since Claude Code and Gemini CLI only find a session from there;
+ * names, since Claude Code only finds a session from there;
  * when that folder is gone, the working folder is used instead.
  */
 async function startSession(provider, card, { resume, cwd, account = selectedAccount(provider).id } = {}) {
@@ -2541,7 +2614,8 @@ function updateCard(node, s) {
   // The LRM keeps a leading "/" in place under the right-to-left truncation style.
   cwd.textContent = `\u200E${s.cwd}`;
   cwd.title = s.cwd;
-  renderAgents(node.querySelector('.agents'), s.agents);
+  renderAgents(node.querySelector('.agents'), s.agents, s.shells || []);
+  paintReporting(node.querySelector('.agents-row'), s);
   node.classList.toggle('exited', s.status === 'exited');
   node.querySelector('.stop').hidden = s.status !== 'running';
   node.querySelector('.remove').hidden = s.status === 'running';
@@ -2553,7 +2627,9 @@ function updateCard(node, s) {
   resume.title = `Start ${s.provider.tool} again on this session${id ? ` (${id})` : ''} in ${s.cwd}`;
   const modelLabel = s.model ? `, model ${modelText(s)}` : '';
   const accountName = accountLabel(s) ? `, ${accountLabel(s)} account` : '';
-  node.setAttribute('aria-label', `${s.name}, ${s.provider.vendor}${accountName}${modelLabel}, ${statusText(s)}, ${s.agents.length} agents`);
+  const shellCount = (s.shells || []).length;
+  const reportingNote = s.status === 'running' && REPORTING_TEXT[s.reporting?.state] ? `, agent reporting: ${REPORTING_TEXT[s.reporting.state]}` : '';
+  node.setAttribute('aria-label', `${s.name}, ${s.provider.vendor}${accountName}${modelLabel}, ${statusText(s)}, ${s.agents.length} agents${shellCount ? `, ${shellCount} shell command${shellCount === 1 ? '' : 's'} running` : ''}${reportingNote}`);
 }
 
 function renderSessions() {
@@ -2810,7 +2886,7 @@ function updatePanel() {
   const id = toolSessionId(s);
   $('panel-sub').textContent = [s.provider.tool, accountLabel(s), modelText(s), statusText(s), s.cwd, id && `session ${id}`].filter(Boolean).join(' · ');
   $('panel-sub').title = modelTitle(s);
-  renderAgents($('panel-agents'), s.agents);
+  renderAgents($('panel-agents'), s.agents, s.shells || []);
   const stop = $('panel-stop');
   stop.textContent = s.status === 'running' ? 'Stop' : 'Remove';
 }

package/web/index.html

@@ -262,6 +262,10 @@
       <div class="accounts" role="tablist" aria-label="Accounts" hidden></div>
       <div class="usage"></div>
       <div class="model-stats"></div>
+      <div class="reporting-row" hidden>
+        <span class="reporting-text"></span>
+        <button class="btn reporting-toggle" type="button"></button>
+      </div>
       <div class="provider-links">
         <a class="console-link usage-link" target="_blank" rel="noopener noreferrer">Usage</a>
         <a class="console-link billing-link" target="_blank" rel="noopener noreferrer">Billing</a>
@@ -349,6 +353,7 @@
       <div class="agents-row">
         <span class="agents-label">Agents</span>
         <div class="agents"></div>
+        <button class="reporting-why" type="button" hidden>Why?</button>
       </div>
       <div class="card-actions">
         <button class="btn primary open" type="button">Open</button>

package/web/styles.css

@@ -196,6 +196,8 @@ main { max-width: 1200px; margin: 0 auto; padding: 26px 16px 56px; display: grid
   .tier-d { --tier: #94a3b8; --tier-ink: #d4dbe4; }
 }
 .provider-links { display: flex; gap: 14px; font-size: 0.78rem; }
+.reporting-row { display: flex; align-items: center; gap: 10px; font-size: 0.78rem; color: var(--muted); }
+.reporting-row .btn { padding: 2px 10px; font-size: 0.75rem; white-space: nowrap; }
 .console-link { color: var(--accent); text-decoration: none; }
 .console-link:hover { text-decoration: underline; }
 .console-link:focus-visible { outline: 2px solid var(--focus); outline-offset: 2px; border-radius: 3px; }
@@ -223,7 +225,7 @@ main { max-width: 1200px; margin: 0 auto; padding: 26px 16px 56px; display: grid
 
 .session-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(300px, 1fr)); gap: 14px; }
 .session-card {
-  display: grid; gap: 12px; padding: 14px; border: 1px solid var(--border); border-radius: var(--radius);
+  display: grid; grid-template-columns: minmax(0, 1fr); gap: 12px; padding: 14px; border: 1px solid var(--border); border-radius: var(--radius);
   background: var(--surface); box-shadow: var(--shadow); cursor: pointer;
 }
 .session-card:focus-visible { outline: 2px solid var(--focus); outline-offset: 2px; }
@@ -256,7 +258,11 @@ main { max-width: 1200px; margin: 0 auto; padding: 26px 16px 56px; display: grid
 .agents-row { display: flex; align-items: center; gap: 10px; min-height: 30px; }
 .agents-label { font-size: 0.75rem; color: var(--muted); }
 .agents { display: flex; flex-wrap: wrap; gap: 6px; }
-.agents:empty::after { content: "none reported"; font-size: 0.75rem; color: var(--muted); }
+.agents-row .agents { flex: 1; min-width: 0; }
+.agents:empty::after { content: attr(data-empty); font-size: 0.75rem; color: var(--muted); }
+.agents.reporting-attention:empty::after { color: var(--warn); }
+.reporting-why { align-self: center; padding: 0 6px; border: 1px solid var(--border); border-radius: 999px; background: none; color: var(--muted); font: inherit; font-size: 0.7rem; cursor: pointer; }
+.reporting-why:hover, .reporting-why:focus-visible { color: var(--text); border-color: var(--muted); }
 .agent {
   --c: #64748b;
   width: 28px; height: 28px; border-radius: 50%; display: grid; place-items: center; position: relative;
@@ -270,6 +276,8 @@ main { max-width: 1200px; margin: 0 auto; padding: 26px 16px 56px; display: grid
 .agent.waiting { border-style: dashed; }
 .agent.done, .agent.idle { opacity: 0.5; }
 .panel-title .agents:empty::after { content: none; }
+.agent.shell { font-family: var(--font-mono, monospace); font-size: 0.8rem; }
+.agent-overflow { align-self: center; font-size: 0.75rem; font-weight: 600; color: var(--muted); }
 
 .card-actions { display: flex; gap: 8px; flex-wrap: wrap; }
 .btn {

package/examples/gemini-settings.json

@@ -1,61 +0,0 @@
-{
-  "hooks": {
-    "BeforeTool": [
-      {
-        "matcher": "invoke_agent",
-        "hooks": [
-          {
-            "type": "command",
-            "name": "Agent Guild agent start",
-            "command": "agent-guild-report --hook"
-          }
-        ]
-      }
-    ],
-    "AfterTool": [
-      {
-        "matcher": "invoke_agent",
-        "hooks": [
-          {
-            "type": "command",
-            "name": "Agent Guild agent stop",
-            "command": "agent-guild-report --hook"
-          }
-        ]
-      }
-    ],
-    "BeforeAgent": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "name": "Agent Guild turn start",
-            "command": "agent-guild-report --hook"
-          }
-        ]
-      }
-    ],
-    "AfterAgent": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "name": "Agent Guild turn end",
-            "command": "agent-guild-report --hook"
-          }
-        ]
-      }
-    ],
-    "BeforeModel": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "name": "Agent Guild model",
-            "command": "agent-guild-report --hook"
-          }
-        ]
-      }
-    ]
-  }
-}