@lamemind/loom-deck 0.78.0 → 0.79.0

package/dist/live-sessions.js

@@ -2,8 +2,10 @@ import { readFileSync, readdirSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
 import { isWithin } from './project-path.js';
-function liveSessionsRoot() {
-    return join(homedir(), '.claude', 'sessions');
+/** La cartella del registry. `LOOM_DECK_LIVE_SESSIONS_ROOT` la sposta, per i
+ *  test che costruiscono un registro finto invece di leggere quello vero. */
+export function liveSessionsRoot(env = process.env) {
+    return env.LOOM_DECK_LIVE_SESSIONS_ROOT || join(homedir(), '.claude', 'sessions');
 }
 /**
  * Campo 22 (`starttime`) di `/proc/<pid>/stat`, o null se la riga non è
@@ -96,24 +98,16 @@ export function parseLiveEntry(content, pid) {
     };
 }
 /**
- * Le sessioni VIVE del solo progetto corrente, indicizzate per `sessionId` —
- * la stessa chiave del sidecar `session-tasks.jsonl` e di `deck-run --resume`,
- * quindi il join con la riga di lista è diretto.
- *
- * Il filtro per `cwd` è d'EFFICIENZA, non di correttezza: risparmia lo `stat`
- * di `/proc` sui processi degli altri progetti (il registry è globale, non
- * per-progetto). Il match resta sul `sessionId`.
+ * Le entry VIVE del registry, nell'ordine di `readdir`.
  *
- * Nessuna cache mtime-keyed come in `sessions.ts`: le entry sono poche e di
- * poche centinaia di byte, mentre `status` cambia a ogni turno — una cache qui
- * mostrerebbe `idle` su una sessione che sta lavorando, cioè il difetto che la
- * colonna esiste per non avere.
+ * `keep` scarta un'entry PRIMA del controllo di liveness: chi filtra per
+ * progetto risparmia così lo `stat` di `/proc` sui processi degli altri.
  */
-export function discoverLiveSessions(projectRoot) {
-    const out = new Map();
+function liveEntries(root, keep = () => true) {
+    const out = [];
     let files;
     try {
-        files = readdirSync(liveSessionsRoot()).filter((f) => f.endsWith('.json'));
+        files = readdirSync(root).filter((f) => f.endsWith('.json'));
     }
     catch {
         return out; // registry assente (CLI mai avviato, o versione che non lo scrive)
@@ -124,7 +118,7 @@ export function discoverLiveSessions(projectRoot) {
             continue;
         let content;
         try {
-            content = readFileSync(join(liveSessionsRoot(), f), 'utf8');
+            content = readFileSync(join(root, f), 'utf8');
         }
         catch {
             continue; // il processo può finire fra readdir e read
@@ -133,16 +127,101 @@ export function discoverLiveSessions(projectRoot) {
         if (!parsed)
             continue;
         const { entry, procStart } = parsed;
-        // T175 — `isWithin` regge le grafie di Windows: il registry scrive `C:\…`,
-        // e la root del deck può arrivare con la lettera del drive in un altro case.
-        if (!isWithin(entry.cwd, projectRoot))
+        if (!keep(entry))
             continue;
         if (!isAlive(pid, procStart))
             continue;
+        out.push(entry);
+    }
+    return out;
+}
+/**
+ * Le sessioni VIVE del solo progetto corrente, indicizzate per `sessionId` —
+ * la stessa chiave del sidecar `session-tasks.jsonl` e di `deck-run --resume`,
+ * quindi il join con la riga di lista è diretto.
+ *
+ * Il filtro per `cwd` è d'EFFICIENZA, non di correttezza: risparmia lo `stat`
+ * di `/proc` sui processi degli altri progetti (il registry è globale, non
+ * per-progetto). Il match resta sul `sessionId`.
+ *
+ * Nessuna cache mtime-keyed come in `sessions.ts`: le entry sono poche e di
+ * poche centinaia di byte, mentre `status` cambia a ogni turno — una cache qui
+ * mostrerebbe `idle` su una sessione che sta lavorando, cioè il difetto che la
+ * colonna esiste per non avere.
+ */
+export function discoverLiveSessions(projectRoot) {
+    const out = new Map();
+    // T175 — `isWithin` regge le grafie di Windows: il registry scrive `C:\…`,
+    // e la root del deck può arrivare con la lettera del drive in un altro case.
+    for (const entry of liveEntries(liveSessionsRoot(), (e) => isWithin(e.cwd, projectRoot))) {
         out.set(entry.sessionId, entry);
     }
     return out;
 }
+/**
+ * Il nome CHIESTO in un argv di `claude` — il valore di `--name` o del suo alias
+ * `-n`, staccato o con `=` — oppure `null` se l'argv non ne chiede uno.
+ *
+ * Non è il campo `name` del registry, ed è la ragione per cui serve: il registry
+ * porta il nome EFFETTIVO, e quando il nome chiesto è già preso il CLI rinomina
+ * la sessione (`🧵 loom-works` → `🧵 loom-works-cryptic-hopper`, con
+ * `nameSource: "collision"`), mentre il titolo della tab resta il nome chiesto.
+ *
+ * GEMELLA di `procRequestedName` in `loom-compass/compass@lamemind/model.js`:
+ * le due letture devono riconoscere le stesse quattro forme.
+ */
+export function requestedNameIn(argv) {
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--name' || a === '-n')
+            return argv[i + 1] ?? null;
+        if (a.startsWith('--name='))
+            return a.slice('--name='.length);
+        if (a.startsWith('-n='))
+            return a.slice('-n='.length);
+    }
+    return null;
+}
+/** Gli argomenti del processo: `/proc/<pid>/cmdline` li separa con NUL e ne
+ *  mette uno anche in coda. Ogni argomento arriva intero, spazi compresi. */
+function procArgv(pid) {
+    let raw;
+    try {
+        raw = readFileSync(`/proc/${pid}/cmdline`, 'utf8');
+    }
+    catch {
+        return null; // processo finito fra la liveness e la lettura
+    }
+    const argv = raw.split('\0');
+    if (argv.length && argv[argv.length - 1] === '')
+        argv.pop();
+    return argv;
+}
+/**
+ * T182 — i nomi chiesti con `--name` dalle conversazioni vive di TUTTI i
+ * progetti: l'ingresso di `twinTitle` (`src/twin-title.ts`).
+ *
+ * Nessun filtro per `cwd`, al contrario di `discoverLiveSessions`: chi cerca la
+ * tab per titolo la cerca in tutte le finestre Ptyxis, quindi una conversazione
+ * dello stesso progetto aperta da un worktree di lane (altro `cwd`, stesso
+ * titolo) è un gemello a tutti gli effetti. Il titolo porta già la label del
+ * progetto, e il confronto per uguaglianza intera non scambia un progetto con
+ * un altro.
+ *
+ * Una viva senza `--name` non entra: il suo titolo di tab non è un nome
+ * chiesto. Dove `/proc` non esiste nessuna entry risulta viva, e la lista
+ * esce vuota: il lancio usa il nome base.
+ */
+export function liveRequestedNames(root = liveSessionsRoot()) {
+    const names = [];
+    for (const entry of liveEntries(root)) {
+        const argv = procArgv(entry.pid);
+        const name = argv ? requestedNameIn(argv) : null;
+        if (name !== null)
+            names.push(name);
+    }
+    return names;
+}
 /** Signature del poll: cambia quando cambia l'insieme delle vive O lo stato di
  *  una di esse. Il `pid` ci sta dentro perché un `/clear` sposta lo stesso
  *  `sessionId` su un processo diverso senza toccare né insieme né stato. */

package/dist/tab-compose.js

@@ -15,6 +15,7 @@
 import { saneNote } from './sane-note.js';
 import { MODEL_DEFAULT, MODELS } from './spawn-catalog.js';
 import { shellQuote } from './spawn.js';
+import { twinTitle } from './twin-title.js';
 export const PERMISSION_MODES = ['acceptEdits', 'auto', 'bypassPermissions', 'manual', 'dontAsk', 'plan'];
 /** L'alfabeto della chiave di stato: il valore entra in `bash -lc "…"` e il
  *  file di progetto è editabile a mano, quindi si scarta invece di quotare. */
@@ -173,6 +174,12 @@ export function posixQuote(text) {
 /**
  * La composizione intera.
  *
+ * Il titolo è `tabTitle` più, solo se una conversazione viva ha già chiesto lo
+ * stesso nome, il carattere del gemello (`twinTitle`, T182). Il carattere entra
+ * nel titolo intero — label, task, nota e fork compresi — perché due
+ * conversazioni della stessa task con note diverse hanno già titoli distinti e
+ * non sono gemelle. Lo stesso `title` alimenta `-T` di Ptyxis e `--name`.
+ *
  * Ordine degli argomenti di `claude`: nome, permission mode e modello prima dei
  * flag di continuità, il prompt sempre ultimo. Il modello sta accanto al
  * permission mode perché sono la stessa cosa — la scelta di chi apre la
@@ -186,7 +193,7 @@ export function posixQuote(text) {
  */
 export function composeTab(req, ctx) {
     const warnings = [];
-    const title = tabTitle(req, projectLabel(ctx.config));
+    const title = twinTitle(tabTitle(req, projectLabel(ctx.config)), ctx.liveRequestedNames ?? []);
     const mode = permissionMode(ctx, warnings);
     const model = modelOf(req, ctx, warnings);
     const key = stateKey(ctx, warnings);

package/dist/tab-launch.js

@@ -21,6 +21,7 @@ import { isUsageError, parseTabArgs } from './tab-args.js';
 import { composeTab, ptyxisArgv } from './tab-compose.js';
 import { loadPromptCatalog, PROMPT_CATALOG } from './prompt-catalog.js';
 import { configFilePath } from './config.js';
+import { liveRequestedNames, liveSessionsRoot } from './live-sessions.js';
 import { resolveGitBash } from './git-bash.js';
 import { semicolonArg, TAB_ARGV_ENV, windowsTabEnv, WT_CMD, wtNewTabArgs, wtProfile, } from './windows-terminal.js';
 /** Il wrapper che gira dentro una tab di Windows Terminal, nel build: lo esegue
@@ -96,6 +97,9 @@ export async function runDeckRun(argv, io) {
         catalog: loadPromptCatalog(catalogPath),
         catalogPath,
         platform: io.platform,
+        // Su Windows niente `/proc`, quindi nessuna liveness (T177): il titolo
+        // resta quello base, cioè il comportamento di prima del gemello.
+        liveRequestedNames: io.platform === 'win32' ? [] : liveRequestedNames(liveSessionsRoot(io.env)),
     });
     for (const w of plan.warnings)
         io.stderr(`${w}\n`);

package/dist/twin-title.js

@@ -0,0 +1,63 @@
+// T182 — il titolo della conversazione GEMELLA: un carattere in coda al
+// `--name` quando una conversazione viva ha già chiesto lo stesso nome.
+//
+// Chi porta davanti la tab di una conversazione la cerca per titolo (coda via
+// AT-SPI, `sessionsByName` di compass), e il titolo della tab è il `--name`
+// passato a `claude`. Due conversazioni vive con lo stesso nome — tipico: il
+// preflight e il run della stessa task — hanno due tab con lo stesso titolo, e
+// chi cerca non può scegliere. Il lanciatore rende unico il secondo titolo; il
+// primo lancio resta senza carattere, quindi nel caso normale il titolo è quello
+// di sempre.
+//
+// Modulo PURO: i nomi chiesti dalle conversazioni vive arrivano già letti
+// (`liveRequestedNames` in `live-sessions.ts`).
+/**
+ * I caratteri del gemello, nell'ordine in cui si assegnano: il primo gemello
+ * prende `#`.
+ *
+ * GEMELLA di `TWIN_MARKS` in `loom-compass/compass@lamemind/model.js`, il
+ * secondo lanciatore di conversazioni: nessun codice confronta le due copie, e
+ * cambiarne una sola fa scegliere caratteri diversi ai due lanciatori senza
+ * errore. Si toccano insieme.
+ *
+ * Ogni carattere sta fuori da cinque classi, e ognuna rompe un consumer in
+ * silenzio:
+ *  - fuori dall'ASCII a una cella: un simbolo di larghezza ambigua (`§`, `†`)
+ *    occupa una o due celle a seconda della locale e sposta il taglio del
+ *    titolo nella tab;
+ *  - dentro l'alfabeto di `saneNote`: un carattere ammesso lì può arrivare da
+ *    una nota digitata, e il gemello non si distingue più dal testo;
+ *  - dentro `[A-Za-z0-9_-]`: il matcher di compass `titleKeyRe` riconosce una
+ *    finestra con `^<emoji> <name>(?![\w-])`;
+ *  - l'apice singolo: il titolo sta dentro `claude --name '…'` nella riga che
+ *    `bash -lc` analizza;
+ *  - i metacaratteri di shell (`; & $ \` | < >`): inerti fra apici, ma il test
+ *    di `saneNote` asserisce che nessun `[;&`$]` sopravviva in un titolo, e un
+ *    gemello della stessa classe renderebbe cieco quel test. Fuori anche la
+ *    punteggiatura che si legge come testo (`. , : /`) e le parentesi.
+ */
+export const TWIN_MARKS = ['#', '+', '=', '~', '^', '%', '@', '*', '?', '!'];
+/**
+ * Il titolo da usare: `base` se nessuna conversazione viva l'ha chiesto,
+ * altrimenti `base` + spazio + il primo carattere di `TWIN_MARKS` che nessuna
+ * conversazione viva porta già su quel nome.
+ *
+ * Lo spazio separa il carattere come ogni altro suffisso del titolo (` · T182`,
+ * ` <nota>`, ` · fork`): incollato all'ultima parola si leggerebbe come un
+ * refuso della nota. Il confronto è per uguaglianza intera, la stessa che fanno
+ * coda e `sessionsByName`.
+ *
+ * Insieme esaurito → `base`: il lancio parte comunque, e chi cerca la tab per
+ * titolo torna all'esito ambiguo che ha anche senza lanciatore.
+ */
+export function twinTitle(base, liveRequestedNames) {
+    const taken = new Set(liveRequestedNames);
+    if (!taken.has(base))
+        return base;
+    for (const mark of TWIN_MARKS) {
+        const candidate = `${base} ${mark}`;
+        if (!taken.has(candidate))
+            return candidate;
+    }
+    return base;
+}

package/package.json

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