@vincemakes/kiso-code 0.45.2 → 0.46.0

package/dist/dispatch.js

@@ -3,10 +3,10 @@
  * turns. The bodies moved verbatim from chat()'s closure; chat provides
  * the context (the chain, the run state, the prompt arming).
  */
-import { STATUS_GLYPHS, contextRows, contextUnavailableRows, displayVerb, escapeTerminal, helpRows, kUnit, modePickView, modelPickView, compactingStatus, palette, renderEvent, settledLabel, slashCommandNames } from "@vincemakes/kiso-tui";
+import { STATUS_GLYPHS, contextRows, contextUnavailableRows, displayVerb, escapeTerminal, helpRows, kUnit, modePickView, modelPickView, namedPickView, compactingStatus, palette, renderEvent, settledLabel, slashCommandNames } from "@vincemakes/kiso-tui";
 import { newSessionId } from "./session-id.js";
 import { buildAdapter, lookupModelMetadata, resolveContinuationScope, resolveReasoning } from "@vincemakes/kiso-runtime/internal";
-import { MODES, MODE_NOTE, OFFERED_MODES, getMode, setMode } from "./mode.js";
+import { MODE_LABEL, MODE_NOTE, OFFERED_MODES, applyModeSetting, getDontAsk, getMode, modeDisplay, parseMode, setDontAsk } from "./mode.js";
 import { clipboardWrite, lastAnswer } from "./clipboard.js";
 import { protectedBangReason, protectedShellVerdict } from "./protected-shell.js";
 import { agentBaseUrl, currentProfileName, setCurrentProfileName, currentModelName, agentModel, body, bodyLog, codingToolOptions, protectedFiles, kisoHome, configModels, dock, lastBinding, loadedSkillsCatalog, mergedConfig, readContextLedger, retryOnRow, sessionsDir, setAgentModel, setConfiguredWindow, setCurrentModelName, setModelChoice, setRetryShown, upstreamOf, VERSION, setLastBinding } from "./state.js";
@@ -17,7 +17,8 @@ import { preferences, setPreference } from "./preferences.js";
 import { settingsRows } from "./settings.js";
 import { floorOn, settingsLayers } from "./state.js";
 import { currentGround } from "@vincemakes/kiso-tui-cells/render";
-import { queuedSwitchLines } from "./state.js";
+import { queuedSwitchLines, seenUnknownTasks, tasksFor } from "./state.js";
+import { taskOutput, taskRow, taskStateLabel } from "./task-notice.js";
 import { contextWindowTokens, microcompactThresholdFor, startStatusSpinner, statedContextWindow, windowSourceNote } from "./chat.js";
 import { authForProfile, directWriteProfile, profileAvailable, resolveContextWindow, unavailableReason } from "./config.js";
 import { shellTool } from "@vincemakes/kiso-tools-node";
@@ -396,6 +397,16 @@ export function dispatch(line, ctx) {
         });
         return;
     }
+    if (trimmed === "\x02background") {
+        // ADR-0058 (3e) — ctrl+b: the running foreground command(s) to the
+        // background, through the session's TaskManager (§6), at once — a
+        // steer waits for a command to be 2 s old (D1), the key never does.
+        // Off the chain on purpose: it is pressed DURING a run.
+        const moved = tasksFor(ctx.session.id)?.detachAll("person") ?? [];
+        if (moved.length === 0)
+            body.notice("nothing to move to the background");
+        return;
+    }
     if (trimmed === "\x14think") {
         // §2.3 / 0.40.6 — ctrl+t hides thinking (one italic line per block,
         // the open one included) and shows it again. DC-50's mechanism: one
@@ -510,7 +521,9 @@ export function dispatch(line, ctx) {
                 env: process.env,
                 ...(settingsLayers.modeFlag !== undefined ? { modeFlag: settingsLayers.modeFlag } : {}),
                 ...(settingsLayers.modelFlag !== undefined ? { modelFlag: settingsLayers.modelFlag } : {}),
+                dontAskFlag: settingsLayers.dontAskFlag,
                 mode: getMode(),
+                dontAsk: getDontAsk(),
                 model: { label: `${agentModel}${providerLabel(agentBaseUrl, upstreamOf(agentBaseUrl))}${profile === null ? "" : ` · profile ${profile}`}`, profile, switched: settingsLayers.modelSwitched },
                 ground: currentGround(),
                 floorOn,
@@ -563,59 +576,89 @@ export function dispatch(line, ctx) {
         // /mode <name> switches — the notice cell leaves the audit
         // line in the body, the status bar repaints at once.
         ctx.chainRef.current = ctx.chainRef.current.then(async () => {
-            const m = MODES.find((x) => x === trimmed.slice(5).trim());
-            if (trimmed.slice(5).trim() === "") {
+            const arg = trimmed.slice(5).trim();
+            // a tier switch, old names included — and when the switch came
+            // with the old dontAsk tier and leaves with it, a line says so
+            const switchTier = (s) => {
+                const wasOn = getDontAsk();
+                applyModeSetting(s);
+                body.notice(`mode → ${MODE_LABEL[getMode()]}`);
+                if (getDontAsk() !== wasOn)
+                    body.notice(`don't ask → ${getDontAsk() ? "on" : "off"}`);
+                ctx.paintIdle();
+            };
+            if (arg === "") {
                 // DC-36 — BARE /mode PICKS, the way bare /model has since
-                // TUI2-R2 ④. The five tiers are a CLOSED set, which makes
-                // this the least defensible place in the product to have
-                // asked a human to type the answer: everything needed to
-                // make it a choice was on screen and only the choosing was
-                // missing.
+                // TUI2-R2 ④. The tiers are a CLOSED set, which makes this the
+                // least defensible place in the product to have asked a human
+                // to type the answer: everything needed to make it a choice
+                // was on screen and only the choosing was missing.
                 //
-                // The printed form survives VERBATIM wherever there is no
-                // panel to draw — a pipe, a dock-less TTY — because that is
-                // a machine-readable surface and this round moves no bytes
-                // on one. `/mode <name>` is untouched.
+                // The printed form survives wherever there is no panel to
+                // draw — a pipe, a dock-less TTY — because that is a
+                // machine-readable surface. `/mode <name>` is untouched.
                 if (dock.active && ctx.input.panelAsk !== undefined) {
                     const current = getMode();
                     const picked = await new Promise((resolve) => {
                         ctx.input.panelAsk(modePickView({
-                            header: `mode — current: ${current}`,
-                            options: OFFERED_MODES.map((name) => ({ label: name, note: [MODE_NOTE[name], ...(name === current ? ["current"] : [])].join(" · ") })),
+                            // the header names the switch when it is on; the
+                            // rows are the tiers alone — don't ask is not a tier
+                            // and is not offered beside them (owner, 2026-09-30)
+                            header: `mode — current: ${modeDisplay()}`,
+                            options: OFFERED_MODES.map((name) => ({ label: MODE_LABEL[name], note: [MODE_NOTE[name], ...(name === current ? ["current"] : [])].join(" · ") })),
                             // MP-1 (0.40.7): the cursor opens on the tier in force
                             ...(OFFERED_MODES.indexOf(current) >= 0 ? { initial: OFFERED_MODES.indexOf(current) } : {}),
                         }, 
                         // DC-12 (design §4): a panel WAITING ON A HUMAN says ❯.
-                        ctx.isRunning() ? "❯ run paused" : `▸ ${current}`), (v) => resolve(v.action === "picked" ? v.result : null));
+                        ctx.isRunning() ? "❯ run paused" : `▸ ${modeDisplay()}`), (v) => resolve(v.action === "picked" ? v.result : null));
                     });
                     ctx.paintIdle();
                     if (picked === null) {
                         ctx.input.prompt();
                         return; // esc — nothing switched, nothing said
                     }
-                    const chosen = "index" in picked ? OFFERED_MODES[picked.index] : MODES.find((x) => x === picked.custom.trim());
+                    const chosen = "index" in picked ? (OFFERED_MODES[picked.index] === undefined ? undefined : { mode: OFFERED_MODES[picked.index] }) : parseMode(picked.custom);
                     if (chosen === undefined) {
                         bodyLog(`no such mode: ${"index" in picked ? String(picked.index) : picked.custom.trim()}`);
                         bodyLog(`tiers: ${OFFERED_MODES.join(" ")}`);
                     }
                     else {
-                        setMode(chosen);
-                        body.notice(`mode → ${chosen}`);
-                        ctx.paintIdle();
+                        switchTier(chosen);
                     }
                     ctx.input.prompt();
                     return;
                 }
                 bodyLog(`mode ${getMode()}`);
+                if (getDontAsk())
+                    bodyLog("don't ask on");
                 bodyLog(`tiers: ${OFFERED_MODES.join(" ")}`);
             }
-            else if (m === undefined) {
-                bodyLog(`no such mode: ${trimmed.slice(5).trim()}`);
-                bodyLog(`tiers: ${OFFERED_MODES.join(" ")}`);
+            else {
+                const typed = parseMode(arg);
+                if (typed === undefined) {
+                    bodyLog(`no such mode: ${arg}`);
+                    bodyLog(`tiers: ${OFFERED_MODES.join(" ")}`);
+                }
+                else {
+                    switchTier(typed);
+                }
+            }
+            ctx.input.prompt();
+        });
+        return;
+    }
+    if (trimmed === "/dont-ask" || trimmed.startsWith("/dont-ask ")) {
+        // The don't-ask switch on its own — the tier stays. Bare flips it;
+        // `on` / `off` set it. A switch set here outlives tier changes.
+        ctx.chainRef.current = ctx.chainRef.current.then(async () => {
+            const arg = trimmed.slice(9).trim();
+            const want = arg === "" ? !getDontAsk() : arg === "on" ? true : arg === "off" ? false : undefined;
+            if (want === undefined) {
+                bodyLog("usage: /dont-ask [on|off]");
             }
             else {
-                setMode(m);
-                body.notice(`mode → ${m}`);
+                setDontAsk(want);
+                body.notice(`don't ask → ${want ? "on" : "off"}`);
                 ctx.paintIdle();
             }
             ctx.input.prompt();
@@ -684,7 +727,7 @@ export function dispatch(line, ctx) {
                     // DC-12 (design §4): a panel WAITING ON A HUMAN says ❯. The
                     // else-branch keeps ▸ — it names the current tier, which is
                     // what ▸ means everywhere else.
-                    ctx.isRunning() ? "❯ run paused" : `▸ ${getMode()}`), (v) => {
+                    ctx.isRunning() ? "❯ run paused" : `▸ ${modeDisplay()}`), (v) => {
                         // OR-7: the level rides beside the result, so a pick
                         // with no second axis is byte-for-byte the old one.
                         if (v.action === "picked")
@@ -1034,15 +1077,31 @@ export function dispatch(line, ctx) {
         // streams), a pipe's "exit" always arrives mid-run, and the
         // approval panel the fix protects only exists on the dock. An idle
         // exit is immediate, byte-for-byte as before, on every surface.
+        // 3e: with live tasks the dock asks first; staying re-prompts
+        const exitAfterAsking = async () => {
+            if (await ctx.confirmExit())
+                ctx.input.close();
+            else
+                ctx.input.prompt();
+        };
         if (ctx.isRunning() && dock.active) {
             if (trimmed === "exit")
                 body.notice("[exit queued — closing after the current run completes]");
-            ctx.chainRef.current = ctx.chainRef.current.then(async () => {
-                ctx.input.close();
-            });
+            ctx.chainRef.current = ctx.chainRef.current.then(exitAfterAsking);
             return;
         }
-        ctx.input.close();
+        void exitAfterAsking();
+        return;
+    }
+    if (trimmed === "/tasks" || trimmed.startsWith("/tasks ")) {
+        // ADR-0058 (3e): the session's tasks, for the PERSON. Everything here
+        // is drawn on the screen and nowhere else — no user_input, no event
+        // in the session log, nothing the model sees, no wake.
+        ctx.chainRef.current = ctx.chainRef.current.then(async () => {
+            await tasksCommand(trimmed.slice("/tasks".length).trim(), ctx);
+            ctx.paintIdle();
+            ctx.input.prompt();
+        });
         return;
     }
     if (trimmed === "/clear") {
@@ -1188,3 +1247,76 @@ export function dispatch(line, ctx) {
     // live count rides the status bar (+N queued).
     ctx.submitTurn(line);
 }
+/** ADR-0058 (3e) — `/tasks`, `/tasks show <id>`, `/tasks stop <id>`. On a
+ *  dock the bare command is a pick: a task, then what to do with it. A
+ *  stop is REQUESTED here; the row says `stopping` until the journal says
+ *  how it ended. Looking at the list counts as having seen its unknown
+ *  tasks (the status row stops counting them). */
+async function tasksCommand(arg, ctx) {
+    const manager = tasksFor(ctx.session.id);
+    if (manager === undefined) {
+        bodyLog("no tasks here — this session has no task manager");
+        return;
+    }
+    let list;
+    try {
+        list = manager.list();
+    }
+    catch (err) {
+        bodyLog(`tasks: ${err.message}`);
+        return;
+    }
+    const show = (t) => {
+        const lines = taskOutput(t);
+        bodyLog(`${t.id} — ${t.agent !== undefined ? "its answer" : "its last output"}${lines.length === 0 ? ": nothing yet" : ""}`);
+        for (const line of lines)
+            bodyLog(`  ${line}`);
+    };
+    const stop = (t) => {
+        bodyLog(manager.stop(t.id, "person") ? `${t.id}: stop requested` : `${t.id}: nothing to stop (${taskStateLabel(t)})`);
+    };
+    const [verb, id] = arg.split(/\s+/);
+    if (verb === "show" || verb === "stop") {
+        const t = list.find((x) => x.id === id);
+        if (t === undefined)
+            bodyLog(`no task ${id ?? ""} in this session`);
+        else if (verb === "show")
+            show(t);
+        else
+            stop(t);
+        return;
+    }
+    if (arg !== "") {
+        bodyLog("usage: /tasks · /tasks show <id> · /tasks stop <id>");
+        return;
+    }
+    if (list.length === 0) {
+        bodyLog("no tasks in this session");
+        return;
+    }
+    for (const t of list)
+        if (t.state.kind === "unknown")
+            seenUnknownTasks.add(t.id);
+    if (!dock.active) {
+        for (const t of list) {
+            const r = taskRow(t);
+            bodyLog(`${r.label}  ${r.note}`);
+        }
+        return;
+    }
+    const ask = (header, options) => new Promise((resolve) => {
+        ctx.input.panelAsk(namedPickView("tasks", { header, options }, ctx.isRunning() ? "❯ run paused" : "▸ tasks", "which task? (id) "), (v) => resolve(v.action === "picked" && "index" in v.result ? v.result.index : null));
+    });
+    const shown = list.slice(-20); // the newest twenty; /tasks show <id> reaches any
+    const which = await ask(`tasks — ${list.length} in this session`, shown.map((t) => taskRow(t)));
+    const task = which === null ? undefined : shown[which];
+    if (task === undefined)
+        return;
+    const live = task.state.kind === "running" || task.state.kind === "starting";
+    const actions = [task.agent !== undefined ? "show its answer" : "show its output", ...(live ? ["stop it"] : [])];
+    const action = await ask(`${task.id} · ${taskStateLabel(task)} · ${taskRow(task).note}`, actions.map((label) => ({ label })));
+    if (action === 0)
+        show(task);
+    else if (action === 1)
+        stop(task);
+}

package/dist/empty-sessions.d.ts

@@ -14,8 +14,10 @@ export interface EmptyScan {
 export declare function pidAlive(pid: number): boolean;
 /** Every session in `dirs` with a sidecar and no log. Reads only. */
 export declare function findEmptySessions(dirs: readonly string[], alive?: (pid: number) => boolean): EmptyScan;
-/** The platform's Trash: ~/.Trash on macOS, the freedesktop one elsewhere. */
-export declare function defaultTrashRoot(): string;
+/** The platform's Trash: ~/.Trash on macOS, kiso's own folder on Windows
+ *  (its Recycle Bin is not a folder a program moves files into), the
+ *  freedesktop one elsewhere. */
+export declare function defaultTrashRoot(kisoHome: string): string;
 /** Move the sessions into one new folder under `trashRoot`, keeping each
  *  session folder's name; returns that folder. Never deletes: a file that
  *  cannot be renamed across devices is copied, then unlinked. */

package/dist/empty-sessions.js

@@ -72,10 +72,14 @@ export function findEmptySessions(dirs, alive = pidAlive) {
     }
     return { empty, inUse };
 }
-/** The platform's Trash: ~/.Trash on macOS, the freedesktop one elsewhere. */
-export function defaultTrashRoot() {
+/** The platform's Trash: ~/.Trash on macOS, kiso's own folder on Windows
+ *  (its Recycle Bin is not a folder a program moves files into), the
+ *  freedesktop one elsewhere. */
+export function defaultTrashRoot(kisoHome) {
     if (process.platform === "darwin")
         return join(homedir(), ".Trash");
+    if (process.platform === "win32")
+        return join(kisoHome, "trash");
     return join(process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share"), "Trash", "files");
 }
 /** Move the sessions into one new folder under `trashRoot`, keeping each

package/dist/external-editor.js

@@ -23,6 +23,7 @@
 import { spawnSync } from "node:child_process";
 import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { launchCommand } from "./launch.js";
 /**
  * Run `bin` on `text` and return what came back, or `null` when the edit
  * failed — in which case `onFailure` has already been told, in one line,
@@ -43,7 +44,9 @@ export function runExternalEditor(bin, root, text, onFailure) {
     const file = join(dir, "message.md"); // .md so the editor lights it up
     try {
         writeFileSync(file, text, { encoding: "utf8", mode: 0o600 });
-        const r = spawnSync(bin, [file], { stdio: "inherit", shell: false });
+        // Windows: an editor is often a .cmd shim (code.cmd) — through cmd.exe
+        const l = launchCommand(bin, [file]);
+        const r = spawnSync(l.file, [...l.args], { stdio: "inherit", shell: false, ...(l.windowsVerbatimArguments === true ? { windowsVerbatimArguments: true } : {}) });
         if (r.error !== undefined || (r.status !== null && r.status !== 0)) {
             onFailure(`[ctrl+g] ${bin} exited ${r.status ?? "abnormally"} — the composer is unchanged`);
             return null;

package/dist/floor.js

@@ -42,8 +42,8 @@
  */
 import { existsSync, statSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
-import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { HOME_SUBTREES, looseCommands, parseShellLooseChecked, resolveShellPath } from "./shell-words.js";
+import { basename, resolve, win32 } from "node:path";
+import { homeSubtrees, hostDialect, looseCommands, msysPath, parseShellLooseChecked, resolveShellPath } from "./shell-words.js";
 /** R8 (the lead's ruling): a system root AND everything inside it. */
 const SYSTEM_ROOTS = [
     "/bin", "/boot", "/dev", "/etc", "/lib", "/lib64", "/opt", "/proc", "/root", "/run", "/sbin", "/srv", "/sys", "/usr", "/var",
@@ -59,28 +59,46 @@ const TEMP_ROOTS = ["/tmp", "/private/tmp", "/var/tmp", "/private/var/tmp", "/va
  *  only the prefix itself; what is inside runs (`brew` put it there and can
  *  again). */
 const SOFTWARE_PREFIXES = ["/opt/homebrew", "/usr/local", "/home/linuxbrew/.linuxbrew"];
+/** Windows P2: the same tables from the environment, never a hard-coded
+ *  user name. System roots: SystemRoot and the program and data roots;
+ *  the users root works as a mount root (it and each home in it refused);
+ *  the temp family is TEMP/TMP. Every drive root is refused in
+ *  `unrecoverable`. */
+function windowsRoots(home) {
+    const env = process.env;
+    const set = (values) => values.filter((v) => v !== undefined && v !== "");
+    return {
+        sys: set([env.SystemRoot, env.ProgramFiles, env["ProgramFiles(x86)"], env.ProgramData]),
+        mounts: [win32.dirname(home)],
+        temps: set([env.TEMP, env.TMP]),
+        prefixes: [],
+    };
+}
 /** Memoized per (workspace, home): the roots do not move within a session,
  *  and resolving forty of them cost every shell call ~4 ms. */
 const WHERE = new Map();
 function where(root, home) {
-    const key = `${root}\0${home}`;
+    const dialect = hostDialect();
+    const key = `${dialect.msys ? "msys" : "posix"}\0${root}\0${home}`;
     const hit = WHERE.get(key);
     if (hit !== undefined)
         return hit;
-    const real = (p) => resolveShellPath(root, "/", p).canonical;
+    const { join } = dialect.path;
+    const real = (p) => resolveShellPath(root, dialect.msys ? root : "/", p, dialect).canonical;
     const named = (names) => names.map((name) => ({ name, real: real(name) }));
     const rootReal = real(root);
+    const roots = dialect.msys ? windowsRoots(home) : { sys: SYSTEM_ROOTS, mounts: MOUNT_ROOTS, temps: [...TEMP_ROOTS, tmpdir()], prefixes: SOFTWARE_PREFIXES };
     const w = {
         root,
         home,
         rootReal,
         homeReal: real(home),
         gitReal: join(rootReal, ".git"),
-        sys: named(SYSTEM_ROOTS),
-        mounts: named(MOUNT_ROOTS),
-        temps: [...new Set([...TEMP_ROOTS, tmpdir()].map(real))],
-        prefixes: named(SOFTWARE_PREFIXES),
-        subtrees: HOME_SUBTREES.map((name) => ({ name, real: real(join(home, name)) })),
+        sys: named(roots.sys),
+        mounts: named(roots.mounts),
+        temps: [...new Set(roots.temps.map(real))],
+        prefixes: named(roots.prefixes),
+        subtrees: homeSubtrees().map((name) => ({ name, real: real(join(home, name)) })),
     };
     WHERE.set(key, w);
     return w;
@@ -97,27 +115,35 @@ function capCwds(w, list) {
 }
 const canon = (w, cwd, p) => resolveShellPath(w.root, cwd, p).canonical;
 const within = (parent, p) => {
+    const { relative, isAbsolute } = hostDialect().path;
     const rel = relative(parent, p);
     return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
 };
+/** The same path: case-insensitive on Windows (Windows P2). */
+const same = (a, b) => (hostDialect().msys ? a.toLowerCase() === b.toLowerCase() : a === b);
 /** Why `p` (canonical) is unrecoverable, or null. `over` is true for a
  *  wildcard over `p` rather than `p` itself — the same set, since
  *  emptying a directory is removing everything it held. */
 function unrecoverable(w, p, over) {
     const what = (s) => (over ? `a wildcard over ${s}` : s);
+    const msys = hostDialect().msys;
     if (p === "/")
         return what("/");
-    if (p === w.homeReal)
+    if (msys && win32.parse(p).root === p)
+        return what(`a drive root (${p})`);
+    if (same(p, w.homeReal))
         return what("the home directory");
-    if (p === w.rootReal)
+    if (same(p, w.rootReal))
         return what("the workspace root");
     if (within(p, w.rootReal))
         return what(`a directory above the workspace (${p})`);
     // R7: the workspace's history — without a remote, gone
     if (within(w.gitReal, p))
         return what("the workspace's .git");
+    // on Windows the temp root sits inside AppData: what is inside a temp
+    // root that lies inside the subtree runs
     for (const sub of w.subtrees)
-        if (within(sub.real, p))
+        if (within(sub.real, p) && !(msys && w.temps.some((t) => within(sub.real, t) && !same(p, t) && within(t, p))))
             return what(`~/${sub.name}`);
     // Inside the workspace or the home directory is the project's and the
     // person's, never a system root's — or a workspace in /opt, or a root
@@ -125,21 +151,21 @@ function unrecoverable(w, p, over) {
     if ((w.rootReal !== "/" && within(w.rootReal, p)) || within(w.homeReal, p))
         return null;
     for (const t of w.temps) {
-        if (p === t)
+        if (same(p, t))
             return what(`a temp root (${t})`);
         if (within(t, p))
             return null;
     }
     for (const x of w.prefixes) {
-        if (p === x.real)
+        if (same(p, x.real))
             return what(`a software prefix (${x.name})`);
         if (within(x.real, p))
             return null;
     }
     for (const m of w.mounts) {
-        if (p === m.real)
+        if (same(p, m.real))
             return what(`a system root (${m.name})`);
-        if (dirname(p) === m.real)
+        if (same(hostDialect().path.dirname(p), m.real))
             return what(`a mount or home root (${p})`);
         // deeper runs — by RESOLVED path: macOS's /home is
         // /System/Volumes/Data/home, which the /System rule would refuse
@@ -147,7 +173,7 @@ function unrecoverable(w, p, over) {
             return null;
     }
     for (const s of w.sys) {
-        if (p === s.real)
+        if (same(p, s.real))
             return what(`a system root (${s.name})`);
         if (within(s.real, p))
             return what(`a path inside a system root (${s.name})`);
@@ -169,7 +195,9 @@ function reUnknown(text, from) {
 /** One target word, from each directory the command might run in. */
 function targetWhy(w, cwds, word) {
     for (const cwd of cwds) {
-        let text = word.text;
+        // Windows P2: either separator separates (the same length, so the
+        // unknown positions hold)
+        let text = hostDialect().msys ? word.text.replace(/\\/g, "/") : word.text;
         let at = word.unknownAt;
         let glob = word.unknownIsGlob;
         let variableOnly = word.variableOnly;
@@ -189,7 +217,10 @@ function targetWhy(w, cwds, word) {
         if (variableOnly)
             return `a target that is only a variable (${word.text})`;
         if (at < 0) {
-            const why = unrecoverable(w, canon(w, cwd, text), false);
+            const target = resolveShellPath(w.root, cwd, text);
+            if (target.opaque !== undefined)
+                return `${word.text}, ${target.opaque}`;
+            const why = unrecoverable(w, target.canonical, false);
             if (why !== null)
                 return why;
             continue;
@@ -200,7 +231,10 @@ function targetWhy(w, cwds, word) {
             continue;
         const prefix = text.slice(0, at);
         const lastSlash = prefix.lastIndexOf("/");
-        const dir = canon(w, cwd, lastSlash < 0 ? "." : prefix.slice(0, lastSlash + 1) || "/");
+        const over = resolveShellPath(w.root, cwd, lastSlash < 0 ? "." : prefix.slice(0, lastSlash + 1) || "/");
+        if (over.opaque !== undefined)
+            return `a wildcard in ${word.text}, ${over.opaque}`;
+        const dir = over.canonical;
         const head = prefix.slice(lastSlash + 1); // the literal start of the unknown component
         const nextSlash = text.indexOf("/", at);
         const component = text.slice(lastSlash + 1, nextSlash < 0 ? text.length : nextSlash);
@@ -210,7 +244,7 @@ function targetWhy(w, cwds, word) {
         for (const sub of w.subtrees) {
             if (within(sub.real, dir))
                 return `a wildcard inside ~/${sub.name}`;
-            if (glob && dir === w.homeReal && head !== "" && sub.name.toLowerCase().startsWith(head.toLowerCase()))
+            if (glob && same(dir, w.homeReal) && head !== "" && sub.name.toLowerCase().startsWith(head.toLowerCase()))
                 return `a wildcard that reaches ~/${sub.name}`;
         }
         // B9: over the directory ONLY when the unknown component is nothing
@@ -318,7 +352,7 @@ const SELECTING = new Set([
 ]);
 /** R5: a checkout/restore operand is a path only when path-shaped — a
  *  branch name is never refused. */
-const pathShaped = (t) => t === "." || t === "./" || t.startsWith("/") || t.startsWith("~") || t.includes("/") || t.startsWith(":");
+const pathShaped = (t) => t === "." || t === "./" || t.startsWith("/") || t.startsWith("~") || t.includes("/") || t.startsWith(":") || (hostDialect().msys && (t.includes("\\") || /^[A-Za-z]:/.test(t)));
 /** B7: pathspec magic from the top of the repository */
 const topMagic = (t) => t.startsWith(":/") || t.startsWith(":(top");
 /** The destructive command's targets, or null when it is not destructive. */
@@ -447,7 +481,7 @@ function destructiveTargets(argv) {
 function isGitDir(p) {
     try {
         const st = statSync(p);
-        return st.isFile() || (st.isDirectory() && existsSync(join(p, "HEAD")));
+        return st.isFile() || (st.isDirectory() && existsSync(hostDialect().path.join(p, "HEAD")));
     }
     catch {
         return false;
@@ -458,6 +492,7 @@ function isGitDir(p) {
  *  inside the workspace, the workspace root; outside it, the directory
  *  itself — git would refuse to run there, and the floor does not bet on it. */
 function repoRoot(w, cwd) {
+    const { dirname, join } = hostDialect().path;
     const start = canon(w, cwd, ".");
     for (let d = start;; d = dirname(d)) {
         if (isGitDir(join(d, ".git")))
@@ -467,6 +502,16 @@ function repoRoot(w, cwd) {
     }
     return within(w.rootReal, start) ? w.rootReal : start;
 }
+/** Windows P2: where a cd to an unreadable path lands — every relative
+ *  path from it is unreadable too. */
+const UNREADABLE_DIR = "//?/unreadable";
+/** Where `cd text` from `c` lands, as the shell spells it (lexically). */
+function cdTo(c, text) {
+    if (!hostDialect().msys)
+        return resolve(c, text);
+    const read = msysPath(text);
+    return "opaque" in read || c === UNREADABLE_DIR ? UNREADABLE_DIR : win32.resolve(c, read.native);
+}
 /** A child shell starts where this node runs — the node's joiner has
  *  already been applied — and nothing it does comes back. */
 const child = (s) => ({ cwds: [...s.cwds], lastCd: null, prev: s.prev });
@@ -544,7 +589,7 @@ export function floorCheck(commandLine, workspaceRoot, home = homedir()) {
                 else if (to === undefined || to.unknownAt >= 0 || to.variableOnly)
                     dest = capCwds(w, [w.home, ...state.cwds]);
                 else
-                    dest = capCwds(w, state.cwds.map((c) => resolve(c, tilde(to))));
+                    dest = capCwds(w, state.cwds.map((c) => cdTo(c, tilde(to))));
                 state.prev = state.cwds;
                 state.lastCd = { to: dest, from };
                 continue;
@@ -554,12 +599,12 @@ export function floorCheck(commandLine, workspaceRoot, home = homedir()) {
                 continue;
             let here = state.cwds;
             for (const cd of d.cds ?? [])
-                here = cd.unknownAt >= 0 ? capCwds(w, [...here, w.home]) : here.map((c) => resolve(c, tilde(cd)));
+                here = cd.unknownAt >= 0 ? capCwds(w, [...here, w.home]) : here.map((c) => cdTo(c, tilde(cd)));
             for (const t of d.targets) {
                 let why = null;
                 if (t === "repo") {
                     for (const c of here)
-                        if ((why = unrecoverable(w, repoRoot(w, c), false)) !== null)
+                        if ((why = c === UNREADABLE_DIR ? "a repository in a directory that cannot be read" : unrecoverable(w, repoRoot(w, c), false)) !== null)
                             break;
                 }
                 else