@iaforged/context-code 1.0.62 → 1.0.65

package/dist/src/outputStyles/loadOutputStylesDir.js

@@ -1,71 +0,0 @@
-import memoize from 'lodash-es/memoize.js';
-import { basename } from 'path';
-import { logForDebugging } from '../utils/debug.js';
-import { coerceDescriptionToString } from '../utils/frontmatterParser.js';
-import { logError } from '../utils/log.js';
-import { extractDescriptionFromMarkdown, loadMarkdownFilesForSubdir, } from '../utils/markdownConfigLoader.js';
-import { clearPluginOutputStyleCache } from '../utils/plugins/loadPluginOutputStyles.js';
-/**
- * Loads markdown files from .claude/output-styles directories throughout the project
- * and from ~/.claude/output-styles directory and converts them to output styles.
- *
- * Each filename becomes a style name, and the file content becomes the style prompt.
- * The frontmatter provides name and description.
- *
- * Structure:
- * - Project .claude/output-styles/*.md -> project styles
- * - User ~/.claude/output-styles/*.md -> user styles (overridden by project styles)
- *
- * @param cwd Current working directory for project directory traversal
- */
-export const getOutputStyleDirStyles = memoize(async (cwd) => {
-    try {
-        const markdownFiles = await loadMarkdownFilesForSubdir('output-styles', cwd);
-        const styles = markdownFiles
-            .map(({ filePath, frontmatter, content, source }) => {
-            try {
-                const fileName = basename(filePath);
-                const styleName = fileName.replace(/\.md$/, '');
-                // Get style configuration from frontmatter
-                const name = (frontmatter['name'] || styleName);
-                const description = coerceDescriptionToString(frontmatter['description'], styleName) ??
-                    extractDescriptionFromMarkdown(content, `Custom ${styleName} output style`);
-                // Parse keep-coding-instructions flag (supports both boolean and string values)
-                const keepCodingInstructionsRaw = frontmatter['keep-coding-instructions'];
-                const keepCodingInstructions = keepCodingInstructionsRaw === true ||
-                    keepCodingInstructionsRaw === 'true'
-                    ? true
-                    : keepCodingInstructionsRaw === false ||
-                        keepCodingInstructionsRaw === 'false'
-                        ? false
-                        : undefined;
-                // Warn if force-for-plugin is set on non-plugin output style
-                if (frontmatter['force-for-plugin'] !== undefined) {
-                    logForDebugging(`Output style "${name}" has force-for-plugin set, but this option only applies to plugin output styles. Ignoring.`, { level: 'warn' });
-                }
-                return {
-                    name,
-                    description,
-                    prompt: content.trim(),
-                    source,
-                    keepCodingInstructions,
-                };
-            }
-            catch (error) {
-                logError(error);
-                return null;
-            }
-        })
-            .filter(style => style !== null);
-        return styles;
-    }
-    catch (error) {
-        logError(error);
-        return [];
-    }
-});
-export function clearOutputStyleCaches() {
-    getOutputStyleDirStyles.cache?.clear?.();
-    loadMarkdownFilesForSubdir.cache?.clear?.();
-    clearPluginOutputStyleCache();
-}

package/dist/src/plugins/builtinPlugins.js

@@ -1,132 +0,0 @@
-/**
- * Built-in Plugin Registry
- *
- * Manages built-in plugins that ship with the CLI and can be enabled/disabled
- * by users via the /plugin UI.
- *
- * Built-in plugins differ from bundled skills (src/skills/bundled/) in that:
- * - They appear in the /plugin UI under a "Built-in" section
- * - Users can enable/disable them (persisted to user settings)
- * - They can provide multiple components (skills, hooks, MCP servers)
- *
- * Plugin IDs use the format `{name}@builtin` to distinguish them from
- * marketplace plugins (`{name}@{marketplace}`).
- */
-import { getSettings_DEPRECATED } from '../utils/settings/settings.js';
-const BUILTIN_PLUGINS = new Map();
-export const BUILTIN_MARKETPLACE_NAME = 'builtin';
-/**
- * Register a built-in plugin. Call this from initBuiltinPlugins() at startup.
- */
-export function registerBuiltinPlugin(definition) {
-    BUILTIN_PLUGINS.set(definition.name, definition);
-}
-/**
- * Check if a plugin ID represents a built-in plugin (ends with @builtin).
- */
-export function isBuiltinPluginId(pluginId) {
-    return pluginId.endsWith(`@${BUILTIN_MARKETPLACE_NAME}`);
-}
-/**
- * Get a specific built-in plugin definition by name.
- * Useful for the /plugin UI to show the skills/hooks/MCP list without
- * a marketplace lookup.
- */
-export function getBuiltinPluginDefinition(name) {
-    return BUILTIN_PLUGINS.get(name);
-}
-/**
- * Get all registered built-in plugins as LoadedPlugin objects, split into
- * enabled/disabled based on user settings (with defaultEnabled as fallback).
- * Plugins whose isAvailable() returns false are omitted entirely.
- */
-export function getBuiltinPlugins() {
-    const settings = getSettings_DEPRECATED();
-    const enabled = [];
-    const disabled = [];
-    for (const [name, definition] of BUILTIN_PLUGINS) {
-        if (definition.isAvailable && !definition.isAvailable()) {
-            continue;
-        }
-        const pluginId = `${name}@${BUILTIN_MARKETPLACE_NAME}`;
-        const userSetting = settings?.enabledPlugins?.[pluginId];
-        // Enabled state: user preference > plugin default > true
-        const isEnabled = userSetting !== undefined
-            ? userSetting === true
-            : (definition.defaultEnabled ?? true);
-        const plugin = {
-            name,
-            manifest: {
-                name,
-                description: definition.description,
-                version: definition.version,
-            },
-            path: BUILTIN_MARKETPLACE_NAME, // sentinel — no filesystem path
-            source: pluginId,
-            repository: pluginId,
-            enabled: isEnabled,
-            isBuiltin: true,
-            hooksConfig: definition.hooks,
-            mcpServers: definition.mcpServers,
-        };
-        if (isEnabled) {
-            enabled.push(plugin);
-        }
-        else {
-            disabled.push(plugin);
-        }
-    }
-    return { enabled, disabled };
-}
-/**
- * Get skills from enabled built-in plugins as Command objects.
- * Skills from disabled plugins are not returned.
- */
-export function getBuiltinPluginSkillCommands() {
-    const { enabled } = getBuiltinPlugins();
-    const commands = [];
-    for (const plugin of enabled) {
-        const definition = BUILTIN_PLUGINS.get(plugin.name);
-        if (!definition?.skills)
-            continue;
-        for (const skill of definition.skills) {
-            commands.push(skillDefinitionToCommand(skill));
-        }
-    }
-    return commands;
-}
-/**
- * Clear built-in plugins registry (for testing).
- */
-export function clearBuiltinPlugins() {
-    BUILTIN_PLUGINS.clear();
-}
-// --
-function skillDefinitionToCommand(definition) {
-    return {
-        type: 'prompt',
-        name: definition.name,
-        description: definition.description,
-        hasUserSpecifiedDescription: true,
-        allowedTools: definition.allowedTools ?? [],
-        argumentHint: definition.argumentHint,
-        whenToUse: definition.whenToUse,
-        model: definition.model,
-        disableModelInvocation: definition.disableModelInvocation ?? false,
-        userInvocable: definition.userInvocable ?? true,
-        contentLength: 0,
-        // 'bundled' not 'builtin' — 'builtin' in Command.source means hardcoded
-        // slash commands (/help, /clear). Using 'bundled' keeps these skills in
-        // the Skill tool's listing, analytics name logging, and prompt-truncation
-        // exemption. The user-toggleable aspect is tracked on LoadedPlugin.isBuiltin.
-        source: 'bundled',
-        loadedFrom: 'bundled',
-        hooks: definition.hooks,
-        context: definition.context,
-        agent: definition.agent,
-        isEnabled: definition.isEnabled ?? (() => true),
-        isHidden: !(definition.userInvocable ?? true),
-        progressMessage: 'running',
-        getPromptForCommand: definition.getPromptForCommand,
-    };
-}

package/dist/src/plugins/bundled/index.js

@@ -1,22 +0,0 @@
-/**
- * Built-in Plugin Initialization
- *
- * Initializes built-in plugins that ship with the CLI and appear in the
- * /plugin UI for users to enable/disable.
- *
- * Not all bundled features should be built-in plugins — use this for
- * features that users should be able to explicitly enable/disable. For
- * features with complex setup or automatic-enabling logic (e.g.
- * claude-in-chrome), use src/skills/bundled/ instead.
- *
- * To add a new built-in plugin:
- * 1. Import registerBuiltinPlugin from '../builtinPlugins.js'
- * 2. Call registerBuiltinPlugin() with the plugin definition here
- */
-/**
- * Initialize built-in plugins. Called during CLI startup.
- */
-export function initBuiltinPlugins() {
-    // No built-in plugins registered yet — this is the scaffolding for
-    // migrating bundled skills that should be user-toggleable.
-}

package/dist/src/projectOnboardingState.js

@@ -1,61 +0,0 @@
-import memoize from 'lodash-es/memoize.js';
-import { join } from 'path';
-import { getCurrentProjectConfig, saveCurrentProjectConfig, } from './utils/config.js';
-import { getCwd } from './utils/cwd.js';
-import { isDirEmpty } from './utils/file.js';
-import { getFsImplementation } from './utils/fsOperations.js';
-export function getSteps() {
-    const hasClaudeMd = getFsImplementation().existsSync(join(getCwd(), 'CLAUDE.md'));
-    const isWorkspaceDirEmpty = isDirEmpty(getCwd());
-    return [
-        {
-            key: 'workspace',
-            text: 'Ask Claude to create a new app or clone a repository',
-            isComplete: false,
-            isCompletable: true,
-            isEnabled: isWorkspaceDirEmpty,
-        },
-        {
-            key: 'claudemd',
-            text: 'Ejecuta /init para crear un archivo CLAUDE.md con instrucciones para Context Code',
-            isComplete: hasClaudeMd,
-            isCompletable: true,
-            isEnabled: !isWorkspaceDirEmpty,
-        },
-    ];
-}
-export function isProjectOnboardingComplete() {
-    return getSteps()
-        .filter(({ isCompletable, isEnabled }) => isCompletable && isEnabled)
-        .every(({ isComplete }) => isComplete);
-}
-export function maybeMarkProjectOnboardingComplete() {
-    // Short-circuit on cached config — isProjectOnboardingComplete() hits
-    // the filesystem, and REPL.tsx calls this on every prompt submit.
-    if (getCurrentProjectConfig().hasCompletedProjectOnboarding) {
-        return;
-    }
-    if (isProjectOnboardingComplete()) {
-        saveCurrentProjectConfig(current => ({
-            ...current,
-            hasCompletedProjectOnboarding: true,
-        }));
-    }
-}
-export const shouldShowProjectOnboarding = memoize(() => {
-    const projectConfig = getCurrentProjectConfig();
-    // Short-circuit on cached config before isProjectOnboardingComplete()
-    // hits the filesystem — this runs during first render.
-    if (projectConfig.hasCompletedProjectOnboarding ||
-        projectConfig.projectOnboardingSeenCount >= 4 ||
-        process.env.IS_DEMO) {
-        return false;
-    }
-    return !isProjectOnboardingComplete();
-});
-export function incrementProjectOnboardingSeenCount() {
-    saveCurrentProjectConfig(current => ({
-        ...current,
-        projectOnboardingSeenCount: current.projectOnboardingSeenCount + 1,
-    }));
-}

package/dist/src/query/config.js

@@ -1,17 +0,0 @@
-import { getSessionId } from '../bootstrap/state.js';
-import { checkStatsigFeatureGate_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js';
-import { isEnvTruthy } from '../utils/envUtils.js';
-export function buildQueryConfig() {
-    return {
-        sessionId: getSessionId(),
-        gates: {
-            streamingToolExecution: checkStatsigFeatureGate_CACHED_MAY_BE_STALE('tengu_streaming_tool_execution2'),
-            emitToolUseSummaries: isEnvTruthy(process.env.CLAUDE_CODE_EMIT_TOOL_USE_SUMMARIES),
-            isAnt: process.env.USER_TYPE === 'ant',
-            // Inlined from fastMode.ts to avoid pulling its heavy module graph
-            // (axios, settings, auth, model, oauth, config) into test shards that
-            // didn't previously load it — changes init order and breaks unrelated tests.
-            fastModeEnabled: !isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_FAST_MODE),
-        },
-    };
-}

package/dist/src/query/deps.js

@@ -1,12 +0,0 @@
-import { randomUUID } from 'crypto';
-import { queryModelWithStreaming } from '../services/api/index.js';
-import { autoCompactIfNeeded } from '../services/compact/autoCompact.js';
-import { microcompactMessages } from '../services/compact/microCompact.js';
-export function productionDeps() {
-    return {
-        callModel: queryModelWithStreaming,
-        microcompact: microcompactMessages,
-        autocompact: autoCompactIfNeeded,
-        uuid: randomUUID,
-    };
-}

package/dist/src/query/stopHooks.js

@@ -1,334 +0,0 @@
-import { feature } from '../recovery/bunBundleShim.js';
-import { createRequire } from 'module';
-const require = createRequire(import.meta.url);
-import { getShortcutDisplay } from '../keybindings/shortcutFormat.js';
-import { isExtractModeActive } from '../memdir/paths.js';
-import { logEvent, } from '../services/analytics/index.js';
-import { createAttachmentMessage } from '../utils/attachments.js';
-import { logForDebugging } from '../utils/debug.js';
-import { errorMessage } from '../utils/errors.js';
-import { executeStopHooks, executeTaskCompletedHooks, executeTeammateIdleHooks, getStopHookMessage, getTaskCompletedHookMessage, getTeammateIdleHookMessage, } from '../utils/hooks.js';
-import { createStopHookSummaryMessage, createSystemMessage, createUserInterruptionMessage, createUserMessage, } from '../utils/messages.js';
-import { getTaskListId, listTasks } from '../utils/tasks.js';
-import { getAgentName, getTeamName, isTeammate } from '../utils/teammate.js';
-/* eslint-disable @typescript-eslint/no-require-imports */
-const extractMemoriesModule = feature('EXTRACT_MEMORIES')
-    ? require('../services/extractMemories/extractMemories.js')
-    : null;
-const jobClassifierModule = feature('TEMPLATES')
-    ? require('../jobs/classifier.js')
-    : null;
-import { executeAutoDream } from '../services/autoDream/autoDream.js';
-import { executePromptSuggestion } from '../services/PromptSuggestion/promptSuggestion.js';
-import { isBareMode, isEnvDefinedFalsy } from '../utils/envUtils.js';
-import { createCacheSafeParams, saveCacheSafeParams, } from '../utils/forkedAgent.js';
-export async function* handleStopHooks(messagesForQuery, assistantMessages, systemPrompt, userContext, systemContext, toolUseContext, querySource, stopHookActive) {
-    const hookStartTime = Date.now();
-    const stopHookContext = {
-        messages: [...messagesForQuery, ...assistantMessages],
-        systemPrompt,
-        userContext,
-        systemContext,
-        toolUseContext,
-        querySource,
-    };
-    // Only save params for main session queries — subagents must not overwrite.
-    // Outside the prompt-suggestion gate: the REPL /btw command and the
-    // side_question SDK control_request both read this snapshot, and neither
-    // depends on prompt suggestions being enabled.
-    if (querySource === 'repl_main_thread' || querySource === 'sdk') {
-        saveCacheSafeParams(createCacheSafeParams(stopHookContext));
-    }
-    // Template job classification: when running as a dispatched job, classify
-    // state after each turn. Gate on repl_main_thread so background forks
-    // (extract-memories, auto-dream) don't pollute the timeline with their own
-    // assistant messages. Await the classifier so state.json is written before
-    // the turn returns — otherwise `claude list` shows stale state for the gap.
-    // Env key hardcoded (vs importing JOB_ENV_KEY from jobs/state) to match the
-    // require()-gated jobs/ import pattern above; spawn.test.ts asserts the
-    // string matches.
-    if (feature('TEMPLATES') &&
-        process.env.CLAUDE_JOB_DIR &&
-        querySource.startsWith('repl_main_thread') &&
-        !toolUseContext.agentId) {
-        // Full turn history — assistantMessages resets each queryLoop iteration,
-        // so tool calls from earlier iterations (Agent spawn, then summary) need
-        // messagesForQuery to be visible in the tool-call summary.
-        const turnAssistantMessages = stopHookContext.messages.filter((m) => m.type === 'assistant');
-        const p = jobClassifierModule
-            .classifyAndWriteState(process.env.CLAUDE_JOB_DIR, turnAssistantMessages)
-            .catch(err => {
-            logForDebugging(`[job] classifier error: ${errorMessage(err)}`, {
-                level: 'error',
-            });
-        });
-        await Promise.race([
-            p,
-            // eslint-disable-next-line no-restricted-syntax -- sleep() has no .unref(); timer must not block exit
-            new Promise(r => setTimeout(r, 60_000).unref()),
-        ]);
-    }
-    // --bare / SIMPLE: skip background bookkeeping (prompt suggestion,
-    // memory extraction, auto-dream). Scripted -p calls don't want auto-memory
-    // or forked agents contending for resources during shutdown.
-    if (!isBareMode()) {
-        // Inline env check for dead code elimination in external builds
-        if (!isEnvDefinedFalsy(process.env.CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION)) {
-            void executePromptSuggestion(stopHookContext);
-        }
-        if (feature('EXTRACT_MEMORIES') &&
-            !toolUseContext.agentId &&
-            isExtractModeActive()) {
-            // Fire-and-forget in both interactive and non-interactive. For -p/SDK,
-            // print.ts drains the in-flight promise after flushing the response
-            // but before gracefulShutdownSync (see drainPendingExtraction).
-            void extractMemoriesModule.executeExtractMemories(stopHookContext, toolUseContext.appendSystemMessage);
-        }
-        if (!toolUseContext.agentId) {
-            void executeAutoDream(stopHookContext, toolUseContext.appendSystemMessage);
-        }
-    }
-    // chicago MCP: auto-unhide + lock release at turn end.
-    // Main thread only — the CU lock is a process-wide module-level variable,
-    // so a subagent's stopHooks releasing it leaves the main thread's cleanup
-    // seeing isLockHeldLocally()===false → no exit notification, and unhides
-    // mid-turn. Subagents don't start CU sessions so this is a pure skip.
-    if (feature('CHICAGO_MCP') && !toolUseContext.agentId) {
-        try {
-            const { cleanupComputerUseAfterTurn } = await import('../utils/computerUse/cleanup.js');
-            await cleanupComputerUseAfterTurn(toolUseContext);
-        }
-        catch {
-            // Failures are silent — this is dogfooding cleanup, not critical path
-        }
-    }
-    try {
-        const blockingErrors = [];
-        const appState = toolUseContext.getAppState();
-        const permissionMode = appState.toolPermissionContext.mode;
-        const generator = executeStopHooks(permissionMode, toolUseContext.abortController.signal, undefined, stopHookActive ?? false, toolUseContext.agentId, toolUseContext, [...messagesForQuery, ...assistantMessages], toolUseContext.agentType);
-        // Consume all progress messages and get blocking errors
-        let stopHookToolUseID = '';
-        let hookCount = 0;
-        let preventedContinuation = false;
-        let stopReason = '';
-        let hasOutput = false;
-        const hookErrors = [];
-        const hookInfos = [];
-        for await (const result of generator) {
-            if (result.message) {
-                yield result.message;
-                // Track toolUseID from progress messages and count hooks
-                if (result.message.type === 'progress' && result.message.toolUseID) {
-                    stopHookToolUseID = result.message.toolUseID;
-                    hookCount++;
-                    // Extract hook command and prompt text from progress data
-                    const progressData = result.message.data;
-                    if (progressData.command) {
-                        hookInfos.push({
-                            command: progressData.command,
-                            promptText: progressData.promptText,
-                        });
-                    }
-                }
-                // Track errors and output from attachments
-                if (result.message.type === 'attachment') {
-                    const attachment = result.message.attachment;
-                    if ('hookEvent' in attachment &&
-                        (attachment.hookEvent === 'Stop' ||
-                            attachment.hookEvent === 'SubagentStop')) {
-                        if (attachment.type === 'hook_non_blocking_error') {
-                            hookErrors.push(attachment.stderr || `Exit code ${attachment.exitCode}`);
-                            // Non-blocking errors always have output
-                            hasOutput = true;
-                        }
-                        else if (attachment.type === 'hook_error_during_execution') {
-                            hookErrors.push(attachment.content);
-                            hasOutput = true;
-                        }
-                        else if (attachment.type === 'hook_success') {
-                            // Check if successful hook produced any stdout/stderr
-                            if ((attachment.stdout && attachment.stdout.trim()) ||
-                                (attachment.stderr && attachment.stderr.trim())) {
-                                hasOutput = true;
-                            }
-                        }
-                        // Extract per-hook duration for timing visibility.
-                        // Hooks run in parallel; match by command + first unassigned entry.
-                        if ('durationMs' in attachment && 'command' in attachment) {
-                            const info = hookInfos.find(i => i.command === attachment.command &&
-                                i.durationMs === undefined);
-                            if (info) {
-                                info.durationMs = attachment.durationMs;
-                            }
-                        }
-                    }
-                }
-            }
-            if (result.blockingError) {
-                const userMessage = createUserMessage({
-                    content: getStopHookMessage(result.blockingError),
-                    isMeta: true, // Hide from UI (shown in summary message instead)
-                });
-                blockingErrors.push(userMessage);
-                yield userMessage;
-                hasOutput = true;
-                // Add to hookErrors so it appears in the summary
-                hookErrors.push(result.blockingError.blockingError);
-            }
-            // Check if hook wants to prevent continuation
-            if (result.preventContinuation) {
-                preventedContinuation = true;
-                stopReason = result.stopReason || 'Stop hook prevented continuation';
-                // Create attachment to track the stopped continuation (for structured data)
-                yield createAttachmentMessage({
-                    type: 'hook_stopped_continuation',
-                    message: stopReason,
-                    hookName: 'Stop',
-                    toolUseID: stopHookToolUseID,
-                    hookEvent: 'Stop',
-                });
-            }
-            // Check if we were aborted during hook execution
-            if (toolUseContext.abortController.signal.aborted) {
-                logEvent('tengu_pre_stop_hooks_cancelled', {
-                    queryChainId: toolUseContext.queryTracking
-                        ?.chainId,
-                    queryDepth: toolUseContext.queryTracking?.depth,
-                });
-                yield createUserInterruptionMessage({
-                    toolUse: false,
-                });
-                return { blockingErrors: [], preventContinuation: true };
-            }
-        }
-        // Create summary system message if hooks ran
-        if (hookCount > 0) {
-            yield createStopHookSummaryMessage(hookCount, hookInfos, hookErrors, preventedContinuation, stopReason, hasOutput, 'suggestion', stopHookToolUseID);
-            // Send notification about errors (shown in verbose/transcript mode via ctrl+o)
-            if (hookErrors.length > 0) {
-                const expandShortcut = getShortcutDisplay('app:toggleTranscript', 'Global', 'ctrl+o');
-                toolUseContext.addNotification?.({
-                    key: 'stop-hook-error',
-                    text: `Stop hook error occurred \u00b7 ${expandShortcut} to see`,
-                    priority: 'immediate',
-                });
-            }
-        }
-        if (preventedContinuation) {
-            return { blockingErrors: [], preventContinuation: true };
-        }
-        // Collect blocking errors from stop hooks
-        if (blockingErrors.length > 0) {
-            return { blockingErrors, preventContinuation: false };
-        }
-        // After Stop hooks pass, run TeammateIdle and TaskCompleted hooks if this is a teammate
-        if (isTeammate()) {
-            const teammateName = getAgentName() ?? '';
-            const teamName = getTeamName() ?? '';
-            const teammateBlockingErrors = [];
-            let teammatePreventedContinuation = false;
-            let teammateStopReason;
-            // Each hook executor generates its own toolUseID — capture from progress
-            // messages (same pattern as stopHookToolUseID at L142), not the Stop ID.
-            let teammateHookToolUseID = '';
-            // Run TaskCompleted hooks for any in-progress tasks owned by this teammate
-            const taskListId = getTaskListId();
-            const tasks = await listTasks(taskListId);
-            const inProgressTasks = tasks.filter(t => t.status === 'in_progress' && t.owner === teammateName);
-            for (const task of inProgressTasks) {
-                const taskCompletedGenerator = executeTaskCompletedHooks(task.id, task.subject, task.description, teammateName, teamName, permissionMode, toolUseContext.abortController.signal, undefined, toolUseContext);
-                for await (const result of taskCompletedGenerator) {
-                    if (result.message) {
-                        if (result.message.type === 'progress' &&
-                            result.message.toolUseID) {
-                            teammateHookToolUseID = result.message.toolUseID;
-                        }
-                        yield result.message;
-                    }
-                    if (result.blockingError) {
-                        const userMessage = createUserMessage({
-                            content: getTaskCompletedHookMessage(result.blockingError),
-                            isMeta: true,
-                        });
-                        teammateBlockingErrors.push(userMessage);
-                        yield userMessage;
-                    }
-                    // Match Stop hook behavior: allow preventContinuation/stopReason
-                    if (result.preventContinuation) {
-                        teammatePreventedContinuation = true;
-                        teammateStopReason =
-                            result.stopReason || 'TaskCompleted hook prevented continuation';
-                        yield createAttachmentMessage({
-                            type: 'hook_stopped_continuation',
-                            message: teammateStopReason,
-                            hookName: 'TaskCompleted',
-                            toolUseID: teammateHookToolUseID,
-                            hookEvent: 'TaskCompleted',
-                        });
-                    }
-                    if (toolUseContext.abortController.signal.aborted) {
-                        return { blockingErrors: [], preventContinuation: true };
-                    }
-                }
-            }
-            // Run TeammateIdle hooks
-            const teammateIdleGenerator = executeTeammateIdleHooks(teammateName, teamName, permissionMode, toolUseContext.abortController.signal);
-            for await (const result of teammateIdleGenerator) {
-                if (result.message) {
-                    if (result.message.type === 'progress' && result.message.toolUseID) {
-                        teammateHookToolUseID = result.message.toolUseID;
-                    }
-                    yield result.message;
-                }
-                if (result.blockingError) {
-                    const userMessage = createUserMessage({
-                        content: getTeammateIdleHookMessage(result.blockingError),
-                        isMeta: true,
-                    });
-                    teammateBlockingErrors.push(userMessage);
-                    yield userMessage;
-                }
-                // Match Stop hook behavior: allow preventContinuation/stopReason
-                if (result.preventContinuation) {
-                    teammatePreventedContinuation = true;
-                    teammateStopReason =
-                        result.stopReason || 'TeammateIdle hook prevented continuation';
-                    yield createAttachmentMessage({
-                        type: 'hook_stopped_continuation',
-                        message: teammateStopReason,
-                        hookName: 'TeammateIdle',
-                        toolUseID: teammateHookToolUseID,
-                        hookEvent: 'TeammateIdle',
-                    });
-                }
-                if (toolUseContext.abortController.signal.aborted) {
-                    return { blockingErrors: [], preventContinuation: true };
-                }
-            }
-            if (teammatePreventedContinuation) {
-                return { blockingErrors: [], preventContinuation: true };
-            }
-            if (teammateBlockingErrors.length > 0) {
-                return {
-                    blockingErrors: teammateBlockingErrors,
-                    preventContinuation: false,
-                };
-            }
-        }
-        return { blockingErrors: [], preventContinuation: false };
-    }
-    catch (error) {
-        const durationMs = Date.now() - hookStartTime;
-        logEvent('tengu_stop_hook_error', {
-            duration: durationMs,
-            queryChainId: toolUseContext.queryTracking
-                ?.chainId,
-            queryDepth: toolUseContext.queryTracking?.depth,
-        });
-        // Yield a system message that is not visible to the model for the user
-        // to debug their hook.
-        yield createSystemMessage(`Stop hook failed: ${errorMessage(error)}`, 'warning');
-        return { blockingErrors: [], preventContinuation: false };
-    }
-}