codewake 0.0.1 → 0.0.2

package/README.md

@@ -4,9 +4,11 @@
 
 `codewake` is an interactive CLI that detects the coding agents installed on your machine — Claude Code, OpenAI Codex CLI, GitHub Copilot CLI, Gemini CLI, Cursor CLI, OpenCode, Aider, Goose, Amp, Qwen Code — lets you pick a session (or start a new one), choose a prompt, and launches the agent at the time you choose. Hit a usage limit at 2 AM? Schedule the resume for when it resets and go to sleep.
 
-- **Interactive console** — arrow keys, sensible defaults, a summary before anything is scheduled.
+- **Interactive console** — two entries: *Schedule / wake an agent* and *Waked agents*, a job browser with agent/text filters where every action is one key (open, retry, cancel, sweep) and the shortcuts are always visible. Leave with a double ctrl+c/ctrl+d.
+- **Open a job's session** — jump from any job straight into the agent's own terminal UI (`claude --resume …`, `codex resume …`, …) to watch or take over what the agent did.
 - **Agent auto-detection** — scans your `PATH` for every supported agent; extend or override the list with a small JSON config.
 - **Session discovery** — lists your existing Claude Code and Codex sessions (with titles and timestamps) for the current project; other agents accept a session id or start fresh.
+- **Right-place resumes** — agents like Claude Code can only resume a session from the project directory it belongs to. codewake locates the session across all your projects and runs the job from the right directory (and tells you), instead of failing later with "No conversation found". If the project moved between scheduling and launch, the job follows it.
 - **Job management** — list, inspect logs, cancel, and clean up scheduled jobs from the console or with subcommands.
 - **Suspend-safe scheduling** — timers track the wall clock, so a laptop that sleeps through the launch time fires the job right after waking instead of drifting.
 - **Cross-platform** — Linux (systemd user timers), macOS, and Windows (detached waiter, `.cmd`-shim aware); CI runs on all three.
@@ -65,12 +67,17 @@ From the console (`codewake`) or directly:
 
 ```bash
 codewake jobs             # list scheduled and finished jobs
-codewake logs <job-id>    # output captured from the agent run
+codewake open <job-id>    # reopen the job's session in its agent's own UI
+codewake logs <job-id>    # job status plus the output captured from the run
 codewake cancel <job-id>  # cancel a pending job
+codewake retry <job-id>   # reschedule a failed/finished/overdue job
+                          #   (--now, --in, --at, --prompt, --project)
 codewake clear            # drop finished/cancelled jobs from the list
 codewake agents           # which agents were detected, and where
 ```
 
+Or interactively: `codewake` → **Waked agents** browses every job — `↑↓` move, `enter` opens the session in the agent's own terminal, `r` retries (asks when + prompt), `x` cancels, `s` sweeps finished jobs, `f` filters by agent, `/` searches, `esc` goes back. The shortcut bar at the bottom always shows what each key does.
+
 ## Non-interactive scheduling
 
 Everything the console does is available as flags — handy for scripts:
@@ -127,7 +134,7 @@ Add or override agents in `~/.config/codewake/config.json` (or point `CODEWAKE_C
 - On **Linux with systemd**, jobs are armed with a transient user timer (`systemd-run --user --on-calendar=…`). Wall-clock timers keep ticking through laptop suspend and fire on resume if their time passed while the lid was closed. They survive the terminal closing; if your machine logs you out completely, enable lingering once: `loginctl enable-linger "$USER"`.
 - On **macOS, Windows, and Linux without systemd**, a small detached Node process waits for the launch time. It re-checks the wall clock every minute rather than sleeping once, so a machine that suspends overnight launches the job right after waking instead of drifting by the suspended time. It survives the terminal closing, but not a reboot.
 
-A session can only have **one pending job** at a time — scheduling a second resume for the same session is refused until you cancel the first, so two agents never race each other over one transcript. Jobs whose launch time passed without running (e.g. after a reboot) show up as `overdue` in `codewake jobs`, with how late they are — reschedule them.
+A session can only have **one pending job** at a time — scheduling a second resume for the same session is refused until you cancel the first, so two agents never race each other over one transcript. Jobs whose launch time passed without running (e.g. after a reboot) show up as `overdue` in `codewake jobs` — reschedule them with `codewake retry <job-id>`.
 
 ### Where state and logs live
 
@@ -155,5 +162,3 @@ The test suite covers argument parsing, duration/time parsing, the agent registr
 ## License
 
 MIT
-
-This is a new line for testing purposes.

package/lib/actions.js

@@ -0,0 +1,165 @@
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { buildCommand, commandPreview, detectAgents, loadAgents } from './agents.js';
+import { cancelJob, displayStatus, loadJob, scheduleJob } from './jobs.js';
+import { spawnAgent } from './proc.js';
+import { resolveSessionPlacement } from './sessions.js';
+import { describeRunAt, parseClockTime, parseDuration } from './time.js';
+
+export const DEFAULT_RESUME_PROMPT = 'continue';
+
+/** Turn a when-descriptor ({type: now|in|at}) or a Date into a launch Date. */
+export function resolveRunAt(when, now = new Date()) {
+  if (when instanceof Date) return when;
+  if (when.type === 'in') return new Date(now.getTime() + parseDuration(when.value) * 1000);
+  if (when.type === 'at') return parseClockTime(when.value, now);
+  return now;
+}
+
+/**
+ * Validate and schedule a job from a spec: { agentId, sessionId, isNew,
+ * prompt, skipPermissions, project, when, bin, fallbackBin, dryRun }.
+ * Returns { job, preview, note }; `note` explains a corrected project.
+ */
+export function scheduleFromSpec(args, env = process.env) {
+  const detected = detectAgents(loadAgents({ env }), { env });
+  const entry = detected.find((candidate) => candidate.agent.id === args.agentId);
+  if (!entry) {
+    const known = detected.map((candidate) => candidate.agent.id).join(', ');
+    throw new Error(`Unknown agent "${args.agentId}". Known agents: ${known}.`);
+  }
+  const bin = args.bin ?? entry.bin ?? args.fallbackBin ?? null;
+  if (!bin) {
+    throw new Error(`${entry.agent.name} is not installed (looked for: ${entry.agent.bins.join(', ')}). Use --bin to point at it.`);
+  }
+  const mode = args.isNew ? 'create' : 'resume';
+  const prompt = args.prompt?.trim() || DEFAULT_RESUME_PROMPT;
+  let project = args.project;
+  let note = null;
+  if (mode === 'resume') {
+    const placement = resolveSessionPlacement(entry.agent, args.sessionId, {
+      project,
+      home: env.HOME || homedir(),
+    });
+    project = placement.project;
+    note = placement.note;
+  }
+  const commandArgs = buildCommand(entry.agent, {
+    mode,
+    sessionId: args.sessionId,
+    prompt,
+    skipPermissions: args.skipPermissions,
+  });
+  const job = scheduleJob({
+    agent: entry.agent,
+    bin,
+    args: commandArgs,
+    mode,
+    sessionId: args.sessionId,
+    prompt,
+    skipPermissions: args.skipPermissions,
+    project,
+    runAt: resolveRunAt(args.when),
+  }, { dryRun: args.dryRun, env });
+  return { job, preview: commandPreview(bin, commandArgs), note };
+}
+
+/**
+ * Re-schedule an existing job through the normal validation path, so the
+ * session is located again and a moved project is corrected instead of
+ * reproducing the original failure. `args`: { jobId, when, prompt, project,
+ * dryRun } — prompt/project default to the previous job's values.
+ */
+export function retryFromSpec(args, env = process.env) {
+  const previous = loadJob(args.jobId, env);
+  if (previous.status === 'running') {
+    throw new Error(`Job ${args.jobId} is still running; nothing to retry.`);
+  }
+  if (previous.status === 'pending') {
+    if (displayStatus(previous) !== 'overdue') {
+      throw new Error(
+        `Job ${args.jobId} is still pending (launching ${describeRunAt(previous.runAt)}). ` +
+        `Cancel it first: codewake cancel ${args.jobId}.`,
+      );
+    }
+    // Its launch window silently passed (reboot, killed waiter): disarm the
+    // stale schedule before arming a fresh one.
+    cancelJob(args.jobId, env);
+  }
+  return scheduleFromSpec({
+    agentId: previous.agentId,
+    sessionId: previous.sessionId,
+    isNew: previous.mode === 'create',
+    prompt: args.prompt ?? previous.prompt,
+    skipPermissions: previous.skipPermissions,
+    project: args.project ?? previous.project,
+    when: args.when,
+    // The bin the job was created with wins (it may have been a --bin
+    // override); if it disappeared, fall back to fresh detection.
+    bin: existsSync(previous.bin) ? previous.bin : null,
+    fallbackBin: previous.bin,
+    dryRun: args.dryRun,
+  }, env);
+}
+
+/**
+ * Work out how to reopen a job's session in its agent's own interactive
+ * terminal UI. Returns { agent, bin, args, project, note, preview }.
+ * Throws with a human explanation when the job cannot be opened.
+ */
+export function prepareOpen(job, env = process.env) {
+  if (!job.sessionId) {
+    throw new Error(`Job ${job.id} started a fresh session; there is no session id to reopen.`);
+  }
+  const detected = detectAgents(loadAgents({ env }), { env });
+  const entry = detected.find((candidate) => candidate.agent.id === job.agentId);
+  if (!entry) {
+    throw new Error(`Agent "${job.agentId}" is not configured anymore (check your codewake config).`);
+  }
+  const bin = entry.bin ?? (existsSync(job.bin) ? job.bin : null);
+  if (!bin) {
+    throw new Error(`${entry.agent.name} is not installed anymore (looked for: ${entry.agent.bins.join(', ')}).`);
+  }
+  const args = buildCommand(entry.agent, { mode: 'open', sessionId: job.sessionId });
+  // Same relocation as launches: the agent only finds the session from the
+  // project it belongs to, and the directory may have moved since.
+  let placement = null;
+  try {
+    placement = resolveSessionPlacement(entry.agent, job.sessionId, {
+      project: job.project,
+      home: env.HOME || homedir(),
+    });
+  } catch {
+    // Best effort: open from the recorded project and let the agent decide.
+  }
+  const project = placement?.project ?? job.project;
+  if (!existsSync(project)) {
+    throw new Error(`Project directory ${project} no longer exists (was it moved or renamed?).`);
+  }
+  return {
+    agent: entry.agent,
+    bin,
+    args,
+    project,
+    note: placement?.note ?? null,
+    preview: commandPreview(bin, args),
+  };
+}
+
+/**
+ * Hand the terminal over to the agent for a prepared open. Resolves with
+ * the agent's exit code once the user leaves it.
+ */
+export function attachOpen(prepared, { stdio = 'inherit' } = {}) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    let child;
+    try {
+      child = spawnAgent(prepared.bin, prepared.args, { cwd: prepared.project, stdio });
+    } catch (error) {
+      rejectPromise(error);
+      return;
+    }
+    child.on('error', rejectPromise);
+    child.on('exit', (code) => resolvePromise(code ?? 0));
+  });
+}

package/lib/agents.js

@@ -41,7 +41,7 @@ function validateAgent(agent, source) {
   if (!agent.name || typeof agent.name !== 'string') throw problem('missing "name".');
   if (!Array.isArray(agent.bins) || !agent.bins.length) throw problem('"bins" must be a non-empty array.');
   if (!agent.resume && !agent.create) throw problem('needs a "resume" or "create" command spec.');
-  for (const key of ['resume', 'create']) {
+  for (const key of ['resume', 'create', 'open']) {
     const spec = agent[key];
     if (spec && (!Array.isArray(spec.args) || !spec.args.length)) {
       throw problem(`"${key}.args" must be a non-empty array.`);
@@ -62,9 +62,14 @@ export function which(command, env = process.env) {
   if (command.includes('/') || command.includes('\\')) {
     return tryPath(isAbsolute(command) ? command : resolve(command));
   }
-  const extensions = process.platform === 'win32'
-    ? (env.PATHEXT || '.EXE;.CMD;.BAT;.COM').split(';').map((ext) => ext.toLowerCase())
-    : [''];
+  let extensions = [''];
+  if (process.platform === 'win32') {
+    extensions = (env.PATHEXT || '.EXE;.CMD;.BAT;.COM').split(';').map((ext) => ext.toLowerCase());
+    // "claude.cmd" already carries its extension: probe the bare name too,
+    // not just claude.cmd.exe / claude.cmd.cmd / ...
+    const lower = command.toLowerCase();
+    if (extensions.some((ext) => ext && lower.endsWith(ext))) extensions = ['', ...extensions];
+  }
   for (const dir of (env.PATH || '').split(delimiter)) {
     if (!dir) continue;
     for (const ext of extensions) {
@@ -90,15 +95,22 @@ export function detectAgents(agents, { env = process.env } = {}) {
   });
 }
 
+const MODE_ACTIONS = {
+  resume: 'resuming sessions',
+  create: 'starting new sessions',
+  open: 'opening sessions interactively',
+};
+
 /**
- * Build the argv for a job. Placeholders are substituted inside argv
- * elements — the command is spawned directly, never through a shell.
+ * Build the argv for a job. `mode` is 'resume', 'create' or 'open' (the
+ * agent's own interactive terminal attached to a session). Placeholders are
+ * substituted inside argv elements — the command is spawned directly, never
+ * through a shell.
  */
 export function buildCommand(agent, { mode, sessionId, prompt, skipPermissions = false }) {
-  const spec = mode === 'resume' ? agent.resume : agent.create;
+  const spec = agent[mode];
   if (!spec) {
-    const action = mode === 'resume' ? 'resuming sessions' : 'starting new sessions';
-    throw new Error(`${agent.name} does not support ${action} from codewake.`);
+    throw new Error(`${agent.name} does not support ${MODE_ACTIONS[mode] ?? mode} from codewake.`);
   }
   // Single-pass substitution: substituted values are never re-scanned, so a
   // session id containing the literal text "{prompt}" (or vice versa) cannot

package/lib/browser.js

@@ -0,0 +1,347 @@
+import { homedir } from 'node:os';
+import { emitKeypressEvents } from 'node:readline';
+import {
+  attachOpen,
+  DEFAULT_RESUME_PROMPT,
+  prepareOpen,
+  retryFromSpec,
+} from './actions.js';
+import { cancelJob, clearJobs, displayStatus, listJobs } from './jobs.js';
+import { describeRunAt, parseClockTime, parseDuration } from './time.js';
+import { cancelKeyName, color, confirm, input, select } from './tui.js';
+
+const EXIT_WINDOW_MS = 5000;
+const PAGE_SIZE = 10;
+
+/** Shorten a path for display: home becomes ~, long paths keep their tail. */
+export function shortenPath(path, max, home = homedir()) {
+  let short = path;
+  if (home && short.startsWith(home)) short = `~${short.slice(home.length)}`;
+  if (short.length > max) short = `…${short.slice(short.length - max + 1)}`;
+  return short;
+}
+
+const truncate = (text, max) =>
+  (text.length > max ? `${text.slice(0, Math.max(0, max - 1))}…` : text);
+
+/**
+ * Fixed-width jobs table that always fits `width` columns: the PROJECT
+ * column absorbs the remaining space (shortened from the left), and is
+ * dropped entirely when the terminal is too narrow for it. With
+ * `selected >= 0` that row gets a pointer and highlight (browser mode).
+ */
+export function renderJobsTable(jobs, now = Date.now(), {
+  width = process.stdout.columns || 120,
+  selected = -1,
+} = {}) {
+  const statusColor = { pending: color.cyan, running: color.yellow, done: color.green, failed: color.red, cancelled: color.dim, overdue: color.red };
+  const pointerPad = selected >= 0 ? 2 : 0;
+  const rows = jobs.map((job) => [
+    job.id,
+    truncate(job.agentName, 20),
+    displayStatus(job, now),
+    truncate(job.status === 'pending' ? describeRunAt(job.runAt, new Date(now)) : new Date(job.runAt).toLocaleString(), 28),
+    job.mode === 'resume' ? truncate(job.sessionId ?? '', 12) : 'new session',
+    job.project,
+  ]);
+  let header = ['ID', 'AGENT', 'STATUS', 'LAUNCH', 'SESSION', 'PROJECT'];
+  const columnWidth = (column) =>
+    Math.max(header[column].length, ...rows.map((row) => String(row[column]).length));
+  const gap = 2;
+  const fixedWidth = header.slice(0, -1).reduce((sum, _title, column) => sum + columnWidth(column) + gap, 0);
+  const projectSpace = width - pointerPad - fixedWidth;
+  if (projectSpace >= 'PROJECT'.length) {
+    for (const row of rows) row[5] = shortenPath(row[5], projectSpace);
+  } else {
+    header = header.slice(0, 5);
+    for (const row of rows) row.length = 5;
+  }
+  const widths = header.map((_title, column) => columnWidth(column));
+  const line = (cells, decorate, isSelected = false) => cells
+    .map((cell, column) => {
+      const text = String(cell).padEnd(widths[column]);
+      if (decorate && column === 2) return (statusColor[cell] ?? color.dim)(text);
+      return isSelected ? color.cyan(text) : text;
+    })
+    .join(' '.repeat(gap))
+    .trimEnd();
+  const pointer = (i) => {
+    if (selected < 0) return '';
+    return i === selected ? color.cyan('❯ ') : '  ';
+  };
+  return [
+    color.dim(`${selected >= 0 ? '  ' : ''}${line(header)}`),
+    ...rows.map((row, i) => `${pointer(i)}${line(row, true, i === selected)}`),
+  ].join('\n');
+}
+
+/** Ask when a job should launch: now, after a delay, or at a clock time. */
+export async function askWhen(io) {
+  const kind = await select('When should it launch?', [
+    { label: 'Right now', value: 'now' },
+    { label: 'After a delay', value: 'in', hint: 'e.g. 2h 30m' },
+    { label: 'At a specific time', value: 'at', hint: 'e.g. 14:30' },
+  ], io);
+  if (!kind) return null;
+  if (kind === 'now') return new Date();
+  if (kind === 'in') {
+    const text = await input('Delay', {
+      required: true,
+      validate: (value) => tryError(() => parseDuration(value)),
+      ...io,
+    });
+    if (text === null) return null;
+    return new Date(Date.now() + parseDuration(text) * 1000);
+  }
+  const text = await input('Time (24h)', {
+    required: true,
+    validate: (value) => tryError(() => parseClockTime(value)),
+    ...io,
+  });
+  if (text === null) return null;
+  return parseClockTime(text);
+}
+
+function tryError(fn) {
+  try {
+    fn();
+    return null;
+  } catch (error) {
+    return error.message;
+  }
+}
+
+const HINTS = '↑↓ move · enter open · r retry · x cancel · s sweep finished · f agent · / search · esc back · ctrl+c ×2 exit';
+const SEARCH_HINTS = '(enter keep · esc clear · ↑↓ still move)';
+
+/**
+ * Interactive job browser ("Waked agents"): navigate every job, filter by
+ * agent (f) or free text (/), open the selected job's session in its
+ * agent's own terminal UI (enter), retry (r), cancel (x) and sweep the
+ * finished ones (s). Resolves 'menu' (esc/q) or 'exit' (double ctrl+c/d).
+ */
+export function browseJobs({ io = {}, env = process.env } = {}) {
+  const stdin = io.stdin ?? process.stdin;
+  const stdout = io.stdout ?? process.stdout;
+  // Tests drive fake streams; only a real terminal can be handed to agents.
+  const attachedStdio = stdin === process.stdin && stdout === process.stdout ? 'inherit' : 'ignore';
+
+  return new Promise((resolvePromise) => {
+    let jobs = listJobs(env);
+    let index = 0;
+    let top = 0;
+    let agentFilter = null;
+    let search = '';
+    let searchActive = false;
+    let flash = null;
+    let renderedLines = 0;
+    let busy = false;
+    let lastCancel = { key: null, at: 0 };
+
+    emitKeypressEvents(stdin);
+    const raw = typeof stdin.setRawMode === 'function';
+
+    const agentChoices = () => [...new Map(jobs.map((job) => [job.agentId, job.agentName])).entries()];
+
+    const visible = () => jobs.filter((job) => {
+      if (agentFilter && job.agentId !== agentFilter) return false;
+      if (!search) return true;
+      const haystack = [
+        job.id, job.agentName, job.sessionId ?? '', job.prompt ?? '', job.project, displayStatus(job),
+      ].join(' ').toLowerCase();
+      return haystack.includes(search.toLowerCase());
+    });
+
+    const render = () => {
+      const rows = visible();
+      if (index >= rows.length) index = Math.max(0, rows.length - 1);
+      if (index < top) top = index;
+      if (index >= top + PAGE_SIZE) top = index - PAGE_SIZE + 1;
+      if (top > 0 && top + PAGE_SIZE > rows.length) top = Math.max(0, rows.length - PAGE_SIZE);
+      if (renderedLines) stdout.write(`\x1b[${renderedLines}A`);
+      if (stdout.isTTY) stdout.write('\x1b[0J');
+      const width = stdout.columns || 120;
+      const filters = [
+        agentFilter ? `agent: ${agentChoices().find(([id]) => id === agentFilter)?.[1] ?? agentFilter}` : null,
+        search ? `search: "${search}"` : null,
+      ].filter(Boolean).join(' · ');
+      const lines = [
+        `${color.bold('Waked agents', stdout)} ${color.dim(`${rows.length}/${jobs.length} job${jobs.length === 1 ? '' : 's'}${filters ? ` · ${filters}` : ''}`, stdout)}`,
+      ];
+      if (!rows.length) {
+        lines.push(color.dim(jobs.length ? '  Nothing matches the current filters.' : '  No jobs yet — schedule one first.', stdout));
+      } else {
+        if (top > 0) lines.push(color.dim(`  ↑ ${top} more`, stdout));
+        const page = rows.slice(top, top + PAGE_SIZE);
+        lines.push(...renderJobsTable(page, Date.now(), { width, selected: index - top }).split('\n'));
+        const below = rows.length - Math.min(rows.length, top + PAGE_SIZE);
+        if (below > 0) lines.push(color.dim(`  ↓ ${below} more`, stdout));
+      }
+      if (flash) lines.push(...flash.split('\n'));
+      lines.push(color.dim(searchActive ? `search: ${search}▌  ${SEARCH_HINTS}` : HINTS, stdout));
+      renderedLines = lines.length;
+      stdout.write(`${lines.join('\n')}\n`);
+    };
+
+    const attach = () => {
+      if (raw) stdin.setRawMode(true);
+      stdin.resume();
+      stdin.on('keypress', onKeypress);
+      if (stdout.isTTY) stdout.write('\x1b[?25l');
+      render();
+    };
+
+    const detach = () => {
+      stdin.removeListener('keypress', onKeypress);
+      if (raw) stdin.setRawMode(false);
+      stdin.pause();
+      if (stdout.isTTY) {
+        stdout.write(`\x1b[${renderedLines}A\x1b[0J`);
+        stdout.write('\x1b[?25h');
+      }
+      renderedLines = 0;
+    };
+
+    const finish = (result) => {
+      detach();
+      resolvePromise(result);
+    };
+
+    /** Leave the raw-key loop, run a prompt-based flow, come back and redraw. */
+    const dialog = (fn) => {
+      busy = true;
+      detach();
+      (async () => {
+        try {
+          await fn();
+        } catch (error) {
+          flash = `${color.red('✘', stdout)} ${error.message}`;
+        } finally {
+          jobs = listJobs(env);
+          busy = false;
+          attach();
+        }
+      })();
+    };
+
+    const openAction = (job) => dialog(async () => {
+      if (job.status === 'running') {
+        const anyway = await confirm(
+          `Job ${job.id} is still running headless — open the same session alongside it?`,
+          { def: false, stdin, stdout },
+        );
+        if (!anyway) return;
+      }
+      const prepared = prepareOpen(job, env);
+      if (prepared.note) stdout.write(`${color.yellow('!', stdout)} ${prepared.note}\n`);
+      stdout.write(color.dim(`Opening ${prepared.agent.name} — leave it to come back here.\n`, stdout));
+      const code = await attachOpen(prepared, { stdio: attachedStdio });
+      flash = color.dim(`${prepared.agent.name} closed (exit ${code}).`, stdout);
+    });
+
+    const retryAction = (job) => dialog(async () => {
+      const status = displayStatus(job);
+      if (!['failed', 'done', 'cancelled', 'overdue'].includes(status)) {
+        flash = `${color.yellow('!', stdout)} Job ${job.id} is ${status}; only finished or overdue jobs can be retried.`;
+        return;
+      }
+      const runAt = await askWhen({ stdin, stdout });
+      if (runAt === null) return;
+      const prompt = job.mode === 'resume'
+        ? await input('Prompt to send', { def: job.prompt || DEFAULT_RESUME_PROMPT, stdin, stdout })
+        : await input('Prompt for the new session', { def: job.prompt, required: true, stdin, stdout });
+      if (prompt === null) return;
+      const { job: fresh, note } = retryFromSpec(
+        { jobId: job.id, when: runAt, prompt, project: null, dryRun: false },
+        env,
+      );
+      flash = [
+        note ? `${color.yellow('!', stdout)} ${note}` : null,
+        `${color.green('✔', stdout)} Rescheduled as ${color.bold(fresh.id, stdout)} (launching ${describeRunAt(fresh.runAt)}).`,
+      ].filter(Boolean).join('\n');
+    });
+
+    const cancelAction = (job) => dialog(async () => {
+      if (job.status !== 'pending') {
+        flash = `${color.yellow('!', stdout)} Job ${job.id} is ${displayStatus(job)}; only pending jobs can be cancelled.`;
+        return;
+      }
+      const sure = await confirm(`Cancel ${job.id}?`, { def: true, stdin, stdout });
+      if (!sure) return;
+      const { warning } = cancelJob(job.id, env);
+      flash = warning
+        ? `${color.yellow('!', stdout)} Cancelled ${job.id} — ${warning}`
+        : `${color.green('✔', stdout)} Cancelled ${job.id}.`;
+    });
+
+    const sweepAction = () => dialog(async () => {
+      const finished = jobs.filter((job) => ['done', 'failed', 'cancelled'].includes(job.status));
+      if (!finished.length) {
+        flash = color.dim('Nothing to clean up.', stdout);
+        return;
+      }
+      const sure = await confirm(
+        `Remove ${finished.length} finished job${finished.length === 1 ? '' : 's'}?`,
+        { def: true, stdin, stdout },
+      );
+      if (!sure) return;
+      const removed = clearJobs(env);
+      flash = `${color.green('✔', stdout)} Removed ${removed.length} job${removed.length === 1 ? '' : 's'}.`;
+    });
+
+    const move = (delta) => {
+      const rows = visible();
+      if (!rows.length) return;
+      index = (index + delta + rows.length) % rows.length;
+      render();
+    };
+
+    const onKeypress = (str, key = {}) => {
+      if (busy) return;
+      if (key.ctrl && (key.name === 'c' || key.name === 'd')) {
+        const name = cancelKeyName(str, key);
+        const now = Date.now();
+        if (lastCancel.key === name && now - lastCancel.at <= EXIT_WINDOW_MS) {
+          finish('exit');
+          return;
+        }
+        lastCancel = { key: name, at: now };
+        flash = color.dim(`Press ${name} again within 5s to exit.`, stdout);
+        render();
+        return;
+      }
+      if (key.name === 'up') { move(-1); return; }
+      if (key.name === 'down') { move(1); return; }
+      if (searchActive) {
+        if (key.name === 'return' || key.name === 'enter') searchActive = false;
+        else if (key.name === 'escape') { searchActive = false; search = ''; index = 0; top = 0; }
+        else if (key.name === 'backspace') search = search.slice(0, -1);
+        else if (str && !key.ctrl && !key.meta && str >= ' ') { search += str; index = 0; top = 0; }
+        else return;
+        render();
+        return;
+      }
+      if (key.name === 'escape' || str === 'q') { finish('menu'); return; }
+      if (str === 'k') { move(-1); return; }
+      if (str === 'j') { move(1); return; }
+      if (str === '/') { searchActive = true; flash = null; render(); return; }
+      if (str === 'f') {
+        const ids = agentChoices().map(([id]) => id);
+        const at = agentFilter ? ids.indexOf(agentFilter) : -1;
+        agentFilter = at + 1 >= ids.length ? null : ids[at + 1];
+        index = 0;
+        top = 0;
+        render();
+        return;
+      }
+      if (str === 's') { flash = null; sweepAction(); return; }
+      const job = visible()[index];
+      if (!job) return;
+      if (key.name === 'return' || key.name === 'enter') { flash = null; openAction(job); return; }
+      if (str === 'r') { flash = null; retryAction(job); return; }
+      if (str === 'x') { flash = null; cancelAction(job); return; }
+    };
+
+    attach();
+  });
+}