@procrastivity/clast 0.0.4 → 0.0.6

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

@@ -1,6 +1,6 @@
 # clast wake — LLM-powered interactive day curation.
 #
-# Replicates the /day-wakeup plugin skill using an OpenAI-compatible chat
+# Replicates the /wake plugin skill using an OpenAI-compatible chat
 # completions endpoint. Calls clast-plumbing for data, assembles prompts,
 # calls the LLM via curl, presents drafts interactively.
 #
@@ -43,7 +43,7 @@ _clast_wake_build_user_prompt() {
   local first_turns="$6" last_turns="$7" breadcrumbs="$8"
 
   local template_file template
-  template_file="$(clast_porcelain_user_prompt_file day-wakeup-draft-user)"
+  template_file="$(clast_porcelain_user_prompt_file wake-draft-user)"
 
   if [[ -n "$template_file" ]]; then
     template="$(cat "$template_file")"
@@ -57,7 +57,7 @@ _clast_wake_build_user_prompt() {
     template="${template//\{\{breadcrumbs\}\}/${breadcrumbs:-None.}}"
     printf '%s' "$template"
   else
-    clast_porcelain_warn "user prompt template not found: day-wakeup-draft-user.md — using inline fallback"
+    clast_porcelain_warn "user prompt template not found: wake-draft-user.md — using inline fallback"
     cat <<EOF
 Session metadata:
 - Project: ${project}
@@ -255,6 +255,34 @@ clast_cmd_wake() {
     clast_porcelain_die "failed to list sessions"
   }
 
+  # Auto-dismiss no-op sessions before any LLM work: sessions where Claude
+  # never replied (substantive == false) — empty sessions, slash-command-only
+  # sessions (/clear, /model, /config), and sessions abandoned before any
+  # response. This is a deterministic pre-filter — the LLM is never called for
+  # them. Sessions driven by a custom slash command still have assistant
+  # replies, so they are kept. Reversible via `clast undismiss <id>`. Opt out
+  # by setting CLAST_WAKE_AUTODISMISS_NOOP=0.
+  local auto_dismissed_count=0
+  if [[ "${CLAST_WAKE_AUTODISMISS_NOOP:-1}" != "0" ]]; then
+    local noop_ids noop_id
+    noop_ids="$(jq -r '
+      .[] | select(.substantive == false and .curated == false and .dismissed == false)
+      | .session_id
+    ' <<<"$sessions_json")"
+    while IFS= read -r noop_id; do
+      [[ -z "$noop_id" ]] && continue
+      if clast-plumbing sessions dismiss "$noop_id" \
+        --reason "auto: no substantive content (empty / slash-command-only)" >/dev/null 2>&1; then
+        auto_dismissed_count=$(( auto_dismissed_count + 1 ))
+      fi
+    done <<<"$noop_ids"
+    if (( auto_dismissed_count > 0 )); then
+      clast_porcelain_info "Auto-dismissed $auto_dismissed_count no-op session(s) (empty / slash-command-only)."
+      # Drop the just-dismissed rows from the working set so they don't reappear.
+      sessions_json="$(jq -c '[.[] | select(.substantive != false or .curated == true)]' <<<"$sessions_json")"
+    fi
+  fi
+
   local uncurated
   uncurated="$(jq -c '[.[] | select(.curated == false or .stale == true)]' <<<"$sessions_json")"
   local total
@@ -301,37 +329,71 @@ clast_cmd_wake() {
     msg_count="$(jq -r '.msg_count_approx' <<<"$session")"
     snapshot_path="$(jq -r '.snapshot_path' <<<"$session")"
 
-    local start_short="${start_ts:11:5}"
-    [[ -z "$start_short" ]] && start_short="${start_ts:0:10}"
+    # Recorded date + time range so the reviewer can tell which day's work
+    # this is (BDS-54). Render the session's own start/end instant in the
+    # local timezone. Deliberately NOT day_bucket: that is clast's
+    # cutoff-adjusted *filing* day, which differs from the instant's calendar
+    # date for pre-cutoff sessions — pairing it with a clock time (and a "UTC"
+    # label) yielded a timestamp wrong by a day. Fall back to the raw UTC
+    # substrings if `date` can't parse the timestamp.
+    local rec_date start_short end_short tz
+    rec_date="$(date -d "$start_ts" +%Y-%m-%d 2>/dev/null)" || rec_date=""
+    [[ -z "$rec_date" ]] && rec_date="${start_ts:0:10}"
+    start_short="$(date -d "$start_ts" +%H:%M 2>/dev/null)" || start_short=""
+    [[ -z "$start_short" ]] && start_short="${start_ts:11:5}"
+    end_short="$(date -d "$end_ts" +%H:%M 2>/dev/null)" || end_short=""
+    [[ -z "$end_short" ]] && end_short="${end_ts:11:5}"
+    tz="$(date -d "$start_ts" +%Z 2>/dev/null)" || tz="UTC"
+    [[ -z "$tz" ]] && tz="UTC"
+
+    local recorded="$rec_date"
+    if [[ -n "$start_short" ]]; then
+      recorded="$recorded $start_short"
+      [[ -n "$end_short" && "$end_short" != "$start_short" ]] && recorded="$recorded–$end_short"
+      recorded="$recorded $tz"
+    fi
 
     local is_stale
     is_stale="$(jq -r '.stale // false' <<<"$session")"
     local label="Session $((i+1))/$total: $project"
     [[ "$is_stale" == "true" ]] && label="$label [STALE]"
-    [[ -n "$start_short" ]] && label="$label ($start_short"
+    [[ -n "$rec_date" ]] && label="$label ($rec_date $start_short"
     [[ -n "$branch" && "$branch" != "null" ]] && label="$label, $branch"
     label="$label)"
 
     _clast_wake_separator "$label"
+    # Full session ID + recorded window: identifies exactly which session is
+    # being reviewed (e.g. for `clast-plumbing sessions dismiss/undismiss <id>`).
+    clast_porcelain_info "  id: $sid"
+    clast_porcelain_info "  recorded: $recorded"
     clast_porcelain_info "Gathering context..."
 
     local show_json
     show_json="$(clast-plumbing --json show "$sid" --full --turns 8 2>/dev/null)" || {
-      clast_porcelain_warn "failed to read session $sid — skipping"
+      local rc=$? reason
+      reason="$(jq -r '.error // empty' <<<"$show_json" 2>/dev/null || true)"
+      [[ -z "$reason" ]] && reason="exit $rc"
+      clast_porcelain_warn "failed to read session $sid ($reason) — skipping"
       skipped_count=$(( skipped_count + 1 ))
       i=$(( i + 1 ))
       continue
     }
 
-    local first_turns last_turns
-    first_turns="$(jq -r '
+    # Cap each turn's text: a single pathological turn (e.g. a huge pasted
+    # blob or tool dump) would otherwise bloat the prompt — costly and liable
+    # to exceed the model's context. show --full keeps the full text; only the
+    # LLM-bound copy is bounded.
+    local first_turns last_turns turn_cap=2000
+    first_turns="$(jq -r --argjson cap "$turn_cap" '
       .first_turns // [] | .[] |
-      "[\(.role)] \(.text)"
+      (.text // "") as $t | ($t | length) as $n |
+      "[\(.role)] \(if $n > $cap then $t[0:$cap] + "… [\($n - $cap) more chars truncated]" else $t end)"
     ' <<<"$show_json" 2>/dev/null)" || true
 
-    last_turns="$(jq -r '
+    last_turns="$(jq -r --argjson cap "$turn_cap" '
       .last_turns // [] | .[] |
-      "[\(.role)] \(.text)"
+      (.text // "") as $t | ($t | length) as $n |
+      "[\(.role)] \(if $n > $cap then $t[0:$cap] + "… [\($n - $cap) more chars truncated]" else $t end)"
     ' <<<"$show_json" 2>/dev/null)" || true
 
     local breadcrumbs=""
@@ -342,7 +404,7 @@ clast_cmd_wake() {
       "$first_turns" "$last_turns" "$breadcrumbs")"
 
     local system_prompt
-    system_prompt="$(clast_porcelain_load_system_prompt day-wakeup-draft-system)"
+    system_prompt="$(clast_porcelain_load_system_prompt wake-draft-system)"
 
     local draft="" edit_extra=""
     local drafting=1
@@ -439,6 +501,9 @@ Revisions requested by user: ${edit_extra}"
   printf '\n'
   _clast_wake_separator "Summary"
   clast_porcelain_info "  Curated: $curated_count session(s) across $unique_projects project(s)"
+  if (( auto_dismissed_count > 0 )); then
+    clast_porcelain_info "  Auto-dismissed (no-op): $auto_dismissed_count session(s)"
+  fi
   if (( dismissed_count > 0 )); then
     clast_porcelain_info "  Dismissed: $dismissed_count session(s)"
   fi

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

@@ -95,6 +95,58 @@ clast_registry_resolve() {
   printf '%s\n' "$slug"
 }
 
+# clast_registry_line_for_path <path-or-segment>
+#   Like clast_registry_resolve, but prints the FULL matching registry line
+#   (the JSON object) instead of just the slug; empty + return 1 on miss.
+#   Use this to recover the per-directory path/label/remote for a specific
+#   session — slug-first-match collapses a multi-directory project onto its
+#   first line, which is wrong once a slug spans several directories.
+clast_registry_line_for_path() {
+  local input="${1:-}"
+  if [[ -z "$input" ]]; then
+    return 1
+  fi
+
+  local arr
+  arr="$(clast_registry_list_json)"
+
+  local -a candidates=()
+  if [[ "$input" == -* ]]; then
+    candidates=("$input")
+    local -a decoded=()
+    mapfile -t decoded < <(clast_decode_candidates "$input")
+    candidates+=("${decoded[@]}")
+  else
+    local canon
+    canon="$(realpath -m "$input" 2>/dev/null || printf '%s' "$input")"
+    candidates=("$canon")
+  fi
+
+  local cands_json line
+  cands_json="$(printf '%s\n' "${candidates[@]}" | jq -Rn '[inputs]')"
+  line="$(_clast_registry_lookup_line "$cands_json" "$arr" 2>/dev/null)" || true
+  if [[ -z "$line" ]]; then
+    return 1
+  fi
+  printf '%s\n' "$line"
+}
+
+# _clast_registry_lookup_line <candidates-json-array> <registry-json-array>
+#   Like _clast_registry_lookup_paths but returns the FIRST matching line's
+#   whole object (path before alias). Print the compact JSON object or empty.
+_clast_registry_lookup_line() {
+  local cands_json="$1" arr="$2"
+  jq -c --argjson cands "$cands_json" '
+    . as $arr
+    | first(
+        $cands[] as $c
+        | ( ($arr | map(select(.path == $c)) | .[0])
+            // ($arr | map(select((.aliases? // []) | index($c) != null)) | .[0]) )
+        | select(. != null)
+      ) // empty
+  ' <<<"$arr"
+}
+
 # _clast_registry_lookup_path <path> <registry-json-array>
 #   First match wins: scan .path, then .aliases[]. Print slug or empty.
 _clast_registry_lookup_path() {
@@ -125,14 +177,30 @@ _clast_registry_lookup_paths() {
   ' <<<"$arr"
 }
 
-# clast_registry_add <path> [--slug NAME] [--remote URL]
-#   Append a single JSONL line. Default slug = basename(path). Default
-#   remote = `git -C <path> remote get-url origin` (or absent). If the
-#   resolved remote matches an existing entry's remote, append a new line
-#   carrying that entry's slug and rolling its known paths into aliases.
+# _clast_registry_slugify <string>
+#   Lowercase, map non-[a-z0-9] runs to single dashes, trim, cap at 32.
+#   Used for auto-derived labels (e.g. a parent-directory basename).
+_clast_registry_slugify() {
+  local s
+  s="$(printf '%s' "${1,,}" | sed 's/[^a-z0-9]/-/g; s/--*/-/g; s/^-//; s/-$//')"
+  s="${s:0:32}"
+  s="${s%-}"
+  printf '%s' "$s"
+}
+
+# clast_registry_add <path> [--slug NAME] [--label NAME] [--remote URL]
+#   Append a single JSONL line. The remote is a *grouping hint*, not an
+#   identity: when it matches an existing entry's remote, an absent --slug
+#   adopts that entry's slug (so clones of one repo share a project), but an
+#   explicit --slug always wins (a divergent one warns). Default slug =
+#   basename(path). Default label = basename(dirname(path)). Default remote
+#   = `git -C <path> remote get-url origin` (or absent). New lines carry
+#   `aliases: []` — sibling paths are no longer rolled up; a shared slug
+#   across distinct .path lines is the supported multi-directory shape.
 #   Print the appended JSON on stdout. Exit 2 on bad args, 1 on write fail.
 clast_registry_add() {
-  local path="" slug="" remote="" remote_explicit=0
+  local path="" slug="" slug_explicit=0 label_raw="" label_explicit=0
+  local remote="" remote_explicit=0
   while [[ $# -gt 0 ]]; do
     case "$1" in
       --slug)
@@ -140,8 +208,25 @@ clast_registry_add() {
           clast_log_error "clast_registry_add: --slug requires a value"
           return 2
         fi
-        slug="$2"; shift 2 ;;
-      --slug=*)  slug="${1#*=}"; shift ;;
+        if [[ -z "$2" ]]; then
+          clast_log_error "clast_registry_add: --slug requires a non-empty value"
+          return 2
+        fi
+        slug="$2"; slug_explicit=1; shift 2 ;;
+      --slug=*)
+        slug="${1#*=}"
+        if [[ -z "$slug" ]]; then
+          clast_log_error "clast_registry_add: --slug requires a non-empty value"
+          return 2
+        fi
+        slug_explicit=1; shift ;;
+      --label)
+        if [[ $# -lt 2 ]]; then
+          clast_log_error "clast_registry_add: --label requires a value"
+          return 2
+        fi
+        label_raw="$2"; label_explicit=1; shift 2 ;;
+      --label=*) label_raw="${1#*=}"; label_explicit=1; shift ;;
       --remote)
         if [[ $# -lt 2 ]]; then
           clast_log_error "clast_registry_add: --remote requires a value"
@@ -196,30 +281,49 @@ clast_registry_add() {
     fi
   fi
 
-  # Default slug from basename.
-  if [[ -z "$slug" ]]; then
+  # Resolve the slug against any existing entry sharing this remote. The
+  # remote groups clones of one repo under a single logical project, but it
+  # is only a hint: an explicit --slug always wins. A divergent explicit
+  # slug warns (you are splitting the remote into two projects on purpose);
+  # the default slug silently adopts the match.
+  local matched_slug=""
+  if [[ -n "$remote" ]]; then
+    matched_slug="$(clast_registry_match_remote "$remote" 2>/dev/null || true)"
+  fi
+
+  if (( slug_explicit == 1 )); then
+    if [[ -n "$matched_slug" && "$matched_slug" != "$slug" ]]; then
+      clast_log_warn "registry: remote '$remote' is already registered under slug '$matched_slug'; registering '$canon' under requested slug '$slug' as a separate project (pass --slug '$matched_slug' to group them)"
+    fi
+  elif [[ -n "$matched_slug" ]]; then
+    slug="$matched_slug"
+    clast_log_info "registry: grouping '$canon' under existing slug '$slug' (shared remote; pass --slug to override)"
+  else
     slug="$(basename "$canon")"
   fi
 
-  # Aliases roll-up only when remote matched an existing entry.
-  local arr matched_slug
-  arr="$(clast_registry_list_json)"
-  local aliases_json='[]'
-  if [[ -n "$remote" ]]; then
-    matched_slug="$(jq -r --arg r "$remote" 'map(select(.remote == $r)) | .[0].slug // empty' <<<"$arr")"
-    if [[ -n "$matched_slug" ]]; then
-      slug="$matched_slug"
-      # Collect every known path for this slug (excluding the new one),
-      # plus their existing aliases.
-      aliases_json="$(jq -c --arg s "$slug" --arg p "$canon" '
-        [ .[] | select(.slug == $s) | [.path] + (.aliases // []) ]
-        | add // []
-        | map(select(. != $p))
-        | unique
-      ' <<<"$arr")"
+  # Per-directory label. An explicit --label is lowercased and validated;
+  # otherwise derive from the parent directory's basename (e.g.
+  # ~/Workspaces/performance/xesapps → "performance"). The label only
+  # distinguishes clones of one slug; a single-directory project never
+  # surfaces it, so a default like "code" is harmless.
+  local label=""
+  if (( label_explicit == 1 )); then
+    label="${label_raw,,}"
+    if [[ ! "$label" =~ ^[a-z0-9][a-z0-9-]{0,31}$ ]]; then
+      clast_log_error "clast_registry_add: invalid --label '$label_raw' (expected [a-z0-9][a-z0-9-]{0,31})"
+      return 2
     fi
+  else
+    label="$(_clast_registry_slugify "$(basename "$(dirname "$canon")")")"
   fi
 
+  # Sibling paths are no longer rolled into aliases: each directory is its
+  # own line keyed by .path, and a shared slug is the supported way to span
+  # directories. `aliases` stays present (reserved for genuine alternate
+  # paths of the same checkout) but empty.
+  local aliases_json='[]'
+
   local journal_dir
   journal_dir="$(clast_journal_dir)"
   if ! mkdir -p "$journal_dir"; then
@@ -234,10 +338,11 @@ clast_registry_add() {
   line="$(jq -c -n \
     --arg path "$canon" \
     --arg slug "$slug" \
+    --arg label "$label" \
     --arg remote "$remote" \
     --arg first_seen "$first_seen" \
     --argjson aliases "$aliases_json" \
-    '{path: $path, slug: $slug, remote: $remote, first_seen: $first_seen}
+    '{path: $path, slug: $slug, label: $label, remote: $remote, first_seen: $first_seen}
      | with_entries(select(.value != null and .value != ""))
      | . + {aliases: $aliases}')" || {
     clast_log_error "clast_registry_add: jq failed to build registry line"