pi-legion 3.0.0 → 3.0.3

package/src/shared/session.ts

@@ -37,7 +37,17 @@ function emptyUsage(): Usage {
 
 /** Mutable clock used while folding events; not part of ParsedSession. */
 export interface GenerationClock {
+	/** Nested Unix-ms timestamp of the message that opened this generation window. */
 	awaitingSince?: number;
+	/**
+	 * Same window edge expressed as the enclosing entry's write instant.
+	 *
+	 * Sessions may carry only the nested timestamp, only the entry ISO timestamp,
+	 * or both. Measuring an end against a start from a different axis yields a
+	 * nonsense span, so each window records both edges and `applyAssistant`
+	 * pairs like with like.
+	 */
+	awaitingWall?: number;
 }
 
 export function emptyParsedSession(): ParsedSession {
@@ -126,10 +136,13 @@ function accumulateUsage(
 }
 
 /**
- * Turn-boundary timestamps for the current-turn elapsed display.
+ * Turn-boundary timestamp for the current-turn elapsed display.
  *
- * The nested message `timestamp` is Unix ms (session-format.md); fall back to
- * the ISO 8601 entry timestamp for entries written without the nested value.
+ * Prefers the nested message `timestamp` (Unix ms, session-format.md) — for the
+ * elapsed display the moment generation began is exactly what we want — and
+ * falls back to the ISO 8601 entry timestamp for entries written without it.
+ * Generation *duration* is measured elsewhere (`applyAssistant`): the nested
+ * value marks a start, not a completion, and `durationMs` carries the length.
  */
 function messageTimestamp(
 	event: Record<string, unknown>,
@@ -145,6 +158,19 @@ function messageTimestamp(
 	return undefined;
 }
 
+/**
+ * The instant a message was written, on the same Unix-ms axis as
+ * `message.timestamp`. Used for the generation clock so start and end share a
+ * basis; a session that only carries the entry ISO timestamp would otherwise
+ * mix a wall-clock instant into a Unix-ms subtraction.
+ */
+function entryWrittenAt(event: Record<string, unknown>): number | undefined {
+	const outer = event.timestamp;
+	if (typeof outer !== "string") return undefined;
+	const ms = Date.parse(outer);
+	return Number.isFinite(ms) ? ms : undefined;
+}
+
 /** Find (or create) the turn an assistant/toolResult message belongs to. */
 function currentTurn(parsed: ParsedSession): TurnRecord {
 	const existing = parsed.turns.at(-1);
@@ -163,6 +189,7 @@ function applyAssistant(
 	parsed: ParsedSession,
 	message: Record<string, unknown>,
 	timestamp: number | undefined,
+	wall: number | undefined,
 	clock: GenerationClock,
 ): void {
 	const turn = currentTurn(parsed);
@@ -181,7 +208,21 @@ function applyAssistant(
 	});
 	if (timestamp !== undefined) turn.endedAt = timestamp;
 
-	if (
+	// Generation time spans the wait for the model plus the model call itself. Two
+	// strictly paired sources, never mixed:
+	//   1. `durationMs` — an exact length reported by the provider, axis-free.
+	//   2. entry-to-entry (`wall` − `awaitingWall`) — both edges are write instants,
+	//      so a session that omits nested timestamps still measures correctly.
+	// Subtracting the nested `message.timestamp` is NOT the completion instant: it
+	// marks when generation began, so it captures only prompt→first-token latency
+	// (2-7ms on real sessions). It survives as a last resort for synthetic or
+	// legacy sessions that carry no entry timestamps at all.
+	const measured = message.durationMs;
+	if (typeof measured === "number" && Number.isFinite(measured) && measured >= 0) {
+		parsed.generationMs += measured;
+	} else if (wall !== undefined && clock.awaitingWall !== undefined && wall >= clock.awaitingWall) {
+		parsed.generationMs += wall - clock.awaitingWall;
+	} else if (
 		timestamp !== undefined &&
 		clock.awaitingSince !== undefined &&
 		timestamp >= clock.awaitingSince
@@ -189,6 +230,7 @@ function applyAssistant(
 		parsed.generationMs += timestamp - clock.awaitingSince;
 	}
 	clock.awaitingSince = undefined;
+	clock.awaitingWall = undefined;
 
 	accumulateUsage(parsed.usage, message);
 	if (typeof message.model === "string") parsed.model = message.model;
@@ -201,6 +243,7 @@ function applyToolResult(
 	parsed: ParsedSession,
 	message: Record<string, unknown>,
 	timestamp: number | undefined,
+	wall: number | undefined,
 	clock: GenerationClock,
 ): void {
 	const turn = parsed.turns.at(-1);
@@ -212,6 +255,7 @@ function applyToolResult(
 	}
 	// Tool completion starts the next generation window (model resumes).
 	if (timestamp !== undefined) clock.awaitingSince = timestamp;
+	if (wall !== undefined) clock.awaitingWall = wall;
 }
 
 /**
@@ -288,6 +332,9 @@ function applyEvent(
 	const message = event.message as Record<string, unknown> | undefined;
 	if (!message || typeof message !== "object") return;
 	const ts = messageTimestamp(event, message);
+	// The entry write instant, on the same Unix-ms axis as `message.timestamp`.
+	// Generation timing uses it so both window edges share one basis.
+	const wall = entryWrittenAt(event);
 
 	switch (message.role) {
 		case "user":
@@ -300,13 +347,14 @@ function applyEvent(
 			});
 			// User prompt opens a generation window.
 			if (ts !== undefined) clock.awaitingSince = ts;
+			if (wall !== undefined) clock.awaitingWall = wall;
 			break;
 		case "assistant":
-			applyAssistant(parsed, message, ts, clock);
+			applyAssistant(parsed, message, ts, wall, clock);
 			break;
 		case "toolResult":
 		case "tool":
-			applyToolResult(parsed, message, ts, clock);
+			applyToolResult(parsed, message, ts, wall, clock);
 			break;
 		default:
 			break;
@@ -529,6 +577,25 @@ export const NO_ASSISTANT_ABORT_REASON = "no assistant message for the last prom
 export const PARENT_SESSION_SHUTDOWN_ABORT_REASON =
 	"parent session shutdown retired the child before it produced an assistant message";
 
+/**
+ * The parent turn ended and the abort signal carried no reason (#227 D3b).
+ *
+ * Upstream writes a reason-less `AbortController` cancellation as
+ * `stopReason:"error"` with a bare `"This operation was aborted"` message, which
+ * used to be indistinguishable from a real provider failure. The status stays
+ * `aborted`; only the reason becomes self-describing.
+ */
+export const ABORT_WITHOUT_REASON =
+	"parent turn ended (abort signal without a reason)";
+
+/**
+ * The exact messages `AbortSignal`/`AbortController` produce with no reason.
+ * Anchored to the whole message so a longer, meaningful error (a provider
+ * message that merely mentions aborting) does not get rewritten.
+ */
+const REASONLESS_ABORT_MESSAGE =
+	/^(this operation was aborted|the operation was aborted|operation aborted)$/i;
+
 /** True when the last turn (or the whole file) has no assistant message. */
 export function lastTurnHasNoAssistant(parsed: ParsedSession): boolean {
 	const last = parsed.turns.at(-1);
@@ -631,11 +698,20 @@ function outcomeFromFinalMessage(
 			// F29: a graceful interrupt surfaces as `error` with an abort-ish message.
 			const msg = final.errorMessage ?? "";
 			if (/abort/i.test(msg)) {
+				// #227 D3b: a reason-less AbortController cancellation reaches us as
+				// the bare engine message. Name it as the parent's abort instead of
+				// echoing text that reads like a provider failure. Anything carrying
+				// more (notably a `timeout`, or a longer provider sentence) keeps the
+				// original message — status is `aborted` either way.
+				const reason =
+					REASONLESS_ABORT_MESSAGE.test(msg.trim()) && !/timeout/i.test(msg)
+						? ABORT_WITHOUT_REASON
+						: msg;
 				return {
 					status: "aborted",
 					stopReason: "error",
 					errorMessage: msg,
-					reason: msg,
+					reason,
 					...base,
 				};
 			}

package/src/shared/types.ts

@@ -364,6 +364,13 @@ export interface ChildRecord {
 	thinking?: string | false;
 	/** Models that were requested but cannot be represented by the RPC child. */
 	modelDropped?: string[];
+	/**
+	 * Backend this child was actually spawned on, as arbitrated by
+	 * `Orchestrator.launch` (#209). Optional because run.json records written
+	 * before the field existed have no value — readers must render those as
+	 * unknown, never guess a backend.
+	 */
+	spawnMode?: SpawnMode;
 }
 
 export interface RunRecord {
@@ -373,8 +380,11 @@ export interface RunRecord {
 	cwd: string;
 
 	herdr: {
-		/** Current transport marker under the historic run.json key. */
-		supervisor?: "rpc";
+		/**
+		 * Transport marker under the historic run.json key: the arbitrated backend
+		 * of the run's own process (#209). Absent on legacy records.
+		 */
+		supervisor?: SpawnMode;
 		/** Reserved for M2 tree identity. */
 		node_id?: string;
 	};
@@ -482,6 +492,11 @@ export interface Handle {
 	 * silently defeated the ownership audit.
 	 */
 	child: ChildRecord;
+	/**
+	 * Backend the orchestrator actually chose for this launch (arbitration
+	 * result, #209). Callers render this instead of assuming `rpc`.
+	 */
+	spawnMode: SpawnMode;
 }
 
 // =============================================================================