jeo-code 0.7.33 → 0.7.37

package/src/commands/approve.ts

@@ -9,14 +9,21 @@ import {
 import { PlanSchema, normalizePlanShape, parseYaml } from "../agent/plan";
 import { getSubagentRole, subagentRoleIds } from "../agent/subagents";
 
-export async function runApproveCommand(args: string[] = []): Promise<void> {
-  const cwd = process.cwd();
-  const planPathInput = args[0];
+export interface ApprovePlanResult {
+  ok: boolean;
+  message: string;
+}
 
+/** Core approval gate, shared by the `jeo approve` CLI command and the agent-facing
+ *  `approve` tool (src/agent/approve-tool.ts). ALL of the plan-quality checks below
+ *  (schema shape, known roles, persisted [OKAY] consensus verdict, hash-vs-consensus
+ *  match) still apply no matter who calls this — approval is a content gate, not an
+ *  identity gate. 2026-07: the identity gate (only a human running `jeo approve` in
+ *  their own terminal could flip `approved: true`) was removed per explicit user
+ *  direction — the agent can now call this itself via the `approve` tool. */
+export async function approvePlan(planPathInput: string, cwd: string): Promise<ApprovePlanResult> {
   if (!planPathInput) {
-    console.log("[ERROR] Plan path argument is required.");
-    process.exitCode = 1;
-    return;
+    return { ok: false, message: "[ERROR] Plan path argument is required." };
   }
 
   const resolvedInputPath = path.resolve(cwd, planPathInput);
@@ -25,23 +32,17 @@ export async function runApproveCommand(args: string[] = []): Promise<void> {
   try {
     await fs.access(resolvedInputPath);
   } catch {
-    console.log(`[ERROR] Plan file not found: ${resolvedInputPath}`);
-    process.exitCode = 1;
-    return;
+    return { ok: false, message: `[ERROR] Plan file not found: ${resolvedInputPath}` };
   }
 
   // Read ralplan state
   const ralplanState = await readWorkflowState("ralplan", cwd);
   if (!ralplanState) {
-    console.log(`[ERROR] No ralplan workflow state found. Please run 'jeo ralplan' first.`);
-    process.exitCode = 1;
-    return;
+    return { ok: false, message: `[ERROR] No ralplan workflow state found. Please run 'jeo ralplan' first.` };
   }
 
   if (!ralplanState.plan_path) {
-    console.log(`[ERROR] No plan path associated with the current ralplan state.`);
-    process.exitCode = 1;
-    return;
+    return { ok: false, message: `[ERROR] No plan path associated with the current ralplan state.` };
   }
 
   // Compare canonical (symlink-resolved) paths so a relative arg, an absolute arg,
@@ -56,20 +57,19 @@ export async function runApproveCommand(args: string[] = []): Promise<void> {
   const resolvedStatePath = path.resolve(cwd, ralplanState.plan_path);
   const [canonInput, canonState] = await Promise.all([canonical(resolvedInputPath), canonical(resolvedStatePath)]);
   if (canonInput !== canonState) {
-    console.log(
-      `[ERROR] Provided plan path does not match the active plan in the ralplan state.\n` +
-      `  provided: ${resolvedInputPath}\n` +
-      `  active:   ${resolvedStatePath}\n` +
-      `  Run 'jeo approve "${resolvedStatePath}"' to approve the active plan.`
-    );
-    process.exitCode = 1;
-    return;
+    return {
+      ok: false,
+      message:
+        `[ERROR] Provided plan path does not match the active plan in the ralplan state.\n` +
+        `  provided: ${resolvedInputPath}\n` +
+        `  active:   ${resolvedStatePath}\n` +
+        `  Run 'jeo approve "${resolvedStatePath}"' to approve the active plan.`,
+    };
   }
 
   // Idempotency: check if already approved
   if (ralplanState.approved) {
-    console.log(`[SUCCESS] Plan is already approved.`);
-    return;
+    return { ok: true, message: `[SUCCESS] Plan is already approved.` };
   }
 
   // Round-10 #4 (architect ref 8-Round10Planning): approval is a GATE, not a
@@ -81,52 +81,53 @@ export async function runApproveCommand(args: string[] = []): Promise<void> {
     planContent = await fs.readFile(resolvedInputPath, "utf-8");
     const parsed = PlanSchema.safeParse(normalizePlanShape(parseYaml(planContent)));
     if (!parsed.success) {
-      console.log(
-        `[ERROR] Refusing to approve: the plan is not in the shape 'jeo team' executes (top-level 'steps:' list of { name, role? }).\n` +
-        `  ${parsed.error.issues[0]?.message ?? "schema mismatch"}\n` +
-        `  Fix ${resolvedInputPath} or re-run 'jeo ralplan'.`,
-      );
-      process.exitCode = 1;
-      return;
+      return {
+        ok: false,
+        message:
+          `[ERROR] Refusing to approve: the plan is not in the shape 'jeo team' executes (top-level 'steps:' list of { name, role? }).\n` +
+          `  ${parsed.error.issues[0]?.message ?? "schema mismatch"}\n` +
+          `  Fix ${resolvedInputPath} or re-run 'jeo ralplan'.`,
+      };
     }
     const cfg = await readGlobalConfig();
     const unknown = [...new Set(parsed.data.steps.map(s => s.role?.trim()).filter((r): r is string => !!r && !getSubagentRole(r, cfg)))];
     if (unknown.length > 0) {
-      console.log(
-        `[ERROR] Refusing to approve: plan references unknown subagent role(s): ${unknown.join(", ")}.\n` +
-        `  Known roles: ${subagentRoleIds(cfg).join(", ")}. Fix ${resolvedInputPath} or re-run 'jeo ralplan'.`,
-      );
-      process.exitCode = 1;
-      return;
+      return {
+        ok: false,
+        message:
+          `[ERROR] Refusing to approve: plan references unknown subagent role(s): ${unknown.join(", ")}.\n` +
+          `  Known roles: ${subagentRoleIds(cfg).join(", ")}. Fix ${resolvedInputPath} or re-run 'jeo ralplan'.`,
+      };
     }
   } catch (err: any) {
-    console.log(`[ERROR] Refusing to approve: the plan file is not parseable YAML (${err.message}). Fix ${resolvedInputPath} or re-run 'jeo ralplan'.`);
-    process.exitCode = 1;
-    return;
+    return {
+      ok: false,
+      message: `[ERROR] Refusing to approve: the plan file is not parseable YAML (${err.message}). Fix ${resolvedInputPath} or re-run 'jeo ralplan'.`,
+    };
   }
 
   // Round-11: approval also requires the PERSISTED consensus verdict — a plan
   // that never passed (or failed) the critic gate cannot be approved. States
   // from older ralplan runs lack the field; re-running ralplan heals them.
   if (ralplanState.consensus !== "okay") {
-    console.log(
-      `[ERROR] Refusing to approve: the plan lacks an [OKAY] consensus verdict (recorded: ${ralplanState.consensus ?? "none"}).\n` +
-      `  Re-run 'jeo ralplan' so the consensus critic can review the plan, then approve again.`,
-    );
-    process.exitCode = 1;
-    return;
+    return {
+      ok: false,
+      message:
+        `[ERROR] Refusing to approve: the plan lacks an [OKAY] consensus verdict (recorded: ${ralplanState.consensus ?? "none"}).\n` +
+        `  Re-run 'jeo ralplan' so the consensus critic can review the plan, then approve again.`,
+    };
   }
 
   // Round-13: verify the plan's hash matches the consensus hash to prevent silent edits
   if (ralplanState.consensus_hash) {
     const currentHash = createHash("sha256").update(planContent).digest("hex");
     if (currentHash !== ralplanState.consensus_hash) {
-      console.log(
-        `[ERROR] Refusing to approve: the plan file has been modified since the consensus critic reviewed it.\n` +
-        `  Re-run 'jeo ralplan' to let the critic review the updated plan, then approve again.`
-      );
-      process.exitCode = 1;
-      return;
+      return {
+        ok: false,
+        message:
+          `[ERROR] Refusing to approve: the plan file has been modified since the consensus critic reviewed it.\n` +
+          `  Re-run 'jeo ralplan' to let the critic review the updated plan, then approve again.`,
+      };
     }
   }
 
@@ -134,5 +135,13 @@ export async function runApproveCommand(args: string[] = []): Promise<void> {
   ralplanState.approved = true;
   await writeWorkflowState("ralplan", ralplanState, cwd);
 
-  console.log(`[SUCCESS] Plan approved successfully.`);
+  return { ok: true, message: `[SUCCESS] Plan approved successfully.` };
+}
+
+export async function runApproveCommand(args: string[] = []): Promise<void> {
+  const cwd = process.cwd();
+  const planPathInput = args[0];
+  const { ok, message } = await approvePlan(planPathInput, cwd);
+  console.log(message);
+  if (!ok) process.exitCode = 1;
 }

package/src/commands/daemon.ts

@@ -0,0 +1,45 @@
+/**
+ * `jeo daemon status|start|stop|reload` — manage the background Telegram
+ * notification/subagent-control daemon (gjc `gjc daemon` parity, scoped to
+ * jeo's one daemon kind). See `src/agent/notify/daemon-control.ts`.
+ */
+import { daemonStatus, startDaemon, stopDaemon, reloadDaemon } from "../agent/notify/daemon-control";
+
+async function printStatus(): Promise<void> {
+  const status = await daemonStatus();
+  if (!status.configured) {
+    console.log("notifications not configured — run 'jeo notify setup' first.");
+  }
+  if (status.running) {
+    console.log(`running (pid ${status.pid}, started ${new Date(status.startedAt!).toISOString()})`);
+  } else if (status.stale) {
+    console.log("stale — a lock file exists but its pid is dead (previous daemon crashed without cleanup). 'jeo daemon start' will reclaim it.");
+  } else {
+    console.log("stopped");
+  }
+}
+
+export async function runDaemonCommand(args: string[]): Promise<void> {
+  const action = args[0] ?? "status";
+  if (action === "status" || action === "list") return printStatus();
+  if (action === "start") {
+    const res = await startDaemon();
+    console.log(res.message);
+    if (!res.ok) process.exitCode = 1;
+    return;
+  }
+  if (action === "stop") {
+    const res = await stopDaemon();
+    console.log(res.message);
+    if (!res.ok) process.exitCode = 1;
+    return;
+  }
+  if (action === "reload") {
+    const res = await reloadDaemon();
+    console.log(res.message);
+    if (!res.ok) process.exitCode = 1;
+    return;
+  }
+  console.log(`Unknown 'jeo daemon' action '${action}'. Usage: jeo daemon [status|start|stop|reload]`);
+  process.exitCode = 1;
+}

package/src/commands/launch.ts

@@ -8,11 +8,14 @@ import { memoryPromptSection, spawnDetachedDistill, recordFailedAttempt } from "
 import { createTaskTool, taskToolProtocolLine, type TaskSubEvent } from "../agent/task-tool";
 import { createSubagentTool, SUBAGENT_TOOL_PROTOCOL_LINE } from "../agent/subagent-tool";
 import { SubagentRegistry } from "../agent/subagent-registry";
+import { stopSessionNotifyEndpoint } from "../agent/notify/session-endpoint";
+
 import { createTodoTool, TODO_TOOL_PROTOCOL_LINE } from "../agent/todo-tool";
 import { createJobTool, JOB_TOOL_PROTOCOL_LINE } from "../agent/job-tool";
 import { JobRegistry } from "../agent/job-registry";
 import { createIrcTool, IRC_TOOL_PROTOCOL_LINE } from "../agent/irc-tool";
 import { createGoalTool, GOAL_TOOL_PROTOCOL_LINE } from "../agent/goal-tool";
+import { createApproveTool, APPROVE_TOOL_PROTOCOL_LINE } from "../agent/approve-tool";
 import { LaunchTui } from "../tui/app";
 import { runDeepInterviewEngine, type DeepInterviewEngineOptions } from "./deep-interview";
 import { runRalplanEngine, type RalplanEngineOptions } from "./ralplan";
@@ -525,7 +528,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // pi-style: load project context (JEO.md / AGENTS.md / .jeo/context.md / CLAUDE.md) into the prompt.
   const contextFiles = await loadProjectContext(cwd);
 
-  const KNOWN_TOOLS = new Set(["read", "write", "edit", "bash", "find", "search", "ls", "task", "todo", "subagent", "job", "irc", "goal", "ast_grep", "ast_edit", "computer", "lsp", "lsp_rename", "debug", "browser"]);
+  const KNOWN_TOOLS = new Set(["read", "write", "edit", "bash", "find", "search", "ls", "task", "todo", "subagent", "job", "irc", "goal", "approve", "ast_grep", "ast_edit", "computer", "lsp", "lsp_rename", "debug", "browser"]);
   let allowedTools = new Set(KNOWN_TOOLS);
 
   if (flags.noTools) {
@@ -599,6 +602,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     (allowedTools.has("job") ? "\n\nBackground jobs: " + JOB_TOOL_PROTOCOL_LINE : "") +
     (allowedTools.has("irc") ? "\n\nPeer messaging: " + IRC_TOOL_PROTOCOL_LINE : "") +
     (allowedTools.has("goal") ? "\n\nGoal tracking: " + GOAL_TOOL_PROTOCOL_LINE : "") +
+    (allowedTools.has("approve") ? "\n\nPlan approval: " + APPROVE_TOOL_PROTOCOL_LINE : "") +
     (effectiveNoSkills ? "" :
     "\n\nJEO workflow routing:\n" +
     "- Answer the user's request DIRECTLY. Never reply with a catalog, list, or summary of skills unless the user explicitly asks what skills exist.\n" +
@@ -880,10 +884,33 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       // Refresh injected OKF memory with THIS turn's query before the model call so
       // failure-first ranking fires and same-session dead ends resurface.
       await refreshSessionMemory(userInput);
-      const compRes = await maybeCompact(history, {
-        model: activeModel,
-        contextTokens,
+      // Esc-cancellable turn-boundary compaction preflight: a slow/hung summarization
+      // LLM call must not be un-cancellable just because it runs before the main
+      // per-turn abort harness (created below) exists yet. A short-lived harness scoped
+      // to just this call gives Esc/Ctrl+C the same abort path without wiring the full
+      // mid-turn steering machinery this early (which needs turn-scoped vars not
+      // constructed until after compaction/history mutation settles).
+      const compactHarness = createInFlightAbortHarness({
+        captureEsc: !!tui,
+        onAbortNotice: msg => {
+          if (tui) tui.events().onNotice?.(msg);
+          else console.log(msg);
+        },
+        onHardExit: () => {
+          if (tui) tui.finish("Cancelled.", { ok: false });
+          process.exit(130);
+        },
       });
+      let compRes: Awaited<ReturnType<typeof maybeCompact>>;
+      try {
+        compRes = await maybeCompact(history, {
+          model: activeModel,
+          contextTokens,
+          signal: compactHarness.controller.signal,
+        });
+      } finally {
+        compactHarness.dispose();
+      }
       if (compRes.error) {
         throw new Error(compRes.error);
       }
@@ -1085,6 +1112,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           job: createJobTool(jobRegistry),
           irc: createIrcTool(subagentRegistry),
           goal: createGoalTool(),
+          approve: createApproveTool(),
         };
         const tools = filterToolMap(fullTools, Array.from(allowedTools));
         // Opik observability (opt-in via JEO_OPIK): one trace per turn, spans per
@@ -1143,7 +1171,9 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       } finally {
         harness.dispose();
         subagentRegistry.cancelAll(); // #9: no detached run leaks past the turn
+        await stopSessionNotifyEndpoint(subagentRegistry); // tear down the Telegram remote-control endpoint, if one was started
         jobRegistry.cancelAll(); // background jobs are turn-scoped too — no orphaned processes
+
         // Steering typed but never drained (e.g. entered just after the final step)
         // must not be lost — fold it into the next prompt draft so it runs next.
         const leftover = steerInbox.splice(0, steerInbox.length).map(s => s.trim()).filter(Boolean);
@@ -3587,6 +3617,26 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         }
         continue;
       }
+      if (input === "/wiki" || input.startsWith("/wiki ")) {
+        const decision = decideWikiSlash(
+          input,
+          resolveWikiRoot(await readGlobalConfig()),
+          !!jeoEnv("WIKI_ROOT"),
+        );
+        for (const line of decision.lines) console.log(line);
+        if (decision.kind === "clear") {
+          await saveConfigPatch(() => ({ wikiRoot: undefined }));
+          delete process.env.JEO_WIKI_ROOT;
+          sessionWikiRoot = undefined;
+          await refreshSessionMemory("");
+        } else if (decision.kind === "set") {
+          await saveConfigPatch(() => ({ wikiRoot: decision.persistArg }));
+          process.env.JEO_WIKI_ROOT = decision.root;
+          sessionWikiRoot = decision.root;
+          await refreshSessionMemory("");
+        }
+        continue;
+      }
       if (input === "/evolve") {
         await runEvolveSimulation(animateAsciiArt);
         continue;

package/src/commands/notify.ts

@@ -0,0 +1,109 @@
+/**
+ * `jeo notify setup|status` — configure and inspect the remote subagent
+ * notification/control channel (gjc `gjc notify setup`/`gjc notify status`
+ * parity, scoped to jeo's Telegram + subagent surface; see `src/agent/notify/`).
+ */
+import { createInterface } from "node:readline/promises";
+import { readGlobalConfig, saveConfigPatch } from "../agent/state";
+import { TelegramApi, maskToken } from "../agent/notify/telegram-api";
+import { daemonStatus } from "../agent/notify/daemon-control";
+
+function parseFlags(args: string[]): { token?: string; chatId?: string } {
+  const out: { token?: string; chatId?: string } = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--token" && args[i + 1]) out.token = args[++i];
+    else if (args[i] === "--chat-id" && args[i + 1]) out.chatId = args[++i];
+  }
+  return out;
+}
+
+async function runSetup(args: string[]): Promise<void> {
+  const flags = parseFlags(args);
+  let token = flags.token;
+  let chatId = flags.chatId;
+
+  if (!token || !chatId) {
+    if (!process.stdin.isTTY) {
+      console.log(
+        "jeo notify setup needs an interactive terminal (TTY) unless both --token and --chat-id are given.\n" +
+          "Non-interactive: jeo notify setup --token <botToken> --chat-id <chatId>",
+      );
+      return;
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+      console.log("\n=== jeo notify setup (Telegram) ===");
+      console.log("Create a bot with @BotFather (https://core.telegram.org/bots/features#botfather), then paste its token below.\n");
+      if (!token) token = (await rl.question("Telegram BotFather token: ")).trim();
+      if (!token) {
+        console.log("No token given — aborting.");
+        return;
+      }
+      const api = new TelegramApi(token);
+      const me = await api.getMe();
+      if (!me.ok || !me.result) {
+        console.log(`Telegram getMe failed: ${me.description ?? "invalid token"}. Re-copy the token from BotFather and retry.`);
+        return;
+      }
+      console.log(`Bot verified: @${me.result.username}`);
+
+      if (!chatId) {
+        console.log(`\nMessage @${me.result.username} from your Telegram account now (any text). Waiting...`);
+        let offset: number | undefined;
+        const deadline = Date.now() + 120_000;
+        while (Date.now() < deadline && !chatId) {
+          const updates = await api.getUpdates(offset, 5);
+          if (updates.ok) {
+            for (const u of updates.result) {
+              offset = u.update_id + 1;
+              const chat = u.message?.chat;
+              if (chat && chat.type === "private") {
+                chatId = String(chat.id);
+                break;
+              }
+            }
+          }
+        }
+        if (!chatId) {
+          console.log("Timed out waiting for a private message. Re-run 'jeo notify setup' and message the bot promptly.");
+          return;
+        }
+        console.log(`Paired private chat id ${chatId}.`);
+      }
+    } finally {
+      rl.close();
+    }
+  } else {
+    const api = new TelegramApi(token);
+    const me = await api.getMe();
+    if (!me.ok) {
+      console.log(`Telegram getMe failed: ${me.description ?? "invalid token"}.`);
+      return;
+    }
+  }
+
+  await saveConfigPatch(raw => ({
+    notifications: { ...raw.notifications, enabled: true, telegram: { botToken: token, chatId } },
+  }));
+  console.log(`\nNotifications enabled. botToken=${maskToken(token!)} chatId=${chatId}`);
+  console.log("Start the daemon with 'jeo daemon start', then run a detached subagent (task {detached:true}) to see it appear in Telegram.");
+}
+
+async function runStatus(): Promise<void> {
+  const config = await readGlobalConfig();
+  const enabled = Boolean(config.notifications?.enabled);
+  const botToken = config.notifications?.telegram?.botToken;
+  const chatId = config.notifications?.telegram?.chatId;
+  const status = await daemonStatus();
+  console.log(`enabled=${enabled}`);
+  console.log(`botToken=${botToken ? maskToken(botToken) : "(not set)"}`);
+  console.log(`chatId=${chatId ?? "(not set)"}`);
+  console.log(`daemon=${status.running ? `running (pid ${status.pid})` : status.stale ? "stale (crashed without cleanup)" : "stopped"}`);
+}
+
+export async function runNotifyCommand(args: string[]): Promise<void> {
+  const sub = args[0] ?? "status";
+  if (sub === "setup") return runSetup(args.slice(1));
+  if (sub === "status") return runStatus();
+  console.log(`Unknown 'jeo notify' subcommand '${sub}'. Usage: jeo notify [setup|status]`);
+}

package/src/commands/ralplan.ts

@@ -142,7 +142,17 @@ export async function runRalplanEngine(opts: RalplanEngineOptions = {}): Promise
     `  - 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.`;
+    `    parallel_group: "<optional short id, e.g. g1>"\n` +
+    `Provide 3-8 concrete, ordered steps. Output ONLY the YAML.\n\n` +
+    `parallel_group is OPTIONAL and OFF by default — omit it unless you are certain. ` +
+    `'jeo team' executes steps strictly in array order, EXCEPT a contiguous (adjacent, ` +
+    `no other step in between) run of steps sharing the SAME non-empty parallel_group value, ` +
+    `which it runs CONCURRENTLY in isolated git worktrees and merges back. Only mark steps ` +
+    `parallel_group when they are TRULY independent: each touches DISJOINT files with no step ` +
+    `reading or building on another's output. Never mark two steps parallel if one depends on, ` +
+    `reads, or extends a file another writes. When unsure, leave parallel_group out — a plain ` +
+    `serial step is always correct; a wrongly-parallel step risks a merge conflict that halts ` +
+    `execution.`;
 
   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;