zooid 0.14.0 → 0.15.0

package/dist/{chunk-R5S26T7B.js → chunk-35IKQPC5.js}

@@ -24368,14 +24368,13 @@ var AcpClient = class {
     );
     const persisted = this.store?.get(threadId);
     if (persisted && this.agentCapabilities.loadSession) {
+      let loaded;
       try {
-        await this.connection.loadSession({
+        loaded = await this.connection.loadSession({
           sessionId: persisted,
           cwd: pathResolve(this.options.agent.cwd ?? process.cwd()),
           mcpServers
         });
-        this.sessions.set(key, { sessionId: persisted, startedAt: Date.now() });
-        return persisted;
       } catch (err) {
         console.warn(
           `[acp-client:${this.options.agent.id}] loadSession(${persisted}) failed; falling back to newSession:`,
@@ -24383,15 +24382,43 @@ var AcpClient = class {
         );
         await this.store?.delete(threadId);
       }
+      if (loaded) {
+        await this.applyMode(persisted, loaded.modes);
+        this.sessions.set(key, { sessionId: persisted, startedAt: Date.now() });
+        return persisted;
+      }
     }
-    const { sessionId } = await this.connection.newSession({
+    const { sessionId, modes } = await this.connection.newSession({
       cwd: pathResolve(this.options.agent.cwd ?? process.cwd()),
       mcpServers
     });
+    await this.applyMode(sessionId, modes);
     this.sessions.set(key, { sessionId, startedAt: Date.now() });
     await this.store?.set(threadId, sessionId);
     return sessionId;
   }
+  /**
+   * Put a freshly created or loaded session into the agent's configured mode.
+   * Mode ids are adapter-defined, so an id the adapter doesn't list is a
+   * config error: fail the session rather than run it in a mode nobody chose.
+   */
+  async applyMode(sessionId, modes) {
+    const wanted = this.options.agent.mode;
+    if (!wanted || !this.connection) return;
+    if (!modes) {
+      throw new Error(
+        `agents.${this.options.agent.id}.acp.mode "${wanted}": this agent does not offer session modes`
+      );
+    }
+    if (!modes.availableModes.some((m) => m.id === wanted)) {
+      const offered = modes.availableModes.map((m) => m.id).join(", ");
+      throw new Error(
+        `agents.${this.options.agent.id}.acp.mode "${wanted}": not offered by this agent (offers: ${offered})`
+      );
+    }
+    if (modes.currentModeId === wanted) return;
+    await this.connection.setSessionMode({ sessionId, modeId: wanted });
+  }
   async ensureStoreLoaded() {
     if (!this.store) {
       if (!this.options.agentDataDir) {
@@ -43471,6 +43498,13 @@ function parseAcpBlock(name, raw) {
       `agents.${name}.acp: must specify either preset or command`
     );
   }
+  let mode;
+  if (a.mode !== void 0) {
+    if (typeof a.mode !== "string" || a.mode.trim().length === 0) {
+      throw new Error(`agents.${name}.acp.mode: must be a non-empty string`);
+    }
+    mode = a.mode.trim();
+  }
   if (hasPreset) {
     if (typeof a.preset !== "string" || a.preset.length === 0) {
       throw new Error(`agents.${name}.acp.preset: must be a non-empty string`);
@@ -43487,6 +43521,7 @@ function parseAcpBlock(name, raw) {
       }
       out.model = a.model.trim();
     }
+    if (mode !== void 0) out.mode = mode;
     return out;
   }
   if (typeof a.command !== "string" || a.command.length === 0) {
@@ -43504,7 +43539,7 @@ function parseAcpBlock(name, raw) {
       args.push(v);
     }
   }
-  return { command: a.command, args };
+  return mode === void 0 ? { command: a.command, args } : { command: a.command, args, mode };
 }
 function parseApprovalTimeout(name, raw) {
   if (raw === void 0) return 0;
@@ -44188,8 +44223,17 @@ function parseTriggers(raw, agents, transports, validateCron, processEnv, config
       }
       rawMessages = t.messages;
     }
+    let ttlMs;
+    if (t.expires_after !== void 0) {
+      if (typeof t.expires_after !== "string" || t.expires_after.length === 0) {
+        throw new Error(`triggers.${name}.expires_after: must be a non-empty duration string`);
+      }
+      ttlMs = parseDurationMs(`triggers.${name}.expires_after`, t.expires_after);
+    } else {
+      ttlMs = webhook ? void 0 : 6 * 36e5;
+    }
     const messages = rawMessages.map(
-      (m, i) => parseTriggerMessage(name, i, m, agents, as, !!webhook)
+      (m, i) => parseTriggerMessage(name, i, m, agents, transports, as, !!webhook, ttlMs)
     );
     const entry = { as, messages };
     if (schedule !== void 0) entry.schedule = schedule;
@@ -44198,7 +44242,34 @@ function parseTriggers(raw, agents, transports, validateCron, processEnv, config
   }
   return result;
 }
-function parseTriggerMessage(name, index, raw, agents, as, hasWebhook) {
+function parseDurationMs(label, raw) {
+  const m = /^(\d+)(s|m|h)$/.exec(raw);
+  if (!m) {
+    throw new Error(`${label}: "${raw}" is not a valid duration (use "<n>s", "<n>m", or "<n>h")`);
+  }
+  const n = Number(m[1]);
+  switch (m[2]) {
+    case "s":
+      return n * 1e3;
+    case "m":
+      return n * 6e4;
+    case "h":
+      return n * 60 * 6e4;
+  }
+  throw new Error("unreachable");
+}
+function soleMatrixTransport(transports) {
+  const matrixTransports = Object.values(transports).filter(
+    (t) => t.type === "matrix"
+  );
+  if (matrixTransports.length !== 1) {
+    throw new Error(
+      `triggers: a full-MXID mention requires exactly one matrix transport to validate its homeserver against (found ${matrixTransports.length})`
+    );
+  }
+  return matrixTransports[0];
+}
+function parseTriggerMessage(name, index, raw, agents, transports, as, hasWebhook, ttlMs) {
   const label = `triggers.${name}.messages[${index}]`;
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
     throw new Error(`${label}: must be a mapping`);
@@ -44213,24 +44284,43 @@ function parseTriggerMessage(name, index, raw, agents, as, hasWebhook) {
   if (typeof m.mention !== "string" || m.mention.length === 0) {
     throw new Error(`${label}.mention: must be a non-empty string`);
   }
-  const mentionedAgent = agents[m.mention];
-  if (!mentionedAgent) {
-    throw new Error(`${label}.mention: unknown agent "${m.mention}"`);
-  }
-  if (!mentionedAgent.matrix) {
-    throw new Error(
-      `${label}.mention: agent "${m.mention}" has no matrix: binding \u2014 a trigger posts through Matrix, so the mentioned agent must be matrix-bound.`
-    );
-  }
-  if (as === mentionedAgent.matrix.user_id) {
-    throw new Error(
-      `triggers.${name}.as: must not equal the mentioned agent's own MXID (${as}) \u2014 a message an agent sends never routes back to itself, so this trigger would silently never wake "${m.mention}". Post as a different identity (a dedicated bot, or another agent's).`
-    );
+  if (m.mention.startsWith("@")) {
+    if (!MATRIX_USER_ID_RE.test(m.mention)) {
+      throw new Error(`${label}.mention: must be a full MXID (got ${JSON.stringify(m.mention)})`);
+    }
+    const server = m.mention.slice(m.mention.indexOf(":") + 1);
+    const local = deriveServerName(soleMatrixTransport(transports).user_namespace);
+    if (server !== local) {
+      throw new Error(
+        `${label}.mention: "${m.mention}" is on a different homeserver than this daemon (${local}). A trigger addresses a user on its own homeserver \u2014 see [[ZOD081]] \xA7Non-goals.`
+      );
+    }
+    if (as === m.mention) {
+      throw new Error(
+        `triggers.${name}.as: must not equal the mentioned agent's own MXID (${as}) \u2014 a message an agent sends never routes back to itself, so this trigger would silently never wake "${m.mention}". Post as a different identity (a dedicated bot, or another agent's).`
+      );
+    }
+  } else {
+    const mentionedAgent = agents[m.mention];
+    if (!mentionedAgent) {
+      throw new Error(`${label}.mention: unknown agent "${m.mention}"`);
+    }
+    if (!mentionedAgent.matrix) {
+      throw new Error(
+        `${label}.mention: agent "${m.mention}" has no matrix: binding \u2014 a trigger posts through Matrix, so the mentioned agent must be matrix-bound.`
+      );
+    }
+    if (as === mentionedAgent.matrix.user_id) {
+      throw new Error(
+        `triggers.${name}.as: must not equal the mentioned agent's own MXID (${as}) \u2014 a message an agent sends never routes back to itself, so this trigger would silently never wake "${m.mention}". Post as a different identity (a dedicated bot, or another agent's).`
+      );
+    }
   }
   if (typeof m.text !== "string" || m.text.length === 0) {
     throw new Error(`${label}.text: must be a non-empty string`);
   }
   const message = { room: m.room, mention: m.mention, text: m.text };
+  if (ttlMs !== void 0) message.ttlMs = ttlMs;
   if (m.match !== void 0) {
     if (typeof m.match !== "string" || m.match.length === 0) {
       throw new Error(`${label}.match: must be a non-empty string`);
@@ -44552,6 +44642,7 @@ var AcpAgentRegistry = class {
         id: name,
         command: spawn4.command,
         args: spawn4.args,
+        mode: cfg.acp.mode,
         env: this.opts.env?.[name],
         cwd: this.resolveSpawnCwd(name),
         image: this.opts.image?.[name],
@@ -44960,6 +45051,15 @@ var MatrixClient = class {
     if (!r.ok) throw new Error(`sync(${opts.asUserId}) failed: ${r.status}`);
     return r.json();
   }
+  async fetchRoomState(roomId, asUserId) {
+    const url2 = `${this.homeserver}/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/state?user_id=${encodeURIComponent(asUserId)}`;
+    const r = await this.fetch(url2, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${this.asToken}` }
+    });
+    if (!r.ok) throw new Error(`fetchRoomState(${roomId}) failed: ${r.status}`);
+    return await r.json();
+  }
   async fetchRoomName(roomId, asUserId) {
     const url2 = `${this.homeserver}/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/state/m.room.name/?user_id=${encodeURIComponent(asUserId)}`;
     const r = await this.fetch(url2, {
@@ -45201,6 +45301,24 @@ function stripMention(body, userId) {
   return body.replace(re, " ").replace(/\s+/g, " ").trim();
 }
 
+// ../transport-matrix/src/mention-content.ts
+function buildMentionContent(input) {
+  return {
+    msgtype: input.msgtype,
+    body: `${input.userId} ${input.text}`.trim(),
+    "m.mentions": { user_ids: [input.userId] }
+  };
+}
+
+// ../transport-matrix/src/trigger-freshness.ts
+function isExpiredTrigger(evt, now) {
+  const stamp = evt.content?.["dev.zooid.trigger"];
+  if (!stamp || typeof stamp !== "object") return false;
+  const { fired_at: firedAt, ttl_ms: ttlMs } = stamp;
+  if (typeof firedAt !== "number" || typeof ttlMs !== "number") return false;
+  return now - firedAt > ttlMs;
+}
+
 // ../transport-matrix/src/router.ts
 var MEDIA_MSGTYPES = /* @__PURE__ */ new Set(["m.image", "m.file", "m.video", "m.audio"]);
 function isMediaMsgtype(t) {
@@ -45210,14 +45328,26 @@ function inboundThreadRoot(event) {
   const r = event.content?.["m.relates_to"];
   return r?.rel_type === "m.thread" && r.event_id ? r.event_id : void 0;
 }
-function route(event, agents, threadStates, task) {
+function route(event, agents, threadStates, task, knownAgentIds) {
   if (event.type !== "m.room.message") return [];
   if (!event.content?.msgtype) return [];
   if (isMediaMsgtype(event.content.msgtype)) return [];
+  if (isExpiredTrigger(event, Date.now())) {
+    const stamp = event.content["dev.zooid.trigger"];
+    const ageMs = stamp?.fired_at !== void 0 ? Date.now() - stamp.fired_at : void 0;
+    console.info(
+      `[router] dropping expired trigger "${stamp?.name ?? "unknown"}"` + (ageMs !== void 0 ? ` fired ${ageMs}ms ago` : "")
+    );
+    return [];
+  }
   const mentions = new Set(extractMentions(event));
   const matches2 = [];
   const threadRoot = inboundThreadRoot(event);
   const threadState = threadRoot ? threadStates?.get(threadRoot) : void 0;
+  const senderIsAgent = agents.some((x) => x.userId === event.sender) || event.sender !== void 0 && knownAgentIds?.has(event.sender) === true || event.content.msgtype === "m.notice";
+  const addressesAgent = [...mentions].some(
+    (id) => id !== event.sender && (knownAgentIds?.has(id) === true || agents.some((x) => x.userId === id && x.rooms.some((r) => r.alias === event.room_id)))
+  );
   for (const a of agents) {
     if (!a.rooms.some((r) => r.alias === event.room_id)) continue;
     if (task?.isRoot) {
@@ -45230,10 +45360,9 @@ function route(event, agents, threadStates, task) {
         matches2.push(a);
         continue;
       }
-      const senderAgent = agents.find((x) => x.userId === event.sender);
-      if (senderAgent) {
+      if (senderIsAgent) {
         continue;
-      } else if (a.name === task.assignee) {
+      } else if (a.name === task.assignee && !addressesAgent) {
         matches2.push(a);
       }
       continue;
@@ -45247,10 +45376,9 @@ function route(event, agents, threadStates, task) {
       continue;
     }
     if (threadState) {
-      const senderAgent = agents.find((x) => x.userId === event.sender);
-      if (senderAgent) {
+      if (senderIsAgent) {
         if (isReturnRoute(event, a, agents, threadState)) matches2.push(a);
-      } else {
+      } else if (!addressesAgent) {
         const lastPoster = threadState.participants.at(-1);
         if (lastPoster) {
           if (lastPoster === a.name) matches2.push(a);
@@ -45484,6 +45612,57 @@ function sessionKeyFor(agentName, threadRoot, state) {
   return arc ? composeHandoffKey(threadRoot, arc) : threadRoot;
 }
 
+// ../transport-matrix/src/workforce-publisher.ts
+function buildWorkforceRoster(agents) {
+  return {
+    version: 1,
+    agents: agents.map((a) => ({
+      user_id: a.userId,
+      name: a.name,
+      rooms: a.rooms.map((r) => r.alias)
+    }))
+  };
+}
+async function publishWorkforce(opts) {
+  await opts.client.sendStateEvent({
+    roomId: opts.spaceRoomId,
+    asUserId: opts.asUserId,
+    eventType: "dev.zooid.workforce",
+    stateKey: opts.stateKey ?? "",
+    content: buildWorkforceRoster(opts.agents)
+  });
+}
+async function startWorkforcePublisher(opts) {
+  await publishWorkforce({ ...opts, agents: opts.getAgents() });
+  return {
+    async reload() {
+      await publishWorkforce({ ...opts, agents: opts.getAgents() });
+    },
+    async stop() {
+    }
+  };
+}
+var WorkforceDirectory = class {
+  rosters = /* @__PURE__ */ new Map();
+  agentIds = /* @__PURE__ */ new Set();
+  /** Seed from a space's full state (`GET /rooms/{id}/state`). */
+  load(events) {
+    for (const ev of events) {
+      if (ev.type === "dev.zooid.workforce" && ev.state_key !== void 0)
+        this.apply(ev.state_key, ev.content);
+    }
+  }
+  /** Replace one workstation's roster; empty content removes it. */
+  apply(stateKey, content) {
+    const agents = content?.agents;
+    const ids = Array.isArray(agents) ? agents.map((a) => a?.user_id).filter((id) => typeof id === "string") : [];
+    if (ids.length > 0) this.rosters.set(stateKey, ids);
+    else this.rosters.delete(stateKey);
+    this.agentIds.clear();
+    for (const list of this.rosters.values()) for (const id of list) this.agentIds.add(id);
+  }
+};
+
 // ../transport-matrix/src/event-encoders.ts
 var RAW_INPUT_STR_MAX = 250;
 function toToolCallBody(evt) {
@@ -45763,7 +45942,33 @@ var SyncLoop = class {
       timeoutMs: this.opts.timeoutMs ?? 3e4
     });
     for (const [roomId, roomState] of Object.entries(res.rooms?.join ?? {})) {
-      for (const baseEvt of roomState.timeline?.events ?? []) {
+      const tl = roomState.timeline;
+      if (tl?.limited && tl.prev_batch && since) {
+        const recovered = [];
+        let from = tl.prev_batch;
+        let pages = 0;
+        const max = this.opts.maxGapPages ?? 10;
+        while (from && from !== since && pages < max) {
+          const page = await this.opts.client.fetchRoomMessages({
+            roomId,
+            asUserId: this.opts.asUserId,
+            from,
+            limit: 100
+          });
+          recovered.push(...page.chunk);
+          from = page.end;
+          pages++;
+        }
+        if (pages >= max && from !== since) {
+          console.warn(`[sync-loop] gap in ${roomId} exceeded ${max} pages \u2014 older events skipped`, {
+            asUserId: this.opts.asUserId
+          });
+        }
+        for (const evt of recovered.reverse()) {
+          await this.opts.onEvent({ ...evt, room_id: roomId });
+        }
+      }
+      for (const baseEvt of tl?.events ?? []) {
         await this.opts.onEvent({ ...baseEvt, room_id: roomId });
       }
     }
@@ -46466,6 +46671,8 @@ function createMatrixTransport(opts) {
     });
     return chained;
   }
+  const workforce = new WorkforceDirectory();
+  let workforceSpaceId;
   async function handleInboundEvent(evt) {
     if (evt.event_id) {
       if (seenEventIds.has(evt.event_id)) {
@@ -46483,6 +46690,11 @@ function createMatrixTransport(opts) {
       );
       return;
     }
+    if (evt.type === "dev.zooid.workforce") {
+      if (evt.room_id === workforceSpaceId && evt.state_key !== void 0)
+        workforce.apply(evt.state_key, evt.content);
+      return;
+    }
     if (evt.type === "m.room.member" && evt.content?.membership === "invite") {
       const target = evt.state_key;
       const inviter = evt.sender;
@@ -46610,7 +46822,13 @@ function createMatrixTransport(opts) {
     const inboundRel = inboundThreadRoot2(evt);
     if (evt.type === "m.room.message" && inboundRel && !threadStates.has(inboundRel) && evt.room_id) {
       try {
-        const rebuilt = await rebuildThreadState(client, evt.room_id, inboundRel, bindings);
+        const rebuilt = await rebuildThreadState(
+          client,
+          evt.room_id,
+          inboundRel,
+          bindings,
+          workforce.agentIds
+        );
         threadStates.set(inboundRel, rebuilt);
         console.log(
           `[matrix] rebuilt threadState for ${inboundRel}: participants=${rebuilt.participants.join(",")} rootMentions=${rebuilt.rootMentions.join(",")}`
@@ -46628,7 +46846,10 @@ function createMatrixTransport(opts) {
       assignee: taskRec.assignee,
       isRoot: !inboundRel && evt.event_id === taskRec.threadRoot
     } : void 0;
-    let matches2 = route(evt, bindings, threadStates, taskCtx);
+    const inboundState = inboundRel ? threadStates.get(inboundRel) : void 0;
+    if (inboundState && evt.type === "m.room.message" && evt.sender && isRemoteAgent(evt.sender, evt.content?.msgtype, bindings, workforce.agentIds) && inboundState.participants.at(-1) !== evt.sender)
+      inboundState.participants.push(evt.sender);
+    let matches2 = route(evt, bindings, threadStates, taskCtx, workforce.agentIds);
     if (taskCtx && !taskCtx.isRoot && evt.event_id && bindings.some((b) => b.userId === evt.sender)) {
       const invocation = invocations.byCallEvent(evt.event_id);
       matches2 = invocation ? matches2.filter((match) => match.name === invocation.calleeAgent) : [];
@@ -47099,6 +47320,15 @@ function createMatrixTransport(opts) {
     syncLoops,
     bootstrap: async (bootstrapOpts = {}) => {
       await pool.bootstrap({ adminUserId, ...bootstrapOpts });
+      const { spaceRoomId, asUserId } = bootstrapOpts;
+      if (spaceRoomId && asUserId) {
+        workforceSpaceId = spaceRoomId;
+        try {
+          workforce.load(await client.fetchRoomState(spaceRoomId, asUserId));
+        } catch (err) {
+          console.warn("[matrix] workforce roster load failed:", err);
+        }
+      }
       await Promise.allSettled(
         bindings.map(
           (b) => client.setPresence({ asUserId: b.userId, presence: "online" }).catch((err) => {
@@ -47110,7 +47340,7 @@ function createMatrixTransport(opts) {
     pool
   };
 }
-async function rebuildThreadState(client, roomId, rootEventId, bindings) {
+async function rebuildThreadState(client, roomId, rootEventId, bindings, knownAgentIds) {
   const state = {
     participants: [],
     rootMentions: [],
@@ -47158,11 +47388,18 @@ async function rebuildThreadState(client, roomId, rootEventId, bindings) {
     const type = ev.type;
     if (type === "m.room.message" && evSender) {
       const a = bindings.find((b) => b.userId === evSender);
-      if (a && state.participants.at(-1) !== a.name) state.participants.push(a.name);
+      const msgtype = ev.content?.msgtype;
+      const participant = a ? a.name : isRemoteAgent(evSender, msgtype, bindings, knownAgentIds) ? evSender : void 0;
+      if (participant && state.participants.at(-1) !== participant)
+        state.participants.push(participant);
     }
   }
   return state;
 }
+function isRemoteAgent(sender, msgtype, bindings, knownAgentIds) {
+  if (bindings.some((b) => b.userId === sender)) return false;
+  return knownAgentIds?.has(sender) === true || msgtype === "m.notice";
+}
 function logInbound(evt) {
   const sender = evt.sender ?? "?";
   const room = evt.room_id ?? "?";
@@ -47182,37 +47419,6 @@ function truncate(s, n) {
   return s.length > n ? s.slice(0, n) + "\u2026" : s;
 }
 
-// ../transport-matrix/src/workforce-publisher.ts
-function buildWorkforceRoster(agents) {
-  return {
-    version: 1,
-    agents: agents.map((a) => ({
-      user_id: a.userId,
-      name: a.name,
-      rooms: a.rooms.map((r) => r.alias)
-    }))
-  };
-}
-async function publishWorkforce(opts) {
-  await opts.client.sendStateEvent({
-    roomId: opts.spaceRoomId,
-    asUserId: opts.asUserId,
-    eventType: "dev.zooid.workforce",
-    stateKey: "",
-    content: buildWorkforceRoster(opts.agents)
-  });
-}
-async function startWorkforcePublisher(opts) {
-  await publishWorkforce({ ...opts, agents: opts.getAgents() });
-  return {
-    async reload() {
-      await publishWorkforce({ ...opts, agents: opts.getAgents() });
-    },
-    async stop() {
-    }
-  };
-}
-
 // ../context-mcp/src/spawn-registry.ts
 import { randomUUID as randomUUID5 } from "crypto";
 var SpawnRegistry = class {
@@ -52963,14 +53169,15 @@ export {
   ApprovalCorrelator,
   MatrixClient,
   renderRegistration,
+  buildMentionContent,
   ensureWorkforceSpace,
   ensureDefaultChannel,
+  startWorkforcePublisher,
   MediaClient,
   createMatrixTransport,
-  startWorkforcePublisher,
   SpawnRegistry,
   startAgentSocketServers,
   buildAcpRegistry,
   contextEligibleAgents
 };
-//# sourceMappingURL=chunk-R5S26T7B.js.map
+//# sourceMappingURL=chunk-35IKQPC5.js.map