@lamemind/loom-deck 0.57.3 → 0.59.0

package/dist/actions.js

@@ -131,12 +131,36 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, setNo
     // T49 — resume di una conversazione in una nuova tab. Unico punto: lo chiamano
     // il `⏎` della lista sessioni e quello sulla riga-sessione della ricerca, che
     // devono restare la stessa azione.
-    function resumeSession(sessionId) {
+    // T148 — il modello lo decide il CHIAMANTE, non questa funzione: la lista
+    // principale passa il selettore della preview (`model.resumeModel`), la
+    // ricerca passa il modello ereditato dalla sessione senza superficie di
+    // scelta (D1 preflight). I due chiamanti restano la stessa azione perché è
+    // lo spawn a essere identico, non la sorgente del valore.
+    function resumeSession(sessionId, modelKind) {
         const bound = model.bindings.get(sessionId) ?? null;
-        const spawned = spawnDeckResume(bound, cwd, sessionId, model.sessionNotes.get(sessionId));
+        const spawned = spawnDeckResume(bound, cwd, sessionId, modelKind, model.sessionNotes.get(sessionId));
         spawned.child.on('error', () => setNote(`⚠ resume fallito (${DECK_RUN})`));
         noteSpawn(spawned);
     }
+    /** T148 — `m`: scorre il modello con cui la sessione selezionata riprenderà
+     *  al successivo del catalogo. Stesso guard di `f` (serve un transcript
+     *  vero, non basta una riga selezionata): su una pinnata stale il blocco
+     *  preview non esiste — non c'è un bottone da cambiare. Nessuna nota di
+     *  conferma sul successo — il feedback è il bottone stesso, già a schermo
+     *  nella preview. */
+    function cycleResumeModel() {
+        if (model.focus !== 'sessions') {
+            setNote('m → modello: seleziona una sessione (→ per il pane)');
+            return;
+        }
+        if (!model.selSessionObj) {
+            setNote(model.selSessionId
+                ? 'm → pin stale: nessun modello da cambiare'
+                : 'm → nessuna sessione selezionata');
+            return;
+        }
+        model.cycleResumeModel();
+    }
     // T53 — scrive il sidecar e ricarica subito, senza attendere il tick del poll
     // (stesso feedback immediato del pin).
     //
@@ -202,7 +226,10 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, setNo
             ...(bound ? { taskId: bound } : {}),
             forkOf: s.sessionId,
         });
-        const spawned = spawnDeckFork(bound, cwd, s.sessionId, newId);
+        // T148 — il fork è l'altra continuità che condivide la stessa riga
+        // selezionata: porta via lo stesso `model.resumeModel` del resume, non un
+        // default fisso (P2 preflight).
+        const spawned = spawnDeckFork(bound, cwd, s.sessionId, newId, model.resumeModel);
         spawned.child.on('error', () => setNote(`⚠ fork fallito (${DECK_RUN})`));
         noteSpawn(spawned);
     }
@@ -310,6 +337,7 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, setNo
         spawnForTask,
         spawnTaskSession,
         resumeSession,
+        cycleResumeModel,
         writeNote,
         assignSession,
         forkSession,

package/dist/cli.js

@@ -19,6 +19,8 @@ import { resolveTasksPath, resolveTasksDir } from './tasks.js';
 import { LAUNCH_SEP } from './config.js';
 import { anchorFrame, enableMouse } from './mouse.js';
 import { sanitize } from './width.js';
+import { modelAlias } from './glyphs.js';
+import { MODEL_DEFAULT } from './spawn.js';
 import { deckLegend, frameGeometry, headlineWidth, indicatorRow, launchRow } from './frame.js';
 import { useDeckModel } from './deck-model.js';
 import { useDeckActions } from './actions.js';
@@ -70,7 +72,9 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         hasNote: Boolean(note),
         setMode,
         setNote,
-        onResume: (row) => actions.resumeSession(row.session.sessionId),
+        // T148/D1 — nessun selettore nella ricerca: il modello è quello ereditato
+        // dalla conversazione, senza superficie di scelta.
+        onResume: (row) => actions.resumeSession(row.session.sessionId, modelAlias(row.session.model) ?? MODEL_DEFAULT),
     });
     // T121 — il project status. Non è solo un overlay come i tre sopra: il suo
     // stato si legge in TESTATA a schermata chiusa, e il viewer è una delle sue
@@ -241,7 +245,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                     purgeBulk: model.purgeBulk,
                     inboxPane: model.rightPane === 'inbox',
                     hasInbox: model.selInbox !== null,
-                }), indicators: indicators, columns: columns }), frame.launchLine ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [launch.segments.map((s) => s.text).join(LAUNCH_SEP), launch.overflow > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 +", launch.overflow, " fuori riga"] })) : null, launch.unreachable > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 ", launch.unreachable, " oltre la 9\u00AA (non raggiungibili)"] })) : null] })) : null, mode === 'create' ? _jsx(TextBox, { glyph: "C", value: textModals.draft }) : null, mode === 'note' ? _jsx(TextBox, { glyph: "\u270E", value: textModals.noteDraft }) : null, mode === 'sort' ? _jsx(SortModal, { sort: model.view.sort }) : null, mode === 'filter' ? (_jsx(FilterModal, { view: model.view, cursor: viewModals.filterCursor })) : null, mode === 'edit' && textModals.edit && textModals.editTask ? (_jsx(EditModal, { id: textModals.editTask.id, draft: textModals.edit, row: textModals.editCursor.row, caret: textModals.editCursor.caret, columns: columns })) : null, mode === 'purge' && purge.draft ? (_jsx(PurgeModal, { draft: purge.draft, columns: columns })) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: frame.windowTasks, counts: model.taskCounts, activeView: model.taskViewId, paneCount: model.paneTasks.length, view: model.view, selected: model.selIndex, spotCount: model.spotCount, allCount: model.sessions.length, idW: model.taskCols.id, tailW: model.taskCols.tail, focused: model.focus === 'tasks', loadError: model.loadError, windowStart: frame.taskWin.start, above: frame.taskWin.start, below: model.paneTasks.length - frame.taskWin.end, columns: columns, data: model.taskRowData }), model.rightPane === 'inbox' ? (_jsx(InboxPane, { files: frame.windowInbox, counts: model.inboxCounts, activeView: model.inboxViewId, paneCount: model.inboxFiles.length, selectedPath: model.selInboxPath, focused: model.focus === 'inbox', above: frame.inboxWin.start, below: model.inboxFiles.length - frame.inboxWin.end, columns: columns, ok: model.inboxOk, scanned: model.inboxScanned })) : (_jsx(SessionsPane, { parentLabel: model.parentLabel, isSpot: model.isSpot, isAll: model.isAll, bindings: model.bindings, taskW: model.sessionCols.task, ageW: model.sessionCols.age, rows: frame.windowRows, counts: model.sessionCounts, activeView: model.sessionViewId, paneCount: model.sessionRows.length, selectedId: model.selSessionId ?? undefined, focused: model.focus === 'sessions', above: frame.sessionWin.start, below: model.sessionRows.length - frame.sessionWin.end, columns: columns, forkOf: model.forkOf, sessionNotes: model.sessionNotes, projectCore: model.projectCore, live: model.live }))] }), frame.budget.preview && previewKind === 'task' && model.detail ? (_jsx(PreviewPane, { kind: "task", detail: model.detail, maxLines: frame.budget.detailLines, columns: columns })) : frame.budget.preview && previewKind === 'inbox' && model.selInbox ? (_jsx(PreviewPane, { kind: "inbox", file: model.selInbox, columns: columns })) : frame.budget.preview && previewKind === 'session' && model.selSessionObj ? (_jsx(PreviewPane, { kind: "session", s: model.selSessionObj, firstLines: frame.budget.sessionFirstLines, lastLines: frame.budget.sessionLastLines, columns: columns, origin: model.forkOf.get(model.selSessionObj.sessionId) ?? null, note: model.sessionNotes.get(model.selSessionObj.sessionId) ?? '', live: model.live.get(model.selSessionObj.sessionId) ?? null })) : null, note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
+                }), indicators: indicators, columns: columns }), frame.launchLine ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [launch.segments.map((s) => s.text).join(LAUNCH_SEP), launch.overflow > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 +", launch.overflow, " fuori riga"] })) : null, launch.unreachable > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 ", launch.unreachable, " oltre la 9\u00AA (non raggiungibili)"] })) : null] })) : null, mode === 'create' ? _jsx(TextBox, { glyph: "C", value: textModals.draft }) : null, mode === 'note' ? _jsx(TextBox, { glyph: "\u270E", value: textModals.noteDraft }) : null, mode === 'sort' ? _jsx(SortModal, { sort: model.view.sort }) : null, mode === 'filter' ? (_jsx(FilterModal, { view: model.view, cursor: viewModals.filterCursor })) : null, mode === 'edit' && textModals.edit && textModals.editTask ? (_jsx(EditModal, { id: textModals.editTask.id, draft: textModals.edit, row: textModals.editCursor.row, caret: textModals.editCursor.caret, columns: columns })) : null, mode === 'purge' && purge.draft ? (_jsx(PurgeModal, { draft: purge.draft, columns: columns })) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: frame.windowTasks, counts: model.taskCounts, activeView: model.taskViewId, paneCount: model.paneTasks.length, view: model.view, selected: model.selIndex, spotCount: model.spotCount, allCount: model.sessions.length, idW: model.taskCols.id, tailW: model.taskCols.tail, focused: model.focus === 'tasks', loadError: model.loadError, windowStart: frame.taskWin.start, above: frame.taskWin.start, below: model.paneTasks.length - frame.taskWin.end, columns: columns, data: model.taskRowData }), model.rightPane === 'inbox' ? (_jsx(InboxPane, { files: frame.windowInbox, counts: model.inboxCounts, activeView: model.inboxViewId, paneCount: model.inboxFiles.length, selectedPath: model.selInboxPath, focused: model.focus === 'inbox', above: frame.inboxWin.start, below: model.inboxFiles.length - frame.inboxWin.end, columns: columns, ok: model.inboxOk, scanned: model.inboxScanned })) : (_jsx(SessionsPane, { parentLabel: model.parentLabel, isSpot: model.isSpot, isAll: model.isAll, bindings: model.bindings, taskW: model.sessionCols.task, ageW: model.sessionCols.age, rows: frame.windowRows, counts: model.sessionCounts, activeView: model.sessionViewId, paneCount: model.sessionRows.length, selectedId: model.selSessionId ?? undefined, focused: model.focus === 'sessions', above: frame.sessionWin.start, below: model.sessionRows.length - frame.sessionWin.end, columns: columns, forkOf: model.forkOf, sessionNotes: model.sessionNotes, projectCore: model.projectCore, live: model.live }))] }), frame.budget.preview && previewKind === 'task' && model.detail ? (_jsx(PreviewPane, { kind: "task", detail: model.detail, maxLines: frame.budget.detailLines, columns: columns })) : frame.budget.preview && previewKind === 'inbox' && model.selInbox ? (_jsx(PreviewPane, { kind: "inbox", file: model.selInbox, columns: columns })) : frame.budget.preview && previewKind === 'session' && model.selSessionObj ? (_jsx(PreviewPane, { kind: "session", s: model.selSessionObj, firstLines: frame.budget.sessionFirstLines, lastLines: frame.budget.sessionLastLines, columns: columns, origin: model.forkOf.get(model.selSessionObj.sessionId) ?? null, note: model.sessionNotes.get(model.selSessionObj.sessionId) ?? '', live: model.live.get(model.selSessionObj.sessionId) ?? null, resumeModel: model.resumeModel })) : null, note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
 }
 const cwd = process.cwd();
 // T116 — `exitOnCtrlC: false` toglie a Ink l'uscita immediata su `^C`: senza,

package/dist/commit-times.js

@@ -0,0 +1,66 @@
+// T136 — data dell'ultimo commit che ha toccato ogni task file, in UNA
+// passata di `git log` invece di uno spawn per file (vedi Description T136).
+//
+// `--format=#%ct` mette un prefisso che nessun path porta: la riga vuota
+// compare anche FRA il timestamp e i path (non solo a fine blocco), quindi non
+// può fare da separatore, e «tutte cifre» sarebbe una regola che un path
+// potrebbe violare. Un merge commit senza `-m` non elenca path e produce un
+// blocco senza righe path: si salta da sé, nessun ramo dedicato serve.
+//
+// git log esce in ordine cronologico DISCENDENTE: il primo hit di un path è
+// già il suo ultimo commit, quindi si tiene solo il primo e si ignorano gli
+// hit successivi dello stesso id.
+import { execFile } from 'node:child_process';
+import { basename } from 'node:path';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const FORMAT_RE = /^#(\d+)$/;
+// Il basename del task file, non il path intero (che cambia con la docs-root)
+// e non `TASK_ID_RE` di tasks.ts (ancorata all'id nudo, non matcha `T136-x.md`).
+const TASK_FILE_RE = /^(T\d+)-.*\.md$/;
+/**
+ * Parsing puro dell'output `git log --format=#%ct --name-only`. Isolato da
+ * `commitTimes` perché è l'unica parte che vale la pena collaudare: invocare
+ * git davvero misurerebbe la storia di QUESTO repo, un valore che si muove a
+ * ogni commit.
+ */
+export function parseCommitLog(output) {
+    const out = new Map();
+    let epoch = null;
+    for (const raw of output.split('\n')) {
+        const line = raw.trim();
+        const m = FORMAT_RE.exec(line);
+        if (m) {
+            epoch = Number(m[1]);
+            continue;
+        }
+        if (!line || epoch === null)
+            continue;
+        const idm = TASK_FILE_RE.exec(basename(line));
+        if (!idm)
+            continue;
+        const id = idm[1];
+        if (!out.has(id))
+            out.set(id, epoch); // primo hit = il più recente
+    }
+    return out;
+}
+/**
+ * `Map<taskId, epoch>` dell'ultimo commit di ogni task file sotto `tasksDir`.
+ *
+ * git muto (repo assente, path fuori dal repo, git non installato) → mappa
+ * vuota, mai un throw, come `archivable.ts`: un dato di ordinamento non può
+ * rompere il deck. Nessun `--since`/`-n`: un cap renderebbe la mappa
+ * incompleta proprio per le task vecchie mai più toccate, quelle che sotto
+ * `desc` finiscono in coda — dove un timestamp assente e uno vecchio si
+ * confonderebbero.
+ */
+export async function commitTimes(tasksDir, projectRoot) {
+    try {
+        const { stdout } = await execFileAsync('git', ['log', '--format=#%ct', '--name-only', '--', tasksDir], { cwd: projectRoot });
+        return parseCommitLog(stdout);
+    }
+    catch {
+        return new Map();
+    }
+}

package/dist/deck-model.js

@@ -14,18 +14,19 @@
 // la ragione per cui i loro conti di parametri restano leggibili.
 import { useEffect, useMemo, useState } from 'react';
 import { loadArchivableDays, loadIdentity, loadLaunch } from './config.js';
-import { useArchivable, useDirtyFolders, useInboxScan, useSessions, useTaskDetail, useTasks, } from './hooks.js';
+import { useArchivable, useCommitTimes, useDirtyFolders, useInboxScan, useSessions, useTaskDetail, useTasks, } from './hooks.js';
 import { DEFAULT_INBOX_STALE_HOURS, staleCount } from './inbox.js';
 import { cycleInboxView, inboxCounts as deriveInboxCounts, inboxView, selectInboxRows, } from './inbox-views.js';
 import { docsRootName } from './tasks.js';
 import { isDone } from './layout.js';
-import { TASK_EMPTY, relTime } from './glyphs.js';
+import { TASK_EMPTY, modelAlias, relTime } from './glyphs.js';
 import { assembleSessionList, firstSelectableId, rowIndexOf, selectedSession, } from './session-list.js';
 import { cycleSessionView, cycleTaskView, selectSessionRows, selectTasks, sessionView, taskView, } from './pane-views.js';
 import { ALL, MAX_SESSIONS, MAX_SESSIONS_ALL, META_ROWS, ROW_ALL, ROW_SPOT, SPOT, } from './model.js';
 import { applyView, taskColumns } from './view.js';
 import { loadView } from './view-store.js';
 import { termWidth } from './width.js';
+import { MODELS, MODEL_DEFAULT } from './spawn.js';
 /**
  * Conteggio dei figli per task, più il rollup delle VIVE e le conversazioni
  * senza binding.
@@ -124,6 +125,12 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, setNote, }) {
     // a due gruppi + separatore è una vista trasformata, un indice grezzo punterebbe
     // alla riga sbagliata dopo un pin o un cambio di contesto (stesso trap T39).
     const [selSessionId, setSelSessionId] = useState(null);
+    // T148/P8 — il modello con cui la riga selezionata riprenderà (resume/fork).
+    // UN SOLO valore, non una mappa sessionId → scelta: si ri-inizializza a ogni
+    // cambio di riga (l'effect qui sotto, keyed su `selSessionId`), quindi
+    // tornare su una riga già visitata NON ricorda la scelta fatta lì — è lo
+    // stesso costo che T108 ha già accettato per il selettore del detail.
+    const [resumeModel, setResumeModel] = useState(MODEL_DEFAULT);
     // T39 — vista corrente (filtri + sort). Vive nel modello e non nell'hook dei
     // modali che la editano: è ciò che `applyView` consuma per produrre la lista,
     // è persistita su disco e la rilegge il tasto `w`. È stato del modello che due
@@ -159,9 +166,12 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, setNote, }) {
     // includeva l'owner.
     const projectCore = identity ? identity.name : null;
     const projectName = cwd.split('/').pop() || cwd;
+    // T136 — data dell'ultimo commit di ogni task file, per la chiave `commit`
+    // della chain di sort.
+    const commitAt = useCommitTimes(tasksDir, cwd);
     // La vista è una trasformazione DERIVATA, applicata a valle del load: il
     // polling di tasks.md continua a funzionare senza saperne nulla.
-    const { visible: viewTasks, hidden: hiddenTasks } = useMemo(() => applyView(tasks, view), [tasks, view]);
+    const { visible: viewTasks, hidden: hiddenTasks } = useMemo(() => applyView(tasks, view, { commitAt }), [tasks, view, commitAt]);
     // T61 — il conteggio guarda la lista GREZZA, non `viewTasks`: le Done fuori
     // dai filtri della vista restano archiviabili, e un contatore che cambiasse
     // filtrando direbbe qualcosa sulla vista invece che sulla task list.
@@ -197,7 +207,9 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, setNote, }) {
         hidden: hiddenTasks,
         archivable: archivable.size,
     };
-    const paneTasks = useMemo(() => taskViewId === 'tasks' ? viewTasks : selectTasks(tasks, taskViewId, { view, archivable }), [taskViewId, viewTasks, tasks, view, archivable]);
+    const paneTasks = useMemo(() => taskViewId === 'tasks'
+        ? viewTasks
+        : selectTasks(tasks, taskViewId, { view, archivable, commitAt }), [taskViewId, viewTasks, tasks, view, archivable, commitAt]);
     const isSpot = sel === SPOT;
     const isAll = sel === ALL;
     // T112 — quando `CANC` pota in BLOCCO invece della sola task selezionata.
@@ -270,6 +282,17 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, setNote, }) {
             setSelSessionId(firstSelectableId(sessionRows));
         }
     }, [sessionRows, selSessionId]);
+    // T148/P8 — reset del selettore modello all'evento «la riga selezionata è
+    // cambiata». Il selettore del detail (T108) si azzera all'APERTURA
+    // dell'overlay; questo blocco non apre e non chiude mai, quindi il suo
+    // evento equivalente è il cambio di `selSessionId`. Keyed SOLO su quello (non
+    // su `selSessionObj`, che cambia identità a ogni poll delle sessioni anche
+    // quando la riga selezionata resta la stessa): un'altra dipendenza
+    // resetterebbe la scelta dell'utente sotto un timer invece che sotto un
+    // movimento del cursore.
+    useEffect(() => {
+        setResumeModel(modelAlias(selSessionObj?.model ?? '') ?? MODEL_DEFAULT);
+    }, [selSessionId]);
     // T134 — gemello dei due sopra: un file drenato sparisce dalla coda al primo
     // scan successivo, e la selezione cade sulla prima riga della lista invece
     // che su una posizione a caso.
@@ -349,6 +372,15 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, setNote, }) {
         const next = Math.max(0, Math.min(inboxFiles.length - 1, (at < 0 ? 0 : at) + delta));
         setSelInboxPath(inboxFiles[next].path);
     }
+    /** T148 — `m` scorre il selettore modello della riga sessione selezionata al
+     *  valore SUCCESSIVO del catalogo (ciclico), gemella di `cycleView` ma su un
+     *  asse diverso: qui non c'è una vista da cambiare, solo un valore da far
+     *  avanzare. Il guard (nessuna sessione, focus altrove) sta nell'attuatore
+     *  `actions.ts`, come per `f`/`p`: qui c'è solo la meccanica dello stato. */
+    function cycleResumeModel() {
+        const next = MODELS[(MODELS.indexOf(resumeModel) + 1) % MODELS.length];
+        setResumeModel(next);
+    }
     /**
      * T134 — `^B` scambia i due pane dello slot destro (D8 preflight).
      *
@@ -427,6 +459,8 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, setNote, }) {
         sessionCounts,
         selSessionObj,
         sessionCols,
+        resumeModel,
+        cycleResumeModel,
         // derivazioni del pane inbox
         rightPane,
         inboxScanned: inbox.scanned,

package/dist/frame.js

@@ -72,7 +72,7 @@ export function deckLegend(state) {
         // apertura: una legenda che annunciasse «tutte» dove il tasto ne pota una
         // sola sarebbe peggio di nessuna legenda.
         ...(state.focus === 'tasks' ? [state.purgeBulk ? 'CANC elimina tutte' : 'CANC elimina'] : []),
-        ...(canResume ? ['f fork'] : []),
+        ...(canResume ? ['f fork', 'm modello'] : []),
         // T117 · D3 — «titolo» anche qui: è lo stesso valore che il detail chiede
         // allo spawn, e due nomi per una cosa sola li paga chi legge le due
         // schermate. Rename di sola ETICHETTA: il dato resta `note` nel sidecar e

package/dist/glyphs.js

@@ -51,6 +51,23 @@ export function modelShort(id) {
     }
     return MODEL_UNKNOWN;
 }
+/**
+ * T148/P3 — id di modello → alias del CLI, stesso catalogo di `modelShort`
+ * (`MODEL_SHORT`): un id vuoto o fuori famiglia (gli stessi due casi che qui
+ * rendono `·` e `?`) torna `null` invece di un valore inventato — il chiamante
+ * degrada a `MODEL_DEFAULT` senza marcare nessun bottone come provenienza,
+ * perché su quei due casi non c'è una provenienza vera da dichiarare.
+ */
+export function modelAlias(id) {
+    if (!id)
+        return null;
+    const lower = id.toLowerCase();
+    for (const family of Object.keys(MODEL_SHORT)) {
+        if (lower.includes(family))
+            return family;
+    }
+    return null;
+}
 // T62 — colonna liveness, larga 1, incollata al sessionId senza gutter proprio:
 // il glifo qualifica QUELL'id, e uno spazio in mezzo lo farebbe leggere come una
 // colonna a sé. Entrambi Ambiguous (EAW) → 1 colonna per il terminale e 1 cella

package/dist/hooks.js

@@ -10,6 +10,7 @@ import { discoverProjectSessions } from './sessions.js';
 import { discoverLiveSessions, liveSig } from './live-sessions.js';
 import { loadSessionIndex } from './task-index.js';
 import { archivableIds, SCAN_INTERVAL_MS } from './archivable.js';
+import { commitTimes } from './commit-times.js';
 import { scanInbox, INBOX_SCAN_INTERVAL_MS } from './inbox.js';
 import { mixedCount, readWrapCache, runWrapScan, wrapCacheFile, wrapCount, } from './wrap-scan.js';
 import { purgeTargets } from './purge.js';
@@ -67,6 +68,43 @@ export function useTasks(tasksPath) {
     }, [tasksPath]);
     return { tasks, loadError };
 }
+/**
+ * T136 — data dell'ultimo commit di ogni task file, per la chiave di sort
+ * `commit`. D1 (preflight): sullo STESSO poll di `tasks.md` (`POLL_MS`), non
+ * su una scala propria come `useArchivable` — una passata di `git log` costa
+ * ~33ms ed è UNA invocazione per tick, indipendentemente dal numero di task.
+ *
+ * P5 (preflight): `commitTimes` ritorna una `Map` nuova a ogni tick anche
+ * quando il contenuto non cambia; passata nuda a una `useMemo` a valle ne
+ * romperebbe la memoizzazione ogni 1,5s. Si confronta per FIRMA prima di
+ * aggiornare lo stato, come `lastMtime` in `useTasks` e `lastSig` in
+ * `useSessions`: l'identità della mappa cambia solo dopo un commit vero.
+ */
+export function useCommitTimes(tasksDir, projectRoot) {
+    const [commitAt, setCommitAt] = useState(() => new Map());
+    useEffect(() => {
+        let lastSig = '';
+        let alive = true;
+        const reload = () => {
+            commitTimes(tasksDir, projectRoot).then((next) => {
+                if (!alive)
+                    return;
+                const sig = [...next.entries()].map(([id, ts]) => `${id}:${ts}`).sort().join(',');
+                if (sig === lastSig)
+                    return;
+                lastSig = sig;
+                setCommitAt(next);
+            });
+        };
+        reload();
+        const id = setInterval(reload, POLL_MS);
+        return () => {
+            alive = false;
+            clearInterval(id);
+        };
+    }, [tasksDir, projectRoot]);
+    return commitAt;
+}
 // Poll delle sessioni del progetto + binding sidecar. discoverProjectSessions
 // ha cache mtime-keyed interna → il poll è economico; qui si evita comunque il
 // re-render inutile con una signature (sessionId:ts + binding entries): setState

package/dist/input.js

@@ -415,7 +415,7 @@ export function useDeckInput({ cwd, tasksDir, mode, setMode, setNote, model, act
                         : 'nessuna sessione da riprendere');
                 }
                 else {
-                    actions.resumeSession(s.sessionId);
+                    actions.resumeSession(s.sessionId, model.resumeModel);
                 }
             }
         }
@@ -466,6 +466,11 @@ export function useDeckInput({ cwd, tasksDir, mode, setMode, setNote, model, act
             // selezionata del pane sessioni.
             actions.togglePin();
         }
+        else if (input === 'm') {
+            // T148 — scorre il modello di resume/fork della riga selezionata,
+            // gemella di `f`/`p`: azione immediata, nessun modale.
+            actions.cycleResumeModel();
+        }
         else if (input === 'N') {
             // T53 — nota sulla conversazione selezionata. MAIUSCOLA perché apre un
             // modale: nel deck le minuscole sono azioni immediate (`f` fork, `p` pin,

package/dist/model.js

@@ -33,7 +33,7 @@ export const ROW_SPOT = 1;
 export const META_ROWS = 2;
 // Modale sort a grammatica libera: un tasto per chiave, pressioni successive
 // ciclano asc → desc → fuori dalla chain.
-export const SORT_TASTI = { p: 'pri', s: 'prog', i: 'id' };
+export const SORT_TASTI = { p: 'pri', s: 'prog', i: 'id', c: 'commit' };
 // T52 — toggle del modale ricerca, tutti su CTRL (D2).
 //
 // I due campi di testo mangiano ogni lettera nuda, quindi un toggle non può

package/dist/pane-views.js

@@ -57,7 +57,7 @@ export const TASK_VIEWS = [
 export function selectTasks(tasks, id, ctx) {
     const entry = taskView(id);
     const picked = tasks.filter((t) => entry.has(t, ctx));
-    picked.sort((a, b) => compareTasks(a, b, ctx.view.sort));
+    picked.sort((a, b) => compareTasks(a, b, ctx.view.sort, ctx));
     return picked;
 }
 /** Glifo della sessione viva, gemello di `LIVE_IDLE` del render. Duplicato qui

package/dist/spawn.js

@@ -224,14 +224,22 @@ export function spawnDeck(id, cwd, sessionId, kind, model = MODEL_DEFAULT, spawn
 // `.claude/loom-works.json`): tenerlo così evita di dare al primitive un secondo
 // file da conoscere. Il titolo si congela qui — `claude --name` lo setta una
 // volta sola, quindi una nota cambiata DOPO non ri-titola la tab già aperta.
-export function resumeArgs(taskId, sessionId, note) {
+//
+// T148 — il modello viaggia SEMPRE, come in `deckArgs`: senza `--model`
+// `deck-run` risolve il proprio default fisso (`opus`) e lo passa comunque al
+// CLI, quindi una conversazione haiku ripresa senza il flag ripartirebbe in
+// opus (P2 preflight). Qui però non c'è un default fisso da cablare: chi
+// chiama ha già risolto il valore — il modello della conversazione d'origine,
+// o quello scelto al suo posto — e lo passa come argomento obbligatorio.
+export function resumeArgs(taskId, sessionId, model, note) {
     const args = taskId ? [taskId, '--resume', sessionId] : ['--no-task', '--resume', sessionId];
+    args.push('--model', model);
     if (note)
         args.push('--title-note', note);
     return args;
 }
-export function spawnDeckResume(taskId, cwd, sessionId, note) {
-    return launchDeckRun(resumeArgs(taskId, sessionId, note), cwd);
+export function spawnDeckResume(taskId, cwd, sessionId, model, note) {
+    return launchDeckRun(resumeArgs(taskId, sessionId, model, note), cwd);
 }
 // T28 — FORK: `deck-run <task|--no-task> --resume <origine> --fork --session-id
 // <nuovo>`. Variante del resume, non una terza forma: cambia solo che CC apre un
@@ -245,7 +253,11 @@ export function spawnDeckResume(taskId, cwd, sessionId, note) {
 // nota nel sidecar — ereditare quella dell'origine metterebbe nel titolo una
 // maniglia che nella lista non compare, cioè una promessa falsa. Il fork si
 // distingue col suo marcatore, `· fork`.
-export function forkArgs(taskId, originId, newId) {
+//
+// T148 — stesso obbligo di `resumeArgs`: il fork è un'altra forma di
+// continuità, quindi eredita anch'esso il modello dell'origine invece del
+// default fisso di uno spawn nuovo (P2 preflight).
+export function forkArgs(taskId, originId, newId, model) {
     return [
         ...(taskId ? [taskId] : ['--no-task']),
         '--resume',
@@ -253,10 +265,12 @@ export function forkArgs(taskId, originId, newId) {
         '--fork',
         '--session-id',
         newId,
+        '--model',
+        model,
     ];
 }
-export function spawnDeckFork(taskId, cwd, originId, newId) {
-    return launchDeckRun(forkArgs(taskId, originId, newId), cwd);
+export function spawnDeckFork(taskId, cwd, originId, newId, model) {
+    return launchDeckRun(forkArgs(taskId, originId, newId, model), cwd);
 }
 // T42 — sessione Claude NUDA: nessuna task, nessun prompt iniziale, nessun
 // sessionId pinnato (quindi nessuna entry nel sidecar session-tasks.jsonl: senza

package/dist/ui/detail-screen.js

@@ -2,10 +2,10 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // Detail della task (T66): quarta schermata sostitutiva, col markdown reso in
 // span tipizzati (T75) e la ricerca interna (T91).
 import { Box, Text } from 'ink';
-import { cut, cutParts } from '../width.js';
+import { cut } from '../width.js';
 import { sliceLine } from '../text-search.js';
 import { sliceSpans } from '../markdown.js';
-import { FieldText } from './fields.js';
+import { ChoiceRow, FieldText, LABEL_W } from './fields.js';
 import { DETAIL_ACTIONS, MODELS } from '../spawn.js';
 import { DROW } from '../overlays/sheet.js';
 import { CARET, CARET_OFF, WARN } from '../glyphs.js';
@@ -62,37 +62,6 @@ const PROMPT_HINT = ' · nessun prompt iniziale';
  *  che nessuno ci ripassi — un'etichetta che nomina dei tasti a mano è accoppiata
  *  al binding, e resta indietro appena il binding cambia. */
 const ACTION_KEYS = DETAIL_ACTIONS.map((a) => a.label[0]).join(' ');
-/** Prefisso incolonnato delle quattro righe dell'area di compilazione: le
- *  etichette si leggono una sotto l'altra, quindi la larghezza è quella della
- *  più lunga. Entra nel budget di ogni campo, da cui la costante. */
-const LABEL_W = 8;
-/** Una riga a SCELTA dell'area di compilazione: bottoni affiancati, voce attiva
- *  in video inverso.
- *
- * Due passate di `cutParts`: la seconda serve SOLO quando qualcosa cade, e
- * riserva le colonne del contatore. Riservarle sempre costerebbe 6 colonne su
- * ogni terminale largo per un avviso che lì non comparirà mai.
- *
- * `priority` sulla voce SELEZIONATA e non sulla prima: qui il troncamento
- * cancellerebbe l'unica informazione che la riga esiste per dare — quale valore
- * sta per essere usato.
- */
-function ChoiceRow({ label, values, index, focused, width, }) {
-    const segs = values.map((v) => `[ ${v} ]`);
-    const parts = [];
-    segs.forEach((s, i) => {
-        if (i > 0)
-            parts.push('  ');
-        parts.push(s);
-    });
-    const avail = Math.max(0, width - LABEL_W - CARET_OFF.length);
-    let shown = cutParts(parts, avail, index * 2);
-    const dropped = (v) => segs.filter((s, i) => v[i * 2] !== s).length;
-    if (dropped(shown) > 0)
-        shown = cutParts(parts, Math.max(0, avail - 6), index * 2);
-    const cut = dropped(shown);
-    return (_jsxs(Text, { wrap: "truncate-end", children: [focused ? CARET : CARET_OFF, _jsx(Text, { dimColor: true, children: label.padEnd(LABEL_W) }), shown.map((part, i) => i % 2 === 1 ? (_jsx(Text, { children: part }, i)) : (_jsx(Text, { inverse: i / 2 === index, color: i / 2 === index ? 'green' : 'gray', children: part }, i))), cut > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 +", cut] }) : null] }));
-}
 /**
  * Detail della task (T66): il task file scrollabile più l'area di compilazione.
  *

package/dist/ui/fields.js

@@ -9,8 +9,9 @@ import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-run
 // il marker di riga, il detail dentro un prefisso incolonnato). Tolta di mezzo,
 // dei due gemelli resta una cosa sola.
 import { Text } from 'ink';
-import { caretWindow, sanitize } from '../width.js';
+import { caretWindow, cutParts, sanitize } from '../width.js';
 import { cpLen } from '../layout.js';
+import { CARET, CARET_OFF } from '../glyphs.js';
 /**
  * Fuori fuoco (`focused` falso) il caret non si disegna e la finestra si ancora
  * in fondo, che è la vista utile per un campo che non si sta scrivendo: `at` lì
@@ -21,3 +22,40 @@ export function FieldText({ value, caret, focused, cols, }) {
     const win = caretWindow(value, focused ? caret : cpLen(value), cols);
     return (_jsxs(_Fragment, { children: [_jsx(Text, { children: sanitize(win.head) }), focused ? _jsx(Text, { inverse: true, children: sanitize(win.at) }) : null, _jsx(Text, { children: sanitize(win.tail) })] }));
 }
+/** Prefisso incolonnato delle righe a scelta/testo di un'area di compilazione:
+ *  le etichette si leggono una sotto l'altra, quindi la larghezza è quella
+ *  della più lunga fra le righe che la usano (T117 nel detail, T148 nella
+ *  preview sessione). */
+export const LABEL_W = 8;
+/**
+ * T117 — una riga a SCELTA di un'area di compilazione: bottoni affiancati,
+ * voce attiva in video inverso.
+ *
+ * Due passate di `cutParts`: la seconda serve SOLO quando qualcosa cade, e
+ * riserva le colonne del contatore. Riservarle sempre costerebbe 6 colonne su
+ * ogni terminale largo per un avviso che lì non comparirà mai.
+ *
+ * `priority` sulla voce SELEZIONATA e non sulla prima: qui il troncamento
+ * cancellerebbe l'unica informazione che la riga esiste per dare — quale valore
+ * sta per essere usato.
+ *
+ * T148 — estratto dal detail della task perché un secondo chiamante (il
+ * selettore modello della preview sessione) ne riusa la stessa resa a quadre,
+ * non un componente gemello capace di divergere.
+ */
+export function ChoiceRow({ label, values, index, focused, width, originIndex, }) {
+    const segs = values.map((v) => `[ ${v} ]`);
+    const parts = [];
+    segs.forEach((s, i) => {
+        if (i > 0)
+            parts.push('  ');
+        parts.push(s);
+    });
+    const avail = Math.max(0, width - LABEL_W - CARET_OFF.length);
+    let shown = cutParts(parts, avail, index * 2);
+    const dropped = (v) => segs.filter((s, i) => v[i * 2] !== s).length;
+    if (dropped(shown) > 0)
+        shown = cutParts(parts, Math.max(0, avail - 6), index * 2);
+    const cut = dropped(shown);
+    return (_jsxs(Text, { wrap: "truncate-end", children: [focused ? CARET : CARET_OFF, _jsx(Text, { dimColor: true, children: label.padEnd(LABEL_W) }), shown.map((part, i) => i % 2 === 1 ? (_jsx(Text, { children: part }, i)) : (_jsx(Text, { inverse: i / 2 === index, underline: i / 2 === originIndex, color: i / 2 === index ? 'green' : 'gray', children: part }, i))), cut > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 +", cut] }) : null] }));
+}

package/dist/ui/modals.js

@@ -9,7 +9,7 @@ import { CARET, CARET_OFF, WARN } from '../glyphs.js';
 import { EDIT_PRI, EDIT_PROG } from '../model.js';
 import { PRI_ENTRIES, PROG_ENTRIES } from '../view.js';
 import { progressText, PRI_GLYPH, PRI_LABEL, PROG_GLYPH } from '../task-edit.js';
-export const SORT_UI = { pri: 'pri', prog: 'stato', id: 'id' };
+export const SORT_UI = { pri: 'pri', prog: 'stato', id: 'id', commit: 'commit' };
 // Modali resi IN FLUSSO (come l'input box di create), non in overlay assoluto:
 // spingono giù i pane invece di coprirli, così la lista che stai filtrando
 // resta sempre visibile mentre la componi.

package/dist/ui/preview.js

@@ -4,15 +4,17 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { Box, Text } from 'ink';
 import { cut, wrapLines } from '../width.js';
 import { previewTextWidth } from '../layout.js';
-import { LIVE_BUSY, LIVE_IDLE, META_KEYS, SID_CHARS, fmtDateTime, fmtSize } from '../glyphs.js';
+import { LIVE_BUSY, LIVE_IDLE, META_KEYS, SID_CHARS, fmtDateTime, fmtSize, modelAlias, } from '../glyphs.js';
 import { NATURA_SHORT, inboxMark } from '../inbox.js';
+import { ChoiceRow } from './fields.js';
+import { MODELS } from '../spawn.js';
 /** Colonne del prefisso delle due anteprime della preview sessione (`» `, `« `,
  *  e i due spazi delle righe di continuazione). Costante perché entra nel
  *  budget di wrap, che è il posto in cui dimenticarla non produce un errore ma
  *  un bordo mangiato. */
 const PREVIEW_PREFIX_W = 2;
 export function PreviewPane(p) {
-    return (_jsx(Box, { flexDirection: "column", marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: p.kind === 'task' ? (_jsx(TaskPreview, { detail: p.detail, maxLines: p.maxLines, columns: p.columns })) : p.kind === 'inbox' ? (_jsx(InboxPreview, { file: p.file, columns: p.columns })) : (_jsx(SessionPreview, { s: p.s, firstLines: p.firstLines, lastLines: p.lastLines, columns: p.columns, origin: p.origin, note: p.note, live: p.live })) }));
+    return (_jsx(Box, { flexDirection: "column", marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: p.kind === 'task' ? (_jsx(TaskPreview, { detail: p.detail, maxLines: p.maxLines, columns: p.columns })) : p.kind === 'inbox' ? (_jsx(InboxPreview, { file: p.file, columns: p.columns })) : (_jsx(SessionPreview, { s: p.s, firstLines: p.firstLines, lastLines: p.lastLines, columns: p.columns, origin: p.origin, note: p.note, live: p.live, resumeModel: p.resumeModel })) }));
 }
 /**
  * T134 — corpo della preview inbox: due righe FISSE, contate da
@@ -45,7 +47,7 @@ export function InboxPreview({ file, columns }) {
 // SOLO con un titolo custom — senza, il titolo È già il primo prompt e la riga
 // lo duplicherebbe (D4 preflight). Le righe rese non superano mai il riservato
 // dal budget (`firstLines`/`lastLines`); renderne meno è sicuro (frame più corto).
-export function SessionPreview({ s, firstLines, lastLines, columns, origin, note, live, }) {
+export function SessionPreview({ s, firstLines, lastLines, columns, origin, note, live, resumeModel, }) {
     // Il prefisso `» `/`« ` è largo 2 e sta SULLA riga: va tolto dal budget di
     // wrap, o una riga piena esce dal box di quelle due colonne e a raccoglierla
     // arriva `cli-truncate`, che sfora di una colonna per emoji e mangia il bordo
@@ -57,7 +59,12 @@ export function SessionPreview({ s, firstLines, lastLines, columns, origin, note
     const width = previewTextWidth(columns) - PREVIEW_PREFIX_W;
     const first = s.customTitle && firstLines > 0 ? wrapLines(s.firstPrompt, width, firstLines) : [];
     const last = s.lastReply && lastLines > 0 ? wrapLines(s.lastReply, width, lastLines) : [];
-    return (_jsxs(_Fragment, { children: [_jsxs(Text, { bold: true, wrap: "truncate-end", children: [_jsx(Text, { color: "cyan", children: s.sessionId.slice(0, SID_CHARS) }), ' ', note ? _jsxs(Text, { color: "yellow", children: ["\u00AB", note, "\u00BB "] }) : null, _jsx(Text, { dimColor: Boolean(note), children: s.title })] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [fmtSize(s.sizeBytes), " \u00B7 ", s.turns, " turni \u00B7 ", fmtDateTime(s.ts), " \u00B7 ", s.gitBranch || '-', s.model ? ` · ${s.model}` : '', origin ? ` · ⑂ da ${origin.slice(0, 8)}` : '', live ? (_jsx(Text, { color: live.status === 'busy' ? 'yellow' : 'green', children: ` · ${live.status === 'busy' ? LIVE_BUSY : LIVE_IDLE} viva pid ${live.pid} (${live.status})` })) : null] }), first.map((line, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [i === 0 ? '» ' : '  ', line] }, `f${i}`))), last.map((line, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [i === 0 ? '« ' : '  ', line] }, `l${i}`)))] }));
+    // T148/P3 — l'alias del modello D'ORIGINE, per la sottolineatura (P5):
+    // `undefined` quando l'id non mappa su nessuna famiglia nota, cioè quando
+    // non c'è una provenienza vera da dichiarare.
+    const originAlias = modelAlias(s.model);
+    const originIndex = originAlias ? MODELS.indexOf(originAlias) : undefined;
+    return (_jsxs(_Fragment, { children: [_jsxs(Text, { bold: true, wrap: "truncate-end", children: [_jsx(Text, { color: "cyan", children: s.sessionId.slice(0, SID_CHARS) }), ' ', note ? _jsxs(Text, { color: "yellow", children: ["\u00AB", note, "\u00BB "] }) : null, _jsx(Text, { dimColor: Boolean(note), children: s.title })] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [fmtSize(s.sizeBytes), " \u00B7 ", s.turns, " turni \u00B7 ", fmtDateTime(s.ts), " \u00B7 ", s.gitBranch || '-', s.model ? ` · ${s.model}` : '', origin ? ` · ⑂ da ${origin.slice(0, 8)}` : '', live ? (_jsx(Text, { color: live.status === 'busy' ? 'yellow' : 'green', children: ` · ${live.status === 'busy' ? LIVE_BUSY : LIVE_IDLE} viva pid ${live.pid} (${live.status})` })) : null] }), _jsx(ChoiceRow, { label: "modello", values: MODELS, index: Math.max(0, MODELS.indexOf(resumeModel)), focused: false, width: previewTextWidth(columns), originIndex: originIndex }), first.map((line, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [i === 0 ? '» ' : '  ', line] }, `f${i}`))), last.map((line, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [i === 0 ? '« ' : '  ', line] }, `l${i}`)))] }));
 }
 /**
  * Righe non-wrappabili del dettaglio (titolo + meta + commit) e loro conteggio.

package/dist/ui/screens.js

@@ -71,7 +71,7 @@ export function HintBar({ mode, purge, keyLegend, indicators, columns, }) {
         return (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["nuova task \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " crea \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] }));
     }
     if (mode === 'sort') {
-        return (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["sort \u00B7 ", _jsx(Text, { color: "yellow", children: "p" }), " pri ", _jsx(Text, { color: "yellow", children: "s" }), " stato", ' ', _jsx(Text, { color: "yellow", children: "i" }), " id (asc\u2192desc\u2192off) \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] }));
+        return (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["sort \u00B7 ", _jsx(Text, { color: "yellow", children: "p" }), " pri ", _jsx(Text, { color: "yellow", children: "s" }), " stato", ' ', _jsx(Text, { color: "yellow", children: "i" }), " id ", _jsx(Text, { color: "yellow", children: "c" }), " commit (asc\u2192desc\u2192off) \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] }));
     }
     if (mode === 'filter') {
         return (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["filtri \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193\u2190\u2192" }), " naviga \u00B7 ", _jsx(Text, { color: "yellow", children: "spazio" }), ' ', "mostra/nascondi \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] }));

package/dist/view-store.js

@@ -10,7 +10,7 @@ import { DEFAULT_VIEW, PRI_ENTRIES, PROG_ENTRIES, } from './view.js';
 export function viewFilePath(projectRoot) {
     return join(projectRoot, '.claude', 'loom', 'deck-view.json');
 }
-const SORT_KEYS = ['pri', 'prog', 'id'];
+const SORT_KEYS = ['pri', 'prog', 'id', 'commit'];
 const PRI_NAMES = PRI_ENTRIES.map((e) => e.name);
 const PROG_NAMES = PROG_ENTRIES.map((e) => e.name);
 // Il file è editabile a mano e sopravvive ai cambi di schema: si tiene solo ciò

package/dist/view.js

@@ -116,11 +116,16 @@ export function taskColumns(tasks, data) {
     }
     return { id: idColumnWidth(tasks), tail: tail > 0 ? tail + 1 : 0 };
 }
-function rankOf(task, key) {
+// La chiave `commit` non ha un glifo: il rango è l'epoch stesso. Assente →
+// UNKNOWN_RANK (0), sempre più basso di un epoch reale → coda sotto `desc`,
+// stessa semantica del glifo non riconosciuto per `pri`/`prog`.
+function rankOf(task, key, ctx) {
     if (key === 'pri')
         return priRank(task.pri);
     if (key === 'prog')
         return progRank(task.prog);
+    if (key === 'commit')
+        return ctx.commitAt.get(task.id) ?? UNKNOWN_RANK;
     return idNum(task.id);
 }
 /**
@@ -129,9 +134,9 @@ function rankOf(task, key) {
  * SEMPRE deterministico (mai instabile fra re-render). Se `id` è già una chiave
  * esplicita della chain il fallback non serve: l'id è unico, la parità è totale.
  */
-export function compareTasks(a, b, sort) {
+export function compareTasks(a, b, sort, ctx) {
     for (const entry of sort) {
-        const diff = rankOf(a, entry.key) - rankOf(b, entry.key);
+        const diff = rankOf(a, entry.key, ctx) - rankOf(b, entry.key, ctx);
         if (diff !== 0)
             return entry.dir === 'asc' ? diff : -diff;
     }
@@ -174,14 +179,14 @@ export function isVisible(task, view) {
     return true;
 }
 /** Filtra poi ordina. Non muta l'input: il polling di tasks.md resta ignaro. */
-export function applyView(tasks, view) {
+export function applyView(tasks, view, ctx) {
     const visible = tasks.filter((t) => isVisible(t, view));
-    visible.sort((a, b) => compareTasks(a, b, view.sort));
+    visible.sort((a, b) => compareTasks(a, b, view.sort, ctx));
     return { visible, hidden: tasks.length - visible.length };
 }
 export const PRI_ENTRIES = PRI_TABLE.map((e) => ({ name: e.name, glyph: e.glyph }));
 export const PROG_ENTRIES = PROG_TABLE.map((e) => ({ name: e.name, glyph: e.glyph }));
-const SORT_LABEL = { pri: 'pri', prog: 'stato', id: 'id' };
+const SORT_LABEL = { pri: 'pri', prog: 'stato', id: 'id', commit: 'commit' };
 /** Riassunto della chain per l'header ("pri↓ id↑"); vuota → "—". */
 export function describeSort(sort) {
     if (sort.length === 0)

package/dist/viewport.js

@@ -38,9 +38,11 @@ const TASKS_PANE_CHROME = 6; // 2 bordi + header "Tasks (n)" + riga sort + 2 rig
 const SESSIONS_PANE_CHROME = 3; // 2 bordi + header "Sessions · …"
 const PREVIEW_CHROME = 3; // marginTop + 2 bordi
 /** Preview sessione: righe fisse = titolo + riga meta (size · turni · ultima
- *  attività · branch). Le due anteprime (primo prompt + ultima risposta) sono
- *  variabili, ciascuna al più MAX_SESSION_PREVIEW righe. */
-const SESSION_DETAIL_FIXED = 2;
+ *  attività · branch) + riga bottoni del modello di resume/fork (T148/P4). Le
+ *  due anteprime (primo prompt + ultima risposta) sono variabili, ciascuna al
+ *  più MAX_SESSION_PREVIEW righe. Conseguenza accettata: su un terminale basso
+ *  il blocco sparisce con una riga di anticipo rispetto a prima di T148. */
+const SESSION_DETAIL_FIXED = 3;
 const MAX_SESSION_PREVIEW = 3;
 /** T134 — preview inbox: nome del file + riga meta (natura, marcatori, branch,
  *  cappello, cifre, età). Righe TUTTE fisse, nessuna variabile: il corpo del

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lamemind/loom-deck",
-  "version": "0.57.3",
+  "version": "0.59.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": {