jeo-code 0.12.9 → 0.12.11

package/src/commands/launch.ts

@@ -62,7 +62,7 @@ import { rememberModelPatch, recentModelsForDisplay } from "../agent/model-recen
 import { describeModel, describeAllProviders, describeProvider, resolveProvider, thinkingMaxTokens, resolveMaxOutputTokens, thinkingToReasoningEffort, discoverModels, flattenModels, resolveSelection, catalogMetadata, catalogByProvider, liveProviderCatalogModels, resolveRoleModel, CODEX_MODELS, qualifyModelId, modelServableWithConfig, isLocalProviderReachable } from "../ai";
 import { rehydrateLiveModels, writeModelCache } from "../ai/model-cache";
 import type { ProviderModelsResult, PickEntry, ProviderName, ModelRole, ThinkLevel } from "../ai";
-import { readGoalState, writeGoalState, clearGoalState, verifyGoal, applyEvidenceGate } from "../agent/goal-verifier";
+import { GoalStateCorruptError, readGoalState, writeGoalState, clearGoalState, verifyGoal, applyEvidenceGate, applyPendingEvidence, type GoalState } from "../agent/goal-verifier";
 import { routePrompt, deriveCacheSessionKey, warnOnce, tierModelPool, selectFromPool, PROMPT_TIERS, withRoutingTierSetting, inferTierForModel, credentialScopeFor, resolveVerifierModel, type PromptTier, type RouteDecision, type RoutingConfig } from "../agent/prompt-router";
 import { RouteHistory } from "../agent/route-history";
 
@@ -122,6 +122,7 @@ import { bashTool } from "../agent/tools";
 import { loadProjectContext, withProjectContext } from "../agent/context-files";
 import { maybeCompact, historyTokens, buildHandoffDocument } from "../agent/compaction";
 import * as path from "node:path";
+import { tmpdir } from "node:os";
 import * as fs from "node:fs";
 import { listThemes, resolveTheme, themeGradient, accentPaint, accentShadowPaint } from "../tui/components/themes";
 import {
@@ -739,7 +740,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // never persisted to config.
   const routeHistory = new RouteHistory();
   // Computer-use session override: undefined = follow config.computer.enabled, true/false = /computer on|off wins this session.
-  let sessionComputerOverride: boolean | undefined;
+  let sessionComputerOverride: boolean | undefined = flags.literalWorker && process.env.JEO_MESSENGER_COMPUTER_ENABLED === "1" ? true : undefined;
 
   // Cache of live, credential-validated models per provider (refreshed by live pickers).
   // Every successful discovery is also persisted (`writeModelCache`), so the NEXT launch
@@ -971,6 +972,15 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // Session-scoped registries for DETACHED subagents, background jobs, and monitors (gjc parity).
   // Created ONCE for the whole launch session lifetime (not per-turn) so detached
   // runs persist across turns and remain controllable/inspectable.
+  let pendingMutationVerification = false;
+  try {
+    pendingMutationVerification = (await readGoalState(cwd))?.pendingMutationVerification === true;
+  } catch (error) {
+    if (!(error instanceof GoalStateCorruptError)) throw error;
+    pendingMutationVerification = true;
+    console.error(`${error.message}. Run /goal clear to remove it; fresh verification is still required.`);
+  }
+
   const subagentRegistry = new SubagentRegistry();
   const jobRegistry = new JobRegistry();
   let activeTui: LaunchTui | null = null;
@@ -1025,8 +1035,27 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // rolling base — the engine's onBudget event keeps the denominator honest as it grows.
   const initialStepLimit = flags.maxSteps > 0 ? flags.maxSteps : initialDynamicStepLimit();
   // Plain (non-TTY / --no-tui) progress sink — the cmd-mode equivalent of the live TUI.
-  const streamEvents = flags.literalPrompt
-    ? { onStep: () => { process.stderr.write("JEO_MESSENGER_STEP\n"); } }
+  const streamEvents = (flags.literalPrompt || flags.literalWorker)
+    ? {
+        onStep: () => {
+          process.stderr.write("JEO_MESSENGER_STEP\n");
+        },
+        onAssistant: (_raw: string, invocation: any) => {
+          if (invocation?.tool) {
+            const summary = summarizeForgeInvocation(invocation.tool, invocation.arguments);
+            process.stderr.write(`JEO_MESSENGER_ACTIVITY ${summary.title}\n`);
+          }
+        },
+        onToolResult: (tool: string) => {
+          process.stderr.write(`JEO_MESSENGER_ACTIVITY Finished ${tool}\n`);
+        },
+        onNotice: (msg: string) => {
+          process.stderr.write(`JEO_MESSENGER_ACTIVITY ${msg}\n`);
+        },
+        onReasoningStart: () => {
+          process.stderr.write("JEO_MESSENGER_ACTIVITY Thinking...\n");
+        },
+      }
     : createStreamEvents(initialStepLimit);
   let queueBusyInput: ((chunk: string) => boolean) | undefined;
   let queueBusyPasteActive: (() => boolean) | undefined;
@@ -1716,10 +1745,61 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         // Todos checklist used to end a finished turn stuck at "✓0 ◐1 ·4 / 5"
         // because nothing ever forced the model to update item statuses).
         let turnTodos: { title: string; status: string }[] = [];
+        const onEvidence = async (
+          evidence: { sawMutation: boolean; sawVerification: boolean; verificationStale: boolean },
+        ): Promise<void> => {
+          if (evidence.sawVerification && !evidence.verificationStale) {
+            pendingMutationVerification = false;
+          } else if (evidence.sawMutation) {
+            pendingMutationVerification = true;
+          }
+
+          let goalState: GoalState | null;
+          try {
+            goalState = await readGoalState(cwd);
+          } catch (error) {
+            if (error instanceof GoalStateCorruptError) return;
+            throw error;
+          }
+          if (!goalState) return;
+          const updatedState = applyPendingEvidence(
+            { ...goalState, pendingMutationVerification },
+            evidence,
+          );
+          pendingMutationVerification = updatedState.pendingMutationVerification === true;
+          await writeGoalState(updatedState, cwd);
+        };
+
         const onBeforeDone = async (
           reason: string,
           evidence: { sawMutation: boolean; sawVerification: boolean; verificationStale: boolean },
         ): Promise<string | null> => {
+          const runningJobs = jobRegistry.running();
+          if (runningJobs.length > 0) {
+            const jobs = runningJobs.map(record => `${record.id} (${record.command})`).join(", ");
+            return (
+              `Cannot finish while background job(s) are still running: ${jobs}. ` +
+              `Wait for them to exit or cancel them, then call done again.`
+            );
+          }
+          const runningMonitors = monitorRegistry.running();
+          if (runningMonitors.length > 0) {
+            const monitors = runningMonitors.map(record => `${record.id} (${record.command})`).join(", ");
+            return (
+              `Cannot finish while background monitor(s) are still running: ${monitors}. ` +
+              `Wait for them to exit or cancel them, then call done again.`
+            );
+          }
+
+          const inFlightMutators = subagentRegistry.inFlightMutators();
+          if (inFlightMutators.length > 0) {
+            const agents = inFlightMutators.map(record => `${record.id} (${record.role})`).join(", ");
+            return (
+              `Cannot finish while mutating subagent(s) are still in flight: ${agents}. ` +
+              `Wait for them to settle after completion or cancellation, then call done again.`
+            );
+          }
+
           const unfinished = turnTodos.filter(t => t.status !== "done");
           if (turnTodos.length > 0 && unfinished.length > 0) {
             return (
@@ -1728,8 +1808,22 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
               `(drop items that no longer apply), then call done again.`
             );
           }
+          let goalState: GoalState | null;
+          try {
+            goalState = await readGoalState(cwd);
+          } catch (error) {
+            if (error instanceof GoalStateCorruptError) {
+              return `Cannot finish: persisted goal state is corrupt. Run /goal clear, then verify any workspace mutations before calling done again.`;
+            }
+            throw error;
+          }
+          if ((pendingMutationVerification || evidence.sawMutation) && !(evidence.sawVerification && !evidence.verificationStale)) {
+            return (
+              `Cannot finish: a workspace mutation from this session still lacks a successful, non-stale verification. ` +
+              `Run a relevant test/build/typecheck/lint after the last change, then call done again.`
+            );
+          }
 
-          const goalState = await readGoalState(cwd);
           if (goalState && goalState.condition) {
             if (tui) tui.events().onNotice?.("[Goal Verifier] Running goal verification...");
             const llmVerdict = await verifyGoal(goalState.condition, history, resolveVerifierModel(turnConfig));
@@ -1737,7 +1831,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
             // judge still needs mutation/verification evidence to back it up —
             // see applyEvidenceGate's own docs (goal-verifier.ts). NOT_MET/
             // IMPOSSIBLE pass through unchanged; this only ever tightens MET.
-            const verdict = applyEvidenceGate(llmVerdict, evidence);
+            const effectiveEvidence = {
+              ...evidence,
+              pendingMutation: goalState.pendingMutationVerification === true,
+            };
+            const verdict = applyEvidenceGate(llmVerdict, effectiveEvidence);
 
             goalState.verdicts.push({
               at: Date.now(),
@@ -1895,7 +1993,8 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           // with the reroute loop below, which `routingEnabled` also gates.
           ...(routingEnabled ? { rateLimitFallbackAvailable, safetyFallbackAvailable } : {}),
 
-          events: wrapEvents(withStepPersistence({ ...withToolDetailCapture(tui ? tui.events() : streamEvents), onBeforeDone }, persistTurnTail), opik),
+          events: wrapEvents(withStepPersistence({ ...withToolDetailCapture(tui ? tui.events() : streamEvents), onBeforeDone, onEvidence }, persistTurnTail), opik),
+
         });
         const routeFailureReason = (doneReason: unknown): string | null => {
           const message = String(doneReason ?? "");
@@ -2236,6 +2335,8 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
               console.log("JEO_MESSENGER_ERROR");
               break;
             }
+
+
           }
         } finally { input.close(); }
         return;
@@ -3152,6 +3253,9 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   let typedLine = ""; // the user-typed line (restored after readline's history nav)
   let pendingSelection: string | undefined; // command chosen via arrows, applied on Enter
   let pendingImages: ImageAttachment[] = []; // clipboard images attached to the next message (ctrl+v)
+  // Remote image paths are already ingested before prompt injection. Count the
+  // associated text so the general typed-path scanner does not read it again.
+  const remoteAttachmentTextCounts = new Map<string, number>();
   let pasteInFlight = false; // guard concurrent ctrl+v clipboard reads
   let imagePasteInFlight = false;
   let idleDirtyCount: number | undefined; // git dirty count refreshed once per prompt
@@ -4508,13 +4612,31 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       // ingestion mechanism, not a parallel one. Bare paths never contain
       // whitespace here (daemon-generated temp names), so simple whitespace
       // joining is a safe token boundary for the path-token scanner.
-      const withPaths = msg.imagePaths?.length ? `${msg.text} ${msg.imagePaths.join(" ")}`.trim() : msg.text;
-      const attached = await attachImagePaths(withPaths, pendingImages.length + 1);
-      const cleanedText = attached.images.length ? attached.text : msg.text;
+      const remoteImagePaths = msg.imagePaths ?? [];
+      // Never scan remote text for local paths: a Telegram user must not be
+      // able to make the REPL read arbitrary files by mentioning one. Only
+      // daemon-owned temp attachments are eligible for image ingestion.
+      const tempRoot = path.resolve(tmpdir());
+      const validImagePaths = remoteImagePaths.filter((filePath) => {
+        if (!path.isAbsolute(filePath)) return false;
+        const relative = path.relative(tempRoot, path.resolve(filePath));
+        const parts = relative.split(path.sep);
+        return parts.length === 2 && parts[0]!.startsWith("jeo-telegram-") && parts[1] !== "" && parts[1] !== "." && parts[1] !== "..";
+      });
+      if (validImagePaths.length !== remoteImagePaths.length) return false;
+      const attached = validImagePaths.length
+        ? await attachImagePaths(validImagePaths.join(" "), pendingImages.length + 1)
+        : { text: msg.text, images: [] };
+      // Attachment parsing receives paths only; preserve the remote message
+      // text verbatim so an image never replaces the user's prompt.
+      const cleanedText = msg.text;
       // Attachment normalization must not expose a remote slash command that
       // bypasses the local approval prompt or changes local execution policy.
-      if (cleanedText.trimStart().startsWith("/")) return false;
-      if (attached.images.length) pendingImages.push(...attached.images);
+      if (cleanedText.trimStart().startsWith("/") || cleanedText.trimStart().startsWith("!")) return false;
+      if (attached.images.length) {
+        pendingImages.push(...attached.images);
+        remoteAttachmentTextCounts.set(cleanedText, (remoteAttachmentTextCounts.get(cleanedText) ?? 0) + 1);
+      }
 
       if (interactiveTurnActive && currentTurnSteer) {
         // Busy: steer the running turn exactly like a local mid-turn Enter.
@@ -4537,7 +4659,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     };
     sessionNotifyEndpoint.onConfigCommand = (cmd): void => {
       if (cmd.verbosity !== undefined) notifyVerbosity = cmd.verbosity;
-      if (cmd.redact !== undefined) notifyRedact = cmd.redact;
+      if (cmd.redact !== undefined) {
+        notifyRedact = cmd.redact;
+        sessionNotifyEndpoint.setRedact(cmd.redact);
+      }
     };
   }
 
@@ -4660,7 +4785,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       // /login→/provider login, /settings→/config, /subagent(s)→/agents.
       input = normalizeSlashAlias(input);
       pendingSelection = undefined;
-      navMatches = [];
+navMatches = [];
       navIdx = -1;
       if (input === "/discord" || input.startsWith("/discord ")) {
         const parts = input.split(/\s+/);
@@ -4711,11 +4836,17 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         }
         continue;
       }
+
+      const remoteAttachmentCount = remoteAttachmentTextCounts.get(input) ?? 0;
+      if (remoteAttachmentCount > 0) {
+        if (remoteAttachmentCount === 1) remoteAttachmentTextCounts.delete(input);
+        else remoteAttachmentTextCounts.set(input, remoteAttachmentCount - 1);
+      }
+      if (remoteAttachmentCount === 0 && input && !input.startsWith("/") && !input.startsWith("!")) {
       // File attachment: a dragged-and-dropped image file arrives as its path in
       // the typed text. Read any image path(s), attach them, and swap the path for
       // an [image #N] tag (continuing the clipboard-image numbering) — the same
       // scheme Ctrl+V uses. Skipped for slash commands and `!` shell escapes.
-      if (input && !input.startsWith("/") && !input.startsWith("!")) {
         const dropped = await attachImagePaths(input, pendingImages.length + 1);
         if (dropped.images.length > 0) {
           pendingImages.push(...dropped.images);
@@ -4956,7 +5087,14 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       if (input === "/goal" || input.startsWith("/goal ")) {
         const arg = input.substring(5).trim();
         if (!arg) {
-          const current = await readGoalState(cwd);
+          let current: GoalState | null;
+          try {
+            current = await readGoalState(cwd);
+          } catch (error) {
+            if (!(error instanceof GoalStateCorruptError)) throw error;
+            console.error(`${error.message}. Run /goal clear to remove it.`);
+            continue;
+          }
           if (current) {
             console.log(`Current goal: "${current.condition}" (set at ${new Date(current.setAt).toLocaleTimeString()})`);
           } else {
@@ -4970,10 +5108,19 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           console.log("Goal cleared.");
           continue;
         }
+        let previous: GoalState | null;
+        try {
+          previous = await readGoalState(cwd);
+        } catch (error) {
+          if (!(error instanceof GoalStateCorruptError)) throw error;
+          console.error(`${error.message}. Run /goal clear before setting a new goal.`);
+          continue;
+        }
         const state = {
           condition: arg,
           setAt: Date.now(),
           verdicts: [],
+          ...(previous?.pendingMutationVerification ? { pendingMutationVerification: true } : {}),
         };
         await writeGoalState(state, cwd);
         console.log(`Goal set to: "${arg}"`);

package/src/commands/messenger.ts

@@ -7,7 +7,7 @@ import { loadMessengerConfig, validateMessengerEnvironment } from "../messenger/
 import { createDiscordAdapter } from "../messenger/discord";
 import { setupDiscordMessenger } from "../messenger/discord-setup";
 import { messengerArtifactPrompt } from "../messenger/artifacts";
-import { createMessengerGateway, messengerSessionRoute } from "../messenger/gateway";
+import { createMessengerGateway, messengerSessionRoute, messengerConversationKey } from "../messenger/gateway";
 import { createMessengerSessionPool } from "../messenger/session-pool";
 import { createSlackAdapter } from "../messenger/slack";
 import { createTelegramAdapter } from "../messenger/telegram";
@@ -57,6 +57,10 @@ function terminalIO() {
 }
 
 function routeUuid(config: MessengerConfig, message: Parameters<MessengerReply>[0]): string {
+	if (config.independentSessions) {
+		const hex = new Bun.CryptoHasher("sha256").update(JSON.stringify([config.cwd, messengerConversationKey(message), message.messageId])).digest("hex");
+		return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-a${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+	}
 	const hex = messengerSessionRoute(config.cwd, message);
 	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-a${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
 }
@@ -114,6 +118,8 @@ export function createMessengerCliReply(config: MessengerConfig, spawn: typeof B
 		const env = Object.fromEntries(Object.entries(process.env).filter(([name, value]) => value !== undefined && !secretNames.has(name))) as Record<string, string>;
 		for (const name of secretNames) env[name] = "";
 		env.JEO_SESSION_DIR = config.sessionDir;
+		// The explicit tool allowlist is the opt-in for this worker only.
+		env.JEO_MESSENGER_COMPUTER_ENABLED = tools.includes("computer") ? "1" : "0";
 		// Never inherit another platform's fallback policy from the gateway environment.
 		delete env.JEO_MESSENGER_USAGE_FALLBACK_MODEL;
 		if (platformConfig?.usageFallbackModel) env.JEO_MESSENGER_USAGE_FALLBACK_MODEL = platformConfig.usageFallbackModel;

package/src/commands/notify.ts

@@ -15,7 +15,6 @@ interface NotifyOptions {
 }
 interface Flags {
   provider: Provider;
-  token?: string;
   tokenEnv?: string;
   appTokenEnv?: string;
   chatId?: string;
@@ -27,13 +26,13 @@ function parseFlags(args: string[]): Flags {
   const out: Flags = { provider: "telegram" };
   for (let i = 0; i < args.length; i++) {
     const flag = args[i];
+    if (flag === "--token") throw new Error("Raw --token credentials are not supported; use --token-env NAME");
     const value = args[++i];
     if (!value || value.startsWith("--")) throw new Error("Missing value for notify option (use --token-env NAME for credentials)");
     if (flag === "--provider" || flag === "--platform") {
       if (value !== "telegram" && value !== "discord" && value !== "slack") throw new Error("Provider must be telegram, discord or slack");
       out.provider = value;
-    } else if (flag === "--token") out.token = value;
-    else if (flag === "--token-env") out.tokenEnv = value;
+    } else if (flag === "--token-env") out.tokenEnv = value;
     else if (flag === "--app-token-env") out.appTokenEnv = value;
     else if (flag === "--chat-id") out.chatId = value;
     else if (flag === "--channel-id") out.channelId = value;
@@ -73,12 +72,12 @@ async function verifySlack(api: SlackApi, channelId: string): Promise<void> {
 
 async function runSetup(flags: Flags, opts: NotifyOptions): Promise<void> {
   const envName = flags.tokenEnv ?? `JEO_${flags.provider.toUpperCase()}_BOT_TOKEN`;
-  let token = flags.token ?? process.env[envName]?.trim();
+  let token = process.env[envName]?.trim();
   if (!token) {
     const name = await question(`Set the bot token in an environment variable, then enter its NAME (default ${envName}): `, opts);
     token = process.env[name || envName]?.trim();
   }
-  if (!token) throw new Error(`Bot token environment variable is empty; use --token-env NAME (preferred over --token)`);
+  if (!token) throw new Error("Bot token environment variable is empty; use --token-env NAME");
   const existing = (await readGlobalConfig()).notifications;
   let allowedUserIds = flags.allowedUserIds;
   if (flags.provider === "slack") {
@@ -237,7 +236,7 @@ export async function runNotifyCommand(args: string[], opts: NotifyOptions = {})
   } catch (error) {
     // Only emit our known configuration/API errors, never fetch URLs or token-bearing bodies.
     const message = error instanceof Error ? error.message : "request failed";
-    const safe = /^(Missing |Unknown notify|Provider |Allowed user|Telegram |Discord |Slack |Bot token|Missing setup|A daemon|Notification lock recovery|Usage:)/.test(message) && !message.includes("https:") && !message.includes("http:");
+    const safe = /^(Missing |Unknown notify|Raw --token|Provider |Allowed user|Telegram |Discord |Slack |Bot token|Missing setup|A daemon|Notification lock recovery|Usage:)/.test(message) && !message.includes("https:") && !message.includes("http:");
     console.error(`Notification ${sub} failed: ${safe ? message : "API or storage request failed; check credentials, connectivity and permissions"}${(error instanceof DiscordApiError || error instanceof SlackApiError) && error.status ? ` (HTTP ${error.status})` : ""}`);
     process.exitCode = 1;
   }

package/src/commands/skills.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { SKILLS, getSkillFrom, formatSkill, loadSkills, skillDirs, bundledSkillFileContent, userSkillsDir } from "../skills/catalog";
+import { inventorySkillConflicts } from "../agent/skill-router";
 import { getLocalJeoDir } from "../agent/state";
 import { appendSkillLesson, evalSkillLessons, type SkillLesson } from "../agent/skill-lessons";
 
@@ -221,6 +222,14 @@ export async function runSkillsCommand(args: string[] = []): Promise<void> {
       console.log("Install/inspect bundled defaults: 'jeo skills sync' (preserve local) · '--check' (drift report) · '--force' (overwrite local)");
       console.log("Discovery dirs (later wins on name clash; JEO_SKILLS_DIR adds more):");
       for (const d of skillDirs(cwd)) console.log(`  ${d}`);
+      const conflicts = inventorySkillConflicts(skills);
+      if (conflicts.length > 0) {
+        console.log("\nECC Single-Harness duplicate identity warnings:");
+        for (const c of conflicts) {
+          console.log(`  ! Duplicate skill '${c.normalized}' installed across multiple distinct paths:`);
+          for (const p of c.paths) console.log(`      ${p}`);
+        }
+      }
       console.log("");
     }
     return;