@procrastivity/clast 0.0.4 → 0.0.6

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

@@ -63,15 +63,16 @@ EOF
     return 0
   fi
 
-  printf '%-17s %-33s %-43s %s\n' slug path remote aliases
-  local n i slug path remote aliases
+  printf '%-17s %-13s %-33s %-43s %s\n' slug label path remote aliases
+  local n i slug label path remote aliases
   n="$(jq 'length' <<<"$arr")"
   for (( i = 0; i < n; i++ )); do
     slug="$(jq -r ".[$i].slug // \"\"" <<<"$arr")"
+    label="$(jq -r ".[$i].label // \"\" | if . == \"\" then \"(none)\" else . end" <<<"$arr")"
     path="$(jq -r ".[$i].path // \"\"" <<<"$arr")"
     remote="$(jq -r ".[$i].remote // \"\"" <<<"$arr")"
     aliases="$(jq -r ".[$i].aliases // [] | if length == 0 then \"(none)\" else join(\",\") end" <<<"$arr")"
-    printf '%-17s %-33s %-43s %s\n' "$slug" "$path" "$remote" "$aliases"
+    printf '%-17s %-13s %-33s %-43s %s\n' "$slug" "$label" "$path" "$remote" "$aliases"
   done
 }
 
@@ -83,18 +84,18 @@ _clast_registry_op_add() {
       --json) json=1; shift ;;
       -h|--help)
         cat <<'EOF'
-Usage: clast registry add <path> [--slug NAME] [--remote URL] [--json]
+Usage: clast registry add <path> [--slug NAME] [--label NAME] [--remote URL] [--json]
 EOF
         return 0
         ;;
       # TODO(v1.1): interactive --slug prompt when stdin is a TTY.
-      --slug|--remote)
+      --slug|--label|--remote)
         if [[ $# -lt 2 ]]; then
           clast_log_error "registry add: $1 requires a value"
           return 2
         fi
         passthrough+=("$1" "$2"); shift 2 ;;
-      --slug=*|--remote=*)
+      --slug=*|--label=*|--remote=*)
         passthrough+=("$1"); shift ;;
       *)
         passthrough+=("$1"); shift ;;
@@ -110,10 +111,15 @@ EOF
   if [[ -n "$json" ]]; then
     printf '%s\n' "$line"
   else
-    local slug path
+    local slug label path
     slug="$(jq -r '.slug' <<<"$line")"
+    label="$(jq -r '.label // ""' <<<"$line")"
     path="$(jq -r '.path' <<<"$line")"
-    printf 'registered %s → %s\n' "$slug" "$path"
+    if [[ -n "$label" ]]; then
+      printf 'registered %s (%s) → %s\n' "$slug" "$label" "$path"
+    else
+      printf 'registered %s → %s\n' "$slug" "$path"
+    fi
   fi
 }
 
@@ -126,6 +132,9 @@ _clast_registry_op_resolve() {
       -h|--help)
         cat <<'EOF'
 Usage: clast registry resolve <path-or-segment> [--json]
+
+Prints the resolved slug. With --json, also includes the directory's
+`label` when the matched line has one.
 EOF
         return 0
         ;;
@@ -144,10 +153,16 @@ EOF
     return 2
   fi
 
-  local slug
-  if slug="$(clast_registry_resolve "$input")" && [[ -n "$slug" ]]; then
+  # Resolve to the specific line so --json can surface the per-directory
+  # label (not just the slug). Human output stays slug-only.
+  local line
+  if line="$(clast_registry_line_for_path "$input")" && [[ -n "$line" ]]; then
+    local slug label
+    slug="$(jq -r '.slug // empty' <<<"$line")"
+    label="$(jq -r '.label // empty' <<<"$line")"
     if [[ -n "$json" ]]; then
-      jq -cn --arg slug "$slug" '{slug: $slug}'
+      jq -cn --arg slug "$slug" --arg label "$label" \
+        '{slug: $slug} + (if $label == "" then {} else {label: $label} end)'
     else
       printf '%s\n' "$slug"
     fi

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

@@ -0,0 +1,217 @@
+# clast-subcommands/retro.bash — `clast-plumbing retro`.
+#
+# Round 1 of the retro feature: run the deterministic day→project manifest
+# (clast_retro_manifest) and render it from the raw entry bodies, in work-day
+# order. No LLM. `--json` emits the manifest verbatim; the human render is the
+# deterministic retro document the porcelain `clast retro` will later condense.
+# See .wip/initiatives/clast-retro/.
+# shellcheck shell=bash
+# shellcheck source=lib/clast/clast-lib.bash
+# shellcheck source=lib/clast/clast-retro-lib.bash
+source "$CLAST_LIB/clast-retro-lib.bash"
+
+_clast_retro_usage() {
+  cat <<'EOF'
+Usage: clast retro [--from DATE] [--to DATE] [--window work-days|file-dates]
+
+Summarize work grouped by the day it actually happened → project, from the
+curated journal entries. Deterministic; no model call.
+
+Flags:
+  --from DATE     Start of the window (inclusive). Default: corpus start.
+  --to DATE       End of the window (inclusive). Default: corpus end.
+  --window WHICH  work-days (default): keep sessions whose work day is in range.
+                  file-dates: keep entries whose filename date is in range
+                  (pulls earlier work days reachable from those files).
+  --bodies        With --json only: add each session's merged entry `body`.
+  -h, --help      Print this usage and exit.
+
+DATE accepts ISO (YYYY-MM-DD), `today`, `yesterday`, `last-week`, `-Nd`, `-Nw`.
+With --json, emits the raw day→project manifest instead of the rendered report.
+EOF
+}
+
+_clast_retro_err() {
+  local msg="$1" code="${2:-2}"
+  if [[ -n "${CLAST_JSON:-}" ]]; then
+    jq -cn --arg m "$msg" --argjson c "$code" '{error:$m, code:$c}'
+  else
+    clast_log_error "retro: $msg"
+  fi
+}
+
+clast_cmd_retro() {
+  local from="" to="" window="work-days" bodies=0
+
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+      --bodies) bodies=1; shift ;;
+      --from)
+        if [[ $# -lt 2 ]]; then _clast_retro_err "--from requires a value"; return 2; fi
+        if ! from="$(clast_parse_date "$2" 2>/dev/null)"; then
+          _clast_retro_err "invalid date '$2'"; return 2
+        fi
+        shift 2 ;;
+      --from=*)
+        if ! from="$(clast_parse_date "${1#*=}" 2>/dev/null)"; then
+          _clast_retro_err "invalid date '${1#*=}'"; return 2
+        fi
+        shift ;;
+      --to)
+        if [[ $# -lt 2 ]]; then _clast_retro_err "--to requires a value"; return 2; fi
+        if ! to="$(clast_parse_date "$2" 2>/dev/null)"; then
+          _clast_retro_err "invalid date '$2'"; return 2
+        fi
+        shift 2 ;;
+      --to=*)
+        if ! to="$(clast_parse_date "${1#*=}" 2>/dev/null)"; then
+          _clast_retro_err "invalid date '${1#*=}'"; return 2
+        fi
+        shift ;;
+      --window)
+        if [[ $# -lt 2 ]]; then _clast_retro_err "--window requires a value"; return 2; fi
+        window="$2"; shift 2 ;;
+      --window=*) window="${1#*=}"; shift ;;
+      -h|--help) _clast_retro_usage; return 0 ;;
+      --) shift; break ;;
+      -*) _clast_retro_err "unknown flag '$1'"; return 2 ;;
+      *)  _clast_retro_err "unexpected positional '$1'"; return 2 ;;
+    esac
+  done
+
+  case "$window" in
+    work-days|file-dates) ;;
+    *) _clast_retro_err "--window must be 'work-days' or 'file-dates'"; return 2 ;;
+  esac
+
+  if [[ -n "$from" && -n "$to" && "$from" > "$to" ]]; then
+    _clast_retro_err "--from must be <= --to"; return 2
+  fi
+
+  local manifest
+  manifest="$(clast_retro_manifest \
+    ${from:+--from "$from"} ${to:+--to "$to"} --window "$window")" || return $?
+
+  if [[ -n "${CLAST_JSON:-}" ]]; then
+    if (( bodies )); then
+      manifest="$(_clast_retro_inject_bodies "$manifest")"
+    fi
+    printf '%s\n' "$manifest"
+    return 0
+  fi
+  if (( bodies )); then
+    _clast_retro_err "--bodies is only meaningful with --json"; return 2
+  fi
+  if [[ -n "${CLAST_QUIET:-}" ]]; then
+    return 0
+  fi
+
+  _clast_retro_render "$manifest"
+}
+
+# _clast_retro_inject_bodies <manifest-json>
+#   Add a `body` string (the merged trimmed entry bodies) to every session,
+#   for `--json --bodies`. Reuses clast_retro_session_body so the body matches
+#   the human render byte-for-byte.
+_clast_retro_inject_bodies() {
+  local manifest="$1"
+  local -a pairs=()
+  local sess key body entry0 title interrupted
+  while IFS= read -r sess; do
+    [[ -z "$sess" ]] && continue
+    # Key by session_id, falling back to the first entry path when a
+    # legacy/hand-curated session has no id (JSON null): entries[0] is unique
+    # per session, so id-less sessions don't collide on a shared "null" key.
+    key="$(jq -r '.session_id // .entries[0]' <<<"$sess")"
+    body="$(clast_retro_session_body "$sess")"
+    entry0="$(jq -r '.entries[0]' <<<"$sess")"
+    title=""
+    [[ -r "$entry0" ]] && title="$(clast_entry_title "$entry0")"
+    if printf '%s' "$body" | clast_retro_is_interrupted; then
+      interrupted=true
+    else
+      interrupted=false
+    fi
+    # Body via --rawfile (process substitution), never argv: a single merged
+    # body can exceed MAX_ARG_STRLEN (~128 KiB) and silently fail the exec.
+    pairs+=("$(jq -cn --arg k "$key" --rawfile b <(printf '%s' "$body") \
+      --arg t "$title" --argjson i "$interrupted" \
+      '{key:$k, body:$b, title:$t, interrupted:$i}')")
+  done < <(jq -c '.days[].projects[].sessions[]' <<<"$manifest")
+
+  if (( ${#pairs[@]} == 0 )); then
+    printf '%s' "$manifest"
+    return 0
+  fi
+
+  # Manifest on stdin and the body-bearing pairs via --slurpfile — both can be
+  # large, so neither goes through argv. The `session_id // .entries[0]` key is
+  # always a non-null string, so this can't `$x[null]` abort jq ("Cannot index
+  # object with null") and id-less sessions don't collide on a shared key.
+  printf '%s' "$manifest" | jq -c --slurpfile pairs <(printf '%s\n' "${pairs[@]}") '
+    (reduce $pairs[] as $p ({}; .[$p.key] = $p)) as $x
+    | .days |= map(.projects |= map(.sessions |= map(
+        (.session_id // .entries[0]) as $k
+        | . + {body:        ($x[$k].body // null),
+               title:       ($x[$k].title // null),
+               interrupted: ($x[$k].interrupted // false)} )))
+  '
+}
+
+# _clast_retro_render <manifest-json>
+#   Render the day→project report to stdout.
+_clast_retro_render() {
+  local manifest="$1"
+  local from to window
+  from="$(jq -r '.from // "(start)"' <<<"$manifest")"
+  to="$(jq -r '.to // "(end)"' <<<"$manifest")"
+  window="$(jq -r '.window' <<<"$manifest")"
+  printf 'Retro: %s -> %s (%s)\n' "$from" "$to" "$window"
+
+  local nd
+  nd="$(jq '.days | length' <<<"$manifest")"
+  if (( nd == 0 )); then
+    printf '\n(no sessions in range)\n'
+    return 0
+  fi
+
+  local di pj si
+  local day np project ns sess sid shortsid title entry note body flag
+  for (( di = 0; di < nd; di++ )); do
+    day="$(jq -r ".days[$di].day" <<<"$manifest")"
+    printf '\n== %s ==\n' "$day"
+    note="$(_clast_retro_provenance_note "$day" "$(jq -c ".days[$di].curation_dates // []" <<<"$manifest")")"
+    [[ -n "$note" ]] && printf '%s\n' "$note"
+    np="$(jq ".days[$di].projects | length" <<<"$manifest")"
+    for (( pj = 0; pj < np; pj++ )); do
+      project="$(jq -r ".days[$di].projects[$pj].project_name // .days[$di].projects[$pj].project_path // \"(no project)\"" <<<"$manifest")"
+      printf '\n[%s]\n' "$project"
+      ns="$(jq ".days[$di].projects[$pj].sessions | length" <<<"$manifest")"
+      for (( si = 0; si < ns; si++ )); do
+        sess="$(jq -c ".days[$di].projects[$pj].sessions[$si]" <<<"$manifest")"
+        sid="$(jq -r '.session_id' <<<"$sess")"
+        shortsid="${sid:0:8}"
+        entry="$(jq -r '.entries[0]' <<<"$sess")"
+        title=""
+        [[ -r "$entry" ]] && title="$(clast_entry_title "$entry")"
+        [[ -z "$title" ]] && title="(untitled)"
+        body="$(clast_retro_session_body "$sess")"
+        flag=""
+        printf '%s' "$body" | clast_retro_is_interrupted && flag="  [interrupted]"
+        printf '\n  * %s  (%s)%s\n' "$title" "$shortsid" "$flag"
+        printf '%s\n' "$body"
+      done
+    done
+  done
+}
+
+# _clast_retro_provenance_note <work-day> <curation_dates-json>
+#   One-line note when a day's entries were curated on other date(s) than the
+#   work day. Empty when they match (or there's nothing to say).
+_clast_retro_provenance_note() {
+  local day="$1" cd_json="$2"
+  jq -r --arg d "$day" '
+    if . == [] or . == [$d] then empty
+    else "  (filed " + (join(", ")) + "; work day reconstructed from session snapshots)"
+    end' <<<"$cd_json"
+}

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
@@ -246,11 +304,12 @@ clast_cmd_sessions() {
   # source_mtime.
   local -a rows=()
   local sid snapshot day_bucket mtime seg abs_path msgs
-  local cached_msgs cached_first cached_last
+  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; do
+  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
@@ -293,6 +352,40 @@ clast_cmd_sessions() {
     start_ts="${first_ts:-$mtime}"
     end_ts="${last_ts:-$mtime}"
 
+    # 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
@@ -338,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,
@@ -350,7 +446,10 @@ 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 < <(
     if [[ -f "$manifest_path" ]]; then
@@ -361,7 +460,8 @@ clast_cmd_sessions() {
           ({}; .[$l.session_id] = $l)
         | to_entries[] | .value
         | [.session_id, .snapshot, .day_bucket, .source_mtime,
-           .msg_count, .first_ts, .last_ts] | @tsv
+           .msg_count, .first_ts, .last_ts,
+           .user_msg_count, .assistant_msg_count] | @tsv
       ' "$manifest_path"
     fi
   )

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
 
@@ -113,14 +114,35 @@ clast_cmd_show() {
   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")"
@@ -174,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,
@@ -187,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
@@ -208,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'
@@ -231,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() {
@@ -118,6 +113,7 @@ clast_cmd_snapshot() {
   if [[ -d "$projects_dir" ]]; then
     local source segment session_id mtime_epoch mtime_iso source_size
     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")")"
@@ -181,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"
 
@@ -209,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" "$msg_count" "$first_ts" "$last_ts"; 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