@procrastivity/clast 0.0.4 → 0.0.5

package/README.md

@@ -9,7 +9,7 @@ Capture, curate, and surface Claude Code session history across all your project
 - **CLI** — two binaries, porcelain over plumbing:
   - `clast` — porcelain (LLM-aware): `clast wake`, `clast brief`. See [run without Claude Code](./docs/guides/run-without-claude-code.md).
   - `clast-plumbing` — deterministic core: snapshot, browse, and query your Claude Code session JSONL history.
-- **Plugin** — installs skills (`/day-wakeup`, `/wakeup`) that surface recent session context.
+- **Plugin** — installs skills (`/wake`, `/brief`) that surface recent session context.
 - **SessionStart hook** — quietly snapshots active sessions in the background each time Claude Code starts.
 
 ## Capture your sessions
@@ -66,7 +66,7 @@ clast-plumbing breadcrumb --read --project xesapps
 clast-plumbing breadcrumb --read --global
 ```
 
-Breadcrumbs are append-only one-line notes for `/wakeup` and `/day-wakeup`.
+Breadcrumbs are append-only one-line notes for `/brief` and `/wake`.
 See [`docs/reference/cli.md#clast-breadcrumb`](./docs/reference/cli.md#clast-breadcrumb)
 for the full command contract.
 
@@ -144,21 +144,21 @@ current with zero manual effort. The hook is best-effort and silent: if the
 [`docs/reference/plugin.md#hook-sessionstart`](./docs/reference/plugin.md#hook-sessionstart)
 for the hook's design rationale.
 
-### `/day-wakeup`
+### `/wake`
 
-At the start of each day, run `/day-wakeup` inside any Claude Code session after
+At the start of each day, run `/wake` inside any Claude Code session after
 the plugin is installed. It performs once-per-day cross-project curation of
 yesterday's sessions into durable journal entries, walking each uncurated session
 through a draft you can accept, edit, skip, or mark for in-entry promotion. See
-[`docs/reference/plugin.md#skill-1-day-wakeup`](./docs/reference/plugin.md#skill-1-day-wakeup).
+[`docs/reference/plugin.md#skill-1-wake`](./docs/reference/plugin.md#skill-1-wake).
 
-### `/wakeup`
+### `/brief`
 
-When starting work on a specific project, run `/wakeup` (or `/wakeup <slug>` from
+When starting work on a specific project, run `/brief` (or `/brief <slug>` from
 anywhere) to get a per-project read-only briefing synthesized from recent curated entries,
-today's breadcrumbs, and any sessions already started today. `/wakeup` never writes — it
+today's breadcrumbs, and any sessions already started today. `/brief` never writes — it
 only reads. See
-[`docs/reference/plugin.md#skill-2-wakeup`](./docs/reference/plugin.md#skill-2-wakeup).
+[`docs/reference/plugin.md#skill-2-brief`](./docs/reference/plugin.md#skill-2-brief).
 
 ## Development
 

package/bin/clast

@@ -1,7 +1,8 @@
 #!/usr/bin/env bash
 # clast — porcelain over clast-plumbing, with an OpenAI-compatible LLM
-# provider. Owns the `wake` and `brief` subcommands. Every other verb is a
-# clean error — the porcelain does not proxy to plumbing.
+# provider. Owns the `wake` and `brief` subcommands, plus `undismiss` as a
+# convenience passthrough to plumbing (recovers an accidental [d] in wake).
+# Every other verb is a clean error — the porcelain does not broadly proxy.
 #
 # Subcommand files live in $CLAST_LIB/clast-porcelain-subcommands/<name>.bash
 # and each defines a single function `clast_cmd_<name>`.
@@ -62,6 +63,16 @@ case "$cmd" in
     source "$CLAST_LIB/clast-porcelain-subcommands/brief.bash"
     clast_cmd_brief "$@"
     ;;
+  retro)
+    # shellcheck source=lib/clast/clast-porcelain-subcommands/retro.bash
+    source "$CLAST_LIB/clast-porcelain-subcommands/retro.bash"
+    clast_cmd_retro "$@"
+    ;;
+  undismiss)
+    # shellcheck source=lib/clast/clast-porcelain-subcommands/undismiss.bash
+    source "$CLAST_LIB/clast-porcelain-subcommands/undismiss.bash"
+    clast_cmd_undismiss "$@"
+    ;;
   *)
     clast_porcelain_log_error "unknown subcommand '$cmd'"
     clast_porcelain_usage >&2

package/bin/clast-plumbing

@@ -18,6 +18,8 @@ source "$CLAST_LIB/clast-decode-lib.bash"
 source "$CLAST_LIB/clast-registry-lib.bash"
 # shellcheck source=lib/clast/clast-manifest-lib.bash
 source "$CLAST_LIB/clast-manifest-lib.bash"
+# shellcheck source=lib/clast/clast-classify-lib.bash
+source "$CLAST_LIB/clast-classify-lib.bash"
 
 # --- Global flag parsing -------------------------------------------------
 #
@@ -165,6 +167,11 @@ case "$cmd" in
     source "$CLAST_LIB/clast-subcommands/doctor.bash"
     clast_cmd_doctor "$@"
     ;;
+  retro)
+    # shellcheck source=lib/clast/clast-subcommands/retro.bash
+    source "$CLAST_LIB/clast-subcommands/retro.bash"
+    clast_cmd_retro "$@"
+    ;;
   *)
     clast_log_error "unknown subcommand '$cmd'"
     clast_usage >&2

package/examples/workflows/morning-briefing.md

@@ -1,11 +1,11 @@
 # Morning Briefing Example
 
-This is a realistic walkthrough of one `/day-wakeup` run. Yesterday, `xesapps`
+This is a realistic walkthrough of one `/wake` run. Yesterday, `xesapps`
 finished a field-normalization fix, `notes` explored a journal template update,
 and `infra-tools` checked a flaky shell lint issue.
 
 ```bash
-# User: /day-wakeup
+# User: /wake
 clast-plumbing snapshot
 clast-plumbing --json sessions --day yesterday
 ```
@@ -43,7 +43,7 @@ AskUserQuestion presents `Accept`, `Accept + promote decision`, `Accept + promot
 common-issue`, `Accept + promote workflow`, `Edit`, `Skip`, and `Stop here`.
 
 The user chooses `Skip`. The skill writes nothing; the session remains
-uncurated and can be revisited in a later `/day-wakeup`.
+uncurated and can be revisited in a later `/wake`.
 
 ## Session 2: notes
 
@@ -123,15 +123,15 @@ clast-plumbing entries write \
 Final summary:
 
 ```text
-Day wakeup complete.
+Wake complete.
 Curated: 2 sessions across 2 projects.
 Skipped: 1 session.
 Remaining uncurated: 1.
 Promoted: 1 decision (folded into the accepted entry for v1.0).
-Run `/wakeup <project>` to start working on a specific project today.
+Run `/brief <project>` to start working on a specific project today.
 ```
 
 What this changes on disk:
 `entries/2026-05-31-1340-notes-entry-template-cleanup.md` and `entries/2026-05-31-0912-xesapps-field-normalization-fix.md` were written.
 `.manifest.jsonl` was already current from `clast-plumbing snapshot`; curation does not append to it.
-The skipped `infra-tools` session stays uncurated and remains eligible for a later `/day-wakeup`.
+The skipped `infra-tools` session stays uncurated and remains eligible for a later `/wake`.

package/lib/clast/clast-classify-lib.bash

@@ -0,0 +1,68 @@
+# clast-classify-lib.bash — deterministic session classification
+#
+# A "no-op" session is one Claude Code captured but that holds no real work:
+# the user opened a session and only ran slash commands (`/clear`, `/model`,
+# `/config`, …) then quit, or typed a prompt and quit before Claude replied.
+# These are worthless to curate, so `wake` auto-dismisses them without ever
+# calling the LLM (see docs/reference/plugin.md + the wake flows).
+#
+# The classification is two counts computed from the transcript JSONL:
+#   user_msg_count      real user prompts — user-role messages that are not
+#                       meta, are non-empty, and are NOT slash-command wrappers.
+#   assistant_msg_count assistant-role messages (presence only; a tool-only
+#                       reply with no text still counts as real work).
+#
+# A session is *substantive* iff assistant_msg_count > 0 — i.e. Claude actually
+# replied. That single test captures both no-op shapes: empty / slash-command-
+# only sessions (/clear, /model, /config) and sessions where the user typed but
+# quit before any response — both have assistant_msg_count == 0. It is
+# deliberately NOT gated on user_msg_count: a custom slash command (e.g.
+# /review) leaves zero prose prompts yet drives real assistant work, and must
+# be kept. user_msg_count is still cached for diagnostics (show, sessions).
+#
+# Counts are computed once at snapshot time and cached on the manifest line
+# (clast-manifest-lib.bash), mirroring msg_count/first_ts/last_ts, so readers
+# never re-open the transcript.
+# shellcheck shell=bash
+
+if [[ -n "${_CLAST_CLASSIFY_LIB_SOURCED:-}" ]]; then
+  return 0
+fi
+_CLAST_CLASSIFY_LIB_SOURCED=1
+
+# Slash-command / local-command marker set. A user-role message whose text
+# contains any of these is Claude Code bookkeeping (e.g. `/clear`, `/model`),
+# not a real prompt. Centralized here so the classifier and show.bash's
+# first_prompt/last_prompt extraction share one definition.
+CLAST_COMMAND_MARKER_RE='<command-name>|<command-message>|<command-args>|<local-command-stdout>|<local-command-stderr>|<local-command-caveat>'
+export CLAST_COMMAND_MARKER_RE
+
+# clast_session_msg_counts <transcript-path>
+#   Print "<user_msg_count>\t<assistant_msg_count>" (tab-separated) for the
+#   given JSONL transcript. Missing/unreadable file prints "0\t0".
+#
+#   Streaming (`reduce inputs`), not slurp: a multi-megabyte transcript is
+#   read one line at a time, O(1) memory. `fromjson?` silently drops malformed
+#   lines, matching the tolerance in clast_manifest_iterate.
+clast_session_msg_counts() {
+  local path="$1"
+  if [[ -z "$path" || ! -r "$path" ]]; then
+    printf '0\t0\n'
+    return 0
+  fi
+  jq -n -R -r --arg cmd_re "$CLAST_COMMAND_MARKER_RE" '
+    def role: (.message.role // .role // .type);
+    def text_str:
+      (.message.content // .content // "")
+      | if type == "array" then (map(.text? // "") | join(" ")) else (. | tostring) end;
+    reduce (inputs | fromjson?) as $l ({u: 0, a: 0};
+      if ($l.isMeta // false) == true then .
+      elif ($l | role) == "user" then
+        ( ($l | text_str) as $t
+          | if ($t | gsub("\\s"; "")) != "" and ($t | test($cmd_re) | not)
+            then .u += 1 else . end )
+      elif ($l | role) == "assistant" then .a += 1
+      else . end
+    ) | "\(.u)\t\(.a)"
+  ' "$path" 2>/dev/null || printf '0\t0\n'
+}

package/lib/clast/clast-dismissed-lib.bash

@@ -72,3 +72,73 @@ clast_dismissed_check() {
 
   grep -q "\"session_id\":\"$session_id\"" "$dismissed_file" 2>/dev/null
 }
+
+# clast_dismissed_remove <session-id> — drop all records for a session,
+# reversing a dismissal. Prints the number of records removed to stdout.
+# Returns 0 if anything was removed, 1 if the session was not dismissed.
+clast_dismissed_remove() {
+  local session_id="$1"
+  if [[ -z "$session_id" ]]; then
+    clast_log_error "clast_dismissed_remove: empty session_id"
+    return 2
+  fi
+
+  local dismissed_file
+  dismissed_file="$(clast_dismissed_path)"
+
+  if [[ ! -f "$dismissed_file" ]]; then
+    printf '0\n'
+    return 1
+  fi
+
+  # Count matches, then rewrite the log without them. A match is a
+  # well-formed JSON *object* whose session_id equals the target;
+  # `try fromjson catch null` turns unparseable lines into null so they
+  # never match, and the `type == "object"` guard keeps non-object JSON
+  # (numbers, strings) from erroring on `.session_id`. This mirrors the
+  # tolerant read in clast_dismissed_set.
+  local removed
+  removed="$(jq -rRn --arg sid "$session_id" '
+    [ inputs
+      | (try fromjson catch null) as $obj
+      | select(($obj | type) == "object" and $obj.session_id == $sid)
+    ] | length
+  ' "$dismissed_file" 2>/dev/null)" || removed=0
+  [[ -z "$removed" ]] && removed=0
+
+  if (( removed == 0 )); then
+    printf '0\n'
+    return 1
+  fi
+
+  local tmp
+  tmp="$(mktemp "${dismissed_file}.XXXXXX")" || {
+    clast_log_error "clast_dismissed_remove: failed to create temp file"
+    return 2
+  }
+  # Emit every line except well-formed objects matching the target id.
+  # Malformed lines parse to null (type != "object") and so are preserved
+  # verbatim rather than silently dropped. Rewrite goes through a temp file
+  # + mv so a crash mid-write can't truncate the log.
+  if jq -Rr --arg sid "$session_id" '
+    . as $line
+    | (try ($line | fromjson) catch null) as $obj
+    | if ($obj | type) == "object" and $obj.session_id == $sid
+      then empty
+      else $line
+      end
+  ' "$dismissed_file" >"$tmp" 2>/dev/null; then
+    if ! mv "$tmp" "$dismissed_file"; then
+      rm -f "$tmp"
+      clast_log_error "clast_dismissed_remove: failed to replace log"
+      return 2
+    fi
+  else
+    rm -f "$tmp"
+    clast_log_error "clast_dismissed_remove: rewrite failed"
+    return 2
+  fi
+
+  printf '%s\n' "$removed"
+  return 0
+}

package/lib/clast/clast-lib.bash

@@ -55,6 +55,78 @@ clast_json_get() {
   jq -r "$expr" <<<"$input"
 }
 
+# --- Front-matter / YAML -------------------------------------------------
+#
+# Curated journal entries are Markdown with a leading YAML front-matter block
+# fenced by `---`. These two primitives are the single source of truth for
+# reading that block; `entries.bash` and `clast-retro-lib.bash` both build on
+# them.
+
+# clast_read_frontmatter <path>
+#   Emit the raw front-matter lines (between the first two `---` fences) to
+#   stdout. Nothing is emitted for a file without a front-matter block.
+clast_read_frontmatter() {
+  local path="$1"
+  awk '
+    BEGIN { in_fm = 0; seen = 0 }
+    /^---[[:space:]]*$/ {
+      if (!seen) { in_fm = 1; seen = 1; next }
+      if (in_fm) { exit }
+    }
+    in_fm { print }
+  ' "$path"
+}
+
+# clast_yaml_unquote <string>
+#   Strip surrounding double quotes and unescape \", \\, \n on a YAML scalar.
+#   A bare (unquoted) value is returned unchanged.
+clast_yaml_unquote() {
+  local v="$1"
+  if [[ "${v:0:1}" == '"' && "${v: -1}" == '"' && ${#v} -ge 2 ]]; then
+    v="${v:1:${#v}-2}"
+    # Process escapes in order: \\ → placeholder, \" → ", \n → LF, placeholder → \
+    v="${v//\\\\/$'\x01'}"
+    v="${v//\\\"/\"}"
+    v="${v//\\n/$'\n'}"
+    v="${v//$'\x01'/\\}"
+  fi
+  printf '%s' "$v"
+}
+
+# clast_entry_body <path>
+#   Emit the entry body — everything after the closing `---` of the
+#   front-matter block. A file with no front-matter is emitted whole.
+clast_entry_body() {
+  awk '
+    BEGIN { in_fm = 0; seen = 0; past = 0 }
+    !past && /^---[[:space:]]*$/ {
+      if (!seen) { in_fm = 1; seen = 1; next }
+      if (in_fm) { in_fm = 0; past = 1; next }
+    }
+    past { print; next }
+    !seen { print }   # no front-matter fence yet seen → plain file, echo through
+  ' "$1"
+}
+
+# clast_entry_title <path>
+#   The session title from `# Session: <title>` (first non-blank body line).
+#   Empty if absent.
+clast_entry_title() {
+  awk '
+    BEGIN { in_fm = 0; seen = 0; past = 0 }
+    /^---[[:space:]]*$/ {
+      if (!seen) { in_fm = 1; seen = 1; next }
+      if (in_fm) { in_fm = 0; past = 1; next }
+    }
+    in_fm { next }
+    past {
+      if ($0 ~ /^[[:space:]]*$/) next
+      if (sub(/^# Session: /, "")) { print; exit }
+      exit
+    }
+  ' "$1"
+}
+
 # --- Date math -----------------------------------------------------------
 #
 # Uses GNU `date -d` for relative-date math. The nix dev shell pulls in
@@ -71,22 +143,31 @@ _clast_now_epoch() {
   fi
 }
 
-# clast_today — local YYYY-MM-DD, adjusted by CLAST_DAY_CUTOFF (HH:MM, default 04:00).
-# A session starting before today's cutoff belongs to yesterday's bucket.
-clast_today() {
+# clast_day_bucket_for_epoch <epoch> — local YYYY-MM-DD for an epoch, adjusted
+# by CLAST_DAY_CUTOFF (HH:MM, default 04:00). Work before the cutoff belongs to
+# the previous day's bucket. Single source of truth for the day-bucket rule;
+# clast_today, `clast snapshot`, and `clast retro` all build on it.
+clast_day_bucket_for_epoch() {
+  local epoch="$1"
   local cutoff="${CLAST_DAY_CUTOFF:-04:00}"
-  local cutoff_hours cutoff_mins cutoff_secs now adjusted
+  local cutoff_hours cutoff_mins cutoff_secs adjusted
   cutoff_hours="${cutoff%%:*}"
   cutoff_mins="${cutoff##*:}"
   # Strip leading zeros so bash arithmetic doesn't treat them as octal.
   cutoff_hours=$((10#$cutoff_hours))
   cutoff_mins=$((10#$cutoff_mins))
   cutoff_secs=$((cutoff_hours * 3600 + cutoff_mins * 60))
-  now="$(_clast_now_epoch)"
-  adjusted=$((now - cutoff_secs))
+  adjusted=$((epoch - cutoff_secs))
+  # GNU `date -d` — BSD date not supported, per overview.md.
   date -d "@$adjusted" +%Y-%m-%d
 }
 
+# clast_today — local YYYY-MM-DD, adjusted by CLAST_DAY_CUTOFF (HH:MM, default 04:00).
+# A session starting before today's cutoff belongs to yesterday's bucket.
+clast_today() {
+  clast_day_bucket_for_epoch "$(_clast_now_epoch)"
+}
+
 # clast_parse_date <input> — print YYYY-MM-DD on stdout, exit non-zero on bad input.
 # Accepts:
 #   - ISO date: 2026-05-30
@@ -219,6 +300,7 @@ Subcommands:
   breadcrumb    Append a one-line in-flight hint
   registry      Manage the project registry
   stats         Token/duration/session-count stats
+  retro         Work summary grouped by actual work day → project
   doctor        Sanity-check the journal
 
 Global flags:

package/lib/clast/clast-manifest-lib.bash

@@ -13,6 +13,13 @@ if [[ -n "${_CLAST_MANIFEST_LIB_SOURCED:-}" ]]; then
 fi
 _CLAST_MANIFEST_LIB_SOURCED=1
 
+# clast_manifest_rebuild_from_disk backfills the session-classification counts
+# via clast_session_msg_counts. Source the classify lib relative to this file
+# (not via CLAST_LIB) so callers that source manifest-lib directly — e.g. the
+# test suite — get the dependency without extra setup.
+# shellcheck source=lib/clast/clast-classify-lib.bash
+source "${BASH_SOURCE[0]%/*}/clast-classify-lib.bash"
+
 # clast_manifest_path — single chokepoint so CLAST_JOURNAL_DIR override
 # (via clast_journal_dir) redirects every read/write in this file.
 clast_manifest_path() {
@@ -26,10 +33,10 @@ _clast_manifest_now_iso() {
   date -u -d "@$epoch" +%Y-%m-%dT%H:%M:%SZ
 }
 
-# clast_manifest_append <session-id> <source> <snapshot> <source-mtime> <source-size> <day-bucket> <msg-count> <first-ts> <last-ts>
+# clast_manifest_append <session-id> <source> <snapshot> <source-mtime> <source-size> <day-bucket> <msg-count> <first-ts> <last-ts> <user-msg-count> <assistant-msg-count>
 clast_manifest_append() {
-  if [[ $# -ne 9 ]]; then
-    clast_log_error "clast_manifest_append: expected 9 args, got $#"
+  if [[ $# -ne 11 ]]; then
+    clast_log_error "clast_manifest_append: expected 11 args, got $#"
     return 2
   fi
   local session_id="$1" source="$2" snapshot="$3" source_mtime="$4" source_size="$5" day_bucket="$6"
@@ -38,6 +45,11 @@ clast_manifest_append() {
   # ("" → stored as JSON null). Readers prefer these over re-reading the
   # snapshot file, falling back to the file when a line predates the cache.
   local msg_count="$7" first_ts="$8" last_ts="$9"
+  # Session classification (clast-classify-lib.bash): counts of real user
+  # prompts and assistant replies. A session is a no-op (auto-dismissed by
+  # wake) when either is 0. Cached here so readers never re-open the
+  # transcript; legacy lines lack them and readers recompute on demand.
+  local user_msg_count="${10}" assistant_msg_count="${11}"
   local field
   for field in session_id source snapshot source_mtime source_size day_bucket; do
     if [[ -z "${!field}" ]]; then
@@ -53,6 +65,14 @@ clast_manifest_append() {
     clast_log_error "clast_manifest_append: msg_count must be a non-negative integer, got '$msg_count'"
     return 2
   fi
+  if ! [[ "$user_msg_count" =~ ^[0-9]+$ ]]; then
+    clast_log_error "clast_manifest_append: user_msg_count must be a non-negative integer, got '$user_msg_count'"
+    return 2
+  fi
+  if ! [[ "$assistant_msg_count" =~ ^[0-9]+$ ]]; then
+    clast_log_error "clast_manifest_append: assistant_msg_count must be a non-negative integer, got '$assistant_msg_count'"
+    return 2
+  fi
 
   local journal_dir
   journal_dir="$(clast_journal_dir)"
@@ -74,7 +94,9 @@ clast_manifest_append() {
     --argjson msg_count "$msg_count" \
     --arg first_ts "$first_ts" \
     --arg last_ts "$last_ts" \
-    '{session_id: $session_id, source: $source, snapshot: $snapshot, captured_at: $captured_at, source_mtime: $source_mtime, source_size: $source_size, day_bucket: $day_bucket, msg_count: $msg_count, first_ts: (if $first_ts == "" then null else $first_ts end), last_ts: (if $last_ts == "" then null else $last_ts end)}')" || {
+    --argjson user_msg_count "$user_msg_count" \
+    --argjson assistant_msg_count "$assistant_msg_count" \
+    '{session_id: $session_id, source: $source, snapshot: $snapshot, captured_at: $captured_at, source_mtime: $source_mtime, source_size: $source_size, day_bucket: $day_bucket, msg_count: $msg_count, first_ts: (if $first_ts == "" then null else $first_ts end), last_ts: (if $last_ts == "" then null else $last_ts end), user_msg_count: $user_msg_count, assistant_msg_count: $assistant_msg_count}')" || {
     clast_log_error "clast_manifest_append: jq failed to build manifest line"
     return 1
   }
@@ -205,6 +227,12 @@ clast_manifest_rebuild_from_disk() {
       last_ts="$(tail -n1 "$snapshot" 2>/dev/null | jq -r '.timestamp // empty' 2>/dev/null || true)"
       msg_count="$(wc -l <"$snapshot" 2>/dev/null | tr -d ' ')"
       [[ "$msg_count" =~ ^[0-9]+$ ]] || msg_count=0
+      # Session classification counts are equally recoverable from the copy.
+      local user_msg_count assistant_msg_count
+      IFS=$'\t' read -r user_msg_count assistant_msg_count \
+        < <(clast_session_msg_counts "$snapshot")
+      [[ "$user_msg_count" =~ ^[0-9]+$ ]] || user_msg_count=0
+      [[ "$assistant_msg_count" =~ ^[0-9]+$ ]] || assistant_msg_count=0
       line="$(jq -c -n \
         --arg session_id "$session_id" \
         --arg snapshot "${snapshot#"$journal_dir/"}" \
@@ -214,7 +242,9 @@ clast_manifest_rebuild_from_disk() {
         --argjson msg_count "$msg_count" \
         --arg first_ts "$first_ts" \
         --arg last_ts "$last_ts" \
-        '{session_id: $session_id, source: null, snapshot: $snapshot, captured_at: $captured_at, source_mtime: $source_mtime, source_size: 0, day_bucket: $day_bucket, msg_count: $msg_count, first_ts: (if $first_ts == "" then null else $first_ts end), last_ts: (if $last_ts == "" then null else $last_ts end)}')" || {
+        --argjson user_msg_count "$user_msg_count" \
+        --argjson assistant_msg_count "$assistant_msg_count" \
+        '{session_id: $session_id, source: null, snapshot: $snapshot, captured_at: $captured_at, source_mtime: $source_mtime, source_size: 0, day_bucket: $day_bucket, msg_count: $msg_count, first_ts: (if $first_ts == "" then null else $first_ts end), last_ts: (if $last_ts == "" then null else $last_ts end), user_msg_count: $user_msg_count, assistant_msg_count: $assistant_msg_count}')" || {
         clast_log_error "clast_manifest_rebuild_from_disk: jq failed for '$snapshot'"
         rm -f "$tmp_file"
         return 1

package/lib/clast/clast-porcelain-lib.bash

@@ -52,8 +52,10 @@ Usage:
   clast [GLOBAL FLAGS] <subcommand> [ARGS...]
 
 Subcommands:
-  wake          Interactive day curation (standalone equivalent of /day-wakeup)
-  brief         Project briefing (standalone equivalent of /wakeup)
+  wake          Interactive day curation (standalone equivalent of /wake)
+  brief         Project briefing (standalone equivalent of /brief)
+  retro         Model-condensed work retrospective by work day → project
+  undismiss     Restore session(s) dismissed in wake (by session id)
 
 Global flags:
   -h, --help    Print this usage and exit
@@ -120,26 +122,37 @@ clast_porcelain_llm_chat() {
   local system_msg="$1"
   local user_msg="$2"
 
-  local payload
-  payload="$(jq -cn \
-    --arg model "$CLAST_LLM_MODEL" \
-    --arg system "$system_msg" \
-    --arg user "$user_msg" \
-    '{
-      model: $model,
-      messages: [
-        {role: "system", content: $system},
-        {role: "user", content: $user}
-      ],
-      temperature: 0.3
-    }')"
+  # Build and send the request without ever passing the (possibly hundreds of
+  # KB) prompt through argv: a single argument above MAX_ARG_STRLEN (128KB on
+  # Linux) fails with "Argument list too long", even well under total ARG_MAX.
+  # jq reads the strings via --rawfile (process substitution; printf is a
+  # builtin with no argv limit) and curl reads the body from a file with @.
+  local payload_file
+  payload_file="$(mktemp)" || { clast_porcelain_warn "failed to create temp file"; return 1; }
+  if ! jq -cn \
+      --arg model "$CLAST_LLM_MODEL" \
+      --rawfile system <(printf '%s' "$system_msg") \
+      --rawfile user <(printf '%s' "$user_msg") \
+      '{
+        model: $model,
+        messages: [
+          {role: "system", content: $system},
+          {role: "user", content: $user}
+        ],
+        temperature: 0.3
+      }' >"$payload_file"; then
+    rm -f "$payload_file"
+    clast_porcelain_warn "failed to build LLM request payload"
+    return 1
+  fi
 
   local response http_code body
   response="$(curl -s -w '\n%{http_code}' \
     "${CLAST_LLM_BASE_URL}/chat/completions" \
     -H "Authorization: Bearer $CLAST_LLM_API_KEY" \
     -H "Content-Type: application/json" \
-    -d "$payload" 2>&1)" || true
+    --data-binary @"$payload_file" 2>&1)" || true
+  rm -f "$payload_file"
 
   http_code="$(tail -n1 <<<"$response")"
   body="$(sed '$d' <<<"$response")"