@openagents-org/agent-launcher 0.2.193 → 0.2.195

package/README.md

@@ -10,6 +10,24 @@ npm install -g @openagents-org/agent-connector
 
 ## CLI Usage
 
+### Shared thread context
+
+Before each triggered agent turn in a workspace thread, the connector reads
+recent messages from all participants, including human-to-human discussion.
+It includes up to 30 chat messages from the latest 100 events before the
+trigger, in chronological order with speaker names. The transcript is bounded
+to 16,000 characters, with long messages shortened to 2,000 characters each.
+Status updates and the triggering message are excluded from the transcript;
+the current request remains separate. Older messages remain available through
+the workspace history tool.
+
+This does not change mention or response-mode rules. Direct messages keep
+their existing conversation handling. If history cannot be fetched within
+five seconds, the connector logs the failure and continues with the request.
+Existing installations need the updated connector and an agent restart.
+
+### Commands
+
 ```bash
 # Browse available agents
 agent-connector search
@@ -32,8 +50,14 @@ agent-connector status
 # View logs
 agent-connector logs
 
-# Connect to a workspace
-agent-connector connect my-agent <token>
+# Connect this device (formerly "node") to a workspace with a pairing code
+# from Workspace → Devices → Connect a device. Pair once; agents created on
+# this device can then join without a token. `agn node ...` still works.
+agent-connector device connect XXXX-XXXX
+agent-connector device status
+
+# Connect an agent to a paired workspace
+agent-connector connect my-agent --workspace <slug>
 
 # Stop
 agent-connector down
@@ -41,6 +65,12 @@ agent-connector down
 
 Run `agent-connector help` for the full command list.
 
+Only the person who connected a device controls it from the workspace
+(remote add/start/stop of its agents); a workspace admin can only unpair it.
+Every request the connector makes for an agent carries `X-Agent-Name`, so the
+workspace applies that agent's permissions rather than treating the call as an
+anonymous machine.
+
 ## Library Usage
 
 ```js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openagents-org/agent-launcher",
-  "version": "0.2.193",
+  "version": "0.2.195",
   "description": "OpenAgents Launcher \u2014 install, configure, and run AI coding agents from your terminal",
   "main": "src/index.js",
   "bin": {

package/registry.json

@@ -329,7 +329,7 @@
     },
     "check_ready": {
       "binary": "agent",
-      "not_ready_message": "Cursor is installed but not signed in — run `cursor-agent login` on the device, or set a CURSOR_API_KEY from cursor.com/settings. Third-party or relay API keys do not work with Cursor.",
+      "not_ready_message": "Cursor is installed but not signed in — run `cursor-agent login` on the device (this is separate from signing in to the Cursor editor), or set a CURSOR_API_KEY from cursor.com/settings. Third-party or relay API keys do not work with Cursor.",
       "env_vars": [
         "CURSOR_API_KEY"
       ],
@@ -337,7 +337,11 @@
       "creds_key": "authInfo",
       "creds_no_parse": true,
       "unverifiable": true,
-      "login_command": "cursor-agent login"
+      "login_command": "cursor-agent login",
+      "status_args": [
+        "status"
+      ],
+      "logged_out_pattern": "not logged in|not signed in|not authenticated|unauthenticated|logged out|signed out|login required|partially authenticated"
     },
     "env_config": [
       {
@@ -1323,9 +1327,11 @@
       "env_vars": [
         "GEMINI_API_KEY"
       ],
+      "credential_target": "gemini:antigravity",
+      "unverifiable": true,
       "saved_env_key": "GEMINI_API_KEY",
       "login_command": "agy",
-      "not_ready_message": "Needs sign-in — run `agy` to sign in with Google, or set GEMINI_API_KEY.",
+      "not_ready_message": "Sign-in not confirmed. Run `agy` in a terminal to sign in with Google, or set GEMINI_API_KEY. On Windows the sign-in is detected once it lands in Credential Manager; elsewhere agy keeps it out of reach, so it is confirmed when you run a task.",
       "auth_detected_labels": {
         "cli_login": "Google account sign-in detected",
         "api_key": "API key detected"

package/src/adapters/antigravity-stream.js

@@ -158,7 +158,21 @@ class AgyRunState {
   }
 }
 
-const AUTH_RE = /authentication (required|failed)|not authenticated|sign[ -]?in|log[ -]?in required|no valid credentials|GEMINI_API_KEY/i;
+// Auth phrasings agy and the Gemini API behind it actually produce. The
+// underscored API status codes are spelled out rather than matched as plain
+// English ("permission denied" alone is just as likely to be a file a tool
+// couldn't read), and an expired/missing token counts as auth because the fix
+// is the same sign-in either way.
+const AUTH_RE =
+  /authentication (required|failed)|not authenticated|unauthenticated|sign[ -]?in|log[ -]?in required|no valid credentials|credentials? (not found|missing|expired|invalid)|(access|auth|refresh|id) token (expired|invalid|missing)|permission_denied|GEMINI_API_KEY/i;
+// agy 1.2.2, verbatim, on an account Antigravity will not serve:
+//   Eligibility check failed: Your current account is not eligible for
+//   Antigravity, because it is not currently available in your location.
+// It is checked BEFORE the auth patterns because it is the one failure a
+// sign-in cannot fix — the account is signed in, which is exactly why telling
+// the user to sign in again is the wrong answer.
+const ELIGIBILITY_RE =
+  /eligibility check failed|not (currently )?available in your (location|country|region)/i;
 const PROVIDER_RE = /modelProvider|model provider/i;
 const MODEL_RE = /unknown model|invalid model/i;
 const TIMEOUT_RE = /print-timeout|timed? ?out/i;
@@ -177,6 +191,17 @@ function classifyAgyFailure({ code, stderr, error } = {}) {
     typeof error === 'string' ? error : [err.type, err.message].filter(Boolean).join(' ');
   const text = [errText, stderr].filter(Boolean).join('\n');
 
+  if (ELIGIBILITY_RE.test(text)) {
+    return {
+      kind: 'eligibility',
+      message:
+        'Antigravity CLI refused the run because this Google account is not ' +
+        'eligible for Antigravity — agy reports it is not available in your ' +
+        'location. Signing in again will not change that. The other path this ' +
+        'agent supports is GEMINI_API_KEY, which runs it against the Gemini API ' +
+        'instead.',
+    };
+  }
   if (AUTH_RE.test(text)) {
     return {
       kind: 'auth',
@@ -206,15 +231,50 @@ function classifyAgyFailure({ code, stderr, error } = {}) {
   if (TIMEOUT_RE.test(text)) {
     return { kind: 'timeout', message: 'Antigravity CLI timed out before producing a response.' };
   }
-  const detail = (errText || (stderr || '').trim().split('\n').pop() || '').slice(0, 200);
+  const detail = errText || stderrTail(stderr);
+  if (!detail) {
+    return {
+      kind: 'unknown',
+      message: `Antigravity CLI exited with code ${code ?? '?'} without a response.`,
+    };
+  }
+  // Unclassified, so the CLI's own words lead — but they are often a bare
+  // "Agent execution terminated due to error.", which tells the user nothing
+  // they can act on. Name the first thing worth checking without claiming to
+  // know it is the cause; agy says nothing more specific when it has no usable
+  // credentials, and that is far and away the most common way a run reaches
+  // here.
   return {
     kind: 'unknown',
-    message: detail
-      ? `Antigravity CLI failed (exit ${code ?? '?'}): ${detail}`
-      : `Antigravity CLI exited with code ${code ?? '?'} without a response.`,
+    message:
+      `Antigravity CLI failed (exit ${code ?? '?'}):\n${detail}\n\n` +
+      'If that does not say why, check the sign-in first — run `agy` once in a ' +
+      'terminal to sign in with Google, or set GEMINI_API_KEY for this agent.',
   };
 }
 
+/**
+ * The tail of a CLI's stderr, as a short quotable block.
+ *
+ * The last line alone used to be it, which threw away the informative half of
+ * every multi-line failure: agy prints its detail above a generic closing line,
+ * so what survived was exactly the part that says nothing. Colour codes are
+ * stripped — agy writes them even into a pipe, and they arrive as mojibake in a
+ * chat message.
+ */
+function stderrTail(stderr, { lines = 3, limit = 600 } = {}) {
+  // eslint-disable-next-line no-control-regex
+  const plain = String(stderr || '').replace(/\u001B\[[0-9;?]*[ -\/]*[@-~]/g, '');
+  const kept = plain
+    .split('\n')
+    .map((l) => l.trimEnd())
+    .filter((l) => l.trim())
+    .slice(-lines)
+    .join('\n')
+    .trim();
+  return kept.length > limit ? kept.slice(-limit) : kept;
+}
+
 /**
  * Filesystem candidates for the agy binary, beyond a PATH lookup. The install
  * script targets ~/.local/bin on macOS/Linux and %LOCALAPPDATA%\agy\bin on

package/src/adapters/base.js

@@ -20,6 +20,8 @@
 const { WorkspaceClient, SessionRevokedError } = require('../workspace-client');
 const { generateSessionTitle, SESSION_DEFAULT_RE } = require('./utils');
 const { defaultAgentWorkdir } = require('../paths');
+const { buildThreadHistory } = require('./thread-history');
+const { publishResponseArtifacts } = require('./response-artifacts');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
@@ -39,6 +41,65 @@ const { FailureStreak, isTransientNetworkError, formatDuration } = require('./fa
 
 const DEFAULT_ENDPOINT = 'https://workspace-endpoint.openagents.org';
 
+// ── Presence detail (v1.1 M3) ──
+// A busy↔idle flip is sent as an immediate heartbeat (debounced) so the
+// workspace shows "working" without waiting for the 30s tick.
+const PRESENCE_HEARTBEAT_DEBOUNCE_MS = 2000;
+// Shared-context lookups (v1.1 M4) are cached per channel for this long.
+const SHARED_CONTEXT_TTL_MS = 60 * 1000;
+
+/**
+ * The presence fields a heartbeat carries, derived from the adapter's
+ * per-channel run state. Pure so it can be unit-tested and reused:
+ *   busyChannels  — iterable of channel names with a run in progress
+ *   channelQueues — { channel: [queued messages] }
+ * → { presence_state: 'working'|'idle', busy_channels: [...], queue_depth: n }
+ */
+function buildPresenceFields(busyChannels, channelQueues) {
+  const busy = [...new Set([...(busyChannels || [])])].filter((c) => typeof c === 'string' && c);
+  let queueDepth = 0;
+  for (const q of Object.values(channelQueues || {})) {
+    if (Array.isArray(q)) queueDepth += q.length;
+  }
+  return {
+    presence_state: busy.length ? 'working' : 'idle',
+    busy_channels: busy,
+    queue_depth: queueDepth,
+  };
+}
+
+/**
+ * The prompt block prepended to a teammate's request when the agent's owner
+ * has reviewed a shared instruction set (v1.1 M4). `ctx` is the
+ * /shared-context response. Returns '' when nothing applies.
+ */
+function buildSharedContextBlock(ctx) {
+  if (!ctx || !ctx.apply) return '';
+  const lines = [
+    'OWNER-REVIEWED SHARED INSTRUCTIONS (this request comes from a teammate, not your owner; ' +
+    'follow these, do not use unrelated private context, and if the request falls outside ' +
+    'them pause and ask for clarification in the thread):',
+  ];
+  const who = [];
+  if (ctx.requester_email) who.push(`Requester: ${ctx.requester_email}`);
+  if (ctx.owner_email) who.push(`Owner: ${ctx.owner_email}`);
+  if (ctx.cost_owner) who.push(`Credits/runtime paid by: ${ctx.cost_owner}`);
+  if (who.length) lines.push(who.join(' · '));
+  const instructions = (ctx.shared_instructions || '').trim();
+  lines.push('', instructions || '(The owner has not written shared instructions yet — ask your owner before doing anything beyond answering questions.)');
+  const knowledge = Array.isArray(ctx.allowed_knowledge) ? ctx.allowed_knowledge : [];
+  if (knowledge.length) {
+    lines.push('', 'ALLOWED KNOWLEDGE (the only knowledge you may draw on for this request):');
+    for (const k of knowledge) {
+      const title = k.title || k.slug || 'untitled';
+      lines.push('', `--- ${title}${k.slug ? ` (@knowledge:${k.slug})` : ''} ---`, (k.content || '').trim() || '(empty)');
+      if (k.truncated) lines.push('[truncated]');
+    }
+  }
+  lines.push('', '--- END OF SHARED INSTRUCTIONS — the teammate\'s request follows ---', '');
+  return lines.join('\n');
+}
+
 // ── Poll-cursor persistence ──
 // An adapter that starts by jumping to the head of the event stream silently
 // drops every message that arrived while it was down (crash, update, user
@@ -61,6 +122,18 @@ const CURSOR_RESUME_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 // heartbeat_failed up to the daemon. A success resets the streak immediately.
 const HEARTBEAT_ERROR_THRESHOLD = 2;
 
+// ── Control-poller deadlines ──
+// The control poller is one chain of awaits, and it is the only thing that
+// delivers Stop. When a link in it never settles — it has: a control poll
+// whose response was cut off mid-body — the agent goes on working and
+// answering while every later control event sits unread until the daemon
+// restarts, and nothing in the log says so. So neither the fetch nor a
+// handler is awaited without a bound. A handler that overruns is not
+// cancelled or re-run; the poller only stops waiting for it.
+const CONTROL_POLL_DEADLINE_MS = 20 * 1000;
+const CONTROL_ACTION_DEADLINE_MS = 60 * 1000;
+const CONTROL_DEADLINE_HIT = Symbol('control deadline hit');
+
 /**
  * Model variables whose name does not follow `<TYPE>_MODEL`. Only the ones an
  * adapter really reads — see `modelLabel`, which tries `<TYPE>_MODEL` first
@@ -129,7 +202,8 @@ class BaseAdapter {
     // Set when the user explicitly stops this adapter (vs an error/revoke), so a
     // clean stop is never mislabeled as an error.
     this._stopRequested = false;
-    this.client = new WorkspaceClient(this.endpoint);
+    // Acts for this one agent: X-Agent-Name on every request (permission model v1.1).
+    this.client = new WorkspaceClient(this.endpoint, { agentName: this.agentName });
     this._lastEventId = null;
     this._cursorFile = this._cursorFilePath();
     this._lastPersistedCursor = null;
@@ -145,6 +219,8 @@ class BaseAdapter {
     this.workspaceModel = null;
     this._lastControlId = null;
     this._controlWake = null;
+    this._CONTROL_POLL_DEADLINE_MS = CONTROL_POLL_DEADLINE_MS;
+    this._CONTROL_ACTION_DEADLINE_MS = CONTROL_ACTION_DEADLINE_MS;
     // Per-channel task tracking for parallel execution
     this._channelBusy = new Set();
     this._channelQueues = {};
@@ -162,6 +238,8 @@ class BaseAdapter {
     // adapter can tell "a stop landed while I was preparing this turn" from
     // "this turn started after the stop and is meant to run".
     this._channelRunGeneration = {};
+    this._channelRequestContent = {};
+    this._channelTriggerId = {};
     // Channels a user stopped whose next turn has not started yet. Everything
     // the send* helpers would post there is dropped: output a killed run was
     // still flushing lands after the stop notice otherwise, and the workspace
@@ -194,6 +272,14 @@ class BaseAdapter {
     // (Claude) fetch directly instead and leave it false.
     this._usesPinnedContext = false;
     this._pinnedContext = {}; // channel → { decisions, glossary }
+    // ── v1.1 M3/M4 ──
+    // Debounce handle for the busy↔idle presence heartbeat.
+    this._presenceHeartbeatTimer = null;
+    // channel → { fetchedAt, requesterEmail, ctx } from /shared-context.
+    this._sharedContext = {};
+    // channel → email of the person whose message is being handled (so the
+    // per-run MCP server can tell the owner who asked).
+    this._requesterEmail = {};
     // Wall-clock timestamp of adapter init, used by the `status` control
     // action to report uptime back to the channel. Reset on reinstantiation
     // (e.g. after a `restart` IPC bounce) so uptime tracks "time since last
@@ -210,6 +296,9 @@ class BaseAdapter {
     // Runs of identical background failures (see failure-streak.js).
     this._pollFailures = new FailureStreak();
     this._heartbeatFailures = new FailureStreak();
+    // The control poller (Stop, mode changes) fails silently otherwise: its
+    // errors are caught so the loop keeps going, and nothing else logs them.
+    this._controlFailures = new FailureStreak();
   }
 
   // ------------------------------------------------------------------
@@ -370,6 +459,7 @@ class BaseAdapter {
       this._running = false;
       this._wakeControlPoller();
       clearInterval(heartbeatInterval);
+      if (this._presenceHeartbeatTimer) { clearTimeout(this._presenceHeartbeatTimer); this._presenceHeartbeatTimer = null; }
       try { await controlPoller; } catch {}
       try {
         await this.client.disconnect(this.workspaceId, this.agentName, this.token);
@@ -461,9 +551,30 @@ class BaseAdapter {
   // Heartbeat
   // ------------------------------------------------------------------
 
+  /** Presence fields for the next heartbeat (see buildPresenceFields). */
+  presenceFields() {
+    return buildPresenceFields(this._channelBusy, this._channelQueues);
+  }
+
+  /**
+   * A channel just went busy or idle (or its queue changed): send a heartbeat
+   * soon so the roster flips promptly instead of on the next 30s tick. Bursts
+   * collapse into one send.
+   */
+  _schedulePresenceHeartbeat() {
+    if (!this._running) return;
+    if (this._presenceHeartbeatTimer) return;
+    this._presenceHeartbeatTimer = setTimeout(() => {
+      this._presenceHeartbeatTimer = null;
+      if (!this._running) return;
+      this._heartbeat().catch(() => {});
+    }, PRESENCE_HEARTBEAT_DEBOUNCE_MS);
+    if (typeof this._presenceHeartbeatTimer.unref === 'function') this._presenceHeartbeatTimer.unref();
+  }
+
   async _heartbeat() {
     try {
-      await this.client.heartbeat(this.workspaceId, this.agentName, this.token, this._sessionId);
+      await this.client.heartbeat(this.workspaceId, this.agentName, this.token, this._sessionId, this.presenceFields());
       this._heartbeatFailStreak = 0;
       const recovered = this._heartbeatFailures.succeed();
       if (recovered) {
@@ -518,10 +629,16 @@ class BaseAdapter {
 
   async _pollControl() {
     try {
-      const events = await this.client.pollControl(
-        this.workspaceId, this.agentName, this.token,
-        { after: this._lastControlId }
+      const events = await this._withinControlDeadline(
+        this.client.pollControl(
+          this.workspaceId, this.agentName, this.token,
+          { after: this._lastControlId }
+        ),
+        this._CONTROL_POLL_DEADLINE_MS, 'control poll',
       );
+      // A poll abandoned at its deadline delivered nothing; the cursor has
+      // not moved, so the next one asks for the same events again.
+      if (events === CONTROL_DEADLINE_HIT) return;
       for (const ev of events) {
         if (ev.id) this._lastControlId = ev.id;
         const payload = ev.payload || {};
@@ -537,12 +654,48 @@ class BaseAdapter {
           // Handled here for every adapter, never by an override: a stop has
           // to stay inside the channel it names, and each adapter used to
           // decide that for itself — several stopped every channel.
-          await this._handleUserStop(payload.channel || null);
+          await this._withinControlDeadline(
+            this._handleUserStop(payload.channel || null),
+            this._CONTROL_ACTION_DEADLINE_MS, `stop for ${payload.channel || 'every channel'}`,
+          );
         } else {
-          await this._onControlAction(action, payload);
+          await this._withinControlDeadline(
+            this._onControlAction(action, payload),
+            this._CONTROL_ACTION_DEADLINE_MS, `control action '${action}'`,
+          );
         }
       }
-    } catch {}
+      const recovered = this._controlFailures.succeed();
+      if (recovered) {
+        this._log(`Control poll recovered after ${recovered.count} unsuccessful attempt(s) over ${formatDuration(recovered.ms)}`);
+      }
+    } catch (e) {
+      // Keep polling, but leave a trace: a control channel that keeps failing
+      // means Stop and mode changes are not reaching this agent.
+      if (this._controlFailures.fail()) {
+        const count = this._controlFailures.count;
+        const streak = count > 1 ? ` (consecutive failures: ${count})` : '';
+        this._log(`Control poll failed: ${e && e.message}${streak}`, isTransientNetworkError(e) ? 'warn' : 'error');
+      }
+    }
+  }
+
+  /**
+   * Await `work` for at most `ms`. Resolves to CONTROL_DEADLINE_HIT when the
+   * deadline wins; `work` is left to finish, or not, on its own.
+   */
+  _withinControlDeadline(work, ms, what) {
+    let timer;
+    const deadline = new Promise((resolve) => {
+      timer = setTimeout(() => {
+        this._log(`Control poller: ${what} still pending after ${Math.round(ms / 1000)}s — polling on without it`, 'warn');
+        resolve(CONTROL_DEADLINE_HIT);
+      }, ms);
+    });
+    return Promise.race([
+      Promise.resolve(work).finally(() => clearTimeout(timer)),
+      deadline,
+    ]);
   }
 
   /**
@@ -1216,6 +1369,7 @@ class BaseAdapter {
       msg._queueId = queueId;
       msg._acceptedGeneration = this._stopGenerationFor(channel);
       this._channelQueues[channel].push(msg);
+      this._schedulePresenceHeartbeat();
       try {
         await this.sendStatus(channel, 'message queued — will process after current task', {
           queued_message: (msg.content || '').slice(0, 200),
@@ -1246,6 +1400,7 @@ class BaseAdapter {
 
   async _channelWorker(channel, msg) {
     this._channelBusy.add(channel);
+    this._schedulePresenceHeartbeat();
     // Messages an adapter queues for itself (Claude's todo nudge) carry no
     // generation; they belong to the turn that queued them.
     const startGeneration = msg._acceptedGeneration !== undefined
@@ -1265,6 +1420,17 @@ class BaseAdapter {
         }
         // Pinned entries may have changed while this message waited.
         await this._prefetchPinnedContext(channel);
+        this._channelRequestContent[channel] = current.originalContent ?? current.content;
+        if (channel && !channel.startsWith('dm:') && current.messageId
+            && typeof this.client?.getRecentMessages === 'function') {
+          await this._applyThreadHistory(channel, current);
+        }
+        // A teammate's request runs under the owner-reviewed shared
+        // instructions (v1.1 M4); the block is prepended to the message.
+        // Gated synchronously so messages it cannot apply to (agents,
+        // anonymous humans, system) add no extra tick before the stop check.
+        this._applyThreadCollaboration(channel, current);
+        if (this._sharedContextCandidate(current)) await this._applySharedContext(channel, current);
         // Checked after the round trips above, which a stop can land inside:
         // a message from before the stop never reaches the CLI.
         if (generation !== this._stopGenerationFor(channel)) {
@@ -1275,6 +1441,7 @@ class BaseAdapter {
           this._mutedChannels.delete(channel);
           this._stopNoticeSent.delete(channel);
           this._stoppingChannels.delete(channel);
+          this._channelTriggerId[channel] = current.messageId || null;
           await this._handleMessage(current);
         }
       } catch (e) {
@@ -1282,6 +1449,8 @@ class BaseAdapter {
         try { await this.sendError(channel, `Agent error: ${e.message}`); } catch {}
       }
       delete this._channelRunGeneration[channel];
+      delete this._channelRequestContent[channel];
+      delete this._channelTriggerId[channel];
       first = false;
 
       const queue = this._channelQueues[channel];
@@ -1289,6 +1458,105 @@ class BaseAdapter {
     }
     if (dropped) this._log(`Stop in ${channel} — dropped ${dropped} message(s) accepted before it`);
     this._channelBusy.delete(channel);
+    delete this._requesterEmail[channel];
+    this._schedulePresenceHeartbeat();
+  }
+
+  // ------------------------------------------------------------------
+  // Shared context for teammates' requests (v1.1 M4)
+  // ------------------------------------------------------------------
+
+  /** The email of the person whose request this channel is running, if known. */
+  requesterEmailFor(channel) {
+    return this._requesterEmail[channel] || null;
+  }
+
+  /**
+   * Fetch (cached 60s per channel + requester) the owner-reviewed shared
+   * context for this run. Returns the /shared-context payload or null.
+   */
+  async _fetchSharedContext(channel, requesterEmail) {
+    const cached = this._sharedContext[channel];
+    const now = Date.now();
+    if (cached && cached.requesterEmail === requesterEmail && (now - cached.fetchedAt) < SHARED_CONTEXT_TTL_MS) {
+      return cached.ctx;
+    }
+    if (!this.client || typeof this.client.getSharedContext !== 'function') return null;
+    try {
+      const ctx = await this.client.getSharedContext(this.workspaceId, this.token, this.agentName, {
+        requesterEmail, channel,
+      });
+      this._sharedContext[channel] = { fetchedAt: now, requesterEmail, ctx };
+      return ctx;
+    } catch (e) {
+      this._log(`Shared-context fetch failed (${e && e.message ? e.message : e}) — running without it`);
+      // Keep a stale-but-recent answer rather than flip-flopping on a blip.
+      return cached && cached.requesterEmail === requesterEmail ? cached.ctx : null;
+    }
+  }
+
+  /**
+   * When the triggering message comes from an identified person, look up the
+   * shared context and, if it applies, prepend the instruction block to the
+   * message the adapter will turn into its prompt. Records the requester for
+   * the per-run MCP server. Never throws.
+   */
+  _sharedContextEmail(msg) {
+    if (!msg) return null;
+    const continuation = msg.senderType === 'agent' && msg.metadata?.orchestration?.action === 'next';
+    if (msg.senderType !== 'human' && !continuation) return null;
+    // Continuations retain the authenticated original requester so the next
+    // agent applies the same owner-reviewed shared context and tool identity.
+    const raw = continuation ? (msg.metadata.requester_email || '')
+      : (msg.senderEmail || (msg.metadata && msg.metadata.sender_email) || '');
+    const email = String(raw).trim().toLowerCase();
+    return email && email.includes('@') ? email : null;
+  }
+
+  _sharedContextCandidate(msg) {
+    return this._sharedContextEmail(msg) !== null;
+  }
+
+  _applyThreadCollaboration(channel, msg) {
+    if (msg._threadCollaborationApplied || !channel || channel.startsWith('dm:')) return;
+    const instructions = msg.metadata?.thread_agent_instructions?.[this.agentName];
+    if (typeof instructions !== 'string' || !instructions.trim()) return;
+    if (msg.originalContent === undefined) msg.originalContent = msg.content;
+    msg.content = `COLLABORATION INSTRUCTIONS FOR THIS THREAD ONLY (do not carry these into other threads; existing owner restrictions still apply):\n${instructions.slice(0, 10000)}\nEND THREAD INSTRUCTIONS\n\n${msg.content || ''}`;
+    msg._threadCollaborationApplied = true;
+  }
+
+  async _applySharedContext(channel, msg) {
+    const email = this._sharedContextEmail(msg);
+    if (!email) return false;
+    this._requesterEmail[channel] = email;
+    if (msg._sharedContextApplied) return true;
+    const ctx = await this._fetchSharedContext(channel, email);
+    const block = buildSharedContextBlock(ctx);
+    if (!block) return false;
+    if (msg.originalContent === undefined) msg.originalContent = msg.content;
+    msg.content = block + '\n' + (msg.content || '');
+    msg._sharedContextApplied = true;
+    this._log(`Shared context applied for ${email} in ${channel} (owner: ${ctx.owner_email || '?'})`);
+    return true;
+  }
+
+  async _applyThreadHistory(channel, msg) {
+    // DMs have separate peer sessions. Synthetic nudges have no event boundary.
+    if (!channel || channel.startsWith('dm:') || !msg.messageId || msg._threadHistoryApplied) return;
+    if (typeof this.client?.getRecentMessages !== 'function') return;
+    try {
+      const messages = await this.client.getRecentMessages(this.workspaceId, channel, this.token, 100, {
+        before: msg.messageId, timeout: 5000, throwOnError: true,
+      });
+      const block = buildThreadHistory(messages, channel, msg);
+      if (!block) return;
+      if (msg.originalContent === undefined) msg.originalContent = msg.content;
+      msg.content = block + (msg.content || '');
+      msg._threadHistoryApplied = true;
+    } catch (e) {
+      this._log(`Recent thread history unavailable for ${channel}: ${e.message}`);
+    }
   }
 
   // ------------------------------------------------------------------
@@ -1492,7 +1760,7 @@ class BaseAdapter {
   async _autoTitleChannel(channel, content) {
     if (this._titledSessions.has(channel)) return;
     this._titledSessions.add(channel);
-    const title = generateSessionTitle(content);
+    const title = generateSessionTitle(this._channelRequestContent[channel] ?? content);
     if (!title) return;
     try {
       const info = await this.client.getSession(this.workspaceId, channel, this.token);
@@ -1555,13 +1823,27 @@ class BaseAdapter {
    * structured field: an earlier attempt matched the word "completed" in the
    * message text and fired on every bash for-loop that ended in `done`.
    */
-  async sendResponse(channel, content) {
+  async sendResponse(channel, content, { statusKind = 'completed' } = {}) {
     if (this._isMuted(channel)) return;
     try {
+      let attachments = [];
+      if (!(this.disabledModules || new Set()).has('files') && channel && !channel.startsWith('dm:') && this.client.uploadFile) {
+        const published = await publishResponseArtifacts({
+          content,
+          workingDir: this.workingDir,
+          upload: (filename, bytes, contentType) => this.client.uploadFile(this.workspaceId, this.token, filename, bytes, {
+            contentType, source: `openagents:${this.agentName}`, channelName: channel, visibility: 'inherit',
+          }),
+          onError: () => this._log('Could not attach a linked document; leaving its original link in the reply.'),
+        });
+        content = published.content;
+        attachments = published.attachments;
+      }
       await this.client.sendMessage(this.workspaceId, channel, this.token, content, {
+        attachments,
         senderType: 'agent',
         senderName: this.agentName,
-        metadata: { status_kind: 'completed' },
+        metadata: { status_kind: statusKind, ...(this._channelTriggerId?.[channel] ? { in_reply_to: this._channelTriggerId[channel] } : {}) },
         sessionId: this._sessionId,
       });
     } catch (e) {
@@ -1701,3 +1983,7 @@ class BaseAdapter {
 module.exports = BaseAdapter;
 module.exports.STALE_MESSAGE_MAX_AGE_MS = STALE_MESSAGE_MAX_AGE_MS;
 module.exports.CURSOR_RESUME_MAX_AGE_MS = CURSOR_RESUME_MAX_AGE_MS;
+module.exports.PRESENCE_HEARTBEAT_DEBOUNCE_MS = PRESENCE_HEARTBEAT_DEBOUNCE_MS;
+module.exports.SHARED_CONTEXT_TTL_MS = SHARED_CONTEXT_TTL_MS;
+module.exports.buildPresenceFields = buildPresenceFields;
+module.exports.buildSharedContextBlock = buildSharedContextBlock;