@os-eco/overstory-cli 0.9.2 → 0.9.4

package/src/commands/worktree.ts

@@ -6,6 +6,7 @@
  * Logs are never auto-deleted.
  */
 
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { Command } from "commander";
 import { loadConfig } from "../config.ts";
@@ -14,6 +15,7 @@ import { jsonOutput } from "../json.ts";
 import { printHint, printSuccess, printWarning } from "../logging/color.ts";
 import { createMailStore } from "../mail/store.ts";
 import { openSessionStore } from "../sessions/compat.ts";
+import { createSessionStore } from "../sessions/store.ts";
 import type { AgentSession } from "../types.ts";
 import {
 	isBranchMerged,
@@ -23,6 +25,51 @@ import {
 } from "../worktree/manager.ts";
 import { isSessionAlive, killSession } from "../worktree/tmux.ts";
 
+/**
+ * Check for live child sessions nested inside a worktree's own .overstory/sessions.db.
+ *
+ * Returns the live children (agentName + pid). Empty array if no nested DB or no live children.
+ */
+export async function checkLiveChildren(
+	worktreePath: string,
+): Promise<{ agentName: string; pid: number }[]> {
+	const nestedDb = join(worktreePath, ".overstory", "sessions.db");
+	if (!existsSync(nestedDb)) {
+		return [];
+	}
+
+	const store = createSessionStore(nestedDb);
+	let sessions: AgentSession[];
+	try {
+		sessions = store.getAll();
+	} finally {
+		store.close();
+	}
+
+	const deadStates = new Set(["completed", "zombie"]);
+	const liveChildren: { agentName: string; pid: number }[] = [];
+
+	for (const session of sessions) {
+		if (deadStates.has(session.state)) continue;
+		if (session.pid === null) continue;
+
+		// process.kill(pid, 0) throws if the process is dead (ESRCH)
+		let alive = false;
+		try {
+			process.kill(session.pid, 0);
+			alive = true;
+		} catch {
+			// ESRCH — process is dead
+		}
+
+		if (alive) {
+			liveChildren.push({ agentName: session.agentName, pid: session.pid });
+		}
+	}
+
+	return liveChildren;
+}
+
 /**
  * Handle `ov worktree list`.
  */
@@ -100,6 +147,7 @@ async function handleClean(
 	const failed: string[] = [];
 	const skipped: string[] = [];
 	const seedsPreserved: string[] = [];
+	const blockedByChildren: string[] = [];
 
 	try {
 		for (const wt of overstoryWts) {
@@ -129,6 +177,33 @@ async function handleClean(
 				}
 			}
 
+			// Live-children guard: refuse to remove a worktree that has active nested agents.
+			// Nested sessions live in {wt.path}/.overstory/sessions.db (lead worktrees).
+			const liveChildren = await checkLiveChildren(wt.path);
+			if (liveChildren.length > 0) {
+				if (!force) {
+					blockedByChildren.push(wt.branch);
+					continue;
+				}
+				// --force: SIGTERM each live child, wait briefly, then proceed.
+				if (!json) {
+					printWarning(
+						`Force-terminating ${liveChildren.length} live child${liveChildren.length === 1 ? "" : "ren"} in ${wt.branch}`,
+					);
+					for (const child of liveChildren) {
+						process.stdout.write(`  ${child.agentName} (pid ${child.pid})\n`);
+					}
+				}
+				for (const child of liveChildren) {
+					try {
+						process.kill(child.pid, "SIGTERM");
+					} catch {
+						// Best effort
+					}
+				}
+				await Bun.sleep(500);
+			}
+
 			// If --all, clean everything
 			// Kill tmux session if still alive
 			if (session?.tmuxSession) {
@@ -243,6 +318,7 @@ async function handleClean(
 				cleaned,
 				failed,
 				skipped,
+				blockedByChildren,
 				pruned: pruneCount,
 				mailPurged,
 				seedsPreserved,
@@ -252,6 +328,7 @@ async function handleClean(
 			pruneCount === 0 &&
 			failed.length === 0 &&
 			skipped.length === 0 &&
+			blockedByChildren.length === 0 &&
 			seedsPreserved.length === 0
 		) {
 			printHint("No worktrees to clean");
@@ -286,6 +363,15 @@ async function handleClean(
 				}
 				printHint("Use --force to delete unmerged branches");
 			}
+			if (blockedByChildren.length > 0) {
+				printWarning(
+					`Skipped ${blockedByChildren.length} worktree${blockedByChildren.length === 1 ? "" : "s"} with live child agents`,
+				);
+				for (const branch of blockedByChildren) {
+					process.stdout.write(`  ${branch}\n`);
+				}
+				printHint("Use --force to cascade-terminate live children");
+			}
 		}
 	} finally {
 		store.close();

package/src/config.test.ts

@@ -1177,6 +1177,84 @@ describe("resolveProjectRoot", () => {
 	});
 });
 
+describe("resolveProjectRoot — env var and walk-up", () => {
+	let tempDir: string;
+	let savedEnv: string | undefined;
+
+	beforeEach(async () => {
+		tempDir = await mkdtemp(join(tmpdir(), "overstory-envtest-"));
+		savedEnv = process.env.OVERSTORY_PROJECT_ROOT;
+		delete process.env.OVERSTORY_PROJECT_ROOT;
+		clearProjectRootOverride();
+	});
+
+	afterEach(async () => {
+		if (savedEnv !== undefined) {
+			process.env.OVERSTORY_PROJECT_ROOT = savedEnv;
+		} else {
+			delete process.env.OVERSTORY_PROJECT_ROOT;
+		}
+		clearProjectRootOverride();
+		await cleanupTempDir(tempDir);
+	});
+
+	test("OVERSTORY_PROJECT_ROOT env var is returned immediately", async () => {
+		await mkdir(join(tempDir, ".overstory"), { recursive: true });
+		await Bun.write(
+			join(tempDir, ".overstory", "config.yaml"),
+			"project:\n  canonicalBranch: main\n",
+		);
+		process.env.OVERSTORY_PROJECT_ROOT = tempDir;
+		const result = await resolveProjectRoot("/some/unrelated/path");
+		expect(result).toBe(tempDir);
+	});
+
+	test("env var beats walk-up worktree resolution", async () => {
+		// Set up a parent root with config.yaml
+		const parentRoot = tempDir;
+		await mkdir(join(parentRoot, ".overstory", "worktrees", "some-agent"), { recursive: true });
+		await Bun.write(
+			join(parentRoot, ".overstory", "config.yaml"),
+			"project:\n  canonicalBranch: main\n",
+		);
+		const worktreePath = join(parentRoot, ".overstory", "worktrees", "some-agent");
+		// Even though walk-up would resolve parentRoot, env var pointing elsewhere wins
+		const envTarget = await mkdtemp(join(tmpdir(), "overstory-envtarget-"));
+		try {
+			process.env.OVERSTORY_PROJECT_ROOT = envTarget;
+			const result = await resolveProjectRoot(worktreePath);
+			expect(result).toBe(envTarget);
+		} finally {
+			await cleanupTempDir(envTarget);
+		}
+	});
+
+	test("walk-up resolves submodule path without git", async () => {
+		// Simulate a submodule worktree: {tempDir}/.overstory/worktrees/my-agent/sub
+		// config.yaml exists at {tempDir}/.overstory/config.yaml
+		const worktreeBase = join(tempDir, ".overstory", "worktrees", "my-agent");
+		const subDir = join(worktreeBase, "sub");
+		await mkdir(subDir, { recursive: true });
+		await mkdir(join(tempDir, ".overstory"), { recursive: true });
+		await Bun.write(
+			join(tempDir, ".overstory", "config.yaml"),
+			"project:\n  canonicalBranch: main\n",
+		);
+		const result = await resolveProjectRoot(subDir);
+		expect(result).toBe(tempDir);
+	});
+
+	test("walk-up is skipped when parent has no config.yaml", async () => {
+		// Same path structure but NO config.yaml at parentRoot
+		const worktreeBase = join(tempDir, ".overstory", "worktrees", "my-agent");
+		await mkdir(worktreeBase, { recursive: true });
+		// No config.yaml written — walk-up guard should prevent false resolution
+		const result = await resolveProjectRoot(worktreeBase);
+		// Falls through to startDir fallback
+		expect(result).toBe(worktreeBase);
+	});
+});
+
 describe("projectRootOverride", () => {
 	let tempDir: string;
 

package/src/config.ts

@@ -905,7 +905,26 @@ export async function resolveProjectRoot(startDir: string): Promise<string> {
 
 	const { existsSync } = require("node:fs") as typeof import("node:fs");
 
-	// Check git worktree FIRST. When running from an agent worktree
+	// Check OVERSTORY_PROJECT_ROOT env var. Zero-heuristic — injected by ov sling
+	// into agent environments so submodule topology doesn't matter.
+	const envRoot = process.env.OVERSTORY_PROJECT_ROOT;
+	if (envRoot && envRoot.length > 0) {
+		return envRoot;
+	}
+
+	// Walk-up worktree-path detection. Topology-independent submodule fix:
+	// if startDir contains /.overstory/worktrees/ as a path segment, the
+	// substring before it is the project root — verify with config.yaml.
+	const WT_SEGMENT = `/${OVERSTORY_DIR}/worktrees/`;
+	const idx = startDir.indexOf(WT_SEGMENT);
+	if (idx > 0) {
+		const parentRoot = startDir.slice(0, idx);
+		if (existsSync(join(parentRoot, OVERSTORY_DIR, CONFIG_FILENAME))) {
+			return parentRoot;
+		}
+	}
+
+	// Check git worktree. When running from an agent worktree
 	// (e.g., .overstory/worktrees/{name}/), the worktree may contain
 	// tracked copies of .overstory/config.yaml. We must resolve to the
 	// main repository root so runtime state (mail.db, metrics.db, etc.)

package/src/doctor/consistency.ts

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { openSessionStore } from "../sessions/compat.ts";
 import type { AgentSession, OverstoryConfig } from "../types.ts";
 import { listWorktrees } from "../worktree/manager.ts";
-import { isProcessAlive, listSessions } from "../worktree/tmux.ts";
+import { isProcessAlive, listSessions, sanitizeTmuxName } from "../worktree/tmux.ts";
 import type { DoctorCheck } from "./types.ts";
 
 /**
@@ -134,7 +134,7 @@ export async function checkConsistency(
 
 	// 5. Check for orphaned tmux sessions (tmux session exists but no SessionStore entry)
 	const projectName = config.project.name;
-	const overstoryTmuxPrefix = `overstory-${projectName}-`;
+	const overstoryTmuxPrefix = `overstory-${sanitizeTmuxName(projectName)}-`;
 	const overstoryTmuxSessions = tmuxSessions.filter((s) => s.name.startsWith(overstoryTmuxPrefix));
 	const storeTmuxNames = new Set(storeSessions.map((s) => s.tmuxSession));
 

package/src/index.ts

@@ -51,7 +51,7 @@ import { ConfigError, OverstoryError, WorktreeError } from "./errors.ts";
 import { jsonError } from "./json.ts";
 import { brand, chalk, muted, setQuiet } from "./logging/color.ts";
 
-export const VERSION = "0.9.2";
+export const VERSION = "0.9.4";
 
 const rawArgs = process.argv.slice(2);
 

package/src/runtimes/codex.test.ts

@@ -203,7 +203,7 @@ describe("CodexRuntime", () => {
 			expect(cmd1).toBe(cmd2);
 		});
 
-		test("all model names pass through unchanged", () => {
+		test("all bare model names pass through unchanged", () => {
 			for (const model of ["gpt-5-codex", "gpt-4o", "o3", "custom-model-v2"]) {
 				const opts: SpawnOpts = {
 					model,
@@ -216,6 +216,30 @@ describe("CodexRuntime", () => {
 			}
 		});
 
+		test("provider-prefixed model strips prefix (openai/gpt-5.4 → gpt-5.4)", () => {
+			const opts: SpawnOpts = {
+				model: "openai/gpt-5.4",
+				permissionMode: "bypass",
+				cwd: "/tmp",
+				env: {},
+			};
+			const cmd = runtime.buildSpawnCommand(opts);
+			expect(cmd).toContain("--model gpt-5.4");
+			expect(cmd).not.toContain("openai/");
+		});
+
+		test("provider-prefixed model with other providers strips prefix", () => {
+			const opts: SpawnOpts = {
+				model: "azure/gpt-4o",
+				permissionMode: "bypass",
+				cwd: "/tmp",
+				env: {},
+			};
+			const cmd = runtime.buildSpawnCommand(opts);
+			expect(cmd).toContain("--model gpt-4o");
+			expect(cmd).not.toContain("azure/");
+		});
+
 		test("systemPrompt field is ignored", () => {
 			const opts: SpawnOpts = {
 				model: "gpt-5-codex",
@@ -248,6 +272,19 @@ describe("CodexRuntime", () => {
 			]);
 		});
 
+		test("provider-prefixed model strips prefix (openai/gpt-5.4 → gpt-5.4)", () => {
+			const argv = runtime.buildPrintCommand("Classify this error", "openai/gpt-5.4");
+			expect(argv).toEqual([
+				"codex",
+				"exec",
+				"--full-auto",
+				"--ephemeral",
+				"--model",
+				"gpt-5.4",
+				"Classify this error",
+			]);
+		});
+
 		test("model undefined omits --model flag", () => {
 			const argv = runtime.buildPrintCommand("Hello", undefined);
 			expect(argv).not.toContain("--model");

package/src/runtimes/codex.ts

@@ -49,6 +49,21 @@ export class CodexRuntime implements AgentRuntime {
 	 */
 	private static readonly MANIFEST_ALIASES = new Set(["sonnet", "opus", "haiku"]);
 
+	/**
+	 * Strip a provider prefix from a model ID.
+	 *
+	 * Codex CLI expects bare model names. The orchestrator may resolve a model to
+	 * a provider-qualified form (e.g. `"openai/gpt-5.4"`) — strip the `"openai/"`
+	 * prefix before passing to the CLI.
+	 *
+	 * @param model - Possibly provider-qualified model ID
+	 * @returns Bare model name (everything after the first `/`, or unchanged if no `/`)
+	 */
+	private static stripProviderPrefix(model: string): string {
+		const slashIdx = model.indexOf("/");
+		return slashIdx !== -1 ? model.slice(slashIdx + 1) : model;
+	}
+
 	/**
 	 * Escape a directory path for use in a single-quoted shell argument.
 	 *
@@ -75,11 +90,14 @@ export class CodexRuntime implements AgentRuntime {
 	 * @returns Shell command string suitable for tmux new-session -c
 	 */
 	buildSpawnCommand(opts: SpawnOpts): string {
+		// Strip provider prefix before alias check and model flag injection.
+		// Codex CLI expects bare model names (e.g. "gpt-5.4", not "openai/gpt-5.4").
+		const bareModel = CodexRuntime.stripProviderPrefix(opts.model);
 		// When model comes from default manifest aliases (sonnet/opus/haiku),
 		// omit --model so Codex uses the user's configured default model.
 		let cmd = "codex --full-auto";
-		if (!CodexRuntime.MANIFEST_ALIASES.has(opts.model)) {
-			cmd += ` --model ${opts.model}`;
+		if (!CodexRuntime.MANIFEST_ALIASES.has(bareModel)) {
+			cmd += ` --model ${bareModel}`;
 		}
 		for (const dir of opts.sharedWritableDirs ?? []) {
 			cmd += ` --add-dir '${CodexRuntime.shellEscape(dir)}'`;
@@ -119,7 +137,8 @@ export class CodexRuntime implements AgentRuntime {
 	buildPrintCommand(prompt: string, model?: string): string[] {
 		const cmd = ["codex", "exec", "--full-auto", "--ephemeral"];
 		if (model !== undefined) {
-			cmd.push("--model", model);
+			// Strip provider prefix — Codex CLI expects bare model names.
+			cmd.push("--model", CodexRuntime.stripProviderPrefix(model));
 		}
 		cmd.push(prompt);
 		return cmd;