chore(release): prepare v0.3.0

.github/copilot-instructions.md

@@ -6,7 +6,7 @@
 - Run server (inside the target repo): `go run ./cmd/myworktree -listen 127.0.0.1:0`
 - Run full test suite: `go test ./...`
 - Run one package: `go test ./internal/worktree -v`
-- Run one test: `go test ./internal/app -run TestNormalizeLabels -v`
+- Run one test: `go test ./internal/app -run TestClientIP -v`
 - Lint/format check used by CI: `test -z "$(gofmt -l .)"`
 
 ## High-level architecture
@@ -36,10 +36,10 @@ Important behavior notes:
 ## Key conventions
 - **Run location matters**: the server is started by the default command (e.g. `myworktree -listen ...`) and should be executed *inside the target git repo* you want to manage, because repo detection and the per-project data dir derive from CWD.
 - **Branch naming**:
-  - Default: managed worktrees are created on branches like `mwt/<slug>`.
-  - Custom grouping: if the task description is in the form `<group>/<name>` (e.g. `feature/auth`), the branch will be `<group>/<name>` (no extra prefix).
-  - `slugify()` is best-effort ASCII, max length ~48; if empty it falls back to `worktree`.
-  - If the target branch already exists, suffix `-2`, `-3`, ... is appended to `<name>`.
+  - Branch name is whatever the user provides in the form (manually entered or LLM-generated).
+  - LLM mode: calls LLM to convert task description into a branch name (e.g. `fix/auth-bug`).
+  - Custom input: when user directly enters a branch name, it is used as-is.
+  - No automatic prefix is added (previously `mwt/`).
 - **Strict deletion**: `worktree delete` refuses to delete if `git status --porcelain` is non-empty (includes untracked files).
 - **State storage discipline**:
   - Persisted state lives in `state.json` via `store.FileStore` and is protected with `flock` + atomic rename.

.github/workflows/release.yml

@@ -39,9 +39,11 @@ jobs:
           target="myworktree_${VERSION}_darwin_${GOARCH}"
           dist_dir="dist/${target}"
           mkdir -p "${dist_dir}"
-          ldflags="-s -w -X myworktree/internal/version.Version=${VERSION} -X myworktree/internal/version.Commit=${COMMIT} -X myworktree/internal/version.BuildDate=${build_date}"
-          GOOS="${GOOS}" GOARCH="${GOARCH}" go build -trimpath -ldflags "${ldflags}" -o "${dist_dir}/myworktree" ./cmd/myworktree
-          GOOS="${GOOS}" GOARCH="${GOARCH}" go build -trimpath -ldflags "${ldflags}" -o "${dist_dir}/mw" ./cmd/mw
+          # Only strip debug symbols (-s), keep symbol table (-w removed)
+          # to preserve macOS code signing compatibility
+          ldflags="-s -X myworktree/internal/version.Version=${VERSION} -X myworktree/internal/version.Commit=${COMMIT} -X myworktree/internal/version.BuildDate=${build_date}"
+          CGO_ENABLED=0 GOOS="${GOOS}" GOARCH="${GOARCH}" go build -trimpath -ldflags "${ldflags}" -o "${dist_dir}/myworktree" ./cmd/myworktree
+          CGO_ENABLED=0 GOOS="${GOOS}" GOARCH="${GOARCH}" go build -trimpath -ldflags "${ldflags}" -o "${dist_dir}/mw" ./cmd/mw
           cp README.md LICENSE CHANGELOG.md "${dist_dir}/"
           tar -C dist -czf "dist/${target}.tar.gz" "${target}"
 
@@ -52,9 +54,83 @@ jobs:
           path: dist/*.tar.gz
           if-no-files-found: error
 
+  codesign-notarize:
+    runs-on: macos-latest
+    needs: build-darwin
+    if: ${{ vars.APPLE_ENABLE_CODESIGN == 'true' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        goarch:
+          - amd64
+          - arm64
+    steps:
+      - name: Download archive
+        uses: actions/download-artifact@v4
+        with:
+          name: release-darwin-${{ matrix.goarch }}
+          path: dist
+
+      - name: Extract and codesign
+        env:
+          APPLE_DEVELOPER_ID_CERT_BASE64: ${{ secrets.APPLE_DEVELOPER_ID_CERT_BASE64 }}
+          APPLE_DEVELOPER_ID_CERT_PASSWORD: ${{ secrets.APPLE_DEVELOPER_ID_CERT_PASSWORD }}
+          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_APP_SPECIFIC_PASSWORD: ${{ secrets.APPLE_APP_SPECIFIC_PASSWORD }}
+        run: |
+          set -euo pipefail
+          archive=$(ls dist/*.tar.gz)
+          basename=$(basename "${archive}" .tar.gz)
+          mkdir -p dist/extracted
+          tar xzf "${archive}" -C dist/extracted
+
+          # Import Apple Developer signing certificate
+          KEYCHAIN="build.keychain"
+          security create-keychain -p "" "${KEYCHAIN}"
+          security default-keychain -s "${KEYCHAIN}"
+          security unlock-keychain -p "" "${KEYCHAIN}"
+          security set-keychain-settings -lut 21600 "${KEYCHAIN}"
+          echo "${APPLE_DEVELOPER_ID_CERT_BASE64}" | base64 -d > cert.p12
+          security import cert.p12 -k "${KEYCHAIN}" -P "${APPLE_DEVELOPER_ID_CERT_PASSWORD}" -T /usr/bin/codesign -T /usr/bin/pkgbuild
+          security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k "" "${KEYCHAIN}"
+
+          for binary in myworktree mw; do
+            # Sign with hardened runtime (required for notarization)
+            codesign --force --options runtime --timestamp --sign "${APPLE_TEAM_ID}" \
+              "dist/extracted/${basename}/${binary}"
+          done
+
+          # Notarize each binary
+          for binary in myworktree mw; do
+            zip_path="dist/${binary}.zip"
+            ditto -c -k --keepParent "dist/extracted/${basename}/${binary}" "${zip_path}"
+            xcrun notarytool submit "${zip_path}" \
+              --apple-id "${APPLE_ID}" \
+              --team-id "${APPLE_TEAM_ID}" \
+              --password "${APPLE_APP_SPECIFIC_PASSWORD}" \
+              --wait
+            xcrun stapler staple "dist/extracted/${basename}/${binary}"
+          done
+
+          # Re-pack the signed archive
+          tar czf "${archive}" -C dist/extracted "${basename}"
+
+          # Clean up keychain
+          security delete-keychain "${KEYCHAIN}"
+
+      - name: Upload signed archive
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-darwin-${{ matrix.goarch }}
+          path: dist/*.tar.gz
+          if-no-files-found: error
+          overwrite: true
+
   publish:
     runs-on: ubuntu-latest
-    needs: build-darwin
+    needs: [build-darwin, codesign-notarize]
+    if: ${{ !failure() }}
     steps:
       - name: Download archives
         uses: actions/download-artifact@v4

CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## v0.3.0
+
+Release focused on remote collaboration, build robustness, and Apple Silicon reliability.
+
+Highlights:
+- Added **Portal Dashboard** — a shared entry port with auto-discovery of running instances across repos, global auth token (HttpOnly Cookie, CSRF protection), and Tailscale serve readiness.
+- Improved **remote access** — instances and portal now bind to `0.0.0.0` by default, auth token auto-generates on first run, and the login flow supports CSRF-protected forms for non-loopback clients.
+- Integrated **LLM-powered branch naming** — configurable protocol (OpenAI / Anthropic), with reasoning split support and a manual override option.
+- Upgraded terminal shell with **xterm.js v6.0.0** and fixed Chinese IME shift-symbol fullwidth issues.
+- Enhanced the **Changes panel** with separate Staged / Unstaged accordion sections, untracked file tracking, and per-file diff stats.
+- Streamlined instance lifecycle — instances can be deleted directly on stop (no archive step), with per-worktree tab reordering via optimistic locking.
+
+Build hardening for Apple Silicon:
+- Release builds now set `CGO_ENABLED=0` to guarantee pure-Go cross-compilation from Linux to Darwin.
+- Removed `-w` linker flag to preserve macOS code-signing compatibility.
+- Added optional macOS codesign + notarization job (enabled via repository variables/secrets) to resolve Gatekeeper blocking on Apple Silicon Macs.
+- Users who still encounter "no response" on Apple Silicon can run `xattr -d com.apple.quarantine ./mw` to clear the download quarantine attribute.
+
+Documentation and validation:
+- Expanded API, architecture, and PRD docs to cover the Portal Dashboard, remote access flow, CSRF protection, and auto-auth generation.
+- Release packaging continues to publish Darwin `amd64` / `arm64` archives plus SHA256 checksums via the tag-triggered GitHub Actions workflow, with an optional codesign job.
+
 ## v0.2.0
 
 Feature release focused on workspace visibility, terminal continuity, and day-to-day usability improvements.

NOTICE

@@ -46,5 +46,5 @@ yusufpapurcu/wmi
   Copyright (c) 2013 Stack Exchange
   MIT License
 
-xterm.js (bundled)
+xterm.js v6.0.0
   MIT License

README.md

@@ -28,14 +28,15 @@ myworktree is a thin management layer that:
 ## Features (MVP)
 - Create/list/import/delete managed worktrees (strict delete: refuses if dirty)
 - Start/list/stop managed instances per worktree via **Tag** templates
-- Instance restart support (keeps worktree/tag-or-command/labels and links old/new instance records)
-- Optional instance labels (`k=v`) with UI filtering/search
+- Instance restart support (keeps worktree/tag-or-command and links old/new instance records)
 - Web UI can be closed/reopened; instances keep running; WebSocket Web TTY is default (with SSE/HTTP fallback)
 - UI shows transport status (`websocket/sse/polling`) and provides WS reconnect action
 - Startup reconcile: stale persisted `running` instances are auto-marked `stopped` after mw restart
 - Optional built-in HTTPS (`--tls-cert/--tls-key`) and token auth for non-loopback
 - Stored backlog redaction for common secrets (e.g. `sk-...`)
 - MCP tool endpoints (`/api/mcp/tools`, `/api/mcp/call`)
+- Portal Dashboard with shared entry port, auto-discovery of running instances across repos
+- Global auth token (HttpOnly Cookie, CSRF protection, tailscale serve integration)
 
 ## Requirements
 - macOS 12+ (other platforms are not validated yet)
@@ -76,6 +77,12 @@ Start from `v0.2.0` or newer for public release binaries. The earlier `v0.1.0` G
 Each release archive contains `mw`, `myworktree`, `README.md`, `LICENSE`, and `CHANGELOG.md`.
 If there is no prerelease/release asset yet, or you need a platform we do not publish, follow the source build steps below.
 
+**Apple Silicon troubleshooting:** macOS may quarantine downloaded binaries and silently prevent execution (Gatekeeper). If the binary does not respond or shows "cannot be opened":
+```bash
+xattr -d com.apple.quarantine ./mw ./myworktree
+```
+Or open **System Settings → Privacy & Security** and click "Allow Anyway" for the blocked binaries.
+
 ### Build & install
 
 ```bash
@@ -138,6 +145,12 @@ mw
 When startup succeeds, `mw` opens the web page automatically at the serving URL by default.
 `myworktree` prints the URL without opening a browser unless you pass `-open=true`.
 
+When Portal is enabled, the startup output includes:
+```
+[portal] Portal dashboard at: http://0.0.0.0:12345/
+[portal] Tailscale URL: https://my-machine.tail-scale.ts.net/
+```
+
 myworktree uses the **current working directory** to detect the target repo (git root) and derives an isolated per-project data dir from it, so you can manage other projects by running the same binary in a different repo directory.
 
 By default, newly created worktrees are placed next to your repo:
@@ -164,6 +177,18 @@ myworktree instance start --worktree <worktreeId> --cmd "echo hello && ls"
 myworktree instance start --worktree <worktreeId>  # starts an interactive shell instance
 myworktree instance list
 myworktree instance stop <instanceId>
+
+# config (global auth token)
+mw config              # interactive guided setup (set/view/clear/regen token)
+mw config set-auth     # set token directly
+mw config get-auth     # view token (masked)
+mw config clear-auth   # clear token
+mw config regen        # regenerate token (with confirmation)
+
+# start with remote access & Portal (IPv6 is explicitly disabled)
+mw start --listen 0.0.0.0:0                     # LAN access, auto-inherits global token
+mw start --listen 0.0.0.0:0 --portal-port 12346 # custom Portal port
+mw start --listen 0.0.0.0:0 --portal-port 0     # disable Portal
 ```
 
 Note: command starts are executed inside the instance shell, and you can continue sending input to the same running instance from the UI.
@@ -212,10 +237,46 @@ The workflow verifies `gofmt`, runs `go test ./...`, and builds both binaries on
 Tagged releases (`v*`) run `.github/workflows/release.yml`, which produces darwin `amd64` / `arm64` archives plus SHA256 checksums.
 
 ## Remote access
-- Default: binds to loopback only.
-- If you listen on a non-loopback address, you must set `--auth`.
-- For HTTPS, provide `--tls-cert` and `--tls-key`.
-- `?token=<token>` works for simple clients, but prefer `Authorization: Bearer <token>` to avoid leaving tokens in browser history or shell history.
+
+### Global Token
+
+Configure a global auth token once, and all instances automatically inherit it:
+
+```bash
+mw config
+# → Interactive guided setup: [1] set token [2] view token [3] clear token [4] regen token [q] quit
+# Token stored in ~/.config/myworktree/auth.json (0600 permissions)
+```
+
+When `--auth` is not provided and no token exists in `auth.json`, the CLI **automatically generates a random 32-character hex token** and persists it. This ensures instances always have authentication enabled by default. Instance-level `--auth` override takes precedence over the global token.
+
+### Portal Dashboard
+
+`mw start --listen 0.0.0.0:0` starts a **Portal Dashboard** on port `12345` (configurable via `--portal-port`). The dashboard:
+
+- Lists all running instances across repos with auto-discovery
+- Click an instance to jump to its Web UI (directly via instance port — Portal reverse proxy `/s/<repo-hash>/` is planned but not yet implemented)
+- Uses **HttpOnly Cookie** (`mw_token`) for authentication — token never appears in URL or JS
+- **CSRF protection** via double-submit cookie pattern on login/logout endpoints
+- Cookie has 24-hour **sliding expiration** (refreshed on each auth-successful request)
+
+Set `--portal-port 0` to disable the Portal.
+
+### Tailscale HTTPS
+
+> **Note**: Automatic `tailscale serve` configuration is **currently disabled** due to a Tailscale 1.98 CLI bug on macOS where `tailscale serve --bg` reports success but does not actually configure the proxy. The relevant code exists in `internal/portal/portal.go` but is not wired into the production code paths. Users can still securely access Portal via Tailscale IP (`http://100.x.x.x:12345`) over the WireGuard tunnel. Automatic `tailscale serve` management will be re-enabled once Tailscale fixes the upstream bug.
+
+### Network Security
+
+| Access Path | Protocol | Encryption Layer |
+|-------------|----------|-----------------|
+| Instance direct (local/LAN IP) | `http://192.168.1.18:PORT` → instance | None (LAN only) |
+| Instance direct (Tailscale IP) | `http://100.x.x.x:PORT` → instance | WireGuard tunnel |
+| Dashboard + proxy (local/LAN) | `http://host:12345` → proxy `http://127.0.0.1:PORT` | None (LAN only) |
+| Dashboard + proxy (Tailscale IP) | `http://100.x.x.x:12345` → proxy `http://127.0.0.1:PORT` | WireGuard tunnel |
+| `tailscale serve` domain | `https://machine.ts.net` → proxy `http://127.0.0.1:PORT` | Let's Encrypt TLS + WireGuard |
+
+> **Note**: Tailscale's WireGuard tunnel provides network-layer encryption. Application-layer HTTPS is only used when accessing via `tailscale serve` domain (Let's Encrypt certificate).
 
 ## License
 MIT. See [LICENSE](./LICENSE).