@agentmeshhq/agent 0.1.16 → 0.2.0

package/src/cli/attach.ts

@@ -1,6 +1,4 @@
-import { execSync } from "node:child_process";
 import pc from "picocolors";
-import { getAgentState } from "../config/loader.js";
 import { attachSession, getSessionName, sessionExists } from "../core/tmux.js";
 
 export function attach(name: string): void {
@@ -9,25 +7,6 @@ export function attach(name: string): void {
     process.exit(1);
   }
 
-  // Check if this is a sandbox agent
-  const localAgent = getAgentState(name);
-
-  if (localAgent?.sandboxContainer) {
-    // Sandbox agent - attach via docker exec
-    console.log(`Attaching to sandbox container ${localAgent.sandboxContainer}...`);
-    console.log(pc.dim("Detach with: Ctrl+B, D\n"));
-
-    try {
-      execSync(`docker exec -it ${localAgent.sandboxContainer} agentmesh attach ${name}`, {
-        stdio: "inherit",
-      });
-    } catch {
-      // execSync throws on non-zero exit, but that's expected when detaching
-    }
-    return;
-  }
-
-  // Host agent - attach via tmux
   const sessionName = getSessionName(name);
 
   if (!sessionExists(sessionName)) {

package/src/cli/index.ts

@@ -53,7 +53,8 @@ program
   .option("-w, --workdir <path>", "Working directory")
   .option("-m, --model <model>", "Model identifier")
   .option("-f, --foreground", "Run in foreground (blocking)")
-  .option("--no-context", "Start fresh without restoring previous context")
+  .option("--restore-context", "Restore context from previous session (default: disabled)")
+  .option("--worker", "Enable auto-nudge and restart for worker agents (default: disabled)")
   .option("--auto-setup", "Auto-clone repository for project assignments")
   .option("--serve", "Run opencode serve instead of tmux TUI (for Integration Service)")
   .option("--serve-port <port>", "Port for opencode serve (default: 3001)", "3001")

package/src/cli/nudge.ts

@@ -1,4 +1,3 @@
-import { spawnSync } from "node:child_process";
 import pc from "picocolors";
 import { getAgentState, loadConfig, loadState } from "../config/loader.js";
 import { registerAgent } from "../core/registry.js";
@@ -25,23 +24,6 @@ export async function nudge(name: string, message: string): Promise<void> {
   // Check if this is a local agent
   const localAgent = getAgentState(name);
 
-  // Sandbox agent - route nudge through docker exec
-  if (localAgent?.sandboxContainer) {
-    const result = spawnSync(
-      "docker",
-      ["exec", localAgent.sandboxContainer, "agentmesh", "nudge", name, message],
-      { encoding: "utf-8", stdio: "pipe" },
-    );
-
-    if (result.status === 0) {
-      console.log(pc.green(`Nudged "${name}" in sandbox.`));
-    } else {
-      console.log(pc.red(`Failed to nudge "${name}" in sandbox: ${result.stderr}`));
-    }
-    return;
-  }
-
-  // Local agent with tmux session on host
   if (localAgent && sessionExists(getSessionName(name))) {
     // Local nudge via tmux send-keys
     const formatted = `[AgentMesh] Nudge from CLI:

package/src/cli/start.ts

@@ -12,7 +12,8 @@ export interface StartOptions {
   workdir?: string;
   model?: string;
   foreground?: boolean;
-  noContext?: boolean;
+  restoreContext?: boolean;
+  worker?: boolean;
   autoSetup?: boolean;
   /** Run opencode serve instead of tmux TUI (for Integration Service) */
   serve?: boolean;
@@ -56,7 +57,8 @@ export async function start(options: StartOptions): Promise<void> {
     try {
       const daemon = new AgentDaemon({
         ...options,
-        restoreContext: !options.noContext,
+        restoreContext: options.restoreContext,
+        worker: options.worker,
         autoSetup: options.autoSetup,
       });
       await daemon.start();
@@ -80,7 +82,8 @@ export async function start(options: StartOptions): Promise<void> {
   if (options.command) args.push("--command", options.command);
   if (options.workdir) args.push("--workdir", options.workdir);
   if (options.model) args.push("--model", options.model);
-  if (options.noContext) args.push("--no-context");
+  if (options.restoreContext) args.push("--restore-context");
+  if (options.worker) args.push("--worker");
   if (options.autoSetup) args.push("--auto-setup");
   if (options.serve) {
     args.push("--serve");

package/src/config/schema.ts

@@ -59,6 +59,8 @@ export interface AgentState {
   stuckSince?: string;
   /** Current agent status */
   status?: AgentStatus;
+  /** OpenCode session ID for native session resume */
+  opencodeSessionId?: string;
 }
 
 export interface State {

package/src/core/daemon.ts

@@ -16,6 +16,7 @@ import { handleWebSocketEvent, injectRestoredContext, injectStartupMessage } fro
 import { checkInbox, fetchAssignments, registerAgent, type ServerContext } from "./registry.js";
 import { buildRunnerConfig, getRunnerDisplayName, type RunnerConfig } from "./runner.js";
 import { DockerSandbox } from "./sandbox.js";
+import { getLatestSessionId, snapshotSessionId, waitForNewSessionId } from "./session-id.js";
 import {
   captureSessionContext,
   captureSessionOutput,
@@ -56,8 +57,10 @@ export interface DaemonOptions {
   workdir?: string;
   model?: string;
   daemonize?: boolean;
-  /** Whether to restore context from previous session (default: true) */
+  /** Whether to restore context from previous session (default: false) */
   restoreContext?: boolean;
+  /** Only send nudges/restart for worker agents (default: false) */
+  worker?: boolean;
   /** Auto-clone repository for project assignments */
   autoSetup?: boolean;
   /** Run opencode serve instead of tmux TUI (for Integration Service) */
@@ -86,6 +89,7 @@ export class AgentDaemon {
   private isRunning = false;
   private assignedProject: string | undefined;
   private shouldRestoreContext: boolean;
+  private isWorkerAgent: boolean;
   private autoSetup: boolean;
   private serveMode: boolean;
   private servePort: number;
@@ -97,6 +101,9 @@ export class AgentDaemon {
   private sandbox: DockerSandbox | null = null;
   private healthCheckInterval: ReturnType<typeof setInterval> | null = null;
   private serverContext: ServerContext | undefined;
+  // Session resume tracking
+  private _preStartSessionId: string | null | undefined;
+  private _attemptedResumeSessionId: string | undefined;
   // Auto-restart tracking
   private restartCount = 0;
   private lastStableTime: Date | null = null;
@@ -111,11 +118,12 @@ export class AgentDaemon {
 
     // Ensure config has required fields with defaults
     if (!config.agents) config.agents = [];
-    if (!config.defaults) config.defaults = { command: "opencode", model: "claude-sonnet-4" };
+    if (!config.defaults) config.defaults = { command: "opencode", model: "claude-sonnet-4-5-20250929" };
 
     this.config = config;
     this.agentName = options.name;
-    this.shouldRestoreContext = options.restoreContext !== false;
+    this.shouldRestoreContext = options.restoreContext === true;
+    this.isWorkerAgent = options.worker === true;
     this.autoSetup = options.autoSetup === true;
 
     // Find or create agent config
@@ -231,6 +239,20 @@ export class AgentDaemon {
 
       // Create tmux session if it doesn't exist
       if (!sessionAlreadyExists) {
+        // Load saved context to check for OpenCode session ID (for native resume)
+        let savedSessionId: string | undefined;
+        if (this.shouldRestoreContext && this.agentId) {
+          const savedContext = loadContext(this.agentId);
+          savedSessionId = savedContext?.custom?.opencodeSessionId as string | undefined;
+          if (savedSessionId) {
+            console.log(`[CONTEXT] Found saved OpenCode session ID: ${savedSessionId}`);
+          }
+        }
+
+        // Snapshot the latest session ID in logs BEFORE starting OpenCode.
+        // This lets us detect whether OpenCode actually resumed vs created a new session.
+        const preStartSessionId = snapshotSessionId(this.agentName);
+
         console.log(`Creating tmux session: ${sessionName}`);
 
         // Include runner env vars (e.g., OPENCODE_MODEL) at session creation
@@ -239,11 +261,16 @@ export class AgentDaemon {
           this.agentConfig.command,
           this.agentConfig.workdir,
           this.runnerConfig.env, // Apply model env at process start
+          savedSessionId, // Resume OpenCode session if available
         );
 
         if (!created) {
           throw new Error("Failed to create tmux session");
         }
+
+        // Store pre-start snapshot for fallback detection later
+        this._preStartSessionId = preStartSessionId;
+        this._attemptedResumeSessionId = savedSessionId;
       } else {
         console.log(`Reconnecting to existing session: ${sessionName}`);
         // Update environment for existing session
@@ -371,10 +398,61 @@ export class AgentDaemon {
       console.log("Checking for previous context...");
       const savedContext = loadContext(this.agentId);
       if (savedContext) {
-        console.log(`Restoring context from ${savedContext.savedAt}`);
-        // Wait a moment for the session to be ready
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-        injectRestoredContext(this.agentName, savedContext);
+        if (this._attemptedResumeSessionId && !this.serveMode && !this.sandboxMode) {
+          // Native session resume was attempted — verify it worked.
+          // Wait for OpenCode to write a NEW session entry to logs.
+          // If resume succeeded, it reuses the session (no new entry).
+          // If resume failed, OpenCode creates a new session (new entry appears).
+          const newSessionId = await waitForNewSessionId(
+            this.agentName,
+            this._preStartSessionId ?? null,
+            15000,
+          );
+
+          if (!newSessionId) {
+            // No new session appeared in logs. Could mean:
+            // a) Resume succeeded (OpenCode reused session, no new "created" log)
+            // b) OpenCode is sitting at splash (session not found, no new session created)
+            const health = isSessionHealthy(this.agentName);
+            const currentSessionId = getLatestSessionId(this.agentName);
+
+            if (!health.healthy) {
+              // OpenCode died — clear stale session ID to prevent restart loop
+              console.log(`[CONTEXT] Fallback: OpenCode not healthy, injecting text summary.`);
+              savedContext.custom = { ...savedContext.custom, opencodeSessionId: undefined };
+              saveContext(savedContext);
+              injectRestoredContext(this.agentName, savedContext);
+            } else if (currentSessionId === this._attemptedResumeSessionId) {
+              // The session ID we tried to resume is still the latest — resume worked
+              console.log(`[CONTEXT] Resumed OpenCode session ${this._attemptedResumeSessionId}`);
+            } else {
+              // Pane is alive but no matching session ID in logs — OpenCode is at splash
+              console.log(
+                `[CONTEXT] Fallback: session not found in OpenCode. Injecting text summary.`,
+              );
+              savedContext.custom = { ...savedContext.custom, opencodeSessionId: undefined };
+              saveContext(savedContext);
+              injectRestoredContext(this.agentName, savedContext);
+            }
+          } else if (newSessionId === this._attemptedResumeSessionId) {
+            // OpenCode logged the same session ID — resume succeeded
+            console.log(`[CONTEXT] Resumed OpenCode session ${this._attemptedResumeSessionId}`);
+          } else {
+            // OpenCode created a different session — resume failed, fallback to text.
+            // Update saved context with new session ID to prevent restart loop.
+            console.log(
+              `[CONTEXT] Fallback: resume failed (expected ${this._attemptedResumeSessionId}, got ${newSessionId}). Injecting text summary.`,
+            );
+            savedContext.custom = { ...savedContext.custom, opencodeSessionId: newSessionId };
+            saveContext(savedContext);
+            injectRestoredContext(this.agentName, savedContext);
+          }
+        } else {
+          // No session ID saved or non-tmux mode — use text injection
+          console.log(`Restoring context from ${savedContext.savedAt}`);
+          await new Promise((resolve) => setTimeout(resolve, 1000));
+          injectRestoredContext(this.agentName, savedContext);
+        }
       }
     }
 
@@ -491,6 +569,11 @@ ${lastOutput}
 
     fs.appendFileSync(logFile, crashLog);
 
+    // Save context (including session ID) before restart attempt
+    if (this.agentId) {
+      this.saveAgentContext();
+    }
+
     // Check if we can restart
     if (this.restartCount < MAX_RESTART_ATTEMPTS) {
       this.restartCount++;
@@ -557,34 +640,39 @@ ${lastOutput}
       });
     }
 
-    // If we haven't sent a nudge yet, send one
-    if (!this.nudgeSentAt) {
-      console.log(`[HEALTH] Sending nudge to unstick agent...`);
-
-      const nudgeMessage =
-        progress.status === "permission_blocked"
-          ? "Please continue with your task. If you see a permission prompt, try an alternative approach that doesn't require that permission."
-          : "Please continue with your current task.";
-
-      const sent = sendNudge(this.agentName, nudgeMessage);
-      if (sent) {
-        this.nudgeSentAt = now;
-        console.log(`[HEALTH] Nudge sent successfully`);
-      } else {
-        console.log(`[HEALTH] Failed to send nudge`);
+    // Only nudge worker agents - others restart immediately
+    if (this.isWorkerAgent) {
+      // If we haven't sent a nudge yet, send one
+      if (!this.nudgeSentAt) {
+        console.log(`[HEALTH] Sending nudge to worker agent...`);
+
+        const nudgeMessage =
+          progress.status === "permission_blocked"
+            ? "Please continue with your task. If you see a permission prompt, try an alternative approach that doesn't require that permission."
+            : "Please continue with your current task.";
+
+        const sent = sendNudge(this.agentName, nudgeMessage);
+        if (sent) {
+          this.nudgeSentAt = now;
+          console.log(`[HEALTH] Nudge sent successfully`);
+        } else {
+          console.log(`[HEALTH] Failed to send nudge`);
+        }
+        return;
       }
-      return;
-    }
 
-    // Check if enough time has passed since nudge
-    const timeSinceNudge = now.getTime() - this.nudgeSentAt.getTime();
-    if (timeSinceNudge < NUDGE_WAIT_MS) {
-      // Still waiting for agent to respond to nudge
-      return;
+      // Check if enough time has passed since nudge
+      const timeSinceNudge = now.getTime() - this.nudgeSentAt.getTime();
+      if (timeSinceNudge < NUDGE_WAIT_MS) {
+        // Still waiting for agent to respond to nudge
+        return;
+      }
     }
 
-    // Agent still stuck after nudge - trigger restart
-    console.log(`[HEALTH] Agent still stuck after nudge, triggering restart...`);
+    // Agent still stuck - trigger restart (or restart immediately if not a worker)
+    console.log(
+      `[HEALTH] Agent still stuck${this.isWorkerAgent ? " after nudge" : ""}, triggering restart...`,
+    );
     this.stuckSince = null;
     this.nudgeSentAt = null;
 
@@ -638,12 +726,25 @@ ${lastOutput}
         sandboxContainer: containerName,
       });
     } else {
-      // Non-sandbox restart - just recreate tmux session
+      // Non-sandbox restart — load saved session ID for native resume
+      let savedSessionId: string | undefined;
+      let savedContext = null;
+      if (this.agentId) {
+        savedContext = loadContext(this.agentId);
+        savedSessionId = savedContext?.custom?.opencodeSessionId as string | undefined;
+        if (savedSessionId) {
+          console.log(`[RESTART] Attempting to resume OpenCode session: ${savedSessionId}`);
+        }
+      }
+
+      const preRestartSessionId = snapshotSessionId(this.agentName);
+
       const created = createSession(
         this.agentName,
         this.agentConfig.command,
         this.agentConfig.workdir,
         this.runnerConfig.env,
+        savedSessionId,
       );
 
       if (!created) {
@@ -656,6 +757,39 @@ ${lastOutput}
         AGENTMESH_AGENT_ID: this.agentId!,
         ...this.runnerConfig.env,
       });
+
+      // Verify native resume and fallback if needed
+      if (savedSessionId && savedContext) {
+        const newSessionId = await waitForNewSessionId(this.agentName, preRestartSessionId, 15000);
+
+        if (!newSessionId) {
+          const health = isSessionHealthy(this.agentName);
+          const currentSessionId = getLatestSessionId(this.agentName);
+
+          if (!health.healthy) {
+            console.log(`[RESTART] Fallback: OpenCode not healthy, injecting text summary.`);
+            savedContext.custom = { ...savedContext.custom, opencodeSessionId: undefined };
+            saveContext(savedContext);
+            injectRestoredContext(this.agentName, savedContext);
+          } else if (currentSessionId === savedSessionId) {
+            console.log(`[RESTART] Resumed OpenCode session ${savedSessionId}`);
+          } else {
+            console.log(`[RESTART] Fallback: session not found. Injecting text summary.`);
+            savedContext.custom = { ...savedContext.custom, opencodeSessionId: undefined };
+            saveContext(savedContext);
+            injectRestoredContext(this.agentName, savedContext);
+          }
+        } else if (newSessionId === savedSessionId) {
+          console.log(`[RESTART] Resumed OpenCode session ${savedSessionId}`);
+        } else {
+          console.log(
+            `[RESTART] Fallback: resume failed (got ${newSessionId}). Injecting text summary.`,
+          );
+          savedContext.custom = { ...savedContext.custom, opencodeSessionId: newSessionId };
+          saveContext(savedContext);
+          injectRestoredContext(this.agentName, savedContext);
+        }
+      }
     }
 
     // Wait for session to be ready
@@ -792,6 +926,16 @@ ${lastOutput}
     await new Promise((resolve) => setTimeout(resolve, 2000));
 
     console.log(`opencode serve started on http://0.0.0.0:${this.servePort}`);
+
+    // Store saved session ID for integration service reuse
+    if (this.shouldRestoreContext && this.agentId) {
+      const savedContext = loadContext(this.agentId);
+      const savedSessionId = savedContext?.custom?.opencodeSessionId as string | undefined;
+      if (savedSessionId) {
+        console.log(`[SERVE] Saved OpenCode session available for reuse: ${savedSessionId}`);
+        updateAgentInState(this.agentName, { opencodeSessionId: savedSessionId });
+      }
+    }
   }
 
   /**
@@ -961,6 +1105,13 @@ Logs:    docker logs ${containerName}
         };
       }
 
+      // Capture OpenCode session ID for native resume on restart
+      const sessionId = getLatestSessionId(this.agentName);
+      if (sessionId) {
+        context.custom = { ...context.custom, opencodeSessionId: sessionId };
+        console.log(`[CONTEXT] Captured OpenCode session ID: ${sessionId}`);
+      }
+
       // Save updated context
       saveContext(context);
       console.log(`Context saved for agent ${this.agentName}`);

package/src/core/registry.ts

@@ -48,7 +48,7 @@ export async function registerAgent(options: RegisterOptions): Promise<RegisterR
       model: options.model,
       capabilities: options.capabilities || ["coding", "review", "debugging"],
       workspace: options.workspace,
-      restore_context: options.restoreContext ?? true,
+      restore_context: options.restoreContext ?? false,
     }),
   });
 

package/src/core/runner.ts

@@ -122,40 +122,17 @@ export function validateOpenCodeModel(model: string): { valid: boolean; error?:
 
 // Common model aliases to their full OpenCode names
 const MODEL_ALIASES: Record<string, string> = {
-  // Anthropic — Claude
   "claude-sonnet-4": "anthropic/claude-sonnet-4-5",
-  "claude-sonnet-4-0": "anthropic/claude-sonnet-4-0",
   "claude-sonnet-4-5": "anthropic/claude-sonnet-4-5",
-  "claude-sonnet-4-6": "anthropic/claude-sonnet-4-6",
   "claude-opus-4": "anthropic/claude-opus-4-5",
-  "claude-opus-4-0": "anthropic/claude-opus-4-0",
-  "claude-opus-4-1": "anthropic/claude-opus-4-1",
   "claude-opus-4-5": "anthropic/claude-opus-4-5",
-  "claude-opus-4-6": "anthropic/claude-opus-4-6",
   "claude-haiku-4": "anthropic/claude-haiku-4-5",
   "claude-haiku-4-5": "anthropic/claude-haiku-4-5",
-  "claude-3-5-sonnet": "anthropic/claude-3-5-sonnet-20241022",
-  "claude-3-5-haiku": "anthropic/claude-3-5-haiku-latest",
-  "claude-3-7-sonnet": "anthropic/claude-3-7-sonnet-latest",
-
-  // OpenAI — GPT & Codex
-  "gpt-5.2": "openai/gpt-5.2",
-  "gpt-5.3-codex": "openai/gpt-5.3-codex",
-  "gpt-5.2-codex": "openai/gpt-5.2-codex",
-  "gpt-5.1-codex": "openai/gpt-5.1-codex",
-  "gpt-5.1-codex-max": "openai/gpt-5.1-codex-max",
-  "gpt-5.1-codex-mini": "openai/gpt-5.1-codex-mini",
-  "gpt-5-codex": "openai/gpt-5-codex",
-  "codex-mini": "openai/codex-mini-latest",
-  codex: "openai/gpt-5.3-codex",
-
-  // xAI — Grok
-  "grok-4": "xai/grok-4",
-  "grok-4-fast": "xai/grok-4-fast",
-  "grok-3": "xai/grok-3",
-  "grok-3-fast": "xai/grok-3-fast",
-  "grok-3-mini": "xai/grok-3-mini",
-  "grok-code": "xai/grok-code-fast-1",
+  "gpt-4o": "openai/gpt-4o",
+  "gpt-4": "openai/gpt-4",
+  o3: "openai/o3",
+  "o3-mini": "openai/o3-mini",
+  codex: "openai/codex",
 };
 
 /**

package/src/core/sandbox.ts

@@ -225,11 +225,8 @@ export class DockerSandbox {
     // Image and command
     args.push(this.config.image);
 
-    // Command: custom command > serve mode > tail
-    if (this.config.command && this.config.command.length > 0) {
-      // Custom command (e.g., agentmesh start inside container)
-      args.push(...this.config.command);
-    } else if (this.config.serveMode) {
+    // Command: either serve mode or keep container alive for tmux-style attach
+    if (this.config.serveMode) {
       args.push(
         "opencode",
         "serve",

package/src/core/session-id.ts

@@ -0,0 +1,111 @@
+/**
+ * OpenCode Session ID Utilities
+ *
+ * Parses OpenCode log files to extract the active session ID (ses_XXXXX).
+ * Used for native session resumption via `opencode --session <id> --continue`.
+ */
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const SESSION_ID_PATTERN = /service=session\s+id=(ses_[A-Za-z0-9]+)/;
+
+function getLogDir(agentName: string): string {
+  return path.join(os.homedir(), ".agentmesh", "opencode-data", agentName, "opencode", "log");
+}
+
+/**
+ * Gets the latest OpenCode session ID from agent log files.
+ *
+ * Parses log files in ~/.agentmesh/opencode-data/<agentName>/opencode/log/
+ * for the pattern: `service=session id=ses_XXXXX ... created`
+ *
+ * @returns The session ID string (e.g. "ses_365c3ec5bffeAV7qWirhNr1sU9") or null
+ */
+export function getLatestSessionId(agentName: string): string | null {
+  const logDir = getLogDir(agentName);
+
+  if (!fs.existsSync(logDir)) {
+    return null;
+  }
+
+  try {
+    // List log files sorted by name (they're timestamped, so newest last)
+    const logFiles = fs
+      .readdirSync(logDir)
+      .filter((f) => f.endsWith(".log"))
+      .sort();
+
+    if (logFiles.length === 0) {
+      return null;
+    }
+
+    // Search from newest log file backwards
+    for (let i = logFiles.length - 1; i >= 0; i--) {
+      const logPath = path.join(logDir, logFiles[i]);
+      const content = fs.readFileSync(logPath, "utf-8");
+
+      // Find all session creation lines and take the last one
+      const lines = content.split("\n");
+      let lastSessionId: string | null = null;
+
+      for (const line of lines) {
+        if (line.includes("service=session") && line.includes("created")) {
+          const match = line.match(SESSION_ID_PATTERN);
+          if (match) {
+            lastSessionId = match[1];
+          }
+        }
+      }
+
+      if (lastSessionId) {
+        return lastSessionId;
+      }
+    }
+
+    return null;
+  } catch (error) {
+    console.error(`[SESSION-ID] Failed to parse logs for ${agentName}:`, error);
+    return null;
+  }
+}
+
+/**
+ * Waits for OpenCode to write a NEW session ID to logs (different from `previousId`).
+ * Polls log files up to `maxWaitMs` with `intervalMs` between checks.
+ *
+ * This solves the race condition where we read logs before OpenCode has started
+ * and see the old session ID, falsely concluding resume succeeded.
+ *
+ * @returns The new session ID, or null if timeout or no new session appeared
+ */
+export async function waitForNewSessionId(
+  agentName: string,
+  previousId: string | null,
+  maxWaitMs = 15000,
+  intervalMs = 1000,
+): Promise<string | null> {
+  const deadline = Date.now() + maxWaitMs;
+
+  while (Date.now() < deadline) {
+    const currentId = getLatestSessionId(agentName);
+
+    // If we see a different session ID than before, OpenCode has started
+    if (currentId && currentId !== previousId) {
+      return currentId;
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+
+  return null;
+}
+
+/**
+ * Snapshots the latest session ID BEFORE starting OpenCode.
+ * Used to detect whether OpenCode created a new session or resumed the requested one.
+ */
+export function snapshotSessionId(agentName: string): string | null {
+  return getLatestSessionId(agentName);
+}

package/src/core/tmux.ts

@@ -31,6 +31,7 @@ export function createSession(
   command: string,
   workdir?: string,
   env?: SessionEnv,
+  opencodeSessionId?: string,
 ): boolean {
   const sessionName = getSessionName(agentName);
 
@@ -92,6 +93,17 @@ export function createSession(
       }
     }
 
+    // Append --session --continue flags for native session resume
+    if (
+      opencodeSessionId &&
+      (finalCommand === "opencode" || finalCommand.startsWith("opencode ")) &&
+      !finalCommand.includes("--session") &&
+      !finalCommand.includes("--continue")
+    ) {
+      finalCommand = `${finalCommand} --session ${opencodeSessionId} --continue`;
+      console.log(`[TMUX] Resuming OpenCode session: ${opencodeSessionId}`);
+    }
+
     const fullCommand = `${envPrefix}${finalCommand}`;
 
     // Set reasonable terminal size for TUI applications

package/src/core/watchdog.ts

@@ -6,7 +6,6 @@
  */
 
 import { execSync, spawnSync } from "node:child_process";
-import fs from "node:fs";
 import { captureSessionOutput } from "./tmux.js";
 
 export type WatchdogStatus = "active" | "idle" | "stuck" | "permission_blocked";
@@ -139,12 +138,8 @@ export function getLastActivityTime(agentName: string, containerName?: string):
       }
       logLine = result.stdout.trim();
     } else {
-      // Non-sandbox mode: read from agent-isolated log directory
-      // Each agent has its own XDG_DATA_HOME at ~/.agentmesh/opencode-data/<agent>/
-      const agentLogDir = `${process.env.HOME}/.agentmesh/opencode-data/${agentName}/opencode/log`;
-      const sharedLogDir = `${process.env.HOME}/.local/share/opencode/log`;
-      // Prefer agent-specific logs, fall back to shared dir for backwards compatibility
-      const logDir = fs.existsSync(agentLogDir) ? agentLogDir : sharedLogDir;
+      // Non-sandbox mode: read from local logs
+      const logDir = `${process.env.HOME}/.local/share/opencode/log`;
       const result = spawnSync(
         "sh",
         ["-c", `ls -t ${logDir}/*.log 2>/dev/null | head -1 | xargs tail -1 2>/dev/null`],