@os-eco/overstory-cli 0.7.7 → 0.7.8

package/src/metrics/store.ts

@@ -21,8 +21,9 @@ export interface MetricsStore {
 	purge(options: { all?: boolean; agent?: string }): number;
 	/** Record a token usage snapshot for a running agent. */
 	recordSnapshot(snapshot: TokenSnapshot): void;
-	/** Get the most recent snapshot per active agent (one row per agent). */
-	getLatestSnapshots(): TokenSnapshot[];
+	/** Get the most recent snapshot per active agent (one row per agent).
+	 * When runId is provided, restricts to snapshots recorded for that run. */
+	getLatestSnapshots(runId?: string): TokenSnapshot[];
 	/** Get the timestamp of the most recent snapshot for an agent, or null. */
 	getLatestSnapshotTime(agentName: string): string | null;
 	/** Delete snapshots matching criteria. Returns number of rows deleted. */
@@ -60,6 +61,7 @@ interface SnapshotRow {
 	cache_creation_tokens: number;
 	estimated_cost_usd: number | null;
 	model_used: string | null;
+	run_id: string | null;
 	created_at: string;
 }
 
@@ -94,6 +96,7 @@ CREATE TABLE IF NOT EXISTS token_snapshots (
   cache_creation_tokens INTEGER NOT NULL DEFAULT 0,
   estimated_cost_usd REAL,
   model_used TEXT,
+  run_id TEXT,
   created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%f','now'))
 )`;
 
@@ -136,6 +139,18 @@ function migrateRunIdColumn(db: Database): void {
 	}
 }
 
+/**
+ * Migrate an existing token_snapshots table to include the run_id column.
+ * Safe to call multiple times — only adds the column if missing.
+ */
+function migrateSnapshotRunIdColumn(db: Database): void {
+	const rows = db.prepare("PRAGMA table_info(token_snapshots)").all() as Array<{ name: string }>;
+	const existingColumns = new Set(rows.map((r) => r.name));
+	if (!existingColumns.has("run_id")) {
+		db.exec("ALTER TABLE token_snapshots ADD COLUMN run_id TEXT");
+	}
+}
+
 /**
  * Migrate an existing sessions table to include token columns.
  * Safe to call multiple times — only adds columns that are missing.
@@ -183,6 +198,7 @@ function rowToSnapshot(row: SnapshotRow): TokenSnapshot {
 		cacheCreationTokens: row.cache_creation_tokens,
 		estimatedCostUsd: row.estimated_cost_usd,
 		modelUsed: row.model_used,
+		runId: row.run_id,
 		createdAt: row.created_at,
 	};
 }
@@ -210,6 +226,7 @@ export function createMetricsStore(dbPath: string): MetricsStore {
 	migrateBeadIdToTaskId(db);
 	migrateTokenColumns(db);
 	migrateRunIdColumn(db);
+	migrateSnapshotRunIdColumn(db);
 
 	// Prepare statements for all queries
 	const insertStmt = db.prepare<
@@ -282,13 +299,14 @@ export function createMetricsStore(dbPath: string): MetricsStore {
 			$cache_creation_tokens: number;
 			$estimated_cost_usd: number | null;
 			$model_used: string | null;
+			$run_id: string | null;
 			$created_at: string;
 		}
 	>(`
 		INSERT INTO token_snapshots
-			(agent_name, input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens, estimated_cost_usd, model_used, created_at)
+			(agent_name, input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens, estimated_cost_usd, model_used, run_id, created_at)
 		VALUES
-			($agent_name, $input_tokens, $output_tokens, $cache_read_tokens, $cache_creation_tokens, $estimated_cost_usd, $model_used, $created_at)
+			($agent_name, $input_tokens, $output_tokens, $cache_read_tokens, $cache_creation_tokens, $estimated_cost_usd, $model_used, $run_id, $created_at)
 	`);
 
 	const latestSnapshotsStmt = db.prepare<SnapshotRow, Record<string, never>>(`
@@ -301,6 +319,18 @@ export function createMetricsStore(dbPath: string): MetricsStore {
 		) latest ON s.agent_name = latest.agent_name AND s.created_at = latest.max_created_at
 	`);
 
+	const latestSnapshotsByRunStmt = db.prepare<SnapshotRow, { $run_id: string }>(`
+		SELECT s.*
+		FROM token_snapshots s
+		INNER JOIN (
+			SELECT agent_name, MAX(created_at) as max_created_at
+			FROM token_snapshots
+			WHERE run_id = $run_id
+			GROUP BY agent_name
+		) latest ON s.agent_name = latest.agent_name AND s.created_at = latest.max_created_at
+		WHERE s.run_id = $run_id
+	`);
+
 	const latestSnapshotTimeStmt = db.prepare<
 		{ created_at: string } | null,
 		{ $agent_name: string }
@@ -401,11 +431,16 @@ export function createMetricsStore(dbPath: string): MetricsStore {
 				$cache_creation_tokens: snapshot.cacheCreationTokens,
 				$estimated_cost_usd: snapshot.estimatedCostUsd,
 				$model_used: snapshot.modelUsed,
+				$run_id: snapshot.runId,
 				$created_at: snapshot.createdAt,
 			});
 		},
 
-		getLatestSnapshots(): TokenSnapshot[] {
+		getLatestSnapshots(runId?: string): TokenSnapshot[] {
+			if (runId !== undefined) {
+				const rows = latestSnapshotsByRunStmt.all({ $run_id: runId });
+				return rows.map(rowToSnapshot);
+			}
 			const rows = latestSnapshotsStmt.all({});
 			return rows.map(rowToSnapshot);
 		},

package/src/schema-consistency.test.ts

@@ -179,6 +179,7 @@ describe("SQL schema consistency", () => {
 				"input_tokens",
 				"model_used",
 				"output_tokens",
+				"run_id",
 			].sort();
 
 			expect(actual).toEqual(expected);

package/src/types.ts

@@ -105,6 +105,13 @@ export interface OverstoryConfig {
 		printCommand?: string;
 		/** Pi runtime configuration for model alias expansion. */
 		pi?: PiRuntimeConfig;
+		/**
+		 * Delay in milliseconds between creating a tmux session and polling
+		 * for TUI readiness. Gives slow shells (oh-my-zsh, starship, etc.)
+		 * time to finish initializing before the agent command starts.
+		 * Default: 0 (no delay).
+		 */
+		shellInitDelayMs?: number;
 	};
 }
 
@@ -435,6 +442,7 @@ export interface TokenSnapshot {
 	estimatedCostUsd: number | null;
 	modelUsed: string | null;
 	createdAt: string;
+	runId: string | null;
 }
 
 // === Task Groups (Batch Coordination) ===

package/src/worktree/tmux.test.ts

@@ -3,6 +3,7 @@ import { AgentError } from "../errors.ts";
 import type { ReadyState } from "../runtimes/types.ts";
 import {
 	capturePaneContent,
+	checkSessionState,
 	createSession,
 	ensureTmuxAvailable,
 	getDescendantPids,
@@ -792,6 +793,54 @@ describe("isSessionAlive", () => {
 	});
 });
 
+describe("checkSessionState", () => {
+	let spawnSpy: ReturnType<typeof spyOn>;
+
+	beforeEach(() => {
+		spawnSpy = spyOn(Bun, "spawn");
+	});
+
+	afterEach(() => {
+		spawnSpy.mockRestore();
+	});
+
+	test("returns alive when tmux has-session succeeds", async () => {
+		spawnSpy.mockReturnValue(mockSpawnResult("", "", 0));
+		const state = await checkSessionState("overstory-test-coordinator");
+		expect(state).toBe("alive");
+	});
+
+	test("returns no_server when tmux reports no server running", async () => {
+		spawnSpy.mockReturnValue(
+			mockSpawnResult("", "no server running on /tmp/tmux-1000/default\n", 1),
+		);
+		const state = await checkSessionState("overstory-test-coordinator");
+		expect(state).toBe("no_server");
+	});
+
+	test("returns no_server when tmux reports no sessions", async () => {
+		spawnSpy.mockReturnValue(mockSpawnResult("", "no sessions\n", 1));
+		const state = await checkSessionState("overstory-test-coordinator");
+		expect(state).toBe("no_server");
+	});
+
+	test("returns dead when session not found", async () => {
+		spawnSpy.mockReturnValue(
+			mockSpawnResult("", "can't find session: overstory-test-coordinator\n", 1),
+		);
+		const state = await checkSessionState("overstory-test-coordinator");
+		expect(state).toBe("dead");
+	});
+
+	test("returns dead for generic tmux failure", async () => {
+		spawnSpy.mockReturnValue(
+			mockSpawnResult("", "error connecting to /tmp/tmux-1000/default\n", 1),
+		);
+		const state = await checkSessionState("overstory-test-coordinator");
+		expect(state).toBe("dead");
+	});
+});
+
 describe("sendKeys", () => {
 	let spawnSpy: ReturnType<typeof spyOn>;
 

package/src/worktree/tmux.ts

@@ -409,6 +409,39 @@ export async function isSessionAlive(name: string): Promise<boolean> {
 	return exitCode === 0;
 }
 
+/**
+ * Detailed session state for distinguishing failure modes.
+ *
+ * - `"alive"` -- tmux session exists and is reachable.
+ * - `"dead"` -- tmux server is running but the session does not exist.
+ * - `"no_server"` -- tmux server is not running at all.
+ */
+export type SessionState = "alive" | "dead" | "no_server";
+
+/**
+ * Check tmux session state with detailed failure mode reporting.
+ *
+ * Unlike `isSessionAlive()` which returns a simple boolean, this function
+ * distinguishes between three states:
+ * - `"alive"`: session exists -- the agent may still be running.
+ * - `"dead"`: tmux server is running but session is gone -- agent exited or was killed.
+ * - `"no_server"`: tmux server itself is not running -- all sessions are gone.
+ *
+ * Callers can use this to provide targeted error messages and decide whether
+ * stale session records should be cleaned up vs flagged as errors.
+ *
+ * @param name - Session name to check
+ * @returns The session state
+ */
+export async function checkSessionState(name: string): Promise<SessionState> {
+	const { exitCode, stderr } = await runCommand(["tmux", "has-session", "-t", name]);
+	if (exitCode === 0) return "alive";
+	if (stderr.includes("no server running") || stderr.includes("no sessions")) {
+		return "no_server";
+	}
+	return "dead";
+}
+
 /**
  * Capture the visible content of a tmux session's pane.
  *