charness 0.0.0-stage → 3.0.0

package/dist/openCodeQuestionFlow.js

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * @description Pure logic for the OpenCode interactive-question UX (plan
+ * `2026-06-09-question-ux.md`, scopes S1 + S2). Kept side-effect-free so the
+ * tricky parts — rendering option descriptions and the sequential
+ * multi-question answer collection — are exhaustively unit-testable without a
+ * live Telegram round-trip (the answer path real topics depend on; a bug here
+ * silently breaks question answering and can't be force-triggered on demand).
+ *
+ * The bot (`bot.ts`) owns all I/O: it calls {@link buildQuestionBodyLines} to
+ * render a question's text body, and drives the answer state machine via
+ * {@link recordAnswerAndAdvance}, then performs the resulting Telegram send /
+ * agent reply.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildQuestionBodyLines = buildQuestionBodyLines;
+exports.buildQuestionBodyLinesPlain = buildQuestionBodyLinesPlain;
+exports.getQuestionReplyRoute = getQuestionReplyRoute;
+exports.recordAnswerAndAdvance = recordAnswerAndAdvance;
+exports.migratePendingQuestionState = migratePendingQuestionState;
+/**
+ * @description Build the message-BODY text lines for ONE question: the header,
+ * the question text (only when it differs from the header), then the numbered
+ * option labels each followed by its description (S1 — descriptions were
+ * previously discarded even though OpenCode delivers them).
+ *
+ * The numbering is 1-based and lines up with the inline option buttons
+ * (`qa_<qIdx>_<optIdx>`), so a user can answer by tapping a button OR by typing
+ * the digit. Descriptions go ONLY in the body (indented under the label), never
+ * on the button — buttons stay label-only under Telegram's 40-char cap.
+ *
+ * `escape` is injected (Markdown or HTML escaper) so this stays pure and
+ * backend-agnostic; the bot passes its own `escapeMarkdown`.
+ */
+function buildQuestionBodyLines(question, escape) {
+    const header = question.header || question.question || 'Question';
+    const lines = [`❓ *${escape(header)}*`];
+    if (question.question && question.question !== header) {
+        lines.push(escape(question.question));
+    }
+    question.options.forEach((option, optIdx) => {
+        lines.push(`${optIdx + 1}. ${escape(option.label)}`);
+        if (option.description) {
+            // Indented under the label so it reads as that option's sub-line.
+            lines.push(`   ${escape(option.description)}`);
+        }
+    });
+    return lines;
+}
+/**
+ * @description Build the same body as {@link buildQuestionBodyLines} but with NO
+ * escaping and no bold markers — the plain-text fallback used when Telegram
+ * rejects the Markdown render of a question.
+ */
+function buildQuestionBodyLinesPlain(question) {
+    const header = question.header || question.question || 'Question';
+    const lines = [`❓ ${header}`];
+    if (question.question && question.question !== header) {
+        lines.push(question.question);
+    }
+    question.options.forEach((option, optIdx) => {
+        lines.push(`${optIdx + 1}. ${option.label}`);
+        if (option.description)
+            lines.push(`   ${option.description}`);
+    });
+    return lines;
+}
+/**
+ * @description Decide how to route a user's reply for a thread that has an
+ * OpenCode question on screen. Pure so the digit-in-range precedence is
+ * unit-testable without a live session.
+ *
+ * Only a bare 1-based digit in range of `currentQuestion.options` answers; any
+ * other text (out-of-range digit, prose, empty) cancels. A digit answer carries
+ * the chosen option label(s) so the caller never re-parses the digit (single
+ * source of truth for the digit→label mapping).
+ */
+function getQuestionReplyRoute(text, currentQuestion) {
+    const trimmed = text.trim();
+    if (currentQuestion && /^\d+$/.test(trimmed)) {
+        const optionIndex = parseInt(trimmed, 10) - 1;
+        const picked = currentQuestion.options[optionIndex];
+        if (picked)
+            return { kind: 'answer', labels: [picked.label] };
+    }
+    return { kind: 'cancel' };
+}
+/**
+ * @description Record the user's answer for the CURRENTLY shown question and
+ * decide what happens next (S2 — sequential multi-question + local answer
+ * collection). Pure: returns the mutated-copy state plus the action; the bot
+ * performs the side effect (post the next question OR reply to the agent).
+ *
+ * The bug this fixes: the old handler closed the whole request on the first
+ * answer, sending EMPTY answers for every other question. Here we only submit
+ * once NO slot is left `null`.
+ *
+ * `answerForCurrent` is the chosen option label(s) or the typed text, wrapped
+ * as a one-element array per OpenCode's `string[][]` matrix shape.
+ */
+function recordAnswerAndAdvance(state, answerForCurrent) {
+    const answers = state.answers.slice();
+    answers[state.currentIndex] = answerForCurrent;
+    const nextUnansweredIndex = answers.findIndex(slot => slot === null);
+    if (nextUnansweredIndex === -1) {
+        // All answered → build the matrix. A null slot can only appear here
+        // defensively (e.g. a migrated/corrupt state); coerce it to [''] so the
+        // reply shape stays valid string[][] and never carries `null`.
+        const matrix = answers.map(slot => slot ?? ['']);
+        return {
+            nextState: { ...state, answers },
+            action: { kind: 'submit', matrix },
+        };
+    }
+    return {
+        nextState: { ...state, answers, currentIndex: nextUnansweredIndex },
+        action: { kind: 'showQuestion', index: nextUnansweredIndex },
+    };
+}
+/**
+ * @description Restore-compat guard for {@link PendingQuestionState} (S2). The
+ * persisted shape grew `answers` + `currentIndex`; an OLD `state.json` entry
+ * written before this change has only `{ data, messageId }`. Returning it raw
+ * would leave `answers`/`currentIndex` undefined and crash the answer handlers
+ * at boot. This normalises any restored entry to the new shape:
+ *  - missing/mismatched-length `answers` → rebuilt as `[null…]` sized to the
+ *    question count (the user must re-answer — the in-progress local answers
+ *    were never sent to the agent anyway);
+ *  - missing/out-of-range `currentIndex` → `0`.
+ */
+function migratePendingQuestionState(raw) {
+    const questionCount = raw.data.questions.length;
+    const hasValidAnswers = Array.isArray(raw.answers) && raw.answers.length === questionCount;
+    const answers = hasValidAnswers
+        ? raw.answers
+        : new Array(questionCount).fill(null);
+    const hasValidIndex = typeof raw.currentIndex === 'number' &&
+        raw.currentIndex >= 0 &&
+        raw.currentIndex < questionCount;
+    const currentIndex = hasValidIndex ? raw.currentIndex : 0;
+    return { ...raw, answers, currentIndex };
+}
+//# sourceMappingURL=openCodeQuestionFlow.js.map

package/dist/openCodeQuestionFlow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openCodeQuestionFlow.js","sourceRoot":"","sources":["../src/openCodeQuestionFlow.ts"],"names":[],"mappings":"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"}

package/dist/openCodeSessionRouting.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Decide whether an incoming OpenCode SSE event belongs to a thread's bound
+ * session — directly, or because the event's session is a SUBAGENT child of
+ * it.
+ *
+ * OpenCode runs subagents (e.g. `@explore` / Task) in CHILD sessions whose
+ * `parentID` points at the originating session. Their events (deltas,
+ * `session.idle`, …) carry the CHILD sessionID, not the parent's. The bot
+ * binds the parent session to a topic, so a child event must be matched by
+ * walking up the lineage chain to the bound session — otherwise subagent
+ * output is dropped and the topic hangs on the ⏳ loader forever.
+ *
+ * The visited-set guards against cyclic lineage so a corrupt chain can never
+ * spin.
+ */
+export declare function checkIsEventForSession(eventSessionId: string, ownedSessionId: string, childToParent: ReadonlyMap<string, string>): boolean;
+/** Prefix shared by every OpenCode session id (`ses_…`). Used to reject
+ * non-session ids (e.g. a `msg_…` id) before recording a lineage link. */
+export declare const openCodeSessionIdPrefix = "ses_";
+/** A bound (active) thread session, reduced to the two fields routing needs. */
+export interface BoundSessionRef {
+    /** Serialised `SessionKey` (`"<chatId>:<threadId>"`). */
+    keyStr: string;
+    /** Server-assigned OpenCode session id (`ses_…`) this thread owns. */
+    sessionId: string;
+}
+/**
+ * @description Resolve the SINGLE bound thread that owns an incoming SSE event,
+ * so an event is delivered to at most one topic (single-owner delivery).
+ *
+ * Even on the single global stream (every instance's events multiplexed on
+ * one `/global/event`), the same event reaches the dispatcher once and may match
+ * more than one bound thread: a false lineage link OR a duplicated session id
+ * (two threads
+ * accidentally bound to the same server session) would make the event match —
+ * and emit to — more than one topic (bug B20: the same answer appeared in two
+ * threads). The single-owner rule picks exactly one.
+ *
+ * Ownership priority:
+ *   1. A thread whose own `sessionId` directly equals `eventSessionId` is the
+ *      canonical owner. Direct ownership always beats lineage descent — a
+ *      session that IS bound to a thread can never be a routing *descendant* of
+ *      another thread, so a real (parent) session is never stolen by a topic
+ *      that merely has it in its lineage chain.
+ *   2. Otherwise the event is a subagent (child-session) event: the bound
+ *      thread whose `sessionId` is the nearest ancestor up the lineage chain
+ *      owns it.
+ *
+ * Determinism on collision: if two threads claim the same `sessionId` (the
+ * corruption case the prevention layer guards against), the first in iteration
+ * order wins — exactly one owner, never two.
+ *
+ * @returns the owning thread's `keyStr`, or `null` if no bound thread owns it.
+ */
+export declare function getEventOwnerKey(eventSessionId: string, boundSessions: readonly BoundSessionRef[], childToParent: ReadonlyMap<string, string>): string | null;
+/**
+ * @description Decide whether a "drop" diagnostic for `(eventType,
+ * eventSessionId)` should be logged now, throttled to once per `throttleMs`.
+ * An orphaned session streams hundreds of deltas; logging each (× each bound
+ * thread) floods the diag log (B19). Mutates `lastLoggedAtByKey` to record the
+ * log time, evicting the oldest entry past `maxEntries` so the map stays
+ * bounded. Pure-ish (single mutation of the passed map) so the throttle is
+ * unit-testable without any I/O.
+ *
+ * @returns `true` if this drop is the first in its window (caller should log).
+ */
+export declare function checkShouldLogDrop(lastLoggedAtByKey: Map<string, number>, eventType: string, eventSessionId: string, now: number, throttleMs: number, maxEntries: number): boolean;
+/**
+ * @description Number of lineage hops from `eventSessionId` up to
+ * `ancestorSessionId`, or `null` if the ancestor is not on the chain. A
+ * visited-set guards against a corrupt cyclic chain. Returns `null` (not 0) for
+ * an equal id — a *direct* match is handled separately in `getEventOwnerKey` so
+ * it always wins over descent. Exported (besides the routing internals) for the
+ * adapter's busy tracking, which must verify a STRICT descendant before
+ * recording a busy child — a dir-fallback-routed foreign sibling must never
+ * count.
+ */
+export declare function getLineageDepthToAncestor(eventSessionId: string, ancestorSessionId: string, childToParent: ReadonlyMap<string, string>): number | null;
+/**
+ * Record a child→parent session link learned from an event that exposes both
+ * ids, keeping the map bounded (oldest insertion evicted past `maxEntries`).
+ *
+ * Originally fed only by `session.updated`, but a child's lineage must be known
+ * BEFORE that beat or its earliest events drop "no owner" — so the adapter now
+ * records from ANY event whose properties expose `parentID` (S2 lineage
+ * durability), not just `session.updated`.
+ *
+ * Returns `true` only when a genuinely new or changed link was stored, so the
+ * caller can emit a diagnostic line for exactly the links worth knowing about.
+ * Ignores root sessions (no `parentID`) and any non-`ses_` id.
+ */
+export declare function updateSessionLineage(childToParent: Map<string, string>, childSessionId: string | undefined, parentSessionId: string | undefined, maxEntries: number): boolean;
+/**
+ * @description Mark every lineage hop walked to route `eventSessionId` to one of
+ * its bound ancestors as MOST-recently-used, so an actively-routing child is
+ * never the eviction victim.
+ *
+ * Why this exists: the lineage map is bounded by `maxEntries` and evicts the
+ * OLDEST INSERTION first (a Map preserves insertion order). A long-lived
+ * subagent that keeps streaming but never re-emits its `parentID` would, after
+ * `maxEntries` newer links land, be evicted mid-turn and its remaining events
+ * would drop "no owner" (the ~9 min gap proven live for a child).
+ * Re-inserting a USED link (delete + set — a plain `set` on an existing key does
+ * NOT reorder a JS Map) moves it to the tail, so the entries doing real routing
+ * work are evicted LAST. The cap is untouched; only the victim choice changes
+ * from "oldest inserted" to "oldest unused".
+ *
+ * Walks the same chain as {@link getLineageDepthToAncestor} (visited-set guards
+ * a corrupt cycle) and touches each link UP TO `ancestorSessionId` inclusive.
+ */
+export declare function touchLineageOnUse(childToParent: Map<string, string>, eventSessionId: string, ancestorSessionId: string): void;
+/**
+ * @description Resolve an event's owner by DIRECTORY when id/lineage resolution
+ * has already failed — the SSE-routing fallback. On the single `/global/event`
+ * stream every session event is tagged with its owning folder, so an event
+ * provably belongs to one of the threads bound to THAT folder, even when the
+ * per-session lineage map briefly disagrees (the child's `parentID` link was
+ * evicted or not yet recorded). Pure: the caller passes the directory's ACTIVE
+ * bound sessions, so it is unit-testable without a live server.
+ *
+ * Decision rule (never guess a topic — a wrong topic is worse than a logged
+ * drop):
+ *   - exactly ONE active session in the directory → it owns the event;
+ *   - more than one → disambiguate ONLY via in-memory lineage: route to the one
+ *     active session that is a lineage ancestor of `eventSessionId`. If zero or
+ *     several active sessions are ancestors → ambiguous → `null`;
+ *   - zero active sessions → `null`.
+ *
+ * @returns the owning thread's `keyStr`, or `null` when it cannot be resolved
+ *   unambiguously (the caller then loud-drops).
+ */
+export declare function resolveOwnerByDirectoryFallback(eventSessionId: string, directoryActiveSessions: readonly BoundSessionRef[], childToParent: ReadonlyMap<string, string>): string | null;
+//# sourceMappingURL=openCodeSessionRouting.d.ts.map

package/dist/openCodeSessionRouting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openCodeSessionRouting.d.ts","sourceRoot":"","sources":["../src/openCodeSessionRouting.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CACpC,cAAc,EAAE,MAAM,EACtB,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACzC,OAAO,CAiBT;AAED;0EAC0E;AAC1E,eAAO,MAAM,uBAAuB,SAAS,CAAC;AAE9C,gFAAgF;AAChF,MAAM,WAAW,eAAe;IAC9B,yDAAyD;IACzD,MAAM,EAAE,MAAM,CAAC;IACf,sEAAsE;IACtE,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,gBAAgB,CAC9B,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,SAAS,eAAe,EAAE,EACzC,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACzC,MAAM,GAAG,IAAI,CAoBf;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EACtC,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,EACtB,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,OAAO,CAWT;AAED;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,MAAM,EACtB,iBAAiB,EAAE,MAAM,EACzB,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACzC,MAAM,GAAG,IAAI,CAmBf;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAClC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAClC,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,UAAU,EAAE,MAAM,GACjB,OAAO,CAoBT;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAC/B,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAClC,cAAc,EAAE,MAAM,EACtB,iBAAiB,EAAE,MAAM,GACxB,IAAI,CAiBN;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,+BAA+B,CAC7C,cAAc,EAAE,MAAM,EACtB,uBAAuB,EAAE,SAAS,eAAe,EAAE,EACnD,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACzC,MAAM,GAAG,IAAI,CAef"}

package/dist/openCodeSessionRouting.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openCodeSessionIdPrefix = void 0;
+exports.checkIsEventForSession = checkIsEventForSession;
+exports.getEventOwnerKey = getEventOwnerKey;
+exports.checkShouldLogDrop = checkShouldLogDrop;
+exports.getLineageDepthToAncestor = getLineageDepthToAncestor;
+exports.updateSessionLineage = updateSessionLineage;
+exports.touchLineageOnUse = touchLineageOnUse;
+exports.resolveOwnerByDirectoryFallback = resolveOwnerByDirectoryFallback;
+/**
+ * Decide whether an incoming OpenCode SSE event belongs to a thread's bound
+ * session — directly, or because the event's session is a SUBAGENT child of
+ * it.
+ *
+ * OpenCode runs subagents (e.g. `@explore` / Task) in CHILD sessions whose
+ * `parentID` points at the originating session. Their events (deltas,
+ * `session.idle`, …) carry the CHILD sessionID, not the parent's. The bot
+ * binds the parent session to a topic, so a child event must be matched by
+ * walking up the lineage chain to the bound session — otherwise subagent
+ * output is dropped and the topic hangs on the ⏳ loader forever.
+ *
+ * The visited-set guards against cyclic lineage so a corrupt chain can never
+ * spin.
+ */
+function checkIsEventForSession(eventSessionId, ownedSessionId, childToParent) {
+    if (eventSessionId === ownedSessionId)
+        return true;
+    const visitedSessionIds = new Set();
+    let currentSessionId = eventSessionId;
+    while (!visitedSessionIds.has(currentSessionId)) {
+        visitedSessionIds.add(currentSessionId);
+        const parentSessionId = childToParent.get(currentSessionId);
+        if (parentSessionId === undefined)
+            return false;
+        if (parentSessionId === ownedSessionId)
+            return true;
+        currentSessionId = parentSessionId;
+    }
+    return false;
+}
+/** Prefix shared by every OpenCode session id (`ses_…`). Used to reject
+ * non-session ids (e.g. a `msg_…` id) before recording a lineage link. */
+exports.openCodeSessionIdPrefix = 'ses_';
+/**
+ * @description Resolve the SINGLE bound thread that owns an incoming SSE event,
+ * so an event is delivered to at most one topic (single-owner delivery).
+ *
+ * Even on the single global stream (every instance's events multiplexed on
+ * one `/global/event`), the same event reaches the dispatcher once and may match
+ * more than one bound thread: a false lineage link OR a duplicated session id
+ * (two threads
+ * accidentally bound to the same server session) would make the event match —
+ * and emit to — more than one topic (bug B20: the same answer appeared in two
+ * threads). The single-owner rule picks exactly one.
+ *
+ * Ownership priority:
+ *   1. A thread whose own `sessionId` directly equals `eventSessionId` is the
+ *      canonical owner. Direct ownership always beats lineage descent — a
+ *      session that IS bound to a thread can never be a routing *descendant* of
+ *      another thread, so a real (parent) session is never stolen by a topic
+ *      that merely has it in its lineage chain.
+ *   2. Otherwise the event is a subagent (child-session) event: the bound
+ *      thread whose `sessionId` is the nearest ancestor up the lineage chain
+ *      owns it.
+ *
+ * Determinism on collision: if two threads claim the same `sessionId` (the
+ * corruption case the prevention layer guards against), the first in iteration
+ * order wins — exactly one owner, never two.
+ *
+ * @returns the owning thread's `keyStr`, or `null` if no bound thread owns it.
+ */
+function getEventOwnerKey(eventSessionId, boundSessions, childToParent) {
+    // 1. Direct id match is canonical — a bound session is never a mere descendant.
+    for (const bound of boundSessions) {
+        if (bound.sessionId === eventSessionId)
+            return bound.keyStr;
+    }
+    // 2. Subagent event: find the bound thread reachable up the lineage chain.
+    //    Walk once, recording the depth at which each bound session is reached,
+    //    and pick the nearest (smallest depth) so a child routes to its closest
+    //    bound ancestor rather than a higher one.
+    let nearestOwnerKey = null;
+    let nearestDepth = Number.POSITIVE_INFINITY;
+    for (const bound of boundSessions) {
+        const depth = getLineageDepthToAncestor(eventSessionId, bound.sessionId, childToParent);
+        if (depth !== null && depth < nearestDepth) {
+            nearestDepth = depth;
+            nearestOwnerKey = bound.keyStr;
+        }
+    }
+    return nearestOwnerKey;
+}
+/**
+ * @description Decide whether a "drop" diagnostic for `(eventType,
+ * eventSessionId)` should be logged now, throttled to once per `throttleMs`.
+ * An orphaned session streams hundreds of deltas; logging each (× each bound
+ * thread) floods the diag log (B19). Mutates `lastLoggedAtByKey` to record the
+ * log time, evicting the oldest entry past `maxEntries` so the map stays
+ * bounded. Pure-ish (single mutation of the passed map) so the throttle is
+ * unit-testable without any I/O.
+ *
+ * @returns `true` if this drop is the first in its window (caller should log).
+ */
+function checkShouldLogDrop(lastLoggedAtByKey, eventType, eventSessionId, now, throttleMs, maxEntries) {
+    const throttleKey = `${eventType}|${eventSessionId}`;
+    const lastLoggedAt = lastLoggedAtByKey.get(throttleKey);
+    if (lastLoggedAt !== undefined && now - lastLoggedAt < throttleMs)
+        return false;
+    lastLoggedAtByKey.set(throttleKey, now);
+    if (lastLoggedAtByKey.size > maxEntries) {
+        const oldestKey = lastLoggedAtByKey.keys().next().value;
+        if (oldestKey !== undefined)
+            lastLoggedAtByKey.delete(oldestKey);
+    }
+    return true;
+}
+/**
+ * @description Number of lineage hops from `eventSessionId` up to
+ * `ancestorSessionId`, or `null` if the ancestor is not on the chain. A
+ * visited-set guards against a corrupt cyclic chain. Returns `null` (not 0) for
+ * an equal id — a *direct* match is handled separately in `getEventOwnerKey` so
+ * it always wins over descent. Exported (besides the routing internals) for the
+ * adapter's busy tracking, which must verify a STRICT descendant before
+ * recording a busy child — a dir-fallback-routed foreign sibling must never
+ * count.
+ */
+function getLineageDepthToAncestor(eventSessionId, ancestorSessionId, childToParent) {
+    if (eventSessionId === ancestorSessionId)
+        return null;
+    const visitedSessionIds = new Set();
+    let currentSessionId = eventSessionId;
+    let depth = 0;
+    while (!visitedSessionIds.has(currentSessionId)) {
+        visitedSessionIds.add(currentSessionId);
+        const parentSessionId = childToParent.get(currentSessionId);
+        if (parentSessionId === undefined)
+            return null;
+        depth += 1;
+        if (parentSessionId === ancestorSessionId)
+            return depth;
+        currentSessionId = parentSessionId;
+    }
+    return null;
+}
+/**
+ * Record a child→parent session link learned from an event that exposes both
+ * ids, keeping the map bounded (oldest insertion evicted past `maxEntries`).
+ *
+ * Originally fed only by `session.updated`, but a child's lineage must be known
+ * BEFORE that beat or its earliest events drop "no owner" — so the adapter now
+ * records from ANY event whose properties expose `parentID` (S2 lineage
+ * durability), not just `session.updated`.
+ *
+ * Returns `true` only when a genuinely new or changed link was stored, so the
+ * caller can emit a diagnostic line for exactly the links worth knowing about.
+ * Ignores root sessions (no `parentID`) and any non-`ses_` id.
+ */
+function updateSessionLineage(childToParent, childSessionId, parentSessionId, maxEntries) {
+    if (typeof childSessionId !== 'string' ||
+        typeof parentSessionId !== 'string' ||
+        !childSessionId.startsWith(exports.openCodeSessionIdPrefix) ||
+        !parentSessionId.startsWith(exports.openCodeSessionIdPrefix)) {
+        return false;
+    }
+    // A session can never be its own parent — a self-link would make the lineage
+    // walk treat the session as its own ancestor and corrupt single-owner routing.
+    if (childSessionId === parentSessionId)
+        return false;
+    if (childToParent.get(childSessionId) === parentSessionId)
+        return false;
+    childToParent.set(childSessionId, parentSessionId);
+    if (childToParent.size > maxEntries) {
+        const oldestSessionId = childToParent.keys().next().value;
+        if (oldestSessionId !== undefined)
+            childToParent.delete(oldestSessionId);
+    }
+    return true;
+}
+/**
+ * @description Mark every lineage hop walked to route `eventSessionId` to one of
+ * its bound ancestors as MOST-recently-used, so an actively-routing child is
+ * never the eviction victim.
+ *
+ * Why this exists: the lineage map is bounded by `maxEntries` and evicts the
+ * OLDEST INSERTION first (a Map preserves insertion order). A long-lived
+ * subagent that keeps streaming but never re-emits its `parentID` would, after
+ * `maxEntries` newer links land, be evicted mid-turn and its remaining events
+ * would drop "no owner" (the ~9 min gap proven live for a child).
+ * Re-inserting a USED link (delete + set — a plain `set` on an existing key does
+ * NOT reorder a JS Map) moves it to the tail, so the entries doing real routing
+ * work are evicted LAST. The cap is untouched; only the victim choice changes
+ * from "oldest inserted" to "oldest unused".
+ *
+ * Walks the same chain as {@link getLineageDepthToAncestor} (visited-set guards
+ * a corrupt cycle) and touches each link UP TO `ancestorSessionId` inclusive.
+ */
+function touchLineageOnUse(childToParent, eventSessionId, ancestorSessionId) {
+    const visitedSessionIds = new Set();
+    let currentSessionId = eventSessionId;
+    while (!visitedSessionIds.has(currentSessionId)) {
+        visitedSessionIds.add(currentSessionId);
+        const parentSessionId = childToParent.get(currentSessionId);
+        if (parentSessionId === undefined)
+            return;
+        // Re-insert to move this link to the tail (most-recently-used).
+        childToParent.delete(currentSessionId);
+        childToParent.set(currentSessionId, parentSessionId);
+        if (parentSessionId === ancestorSessionId)
+            return;
+        currentSessionId = parentSessionId;
+    }
+}
+/**
+ * @description Resolve an event's owner by DIRECTORY when id/lineage resolution
+ * has already failed — the SSE-routing fallback. On the single `/global/event`
+ * stream every session event is tagged with its owning folder, so an event
+ * provably belongs to one of the threads bound to THAT folder, even when the
+ * per-session lineage map briefly disagrees (the child's `parentID` link was
+ * evicted or not yet recorded). Pure: the caller passes the directory's ACTIVE
+ * bound sessions, so it is unit-testable without a live server.
+ *
+ * Decision rule (never guess a topic — a wrong topic is worse than a logged
+ * drop):
+ *   - exactly ONE active session in the directory → it owns the event;
+ *   - more than one → disambiguate ONLY via in-memory lineage: route to the one
+ *     active session that is a lineage ancestor of `eventSessionId`. If zero or
+ *     several active sessions are ancestors → ambiguous → `null`;
+ *   - zero active sessions → `null`.
+ *
+ * @returns the owning thread's `keyStr`, or `null` when it cannot be resolved
+ *   unambiguously (the caller then loud-drops).
+ */
+function resolveOwnerByDirectoryFallback(eventSessionId, directoryActiveSessions, childToParent) {
+    if (directoryActiveSessions.length === 0)
+        return null;
+    if (directoryActiveSessions.length === 1)
+        return directoryActiveSessions[0].keyStr;
+    // >1 active in the same folder (two topics on one project): only route when
+    // exactly one of them is a genuine lineage ancestor of the event's session.
+    let ancestorOwnerKey = null;
+    for (const bound of directoryActiveSessions) {
+        if (bound.sessionId === eventSessionId)
+            return bound.keyStr;
+        if (getLineageDepthToAncestor(eventSessionId, bound.sessionId, childToParent) !== null) {
+            if (ancestorOwnerKey !== null)
+                return null; // two ancestors → ambiguous
+            ancestorOwnerKey = bound.keyStr;
+        }
+    }
+    return ancestorOwnerKey;
+}
+//# sourceMappingURL=openCodeSessionRouting.js.map

package/dist/openCodeSessionRouting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openCodeSessionRouting.js","sourceRoot":"","sources":["../src/openCodeSessionRouting.ts"],"names":[],"mappings":"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"}

package/dist/openCodeSessionTitle.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Pure helpers for naming bot-created OpenCode sessions.
+ *
+ * Primary mechanism (R1, verified live 2026-06-04): a session created WITHOUT
+ * an explicit `title` lets opencode auto-name it from the first prompt's LLM
+ * turn — nicer than any raw snippet, and it ignores the glued thread-context
+ * preamble. A session created WITH a title is treated as user-set and never
+ * auto-renamed, so the bot only passes a title for the explicit `/opencode
+ * <args>` case.
+ *
+ * Fallback mechanism: if auto-title never lands (the title stays the bare
+ * `New session - <ts>` placeholder — e.g. the server failed to generate one),
+ * the adapter renames the session itself via `PATCH /session/:id {title}` on
+ * the first MEANINGFUL prompt, using {@link buildSessionTitleSnippet}. The
+ * snippet always derives from the RAW user text (the caller strips the
+ * preamble first), so it can never carry the service header.
+ */
+/**
+ * Minimum length (chars, after trim) for a prompt to count as "meaningful"
+ * enough to name a session after. Short acknowledgements ("да", "go", "ok")
+ * sit below it and leave the name to be decided by a later, substantial
+ * prompt. 10 is the locked value from the plan's IDEAL.
+ */
+export declare const meaningfulPromptMinLength = 10;
+/** Max length (chars) of a fallback snippet title; longer text is truncated. */
+export declare const sessionTitleSnippetMaxLength = 60;
+/**
+ * @description Whether a forwarded prompt is substantial enough to name a
+ * session after. A slash command (`/clear`, `/model …`) is a control token,
+ * never a name source; anything shorter than {@link meaningfulPromptMinLength}
+ * is a throwaway acknowledgement. The argument MUST be the RAW user text —
+ * strip the thread-context preamble before calling (see
+ * {@link buildSessionTitleSnippet} for the same requirement).
+ */
+export declare function checkIsMeaningfulPrompt(rawText: string): boolean;
+/**
+ * @description Build a fallback session-title snippet from the first
+ * meaningful prompt. Collapses all internal whitespace (incl. newlines) to
+ * single spaces, trims, and truncates to {@link sessionTitleSnippetMaxLength}
+ * with an ellipsis. The thread-context preamble is stripped first so the title
+ * reflects what the USER said, never the bot's glue.
+ */
+export declare function buildSessionTitleSnippet(rawText: string): string;
+/**
+ * @description Whether `title` is one of opencode's "no real name yet"
+ * placeholders, so the fallback rename is allowed to overwrite it. A real
+ * auto-generated or user-set title returns `false` and is left untouched.
+ */
+export declare function checkIsPlaceholderTitle(title: string | undefined): boolean;
+//# sourceMappingURL=openCodeSessionTitle.d.ts.map

package/dist/openCodeSessionTitle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openCodeSessionTitle.d.ts","sourceRoot":"","sources":["../src/openCodeSessionTitle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAE5C,gFAAgF;AAChF,eAAO,MAAM,4BAA4B,KAAK,CAAC;AAe/C;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAIhE;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAMhE;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAG1E"}