jeo-code 0.12.10 → 0.12.12

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

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;

package/src/commands/team.ts

@@ -168,8 +168,14 @@ export interface TeamEngineOptions {
    *  write/edit/bash fails the task instead of merely warning (round-11). */
   strictMutations?: boolean;
 }
+export interface TeamEngineResult {
+  ok: boolean;
+  reason?: string;
+  /** True when a delegated child may have changed workspace state before settling. */
+  mutationMayHaveOccurred?: boolean;
+}
 
-export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<{ ok: boolean; reason?: string }> {
+export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<TeamEngineResult> {
   const cwd = opts.cwd ?? process.cwd();
 
   const log = (msg?: any) => {
@@ -339,6 +345,7 @@ export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<{ ok:
 
     await writeWorkflowState("team", teamState, cwd);
     const renderOpts: RalphRenderOptions = { color: !!process.stdout.isTTY, indexed: true };
+    let mutationMayHaveOccurred = false;
     for (const line of formatRalphTodoGuide(tasks, activeStepIndex(tasks.length, teamState.pending_tasks), teamState.completed_tasks ?? [], renderOpts)) log(line);
 
     while (teamState.pending_tasks && teamState.pending_tasks.length > 0) {
@@ -384,20 +391,22 @@ export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<{ ok:
         });
 
         if (opts.signal?.aborted) {
-          return { ok: false, reason: "aborted" };
+          return { ok: false, reason: "aborted", ...(mutationMayHaveOccurred ? { mutationMayHaveOccurred: true } : {}) };
         }
 
         if (groupResult.ok) {
+          mutationMayHaveOccurred ||= groupResult.mutationMayHaveOccurred === true;
           teamState.completed_tasks = [...(teamState.completed_tasks ?? []), ...groupSteps.map(s => s.name)];
           teamState.pending_tasks = teamState.pending_tasks.slice(groupSteps.length);
           await writeWorkflowState("team", teamState, cwd);
           log(`${categoryBadge("done")} Completed parallel group: ${groupSteps.map(s => `"${s.name}"`).join(", ")}`);
         } else {
+          mutationMayHaveOccurred ||= groupResult.mutationMayHaveOccurred === true;
           teamState.current_phase = "failed";
           teamState.failed_task = groupResult.failedTaskName;
           await writeWorkflowState("team", teamState, cwd);
           log(`${categoryBadge("error")} Failed on parallel group step: "${groupResult.failedTaskName}". Halting execution.`);
-          return { ok: false, reason: `Failed on task: "${groupResult.failedTaskName}"` };
+          return { ok: false, reason: `Failed on task: "${groupResult.failedTaskName}"`, ...(mutationMayHaveOccurred ? { mutationMayHaveOccurred: true } : {}) };
         }
         continue;
       }
@@ -409,7 +418,7 @@ export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<{ ok:
         opts.onProgress({ skill: "team", phase: "executing", detail: `Current task: ${currentTask}` });
       }
 
-      const success = await executeTaskWithAgent({
+      const taskResult = await executeTaskWithAgent({
         task: currentTask,
         tasks,
         activeIndex,
@@ -419,12 +428,13 @@ export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<{ ok:
         strictMutations: opts.strictMutations ?? false,
         log,
       });
+      mutationMayHaveOccurred ||= taskResult.mutationMayHaveOccurred === true;
 
       if (opts.signal?.aborted) {
-        return { ok: false, reason: "aborted" };
+        return { ok: false, reason: "aborted", ...(mutationMayHaveOccurred ? { mutationMayHaveOccurred: true } : {}) };
       }
 
-      if (success) {
+      if (taskResult.ok) {
         teamState.completed_tasks = [...(teamState.completed_tasks ?? []), currentTask];
         teamState.pending_tasks = teamState.pending_tasks.slice(1);
         await writeWorkflowState("team", teamState, cwd);
@@ -436,7 +446,7 @@ export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<{ ok:
         teamState.failed_task = currentTask;
         await writeWorkflowState("team", teamState, cwd);
         log(`${categoryBadge("error")} Failed on task: "${currentTask}". Halting execution.`);
-        return { ok: false, reason: `Failed on task: "${currentTask}"` };
+        return { ok: false, reason: `Failed on task: "${currentTask}"`, ...(mutationMayHaveOccurred ? { mutationMayHaveOccurred: true } : {}) };
       }
     }
 
@@ -450,7 +460,7 @@ export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<{ ok:
         opts.onProgress({ skill: "team", phase: "complete" });
       }
     }
-    return { ok: true };
+    return { ok: true, ...(mutationMayHaveOccurred ? { mutationMayHaveOccurred: true } : {}) };
   } finally {
     await releaseLock();
   }
@@ -464,7 +474,11 @@ export async function runTeamCommand(args: string[] = []): Promise<void> {
   }
 }
 
-async function executeTaskWithAgent(ctx: RalphSubagentPromptContext & { cwd: string; roleId?: string; strictMutations?: boolean; log: (line: string) => void }): Promise<boolean> {
+interface TeamTaskResult {
+  ok: boolean;
+  mutationMayHaveOccurred?: boolean;
+}
+async function executeTaskWithAgent(ctx: RalphSubagentPromptContext & { cwd: string; roleId?: string; strictMutations?: boolean; log: (line: string) => void }): Promise<TeamTaskResult> {
   const log = ctx.log;
   const config = await readGlobalConfig();
   const role = getSubagentRole(ctx.roleId, config) ?? defaultSubagentRole();
@@ -476,25 +490,33 @@ async function executeTaskWithAgent(ctx: RalphSubagentPromptContext & { cwd: str
   const projectContext = await loadProjectContext(ctx.cwd);
 
   // `jeo team` now runs every step through the SAME execution core as the `task`/
-  // `subagent` tools (`runSubagentOnce`) — one way a jeo-code subagent runs,
-  // whether launched interactively, in a fan-out batch, detached, or as a team
-  // plan step. This gets team plan steps the same fenced-report protection
-  // (prompt-injection-safe) and done-reason contract validation the interactive
-  // tools already had, instead of a second hand-rolled copy of that logic.
-  const result = await runSubagentOnce(role, buildRalphSubagentPrompt(ctx), "", ctx.cwd, {
-    config,
-    projectContext,
-    onEvent: ev => {
-      if (ev.kind === "step") {
-        log(formatRalphStreamEvent("step", ev.detail ?? `${role.title} thinking ${ev.step ?? "?"}/${ev.maxSteps ?? maxSteps}`, renderOpts));
-      } else if (ev.kind === "tool") {
-        const suffix = ev.summary ? ` — ${ev.summary}` : "";
-        log(formatRalphStreamEvent(ev.success ? "complete" : "error", `tool ${ev.detail}${suffix}`, renderOpts));
-      }
-    },
-  });
+  // `subagent` tools — one way a jeo-code subagent runs, whether launched
+  // interactively, in a fan-out batch, detached, or as a team plan step.
+  let result: SubagentRunResult;
+  try {
+    result = await runSubagentOnce(role, buildRalphSubagentPrompt(ctx), "", ctx.cwd, {
+      config,
+      projectContext,
+      onEvent: ev => {
+        if (ev.kind === "step") {
+          log(formatRalphStreamEvent("step", ev.detail ?? `${role.title} thinking ${ev.step ?? "?"}/${ev.maxSteps ?? maxSteps}`, renderOpts));
+        } else if (ev.kind === "tool") {
+          const suffix = ev.summary ? ` — ${ev.summary}` : "";
+          log(formatRalphStreamEvent(ev.success ? "complete" : "error", `tool ${ev.detail}${suffix}`, renderOpts));
+        }
+      },
+    });
+  } catch (error: unknown) {
+    const explicitSignal = typeof error === "object" && error !== null && "mutationMayHaveOccurred" in error && error.mutationMayHaveOccurred === true;
+    const message = error instanceof Error ? error.message : String(error);
+    log(formatRalphStreamEvent("error", message, renderOpts));
+    return { ok: false, ...(explicitSignal || !role.readOnly ? { mutationMayHaveOccurred: true } : {}) };
+  }
 
-  return evaluateSubagentResult(result, role, ctx.strictMutations ?? false, log, renderOpts);
+  return {
+    ok: evaluateSubagentResult(result, role, ctx.strictMutations ?? false, log, renderOpts),
+    ...(result.mutationMayHaveOccurred ? { mutationMayHaveOccurred: true } : {}),
+  };
 }
 
 /**
@@ -543,23 +565,14 @@ function evaluateSubagentResult(
     return false;
   }
 
-  // Round-8: a mutating role finished without a successful file mutation — the
-  // task may be legitimately read-only, but its "Changed Files:" claim is
-  // unverified. bash is tracked apart: an only-bash run MIGHT have mutated.
+  // A mutating role's changed-files claim needs an observed workspace mutation.
+  // Bash is separate because it may or may not have changed files.
   if (!role.readOnly && result.fileMutations === 0) {
     const msg = result.bashRuns === 0
-      ? `${role.title} completed WITHOUT any successful write/edit/bash — treat its changed-files claim as unverified.`
-      : `${role.title} completed with only bash (no write/edit) — verify its changed-files claim independently.`;
-    // Round-11: under --strict-mutations, a mutating role that took NO action at
-    // all (no write/edit/bash) is a hard failure — an empty run must not pass as
-    // a completed task. bash-only stays advisory to avoid penalizing shell edits.
-    const hardFail = strictMutations && result.bashRuns === 0;
-    // Round-12: separate the tones so a passing advisory run doesn't masquerade
-    // as a stream:error — only a real hard-fail is red; an advisory note is warn.
-    log(formatRalphStreamEvent(hardFail ? "error" : "warn", msg, renderOpts));
-    if (hardFail) {
-      return false;
-    }
+      ? `${role.title} completed WITHOUT any successful workspace mutation or bash call — treat its changed-files claim as unverified.`
+      : `${role.title} completed without a successful workspace mutation (only bash ran) — verify its changed-files claim independently.`;
+    log(formatRalphStreamEvent(strictMutations ? "error" : "warn", msg, renderOpts));
+    if (strictMutations && result.bashRuns === 0) return false;
   }
 
   // Surface the subagent's full report (header + step trace + fenced reason +
@@ -610,7 +623,7 @@ async function runParallelGroup(
     log: (line: string) => void;
     slug: string;
   },
-): Promise<{ ok: true } | { ok: false; failedTaskName: string }> {
+): Promise<{ ok: true; mutationMayHaveOccurred?: boolean } | { ok: false; failedTaskName: string; mutationMayHaveOccurred?: boolean }> {
   const { cwd, teamCfg, tasks, completed, strictMutations, log, slug } = ctx;
   const renderOpts: RalphRenderOptions = { color: !!process.stdout.isTTY, indexed: true };
 
@@ -654,16 +667,22 @@ async function runParallelGroup(
           }
         },
       });
-      // Capture the FULL SubagentRunResult (doneReason/fileMutations/etc.) before
-      // collapsing it to the plain ToolResult shape SubagentRegistry stores.
+      // Capture the FULL SubagentRunResult before collapsing it to the plain
+      // ToolResult shape SubagentRegistry stores, including mutation evidence.
       resultsByIndex.set(step.index, result);
-      return { success: result.success, output: result.output, error: result.error };
-    });
+      return {
+        success: result.success,
+        output: result.output,
+        error: result.error,
+        mutationMayHaveOccurred: result.mutationMayHaveOccurred,
+      };
+    }, { readOnly: role.readOnly });
     idByIndex.set(step.index, record.id);
   }
 
   // No timeout — team runs can take as long as needed.
   await registry.awaitIds([...idByIndex.values()]);
+  const registryMutation = registry.list().some(record => record.mutationMayHaveOccurred === true);
 
   // Evaluate + commit each successful worktree, IN ARRAY ORDER (not completion
   // order). Any failure stops the whole group immediately: no merges happen,
@@ -674,12 +693,12 @@ async function runParallelGroup(
     const wt = worktreeByIndex.get(step.index)!;
     if (!result) {
       log(formatRalphStreamEvent("error", `[${step.name}] subagent produced no result`, renderOpts));
-      return { ok: false, failedTaskName: step.name };
+      return { ok: false, failedTaskName: step.name, ...(registryMutation ? { mutationMayHaveOccurred: true } : {}) };
     }
     const success = evaluateSubagentResult(result, role, strictMutations, log, renderOpts);
     if (!success) {
       log(`${categoryBadge("error")} Parallel group step "${step.name}" failed — its worktree (${wt.path}) and the OTHER group worktrees are left in place for inspection; nothing was merged.`);
-      return { ok: false, failedTaskName: step.name };
+      return { ok: false, failedTaskName: step.name, ...(registryMutation || result.mutationMayHaveOccurred ? { mutationMayHaveOccurred: true } : {}) };
     }
     // An empty diff (read-only role, or a no-op) needs no commit — skip it for
     // the merge step below without treating it as an error.
@@ -687,12 +706,12 @@ async function runParallelGroup(
       const add = runGitSync(wt.path, ["add", "-A"]);
       if (!add.ok) {
         log(`${categoryBadge("error")} Failed to stage changes in worktree ${wt.path} for step "${step.name}": ${add.stderr.trim()}`);
-        return { ok: false, failedTaskName: step.name };
+        return { ok: false, failedTaskName: step.name, ...(registryMutation ? { mutationMayHaveOccurred: true } : {}) };
       }
       const commit = runGitSync(wt.path, ["commit", "-m", step.name]);
       if (!commit.ok) {
         log(`${categoryBadge("error")} Failed to commit changes in worktree ${wt.path} for step "${step.name}": ${commit.stderr.trim()}`);
-        return { ok: false, failedTaskName: step.name };
+        return { ok: false, failedTaskName: step.name, ...(registryMutation ? { mutationMayHaveOccurred: true } : {}) };
       }
     }
   }
@@ -710,7 +729,7 @@ async function runParallelGroup(
         `the merge was aborted automatically (no changes were auto-resolved). Resolve manually: ` +
         `cd ${wt.path} to inspect the change, then run 'git merge ${wt.branch}' yourself from ${cwd}.\n${(merge.stderr + merge.stdout).trim()}`,
       );
-      return { ok: false, failedTaskName: step.name };
+      return { ok: false, failedTaskName: step.name, ...(registryMutation ? { mutationMayHaveOccurred: true } : {}) };
     }
     log(`${categoryBadge("done")} Merged step "${step.name}" (branch ${wt.branch}) into the current branch.`);
   }
@@ -725,5 +744,5 @@ async function runParallelGroup(
     }
   }
 
-  return { ok: true };
+  return { ok: true, ...(registryMutation ? { mutationMayHaveOccurred: true } : {}) };
 }

package/src/messenger/activity.ts

@@ -1,30 +1,26 @@
 import type { AgentLoopEvents, ToolInvocation } from "../agent/engine";
 import type { MessengerActivityReporter } from "./types";
 
-/**
- * Derive one-line progress from session events: the model's declared tool intent (falling back to the
- * tool name) and long-running lifecycle notices. Raw tool arguments, results and errors never surface.
- */
+/** Derive bounded progress without exposing tool arguments, results, or provider errors. */
 export function createMessengerActivityEvents(report: MessengerActivityReporter): AgentLoopEvents {
 	let step = 0;
 	return {
+		onStep(current) {
+			step = current;
+			report(`Step ${step} · Thinking`);
+		},
 		onAssistant(_raw: string, invocation: ToolInvocation | null) {
 			if (!invocation || invocation.tool === "done") return;
-			step++;
-			const intent =
-				invocation.arguments &&
-				typeof invocation.arguments.i === "string" &&
-				invocation.arguments.i.trim()
-					? invocation.arguments.i.trim()
-					: `Using ${invocation.tool}`;
-			report(`Step ${step} · ${intent}`);
+			const tool = /^[a-zA-Z0-9_-]{1,40}$/.test(invocation.tool) ? invocation.tool : "tool";
+			report(`Step ${step} · Running ${tool}`);
+		},
+		onToolResult(tool, success) {
+			const name = /^[a-zA-Z0-9_-]{1,40}$/.test(tool) ? tool : "tool";
+			report(`Step ${step} · ${name} ${success ? "finished" : "failed"}`);
 		},
 		onNotice(message: string) {
-			if (/compact/i.test(message)) {
-				report("Compacting context");
-			} else if (/retry|rate limit/i.test(message)) {
-				report("Retrying after a provider error");
-			}
+			if (/compact/i.test(message)) report("Compacting context");
+			else if (/retry|rate limit/i.test(message)) report("Retrying after a provider error");
 		},
 	};
 }

package/src/messenger/config.ts

@@ -61,9 +61,11 @@ export function resolveMessengerToken(
 	return undefined;
 }
 
+export const DEFAULT_MESSENGER_TOOLS = ["read", "find", "search", "write", "edit", "bash", "computer"];
+
 export function parseMessengerConfig(value: unknown, baseDir: string): MessengerConfig {
 	const input = object(value, "Messenger config");
-	keys(input, ["cwd", "sessionDir", "toolNames", "platforms"], "Messenger config");
+	keys(input, ["cwd", "sessionDir", "toolNames", "platforms", "independentSessions"], "Messenger config");
 	const platformsInput = object(input.platforms, "platforms");
 	keys(platformsInput, PLATFORMS, "platforms");
 	if (Object.keys(platformsInput).length === 0) throw new Error("At least one messenger platform is required");
@@ -98,7 +100,7 @@ export function parseMessengerConfig(value: unknown, baseDir: string): Messenger
 		}
 		platforms[platform] = config;
 	}
-	const toolNames = input.toolNames === undefined ? [] : input.toolNames;
+	const toolNames = input.toolNames === undefined ? DEFAULT_MESSENGER_TOOLS : input.toolNames;
 	if (
 		!Array.isArray(toolNames) ||
 		toolNames.some(name => typeof name !== "string" || !Object.hasOwn(TOOLS, name)) ||
@@ -106,6 +108,7 @@ export function parseMessengerConfig(value: unknown, baseDir: string): Messenger
 	) {
 		throw new Error("toolNames must be a unique list drawn from read, grep, glob, find, search, bash, edit, write, computer");
 	}
+	const independentSessions = input.independentSessions !== undefined ? Boolean(input.independentSessions) : true;
 	return {
 		cwd: path.resolve(baseDir, input.cwd === undefined ? "." : string(input.cwd, "cwd")),
 		sessionDir: path.resolve(
@@ -114,6 +117,7 @@ export function parseMessengerConfig(value: unknown, baseDir: string): Messenger
 		),
 		toolNames: [...toolNames] as string[],
 		platforms,
+		independentSessions,
 	};
 }
 

package/src/messenger/discord-setup.ts

@@ -510,11 +510,13 @@ export async function setupDiscordMessenger(
 
 	const discord: Record<string, unknown> = { ...previous, tokenEnv, allowedUserIds: userIds, allowedChannelIds };
 	if (options.artifacts) discord.artifactDir = "./artifacts";
+	const defaultTools = ["read", "find", "search", "write", "edit", "bash", "computer"];
 	const config = {
 		...existing,
 		cwd: str(existing?.cwd) ?? "./workspace",
 		sessionDir: str(existing?.sessionDir) ?? "./sessions",
-		toolNames: options.toolNames ?? (Array.isArray(existing?.toolNames) ? existing.toolNames : []),
+		toolNames: options.toolNames ?? (Array.isArray(existing?.toolNames) ? existing.toolNames : defaultTools),
+		independentSessions: existing?.independentSessions !== undefined ? Boolean(existing.independentSessions) : true,
 		platforms: { ...platforms, discord },
 	};
 	for (const relative of [config.cwd, config.sessionDir, discord.artifactDir]) {

package/src/messenger/discord.ts

@@ -344,6 +344,7 @@ export function createDiscordAdapter(
 		}
 	};
 	const activityMessages = new Map<string, string>();
+	const activityHistory = new Map<string, string[]>();
 	const headers = (): Record<string, string> => {
 		if (!token) throw new DiscordConfigurationError("Discord bot token is missing");
 		return { Authorization: `Bot ${token}`, "Content-Type": "application/json" };
@@ -531,39 +532,39 @@ export function createDiscordAdapter(
 				deps.fetch,
 			);
 		},
-		async activity(message, text, signal) {
+		async activity(message, text, signal, outcome = "success") {
 			const channelId = message.threadId ?? message.channelId;
 			const key = JSON.stringify([channelId, message.messageId]);
 			const messages = `${DISCORD_API}/channels/${encodeURIComponent(channelId)}/messages`;
 			const statusId = activityMessages.get(key);
+			const previous = activityHistory.get(key) ?? [];
 			if (text === undefined) {
 				if (!statusId) return;
+				const label = outcome === "success" ? "✅ Complete" : outcome === "failure" ? "❌ Failed" : "⏹ Cancelled";
 				try {
 					await messengerFetchJson(
 						`${messages}/${encodeURIComponent(statusId)}`,
-						{ method: "DELETE", headers: headers() },
-						signal,
-						deps.fetch,
+						{ method: "PATCH", headers: headers(), body: JSON.stringify({ content: [label, ...previous].join("\n"), allowed_mentions: { parse: [] } }) },
+						signal, deps.fetch,
 					);
 				} catch (error) {
 					if (!(error instanceof MessengerHttpError && error.status === 404)) throw error;
 				}
 				activityMessages.delete(key);
+				activityHistory.delete(key);
 				return;
 			}
-			const content = `⏳ ${text}`;
+			// Keep only a short, bounded history of delivered updates in one editable message.
+			const history = [...previous, `• ${text}`].slice(-6);
+			const content = ["⏳ In progress", ...history].join("\n");
 			if (statusId) {
 				try {
 					await messengerFetchJson(
 						`${messages}/${encodeURIComponent(statusId)}`,
-						{
-							method: "PATCH",
-							headers: headers(),
-							body: JSON.stringify({ content, allowed_mentions: { parse: [] } }),
-						},
-						signal,
-						deps.fetch,
+						{ method: "PATCH", headers: headers(), body: JSON.stringify({ content, allowed_mentions: { parse: [] } }) },
+						signal, deps.fetch,
 					);
+					activityHistory.set(key, history);
 					return;
 				} catch (error) {
 					if (!(error instanceof MessengerHttpError && error.status === 404)) throw error;
@@ -572,17 +573,13 @@ export function createDiscordAdapter(
 			}
 			const created = await messengerFetchJson(
 				messages,
-				{
-					method: "POST",
-					headers: headers(),
-					body: JSON.stringify({ content, allowed_mentions: { parse: [] }, flags: DISCORD_ACTIVITY_FLAGS }),
-				},
-				signal,
-				deps.fetch,
+				{ method: "POST", headers: headers(), body: JSON.stringify({ content, allowed_mentions: { parse: [] }, flags: DISCORD_ACTIVITY_FLAGS }) },
+				signal, deps.fetch,
 			);
 			if (!isRecord(created) || typeof created.id !== "string" || !created.id)
 				throw new Error("Discord activity message returned no ID");
 			activityMessages.set(key, created.id);
+			activityHistory.set(key, history);
 		},
 		async send(message, text, signal) {
 			let files: { name: string; data: Uint8Array }[] = [];

package/src/messenger/gateway.ts

@@ -33,8 +33,8 @@ export function activityLine(text: string): string {
 
 export interface ActivityReporter {
 	report: MessengerActivityReporter;
-	/** Stop updates and remove any shown line; idempotent and never rejects. */
-	close(): Promise<void>;
+	/** Stop updates and finalize the status; idempotent and never rejects. */
+	close(outcome?: "success" | "failure" | "cancelled"): Promise<void>;
 }
 
 const NO_ACTIVITY: ActivityReporter = { report() {}, close: () => Promise.resolve() };
@@ -132,7 +132,7 @@ export function createActivityReporter(
 			pumping = true;
 			pump = run();
 		},
-		close() {
+		close(outcome = "success") {
 			closing ??= (async () => {
 				closed = true;
 				wake?.();
@@ -140,7 +140,7 @@ export function createActivityReporter(
 				if (!shown) return;
 				for (let attempt = 0; ; attempt++) {
 					try {
-						await boundedActivity(bounded => activity.call(adapter, destination, undefined, bounded));
+						await boundedActivity(bounded => activity.call(adapter, destination, undefined, bounded, outcome));
 						return;
 					} catch (error) {
 						const wait =
@@ -340,6 +340,7 @@ export function createMessengerGateway(
 			conversationTails.set(conversation, tail);
 			await previous;
 			activity = createActivityReporter(adapter, destination, signal, activityIntervalMs);
+			activity.report("Starting request");
 			let text: string;
 			try {
 				text = await reply(destination, signal, activity.report);
@@ -353,9 +354,6 @@ export function createMessengerGateway(
 				}
 				if (signal.aborted) return;
 				text = "The request could not be completed. Please try again.";
-			} finally {
-				// Retire the status line alongside reply delivery rather than delaying the reply on it.
-				void activity.close();
 			}
 			if (!signal.aborted && text.trim()) {
 				// A failed send may already have delivered a chunk: never retry the entire reply.
@@ -363,9 +361,10 @@ export function createMessengerGateway(
 			}
 			if (!signal.aborted) status(failed ? "failure" : "success");
 		} catch {
+			failed = true;
 			if (!signal.aborted) status("failure");
 		} finally {
-			await activity.close();
+			await activity.close(failed ? "failure" : signal.aborted ? "cancelled" : "success");
 			release();
 			if (tail && conversationTails.get(conversation) === tail) conversationTails.delete(conversation);
 			resolve();