@kortix/sdk 0.12.7 → 0.13.0

package/dist/core/session/working.d.ts

@@ -0,0 +1,241 @@
+import type { SessionPrompt, SessionTurn, SessionTurnEnded } from '../rest/projects-client/sessions.js';
+/**
+ * WHICH observation decided the state.
+ *
+ * `server` — `GET .../turn`, the control plane's lifecycle authority, or the
+ * session's durable prompt inbox. Both are rows the server owns.
+ * `stream` — a `session.status` / `session.idle` frame off the live SSE stream.
+ * `optimistic` — this tab's own send receipt, which no server source has
+ * answered yet.
+ *
+ * Provenance is part of the answer because the failure this replaces was a
+ * projection nobody could attribute: three machines wrote "busy" into one
+ * slot — a stall timer, a 30s safety timeout, a status latch — and when the
+ * session stayed busy forever, no one could say which of them was lying.
+ */
+export type WorkingSource = 'server' | 'stream' | 'optimistic';
+export interface WorkingProjection {
+    state: 'idle' | 'working';
+    /** WHICH observation decided this. Never inferred, never fabricated. */
+    source: WorkingSource;
+    /** The wire message id (server) or the optimistic receipt id. */
+    turnId: string | null;
+    /** ms epoch at which THIS state began, from the deciding observation. */
+    since: number;
+    /**
+     * The `turn_token` of the turn the control plane is holding open in the
+     * freshest read we have, EVEN WHEN something newer outranked it above.
+     *
+     * `state` is the answer; this is the raw fact behind one of its inputs, and
+     * the two are deliberately separable. A caller that must not act while the
+     * server still holds authority — a `/` command, which goes straight at
+     * OpenCode with no admission gate in front of it — needs to see that
+     * authority even in the window where a fresher status frame is (correctly)
+     * deciding `idle`. `null` when no fresh read reports one, so a read too old
+     * to decide cannot latch it.
+     *
+     * The TOKEN, never `message_id`. `message_id` is the WIRE id of the prompt
+     * that opened the turn, and most producers send none: `postPrompt` omits
+     * `messageID` for triggers, Slack/Teams/Telegram, approval-resume and email,
+     * and `buildSessionCommandInput` omits it for every `/` command. `GET
+     * .../turn` answers `message_id: null` for all of them (the field is
+     * `z.string().nullable()`), so an authority check keyed on it read "the
+     * server holds nothing" over turns that were streaming. `turn_token` is
+     * minted by the control plane for every turn and is never null.
+     */
+    serverOpenTurnToken: string | null;
+}
+/**
+ * How long an unanswered optimistic receipt may claim `working` on its own.
+ *
+ * Bounded because a send whose response never arrives must not latch the UI —
+ * the failure this whole phase exists to end. Released the moment a server
+ * source that CAN know about the send answers; the cap only covers the case
+ * where none ever does.
+ */
+export declare const OPTIMISTIC_RECEIPT_MAX_MS = 60000;
+/**
+ * How long a server observation keeps deciding anything.
+ *
+ * `useSessionWorking` polls `GET .../turn` every 5s while working and every
+ * 15s while idle, and react-query hands back the last SUCCESSFUL read for as
+ * long as the ones after it fail. Without this bound, one successful read of an
+ * open turn followed by a dev-api 503, an expired JWT, or a closed laptop lid
+ * pinned the composer on "working" for the lifetime of the tab — literally the
+ * reported bug. Three idle cadences is long enough that an ordinary retry or a
+ * backgrounded tab never trips it, and short enough that a dead poll stops
+ * being believed.
+ */
+export declare const SERVER_OBSERVATION_MAX_MS = 45000;
+/**
+ * How long a status frame keeps deciding anything.
+ *
+ * The stream needs its own bound for the same reason the server read does, and
+ * the failure it covers is the SAME one: the SSE stream reaches this tab
+ * through the API that serves `/turn`, so when that API drains they stop
+ * together. The stream does not go `null` when it stops — the last `busy`
+ * frame this tab ever observed stays in the store — so bounding only the
+ * server read moved the latch one source over instead of ending it.
+ *
+ * Equal to the server bound on purpose: while the API answers at all, a fresh
+ * `/turn` read decides and this bound is never reached; once it stops
+ * answering, both observations are equally blind and neither may stand.
+ */
+export declare const STREAM_OBSERVATION_MAX_MS = 45000;
+/**
+ * How long ONE reading of the durable inbox keeps deciding.
+ *
+ * Three cadences of the prompt list's own poll (3s), not of `/turn`'s. A
+ * reading says "the server still intends to run N rows", and that claim decays
+ * fast: the row it counted may already have been delivered, run, and finished.
+ * Held for the server bound instead, a finished prompt left the composer on
+ * Stop with its reply on screen for up to 45s.
+ */
+export declare const INBOX_OBSERVATION_MAX_MS = 10000;
+/**
+ * How long a stop this tab issued may bar a server read from reporting the
+ * turn it is ending.
+ *
+ * Bounded for the same reason the send receipt is, in the other direction: an
+ * abort whose acknowledgement never comes must not pin the composer on `idle`
+ * over a turn that is genuinely still running. Generous next to the ~1.6s a
+ * cancel takes to reach the daemon, and far below the send receipt's cap
+ * because the evidence arrives sooner.
+ */
+export declare const OPTIMISTIC_ABORT_MAX_MS = 15000;
+/** This tab's own record that a prompt went out. */
+export interface SendReceipt {
+    /** The submission's tab-local name — never sent anywhere. It exists so a
+     *  `working` state can say WHICH send it is standing on. */
+    messageId: string;
+    /** ms epoch at which the send left this tab. */
+    atMs: number;
+    /**
+     * ms epoch at which the SERVER durably accepted the send (`POST .../prompts`
+     * returned, or the REST prompt was acknowledged), or null while the request
+     * is still on the wire.
+     *
+     * This is the instant from which a server read can speak for the send AT ALL.
+     * A `/turn` read issued while the POST is still in flight is stamped after
+     * the receipt and honestly answers "no turns" — because there is nothing for
+     * it to see yet. Believing it swapped the composer's Stop back to Send in the
+     * middle of the send and opened the queue drain into the turn about to start.
+     */
+    acceptedAtMs?: number | null;
+}
+/**
+ * This tab's own record that it asked the running turn to END.
+ *
+ * The mirror of `SendReceipt`, and it exists for the mirror-image failure. Stop
+ * paints the session idle and issues the cancel; the cancel needs a round trip
+ * through the control plane and the daemon (~1.6s measured) before the turn
+ * authority is actually released. Every `/turn` read issued inside that window
+ * still reports the doomed turn — including the one the optimistic idle FRAME
+ * itself triggers — so the composer swapped Send back to Stop about 120ms
+ * after the click and stayed there for the whole abort.
+ */
+export interface AbortReceipt {
+    /** ms epoch at which the cancel left this tab. */
+    atMs: number;
+    /**
+     * ms epoch at which the server acknowledged the cancel, or null while it is
+     * still on the wire.
+     *
+     * This is the instant from which a server read can see the abort's EFFECT.
+     * A read issued before it is honest and out of date, exactly like a `/turn`
+     * read issued before `POST .../prompts` returns.
+     */
+    settledAtMs?: number | null;
+}
+/** One read of `GET .../turn`, stamped with the instant the read was ISSUED —
+ *  not when it landed. An answer is only as fresh as the moment it was asked. */
+export interface WorkingServerInput {
+    turns: SessionTurn[];
+    lastEnded?: SessionTurnEnded;
+    atMs: number;
+}
+/** One observed runtime status frame, stamped when this tab observed it. */
+export interface WorkingStreamInput {
+    type: 'busy' | 'retry' | 'idle';
+    atMs: number;
+}
+/** One read of the session's durable prompt inbox: how many rows the server is
+ *  still going to run, and when that list was read. */
+export interface WorkingInboxInput {
+    pending: number;
+    atMs: number;
+}
+export interface WorkingInputs {
+    optimistic: SendReceipt | null;
+    /** This tab's pending stop. `null`/absent means it is not stopping. */
+    abort?: AbortReceipt | null;
+    /** The durable inbox. `null`/absent means it has never been read here. */
+    inbox?: WorkingInboxInput | null;
+    server: WorkingServerInput | null;
+    stream: WorkingStreamInput | null;
+    nowMs: number;
+}
+/**
+ * How many inbox rows are work the server still intends to run.
+ *
+ * `held` is excluded on purpose: it is the Stop button's own state — the row
+ * stays, deliberately not due, until the user sends something or presses "send
+ * now". Counting it would leave the composer on Stop with nothing running.
+ * `failed` is excluded for the same reason in the other direction: it is over.
+ */
+export declare function countLiveInboxPrompts(prompts: readonly SessionPrompt[]): number;
+/**
+ * The one place a session's working state is decided.
+ *
+ * Pure, so every rule below is asserted rather than observed by hand. No
+ * timers, no latch, no fabricated `SessionStatus` write — a caller that wants
+ * to re-evaluate simply calls again with a newer `nowMs`.
+ *
+ * Precedence:
+ *
+ *  1. The server is holding a turn open, and no NEWER stream frame contradicts
+ *     it → working. `GET .../turn` reads the lifecycle authority rather than the
+ *     ledger, so it is the strongest answer there is — but it is still a read
+ *     taken at an instant, and an SSE frame from after that instant knows more.
+ *  2. The server holds durable inbox rows for this session → working. A prompt
+ *     is accepted long before it is a turn: the row has to be drained, the box
+ *     may have to resume (18.9s Daytona / 24.5s Platinum, measured), and only
+ *     then does `beginSandboxTurn` run. "No turn is running" and "nothing of
+ *     yours is in flight" stopped being the same statement when the inbox
+ *     landed.
+ *  3. The server says no turns, and its read is at least as new as the stream's
+ *     last frame → idle. (A dropped end-of-turn frame is exactly why the server
+ *     has to be able to outrank a stale stream busy.)
+ *  4. The stream's own frame decides.
+ *  5. A live optimistic receipt → working.
+ *  6. Nothing observed → idle.
+ *
+ * With TWO cross-cutting freshness rules:
+ *
+ *  * An observation that could not yet know about a live LOCAL action cannot
+ *    answer for it — the send's floors (`SendReceipt.acceptedAtMs`) and the
+ *    stop's (`AbortReceipt.settledAtMs`), all built the same way.
+ *  * EVERY observation has a maximum age, and past it decides nothing at all in
+ *    either direction: `SERVER_OBSERVATION_MAX_MS`, `STREAM_OBSERVATION_MAX_MS`,
+ *    `INBOX_OBSERVATION_MAX_MS`. An observation the poll has failed to refresh
+ *    for that long is not evidence, and standing on one is the latch. Callers
+ *    must re-evaluate at those instants — see `workingExpiryAtMs`.
+ */
+export declare function projectWorking(inputs: WorkingInputs): WorkingProjection;
+/**
+ * The next instant at which `projectWorking` could answer differently on its
+ * own — i.e. when the OLDEST-lived input ages past its bound.
+ *
+ * The projection is pure and moves with `nowMs`, which means something has to
+ * ask it again at that instant or the bound is never applied. Nothing did: the
+ * hook re-renders when react-query hands it new `data`, and a run of failed
+ * reads hands back the SAME retained `data` — the observer does not even
+ * notify. `SERVER_OBSERVATION_MAX_MS` was therefore evaluated only on renders
+ * that happened for some unrelated reason, and in the exact outage it was
+ * written for (one success, then a run of 503s) there are none.
+ *
+ * `null` when nothing is left to expire. Deadlines already in the past are
+ * skipped, so re-arming from the timer this returns terminates.
+ */
+export declare function workingExpiryAtMs(inputs: WorkingInputs): number | null;
+//# sourceMappingURL=working.d.ts.map

package/dist/core/session/working.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"working.d.ts","sourceRoot":"","sources":["../../../src/core/session/working.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,WAAW,EACX,gBAAgB,EACjB,MAAM,kCAAkC,CAAC;AAE1C;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,QAAQ,GAAG,YAAY,CAAC;AAE/D,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,wEAAwE;IACxE,MAAM,EAAE,aAAa,CAAC;IACtB,iEAAiE;IACjE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,yEAAyE;IACzE,KAAK,EAAE,MAAM,CAAC;IACd;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAEhD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAEhD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAEhD;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,QAAS,CAAC;AAE/C;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,QAAS,CAAC;AAE9C,oDAAoD;AACpD,MAAM,WAAW,WAAW;IAC1B;gEAC4D;IAC5D,SAAS,EAAE,MAAM,CAAC;IAClB,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;;;;OAUG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,YAAY;IAC3B,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED;iFACiF;AACjF,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;CACd;AAED,4EAA4E;AAC5E,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;CACd;AAED;uDACuD;AACvD,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,WAAW,GAAG,IAAI,CAAC;IAC/B,uEAAuE;IACvE,KAAK,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IAC5B,0EAA0E;IAC1E,KAAK,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACjC,MAAM,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAClC,MAAM,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAClC,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,GAAG,MAAM,CAO/E;AASD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,aAAa,GAAG,iBAAiB,CAmHvE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,GAAG,IAAI,CAetE"}

package/dist/core/session/working.js

@@ -0,0 +1,261 @@
+/**
+ * How long an unanswered optimistic receipt may claim `working` on its own.
+ *
+ * Bounded because a send whose response never arrives must not latch the UI —
+ * the failure this whole phase exists to end. Released the moment a server
+ * source that CAN know about the send answers; the cap only covers the case
+ * where none ever does.
+ */
+export const OPTIMISTIC_RECEIPT_MAX_MS = 60_000;
+/**
+ * How long a server observation keeps deciding anything.
+ *
+ * `useSessionWorking` polls `GET .../turn` every 5s while working and every
+ * 15s while idle, and react-query hands back the last SUCCESSFUL read for as
+ * long as the ones after it fail. Without this bound, one successful read of an
+ * open turn followed by a dev-api 503, an expired JWT, or a closed laptop lid
+ * pinned the composer on "working" for the lifetime of the tab — literally the
+ * reported bug. Three idle cadences is long enough that an ordinary retry or a
+ * backgrounded tab never trips it, and short enough that a dead poll stops
+ * being believed.
+ */
+export const SERVER_OBSERVATION_MAX_MS = 45_000;
+/**
+ * How long a status frame keeps deciding anything.
+ *
+ * The stream needs its own bound for the same reason the server read does, and
+ * the failure it covers is the SAME one: the SSE stream reaches this tab
+ * through the API that serves `/turn`, so when that API drains they stop
+ * together. The stream does not go `null` when it stops — the last `busy`
+ * frame this tab ever observed stays in the store — so bounding only the
+ * server read moved the latch one source over instead of ending it.
+ *
+ * Equal to the server bound on purpose: while the API answers at all, a fresh
+ * `/turn` read decides and this bound is never reached; once it stops
+ * answering, both observations are equally blind and neither may stand.
+ */
+export const STREAM_OBSERVATION_MAX_MS = 45_000;
+/**
+ * How long ONE reading of the durable inbox keeps deciding.
+ *
+ * Three cadences of the prompt list's own poll (3s), not of `/turn`'s. A
+ * reading says "the server still intends to run N rows", and that claim decays
+ * fast: the row it counted may already have been delivered, run, and finished.
+ * Held for the server bound instead, a finished prompt left the composer on
+ * Stop with its reply on screen for up to 45s.
+ */
+export const INBOX_OBSERVATION_MAX_MS = 10_000;
+/**
+ * How long a stop this tab issued may bar a server read from reporting the
+ * turn it is ending.
+ *
+ * Bounded for the same reason the send receipt is, in the other direction: an
+ * abort whose acknowledgement never comes must not pin the composer on `idle`
+ * over a turn that is genuinely still running. Generous next to the ~1.6s a
+ * cancel takes to reach the daemon, and far below the send receipt's cap
+ * because the evidence arrives sooner.
+ */
+export const OPTIMISTIC_ABORT_MAX_MS = 15_000;
+/**
+ * How many inbox rows are work the server still intends to run.
+ *
+ * `held` is excluded on purpose: it is the Stop button's own state — the row
+ * stays, deliberately not due, until the user sends something or presses "send
+ * now". Counting it would leave the composer on Stop with nothing running.
+ * `failed` is excluded for the same reason in the other direction: it is over.
+ */
+export function countLiveInboxPrompts(prompts) {
+    let live = 0;
+    for (const prompt of prompts) {
+        if (prompt.state === 'queued' || prompt.state === 'delivering')
+            live += 1;
+        else if (prompt.state === 'waiting' && prompt.reason !== 'held')
+            live += 1;
+    }
+    return live;
+}
+/** ms epoch, or null for an absent/unparseable instant. */
+function instant(value) {
+    if (!value)
+        return null;
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? null : parsed;
+}
+/**
+ * The one place a session's working state is decided.
+ *
+ * Pure, so every rule below is asserted rather than observed by hand. No
+ * timers, no latch, no fabricated `SessionStatus` write — a caller that wants
+ * to re-evaluate simply calls again with a newer `nowMs`.
+ *
+ * Precedence:
+ *
+ *  1. The server is holding a turn open, and no NEWER stream frame contradicts
+ *     it → working. `GET .../turn` reads the lifecycle authority rather than the
+ *     ledger, so it is the strongest answer there is — but it is still a read
+ *     taken at an instant, and an SSE frame from after that instant knows more.
+ *  2. The server holds durable inbox rows for this session → working. A prompt
+ *     is accepted long before it is a turn: the row has to be drained, the box
+ *     may have to resume (18.9s Daytona / 24.5s Platinum, measured), and only
+ *     then does `beginSandboxTurn` run. "No turn is running" and "nothing of
+ *     yours is in flight" stopped being the same statement when the inbox
+ *     landed.
+ *  3. The server says no turns, and its read is at least as new as the stream's
+ *     last frame → idle. (A dropped end-of-turn frame is exactly why the server
+ *     has to be able to outrank a stale stream busy.)
+ *  4. The stream's own frame decides.
+ *  5. A live optimistic receipt → working.
+ *  6. Nothing observed → idle.
+ *
+ * With TWO cross-cutting freshness rules:
+ *
+ *  * An observation that could not yet know about a live LOCAL action cannot
+ *    answer for it — the send's floors (`SendReceipt.acceptedAtMs`) and the
+ *    stop's (`AbortReceipt.settledAtMs`), all built the same way.
+ *  * EVERY observation has a maximum age, and past it decides nothing at all in
+ *    either direction: `SERVER_OBSERVATION_MAX_MS`, `STREAM_OBSERVATION_MAX_MS`,
+ *    `INBOX_OBSERVATION_MAX_MS`. An observation the poll has failed to refresh
+ *    for that long is not evidence, and standing on one is the latch. Callers
+ *    must re-evaluate at those instants — see `workingExpiryAtMs`.
+ */
+export function projectWorking(inputs) {
+    const { optimistic, abort, inbox, server, stream, nowMs } = inputs;
+    const receiptLive = !!optimistic && nowMs - optimistic.atMs < OPTIMISTIC_RECEIPT_MAX_MS;
+    // TWO floors, because the two server-side observers have different knowledge.
+    //
+    // `GET .../turn` reads the control plane's ledger, and there is NO row in it
+    // until `POST .../prompts` returns. A read issued in that window is stamped
+    // after the receipt and still provably cannot see the send, so it may not
+    // answer for it at all — hence the infinity while `acceptedAtMs` is null.
+    //
+    // The SSE stream is the RUNTIME's own voice, and the store stamps a frame
+    // when this tab observed it — which only moves when the frame itself changes.
+    // So a frame stamped after the send is a NEW transition, not a stale reading,
+    // and it is the freshest thing there is. Blocking it too would leave a
+    // command's receipt (nothing ever "accepts" a command) claiming `working` for
+    // a full minute after its turn had visibly ended.
+    const serverFloor = receiptLive
+        ? (optimistic.acceptedAtMs ?? Number.POSITIVE_INFINITY)
+        : Number.NEGATIVE_INFINITY;
+    const streamFloor = receiptLive ? optimistic.atMs : Number.NEGATIVE_INFINITY;
+    // The stop's floor, built exactly like the send's. A `/turn` read issued
+    // before the cancel was ACKNOWLEDGED still reports the turn the cancel is
+    // ending, so it may not report `working` from it — the read is honest and
+    // out of date. Infinite while the acknowledgement is outstanding, and gone
+    // entirely once the receipt ages out, so a cancel nobody answers cannot pin
+    // the composer on idle over a turn that is really still running.
+    const abortLive = !!abort && nowMs - abort.atMs < OPTIMISTIC_ABORT_MAX_MS;
+    const abortFloor = abortLive
+        ? (abort.settledAtMs ?? Number.POSITIVE_INFINITY)
+        : Number.NEGATIVE_INFINITY;
+    const serverFresh = !!server && nowMs - server.atMs <= SERVER_OBSERVATION_MAX_MS;
+    const streamFresh = !!stream && nowMs - stream.atMs <= STREAM_OBSERVATION_MAX_MS;
+    const inboxFresh = !!inbox && nowMs - inbox.atMs <= INBOX_OBSERVATION_MAX_MS;
+    const openTurn = serverFresh ? server.turns[0] : undefined;
+    const serverOpenTurnToken = openTurn?.turn_token ?? null;
+    // A turn the authority is holding open, unless the stream has since said the
+    // session went idle. The stream frame is newer BY OBSERVATION, and the daemon
+    // relays `turn_end` to the control plane at the same moment the frame is
+    // emitted — so a fresher idle frame means this read is simply out of date.
+    if (openTurn && server.atMs >= abortFloor && (!stream || server.atMs >= stream.atMs)) {
+        return {
+            state: 'working',
+            source: 'server',
+            turnId: openTurn.message_id,
+            since: instant(openTurn.started_at) ?? server.atMs,
+            serverOpenTurnToken,
+        };
+    }
+    // Durable rows outrank an idle read: the read is right that no TURN is
+    // running and wrong that nothing is happening.
+    if (inboxFresh && inbox.pending > 0) {
+        return {
+            state: 'working',
+            source: 'server',
+            turnId: null,
+            since: inbox.atMs,
+            serverOpenTurnToken,
+        };
+    }
+    const serverAnswers = serverFresh && !openTurn && server.atMs >= serverFloor;
+    const streamAnswers = streamFresh && stream.atMs >= streamFloor;
+    if (serverAnswers && (!stream || server.atMs >= stream.atMs)) {
+        return {
+            state: 'idle',
+            source: 'server',
+            turnId: null,
+            since: instant(server.lastEnded?.ended_at) ?? server.atMs,
+            serverOpenTurnToken,
+        };
+    }
+    if (streamAnswers) {
+        return {
+            state: stream.type === 'idle' ? 'idle' : 'working',
+            source: 'stream',
+            turnId: null,
+            since: stream.atMs,
+            serverOpenTurnToken,
+        };
+    }
+    if (receiptLive) {
+        return {
+            state: 'working',
+            source: 'optimistic',
+            turnId: optimistic.messageId,
+            since: optimistic.atMs,
+            serverOpenTurnToken,
+        };
+    }
+    // Nothing has answered. Idle is the only honest default: a session is not
+    // working because a page failed to ask.
+    const newest = server && stream
+        ? server.atMs >= stream.atMs
+            ? { source: 'server', atMs: server.atMs }
+            : { source: 'stream', atMs: stream.atMs }
+        : server
+            ? { source: 'server', atMs: server.atMs }
+            : stream
+                ? { source: 'stream', atMs: stream.atMs }
+                : { source: 'server', atMs: nowMs };
+    return {
+        state: 'idle',
+        source: newest.source,
+        turnId: null,
+        since: newest.atMs,
+        serverOpenTurnToken,
+    };
+}
+/**
+ * The next instant at which `projectWorking` could answer differently on its
+ * own — i.e. when the OLDEST-lived input ages past its bound.
+ *
+ * The projection is pure and moves with `nowMs`, which means something has to
+ * ask it again at that instant or the bound is never applied. Nothing did: the
+ * hook re-renders when react-query hands it new `data`, and a run of failed
+ * reads hands back the SAME retained `data` — the observer does not even
+ * notify. `SERVER_OBSERVATION_MAX_MS` was therefore evaluated only on renders
+ * that happened for some unrelated reason, and in the exact outage it was
+ * written for (one success, then a run of 503s) there are none.
+ *
+ * `null` when nothing is left to expire. Deadlines already in the past are
+ * skipped, so re-arming from the timer this returns terminates.
+ */
+export function workingExpiryAtMs(inputs) {
+    const { optimistic, abort, inbox, server, stream, nowMs } = inputs;
+    const deadlines = [
+        optimistic ? optimistic.atMs + OPTIMISTIC_RECEIPT_MAX_MS : null,
+        abort ? abort.atMs + OPTIMISTIC_ABORT_MAX_MS : null,
+        inbox ? inbox.atMs + INBOX_OBSERVATION_MAX_MS : null,
+        server ? server.atMs + SERVER_OBSERVATION_MAX_MS : null,
+        stream ? stream.atMs + STREAM_OBSERVATION_MAX_MS : null,
+    ];
+    let next = null;
+    for (const deadline of deadlines) {
+        if (deadline === null || deadline <= nowMs)
+            continue;
+        if (next === null || deadline < next)
+            next = deadline;
+    }
+    return next;
+}
+//# sourceMappingURL=working.js.map

package/dist/core/session/working.js.map

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

package/dist/core/session-sync/session-sync-controller.d.ts

@@ -19,12 +19,22 @@ export interface SessionSyncPage {
     messages: SessionSyncMessage[];
     nextCursor?: string;
 }
+/**
+ * Transcript state, and nothing else.
+ *
+ * This snapshot used to carry `isPromptObservedBusy` — a busy OPINION inferred
+ * from silence by a phase machine with a stall timer, a retry budget and an
+ * epoch counter. It was one of four disagreeing answers to "is this session
+ * working?", and the one that latched: every signal that could release it
+ * (`session.idle`, a status frame, the poll) can be lost, and losing them left
+ * the composer pinned on "stop" until the user reloaded. The answer now comes
+ * from `projectWorking` over the server's own turn authority
+ * (`core/session/working.ts`), so this controller holds no opinion about it.
+ */
 export interface SessionSyncSnapshot {
     freshness: SessionSyncFreshness;
     hasOlder: boolean;
     isLoadingOlder: boolean;
-    /** True while an accepted REST prompt has not reached stable runtime idle. */
-    isPromptObservedBusy?: boolean;
 }
 export interface SessionSyncScheduler {
     now: () => number;
@@ -47,9 +57,23 @@ export interface SessionSyncControllerOptions {
         limit: number;
         before?: string;
     }) => Promise<SessionSyncPage>;
+    /**
+     * @deprecated Never called. The liveness poll no longer reads status: `GET
+     * .../turn` is the status authority, and this controller's own `setBusy` is
+     * already driven FROM that projection, so a status read here could only
+     * confirm or latch — never correct. Retained (ignored) because 0.12.8
+     * published it on this options type; removed in the next major.
+     */
     loadStatus?: () => Promise<SessionStatus>;
     hydrate: (messages: SessionSyncMessage[]) => void;
     markLoaded: () => void;
+    /**
+     * @deprecated Never called. Writing a REST poll's answer into the slot SSE
+     * status frames land in made a poll indistinguishable from the runtime's own
+     * voice, and re-stamped the stream observation on every tick so its age
+     * bound was never reached. Retained (ignored) because 0.12.8 published it;
+     * removed in the next major.
+     */
     setStatus?: (status: SessionStatus) => void;
     onTelemetry?: (event: SessionSyncTelemetryEvent) => void;
     scheduler?: SessionSyncScheduler;
@@ -81,8 +105,6 @@ export declare class SessionSyncController {
     private tailRequest;
     private olderRequest;
     private livenessTimer;
-    private promptSettlementTimer;
-    private promptObservationPhase;
     private lastActivityAt;
     private listeners;
     private destroyed;
@@ -94,19 +116,13 @@ export declare class SessionSyncController {
     loadOlder: () => Promise<void>;
     noteActivity(): void;
     /**
-     * Start monotonic completion observation for an accepted REST prompt.
+     * Switch the liveness poll on or off.
      *
-     * OpenCode can publish an idle snapshot from before the prompt and publish
-     * the real busy event later. Keep the public projection busy until real work
-     * starts and the following idle state remains quiet.
+     * NOT an opinion about whether the session is working — that answer belongs
+     * to `projectWorking` alone. This only says whether anyone still needs the
+     * transcript refreshed behind the SSE stream: a caller passes the working
+     * state it already has, and the last consumer leaving passes `false`.
      */
-    beginPromptObservation(): void;
-    /** Observe an authoritative runtime status from SSE or status reconciliation. */
-    observePromptStatus(status: SessionStatus): void;
-    /** Mark assistant output as proof that the accepted prompt started. */
-    observePromptActivity(): void;
-    /** End observation after rejection, cancellation, or a terminal runtime error. */
-    endPromptObservation(): void;
     setBusy(isBusy: boolean): void;
     destroy(): void;
     private loadTail;
@@ -115,13 +131,12 @@ export declare class SessionSyncController {
     private loadCompleteTurn;
     private rememberUserMessages;
     private checkLiveness;
-    private containsNewPromptReply;
-    private reconcileStatus;
+    /** Resolve when `work` settles, or when `timeoutMs` elapses — whichever first. */
+    private raceDeadline;
     private setCursor;
     private stopLivenessTimer;
-    private markPromptRunning;
-    private schedulePromptSettlement;
-    private clearPromptSettlementTimer;
+    private startTimer;
+    private cancelTimer;
     private update;
 }
 export {};

package/dist/core/session-sync/session-sync-controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-sync-controller.d.ts","sourceRoot":"","sources":["../../../src/core/session-sync/session-sync-controller.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"session-sync-controller.d.ts","sourceRoot":"","sources":["../../../src/core/session-sync/session-sync-controller.ts"],"names":[],"mappings":"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"}