jeo-code 0.7.35 → 0.7.38

package/src/agent/tools.ts

@@ -189,22 +189,23 @@ function stripAnchorPrefixes(block: string): string | null {
   if (!lines.every(l => l.trim() === "" || ANCHOR_PREFIX_RE.test(l))) return null;
   return lines.map(l => l.replace(ANCHOR_PREFIX_RE, "")).join("\n");
 }
-// ── File-freshness guard (plan/gjc-inheritance.md B7, gjc edit/file-read-cache 계승) ──
-// `read` records each file's stat fingerprint; `edit`/`write` verify it before
-// mutating. A file changed by someone else (concurrent agent, user, formatter)
-// between the read and the edit is REJECTED once — with the CURRENT content
-// re-presented so the model can retry immediately (recovery, not just a guard).
-const lastReadSnapshots = new Map<string, { mtimeMs: number; size: number }>();
+// ── Blind-edit guard (plan/gjc-inheritance.md B7, gjc edit/file-read-cache 계승) ──
+// `read` records that this session has SEEN a path; a line-range `edit` with
+// no hash anchors on either bound refuses to run against a path never read
+// this session (see the narrow guard below in editTool). NOTE: this module
+// does NOT reject a write/edit just because the file changed on disk since
+// the last read — the agent's write always wins (2026-07: guardrail removed
+// per explicit user direction to stop blocking on external/concurrent edits).
+const readThisSession = new Set<string>();
 const MAX_SNAPSHOT_ENTRIES = 64;
 
-function recordReadSnapshot(absPath: string, st: { mtimeMs: number; size: number } | null): void {
-  if (!st) return;
-  if (lastReadSnapshots.size >= MAX_SNAPSHOT_ENTRIES && !lastReadSnapshots.has(absPath)) {
-    const oldest = lastReadSnapshots.keys().next().value;
-    if (oldest !== undefined) lastReadSnapshots.delete(oldest);
+function markRead(absPath: string): void {
+  if (readThisSession.size >= MAX_SNAPSHOT_ENTRIES && !readThisSession.has(absPath)) {
+    const oldest = readThisSession.values().next().value;
+    if (oldest !== undefined) readThisSession.delete(oldest);
   }
-  lastReadSnapshots.delete(absPath); // re-insert to refresh LRU order
-  lastReadSnapshots.set(absPath, { mtimeMs: st.mtimeMs, size: st.size });
+  readThisSession.delete(absPath); // re-insert to refresh LRU order
+  readThisSession.add(absPath);
 }
 
 /** Annotated excerpt of the file's CURRENT content for recovery errors (read-format `N|`). */
@@ -221,26 +222,6 @@ function excerptForRecovery(content: string, centerLine?: number): string {
   const note = lines.length > end - start + 1 ? `\n…(showing lines ${start}-${end} of ${lines.length})` : "";
   return body + note;
 }
-
-/** Returns a recovery error when `absPath` changed since the agent last read it; null when fresh.
- *  Refreshes the snapshot to CURRENT so the immediate retry (model just saw fresh content) passes. */
-async function staleReadError(absPath: string, filePath: string, verb: string): Promise<ToolResult | null> {
-  const snap = lastReadSnapshots.get(absPath);
-  if (!snap) return null; // never read → no guard here (see the narrow blind-replace guard in editTool)
-  const st = await fs.stat(absPath).catch(() => null);
-  if (!st || !st.isFile()) return null; // deleted/replaced-by-dir: let the op surface its own error
-  if (st.mtimeMs === snap.mtimeMs && st.size === snap.size) return null;
-  const content = await fs.readFile(absPath, "utf-8").catch(() => null);
-  recordReadSnapshot(absPath, st); // the model sees the fresh content below → retry passes
-  const excerpt = content !== null ? `\nCurrent content:\n${excerptForRecovery(content)}` : "";
-  return {
-    success: false,
-    output: "",
-    error:
-      `${verb} rejected: ${filePath} changed on disk since you last read it (another agent, the user, or a formatter touched it). ` +
-      `Re-target your ${verb.toLowerCase()} against the CURRENT content below, then retry.${excerpt}`,
-  };
-}
 export async function readTool(
   filePath: string,
   lineRange?: string | number,
@@ -261,7 +242,7 @@ export async function readTool(
       return lsTool(filePath, cwd);
     }
     const content = await fs.readFile(absPath, "utf-8");
-    if (st?.isFile()) recordReadSnapshot(absPath, st); // arm the edit/write freshness guard
+    if (st?.isFile()) markRead(absPath); // arm the blind-edit read-first guard
 
     if (raw) {
       // Verbatim bytes, no "N|" line prefixes (gjc `:raw`), char-capped for context safety.
@@ -339,11 +320,9 @@ export async function writeTool(
     }
     await assertMutationAllowed(filePath, cwd);
     const absPath = path.resolve(cwd, filePath);
-    const stale = await staleReadError(absPath, filePath, "Write");
-    if (stale) return stale;
     await fs.mkdir(path.dirname(absPath), { recursive: true });
     await fs.writeFile(absPath, content, "utf-8");
-    recordReadSnapshot(absPath, await fs.stat(absPath).catch(() => null)); // own change ≠ stale
+    markRead(absPath); // own change counts as having seen the file
     return { success: true, output: `Successfully wrote ${content.length} characters to ${filePath}` };
   } catch (err: any) {
     return { success: false, output: "", error: err.message };
@@ -392,8 +371,6 @@ export async function editTool(
     }
     await assertMutationAllowed(filePath, cwd);
     const absPath = path.resolve(cwd, filePath);
-    const stale = await staleReadError(absPath, filePath, "Edit");
-    if (stale) return stale;
     let content = await fs.readFile(absPath, "utf-8");
 
     // Line-anchored edit parser. Modes (payload follows the directive's newline):
@@ -517,7 +494,7 @@ export async function editTool(
         // (Insert/append directives above are unaffected: they don't destroy content.
         // Checked AFTER the bounds check so an out-of-range request still reports as
         // out-of-range rather than being masked by this guard.)
-        if (!aStart && !aEnd && !lastReadSnapshots.has(absPath)) {
+        if (!aStart && !aEnd && !readThisSession.has(absPath)) {
           return {
             success: false,
             output: "",
@@ -605,7 +582,7 @@ export async function editTool(
     }
 
     await fs.writeFile(absPath, content, "utf-8");
-    recordReadSnapshot(absPath, await fs.stat(absPath).catch(() => null)); // own change ≠ stale
+    markRead(absPath); // own change counts as having seen the file
     return { success: true, output: `Successfully updated ${filePath}` };
   } catch (err: any) {
     return { success: false, output: "", error: err.message };
@@ -1147,7 +1124,7 @@ export async function deleteTool(
       return { success: false, output: "", error: `${targetPath} is a directory — pass recursive:true to remove it and its contents.` };
     }
     await fs.rm(abs, { recursive, force: false });
-    lastReadSnapshots.delete(abs); // a future write to this path must not be flagged stale
+    readThisSession.delete(abs); // a future edit against this path must read it again first
     return { success: true, output: `Deleted ${st.isDirectory() ? "directory" : "file"}: ${targetPath}` };
   } catch (err: any) {
     return { success: false, output: "", error: err.message };

package/src/cli/runner.ts

@@ -101,6 +101,25 @@ export const COMMANDS: readonly CommandSpec[] = [
       return args => m.runMcpCommand(args);
     },
   },
+  {
+    name: "notify",
+    summary: "Configure/inspect remote subagent notifications over Telegram (gjc notify parity).",
+    usage: "notify [setup [--token <t> --chat-id <id>]|status]",
+    loader: async () => {
+      const m = await import("../commands/notify");
+      return args => m.runNotifyCommand(args);
+    },
+  },
+  {
+    name: "daemon",
+    summary: "Manage the background Telegram notification/subagent-control daemon.",
+    usage: "daemon [status|start|stop|reload]",
+    loader: async () => {
+      const m = await import("../commands/daemon");
+      return args => m.runDaemonCommand(args);
+    },
+  },
+
   {
     name: "skills",
     summary: "List bundled workflow skills, or sync them into ~/.jeo/skills (jeo skills <name> for details).",
@@ -155,6 +174,16 @@ export const COMMANDS: readonly CommandSpec[] = [
       return args => m.runMemoryMigrateCommand(args);
     },
   },
+  {
+    name: "notify-daemon-run",
+    summary: "(internal) Foreground worker for the Telegram notification daemon, spawned by 'jeo daemon start'.",
+    usage: "notify-daemon-run",
+    loader: async () => {
+      const m = await import("../agent/notify/telegram-daemon");
+      return async () => m.runNotifyDaemonForeground();
+    },
+  },
+
   {
     name: "state",
     summary: "Read or update workflow state receipts under .jeo/state (gjc-state parity).",

package/src/commands/AGENTS.md

@@ -9,16 +9,20 @@ Concrete implementations of `jeo` subcommands (e.g., launch, setup, team, ultrag
 ## Key Files
 | File | Description |
 |------|-------------|
-| `approve.ts` | Brief description of purpose |
+| `approve.ts` | `jeo approve <plan-path>` CLI + exported `approvePlan()` core (schema shape, known roles, persisted [OKAY] consensus, hash-vs-consensus match) — shared with the agent-facing `approve` tool (`src/agent/approve-tool.ts`) so the agent can flip a plan's `approved` flag itself; the identity restriction (human-only) was removed 2026-07 per explicit user direction, the content gate was not |
 | `auth.ts` | Brief description of purpose |
 | `chat.ts` | Brief description of purpose |
 | `deep-interview.ts` | Brief description of purpose |
+| `daemon.ts` | `jeo daemon status\|start\|stop\|reload` — manages the background Telegram notification/subagent-control daemon (`src/agent/notify/daemon-control.ts`) |
 | `doctor.ts` | Brief description of purpose |
+
 | `evolve-core.ts` | Brief description of purpose |
 | `evolve.ts` | Brief description of purpose |
 | `export.ts` | Brief description of purpose |
 | `launch.ts` | The primary interactive/one-shot execution command |
 | `mcp.ts` | Brief description of purpose |
+| `notify.ts` | `jeo notify setup\|status` — pairs a Telegram bot (BotFather token + `getMe` verification, private-chat pairing via `getUpdates`) and reports masked settings + daemon state |
+
 | `ooo-seed.ts` | Brief description of purpose |
 | `ralplan.ts` | Brief description of purpose |
 | `resume.ts` | Brief description of purpose |

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" +
@@ -1108,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
@@ -1166,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);

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]`);
+}