@lamemind/loom-deck 0.43.0 → 0.45.0

package/dist/ui/panes.js

@@ -5,11 +5,11 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { Box, Text } from 'ink';
 import { cut, cutParts, pad, sanitize, termWidth } from '../width.js';
 import { isDone, paneTextWidth } from '../layout.js';
-import { CARET, CARET_OFF, LIVE_BUSY, LIVE_IDLE, LIVE_NONE, MODEL_W, SESSION_SEP, SID_CHARS, TASK_EMPTY, WARN, displayProg, modelShort, relTime, } from '../glyphs.js';
+import { CARET, CARET_OFF, LIVE_BUSY, LIVE_IDLE, LIVE_NONE, MODEL_W, SESSION_SEP, SID_CHARS, TASK_EMPTY, WARN, displayProg, modelShort, relTime, taskTail, } from '../glyphs.js';
 import { META_ROWS, ROW_ALL, ROW_SPOT } from '../model.js';
 import { rowLabel, sessionTitle } from '../session-list.js';
 import { sessionView, taskView, SESSION_VIEWS, TASK_VIEWS, } from '../pane-views.js';
-import { describeSort, PRI_ENTRIES, PROG_ENTRIES } from '../view.js';
+import { describeSort, padId, PRI_ENTRIES, PROG_ENTRIES } from '../view.js';
 /**
  * Header del pane task, tagliato QUI e non da Ink — stesso motivo del gemello
  * `SessionsHeader`, con una differenza di rischio: qui i segmenti sono tutti
@@ -49,7 +49,7 @@ export function TasksHeader({ counts, active, above, below, focused, columns, })
     const shown = cutParts(segments.map((s) => s.text), paneTextWidth(columns), segments.findIndex((s) => s.active));
     return (_jsx(Text, { bold: true, color: focused ? 'cyan' : undefined, wrap: "truncate-end", children: segments.map((seg, i) => shown[i] ? (_jsx(Text, { color: seg.color, dimColor: seg.dim, inverse: seg.active, children: shown[i] }, i)) : null) }));
 }
-export function TasksPane({ tasks, counts, activeView, paneCount, view, selected, spotCount, allCount, childCount, focused, loadError, windowStart, above, below, columns, dirty, }) {
+export function TasksPane({ tasks, counts, activeView, paneCount, view, selected, spotCount, allCount, childCount, idW, tailW, focused, loadError, windowStart, above, below, columns, dirty, }) {
     const allSelected = selected === ROW_ALL;
     const spotSelected = selected === ROW_SPOT;
     return (_jsxs(Box, { flexDirection: "column", width: "50%", marginRight: 1, borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsx(TasksHeader, { counts: counts, active: activeView, above: above, below: below, focused: focused, columns: columns }), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: cut(sanitize(`sort: ${describeSort(view.sort)}` +
@@ -71,17 +71,31 @@ export function TasksPane({ tasks, counts, activeView, paneCount, view, selected
                 // completa, su cui è keyata la selezione. +META_ROWS: le prime due
                 // righe sono le meta.
                 const sel = windowStart + i + META_ROWS === selected;
-                const n = childCount.get(task.id) ?? 0;
+                const tail = taskTail(childCount.get(task.id) ?? 0, dirty.has(task.id));
+                // T118 — l'id è paddato a `idW`, quindi `head` ha la stessa larghezza
+                // su ogni riga e Pri/Prog cadono sempre nella stessa colonna.
+                const id = padId(task.id, idW);
                 // Invariante ③: la descrizione è l'unico pezzo a lunghezza libera, e
                 // si taglia QUI sul budget che resta dopo le colonne fisse. Lasciarlo
                 // fare a `truncate-end` significa passare da `cli-truncate`, che
                 // restituisce una riga più larga del pane (una colonna per emoji) e
                 // quindi scrive sopra il bordo. Le parti fisse si misurano con
-                // `termWidth`: `task.id` è `T9` o `T52`, i due glifi valgono 2 ciascuno.
-                const head = `${CARET_OFF}${task.id}  ${sanitize(task.pri)}  ${displayProg(task.prog)}  `;
-                const tail = `${n > 0 ? ` (${n})` : ''}${dirty.has(task.id) ? ` ${WARN}` : ''}`;
-                const desc = cut(task.desc, Math.max(4, paneTextWidth(columns) - termWidth(head) - termWidth(tail)));
-                return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, dimColor: !sel && isDone(task.prog), wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, task.id, "  ", sanitize(task.pri), "  ", displayProg(task.prog), "  ", desc, tail] }, task.id));
+                // `termWidth`: i due glifi Pri/Prog valgono 2 ciascuno.
+                const head = `${CARET_OFF}${id}  ${sanitize(task.pri)}  ${displayProg(task.prog)}  `;
+                // T118 — la colonna della coda si riserva PRIMA di tagliare la
+                // descrizione, e per la stessa larghezza su ogni riga: appesa dopo,
+                // entrava nel budget solo dove c'era qualcosa da scrivere, e la
+                // descrizione si tagliava a una colonna diversa riga per riga.
+                //
+                // Pavimento `0` su tutte e tre le misure e non un minimo di cortesia:
+                // il budget è un TETTO. Un pavimento sopra lo spazio reale fa uscire
+                // la riga dal pane e le mangia il bordo. `reserve` si clampa su ciò
+                // che avanza, così `head + desc + coda` sta sempre dentro il pane.
+                const avail = Math.max(0, paneTextWidth(columns) - termWidth(head));
+                const reserve = Math.min(tailW, avail);
+                const descW = avail - reserve;
+                const desc = cut(task.desc, descW);
+                return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, dimColor: !sel && isDone(task.prog), wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, id, "  ", sanitize(task.pri), "  ", displayProg(task.prog), "  ", desc, ' '.repeat(Math.max(0, descW - termWidth(desc))), pad(tail, reserve, 'right')] }, task.id));
             }))] }));
 }
 /**

package/dist/view.js

@@ -59,6 +59,37 @@ export function idNum(id) {
     const m = /^T(\d+)$/.exec(id);
     return m ? Number(m[1]) : Number.MAX_SAFE_INTEGER;
 }
+/**
+ * T118 — larghezza della colonna id, DERIVATA dalla popolazione.
+ *
+ * La popolazione è la vista attiva COMPLETA, non la finestra visibile: una
+ * larghezza misurata sulle sole righe renderizzate sposta le colonne mentre si
+ * scorre, cioè una tabella corretta a ogni frame e illeggibile nel movimento.
+ * Il chiamante deve quindi passare `paneTasks`, non l'array che finisce nel
+ * pane (`tasks` in `TaskPane` è già la finestra).
+ *
+ * Gli id sono `T` + cifre (`TASK_ID_RE`), cioè ASCII: `.length` conta colonne.
+ */
+export function idColumnWidth(tasks) {
+    let w = 0;
+    for (const t of tasks)
+        w = Math.max(w, t.id.length);
+    return w;
+}
+/**
+ * T118 — id allineato a destra DENTRO il prefisso: `T102` in lista rende `T90`
+ * come `T 90`, non come ` T90`.
+ *
+ * Il prefisso di tipo è l'ancora con cui l'occhio riconosce la colonna:
+ * spostarlo riga per riga toglie proprio ciò che l'allineamento dava. Sono le
+ * cifre ad allinearsi fra loro, la `T` resta ferma.
+ */
+export function padId(id, cols) {
+    const m = /^([A-Za-z]+)(\d+)$/.exec(id);
+    if (!m)
+        return id.padEnd(cols);
+    return m[1] + ' '.repeat(Math.max(0, cols - id.length)) + m[2];
+}
 function rankOf(task, key) {
     if (key === 'pri')
         return priRank(task.pri);

package/dist/viewport.js

@@ -223,23 +223,22 @@ export function readerCapacity(rows) {
 //   1  riga hint
 //   1  marginTop del box testo
 //   2  bordi del box testo
-//   1  marginTop della riga azioni
-//   1  riga modello (T108)
-//   1  riga nota (T111)
-//   1  riga azioni
+//   1  marginTop dell'area di compilazione
+//   1  riga azione   (T66)
+//   1  riga prompt   (T117)
+//   1  riga modello  (T108)
+//   1  riga titolo   (T111)
 //
-// Le ultime quattro sono il motivo per cui il detail non può riusare
-// READER_CHROME: barra bottoni, selettore modello e campo nota sono righe FISSE
-// in più dentro l'overlay, e ogni riga fissa aggiunta va scalata dalla capienza
-// del contenuto o il frame sfonda `rows` (stessa invariante di
-// TASKS_PANE_CHROME).
+// Le ultime cinque sono il motivo per cui il detail non può riusare
+// READER_CHROME: le quattro righe dell'area di compilazione sono righe FISSE in
+// più dentro l'overlay, e ogni riga fissa aggiunta va scalata dalla capienza del
+// contenuto o il frame sfonda `rows` (stessa invariante di TASKS_PANE_CHROME).
 //
-// La nota è una riga fissa e non un secondo `extra` di `detailCapacity` (T111 ·
-// D1): due condizionali mutuamente esclusivi obbligherebbero il parametro a dire
-// QUALE è aperto — un solo booleano per entrambi sottostima quando quello aperto
-// è il più alto, e sommarli toglie righe al testo per un campo che non è a
-// schermo.
-const DETAIL_CHROME = 12;
+// Sono fisse e non `extra` condizionali di `detailCapacity` (T111 · D1): due
+// condizionali mutuamente esclusivi obbligherebbero il parametro a dire QUALE è
+// a schermo — un solo booleano per entrambi sottostima quando quello aperto è il
+// più alto, e sommarli toglie righe al testo per un campo che non c'è.
+const DETAIL_CHROME = 13;
 // T91 — la ricerca dentro il detail: marginTop + riga del campo.
 //
 // `MODAL_HEIGHT` dice che il detail costa 0 ai due pane (li sostituisce), e da

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lamemind/loom-deck",
-  "version": "0.43.0",
+  "version": "0.45.0",
   "description": "Deck TUI Ink per-progetto della famiglia loom: legge tasks.md e spawna sessioni Claude Code bound via LOOM_TASK",
   "type": "module",
   "bin": {

package/scripts/deck-run

@@ -11,14 +11,18 @@
 # Quattro assi ORTOGONALI, da non confondere fra loro:
 #   binding task   <TaskID> ..... --no-task
 #   continuità     nuova ........ --resume [--fork]
-#   prompt         --prompt-kind none|recap|preflight|run|checkpoint
+#   prompt         --prompt-kind none|recap|preflight|run|checkpoint | --prompt <testo>
 #   modello        --model fable|opus|sonnet|haiku
 # Il terzo asse (T56) prima non esisteva: il prompt era una CONSEGUENZA degli
 # altri due (bound ⇒ recap, --no-task ⇒ niente, --resume ⇒ niente), quindi
 # "task-bound SENZA prompt" era inesprimibile e l'unico modo di non avere un
-# prompt era perdere la task. Il catalogo dei prompt vive qui e non nel deck
-# perché questo è il primitive UI-agnostico: il chiamante passa un SIMBOLO, non
-# una stringa — il quoting resta verificato in un posto solo (vedi PROMPT sotto).
+# prompt era perdere la task. Il kind è un SIMBOLO e il suo testo sta nel
+# catalogo condiviso `prompt-catalog` (sibling di questo script).
+# T117 — accanto al kind c'è ora `--prompt <testo>`, che passa il prompt
+# LETTERALE. I due sono mutuamente esclusivi: sono due modi di dire la stessa
+# cosa, e accettarli insieme costringerebbe a stabilire quale vince. Serve a chi
+# mostra il prompt all'utente prima dello spawn e glielo lascia modificare —
+# dopo una modifica nessun kind descrive più quel testo.
 # Il quarto asse (T108) è indipendente dagli altri tre: vale sul ramo bound come
 # su --no-task, su una sessione nuova come su una ripresa.
 #
@@ -56,6 +60,12 @@
 #
 set -euo pipefail
 
+# Il catalogo dei prompt è un file DATI sibling di questo script, non un `case`
+# qui dentro: lo legge anche il deck TUI, che con la stessa risoluzione sibling
+# arriva allo stesso file della stessa installazione.
+_SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROMPT_CATALOG="${LOOM_DECK_PROMPT_CATALOG:-${_SCRIPT_DIR}/prompt-catalog}"
+
 TASK=""
 SESSION_ID=""
 RESUME_ID=""
@@ -66,6 +76,11 @@ TITLE_NOTE=""
 # "kind implicito" da "kind chiesto", perché con --no-task il primo è legittimo
 # (nessun prompt, come sempre) e il secondo è un errore d'uso.
 PROMPT_KIND=""
+# T117 — prompt letterale. Vuoto NON basta a dire "non passato": `--prompt ''`
+# è una richiesta legittima (nessun prompt, deciso da chi ha svuotato il campo),
+# quindi la presenza del flag si tiene in un booleano a parte.
+PROMPT_TEXT=""
+PROMPT_GIVEN=0
 # Vuoto = flag non passato: la cascata (env, poi default) si risolve più sotto,
 # insieme alla validazione, così l'ingresso da argomento e quello da env passano
 # per lo stesso enum.
@@ -117,6 +132,10 @@ while [[ $# -gt 0 ]]; do
       PROMPT_KIND="${2:-}"; shift 2 ;;
     --prompt-kind=*)
       PROMPT_KIND="${1#*=}"; shift ;;
+    --prompt)
+      PROMPT_TEXT="${2:-}"; PROMPT_GIVEN=1; shift 2 ;;
+    --prompt=*)
+      PROMPT_TEXT="${1#*=}"; PROMPT_GIVEN=1; shift ;;
     --session-id)
       SESSION_ID="${2:-}"; shift 2 ;;
     --session-id=*)
@@ -150,6 +169,9 @@ USAGE="uso: deck-run <TaskID> [--model <alias>] [--prompt-kind <kind>] [--sessio
        run         /loom-works:run-task <TaskID>
        checkpoint  /loom-works:checkpoint-task <TaskID>
 
+  --prompt       prompt LETTERALE, per chi lo ha già composto (o fatto
+                 modificare). Esclusivo con --prompt-kind; vuoto = nessun prompt
+
   --model        modello della sessione: fable|opus|sonnet|haiku (default: opus)
                  valore ignoto → fallback sul default, con avviso su stderr
 
@@ -195,6 +217,18 @@ if [[ $NO_TASK -eq 1 && -n "$PROMPT_KIND" ]]; then
   echo "$USAGE" >&2
   exit 2
 fi
+if [[ $NO_TASK -eq 1 && $PROMPT_GIVEN -eq 1 ]]; then
+  echo "--prompt richiede una task: una sessione --no-task non ha prompt iniziale" >&2
+  echo "$USAGE" >&2
+  exit 2
+fi
+# Due modi di dire la stessa cosa: accettarli insieme obbligherebbe a stabilire
+# quale vince, cioè a scrivere una precedenza che nessun chiamante ha chiesto.
+if [[ $PROMPT_GIVEN -eq 1 && -n "$PROMPT_KIND" ]]; then
+  echo "--prompt e --prompt-kind sono mutuamente esclusivi (il testo o il simbolo, non entrambi)" >&2
+  echo "$USAGE" >&2
+  exit 2
+fi
 
 MODE="${LOOM_DECK_SPAWN_MODE:-inline}"
 PROFILE_UUID="${LOOM_DECK_PROFILE_UUID:-5a36ae48df1c4d4882f43060e3e59656}"
@@ -381,7 +415,7 @@ RES_FLAG=""
 FORK_FLAG=""
 [[ $FORK -eq 1 ]] && FORK_FLAG="--fork-session "
 
-# ── Catalogo dei prompt iniziali (T56) ───────────────────────────────────────
+# ── Catalogo dei prompt iniziali (T56 · T117) ────────────────────────────────
 # Il prompt iniziale è la scelta di CHI APRE la sessione, non una proprietà della
 # task: lo stesso task file si apre per leggerne lo stato, per un preflight, per
 # eseguirlo o a mani nude. Il kind è quell'intento.
@@ -391,28 +425,53 @@ FORK_FLAG=""
 #   preflight  → skill di preflight sulla task
 #   run        → skill di esecuzione sulla task
 #   checkpoint → skill di checkpoint sulla task
-# Vincolo di quoting: nessun template deve contenere apici singoli (viaggia
-# dentro '...' nel comando in-tab). `/loom-works:...` passa intero proprio perché
-# è single-quoted — lo slash e i due punti non sono metacaratteri lì dentro.
+#
+# T117 — i testi non stanno più qui ma nel file dati `prompt-catalog`, sibling di
+# questo script. Il deck TUI li mostra nel campo prompt del detail prima dello
+# spawn, e per farlo deve leggerli: come `case` bash sarebbe una seconda scrittura
+# delle stesse regole. Il file resta l'unica copia, letta da entrambi i lati.
+# Formato a righe e non JSON perché `jq` è dipendenza OPZIONALE di questo script
+# (con fallback) e leggere il catalogo lo renderebbe dura.
 #
 # Precedenza con l'env: LOOM_DECK_ENTER_PROMPT VINCE sul kind (retro-compat: chi
 # lo usa oggi non si accorge del cambio), tranne su `none` — chiedere
 # esplicitamente nessun prompt non è una richiesta che un default d'ambiente
-# possa scavalcare. Il placeholder {TASK} vale solo per il valore dell'override;
-# i template del catalogo interpolano ${TASK} diretto (nel `${VAR:-...}` la `}`
-# di `{TASK}` chiuderebbe in anticipo l'espansione).
-# Ogni kind è un template diretto sull'id: la lista del deck è monofamiglia
+# possa scavalcare. Non vince invece su `--prompt`, che è una richiesta esplicita
+# e già risolta: un override d'ambiente che scavalca un testo composto a mano
+# butterebbe via proprio la modifica che il flag esiste per portare.
+# Ogni template nomina il TaskID via `{TASK}`: la lista del deck è monofamiglia
 # (`T`, unico prefisso del contratto loom), quindi nessun prompt discrimina sulla
 # forma dell'id.
-case "${PROMPT_KIND:-recap}" in
-  none)       PROMPT="" ;;
-  recap)      PROMPT="recap stato task ${TASK}" ;;
-  preflight)  PROMPT="/loom-works:preflight-task ${TASK}" ;;
-  checkpoint) PROMPT="/loom-works:checkpoint-task ${TASK}" ;;
-  run)        PROMPT="/loom-works:run-task ${TASK}" ;;
-esac
-if [[ "${PROMPT_KIND:-}" != "none" && -n "${LOOM_DECK_ENTER_PROMPT:-}" ]]; then
-  PROMPT="${LOOM_DECK_ENTER_PROMPT//\{TASK\}/${TASK}}"
+_prompt_template() {  # <kind> → template col placeholder {TASK}, o niente
+  local want="$1" k t
+  [[ -f "$PROMPT_CATALOG" ]] || return 1
+  while IFS=$'\t' read -r k t || [[ -n "$k" ]]; do
+    [[ -z "$k" || "$k" == \#* ]] && continue
+    [[ "$k" == "$want" ]] && { printf '%s' "$t"; return 0; }
+  done < "$PROMPT_CATALOG"
+  return 1
+}
+
+if [[ $PROMPT_GIVEN -eq 1 ]]; then
+  PROMPT="$PROMPT_TEXT"
+else
+  _kind="${PROMPT_KIND:-recap}"
+  if [[ "$_kind" == "none" ]]; then
+    PROMPT=""
+  else
+    # Catalogo assente o voce mancante: il kind è già passato dall'enum sopra,
+    # quindi qui manca il FILE — un'installazione mutila, non un errore d'uso.
+    # Si degrada a nessun prompt dicendolo, invece di aprire una sessione con un
+    # prompt inventato al volo (che sarebbe la copia del catalogo).
+    if ! PROMPT="$(_prompt_template "$_kind")"; then
+      echo "catalogo prompt non leggibile ('${PROMPT_CATALOG}'): sessione senza prompt iniziale" >&2
+      PROMPT=""
+    fi
+    PROMPT="${PROMPT//\{TASK\}/${TASK}}"
+  fi
+  if [[ "$_kind" != "none" && -n "${LOOM_DECK_ENTER_PROMPT:-}" ]]; then
+    PROMPT="${LOOM_DECK_ENTER_PROMPT//\{TASK\}/${TASK}}"
+  fi
 fi
 
 # Comando eseguito dentro la tab: bind LOOM_TASK per la sessione, avvia CC sul PROMPT.
@@ -427,8 +486,21 @@ fi
 # fork (T28) ricade nello stesso ramo — è una ripresa, con id nuovo.
 # Il kind `none` (T56) atterra sulla stessa assenza per una ragione diversa: lì
 # la sessione è nuova e bound, ma l'utente ha chiesto di entrarci a mani nude.
+#
+# QUOTING DEL PROMPT — il testo entra in `bash -lc "$IN_TAB_CMD"`, cioè in una
+# riga che una shell PARSA. Finché i template erano scritti qui dentro bastava il
+# vincolo "nessun apice singolo nel catalogo"; da T117 il testo può arrivare da
+# `--prompt`, cioè digitato a mano dall'utente nel campo del detail — e lì un
+# apice singolo chiuderebbe la stringa, consegnando alla shell tutto ciò che
+# segue come comando. Si passa quindi per la stessa forma canonica di
+# `shellQuote` in spawn.ts: apice chiuso, apice letterale escapato, apice
+# riaperto (`'\''`). Dentro apici singoli nessun altro carattere resta speciale,
+# quindi non c'è nient'altro da enumerare — newline compresi.
+_shell_quote() {  # <testo> → il testo come argomento singolo per una shell POSIX
+  printf "'%s'" "${1//\'/\'\\\'\'}"
+}
 PROMPT_ARG=""
-[[ -n "$PROMPT" && -z "$RESUME_ID" ]] && PROMPT_ARG="'${PROMPT}'"
+[[ -n "$PROMPT" && -z "$RESUME_ID" ]] && PROMPT_ARG="$(_shell_quote "$PROMPT")"
 # Il SID_FLAG entra anche nel ramo --no-task, che altrimenti lo scarta insieme
 # agli altri elementi task-bound: nel fork di una sessione SPOT il sessionId
 # pinnato non serve a legare una task (non c'è) ma a rendere noto in anticipo

package/scripts/prompt-catalog

@@ -0,0 +1,21 @@
+# Catalogo dei prompt iniziali di una sessione Claude aperta dal deck.
+#
+# Formato a righe: <kind><TAB><template>, con `{TASK}` interpolato col TaskID.
+# Righe vuote e righe che iniziano con `#` sono commenti.
+#
+# Perché un file dati e non un `case` dentro deck-run: due lati hanno bisogno
+# dello stesso testo — deck-run per comporre il comando in-tab, il deck TUI per
+# pre-riempire il campo prompt del detail con ciò che sta per essere eseguito.
+# Come codice, il secondo lato dovrebbe riscriverlo, e le due copie divergono
+# alla prima voce aggiunta da una parte sola.
+#
+# `none` non compare: nessun prompt non è un template vuoto, è l'assenza della
+# voce. Chi chiede un kind fuori da questo file riceve un prompt vuoto.
+#
+# Vincolo sui template: nessun apice singolo. Il testo finisce dentro `'...'`
+# nel comando passato a `bash -lc`, e questo file è committato — un apice qui
+# sarebbe un errore di scrittura, non un input da quotare.
+recap	recap stato task {TASK}
+preflight	/loom-works:preflight-task {TASK}
+run	/loom-works:run-task {TASK}
+checkpoint	/loom-works:checkpoint-task {TASK}