jeo-code 0.9.9 → 0.9.11

package/src/commands/launch/session-slash.ts

@@ -13,6 +13,8 @@ import type { Message } from "../../agent/loop";
 import { createSession, deleteSession, renameSession, loadSession, listSessions, sessionPath, resolveSessionRef } from "../../agent/session";
 import { SessionPicker, renderSessionPicker } from "../../tui/components/session-picker";
 import { formatTranscript } from "../../tui/components/transcript";
+import { importGjcSession, listGjcSessions, type GjcSessionLeaf } from "../../agent/gjc-session-import";
+import { SelectList, renderSelectList, type SelectItem } from "../../tui/components/select-list";
 
 export interface SessionSlashCtx {
   cwd: string;
@@ -54,6 +56,56 @@ export interface SessionSlashResult {
 
 }
 
+interface GjcResumeRequest {
+  sessionId?: string;
+  leafId?: string;
+  anyCwd: boolean;
+  error?: string;
+}
+
+function parseGjcResumeArgument(arg: string): GjcResumeRequest | undefined {
+  const tokens = arg.trim().split(/\s+/).filter(Boolean);
+  if (!tokens.some(token => token.toLowerCase().startsWith("gajae:"))) return undefined;
+
+  let refToken: string | undefined;
+  let anyCwd = false;
+  for (const token of tokens) {
+    if (token === "--any-cwd") {
+      anyCwd = true;
+      continue;
+    }
+    if (refToken !== undefined) {
+      return { anyCwd, error: `Unexpected argument '${token}'.` };
+    }
+    refToken = token;
+  }
+
+  if (!refToken || !refToken.toLowerCase().startsWith("gajae:")) {
+    return { anyCwd, error: "Use /resume gajae:<session-id>[#<leaf-entry-id>] [--any-cwd]." };
+  }
+
+  const reference = refToken.slice("gajae:".length);
+  if (!reference) return { anyCwd };
+  const pieces = reference.split("#");
+  if (pieces.length > 2 || !pieces[0]) {
+    return { anyCwd, error: "Malformed GJC reference. Use gajae:<session-id>[#<leaf-entry-id>]." };
+  }
+
+  return {
+    sessionId: pieces[0],
+    ...(pieces[1] ? { leafId: pieces[1] } : {}),
+    anyCwd,
+  };
+}
+
+function gjcResumeItems(pool: GjcSessionLeaf[]): SelectItem<GjcSessionLeaf>[] {
+  return pool.map(item => ({
+    value: item,
+    label: `${item.sessionId}#${item.leafId || "(no-leaf)"}`,
+    hint: item.selected ? "selected leaf" : item.cwd,
+  }));
+}
+
 /**
  * Handle `/session [new|drop|delete|rename <title>|resume [id]|list|info]`
  * (default: list + current-session summary). Extracted verbatim from
@@ -126,9 +178,13 @@ export async function runSessionSlash(input: string, ctx: SessionSlashCtx): Prom
   }
   if (sub === "resume") {
     const arg = tokens.slice(1).join(" ").trim();
-    const applyResume = async (rid: string): Promise<void> => {
+    const applyResume = async (
+      rid: string,
+      loaded?: Awaited<ReturnType<typeof loadSession>>,
+    ): Promise<void> => {
       try {
-        const { header, messages } = await loadSession(rid, cwd);
+        const loadedSession = loaded ?? await loadSession(rid, cwd);
+        const { header, messages } = loadedSession;
         history.length = 1;
         for (const m of messages) history.push(m);
         sessionId = rid;
@@ -181,6 +237,94 @@ export async function runSessionSlash(input: string, ctx: SessionSlashCtx): Prom
         console.log(`! ${(err as Error).message}`);
       }
     };
+    const gjcRequest = parseGjcResumeArgument(arg);
+    if (gjcRequest) {
+      if (gjcRequest.error) {
+        console.log(`! ${gjcRequest.error}`);
+        return result();
+      }
+
+      const importOne = async (source: GjcSessionLeaf | undefined): Promise<void> => {
+        if (!source) return;
+        try {
+          const imported = await importGjcSession({
+            sessionId: gjcRequest.sessionId ?? source.sessionId,
+            ...(gjcRequest.leafId || source.leafId ? { leafId: gjcRequest.leafId ?? source.leafId } : {}),
+            cwd,
+            anyCwd: gjcRequest.anyCwd,
+          });
+          console.log(
+            `(imported GJC v5 session ${imported.sourceSessionId}#${imported.sourceLeafId} as Jeo session ${imported.sessionId}${imported.reused ? " (reused)" : ""})`,
+          );
+          await applyResume(imported.sessionId);
+        } catch (err) {
+          console.log(`! GJC /resume failed: ${(err as Error).message}`);
+        }
+      };
+
+      if (gjcRequest.sessionId) {
+        await importOne({
+          rootPath: "",
+          sourcePath: "",
+          sessionId: gjcRequest.sessionId,
+          leafId: gjcRequest.leafId ?? "",
+          cwd,
+          selected: false,
+        });
+        return result();
+      }
+
+      let sourcePool: GjcSessionLeaf[];
+      try {
+        sourcePool = await listGjcSessions({ cwd, anyCwd: gjcRequest.anyCwd });
+      } catch (err) {
+        console.log(`! GJC /resume listing failed: ${(err as Error).message}`);
+        return result();
+      }
+      if (sourcePool.length === 0) {
+        console.log("(no GJC v5 sessions for this workspace)");
+        console.log("Usage: /resume gajae:<session-id>[#<leaf-entry-id>] [--any-cwd]");
+        return result();
+      }
+
+      if (process.stdin.isTTY && process.stdout.isTTY) {
+        const picker = new SelectList(gjcResumeItems(sourcePool));
+        let selected: SelectItem<GjcSessionLeaf> | undefined;
+        await runSelectPicker(
+          (cols, rows) => renderSelectList(picker, {
+            title: "Import a GJC v5 session",
+            cols,
+            rows: Math.max(8, rows),
+            unicode: true,
+            color: true,
+          }),
+          (ch, key) => {
+            if (key?.name === "up") { picker.up(); return false; }
+            if (key?.name === "down") { picker.down(); return false; }
+            if (key?.name === "pageup") { picker.page(-1); return false; }
+            if (key?.name === "pagedown") { picker.page(1); return false; }
+            if (key?.name === "backspace") { picker.backspace(); return false; }
+            if (key?.name === "escape" || (key?.ctrl && key.name === "c")) return true;
+            if (key?.name === "return" || key?.name === "enter") {
+              selected = picker.selected();
+              return true;
+            }
+            if (ch && ch >= " " && !key?.ctrl && !key?.meta) picker.typeChar(ch);
+            return false;
+          },
+        );
+        await importOne(selected?.value);
+        return result();
+      }
+
+      console.log("GJC v5 sessions — resume with /resume gajae:<session-id>[#<leaf-entry-id>]:");
+      for (const source of sourcePool.slice(0, 20)) {
+        const selected = source.selected ? " *" : "";
+        console.log(` ${source.sessionId}#${source.leafId || "(no-leaf)"}${selected}  ${source.cwd}`);
+      }
+      console.log("Add --any-cwd to include sessions from other workspaces.");
+      return result();
+    }
     if (arg) {
       // gjc-parity: resolve `arg` as a full id OR a short id prefix before resuming.
       const resolved = await resolveSessionRef(arg, cwd);

package/src/commands/launch.ts

@@ -46,6 +46,7 @@ import { renderWelcome, playWelcomeSweep } from "../tui/components/welcome";
 import { jeoEnv } from "../util/env";
 import { renderUpdateBox } from "../tui/components/update-box";
 import { consumeLaunchWhatsNew } from "../util/whats-new";
+import { runWhatsNewCommand } from "./whats-new";
 import { maybeBell } from "../util/notify";
 import { supportsUnicode } from "../tui/components/capability";
 import pkg from "../../package.json";
@@ -225,6 +226,7 @@ import {
 } from "./launch/code-slash";
 import { handleUndoSlash } from "./launch/git-slash";
 import { runSessionSlash } from "./launch/session-slash";
+import { runJobsSlash } from "./launch/jobs-slash";
 import { runModelSlash } from "./launch/model-slash";
 import { runRouteSlash } from "./launch/route-slash";
 import { runComputerSlash } from "./launch/computer-slash";
@@ -2416,7 +2418,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // protocol nor xterm modifyOtherKeys. JEO_NO_MULTILINE=1 fully disables the
   // filter (reads stdin directly).
   const multilineInput = !!process.stdin.isTTY && jeoEnv("NO_MULTILINE") !== "1";
-  const loneLfShiftEnter = jeoEnv("MULTILINE") !== "0";
+  // tmux-owned panes can translate the plain Enter key to LF after the launcher's
+  // keyboard modes are enabled. In that mode LF must remain readline's submit key;
+  // explicit Shift+Enter escape sequences still become MULTILINE_SENTINEL below.
+  const loneLfShiftEnter =
+    jeoEnv("MULTILINE") !== "0" && jeoEnv("TMUX_LAUNCHED") !== "1";
   const expandSentinel = (s: string): string => (multilineInput ? s.split(SENTINEL).join("\n") : s);
   // Prompt-scoped process listeners (stdin data/keypress, stdout resize). Registered
   // once per launch but previously anonymous and never removed — benign for a single
@@ -4323,6 +4329,16 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         logLines(handoffLines(res, process.stdout.columns));
         continue;
       }
+      if (input === "/changelog" || input.startsWith("/changelog ")) {
+        const args = input.slice("/changelog".length).trim().split(/\s+/).filter(Boolean)
+          .map(arg => arg === "--full" ? "--all" : arg);
+        await runWhatsNewCommand(args);
+        continue;
+      }
+      if (input === "/jobs" || input.startsWith("/jobs ")) {
+        await runJobsSlash(input, jobRegistry, cwd, lines => logLines(lines));
+        continue;
+      }
       if (input === "/session" || input.startsWith("/session ")) {
         const result = await runSessionSlash(input, {
           cwd, history, noSession: flags.noSession, sessionId, sessionModel, rl,

package/src/commands/update.ts

@@ -43,6 +43,36 @@ export interface UpdateDeps {
   activeVersion?: () => string | null;
 }
 
+/**
+ * Ordered install attempts for `target` (`jeo-code@<version>`).
+ *
+ * `bun install -g` alone is not enough in practice: right after a publish bun can
+ * still hold a stale registry manifest and fail with `No version matching "<v>"
+ * found ... (but package exists)`. `--force` re-resolves against the registry and
+ * is what actually recovers that state. npm remains the last resort for
+ * npm-installed globals. Pure so the policy is unit-testable without spawning.
+ */
+export function installCandidates(target: string): string[][] {
+  return [
+    ["bun", "install", "-g", target],
+    // Cache-buster: bun's resolver held a stale manifest for a just-published version.
+    ["bun", "install", "-g", target, "--force"],
+    ["npm", "install", "-g", target],
+  ];
+}
+
+/** Version of the `jeo` binary PATH actually resolves, or null when unreadable. */
+function readActiveVersion(): string | null {
+  try {
+    const proc = Bun.spawnSync(["jeo", "--version"], { stdout: "pipe", stderr: "pipe" });
+    if (!proc.success) return null;
+    const out = new TextDecoder().decode(proc.stdout);
+    const m = out.match(/(\d+\.\d+\.\d+(?:-[\w.]+)?)/);
+    return m ? m[1] : null;
+  } catch {
+    return null;
+  }
+}
 export const defaultDeps: UpdateDeps = {
   fetchJson: async (url: string, options?: { signal?: AbortSignal }) => {
     const res = await fetch(url, options);
@@ -65,17 +95,20 @@ export const defaultDeps: UpdateDeps = {
     // Self-update the global install via the SAME toolchain it was installed with. jeo
     // ships as a `#!/usr/bin/env bun` script so bun is the common case, but npm-installed
     // globals exist too — try bun first, fall back to npm (and tolerate either missing).
-    // `@<version>` (the resolved latest) forces the newest publish past a stale global cache.
     const target = `jeo-code@${version ?? "latest"}`;
-    const managers: string[][] = [
-      ["bun", "install", "-g", target],
-      ["npm", "install", "-g", target],
-    ];
     let lastErr = "";
-    for (const cmd of managers) {
+    for (const cmd of installCandidates(target)) {
       try {
         const proc = Bun.spawnSync(cmd, { stdout: "inherit", stderr: "inherit" });
-        if (proc.success) return { success: true };
+        if (proc.success) {
+          // A zero exit is NOT proof the user's `jeo` moved: npm's global prefix is
+          // often a different directory than the bun prefix PATH actually resolves,
+          // so an npm fallback can "succeed" while the active binary is untouched.
+          // Only stop once the binary on PATH really reports the requested version.
+          if (!version || readActiveVersion() === version) return { success: true };
+          lastErr = `${cmd[0]} reported success but the active 'jeo' is still ${readActiveVersion() ?? "unknown"}`;
+          continue;
+        }
         lastErr = `${cmd[0]} exited with code ${proc.exitCode}`;
       } catch (err: any) {
         lastErr = `${cmd[0]} unavailable: ${err?.message ?? String(err)}`;
@@ -84,20 +117,10 @@ export const defaultDeps: UpdateDeps = {
     return { success: false, stderr: lastErr };
   }
 ,
-  activeVersion: () => {
-    // Read the version of the `jeo` actually on PATH (may differ from this process's bundled
-    // version after a self-update, e.g. when bun installed to ~/.bun/bin but PATH prefers an
-    // npm global). Used to detect a silent "installed but PATH unchanged" no-op.
-    try {
-      const proc = Bun.spawnSync(["jeo", "--version"], { stdout: "pipe", stderr: "pipe" });
-      if (!proc.success) return null;
-      const out = new TextDecoder().decode(proc.stdout);
-      const m = out.match(/(\d+\.\d+\.\d+(?:-[\w.]+)?)/);
-      return m ? m[1] : null;
-    } catch {
-      return null;
-    }
-  }
+  // Version of the `jeo` actually on PATH — may differ from this process's bundled
+  // version after a self-update (e.g. npm installed into a prefix PATH does not
+  // resolve). Detects the silent "installed but PATH unchanged" no-op.
+  activeVersion: readActiveVersion
   ,
   showWhatsNew: () => {
     try {
@@ -279,25 +302,31 @@ export async function runUpdateCommandWith(args: string[], deps: UpdateDeps): Pr
       try {
         const result = await deps.install(latest ?? undefined);
         if (result.success) {
+          // A package manager's zero exit does not prove the user's `jeo` moved: npm's
+          // global prefix is frequently a different directory than the one PATH resolves,
+          // so the install lands somewhere the user never runs. Verify the ACTIVE binary
+          // and treat a still-stale one as a failed update (exit 1) rather than printing
+          // a success line the machine contradicts.
+          const active = deps.activeVersion?.();
+          const stale = !!(active && latest && compareVersions(active, latest) < 0);
           if (hasJson) {
             console.log(JSON.stringify({
               current,
               latest,
               upToDate: false,
-              installed: true
+              installed: !stale,
+              ...(stale ? { activeVersion: active, error: "active jeo still reports an older version" } : {}),
             }));
+            if (stale) process.exitCode = 1;
+          } else if (stale) {
+            console.error(`[FAILED] Installed jeo-code@${latest}, but the active 'jeo' on PATH still reports ${active}.`);
+            console.error(`The install landed in a prefix your PATH does not use. Fix it with one of:`);
+            console.error(`  bun install -g jeo-code@${latest} --force`);
+            console.error(`  npm install -g jeo-code@${latest}`);
+            console.error(`Then confirm with: jeo --version`);
+            process.exitCode = 1;
           } else {
             console.log(`Successfully installed jeo-code@${latest}`);
-            // Verify the `jeo` on PATH actually picked up the new install — a bun-vs-npm or
-            // PATH mismatch can leave an older binary in front, which looks like "update did
-            // nothing". Surface that loudly with the manual fix instead of failing silently.
-            const active = deps.activeVersion?.();
-            if (active && latest && compareVersions(active, latest) < 0) {
-              console.warn(`Warning: installed ${latest}, but the active 'jeo' on PATH still reports ${active}.`);
-              console.warn(`Your PATH points at a different install. Fix it with one of:`);
-              console.warn(`  npm install -g jeo-code@${latest}`);
-              console.warn(`  bun install -g jeo-code@${latest}`);
-            }
             deps.showWhatsNew?.();
           }
         } else {

package/src/tui/components/slash.ts

@@ -27,7 +27,8 @@ export const SLASH_COMMAND_DETAILS: readonly SlashCommandInfo[] = [
   { command: "/drop", usage: "/drop", description: "Delete the current session and start a new one", group: "session" },
   { command: "/session", usage: "/session [info|delete]", description: "Show current session info, or delete it", group: "session" },
   { command: "/rename", usage: "/rename <title>", description: "Rename the current session", group: "session" },
-  { command: "/resume", usage: "/resume [id]", description: "Resume a saved session in this REPL", group: "session" },
+  { command: "/resume", usage: "/resume [id|gajae:<session-id>[#<leaf>]] [--any-cwd]", description: "Resume a saved session or import a read-only GJC v5 session", group: "session" },
+  { command: "/changelog", usage: "/changelog [--full]", description: "Show recent release notes (use --full for the complete changelog)", group: "system" },
   { command: "/retry", usage: "/retry", description: "Retry the last request", group: "session" },
   { command: "/undo", usage: "/undo", description: "Undo the last jeo auto-commit and restore the working tree", group: "session" },
   { command: "/history", usage: "/history [n|all]", description: "Re-print the worked turn history (prompts, tool steps, replies) into scrollback", group: "session" },
@@ -53,6 +54,7 @@ export const SLASH_COMMAND_DETAILS: readonly SlashCommandInfo[] = [
   { command: "/search", usage: "/search <pat> [glob]", description: "Search the repo for a pattern", group: "code" },
 
   { command: "/sessions", usage: "/sessions", description: "List saved sessions", group: "session" },
+  { command: "/jobs", usage: "/jobs [list|tail|await|cancel]", description: "List, inspect, await, or cancel background jobs in this session", group: "system" },
   { command: "/usage", usage: "/usage", description: "Show cumulative token usage for this session", group: "system" },
   { command: "/context", usage: "/context", description: "Show context token usage breakdown", group: "system" },
   { command: "/tools", usage: "/tools", description: "Show the tools currently visible to the agent", group: "system" },

package/src/tui/components/welcome.ts

@@ -9,8 +9,8 @@ import { parseChangelogSections, changelogText } from "../../util/whats-new";
 function getLatestChangelogItems(): { version: string; items: string[] } {
   try {
     const sections = parseChangelogSections(changelogText);
-    if (sections.length > 0) {
-      const latest = sections[0];
+    const latest = sections.find(section => section.groups.some(group => group.items.length > 0));
+    if (latest) {
       const items: string[] = [];
       for (const g of latest.groups) {
         for (const item of g.items) {