@procrastivity/clast 0.0.4 → 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
@@ -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

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`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@procrastivity/clast",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Capture, curate, and surface Claude Code session history across all your projects.",
   "homepage": "https://github.com/procrastivity/clast#readme",
   "bin": {
@@ -11,6 +11,7 @@
     "bin/",
     "lib/",
     ".claude-plugin/",
+    "skills/",
     "hooks/",
     "examples/",
     "README.md",

package/{.claude-plugin/skills/wakeup → skills/brief}/SKILL.md

@@ -1,16 +1,16 @@
 ---
-name: wakeup
+name: brief
 description: |
-  Synthesize a briefing for the current project (or a named one) so the user can resume work without re-explaining context. Use when the user says "/wakeup", "wakeup", "wake up", "catch me up", "where was I", "what was I working on", "load last session", "resume", or otherwise signals they want prior context for the project they're about to work on. Optionally accepts a project slug like "/wakeup xesapps". Reads recent curated entries and today's breadcrumbs from `~/.claude/journal/` and produces a 2–5k-token briefing. This is the per-project read flow; for cross-project daily curation use /day-wakeup; for mid-session pivots use session-brief.
+  Synthesize a briefing for the current project (or a named one) so the user can resume work without re-explaining context. Use when the user says "/brief", "brief me", "catch me up", "where was I", "what was I working on", "load last session", "resume", or otherwise signals they want prior context for the project they're about to work on. Optionally accepts a project slug like "/brief xesapps". Reads recent curated entries and today's breadcrumbs from `~/.claude/journal/` and produces a 2–5k-token briefing. This is the per-project read flow; for cross-project daily curation use /wake; for mid-session pivots use session-brief.
 ---
 
-# Wakeup
+# Brief
 
 Synthesize a briefing for the current (or named) project so the user can resume without re-explaining context.
 
 ## Why this exists
 
-`/day-wakeup` curates yesterday's work into entries. `/wakeup` reads those entries back when starting work in a specific repo. The two are complementary: one writes, one reads.
+`/wake` curates yesterday's work into entries. `/brief` reads those entries back when starting work in a specific repo. The two are complementary: one writes, one reads.
 
 ## Step 0: Resolve the clast-plumbing binary
 
@@ -39,13 +39,13 @@ Use `$CLAST_BIN` in place of bare `clast-plumbing` for all commands in this skil
 
 ## Step 1: Resolve the project
 
-If the user passed a slug as an argument (`/wakeup xesapps`), use it directly. Otherwise resolve from current working directory:
+If the user passed a slug as an argument (`/brief xesapps`), use it directly. Otherwise resolve from current working directory:
 
 ```bash
 $CLAST_BIN registry resolve "$(pwd)"
 ```
 
-If `pwd` doesn't resolve and no slug was given: print "Not in a registered project. Run `clast-plumbing registry add .` first, or invoke as `/wakeup <slug>`." and stop.
+If `pwd` doesn't resolve and no slug was given: print "Not in a registered project. Run `clast-plumbing registry add .` first, or invoke as `/brief <slug>`." and stop.
 
 ## Step 2: Gather data
 
@@ -73,7 +73,7 @@ $CLAST_BIN entries read <entry-path>
 Using the **synthesis prompt** (see below), produce a briefing of 2–5k tokens. Structure:
 
 ```
-## Wakeup briefing — <project>
+## Brief — <project>
 
 **Active thread:** <one-line from most recent entry's "Open threads" section, or "None">
 
@@ -101,11 +101,11 @@ End with one of:
 
 ## Step 4: Don't write anything
 
-Wakeup is read-only. Never invoke write-form subcommands (`entries write`, `breadcrumb '<text>'`, `snapshot`) from this skill.
+Brief is read-only. Never invoke write-form subcommands (`entries write`, `breadcrumb '<text>'`, `snapshot`) from this skill.
 
 ## Edge cases
 
-- **No entries for project**: print "No curated entries for `<slug>` yet. Run `/day-wakeup` to process recent sessions, or run `clast-plumbing sessions --project <slug>` to see what's available." and stop.
+- **No entries for project**: print "No curated entries for `<slug>` yet. Run `/wake` to process recent sessions, or run `clast-plumbing sessions --project <slug>` to see what's available." and stop.
 - **Slug resolves but no entries and no sessions**: print "Project `<slug>` registered but has no journal activity yet."
 - **Today's session count > 5**: summarize ("worked 12 sessions today, most recent 16:22 on branch `loop-guard-ngram`") rather than listing all.
 

package/{.claude-plugin/skills/day-wakeup → skills/wake}/SKILL.md

@@ -1,17 +1,17 @@
 ---
-name: day-wakeup
-description: 'Generate curated journal entries from yesterday''s Claude Code sessions across all projects. Use when the user says "/day-wakeup", "day wakeup", "morning briefing", "catch me up on yesterday", "what did I work on yesterday", "review my day", "process yesterday''s sessions", or otherwise signals they want to curate prior work across projects at the start of a new day. Runs `clast-plumbing snapshot` to ensure fresh data, then walks through each uncurated session from yesterday and proposes a draft entry the user can accept, edit, or skip. Prompts for promotion of decisions, common-issues, and workflows per accepted session. This is the once-per-day curation flow; for per-project briefings use /wakeup; for mid-session pivots use session-brief.'
+name: wake
+description: 'Generate curated journal entries from yesterday''s Claude Code sessions across all projects. Use when the user says "/wake", "wake", "morning briefing", "catch me up on yesterday", "what did I work on yesterday", "review my day", "process yesterday''s sessions", or otherwise signals they want to curate prior work across projects at the start of a new day. Runs `clast-plumbing snapshot` to ensure fresh data, then walks through each uncurated session from yesterday and proposes a draft entry the user can accept, edit, or skip. Prompts for promotion of decisions, common-issues, and workflows per accepted session. This is the once-per-day curation flow; for per-project briefings use /brief; for mid-session pivots use session-brief.'
 ---
 
-# Day Wakeup
+# Wake
 
 Process yesterday's Claude Code sessions across all projects. For each session, generate a draft journal entry and walk the user through accepting/editing/skipping it.
 
 ## Why this exists
 
-Curation at end-of-session has high friction (the user wants to stop, not summarize). Curation at start-of-next-day has lower friction (fresh eyes, easier to decide what's worth keeping). `/day-wakeup` is that start-of-next-day flow.
+Curation at end-of-session has high friction (the user wants to stop, not summarize). Curation at start-of-next-day has lower friction (fresh eyes, easier to decide what's worth keeping). `/wake` is that start-of-next-day flow.
 
-The transcripts themselves are captured automatically by the SessionStart hook + cron — the user never has to remember to log anything. What `/day-wakeup` does is **curate the captured transcripts into durable entries the user controls**, and prompt for promotion of decisions, common-issues, and workflows along the way.
+The transcripts themselves are captured automatically by the SessionStart hook + cron — the user never has to remember to log anything. What `/wake` does is **curate the captured transcripts into durable entries the user controls**, and prompt for promotion of decisions, common-issues, and workflows along the way.
 
 ## Step 0: Resolve the clast-plumbing binary
 
@@ -58,6 +58,27 @@ $CLAST_BIN --json sessions --since -30d
 
 Filter to sessions with `curated: false` or `stale: true` (stale sessions were curated but their transcript was updated since). If none remain, print "Nothing to curate — all sessions are curated or dismissed." and stop.
 
+### Step 2a: Auto-dismiss no-op sessions (deterministic, no LLM)
+
+Each session row carries a deterministic `substantive` flag (computed by
+`clast-plumbing` from the transcript, cached at snapshot time). A session is
+`substantive: false` when **Claude never replied** — an empty session, one that
+contains only slash commands like `/clear`, `/model`, `/config`, or one abandoned
+before any response. These are worthless to curate. (A session driven by a *custom*
+slash command still has assistant replies, so it stays `substantive: true`.)
+
+Before generating any drafts, auto-dismiss every uncurated session with
+`substantive == false` (skip this if the user set `CLAST_WAKE_AUTODISMISS_NOOP=0`):
+
+```bash
+$CLAST_BIN sessions dismiss <session-id> --reason "auto: no substantive content (empty / slash-command-only)"
+```
+
+Do **not** call the LLM for these. Dismissal is reversible via `clast undismiss <id>`.
+Remove them from the working set, keep a count, and report it in the final summary
+(e.g. "Auto-dismissed 5 no-op session(s)."). If nothing substantive remains after this,
+print "Nothing to curate — all remaining sessions were empty or slash-command-only." and stop.
+
 ### Triage when multiple days have uncurated sessions
 
 If uncurated sessions span more than one day (e.g., after a weekend or break), present a triage step before processing. Show a per-day breakdown:
@@ -113,15 +134,16 @@ For each session in the list:
    - **Accept** (any combination of accept-flavored options): pipe the draft to `clast-plumbing entries write` via stdin.
    - **Edit**: prompt the user for what to change, regenerate the draft incorporating their feedback, loop.
    - **Skip**: do not write.
-   - **Stop here**: end the entire `/day-wakeup` flow, leaving remaining sessions uncurated (user can resume tomorrow).
+   - **Stop here**: end the entire `/wake` flow, leaving remaining sessions uncurated (user can resume tomorrow).
 
 ## Step 4: Final summary
 
 After all sessions are processed (or user stopped early), print a summary:
 
 ```
-Day wakeup complete.
+Wake complete.
 Curated: 3 sessions across 2 projects.
+Auto-dismissed (no-op): 5 sessions.
 Skipped: 1 session.
 Remaining uncurated: 0.
 
@@ -130,15 +152,15 @@ Promoted:
   Common-issues: 0
   Workflows: 1
 
-Run `/wakeup <project>` to start working on a specific project today.
+Run `/brief <project>` to start working on a specific project today.
 ```
 
 ## Draft generation prompt
 
-The prompt templates live in `lib/clast/prompts/` so they are shared with the porcelain `clast wake` subcommand:
+The prompt templates are installed alongside the plugin under `$CLAUDE_PLUGIN_ROOT/lib/clast/prompts/`:
 
-- **System prompt:** `lib/clast/prompts/day-wakeup-draft-system.md`
-- **User prompt template:** `lib/clast/prompts/day-wakeup-draft-user.md` (uses `{{placeholder}}` syntax)
+- **System prompt:** `$CLAUDE_PLUGIN_ROOT/lib/clast/prompts/wake-draft-system.md`
+- **User prompt template:** `$CLAUDE_PLUGIN_ROOT/lib/clast/prompts/wake-draft-user.md` (uses `{{placeholder}}` syntax)
 
 When generating each draft, read those files and substitute the placeholders with session data. The user prompt template uses these placeholders: `{{project}}`, `{{branch}}`, `{{start}}`, `{{end}}`, `{{msg_count}}`, `{{first_turns}}`, `{{last_turns}}`, `{{breadcrumbs}}`.
 
@@ -156,7 +178,7 @@ After showing the draft, present:
   - `Accept + promote workflow` — also write a workflow file
   - `Edit` — user wants to revise; will prompt for changes
   - `Skip` — do not write this entry
-  - `Stop here` — end /day-wakeup entirely, leave remaining sessions uncurated
+  - `Stop here` — end /wake entirely, leave remaining sessions uncurated
 
 If `Skip` and `Stop here` are both selected, treat as `Stop here`. If `Edit` is selected alongside any accept option, treat as `Edit` first (the user wants to revise before accepting).
 
@@ -199,6 +221,7 @@ For promoted items (decisions, common-issues, workflows): currently these are tr
 ## Edge cases
 
 - **No uncurated sessions**: print "Nothing to curate — all sessions are curated or dismissed." and stop.
+- **All uncurated sessions are no-ops**: after Step 2a auto-dismisses them, nothing substantive remains — print "Nothing to curate — all remaining sessions were empty or slash-command-only." and stop.
 - **Multi-day backlog**: present the triage step (Step 2) so the user can choose scope before processing.
 - **`clast-plumbing snapshot` fails**: warn the user, then attempt to proceed with whatever's already in the manifest.
 - **`clast-plumbing show` fails for a specific session**: skip that session, note it in the final summary, continue with the rest.