jeo-code 0.1.0 → 0.4.5

package/src/commands/mcp.ts

@@ -8,11 +8,11 @@ export async function runMcpCommand(args: string[]): Promise<void> {
   }
   if (sub === "tools") {
     const { TOOLS } = await import("../mcp");
-    console.log(`Available joc-mcp tools (${TOOLS.length}):`);
+    console.log(`Available jeo-mcp tools (${TOOLS.length}):`);
     for (const t of TOOLS) console.log(`  ${t.name.padEnd(28)} ${t.description}`);
     return;
   }
-  console.log(`unknown 'joc mcp' subcommand: ${sub}`);
-  console.log("Usage: joc mcp [serve|tools]");
+  console.log(`unknown 'jeo mcp' subcommand: ${sub}`);
+  console.log("Usage: jeo mcp [serve|tools]");
   process.exit(1);
 }

package/src/commands/ooo-seed.ts

@@ -0,0 +1,19 @@
+import { syncSpecificationToSeed } from "../agent/dev/spec-automation";
+import { categoryBadge } from "../tui/components/category-index";
+import chalk from "chalk";
+
+/**
+ * jeo ooo-seed: Syncs .specify/specification.md to an ooo seed.
+ */
+export async function runOooSeedCommand(args: string[]): Promise<void> {
+  const cwd = process.cwd();
+  console.log(`\n=== ${chalk.bold("ooo seed")} Specification Sync ===`);
+  
+  try {
+    await syncSpecificationToSeed(cwd);
+    console.log(`\n${categoryBadge("done")} ooo seed sync completed.`);
+  } catch (err: any) {
+    console.error(`\n${categoryBadge("error")} ooo seed sync failed: ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/ralplan.ts

@@ -1,35 +1,124 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { callLlm } from "../agent/loop";
+import { callLlm, type Message } from "../agent/loop";
 import {
   readWorkflowState,
   writeWorkflowState,
-  getLocalJocDir,
+  readGlobalConfig,
+  getLocalJeoDir,
   type WorkflowState,
 } from "../agent/state";
+import { PlanSchema, normalizePlanShape, parseYaml } from "../agent/plan";
+import {
+  getSubagentRole,
+  subagentSystemPrompt,
+  subagentToolset,
+  validateSubagentDoneReason,
+  resolveSubagentModel,
+  resolveSubagentMaxSteps,
+} from "../agent/subagents";
+import { runAgentLoop } from "../agent/engine";
 
-export async function runRalplanCommand(): Promise<void> {
-  const cwd = process.cwd();
+/** Round-11 (architect ref 8-Round10Planning #1): the REAL consensus gate. A
+ *  read-only critic SUBAGENT (repo access via read/search/find) reviews the
+ *  candidate plan and must return an explicit verdict — unlike the drafting
+ *  passes, this one can actually BLOCK. Fail-closed: anything but a clean
+ *  [OKAY] contract is non-approval. */
+export async function runConsensusCriticGate(args: {
+  cwd: string;
+  seedContent: string;
+  plan: string;
+  signal?: AbortSignal;
+}): Promise<{ verdict: "okay" | "iterate" | "reject" | "unverified"; detail: string }> {
+  const role = getSubagentRole("critic")!;
+  const config = await readGlobalConfig();
+  const model = resolveSubagentModel(role.id, config);
+  const maxSteps = resolveSubagentMaxSteps(role.id, config);
+  const history: Message[] = [
+    { role: "system", content: subagentSystemPrompt(role) },
+    {
+      role: "user",
+      content:
+        `Review this implementation plan BEFORE it can be approved for execution.\n\n` +
+        `Crystallized spec (seed.yaml):\n${args.seedContent}\n\n` +
+        `Proposed plan (YAML — 'jeo team' executes the steps strictly top-to-bottom):\n${args.plan}\n\n` +
+        `Verify against the ACTUAL repository (use read/search/find/ls): file targets exist or are sensibly placed, ` +
+        `steps are ordered and independently verifiable, and the acceptance criteria are covered. ` +
+        `Then call done — your reason MUST start with [OKAY], [ITERATE], or [REJECT] and include a 'Justification:' section.`,
+    },
+  ];
+  const result = await runAgentLoop(history, {
+    cwd: args.cwd,
+    model,
+    maxSteps,
+    budget: { maxExtensions: 0 },
+    signal: args.signal,
+    tools: subagentToolset(role),
+  });
+  const reason = result.doneReason?.trim() ?? "";
+  if (!result.done) return { verdict: "unverified", detail: reason || `critic did not converge within ${result.steps} steps` };
+  const contract = validateSubagentDoneReason(role, reason);
+  if (!contract.ok) return { verdict: "unverified", detail: `critic report incomplete (missing ${contract.missing?.join(", ")}): ${reason.slice(0, 300)}` };
+  const firstLine = reason.split(/\r?\n/, 1)[0]?.trim() ?? "";
+  const verdict = firstLine === "[OKAY]" ? "okay" : firstLine === "[ITERATE]" ? "iterate" : firstLine === "[REJECT]" ? "reject" : "unverified";
+  return { verdict, detail: reason };
+}
+
+export interface RalplanEngineOptions {
+  cwd?: string;
+  signal?: AbortSignal;
+  onProgress?: (e: { skill: string; phase: string; detail?: string }) => void;
+  io?: {
+    output?: (line: string) => void;
+  };
+}
+
+export async function runRalplanEngine(opts: RalplanEngineOptions = {}): Promise<{ ok: boolean; reason?: string }> {
+  const cwd = opts.cwd ?? process.cwd();
+
+  const log = (msg?: any) => {
+    const str = msg !== undefined ? String(msg) : "";
+    if (opts.io?.output) {
+      const lines = str.split("\n");
+      for (const line of lines) {
+        opts.io.output(line);
+      }
+    } else {
+      console.log(str);
+    }
+  };
+
+  if (opts.onProgress) {
+    opts.onProgress({ skill: "ralplan", phase: "start" });
+  }
+
+  if (opts.signal?.aborted) {
+    return { ok: false, reason: "aborted" };
+  }
 
   // Read deep-interview state
   const interviewState = await readWorkflowState("deep-interview", cwd);
   if (!interviewState || interviewState.current_phase !== "complete" || !interviewState.seed_path) {
-    console.log(
-      `[ERROR] No crystallized requirements found. Please run 'joc deep-interview' to crystallize requirements first.`
+    log(
+      `[ERROR] No crystallized requirements found. Please run 'jeo deep-interview' to crystallize requirements first.`
     );
-    return;
+    return { ok: false, reason: "No crystallized requirements found" };
   }
 
   const seedPath = interviewState.seed_path;
-  console.log(`\n=== Starting Ralplan Planning Stage ===`);
-  console.log(`Reading requirements seed from: ${seedPath}`);
+  log(`\n=== Starting Ralplan Planning Stage ===`);
+  log(`Reading requirements seed from: ${seedPath}`);
 
   let seedContent = "";
   try {
     seedContent = await fs.readFile(seedPath, "utf-8");
   } catch (err: any) {
-    console.log(`[ERROR] Failed to read seed file: ${err.message}`);
-    return;
+    log(`[ERROR] Failed to read seed file: ${err.message}`);
+    return { ok: false, reason: err.message };
+  }
+
+  if (opts.signal?.aborted) {
+    return { ok: false, reason: "aborted" };
   }
 
   // Initialize ralplan state
@@ -42,45 +131,174 @@ export async function runRalplanCommand(): Promise<void> {
   };
   await writeWorkflowState("ralplan", ralplanState, cwd);
 
-  console.log("Generating resilient task sequence plan (Critiqued by Planner/Architect/Critic)...");
+  log("Running Planner → Architect drafting passes + a repo-grounded Critic consensus gate…");
 
-  // Standard multi-role system prompt
-  const systemPrompt = 
-    `You are the Ralplan Orchestrator, combining three expert roles:\n` +
-    `1. Planner: Focuses on sequencing tasks into a highly logical, outcome-based progression.\n` +
-    `2. Architect: Reviews technical feasibility, structural directories, and patterns.\n` +
-    `3. Critic: Critiques the plan for vagueness, redundant copies, and missing steps.\n\n` +
-    `Analyze the given crystallized spec (seed.yaml) and generate a step-by-step implementation plan.\n` +
-    `Output the final plan in YAML format. Ensure it contains a clear sequence of tasks with descriptive names and target files.\n` +
-    `Output ONLY the YAML. Do not include markdown wraps or code blocks.`;
+  // Shared output contract (the exact shape `team` consumes) included in every pass.
+  const SCHEMA_SPEC =
+    `Output the plan as YAML with EXACTLY this shape (no prose, no markdown, no code fences):\n` +
+    `name: "<short plan name>"\n` +
+    `steps:\n` +
+    `  - name: "<imperative task, e.g. Implement reverse() in src/reverse.ts>"\n` +
+    `    role: executor   # one of: executor | planner | architect | critic\n` +
+    `    target: "<primary file path>"\n` +
+    `Provide 3-8 concrete, ordered steps. Output ONLY the YAML.`;
 
-  const messages = [
-    { role: "user" as const, content: `Here is the crystallized spec (seed.yaml):\n\n${seedContent}` }
-  ];
+  const PLANNER = `You are the PLANNER. From the crystallized spec, sequence the work into a logical, outcome-based progression of concrete, ordered tasks.\n` + SCHEMA_SPEC;
+  const ARCHITECT = `You are the ARCHITECT. Review the Planner's draft for technical feasibility, correct file targets, directory structure, and any missing setup/wiring/test steps. Return an improved plan (same shape).\n` + SCHEMA_SPEC;
+  const CRITIC = `You are the CRITIC. Finalize the plan: remove vague or redundant steps, make each step actionable and independently verifiable, and ensure the acceptance criteria are covered. Return the final plan (same shape).\n` + SCHEMA_SPEC;
 
   try {
-    const rawPlan = await callLlm(messages, { systemPrompt });
-    const cleanPlan = rawPlan.replace(/```yaml|```/g, "").trim();
+    const callRole = async (systemPrompt: string, userContent: string): Promise<string> => {
+      const raw = await callLlm([{ role: "user" as const, content: userContent }], { systemPrompt });
+      return raw.replace(/```yaml|```/g, "").trim();
+    };
+    const isValidPlan = (yaml: string): boolean => {
+      try {
+        const parsed = PlanSchema.safeParse(normalizePlanShape(parseYaml(yaml)));
+        if (!parsed.success) return false;
+        // Round-10 #2 (architect ref 8-Round10Planning): write-time parity with
+        // team's execution gate — an unknown role (e.g. "developer") used to pass
+        // here and abort only at `jeo team`, after the planning model was gone.
+        return parsed.data.steps.every(s => !s.role?.trim() || !!getSubagentRole(s.role));
+      } catch {
+        return false;
+      }
+    };
 
-    const planDir = path.join(getLocalJocDir(cwd), "plans");
+    if (opts.signal?.aborted) {
+      return { ok: false, reason: "aborted" };
+    }
+
+    // Three chained role passes, each consuming the prior output (gjc consensus).
+    log("  [1/3] Planner drafting the task sequence…");
+    if (opts.onProgress) {
+      opts.onProgress({ skill: "ralplan", phase: "planning", detail: "Planner drafting" });
+    }
+    const draft = await callRole(PLANNER, `Crystallized spec (seed.yaml):\n\n${seedContent}`);
+
+    if (opts.signal?.aborted) {
+      return { ok: false, reason: "aborted" };
+    }
+
+    log("  [2/3] Architect reviewing feasibility & structure…");
+    if (opts.onProgress) {
+      opts.onProgress({ skill: "ralplan", phase: "planning", detail: "Architect reviewing" });
+    }
+    const reviewed = await callRole(ARCHITECT, `Crystallized spec (seed.yaml):\n\n${seedContent}\n\nPlanner's draft plan:\n\n${draft}\n\nReturn the improved plan.`);
+
+    if (opts.signal?.aborted) {
+      return { ok: false, reason: "aborted" };
+    }
+
+    log("  [3/3] Critic finalizing (tightening + verifiability)…");
+    if (opts.onProgress) {
+      opts.onProgress({ skill: "ralplan", phase: "planning", detail: "Critic finalizing" });
+    }
+    let cleanPlan = await callRole(CRITIC, `Crystallized spec (seed.yaml):\n\n${seedContent}\n\nArchitect's plan:\n\n${reviewed}\n\nReturn the final, critiqued plan.`);
+
+    if (opts.signal?.aborted) {
+      return { ok: false, reason: "aborted" };
+    }
+
+    // Self-validate the Critic's output against team's schema (incl. role names);
+    // repair once, else fall back to the best valid earlier pass. When NO pass is
+    // valid, the plan is saved for inspection but the workflow is NOT marked
+    // complete (round-10 #2) — failing here, while the model is still in the loop,
+    // beats failing later at `jeo team` with the same plan.
+    let planValid = true;
+    if (!isValidPlan(cleanPlan)) {
+      log("[ralplan] Final plan did not match the required shape; requesting a corrected plan…");
+      cleanPlan = await callRole(CRITIC, `Your previous output was not valid for the required schema. Fix it (roles MUST be one of executor|planner|architect|critic).\n\n${SCHEMA_SPEC}\n\nPlan to fix:\n\n${cleanPlan}`);
+      if (!isValidPlan(cleanPlan)) {
+        const fallback = [reviewed, draft].find(isValidPlan);
+        if (fallback) {
+          cleanPlan = fallback;
+          log("[ralplan] Using an earlier valid pass output (Critic output was unparseable).");
+        } else {
+          planValid = false;
+        }
+      }
+    }
+
+    const planDir = path.join(getLocalJeoDir(cwd), "plans");
     await fs.mkdir(planDir, { recursive: true });
     const planPath = path.join(planDir, `plan-${interviewState.slug}.yaml`);
 
     await fs.writeFile(planPath, cleanPlan, "utf-8");
-    console.log(`\n[SUCCESS] Plan successfully created and saved to: ${planPath}`);
 
-    ralplanState.current_phase = "complete";
+    if (!planValid) {
+      ralplanState.plan_path = planPath; // saved for inspection — but NOT complete
+      ralplanState.approved = false;
+      await writeWorkflowState("ralplan", ralplanState, cwd);
+      log(
+        `[ERROR] No pass produced a schema/role-valid plan. The last output was saved to ${planPath} for review, ` +
+        `but the workflow was NOT marked complete — edit the plan to match the schema (roles: executor|planner|architect|critic) ` +
+        `and re-run 'jeo ralplan', or retry with a stronger model.`,
+      );
+      return { ok: false, reason: "no schema-valid plan produced" };
+    }
+
+    // Round-11: REAL consensus gate — a read-only critic subagent with repo
+    // access must return [OKAY] before this plan can be marked complete. One
+    // [ITERATE] revision round is honored; anything else fails closed.
+    log("  [gate] Consensus critic (read-only subagent) reviewing the plan against the repo…");
+    if (opts.onProgress) {
+      opts.onProgress({ skill: "ralplan", phase: "planning", detail: "Critic gate reviewing" });
+    }
+    let gate = await runConsensusCriticGate({ cwd, seedContent, plan: cleanPlan, signal: opts.signal });
+    if (gate.verdict === "iterate") {
+      log(`[ralplan] Critic returned [ITERATE] — revising the plan once to address the justification…`);
+      const revised = await callRole(
+        CRITIC,
+        `The consensus critic returned [ITERATE] on the plan with this justification:\n\n${gate.detail}\n\n` +
+        `Revise the plan to address every point.\n\n${SCHEMA_SPEC}\n\nCurrent plan:\n\n${cleanPlan}`,
+      );
+      if (isValidPlan(revised)) {
+        cleanPlan = revised;
+        await fs.writeFile(planPath, cleanPlan, "utf-8");
+        gate = await runConsensusCriticGate({ cwd, seedContent, plan: cleanPlan, signal: opts.signal });
+      }
+    }
     ralplanState.plan_path = planPath;
+    ralplanState.consensus = gate.verdict;
+    ralplanState.consensus_detail = gate.detail.slice(0, 600);
+    if (gate.verdict !== "okay") {
+      ralplanState.approved = false;
+      await writeWorkflowState("ralplan", ralplanState, cwd);
+      log(
+        `[ERROR] Consensus critic did NOT approve the plan (verdict: ${gate.verdict.toUpperCase()}).\n` +
+        `  Justification:\n${gate.detail.slice(0, 800)}\n` +
+        `  The plan was saved to ${planPath} but the workflow was NOT marked complete — address the justification and re-run 'jeo ralplan'.`,
+      );
+      return { ok: false, reason: `critic verdict: ${gate.verdict}` };
+    }
+    log(`  [gate] Critic verdict: [OKAY] — consensus recorded.`);
+
+    log(`\n[SUCCESS] Plan successfully created and saved to: ${planPath}`);
+
+    ralplanState.current_phase = "complete";
     ralplanState.approved = false;
     await writeWorkflowState("ralplan", ralplanState, cwd);
 
-    console.log("\nPlan preview:");
-    console.log("-----------------------------------------");
-    console.log(cleanPlan);
-    console.log("-----------------------------------------");
-    console.log("\n[Handoff Ready] The blueprint is prepared. Run 'joc team' to execute the plan.");
+    log("\nPlan preview:");
+    log("-----------------------------------------");
+    log(cleanPlan);
+    log("-----------------------------------------");
+    log(`\n[Handoff Ready] The blueprint is prepared but NOT yet approved.`);
+    log(`  1) Review it, then approve:  jeo approve "${planPath}"`);
+    log(`  2) Execute the plan:         jeo team`);
+
+    if (opts.onProgress) {
+      opts.onProgress({ skill: "ralplan", phase: "complete" });
+    }
+    return { ok: true };
 
   } catch (error: any) {
-    console.log(`[ERROR calling LLM during Planning]: ${error.message}`);
+    log(`[ERROR calling LLM during Planning]: ${error.message}`);
+    return { ok: false, reason: error.message };
   }
 }
+
+export async function runRalplanCommand(): Promise<void> {
+  await runRalplanEngine();
+}

package/src/commands/resume.ts

@@ -1,6 +1,6 @@
 import { runLaunchCommand } from "./launch";
 
-/** `joc resume [id]` — resume the latest (or a specific) interactive session. */
+/** `jeo resume [id]` — resume the latest (or a specific) interactive session. */
 export async function runResumeCommand(args: string[] = []): Promise<void> {
   return runLaunchCommand(["--resume", ...args]);
 }

package/src/commands/session.ts

@@ -0,0 +1,183 @@
+import { spawnSync } from "bun";
+
+export type RunTmuxFn = (
+  argv: string[]
+) => { exitCode: number; stdout: string; stderr: string } | Promise<{ exitCode: number; stdout: string; stderr: string }>;
+
+export const defaultRunTmux: RunTmuxFn = (argv: string[]) => {
+  const isAttach = argv[0] === "attach" || argv[0] === "attach-session";
+  const proc = Bun.spawnSync(["tmux", ...argv], {
+    stdout: isAttach ? "inherit" : "pipe",
+    stderr: isAttach ? "inherit" : "pipe",
+    stdin: isAttach ? "inherit" : "pipe",
+  });
+  return {
+    exitCode: proc.exitCode,
+    stdout: proc.stdout ? proc.stdout.toString() : "",
+    stderr: proc.stderr ? proc.stderr.toString() : "",
+  };
+};
+
+interface SessionInfo {
+  name: string;
+  created: string;
+  attached: boolean;
+  /** Carries the `@jeo-profile` ownership marker set by `jeo --tmux` (gjc `@gjc-profile` parity). */
+  owned: boolean;
+  /** `@jeo-branch` identity recorded at session creation, when present. */
+  branch?: string;
+  /** `@jeo-project` (cwd) identity recorded at session creation, when present. */
+  project?: string;
+}
+
+function printUsage(): void {
+  console.log("Usage: jeo session [list] [--json]");
+  console.log("       jeo session attach <name>");
+  console.log("       jeo session rm/kill <name>");
+}
+
+/** Exact-name tmux session target: `=name` is exact-matched (never prefix-matched)
+ *  and accepted by attach-session/kill-session on every supported tmux. (Option
+ *  commands need the `=name:` form instead — see launch.ts `tmuxProfileCommands`.) */
+function exactTarget(name: string): string {
+  return `=${name}`;
+}
+
+const LIST_FORMAT =
+  "#{session_name}\t#{session_created}\t#{session_attached}\t#{@jeo-profile}\t#{@jeo-branch}\t#{@jeo-project}";
+
+async function getJeoSessions(runTmux: RunTmuxFn): Promise<SessionInfo[] | null> {
+  try {
+    const res = await runTmux(["list-sessions", "-F", LIST_FORMAT]);
+    if (res.exitCode !== 0) {
+      return null;
+    }
+    const sessions: SessionInfo[] = [];
+    const lines = res.stdout.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const parts = trimmed.split("\t");
+      if (parts.length < 3) continue;
+      const [name, created, attached, marker, branch, project] = parts;
+      const owned = marker === "1";
+      // Ownership: the `@jeo-profile` marker is authoritative (set by `jeo --tmux`
+      // regardless of how the session is named); the `jeo-` name prefix is accepted
+      // for directly named sessions.
+      if (!owned && !name.startsWith("jeo-")) continue;
+
+      const createdSeconds = parseInt(created, 10);
+      const createdIso = isNaN(createdSeconds) ? "" : new Date(createdSeconds * 1000).toISOString();
+      sessions.push({
+        name,
+        created: createdIso,
+        attached: attached === "1",
+        owned,
+        ...(branch ? { branch } : {}),
+        ...(project ? { project } : {}),
+      });
+    }
+    return sessions;
+  } catch {
+    return null;
+  }
+}
+
+export async function runSessionCommand(args: string[]): Promise<void> {
+  await runSessionCommandWith(args, defaultRunTmux);
+}
+
+export async function runSessionCommandWith(args: string[], runTmux: RunTmuxFn): Promise<void> {
+  const isHelp = args.includes("--help") || args.includes("-h");
+  if (isHelp) {
+    printUsage();
+    process.exitCode = 0;
+    return;
+  }
+
+  const isJson = args.includes("--json");
+  const cleanArgs = args.filter(a => a !== "--json");
+  const verb = cleanArgs[0];
+
+  if (!verb || verb === "list") {
+    const sessions = await getJeoSessions(runTmux);
+    if (!sessions || sessions.length === 0) {
+      if (isJson) {
+        console.log("[]");
+      } else {
+        console.log("No active jeo sessions found.");
+      }
+      process.exitCode = 0;
+      return;
+    }
+
+    if (isJson) {
+      console.log(JSON.stringify(sessions, null, 2));
+    } else {
+      const branchOf = (s: SessionInfo): string => s.branch ?? "";
+      const nameWidth = Math.max("Name".length, ...sessions.map(s => s.name.length));
+      const createdWidth = Math.max("Created".length, ...sessions.map(s => s.created.length));
+      const branchWidth = Math.max("Branch".length, ...sessions.map(s => branchOf(s).length));
+
+      console.log(`${"Name".padEnd(nameWidth)}  ${"Created".padEnd(createdWidth)}  ${"Branch".padEnd(branchWidth)}  Attached`);
+      for (const s of sessions) {
+        const attachedStr = s.attached ? "yes" : "no";
+        console.log(`${s.name.padEnd(nameWidth)}  ${s.created.padEnd(createdWidth)}  ${branchOf(s).padEnd(branchWidth)}  ${attachedStr}`);
+      }
+    }
+    process.exitCode = 0;
+    return;
+  }
+
+  if (verb === "attach") {
+    const name = cleanArgs[1];
+    if (!name) {
+      console.log("Error: Session name required.");
+      process.exitCode = 1;
+      return;
+    }
+
+    const sessions = await getJeoSessions(runTmux);
+    const exists = sessions ? sessions.some(s => s.name === name) : false;
+    if (!exists) {
+      console.log(`Error: Session '${name}' not found.`);
+      process.exitCode = 1;
+      return;
+    }
+
+    const res = await runTmux(["attach", "-t", exactTarget(name)]);
+    process.exitCode = res.exitCode;
+    return;
+  }
+
+  if (verb === "rm" || verb === "kill") {
+    const name = cleanArgs[1];
+    if (!name) {
+      console.log("Error: Session name required.");
+      process.exitCode = 1;
+      return;
+    }
+
+    // Ownership gate (gjc parity): the `jeo-` name prefix allows directly,
+    // and any session carrying the `@jeo-profile` marker (set by `jeo --tmux`)
+    // is jeo-owned regardless of its name. Everything else is refused.
+    if (!name.startsWith("jeo-")) {
+      const sessions = await getJeoSessions(runTmux);
+      const owned = sessions?.some(s => s.name === name && s.owned) ?? false;
+      if (!owned) {
+        console.log(`Error: Refusing to kill non-jeo session '${name}'.`);
+        process.exitCode = 1;
+        return;
+      }
+    }
+
+    const res = await runTmux(["kill-session", "-t", exactTarget(name)]);
+    process.exitCode = res.exitCode;
+    return;
+  }
+
+  // Unknown verb
+  console.log(`Unknown subcommand: ${verb}`);
+  printUsage();
+  process.exitCode = 1;
+}

package/src/commands/setup-helpers.ts

@@ -1,10 +1,11 @@
 /**
- * Pure helpers for the model/provider setting flow (`joc setup`). Extracted from
+ * Pure helpers for the model/provider setting flow (`jeo setup`). Extracted from
  * the readline-driven command so the validation, normalization, recommendation,
  * and summary logic is unit-testable without a TTY.
  */
 import type { ProviderName } from "../ai/types";
 import { recommendedModel, validateModelId, suggestModels, findCatalogEntry, catalogForProvider } from "../ai/model-catalog-compat";
+import { CODEX_MODELS } from "../ai/model-catalog";
 import { resolveProvider } from "../ai/model-manager";
 import type { Config } from "../agent/state";
 
@@ -56,7 +57,13 @@ export function chooseDefaultModel(typed: string | undefined, provider: Provider
 }
 
 /** Top-N recommended catalog rows for a provider, as `id — note` display lines. */
-export function recommendedModelsFor(provider: ProviderName, n = 5): string[] {
+export function recommendedModelsFor(provider: ProviderName, n = 5, opts: { codex?: boolean } = {}): string[] {
+  if (provider === "openai" && opts.codex) {
+    return CODEX_MODELS.slice(0, n).map(id => {
+      const entry = findCatalogEntry(id);
+      return `${id}${entry?.note ? ` — ${entry.note}, Codex OAuth` : " — Codex OAuth"}`;
+    });
+  }
   return catalogForProvider(provider)
     .slice(0, n)
     .map(e => `${e.id}${e.note ? ` — ${e.note}` : ""}`);
@@ -68,7 +75,7 @@ export function buildEnabledProviders(config: Config): string[] {
   const cfg = config as Config & { openaiBaseUrl?: string };
   if (cfg.providers?.anthropic || cfg.oauth?.anthropic) enabled.push("anthropic");
   if (cfg.providers?.openai || cfg.oauth?.openai) enabled.push("openai");
-  if (cfg.providers?.gemini || cfg.oauth?.gemini) enabled.push("gemini");
+  if (cfg.providers?.gemini || cfg.oauth?.gemini || cfg.providers?.antigravity || cfg.oauth?.antigravity) enabled.push("google-oauth");
   if (cfg.ollamaBaseUrl) enabled.push(`ollama(${cfg.ollamaBaseUrl})`);
   if (cfg.openaiBaseUrl) enabled.push(`openai-compatible(${cfg.openaiBaseUrl})`);
   return enabled;