@lamemind/loom-deck 0.75.0 → 0.77.0

package/README.md

@@ -387,11 +387,33 @@ npx @lamemind/loom-deck
 ## Requisiti runtime
 
 - **Node.js ≥ 18** (dichiarato in `engines`).
-- **[Ptyxis](https://gitlab.gnome.org/chergert/ptyxis)** (terminale GNOME) — **dipendenza di runtime, non risolvibile da npm**. Lo spawn di una tab (`scripts/deck-run`) invoca il binario `ptyxis`: l'**install riesce anche senza**, ma al momento dello spawn il comando
+- **[Ptyxis](https://gitlab.gnome.org/chergert/ptyxis)** (terminale GNOME), su Linux — **dipendenza di runtime, non risolvibile da npm**. Lo spawn di una tab (`scripts/deck-run`) invoca il binario `ptyxis`: l'**install riesce anche senza**, ma al momento dello spawn il comando
   fallisce (gestito: handler `error` → la TUI resta viva, mostra la nota). Senza una GUI
   GNOME con Ptyxis installato, il deck naviga i task ma **non apre sessioni**.
 - **[Claude Code](https://claude.com/claude-code)** nel `PATH` — la tab spawnata avvia `claude`.
 
+### Su Windows
+
+Le tab si aprono in **Windows Terminal** (`wt.exe`, l'alias d'esecuzione che l'installazione dello Store mette nel `PATH`), nella finestra usata per ultima: `wt.exe -w 0 new-tab -p loom-deck -d <root> --title <titolo> --suppressApplicationTitle -- <node> <dist/tab-wrapper.js>`. L'argv di `claude` — nome, flag, prompt — non sta su quella riga: viaggia come JSON nella variabile `LOOM_DECK_TAB_ARGV`, che la tab eredita dal processo che lancia `wt.exe`, e il wrapper lo passa a `claude` senza shell. Il prompt non passa quindi né dal parser di `wt`, che legge `;` come separatore di sottocomandi in qualunque argomento, né da cmd o PowerShell.
+
+Le tab usano il profilo di Windows Terminal **`loom-deck`**, uno solo per tutti i progetti. Il deck non lo crea e non scrive `settings.json`: lo si aggiunge a mano in `%LOCALAPPDATA%\Packages\Microsoft.WindowsTerminal_8wekyb3d8bbwe\LocalState\settings.json`, sotto `profiles.list`, nascosto dal menu. Porta solo ciò che i flag di `wt` non sanno dire — titolo, cartella e comando li passa il deck, e battono quelli del profilo:
+
+```jsonc
+{
+  "name": "loom-deck",
+  "guid": "{<un GUID nuovo>}",
+  "hidden": true,
+  "commandline": "%SystemRoot%\\System32\\WindowsPowerShell\\v1.0\\powershell.exe -NoLogo",
+  "closeOnExit": "graceful"
+}
+```
+
+`commandline` è la shell del tasto `t`; nelle conversazioni il comando del deck prende il suo posto. `closeOnExit` decide cosa resta della tab quando `claude` esce (il wrapper esce col suo codice). Senza il profilo la tab si apre comunque, col profilo di default. Il nome si cambia con `LOOM_DECK_WT_PROFILE` (vuota = nessun `-p`).
+
+La tab eredita tutto l'env del deck, tranne i marker che una sessione Claude Code inietta nei figli (`CLAUDECODE`, `CLAUDE_CODE_CHILD_SESSION`, …): con quelli una conversazione aperta da un deck lanciato dentro Claude Code non salverebbe il transcript. Se manca, il deck aggiunge `CLAUDE_CODE_GIT_BASH_PATH`: col `PATH` di Git Bash `claude` eseguirebbe gli hook del plugin in PowerShell, e la task non arriverebbe in contesto.
+
+Su Windows il resume di una conversazione e il restore (`^T`) restano spenti con un avviso finché il deck non sa quali conversazioni sono vive: senza quella informazione un resume può riaprire una conversazione già aperta in un'altra tab. Il fork resta acceso, perché apre un transcript nuovo.
+
 ## Uso (spike ①)
 
 ```bash
@@ -419,7 +441,7 @@ npm test         # node:test sul core vista (src/view.ts), senza Ink né termina
 
 Il core di filtri e ordinamenti (`src/view.ts`) è **puro**: nessun import da Ink o React, nessun I/O. È il motivo per cui è testabile con `node:test` su array fixture, mentre la TUI resta un guscio sottile che lo consuma.
 
-Il deck cerca `tasks.md` in `$PWD/${LOOM_DECK_DOCS_ROOT:-docs}/tasks.md`. Progetti con docs-root non-standard esportano la variabile, es. `LOOM_DECK_DOCS_ROOT=runtime`.
+Il deck cerca `tasks.md` in `$PWD/<docs-root>/tasks.md`. La docs-root si risolve in quest'ordine: la variabile `LOOM_DECK_DOCS_ROOT`, se impostata; il campo `docsRoot` di `$PWD/.claude/loom-works.json`; `docs`. Un progetto con docs-root non-standard la dichiara nel file, e il deck la trova anche avviato a mano.
 
 La lista si **auto-aggiorna** quando `tasks.md` cambia sotto (poll su `mtime`, ~1.5s):
 crei/checkpoint una task da un'altra sessione → il deck la riflette senza riavvio.

package/dist/actions.js

@@ -17,13 +17,15 @@
 // migliorano di passaggio.
 import { useRef } from 'react';
 import { randomUUID } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { conversationCwd } from './project-path.js';
 import { taskSlug } from './tasks.js';
 import { appendNote, appendPin, appendPriority, appendSessionRecord, appendTaskBinding, } from './task-index.js';
 import { neighborId } from './session-list.js';
 import { cut, cutMiddle } from './width.js';
 import { dropSessionFiles, sessionArtifacts } from './session-drop.js';
 import { saveView, viewFilePath } from './view-store.js';
-import { onInTabCommand, runLaunch, spawnClaudeEmpty, spawnBare, spawnDeck, spawnDeckFork, spawnDeckResume, spawnTerminal, DECK_RUN, } from './spawn.js';
+import { onInTabCommand, runLaunch, spawnClaudeEmpty, spawnBare, spawnDeck, spawnDeckFork, spawnDeckResume, spawnTerminal, terminalName, DECK_RUN, } from './spawn.js';
 import { MODEL_DEFAULT } from './spawn-catalog.js';
 import { modelAlias } from './glyphs.js';
 import { resolveSpawnId } from './spawn-config.js';
@@ -32,6 +34,7 @@ import { inboxPrompt, inboxWords } from './inbox.js';
 import { docTargetKind, docWords } from './doc-tree.js';
 import { wrapWords } from './wrap-scan.js';
 import { enterSession, focusSession } from './focus-session.js';
+import { refuse } from './platform.js';
 /**
  * T181 — l'attesa massima di un passo del restore prima di passare al
  * successivo. Un `deck-run` esce appena `ptyxis --tab` ha consegnato la tab
@@ -102,7 +105,7 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
     }
     /** I buchi di un'azione su task. Lo slug viene dal NOME del task file, non
      *  dalla descrizione di `tasks.md`: il nome è già dentro l'alfabeto di
-     *  `_sane_note` per costruzione — minuscolo, separato da trattini, senza
+     *  `saneNote` per costruzione — minuscolo, separato da trattini, senza
      *  punteggiatura — mentre la descrizione porta apostrofi e `/` che la riduzione
      *  toglie senza sostituto, saldando le parole. Task file assente → slug vuoto,
      *  e il titolo si spegne invece di ridursi al solo prefisso. */
@@ -156,6 +159,10 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
     // della lista (^K/^P/^R), che passano di qui con `spawnNote` sul proprio
     // default '' (P1 preflight) — nascono quindi titolati anche loro.
     function spawnForTask(id, modelKind, spawnNote = '', prompt = '', priority = false) {
+        // T175 — prima del sidecar: un binding scritto per una tab che non si apre
+        // sarebbe una conversazione figlia della task che non esiste.
+        if (refuse('spawn', '⏎', setNote))
+            return;
         const sid = randomUUID();
         const note = spawnNote;
         appendTaskBinding(cwd, sid, id);
@@ -185,6 +192,8 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
     // async: senza handler diventa uncaughtException e ucciderebbe il deck, che
     // invece deve restare vivo.
     function spawnTaskSession(kind, keyLabel) {
+        if (refuse('spawn', keyLabel, setNote))
+            return;
         const task = selectedTaskOr(keyLabel, 'spawnare');
         if (!task)
             return;
@@ -213,9 +222,22 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
     // ricerca e il restore il modello ereditato dalla sessione senza superficie
     // di scelta (D1 preflight). I chiamanti restano la stessa azione perché è
     // lo spawn a essere identico, non la sorgente del valore.
+    /**
+     * T176 — la cartella della tab di una ripresa o di un fork: la root su Linux,
+     * la cwd registrata dalla conversazione su Windows (`conversationCwd`, P7
+     * preflight). Una cartella che non esiste più ricade sulla root: lo spawn
+     * fallirebbe prima ancora di aprire la tab.
+     */
+    function tabCwdOf(sessionId) {
+        const s = model.sessions.find((x) => x.sessionId === sessionId);
+        if (!s)
+            return cwd;
+        const dir = conversationCwd(s.cwd, s.path, cwd);
+        return dir === cwd || existsSync(dir) ? dir : cwd;
+    }
     function resumeSession(sessionId, modelKind) {
         const bound = model.bindings.get(sessionId) ?? null;
-        const spawned = spawnDeckResume(bound, cwd, sessionId, modelKind, model.sessionNotes.get(sessionId));
+        const spawned = spawnDeckResume(bound, tabCwdOf(sessionId), sessionId, modelKind, model.sessionNotes.get(sessionId));
         spawned.child.on('error', () => setNote(`⚠ resume fallito (${DECK_RUN})`));
         noteSpawn(spawned);
         return spawned;
@@ -233,6 +255,14 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
      * tab); senza nome, il prefisso del `sessionId` come nelle altre note.
      */
     function openSession(sessionId, modelKind) {
+        if (refuse('spawn', '⏎', setNote, 'resume'))
+            return;
+        // T176 — il resume vuole sapere se la conversazione è viva, non solo poter
+        // aprire una tab (D4 preflight): senza liveness un `⏎` su una conversazione
+        // aperta in un'altra tab avvierebbe un secondo `claude` sullo stesso
+        // transcript. Spento finché la piattaforma non ha le sessioni vive.
+        if (refuse('liveSessions', '⏎', setNote, 'resume'))
+            return;
         enterSession(sessionId, {
             isLive: (id) => model.live.has(id),
             nameOf: (id) => model.live.get(id)?.name || id.slice(0, 8),
@@ -266,6 +296,14 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
      * chiudendo le tab.
      */
     function restoreSessions() {
+        // T176 — la guardia delle sessioni vive PRIMA di quella dello spawn (P8
+        // preflight): l'insieme da riaprire è l'ultimo insieme vivo, e senza
+        // liveness sarebbe vuoto — «nessuna conversazione da riaprire» direbbe uno
+        // stato dove manca una funzione.
+        if (refuse('liveSessions', '^T', setNote, 'restore delle conversazioni'))
+            return;
+        if (refuse('spawn', '^T', setNote, 'restore delle conversazioni'))
+            return;
         const list = model.restorable;
         if (list.length === 0) {
             setNote(model.restoring ? '^T → restore già in corso' : '^T → nessuna conversazione da riaprire');
@@ -368,6 +406,8 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
     // ha per oggetto una conversazione, e senza focus lì non ce n'è una
     // selezionata su cui agire.
     function forkSession() {
+        if (refuse('spawn', 'f', setNote, 'fork'))
+            return;
         if (model.focus !== 'sessions') {
             setNote('f → fork: seleziona una sessione (→ per il pane)');
             return;
@@ -393,7 +433,7 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
         // 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);
+        const spawned = spawnDeckFork(bound, tabCwdOf(s.sessionId), s.sessionId, newId, model.resumeModel);
         spawned.child.on('error', () => setNote(`⚠ fork fallito (${DECK_RUN})`));
         noteSpawn(spawned);
     }
@@ -463,6 +503,12 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
             setNote('CANC → eliminare: seleziona una conversazione (→ per il pane)');
             return null;
         }
+        // T175 — il rifiuto della VIVA qui sotto legge `model.live`, e dove la
+        // liveness manca la mappa è sempre vuota: il rifiuto non scatterebbe mai, e
+        // `CANC` toglierebbe il transcript a una conversazione aperta. Spento finché
+        // la liveness non c'è, non degradato a «nessuna è viva».
+        if (refuse('liveSessions', 'CANC', setNote, 'eliminazione delle conversazioni'))
+            return null;
         const sid = model.selSessionId;
         if (!sid) {
             setNote('CANC → nessuna conversazione da eliminare');
@@ -488,6 +534,10 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
      * appena eliminata apposta.
      */
     function dropSession(draft) {
+        // La stessa guardia della bozza: chi arrivasse qui senza passare da lei non
+        // deve trovare un `rmSync` sguarnito.
+        if (refuse('liveSessions', 'CANC', setNote, 'eliminazione delle conversazioni'))
+            return;
         const short = draft.sessionId.slice(0, 8);
         const landing = neighborId(model.sessionRows, draft.sessionId);
         try {
@@ -506,9 +556,11 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
     }
     /** `t` — terminale a project root, con un titolo che il matcher di compass riconosce. */
     function openTerminal() {
+        if (refuse('spawn', 't', setNote, 'terminale'))
+            return;
         const title = model.identity ? `🖥️ ${model.identity.name} [term]` : null;
         const child = spawnTerminal(cwd, title);
-        child.on('error', () => setNote('⚠ t → ptyxis non lanciabile'));
+        child.on('error', () => setNote(`⚠ t → ${terminalName()} non lanciabile`));
         setNote(`t → terminale su ${model.projectName}`);
     }
     /**
@@ -532,6 +584,8 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
      * due superfici mostrano nasce da un valore solo.
      */
     function drainInbox(file, prompt) {
+        if (refuse('spawn', '⏎', setNote))
+            return;
         const sid = randomUUID();
         const d = spawnDefaults('drain', { file: inboxWords(file) });
         const title = d.title ?? '';
@@ -608,6 +662,8 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
     function rebalanceDoc(row, prompt) {
         if (!prompt)
             return;
+        if (refuse('spawn', '⏎', setNote))
+            return;
         // Il bersaglio inbox prende la terna della riga `drain`, non quella di
         // `rebalance`: il prompt da solo non basterebbe — modello e titolo della tab
         // verrebbero comunque dalla riga sbagliata, e la conversazione si
@@ -642,6 +698,8 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
      * non progettare niente.
      */
     function unwrapPath(path) {
+        if (refuse('spawn', '⏎', setNote))
+            return;
         const sid = randomUUID();
         const d = spawnDefaults('unwrap', { path: wrapWords(path) });
         const title = d.title ?? '';
@@ -655,6 +713,8 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
      *  modello è quello del selettore proprio della nuda (`model.bareModel`),
      *  passato SEMPRE nell'argv anche sul default. */
     function openClaude() {
+        if (refuse('spawn', 'c', setNote, 'sessione claude'))
+            return;
         const spawned = spawnClaudeEmpty(cwd, model.bareModel);
         spawned.child.on('error', () => setNote(`⚠ c → spawn claude fallito (${DECK_RUN})`));
         noteSpawn(spawned);
@@ -672,6 +732,8 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
     }
     /** `1`-`9` — le voci launch del progetto, per indice base-1. */
     function runLaunchAt(input) {
+        if (refuse('launch', input, setNote))
+            return;
         const entry = model.launch[Number(input) - 1];
         if (!entry) {
             setNote(`${input} → nessuna voce launch (${model.launch.length} configurate)`);

package/dist/archivable.js

@@ -102,7 +102,7 @@ async function resolveDoneDate(id, content, taskFile, projectRoot) {
  *  un throw: un contatore informativo non può rompere il deck. */
 async function gitOut(args, cwd) {
     try {
-        const { stdout } = await execFileAsync('git', args, { cwd });
+        const { stdout } = await execFileAsync('git', args, { cwd, windowsHide: true });
         return stdout.trim() || null;
     }
     catch {

package/dist/claude-cmd.js

@@ -0,0 +1,101 @@
+// T175 — COME il deck lancia `claude`, senza shell, su ogni installazione.
+//
+// Su Linux `claude` è un eseguibile nel `PATH` e basta il nome. Su Windows le
+// installazioni sono due e si comportano in modo opposto davanti a `spawn`:
+//
+//  - l'installer nativo dà `claude.exe`, e `spawn('claude')` lo trova — libuv
+//    prova da sé `.com` ed `.exe`;
+//  - l'installazione npm dà uno shim `claude.cmd`, e `spawn` non lo trova
+//    (`ENOENT` col nome nudo) né lo lancia (`EINVAL` col nome intero: Node ≥
+//    18.20.2 rifiuta un `.cmd` senza shell).
+//
+// La shell non è un rimedio: con `shell: true` il prompt passerebbe da cmd.exe,
+// che interpreta `& | % ^`, e un prompt è testo arbitrario. Lo shim invece è un
+// file generato da cmd-shim con una forma fissa, e dice in chiaro cosa lancia:
+// il deck lo legge e lancia il bersaglio da sé (P5 preflight).
+//
+// Modulo PURO nel cuore (`resolveClaude` riceve il filesystem come funzioni),
+// con un involucro che legge quello vero.
+import { existsSync, readFileSync } from 'node:fs';
+import { win32 } from 'node:path';
+/**
+ * Il bersaglio di uno shim di cmd-shim, o `null` se il testo non ne ha uno che
+ * il deck sappia lanciare.
+ *
+ * Il bersaglio è l'ultimo `"%dp0%\<path>"` seguito da `%*` (le due forme dello
+ * shim: `%dp0%` dalla v4 di cmd-shim, `%~dp0` prima). Un `.js` parte col node
+ * del deck — è il node che lo shim userebbe in assenza di un `node.exe`
+ * accanto, cioè quello del `PATH` —, un `.exe` parte da sé. Ogni altro bersaglio
+ * (uno script sh, per esempio) vorrebbe il suo interprete, e il deck non lo
+ * indovina.
+ */
+export function parseCmdShim(text, shimPath, nodePath) {
+    const re = /"%~?dp0%?\\?([^"]+)"\s+%\*/g;
+    let rel = null;
+    for (let m = re.exec(text); m; m = re.exec(text))
+        rel = m[1];
+    if (!rel)
+        return null;
+    const target = win32.join(win32.dirname(shimPath), rel);
+    if (/\.(c|m)?js$/i.test(target))
+        return { cmd: nodePath, prefix: [target] };
+    if (/\.(exe|com)$/i.test(target))
+        return { cmd: target, prefix: [] };
+    return null;
+}
+/**
+ * La cascata (P5 preflight): `LOOM_DECK_CLAUDE_CMD` → `claude` così com'è →
+ * shim `claude.cmd` nel `PATH`.
+ *
+ * Su win32 «così com'è» vuol dire che un `claude.exe` o `claude.com` sta nel
+ * `PATH`: è lo stesso giro che farebbe libuv, fatto prima per sapere se serve
+ * il gradino dopo. Un override che nomina un `.cmd` passa dallo stesso parser,
+ * o cadrebbe nell'`EINVAL`. Niente trovato → `claude` nudo: lo spawn fallirà,
+ * e l'errore dirà «`claude` non lanciabile», che è il fatto.
+ */
+export function resolveClaude(env, platform, nodePath, fs) {
+    const fromShim = (shim) => {
+        try {
+            return parseCmdShim(fs.read(shim), shim, nodePath);
+        }
+        catch {
+            return null;
+        }
+    };
+    const override = env.LOOM_DECK_CLAUDE_CMD;
+    if (override) {
+        if (platform === 'win32' && /\.(cmd|bat)$/i.test(override)) {
+            return fromShim(override) ?? { cmd: override, prefix: [] };
+        }
+        return { cmd: override, prefix: [] };
+    }
+    const bare = { cmd: 'claude', prefix: [] };
+    if (platform !== 'win32')
+        return bare;
+    const dirs = (env.PATH ?? env.Path ?? '').split(win32.delimiter).filter(Boolean);
+    for (const dir of dirs) {
+        if (fs.exists(win32.join(dir, 'claude.com')) || fs.exists(win32.join(dir, 'claude.exe')))
+            return bare;
+    }
+    for (const dir of dirs) {
+        const shim = win32.join(dir, 'claude.cmd');
+        if (!fs.exists(shim))
+            continue;
+        const launcher = fromShim(shim);
+        if (launcher)
+            return launcher;
+    }
+    return bare;
+}
+let cached;
+/** Il `claude` di questa macchina, risolto alla prima richiesta e tenuto per la
+ *  vita del deck. */
+export function claudeLauncher() {
+    if (!cached) {
+        cached = resolveClaude(process.env, process.platform, process.execPath, {
+            exists: existsSync,
+            read: (p) => readFileSync(p, 'utf8'),
+        });
+    }
+    return cached;
+}

package/dist/cli.js

@@ -16,7 +16,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { render, Box, Text } from 'ink';
 import { useMemo, useState } from 'react';
 import { resolveTasksPath, resolveTasksDir } from './tasks.js';
-import { LAUNCH_SEP } from './config.js';
+import { LAUNCH_SEP, docsRootName } from './config.js';
 import { anchorFrame, enableMouse } from './mouse.js';
 import { sanitize } from './width.js';
 import { MODEL_SHORT_LIST, modelAlias } from './glyphs.js';
@@ -48,7 +48,7 @@ import { DocPane } from './ui/doc-pane.js';
 import { PreviewPane, detailMetaOf } from './ui/preview.js';
 import { CompactNotice, HintBar, TextBox, screenFor } from './ui/screens.js';
 import { VERSION } from './version.js';
-function Deck({ cwd, tasksPath, tasksDir }) {
+function Deck({ cwd, docsRoot, tasksPath, tasksDir, }) {
     // La riga di STATO in fondo al frame: il feedback dell'ultima azione. Non è
     // la nota di una conversazione, che nel modello si chiama `sessionNotes`.
     const [note, setNote] = useState('');
@@ -68,6 +68,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     const bareDefault = resolveSpawnId('bare', spawnConfig.overrides, catalog).model;
     const model = useDeckModel({
         cwd,
+        docsRoot,
         tasksPath,
         tasksDir,
         bareModel: bareDefault,
@@ -267,6 +268,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                 scanned: gitlink.scanned,
                 ok: gitlink.ok,
                 failed: gitlink.failed,
+                available: gitlink.available,
             }
             : null,
         inbox: {
@@ -274,8 +276,15 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             stale: model.inboxStale,
             scanned: model.inboxScanned,
             ok: model.inboxOk,
+            available: model.pluginScripts,
+        },
+        wrap: {
+            count: wrap.count,
+            mtime: wrap.mtime,
+            ok: wrap.ok,
+            scanning: wrap.scanning,
+            available: wrap.available,
         },
-        wrap: { count: wrap.count, mtime: wrap.mtime, ok: wrap.ok, scanning: wrap.scanning },
     }, columns);
     const frame = frameGeometry({
         rows,
@@ -357,9 +366,13 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                     hasDoc: model.selDoc !== null,
                     gitlink: gitlink.enabled,
                     restore: frame.headerButton !== 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, launch.filler, BARE_LABEL.text, ' ', bareButtons.nodes] })) : 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, mode === 'drop' && drop.draft ? _jsx(DropModal, { draft: drop.draft, columns: columns }) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [model.deckMode === 'doc' ? (_jsx(DocPane, { rows: frame.windowDoc, counts: model.docCounts, activeView: model.docViewId, paneCount: model.docRows.length, selectedPath: model.selDocPath, focused: model.focus === 'doctree', above: frame.docWin.start, below: model.docRows.length - frame.docWin.end, columns: columns, ok: model.docOk, scanned: model.docScanned, scanning: model.docScanning, hasDirs: model.docHasDirs })) : (_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, blockMark: model.blockMark })), model.deckMode === 'doc' ? (_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, sessionPriority: model.sessionPriority, 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 === 'doc' && model.selDoc ? (_jsx(PreviewPane, { kind: "doc", row: model.selDoc, 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] }));
+                }), 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, launch.filler, BARE_LABEL.text, ' ', bareButtons.nodes] })) : 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, mode === 'drop' && drop.draft ? _jsx(DropModal, { draft: drop.draft, columns: columns }) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [model.deckMode === 'doc' ? (_jsx(DocPane, { rows: frame.windowDoc, counts: model.docCounts, activeView: model.docViewId, paneCount: model.docRows.length, selectedPath: model.selDocPath, focused: model.focus === 'doctree', above: frame.docWin.start, below: model.docRows.length - frame.docWin.end, columns: columns, ok: model.docOk, scanned: model.docScanned, scanning: model.docScanning, hasDirs: model.docHasDirs, available: model.pluginScripts })) : (_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, blockMark: model.blockMark })), model.deckMode === 'doc' ? (_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, available: model.pluginScripts })) : (_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, sessionPriority: model.sessionPriority, 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 === 'doc' && model.selDoc ? (_jsx(PreviewPane, { kind: "doc", row: model.selDoc, 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();
+// T175 — la docs-root si risolve QUI, una volta, e scende a tutti: i path di
+// `tasks.md` e dei task file e i due scan del modo doc devono vedere la stessa
+// cartella, e due risoluzioni potrebbero non vederla.
+const docsRoot = docsRootName(cwd);
 // T116 — `exitOnCtrlC: false` toglie a Ink l'uscita immediata su `^C`: senza,
 // il tasto non arriverebbe mai a `useInput` e il doppio colpo non sarebbe
 // osservabile. In raw mode `^C` non è un SIGINT — è il byte `\x03` nello
@@ -372,6 +385,4 @@ const cwd = process.cwd();
 // esista qualcosa da cui uscire.
 anchorFrame();
 enableMouse();
-render(_jsx(Deck, { cwd: cwd, tasksPath: resolveTasksPath(cwd), tasksDir: resolveTasksDir(cwd) }), {
-    exitOnCtrlC: false,
-});
+render(_jsx(Deck, { cwd: cwd, docsRoot: docsRoot, tasksPath: resolveTasksPath(cwd, docsRoot), tasksDir: resolveTasksDir(cwd, docsRoot) }), { exitOnCtrlC: false });

package/dist/commit-times.js

@@ -37,7 +37,10 @@ export function commitLogSpawnCount() {
 }
 async function headSha(projectRoot) {
     try {
-        const { stdout } = await execFileAsync('git', ['rev-parse', 'HEAD'], { cwd: projectRoot });
+        const { stdout } = await execFileAsync('git', ['rev-parse', 'HEAD'], {
+            cwd: projectRoot,
+            windowsHide: true,
+        });
         return stdout.trim();
     }
     catch {
@@ -98,7 +101,7 @@ export async function commitTimes(tasksDir, projectRoot) {
         // Il contatore sale PRIMA dell'await: conta gli spawn partiti, e uno
         // spawn fallito costa comunque la fork del processo.
         logSpawns++;
-        const { stdout } = await execFileAsync('git', ['log', '--format=#%ct', '--name-only', '--', tasksDir], { cwd: projectRoot });
+        const { stdout } = await execFileAsync('git', ['log', '--format=#%ct', '--name-only', '--', tasksDir], { cwd: projectRoot, windowsHide: true });
         map = parseCommitLog(stdout);
     }
     catch {

package/dist/config.js

@@ -112,12 +112,10 @@ export function launchLegend(entries, columns, reserved = 0) {
 // T61 — soglia d'età del contatore archiviabili, campo `archivableDays`.
 //
 // È il PRIMO scalare che il lato TypeScript legge dal file config: `launch` e
-// `identity` sopra sono strutture, e `docsRoot` arriva ancora dalla sola env
-// `LOOM_DECK_DOCS_ROOT` (vedi `tasks.ts`). La catena da percorrere si ferma
-// qui: nessun passaggio da `lib-config.sh`/`reg_pull`/dconf, perché il solo
-// consumer è il deck e il file ce l'ha sotto mano. Il precedente esatto è
-// `permissionMode`, che vive nel file, lo legge `deck-run` via jq e non è
-// propagato al registry.
+// `identity` sopra sono strutture. La catena da percorrere si ferma qui: nessun
+// passaggio da `lib-config.sh`/`reg_pull`/dconf, perché il solo consumer è il
+// deck e il file ce l'ha sotto mano. Il precedente esatto è `permissionMode`,
+// che vive nel file, lo legge anche `deck-run` e non è propagato al registry.
 /** Interi positivi soltanto: uno 0 spegnerebbe la soglia (tutte le Done
  *  archiviabili), un negativo o un decimale sono un typo. Valore fuori dominio
  *  → default, mai passaggio cieco di un numero senza senso al conteggio. */
@@ -149,6 +147,53 @@ export function loadArchivableDays(projectRoot) {
     }
     return DEFAULT_ARCHIVABLE_DAYS;
 }
+/** La docs-root di un progetto che non la dichiara: la stessa di `lw_docs_root`
+ *  nel plugin. */
+export const DEFAULT_DOCS_ROOT = 'docs';
+/** Stringa non vuota, presa così com'è: è il valore che il plugin legge con
+ *  `jq -r '.docsRoot'`, e due letture che normalizzassero in modo diverso
+ *  manderebbero deck e skill in due cartelle. */
+export function parseDocsRoot(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const v = raw.docsRoot;
+    return typeof v === 'string' && v.trim() ? v : null;
+}
+/**
+ * Nome della cartella doc del progetto (`docs`, `runtime`, …): `tasks.md`,
+ * `tasks/`, `inbox/` stanno lì sotto.
+ *
+ * T175 — precedenza `env → file → default`. Fino a T175 il deck leggeva la sola
+ * env `LOOM_DECK_DOCS_ROOT`, contando su chi lo avvia: compass la antepone al
+ * comando, il profilo Ptyxis la porta cablata. Un deck avviato a mano da una
+ * shell — su Linux, e su Windows sempre, perché lì nessuno dei due canali
+ * esiste — cercava `docs/` e mostrava una lista vuota invece di un errore. Il
+ * campo `docsRoot` del file è la fonte unica della famiglia (lo legge anche il
+ * plugin): il deck lo legge da sé.
+ *
+ * L'env resta IN TESTA, e non solo per i test: è il canale con cui compass
+ * passa il valore del registry, e una env impostata è una scelta esplicita di
+ * chi avvia, che batte il file come `LOOM_DECK_ARCHIVABLE_DAYS` batte
+ * `archivableDays`.
+ *
+ * Si risolve UNA volta per vita del deck, in `cli.tsx`, e il valore scende a
+ * chi lo usa: i path di `tasks.md` e dei task file e i due scan del modo doc
+ * devono vedere la stessa cartella.
+ */
+export function docsRootName(projectRoot) {
+    const env = process.env.LOOM_DECK_DOCS_ROOT;
+    if (env)
+        return env;
+    try {
+        const fromFile = parseDocsRoot(JSON.parse(readFileSync(configFilePath(projectRoot), 'utf8')));
+        if (fromFile !== null)
+            return fromFile;
+    }
+    catch {
+        // file assente o malformato → default, come loadLaunch/loadIdentity
+    }
+    return DEFAULT_DOCS_ROOT;
+}
 export function parseIdentity(raw) {
     if (!raw || typeof raw !== 'object')
         return null;

package/dist/deck-model.js

@@ -19,7 +19,6 @@ import { DEFAULT_INBOX_STALE_HOURS, staleCount } from './inbox.js';
 import { aliveIds, restoreSet } from './live-marks.js';
 import { cycleDocView, docCounts as deriveDocCounts, docView, selectDocRows, } from './doc-views.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, modelAlias, relTime } from './glyphs.js';
 import { assembleSessionList, firstSelectableId, rowIndexOf, selectedSession, } from './session-list.js';
@@ -29,6 +28,8 @@ import { applyView, epicRollup, taskColumns } from './view.js';
 import { loadView } from './view-store.js';
 import { termWidth } from './width.js';
 import { MODELS, MODEL_DEFAULT } from './spawn-catalog.js';
+import { isAvailable } from './platform.js';
+import { projectBaseName } from './project-path.js';
 /**
  * Conteggio dei figli per task, più il rollup delle VIVE e le conversazioni
  * senza binding.
@@ -107,7 +108,7 @@ export function childSessionsOf(sessions, bindings, selectedTaskId, isAll) {
         return selectedTaskId ? bound === selectedTaskId : !bound;
     });
 }
-export function useDeckModel({ cwd, tasksPath, tasksDir, bareModel: bareModelDefault, setNote, }) {
+export function useDeckModel({ cwd, docsRoot, tasksPath, tasksDir, bareModel: bareModelDefault, setNote, }) {
     const { tasks, loadError } = useTasks(tasksPath);
     // Voci launch del progetto (T32): lette una volta, raggiunte per indice 1..9.
     const launch = useMemo(() => loadLaunch(cwd), [cwd]);
@@ -125,7 +126,9 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, bareModel: bareModelDef
     // scrive nel sidecar il residuo del titolo, e quel residuo si ottiene
     // togliendo questo stesso core (§Riempimento dei buchi in `hooks.ts`).
     const projectCore = identity ? identity.name : null;
-    const projectName = cwd.split('/').pop() || cwd;
+    // T175 — `projectBaseName` e non uno split su `/`: su Windows restituiva il
+    // path intero.
+    const projectName = projectBaseName(cwd);
     // `notes` esce dall'indice come `sessionNotes`: nel deck `note` è già la riga
     // di STATO in fondo al frame (il feedback di un'azione). Due concetti diversi
     // a una lettera di distanza sarebbero una trappola di lettura — e di
@@ -214,11 +217,12 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, bareModel: bareModelDef
     const archivableSig = useMemo(() => [...archivable].sort().join(','), [archivable]);
     const dirtyFolders = useDirtyFolders(archivableSig, tasksDir, cwd);
     // T134 — terzo scan della famiglia (D1): coda inbox per natura, età del più
-    // vecchio. La docs-root arriva dalla sola env, come `resolveTasksPath` — il
-    // limite si eredita invece di aprire qui una cascata che nessun percorso di
-    // avvio reale userebbe (D1 preflight).
-    const docsRoot = useMemo(() => docsRootName(), []);
-    const inbox = useInboxScan(cwd, docsRoot);
+    // vecchio. T175 — la docs-root è quella di `tasksPath`, risolta una volta in
+    // `cli.tsx`: lista task e coda inbox guardano la stessa cartella.
+    // T175 — coda inbox e albero doc li misura lo stesso script del plugin: dove
+    // non gira, nessuno dei due scan parte e i due pane dicono perché.
+    const pluginScripts = isAvailable('pluginScripts');
+    const inbox = useInboxScan(cwd, docsRoot, pluginScripts);
     const inboxCounts = useMemo(() => deriveInboxCounts(inbox.files), [inbox.files]);
     // Il numero accanto alla sirena: solo i file in coda oltre soglia. `Date.now()`
     // letto a ogni render e non memoizzato — è una sottrazione, e congelarlo
@@ -232,7 +236,7 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, bareModel: bareModelDef
     // vero, quindi il montaggio rimisura da sé — `toggleDeckMode` sotto non deve
     // chiamare `doc.scan()` come fa il gemello inbox, e chiamarlo darebbe due
     // spawn da quattro secondi per un gesto solo.
-    const doc = useDocScan(cwd, docsRoot, deckMode === 'doc');
+    const doc = useDocScan(cwd, docsRoot, deckMode === 'doc' && pluginScripts);
     // La misura GREZZA, memoizzata a parte: la consumano tre derivazioni (i
     // contatori, le righe della vista, l'elenco dei file di una cartella nello
     // sheet) e ricomporre l'oggetto a ogni render darebbe una identità nuova a
@@ -599,6 +603,7 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, bareModel: bareModelDef
         deckMode,
         // derivazioni del pane inbox
         docsRoot,
+        pluginScripts,
         inboxScanned: inbox.scanned,
         inboxOk: inbox.ok,
         inboxViewId,

package/dist/deck-run.js

@@ -0,0 +1,7 @@
+// T176 — il punto d'ingresso di `deck-run`: `scripts/deck-run` (lo shim bash
+// che compass e i test lanciano) e il deck su Windows eseguono questo file col
+// proprio node. La logica sta in `tab-launch.ts`, che si testa senza aprire tab.
+import { realIo, runDeckRun } from './tab-launch.js';
+runDeckRun(process.argv.slice(2), realIo()).then((code) => {
+    process.exitCode = code;
+});

package/dist/doc-tree.js

@@ -376,7 +376,7 @@ export function docTargetKind(row, docsRoot) {
  * T160 — il buco `{words}` del titolo di una sessione di rebalance: il path reso
  * a parole.
  *
- * Gemello di `wrapWords`, e per la stessa ragione: l'alfabeto di `_sane_note`
+ * Gemello di `wrapWords`, e per la stessa ragione: l'alfabeto di `saneNote`
  * non ha né `/` né `.`, quindi un path lasciato cadere lì dentro esce con le
  * parole saldate (`runtimereferencedoc-systemmd`) mentre la lista del deck, che
  * legge la nota grezza dal sidecar, mostrerebbe il path intero — la stessa
@@ -468,7 +468,7 @@ export async function scanDocTree(projectRoot, docsRoot) {
     if (!script)
         return { files: [], dirs: [], hasDirs: false, ok: false };
     try {
-        const { stdout } = await execFileAsync(script, ['--docs-root', docsRoot, '--format', 'tsv'], { cwd: projectRoot, maxBuffer: 8 * 1024 * 1024 });
+        const { stdout } = await execFileAsync(script, ['--docs-root', docsRoot, '--format', 'tsv'], { cwd: projectRoot, maxBuffer: 8 * 1024 * 1024, windowsHide: true });
         return { ...parseDocTsv(stdout), ok: true };
     }
     catch {