unsnooze 1.14.4 → 1.16.0

package/src/design.js

@@ -0,0 +1,209 @@
+// Claude Design support (issue #13).
+//
+// Claude Design has three surfaces: the canvas at claude.ai/design, the Claude
+// Desktop sidebar, and — the one that matters here — an official MCP server
+// that Claude Code drives from the terminal:
+//
+//   claude mcp add --scope user --transport http claude-design \
+//     https://api.anthropic.com/v1/design/mcp
+//   /design-login
+//
+// unsnooze deliberately supports only that third surface. The canvas is a web
+// app, and Anthropic's Consumer ToS bars accessing Claude "through automated or
+// non-human means, whether through a bot, script, or otherwise" — driving it
+// with a headless browser risks the user's account, and Claude Code is the
+// documented exemption. There is no version of this file that opens a browser.
+//
+// Design draws from the same 5-hour and weekly pool as chat, Cowork and Claude
+// Code (it had its own weekly allowance once; it does not now), so a design
+// session that stops is an ordinary limit stop and the existing machinery
+// already handles it. What was missing was setup and visibility, which is all
+// this module adds.
+
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export const DESIGN_MCP_NAME = 'claude-design';
+export const DESIGN_MCP_URL = 'https://api.anthropic.com/v1/design/mcp';
+
+export function designMcpAddArgs() {
+  return ['mcp', 'add', '--scope', 'user', '--transport', 'http',
+    DESIGN_MCP_NAME, DESIGN_MCP_URL];
+}
+
+function defaultRunner(args) {
+  const bin = process.env.UNSNOOZE_CLAUDE_BIN || 'claude';
+  const r = spawnSync(bin, args, { encoding: 'utf-8' });
+  if (r.error) throw r.error;
+  return `${r.stdout || ''}${r.stderr || ''}`;
+}
+
+// One row per configured MCP server, from `claude mcp list`. Real output:
+//
+//   Checking MCP server health…
+//   [mcp-sdk] SEP-2352: stored OAuth credential has no 'issuer' stamp (…)
+//   claude.ai Notion: https://mcp.notion.com/mcp - ! Needs authentication
+//   plugin:context7:context7: https://mcp.context7.com/mcp (HTTP) - ✔ Connected
+//
+// Two shapes make this fussier than a split(': '): names carry both colons
+// (plugin:context7:context7) and spaces (claude.ai Notion), and the SDK prints
+// unrelated diagnostics that look like rows. So the row separator is the LAST
+// ' - ' on the line, and the name is everything before the first COLON-SPACE —
+// which no name contains, because a bare colon inside a name is never followed
+// by a space.
+export function parseMcpList(stdout) {
+  if (typeof stdout !== 'string' || stdout === '') return [];
+  const rows = [];
+  for (const raw of stdout.split('\n')) {
+    const line = raw.trim();
+    if (!line || line.startsWith('[')) continue;   // sdk diagnostics
+    const sep = line.lastIndexOf(' - ');
+    if (sep === -1) continue;
+    const head = line.slice(0, sep);
+    const status = line.slice(sep + 3).trim();
+    const colon = head.indexOf(': ');
+    if (colon === -1) continue;
+    const name = head.slice(0, colon).trim();
+    if (!name) continue;
+    const target = head.slice(colon + 2).trim();
+    const needsAuth = /needs? authentication/i.test(status);
+    rows.push({
+      name,
+      target,
+      status,
+      connected: /connected/i.test(status) && !needsAuth,
+      needsAuth,
+    });
+  }
+  return rows;
+}
+
+// Registration, answered from disk instead of over the wire.
+//
+// `claude mcp list` health-checks every configured server, which takes seconds
+// — fine for an explicit `unsnooze design`, far too slow for `unsnooze doctor`,
+// which people run casually. `--scope user` writes the TOP-LEVEL mcpServers map
+// in ~/.claude.json; the per-project maps under .projects are a different scope
+// and must not be mistaken for it.
+export function designRegisteredOffline({
+  readConfig = () => readFileSync(join(homedir(), '.claude.json'), 'utf-8'),
+} = {}) {
+  try {
+    const parsed = JSON.parse(readConfig());
+    return Boolean(parsed?.mcpServers?.[DESIGN_MCP_NAME]);
+  } catch {
+    return false;   // missing, unreadable or corrupt — treat as not set up
+  }
+}
+
+// Is this machine ready to run Claude Design work from the terminal?
+//
+// Three distinguishable states, because the remedies differ completely:
+//   - claude missing/broken  -> nothing to do with Design at all
+//   - not registered         -> `unsnooze design setup`
+//   - registered, logged out -> `/design-login`, and note that this one is
+//     NOT a usage limit: no amount of waiting clears it.
+export function designStatus({ runner = defaultRunner } = {}) {
+  let out;
+  try {
+    out = runner(['mcp', 'list']);
+  } catch (err) {
+    return {
+      available: false, registered: false, connected: false, needsAuth: false,
+      hint: `could not run \`claude mcp list\` (${err.message}) — is the claude CLI installed?`,
+    };
+  }
+  const row = parseMcpList(out).find(r => r.name === DESIGN_MCP_NAME);
+  if (!row) {
+    return {
+      available: true, registered: false, connected: false, needsAuth: false,
+      hint: 'Claude Design is not wired into Claude Code — run `unsnooze design setup`',
+    };
+  }
+  if (row.needsAuth || !row.connected) {
+    return {
+      available: true, registered: true, connected: false, needsAuth: true,
+      hint: 'Claude Design is registered but signed out — run `/design-login` inside Claude Code. '
+        + 'This is not a usage limit; waiting will not clear it.',
+    };
+  }
+  return {
+    available: true, registered: true, connected: true, needsAuth: false,
+    hint: 'Claude Design is connected — design sessions are watched like any other Claude Code session',
+  };
+}
+
+// Register the MCP server. Editing the user's Claude config is not something to
+// do quietly, so this is only ever reached from an explicit `unsnooze design
+// setup`, and it prints exactly what it ran.
+export function installDesignMcp({ runner = defaultRunner } = {}) {
+  const args = designMcpAddArgs();
+  try {
+    return { ok: true, output: runner(args), args };
+  } catch (err) {
+    return { ok: false, output: err.message, args };
+  }
+}
+
+// --- command ---------------------------------------------------------------
+
+const USAGE = `unsnooze design — Claude Design from the terminal
+
+  unsnooze design            show whether Claude Design is wired up
+  unsnooze design setup      register the claude-design MCP server with Claude Code
+
+Claude Design's canvas (claude.ai/design, Claude Desktop) is a web surface and
+unsnooze does not automate it: Anthropic's Consumer Terms bar automated access
+to claude.ai, and doing it anyway risks your account. The supported route is the
+claude-design MCP server inside Claude Code, which unsnooze watches like any
+other Claude Code session.
+`;
+
+export function cmdDesign(rest = [], { runner = defaultRunner, log = console.log } = {}) {
+  const sub = rest[0];
+
+  if (sub === 'help' || sub === '--help' || sub === '-h') {
+    log(USAGE);
+    return 0;
+  }
+
+  if (sub === 'setup') {
+    const before = designStatus({ runner });
+    if (!before.available) {
+      log(`unsnooze: ${before.hint}`);
+      return 1;
+    }
+    if (before.registered) {
+      log(`unsnooze: ${DESIGN_MCP_NAME} is already registered.`);
+      log(`unsnooze: ${before.hint}`);
+      return 0;
+    }
+    log(`unsnooze: running \`claude ${designMcpAddArgs().join(' ')}\``);
+    const result = installDesignMcp({ runner });
+    if (!result.ok) {
+      log(`unsnooze: registration failed — ${result.output}`);
+      return 1;
+    }
+    log('unsnooze: registered. Now run `/design-login` inside Claude Code to sign in.');
+    log('unsnooze: design work shares your usual 5-hour and weekly limits, so a');
+    log('unsnooze: design session that stops is resumed like any other.');
+    return 0;
+  }
+
+  if (sub && sub !== 'status') {
+    log(`unsnooze: unknown design subcommand "${sub}"`);
+    log(USAGE);
+    return 1;
+  }
+
+  const status = designStatus({ runner });
+  log(`unsnooze: ${status.hint}`);
+  if (status.connected) {
+    log('unsnooze: tip — long design runs burn context fast; set');
+    log('unsnooze:   unsnooze config set launchExtraArgs.claude "--autocompact 400000"');
+    log('unsnooze: so a context-heavy session compacts instead of stalling.');
+  }
+  return status.connected ? 0 : 1;
+}

package/src/doctor.js

@@ -14,6 +14,8 @@ import { CLAUDE_SETTINGS, RESUMER_LOCK } from './config.js';
 import { getMultiplexer } from './multiplexer.js';
 import { makeLogger } from './logger.js';
 import { shouldUseTui, formatDoctorTui } from './tui.js';
+import { designRegisteredOffline } from './design.js';
+import { powershellProfilePath } from './powershell.js';
 
 const log = makeLogger('doctor');
 
@@ -104,11 +106,31 @@ function defaultHookInstalled(settingsPath = CLAUDE_SETTINGS) {
   }
 }
 
-function defaultWrappersInstalled() {
-  return [join(homedir(), '.zshrc'), join(homedir(), '.bashrc')].some(rc => {
-    try { return readFileSync(rc, 'utf-8').includes('# >>> unsnooze >>>'); }
-    catch { return false; }
-  });
+const WRAPPER_MARK = '# >>> unsnooze >>>';
+
+function readOrEmpty(path) {
+  try { return readFileSync(path, 'utf-8'); } catch { return ''; }
+}
+
+// The wrapper shadowing the real CLI is unsnooze's entry point, so "are the
+// wrappers installed" is a health question — but it has to be asked of the
+// right file. A PowerShell user has no ~/.zshrc, so checking only the POSIX rc
+// files made every native-Windows `unsnooze doctor` report the wrappers
+// missing and point the user at an install they had already run.
+function defaultWrappersInstalled({
+  platform = process.platform,
+  rcContent = readOrEmpty,
+  profileContent = null,
+} = {}) {
+  const rcs = [join(homedir(), '.zshrc'), join(homedir(), '.bashrc')];
+  if (rcs.some(rc => rcContent(rc).includes(WRAPPER_MARK))) return true;
+  if (platform !== 'win32') return false;
+  const readProfile = profileContent
+    || (() => {
+      const p = powershellProfilePath({ platform });
+      return p ? readOrEmpty(p) : '';
+    });
+  return readProfile().includes(WRAPPER_MARK);
 }
 
 function daemonRunning() {
@@ -136,8 +158,11 @@ export async function runDoctor({
   csgStateDir = join(homedir(), '.claude-session-guard'),
   csgBinPath = defaultCsgPackagePath({ runner }),
   mux = getMultiplexer(),
+  designRegistered = designRegisteredOffline,
   hookInstalled = defaultHookInstalled,
   wrappersInstalled = defaultWrappersInstalled,
+  rcContent = undefined,
+  profileContent = undefined,
   autostartDir = null,
 } = {}) {
   const findings = [];
@@ -188,7 +213,7 @@ export async function runDoctor({
       detail: '  run: unsnooze install --yes',
     });
   }
-  if (!wrappersInstalled()) {
+  if (!wrappersInstalled({ platform, ...(rcContent ? { rcContent } : {}), ...(profileContent ? { profileContent } : {}) })) {
     findings.push({
       id: 'wrappers-missing', kind: 'health',
       title: 'shell wrappers are not installed',
@@ -230,6 +255,18 @@ export async function runDoctor({
     detail: '',
   });
 
+  // Claude Design (issue #13). Informational only — Design is optional, so a
+  // machine without it is not unhealthy. Read from config rather than
+  // `claude mcp list`, which health-checks every server and would put seconds
+  // onto every doctor run.
+  findings.push({
+    id: 'claude-design', kind: 'info',
+    title: designRegistered()
+      ? 'Claude Design: MCP server registered (run `unsnooze design` to check sign-in)'
+      : 'Claude Design: not set up (optional — `unsnooze design setup`)',
+    detail: '',
+  });
+
   const healthy = findings.every(f => f.kind === 'info');
   return { findings, healthy };
 }

package/src/fleet.js

@@ -845,7 +845,11 @@ export const MUX_SESSION_RE = /^[A-Za-z0-9_.-]{1,64}$/;
 // validation — callers must treat null as "omit the attach line".
 export function attachHintRemote(dest, muxName, muxSession) {
   if (!validHostToken(dest) || typeof muxSession !== 'string' || !MUX_SESSION_RE.test(muxSession)) return null;
-  const inner = muxName === 'zellij' ? `zellij attach ${muxSession}` : `tmux new -A -s ${muxSession}`;
+  // cmux has no joinable named-session model — there is no remote command
+  // that reattaches to a surface, so omit the hint (see attachHint).
+  if (muxName === 'cmux') return null;
+  const inner = muxName === 'herdr' ? `herdr session attach ${muxSession}`
+    : muxName === 'zellij' ? `zellij attach ${muxSession}` : `tmux new -A -s ${muxSession}`;
   return `ssh -t ${dest} '${inner}'`;
 }
 

package/src/hook.js

@@ -41,6 +41,21 @@ function classify(payload, raw) {
   return 'unknown';
 }
 
+export function hookContext(env = process.env, payload = {}) {
+  const managedMux = env.UNSNOOZE_MUX;
+  const muxName = managedMux || (env.HERDR_PANE_ID ? 'herdr' : env.ZELLIJ_PANE_ID ? 'zellij' : 'tmux');
+  const pane = managedMux
+    ? (env.UNSNOOZE_PANE || null)
+    : (muxName === 'herdr' ? env.HERDR_PANE_ID
+      : muxName === 'zellij' ? env.ZELLIJ_PANE_ID : env.TMUX_PANE || payload.tmux_pane) || null;
+  const paneOwner = muxName === 'herdr'
+    ? (managedMux ? env.UNSNOOZE_PANE_OWNER : (env.HERDR_SESSION || 'default'))
+    : muxName === 'zellij'
+      ? (managedMux ? env.UNSNOOZE_PANE_OWNER : env.ZELLIJ_SESSION_NAME) || null
+      : null;
+  return { muxName, pane, paneOwner };
+}
+
 export async function runHook(rest = []) {
   try {
     const agentIdx = rest.indexOf('--agent');
@@ -57,16 +72,16 @@ export async function runHook(rest = []) {
       return 0;
     }
 
-    const managedMux = process.env.UNSNOOZE_MUX;
-    const muxName = managedMux || (process.env.ZELLIJ_PANE_ID ? 'zellij' : 'tmux');
-    const pane = managedMux
-      ? (process.env.UNSNOOZE_PANE || null)
-      : (muxName === 'zellij' ? process.env.ZELLIJ_PANE_ID : process.env.TMUX_PANE || payload.tmux_pane) || null;
-    const paneOwner = muxName === 'zellij'
-      ? (managedMux ? process.env.UNSNOOZE_PANE_OWNER : process.env.ZELLIJ_SESSION_NAME) || null
-      : null;
+    const { muxName, pane: rawPane, paneOwner } = hookContext(process.env, payload);
     const leaseId = process.env.UNSNOOZE_LEASE_ID || null;
     const mux = getMultiplexer(muxName, { owner: paneOwner });
+    // Same guard as the launcher: a pane we cannot prove we are addressing on
+    // the right server is worse than no pane, because every later action —
+    // capture, inject, close — would be aimed at whatever occupies that id
+    // elsewhere. Record the stop without a pane instead.
+    const pane = (typeof mux.paneAddressable !== 'function' || mux.paneAddressable())
+      ? rawPane : null;
+    if (rawPane && !pane) log(`StopFailure: ignoring pane ${rawPane} — not safely addressable`);
     const kind = classify(payload, raw);
     log(`StopFailure: kind=${kind} pane=${pane} session=${payload.session_id || '?'}`);
 

package/src/install.js

@@ -19,6 +19,7 @@ import { installGrokHooks, uninstallGrokHooks } from './agents/grok.js';
 import { findCsgProcesses, findCsgAutostarts } from './doctor.js';
 import { UNSNOOZE_BIN, stopResumer } from './spawn.js';
 import { uninstallStatuslineShim } from './usage.js';
+import { powershellProfilePath } from './powershell.js';
 
 const FENCE_OPEN = '# >>> unsnooze >>>';
 const FENCE_CLOSE = '# <<< unsnooze <<<';
@@ -67,18 +68,36 @@ function isLegacy(entry) {
   return (entry.hooks || []).some(h => /claude-auto-retry|csg\.js _hook-stopfailure/.test(h.command || ''));
 }
 
+// The StopFailure hook command, per platform.
+//
+// Guarded like the shell wrapper: a vanished entry point must exit 0, not
+// spray MODULE_NOT_FOUND errors into every Claude Code turn. The guard has to
+// be written in the shell that will actually run it — Claude Code runs hooks
+// through cmd.exe on native Windows, where `test` does not exist, so the POSIX
+// form silently failed on every turn and took the hook detection channel with
+// it. That mattered little while Windows had no multiplexer to watch with; it
+// matters entirely now that headless leans on the hook.
+export function hookCommand({ platform = process.platform, bin = UNSNOOZE_BIN, agent = null } = {}) {
+  const agentFlag = agent ? ` --agent ${agent}` : '';
+  if (platform === 'win32') {
+    return `if exist "${bin}" (node "${bin}" _hook-stopfailure${agentFlag}) else (exit 0)`;
+  }
+  return `test -f "${bin}" && node "${bin}" _hook-stopfailure${agentFlag} || exit 0`;
+}
+
 // agent/matcher options cover CLIs with Claude-shaped hook config in their own
 // settings.json (qwen); the default stays byte-identical for claude.
-export function mergeHookIntoSettings(settingsJson, { agent = null, matcher = 'overloaded|server_error|rate_limit' } = {}) {
+export function mergeHookIntoSettings(settingsJson, {
+  agent = null,
+  matcher = 'overloaded|server_error|rate_limit',
+  platform = process.platform,
+} = {}) {
   const settings = JSON.parse(settingsJson);
   settings.hooks = settings.hooks || {};
   const list = (settings.hooks.StopFailure || []).filter(e => !isLegacy(e) && !isOurs(e));
-  const agentFlag = agent ? ` --agent ${agent}` : '';
   list.push({
     matcher,
-    // Guarded like the shell wrapper: a vanished entry point must exit 0, not
-    // spray MODULE_NOT_FOUND errors into every Claude Code turn.
-    hooks: [{ type: 'command', command: `test -f "${UNSNOOZE_BIN}" && node "${UNSNOOZE_BIN}" _hook-stopfailure${agentFlag} || exit 0`, timeout: 5 }],
+    hooks: [{ type: 'command', command: hookCommand({ platform, agent }), timeout: 5 }],
   });
   settings.hooks.StopFailure = list;
   return JSON.stringify(settings, null, 2) + '\n';
@@ -115,6 +134,38 @@ ${fns}
 ${FENCE_CLOSE}`;
 }
 
+// The PowerShell twin of wrapperBlock(), for native Windows where there is no
+// ~/.zshrc or ~/.bashrc to put a function in. Nobody types `unsnooze claude` —
+// the wrapper shadowing the real CLI *is* the entry point, so without this
+// nothing on native Windows routes through unsnooze at all.
+//
+// PowerShell comments are `#`, so the same fence markers work and
+// stripFencedBlock() removes it unchanged.
+export function powershellWrapperBlock(agents = ['claude'], bin = UNSNOOZE_BIN) {
+  const fns = agents.map(id => `Remove-Item -Path Alias:${id} -Force -ErrorAction SilentlyContinue
+function ${id} {
+  if ($env:UNSNOOZE_ACTIVE -eq '1' -or -not (Test-Path -LiteralPath '${bin}')) {
+    $real = Get-Command ${id} -CommandType Application -ErrorAction SilentlyContinue |
+      Select-Object -First 1
+    if ($real) { & $real.Source @args } else { Write-Error '${id}: not found' }
+    return
+  }
+  & node '${bin}' _run ${id} @args
+}`).join('\n');
+  return `${FENCE_OPEN}
+# unsnooze wrappers: route every interactive launch of the CLIs below through
+# unsnooze so limit stops are recorded and auto-resumed.
+${fns}
+${FENCE_CLOSE}`;
+}
+
+// installZshrcBlock's PowerShell twin. Same fence, same replace-don't-append
+// behaviour, so re-running setup never stacks a second copy of the wrappers.
+export function installPowershellBlock(content, agents = ['claude'], bin = UNSNOOZE_BIN) {
+  const { content: cleaned } = stripFencedBlock(content, FENCE_OPEN, FENCE_CLOSE);
+  return cleaned.replace(/\n+$/, '\n') + '\n' + powershellWrapperBlock(agents, bin) + '\n';
+}
+
 export function stripFencedBlock(content, open, close) {
   const lines = content.split('\n');
   const out = [];
@@ -148,6 +199,9 @@ export function installZshrcBlock(content, agents = ['claude']) {
 // user unit on Linux/WSL.
 
 export const DAEMON_LABEL = 'com.unsnooze.daemon';
+// Task Scheduler has no reverse-DNS convention and shows this name to the user
+// in taskschd.msc, so it is a plain word rather than the launchd label.
+export const WINDOWS_TASK_NAME = 'unsnooze';
 
 // Is this process running under the supervisor we install, rather than from
 // somebody's shell? It decides whether exiting is safe: a supervised daemon
@@ -163,7 +217,15 @@ export const DAEMON_LABEL = 'com.unsnooze.daemon';
 export function isSupervised({ platform = process.platform, env = process.env } = {}) {
   if (platform === 'darwin') return env.XPC_SERVICE_NAME === DAEMON_LABEL;
   if (platform === 'linux') return typeof env.INVOCATION_ID === 'string' && env.INVOCATION_ID !== '';
-  return false;   // nowhere else do we install a supervisor to be run by
+  // win32 stays false on purpose, even though we now install a Scheduled Task.
+  // launchd KeepAlive and systemd Restart=always bring the daemon straight
+  // back; a logon-triggered task does not restart anything until the next
+  // logon. Answering true here would let the version-skew guard exit 0 into
+  // nothing and stop Windows watching silently — the exact failure mode of
+  // issue #8, just with a different trigger. The cost is that a Windows daemon
+  // keeps running pre-upgrade code until the user logs back in; that is the
+  // lesser of the two, and `unsnooze doctor` reports the skew.
+  return false;
 }
 
 // Env overrides keep tests/e2e away from the real LaunchAgents / systemd dirs.
@@ -323,8 +385,20 @@ function defaultActivate(cmd, args) {
 export function installDaemonAutostart({
   platform = process.platform, dir = null, activate = defaultActivate, path = undefined,
 } = {}) {
+  // Native Windows has no unit *file* — the Task Scheduler holds the record —
+  // so it is handled before the file-based platforms below. It matters more
+  // here than anywhere else: the transcript watcher lives in the daemon, and
+  // headless has no pane monitor to fall back on, so without this a Windows
+  // machine only ever catches limit stops through the StopFailure hook.
+  if (platform === 'win32') {
+    // /f overwrites an existing task rather than failing with "already exists",
+    // which is what re-running setup does every time.
+    activate('schtasks', ['/create', '/f', '/tn', WINDOWS_TASK_NAME, '/sc', 'onlogon',
+      '/tr', `"${process.execPath}" "${UNSNOOZE_BIN}" daemon`]);
+    return `Scheduled Task \\${WINDOWS_TASK_NAME}`;
+  }
   const target = autostartUnitPath({ platform, dir });
-  if (!target) return null;   // native Windows: no supported multiplexer to revive into
+  if (!target) return null;
   // Safety interlock. Every unit we generate carries the SAME label, so running
   // the real launchctl/systemctl against a unit written somewhere else (a test
   // fixture, a staging copy) does not create a second job — it HIJACKS the
@@ -403,6 +477,11 @@ export function healDaemonAutostart({
 }
 
 export function uninstallDaemonAutostart({ platform = process.platform, dir = null, activate = defaultActivate } = {}) {
+  if (platform === 'win32') {
+    // /f so a missing task is not an interactive prompt on an uninstall path.
+    activate('schtasks', ['/delete', '/f', '/tn', WINDOWS_TASK_NAME]);
+    return `Scheduled Task \\${WINDOWS_TASK_NAME}`;
+  }
   if (platform === 'darwin') {
     const target = join(dir || autostartDir(platform), `${DAEMON_LABEL}.plist`);
     if (!existsSync(target)) return null;
@@ -516,6 +595,22 @@ export function cmdInstall(rest, { agents = enabledAgents() } = {}) {
     console.log(`unsnooze: wrappers (${agents.join(', ')}) installed in ${rc}${oldRemoved ? ' (legacy wrapper block removed)' : ''}`);
   }
 
+  // 3b. PowerShell profile (native Windows). The rc loop above only ever
+  //     reaches ~/.zshrc and ~/.bashrc, which a PowerShell user does not have —
+  //     without this nothing routes their `claude` through unsnooze at all.
+  const psProfile = powershellProfilePath();
+  if (psProfile) {
+    try {
+      mkdirSync(dirname(psProfile), { recursive: true });
+      const before = existsSync(psProfile) ? readFileSync(psProfile, 'utf-8') : '';
+      if (existsSync(psProfile)) backupOnce(psProfile);
+      atomicWrite(psProfile, installPowershellBlock(before, agents, UNSNOOZE_BIN));
+      console.log(`unsnooze: PowerShell wrappers (${agents.join(', ')}) installed in ${psProfile}`);
+    } catch (err) {
+      console.log(`unsnooze: could not write the PowerShell profile (${err.message})`);
+    }
+  }
+
   // 4. Daemon autostart (GUI-session watching), opt-in via --daemon / wizard.
   if (opts.daemon) {
     const target = installDaemonAutostart();
@@ -575,6 +670,22 @@ export function cmdUninstall(rest) {
     }
   }
 
+  // The PowerShell profile is a wrapper site too — leaving its block behind
+  // would keep shadowing `claude` with a function pointing at a bin that
+  // uninstall just removed.
+  try {
+    const psProfile = powershellProfilePath();
+    if (psProfile && existsSync(psProfile)) {
+      const { content, found } = stripFencedBlock(readFileSync(psProfile, 'utf-8'), FENCE_OPEN, FENCE_CLOSE);
+      if (found) {
+        atomicWrite(psProfile, content);
+        console.log(`unsnooze: PowerShell wrappers removed from ${psProfile}`);
+      }
+    }
+  } catch (err) {
+    console.log(`unsnooze: could not clean the PowerShell profile (${err.message})`);
+  }
+
   const autostart = uninstallDaemonAutostart();
   if (autostart) console.log(`unsnooze: daemon autostart removed (${autostart})`);