mtech-ai-local-runner 0.1.59 → 0.1.61

package/README.md

@@ -1,3 +1,9 @@
+## 0.1.60: answers go back to the session that asked
+
+An answer to a colleague ask now goes first to the session that made the ask, when the asking AI passed its client
+session id (Work Item e1c08b33). Among the sessions an answer names, the runner takes the one listed first, as long
+as a person typed in it in the last 30 minutes.
+
 ## 0.1.59: completed publication acknowledgement
 
 Runner 0.1.59 corrects post-publication completion acknowledgement. The Gateway binding primary key is independent of the client session UUID. Recovery uses the saved binding/Job/generation mapping and exact server completion receipt; it does not renew an expired lease or replay a completed publication. Unverified PRs retain `unverified` / `CI not_run` status.

package/dist/src/asks/inbox.js

@@ -1,5 +1,5 @@
 import { emptyAskState, pruneAskState, sessionKey } from "./store.js";
-import { addDeliveries, claimOpen, closeDeliveries, confirmNotified, confirmOpened, confirmWake, isLive, planRoutes, preferredApp, promptSubmitted, releaseOpen, sessionEnded, sessionStarted, turnEnded, } from "./routing.js";
+import { addDeliveries, claimOpen, closeDeliveries, confirmNotified, confirmOpened, confirmWake, isLive, openApp, planRoutes, promptSubmitted, releaseOpen, sessionEnded, sessionStarted, turnEnded, } from "./routing.js";
 import { droppableDeliveryId, parseAskDelivery } from "./types.js";
 import { renderOutput } from "./templates.js";
 import { PRESENCE_RECHECK_MS } from "./presence.js";
@@ -292,11 +292,16 @@ export class AskInbox {
         // Claimed before anything runs, so a delivery is never opened or notified twice.
         const opening = new Set(plan.open.map(item => item.deliveryId));
         claimOpen(this.state, [...opening], now);
-        for (const item of plan.notify)
+        for (const item of [...plan.notify, ...plan.held])
             confirmNotified(this.state, item.deliveryId, now, false);
         const notify = plan.notify.map(item => item.deliveryId);
+        const held = plan.held.flatMap(item => {
+            const session = item.sessionKey === null ? undefined : this.state.sessions[item.sessionKey];
+            return session === undefined ? [] : [{ deliveryId: item.deliveryId, app: session.app }];
+        });
         return {
             notify: notify.filter(id => !opening.has(id)),
+            held,
             // The notification of a delivery in the open waits for its outcome, which decides the text.
             open: opening.size === 0 ? null : { deliveryIds: [...opening], notifyAfter: notify.filter(id => opening.has(id)) },
         };
@@ -306,6 +311,8 @@ export class AskInbox {
         await this.persist();
         if (work.notify.length > 0)
             this.startNotifying(work.notify);
+        for (const { deliveryId, app } of work.held)
+            this.startNotifying([deliveryId], { heldIn: app });
         if (work.open !== null)
             this.startOpening(work.open);
         try {
@@ -411,7 +418,7 @@ export class AskInbox {
             return { status: "skipped" };
         const kinds = { asks: items.some(item => item.direction === "ask"), answers: items.some(item => item.direction === "answer") };
         try {
-            return await this.deps.openSession(preferredApp(this.state), kinds);
+            return await this.deps.openSession(openApp(this.state, items), kinds);
         }
         catch {
             return { status: "failed", code: "open_failed" };

package/dist/src/asks/notifier.js

@@ -25,6 +25,11 @@ const OPENED_TEXT = {
         codex: "AI Gateway: your ask has an answer. A Codex session is open to continue.",
     },
 };
+/** An answer held in its live asking session (Work Decision 8562d191): no session is opened, the person goes back to it. */
+const HELD_TEXT = {
+    claude: "AI Gateway: your ask has an answer. It is waiting in the Claude session that asked. Type there to see it.",
+    codex: "AI Gateway: your ask has an answer. It is waiting in the Codex session that asked. Type there to see it.",
+};
 export const OSASCRIPT = "/usr/bin/osascript";
 const SCRIPT = ["on run argv", "display notification (item 1 of argv) with title \"AI Gateway\"", "end run"];
 /**
@@ -34,6 +39,8 @@ const SCRIPT = ["on run argv", "display notification (item 1 of argv) with title
  */
 export const NOTIFY_TIMEOUT_MS = 3_000;
 export function notificationText(item, options = {}) {
+    if (options.heldIn !== undefined)
+        return HELD_TEXT[options.heldIn];
     if (options.openedApp !== undefined)
         return OPENED_TEXT[item.direction][options.openedApp];
     return (item.direction === "ask" ? ASK_TEXT : ANSWER_TEXT)[item.subjectType];

package/dist/src/asks/routing.js

@@ -59,17 +59,54 @@ export function preferredApp(state) {
     }
     return best?.app ?? null;
 }
+/**
+ * The live session on this Mac that made an answer's ask (Work Decision 8562d191): null for an ask, without a hash, or
+ * when that session is unknown here or no longer live.
+ */
+export function askerSessionKey(item, state, now) {
+    if (item.direction !== "answer" || item.askerSessionHash === undefined || item.askerSessionHash === null)
+        return null;
+    for (const [key, session] of Object.entries(state.sessions)) {
+        if (isLive(session, now) && hashSessionId(session.sessionId) === item.askerSessionHash)
+            return key;
+    }
+    return null;
+}
+/**
+ * The app an open uses: for answers only, the app of the first one whose asking session this Mac still knows, live or
+ * ended, so the new session opens where the person asked; otherwise preferredApp.
+ */
+export function openApp(state, items) {
+    if (items.length > 0 && items.every(item => item.direction === "answer")) {
+        for (const item of items) {
+            if (item.askerSessionHash === undefined || item.askerSessionHash === null)
+                continue;
+            const asking = Object.values(state.sessions).find(session => hashSessionId(session.sessionId) === item.askerSessionHash);
+            if (asking !== undefined)
+                return asking.app;
+        }
+    }
+    return preferredApp(state);
+}
 /**
  * Spec section 5: a live session the delivery names, else the live session with the most recent human prompt. A named
  * session counts only with a human prompt in the last 30 minutes: named sessions stay live until closed, and an older
- * one would otherwise keep the delivery from the session the person is using (2026-10-26 Test B).
+ * one would otherwise keep the delivery from the session the person is using (2026-10-26 Test B). Among named sessions
+ * the one listed first wins: the Gateway lists the session that made the ask first (2026-10-26 test C). An answer whose
+ * asking session is live goes there, however long ago it was typed in (Work Decision 8562d191).
  */
 export function chooseSession(item, state, now) {
+    const asking = askerSessionKey(item, state, now);
+    if (asking !== null)
+        return asking;
     const live = Object.entries(state.sessions).filter(([, session]) => isLive(session, now));
-    const targets = new Set(item.targetSessionHashes);
-    const named = live.filter(([, session]) => targets.has(hashSessionId(session.sessionId)) && humanPromptWithin(session, now));
+    const order = new Map(item.targetSessionHashes.map((hash, index) => [hash, index]));
+    const rank = (session) => order.get(hashSessionId(session.sessionId)) ?? order.size;
+    const named = live.filter(([, session]) => rank(session) < order.size && humanPromptWithin(session, now));
     const pool = named.length > 0 ? named : live;
-    pool.sort(([keyA, a], [keyB, b]) => (b.lastPromptAt ?? -1) - (a.lastPromptAt ?? -1) || b.lastEventAt - a.lastEventAt || keyA.localeCompare(keyB));
+    const byOrder = named.length > 0 ? rank : () => 0;
+    pool.sort(([keyA, a], [keyB, b]) => byOrder(a) - byOrder(b) || (b.lastPromptAt ?? -1) - (a.lastPromptAt ?? -1)
+        || b.lastEventAt - a.lastEventAt || keyA.localeCompare(keyB));
     return pool[0]?.[0] ?? null;
 }
 /**
@@ -80,17 +117,22 @@ export function chooseSession(item, state, now) {
  *   becomes the chosen one by that prompt (see promptSubmitted);
  * - an idle Claude session whose Stop watcher waits, under its hourly limit: woken now;
  * - otherwise (an idle Codex session, no watcher, or the limit reached): a notification.
+ * An answer whose asking session is live is pinned or woken there by the same rules, and otherwise held there: it waits
+ * for that session, with a notification that says so, and no session is opened for it (Work Decision 8562d191).
  */
 export function routeItem(item, state, now, watching) {
-    const key = chooseSession(item, state, now);
+    const asking = askerSessionKey(item, state, now);
+    const key = asking ?? chooseSession(item, state, now);
     const session = key === null ? undefined : state.sessions[key];
-    if (key === null || session === undefined || !humanPromptWithin(session, now))
+    if (key === null || session === undefined)
+        return { action: "notify" };
+    if (asking === null && !humanPromptWithin(session, now))
         return { action: "notify" };
     if (turnInProgress(session))
         return { action: "pin", sessionKey: key };
-    if (session.app === "claude" && watching.has(key) && wakesLeft(session, now) > 0)
+    if (session.app === "claude" && humanPromptWithin(session, now) && watching.has(key) && wakesLeft(session, now) > 0)
         return { action: "wake", sessionKey: key };
-    return { action: "notify" };
+    return asking === null ? { action: "notify" } : { action: "hold", sessionKey: key };
 }
 /** At most 5 spelled out, oldest first; the rest are summarized by one "and N more" line. */
 export function selectForOutput(items) {
@@ -259,6 +301,7 @@ export function sessionEnded(state, context) {
 export function planRoutes(state, now, watching, options = {}) {
     const wakeGroups = new Map();
     const notify = [];
+    const held = [];
     const unseen = [];
     for (const item of itemsWhere(state, item => item.phase === "waiting" || item.phase === "pinned")) {
         const decision = routeItem(item, state, now, watching);
@@ -272,12 +315,14 @@ export function planRoutes(state, now, watching, options = {}) {
         }
         item.phase = "pinned";
         item.sessionKey = decision.sessionKey;
+        if (decision.action === "hold" && item.notifiedAt === null)
+            held.push(item);
         if (decision.action === "wake")
             wakeGroups.set(decision.sessionKey, [...wakeGroups.get(decision.sessionKey) ?? [], item]);
     }
     const openable = unseen.filter(item => item.openedAt === null);
     const open = options.canOpen === true && openable.length > 0 && !openPending(state, now) && opensLeft(state, now) > 0 ? openable : [];
-    return { wakes: [...wakeGroups].map(([key, items]) => ({ sessionKey: key, output: selectForOutput(items) })), notify, open };
+    return { wakes: [...wakeGroups].map(([key, items]) => ({ sessionKey: key, output: selectForOutput(items) })), notify, held, open };
 }
 /** The hub delivered a wake to the session's watcher: everything in it counts as shown there. */
 export function confirmWake(state, key, output, now) {

package/dist/src/asks/runtime.js

@@ -6,6 +6,7 @@ import { installedApps } from "./integrations.js";
 import { createNotifier } from "./notifier.js";
 import { createPresenceReader } from "./presence.js";
 import { createSessionOpener } from "./opener.js";
+import { ASK_INBOX_VERSION } from "./types.js";
 /*
  * AI-first ask delivery inside the daemon (Work Item e1c08b33). It rides on the existing session-open loop:
  * no new long-poll. The hub runs for as long as that loop runs, deliveries from each wait are stored and
@@ -152,7 +153,7 @@ export class AskRuntime {
         catch {
             apps = [];
         }
-        return apps.length > 0 ? { version: 1, apps: [...apps] } : undefined;
+        return apps.length > 0 ? { version: ASK_INBOX_VERSION, apps: [...apps] } : undefined;
     }
     /** Resolves when the start settles or the bound passes, whichever comes first. Never rejects: start() never throws. */
     async waitForStart(starting) {

package/dist/src/asks/store.js

@@ -79,6 +79,10 @@ function normalizeItem(key, value) {
     // Missing in a file written before opens existed: never opened.
     if (v.openedAt !== undefined && !isTimeOrNull(v.openedAt))
         return null;
+    // Missing in a file written before 0.1.61 or from a seven-key delivery: no asking session known.
+    if (v.askerSessionHash !== undefined && v.askerSessionHash !== null
+        && (typeof v.askerSessionHash !== "string" || !SESSION_HASH.test(v.askerSessionHash)))
+        return null;
     const outbox = v.outbox.map(normalizeReport);
     if (outbox.some(report => report === null))
         return null;
@@ -86,7 +90,8 @@ function normalizeItem(key, value) {
         targetSessionHashes: [...v.targetSessionHashes], createdAt: v.createdAt, receivedAt: v.receivedAt,
         phase: settlePhase(v.phase, v.sessionKey),
         sessionKey: v.sessionKey, shownVia: v.shownVia, shownAt: v.shownAt, firstShownVia: v.firstShownVia,
-        notifiedAt: v.notifiedAt, openedAt: (v.openedAt ?? null), seenAt: v.seenAt, outbox: outbox };
+        notifiedAt: v.notifiedAt, openedAt: (v.openedAt ?? null), seenAt: v.seenAt, outbox: outbox,
+        ...(v.askerSessionHash === undefined ? {} : { askerSessionHash: v.askerSessionHash }) };
 }
 function normalizeSession(key, value) {
     if (value === null || typeof value !== "object")

package/dist/src/asks/types.js

@@ -9,6 +9,11 @@ export const SUBJECT_TYPES = ["decision", "review", "request"];
 export const DIRECTIONS = ["ask", "answer"];
 export const VIAS = ["prompt", "session_start", "stop", "rewake", "notification"];
 export const REPORT_EVENTS = ["received", "shown", "seen", "dropped"];
+/**
+ * heartbeat runner.session_open.ask_inbox: the integrations actually installed on this Mac. Version 2 says the runner
+ * reads asker_session_hash on deliveries (Work Decision 8562d191); it needs a Gateway that accepts version 2.
+ */
+export const ASK_INBOX_VERSION = 2;
 /** Gateway ids are lowercase UUIDs (contract: subject keys must be lowercase UUIDs). */
 export const LOWER_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 /** sha256 of a client session id, as the Gateway stores external_session_id_hash. */
@@ -22,8 +27,10 @@ export const OPEN_ASKS_LEAD = "AI Gateway: colleagues' AIs are waiting for you."
 export const OPEN_ANSWERS_LEAD = "AI Gateway: your asks have answers.";
 /** The most target session hashes one delivery may carry: a longer list is refused on the wire and dropped on load. */
 export const MAX_TARGET_HASHES = 50;
-// Sorted, so they compare directly with the sorted keys of a wire item.
+// Sorted, so they compare directly with the sorted keys of a wire item. A Gateway that knows this runner reads
+// ask_inbox version 2 adds asker_session_hash; an older one sends the seven keys only.
 const DELIVERY_FIELDS = ["created_at", "delivery_id", "direction", "subject_key", "subject_type", "target_session_hashes", "work_item_id"];
+const DELIVERY_FIELDS_WITH_ASKER = ["asker_session_hash", ...DELIVERY_FIELDS];
 function oneOf(values, value) {
     return typeof value === "string" && values.includes(value);
 }
@@ -39,9 +46,13 @@ export function parseAskDelivery(input) {
         return null;
     const record = input;
     const keys = Object.keys(record).sort();
-    if (keys.length !== DELIVERY_FIELDS.length || keys.some((key, index) => key !== DELIVERY_FIELDS[index]))
+    const withAsker = keys.includes("asker_session_hash");
+    const fields = withAsker ? DELIVERY_FIELDS_WITH_ASKER : DELIVERY_FIELDS;
+    if (keys.length !== fields.length || keys.some((key, index) => key !== fields[index]))
+        return null;
+    const { delivery_id: deliveryId, subject_type: subjectType, subject_key: subjectKey, direction, work_item_id: workItemId, target_session_hashes: hashes, created_at: createdAt, asker_session_hash: asker } = record;
+    if (withAsker && asker !== null && (typeof asker !== "string" || !SESSION_HASH.test(asker)))
         return null;
-    const { delivery_id: deliveryId, subject_type: subjectType, subject_key: subjectKey, direction, work_item_id: workItemId, target_session_hashes: hashes, created_at: createdAt } = record;
     if (typeof deliveryId !== "string" || !LOWER_UUID.test(deliveryId))
         return null;
     if (!isSubjectType(subjectType) || !isDirection(direction))
@@ -56,7 +67,8 @@ export function parseAskDelivery(input) {
         return null;
     if (typeof createdAt !== "number" || !Number.isSafeInteger(createdAt) || createdAt < 0)
         return null;
-    return { deliveryId, subjectType, subjectKey, direction, workItemId, targetSessionHashes: [...hashes], createdAt };
+    return { deliveryId, subjectType, subjectKey, direction, workItemId, targetSessionHashes: [...hashes], createdAt,
+        ...(withAsker ? { askerSessionHash: asker } : {}) };
 }
 /** The id of a wire item that failed validation, when the id itself is valid, so it can be reported as dropped. */
 export function droppableDeliveryId(input) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mtech-ai-local-runner",
-  "version": "0.1.59",
+  "version": "0.1.61",
   "private": false,
   "license": "UNLICENSED",
   "bin": {