release: v2.2.20 — Windows platform hardening + channel capabilities

AGENTS.md

@@ -47,6 +47,7 @@ git add devlog && git commit -m "chore: update devlog ref" && git push
 - Recent non-strict hotspots: explicit `/continue`, workflow helper slash commands (`/plan` as PABCD P compatibility guide, `/interview`, `/deliberate`, `/planaudit`, `/review`, `/search`, `/goal`, `/goalplan`, `/team`, `/task`, `/fork`, `/gd`; forward PABCD transitions require `cli-jaw orchestrate <phase> --attest '{"from","to","did",...}'`), pre-prompt context hooks (`context-hooks.json`, `cli-jaw hooks`), bounded local search contract (narrow-path Grep/rg; external search via active search skill), Telegram Hub P0–P4 (`structure/telegram.md`, `/api/dashboard/telegram-hub`), goal pause gate continuation suppression (`goal_pause_gate_pending`), `tests/run.mts` programmatic test driver, `/goal plan` and `/goalplan` store user direction as `planHint` and require `/goal refine` before checkpoints; agent pause first-tap state is exposed as derived `pauseGate` on status/API surfaces while persisted status remains `active`; bounded automation is `/goal run ...`, not top-level `/autopilot`), Codex App clean-install default with opt-in migration for existing settings, bounded child-backed nullable CLI status, read-only OpenCodex root-URL/live-health diagnostics, Pi top-level `pi --mode rpc` runtime with isolated `PI_CODING_AGENT_DIR` profiles, AGY `-p` print-mode runtime with capability-probed optional `--model` (observed in AGY 1.0.12), Grok weekly quota via `~/.grok/auth.json` + Grok Build billing gRPC-web before legacy monthly fallback, SSE-first `GET /api/events` event channel with WebSocket fallback, bounded tool-log sanitizer, worker progress query/watch, canonical `/api/channel/send`, heartbeat `every`/`cron` schedules, browser runtime diagnostics/session lifecycle, Electron Node sidecar packaging, private active `k-writing` routing for Korean promotional/content writing, canonical platform classification via `src/core/platform-kind.ts` (`windows-native|wsl|linux|darwin|other`; `process.platform` decides first and `WSLENV` is never a WSL signal), and `npm run gate:all`.
 - Standalone lifecycle is home-scoped: `jaw --home <path> service stop|restart [--port N]` verifies `<JAW_HOME>/jaw.pid.json` before signalling; registered launchd/systemd instances delegate to their native manager. Never recommend killing every Node process.
 - Slack connection environment variables own their matching fields at runtime. Settings exposes only variable names and conservatively locks connection editing/reset while any are present; CLI setup refuses mixed input. Generic settings writes reject only env-owned paths, and persistence strips only those fields so env values never enter `settings.json` or erase unrelated file-backed credentials.
+- Slack-triggered Boss turns receive `channel_id` and parent `thread_ts` in the per-turn user prompt regardless of multi-session state; agents must use that explicit context for Slack lookup/send APIs instead of parsing session labels.
 - Optimization/score-maximization goals follow the optimization-loop discipline (LOOP-PHASE-DEATH/CONTINUITY/CANDIDATE-ANCHOR/INSTANCE-CHECK + GATE-ORACLE-VALIDITY):
   classify candidate changes, ban a class after 3 consecutive discards, force evaluator-gate work on repeated D-phase deaths.
   Canonical: dev-pabcd §10, dev-testing §9.5; injected via orchestration template and goal continuation.

CLAUDE.md

@@ -39,6 +39,7 @@ This repository is a Node.js ESM orchestration runtime for boss/employee dispatc
 - Gemini full-access runs use `--skip-trust --approval-mode yolo` on both fresh and resume sessions.
 - `/api/channel/send` is the canonical outbound Telegram/Discord/Slack delivery endpoint.
 - Slack connection environment variables own their matching fields at runtime: `GET /api/settings` reports `slackEnvironmentVariables` while redacting values, Settings and CLI setup conservatively refuse connection editing while any are present, generic `PUT`s reject only env-owned paths, and persistence strips only those fields so environment values never enter `settings.json` or erase unrelated file-backed credentials. Full `POST /api/settings/slack/reset` still returns `409` while any connection env variable exists.
+- Slack-triggered Boss turns receive `channel_id` and parent `thread_ts` in the per-turn user prompt regardless of multi-session state; agents use that explicit context for Slack lookup/send APIs instead of parsing session labels.
 - Heartbeat schedules support `{ kind: "every", minutes }` and `{ kind: "cron", cron, timeZone? }`.
 - Tool logs are capped by `src/shared/tool-log-sanitize.ts` before SSE/WebSocket, `agent_done`, and orchestration snapshot delivery. Web UI delivery is SSE-first through `GET /api/events`, with WebSocket as the legacy fallback dispatcher.
 - Employee worker progress is query-first via `jaw worker status [agent]`, watchable via `jaw worker watch [agent]` or `jaw dispatch --watch`, memory-only for current plus previous completed run, and safe-summary only with thinking detail hidden.

README.md

@@ -108,6 +108,97 @@ wsl.exe -d Ubuntu -- bash -lc "jaw dashboard"
 
 </details>
 
+<details>
+<summary><b>Native Windows (PowerShell beta)</b> — detached server logs</summary>
+
+`jaw serve` writes to the stdout and stderr streams it inherits. It does not
+create or open `serve.out.log`, and native Windows does not have a registered
+`jaw service` logging backend. PowerShell's
+`Start-Process -RedirectStandardOutput/-RedirectStandardError` creates or
+truncates its target files on every launch.
+
+Run the redirection inside a child PowerShell process instead. This example
+appends operator-owned logs under `<JAW_HOME>\logs`:
+
+```powershell
+$jawHome = 'C:\jaw\worker-a'
+$port = 3458
+$logDir = Join-Path $jawHome 'logs'
+$outLog = Join-Path $logDir 'serve.out.log'
+$errLog = Join-Path $logDir 'serve.err.log'
+New-Item -ItemType Directory -Force -Path $logDir -ErrorAction Stop | Out-Null
+foreach ($path in @($outLog, $errLog)) {
+    # OpenOrCreate preserves existing content while proving that the child can append.
+    $probe = [IO.File]::Open($path, 'OpenOrCreate', 'Write', 'ReadWrite')
+    $probe.Dispose()
+}
+
+$jaw = (Get-Command jaw.cmd -ErrorAction Stop).Source
+$childCommand = "& '$jaw' --home '$jawHome' serve --port $port --no-open 1>> '$outLog' 2>> '$errLog'"
+$encoded = [Convert]::ToBase64String([Text.Encoding]::Unicode.GetBytes($childCommand))
+Start-Process -FilePath powershell.exe -ArgumentList '-NoProfile', '-EncodedCommand', $encoded -WindowStyle Hidden | Out-Null
+```
+
+Read each stream from a separate PowerShell terminal (`Get-Content -Wait`
+occupies its terminal). These commands use explicit paths because variables
+from the launch terminal are not available in a new PowerShell session:
+
+```powershell
+# Terminal 1
+Get-Content -LiteralPath 'C:\jaw\worker-a\logs\serve.out.log' -Tail 100 -Wait
+
+# Terminal 2
+Get-Content -LiteralPath 'C:\jaw\worker-a\logs\serve.err.log' -Tail 100 -Wait
+```
+
+Lifecycle commands are home-scoped and verify `<JAW_HOME>\jaw.pid.json`
+before signalling:
+
+```powershell
+& $jaw --home $jawHome service stop --port $port
+& $jaw --home $jawHome service restart --port $port
+```
+
+A standalone `service restart` safely relaunches the instance detached, but
+cannot recreate the operator's file redirection. To preserve file capture,
+`stop`, optionally rotate the closed logs, and run the launch block again:
+
+```powershell
+$pidFile = Join-Path $jawHome 'jaw.pid.json'
+$serverProcess = $null
+if (Test-Path -LiteralPath $pidFile -PathType Leaf) {
+    $record = Get-Content -LiteralPath $pidFile -Raw -ErrorAction Stop | ConvertFrom-Json
+    $serverProcess = Get-Process -Id ([int]$record.pid) -ErrorAction SilentlyContinue
+}
+
+& $jaw --home $jawHome service stop --port $port
+if ($LASTEXITCODE -ne 0) {
+    throw "jaw service stop failed with exit code $LASTEXITCODE"
+}
+if ($serverProcess) {
+    try {
+        if (-not $serverProcess.WaitForExit(5000)) {
+            throw "jaw serve pid $($serverProcess.Id) did not exit within 5000ms"
+        }
+    } finally {
+        $serverProcess.Dispose()
+    }
+}
+
+$stamp = Get-Date -Format 'yyyyMMdd-HHmmss'
+foreach ($path in @($outLog, $errLog)) {
+    if (Test-Path -LiteralPath $path) {
+        Move-Item -LiteralPath $path -Destination "$path.$stamp" -ErrorAction Stop
+    }
+}
+# Run the Start-Process launch block above again.
+```
+
+Do not use `Get-Process node | Stop-Process`; it can terminate unrelated
+cli-jaw instances and AI runtime processes.
+
+</details>
+
 <details>
 <summary><b>Fresh-machine evidence</b> — maintainer release check</summary>
 
@@ -485,7 +576,7 @@ jaw skill list              # see what's available
 | **Web-AI vendors** | `jaw browser web-ai --vendor chatgpt\|gemini\|grok` with session lifecycle, diagnostics, source-audit/answer-artifact support, and ChatGPT code-mode zip recovery |
 | **Diagram Skill** | Generate SVG diagrams and interactive visualizations, rendered inline in chat |
 
-Computer Use lets you control any macOS app — Finder, Safari, System Settings, Xcode — through natural language. Point it at your localhost dev server in Safari and you get a full visual testing loop.
+Computer Use lets you control desktop apps — Finder, Safari, System Settings, Xcode on macOS; any window on Windows — through natural language. Point it at your localhost dev server in a browser and you get a full visual testing loop. The two hosts expose different APIs (macOS is app-scoped, Windows is window-scoped), and the `desktop-control` skill routes between them.
 
 ---
 
@@ -514,7 +605,7 @@ Same capabilities as Telegram — text, files, commands. Channel/thread routing,
 
 ### Slack
 
-Socket Mode bot with the same shared command catalog — mentions, DMs, slash commands, file/image relay, thread replies.
+Socket Mode bot with the same shared command catalog — mentions, DMs, slash commands, file/image relay, thread replies. Each Slack-triggered agent turn receives the current conversation ID and parent thread timestamp explicitly, so history/member lookups and targeted replies do not depend on parsing an internal session label or enabling multi-session.
 
 <details>
 <summary>Setup (guided wizard)</summary>
@@ -690,7 +781,7 @@ Architecture details: [ARCHITECTURE.md](docs/ARCHITECTURE.md) · Pre-prompt cont
 | Browser commands fail | Install Chrome/Chromium. Run `jaw browser start` first |
 | Employee dispatch hangs | Run `jaw employee list`, ensure the employee CLI is authenticated (`jaw doctor`), then retry with `jaw dispatch --watch` |
 | Employee dispatch returns non-JSON or HTML | The server may be stale or missing the route. Run `npm run build` or restart the manager/dashboard process. |
-| Computer Use not working | macOS only. Codex CLI required. Check Automation permission in System Settings |
+| Computer Use not working | macOS or Windows; Codex CLI required. macOS: check Automation permission in System Settings. Windows: run calls inside `node_repl` and keep the Codex desktop app running in the logged-on session — an empty `list_windows()` means you are not on the pipe, not that no windows are open |
 
 ---
 

electron/src/main/lib/terminal/shell-discovery.ts

@@ -1,12 +1,33 @@
 import { existsSync } from 'node:fs';
+import {
+    detectWindowsShell,
+    windowsGitBashPaths,
+    type WindowsShellKind,
+} from '../../../../../src/core/windows-shell.js';
 
 const SHELLS: Record<string, string[]> = {
     darwin: ['/bin/zsh', '/bin/bash', '/bin/sh'],
     linux: ['/bin/bash', '/bin/zsh', '/bin/sh'],
-    win32: ['powershell.exe', 'cmd.exe'],
 };
 
+function windowsShellExecutable(kind: WindowsShellKind): string {
+    switch (kind) {
+        case 'pwsh7':
+            return 'pwsh.exe';
+        case 'powershell5':
+            return 'powershell.exe';
+        case 'gitbash':
+            return windowsGitBashPaths(process.env).find(existsSync) ?? 'bash.exe';
+        case 'cmd':
+        case 'unknown':
+            return process.env['ComSpec'] || process.env['COMSPEC'] || 'cmd.exe';
+    }
+}
+
 export function discoverShell(): string {
+    if (process.platform === 'win32') {
+        return windowsShellExecutable(detectWindowsShell());
+    }
     const envShell = process.env.SHELL;
     if (envShell && existsSync(envShell)) return envShell;
     const candidates = SHELLS[process.platform] ?? ['/bin/sh'];

package.json

@@ -1,6 +1,6 @@
 {
   "name": "cli-jaw",
-  "version": "2.2.18",
+  "version": "2.2.20",
   "description": "Personal AI assistant powered by Pi, Antigravity, AI-E, Claude, Claude E, Codex, Codex App, Cursor, Grok, Kiro, OpenCode, and Copilot — Web, Terminal, Telegram, and Discord interfaces with 107 built-in skills",
   "type": "module",
   "keywords": [

public/manager/src/settings/cli-status-polling.ts

@@ -0,0 +1,84 @@
+// #312: the Settings panel used to read /api/cli-status once, so a probe that
+// was still running when the page mounted left "상태 확인 중" on screen forever.
+//
+// The server cannot fix this on its own: CliStatusCache is demand-driven and
+// has no timer (src/cli/cli-status.ts), so a snapshot only advances when
+// somebody reads it again. The UI has to be that somebody — but bounded, since
+// a read can fork a worker that runs real CLI probes.
+
+export type CliStatusProbeState = 'checking' | 'fresh' | 'stale' | 'failing';
+
+export type PollableCliStatus = {
+    probeState?: CliStatusProbeState;
+    /** Server-provided backoff deadline, present while probeState is `failing`. */
+    nextRetryAt?: number;
+};
+
+/** Floor for the first delay: a GET can fork a worker running real CLI probes. */
+export const CLI_STATUS_MIN_DELAY_MS = 1_000;
+export const CLI_STATUS_MAX_DELAY_MS = 8_000;
+
+/**
+ * The worker itself may legitimately run for 60s
+ * (WORKER_OUTER_TIMEOUT_MS in src/cli/cli-status-worker.ts). Give it that plus
+ * room for one observing read, or a healthy slow host gets reported as a
+ * timeout.
+ */
+export const CLI_STATUS_POLL_HORIZON_MS = 90_000;
+export const CLI_STATUS_MAX_ATTEMPTS = 24;
+
+/**
+ * `failing` is deliberately NOT terminal. The cache restarts probing on the
+ * first read after its backoff expires, so a UI that stops on `failing` would
+ * simply swap one permanent notice for another and never observe the recovery.
+ */
+export function shouldPollCliStatus(
+    snapshot: Record<string, PollableCliStatus> | null | undefined,
+    cli: string | null | undefined,
+): boolean {
+    if (!snapshot || !cli) return false;
+    const state = snapshot[cli]?.probeState;
+    if (!state) return false;
+    return state === 'checking' || state === 'failing';
+}
+
+/** Gentle backoff between the floor and the ceiling. */
+export function nextCliStatusPollDelay(attempt: number): number {
+    const step = Number.isFinite(attempt) && attempt > 0 ? Math.floor(attempt) : 0;
+    const delay = CLI_STATUS_MIN_DELAY_MS * 2 ** Math.min(step, 8);
+    return Math.min(Math.max(delay, CLI_STATUS_MIN_DELAY_MS), CLI_STATUS_MAX_DELAY_MS);
+}
+
+export type PollSchedule =
+    | { kind: 'stop' }
+    | { kind: 'exhausted' }
+    | { kind: 'wait'; delayMs: number };
+
+/**
+ * Decides the next move. Two independent bounds, neither of which resets on
+ * server responses: a wall-clock deadline and a cap on real requests. Waiting
+ * out a server backoff must NOT consume an attempt, or a host that is merely
+ * backing off would be declared timed-out without ever being asked again.
+ */
+export function planCliStatusPoll(input: {
+    snapshot: Record<string, PollableCliStatus> | null | undefined;
+    cli: string | null | undefined;
+    attempts: number;
+    now: number;
+    deadline: number;
+}): PollSchedule {
+    const { snapshot, cli, attempts, now, deadline } = input;
+    if (!shouldPollCliStatus(snapshot, cli)) return { kind: 'stop' };
+    if (now >= deadline) return { kind: 'exhausted' };
+    if (attempts >= CLI_STATUS_MAX_ATTEMPTS) return { kind: 'exhausted' };
+
+    const backoff = snapshot?.[cli!]?.nextRetryAt;
+    const earliest = typeof backoff === 'number' && backoff > now
+        ? backoff
+        : now + nextCliStatusPollDelay(attempts);
+    // A backoff reaching past the deadline means the answer will not arrive in
+    // time: wait until the deadline and report exhaustion there rather than
+    // firing a doomed request or arming an unbounded timer.
+    const target = Math.min(earliest, deadline);
+    return { kind: 'wait', delayMs: Math.max(target - now, 0) };
+}