@bike4mind/cli 0.4.0 → 0.6.0

package/dist/{ConfigStore-DBUmvCfe.mjs → ConfigStore-Dt6utdSA.mjs}

@@ -1027,6 +1027,8 @@ const SreRepoConfigSchema = z.object({
 	maxFixesPerDay: z.number().min(0).default(5),
 	/** Max revision attempts before escalating to human */
 	maxRevisions: z.number().int().min(0).max(10).default(2),
+	/** Max CI retry attempts before permanently failing (typecheck/apply-fix failures) */
+	maxCiRetries: z.number().int().min(0).max(3).default(1),
 	/** Log actions without dispatching */
 	dryRun: z.boolean().default(false),
 	/** Comma-separated GitHub usernames to request as PR reviewers */
@@ -1035,6 +1037,12 @@ const SreRepoConfigSchema = z.object({
 	defaultBranch: z.string().default(""),
 	/** Build command for the workflow */
 	buildCommand: z.string().default(""),
+	/**
+	* Repository-specific instructions for the Diagnostician (max 2,000 chars).
+	* For critical constraints that would cause broken fixes if unknown — e.g., "never modify X",
+	* "all DB calls must go through Y wrapper". Not for general coding conventions (use CLAUDE.md).
+	*/
+	sreInstructions: z.string().max(2e3).default(""),
 	/** Files the Surgeon can modify (glob patterns). Base patterns always merged in. */
 	allowedFilePatterns: z.array(z.string()).default([]),
 	/** Files never auto-fixed (glob patterns) */
@@ -1062,11 +1070,11 @@ const SreRepoConfigSchema = z.object({
 	/** Token budget per analysis */
 	tokenBudget: z.object({
 		maxInputTokens: z.number().default(5e4),
-		maxOutputTokens: z.number().default(8e3),
+		maxOutputTokens: z.number().default(16e3),
 		maxGithubApiCalls: z.number().default(20)
 	}).default({
 		maxInputTokens: 5e4,
-		maxOutputTokens: 8e3,
+		maxOutputTokens: 16e3,
 		maxGithubApiCalls: 20
 	}),
 	/** Error sources */
@@ -6280,6 +6288,49 @@ let FriendshipEvents = /* @__PURE__ */ function(FriendshipEvents) {
 	FriendshipEvents["FRIENDSHIP_CANCEL"] = "Friendship Cancelled";
 	return FriendshipEvents;
 }({});
+/**
+* Overwatch Analytics Event Schema
+*
+* Cross-product event schema for the Overwatch marketing command center.
+* Products (VibesWire, B4M, StocksAndVibes, K2Kanji) emit these events
+* to a shared SQS queue. Overwatch consumes them and rolls up DAU/WAU/MAU.
+*
+* Unlike the B4M-internal IBaseEvent analytics events, this schema is
+* designed for cross-product use with Zod validation at both emission
+* and consumption boundaries.
+*/
+const OverwatchUtmSchema = z.object({
+	source: z.string().max(128).optional(),
+	medium: z.string().max(128).optional(),
+	campaign: z.string().max(128).optional(),
+	content: z.string().max(128).optional()
+});
+z.object({
+	/** UUID for deduplication (SQS is at-least-once) */
+	eventId: z.string().uuid(),
+	/** Schema version for forward compatibility */
+	schemaVersion: z.number().int().positive(),
+	/** Product identifier: 'vibeswire', 'bike4mind', 'stocksandvibes', 'k2kanji', etc. */
+	productId: z.string().min(1).max(64),
+	/** Product's internal user ID */
+	userId: z.string().min(1).max(256),
+	/** Session identifier for retention/funnel analysis */
+	sessionId: z.string().min(1).max(256),
+	/** Event type: 'session_start', 'signup', 'feature_used', etc. */
+	event: z.string().min(1).max(128),
+	/** ISO 8601 timestamp */
+	timestamp: z.string().datetime(),
+	/** Where the user came from */
+	referrer: z.string().url().refine((url) => /^https?:\/\//i.test(url), "referrer must be an http or https URL").max(2048).optional(),
+	/** UTM attribution parameters */
+	utm: OverwatchUtmSchema.optional(),
+	/** Event-specific key-value data. Flat values only, max 1KB serialized. */
+	metadata: z.record(z.string(), z.union([
+		z.string(),
+		z.number(),
+		z.boolean()
+	])).refine((v) => JSON.stringify(v).length <= 1024, "metadata must be ≤ 1KB serialized").optional()
+});
 const InternalTeamMemberSchema = z.object({
 	name: z.string().min(1, "Name is required"),
 	phone: z.string().min(1, "Phone is required"),

package/dist/commands/doctorCommand.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { i as version, n as fetchLatestVersion, r as forceCheckForUpdate } from "../updateChecker-DcJC1C8S.mjs";
+import { i as version, n as fetchLatestVersion, r as forceCheckForUpdate } from "../updateChecker-DZXWZfKF.mjs";
 import { execSync } from "child_process";
 import { constants, existsSync, promises } from "fs";
 import { homedir } from "os";

package/dist/commands/headlessCommand.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { B as ReActAgent, C as loadContextFiles, D as generateCliTools, E as PermissionManager, F as setWebSocketToolExecutor, H as CheckpointStore, L as buildCoreSystemPrompt, V as CustomCommandStore, W as SessionStore, _ as WebSocketLlmBackend, a as createCoordinateTaskTool, c as createAgentDelegateTool, d as createSkillTool, g as FallbackLlmBackend, h as WebSocketConnectionManager, i as createWriteTodosTool, l as AgentStore, m as WebSocketToolExecutor, n as createFindDefinitionTool, o as createBackgroundAgentTools, p as ApiClient, r as createTodoStore, s as BackgroundAgentManager, t as createGetFileStructureTool, u as SubagentOrchestrator, v as ServerLlmBackend, w as getApiUrl, y as McpManager, z as isReadOnlyTool } from "../tools-DiSJh1Dv.mjs";
-import { n as logger, t as ConfigStore } from "../ConfigStore-DBUmvCfe.mjs";
+import { A as getApiUrl, C as WebSocketLlmBackend, G as isReadOnlyTool, J as CheckpointStore, K as ReActAgent, M as PermissionManager, N as generateCliTools, S as FallbackLlmBackend, T as McpManager, U as buildCoreSystemPrompt, V as setWebSocketToolExecutor, X as SessionStore, _ as createSkillTool, b as WebSocketToolExecutor, c as createFindDefinitionTool, d as createCoordinateTaskTool, f as createBackgroundAgentTools, g as SubagentOrchestrator, h as AgentStore, k as loadContextFiles, l as createTodoStore, m as createAgentDelegateTool, p as BackgroundAgentManager, q as CustomCommandStore, s as createGetFileStructureTool, u as createWriteTodosTool, w as ServerLlmBackend, x as WebSocketConnectionManager, y as ApiClient } from "../tools-dIVxi-6-.mjs";
+import { n as logger, t as ConfigStore } from "../ConfigStore-Dt6utdSA.mjs";
 import { t as DEFAULT_SANDBOX_CONFIG } from "../types-DBEjF9YS.mjs";
 import { t as createSandboxRuntime } from "../SandboxRuntimeAdapter-C1B4t20N.mjs";
 import { t as SandboxOrchestrator } from "../SandboxOrchestrator-BEW3rqYi.mjs";

package/dist/commands/mcpCommand.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as ConfigStore } from "../ConfigStore-DBUmvCfe.mjs";
+import { t as ConfigStore } from "../ConfigStore-Dt6utdSA.mjs";
 //#region src/commands/mcpCommand.ts
 /**
 * External MCP commands (b4m mcp list, b4m mcp add, etc.)

package/dist/commands/updateCommand.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { i as version, r as forceCheckForUpdate } from "../updateChecker-DcJC1C8S.mjs";
+import { i as version, r as forceCheckForUpdate } from "../updateChecker-DZXWZfKF.mjs";
 import { execSync } from "child_process";
 //#region src/commands/updateCommand.ts
 /**

package/dist/index.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 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 { $ as processFileReferences, A as getApiUrl, B as registerFeatureModuleTools, C as WebSocketLlmBackend, D as formatStep, E as substituteArguments, F as DEFAULT_AGENT_MODEL, G as isReadOnlyTool, H as OllamaBackend, I as DEFAULT_MAX_ITERATIONS, J as CheckpointStore, K as ReActAgent, L as DEFAULT_RETRY_CONFIG, M as PermissionManager, N as generateCliTools, O as extractCompactInstructions, P as ALWAYS_DENIED_FOR_AGENTS, Q as hasFileReferences, R as DEFAULT_THOROUGHNESS, S as FallbackLlmBackend, T as McpManager, U as buildCoreSystemPrompt, V as setWebSocketToolExecutor, W as buildSkillsPromptSection, X as SessionStore, Y as CommandHistoryStore, Z as OAuthClient, _ as createSkillTool, a as createDecisionStore, b as WebSocketToolExecutor, c as createFindDefinitionTool, d as createCoordinateTaskTool, et as searchCommands, f as createBackgroundAgentTools, g as SubagentOrchestrator, h as AgentStore, i as createDecisionLogTool, it as warmFileCache, j as getEnvironmentName, k as loadContextFiles, l as createTodoStore, m as createAgentDelegateTool, n as createBlockerTools, nt as formatFileSize, o as formatDecisionsOutput, p as BackgroundAgentManager, q as CustomCommandStore, r as formatBlockersOutput, rt as searchFiles, s as createGetFileStructureTool, t as createBlockerStore, tt as mergeCommands, u as createWriteTodosTool, v as parseAgentConfig, w as ServerLlmBackend, x as WebSocketConnectionManager, y as ApiClient, z as clearFeatureModuleTools } from "./tools-dIVxi-6-.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-Dt6utdSA.mjs";
+import { i as version, t as checkForUpdate } from "./updateChecker-DZXWZfKF.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";
@@ -2484,10 +2484,207 @@ function createCompactedSession(originalSession, summary, preservedMessages) {
 			totalTokens: 0,
 			totalCost: 0,
 			toolCallCount: 0,
-			compactedFrom: originalSession.id
+			compactedFrom: originalSession.id,
+			...originalSession.metadata.workflow ? { workflow: originalSession.metadata.workflow } : {}
 		}
 	};
 }
+/**
+* Prefix tag used to mark a system message as an injected handoff. Kept as a
+* single source of truth so the dedup-on-resume check and the system-message
+* builder cannot drift out of sync.
+*/
+const HANDOFF_MARKER = "[Session handoff from previous session]";
+const MAX_MESSAGE_CHARS = 2e3;
+/**
+* Cap on the number of conversation messages included in the handoff prompt.
+* Prevents unbounded prompt growth on long sessions; the most recent messages
+* are kept since they best reflect the session's current state. Decisions and
+* blockers from workflow state are still included in full above the excerpt.
+*/
+const MAX_CONVERSATION_MESSAGES = 50;
+const ROLE_LABELS = {
+	user: "User",
+	assistant: "Assistant",
+	system: "System"
+};
+/**
+* Build a prompt instructing the LLM to produce a structured session handoff
+* as JSON. Incorporates decisions and blockers from the existing workflow state
+* so the handoff reflects durable state, not just chat history.
+*
+* Any previously-injected handoff message (from a prior /resume) is filtered
+* out — the LLM should produce a fresh handoff from the actual conversation,
+* not echo back a prior handoff sitting at the top of the message list.
+*
+* Returns an empty string for short sessions — callers should skip generation.
+*/
+function buildHandoffPrompt(session) {
+	if (session.messages.length < 4) return "";
+	const filtered = session.messages.filter((m) => !isInjectedHandoff(m));
+	const conversation = filtered.length > MAX_CONVERSATION_MESSAGES ? filtered.slice(-MAX_CONVERSATION_MESSAGES) : filtered;
+	let prompt = `You are generating a structured session handoff so the next session (or another agent) can pick up seamlessly without re-reading the full chat history.
+
+Output a single JSON object — no prose, no markdown fences — with exactly these fields:
+
+{
+  "summary": "2-4 sentence overview of what this session accomplished and where it ended",
+  "keyFindings": ["concise factual discoveries — e.g. 'auth bug is in middleware.ts:42, caused by missing token refresh'"],
+  "nextSteps": ["concrete actions the next session should take, in priority order"],
+  "pendingDecisions": ["open questions or trade-offs awaiting a decision"],
+  "blockers": ["anything preventing progress — wait conditions, missing inputs, broken upstream"]
+}
+
+Rules:
+- Each list item is a single line, no nested structure.
+- Empty lists are fine — use [] when nothing applies.
+- Be specific: cite filenames, function names, error messages where relevant.
+- Do not invent context. Only include items grounded in the conversation or workflow state below.
+
+`;
+	prompt += appendWorkflowContext(session.metadata.workflow);
+	prompt += `CONVERSATION:\n\n`;
+	for (const msg of conversation) {
+		const role = ROLE_LABELS[msg.role] || "System";
+		const content = msg.content.length > MAX_MESSAGE_CHARS ? msg.content.slice(0, MAX_MESSAGE_CHARS) + "...[truncated]" : msg.content;
+		prompt += `**${role}:** ${content}\n\n`;
+	}
+	prompt += `\nReturn only the JSON object.`;
+	return prompt;
+}
+function appendWorkflowContext(workflow) {
+	if (!workflow) return "";
+	const sections = [];
+	if (workflow.decisions.length > 0) {
+		const lines = workflow.decisions.map((d) => `- ${d.summary} (rationale: ${d.rationale})`);
+		sections.push(`LOGGED DECISIONS:\n${lines.join("\n")}`);
+	}
+	const openBlockers = workflow.blockers.filter((b) => b.status === "open");
+	if (openBlockers.length > 0) {
+		const lines = openBlockers.map((b) => `- ${b.description}`);
+		sections.push(`OPEN BLOCKERS:\n${lines.join("\n")}`);
+	}
+	return sections.length > 0 ? `${sections.join("\n\n")}\n\n` : "";
+}
+/**
+* Parse a raw LLM response into a SessionHandoff.
+*
+* Tolerates fenced code blocks (```json ... ```) and surrounding prose by
+* extracting the first balanced JSON object. Returns null if no valid handoff
+* can be parsed — callers decide how to surface that to the user.
+*/
+function parseHandoffResponse(response) {
+	const json = extractJsonObject(response);
+	if (!json) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(json);
+	} catch {
+		return null;
+	}
+	if (!parsed || typeof parsed !== "object") return null;
+	const obj = parsed;
+	const summary = typeof obj.summary === "string" ? obj.summary.trim() : "";
+	if (!summary) return null;
+	return {
+		summary,
+		keyFindings: toStringArray(obj.keyFindings),
+		nextSteps: toStringArray(obj.nextSteps),
+		pendingDecisions: toStringArray(obj.pendingDecisions),
+		blockers: toStringArray(obj.blockers),
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+function toStringArray(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((v) => typeof v === "string" && v.trim().length > 0).map((v) => v.trim());
+}
+function extractJsonObject(text) {
+	const trimmed = text.trim();
+	if (!trimmed) return null;
+	const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+	const candidate = fenced ? fenced[1].trim() : trimmed;
+	const start = candidate.indexOf("{");
+	if (start === -1) return null;
+	let depth = 0;
+	let inString = false;
+	let escaped = false;
+	for (let i = start; i < candidate.length; i++) {
+		const ch = candidate[i];
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (ch === "\\" && inString) {
+			escaped = true;
+			continue;
+		}
+		if (ch === "\"") {
+			inString = !inString;
+			continue;
+		}
+		if (inString) continue;
+		if (ch === "{") depth++;
+		else if (ch === "}") {
+			depth--;
+			if (depth === 0) return candidate.slice(start, i + 1);
+		}
+	}
+	return null;
+}
+/**
+* Render a SessionHandoff for terminal display, including the generation
+* timestamp so the user knows how fresh the context is.
+*/
+function formatHandoffOutput(handoff) {
+	return formatHandoff(handoff, { includeTimestamp: true });
+}
+/**
+* Build the system message that injects handoff context into a resumed
+* session. Excludes the timestamp so the message text is stable across
+* regenerations — important for keeping LLM prompt caches warm.
+*/
+function buildHandoffSystemMessage(handoff) {
+	return `${HANDOFF_MARKER}\n\n${formatHandoff(handoff, { includeTimestamp: false })}`;
+}
+function formatHandoff(handoff, options) {
+	const lines = [handoff.summary, ""];
+	appendSection(lines, "Key findings", handoff.keyFindings);
+	appendSection(lines, "Next steps", handoff.nextSteps);
+	appendSection(lines, "Pending decisions", handoff.pendingDecisions);
+	appendSection(lines, "Blockers", handoff.blockers);
+	if (options.includeTimestamp) lines.push(`Generated: ${handoff.generatedAt}`);
+	else if (lines[lines.length - 1] === "") lines.pop();
+	return lines.join("\n");
+}
+function appendSection(lines, heading, items) {
+	if (items.length === 0) return;
+	lines.push(`${heading}:`);
+	for (const item of items) lines.push(`  - ${item}`);
+	lines.push("");
+}
+/**
+* True when a message is a previously-injected handoff system message.
+* Used to deduplicate handoff injections across save/resume cycles.
+*/
+function isInjectedHandoff(message) {
+	return message.role === "system" && message.content.startsWith("[Session handoff from previous session]");
+}
+/**
+* Return a new message list with the handoff prepended as a system message.
+* Any previously-injected handoff anywhere in the list is removed so the
+* message list stays stable across repeated save/resume cycles. We scan the
+* whole list rather than just index 0 because compaction can prepend a
+* summary system message, pushing the prior handoff to a later index.
+*/
+function injectHandoffMessage(messages, handoff) {
+	return [{
+		id: v4(),
+		role: "system",
+		content: buildHandoffSystemMessage(handoff),
+		timestamp: (/* @__PURE__ */ new Date()).toISOString()
+	}, ...messages.filter((m) => !isInjectedHandoff(m))];
+}
 //#endregion
 //#region src/utils/imageRenderer.ts
 /**
@@ -5036,6 +5233,8 @@ function CliApp() {
 	const [initError, setInitError] = useState(null);
 	const [commandHistory, setCommandHistory] = useState([]);
 	const imageStoreInitPromise = useRef(null);
+	const decisionStoreRef = useRef(createDecisionStore());
+	const blockerStoreRef = useRef(createBlockerStore());
 	const setStoreSession = useCliStore((state) => state.setSession);
 	const enqueuePermissionPrompt = useCliStore((state) => state.enqueuePermissionPrompt);
 	const enqueueUserQuestionPrompt = useCliStore((state) => state.enqueueUserQuestionPrompt);
@@ -5478,6 +5677,15 @@ function CliApp() {
 				logger.warn(`⚠️  Model "${fromModel}" failed (${error.message}) — falling back to "${toModel}"`);
 			}) : llm, backgroundManager);
 			const writeTodosTool = createWriteTodosTool(createTodoStore());
+			const decisionLogTool = createDecisionLogTool(decisionStoreRef.current);
+			const blockerTools = createBlockerTools(blockerStoreRef.current);
+			if (newSession.metadata.workflow) {
+				decisionStoreRef.current.decisions = [...newSession.metadata.workflow.decisions];
+				blockerStoreRef.current.blockers = [...newSession.metadata.workflow.blockers];
+			} else {
+				decisionStoreRef.current.decisions = [];
+				blockerStoreRef.current.blockers = [];
+			}
 			const enableSkillTool = config.preferences.enableSkillTool !== false;
 			const skillTool = enableSkillTool ? createSkillTool({
 				customCommandStore: state.customCommandStore,
@@ -5495,6 +5703,8 @@ function CliApp() {
 				agentDelegateTool,
 				...backgroundTools,
 				writeTodosTool,
+				decisionLogTool,
+				...blockerTools,
 				findDefinitionTool,
 				getFileStructureTool
 			];
@@ -5924,7 +6134,13 @@ function CliApp() {
 					...currentSession.metadata,
 					totalTokens: currentSession.metadata.totalTokens + result.completionInfo.totalTokens,
 					totalCredits: (currentSession.metadata.totalCredits || 0) + (result.completionInfo.totalCredits || 0),
-					toolCallCount: currentSession.metadata.toolCallCount + successfulToolCalls
+					toolCallCount: currentSession.metadata.toolCallCount + successfulToolCalls,
+					workflow: decisionStoreRef.current.decisions.length > 0 || blockerStoreRef.current.blockers.length > 0 ? {
+						decisions: decisionStoreRef.current.decisions,
+						blockers: blockerStoreRef.current.blockers,
+						handoff: currentSession.metadata.workflow?.handoff,
+						reviewGates: currentSession.metadata.workflow?.reviewGates
+					} : currentSession.metadata.workflow
 				}
 			};
 			setState((prev) => ({
@@ -6407,6 +6623,46 @@ function CliApp() {
 			console.log("");
 		}
 	};
+	/**
+	* Generate a structured session handoff via a single LLM call and persist it
+	* onto the session's workflow state. Returns the handoff on success, or null
+	* if generation was skipped (short session) or failed (parse / agent error).
+	*
+	* Failures are best-effort and surfaced as a warning rather than thrown —
+	* the surrounding /save flow must not block on handoff generation.
+	*
+	* Callers are responsible for saving the session afterwards.
+	*/
+	const generateHandoff = async (session) => {
+		if (!state.agent) return null;
+		const prompt = buildHandoffPrompt(session);
+		if (!prompt) return null;
+		console.log("📝 Generating session handoff...");
+		useCliStore.getState().setIsThinking(true);
+		try {
+			const result = await state.agent.run(prompt, { maxIterations: 1 });
+			const handoff = parseHandoffResponse(result.finalAnswer);
+			if (!handoff) {
+				console.warn("⚠️  Handoff generation returned no parseable JSON; skipping.");
+				logger.debug(`Handoff response: ${result.finalAnswer.slice(0, 500)}`);
+				return null;
+			}
+			session.metadata.workflow = {
+				decisions: decisionStoreRef.current.decisions,
+				blockers: blockerStoreRef.current.blockers,
+				handoff,
+				reviewGates: session.metadata.workflow?.reviewGates
+			};
+			return handoff;
+		} catch (err) {
+			const reason = err instanceof Error ? err.message : String(err);
+			console.warn(`⚠️  Handoff generation failed: ${reason}`);
+			logger.debug(`Handoff generation error: ${reason}`);
+			return null;
+		} finally {
+			useCliStore.getState().setIsThinking(false);
+		}
+	};
 	const handleCommand = async (command, args) => {
 		const customCommand = state.customCommandStore.getCommand(command);
 		if (customCommand) try {
@@ -6540,8 +6796,16 @@ Multi-line Input:
 				}
 				const sessionName = args.join(" ") || state.session.name;
 				state.session.name = sessionName;
+				if (decisionStoreRef.current.decisions.length > 0 || blockerStoreRef.current.blockers.length > 0) state.session.metadata.workflow = {
+					decisions: decisionStoreRef.current.decisions,
+					blockers: blockerStoreRef.current.blockers,
+					handoff: state.session.metadata.workflow?.handoff,
+					reviewGates: state.session.metadata.workflow?.reviewGates
+				};
+				const handoff = await generateHandoff(state.session);
 				await state.sessionStore.save(state.session);
 				console.log(`✅ Session saved as "${sessionName}"`);
+				if (handoff) console.log("🤝 Session handoff generated");
 				break;
 			}
 			case "resume":
@@ -6567,15 +6831,24 @@ Multi-line Input:
 					await logger.initialize(loadedSession.id);
 					logger.debug("=== Session Resumed ===");
 					if (state.checkpointStore) state.checkpointStore.setSessionId(loadedSession.id);
+					const handoff = loadedSession.metadata.workflow?.handoff;
+					const sessionForState = handoff ? {
+						...loadedSession,
+						messages: injectHandoffMessage(loadedSession.messages, handoff)
+					} : loadedSession;
 					setState((prev) => ({
 						...prev,
-						session: loadedSession
+						session: sessionForState
 					}));
-					setStoreSession(loadedSession);
+					setStoreSession(sessionForState);
 					useCliStore.getState().clearPendingMessages();
 					usageCache = null;
-					console.log(`\n✅ Session resumed: "${loadedSession.name}"`);
-					console.log(`📝 ${loadedSession.messages.length} messages | 🤖 ${loadedSession.model} | 📊 ${loadedSession.metadata.totalTokens.toLocaleString()} tokens\n`);
+					console.log(`\n✅ Session resumed: "${sessionForState.name}"`);
+					console.log(`📝 ${sessionForState.messages.length} messages | 🤖 ${sessionForState.model} | 📊 ${sessionForState.metadata.totalTokens.toLocaleString()} tokens\n`);
+					if (handoff) {
+						console.log("🤝 Session handoff:\n");
+						console.log(formatHandoffOutput(handoff));
+					}
 				};
 				setState((prev) => ({
 					...prev,
@@ -6800,6 +7073,8 @@ Multi-line Input:
 				};
 				await logger.initialize(newSession.id);
 				logger.debug("=== New Session Started via /clear ===");
+				decisionStoreRef.current.decisions = [];
+				blockerStoreRef.current.blockers = [];
 				if (state.checkpointStore) state.checkpointStore.setSessionId(newSession.id);
 				setState((prev) => ({
 					...prev,
@@ -7491,6 +7766,48 @@ Multi-line Input:
 				console.log(`✅ Removed directory: ${resolvedRemovePath}`);
 				break;
 			}
+			case "decisions":
+				console.log("\n📋 Decision Log\n");
+				console.log(formatDecisionsOutput(decisionStoreRef.current.decisions));
+				console.log("");
+				break;
+			case "blockers":
+				console.log("\n🚧 Blockers\n");
+				console.log(formatBlockersOutput(blockerStoreRef.current.blockers));
+				console.log("");
+				break;
+			case "handoff": {
+				if (!state.session) {
+					console.log("No active session");
+					break;
+				}
+				const existing = state.session.metadata.workflow?.handoff;
+				const wantsRegen = args[0] === "generate" || args[0] === "regen";
+				if (existing && !wantsRegen) {
+					console.log("\n🤝 Session handoff\n");
+					console.log(formatHandoffOutput(existing));
+					console.log("Run /handoff generate to refresh.\n");
+					break;
+				}
+				if (state.session.messages.length < 4) {
+					console.log(`Not enough messages to generate a handoff (need at least 4)`);
+					break;
+				}
+				if (!state.agent) {
+					console.log("Cannot generate handoff: no active agent");
+					break;
+				}
+				const handoff = await generateHandoff(state.session);
+				if (!handoff) {
+					console.log("❌ Failed to generate handoff");
+					break;
+				}
+				await state.sessionStore.save(state.session);
+				console.log("\n🤝 Session handoff\n");
+				console.log(formatHandoffOutput(handoff));
+				console.log("\n✅ Session saved with refreshed handoff");
+				break;
+			}
 			case "dirs": {
 				const additionalDirs = await state.configStore.getAdditionalDirectories();
 				const cwd = process.cwd();