hiiro 0.1.133 → 0.1.134

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fad92bb1b8ae6893d1b27fe0c9f077c938fbdafb440cedeabb8dedf50f09f31
-  data.tar.gz: 6c702fe77535f178498b5bf561edcde9f247dca6b816b2d1ee68bb9985fb0a25
+  metadata.gz: e5c49242912889d365b5eabdfdc3adeb72ea6d55dd7311280dcc9b3f6ac40013
+  data.tar.gz: 219b6710d528233190c7bfb30465d4f3b293cea21f24c8a01561768566ce83ff
 SHA512:
-  metadata.gz: 599336e66a32564d50eda3c945b7a01be369aa751a0e738f8083e793c35e9a427a976ce508028ca9ef6ff0b75d2bcc888d19d10668bd93b65355358ad2bac6c8
-  data.tar.gz: da2877f35766f04272a6cb8b4a0c62a4d8d5a2b427fb8366dcba7246ec295cf6060915afb94ca335eb055785c543bf0b656a22d99bf7d37dc3f62568325181b5
+  metadata.gz: 8ae90dc0c81c21b6d580ccfa3b2ba3475633f7686efdc5de97147cc3030538632e01c436a244e682d6ee7cc361cd3ed9945652c2fd1c4792da8ad98d6a160913
+  data.tar.gz: ebca695230cc51d34b926726c5514af9b6c535eb368920fca89a0dd3dbec0e37d16748612612032485819ac01419b6c1f7b87ca44fc4d5281885610dec8e3900

data/README.md

@@ -82,6 +82,7 @@ h ping
 | `h plugin` | Manage hiiro plugins (list, edit, search) |
 | `h pr` | GitHub PR management via gh CLI |
 | `h project` | Project navigation with tmux session management |
+| `h queue` | Claude prompt queue with tmux-based task execution |
 | `h session` | Tmux session management |
 | `h sha` | Extract short SHA from git log |
 | `h todo` | Todo list management with tags and task association |
@@ -212,6 +213,7 @@ All configuration lives in `~/.config/hiiro/`:
 ~/.config/hiiro/
   plugins/        # Plugin files (auto-loaded)
   pins/           # Pin storage (per command)
+  queue/          # Prompt queue (wip, pending, running, done, failed)
   tasks/          # Task metadata
   projects.yml    # Project aliases
   apps.yml        # App directory mappings

data/bin/h-jumplist

@@ -0,0 +1,183 @@
+#!/usr/bin/env ruby
+
+require "hiiro"
+require "fileutils"
+
+JUMPLIST_DIR = File.join(Dir.home, '.config', 'hiiro', 'jumplist')
+JUMPLIST_FILE = File.join(JUMPLIST_DIR, 'entries')
+POS_FILE = File.join(JUMPLIST_DIR, 'position')
+MAX_SIZE = 50
+
+FileUtils.mkdir_p(JUMPLIST_DIR)
+
+def read_entries
+  return [] unless File.exist?(JUMPLIST_FILE)
+  File.readlines(JUMPLIST_FILE, chomp: true).reject(&:empty?)
+end
+
+def write_entries(entries)
+  File.write(JUMPLIST_FILE, entries.join("\n") + "\n")
+end
+
+def get_pos
+  return 0 unless File.exist?(POS_FILE)
+  File.read(POS_FILE).strip.to_i
+end
+
+def set_pos(n)
+  File.write(POS_FILE, n.to_s)
+end
+
+def pane_exists?(pane_id)
+  panes = `tmux list-panes -a -F '\#{pane_id}' 2>/dev/null`.strip.split("\n")
+  panes.include?(pane_id)
+end
+
+def tmux_display(fmt)
+  `tmux display-message -p '#{fmt}'`.strip
+end
+
+Hiiro.run(*ARGV) do
+  add_subcmd(:setup) do
+    puts <<~SETUP
+      # Add the following to your tmux.conf:
+
+      # --- Jumplist hooks (record pane/window navigation) ---
+      set-hook -g after-select-pane  "run-shell -b 'h jumplist record'"
+      set-hook -g after-select-window "run-shell -b 'h jumplist record'"
+
+      # --- Jumplist keybindings ---
+      bind-key -r C-b run-shell "h jumplist back"
+      bind-key -r C-f run-shell "h jumplist forward"
+    SETUP
+  end
+
+  add_subcmd(:record) do
+    # Check suppression flag
+    suppress = `tmux show-environment TMUX_JUMPLIST_SUPPRESS 2>/dev/null`.strip
+    if suppress == "TMUX_JUMPLIST_SUPPRESS=1"
+      system('tmux', 'set-environment', '-u', 'TMUX_JUMPLIST_SUPPRESS')
+      next
+    end
+
+    pane_id = tmux_display('#\{pane_id\}')
+    window_id = tmux_display('#\{window_id\}')
+    session_name = tmux_display('#\{session_name\}')
+    pane_cmd = tmux_display('#\{pane_current_command\}')
+    timestamp = Time.now.to_i.to_s
+
+    entries = read_entries
+    pos = get_pos
+
+    # If position is not at head, truncate forward history
+    if pos > 0 && entries.any?
+      entries = entries[pos..]
+      set_pos(0)
+    elsif pos > 0
+      set_pos(0)
+    end
+
+    # Deduplicate: skip if most recent entry is same pane
+    if entries.any?
+      last_pane = entries[0].split('|', 2).first
+      next if last_pane == pane_id
+    end
+
+    # Prepend new entry (newest first)
+    new_entry = [pane_id, window_id, session_name, timestamp, pane_cmd].join('|')
+    entries.unshift(new_entry)
+    entries = entries.first(MAX_SIZE)
+    write_entries(entries)
+  end
+
+  add_subcmd(:back) do
+    entries = read_entries
+    pos = get_pos
+
+    if entries.empty?
+      system('tmux', 'display-message', 'Jumplist: empty')
+      next
+    end
+
+    # If at position 0, record current pane first so forward works
+    if pos == 0
+      pane_id = tmux_display('#\{pane_id\}')
+      window_id = tmux_display('#\{window_id\}')
+      session_name = tmux_display('#\{session_name\}')
+      pane_cmd = tmux_display('#\{pane_current_command\}')
+      timestamp = Time.now.to_i.to_s
+
+      new_entry = [pane_id, window_id, session_name, timestamp, pane_cmd].join('|')
+
+      # Only prepend if different from current head
+      if entries.empty? || entries[0].split('|', 2).first != pane_id
+        entries.unshift(new_entry)
+        entries = entries.first(MAX_SIZE)
+        write_entries(entries)
+      end
+    end
+
+    # Find next valid entry going backward
+    new_pos = pos + 1
+    while new_pos < entries.length
+      entry = entries[new_pos]
+      parts = entry.split('|')
+      target_pane = parts[0]
+      target_window = parts[1]
+      target_session = parts[2]
+
+      if pane_exists?(target_pane)
+        system('tmux', 'set-environment', 'TMUX_JUMPLIST_SUPPRESS', '1')
+        system('tmux', 'switch-client', '-t', target_session)
+        system('tmux', 'select-window', '-t', target_window)
+        system('tmux', 'select-pane', '-t', target_pane)
+        set_pos(new_pos)
+        next # exit the subcmd block
+      end
+
+      new_pos += 1
+    end
+
+    system('tmux', 'display-message', 'Jumplist: at oldest entry')
+  end
+
+  add_subcmd(:forward) do
+    pos = get_pos
+
+    if pos <= 0
+      system('tmux', 'display-message', 'Jumplist: at newest entry')
+      next
+    end
+
+    entries = read_entries
+
+    if entries.empty?
+      system('tmux', 'display-message', 'Jumplist: empty')
+      next
+    end
+
+    # Find next valid entry going forward (toward index 0)
+    new_pos = pos - 1
+    while new_pos >= 0
+      entry = entries[new_pos]
+      parts = entry.split('|')
+      target_pane = parts[0]
+      target_window = parts[1]
+      target_session = parts[2]
+
+      if pane_exists?(target_pane)
+        system('tmux', 'set-environment', 'TMUX_JUMPLIST_SUPPRESS', '1')
+        system('tmux', 'switch-client', '-t', target_session)
+        system('tmux', 'select-window', '-t', target_window)
+        system('tmux', 'select-pane', '-t', target_pane)
+        set_pos(new_pos)
+        next # exit the subcmd block
+      end
+
+      new_pos -= 1
+    end
+
+    system('tmux', 'display-message', 'Jumplist: at newest entry')
+    set_pos(0)
+  end
+end

data/bin/h-notify

@@ -0,0 +1,148 @@
+#!/usr/bin/env ruby
+
+require "hiiro"
+require "fileutils"
+
+TYPE_PRESETS = {
+  'success' => { prefix: '[OK]',   sound: 'Glass', title: 'Success' },
+  'error'   => { prefix: '[ERR]',  sound: 'Basso', title: 'Error' },
+  'info'    => { prefix: '[INFO]', sound: 'Pop',   title: 'Info' },
+  'warning' => { prefix: '[WARN]', sound: 'Purr',  title: 'Warning' },
+}
+
+def session_name
+  `tmux display-message -p '\#{session_name}'`.strip
+end
+
+def notify_file(session = nil)
+  session ||= session_name
+  "/tmp/tmux-notifications-#{session}"
+end
+
+def read_notifications(session = nil)
+  file = notify_file(session)
+  return [] unless File.exist?(file)
+  File.readlines(file, chomp: true).reject(&:empty?)
+end
+
+def write_notifications(entries, session = nil)
+  file = notify_file(session)
+  if entries.empty?
+    File.delete(file) if File.exist?(file)
+  else
+    File.write(file, entries.join("\n") + "\n")
+  end
+end
+
+def pane_exists?(pane_id)
+  panes = `tmux list-panes -a -F '\#{pane_id}' 2>/dev/null`.strip.split("\n")
+  panes.include?(pane_id)
+end
+
+Hiiro.run(*ARGV) do
+  opts = Hiiro::Options.parse(args) do
+    option(:type, short: 't', desc: 'Notification type (success, error, info, warning)', default: 'info')
+  end
+
+  preset = TYPE_PRESETS[opts.type] || TYPE_PRESETS['info']
+
+  add_subcmd(:push) do |*push_args|
+    message = push_args.join(' ')
+    if message.empty?
+      puts "Usage: h notify push [-t TYPE] \"message\""
+      next
+    end
+
+    pane_id = `tmux display-message -p '\#{pane_id}'`.strip
+    window_id = `tmux display-message -p '\#{window_id}'`.strip
+    session = session_name
+    pane_cmd = `tmux display-message -p '\#{pane_current_command}'`.strip
+    timestamp = Time.now.to_i.to_s
+
+    entry = [pane_id, window_id, session, timestamp, pane_cmd, message].join('|')
+
+    entries = read_notifications(session)
+    entries.unshift(entry)
+    write_notifications(entries, session)
+
+    # Show tmux display-message with type prefix
+    system('tmux', 'display-message', "#{preset[:prefix]} #{message}")
+
+    # Also send terminal-notifier
+    system('terminal-notifier',
+      '-title', preset[:title],
+      '-message', message,
+      '-sound', preset[:sound])
+  end
+
+  add_subcmd(:menu) do
+    session = session_name
+    entries = read_notifications(session)
+
+    if entries.empty?
+      system('tmux', 'display-message', 'No notifications')
+      next
+    end
+
+    # Build display-menu arguments
+    menu_args = ['-T', 'Notifications']
+
+    entries.first(10).each_with_index do |line, idx|
+      parts = line.split('|')
+      pane_id = parts[0]
+      cmd = parts[4]
+      msg = parts[5..].join('|')
+      msg = msg[0..46] + '...' if msg.length > 50
+
+      label = "#{idx}: [#{pane_id}] #{cmd}: #{msg}"
+      menu_args.push(label, idx.to_s, "run-shell 'h notify jump #{idx}'")
+    end
+
+    # Separator and clear option
+    menu_args.push('', '', 'Clear all', 'c', "run-shell 'h notify clear'")
+
+    system('tmux', 'display-menu', *menu_args)
+  end
+
+  add_subcmd(:jump) do |index_str = nil|
+    if index_str.nil?
+      puts "Usage: h notify jump INDEX"
+      next
+    end
+
+    index = index_str.to_i
+    session = session_name
+    entries = read_notifications(session)
+
+    if index >= entries.length
+      system('tmux', 'display-message', 'Notification not found')
+      next
+    end
+
+    entry = entries[index]
+    parts = entry.split('|')
+    target_pane = parts[0]
+    target_window = parts[1]
+
+    unless pane_exists?(target_pane)
+      system('tmux', 'display-message', "Pane #{target_pane} no longer exists")
+      entries.delete_at(index)
+      write_notifications(entries, session)
+      next
+    end
+
+    system('tmux', 'select-window', '-t', target_window)
+    system('tmux', 'select-pane', '-t', target_pane)
+
+    # Remove the notification
+    entries.delete_at(index)
+    write_notifications(entries, session)
+  end
+
+  add_subcmd(:clear) do
+    session = session_name
+    file = notify_file(session)
+    File.delete(file) if File.exist?(file)
+    system('tmux', 'display-message', 'Notifications cleared')
+  end
+end

data/bin/h-pr

@@ -268,87 +268,7 @@ class PinnedPRManager
   end
 
 
-  def batch_fetch_pr_info(pr_numbers)
-    return {} if pr_numbers.empty?
-
-    # Build GraphQL query to fetch multiple PRs at once
-    pr_queries = pr_numbers.map.with_index do |num, idx|
-      <<~GRAPHQL.strip
-        pr#{idx}: pullRequest(number: #{num}) {
-          number
-          title
-          url
-          headRefName
-          state
-          isDraft
-          mergeable
-          reviewDecision
-          statusCheckRollup {
-            contexts {
-              ... on CheckRun {
-                conclusion
-                status
-              }
-              ... on StatusContext {
-                state
-              }
-            }
-          }
-          reviews(last: 50) {
-            nodes {
-              author {
-                login
-              }
-              state
-            }
-          }
-        }
-      GRAPHQL
-    end
-
-    query = <<~GRAPHQL
-      query {
-        repository(owner: "instacart", name: "carrot") {
-          #{pr_queries.join("\n")}
-        }
-      }
-    GRAPHQL
-
-    result = `gh api graphql -f query='#{query.gsub("'", "'\\''")}' 2>/dev/null`
-    return {} if result.empty?
-
-    data = JSON.parse(result)
-    repo_data = data.dig('data', 'repository')
-    return {} unless repo_data
-
-    # Convert GraphQL response to hash keyed by PR number
-    pr_info_by_number = {}
-    pr_numbers.each_with_index do |num, idx|
-      pr_data = repo_data["pr#{idx}"]
-      next unless pr_data
-
-      # Transform GraphQL response to match gh pr view format
-      pr_info_by_number[num] = {
-        'number' => pr_data['number'],
-        'title' => pr_data['title'],
-        'url' => pr_data['url'],
-        'headRefName' => pr_data['headRefName'],
-        'state' => pr_data['state'],
-        'isDraft' => pr_data['isDraft'],
-        'mergeable' => pr_data['mergeable'],
-        'reviewDecision' => pr_data['reviewDecision'],
-        'statusCheckRollup' => pr_data['statusCheckRollup'],
-        'reviews' => pr_data.dig('reviews', 'nodes') || []
-      }
-    end
-
-    pr_info_by_number
-  rescue JSON::ParserError, StandardError
-    {}
-  end
-
   def refresh_all_status(prs, force: false)
-    # Determine which PRs need refreshing
     prs_to_refresh = prs.select { |pr| needs_refresh?(pr, force: force) }
 
     if prs_to_refresh.empty?
@@ -356,25 +276,7 @@ class PinnedPRManager
       return prs
     end
 
-    # Batch fetch all PR info at once
-    pr_numbers = prs_to_refresh.map { |pr| pr['number'] }
-    fetched_info = batch_fetch_pr_info(pr_numbers)
-
-    # Update each PR with fetched info
-    prs_to_refresh.each do |pr|
-      info = fetched_info[pr['number']]
-      next unless info
-
-      pr['state'] = info['state']
-      pr['title'] = info['title']
-      pr['checks'] = summarize_checks(info['statusCheckRollup'])
-      pr['reviews'] = summarize_reviews(info['reviews'])
-      pr['review_decision'] = info['reviewDecision']
-      pr['is_draft'] = info['isDraft']
-      pr['mergeable'] = info['mergeable']
-      pr['last_checked'] = Time.now.iso8601
-    end
-
+    prs_to_refresh.each { |pr| refresh_status(pr, force: true) }
     prs
   end
 
@@ -766,7 +668,9 @@ Hiiro.run(*ARGV, plugins: [Pins]) do
     end
   end
 
-  add_subcmd(:status) do |*status_args|
+  add_subcmd(:ls) do |*ls_args|
+    update = ls_args.include?('-u') || ls_args.include?('--update')
+
     pinned = pinned_manager.load_pinned
 
     if pinned.empty?
@@ -774,13 +678,31 @@ Hiiro.run(*ARGV, plugins: [Pins]) do
       next
     end
 
-    compact = status_args.include?('-c') || status_args.include?('--compact')
-    force = status_args.include?('-U') || status_args.include?('--force-update')
+    if update
+      puts "Updating status for #{pinned.length} PR(s)..."
+      pinned_manager.refresh_all_status(pinned, force: true)
+      pinned_manager.save_pinned(pinned)
+      puts
+    end
 
-    puts "Refreshing status for #{pinned.length} pinned PR(s)..."
-    puts
+    pinned.each_with_index do |pr, idx|
+      puts pinned_manager.display_pinned(pr, idx)
+    end
 
-    pinned_manager.refresh_all_status(pinned, force: force)
+    last_checked = pinned.filter_map { |pr| pr['last_checked'] }.max
+    puts "---"
+    puts "Last updated: #{last_checked || 'never'}"
+  end
+
+  add_subcmd(:status) do |*status_args|
+    pinned = pinned_manager.load_pinned
+
+    if pinned.empty?
+      puts "No pinned PRs"
+      next
+    end
+
+    compact = status_args.include?('-c') || status_args.include?('--compact')
 
     pinned.each_with_index do |pr, idx|
       if compact
@@ -791,9 +713,9 @@ Hiiro.run(*ARGV, plugins: [Pins]) do
       end
     end
 
-    pinned_manager.save_pinned(pinned)
+    last_checked = pinned.filter_map { |pr| pr['last_checked'] }.max
     puts "---"
-    puts "Status updated at #{Time.now.strftime('%H:%M:%S')}"
+    puts "Last updated: #{last_checked || 'never'}"
   end
 
   add_subcmd(:update) do |*update_args|
@@ -814,10 +736,6 @@ Hiiro.run(*ARGV, plugins: [Pins]) do
 
   add_subcmd(:green) do |*green_args|
     pinned = pinned_manager.load_pinned
-    force = green_args.include?('-U') || green_args.include?('--force-update')
-
-    pinned_manager.refresh_all_status(pinned, force: force)
-    pinned_manager.save_pinned(pinned)
 
     filtered = pinned.select { |pr|
       c = pr['checks']
@@ -836,10 +754,6 @@ Hiiro.run(*ARGV, plugins: [Pins]) do
 
   add_subcmd(:red) do |*red_args|
     pinned = pinned_manager.load_pinned
-    force = red_args.include?('-U') || red_args.include?('--force-update')
-
-    pinned_manager.refresh_all_status(pinned, force: force)
-    pinned_manager.save_pinned(pinned)
 
     filtered = pinned.select { |pr|
       c = pr['checks']
@@ -858,10 +772,6 @@ Hiiro.run(*ARGV, plugins: [Pins]) do
 
   add_subcmd(:old) do |*old_args|
     pinned = pinned_manager.load_pinned
-    force = old_args.include?('-U') || old_args.include?('--force-update')
-
-    pinned_manager.refresh_all_status(pinned, force: force)
-    pinned_manager.save_pinned(pinned)
 
     filtered = pinned.select { |pr| pr['state'] == 'MERGED' }
 
@@ -884,14 +794,10 @@ Hiiro.run(*ARGV, plugins: [Pins]) do
       next
     end
 
-    force = args.include?('-U') || args.include?('--force-update')
-    pinned_manager.refresh_all_status(pinned, force: force)
-
     merged_or_closed = pinned.select { |pr| pr['state'] == 'MERGED' || pr['state'] == 'CLOSED' }
 
     if merged_or_closed.empty?
       puts "No merged or closed PRs to prune"
-      pinned_manager.save_pinned(pinned)
       next
     end
 
@@ -909,10 +815,6 @@ Hiiro.run(*ARGV, plugins: [Pins]) do
 
   add_subcmd(:draft) do |*draft_args|
     pinned = pinned_manager.load_pinned
-    force = draft_args.include?('-U') || draft_args.include?('--force-update')
-
-    pinned_manager.refresh_all_status(pinned, force: force)
-    pinned_manager.save_pinned(pinned)
 
     filtered = pinned.select { |pr| pr['is_draft'] == true }
 
@@ -1077,11 +979,6 @@ Hiiro.run(*ARGV, plugins: [Pins]) do
       next
     end
 
-    # Refresh all statuses first
-    force = args.include?('-U') || args.include?('--force-update')
-    pinned_manager.refresh_all_status(pinned, force: force)
-    pinned_manager.save_pinned(pinned)
-
     merged = pinned.select { |pr| pr['state'] == 'MERGED' }
     closed = pinned.select { |pr| pr['state'] == 'CLOSED' }
 
@@ -1109,15 +1006,10 @@ Hiiro.run(*ARGV, plugins: [Pins]) do
       next
     end
 
-    # Refresh all statuses first
-    force = args.include?('-U') || args.include?('--force-update')
-    pinned_manager.refresh_all_status(pinned, force: force)
-
     merged_or_closed = pinned.select { |pr| pr['state'] == 'MERGED' || pr['state'] == 'CLOSED' }
 
     if merged_or_closed.empty?
       puts "No merged or closed PRs to unpin"
-      pinned_manager.save_pinned(pinned)
       next
     end
 

data/bin/h-project

@@ -4,7 +4,7 @@ require "hiiro"
 
 # Helper to start or attach to a tmux session
 def start_tmux_session(session_name)
-  session_name = session_name.to_s
+  session_name = session_name.to_s.gsub(?., ?_)
 
   unless system('tmux', 'has-session', '-t', session_name)
     system('tmux', 'new', '-d', '-A', '-s', session_name)

data/demo.sh

@@ -0,0 +1,116 @@
+#!/usr/bin/env bash
+#
+# Hiiro Quick Demo
+#
+# Usage: bash demo.sh
+#
+# Walks through key Hiiro features with commentary.
+# Each step pauses so you can see the output.
+
+set -e
+
+BOLD="\033[1m"
+DIM="\033[2m"
+CYAN="\033[36m"
+GREEN="\033[32m"
+YELLOW="\033[33m"
+RESET="\033[0m"
+
+step=0
+
+demo() {
+  step=$((step + 1))
+  echo ""
+  echo -e "${BOLD}${CYAN}── Step $step: $1${RESET}"
+  echo -e "${DIM}$ $2${RESET}"
+  echo ""
+  eval "$2"
+  echo ""
+  echo -e "${DIM}(press enter to continue)${RESET}"
+  read -r
+}
+
+echo -e "${BOLD}${GREEN}"
+echo "╔══════════════════════════════════════╗"
+echo "║         Hiiro Quick Demo             ║"
+echo "╚══════════════════════════════════════╝"
+echo -e "${RESET}"
+echo "Hiiro is a lightweight CLI framework for Ruby."
+echo "It gives you subcommand dispatch, abbreviation"
+echo "matching, and a plugin system."
+echo ""
+echo -e "${DIM}(press enter to start)${RESET}"
+read -r
+
+# ─── Abbreviations ───
+
+demo "List all top-level commands" \
+     "h || true"
+
+demo "Abbreviation matching: 'h to' resolves to 'h todo'" \
+     "h to || true"
+
+demo "Abbreviations work at every level: 'h to ls' = 'h todo ls'" \
+     "h to ls || true"
+
+demo "Ambiguous abbreviations show candidates: 'h s' matches multiple commands" \
+     "h s || true"
+
+demo "More specific prefix resolves: 'h se' narrows to 'h serve' (if unambiguous) or shows remaining matches" \
+     "h se || true"
+
+demo "Abbreviations chain: 'h wi ls' = 'h window ls'" \
+     "h wi ls || true"
+
+demo "Even shorter: 'h br' = 'h branch'" \
+     "h br || true"
+
+# ─── h task ───
+
+demo "h task - manage worktree-based tasks (via Tasks plugin)" \
+     "h task || true"
+
+demo "h task ls - list current tasks" \
+     "h task ls || true"
+
+demo "Abbreviation: 'h ta ls' = 'h task ls'" \
+     "h ta ls || true"
+
+# ─── h subtask ───
+
+demo "h subtask - same interface as task, scoped to subtasks" \
+     "h subtask || true"
+
+demo "h subtask ls - list current subtasks" \
+     "h subtask ls || true"
+
+demo "Abbreviation: 'h su ls' = 'h subtask ls'" \
+     "h su ls || true"
+
+# ─── h queue ───
+
+demo "h queue - background job queue management" \
+     "h queue || true"
+
+demo "h queue ls - list queued jobs" \
+     "h queue ls || true"
+
+demo "h queue status - show queue status" \
+     "h queue status || true"
+
+demo "Abbreviation: 'h q ls' = 'h queue ls'" \
+     "h q ls || true"
+
+# ─── Wrap up ───
+
+echo -e "${BOLD}${GREEN}"
+echo "╔══════════════════════════════════════╗"
+echo "║           Demo Complete!             ║"
+echo "╚══════════════════════════════════════╝"
+echo -e "${RESET}"
+echo "Key takeaways:"
+echo "  - Type just enough letters to be unambiguous"
+echo "  - Abbreviations work at every level (command + subcommand)"
+echo "  - 'h task' / 'h subtask' manage worktree-based workflows"
+echo "  - 'h queue' manages background jobs"
+echo ""

data/h-tmux-plugins.tmux

@@ -0,0 +1,30 @@
+#!/bin/bash
+# h-tmux-plugins.tmux -- Main entry point (sourced by TPM)
+# Provides: Jumplist navigation + Notification tracker via Hiiro bin commands
+
+# Helper to read tmux option with default
+get_option() {
+  local option="$1"
+  local default="$2"
+  local value
+  value=$(tmux show-option -gqv "$option" 2>/dev/null || true)
+  echo "${value:-$default}"
+}
+
+# --- Configuration ---
+JUMPLIST_BACK_KEY=$(get_option "@jumplist-back-key" "C-b")
+JUMPLIST_FORWARD_KEY=$(get_option "@jumplist-forward-key" "C-f")
+NOTIFY_MENU_KEY=$(get_option "@notify-menu-key" "C-n")
+NOTIFY_CLEAR_KEY=$(get_option "@notify-clear-key" "M-n")
+
+# --- Jumplist hooks ---
+tmux set-hook -g after-select-pane "run-shell -b 'h jumplist record'"
+tmux set-hook -g after-select-window "run-shell -b 'h jumplist record'"
+
+# --- Jumplist keybindings ---
+tmux bind-key -r "$JUMPLIST_BACK_KEY" run-shell "h jumplist back"
+tmux bind-key -r "$JUMPLIST_FORWARD_KEY" run-shell "h jumplist forward"
+
+# --- Notification keybindings ---
+tmux bind-key "$NOTIFY_MENU_KEY" run-shell "h notify menu"
+tmux bind-key "$NOTIFY_CLEAR_KEY" run-shell "h notify clear"

data/lib/hiiro/tmux.rb

@@ -79,24 +79,33 @@ class Hiiro
 
     # Session methods
 
+    def find_session(name)
+      normalized = name.to_s.tr('.', '_')
+      sessions.find { |s| s.name == normalized } ||
+        Matcher.by_prefix(sessions.map(&:name), normalized)&.resolved&.then { |m| sessions.find { |s| s.name == m.item } }
+    end
+
     def session_exists?(name)
-      sessions.any?{|session| session.name == name }
+      !find_session(name).nil?
     end
 
     def open_session(name, **opts)
-      session_name = name.to_s
+      session_name = name.to_s.tr('.', '_')
+      existing = find_session(session_name)
 
-      unless session_exists?(session_name)
+      unless existing
         new_session(session_name, **opts, detached: true)
       end
 
+      resolved_name = existing&.name || session_name
+
       if in_tmux?
-        switch_client(session_name)
+        switch_client(resolved_name)
       elsif in_nvim?
         puts "Can't attach to tmux inside a vim terminal"
         false
       else
-        attach_session(session_name)
+        attach_session(resolved_name)
       end
     end
 
@@ -110,25 +119,32 @@ class Hiiro
     end
 
     def kill_session(name)
-      run_system('kill-session', '-t', name)
+      resolved = find_session(name)&.name || name.to_s.tr('.', '_')
+      run_system('kill-session', '-t', resolved)
     end
 
     def attach_session(name)
-      run_system('attach-session', '-t', name)
+      resolved = find_session(name)&.name || name.to_s.tr('.', '_')
+      run_system('attach-session', '-t', resolved)
     end
 
     def switch_client(name)
-      run_system('switch-client', '-t', name)
+      resolved = find_session(name)&.name || name.to_s.tr('.', '_')
+      run_system('switch-client', '-t', resolved)
     end
 
     def detach_client(session: nil)
       args = ['detach-client']
-      args += ['-s', session] if session
+      if session
+        resolved = find_session(session)&.name || session.to_s.tr('.', '_')
+        args += ['-s', resolved]
+      end
       run_system(*args)
     end
 
     def rename_session(old_name, new_name)
-      run_system('rename-session', '-t', old_name, new_name)
+      resolved = find_session(old_name)&.name || old_name.to_s.tr('.', '_')
+      run_system('rename-session', '-t', resolved, new_name)
     end
 
     # Window methods

data/lib/hiiro/version.rb

@@ -1,3 +1,3 @@
 class Hiiro
-  VERSION = "0.1.133"
+  VERSION = "0.1.134"
 end

data/record-demo.sh

@@ -0,0 +1,176 @@
+#!/usr/bin/env bash
+#
+# Record a Hiiro demo typescript
+#
+# Usage:
+#   bash record-demo.sh
+#
+# This records a terminal session to 'demo.typescript' that can be
+# played back with:
+#   script -p demo.typescript
+#
+# The recording simulates typing commands and showing their output.
+
+TYPESCRIPT_FILE="demo.typescript"
+
+# If called without the __INNER flag, wrap ourselves in `script -r`
+if [[ -z "$__HIIRO_DEMO_INNER" ]]; then
+  export __HIIRO_DEMO_INNER=1
+  echo "Recording demo to $TYPESCRIPT_FILE ..."
+  echo "Play back with: script -p $TYPESCRIPT_FILE"
+  echo ""
+  script -r "$TYPESCRIPT_FILE" bash "$0"
+  exit $?
+fi
+
+# ── Helpers ──
+
+BOLD="\033[1m"
+DIM="\033[2m"
+CYAN="\033[36m"
+GREEN="\033[32m"
+YELLOW="\033[33m"
+WHITE="\033[37m"
+RESET="\033[0m"
+
+# Simulate typing a command character by character
+typecmd() {
+  local cmd="$1"
+  echo -ne "${GREEN}\$ ${BOLD}${WHITE}"
+  for (( i=0; i<${#cmd}; i++ )); do
+    echo -n "${cmd:$i:1}"
+    sleep 0.08
+  done
+  echo -e "${RESET}"
+  sleep 1.5  # pause after typing so viewer can read the command
+}
+
+# Print a section header
+header() {
+  echo ""
+  echo -e "${BOLD}${CYAN}━━━ $1 ━━━${RESET}"
+  echo ""
+  sleep 2.5  # time to read the section heading
+}
+
+# Pause after output so viewer can read what happened
+pause() {
+  sleep "${1:-3}"
+}
+
+# Run a command with simulated typing
+run() {
+  typecmd "$1"
+  eval "$1"
+  echo ""
+  pause
+}
+
+# ── Banner ──
+
+clear
+echo ""
+echo -e "${BOLD}${GREEN}╔══════════════════════════════════════╗${RESET}"
+echo -e "${BOLD}${GREEN}║         Hiiro Quick Demo             ║${RESET}"
+echo -e "${BOLD}${GREEN}╚══════════════════════════════════════╝${RESET}"
+echo ""
+echo -e "Hiiro is a lightweight CLI framework for Ruby."
+echo -e "It gives you subcommand dispatch, abbreviation"
+echo -e "matching, and a plugin system."
+echo ""
+sleep 4
+
+# ── Abbreviations ──
+
+header "Top-level commands"
+run "h || true"
+
+header "Abbreviation matching"
+echo -e "${DIM}h to  →  resolves to  →  h todo${RESET}"
+echo ""
+sleep 2
+run "h to || true"
+
+header "Deep abbreviations"
+echo -e "${DIM}h to ls  →  resolves to  →  h todo ls${RESET}"
+echo ""
+sleep 2
+run "h to ls || true"
+
+header "Ambiguous abbreviations"
+echo -e "${DIM}h s  →  matches multiple commands${RESET}"
+echo ""
+sleep 2
+run "h s || true"
+
+header "Narrowing down"
+echo -e "${DIM}h se  →  narrows the match${RESET}"
+echo ""
+sleep 2
+run "h se || true"
+
+header "Chained abbreviations"
+echo -e "${DIM}h wi ls  →  resolves to  →  h window ls${RESET}"
+echo ""
+sleep 2
+run "h wi ls || true"
+
+echo -e "${DIM}h br  →  resolves to  →  h branch${RESET}"
+echo ""
+sleep 2
+run "h br || true"
+
+# ── h task ──
+
+header "h task — worktree-based task management"
+run "h task || true"
+
+run "h task ls || true"
+
+echo -e "${DIM}h ta ls  →  resolves to  →  h task ls${RESET}"
+echo ""
+sleep 2
+run "h ta ls || true"
+
+# ── h subtask ──
+
+header "h subtask — scoped subtask management"
+run "h subtask || true"
+
+run "h subtask ls || true"
+
+echo -e "${DIM}h su ls  →  resolves to  →  h subtask ls${RESET}"
+echo ""
+sleep 2
+run "h su ls || true"
+
+# ── h queue ──
+
+header "h queue — background job queue"
+run "h queue || true"
+
+run "h queue ls || true"
+
+run "h queue status || true"
+
+echo -e "${DIM}h q ls  →  resolves to  →  h queue ls${RESET}"
+echo ""
+sleep 2
+run "h q ls || true"
+
+# ── Wrap up ──
+
+echo ""
+echo -e "${BOLD}${GREEN}╔══════════════════════════════════════╗${RESET}"
+echo -e "${BOLD}${GREEN}║           Demo Complete!             ║${RESET}"
+echo -e "${BOLD}${GREEN}╚══════════════════════════════════════╝${RESET}"
+echo ""
+echo -e "Key takeaways:"
+echo -e "  ${CYAN}•${RESET} Type just enough letters to be unambiguous"
+echo -e "  ${CYAN}•${RESET} Abbreviations work at every level"
+echo -e "  ${CYAN}•${RESET} ${WHITE}h task${RESET} / ${WHITE}h subtask${RESET} manage worktree-based workflows"
+echo -e "  ${CYAN}•${RESET} ${WHITE}h queue${RESET} manages background jobs"
+echo ""
+sleep 4
+
+exit 0

data/slides.md

@@ -0,0 +1,211 @@
+---
+author: Hiiro
+date: 2026-03-01
+paging: "%d / %d"
+---
+
+# Hiiro
+
+A lightweight CLI framework for Ruby
+
+- Subcommand dispatch
+- Abbreviation matching
+- Plugin system
+
+---
+
+# Abbreviation Matching
+
+Type just enough letters to be unambiguous.
+
+Hiiro resolves prefixes at **every level** of the command tree.
+
+```bash
+h
+```
+
+> Press `Ctrl+E` to run
+
+---
+
+# Abbreviations in Action
+
+`h to` resolves to `h todo`
+
+```bash
+h to
+```
+
+---
+
+# Deep Abbreviations
+
+Abbreviations work at every level.
+
+`h to ls` resolves to `h todo ls`
+
+```bash
+h to ls
+```
+
+---
+
+# Ambiguous Abbreviations
+
+When a prefix matches multiple commands,
+Hiiro shows the candidates.
+
+`h s` matches several commands:
+
+```bash
+h s || true
+```
+
+---
+
+# Narrowing Down
+
+A longer prefix narrows the match.
+
+`h se` gets closer:
+
+```bash
+h se || true
+```
+
+---
+
+# More Examples
+
+`h wi ls` = `h window ls`
+
+```bash
+h wi ls
+```
+
+---
+
+# Even Shorter
+
+`h br` = `h branch`
+
+```bash
+h br
+```
+
+---
+
+# h task
+
+Manage **worktree-based tasks** via the Tasks plugin.
+
+```bash
+h task
+```
+
+---
+
+# h task ls
+
+List current tasks:
+
+```bash
+h task ls || true
+```
+
+---
+
+# Task Abbreviation
+
+`h ta ls` = `h task ls`
+
+```bash
+h ta ls || true
+```
+
+---
+
+# h subtask
+
+Same interface as task, scoped to **subtasks**.
+
+```bash
+h subtask
+```
+
+---
+
+# h subtask ls
+
+List current subtasks:
+
+```bash
+h subtask ls || true
+```
+
+---
+
+# Subtask Abbreviation
+
+`h su ls` = `h subtask ls`
+
+```bash
+h su ls || true
+```
+
+---
+
+# h queue
+
+Background **job queue** management.
+
+```bash
+h queue
+```
+
+---
+
+# h queue ls
+
+List queued jobs:
+
+```bash
+h queue ls || true
+```
+
+---
+
+# h queue status
+
+Show queue status:
+
+```bash
+h queue status || true
+```
+
+---
+
+# Queue Abbreviation
+
+`h q ls` = `h queue ls`
+
+```bash
+h q ls || true
+```
+
+---
+
+# Key Takeaways
+
+- Type just enough letters to be unambiguous
+- Abbreviations work at every level
+- `h task` / `h subtask` - worktree-based workflows
+- `h queue` - background job management
+
+---
+
+# Thanks!
+
+```
+github.com/unixsuperhero/hiiro
+```

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hiiro
 version: !ruby/object:Gem::Version
-  version: 0.1.133
+  version: 0.1.134
 platform: ruby
 authors:
 - Joshua Toyota
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-03-01 00:00:00.000000000 Z
+date: 2026-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -90,8 +90,10 @@ files:
 - bin/h-claude
 - bin/h-commit
 - bin/h-config
+- bin/h-jumplist
 - bin/h-link
 - bin/h-misc
+- bin/h-notify
 - bin/h-pane
 - bin/h-plugin
 - bin/h-pr
@@ -101,7 +103,8 @@ files:
 - bin/h-todo
 - bin/h-window
 - bin/h-wtree
-- bin/testlink
+- demo.sh
+- demo.typescript
 - docs/README.md
 - docs/docker-testing-guide.md
 - docs/h-buffer.md
@@ -112,6 +115,7 @@ files:
 - editboth
 - exe/h
 - exe/hiiro
+- h-tmux-plugins.tmux
 - hiiro.gemspec
 - lib/hiiro.rb
 - lib/hiiro/bins.rb
@@ -146,12 +150,14 @@ files:
 - plugins/notify.rb
 - plugins/pins.rb
 - plugins/project.rb
+- record-demo.sh
 - scripts/compare
 - scripts/install
 - scripts/publish
 - scripts/sync
 - scripts/test
 - scripts/update
+- slides.md
 homepage: https://github.com/unixsuperhero/hiiro
 licenses:
 - MIT

data/bin/testlink

@@ -1 +0,0 @@
-../exe/h