@procrastivity/clast 0.0.3 → 0.0.5

package/lib/clast/clast-subcommands/sessions.bash

@@ -6,6 +6,7 @@
 # shellcheck shell=bash
 # shellcheck source=lib/clast/clast-lib.bash
 # shellcheck source=lib/clast/clast-manifest-lib.bash
+# shellcheck source=lib/clast/clast-classify-lib.bash
 # shellcheck source=lib/clast/clast-registry-lib.bash
 # shellcheck source=lib/clast/clast-decode-lib.bash
 # shellcheck source=lib/clast/clast-dismissed-lib.bash
@@ -14,11 +15,13 @@ _clast_sessions_usage() {
   cat <<'EOF'
 Usage: clast sessions [--day DATE] [--since DATE] [--until DATE] [--project SLUG]
        clast sessions dismiss <session-id> [<session-id>...] [--reason TEXT]
+       clast sessions undismiss <session-id> [<session-id>...]
 
 List sessions captured in a date window.
 
 Subcommands:
   dismiss ID...    Mark session(s) as dismissed (excluded from future queries).
+  undismiss ID...  Restore previously dismissed session(s).
 
 Flags:
   --day DATE              Single-day window (default: today). Mutually exclusive
@@ -98,6 +101,54 @@ _clast_sessions_dismiss() {
   fi
 }
 
+# _clast_sessions_undismiss <id> [<id>...]
+# Reverse a dismissal so the session reappears in queries.
+_clast_sessions_undismiss() {
+  source "$CLAST_LIB/clast-dismissed-lib.bash"
+
+  local -a ids=()
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+      -h|--help)
+        _clast_sessions_usage; return 0 ;;
+      -*)
+        _clast_sessions_err "undismiss: unknown flag '$1'"; return 2 ;;
+      *)
+        ids+=("$1"); shift ;;
+    esac
+  done
+
+  if [[ ${#ids[@]} -eq 0 ]]; then
+    _clast_sessions_err "undismiss requires at least one session ID"
+    return 2
+  fi
+
+  local id count=0 rc
+  for id in "${ids[@]}"; do
+    if ! [[ "$id" =~ ^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$ ]]; then
+      _clast_sessions_err "undismiss: '$id' is not a valid UUID"
+      return 2
+    fi
+    # `|| rc=$?` keeps the non-zero return from tripping `set -e` (the normal
+    # "not dismissed" path returns 1); rc stays 0 on success.
+    rc=0
+    clast_dismissed_remove "$id" >/dev/null || rc=$?
+    case "$rc" in
+      0) count=$(( count + 1 )) ;;
+      1) [[ -z "${CLAST_QUIET:-}" ]] && clast_log_info "not dismissed: $id" ;;
+      # Any other code is a real failure (temp file / rewrite / mv). Don't
+      # report success while the session is still dismissed — surface it.
+      *) _clast_sessions_err "undismiss: failed to restore $id"; return 1 ;;
+    esac
+  done
+
+  if [[ -n "${CLAST_JSON:-}" ]]; then
+    jq -cn --argjson count "$count" '{undismissed: $count}'
+  elif [[ -z "${CLAST_QUIET:-}" ]]; then
+    clast_log_info "Restored $count session(s)."
+  fi
+}
+
 clast_cmd_sessions() {
   # Handle "sessions dismiss" sub-action before flag parsing.
   if [[ "${1:-}" == "dismiss" ]]; then
@@ -106,6 +157,13 @@ clast_cmd_sessions() {
     return $?
   fi
 
+  # Handle "sessions undismiss" sub-action before flag parsing.
+  if [[ "${1:-}" == "undismiss" ]]; then
+    shift
+    _clast_sessions_undismiss "$@"
+    return $?
+  fi
+
   local day_filter="" since_date="" until_date=""
   local project_filter=""
   local include_dismissed=0
@@ -207,32 +265,61 @@ clast_cmd_sessions() {
       | jq -r --arg s "$project_filter" '.[] | select(.slug == $s) | .path')
   fi
 
-  # Most-recent manifest line per session_id within window.
-  declare -A latest_line=()
-  local line sid
-  while IFS= read -r line; do
-    [[ -z "$line" ]] && continue
-    sid="$(jq -r '.session_id' <<<"$line")"
-    [[ -z "$sid" || "$sid" == "null" ]] && continue
-    # Skip dismissed sessions early to avoid unnecessary work.
-    if [[ -n "${dismissed_ids[$sid]:-}" ]]; then
-      continue
-    fi
-    latest_line["$sid"]="$line"
-  done < <(clast_manifest_iterate "$filter")
+  local manifest_path
+  manifest_path="$(clast_manifest_path)"
 
-  local -a rows=()
-  local snapshot day_bucket mtime seg abs_path msgs
-  local first_ts last_ts start_ts end_ts curated branch slug
   local entries_dir
   entries_dir="$journal_dir/entries"
 
-  for sid in "${!latest_line[@]}"; do
-    line="${latest_line[$sid]}"
-    snapshot="$(jq -r '.snapshot' <<<"$line")"
-    day_bucket="$(jq -r '.day_bucket' <<<"$line")"
-    mtime="$(jq -r '.source_mtime' <<<"$line")"
-    seg="$(awk -F/ 'NR==1{print $3}' <<<"$snapshot")"
+  # Curated/stale index: scan every entry file ONCE up front instead of
+  # grepping the entries dir per session (the old approach was
+  # O(sessions × entries)). `curated_seen[sid]` marks a session as curated;
+  # `curated_mtime[sid]` holds the max curated_source_mtime across its
+  # entries ("" when none carry one — legacy entries then stay non-stale).
+  declare -A curated_seen=() curated_mtime=()
+  if [[ -d "$entries_dir" ]] && compgen -G "$entries_dir/*.md" >/dev/null 2>&1; then
+    local idx_sid idx_cm
+    while IFS=$'\t' read -r idx_sid idx_cm; do
+      [[ -z "$idx_sid" ]] && continue
+      curated_seen["$idx_sid"]=1
+      if [[ -n "$idx_cm" ]]; then
+        if [[ -z "${curated_mtime[$idx_sid]:-}" || "$idx_cm" > "${curated_mtime[$idx_sid]}" ]]; then
+          curated_mtime["$idx_sid"]="$idx_cm"
+        fi
+      fi
+    done < <(awk '
+      function flush() { if (sid != "") { print sid "\t" cm } sid=""; cm="" }
+      FNR==1 && NR>1 { flush() }
+      /^session_id:/           { v=$0; sub(/^session_id:[[:space:]]*/, "", v); sid=v }
+      /^curated_source_mtime:/ { v=$0; sub(/^curated_source_mtime:[[:space:]]*/, "", v); gsub(/"/, "", v); cm=v }
+      END { flush() }
+    ' "$entries_dir"/*.md 2>/dev/null)
+  fi
+
+  # Most-recent manifest line per session_id within window, in a SINGLE jq
+  # pass. Previously this forked one jq per manifest line plus several more
+  # per session; for large manifests that dominated runtime. The reduce keeps
+  # the last line seen per session_id (manifest is append-only, so last =
+  # most recent). Emits @tsv columns: session_id, snapshot, day_bucket,
+  # source_mtime.
+  local -a rows=()
+  local sid snapshot day_bucket mtime seg abs_path msgs
+  local cached_msgs cached_first cached_last cached_user cached_assistant
+  local user_count assistant_count substantive
+  local first_ts last_ts start_ts end_ts curated stale branch slug
+  declare -A seg_slug=()
+
+  while IFS=$'\t' read -r sid snapshot day_bucket mtime cached_msgs cached_first cached_last cached_user cached_assistant; do
+    [[ -z "$sid" ]] && continue
+    # Skip dismissed sessions early, before any per-session file work.
+    if [[ -n "${dismissed_ids[$sid]:-}" ]]; then
+      continue
+    fi
+
+    # segment = third path component of transcripts/<day>/<segment>/<uuid>.
+    seg="${snapshot#transcripts/}"   # <day>/<segment>/<uuid>.jsonl
+    seg="${seg#*/}"                  # <segment>/<uuid>.jsonl
+    seg="${seg%%/*}"                 # <segment>
 
     if (( have_project_filter == 1 )); then
       if [[ -z "${allowed_segs[$seg]:-}" ]]; then
@@ -241,7 +328,15 @@ clast_cmd_sessions() {
     fi
 
     abs_path="$journal_dir/$snapshot"
-    if [[ -r "$abs_path" ]]; then
+    if [[ -n "$cached_msgs" ]]; then
+      # Cache hit (step 21): the manifest line carries msg_count/first_ts/
+      # last_ts, so we never open the transcript. Empty cached_first/last
+      # means the cached value was JSON null (no first/last timestamp).
+      msgs="$cached_msgs"
+      first_ts="$cached_first"
+      last_ts="$cached_last"
+    elif [[ -r "$abs_path" ]]; then
+      # Legacy line (pre-cache): fall back to reading the transcript.
       msgs="$(wc -l <"$abs_path" 2>/dev/null | tr -d ' ')"
       [[ -z "$msgs" ]] && msgs=0
       first_ts="$(head -n1 "$abs_path" 2>/dev/null | jq -r '.timestamp // empty' 2>/dev/null || true)"
@@ -257,35 +352,64 @@ clast_cmd_sessions() {
     start_ts="${first_ts:-$mtime}"
     end_ts="${last_ts:-$mtime}"
 
-    if slug="$(clast_registry_resolve "$seg" 2>/dev/null)" && [[ -n "$slug" ]]; then
-      :
+    # Session classification (clast-classify-lib.bash). Prefer the cached
+    # counts on the manifest line; recompute from the transcript for legacy
+    # lines that predate them. When neither is available (snapshot missing),
+    # leave the counts unknown and fall SAFE — substantive=true — so wake
+    # never auto-dismisses a session we couldn't classify. Note: a line may
+    # carry cached_msgs (step 21) yet lack these counts, so resolve them
+    # independently of the msg_count branch above.
+    if [[ -n "$cached_user" ]]; then
+      user_count="$cached_user"
+      assistant_count="$cached_assistant"
+    elif [[ -r "$abs_path" ]]; then
+      IFS=$'\t' read -r user_count assistant_count < <(clast_session_msg_counts "$abs_path")
+      [[ "$user_count" =~ ^[0-9]+$ ]] || user_count=""
+      [[ "$assistant_count" =~ ^[0-9]+$ ]] || assistant_count=""
+    else
+      user_count=""
+      assistant_count=""
+    fi
+    # substantive iff Claude actually produced a reply. assistant_msg_count==0
+    # captures BOTH no-op shapes the feature targets: empty / slash-command-only
+    # sessions (/clear, /model, /config) AND sessions where the user typed but
+    # quit before any response. Deliberately NOT gated on user_msg_count: a
+    # custom slash command (e.g. /review) leaves zero prose prompts yet drives
+    # real assistant work — those must be kept. Unknown count → SAFE (true).
+    if [[ "$assistant_count" =~ ^[0-9]+$ ]]; then
+      if (( assistant_count > 0 )); then
+        substantive=true
+      else
+        substantive=false
+      fi
+    else
+      substantive=true
+    fi
+
+    # Resolve the slug once per unique segment (segments repeat heavily
+    # across sessions; each resolve forks several jq calls).
+    if [[ -n "${seg_slug[$seg]+x}" ]]; then
+      slug="${seg_slug[$seg]}"
     else
-      slug="$seg"
+      if slug="$(clast_registry_resolve "$seg" 2>/dev/null)" && [[ -n "$slug" ]]; then
+        :
+      else
+        slug="$seg"
+      fi
+      seg_slug["$seg"]="$slug"
     fi
 
     # TODO(step-10): branch field is best-effort; revisit when stats command lands.
     branch=""
 
+    # Curated/stale from the prebuilt index (no per-session grep).
     curated=false
-    local stale=false
-    if [[ -d "$entries_dir" ]]; then
-      local entry_matches
-      entry_matches="$(grep -l "session_id: $sid" "$entries_dir"/*.md 2>/dev/null)" || true
-      if [[ -n "$entry_matches" ]]; then
-        curated=true
-        local best_curated_mtime="" ef cm
-        while IFS= read -r ef; do
-          [[ -z "$ef" ]] && continue
-          cm="$(grep '^curated_source_mtime:' "$ef" 2>/dev/null | head -n1 | sed 's/^curated_source_mtime:[[:space:]]*//')" || true
-          cm="${cm#\"}"
-          cm="${cm%\"}"
-          if [[ -n "$cm" && ( -z "$best_curated_mtime" || "$cm" > "$best_curated_mtime" ) ]]; then
-            best_curated_mtime="$cm"
-          fi
-        done <<<"$entry_matches"
-        if [[ -n "$best_curated_mtime" && "$best_curated_mtime" != "$mtime" ]]; then
-          stale=true
-        fi
+    stale=false
+    if [[ -n "${curated_seen[$sid]:-}" ]]; then
+      curated=true
+      local best_curated_mtime="${curated_mtime[$sid]:-}"
+      if [[ -n "$best_curated_mtime" && "$best_curated_mtime" != "$mtime" ]]; then
+        stale=true
       fi
     fi
 
@@ -307,6 +431,9 @@ clast_cmd_sessions() {
       --argjson curated "$curated" \
       --argjson stale "$stale" \
       --argjson dismissed "$is_dismissed" \
+      --arg user_msg_count "$user_count" \
+      --arg assistant_msg_count "$assistant_count" \
+      --argjson substantive "$substantive" \
       '{
          session_id: $session_id,
          project: $project,
@@ -319,13 +446,31 @@ clast_cmd_sessions() {
          day_bucket: $day_bucket,
          curated: $curated,
          stale: $stale,
-         dismissed: $dismissed
+         dismissed: $dismissed,
+         user_msg_count: (if $user_msg_count == "" then null else ($user_msg_count | tonumber) end),
+         assistant_msg_count: (if $assistant_msg_count == "" then null else ($assistant_msg_count | tonumber) end),
+         substantive: $substantive
        }')")
-  done
+  done < <(
+    if [[ -f "$manifest_path" ]]; then
+      jq -rRn '
+        reduce (inputs | fromjson?
+                | select('"$filter"')
+                | select(.session_id != null and .session_id != "")) as $l
+          ({}; .[$l.session_id] = $l)
+        | to_entries[] | .value
+        | [.session_id, .snapshot, .day_bucket, .source_mtime,
+           .msg_count, .first_ts, .last_ts,
+           .user_msg_count, .assistant_msg_count] | @tsv
+      ' "$manifest_path"
+    fi
+  )
 
   local rows_json='[]'
   if (( ${#rows[@]} > 0 )); then
-    rows_json="$(printf '%s\n' "${rows[@]}" | jq -cs 'sort_by(.start)')"
+    # Tiebreak on session_id so the order is deterministic when sessions
+    # share a start timestamp (the old assoc-array iteration order was not).
+    rows_json="$(printf '%s\n' "${rows[@]}" | jq -cs 'sort_by(.start, .session_id)')"
   fi
 
   if [[ -n "${CLAST_JSON:-}" ]]; then

package/lib/clast/clast-subcommands/show.bash

@@ -5,6 +5,7 @@
 # shellcheck shell=bash
 # shellcheck source=lib/clast/clast-lib.bash
 # shellcheck source=lib/clast/clast-manifest-lib.bash
+# shellcheck source=lib/clast/clast-classify-lib.bash
 # shellcheck source=lib/clast/clast-registry-lib.bash
 # shellcheck source=lib/clast/clast-decode-lib.bash
 
@@ -94,22 +95,54 @@ clast_cmd_show() {
     slug="$seg"
   fi
 
+  # Prefer the cached metadata on the manifest line (step 21); fall back to
+  # reading the transcript for legacy lines that predate the cache.
   local msgs first_ts last_ts start_ts end_ts
-  msgs="$(wc -l <"$abs_path" 2>/dev/null | tr -d ' ')"
-  [[ -z "$msgs" ]] && msgs=0
-  first_ts="$(head -n1 "$abs_path" 2>/dev/null | jq -r '.timestamp // empty' 2>/dev/null || true)"
-  last_ts="$(tail -n1 "$abs_path" 2>/dev/null | jq -r '.timestamp // empty' 2>/dev/null || true)"
+  local cached_msgs cached_first cached_last
+  IFS=$'\t' read -r cached_msgs cached_first cached_last \
+    < <(jq -r '[(.msg_count // ""), (.first_ts // ""), (.last_ts // "")] | @tsv' <<<"$line")
+  if [[ -n "$cached_msgs" ]]; then
+    msgs="$cached_msgs"
+    first_ts="$cached_first"
+    last_ts="$cached_last"
+  else
+    msgs="$(wc -l <"$abs_path" 2>/dev/null | tr -d ' ')"
+    [[ -z "$msgs" ]] && msgs=0
+    first_ts="$(head -n1 "$abs_path" 2>/dev/null | jq -r '.timestamp // empty' 2>/dev/null || true)"
+    last_ts="$(tail -n1 "$abs_path" 2>/dev/null | jq -r '.timestamp // empty' 2>/dev/null || true)"
+  fi
   start_ts="${first_ts:-$source_mtime}"
   end_ts="${last_ts:-$source_mtime}"
 
+  # Session classification (clast-classify-lib.bash): prefer cached counts on
+  # the manifest line, else recompute from the transcript (always readable
+  # here — the -r guard above already returned otherwise). substantive is true
+  # iff Claude produced at least one reply (assistant_msg_count > 0) — this is
+  # the no-op signal wake keys on; see sessions.bash for the full rationale.
+  local user_count assistant_count substantive
+  IFS=$'\t' read -r user_count assistant_count \
+    < <(jq -r '[(.user_msg_count // ""), (.assistant_msg_count // "")] | @tsv' <<<"$line")
+  if ! [[ "$user_count" =~ ^[0-9]+$ && "$assistant_count" =~ ^[0-9]+$ ]]; then
+    IFS=$'\t' read -r user_count assistant_count < <(clast_session_msg_counts "$abs_path")
+    [[ "$user_count" =~ ^[0-9]+$ ]] || user_count=0
+    [[ "$assistant_count" =~ ^[0-9]+$ ]] || assistant_count=0
+  fi
+  if (( assistant_count > 0 )); then
+    substantive=true
+  else
+    substantive=false
+  fi
+
   # first_prompt / last_prompt — best-effort scan of user messages.
   # These pipelines must never abort the command: malformed JSONL lines are
   # routine, and the fields are explicitly documented as best-effort.
   local first_prompt last_prompt user_msgs=""
   user_msgs="$(_clast_show_user_messages "$abs_path" 2>/dev/null || true)"
-  first_prompt="$(printf '%s\n' "$user_msgs" | head -n1)"
-  last_prompt="$(printf '%s\n' "$user_msgs" | tail -n1)"
-  # If the stream was empty the head/tail of '\n' is empty — keep as ''.
+  # Pure parameter expansion — no subshell/pipe, so a >64KB multi-line
+  # $user_msgs can never SIGPIPE a `printf | head` and abort under pipefail.
+  first_prompt="${user_msgs%%$'\n'*}"   # text up to the first newline
+  last_prompt="${user_msgs##*$'\n'}"    # text after the last newline
+  # If the stream was empty the expansions yield '' anyway — keep as ''.
   [[ -z "$user_msgs" ]] && first_prompt="" && last_prompt=""
   first_prompt="$(_clast_show_truncate "$first_prompt")"
   last_prompt="$(_clast_show_truncate "$last_prompt")"
@@ -163,6 +196,9 @@ clast_cmd_show() {
       --argjson curated "$curated" \
       --arg first_prompt "$first_prompt" \
       --arg last_prompt "$last_prompt" \
+      --argjson user_msg_count "$user_count" \
+      --argjson assistant_msg_count "$assistant_count" \
+      --argjson substantive "$substantive" \
       '{
          session_id: $session_id,
          project: $project,
@@ -176,11 +212,19 @@ clast_cmd_show() {
          day_bucket: $day_bucket,
          curated: $curated,
          first_prompt: (if $first_prompt == "" then null else $first_prompt end),
-         last_prompt: (if $last_prompt == "" then null else $last_prompt end)
+         last_prompt: (if $last_prompt == "" then null else $last_prompt end),
+         user_msg_count: $user_msg_count,
+         assistant_msg_count: $assistant_msg_count,
+         substantive: $substantive
        }')"
     if (( include_turns == 1 )); then
-      obj="$(jq -c --argjson f "$first_turns_json" --argjson l "$last_turns_json" \
-        '. + {first_turns:$f, last_turns:$l}' <<<"$obj")"
+      # Feed the (potentially multi-hundred-KB) turn arrays via stdin, not as
+      # --argjson argv: a single argument >128KB (MAX_ARG_STRLEN) fails with
+      # "Argument list too long" even when total ARG_MAX is far larger. printf
+      # is a builtin, so it has no argv size limit; jq reads three JSON values.
+      obj="$(printf '%s\n%s\n%s\n' "$obj" "$first_turns_json" "$last_turns_json" \
+        | jq -cn 'input as $o | input as $f | input as $l
+                  | $o + {first_turns:$f, last_turns:$l}')"
     fi
     printf '%s\n' "$obj"
     return 0
@@ -197,6 +241,13 @@ clast_cmd_show() {
       printf 'duration:         %s\n' "$duration_str"
     fi
     printf 'msg_count:        %s (approx)\n' "$msgs"
+    printf 'user_msgs:        %s\n' "$user_count"
+    printf 'assistant_msgs:   %s\n' "$assistant_count"
+    if [[ "$substantive" == "true" ]]; then
+      printf 'substantive:      yes\n'
+    else
+      printf 'substantive:      no (no-op — empty / slash-command-only)\n'
+    fi
     printf 'snapshot:         %s\n' "$abs_path"
     if [[ "$curated" == "true" ]]; then
       printf 'curated:          yes\n'
@@ -220,14 +271,20 @@ clast_cmd_show() {
 }
 
 # _clast_show_user_messages <abs_path>
-#   Stream user-message text content, one per line. Empty lines dropped.
+#   Stream real user-prompt text content, one per line. Empty lines, meta
+#   messages, and slash-command wrappers (`/clear`, `/model`, …) are dropped
+#   so first_prompt/last_prompt reflect what the user actually typed — not a
+#   `<local-command-caveat>…` marker. Shares CLAST_COMMAND_MARKER_RE with the
+#   classifier (clast-classify-lib.bash) so the two can't drift.
 _clast_show_user_messages() {
   local path="$1"
-  jq -r '
+  jq -r --arg cmd_re "$CLAST_COMMAND_MARKER_RE" '
     select((.role // .message.role // .type) == "user")
+    | select((.isMeta // false) != true)
     | (.message.content // .content // empty)
     | if type == "array" then map(.text? // "") | join(" ") else . end
     | select(. != null and . != "")
+    | select(test($cmd_re) | not)
   ' "$path" 2>/dev/null
 }
 

package/lib/clast/clast-subcommands/snapshot.bash

@@ -7,6 +7,7 @@
 # shellcheck shell=bash
 # shellcheck source=lib/clast/clast-lib.bash
 # shellcheck source=lib/clast/clast-manifest-lib.bash
+# shellcheck source=lib/clast/clast-classify-lib.bash
 # shellcheck source=lib/clast/clast-decode-lib.bash
 # shellcheck source=lib/clast/clast-registry-lib.bash
 
@@ -28,16 +29,10 @@ EOF
 
 # _clast_snapshot_bucket_for_epoch <epoch>
 #   Mirror of clast_today's cutoff math against an arbitrary epoch. Local
-#   time per docs/explanation/conventions.md.
+#   time per docs/explanation/conventions.md. Thin alias over the shared
+#   primitive in clast-lib.bash.
 _clast_snapshot_bucket_for_epoch() {
-  local epoch="$1"
-  local cutoff="${CLAST_DAY_CUTOFF:-04:00}"
-  local h="${cutoff%%:*}" m="${cutoff##*:}"
-  h=$((10#$h))
-  m=$((10#$m))
-  local off=$((h * 3600 + m * 60))
-  # GNU `date -d` — BSD date not supported, per overview.md.
-  date -d "@$((epoch - off))" +%Y-%m-%d
+  clast_day_bucket_for_epoch "$1"
 }
 
 clast_cmd_snapshot() {
@@ -117,7 +112,8 @@ clast_cmd_snapshot() {
   # TODO(v1.1): parallel capture across segments.
   if [[ -d "$projects_dir" ]]; then
     local source segment session_id mtime_epoch mtime_iso source_size
-    local first_ts ts_epoch day_bucket
+    local first_ts ts_epoch day_bucket last_ts msg_count
+    local user_msg_count assistant_msg_count
     local dest_rel dest dest_dir tmp
     while IFS= read -r -d '' source; do
       segment="$(basename "$(dirname "$source")")"
@@ -163,6 +159,16 @@ clast_cmd_snapshot() {
         day_bucket="$(_clast_snapshot_bucket_for_epoch "$mtime_epoch")"
       fi
 
+      # Cache per-session metadata in the manifest (step 21) so readers
+      # don't re-open the transcript. msg_count uses wc -l semantics to
+      # match the readers' file-read fallback exactly; last_ts mirrors the
+      # existing first_ts extraction. Kept as separate reads (not a fused
+      # awk pass) to avoid the trailing-newline parsing hazard and because
+      # snapshot is a batch path where the extra forks are negligible.
+      last_ts="$(tail -n1 "$source" 2>/dev/null | jq -r '.timestamp // empty' 2>/dev/null || true)"
+      msg_count="$(wc -l <"$source" 2>/dev/null | tr -d ' ')"
+      [[ "$msg_count" =~ ^[0-9]+$ ]] || msg_count=0
+
       # Dedup on (session_id, source_mtime). Mtime — not ctime or size —
       # is the manifest's "most recent line wins" key; Claude Code's
       # writer bumps mtime whenever a session grows.
@@ -171,6 +177,18 @@ clast_cmd_snapshot() {
         continue
       fi
 
+      # Session classification (clast-classify-lib.bash): count real user
+      # prompts and assistant replies so wake can auto-dismiss no-op sessions
+      # (empty / slash-command-only) without an LLM call. Cached on the
+      # manifest line alongside msg_count so readers never re-open the file.
+      # Computed AFTER the dedupe check: unlike the head/tail/wc reads above,
+      # this streams the whole transcript through jq, so we must not pay it for
+      # already-captured sessions skipped on every wake/hook run.
+      IFS=$'\t' read -r user_msg_count assistant_msg_count \
+        < <(clast_session_msg_counts "$source")
+      [[ "$user_msg_count" =~ ^[0-9]+$ ]] || user_msg_count=0
+      [[ "$assistant_msg_count" =~ ^[0-9]+$ ]] || assistant_msg_count=0
+
       dest_rel="transcripts/$day_bucket/$segment/$session_id.jsonl"
       dest="$journal_dir/$dest_rel"
 
@@ -199,7 +217,7 @@ clast_cmd_snapshot() {
         # Invariant: a manifest line implies the dest file exists. If the
         # append fails the dest is an orphan; doctor (step 10) will reap
         # it, and a re-run of snapshot overwrites + retries the append.
-        if ! clast_manifest_append "$session_id" "$source" "$dest_rel" "$mtime_iso" "$source_size" "$day_bucket"; then
+        if ! clast_manifest_append "$session_id" "$source" "$dest_rel" "$mtime_iso" "$source_size" "$day_bucket" "$msg_count" "$first_ts" "$last_ts" "$user_msg_count" "$assistant_msg_count"; then
           error_lines+=("$(jq -cn --arg f "$source" --arg r "manifest append failed" '{file:$f,reason:$r}')")
           continue
         fi

package/lib/clast/clast-subcommands/stats.bash

@@ -244,8 +244,13 @@ clast_cmd_stats() {
     [[ "$size" =~ ^[0-9]+$ ]] || size=0
     bytes_sum=$((bytes_sum + size))
 
-    local abs="$journal_dir/$snapshot" m=0
-    if [[ -r "$abs" ]]; then
+    # Prefer cached msg_count on the manifest line (step 21); fall back to
+    # counting transcript lines for legacy lines that predate the cache.
+    local abs="$journal_dir/$snapshot" m=0 cached_m
+    cached_m="$(jq -r '.msg_count // empty' <<<"$row")"
+    if [[ -n "$cached_m" ]]; then
+      m="$cached_m"
+    elif [[ -r "$abs" ]]; then
       m="$(wc -l <"$abs" 2>/dev/null | tr -d ' ')"
       [[ -z "$m" ]] && m=0
     fi

package/lib/clast/prompts/brief-system.md

@@ -1,17 +1,23 @@
 You are synthesizing a project briefing for the user. They are about to start work on a project and want a tight summary of where they left off.
 
+The recent entries may be grouped under `## Workspace: <label>` headers when
+this project spans more than one directory (separate clones/worktrees of the
+same repo). Treat each workspace as a distinct line of work — do NOT blend
+them. When there are no workspace headers, the project is a single directory;
+render exactly as the structure below.
+
 Produce a briefing using this structure (omit any section that has no content):
 
 ## Wakeup briefing — {project}
 
-**Active thread:** one-line from most recent entry's "Open threads", or "None"
+**Active thread:** one-line from the most recent entry's "Open threads", or "None". When the entries are split across workspaces, pick the active thread from the **current workspace** (named in the user prompt) if it has any entries; otherwise from the most recent entry overall. State which workspace it came from, e.g. "(dev)".
 
-**Last session:** date, branch, one-line goal
-- Work done: 2-3 bullets condensed from most recent entry
+**Last session:** date, workspace/branch, one-line goal
+- Work done: 2-3 bullets condensed from the most recent entry
 - Open threads: bullets, if any
 - Dead ends to avoid: bullets, if any
 
-**Recent sessions:** (up to 5 entries)
+**Recent sessions:** (up to ~8 entries) — when multiple workspaces are present, group these under a short `**<label>:**` subheading per workspace, newest first within each:
 - date [branch] slug: one-line goal
 
 **Today's breadcrumbs:** (if any)
@@ -24,7 +30,7 @@ Produce a briefing using this structure (omit any section that has no content):
 
 Be concise. Use the user's terminology. Don't repeat content across sections. The total briefing should be 2-5k tokens — if you're approaching that, summarize rather than list verbatim.
 
-For the "Suggested next step": prefer the most recent entry's "Open threads" content, then the most recent breadcrumb, then a synthesis of the recent work. If nothing concrete, say "No active thread."
+For the "Suggested next step": prefer the active thread's workspace — its most recent entry's "Open threads" content, then the most recent breadcrumb, then a synthesis of the recent work. If nothing concrete, say "No active thread."
 
 End with one of:
 - "Resume? Active thread: '<thread>'. Suggested next step: <step>."

package/lib/clast/prompts/brief-user.md

@@ -1,6 +1,9 @@
 Project: {{project}}
+Current workspace (the directory you are in now): {{current_label}}
 
-Recent curated entries (newest first):
+Recent curated entries, grouped by workspace (newest first). When a project
+spans more than one directory, entries appear under `## Workspace: <label>`
+headers; a single-workspace project has no headers:
 {{entries}}
 
 Today's breadcrumbs for this project:

package/lib/clast/prompts/retro-summary-system.md

@@ -0,0 +1,14 @@
+You are condensing a single already-curated Claude Code session into a few tight retro bullets. The input is the body of a journal entry (or several merged entries for one session). Your output will appear in a work retrospective grouped by day and project, so it must be skimmable and factual.
+
+Condense the session into at most 3-5 bullets, in this order, omitting any that have no content (do not write "N/A" or empty headers):
+
+- **Shipped:** what actually got done — features, fixes, files, decisions. One bullet per distinct outcome.
+- **Issues:** notable problems hit and how they were resolved (only if the body records them).
+- **Open:** anything left unfinished, deferred, or flagged for next time.
+
+Rules:
+- Use only what the body states. Do not invent, infer motivation, or add detail that is not present.
+- Keep the user's terminology — project names, file paths, branch names, ticket ids — verbatim.
+- Be terse: bullets, not paragraphs. No preamble, no closing summary, no headers other than the bold lead-ins above.
+- If the body is an interrupted session (a goal and open threads but nothing shipped), say so in one **Open:** bullet rather than overstating progress.
+- Output the bullets only — no title line, no tags, no surrounding prose.

package/lib/clast/prompts/retro-summary-user.md

@@ -0,0 +1,7 @@
+Session to condense:
+- Project: {{project}}
+- Work day: {{work_day}}
+- Session id: {{session_id}}
+
+Entry body:
+{{body}}

package/lib/clast/prompts/{day-wakeup-draft-system.md → wake-draft-system.md}

@@ -26,4 +26,4 @@ One sentence describing what this session was trying to accomplish.
 Be concise. Prefer bullets over paragraphs. Use the user's terminology (project-specific names, file paths). Do not invent details. If you are uncertain about something, omit it rather than guess.
 
 After the entry, add a blank line and then: "Suggested tags: tag1, tag2, tag3"
-Tags must be lowercase kebab-case (regex: `^[a-z0-9][a-z0-9-]{0,31}$`). Examples: `adrs`, `symfony-bot`, `mr-umbrella`, `phase-0`. Never use uppercase letters.
+Tags must be lowercase kebab-case (regex: `^[a-z0-9][a-z0-9-]{0,31}$`). Examples: `adrs`, `symfony-bot`, `mr-umbrella`, `phase-0`. Never use uppercase letters. Use hyphens, not dots or spaces, for separators — write versions like `php-8-5`, not `php-8.5`.