@volter/supercode-teams 0.3.99 → 0.3.100

package/machine.mjs

@@ -3419,7 +3419,8 @@ export class TeamsMachine extends MachineCore {
       case 'harness.v1.mail.handover': {
         if (entry.principal !== 'local' || entry.appDoor) throw Object.assign(new Error('mail is handed over here by this machine\'s own processes'), { code: 403 });
         if (typeof params.address !== 'string' || typeof params.id !== 'string' || !parseAddress(params.address)) throw Object.assign(new Error('a hand-over names an address and a message id'), { code: 400 });
-        return this.mailSend.handOver(params.address, params.id, { markRead: params.mark_read === true, wake: params.wake === true });
+        // a hand-over is moved to cur/ once delivered whatever `mark_read` says (MailSend.handOver)
+        return this.mailSend.handOver(params.address, params.id, { wake: params.wake === true });
       }
       // harness serve's `sessions.message` (its mail to a session or an agent, not its `as_user` turn), asked here by
       // harness serve itself: one implementation of a send, whatever the entry.

package/mail/send.mjs

@@ -52,6 +52,7 @@ export class MailSend {
    */
   constructor({ machine, mailRoot, live, store, agents, relays, askMachine, deliverRuntime, codexAnswer, typeTurn, log = () => {} }) {
     Object.assign(this, { machine, mailRoot, live, store, agents, relays, askMachine, deliverRuntime, codexAnswer, typeTurn, log });
+    this.handing = new Set(); // `<address>\n<id>` of each hand-over running here (handOver)
   }
 
   // ---- one send ----------------------------------------------------------------------------------------------------
@@ -665,16 +666,27 @@ export class MailSend {
   /**
    * A message filed unread in `address`'s mailbox handed to its session's door, once (mail_watch.rs `carry` and message.rs
    * `push`, and the native watch's notices): only a door that hands it to the session (a relay, a runtime) takes it, a
-   * hook's is woken when `wake`, and an agent's mail is planned; `markRead` moves it to `cur/` once handed over. The
-   * hand-over is recorded on its wake before it starts, so one interrupted mid-way is never handed over again. Answers
+   * hook's is woken when `wake`, and an agent's mail is planned. One handed over is moved to `cur/` here, whoever asked:
+   * its receiver has it, so its next inbox read never shows it again (the carrier marks it read only when its own call
+   * answers delivered, which a hand-over past its bound never does). The
+   * hand-over is recorded on its wake before it starts, so one interrupted mid-way (its daemon ended) is never handed over
+   * again; one still running here, its carrier past its bound, answers 'later' until it settles. Answers
    * `{ outcome: 'delivered' | 'filed' | 'later', detail }`.
    */
-  async handOver(address, id, { markRead = false, wake = false } = {}) {
+  async handOver(address, id, { wake = false } = {}) {
     const found = this.store.findIn(address, id);
     if (!found) return { outcome: 'filed', detail: 'not in its mailbox' };
     const sent = readJson(found.path);
     if (!sent) return { outcome: 'later', detail: 'its envelope could not be read' };
     if (found.state !== 'unread') return { outcome: 'filed', detail: 'already read' };
+    // one already handed to its receiver's door (that delivery's claim, the door's or the carrier's: a daemon that ended
+    // between the delivery and moving the copy left it unread) is moved to `cur/`, never handed over again. A reader's
+    // claim is not one: a reader that ended before reading put the copy back unread, and it is handed over
+    const claim = this.store.claimOf(address, id);
+    if (claim?.recipient === true && (claim.via === 'door' || claim.via === 'carrier')) {
+      this.store.markRead(address, found.path);
+      return { outcome: 'filed', detail: 'already handed over' };
+    }
     const parsed = parseAddress(address);
     if (parsed?.harness === AGENT_HARNESS) {
       const plan = await this.#plan(sent, address, {});
@@ -691,11 +703,18 @@ export class MailSend {
       return { outcome: 'filed', detail: `its door is ${door.kind}` };
     }
     const state = this.store.wakeState(address, id);
+    // one still running here (its carrier gave up on its answer, past its bound) is waited for: the wake stays and is
+    // tried again after its backoff, settled by that hand-over's own outcome
+    const key = `${address}\n${id}`;
+    if (this.handing.has(key)) return { outcome: 'later', detail: 'its hand-over is still in progress' };
     if (state.handover_at_ms != null) return { outcome: 'filed', detail: 'an earlier hand-over never settled' };
     this.store.setWakeState(address, id, { ...state, handover_at_ms: Date.now() });
+    this.handing.add(key);
     try {
-      await this.route(sent, address, door, true, false);
-      if (markRead) { const now = this.store.findIn(address, id); if (now?.state === 'unread') this.store.markRead(address, now.path); }
+      const how = await this.route(sent, address, door, true, false);
+      // handed to the session (or already its): moved to cur/ (one only queued for a runtime not woken would stay unread)
+      const now = this.store.findIn(address, id);
+      if (how !== 'queued' && now?.state === 'unread') this.store.markRead(address, now.path);
       return { outcome: 'delivered', detail: null };
     } catch (error) {
       // a message its door can never take (too long for a relay) stays filed for the session to read
@@ -704,6 +723,7 @@ export class MailSend {
       if (error.unanswered) return { outcome: 'later', detail: `unanswered: ${error.message}` };
       return error instanceof Refused ? { outcome: 'filed', detail: error.kind } : { outcome: 'later', detail: error.message };
     } finally {
+      this.handing.delete(key);
       const after = this.store.wakeState(address, id);
       this.store.setWakeState(address, id, { ...after, handover_at_ms: null });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.99",
+  "version": "0.3.100",
   "type": "module",
   "description": "A machine daemon serving this machine's doors, and a local or remote Teams server for shared session discovery, OpenTelemetry ingestion and access to enrolled machines.",
   "license": "MIT",