fix(session): close the review gaps the boundary opened

- `SessionSummary.updatedAt`'s wire doc still said "Persisted file mtime",
  which stopped being true for attached sessions.
- The core invariant let `session/inherited` fall through the merge-extensible
  default. It is core-owned, so it gets an explicit case; an unbalanced seed
  legally places it inside an open turn, which the relation permits.
- The Agent Note claimed the boundary reaches disk via `live.pending`/
  `scheduleDrain`. Verified false: the constructor append precedes `enter()`,
  so it never publishes on `session/event` and rides the creation seed instead.
  Attaching is therefore a write where none happened before — recorded, since
  only `load()` stays a pure read.
- The deferred-index proposal asserted this change documented the cold-mtime
  skew on `dsh-host-apiproxy`. It did not; the README entry now exists.
- `firstLiveSeq`'s firehose gap runs through its own seq, not below it.
- The boundary is not always at `firstLiveSeq` (the idempotence guard), so
  consumers scan for the last one.
- `lastActivityTime` excludes by type, so a pickup time still leaks onto a
  synthetic closer when a boundary ends an open turn. Documented.
- Pin the fork claim end-to-end: a child inherits a still-running parent's
  open bracket below its own boundary, while the parent has none. Fails if the
  write moves back to the load path.
- Fix the telemetry title that contradicted its own assertions.

The `/status` call site cannot be pinned the way the other two are: the
command appends its own `command/run` before rendering, so the boundary is
never the log tail there. Its fixture now at least renders over a
boundary-bearing log.

packages/core/session/src/index.ts

@@ -394,6 +394,10 @@ export class Session {
    * `session/inherited` event at this seq, which is what a consumer reading
    * STORED history reads. Prefer this field in-process — it is exact before
    * the marker's write reaches storage.
+   *
+   * The marker is appended before the store attaches, so when one exists the
+   * event AT this seq did not publish either: the firehose gap runs through
+   * `firstLiveSeq`, not just below it.
    */
   readonly firstLiveSeq: number
 

packages/core/session/src/invariant.ts

@@ -144,6 +144,9 @@ function validateEvent(
     }
     case 'user/message':
       break
+    case 'session/inherited':
+      // Unconstrained: an unbalanced seed legally puts it inside an open turn.
+      break
     case 'steering/message':
     case 'todo/write':
     case 'request/header': {

packages/core/session/src/repair.ts

@@ -14,6 +14,11 @@ import type { SessionEvent } from './types.ts'
  * The `time` of the log's last event representing actual work, skipping the
  * `session/inherited` boundary — picking a session up is not activity, so
  * activity ordering must exclude it.
+ *
+ * Excluded by type, so a pickup time still leaks when a boundary is the last
+ * event of an open turn: {@link interruptedTurnClosers} copies it onto the
+ * synthetic `turn/end`, which this counts as work. Reachable only by seeding an
+ * unbalanced log directly — `load()` balances first.
  * @param events - the log to scan, in seq order.
  * @returns the latest non-boundary event's `time`, or undefined when there is none.
  */

packages/core/session/src/types.ts

@@ -256,6 +256,10 @@ export interface SessionEventMap {
    * and no writer in this lifecycle produced it. Payload is empty — position
    * and `time` carry the meaning.
    *
+   * Locate the LAST one rather than reading `firstLiveSeq`: a seed already
+   * ending in a boundary is not re-marked, so reopening an untouched session
+   * does not grow its log per pickup.
+   *
    * An owner of a standalone open/close bracket (`compact/start` …
    * `compact/end`) reads it because inherited history and live work are
    * otherwise byte-identical: an unmatched opening marker below the boundary