@openagents-org/agent-launcher 0.2.151 → 0.2.153

package/src/adapters/codex.js

@@ -324,12 +324,15 @@ class CodexAdapter extends BaseAdapter {
           this._saveSessions();
           continue;
         } else {
-          await this.sendResponse(msgChannel, 'No response generated. Please try again.');
+          // Surface the actual reason (turn.failed message, stderr, exit code)
+          // instead of a generic "no response" — mirrors the OpenCode adapter
+          // so auth/model/network problems are actionable from the chat.
+          await this._sendRunFailure(msgChannel, result);
           return;
         }
       } catch (e) {
         this._log(`Error in subprocess: ${e.message}`);
-        await this.sendError(msgChannel, `Error: ${e.message}`);
+        await this.sendError(msgChannel, `⚠️ **Codex couldn't run** — ${CodexAdapter._redact(e.message)}`);
         return;
       }
     }
@@ -351,6 +354,7 @@ class CodexAdapter extends BaseAdapter {
       let hasToolUseSinceLastText = false;
       let lineBuffer = '';
       let stderrBuf = '';
+      let lastErrorMessage = '';
       let _pendingLines = Promise.resolve();
 
       if (proc.stderr) {
@@ -407,7 +411,12 @@ class CodexAdapter extends BaseAdapter {
         } else if (eventType === 'turn.failed') {
           const error = event.error || {};
           const errMsg = error.message || JSON.stringify(error);
+          lastErrorMessage = errMsg;
           this._log(`Turn failed: ${errMsg}`);
+        } else if (eventType === 'error') {
+          const errMsg = event.message || JSON.stringify(event);
+          lastErrorMessage = errMsg;
+          this._log(`Error event: ${errMsg}`);
         }
       };
 
@@ -442,6 +451,7 @@ class CodexAdapter extends BaseAdapter {
           responseText: responseTexts.join('\n').trim(),
           exitCode: code,
           stderr: stderrBuf,
+          errorMessage: lastErrorMessage,
         });
       });
 
@@ -452,6 +462,50 @@ class CodexAdapter extends BaseAdapter {
     });
   }
 
+  // ------------------------------------------------------------------
+  // Failure reporting
+  // ------------------------------------------------------------------
+
+  /**
+   * Post a user-visible failure carrying the actual reason a run produced no
+   * reply, instead of a generic "No response generated".
+   */
+  async _sendRunFailure(msgChannel, result) {
+    const detail = CodexAdapter._failureDetail(result);
+    const body = detail
+      ? `Codex failed to complete this run.\n\n> ${detail}`
+      : 'Codex finished without producing a reply. Please try again.';
+    await this.sendError(msgChannel, `⚠️ **Codex couldn't run** — ${body}`);
+  }
+
+  /**
+   * Pick the most informative failure detail from a run result:
+   * turn.failed / error event message → stderr tail → exit code. Redacted.
+   */
+  static _failureDetail({ errorMessage, stderr, exitCode } = {}) {
+    const stderrTail = String(stderr || '').trim().split('\n').slice(-5).join('\n').trim();
+    const raw = String(errorMessage || '').trim()
+      || stderrTail
+      || (exitCode ? `codex exited with code ${exitCode}` : '');
+    return CodexAdapter._redact(raw).slice(0, 500).trim();
+  }
+
+  /** Redact secrets (keys, tokens, bearer/authorization, query secrets) from diagnostics. */
+  static _redact(s) {
+    let out = String(s == null ? '' : s);
+    out = out
+      .replace(/\bsk-[A-Za-z0-9_-]{6,}/g, 'sk-[REDACTED]')
+      .replace(/\b(?:github_pat|gh[pousr])_[A-Za-z0-9_]{10,}/g, '[REDACTED_TOKEN]')
+      .replace(/\bxox[baprs]-[A-Za-z0-9-]{8,}/g, '[REDACTED_TOKEN]')
+      .replace(/\bAKIA[0-9A-Z]{12,}/g, '[REDACTED_KEY]')
+      .replace(/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}/g, '[REDACTED_JWT]')
+      .replace(/(authorization|api[_-]?key|x-api-key|token|bearer|secret|password|passwd)(["'\s:=]+)([^\s"',}]+)/gi,
+        (m, k, sep) => `${k}${sep}[REDACTED]`)
+      .replace(/([?&](?:api[_-]?key|key|token|access_token)=)[^&\s"']+/gi, '$1[REDACTED]')
+      .replace(/\b[A-Za-z0-9_-]{40,}\b/g, '[REDACTED]');
+    return out;
+  }
+
   // ------------------------------------------------------------------
   // Direct HTTP mode (fallback when CLI not available)
   // ------------------------------------------------------------------
@@ -467,11 +521,11 @@ class CodexAdapter extends BaseAdapter {
         }
         await this.sendResponse(msgChannel, responseText);
       } else {
-        await this.sendResponse(msgChannel, 'No response generated. Please try again.');
+        await this._sendRunFailure(msgChannel, {});
       }
     } catch (e) {
       this._log(`Error in direct API: ${e.message}`);
-      await this.sendError(msgChannel, `Error: ${e.message}`);
+      await this.sendError(msgChannel, `⚠️ **Codex couldn't run** — ${CodexAdapter._redact(e.message)}`);
     }
   }
 

package/src/adapters/cursor.js

@@ -16,7 +16,7 @@ const { execSync, spawn } = require('child_process');
 
 const BaseAdapter = require('./base');
 const { formatAttachmentsForPrompt, SESSION_DEFAULT_RE, generateSessionTitle } = require('./utils');
-const { buildCursorSkillMd } = require('./workspace-prompt');
+const { buildCursorSkillMd, workspaceSkillName } = require('./workspace-prompt');
 const { defaultAgentWorkdir, whichBinary, whereBinary } = require('../paths');
 
 const IS_WINDOWS = process.platform === 'win32';
@@ -308,7 +308,12 @@ class CursorAdapter extends BaseAdapter {
     const workDir = this.workingDir || defaultAgentWorkdir(this.agentName);
     const skillDir = path.join(workDir, '.cursor', 'skills');
     fs.mkdirSync(skillDir, { recursive: true });
-    const skillFile = path.join(skillDir, 'openagents-workspace.md');
+    // Per-agent filename: agents sharing a working directory used to clobber
+    // one shared openagents-workspace.md, so uploads carried the identity of
+    // whichever agent wrote the file last. Drop that legacy file so a stale
+    // copy (with another agent's embedded identity) can never be read again.
+    const skillFile = path.join(skillDir, `${workspaceSkillName(this.agentName)}.md`);
+    try { fs.unlinkSync(path.join(skillDir, 'openagents-workspace.md')); } catch {}
 
     const skillContent = buildCursorSkillMd({
       endpoint: this.endpoint,
@@ -330,7 +335,20 @@ class CursorAdapter extends BaseAdapter {
       throw new Error('Cursor CLI not found. Install with: curl https://cursor.com/install -fsSL | bash');
     }
 
-    const cmd = [agentBin, '-p', prompt, '--output-format', 'stream-json', '--trust', '--force'];
+    // Cursor has no system-prompt flag, so the CLI would otherwise learn its
+    // identity ONLY from whichever workspace skill it happens to open. With a
+    // shared working directory several agents' skills coexist (same
+    // description, different embedded identity), so every spawn must pin who
+    // this agent is and exactly which skill file is its interface — otherwise
+    // it can read a sibling's skill and upload under that agent's name.
+    const identityHeader =
+      `[workspace] You are agent '${this.agentName}'. For ANY workspace ` +
+      `operation (messages, files, agents, browser) read and follow ONLY the ` +
+      `'${workspaceSkillName(this.agentName)}' skill. Other ` +
+      `openagents-workspace-* skills belong to OTHER agents and carry the ` +
+      `wrong identity — never use them.\n\n`;
+
+    const cmd = [agentBin, '-p', identityHeader + prompt, '--output-format', 'stream-json', '--trust', '--force'];
 
     // Model selection
     const model = (this.agentEnv || process.env).CURSOR_MODEL;

package/src/adapters/decision-log.js

@@ -0,0 +1,181 @@
+/**
+ * Pure helpers for the Claude adapter's decision log ("constraint pinning").
+ *
+ * The decision log is a per-channel knowledge entry that records every
+ * decision the user has confirmed. The adapter re-reads it on every message
+ * and injects it into the CLI system prompt — the only position that survives
+ * both the CLI's auto-compaction and a session reset. Everything here is
+ * side-effect free so it can be unit tested without an adapter instance.
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+
+/** Max characters a single recap line may occupy before being cut. */
+const RECAP_LINE_MAX_CHARS = 2000;
+
+/** Default budget for the pinned-decisions block inside the system prompt. */
+const PINNED_DECISIONS_MAX_CHARS = 4000;
+
+/**
+ * Canonical knowledge-entry title for a channel's decision log. The slug the
+ * backend derives from it is NOT stable (collisions get a numeric suffix), so
+ * lookups must match on this exact title, never on the slug.
+ */
+function decisionLogTitle(channelName) {
+  return `Decisions for channel ${channelName}`;
+}
+
+/**
+ * Stable hash of the decision log content. null/undefined and '' hash
+ * identically so "no entry yet" never reads as a change.
+ */
+function hashDecisions(content) {
+  return crypto.createHash('sha256').update(String(content || '').trim(), 'utf-8').digest('hex');
+}
+
+/**
+ * Fingerprint of everything the system prompt pins from the decision log —
+ * the entry id AND the content — used to detect that a persistent CLI
+ * process was spawned with an outdated prompt. Content alone is not enough:
+ * a deleted-and-recreated log can carry identical content under a new id,
+ * and a prompt still holding the old id would send updates to a dead entry.
+ */
+function decisionFingerprint(entryId, content) {
+  return crypto.createHash('sha256')
+    .update(`${entryId || ''}\u0000${String(content || '').trim()}`, 'utf-8')
+    .digest('hex');
+}
+
+/**
+ * Pick the channel's decision entry from a knowledge listing: exact-title
+ * matches only, earliest created_at wins (concurrent creates produce
+ * duplicates — the earliest is the one other turns have been updating).
+ * Returns { entry, duplicates } where duplicates counts the extra matches.
+ */
+function pickDecisionEntry(entries, channelName) {
+  const title = decisionLogTitle(channelName);
+  const matches = (entries || []).filter((e) => e && e.title === title);
+  if (matches.length === 0) return { entry: null, duplicates: 0 };
+  const sorted = matches.slice().sort((a, b) => {
+    // ISO-8601 strings compare chronologically as strings; entries without a
+    // timestamp are anomalous and sort last so a dated original wins.
+    const ka = a.created_at || '\uffff';
+    const kb = b.created_at || '\uffff';
+    return ka < kb ? -1 : ka > kb ? 1 : 0;
+  });
+  return { entry: sorted[0], duplicates: matches.length - 1 };
+}
+
+/**
+ * Fit the decision log into a character budget without ever cutting a line
+ * in half. Over budget, whole lines are kept from the head (earliest
+ * decisions) and the tail (latest decisions) with the middle dropped, so
+ * neither end of the log silently disappears.
+ * Returns { text, truncated, omitted }.
+ */
+function renderPinnedDecisions(content, { maxChars = PINNED_DECISIONS_MAX_CHARS } = {}) {
+  const text = String(content || '').trim();
+  if (!text) return { text: '', truncated: false, omitted: 0 };
+  if (text.length <= maxChars) return { text, truncated: false, omitted: 0 };
+
+  const lines = text.split('\n');
+  // Reserve room for the omission marker inserted between head and tail.
+  const budget = Math.max(maxChars - 80, 0);
+  const headBudget = Math.floor(budget / 2);
+
+  const head = [];
+  let used = 0;
+  let i = 0;
+  for (; i < lines.length; i++) {
+    const cost = lines[i].length + 1;
+    if (used + cost > headBudget) break;
+    head.push(lines[i]);
+    used += cost;
+  }
+
+  const tail = [];
+  let j = lines.length - 1;
+  for (; j >= i; j--) {
+    const cost = lines[j].length + 1;
+    if (used + cost > budget) break;
+    tail.unshift(lines[j]);
+    used += cost;
+  }
+
+  const omitted = lines.length - head.length - tail.length;
+  if (omitted <= 0) {
+    // Everything fit after all (short middle) — no marker needed.
+    return { text: [...head, ...tail].join('\n'), truncated: false, omitted: 0 };
+  }
+  const marker = `[… ${omitted} middle line(s) omitted — read the decision log entry for the full list …]`;
+  return {
+    text: [...head, marker, ...tail].join('\n'),
+    truncated: true,
+    omitted,
+  };
+}
+
+/** A message qualifies for the recap when it is real chat with content. */
+function isRecapEligible(msg, currentMessage) {
+  if (!msg) return false;
+  const mt = msg.messageType || 'chat';
+  if (mt === 'status' || mt === 'thinking' || mt === 'loading') return false;
+  const text = (msg.content || '').trim();
+  if (!text) return false;
+  if (text === currentMessage) return false;
+  return true;
+}
+
+function formatRecapLine(msg) {
+  const text = (msg.content || '').trim();
+  const who = msg.senderType === 'human'
+    ? (msg.senderName || 'user')
+    : (msg.senderName || 'agent');
+  const cut = text.length > RECAP_LINE_MAX_CHARS
+    ? text.slice(0, RECAP_LINE_MAX_CHARS) + '…'
+    : text;
+  return `[${who}] ${cut}`;
+}
+
+/**
+ * Build recap lines from the channel's opening messages (fetched ascending)
+ * and its most recent ones (fetched descending, already reversed to
+ * chronological). Head keeps the original requirement, tail keeps the live
+ * discussion; overlap is removed by event ID. An omission marker is inserted
+ * only when the two windows do not overlap, i.e. messages in between were
+ * actually dropped.
+ */
+function sampleRecap(headMsgs, tailMsgs, currentMessage, { headKeep = 5, tailKeep = 15 } = {}) {
+  const head = (headMsgs || [])
+    .filter((m) => isRecapEligible(m, currentMessage))
+    .slice(0, headKeep);
+  const tail = (tailMsgs || [])
+    .filter((m) => isRecapEligible(m, currentMessage))
+    .slice(-tailKeep);
+
+  const headIds = new Set(head.map((m) => m.messageId).filter(Boolean));
+  const tailDeduped = tail.filter((m) => !m.messageId || !headIds.has(m.messageId));
+  const windowsOverlap = tailDeduped.length < tail.length;
+
+  const lines = head.map(formatRecapLine);
+  if (head.length > 0 && tailDeduped.length > 0 && !windowsOverlap) {
+    lines.push('[… earlier messages omitted …]');
+  }
+  lines.push(...tailDeduped.map(formatRecapLine));
+  return lines;
+}
+
+module.exports = {
+  PINNED_DECISIONS_MAX_CHARS,
+  RECAP_LINE_MAX_CHARS,
+  decisionLogTitle,
+  hashDecisions,
+  decisionFingerprint,
+  pickDecisionEntry,
+  renderPinnedDecisions,
+  isRecapEligible,
+  formatRecapLine,
+  sampleRecap,
+};

package/src/adapters/openclaw.js

@@ -18,7 +18,7 @@ const { spawn, execSync } = require('child_process');
 
 const BaseAdapter = require('./base');
 const { formatAttachmentsForPrompt } = require('./utils');
-const { buildOpenclawSkillMd, buildOpenclawSystemPrompt } = require('./workspace-prompt');
+const { buildOpenclawSkillMd, buildOpenclawSystemPrompt, workspaceSkillName } = require('./workspace-prompt');
 const { getRuntimePrefix } = require('../paths');
 
 const IS_WINDOWS = process.platform === 'win32';
@@ -151,7 +151,44 @@ class OpenClawAdapter extends BaseAdapter {
       return;
     }
 
-    const skillName = `openagents-workspace-${this.agentName}`;
+    const skillName = workspaceSkillName(this.agentName);
+    // Migration — pre-normalization versions installed the skill under the
+    // RAW agent name. For names the normalizer rewrites (uppercase,
+    // underscores, …) that leaves a stale directory with an outdated
+    // channel/token/endpoint that OpenClaw would keep auto-loading alongside
+    // the new one (`always: true` metadata). Remove the exact legacy dir when
+    // its name differs from the current one; for already-valid names the two
+    // coincide and nothing is deleted.
+    // The raw name feeds a recursive delete, so it must be provably inert
+    // first — agent names are not validated at creation, and a name carrying
+    // path separators or `..` would otherwise let the join escape the skills
+    // root (rmSync then destroys whatever it lands on). Only names the safe
+    // charset allows are considered, and the resolved target must still be a
+    // DIRECT child of the skills root. Legacy dirs from weirder names are
+    // left in place — stale beats deleting an unproven path.
+    const skillsRoot = path.join(wsDir, 'skills');
+    const legacyName = `openagents-workspace-${this.agentName}`;
+    const legacyDir = path.join(skillsRoot, legacyName);
+    if (
+      legacyName !== skillName &&
+      /^[A-Za-z0-9._-]+$/.test(String(this.agentName)) &&
+      path.dirname(path.resolve(legacyDir)) === path.resolve(skillsRoot)
+    ) {
+      // Ownership proof — the path checks above cannot see filesystem
+      // aliasing (case-insensitive lookup on Windows/macOS, trailing-dot
+      // stripping on Windows): agent Foo's legacy path can be the SAME
+      // directory as agent foo's CURRENT skill. The stored SKILL.md embeds
+      // its owner's identity in a quote-delimited phrase, so delete only
+      // when that identity is exactly this agent; otherwise leave the dir.
+      let owned = false;
+      try {
+        const stored = fs.readFileSync(path.join(legacyDir, 'SKILL.md'), 'utf-8');
+        owned = stored.includes(`agent '${this.agentName}'`);
+      } catch {}
+      if (owned) {
+        try { fs.rmSync(legacyDir, { recursive: true, force: true }); } catch {}
+      }
+    }
     const skillDir = path.join(wsDir, 'skills', skillName);
     fs.mkdirSync(skillDir, { recursive: true });
 

package/src/adapters/opencode.js

@@ -13,11 +13,12 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const crypto = require('crypto');
 const { execSync, spawn } = require('child_process');
 
 const BaseAdapter = require('./base');
 const { formatAttachmentsForPrompt } = require('./utils');
-const { buildOpenCodeSkillMd, buildOpenCodeSystemPrompt } = require('./workspace-prompt');
+const { buildOpenCodeSkillMd, buildOpenCodeSystemPrompt, workspaceSkillName } = require('./workspace-prompt');
 const { whichBinary, whereBinary, getEnhancedEnv } = require('../paths');
 
 const IS_WINDOWS = process.platform === 'win32';
@@ -64,7 +65,7 @@ const FAILURE_MESSAGES = {
   stream_parse_error: 'OpenCode produced output this version could not parse. Update to a supported OpenCode version, or open diagnostics.',
   empty_response: 'OpenCode finished without producing a final reply. Retry; if it persists, open diagnostics.',
   process_crashed: 'OpenCode exited unexpectedly. Open diagnostics or retry.',
-  cwd_unavailable: "OpenCode's working directory is not accessible. Check the agent home directory's permissions.",
+  cwd_unavailable: "OpenCode's working directory is not accessible. Check the agent's configured path (or agent home) permissions.",
   unknown_error: 'OpenCode failed for an undetermined reason. Open diagnostics or retry.',
 };
 
@@ -78,12 +79,15 @@ class OpenCodeAdapter extends BaseAdapter {
     super(opts);
     this.disabledModules = opts.disabledModules || new Set();
 
-    // Agent home directory: ~/.openagents/agents/{agentName}/
+    // Agent home directory: ~/.openagents/agents/{agentName}/ — scratch storage
+    // for sessions, skills, and opencode config. This is NOT the directory
+    // opencode runs in; opencode runs in the configured workingDir (see
+    // _resolveCwd) so it can actually reach the project's files. (issue #435)
     this.agentHome = path.join(os.homedir(), '.openagents', 'agents', this.agentName);
     fs.mkdirSync(this.agentHome, { recursive: true });
 
     this._channelSessions = {};
-    this._sessionsFile = path.join(this.agentHome, 'sessions.json');
+    this._sessionsFile = this._sessionsFileFor();
     this._migrateSessionsFile();
     this._loadSessions();
 
@@ -103,6 +107,11 @@ class OpenCodeAdapter extends BaseAdapter {
    * Migrate sessions file from old location to agent home.
    */
   _migrateSessionsFile() {
+    // Only the legacy sessions.json (no workingDir → opencode still runs in
+    // agentHome) inherits sessions from the pre-agentHome location. A scoped
+    // file belongs to a different --dir, so seeding it with IDs created under
+    // agentHome would make every later resume 404.
+    if (path.basename(this._sessionsFile) !== 'sessions.json') return;
     const oldPath = path.join(
       os.homedir(), '.openagents', 'sessions',
       `${this.workspaceId}_${this.agentName}_opencode.json`
@@ -137,6 +146,38 @@ class OpenCodeAdapter extends BaseAdapter {
     } catch {}
   }
 
+  /**
+   * Effective working directory for `opencode run --dir` and the spawn cwd.
+   *
+   * opencode confines an agent's file access to its --dir worktree root; in
+   * headless mode a tool call that reaches outside it is auto-rejected with
+   * "user rejected permission". So opencode must run in the agent's configured
+   * project path (workingDir), not the per-agent scratch dir (agentHome). With
+   * no path configured, fall back to agentHome so pre-existing agents keep
+   * running where they always did. (issue #435)
+   */
+  _resolveCwd() {
+    return this.workingDir || this.agentHome;
+  }
+
+  /**
+   * Persisted-session-store path, scoped per working directory.
+   *
+   * An opencode session ID is only resumable against the --dir it was created
+   * under. If an agent's workingDir changes (or an agent that previously ran in
+   * agentHome gets a path configured), resuming a stored ID under the new --dir
+   * 404s with a confusing error. Scope the store by working dir so each project
+   * keeps its own IDs; the default (no workingDir) keeps the legacy
+   * sessions.json so existing agents retain their context. Files always live
+   * under agentHome — never inside the project tree. Mirrors the sha256[:16]
+   * per-cwd idiom used by the goose and nanoclaw adapters.
+   */
+  _sessionsFileFor() {
+    if (!this.workingDir) return path.join(this.agentHome, 'sessions.json');
+    const slug = crypto.createHash('sha256').update(this.workingDir).digest('hex').slice(0, 16);
+    return path.join(this.agentHome, `sessions-${slug}.json`);
+  }
+
   async _onControlAction(action, payload) {
     if (action === 'stop') {
       const channel = (payload && typeof payload === 'object') ? payload.channel : null;
@@ -168,7 +209,12 @@ class OpenCodeAdapter extends BaseAdapter {
    */
   _ensureWorkspaceSkill(channelName) {
     const skillDir = path.join(this.agentHome, '.opencode', 'skills');
-    const skillFile = path.join(skillDir, 'openagents-workspace.md');
+    // Filename matches the per-agent frontmatter name; remove the legacy
+    // shared-name file so a stale duplicate skill is never auto-discovered.
+    const skillFile = path.join(skillDir, `${workspaceSkillName(this.agentName)}.md`);
+    try {
+      fs.unlinkSync(path.join(skillDir, 'openagents-workspace.md'));
+    } catch {}
     try {
       const content = buildOpenCodeSkillMd({
         endpoint: this.endpoint,
@@ -642,7 +688,8 @@ class OpenCodeAdapter extends BaseAdapter {
     }
 
     const binary = this._opencodeBinary;
-    const cmd = [binary, 'run', '--format', 'json', '--dir', this.agentHome];
+    const runCwd = this._resolveCwd();
+    const cmd = [binary, 'run', '--format', 'json', '--dir', runCwd];
 
     // Preflight guarantees a resolvable model; pin it explicitly — without it
     // opencode hangs waiting for interactive provider/model selection.
@@ -660,7 +707,7 @@ class OpenCodeAdapter extends BaseAdapter {
       fullPrompt = `${context}\n\n---\n\n${content}`;
     }
 
-    this._log(`CLI: ${binary} run --format json --dir … --model ${model || '(none)'}`);
+    this._log(`CLI: ${binary} run --format json --dir ${runCwd} --model ${model || '(none)'}`);
 
     const spawnEnv = { ...(this.agentEnv || process.env) };
 
@@ -677,7 +724,7 @@ class OpenCodeAdapter extends BaseAdapter {
       const proc = spawn(spawnBinary, spawnArgs, {
         stdio: ['pipe', 'pipe', 'pipe'],
         env: spawnEnv,
-        cwd: this.agentHome,
+        cwd: runCwd,
         timeout: TIMEOUT_MS,
         detached: !IS_WINDOWS,
         // Never let a console window appear. Besides being ugly, an attached
@@ -825,10 +872,11 @@ class OpenCodeAdapter extends BaseAdapter {
     const cred = this._credentialState();
     if (cred === 'missing') return { ok: false, category: 'credential_missing' };
 
+    const runCwd = this._resolveCwd();
     try {
-      fs.accessSync(this.agentHome, fs.constants.R_OK | fs.constants.W_OK);
+      fs.accessSync(runCwd, fs.constants.R_OK | fs.constants.W_OK);
     } catch {
-      return { ok: false, category: 'cwd_unavailable', diagnostic: `cannot access ${this.agentHome}` };
+      return { ok: false, category: 'cwd_unavailable', diagnostic: `cannot access ${runCwd}` };
     }
 
     return { ok: true, version: probe.version, versionClass: vclass, model, credential: cred };