@bike4mind/cli 0.2.82 → 0.4.0

package/dist/index.mjs

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
-import { n as useCliStore, t as selectActiveBackgroundAgents } from "./store-Dw1nZX2Y.mjs";
-import { A as DEFAULT_MAX_ITERATIONS, B as ReActAgent, C as loadContextFiles, D as generateCliTools, E as PermissionManager, F as setWebSocketToolExecutor, G as OAuthClient, H as CheckpointStore, I as OllamaBackend, J as searchCommands, K as hasFileReferences, L as buildCoreSystemPrompt, M as DEFAULT_THOROUGHNESS, N as clearFeatureModuleTools, O as ALWAYS_DENIED_FOR_AGENTS, P as registerFeatureModuleTools, Q as warmFileCache, R as buildSkillsPromptSection, S as extractCompactInstructions, T as getEnvironmentName, U as CommandHistoryStore, V as CustomCommandStore, W as SessionStore, X as formatFileSize, Y as mergeCommands, Z as searchFiles, _ as WebSocketLlmBackend, a as createCoordinateTaskTool, b as substituteArguments, c as createAgentDelegateTool, d as createSkillTool, f as parseAgentConfig, g as FallbackLlmBackend, h as WebSocketConnectionManager, i as createWriteTodosTool, j as DEFAULT_RETRY_CONFIG, k as DEFAULT_AGENT_MODEL, l as AgentStore, m as WebSocketToolExecutor, n as createFindDefinitionTool, o as createBackgroundAgentTools, p as ApiClient, q as processFileReferences, r as createTodoStore, s as BackgroundAgentManager, t as createGetFileStructureTool, u as SubagentOrchestrator, v as ServerLlmBackend, w as getApiUrl, x as formatStep, y as McpManager, z as isReadOnlyTool } from "./tools-C0eJHV0Y.mjs";
-import { Dt as validateJupyterKernelName, Ot as validateNotebookPath$1, g as ChatModels, m as CREDIT_DEDUCT_TRANSACTION_TYPES, n as logger, t as ConfigStore } from "./ConfigStore-DTyUBb3A.mjs";
-import { i as version, t as checkForUpdate } from "./updateChecker-CPr5OfMn.mjs";
+import { n as useCliStore, t as selectActiveBackgroundAgents } from "./store-B7-LLvvx.mjs";
+import { A as DEFAULT_MAX_ITERATIONS, B as ReActAgent, C as loadContextFiles, D as generateCliTools, E as PermissionManager, F as setWebSocketToolExecutor, G as OAuthClient, H as CheckpointStore, I as OllamaBackend, J as searchCommands, K as hasFileReferences, L as buildCoreSystemPrompt, M as DEFAULT_THOROUGHNESS, N as clearFeatureModuleTools, O as ALWAYS_DENIED_FOR_AGENTS, P as registerFeatureModuleTools, Q as warmFileCache, R as buildSkillsPromptSection, S as extractCompactInstructions, T as getEnvironmentName, U as CommandHistoryStore, V as CustomCommandStore, W as SessionStore, X as formatFileSize, Y as mergeCommands, Z as searchFiles, _ as WebSocketLlmBackend, a as createCoordinateTaskTool, b as substituteArguments, c as createAgentDelegateTool, d as createSkillTool, f as parseAgentConfig, g as FallbackLlmBackend, h as WebSocketConnectionManager, i as createWriteTodosTool, j as DEFAULT_RETRY_CONFIG, k as DEFAULT_AGENT_MODEL, l as AgentStore, m as WebSocketToolExecutor, n as createFindDefinitionTool, o as createBackgroundAgentTools, p as ApiClient, q as processFileReferences, r as createTodoStore, s as BackgroundAgentManager, t as createGetFileStructureTool, u as SubagentOrchestrator, v as ServerLlmBackend, w as getApiUrl, x as formatStep, y as McpManager, z as isReadOnlyTool } from "./tools-DiSJh1Dv.mjs";
+import { Mt as validateNotebookPath$1, g as ChatModels, jt as validateJupyterKernelName, m as CREDIT_DEDUCT_TRANSACTION_TYPES, n as logger, t as ConfigStore } from "./ConfigStore-DBUmvCfe.mjs";
+import { i as version, t as checkForUpdate } from "./updateChecker-DcJC1C8S.mjs";
 import React, { useCallback, useEffect, useMemo, useReducer, useRef, useState } from "react";
 import { Box, Static, Text, render, useApp, useInput } from "ink";
 import { execSync } from "child_process";
 import { randomBytes, randomUUID } from "crypto";
 import { existsSync, promises, readFileSync, statSync } from "fs";
 import { homedir } from "os";
-import path, { extname } from "path";
+import path, { basename, extname, join } from "path";
 import { v4 } from "uuid";
 import * as path$1 from "node:path";
 import Spinner from "ink-spinner";
@@ -1980,14 +1980,14 @@ function App({ onMessage, onBackgroundCompletion, onCommand, onBashCommand, onPe
 		args: permissionPrompt.args,
 		preview: permissionPrompt.preview,
 		canBeTrusted: permissionPrompt.canBeTrusted,
-		onResponse: onPermissionResponse
+		onResponse: (response) => onPermissionResponse(response, permissionPrompt.id)
 	})), userQuestionPrompt && /* @__PURE__ */ React.createElement(Box, {
 		key: userQuestionPrompt.id,
 		flexDirection: "column",
 		paddingX: 1
 	}, /* @__PURE__ */ React.createElement(UserQuestionPrompt, {
 		payload: userQuestionPrompt.payload,
-		onResponse: onUserQuestionResponse
+		onResponse: (response) => onUserQuestionResponse(response, userQuestionPrompt.id)
 	})), !permissionPrompt && !userQuestionPrompt && /* @__PURE__ */ React.createElement(AgentThinking, null), /* @__PURE__ */ React.createElement(BackgroundAgentStatus, null), /* @__PURE__ */ React.createElement(CompletedGroupNotification, null), exitRequested && /* @__PURE__ */ React.createElement(Box, {
 		paddingX: 1,
 		marginBottom: 1
@@ -3439,6 +3439,27 @@ var TavernService = class {
 	async abortHeartbeats() {
 		await this.apiClient.post("/api/tavern/abort-heartbeats", { abort: true });
 	}
+	async getQuestPlan(planId) {
+		return this.apiClient.get(`/api/quest-master-plans/${encodeURIComponent(planId)}`);
+	}
+	async updateReviewGate(planId, questId, subQuestId, reviewStatus, reviewNote) {
+		return this.apiClient.post(`/api/quest-master-plans/${encodeURIComponent(planId)}/review-gate`, {
+			questId,
+			subQuestId,
+			reviewStatus,
+			reviewNote
+		});
+	}
+	async updateSubQuestProgress(planId, questId, subQuestId, updates) {
+		return this.apiClient.post(`/api/quest-master-plans/${encodeURIComponent(planId)}/subquest-progress`, {
+			questId,
+			subQuestId,
+			...updates
+		});
+	}
+	async updateHandoff(planId, handoff) {
+		return this.apiClient.post(`/api/quest-master-plans/${encodeURIComponent(planId)}/handoff`, handoff);
+	}
 };
 //#endregion
 //#region src/features/tavern/types.ts
@@ -3626,6 +3647,109 @@ z.object({
 		error: z.string().optional()
 	}))
 });
+/** Sub-quest within a quest */
+const SubQuestSchema = z.object({
+	id: z.string(),
+	title: z.string(),
+	status: z.enum([
+		"not_started",
+		"in_progress",
+		"completed",
+		"skipped",
+		"deleted"
+	]),
+	questId: z.string().optional(),
+	startedAt: z.number().optional(),
+	evidence: z.string().optional(),
+	reviewGate: z.boolean().optional(),
+	reviewStatus: z.enum([
+		"pending",
+		"approved",
+		"rejected"
+	]).optional(),
+	reviewNote: z.string().optional()
+});
+/** Quest containing sub-quests */
+const QuestDataSchema = z.object({
+	id: z.string(),
+	title: z.string(),
+	description: z.string(),
+	complexity: z.string(),
+	subQuests: z.array(SubQuestSchema)
+});
+/** Handoff state for session continuity */
+const HandoffSchema = z.object({
+	summary: z.string(),
+	nextSteps: z.array(z.string()),
+	pendingDecisions: z.array(z.string()),
+	blockers: z.array(z.string()),
+	lastUpdatedBy: z.string(),
+	updatedAt: z.string()
+});
+z.object({
+	_id: z.string(),
+	notebookId: z.string(),
+	goal: z.string(),
+	quests: z.array(QuestDataSchema),
+	state: z.enum([
+		"draft",
+		"active",
+		"paused",
+		"completed",
+		"archived"
+	]).optional(),
+	handoff: HandoffSchema.optional(),
+	metrics: z.object({
+		totalTimeSpent: z.number(),
+		completionRate: z.number(),
+		subQuestsCompleted: z.number(),
+		subQuestsTotal: z.number(),
+		lastProgress: z.string().optional()
+	}).optional()
+});
+z.object({
+	planId: z.string(),
+	questId: z.string(),
+	subQuestId: z.string(),
+	reviewStatus: z.enum([
+		"pending",
+		"approved",
+		"rejected"
+	]),
+	reviewNote: z.string().optional()
+});
+z.object({
+	planId: z.string(),
+	questId: z.string(),
+	subQuestId: z.string(),
+	status: z.enum([
+		"not_started",
+		"in_progress",
+		"completed",
+		"skipped",
+		"deleted"
+	]).optional(),
+	evidence: z.string().optional(),
+	timeSpent: z.number().optional()
+});
+z.object({
+	planId: z.string(),
+	summary: z.string(),
+	nextSteps: z.array(z.string()),
+	pendingDecisions: z.array(z.string()),
+	blockers: z.array(z.string())
+});
+z.object({
+	success: z.boolean(),
+	plan: z.unknown().optional(),
+	metrics: z.object({
+		totalTimeSpent: z.number(),
+		completionRate: z.number(),
+		subQuestsCompleted: z.number(),
+		subQuestsTotal: z.number(),
+		lastProgress: z.string().optional()
+	}).optional()
+});
 //#endregion
 //#region src/features/tavern/TavernActivityStream.ts
 /**
@@ -3660,6 +3784,39 @@ var TavernActivityStream = class {
 };
 //#endregion
 //#region src/features/tavern/tavernTools.ts
+const GetQuestPlanParamsSchema = z.object({ plan_id: z.string().min(1) });
+const UpdateReviewGateParamsSchema = z.object({
+	plan_id: z.string().min(1),
+	quest_id: z.string().min(1),
+	sub_quest_id: z.string().min(1),
+	review_status: z.enum([
+		"pending",
+		"approved",
+		"rejected"
+	]),
+	review_note: z.string().optional()
+});
+const UpdateQuestProgressParamsSchema = z.object({
+	plan_id: z.string().min(1),
+	quest_id: z.string().min(1),
+	sub_quest_id: z.string().min(1),
+	status: z.enum([
+		"not_started",
+		"in_progress",
+		"completed",
+		"skipped",
+		"deleted"
+	]).optional(),
+	evidence: z.string().optional(),
+	time_spent: z.number().min(0).optional()
+});
+const WriteHandoffParamsSchema = z.object({
+	plan_id: z.string().min(1),
+	summary: z.string().min(1),
+	next_steps: z.array(z.string()),
+	pending_decisions: z.array(z.string()),
+	blockers: z.array(z.string())
+});
 /**
 * Factory that creates ICompletionOptionTools[] for the Tavern feature.
 *
@@ -3682,7 +3839,11 @@ function createTavernTools(service) {
 		createToggleHeartbeatsTool(service),
 		createTriggerHeartbeatTool(service),
 		createAbortHeartbeatsTool(service),
-		createStatusTool(service)
+		createStatusTool(service),
+		createGetQuestPlanTool(service),
+		createUpdateReviewGateTool(service),
+		createUpdateQuestProgressTool(service),
+		createWriteHandoffTool(service)
 	];
 }
 function createListAgentsTool(service) {
@@ -4211,6 +4372,187 @@ function createStatusTool(service) {
 		}
 	};
 }
+function createGetQuestPlanTool(service) {
+	return {
+		toolSchema: {
+			name: "tavern_get_quest_plan",
+			description: "Fetch a quest master plan by ID. Returns the full plan with all quests, sub-quests, review gate status, handoff state, and progress metrics. Use this to check which sub-quests have review gates and their current status.",
+			parameters: {
+				type: "object",
+				properties: { plan_id: {
+					type: "string",
+					description: "The MongoDB ObjectId of the quest master plan"
+				} },
+				required: ["plan_id"]
+			}
+		},
+		toolFn: async (params) => {
+			const { plan_id } = GetQuestPlanParamsSchema.parse(params);
+			const result = await service.getQuestPlan(plan_id);
+			return JSON.stringify(result);
+		}
+	};
+}
+function createUpdateReviewGateTool(service) {
+	return {
+		toolSchema: {
+			name: "tavern_update_review_gate",
+			description: "Approve or reject a review gate on a sub-quest. Review gates are human approval checkpoints — when a sub-quest has reviewGate: true, the AI must stop and wait for human approval before proceeding.",
+			parameters: {
+				type: "object",
+				properties: {
+					plan_id: {
+						type: "string",
+						description: "The MongoDB ObjectId of the quest master plan"
+					},
+					quest_id: {
+						type: "string",
+						description: "The ID of the parent quest"
+					},
+					sub_quest_id: {
+						type: "string",
+						description: "The ID of the sub-quest with the review gate"
+					},
+					review_status: {
+						type: "string",
+						description: "The review decision",
+						enum: [
+							"pending",
+							"approved",
+							"rejected"
+						]
+					},
+					review_note: {
+						type: "string",
+						description: "Optional note explaining the review decision"
+					}
+				},
+				required: [
+					"plan_id",
+					"quest_id",
+					"sub_quest_id",
+					"review_status"
+				]
+			}
+		},
+		toolFn: async (params) => {
+			const { plan_id, quest_id, sub_quest_id, review_status, review_note } = UpdateReviewGateParamsSchema.parse(params);
+			const result = await service.updateReviewGate(plan_id, quest_id, sub_quest_id, review_status, review_note);
+			return JSON.stringify(result);
+		}
+	};
+}
+function createUpdateQuestProgressTool(service) {
+	return {
+		toolSchema: {
+			name: "tavern_update_quest_progress",
+			description: "Update a sub-quest's progress. Set status to track completion, add evidence of what was accomplished, and optionally record time spent. Setting status to \"in_progress\" auto-resumes a paused plan.",
+			parameters: {
+				type: "object",
+				properties: {
+					plan_id: {
+						type: "string",
+						description: "The MongoDB ObjectId of the quest master plan"
+					},
+					quest_id: {
+						type: "string",
+						description: "The ID of the parent quest"
+					},
+					sub_quest_id: {
+						type: "string",
+						description: "The ID of the sub-quest to update"
+					},
+					status: {
+						type: "string",
+						description: "New status for the sub-quest",
+						enum: [
+							"not_started",
+							"in_progress",
+							"completed",
+							"skipped",
+							"deleted"
+						]
+					},
+					evidence: {
+						type: "string",
+						description: "Evidence of completion — links to artifacts, descriptions of output, or references to results"
+					},
+					time_spent: {
+						type: "number",
+						description: "Time spent on this sub-quest in milliseconds"
+					}
+				},
+				required: [
+					"plan_id",
+					"quest_id",
+					"sub_quest_id"
+				]
+			}
+		},
+		toolFn: async (params) => {
+			const { plan_id, quest_id, sub_quest_id, status, evidence, time_spent } = UpdateQuestProgressParamsSchema.parse(params);
+			const updates = {};
+			if (status !== void 0) updates.status = status;
+			if (evidence !== void 0) updates.evidence = evidence;
+			if (time_spent !== void 0) updates.timeSpent = time_spent;
+			const result = await service.updateSubQuestProgress(plan_id, quest_id, sub_quest_id, updates);
+			return JSON.stringify(result);
+		}
+	};
+}
+function createWriteHandoffTool(service) {
+	return {
+		toolSchema: {
+			name: "tavern_write_handoff",
+			description: "Write a handoff state for session continuity. Called when ending a session so the next session can resume with full context. Includes a summary of progress, next steps, pending decisions, and blockers.",
+			parameters: {
+				type: "object",
+				properties: {
+					plan_id: {
+						type: "string",
+						description: "The MongoDB ObjectId of the quest master plan"
+					},
+					summary: {
+						type: "string",
+						description: "Summary of what was accomplished in this session"
+					},
+					next_steps: {
+						type: "array",
+						items: { type: "string" },
+						description: "List of next steps for the following session"
+					},
+					pending_decisions: {
+						type: "array",
+						items: { type: "string" },
+						description: "Decisions that still need to be made"
+					},
+					blockers: {
+						type: "array",
+						items: { type: "string" },
+						description: "Current blockers preventing progress"
+					}
+				},
+				required: [
+					"plan_id",
+					"summary",
+					"next_steps",
+					"pending_decisions",
+					"blockers"
+				]
+			}
+		},
+		toolFn: async (params) => {
+			const { plan_id, summary, next_steps, pending_decisions, blockers } = WriteHandoffParamsSchema.parse(params);
+			const result = await service.updateHandoff(plan_id, {
+				summary,
+				nextSteps: next_steps,
+				pendingDecisions: pending_decisions,
+				blockers
+			});
+			return JSON.stringify(result);
+		}
+	};
+}
 //#endregion
 //#region src/features/tavern/TavernModule.ts
 /** Icons for heartbeat log actions shown in /tavern command */
@@ -4274,9 +4616,23 @@ Available actions:
 - **tavern_trigger_heartbeat**: Manually trigger a heartbeat cycle
 - **tavern_abort_heartbeats**: Emergency stop all in-flight heartbeats
 - **tavern_status**: Quick overview of agents, quests, and gates — good for situational awareness
+- **tavern_get_quest_plan**: Fetch a quest master plan with review gate status and handoff state
+- **tavern_update_review_gate**: Approve or reject a review gate on a sub-quest
+- **tavern_update_quest_progress**: Update sub-quest status and record evidence of completion
+- **tavern_write_handoff**: Write session handoff for continuity across sessions
 
 When the user mentions talking to agents, checking the quest board, or managing the tavern, use these tools.
-Agents have personalities, moods, quests, and memories — they are autonomous entities, not chatbots.`;
+Agents have personalities, moods, quests, and memories — they are autonomous entities, not chatbots.
+
+## Quest Workflow (Review Gates)
+When working on a quest plan with review gates (reviewGate: true on sub-quests), you MUST:
+1. Check review gate status with tavern_get_quest_plan before proceeding past a gated step
+2. If the next sub-quest has reviewGate: true and reviewStatus is not 'approved', STOP and inform the user
+3. Record evidence of completion with tavern_update_quest_progress when finishing a sub-quest
+4. Write a handoff with tavern_write_handoff before ending a session with an active quest plan
+
+## Session Handoff & Resume
+When the user runs /quest resume <plan_id>, read the handoff context and continue from where the previous session left off. The handoff contains: summary of prior work, next steps, pending decisions, and blockers.`;
 	}
 	getCommands() {
 		return [{
@@ -4301,6 +4657,95 @@ Agents have personalities, moods, quests, and memories — they are autonomous e
 				}
 				console.log("");
 			}
+		}, {
+			name: "quest",
+			description: "Quest workflow commands: review gates, resume from handoff",
+			execute: async (args) => {
+				const subCommand = args[0];
+				if (subCommand === "resume") {
+					const planId = args[1];
+					if (!planId) {
+						console.log("\nUsage: /quest resume <plan_id>");
+						console.log("  Loads the quest plan and displays the session handoff for continuity.\n");
+						return;
+					}
+					try {
+						const plan = await this.service.getQuestPlan(planId);
+						console.log(`\nQuest Plan: ${plan.goal}`);
+						console.log(`State: ${plan.state ?? "unknown"}`);
+						if (plan.metrics) {
+							const pct = Math.round(plan.metrics.completionRate * 100);
+							console.log(`Progress: ${plan.metrics.subQuestsCompleted}/${plan.metrics.subQuestsTotal} sub-quests (${pct}%)`);
+						}
+						if (!plan.handoff) {
+							console.log("\n  No handoff found — this plan has no saved session context.");
+							console.log("  The AI can still read the plan via tavern_get_quest_plan.\n");
+							return;
+						}
+						const { handoff } = plan;
+						console.log(`\nSession Handoff (${new Date(handoff.updatedAt).toLocaleString()}):`);
+						console.log(`\n  Summary: ${handoff.summary}`);
+						if (handoff.nextSteps.length > 0) {
+							console.log("\n  Next Steps:");
+							for (const step of handoff.nextSteps) console.log(`    \u2022 ${step}`);
+						}
+						if (handoff.pendingDecisions.length > 0) {
+							console.log("\n  Pending Decisions:");
+							for (const decision of handoff.pendingDecisions) console.log(`    \u2753 ${decision}`);
+						}
+						if (handoff.blockers.length > 0) {
+							console.log("\n  Blockers:");
+							for (const blocker of handoff.blockers) console.log(`    \u{1F6D1} ${blocker}`);
+						}
+						console.log("");
+					} catch (error) {
+						const message = error instanceof Error ? error.message : String(error);
+						console.log(`\nError fetching quest plan: ${message}\n`);
+					}
+					return;
+				}
+				if (subCommand === "review") {
+					const planId = args[1];
+					if (!planId) {
+						console.log("\nUsage: /quest review <plan_id>");
+						console.log("  Fetches the quest plan and shows sub-quests with pending review gates.\n");
+						return;
+					}
+					try {
+						const plan = await this.service.getQuestPlan(planId);
+						const pendingGates = [];
+						for (const quest of plan.quests) for (const sq of quest.subQuests) if (sq.reviewGate) pendingGates.push({
+							questTitle: quest.title,
+							questId: quest.id,
+							subQuestTitle: sq.title,
+							subQuestId: sq.id,
+							status: sq.reviewStatus ?? "pending"
+						});
+						if (pendingGates.length === 0) {
+							console.log(`\nQuest Plan: ${plan.goal}`);
+							console.log("  No review gates configured in this plan.\n");
+							return;
+						}
+						console.log(`\nQuest Plan: ${plan.goal}`);
+						console.log(`State: ${plan.state ?? "unknown"}\n`);
+						console.log("Review Gates:");
+						for (const gate of pendingGates) {
+							const icon = gate.status === "approved" ? "✅" : gate.status === "rejected" ? "❌" : "⏸️";
+							console.log(`  ${icon} [${gate.status}] ${gate.questTitle} > ${gate.subQuestTitle}`);
+							console.log(`     quest_id: ${gate.questId}  sub_quest_id: ${gate.subQuestId}`);
+						}
+						console.log("\n  To approve: ask the AI to approve a review gate, or use tavern_update_review_gate tool.\n");
+					} catch (error) {
+						const message = error instanceof Error ? error.message : String(error);
+						console.log(`\nError fetching quest plan: ${message}\n`);
+					}
+					return;
+				}
+				console.log("\nUsage:");
+				console.log("  /quest review <plan_id>  — Show review gates and their status");
+				console.log("  /quest resume <plan_id>  — Load handoff and resume from where you left off");
+				console.log("");
+			}
 		}];
 	}
 	registerWsHandlers(wsManager) {
@@ -4311,6 +4756,224 @@ Agents have personalities, moods, quests, and memories — they are autonomous e
 	}
 };
 //#endregion
+//#region src/features/bridgePresence/BridgePresence.ts
+const DEFAULT_PORT = Number(process.env.CC_BRIDGE_PORT ?? 48732);
+const CONFIG_PATH = join(homedir(), ".b4m", "cc-bridge.json");
+const ANNOUNCE_TIMEOUT_MS = 2e3;
+async function readBridgeConfig() {
+	try {
+		const raw = await promises.readFile(CONFIG_PATH, "utf8");
+		const parsed = JSON.parse(raw);
+		if (typeof parsed.hookSecret !== "string" || !parsed.hookSecret) return null;
+		return {
+			port: typeof parsed.port === "number" ? parsed.port : DEFAULT_PORT,
+			hookSecret: parsed.hookSecret
+		};
+	} catch {
+		return null;
+	}
+}
+var BridgePresence = class {
+	constructor() {
+		this.config = null;
+		this.instanceId = null;
+		this.ws = null;
+		this.callbacks = {};
+		this.started = false;
+		this.stopped = false;
+		this.reconnectTimer = null;
+		this.reconnectAttempts = 0;
+		this.announceRetryTimer = null;
+		this.announceAttempts = 0;
+		this.startOpts = null;
+		this.pendingWorkspaceName = null;
+		this.pendingCapabilities = null;
+		this.pendingSource = null;
+		this.emitQueue = Promise.resolve();
+	}
+	setCallbacks(cbs) {
+		this.callbacks = cbs;
+	}
+	/**
+	* Probe the local bridge and, if present, announce this CLI session.
+	* Returns true iff the announce succeeded (tavern presence is active).
+	* Safe to call multiple times — second call no-ops.
+	*
+	* If announce fails (bridge absent or not yet up), a background retry
+	* loop keeps trying with bounded backoff so the sprite appears when the
+	* bridge comes online later in the CLI's lifetime.
+	*/
+	async start(opts) {
+		if (this.started) return this.instanceId !== null;
+		this.started = true;
+		const config = await readBridgeConfig();
+		if (!config) {
+			logger.debug("[tavern] cc-bridge not configured; CLI runs without tavern presence");
+			return false;
+		}
+		this.config = config;
+		this.startOpts = opts;
+		this.pendingWorkspaceName = opts.workspaceName ?? (basename(opts.workspacePath) || "workspace");
+		this.pendingCapabilities = opts.capabilities ?? ["interactive"];
+		this.pendingSource = opts.source ?? "b4m-cli";
+		return this.attemptAnnounce();
+	}
+	/** One announce attempt. Schedules a retry on failure; wires up the
+	*  command WS + initial status on success. Idempotent: re-entering after
+	*  a successful announce short-circuits at the instanceId guard. */
+	async attemptAnnounce() {
+		if (this.stopped || !this.config || !this.startOpts) return false;
+		if (this.instanceId) return true;
+		const instanceId = v4();
+		const workspaceName = this.pendingWorkspaceName;
+		const capabilities = this.pendingCapabilities;
+		const source = this.pendingSource;
+		if (!await this.announce({
+			instanceId,
+			source,
+			workspaceName,
+			workspacePath: this.startOpts.workspacePath,
+			capabilities
+		})) {
+			this.scheduleAnnounceRetry();
+			return false;
+		}
+		this.instanceId = instanceId;
+		this.announceAttempts = 0;
+		logger.info(`[tavern] announced ${workspaceName} to cc-bridge on 127.0.0.1:${this.config.port ?? DEFAULT_PORT}`);
+		this.connectCommandWs();
+		this.emitEvent({
+			type: "status",
+			status: "idle"
+		});
+		return true;
+	}
+	scheduleAnnounceRetry() {
+		if (this.stopped || this.announceRetryTimer) return;
+		this.announceAttempts += 1;
+		const delay = Math.min(1e3 * 2 ** (this.announceAttempts - 1), 3e4);
+		this.announceRetryTimer = setTimeout(() => {
+			this.announceRetryTimer = null;
+			this.attemptAnnounce();
+		}, delay);
+	}
+	/** Emit an event for this session. No-op if the bridge isn't up. Events
+	*  leave in strict order — see `emitQueue` comment. */
+	async emitEvent(event) {
+		if (!this.config || !this.instanceId) return;
+		const task = () => this.post("/event", {
+			instanceId: this.instanceId,
+			event
+		}).catch((err) => logger.info(`[tavern] emitEvent ${event.type} failed: ${err.message}`));
+		this.emitQueue = this.emitQueue.then(task, task);
+		return this.emitQueue;
+	}
+	/** Tear down the tavern presence cleanly. */
+	async stop(reason = "cli_exit") {
+		if (this.stopped) return;
+		this.stopped = true;
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+		if (this.announceRetryTimer) {
+			clearTimeout(this.announceRetryTimer);
+			this.announceRetryTimer = null;
+		}
+		if (this.ws) {
+			try {
+				this.ws.close();
+			} catch {}
+			this.ws = null;
+		}
+		if (this.config && this.instanceId) await this.post("/disconnect", {
+			instanceId: this.instanceId,
+			reason
+		}).catch(() => {});
+	}
+	async announce(body) {
+		try {
+			await this.post("/announce", body);
+			return true;
+		} catch (err) {
+			logger.info(`[tavern] bridge announce failed: ${err.message}`);
+			return false;
+		}
+	}
+	async post(path, body) {
+		if (!this.config) throw new Error("bridge config not loaded");
+		const url = `http://127.0.0.1:${this.config.port ?? DEFAULT_PORT}${path}?secret=${encodeURIComponent(this.config.hookSecret)}`;
+		const res = await fetch(url, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body),
+			signal: AbortSignal.timeout(ANNOUNCE_TIMEOUT_MS)
+		});
+		if (!res.ok) throw new Error(`bridge ${path} -> ${res.status}`);
+	}
+	connectCommandWs() {
+		if (this.stopped || !this.config || !this.instanceId) return;
+		const url = `ws://127.0.0.1:${this.config.port ?? DEFAULT_PORT}/commands?instanceId=${encodeURIComponent(this.instanceId)}&secret=${encodeURIComponent(this.config.hookSecret)}`;
+		let ws;
+		try {
+			ws = new WsWebSocket(url);
+		} catch (err) {
+			logger.debug(`[tavern] command WS construct failed: ${err.message}`);
+			this.scheduleReconnect();
+			return;
+		}
+		this.ws = ws;
+		ws.on("open", () => {
+			this.reconnectAttempts = 0;
+			logger.debug("[tavern] command WS open");
+		});
+		ws.on("message", (raw) => {
+			let frame = null;
+			try {
+				frame = JSON.parse(raw.toString());
+			} catch {
+				logger.debug("[tavern] malformed command frame; ignored");
+				return;
+			}
+			if (!frame?.command) return;
+			this.dispatchCommand(frame.command).catch((err) => logger.warn(`[tavern] command dispatch threw: ${err.message}`));
+		});
+		ws.on("close", () => {
+			this.ws = null;
+			if (this.stopped) return;
+			logger.debug("[tavern] command WS closed; reconnecting");
+			this.scheduleReconnect();
+		});
+		ws.on("error", (err) => {
+			logger.debug(`[tavern] command WS error: ${err.message}`);
+		});
+	}
+	scheduleReconnect() {
+		if (this.stopped || this.reconnectTimer) return;
+		this.reconnectAttempts += 1;
+		const delay = Math.min(500 * 2 ** (this.reconnectAttempts - 1), 1e4);
+		this.reconnectTimer = setTimeout(() => {
+			this.reconnectTimer = null;
+			this.connectCommandWs();
+		}, delay);
+	}
+	async dispatchCommand(command) {
+		switch (command.type) {
+			case "send_prompt":
+				if (this.callbacks.onSendPrompt) await this.callbacks.onSendPrompt(command.text);
+				break;
+			case "resolve_permission":
+				if (this.callbacks.onResolvePermission) await this.callbacks.onResolvePermission(command.requestId, command.allow);
+				break;
+			case "abort":
+				if (this.callbacks.onAbort) await this.callbacks.onAbort();
+				break;
+		}
+	}
+};
+/** Process-wide singleton — the CLI only ever has one tavern presence per run. */
+const bridgePresence = new BridgePresence();
+//#endregion
 //#region src/index.tsx
 process.removeAllListeners("warning");
 process.on("warning", (warning) => {
@@ -4326,6 +4989,16 @@ function getRequiredJupyterClient() {
 	if (!client) throw new Error("Jupyter not configured. Set JUPYTER_SERVER_URL and optionally JUPYTER_TOKEN environment variables.");
 	return client;
 }
+/**
+* Render the first question from a UserQuestion payload as a 240-char-capped
+* summary for tavern status events. Returns undefined if the payload has no
+* questions (defensive: payload.questions[0]?.question is typed string but
+* the array itself can be empty).
+*/
+function summarizeUserQuestion(payload) {
+	const first = payload.questions?.[0]?.question;
+	return first ? first.slice(0, 240) : void 0;
+}
 let exitTimestamp = null;
 const EXIT_TIMEOUT_MS = 2e3;
 let usageCache = null;
@@ -4365,7 +5038,6 @@ function CliApp() {
 	const imageStoreInitPromise = useRef(null);
 	const setStoreSession = useCliStore((state) => state.setSession);
 	const enqueuePermissionPrompt = useCliStore((state) => state.enqueuePermissionPrompt);
-	const dequeuePermissionPrompt = useCliStore((state) => state.dequeuePermissionPrompt);
 	const enqueueUserQuestionPrompt = useCliStore((state) => state.enqueueUserQuestionPrompt);
 	const dequeueUserQuestionPrompt = useCliStore((state) => state.dequeueUserQuestionPrompt);
 	const setShowConfigEditor = useCliStore((state) => state.setShowConfigEditor);
@@ -4384,6 +5056,9 @@ function CliApp() {
 			state.wsManager.disconnect();
 			setWebSocketToolExecutor(null);
 		}
+		cleanupTasks.push(bridgePresence.stop("cli_exit").catch((err) => {
+			logger.debug(`[CLEANUP] Bridge presence stop error: ${err.message}`);
+		}));
 		if (state.agent) state.agent.removeAllListeners();
 		if (state.imageStore) try {
 			state.imageStore.close();
@@ -4486,10 +5161,12 @@ function CliApp() {
 			};
 			let wsManager = null;
 			let llm;
+			let completionsUrl;
 			try {
 				const serverConfig = await apiClient.get("/api/settings/serverConfig");
 				const wsUrl = serverConfig?.websocketUrl;
 				const wsCompletionUrl = serverConfig?.wsCompletionUrl;
+				completionsUrl = serverConfig?.completionsUrl;
 				if (wsUrl && wsCompletionUrl) {
 					wsManager = new WebSocketConnectionManager(wsUrl, tokenGetter);
 					await wsManager.connect();
@@ -4605,7 +5282,8 @@ function CliApp() {
 				setWebSocketToolExecutor(null);
 				llm = new ServerLlmBackend({
 					apiClient,
-					model: config.defaultModel
+					model: config.defaultModel,
+					completionsUrl
 				});
 			}
 			const ollamaHost = process.env.B4M_OLLAMA_HOST;
@@ -4700,8 +5378,9 @@ function CliApp() {
 			const promptFn = (toolName, args, preview) => {
 				return new Promise((resolve) => {
 					const canBeTrusted = permissionManager.canBeTrusted(toolName);
+					const id = `perm-${++permissionPromptCounter}`;
 					const prompt = {
-						id: `perm-${++permissionPromptCounter}`,
+						id,
 						toolName,
 						args,
 						preview,
@@ -4713,6 +5392,24 @@ function CliApp() {
 						permissionManager
 					}));
 					enqueuePermissionPrompt(prompt);
+					let summary;
+					if (preview) summary = preview.slice(0, 4e3);
+					else try {
+						summary = JSON.stringify(args).slice(0, 4e3);
+					} catch {
+						summary = void 0;
+					}
+					bridgePresence.emitEvent({
+						type: "permission_request",
+						requestId: id,
+						toolName,
+						input: summary
+					});
+					bridgePresence.emitEvent({
+						type: "status",
+						status: "awaiting_permission",
+						text: `${toolName} permission requested`.slice(0, 240)
+					});
 				});
 			};
 			let userQuestionCounter = 0;
@@ -4723,6 +5420,11 @@ function CliApp() {
 						payload,
 						resolve
 					});
+					bridgePresence.emitEvent({
+						type: "status",
+						status: "awaiting_input",
+						text: summarizeUserQuestion(payload)
+					});
 				});
 			};
 			const agentContext = {
@@ -4878,6 +5580,82 @@ function CliApp() {
 				subagent.off("observation", stepHandler);
 				subagent.off("action", stepHandler);
 			});
+			const pendingToolUseIds = /* @__PURE__ */ new Map();
+			const summarizeToolInput = (input) => {
+				if (input == null) return void 0;
+				if (typeof input === "string") return input.slice(0, 240);
+				try {
+					return JSON.stringify(input).slice(0, 240);
+				} catch {
+					return;
+				}
+			};
+			const tavernActionHandler = (step) => {
+				const toolName = step.metadata?.toolName ?? "tool";
+				const toolUseId = `${toolName}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+				const queue = pendingToolUseIds.get(toolName) ?? [];
+				queue.push(toolUseId);
+				pendingToolUseIds.set(toolName, queue);
+				bridgePresence.emitEvent({
+					type: "tool_use",
+					tool: toolName,
+					toolUseId,
+					text: summarizeToolInput(step.metadata?.toolInput)
+				});
+			};
+			const tavernObservationHandler = (step) => {
+				const toolName = step.metadata?.toolName;
+				let toolUseId;
+				if (toolName) {
+					const queue = pendingToolUseIds.get(toolName);
+					if (queue && queue.length > 0) {
+						toolUseId = queue.shift();
+						if (queue.length === 0) pendingToolUseIds.delete(toolName);
+					}
+				}
+				if (!toolUseId) {
+					for (const [name, queue] of pendingToolUseIds.entries()) if (queue.length > 0) {
+						toolUseId = queue.shift();
+						if (queue.length === 0) pendingToolUseIds.delete(name);
+						break;
+					}
+				}
+				if (!toolUseId) toolUseId = `orphan-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+				bridgePresence.emitEvent({
+					type: "tool_result",
+					tool: toolName,
+					toolUseId,
+					text: typeof step.content === "string" ? step.content.slice(0, 4e3) : void 0
+				});
+			};
+			const tavernFinalAnswerHandler = (step) => {
+				const text = typeof step.content === "string" ? step.content : "";
+				if (!text) return;
+				bridgePresence.emitEvent({
+					type: "message",
+					role: "assistant",
+					text: text.slice(0, 4e3)
+				});
+			};
+			agent.on("action", tavernActionHandler);
+			agent.on("observation", tavernObservationHandler);
+			agent.on("final_answer", tavernFinalAnswerHandler);
+			orchestrator.setBeforeRunCallback((subagent, _subagentType) => {
+				subagent.on("thought", stepHandler);
+				subagent.on("observation", stepHandler);
+				subagent.on("action", stepHandler);
+				subagent.on("action", tavernActionHandler);
+				subagent.on("observation", tavernObservationHandler);
+				subagent.on("final_answer", tavernFinalAnswerHandler);
+			});
+			orchestrator.setAfterRunCallback((subagent, _subagentType) => {
+				subagent.off("thought", stepHandler);
+				subagent.off("observation", stepHandler);
+				subagent.off("action", stepHandler);
+				subagent.off("action", tavernActionHandler);
+				subagent.off("observation", tavernObservationHandler);
+				subagent.off("final_answer", tavernFinalAnswerHandler);
+			});
 			setState((prev) => ({
 				...prev,
 				session: newSession,
@@ -4969,6 +5747,60 @@ function CliApp() {
 	useEffect(() => {
 		init();
 	}, [init]);
+	const handleMessageRef = useRef(null);
+	const abortControllerRef = useRef(state.abortController);
+	abortControllerRef.current = state.abortController;
+	const emitNextAwaitingStatus = () => {
+		const s = useCliStore.getState();
+		if (s.permissionPrompt) {
+			bridgePresence.emitEvent({
+				type: "status",
+				status: "awaiting_permission",
+				text: `${s.permissionPrompt.toolName} permission requested`.slice(0, 240)
+			});
+			return;
+		}
+		if (s.userQuestionPrompt) {
+			bridgePresence.emitEvent({
+				type: "status",
+				status: "awaiting_input",
+				text: summarizeUserQuestion(s.userQuestionPrompt.payload)
+			});
+			return;
+		}
+		const abort = abortControllerRef.current;
+		if (!abort || abort.signal.aborted) return;
+		bridgePresence.emitEvent({
+			type: "status",
+			status: "running"
+		});
+	};
+	useEffect(() => {
+		if (!isInitialized) return;
+		let cancelled = false;
+		bridgePresence.setCallbacks({
+			onSendPrompt: (text) => handleMessageRef.current?.(text),
+			onAbort: () => abortControllerRef.current?.abort(),
+			onResolvePermission: (requestId, allow) => {
+				const action = allow ? "allow-once" : "deny";
+				if (!useCliStore.getState().resolvePermissionPromptById(requestId, action)) return;
+				bridgePresence.emitEvent({
+					type: "permission_resolved",
+					requestId,
+					allow,
+					resolvedBy: "user"
+				});
+				emitNextAwaitingStatus();
+			}
+		});
+		bridgePresence.start({ workspacePath: process.cwd() }).then((live) => {
+			if (cancelled) return;
+			if (live) logger.debug("[tavern] presence active");
+		}).catch((err) => logger.debug(`[tavern] start threw: ${err.message}`));
+		return () => {
+			cancelled = true;
+		};
+	}, [isInitialized]);
 	/**
 	* Handle custom command execution with proper display
 	* Shows concise user message but sends full template to agent
@@ -5188,6 +6020,16 @@ function CliApp() {
 			console.error("❌ CLI failed to initialize. Try restarting b4m.\n");
 			return;
 		}
+		bridgePresence.emitEvent({
+			type: "message",
+			role: "user",
+			text: message.slice(0, 4e3)
+		});
+		bridgePresence.emitEvent({
+			type: "status",
+			status: "running",
+			text: message.slice(0, 240)
+		});
 		await state.commandHistoryStore.add(message);
 		setCommandHistory(await state.commandHistoryStore.list());
 		const config = state.config;
@@ -5358,13 +6200,19 @@ function CliApp() {
 			console.error(`\n❌ ${errorMessage}\n`);
 			logger.debug(`Full error details: ${error instanceof Error ? error.stack || error.message : String(error)}`);
 		} finally {
+			const wasAborted = abortController.signal.aborted;
 			setState((prev) => ({
 				...prev,
 				abortController: null
 			}));
 			useCliStore.getState().setIsThinking(false);
+			bridgePresence.emitEvent({
+				type: "status",
+				status: wasAborted ? "idle" : "awaiting_input"
+			});
 		}
 	};
+	handleMessageRef.current = handleMessage;
 	/**
 	* Handle background agent completion - runs agent to process results silently
 	* without adding a user message to the conversation.
@@ -6857,19 +7705,22 @@ Multi-line Input:
 			}));
 		},
 		mcpManager: state.mcpManager ?? void 0,
-		onPermissionResponse: (response) => {
-			const currentPrompt = useCliStore.getState().permissionPrompt;
-			if (currentPrompt) {
-				currentPrompt.resolve({ action: response });
-				dequeuePermissionPrompt();
-			}
+		onPermissionResponse: (response, promptId) => {
+			if (!useCliStore.getState().resolvePermissionPromptById(promptId, response)) return;
+			bridgePresence.emitEvent({
+				type: "permission_resolved",
+				requestId: promptId,
+				allow: response !== "deny",
+				resolvedBy: "user"
+			});
+			emitNextAwaitingStatus();
 		},
-		onUserQuestionResponse: (response) => {
+		onUserQuestionResponse: (response, promptId) => {
 			const currentPrompt = useCliStore.getState().userQuestionPrompt;
-			if (currentPrompt) {
-				currentPrompt.resolve(response);
-				dequeueUserQuestionPrompt();
-			}
+			if (currentPrompt?.id !== promptId) return;
+			currentPrompt.resolve(response);
+			dequeueUserQuestionPrompt();
+			emitNextAwaitingStatus();
 		}
 	});
 }