npm - @procrastivity/clast - Versions diffs - 0.0.5 → 0.0.7 - Mend

@procrastivity/clast 0.0.5 → 0.0.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/lib/clast/clast-porcelain-lib.bash +21 -0
package/lib/clast/clast-porcelain-subcommands/retro.bash +77 -11
package/lib/clast/clast-porcelain-subcommands/wake.bash +97 -10
package/package.json +1 -1
package/skills/wake/SKILL.md +35 -4

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

@@ -21,6 +21,27 @@ clast_porcelain_info() { printf '%s\n' "$1"; }
 clast_porcelain_log_error() { printf 'clast: error: %s\n' "$1" >&2; }
+# --- Timing ------------------------------------------------------------------
+#
+# Shared by the porcelain subcommands that time model calls (wake, retro) so
+# their progress output stays consistent.
+# clast_porcelain_now — epoch seconds with fraction (GNU date). Falls back to
+# whole seconds where `%N` is unsupported (e.g. BSD/macOS date echoes a literal
+# N). Pair two readings with clast_porcelain_elapsed.
+clast_porcelain_now() {
+  local t
+  t="$(date +%s.%N 2>/dev/null)" || t="$(date +%s)"
+  [[ "$t" == *N* ]] && t="$(date +%s)"
+  printf '%s' "$t"
+}
+# clast_porcelain_elapsed <start> <end> — seconds between two clast_porcelain_now
+# readings, one decimal place (never negative).
+clast_porcelain_elapsed() {
+  awk -v a="$1" -v b="$2" 'BEGIN { d = b - a; if (d < 0) d = 0; printf "%.1f", d }'
+}
 # --- Version / usage ---------------------------------------------------------
 # Reuses the plumbing's clast_version helper if available (loaded by sourcing

package/lib/clast/clast-porcelain-subcommands/retro.bash CHANGED Viewed

@@ -9,26 +9,43 @@
 _clast_retrosum_usage() {
   cat <<'EOF'
-Usage: clast retro [--from DATE] [--to DATE] [--window work-days|file-dates]
-                   [--refresh] [--json]
+Usage: clast retro [--from DATE] [--to DATE] [--all]
+                   [--window work-days|file-dates] [--refresh] [--json]
 Condense the work retrospective (grouped by actual work day → project) into
 model-written bullets per session. Structure is deterministic; only the prose
 condensation calls the LLM. Summaries are cached per session under
 <journal>/.retro-summaries/ and reused until the session content changes.
+With no window flags, defaults to the last 7 days (one model call per new
+session, so an unbounded run over the whole corpus can be slow and costly).
 Flags:
-  --from DATE     Start of the window (inclusive). Default: corpus start.
+  --from DATE     Start of the window (inclusive). Default: 7 days ago.
   --to DATE       End of the window (inclusive). Default: corpus end.
+  --all           Cover the whole corpus (overrides the 7-day default).
   --window WHICH  work-days (default) | file-dates. See `clast-plumbing retro`.
   --refresh       Ignore cached summaries and re-summarize (rewrites the cache).
   --json          Emit the manifest with a `summary` per session (no render).
   -h, --help      Print this usage and exit.
+DATE accepts ISO (YYYY-MM-DD), `today`, `yesterday`, `last-week`, `-Nd`, `-Nw`.
 Requires the CLAST_LLM_* env vars (see `clast --help`).
 EOF
 }
+# _clast_retro_progress <msg>
+#   Emit a progress line to stderr so stdout (render or --json) stays clean.
+#   Silent when CLAST_QUIET is set or stderr is not a TTY; CLAST_RETRO_PROGRESS=always
+#   forces it on (used by tests, which have no tty).
+_clast_retro_progress() {
+  [[ -n "${CLAST_QUIET:-}" ]] && return 0
+  if [[ "${CLAST_RETRO_PROGRESS:-}" == "always" || -t 2 ]]; then
+    printf 'clast: %s\n' "$*" >&2
+  fi
+}
 # _clast_retrosum_fingerprint  (stdin → short hex/cksum on stdout)
 #   Content fingerprint of a session body; changes invalidate the cache.
 _clast_retrosum_fingerprint() {
@@ -58,8 +75,11 @@ _clast_retrosum_build_user() {
 }
 # _clast_retrosum_summary <project> <work_day> <session_id> <body> <cache_dir> <refresh>
-#   Echo the condensed summary. Cache hit (matching fingerprint) reuses; miss
-#   calls the LLM and writes the cache. Returns nonzero on LLM failure.
+#   Echo the condensed summary. Return code tells the caller what happened so it
+#   can time only the calls that hit the model:
+#     0 — served from cache (no model call)
+#     3 — fresh summary via a model call (success)
+#     1 — model call failed
 _clast_retrosum_summary() {
   local project="$1" work_day="$2" sid="$3" body="$4" cache_dir="$5" refresh="$6"
   local fp cache_file cached_fp
@@ -74,6 +94,7 @@ _clast_retrosum_summary() {
     fi
   fi
+  _clast_retro_progress "        querying model..."
   local system user summary
   system="$(clast_porcelain_load_system_prompt retro-summary-system)"
   user="$(_clast_retrosum_build_user "$project" "$work_day" "$sid" "$body")"
@@ -86,6 +107,7 @@ _clast_retrosum_summary() {
       >"$cache_file" 2>/dev/null || clast_porcelain_warn "failed to cache summary for $sid"
   fi
   printf '%s' "$summary"
+  return 3
 }
 # _clast_retrosum_journal_dir — resolve the journal dir (for the cache).
@@ -100,7 +122,7 @@ _clast_retrosum_journal_dir() {
 }
 clast_cmd_retro() {
-  local from="" to="" window="work-days" refresh=0 as_json=0
+  local from="" to="" window="work-days" refresh=0 as_json=0 all=0
   while [[ $# -gt 0 ]]; do
     case "$1" in
@@ -108,6 +130,7 @@ clast_cmd_retro() {
       --from=*)   from="${1#*=}"; shift ;;
       --to)       [[ $# -lt 2 ]] && { clast_porcelain_log_error "retro: --to requires a value"; return 2; }; to="$2"; shift 2 ;;
       --to=*)     to="${1#*=}"; shift ;;
+      --all)      all=1; shift ;;
       --window)   [[ $# -lt 2 ]] && { clast_porcelain_log_error "retro: --window requires a value"; return 2; }; window="$2"; shift 2 ;;
       --window=*) window="${1#*=}"; shift ;;
       --refresh)  refresh=1; shift ;;
@@ -118,9 +141,17 @@ clast_cmd_retro() {
     esac
   done
+  # An unbounded retro means one model call per session across the whole corpus
+  # (slow and costly). Default to the last 7 days unless the caller bounded the
+  # window themselves (--from/--to) or opted into everything with --all.
+  if (( ! all )) && [[ -z "$from" && -z "$to" ]]; then
+    from="-7d"
+  fi
   clast_porcelain_preflight_llm
   # Structure + per-session bodies from the deterministic core.
+  _clast_retro_progress "building work-day manifest..."
   local -a pl=(--json retro --bodies --window "$window")
   [[ -n "$from" ]] && pl+=(--from "$from")
   [[ -n "$to" ]] && pl+=(--to "$to")
@@ -131,12 +162,26 @@ clast_cmd_retro() {
     clast_porcelain_die "retro: ${msg:-failed to build manifest}" 2
   fi
+  # Report the resolved window + discovered work days before the slow summarize
+  # loop — the "dates it resolved to" the user wants to see up front.
+  local pf pt pw ndays nsess daylist
+  pf="$(jq -r '.from // "(start)"'  <<<"$manifest")"
+  pt="$(jq -r '.to   // "(end)"'    <<<"$manifest")"
+  pw="$(jq -r '.window'             <<<"$manifest")"
+  ndays="$(jq '.days | length'      <<<"$manifest")"
+  nsess="$(jq '[.days[].projects[].sessions[]] | length' <<<"$manifest")"
+  daylist="$(jq -r '[.days[].day] | join(", ")' <<<"$manifest")"
+  _clast_retro_progress "window: $pf -> $pt ($pw)"
+  _clast_retro_progress "resolved $nsess session(s) across $ndays day(s): $daylist"
   local cache_dir
   cache_dir="$(_clast_retrosum_journal_dir)/.retro-summaries"
   # Summarize each session; collect key → summary.
   local -a summary_pairs=()
-  local sess sid key cache_id project work_day body title summary
+  local sess sid key cache_id project work_day body title summary pname
+  local t0 t1 dt rc
+  local idx=0 total="$nsess" queried=0 model_total="0.0"
   while IFS= read -r sess; do
     [[ -z "$sess" ]] && continue
     sid="$(jq -r '.session_id // ""' <<<"$sess")"
@@ -153,14 +198,35 @@ clast_cmd_retro() {
     work_day="$(jq -r '.work_day' <<<"$sess")"
     body="$(jq -r '.body // ""' <<<"$sess")"
     project="$(jq -r '.project_path // "(no project)"' <<<"$sess")"
+    idx=$(( idx + 1 ))
+    pname="$(jq -r '.progress_project // .project_path // "(no project)"' <<<"$sess")"
+    title="$(jq -r '.title // ""' <<<"$sess")"
+    _clast_retro_progress "[$idx/$total] $work_day  $pname  ${title:-${sid:0:8}}"
     if [[ -z "$body" ]]; then
       summary="(no body to summarize)"
-    elif ! summary="$(_clast_retrosum_summary "$project" "$work_day" "$cache_id" "$body" "$cache_dir" "$refresh")"; then
-      clast_porcelain_warn "summary failed for session ${sid:-<no id>} — leaving it unsummarized"
-      summary="(summary unavailable)"
+    else
+      # Time the call so we can report how long the model took. rc distinguishes
+      # a cache hit (0, instant) from a fresh model call (3) from a failure.
+      rc=0
+      t0="$(clast_porcelain_now)"
+      summary="$(_clast_retrosum_summary "$project" "$work_day" "$cache_id" "$body" "$cache_dir" "$refresh")" || rc=$?
+      t1="$(clast_porcelain_now)"
+      case "$rc" in
+        0) : ;;  # served from cache — no model call, nothing to time
+        3) dt="$(clast_porcelain_elapsed "$t0" "$t1")"
+           queried=$(( queried + 1 ))
+           model_total="$(awk -v a="$model_total" -v d="$dt" 'BEGIN { printf "%.1f", a + d }')"
+           _clast_retro_progress "        done in ${dt}s (model total ${model_total}s)" ;;
+        *) clast_porcelain_warn "summary failed for session ${sid:-<no id>} — leaving it unsummarized"
+           summary="(summary unavailable)" ;;
+      esac
     fi
     summary_pairs+=("$(jq -cn --arg k "$key" --arg v "$summary" '{key:$k, summary:$v}')")
-  done < <(jq -c '.days[].projects[].sessions[]' <<<"$manifest")
+  done < <(jq -c '.days[].projects[] | .project_name as $pn | .sessions[] | . + {progress_project: $pn}' <<<"$manifest")
+  if (( total > 0 )); then
+    _clast_retro_progress "summarized $total session(s); $queried queried the model (${model_total}s)"
+  fi
   # Fold summaries back into the manifest and drop the raw bodies. The manifest
   # carries --bodies only as summarizer input; neither the JSON nor the render

package/lib/clast/clast-porcelain-subcommands/wake.bash CHANGED Viewed

@@ -27,11 +27,41 @@ _clast_wake_separator() {
   printf '── %s %s\n' "$label" "$dashes"
 }
-# --- Preflight ---------------------------------------------------------------
+# --- Usage / preflight -------------------------------------------------------
+_clast_wake_usage() {
+  cat <<'EOF'
+Usage: clast wake [--auto]
+Interactive day curation: for each uncurated session, generate a draft journal
+entry with the LLM and accept/edit/dismiss/skip it.
+Flags:
+  --auto      Non-interactive: auto-accept every generated draft and write it.
+              Skips the triage menu and the per-session prompt, and does not
+              require a tty — suitable for cron/scripts. Sessions whose draft
+              fails to generate are skipped. The scan window still honors
+              CLAST_WAKE_SINCE (default -14d).
+  -h, --help  Print this usage and exit.
+Env:
+  CLAST_WAKE_SINCE            Scan window (default -14d).
+  CLAST_WAKE_AUTO_MIN_CHARS   In --auto, skip drafts whose body is shorter than
+                              this many characters (likely trivial sessions);
+                              they stay uncurated for a later interactive pass.
+                              Default 60. Set 0 to write every draft.
+Requires the CLAST_LLM_* env vars (see `clast --help`).
+EOF
+}
+# _clast_wake_preflight <auto>
+#   In interactive mode (auto=0) a tty is required so we can read choices; --auto
+#   reads nothing from the terminal, so that check is skipped.
 _clast_wake_preflight() {
-  if [[ ! -t 0 ]]; then
-    clast_porcelain_die "clast wake requires an interactive terminal (stdin is not a tty)."
+  local auto="${1:-0}"
+  if (( ! auto )) && [[ ! -t 0 ]]; then
+    clast_porcelain_die "clast wake requires an interactive terminal (stdin is not a tty). Use --auto for non-interactive curation."
   fi
   clast_porcelain_preflight_llm
 }
@@ -239,7 +269,19 @@ _clast_wake_triage() {
 # --- Main --------------------------------------------------------------------
 clast_cmd_wake() {
-  _clast_wake_preflight
+  local auto=0
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+      --auto)     auto=1; shift ;;
+      -h|--help)  _clast_wake_usage; return 0 ;;
+      --) shift; break ;;
+      *) clast_porcelain_log_error "wake: unknown argument '$1'"; return 2 ;;
+    esac
+  done
+  _clast_wake_preflight "$auto"
+  (( auto )) && clast_porcelain_info "Auto mode: drafts will be accepted without review."
   clast_porcelain_info "Snapshotting fresh transcripts..."
   if ! clast-plumbing snapshot 2>/dev/null; then
@@ -299,7 +341,8 @@ clast_cmd_wake() {
   last_day="$(jq -r '[.[].day_bucket] | sort | last' <<<"$uncurated")"
   project_count="$(jq '[.[].project] | unique | length' <<<"$uncurated")"
-  if (( day_count > 1 )); then
+  # Triage is an interactive scope picker; --auto processes the whole window.
+  if (( ! auto )) && (( day_count > 1 )); then
     uncurated="$(_clast_wake_triage "$uncurated" "$total" "$day_count" "$first_day" "$last_day" "$project_count")"
     total="$(jq 'length' <<<"$uncurated")"
     if (( total == 0 )); then
@@ -315,6 +358,15 @@ clast_cmd_wake() {
   local curated_count=0 skipped_count=0 dismissed_count=0
   local -a curated_projects=()
   local i=0 stop=0
+  # Cumulative model time across every draft generation (excludes the time the
+  # reviewer spends at the menu), so the run's LLM cost is legible — mirrors the
+  # per-call + total timing `clast retro` reports.
+  local wake_model_total="0.0"
+  # --auto guard: skip (do NOT write) a draft whose body is shorter than this
+  # many characters — likely a trivial/low-value session. Skipped sessions stay
+  # uncurated for a later interactive pass, so this is safe to tune aggressively.
+  # 0 disables the guard. Ignored in interactive mode (the reviewer decides).
+  local auto_min_chars="${CLAST_WAKE_AUTO_MIN_CHARS:-60}"
   while (( i < total && stop == 0 )); do
     local session
@@ -349,7 +401,10 @@ clast_cmd_wake() {
     local recorded="$rec_date"
     if [[ -n "$start_short" ]]; then
       recorded="$recorded $start_short"
-      [[ -n "$end_short" && "$end_short" != "$start_short" ]] && recorded="$recorded–$end_short"
+      # Brace the expansion: the separator is an en dash (U+2013), and bash in a
+      # UTF-8 locale reads its bytes as part of the identifier — `$recorded–` then
+      # expands as the unset name `recorded–` and `set -u` kills the run.
+      [[ -n "$end_short" && "$end_short" != "$start_short" ]] && recorded="${recorded}–${end_short}"
       recorded="$recorded $tz"
     fi
@@ -419,9 +474,15 @@ Revisions requested by user: ${edit_extra}"
       fi
       clast_porcelain_info "Generating draft..."
+      local gen_t0 gen_t1 gen_dt
+      gen_t0="$(clast_porcelain_now)"
       if ! draft="$(clast_porcelain_llm_chat "$full_system" "$full_user")"; then
         printf '\n'
         clast_porcelain_warn "LLM call failed for session $sid"
+        # No tty to prompt in auto mode — skip this session and move on.
+        if (( auto )); then
+          skipped_count=$(( skipped_count + 1 )); break
+        fi
         local retry
         printf '  [r] Retry    [s] Skip    [q] Stop\n  Choice: '
         read -r -n1 retry </dev/tty
@@ -432,12 +493,37 @@ Revisions requested by user: ${edit_extra}"
           *) skipped_count=$(( skipped_count + 1 )); break ;;
         esac
       fi
-      printf '\n%s\n' "$draft"
-      printf '\n'
+      # Only reached when the draft succeeded (every failure branch above
+      # continues or breaks), so this times just the model call.
+      gen_t1="$(clast_porcelain_now)"
+      gen_dt="$(clast_porcelain_elapsed "$gen_t0" "$gen_t1")"
+      wake_model_total="$(awk -v a="$wake_model_total" -v d="$gen_dt" 'BEGIN { printf "%.1f", a + d }')"
+      clast_porcelain_info "  done in ${gen_dt}s (model total ${wake_model_total}s)"
       local choice
-      choice="$(_clast_wake_prompt_choice)"
+      if (( auto )); then
+        # Guard unattended writes: skip a draft whose body is below the minimum
+        # length (likely a trivial session). Skipped — not dismissed — so it
+        # stays uncurated and can be handled in a later interactive pass.
+        local auto_body auto_len
+        auto_body="$(_clast_wake_strip_tags_trailer "$draft")"
+        auto_body="${auto_body#"${auto_body%%[![:space:]]*}"}"   # ltrim
+        auto_body="${auto_body%"${auto_body##*[![:space:]]}"}"   # rtrim
+        auto_len=${#auto_body}
+        if (( auto_min_chars > 0 && auto_len < auto_min_chars )); then
+          clast_porcelain_info "  Draft below threshold (${auto_len} < ${auto_min_chars} chars) — skipping (stays uncurated)."
+          skipped_count=$(( skipped_count + 1 ))
+          drafting=0
+          continue
+        fi
+        # Auto-accept without printing the full draft or prompting — the write
+        # result below records what landed. Reuses the `a` case verbatim.
+        choice="a"
+      else
+        printf '\n%s\n' "$draft"
+        printf '\n'
+        choice="$(_clast_wake_prompt_choice)"
+      fi
       case "$choice" in
         a|A)
@@ -511,4 +597,5 @@ Revisions requested by user: ${edit_extra}"
   if (( remaining > 0 )); then
     clast_porcelain_info "  Remaining: $remaining session(s) (stopped early)"
   fi
+  clast_porcelain_info "  Model time: ${wake_model_total}s"
 }

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@procrastivity/clast",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Capture, curate, and surface Claude Code session history across all your projects.",
   "homepage": "https://github.com/procrastivity/clast#readme",
   "bin": {

package/skills/wake/SKILL.md CHANGED Viewed

@@ -1,6 +1,6 @@
 ---
 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.'
+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. Supports an opt-in auto mode when the user explicitly asks to curate everything without review ("do them all", "don''t ask me") — the equivalent of `clast wake --auto`. This is the once-per-day curation flow; for per-project briefings use /brief; for mid-session pivots use session-brief.'
 ---
 # Wake
@@ -81,7 +81,7 @@ print "Nothing to curate — all remaining sessions were empty or slash-command-
 ### 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:
+If uncurated sessions span more than one day (e.g., after a weekend or break), present a triage step before processing. (In [Auto mode](#auto-mode) skip triage entirely and process the whole window.) Show a per-day breakdown:
 ```
 Found 45 uncurated sessions across 5 days (2026-05-26 to 2026-05-30).
@@ -128,7 +128,7 @@ For each session in the list:
 4. Display the draft to the user inside a fenced markdown code block, with a brief preamble: "Here's a draft for the X session in <project> at HH:MM:".
-5. Present the **promotion question** (see below) via AskUserQuestion.
+5. Present the **promotion question** (see below) via AskUserQuestion. (In [Auto mode](#auto-mode) skip this and accept the draft, subject to the length guard.)
 6. Handle the response:
    - **Accept** (any combination of accept-flavored options): pipe the draft to `clast-plumbing entries write` via stdin.
@@ -147,6 +147,8 @@ Auto-dismissed (no-op): 5 sessions.
 Skipped: 1 session.
 Remaining uncurated: 0.
+(In Auto mode, also report: "Skipped (below length threshold): N sessions.")
 Promoted:
   Decisions: 1
   Common-issues: 0
@@ -155,6 +157,35 @@ Promoted:
 Run `/brief <project>` to start working on a specific project today.
 ```
+## Auto mode
+By default every session gets its own AskUserQuestion — the friction is the point, it's where
+curation happens. But if the user **explicitly** asks to curate everything without reviewing it
+("do them all", "don't ask me", "no prompts", "just write them all"), switch to auto mode.
+This mirrors `clast wake --auto` in the CLI porcelain, and behaves the same way:
+- **Skip the triage step** (Step 2) even when the backlog spans multiple days. The whole scan
+  window is processed.
+- **Skip the per-session promotion question** (Step 3, item 5). Accept and write every draft via
+  the normal `entries write` path in "Writing the entry" below. Nothing is promoted — promotion
+  requires a human choice.
+- **Length guard.** Before writing, take the draft body *without* the suggested-tags trailer and
+  trim surrounding whitespace. If it is shorter than `CLAST_WAKE_AUTO_MIN_CHARS` characters
+  (default `60`; `0` disables the guard), **skip** it — do not write it, and do **not** dismiss
+  it. It stays uncurated so it can be handled in a later interactive pass. Report it as
+  `Draft below threshold (N < M chars) — skipping (stays uncurated).`
+- **A draft that fails to generate is skipped**, not retried — there's no reviewer to ask.
+- Step 2a no-op auto-dismissal still runs first, unchanged.
+- Don't print each draft in full; the write confirmation is the record of what landed.
+Everything else is unchanged. Announce the mode up front ("Auto mode: drafts will be accepted
+without review.") and report the counts in the Step 4 summary, including how many were skipped
+for being under the length threshold.
+For unattended/cron curation outside a Claude Code session, the CLI equivalent is
+`clast wake --auto`.
 ## Draft generation prompt
 The prompt templates are installed alongside the plugin under `$CLAUDE_PLUGIN_ROOT/lib/clast/prompts/`:
@@ -225,4 +256,4 @@ For promoted items (decisions, common-issues, workflows): currently these are tr
 - **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.
-- **User says "do them all without prompting"**: not a v1 feature. Each session gets its own AskUserQuestion. The friction is intentional — it's where curation happens.
+- **User says "do them all without prompting"**: switch to [Auto mode](#auto-mode) — accept and write every draft, skipping triage and the per-session question, with the `CLAST_WAKE_AUTO_MIN_CHARS` length guard applied. This is opt-in only: the interactive per-session AskUserQuestion stays the default, because the friction is where curation happens.