@erclx/aitk 3.51.0 → 3.52.0

package/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "aitk",
   "description": "Automated governance, versioning, and discovery tools for Claude Code.",
-  "version": "3.51.0",
+  "version": "3.52.0",
   "author": {
     "name": "Eric Le",
     "url": "https://github.com/erclx"

package/claude/skills/claude-autoship/REQUIREMENT.md

@@ -17,6 +17,7 @@ Review is the step that varies most. It gets skipped on a diff that needed one,
 - Give every step a stop condition, and leave the code on the branch and the receipts on disk at each one
 - Classify the changed-file list by path as well as by extension, so informational prose skips a code review with no signal on it and executable prose still reaches one
 - Split findings by origin, stopping on a critical or should-fix one the branch inherited and repairing one this run caused
+- Own the review receipt's lifetime, since this chain writes it, cites it in its own closing block, and is the only body that can read whether the step keeping it is still using it
 - Delegate the ship sequence to `git-ship` rather than restating it, and name only what this chain adds to it
 - Open the pull request as a draft before the continuous integration watch begins, since a pull request marked after it is mergeable for the length of the run
 - Name the recovery for the stop it took, since the value of stopping is that the user knows where to resume

package/claude/skills/claude-autoship/SKILL.md

@@ -152,6 +152,8 @@ Read origin as causation rather than authorship. Staleness this run induced in a
 
 Bound the repair at one pass, the way Step 3 bounds verify. When that re-read shows the finding still standing, stop: `❌ A self-introduced finding survived one fix pass. See .claude/review/branch/review-<slug>.md. Fix and run /git-ship.`
 
+This chain owns the receipt's lifetime, which is what makes the Output block's citation resolve on a run that reaches it. `claude-docs` used to delete the current slug's receipt while running under Step 7 below, so the closing line named a file the same run had already removed. That sweep now reaches only reports whose branch is gone, which collects this one a branch later rather than during the run that wrote it. The cost is one receipt per live branch left in `.claude/review/branch/`, bounded by the branch count rather than by the lifetime of the checkout.
+
 ## Step 7: ship
 
 Invoke `aitk:git-ship`. That body owns the sequence, being the verify gate, memory capture, both doc syncs, staging, the commit grouping, the branch rename, the pull request, the CI watch, and the scoped memory review, along with the reason each step sits where it does. This step used to restate that list and the two drifted apart with nothing comparing them, so read the order there and never here.

package/claude/skills/claude-docs/REQUIREMENT.md

@@ -13,7 +13,7 @@ A decision's verification anchor has the same shape of gap in the other directio
 
 A handoff file has the same shape of gap as an unmarked outcome. A page a learning workspace produced and an operator already picked a destination for sits in gitignored scratch until something lands it, and the session that produced it is gone by the time a branch exists to carry the write. Left unfolded it reads as promoted while the destination holds nothing.
 
-The receipt half of that sweep was missing entirely. A review receipt is deleted per shipped branch and a memory-review receipt was skipped, because the exclusion protecting the checklist and audit prefixes caught a third by accident. Nothing but an operator asking collected it, and a collection that waits on someone remembering to ask is one a folder outgrows, so the skipped population grew per shipped branch and never shrank until it was most of the folder.
+The receipt half of that sweep was missing entirely. A review receipt was deleted per shipped branch and a memory-review receipt was skipped, because the exclusion protecting the checklist and audit prefixes caught a third by accident. Nothing but an operator asking collected it, and a collection that waits on someone remembering to ask is one a folder outgrows, so the skipped population grew per shipped branch and never shrank until it was most of the folder.
 
 The trigger side carries a gap of its own. "Sync the docs" names either corpus to the person saying it, so a description leaving its corpus to the opening clause alone competes with its public-facing sibling on nothing the routing field states, and the planning surface the request was about goes untouched.
 
@@ -31,6 +31,7 @@ The trigger side carries a gap of its own. "Sync the docs" names either corpus t
 - Scan every memory-review receipt rather than the one matching this slug, since the skill that writes them runs after this one in the ship chain and a slug is unique per feature
 - Collect a memory-review receipt whose items are all decided, folding each skip into its memory entry first, since a declined item is recorded nowhere else and a promoted one is already in git
 - Leave a memory-review receipt holding a pending item, and report the count. A branch shipping is not an operator deciding what the receipt proposed.
+- Leave the current branch's review receipt alone, since the chain that wrote it cites it in its own closing line and this skill cannot read whether that citation is still live
 - Land each block of a promotion handoff at the destination its heading names, then delete the file so a later run does not fold it twice
 - Take a promotion destination as already decided, since the operator confirmed it where the page was produced
 

package/claude/skills/claude-docs/SKILL.md

@@ -245,15 +245,15 @@ Write the retarget as a markdown link, `Plan: [feature-<slug>](../plans/archive/
 
 ### Reviews
 
-Derive `<slug>` per `${CLAUDE_SKILL_DIR}/../../standards/slug.md`. Fall back to `latest` on an empty result.
+Leave the current branch's review receipt where it is. `claude-autoship` Step 6 keeps minor findings in `.claude/review/branch/review-<slug>.md` and its closing block hands the reader that path, so deleting it here removes the file the chain that invoked this skill is still citing. Seven runs recorded that collision across two days before a sandbox fixture asserted the receipt and could pass only on a run the chain stopped early.
 
-If `.claude/review/branch/review-<slug>.md` exists, delete it. `claude-review` writes with this convention.
+The body that writes a receipt owns its lifetime. This skill sweeps on behalf of whatever called it and has no way to read whether a file is still in use, where the chain that wrote this one cites it in its own output and knows. What reaps it is the branch sweep below, one branch later, once the branch it names is gone.
 
-Then sweep the branch reports this session never opened. List `.claude/review/branch/review-*.md`, run the same slug transform over every name `git branch --format='%(refname:short)'` prints, and delete a report whose slug matches none of them. Take the names from that format rather than from `git branch --list`, which marks the current branch with `* ` and a branch checked out in another worktree with `+ `, so a transform reading the marked lines as written turns a live branch into a slug nothing matches and sweeps a report a sibling worktree is still working from. A branch report is read once, by the session addressing it, and the durable record of what a review found is the comment `claude-pr-review` posts on the pull request, so a report outliving its branch is holding nothing. Skipping this leaves them accumulating for the life of the checkout, since a slug is unique per feature and no later branch ever looks for one.
+Sweep the branch reports this session never opened. List `.claude/review/branch/review-*.md`, run the slug transform in `${CLAUDE_SKILL_DIR}/../../standards/slug.md` over every name `git branch --format='%(refname:short)'` prints, and delete a report whose slug matches none of them. Take the names from that format rather than from `git branch --list`, which marks the current branch with `* ` and a branch checked out in another worktree with `+ `, so a transform reading the marked lines as written turns a live branch into a slug nothing matches and sweeps a report a sibling worktree is still working from. A branch report is read once, by the session addressing it, and the durable record of what a review found is the comment `claude-pr-review` posts on the pull request, so a report outliving its branch is holding nothing. Skipping this leaves them accumulating for the life of the checkout, since a slug is unique per feature and no later branch ever looks for one.
 
 What that removes is a local-only review on a branch deleted before it opened a pull request. `claude-review` says so where a reader meets the report, and the sweep runs anyway rather than keeping every report against the one case, since nothing else ever clears them.
 
-Memory receipts sweep board-wide, like plans above and unlike the current slug's review report. Scan every `.claude/review/memory/memory-review-*.md`, not only the one matching this slug. `claude-memory-review` writes its receipt after this skill has run in every ship chain, so a sweep keyed on the current slug looks for a file that does not exist yet, and no later branch looks for it either because a slug is unique per feature. Scanning the folder is what makes the sweep fire at all.
+Memory receipts sweep board-wide, like both halves of this step above them. Scan every `.claude/review/memory/memory-review-*.md`, not only the one matching this slug. `claude-memory-review` writes its receipt after this skill has run in every ship chain, so a sweep keyed on the current slug looks for a file that does not exist yet, and no later branch looks for it either because a slug is unique per feature. Scanning the folder is what makes the sweep fire at all.
 
 For each receipt, count the H2 items still marked 📝 pending:
 
@@ -268,7 +268,6 @@ Output one line per file swept:
 
 - `📦 Archived: <path>` for a plan moved into `.claude/plans/archive/`
 - `⏭ Kept: <path>, still cited by <task-file>` for a plan another live task shares
-- `🧹 Deleted: <path>` for a swept branch report
 - `🧹 Deleted: <path>, branch gone` for a branch report whose branch no longer exists
 - `🧹 Deleted: <path>, folded <n> skips` for a swept memory receipt
 - `⏭ Kept: <path>, <n> items pending` for a memory receipt still holding decisions

package/claude/skills/claude-orchestrate/scripts/watch.sh

@@ -5,7 +5,12 @@
 # holds. This answers "what just changed" on a loop of its own, and it exists
 # because the two readings a dispatch needs are not one reading: a worker that
 # finishes goes idle and a worker that crashes vanishes, so a watch matching
-# only the pull request list stays silent through the second.
+# only the pull request list stays silent through the second. A third case is
+# neither: a worker that stops on a question or a prompt neither finishes nor
+# crashes, and sits reading "waiting" beside the two statuses that resolve on
+# their own until something reports it, which is the WORKER-STOPPED line
+# below, or WORKER-UNMEASURABLE for a "waiting" row too old to carry a stamp
+# this reads.
 #
 # `set -e` is deliberately not set. This runs for hours, and one transient `gh`
 # failure aborting the loop is a silent stop rather than a reported one. Every
@@ -17,6 +22,28 @@ set -uo pipefail
 # in a project whose workers run long.
 INTERVAL=60
 
+# Seconds a worker can sit in "waiting" before this reports it as stopped
+# rather than folding it into the ordinary status-change lines below. "busy"
+# and "idle" resolve on their own; "waiting" does not, so a dwell that keeps
+# growing there is a session blocked on something outside itself.
+#
+# Measured against the live session registry: 341 usable records carried a
+# status at all, and exactly one carried "waiting", too sparse a sample to fit
+# a distribution. The number is picked from the two bounds the measurement can
+# still name rather than from a round guess: well above INTERVAL, so a handful
+# of passes confirm the row before it reports rather than one slow tool call
+# tripping it, and well inside the ten-to-thirty-minute span a dispatched build
+# ordinarily runs, so a real stall is caught with most of that window still
+# open to act on it.
+#
+# That one record carried `waitingFor: "approve Bash"`, a permission prompt
+# rather than a question, and the two clear on different schedules: a prompt
+# resolves the moment a person approves it, where a question can sit
+# legitimately while a controller finishes a turn. This number is defensible
+# for the second and generous for the first, and the gap stays open rather
+# than splitting the constant on a sample of one.
+STALL_THRESHOLD_S=300
+
 # Resolving the main worktree root rather than this file's folder keeps a watch
 # started from a linked worktree reading the same repository as one started from
 # main. The repository field on a roster row is that root's `.git`.
@@ -40,13 +67,19 @@ BASE_BRANCH="${BASE_REF#origin/}"
 # worker, whoever launched it. The prototype matched the `orchestrator-` prefix
 # instead, which reads a dispatched worker and misses every hand-launched one,
 # and those are the ordinary shape whenever the operator is launching.
+#
+# The row goes out tab-separated and comes back read with IFS set to a tab. A
+# name this client actually writes carries spaces, `Update session markdown
+# and check runnable commands (3)` among them, and splitting on whitespace
+# took that one apart into a wrong name, branch, status, and dwell.
 read_workers() {
   aitk sessions list --json 2>/dev/null | tail -1 | jq -r \
     --arg repository "$REPOSITORY" --arg base "$BASE_BRANCH" '
       .sessions[]?
       | select(.repository == $repository)
       | select(.branch != null and .branch != $base)
-      | "\(.name) \(.branch) \(.status)"
+      | [.name, .branch, .status, (.statusDwellMs // -1 | tostring)]
+      | @tsv
     ' 2>/dev/null | sort
 }
 
@@ -70,6 +103,15 @@ prev_names=""
 pulls_seen=0
 workers_seen=0
 
+# One row per worker name currently reported, waiting past STALL_THRESHOLD_S
+# or waiting with no stamp to measure, so a reader watching the log is told
+# once rather than on every remaining pass. The prototype for that shape is
+# the WORKER-GONE/WORKER pair above, tracked in the same state a status change
+# is: a name drops out the pass it stops reading "waiting", which lets the
+# same worker report a second stall later in its life rather than being
+# marked forever by its first one.
+declare -A stalled
+
 while true; do
   pulls="$(read_pulls)"
   pulls_read=$?
@@ -83,7 +125,7 @@ while true; do
     echo "watch: the session roster failed to load, so no worker is classified this pass"
   fi
 
-  names="$(printf '%s\n' "$workers" | awk 'NF {print $1}' | sort -u)"
+  names="$(printf '%s\n' "$workers" | awk -F'\t' 'NF {print $1}' | sort -u)"
 
   if [ "$pulls_seen" -eq 1 ] && [ "$pulls_read" -eq 0 ]; then
     comm -13 <(printf '%s\n' "$prev_pulls") <(printf '%s\n' "$pulls") | grep . || true
@@ -96,6 +138,35 @@ while true; do
       grep . | sed 's/^/WORKER-GONE /' || true
   fi
 
+  if [ "$workers_read" -eq 0 ]; then
+    while IFS=$'\t' read -r w_name w_branch w_status w_dwell_ms; do
+      [ -z "$w_name" ] && continue
+
+      if [ "$w_status" != "waiting" ]; then
+        unset "stalled[$w_name]"
+        continue
+      fi
+
+      if [ "$w_dwell_ms" = "-1" ]; then
+        if [ -z "${stalled[$w_name]:-}" ]; then
+          echo "WORKER-UNMEASURABLE $w_name $w_branch"
+          stalled[$w_name]=1
+        fi
+        continue
+      fi
+
+      w_dwell_s=$((w_dwell_ms / 1000))
+      if [ "$w_dwell_s" -ge "$STALL_THRESHOLD_S" ]; then
+        if [ -z "${stalled[$w_name]:-}" ]; then
+          echo "WORKER-STOPPED $w_name $w_branch ${w_dwell_s}s"
+          stalled[$w_name]=1
+        fi
+      else
+        unset "stalled[$w_name]"
+      fi
+    done <<<"$workers"
+  fi
+
   if [ "$pulls_read" -eq 0 ]; then
     prev_pulls="$pulls"
     pulls_seen=1

package/claude/skills/claude-review/SKILL.md

@@ -128,7 +128,7 @@ If there are no findings, write `✅ No findings.` to the file with a timestamp.
 
 The `.claude/review/` directory is gitignored. Do not stage or commit the file.
 
-The report is disposable. `claude-docs` deletes it at ship, and sweeps any branch report whose branch no longer exists, because the durable record of what a review found is the comment `claude-pr-review` posts on the pull request. A review run on a branch that never opens one leaves nothing behind once that branch is gone, so fold anything worth keeping into the pull request body or a task finding while the report is still on disk.
+The report is disposable. It outlives the ship chain that reads it, and `claude-docs` sweeps it once the branch it names is gone, because the durable record of what a review found is the comment `claude-pr-review` posts on the pull request. A review run on a branch that never opens one leaves nothing behind once that branch is gone, so fold anything worth keeping into the pull request body or a task finding while the report is still on disk.
 
 ### Chat output
 

package/docs/agents/sessions.md

@@ -105,6 +105,14 @@ Every report states how liveness was decided, on a pass as well as a failure.
 
 The registry holds one record per session and is never pruned, so it accumulates thousands of entries. On the `unverified` path a stale record whose pid has been reused reads as live, which is why the field is reported rather than assumed.
 
+## The status dwell
+
+Every row carries `statusUpdatedAt`, the stamp a client writes beside `status` at the moment it last changed, and `statusDwellMs`, the elapsed milliseconds since that stamp. Measured over the live registry, 23 of 341 usable records carry `statusUpdatedAt`, so `null` is the ordinary answer rather than an edge case, and the absence tracks a client version rather than a record's age alone: the one record ever measured carrying `status: "waiting"` is among the 318 without it.
+
+`statusDwellMs` falls back to the coarser `updatedAt` stamp when `statusUpdatedAt` is absent, so it is `null` only where a record carries neither. `statusUpdatedAt` itself is never backfilled from the fallback and stays `null` in that case, since it names the exact stamp rather than an estimate. A stamp ahead of the reading clock clamps the dwell to zero rather than reporting a negative one.
+
+The dwell is what separates a status that resolves on its own from one that does not. `busy` and `idle` transition without help, so a long dwell there is ordinary. `waiting` does not: a session in that state is blocked on something outside itself, and a dwell that keeps growing past the ordinary span of a prompt is a session stalled rather than paused. `aitk sessions list` renders the dwell beside the status at the coarsest unit that keeps it a whole number, and the JSON record carries both fields on every row.
+
 ## What the read depends on
 
 The records live under the Claude Code configuration directory, which the verb resolves from `CLAUDE_CONFIG_DIR` and falls back to `~/.claude`. Their location, their filenames, and the fields inside them are a client implementation detail rather than a published interface, so a client change can move them. The verb reports an absent registry as a refusal rather than as a machine running no sessions, which is what surfaces the move instead of burying it in an empty roster.

package/docs/ai-workflow.md

@@ -103,7 +103,7 @@ A person points it at a private repository once and both verbs refuse until they
 
 A plan that ships is archived, never deleted. `aitk:claude-docs` moves it to `.claude/plans/archive/` and retargets the task file's `Plan:` line at the new location, so a completed task still leads to the reasoning behind it. An archive sits inside the record folder it archives rather than beside it, so one ignore entry and one backed-folder entry cover a record and everything it has retired. The folder is gitignored, which is why a deleted plan had no recovery path. A plan cited by more than one task stays put until the last of them closes, since moving it early would strand every other pointer.
 
-A branch review report takes the other route and is swept rather than archived. `claude-review` writes it to `.claude/review/branch/`, the session addressing it reads it once, and the durable record of what a review found is the comment `claude-pr-review` posts on the pull request, so `claude-docs` deletes the report at ship and any report whose branch is gone. What that loses is a local-only review on a branch that never opened a pull request, which is why the report says so where a reader meets it.
+A branch review report takes the other route and is swept rather than archived. `claude-review` writes it to `.claude/review/branch/`, the session addressing it reads it once, and the durable record of what a review found is the comment `claude-pr-review` posts on the pull request, so `claude-docs` deletes any report whose branch is gone. The body that writes a report owns how long it lives, which leaves the shipping branch's own report on disk through the run that cites it and collects it a branch later. What that loses is a local-only review on a branch that never opened a pull request, which is why the report says so where a reader meets it.
 
 The plans sweep reads the whole board rather than the tasks the session touched. It is the one place the skill reaches past its own rule against editing a task file the session did not change, because a task that closed while an earlier run missed its archive is exactly what the sweep exists to clear. Reaching it is safe: the archive moves the plan and retargets the pointer in the same pass, so an untouched task ends up with a working link rather than a broken one.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@erclx/aitk",
   "type": "module",
-  "version": "3.51.0",
+  "version": "3.52.0",
   "description": "Infrastructure and quality tooling for developer workflows",
   "license": "MIT",
   "bin": {

package/src/commands/sessions.ts

@@ -124,6 +124,14 @@ export function register(program: Command): void {
         'cannot rule out a pid handed to an unrelated process, so a roster',
         'reported that way is a candidate list rather than an identity.',
         '',
+        'The JSON record also carries "statusUpdatedAt" (the stamp the client',
+        'wrote beside "status", or null where its record carries none) and',
+        '"statusDwellMs" (the elapsed milliseconds since that stamp, falling',
+        'back to the coarser "updatedAt" where the narrower one is absent,',
+        'computed at read time and clamped at zero against clock skew). The',
+        'framed listing renders the same dwell beside the status, at the',
+        'coarsest unit that keeps it a whole number.',
+        '',
         'Examples:',
         '  aitk sessions list',
         '  aitk sessions list --json',
@@ -349,12 +357,30 @@ function reportSessions(
         const held =
           session.branch ??
           `unresolved: ${REASONS[session.unresolved ?? ''] ?? 'unknown'}`
-        return `${session.name}  ${session.status}  ${held}\n  ${session.cwd}`
+        const dwell = formatDwell(session.statusDwellMs)
+        const status = dwell ? `${session.status} ${dwell}` : session.status
+        return `${session.name}  ${status}  ${held}\n  ${session.cwd}`
       })
       .join('\n'),
   )
 }
 
+/**
+ * Renders the dwell at the coarsest unit that keeps it a whole number, since a
+ * reader scanning a roster wants an age at a glance rather than a millisecond
+ * count. An absent dwell renders as nothing, folding a status carrying no
+ * stamp back to the bare status line the reader already knew.
+ */
+function formatDwell(ms: number | null): string {
+  if (ms === null) return ''
+  const seconds = Math.round(ms / 1000)
+  if (seconds < 60) return `${seconds}s`
+  const minutes = Math.round(seconds / 60)
+  if (minutes < 60) return `${minutes}m`
+  const hours = Math.round(minutes / 60)
+  return `${hours}h`
+}
+
 function reportClaim(claim: ClaimReport): void {
   logStep('Claim')
 

package/src/sessions/registry.ts

@@ -21,6 +21,23 @@ export interface SessionRecord {
   readonly sessionId: string | undefined
   readonly kind: string | undefined
   readonly status: string | undefined
+  /**
+   * The epoch millisecond the client last changed `status`. Measured against
+   * the live registry, 23 of 341 usable records carry it, and the one record
+   * that has ever carried `status: "waiting"` is not among them, so its
+   * absence tracks a client version rather than a record's age alone.
+   * Declared here rather than read opportunistically off the parsed object,
+   * since this file is what states what the domain reads and an undeclared
+   * field read anyway is the drift this domain exists downstream of.
+   */
+  readonly statusUpdatedAt: number | undefined
+  /**
+   * The epoch millisecond the client last wrote the record at all, a coarser
+   * stamp than `statusUpdatedAt` that a client writes whether or not it also
+   * stamps the status change itself. Declared as the fallback dwell source
+   * for a record predating the narrower field, per the same reasoning above.
+   */
+  readonly updatedAt: number | undefined
   readonly startedAt: number | undefined
   /**
    * The process start time the client stamped at launch, compared against the

package/src/sessions/resolve.ts

@@ -23,6 +23,25 @@ export interface ResolvedSession {
   readonly kind: string
   readonly status: string
   readonly startedAt: string | null
+  /**
+   * The stamp the record carries beside `status`, kept alongside the dwell it
+   * computes below for a caller comparing two sessions rather than reading the
+   * age of one.
+   */
+  readonly statusUpdatedAt: string | null
+  /**
+   * Elapsed milliseconds since `statusUpdatedAt`, falling back to the coarser
+   * `updatedAt` when the record predates the narrower field, computed once at
+   * read time so three callers do not each convert the raw stamp and each get
+   * the clock-skew case wrong. The one record ever measured carrying
+   * `status: "waiting"` has exactly this shape: no `statusUpdatedAt`, an
+   * `updatedAt` beside it, so a caller reading this field alone would report
+   * the single real instance as unmeasured rather than as stalled.
+   * Clamped at zero rather than reported negative: a record stamped
+   * by a clock running ahead of this one is a skew to absorb, not a session
+   * that has not started waiting yet.
+   */
+  readonly statusDwellMs: number | null
   /**
    * The shared git directory every worktree of one repository resolves to,
    * which is what identifies the repository a row belongs to. A branch name is
@@ -52,6 +71,8 @@ export interface ResolveOptions {
   readonly dir?: string
   readonly probes?: LivenessProbes
   readonly locate?: (cwd: string) => Promise<Located>
+  /** The instant the dwell is computed against. Defaults to `Date.now`. */
+  readonly now?: () => number
 }
 
 export interface Located {
@@ -123,6 +144,17 @@ export async function repositoryOf(cwd: string): Promise<string | null> {
   return resolved.length > 0 ? resolved : null
 }
 
+/**
+ * Falls back to `updatedAt` when `statusUpdatedAt` is absent, since the
+ * narrower field is the newer of the two and a record predating it still
+ * carries the coarser one. The one record measured with `status: "waiting"`
+ * takes exactly this path: no `statusUpdatedAt`, an `updatedAt` beside it.
+ */
+function dwellMs(record: SessionRecord, now: number): number | null {
+  const stamp = record.statusUpdatedAt ?? record.updatedAt
+  return stamp === undefined ? null : Math.max(0, now - stamp)
+}
+
 /**
  * An absent field is rendered as an absence rather than as a value.
  *
@@ -131,7 +163,11 @@ export async function repositoryOf(cwd: string): Promise<string | null> {
  * for data. Null says the record did not carry it, which is the same
  * distinction the registry draws between an absent folder and an empty one.
  */
-function present(record: SessionRecord, located: Located): ResolvedSession {
+function present(
+  record: SessionRecord,
+  located: Located,
+  now: number,
+): ResolvedSession {
   return {
     name: record.name,
     pid: record.pid,
@@ -143,6 +179,11 @@ function present(record: SessionRecord, located: Located): ResolvedSession {
       record.startedAt === undefined
         ? null
         : new Date(record.startedAt).toISOString(),
+    statusUpdatedAt:
+      record.statusUpdatedAt === undefined
+        ? null
+        : new Date(record.statusUpdatedAt).toISOString(),
+    statusDwellMs: dwellMs(record, now),
     repository: located.repository,
     worktree: located.worktree,
     branch: located.branch,
@@ -167,6 +208,7 @@ export async function resolveSessions(
 ): Promise<SessionReport> {
   const probes = opts.probes ?? SYSTEM_PROBES
   const find = opts.locate ?? locate
+  const now = opts.now?.() ?? Date.now()
   const registry = readRegistry(opts.dir)
 
   if (registry.kind === 'absent') return { kind: 'absent', dir: registry.dir }
@@ -182,7 +224,7 @@ export async function resolveSessions(
   }
 
   const sessions = await Promise.all(
-    live.map(async (record) => present(record, await find(record.cwd))),
+    live.map(async (record) => present(record, await find(record.cwd), now)),
   )
 
   return { kind: 'resolved', dir: registry.dir, confidence, sessions }