@os-eco/overstory-cli 0.7.6 → 0.7.8

package/src/commands/dashboard.ts

@@ -24,6 +24,7 @@ import { createEventStore } from "../events/store.ts";
 import { accent, brand, color, visibleLength } from "../logging/color.ts";
 import {
 	buildAgentColorMap,
+	extendAgentColorMap,
 	formatDuration,
 	formatEventLine,
 	formatRelativeTime,
@@ -128,10 +129,10 @@ export { pad, truncate, horizontalLine };
 
 /**
  * Compute agent panel height from screen height and agent count.
- * min 8 rows, max floor(height * 0.5), grows with agent count (+4 for chrome).
+ * min 8 rows, max floor(height * 0.35), grows with agent count (+4 for chrome).
  */
 export function computeAgentPanelHeight(height: number, agentCount: number): number {
-	return Math.max(8, Math.min(Math.floor(height * 0.5), agentCount + 4));
+	return Math.max(8, Math.min(Math.floor(height * 0.35), agentCount + 4));
 }
 
 /**
@@ -241,6 +242,49 @@ export function closeDashboardStores(stores: DashboardStores): void {
 	}
 }
 
+/**
+ * Rolling event buffer with incremental dedup by lastSeenId.
+ * Maintains a fixed-size window of the most recent events.
+ */
+export class EventBuffer {
+	private events: StoredEvent[] = [];
+	private lastSeenId = 0;
+	private colorMap: Map<string, (s: string) => string> = new Map();
+	private readonly maxSize: number;
+
+	constructor(maxSize = 100) {
+		this.maxSize = maxSize;
+	}
+
+	poll(eventStore: EventStore): void {
+		const since = new Date(Date.now() - 60 * 1000).toISOString();
+		const allEvents = eventStore.getTimeline({ since, limit: 1000 });
+		const newEvents = allEvents.filter((e) => e.id > this.lastSeenId);
+
+		if (newEvents.length === 0) return;
+
+		extendAgentColorMap(this.colorMap, newEvents);
+		this.events = [...this.events, ...newEvents].slice(-this.maxSize);
+
+		const lastEvent = newEvents[newEvents.length - 1];
+		if (lastEvent) {
+			this.lastSeenId = lastEvent.id;
+		}
+	}
+
+	getEvents(): StoredEvent[] {
+		return this.events;
+	}
+
+	getColorMap(): Map<string, (s: string) => string> {
+		return this.colorMap;
+	}
+
+	get size(): number {
+		return this.events.length;
+	}
+}
+
 /** Tracker data cached between dashboard ticks (10s TTL). */
 interface TrackerCache {
 	tasks: TrackerIssue[];
@@ -263,6 +307,7 @@ interface DashboardData {
 	};
 	tasks: TrackerIssue[];
 	recentEvents: StoredEvent[];
+	feedColorMap: Map<string, (s: string) => string>;
 }
 
 /**
@@ -289,6 +334,7 @@ async function loadDashboardData(
 	stores: DashboardStores,
 	runId?: string | null,
 	thresholds?: { staleMs: number; zombieMs: number },
+	eventBuffer?: EventBuffer,
 ): Promise<DashboardData> {
 	// Get all sessions from the pre-opened session store
 	const allSessions = stores.sessionStore.getAll();
@@ -450,13 +496,14 @@ async function loadDashboardData(
 		tasks = trackerCache.tasks;
 	}
 
-	// Load recent events from event store
+	// Load recent events via incremental buffer (or fallback to empty)
 	let recentEvents: StoredEvent[] = [];
-	if (stores.eventStore) {
+	let feedColorMap: Map<string, (s: string) => string> = new Map();
+	if (eventBuffer && stores.eventStore) {
 		try {
-			const fiveMinAgo = new Date(Date.now() - 5 * 60 * 1000).toISOString();
-			const events = stores.eventStore.getTimeline({ since: fiveMinAgo, limit: 20 });
-			recentEvents = [...events].reverse(); // most recent first
+			eventBuffer.poll(stores.eventStore);
+			recentEvents = [...eventBuffer.getEvents()].reverse();
+			feedColorMap = eventBuffer.getColorMap();
 		} catch {
 			/* best effort */
 		}
@@ -470,6 +517,7 @@ async function loadDashboardData(
 		metrics: { totalSessions, avgDuration, byCapability },
 		tasks,
 		recentEvents,
+		feedColorMap,
 	};
 }
 
@@ -496,7 +544,7 @@ export function renderAgentPanel(
 	panelHeight: number,
 	startRow: number,
 ): string {
-	const leftWidth = Math.floor(fullWidth * 0.6);
+	const leftWidth = fullWidth;
 	let output = "";
 
 	// Panel header
@@ -650,7 +698,7 @@ export function renderFeedPanel(
 	let output = "";
 
 	// Header
-	const headerLine = `${dimBox.vertical} ${brand.bold("Feed")} (last 5 min)`;
+	const headerLine = `${dimBox.vertical} ${brand.bold("Feed")} (live)`;
 	const headerPadding = " ".repeat(
 		Math.max(0, panelWidth - visibleLength(headerLine) - visibleLength(dimBox.vertical)),
 	);
@@ -676,7 +724,8 @@ export function renderFeedPanel(
 		return output;
 	}
 
-	const colorMap = buildAgentColorMap(data.recentEvents);
+	const colorMap =
+		data.feedColorMap.size > 0 ? data.feedColorMap : buildAgentColorMap(data.recentEvents);
 	const visibleEvents = data.recentEvents.slice(0, maxRows);
 
 	for (let i = 0; i < visibleEvents.length; i++) {
@@ -733,12 +782,10 @@ export function renderFeedPanel(
  */
 function renderMailPanel(
 	data: DashboardData,
-	width: number,
-	height: number,
+	panelWidth: number,
+	panelHeight: number,
 	startRow: number,
 ): string {
-	const panelHeight = Math.floor(height * 0.3);
-	const panelWidth = Math.floor(width * 0.5);
 	let output = "";
 
 	const unreadCount = data.status.unreadMailCount;
@@ -787,13 +834,11 @@ function renderMailPanel(
  */
 function renderMergeQueuePanel(
 	data: DashboardData,
-	width: number,
-	height: number,
+	panelWidth: number,
+	panelHeight: number,
 	startRow: number,
 	startCol: number,
 ): string {
-	const panelHeight = Math.floor(height * 0.3);
-	const panelWidth = width - startCol + 1;
 	let output = "";
 
 	const headerLine = `${dimBox.vertical} ${brand.bold("Merge Queue")} (${data.mergeQueue.length})`;
@@ -847,26 +892,20 @@ function renderMetricsPanel(
 	const separator = dimHorizontalLine(width, dimBox.tee, dimBox.teeRight);
 	output += `${CURSOR.cursorTo(startRow, 1)}${separator}\n`;
 
-	const headerLine = `${dimBox.vertical} ${brand.bold("Metrics")}`;
-	const headerPadding = " ".repeat(
-		Math.max(0, width - visibleLength(headerLine) - visibleLength(dimBox.vertical)),
-	);
-	output += `${CURSOR.cursorTo(startRow + 1, 1)}${headerLine}${headerPadding}${dimBox.vertical}\n`;
-
 	const totalSessions = data.metrics.totalSessions;
 	const avgDur = formatDuration(data.metrics.avgDuration);
 	const byCapability = Object.entries(data.metrics.byCapability)
 		.map(([cap, count]) => `${cap}:${count}`)
 		.join(", ");
 
-	const metricsLine = `${dimBox.vertical} Total sessions: ${totalSessions} | Avg duration: ${avgDur} | By capability: ${byCapability}`;
+	const metricsLine = `${dimBox.vertical} ${brand.bold("Metrics")}  Total: ${totalSessions} | Avg: ${avgDur} | ${byCapability}`;
 	const metricsPadding = " ".repeat(
 		Math.max(0, width - visibleLength(metricsLine) - visibleLength(dimBox.vertical)),
 	);
-	output += `${CURSOR.cursorTo(startRow + 2, 1)}${metricsLine}${metricsPadding}${dimBox.vertical}\n`;
+	output += `${CURSOR.cursorTo(startRow + 1, 1)}${metricsLine}${metricsPadding}${dimBox.vertical}\n`;
 
 	const bottomBorder = dimHorizontalLine(width, dimBox.bottomLeft, dimBox.bottomRight);
-	output += `${CURSOR.cursorTo(startRow + 3, 1)}${bottomBorder}\n`;
+	output += `${CURSOR.cursorTo(startRow + 2, 1)}${bottomBorder}\n`;
 
 	return output;
 }
@@ -883,50 +922,42 @@ function renderDashboard(data: DashboardData, interval: number): void {
 	// Header (rows 1-2)
 	output += renderHeader(width, interval, data.currentRunId);
 
-	// Agent panel start row
+	// Agent panel: full width, capped at 35% of height
 	const agentPanelStart = 3;
-
-	// Dynamic agent panel height
 	const agentCount = data.status.agents.length;
 	const agentPanelHeight = computeAgentPanelHeight(height, agentCount);
+	output += renderAgentPanel(data, width, agentPanelHeight, agentPanelStart);
 
-	// Column widths
-	const leftWidth = Math.floor(width * 0.6);
-	const rightWidth = width - leftWidth;
-	const rightStartCol = leftWidth + 1;
+	// Middle zone: Feed (left 60%) | Tasks (right 40%)
+	const middleStart = agentPanelStart + agentPanelHeight + 1;
+	const compactPanelHeight = 5; // fixed for mail/merge panels
+	const metricsHeight = 3; // separator + data + border
+	const middleHeight = Math.max(6, height - middleStart - compactPanelHeight - metricsHeight);
 
-	// Right column split (Tasks upper / Feed lower)
-	const rightHalf = Math.floor(agentPanelHeight / 2);
-	const feedHeight = agentPanelHeight - rightHalf;
+	const feedWidth = Math.floor(width * 0.6);
+	output += renderFeedPanel(data, 1, feedWidth, middleHeight, middleStart);
 
-	// Render left: agents (60% wide, dynamic height)
-	output += renderAgentPanel(data, width, agentPanelHeight, agentPanelStart);
+	const taskWidth = width - feedWidth;
+	const taskStartCol = feedWidth + 1;
+	output += renderTasksPanel(data, taskStartCol, taskWidth, middleHeight, middleStart);
 
-	// Render right-upper: tasks
-	output += renderTasksPanel(data, rightStartCol, rightWidth, rightHalf, agentPanelStart);
+	// Compact panels: Mail (left 50%) | Merge Queue (right 50%) — fixed 5 rows
+	const compactStart = middleStart + middleHeight;
+	const mailWidth = Math.floor(width * 0.5);
+	output += renderMailPanel(data, mailWidth, compactPanelHeight, compactStart);
 
-	// Render right-lower: feed
-	output += renderFeedPanel(
+	const mergeStartCol = mailWidth + 1;
+	const mergeWidth = width - mailWidth;
+	output += renderMergeQueuePanel(
 		data,
-		rightStartCol,
-		rightWidth,
-		feedHeight,
-		agentPanelStart + rightHalf,
+		mergeWidth,
+		compactPanelHeight,
+		compactStart,
+		mergeStartCol,
 	);
 
-	// Middle panels (mail/merge) start after agent block
-	const middlePanelStart = agentPanelStart + agentPanelHeight + 1;
-
-	// Mail panel (left 50%)
-	output += renderMailPanel(data, width, height, middlePanelStart);
-
-	// Merge queue panel (right 50%)
-	const mergeQueueCol = Math.floor(width * 0.5) + 1;
-	output += renderMergeQueuePanel(data, width, height, middlePanelStart, mergeQueueCol);
-
-	// Metrics panel (bottom strip)
-	const middlePanelHeight = Math.floor(height * 0.3);
-	const metricsStart = middlePanelStart + middlePanelHeight + 1;
+	// Metrics footer
+	const metricsStart = compactStart + compactPanelHeight;
 	output += renderMetricsPanel(data, width, height, metricsStart);
 
 	process.stdout.write(output);
@@ -963,6 +994,9 @@ async function executeDashboard(opts: DashboardOpts): Promise<void> {
 	// Open stores once for the entire poll loop lifetime
 	const stores = openDashboardStores(root);
 
+	// Create rolling event buffer (persisted across poll ticks)
+	const eventBuffer = new EventBuffer(100);
+
 	// Compute health thresholds once from config (reused across poll ticks)
 	const thresholds = {
 		staleMs: config.watchdog.staleThresholdMs,
@@ -984,7 +1018,7 @@ async function executeDashboard(opts: DashboardOpts): Promise<void> {
 
 	// Poll loop
 	while (running) {
-		const data = await loadDashboardData(root, stores, runId, thresholds);
+		const data = await loadDashboardData(root, stores, runId, thresholds, eventBuffer);
 		renderDashboard(data, interval);
 		await Bun.sleep(interval);
 	}

package/src/commands/log.ts

@@ -583,6 +583,7 @@ async function runLog(opts: {
 							const cost = estimateCost(usage);
 							const metricsDbPath = join(config.project.root, ".overstory", "metrics.db");
 							const metricsStore = createMetricsStore(metricsDbPath);
+							const agentSession = getAgentSession(config.project.root, opts.agent);
 							metricsStore.recordSnapshot({
 								agentName: opts.agent,
 								inputTokens: usage.inputTokens,
@@ -591,6 +592,7 @@ async function runLog(opts: {
 								cacheCreationTokens: usage.cacheCreationTokens,
 								estimatedCostUsd: cost,
 								modelUsed: usage.modelUsed,
+								runId: agentSession?.runId ?? null,
 								createdAt: new Date().toISOString(),
 							});
 							metricsStore.close();

package/src/commands/sling.test.ts

@@ -1,8 +1,13 @@
-import { describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { realpathSync } from "node:fs";
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { resolveModel, resolveProviderEnv } from "../agents/manifest.ts";
 import { HierarchyError } from "../errors.ts";
 import { ClaudeRuntime } from "../runtimes/claude.ts";
 import { getRuntime } from "../runtimes/registry.ts";
+import { cleanupTempDir, createTempGitRepo } from "../test-helpers.ts";
 import type { AgentManifest, OverstoryConfig } from "../types.ts";
 import {
 	type AutoDispatchOptions,
@@ -15,6 +20,7 @@ import {
 	checkRunSessionLimit,
 	checkTaskLock,
 	extractMulchRecordIds,
+	getCurrentBranch,
 	inferDomainsFromFiles,
 	isRunningAsRoot,
 	parentHasScouts,
@@ -1274,3 +1280,59 @@ describe("extractMulchRecordIds", () => {
 		expect(result).toContainEqual({ id: "mx-2ce43d", domain: "typescript" });
 	});
 });
+
+describe("getCurrentBranch", () => {
+	let repoDir: string;
+
+	beforeEach(async () => {
+		repoDir = realpathSync(await createTempGitRepo());
+	});
+
+	afterEach(async () => {
+		await cleanupTempDir(repoDir);
+	});
+
+	test("returns the current branch name", async () => {
+		const branch = await getCurrentBranch(repoDir);
+		expect(branch).toMatch(/^(main|master)$/);
+	});
+
+	test("returns feature branch name after checkout", async () => {
+		const proc = Bun.spawn(["git", "checkout", "-b", "feature/test-branch"], {
+			cwd: repoDir,
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		await proc.exited;
+		const branch = await getCurrentBranch(repoDir);
+		expect(branch).toBe("feature/test-branch");
+	});
+
+	test("returns null for detached HEAD", async () => {
+		const hashProc = Bun.spawn(["git", "rev-parse", "HEAD"], {
+			cwd: repoDir,
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		const hash = (await new Response(hashProc.stdout).text()).trim();
+		await hashProc.exited;
+		const proc = Bun.spawn(["git", "checkout", hash], {
+			cwd: repoDir,
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		await proc.exited;
+		const branch = await getCurrentBranch(repoDir);
+		expect(branch).toBeNull();
+	});
+
+	test("returns null for non-git directory", async () => {
+		const tmpDir = realpathSync(await mkdtemp(join(tmpdir(), "overstory-notgit-")));
+		try {
+			const branch = await getCurrentBranch(tmpDir);
+			expect(branch).toBeNull();
+		} finally {
+			await cleanupTempDir(tmpDir);
+		}
+	});
+});

package/src/commands/sling.ts

@@ -124,6 +124,7 @@ export interface SlingOptions {
 	dispatchMaxAgents?: string;
 	runtime?: string;
 	noScoutCheck?: boolean;
+	baseBranch?: string;
 }
 
 export interface AutoDispatchOptions {
@@ -389,6 +390,28 @@ export function extractMulchRecordIds(primeText: string): Array<{ id: string; do
 	return results;
 }
 
+/**
+ * Get the current git branch name for the repo at the given path.
+ *
+ * Returns null if in detached HEAD state, the directory is not a git repo,
+ * or git exits non-zero.
+ *
+ * @param repoRoot - Absolute path to the git repository root
+ */
+export async function getCurrentBranch(repoRoot: string): Promise<string | null> {
+	const proc = Bun.spawn(["git", "rev-parse", "--abbrev-ref", "HEAD"], {
+		cwd: repoRoot,
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const [stdout, exitCode] = await Promise.all([new Response(proc.stdout).text(), proc.exited]);
+	if (exitCode !== 0) return null;
+	const branch = stdout.trim();
+	// "HEAD" is returned when in detached HEAD state
+	if (branch === "HEAD" || branch === "") return null;
+	return branch;
+}
+
 /**
  * Entry point for `ov sling <task-id> [flags]`.
  *
@@ -658,11 +681,17 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 		const worktreeBaseDir = join(config.project.root, config.worktrees.baseDir);
 		await mkdir(worktreeBaseDir, { recursive: true });
 
+		// Resolve base branch: --base-branch flag > current HEAD > config.project.canonicalBranch
+		const baseBranch =
+			opts.baseBranch ??
+			(await getCurrentBranch(config.project.root)) ??
+			config.project.canonicalBranch;
+
 		const { path: worktreePath, branch: branchName } = await createWorktree({
 			repoRoot: config.project.root,
 			baseDir: worktreeBaseDir,
 			agentName: name,
-			baseBranch: config.project.canonicalBranch,
+			baseBranch,
 			taskId: taskId,
 		});
 
@@ -862,7 +891,13 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 			runStore.close();
 		}
 
-		// 13b. Wait for Claude Code TUI to render before sending input.
+		// 13b. Give slow shells time to finish initializing before polling for TUI readiness.
+		const shellDelay = config.runtime?.shellInitDelayMs ?? 0;
+		if (shellDelay > 0) {
+			await Bun.sleep(shellDelay);
+		}
+
+		// Wait for Claude Code TUI to render before sending input.
 		// Polling capture-pane is more reliable than a fixed sleep because
 		// TUI init time varies by machine load and model state.
 		await waitForTuiReady(tmuxSessionName, (content) => runtime.detectReady(content));

package/src/config.test.ts

@@ -775,6 +775,74 @@ project:
 		await expect(loadConfig(tempDir)).rejects.toThrow(ValidationError);
 	});
 
+	test("resets negative shellInitDelayMs to 0 with warning", async () => {
+		await writeConfig("runtime:\n  shellInitDelayMs: -100\n");
+		const origWrite = process.stderr.write;
+		let capturedStderr = "";
+		process.stderr.write = ((s: string | Uint8Array) => {
+			if (typeof s === "string") capturedStderr += s;
+			return true;
+		}) as typeof process.stderr.write;
+		try {
+			const config = await loadConfig(tempDir);
+			expect(config.runtime?.shellInitDelayMs).toBe(0);
+		} finally {
+			process.stderr.write = origWrite;
+		}
+		expect(capturedStderr).toContain("WARNING: runtime.shellInitDelayMs");
+	});
+
+	test("resets Infinity shellInitDelayMs to 0 with warning", async () => {
+		await writeConfig("runtime:\n  shellInitDelayMs: .inf\n");
+		const origWrite = process.stderr.write;
+		let capturedStderr = "";
+		process.stderr.write = ((s: string | Uint8Array) => {
+			if (typeof s === "string") capturedStderr += s;
+			return true;
+		}) as typeof process.stderr.write;
+		try {
+			const config = await loadConfig(tempDir);
+			expect(config.runtime?.shellInitDelayMs).toBe(0);
+		} finally {
+			process.stderr.write = origWrite;
+		}
+		expect(capturedStderr).toContain("WARNING: runtime.shellInitDelayMs");
+	});
+
+	test("warns when shellInitDelayMs exceeds 30s", async () => {
+		await writeConfig("runtime:\n  shellInitDelayMs: 60000\n");
+		const origWrite = process.stderr.write;
+		let capturedStderr = "";
+		process.stderr.write = ((s: string | Uint8Array) => {
+			if (typeof s === "string") capturedStderr += s;
+			return true;
+		}) as typeof process.stderr.write;
+		try {
+			const config = await loadConfig(tempDir);
+			expect(config.runtime?.shellInitDelayMs).toBe(60000);
+		} finally {
+			process.stderr.write = origWrite;
+		}
+		expect(capturedStderr).toContain("WARNING: runtime.shellInitDelayMs is 60000ms");
+	});
+
+	test("accepts valid shellInitDelayMs without warning", async () => {
+		await writeConfig("runtime:\n  shellInitDelayMs: 2000\n");
+		const origWrite = process.stderr.write;
+		let capturedStderr = "";
+		process.stderr.write = ((s: string | Uint8Array) => {
+			if (typeof s === "string") capturedStderr += s;
+			return true;
+		}) as typeof process.stderr.write;
+		try {
+			const config = await loadConfig(tempDir);
+			expect(config.runtime?.shellInitDelayMs).toBe(2000);
+		} finally {
+			process.stderr.write = origWrite;
+		}
+		expect(capturedStderr).not.toContain("shellInitDelayMs");
+	});
+
 	test("rejects qualityGate with empty description", async () => {
 		await writeConfig(`
 project:

package/src/config.ts

@@ -64,6 +64,7 @@ export const DEFAULT_CONFIG: OverstoryConfig = {
 	},
 	runtime: {
 		default: "claude",
+		shellInitDelayMs: 0,
 		pi: {
 			provider: "anthropic",
 			modelMap: {
@@ -664,6 +665,21 @@ function validateConfig(config: OverstoryConfig): void {
 		}
 	}
 
+	// runtime.shellInitDelayMs: validate if present
+	if (config.runtime?.shellInitDelayMs !== undefined) {
+		const delay = config.runtime.shellInitDelayMs;
+		if (typeof delay !== "number" || delay < 0 || !Number.isFinite(delay)) {
+			process.stderr.write(
+				`[overstory] WARNING: runtime.shellInitDelayMs must be a non-negative number. Got: ${delay}. Using default (0).\n`,
+			);
+			config.runtime.shellInitDelayMs = 0;
+		} else if (delay > 30_000) {
+			process.stderr.write(
+				`[overstory] WARNING: runtime.shellInitDelayMs is ${delay}ms (>${30}s). This adds delay before every agent spawn. Consider a lower value.\n`,
+			);
+		}
+	}
+
 	// models: validate each value — accepts aliases and provider-prefixed refs
 	const validAliases = ["sonnet", "opus", "haiku"];
 	const toolHeavyRoles = ["builder", "scout"];

package/src/index.ts

@@ -45,7 +45,7 @@ import { OverstoryError, WorktreeError } from "./errors.ts";
 import { jsonError } from "./json.ts";
 import { brand, chalk, muted, setQuiet } from "./logging/color.ts";
 
-export const VERSION = "0.7.6";
+export const VERSION = "0.7.8";
 
 const rawArgs = process.argv.slice(2);
 
@@ -267,6 +267,7 @@ program
 	.option("--no-scout-check", "Suppress the parentHasScouts scout-before-build warning")
 	.option("--dispatch-max-agents <n>", "Per-lead max agents ceiling (injected into overlay)")
 	.option("--runtime <name>", "Runtime adapter (default: config or claude)")
+	.option("--base-branch <branch>", "Base branch for worktree creation (default: current HEAD)")
 	.option("--json", "Output result as JSON")
 	.action(async (taskId, opts) => {
 		await slingCommand(taskId, opts);